open-index/open-npm huggingface dataset:
npm package: @hq20/solidity-parser-antlr
Description: A Solidity parser built from a robust ANTLR 4 grammar
Author: Federico Bond
Latest version: 0.4.12-alpha.0

solidity-parser-antlr
=====================

[![npm](https://img.shields.io/npm/v/solidity-parser-antlr.svg)](https://www.npmjs.com/package/solidity-parser-antlr)
[![Build Status](https://travis-ci.org/federicobond/solidity-parser-antlr.svg?branch=master)](https://travis-ci.org/federicobond/solidity-parser-antlr)

A Solidity parser built on top of a robust [ANTLR4 grammar](https://github.com/solidityj/solidity-antlr4).

### Usage

```javascript
import parser from 'solidity-parser-antlr';

var input = `
    contract test {
        uint256 a;
        function f() {}
    }
`
try {
    parser.parse(input)
} catch (e) {
    if (e instanceof parser.ParserError) {
        console.log(e.errors)
    }
}
```

The `parse` method also accepts a second argument which lets you specify the
following options, in a style similar to the _esprima_ API:

| Key      | Type    | Default | Description                                                                                                                                                                                          |
|----------|---------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| tolerant | Boolean | false   | When set to `true` it will collect syntax errors and place them in a list under the key `errors` inside the root node of the returned AST. Otherwise, it will raise a `parser.ParserError`.          |
| loc      | Boolean | false   | When set to `true`, it will add location information to each node, with start and stop keys that contain the corresponding line and column numbers. Column numbers start from 0, lines start from 1. |
| range    | Boolean | false   | When set to `true`, it will add range information to each node, which consists of a two-element array with start and stop character indexes in the input.                                            |


#### Example with location information

```javascript
parser.parse('contract test { uint a; }', { loc: true })

// { type: 'SourceUnit',
//   children:
//    [ { type: 'ContractDefinition',
//        name: 'test',
//        baseContracts: [],
//        subNodes: [Array],
//        kind: 'contract',
//        loc: [Object] } ],
//   loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 24 } } }

```

#### Example using a visitor to walk over the AST

```javascript
var ast = parser.parse('contract test { uint a; }')

// output the path of each import found
parser.visit(ast, {
  ImportDirective: function(node) {
    console.log(node.path)
  }
})
```

### Author

Federico Bond ([@federicobond](https://github.com/federicobond))

### License

MIT
npm package: @hqbly/eval-util
Description: utils
Author: hqbly
Latest version: 1.0.1

# expr-util

## 依赖

pnpm
expr-eval
vite
vitest

## 安装

```
pnpm i @hqbly/eval-util
```

打包后的 dist/index.js 可直接引用，无需单独引入 expr-eval 类库
npm package: @hqdaemon/db
Description: Work with MongoDB and MySQL through the simple connector.
Author: HQ
Latest version: 1.0.4

# DB
Work with MongoDB and MySQL through the simple connector.

## Installation
```
npm i @hqdaemon/db
```

## Usage
```js
let hqDB = require("@hqdaemon/db");
let options = {};
let db = await hqDB(options);
```

## Options
Field | Type | Value
-- | -- | --
type | string | "mongo" or "mysql"
database | string | "DB_NAME"
host | string | default "localhost"
port | int  | MongoDB default 27017, MySQL not use
connectionLimit | int | MongoDB not use, MySQL default 5
user | string | default ""
password | string | default ""

<br/>
<br/>

# Mongo
```js
let options = {
	type: "mongo"
};

let mongodb = await hqDB(options);
/*

Object {
	server: MongoServer,
	client: MongoClient,
	ObjectID: mongodb.ObjectID,
	DBRef: mongodb.DBRef,
	Double: mongodb.Double,
	Int32: mongodb.Int32,
	Long: mongodb.Long,
	BSONRegExp: mongodb.BSONRegExp,
	Decimal128: mongodb.Decimal128
}

*/
```

### Base methods
See full documentation on [MongoDB](https://www.npmjs.com/package/mongodb)
```js
let mongo = mongodb.client;
let db = await mongo.db("DB_NAME");
let collection = await db.collection("COLLECTION_NAME");
let resultOn = await collection.findOne({});
let result = await collection.find({});
mongo.close();
```

<br/>
<br/>

# MySQL
Connection pools help reduce the time spent connecting to the MySQL server by reusing a previous connection, leaving them open instead of closing when you are done with them.

See full documentation on [MySQL2](https://www.npmjs.com/package/mysql2)

```js
let mysql = await hqDB({
	type: "mysql",
	database: "DB_NAME",
	user: "USER_NAME",
	password: "PASSWORD",
	connectionLimit: 2
});
```

### Return
```js
{
	"type": "mysql",
	"database": "DB_NAME",
	"user": "USER_NAME",
	"connectionLimit": 2,
	"pool": Pool
}
```

### Base methods
```js
let result = await mysql.query("YOUR_QUERY",[]); // Sync
mysql.query("YOUR_QUERY", [], function(err,result){}); // Async
mysql.pool.end();
```


<br />
<br />
<br />
<br />

## MIT License

Copyright (c) HQ • [hqmode.com](https://hqmode.com)

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
npm package: @hqdaemon/jscompose
Description: Compose Your JavaScript Files Into One Bundle Including Required Files
Author: HQ
Latest version: 1.0.8

# JSCompose
Compose Your JavaScript Files Into One Bundle Including Required or Imported Files

<br/>

## Installation
```
npm install @hqdaemon/jscompose
```

## Usage
Just add in the main JavaScript file other files with **require()** or **import** method.

In app.js (or other file)
```js
require("path_to_other_js_file/file.1.js");
import "path_to_other_js_file/file.2.js";
require("path_to_other_js_file/file.3");
```

...then compose it with **Node.js** and **jscompose**
```js
import jscompose from "@hqdaemon/jscompose";
let result = jscompose("/path_to_file/app.js");

// Return false or composed string
```

<br />
<br />
<br />
<br />

## MIT License

Copyright (c) Alexander Yermolenko • [surfy.one](https://surfy.one)

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
npm package: @hqdaemon/minify
Description: Compose & Minify HTML, JavaScript, CSS, and SCSS.
Author: Alexander Yermolenko
Latest version: 1.1.0

# Minify
Compose &amp; Minify HTML, JavaScript, CSS, and SCSS.

<br/>

## Installation
```
npm install @hqdaemon/minify
```

## Usage

### Node.js
```js
const minify = require("@hqdaemon/minify");

// To String
let jsResult = await minify("/path_to_file/script.js");
let cssResult = await minify("/path_to_file/style.scss");
let htmlResult = await minify("/path_to_file/dom.html");

// To File
minify("/path_to_file/script.js", {to: "/path_to_new_file/new_file_name.js"});
minify("/path_to_file/style.scss", {to: "/path_to_new_file/new_file_name.css"});
minify("/path_to_file/dom.html", {to: "/path_to_new_file/dom.html"});

// Return false or composed string
```

### CLI
```
minify file.js > file.min.js
minify style.scss > style.min.css
minify dom.html > dom.min.html
```

<br />
<br />
<br />
<br />

## MIT License

Copyright (c) Alexander Yermolenko • [surfy.one](https://surfy.one)

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
npm package: @hqdaemon/request
Description: The simplest and lightest Node.js module for sending Post or Get Requests.
Author: Alexander Yermolenko
Latest version: 1.0.2

# Request.js
The simplest and lightest Node.js module for sending Post or Get Requests.
You can use both HTTPS as well as HTTP for your own purposes.

<br/>

## Installation
```
npm install @hqdaemon/request
```

## Usage Node.js
The module will try to convert the received information into JSON.
If it fails output Plain Text.

```js

// Import library
const request = require("@hqdaemon/request");

/*

Request Options

*/

let options = {

	/*

	Full requested URL without queries

	*/

	url: "https://example.com",

	/*

	Request Method
	Values: "GET" or "POST"
	Default "POST"

	*/

	method: "GET",

	/*
	
	Query params
	Object or String
	Default {}

	*/

	params: {
		firstParam: "firstValue",
		secondParam: "secondValue"
	},

	/*

	Authorization header
	Default False

	*/

	auth: "AUTH_STRING",

	/*
		Additional Headers
		Default False
	*/

	headers: {
		"-x-your-header-param": "Some value",

		/*

		You can override Content-Type
		Default "application/json"

		*/

		"Content-Type": "application/x-www-form-urlencoded"
	}
};

/*

Send Request
Result: JSON, String or False if error has occurred

*/

let result = await request(options);

```

<br />
<br />
<br />
<br />

## MIT License

Copyright (c) Alexander Yermolenko • [surfy.one](https://surfy.one)

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
npm package: @hqdaemon/translit
Description: Lightweight JavaScript library for converting Cyrillic symbols to English.
Author: HQ
Latest version: 1.0.0

# Translit
Lightweight JavaScript library for converting Cyrillic symbols to English.


<br/>

## Installation
```
npm install @hqdaemon/translit
```

## Usage
```js
const translit = require("@hqdaemon/translit");

let result = translit(`Умом — Россию не понять,
Аршином общим не измерить.
У ней особенная стать —
В Россию можно только верить.
Федор Тютчев
1866 г.`)

console.log(result);

/* String
Umom — Rossiyu ne ponyat,
Arshinom obshchim ne izmerit.
U ney osobennaya stat —
V Rossiyu mozhno tolko verit.
Fedor Tyutchev
1866 g.
*/
```

<br />
<br />
<br />
<br />

## MIT License

Copyright (c) HQ • [hqmode.com](https://hqmode.com)

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
npm package: @hqjs/babel-plugin-add-decorators-metadata
Description: Add decorators metadata
Author: hqjs
Latest version: 0.0.2

# babel-plugin-add-decorators-metadata
Add decorators metadata

# Installation
```sh
npm install hqjs@babel-plugin-add-decorators-metadata
```

# Usage
```json
{
  "plugins": [["hqjs@babel-plugin-add-decorators-metadata"]]
}
```

# Transformation
Transforms decorators into class metadata, takes care of wrapping `providers` property into an object. This transformations allow angular to use dependency injection.123

So the code
```ts
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import {CoreConfig} from './app.service';

import { AppComponent } from './app.component';

@NgModule({
  declarations: [
    AppComponent
  ],
  imports: [
    BrowserModule
  ],
  providers: [
    CoreConfig
  ],
  bootstrap: [AppComponent]
})
export class AppModule { }
```
will turn into

```ts
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { CoreConfig } from './app.service';
import { AppComponent } from './app.component';
@NgModule({
  declarations: [AppComponent],
  imports: [BrowserModule],
  providers: [{
    provide: CoreConfig
  }],
  bootstrap: [AppComponent]
})
export class AppModule {}
AppModule.decorators = [{
  type: NgModule,
  args: [{
    declarations: [AppComponent],
    imports: [BrowserModule],
    providers: [{
      provide: CoreConfig
    }],
    bootstrap: [AppComponent]
  }]
}];
```
npm package: @hqjs/babel-plugin-add-type-metadata
Description: Add plugin metadata
Author: hqjs
Latest version: 0.0.4

# babel-plugin-add-type-metadata
Add types metadata

# Installation
```sh
npm install hqjs@babel-plugin-add-type-metadata
```

# Transformation
Plugin adds type metadata from constructor to classes to help Angular e.g.
```ts
...
import { MessageService } from './message.service';

@Injectable({
  providedIn: 'root',
})
export class HeroService {

  constructor(private messageService: MessageService) { }

  ...
}
```

will turn into
```ts
...
import { MessageService } from './message.service';

@Injectable({
  providedIn: 'root',
})
export class HeroService {

  static "ctorParameters"() {
    return [{
      "type": HeroService
    }];
  }

  constructor(private messageService: MessageService) { }

  ...
}
```

that works nice with decorator plugin.
npm package: @hqjs/babel-plugin-expose-global-to-window
Description: Explicitly expose global variables and functions to window in non module script
Author: hqjs
Latest version: 0.0.2

# https://hqjs.org
Explicitly expose global variables and functions to window in non module script.

# Installation
```sh
npm install hqjs@babel-plugin-expose-global-to-window
```

# Transformation
```js
var x = 1, xx = 11, xxx = 111;

if (true) {
  var y = 2;
  function w() {}
}

class A {}

function f() {
  var x = 2;
  var z = 17;
  function f() {}
  
  function g() {}
}

const z = () => 0;
```

will turn into
```js
var x = 1,
    xx = 11,
    xxx = 111;

if (true) {
  var y = 2;

  function w() {}
}

class A {}

function f() {
  var x = 2;
  var z = 17;

  function f() {}

  function g() {}
}

const z = () => 0;

window.x = x;
window.xx = xx;
window.xxx = xxx;
window.y = y;
window.f = f;
```
npm package: @hqjs/babel-plugin-patch-angular-fesm5-compiler
Description: Patch angular dynamic compiler to work without bundling
Author: hqjs
Latest version: 0.0.2

# babel-plugin-patch-angular-fesm5-compiler
Patch angular dynamic compiler to work without bundling

# Installation
```sh
npm install hqjs@babel-plugin-patch-angular-fesm5-compiler
```

# Transformation
Patch allows to resolve absolute URLs and URLs starting from `http` or `https`.
npm package: @hqjs/babel-plugin-resolve-modules
Description: Transform name imports for web browser
Author: hqjs
Latest version: 0.0.2

# http://hqjs.org
Resolve module names

# Installation
```sh
npm install hqjs@babel-plugin-resolve-modules
```

# Usage
```json
{
  "plugins": [[ "hqjs@babel-plugin-resolve-modules", {
      "resolve": {
        "foo": "/packages/foo",
        "bar/*": "/packages/bar/",
        "baz/b": "/packages/baz/b",
        "baz/b/*": "/packages/baz/b/",
        "qux_": "/packages/qux"
      }
    }]]
}
```

# Transformation
Plugin will resolve provided modules according to schema. In the example above `foo` and `baz/b` are exact transformations so only exact occurance of this names would be transformed, while `bar/*` and `baz/b/*` are wildcards, meaning all pathes started with `bar/` and `baz/b/` would be transformed. Special character `_` mean both exact and wildcard matches.

Plugin is stupid and simple so be careful with backslashes.

So script
```js
require('foo');
require('foo/a');
require('bar');
require('bar/a');
require('baz/b');
require('baz/b/c');
require('qux');
require('qux/a');

import 'foo';
import 'foo/a';
import 'bar';
import 'bar/a';
import 'baz/b';
import 'baz/b/c';
import 'qux';
import 'qux/a';

export * from 'foo';
export * from 'foo/a';
export * from 'bar';
export * from 'bar/a';
export * from 'baz/b';
export * from 'baz/b/c';
export * from 'qux';
export * from 'qux/a';

export {foo} from 'foo';
export {fooA} from 'foo/a';
export {bar} from 'bar';
export {barA} from 'bar/a';
export {bazB} from 'baz/b';
export {bazC} from 'baz/b/c';
export {qux} from 'qux';
export {quxA} from 'qux/a';
```

will turn into

```js
require("/packages/foo");
require('foo/a');
require('bar');
require("/packages/bar/a");
require("/packages/baz/b");
require("/packages/baz/b/c");
require('/packages/qux');
require('/packages/qux/a');

import "/packages/foo";
import 'foo/a';
import 'bar';
import "/packages/bar/a";
import "/packages/baz/b";
import "/packages/baz/b/c";
import '/packages/qux';
import '/packages/qux/a';

export * from "/packages/foo";
export * from 'foo/a';
export * from 'bar';
export * from "/packages/bar/a";
export * from "/packages/baz/b";
export * from "/packages/baz/b/c";
export * from '/packages/qux';
export * from '/packages/qux/a';

export { foo } from "/packages/foo";
export { fooA } from 'foo/a';
export { bar } from 'bar';
export { barA } from "/packages/bar/a";
export { bazB } from "/packages/baz/b";
export { bazC } from "/packages/baz/b/c";
export {qux} from '/packages/qux';
export {quxA} from '/packages/qux/a';
```
npm package: @hqjs/babel-plugin-support-nodejs-globals
Description: Support nodejs globals
Author: hqjs
Latest version: 0.0.2

# http://hqjs.org
Support-nodejs globals
* Buffer - adds `import Buffer from 'buffer';` on top of the program [npm buffer package](https://www.npmjs.com/package/buffer)
* process - adds `iport process from 'process';` on top of the program [npm process package](https://www.npmjs.com/package/process)
* __dirname - substitutes exact value
* __filename - substitutes exact value
* global - changes to `globalThis` (which has polyfill in core-js) works in combination with globals above

# Installation
```sh
npm install hqjs@babel-plugin-support-nodejs-globals
```

# Usage
```json
{
  "plugins": ["hqjs@babel-plugin-support-nodejs-globals"]
}
```
npm package: @hqjs/babel-plugin-transform-css-imports
Description: Transform css imports, supports css modules
Author: hqjs
Latest version: 0.0.3

# https://hqjs.org
Transform css imports

# Installation
```sh
npm install hqjs@babel-plugin-transform-css-imports
```

# Usage
```json
{
    "plugins": [
      ["hqjs@babel-plugin-transform-css-imports", {
        "styleMaps": {
          "/main.css" : {
            "root": "root_01",
            "text": "text_1217",
            "color": "color_918"
          }
        }
      }
    ]
  ]
}
```
Option `styleMaps` pass relations between module name and class names translated by css modules.

# Transformation
Transforms `.css` imports into style loading and in case of named import - add css mosules transformation.

Let's say we have file `/main.css`
```css
.root {
  border-width: 2px;
  border-style: solid;
  border-color: #777;
  padding: 0 20px;
  margin: 0 6px;
  max-width: 400px;
}

.text {
  color: #777;
  font-size: 24px;
  font-family: helvetica, arial, sans-serif;
  font-weight: 600;
}
```
transformed with css modules
```css
.root_01 {
    border-width: 2px;
    border-style: solid;
    border-color: #777;
    padding: 0 20px;
    margin: 0 6px;
    max-width: 400px;
}

.text_1217 {
    color: #777;
    font-size: 24px;
    font-family: helvetica, arial, sans-serif;
    font-weight: 600;
}
```

and importing it

```js
import '/main.css';
// Named imports will use css modules
import styles from '/main.css';
// Or with destructure
import {root, text as t} from '/main.css';
```
or similar expressions with require
```js
require('/main.css');
// Named imports will use css modules
const styles = require('/main.css');
// Or with destructure
const {root, text: t} = require('/main.css');
```
we will obtain
```js
const _ref = document.createElement("link");
_ref.rel = "stylesheet";
_ref.href = "/main.css";
document.head.appendChild(_ref);

// Named imports will use css modules
const _ref2 = document.createElement("link");
_ref2.rel = "stylesheet";
_ref2.href = "/main.css";
document.head.appendChild(_ref2);
const styles = {
  root: 'root_01',
  text: 'text_1217',
  color: 'color_918'
};

// Or with destructure
const _ref3 = document.createElement("link");
_ref3.rel = "stylesheet";
_ref3.href = "/main.css";
document.head.appendChild(_ref3);
const {
  root: root,
  text: t
} = {
  root: 'root_01',
  text: 'text_1217'
};
```
npm package: @hqjs/babel-plugin-transform-define
Description: Substitute object defenitions and typeof expressions
Author: hqjs
Latest version: 0.0.1

# babel-plugin-transform-define
Substitute object defenitions and typeof expressions e.g.
```js
import babelTransformDefine from '@hqjs/babel-plugin-transform-define';

{
  plugins: [
    [ babelTransformDefine, {
      'process.env.NODE_ENV': 'development',
      'typeof window': 'object',
    }]
  ]
}
```
will substitute values of expressions `process.env.NODE_ENV` and `typeof window` into the code.

# Installation
```sh
npm install hqjs@babel-plugin-transform-define
```
npm package: @hqjs/babel-plugin-transform-export-all
Description: Transform export all to named imports and export default
Author: hqjs
Latest version: 0.0.3

# https://hqjs.org
TTransform export all to named imports and export default.

# Installation
```sh
npm install hqjs@babel-plugin-transform-export-all
```

# Transformation
Plugin transforms export all to named imports and export default
```js
export * from "./hello";
export * from "./nameEdit";
export * from "./colorBrowser";
export * from "./colorPicker";
export * from "./sidebar";
```

will turn into
```js
import * as _ref from "./hello";
import * as _ref2 from "./nameEdit";
import * as _ref3 from "./colorBrowser";
import * as _ref4 from "./colorPicker";
import * as _ref5 from "./sidebar";
export default Object.assign({}, _ref, _ref2, _ref3, _ref4, _ref5);
```
npm package: @hqjs/babel-plugin-transform-json-imports
Description: Transform json imports
Author: hqjs
Latest version: 0.0.6

# https://hqjs.org
Transform json imports

# Installation
```sh
npm install hqjs@babel-plugin-transform-json-imports
```

# Usage
```json
{
  "plugins": [["hqjs@babel-plugin-transform-json-imports", { "dirname": "/json/directory", "root": "/root/directory" }]]
}
```
If you are invoking this plugin from javascript it becomes possible to pass filesystem implementation trough `fs` option, it expects the object with `readFileSync` method defined.

# Transformation
Transforms `.json` imports into inplace definition e.g. having file values.json

```json
{
  "a": 1,
  "b": 2,
  "c": 3
}
```
and importing it

```js
import values from './values.json';
// Or with destructure
import {a, b} from './values.json';
```
or similar expressions with require
```js
const values = require('./values.json');
// Or with destructure
const {a, b} = require('./values.json');
```
we will obtain
```js
const values = {a: 1, b: 2, c: 3};
const {a, b} = {a: 1, b: 2};
```
npm package: @hqjs/babel-plugin-transform-mixed-imports
Description: Transform mixed imports
Author: hqjs
Latest version: 0.0.1

# hqjs.org
Transform mixed imports
```js
import a, {b, c} from 'd';
```
into
```js
import a from 'd';
import {b, c} from 'd';
```

# Installation
```sh
npm install hqjs@babel-plugin-transform-mixed-imports
```
npm package: @hqjs/babel-plugin-transform-modules
Description: Transform CommonJS into ES modules
Author: hqjs
Latest version: 0.0.9

# https://hqjs.org
Transform CommonJS modules files into ES modules

# Installation
```sh
npm install hqjs@babel-plugin-transform-modules
```

# Transformation
Can recognise UMD files and mixed `import`, `export` with `require` statements. Turns dynamic require into static imports. Transforms double `default`.

It will turn
```js
import a from 'a';
import b from 'b';

let t;
if (process.env.NODE_ENV === 'production') {
  require('x');
} else {
  t = require('y');
}

import 'w';

export const z = 0;

export default class A {}

exports.q = 1;

exports.default = {t};

module.exports = {a};
```
into
```js
import a from 'a';
import b from 'b';
import "x";
import _ref2 from "y";
import 'w';
const _ref = {
  exports: {}
};

(function (module, exports) {
  let t;

  if (process.env.NODE_ENV === 'production') {} else {
    t = _ref2;
  }

  exports.z = 0;

  class A {}

  exports.q = 1;
  module.exports = Object.assign(A, exports);
  module.exports = {
    t
  };
  module.exports = {
    a
  };
})(_ref, _ref.exports);

export default _ref.exports;
```
npm package: @hqjs/babel-plugin-transform-name-imports
Description: Transform name imports for web browser
Author: hqjs
Latest version: 0.0.6

# http://hqjs.org
Transform name imports for web browser

# Installation
```sh
npm install hqjs@babel-plugin-transform-name-imports
```

# Usage
```json
{
  "plugins": [[ "hqjs@babel-plugin-transform-name-imports", {
      "resolve": { "vue": "vue/dist/vue.esm.js" },
      "versions": { "react": "react@16.0.1" },
      "browser": {
        "module-a": "./shims/module-a.js",
        "module-b": false
      },
      "empty": "/hq-empty-module.js"
    }]]
}
```

# Transformation
Plugin will transform all bare imports into absolute imports starting with `/node_modules/`, it will take care of [builtins](https://github.com/webpack/node-libs-browser), substitute resolution configured by `resolved` parameter and pick correct version specified in `version` option. It will respect [package browser field spec](https://github.com/defunctzombie/package-browser-field-spec) for name imports if you pass `browser` parameter and specify `empty` files resolution path.

So script
```js
import React from 'react';
import Vue from 'vue';
import { Component, OnInit } from '@angular/core';

import 'module-a';
import 'module-b';

(async () => {
  const { default: ReactDOM } = await import('react-dom');
})();
```

will turn into

```js
import React from "/node_modules/react";
import Vue from "/node_modules/vue";
import { Component, OnInit } from "/node_modules/@angular/core";

import './shims/module-a.js';
import '/hq-empty-module.js';

(async () => {
  const { default: ReactDOM } = await import("/node_modules/react-dom");
})();
```
npm package: @hqjs/babel-plugin-transform-named-export-to-destructure
Description: Transform named export to destructure
Author: hqjs
Latest version: 0.0.4

# https://hqjs.org
Transform named export to destructure.

# Installation
```sh
npm install hqjs@babel-plugin-transform-named-export-to-destructure
```

# Transformation
Plugin makes destructure export work with modules that only provide default export.
```js
export { default } from './CssBaseline';
import css from '@emotion/css';
console.log(css);
export { default as css } from '@emotion/css';
import {x as y, h as l} from 'z';
console.log(y);
export {x as y} from 'z';
export {a} from 'zz';
console.log(a);
import {a, b} from 'zz';
import * as w from 'zzz';
console.log(w);
export * as w from 'zzz';
```

will turn into
```js
import { default as _ref } from './CssBaseline';
export default _ref;
import { default as _ref2 } from '@emotion/css';
export const css = _ref2;
console.log(css);
import { x as _ref3, h as l } from 'z';
export const y = _ref3;
console.log(y);
import { a as _ref4 } from 'zz';
export const a = _ref4;
console.log(a);
import { b } from 'zz';
import * as _ref5 from 'zzz';
export const w = _ref5;
console.log(w);
```
npm package: @hqjs/babel-plugin-transform-namespace-imports
Description: Transform namespace imports into default imports
Author: hqjs
Latest version: 0.0.4

# https://hqjs.org
Transform namespace imports into default imports when required

# Installation
```sh
npm install hqjs@babel-plugin-transform-namespace-imports
```

# Usage
```json
{
  "plugins": [["hqjs@babel-plugin-transform-namespace-imports", {
    "include": ["react-dom"],
    "exclude": ["lodash"]
  }]]
}
```

# Transformation
Transforms namespace imports into default imports to meet specification requirements. Packages from `include` will be transformed to default import without runtime checking. Packages from `exclude` won't be transformed. Rest packages will be checked and transformed in runtime.

```js
import * as React from 'react';
import * as ReactDOM from 'react-dom';
import * as _ from 'lodash';
import * as R from 'ramda';
```
we will obtain
```js
import * as _ref from 'react';
const React = Object.keys(_ref).length === 1 && _ref.default ? _ref.default : _ref;
import ReactDOM from 'react-dom';
import * as _ from 'lodash';
import * as _ref1 from 'ramda';
const R = Object.keys(_ref1).length === 1 && _ref1.default ? _ref1.default : _ref1;
```
npm package: @hqjs/babel-plugin-transform-paths
Description: Transform global and local paths to full path with server URL
Author: hqjs
Latest version: 0.0.7

# https://hqjs.org
Transform global and local paths to full path with server URL

# Installation
```sh
npm install hqjs@babel-plugin-transform-paths
```

# Usage
```json
{
  "plugins": [["hqjs@babel-plugin-transform-paths", {
    "basePath": "",
    "baseURI": "http://localhost:8080",
    "dirname": "/path/to/module",
    "removeNodeModules": false,
    "transformAbsolute": false
  }]]
}
```
where
* **basePath** - basic path to a module, `''` by default
* **baseURI** - server baseURI
* **dirname** - path to module relative to `basePath`, meant to resolve relative imports
* **removeNodeModules** - should `/node_modules` part of the path be removed
* **transformAbsolute** - should absolute path be transformed

URL will be constructed this way:
* `./rest` -> `${baseURI}${basePath}${dirname}${rest}`
* `@/rest` -> `${baseURI}${basePath}/${rest}`
* `/rest` -> `${baseURI}${basePath}/${rest}` or `/${rest}` depending on `transformAbsolute` option
* `/node-modules/rest` -> `${baseURI}${basePath}${rest}` or `${baseURI}${basePath}node_modules/${rest}` depending on `removeNodeModules` option

# Transformation
Plugin resolves relative paths `./...`, `../...`, node_modules paths `/node_modules/...` and vue absolute paths `@/...` to full URL.
npm package: @hqjs/babel-plugin-transform-typescript
Description: Original babel plugin fork that supports parameters decorators and dependency injection
Author: hqjs
Latest version: 0.0.12

# https://hqjs.org
[Original bebel plugin](https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-typescript) fork that allows to work with parameter decorators and dependency injection

The plugin is in sync with version `7.12.1` of official plugin, the difference is that Program transformation is done on exit rather then on enter (due to that `jsxPragma` check is done differently as on program exit there is no JSX left when `react` preset is being used), that allows to apply additional transformations to import statements. Plugin has extra option `removeUnusedImports` default to true. When the option is set to false, plugin does not try to remove unused imports that could be suitable for preprocessing templates like `svelte`.

# Installation
```sh
npm install hqjs@babel-plugin-transform-typescript
```
npm package: @hqjs/stream-buffer-cache
Description: Cache for node.js streams
Author: hqjs
Latest version: 1.0.1

# stream-buffer-cache
Cache for node.js streams. Stores stream results in a memory allowing to immediatly replay the stream.

Speed up your services.

Can be applied to any cache that implements `Map` interface e.g. regular `Map` or LRU-cache. It redefines `get` and `set` methods to make a `Map` works with streams.

Usefull for caching slow repetitive streaming connections, such as S3 requests or complex database queries.


Installation
------------

```npm i @hqjs/stream-buffer-cache```


Example
-------------

```js
// You can pass any class that implements Map interface
const LRUMap = require('lru-cache');
const Cache = require('@hqjs/stream-buffer-cache')(LRUMap);

// LRU cache options
const options = {
  max: 500,
  maxAge: 1000 * 60 * 60,
};

// Pass your Map class option to Cache constructor
const cache = new Cache(options);
const fs = require('fs');

fs.createReadStream('./buffer-cache.js', { encoding: 'utf8' })
  .pipe(cache.set('test'));

cache.get('test')
  .pipe(fs.createWriteStream('./buffer-cache.js.test'));
```


API
---

This methods from parent `Map` class are overriden

##### set(key)
returns a Duplex stream
```js
fileStream.pipe(cache.set('key')).pipe(res);
```


##### get(key) => ReadableStream

```js
const cached = cache.get('key');
if (cached) {
	cached.pipe(res);
}
```
npm package: @hqleo/jslibs
Description: + 由于编写的语言越来越来，经常使用A语言时，会把B语言的常用的库，规则，语法忘记了，所以每个语言都会建立语法类似的库，以API的形式进行调用； + 第一版是一个比较简单的库先发布；
Author: HQLeo
Latest version: 0.0.1

### 常用的JS包
+ 由于编写的语言越来越来，经常使用A语言时，会把B语言的常用的库，规则，语法忘记了，所以每个语言都会建立语法类似的库，以API的形式进行调用；
+ 第一版是一个比较简单的库先发布；
npm package: @hqnseung/captcha.js
Description: `@hqnseung/captcha.js`는 간단한 캡차 이미지를 생성할 수 있는 Node.js 라이브러리입니다. 보안과 사용자 확인을 위한 캡차 이미지를 빠르게 생성할 수 있습니다.
Author: hqnsueng
Latest version: 1.0.2

# @hqnseung/captcha.js

`@hqnseung/captcha.js`는 간단한 캡차 이미지를 생성할 수 있는 Node.js 라이브러리입니다. 보안과 사용자 확인을 위한 캡차 이미지를 빠르게 생성할 수 있습니다.

## 설치
```
npm install @hqnseung/captcha.js
```

## 예제

```js
const { generateCaptcha } = require('@hqnseung/captcha.js');
const fs = require('fs');

const { image, text } = generateCaptcha(); // 캡차 생성
console.log('CAPTCHA Text:', text); // 캡차 텍스트 출력
fs.writeFileSync('captcha.png', image); // 이미지 저장
console.log('CAPTCHA image saved as captcha.png'); 
```

## 함수 설명

### `generateCaptcha()`

캡차 이미지를 생성합니다.

- 반환값: `{ image: Buffer, text: string }`
  - `image`: 캡차 이미지 데이터 (`Buffer` 형태)
  - `text`: 캡차의 텍스트 값

## 특징

- 랜덤 글자와 스타일
- 배경 및 글자에 대한 다양한 색상 적용
- 직선, 원, 곡선 등의 추가적인 잡음 요소 생성


## 라이센스
이 프로젝트는 MIT 라이센스 하에 배포됩니다. 자세한 내용은 [LICENSE](./LICENSE) 파일을 참조하세요.
npm package: @hqro/conduct
Description: Replacing redux with the new React context API
Author: Guillaume L.
Latest version: 1.0.1
Deprecated: useless package

# Conduct

Replacing redux with the new React context API

### How to use ?

```bash
yarn add @hqro/conduct
```

```js
// src/index.js
import React from 'react'
import ReactDOM from 'react-dom'
import { Provider } from 'conduct'

import './index.css'
import App from './src/containers/App'

const store = { count: 0 }

ReactDOM.render(
  <Provider store={store}>
    <App />
  </Provider>,
  document.getElementById('root'),
)
```

```js
// src/containers/App
import React, { Component } from 'react'
import PropTypes from 'prop-types'
import { connect } from 'conduct'

class App extends Component {
  static propTypes = {
    count: PropTypes.number,
  }

  static defaultProps = {
    count: 0,
  }

  render() {
    const { count } = this.props

    return (
      <div className="App">
        <p>Count: {count}</p>
      </div>
    )
  }
}

const mapStateToProps = state => ({
  count: state.count || 0,
})

export default connect(mapStateToProps)(App)
```
npm package: @hqro/create-react-component
Description: Command line interface to initialize empty ES8 React & React Native components
Author: Guillaume L.
Latest version: 2.1.4

# create-react-component

Command line interface to initialize empty ES8 React and React Native components


## Installation

```bash
npm install --global @hqro/create-react-component
```


## Usage information

```bash
  Usage: crc [options]


  Options:

    -V, --version       Output the version number
    -n, --name <name>   Component name (default: Test)
    -d, --dest <path>   Component destination (default: current path)
    -L, --stateless     Apply stateless component template
    -F, --statefull     Apply statefull component template
    -X, --redux         Connect your component with Redux
    -W, --web           Create React Web component
    -N, --native        Create React Native component
    -C, --css           Create CSS stylesheet
    -S, --scss          Create SCSS stylesheet
    -h, --help          Output usage information
```


## Example

Generate a statefull component connected to the Redux store and using CSS stylesheet:

```bash
cd src/components
crc -n Test --web --css --statefull --redux
```

Output:

```bash
  Test
  ├── Test.js
  ├── Test.css
  └── index.js
```
npm package: @hqro/gojji
Description: Modulable React components library
Author: Guillaume L.
Latest version: 1.0.4

# React-Components-Library-Starter-Kit

Boilerplate to building a React components library for NPM

## How to start ?

#### Setup you development environement

```bash
git clone git@github.com:hqro/React-Components-Library-Starter-Kit.git
cd React-Components-Library-Starter-Kit
yarn install
```

#### Rename project and initialize your git repository

```bash
cd ..
mv React-Components-Library-Starter-Kit my-components-library
cd my-components-library
rm -Rvf .git
git init
git remote add ...
```

Don't forget to edit the `package.json`. Add your dependencies and customize `name`, `description` and `author`.

## How to use ?

```bash
yarn start
```

`webpack` now wath for file changes in `src/components` folder. Each time you add a new component, it will compile your source files again. Don't forget to export your components on `index.js` file.

## How to test ?

```bash
yarn link
```

This command is run in the package folder you’d like to link. Then initialize a new react project with `create-react-app` for example

```bash
cd ..
create-react-app Demo
cd Demo
yarn link my-components-library
```

Then go to you React project and try to import your components.

```javascript
import React from 'react'
import { Button } from 'my-components-library'

const App = () => (
  <div className="App">
    <Button label="Awesome button" onClick={() => console.log('click')} />
  </div>
)
```

## How to build for production ?

```bash
yarn build
yarn login
yarn publish --access=public
```

You need a NPM account to publish your package
npm package: @hqro/redux-request
Description: Simple Redux API request middleware
Author: g.lariviere
Latest version: 1.0.4

## Redux Request Middleware

Simple Redux API request middleware

### Installation

```bash
yarn add @hqro/redux-request
```

```js
import { createStore, applyMiddleware, compose } from 'redux'
import requestMiddleware from '@hqro/redux-request'

import reducers from './reducers'

const store = createStore(
  reducers,
  undefined, // Initial state
  compose(
    applyMiddleware(
      requestMiddleware,
    ),
  ),
)

export default store
```

### Usage

```js
// actions/users.js
const { API_URL } = process.env

const fetchAllUsers = token => ({
  type: '@@REQUEST/FETCH_ALL_USERS',
  url: `${API_URL}/users`,
  headers: { Authorization: token },
})

const createUser = data => ({
  type: '@@REQUEST/CREATE_USER',
  method: 'POST',
  url: `${API_URL}/user`,
  body: JSON.stringify(data),
  onSuccess: () => console.log('User created !'),
  onError: e => console.error(e),
})
```

```js
// reducers/users.js
const initialState = {
  users: [],
}

const userReducer = (state = initialState, { type, payload }) => {
  switch (type) {
    case '@@REQUEST/FETCH_ALL_USERS_PENDING':
    case '@@REQUEST/FETCH_ALL_USERS_ERROR':
      return initialState
    case '@@REQUEST/FETCH_ALL_USERS_SUCCESS':
      return ({
        ...state,
        users: payload.data,
      })
    default:
      return state
  }
}
```

### Using Redux-Thunk

```js
// actions/users.js
const { API_URL } = process.env

const fetchAllUsers = (token, retries = 2) =>
  async dispatch => dispatch({
    type: '@@REQUEST/FETCH_ALL_USERS',
    url: `${API_URL}/users`,
    headers: { Authorization: token },
    onError: () =>
      retries && dispatch(fetchAllUsers(token, retries - 1)),
  })
```
npm package: @hqtsm/crc
Description: CRC functions with a parameterized engine optimized for both speed and size
Latest version: 2.1.0

# HQTSM: CRC

CRC functions with a parameterized engine optimized for both speed and size

![crc](https://img.shields.io/badge/crc-eee)
![digest](https://img.shields.io/badge/digest-eee)
![checksum](https://img.shields.io/badge/checksum-eee)
![hash](https://img.shields.io/badge/hash-eee)
![typescript](https://img.shields.io/badge/typescript-eee)
![esm](https://img.shields.io/badge/esm-eee)
![streamable](https://img.shields.io/badge/streamable-eee)
![crc-8](https://img.shields.io/badge/crc--8-eee)
![crc-16](https://img.shields.io/badge/crc--16-eee)
![crc-24](https://img.shields.io/badge/crc--24-eee)
![crc-32](https://img.shields.io/badge/crc--32-eee)
![crc-64](https://img.shields.io/badge/crc--64-eee)

[![JSR](https://jsr.io/badges/@hqtsm/crc)](https://jsr.io/@hqtsm/crc)
[![npm](https://img.shields.io/npm/v/@hqtsm/crc.svg)](https://npmjs.com/package/@hqtsm/crc)
[![CI](https://github.com/hqtsm/crc/actions/workflows/ci.yaml/badge.svg)](https://github.com/hqtsm/crc/actions/workflows/ci.yaml)

# Features

- Pure TypeScript, run anywhere
- Zero dependencies
- Optimized for speed
  - Table-based algorithm
  - Minimal initialization code
- Optimized for size
  - Shared engine < 500 bytes with standard web compression
  - Tables generated on first use
  - Minimal additional overhead to each variant
  - Individually importable algorithms
- Tree shaking friendly design
- 100+ known digests provided, plus the option of configuring custom ones
- Streamable and resumable interface, just call update for each chunk
- Number for small digests, 32-bit or less
- BigInt for larger digests
- Digest values always an unsigned integer
- Supports 8-bit typed arrays, regular arrays, and array-like objects
- Pure methods, can be assigned directly to variables as needed

# Usage

## CRC-32/ISO-HDLC

The most-common 32-bit digest, used by PNG, ZIP, and more.

```js
import CRC32 from '@hqtsm/crc/crc-32/iso-hdlc';

let crc = CRC32.init();
crc = CRC32.update(crc, new TextEncoder().encode('123456789'));
crc = CRC32.finalize(crc);
console.assert(crc.toString(16) === 'cbf43926');
```

## CRC-64/XZ

A common 64-bit digest, sometimes incorrectly refered to as ECMA-182.

```js
import CRC64 from '@hqtsm/crc/crc-64/xz';

let crc = CRC64.init();
crc = CRC64.update(crc, new TextEncoder().encode('123456789'));
crc = CRC64.finalize(crc);
console.assert(crc.toString(16) === '995dc9bbdf1939fa');
```

# Acknowledgements

Thanks to pycrc for the inspiration and validation checking.

Thanks to CRC RevEng for cataloging the different digests.
npm package: @hqtsm/dataview
Description: DataView utilities
Latest version: 2.0.0

# HQTSM: DataView

DataView utilities

![dataview](https://img.shields.io/badge/dataview-eee)
![float16](https://img.shields.io/badge/float16-eee)
![int24](https://img.shields.io/badge/int24-eee)
![uint24](https://img.shields.io/badge/uint24-eee)

[![JSR](https://jsr.io/badges/@hqtsm/dataview)](https://jsr.io/@hqtsm/dataview)
[![npm](https://img.shields.io/npm/v/@hqtsm/dataview.svg)](https://npmjs.com/package/@hqtsm/dataview)
[![CI](https://github.com/hqtsm/dataview/actions/workflows/ci.yaml/badge.svg)](https://github.com/hqtsm/dataview/actions/workflows/ci.yaml)

# Features

- Pure TypeScript, run anywhere
- Zero dependencies
- Optimized for speed and size
- Tree shaking friendly design

# Usage

## Float16

```js
import { getFloat16, setFloat16 } from '@hqtsm/dataview';

const data = new Uint8Array(4);
const view = new DataView(data.buffer);
setFloat16(view, 0, Math.PI);
setFloat16(view, 2, Math.LN10, true);
console.assert(data.join(', ') === '66, 72, 155, 64');
console.assert(getFloat16(view, 0) === 3.140625);
console.assert(getFloat16(view, 2, true) === 2.302734375);
```

## Int24

```js
import { getInt24, setInt24 } from '@hqtsm/dataview';

const data = new Uint8Array(6);
const view = new DataView(data.buffer);
setInt24(view, 0, -1234);
setInt24(view, 3, -4567, true);
console.assert(data.join(', ') === '255, 251, 46, 41, 238, 255');
console.assert(getInt24(view, 0) === -1234);
console.assert(getInt24(view, 3, true) === -4567);
```

## Uint24

```js
import { getUint24, setUint24 } from '@hqtsm/dataview';

const data = new Uint8Array(6);
const view = new DataView(data.buffer);
setUint24(view, 0, 12345678);
setUint24(view, 3, 11223344, true);
console.assert(data.join(', ') === '188, 97, 78, 48, 65, 171');
console.assert(getUint24(view, 0) === 12345678);
console.assert(getUint24(view, 3, true) === 11223344);
```