llonebot-dist 6.6.4

dist/node_modules/token-types/README.md

@@ -0,0 +1,120 @@
+[![Node.js CI](https://github.com/Borewit/token-types/actions/workflows/nodejs-ci.yml/badge.svg?branch=master)](https://github.com/Borewit/token-types/actions/workflows/nodejs-ci.yml?query=branch%3Amaster)
+[![NPM version](https://badge.fury.io/js/token-types.svg)](https://npmjs.org/package/token-types)
+[![npm downloads](http://img.shields.io/npm/dm/token-types.svg)](https://npmcharts.com/compare/token-types,strtok3?start=1200&interval=30)
+[![coveralls](https://coveralls.io/repos/github/Borewit/token-types/badge.svg?branch=master)](https://coveralls.io/github/Borewit/token-types?branch=master)
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/4723ce4613fc49cda8db5eed29f18834)](https://www.codacy.com/app/Borewit/token-types?utm_source=github.com&utm_medium=referral&utm_content=Borewit/token-types&utm_campaign=Badge_Grade)
+[![DeepScan grade](https://deepscan.io/api/teams/5165/projects/6940/branches/61852/badge/grade.svg)](https://deepscan.io/dashboard#view=project&tid=5165&pid=6940&bid=61852)
+[![Known Vulnerabilities](https://snyk.io/test/github/Borewit/token-types/badge.svg?targetFile=package.json)](https://snyk.io/test/github/Borewit/token-types?targetFile=package.json)
+
+# token-types
+
+A primitive token library used to read and write from a `Uint8Array`.
+Although it is possible to use this module directly, it is primarily designed to be used with [strtok3 tokenizer](https://github.com/Borewit/strtok3).
+
+## Compatibility
+
+Module: version 5 migrated from [CommonJS](https://en.wikipedia.org/wiki/CommonJS) to [pure ECMAScript Module (ESM)](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c).
+JavaScript is compliant with [ECMAScript 2019 (ES10)](https://en.wikipedia.org/wiki/ECMAScript#10th_Edition_%E2%80%93_ECMAScript_2019).
+
+## Installation
+
+```sh
+npm install --save token-types
+```
+Usually in combination with [strtok3](https://github.com/Borewit/strtok3):
+```sh
+npm install --save strtok3
+```
+
+Using TypeScript you should also install [@tokenizer/token](https://github.com/Borewit/tokenizer-token) as a development
+dependency:
+
+```shell
+npm install --save-dev @tokenizer/token
+```
+
+
+## Example
+
+```js
+import * as strtok3 from 'strtok3';
+import * as token from 'token-types';
+
+(async () => {
+
+  const tokenizer = await strtok3.fromFile("somefile.bin");
+  try {
+    const myNumber = await tokenizer.readToken(token.Float32_BE);
+    console.log(`My number: ${myNumber}`);
+  } finally {
+    tokenizer.close(); // Close the file
+  }
+})();
+```
+
+## Tokens
+
+### Numeric tokens
+
+`token-types` supports a wide variety of numeric tokens out of the box:
+
+| Token         | Number           | Bits | Endianness     |
+|---------------|------------------|------|----------------|
+| `UINT8`       | Unsigned integer |    8 | n/a            |
+| `UINT16_BE`   | Unsigned integer |   16 | big endian     |
+| `UINT16_LE`   | Unsigned integer |   16 | little endian  |
+| `UINT24_BE`   | Unsigned integer |   24 | big endian     |
+| `UINT24_LE`   | Unsigned integer |   24 | little endian  |
+| `UINT32_BE`   | Unsigned integer |   32 | big endian     |
+| `UINT32_LE`   | Unsigned integer |   32 | little endian  |
+| `UINT64_BE`   | Unsigned integer |   64 | big endian     |
+| `UINT64_LE`*  | Unsigned integer |   64 | little endian  |
+| `INT8`        | Signed integer   |    8 | n/a            |
+| `INT16_BE`    | Signed integer   |   16 | big endian     |
+| `INT16_LE`    | Signed integer   |   16 | little endian  |
+| `INT24_BE`    | Signed integer   |   24 | big endian     |
+| `INT24_LE`    | Signed integer   |   24 | little endian  |
+| `INT32_BE`    | Signed integer   |   32 | big endian     |
+| `INT32_LE`    | Signed integer   |   32 | little endian  |
+| `INT64_BE`    | Signed integer   |   64 | big endian     |
+| `INT64_LE`*   | Signed integer   |   64 | little endian  |
+| `Float16_BE`  | IEEE 754 float   |   16 | big endian     |
+| `Float16_LE`  | IEEE 754 float   |   16 | little endian  |
+| `Float32_BE`  | IEEE 754 float   |   32 | big endian     |
+| `Float32_LE`  | IEEE 754 float   |   32 | little endian  |
+| `Float64_BE`  | IEEE 754 float   |   64 | big endian     |
+| `Float64_LE`  | IEEE 754 float   |   64 | little endian  |
+| `Float80_BE`* | IEEE 754 float   |   80 | big endian     |
+| `Float80_LE`* | IEEE 754 float   |   80 | little endian  |
+
+(*) The tokens exceed the JavaScript IEEE 754 64-bit Floating Point precision, decoding and encoding is best effort based.
+
+### String tokens
+
+StringType decoding is using [@borewit/text-codec](https://github.com/Borewit/text-codec).
+
+### Custom tokens
+
+Custom tokens can be added, suitable for reading binary files or network messages:
+```js
+  ExtendedHeader = {
+    len: 10,
+
+    get: (buf, off) => {
+      return {
+        // Extended header size
+        size: Token.UINT32_BE.get(buf, off),
+        // Extended Flags
+        extendedFlags: Token.UINT16_BE.get(buf, off + 4),
+        // Size of padding
+        sizeOfPadding: Token.UINT32_BE.get(buf, off + 6),
+        // CRC data present
+        crcDataPresent: common.strtokBITSET.get(buf, off + 4, 31)
+      };
+    }
+  };
+```
+
+## Licence
+
+This project is licensed under the [MIT License](LICENSE.txt). Feel free to use, modify, and distribute as needed.

dist/node_modules/token-types/lib/index.d.ts

@@ -0,0 +1,135 @@
+import type { IToken, IGetToken } from '@tokenizer/token';
+export declare const UINT8: IToken<number>;
+/**
+ * 16-bit unsigned integer, Little Endian byte order
+ */
+export declare const UINT16_LE: IToken<number>;
+/**
+ * 16-bit unsigned integer, Big Endian byte order
+ */
+export declare const UINT16_BE: IToken<number>;
+/**
+ * 24-bit unsigned integer, Little Endian byte order
+ */
+export declare const UINT24_LE: IToken<number>;
+/**
+ * 24-bit unsigned integer, Big Endian byte order
+ */
+export declare const UINT24_BE: IToken<number>;
+/**
+ * 32-bit unsigned integer, Little Endian byte order
+ */
+export declare const UINT32_LE: IToken<number>;
+/**
+ * 32-bit unsigned integer, Big Endian byte order
+ */
+export declare const UINT32_BE: IToken<number>;
+/**
+ * 8-bit signed integer
+ */
+export declare const INT8: IToken<number>;
+/**
+ * 16-bit signed integer, Big Endian byte order
+ */
+export declare const INT16_BE: IToken<number>;
+/**
+ * 16-bit signed integer, Little Endian byte order
+ */
+export declare const INT16_LE: IToken<number>;
+/**
+ * 24-bit signed integer, Little Endian byte order
+ */
+export declare const INT24_LE: IToken<number>;
+/**
+ * 24-bit signed integer, Big Endian byte order
+ */
+export declare const INT24_BE: IToken<number>;
+/**
+ * 32-bit signed integer, Big Endian byte order
+ */
+export declare const INT32_BE: IToken<number>;
+/**
+ * 32-bit signed integer, Big Endian byte order
+ */
+export declare const INT32_LE: IToken<number>;
+/**
+ * 64-bit unsigned integer, Little Endian byte order
+ */
+export declare const UINT64_LE: IToken<bigint>;
+/**
+ * 64-bit signed integer, Little Endian byte order
+ */
+export declare const INT64_LE: IToken<bigint>;
+/**
+ * 64-bit unsigned integer, Big Endian byte order
+ */
+export declare const UINT64_BE: IToken<bigint>;
+/**
+ * 64-bit signed integer, Big Endian byte order
+ */
+export declare const INT64_BE: IToken<bigint>;
+/**
+ * IEEE 754 16-bit (half precision) float, big endian
+ */
+export declare const Float16_BE: IToken<number>;
+/**
+ * IEEE 754 16-bit (half precision) float, little endian
+ */
+export declare const Float16_LE: IToken<number>;
+/**
+ * IEEE 754 32-bit (single precision) float, big endian
+ */
+export declare const Float32_BE: IToken<number>;
+/**
+ * IEEE 754 32-bit (single precision) float, little endian
+ */
+export declare const Float32_LE: IToken<number>;
+/**
+ * IEEE 754 64-bit (double precision) float, big endian
+ */
+export declare const Float64_BE: IToken<number>;
+/**
+ * IEEE 754 64-bit (double precision) float, little endian
+ */
+export declare const Float64_LE: IToken<number>;
+/**
+ * IEEE 754 80-bit (extended precision) float, big endian
+ */
+export declare const Float80_BE: IToken<number>;
+/**
+ * IEEE 754 80-bit (extended precision) float, little endian
+ */
+export declare const Float80_LE: IToken<number>;
+/**
+ * Ignore a given number of bytes
+ */
+export declare class IgnoreType implements IGetToken<void> {
+    len: number;
+    /**
+     * @param len number of bytes to ignore
+     */
+    constructor(len: number);
+    get(_array: Uint8Array, _off: number): void;
+}
+export declare class Uint8ArrayType implements IGetToken<Uint8Array> {
+    len: number;
+    constructor(len: number);
+    get(array: Uint8Array, offset: number): Uint8Array;
+}
+/**
+ * Consume a fixed number of bytes from the stream and return a string with a specified encoding.
+ * Supports all encodings supported by TextDecoder, plus 'windows-1252'.
+ */
+export declare class StringType implements IGetToken<string> {
+    len: number;
+    private encoding?;
+    constructor(len: number, encoding?: string);
+    get(data: Uint8Array, offset?: number): string;
+}
+/**
+ * ANSI Latin 1 String using Windows-1252 (Code Page 1252)
+ * Windows-1252 is a superset of ISO 8859-1 / Latin-1.
+ */
+export declare class AnsiStringType extends StringType {
+    constructor(len: number);
+}

dist/node_modules/token-types/lib/index.js

@@ -0,0 +1,401 @@
+import * as ieee754 from 'ieee754';
+import { textDecode } from "@borewit/text-codec";
+// Primitive types
+function dv(array) {
+    return new DataView(array.buffer, array.byteOffset);
+}
+/*
+ * 8-bit unsigned integer
+ */
+export const UINT8 = {
+    len: 1,
+    get(array, offset) {
+        return dv(array).getUint8(offset);
+    },
+    put(array, offset, value) {
+        dv(array).setUint8(offset, value);
+        return offset + 1;
+    }
+};
+/**
+ * 16-bit unsigned integer, Little Endian byte order
+ */
+export const UINT16_LE = {
+    len: 2,
+    get(array, offset) {
+        return dv(array).getUint16(offset, true);
+    },
+    put(array, offset, value) {
+        dv(array).setUint16(offset, value, true);
+        return offset + 2;
+    }
+};
+/**
+ * 16-bit unsigned integer, Big Endian byte order
+ */
+export const UINT16_BE = {
+    len: 2,
+    get(array, offset) {
+        return dv(array).getUint16(offset);
+    },
+    put(array, offset, value) {
+        dv(array).setUint16(offset, value);
+        return offset + 2;
+    }
+};
+/**
+ * 24-bit unsigned integer, Little Endian byte order
+ */
+export const UINT24_LE = {
+    len: 3,
+    get(array, offset) {
+        const dataView = dv(array);
+        return dataView.getUint8(offset) + (dataView.getUint16(offset + 1, true) << 8);
+    },
+    put(array, offset, value) {
+        const dataView = dv(array);
+        dataView.setUint8(offset, value & 0xff);
+        dataView.setUint16(offset + 1, value >> 8, true);
+        return offset + 3;
+    }
+};
+/**
+ * 24-bit unsigned integer, Big Endian byte order
+ */
+export const UINT24_BE = {
+    len: 3,
+    get(array, offset) {
+        const dataView = dv(array);
+        return (dataView.getUint16(offset) << 8) + dataView.getUint8(offset + 2);
+    },
+    put(array, offset, value) {
+        const dataView = dv(array);
+        dataView.setUint16(offset, value >> 8);
+        dataView.setUint8(offset + 2, value & 0xff);
+        return offset + 3;
+    }
+};
+/**
+ * 32-bit unsigned integer, Little Endian byte order
+ */
+export const UINT32_LE = {
+    len: 4,
+    get(array, offset) {
+        return dv(array).getUint32(offset, true);
+    },
+    put(array, offset, value) {
+        dv(array).setUint32(offset, value, true);
+        return offset + 4;
+    }
+};
+/**
+ * 32-bit unsigned integer, Big Endian byte order
+ */
+export const UINT32_BE = {
+    len: 4,
+    get(array, offset) {
+        return dv(array).getUint32(offset);
+    },
+    put(array, offset, value) {
+        dv(array).setUint32(offset, value);
+        return offset + 4;
+    }
+};
+/**
+ * 8-bit signed integer
+ */
+export const INT8 = {
+    len: 1,
+    get(array, offset) {
+        return dv(array).getInt8(offset);
+    },
+    put(array, offset, value) {
+        dv(array).setInt8(offset, value);
+        return offset + 1;
+    }
+};
+/**
+ * 16-bit signed integer, Big Endian byte order
+ */
+export const INT16_BE = {
+    len: 2,
+    get(array, offset) {
+        return dv(array).getInt16(offset);
+    },
+    put(array, offset, value) {
+        dv(array).setInt16(offset, value);
+        return offset + 2;
+    }
+};
+/**
+ * 16-bit signed integer, Little Endian byte order
+ */
+export const INT16_LE = {
+    len: 2,
+    get(array, offset) {
+        return dv(array).getInt16(offset, true);
+    },
+    put(array, offset, value) {
+        dv(array).setInt16(offset, value, true);
+        return offset + 2;
+    }
+};
+/**
+ * 24-bit signed integer, Little Endian byte order
+ */
+export const INT24_LE = {
+    len: 3,
+    get(array, offset) {
+        const unsigned = UINT24_LE.get(array, offset);
+        return unsigned > 0x7fffff ? unsigned - 0x1000000 : unsigned;
+    },
+    put(array, offset, value) {
+        const dataView = dv(array);
+        dataView.setUint8(offset, value & 0xff);
+        dataView.setUint16(offset + 1, value >> 8, true);
+        return offset + 3;
+    }
+};
+/**
+ * 24-bit signed integer, Big Endian byte order
+ */
+export const INT24_BE = {
+    len: 3,
+    get(array, offset) {
+        const unsigned = UINT24_BE.get(array, offset);
+        return unsigned > 0x7fffff ? unsigned - 0x1000000 : unsigned;
+    },
+    put(array, offset, value) {
+        const dataView = dv(array);
+        dataView.setUint16(offset, value >> 8);
+        dataView.setUint8(offset + 2, value & 0xff);
+        return offset + 3;
+    }
+};
+/**
+ * 32-bit signed integer, Big Endian byte order
+ */
+export const INT32_BE = {
+    len: 4,
+    get(array, offset) {
+        return dv(array).getInt32(offset);
+    },
+    put(array, offset, value) {
+        dv(array).setInt32(offset, value);
+        return offset + 4;
+    }
+};
+/**
+ * 32-bit signed integer, Big Endian byte order
+ */
+export const INT32_LE = {
+    len: 4,
+    get(array, offset) {
+        return dv(array).getInt32(offset, true);
+    },
+    put(array, offset, value) {
+        dv(array).setInt32(offset, value, true);
+        return offset + 4;
+    }
+};
+/**
+ * 64-bit unsigned integer, Little Endian byte order
+ */
+export const UINT64_LE = {
+    len: 8,
+    get(array, offset) {
+        return dv(array).getBigUint64(offset, true);
+    },
+    put(array, offset, value) {
+        dv(array).setBigUint64(offset, value, true);
+        return offset + 8;
+    }
+};
+/**
+ * 64-bit signed integer, Little Endian byte order
+ */
+export const INT64_LE = {
+    len: 8,
+    get(array, offset) {
+        return dv(array).getBigInt64(offset, true);
+    },
+    put(array, offset, value) {
+        dv(array).setBigInt64(offset, value, true);
+        return offset + 8;
+    }
+};
+/**
+ * 64-bit unsigned integer, Big Endian byte order
+ */
+export const UINT64_BE = {
+    len: 8,
+    get(array, offset) {
+        return dv(array).getBigUint64(offset);
+    },
+    put(array, offset, value) {
+        dv(array).setBigUint64(offset, value);
+        return offset + 8;
+    }
+};
+/**
+ * 64-bit signed integer, Big Endian byte order
+ */
+export const INT64_BE = {
+    len: 8,
+    get(array, offset) {
+        return dv(array).getBigInt64(offset);
+    },
+    put(array, offset, value) {
+        dv(array).setBigInt64(offset, value);
+        return offset + 8;
+    }
+};
+/**
+ * IEEE 754 16-bit (half precision) float, big endian
+ */
+export const Float16_BE = {
+    len: 2,
+    get(dataView, offset) {
+        return ieee754.read(dataView, offset, false, 10, this.len);
+    },
+    put(dataView, offset, value) {
+        ieee754.write(dataView, value, offset, false, 10, this.len);
+        return offset + this.len;
+    }
+};
+/**
+ * IEEE 754 16-bit (half precision) float, little endian
+ */
+export const Float16_LE = {
+    len: 2,
+    get(array, offset) {
+        return ieee754.read(array, offset, true, 10, this.len);
+    },
+    put(array, offset, value) {
+        ieee754.write(array, value, offset, true, 10, this.len);
+        return offset + this.len;
+    }
+};
+/**
+ * IEEE 754 32-bit (single precision) float, big endian
+ */
+export const Float32_BE = {
+    len: 4,
+    get(array, offset) {
+        return dv(array).getFloat32(offset);
+    },
+    put(array, offset, value) {
+        dv(array).setFloat32(offset, value);
+        return offset + 4;
+    }
+};
+/**
+ * IEEE 754 32-bit (single precision) float, little endian
+ */
+export const Float32_LE = {
+    len: 4,
+    get(array, offset) {
+        return dv(array).getFloat32(offset, true);
+    },
+    put(array, offset, value) {
+        dv(array).setFloat32(offset, value, true);
+        return offset + 4;
+    }
+};
+/**
+ * IEEE 754 64-bit (double precision) float, big endian
+ */
+export const Float64_BE = {
+    len: 8,
+    get(array, offset) {
+        return dv(array).getFloat64(offset);
+    },
+    put(array, offset, value) {
+        dv(array).setFloat64(offset, value);
+        return offset + 8;
+    }
+};
+/**
+ * IEEE 754 64-bit (double precision) float, little endian
+ */
+export const Float64_LE = {
+    len: 8,
+    get(array, offset) {
+        return dv(array).getFloat64(offset, true);
+    },
+    put(array, offset, value) {
+        dv(array).setFloat64(offset, value, true);
+        return offset + 8;
+    }
+};
+/**
+ * IEEE 754 80-bit (extended precision) float, big endian
+ */
+export const Float80_BE = {
+    len: 10,
+    get(array, offset) {
+        return ieee754.read(array, offset, false, 63, this.len);
+    },
+    put(array, offset, value) {
+        ieee754.write(array, value, offset, false, 63, this.len);
+        return offset + this.len;
+    }
+};
+/**
+ * IEEE 754 80-bit (extended precision) float, little endian
+ */
+export const Float80_LE = {
+    len: 10,
+    get(array, offset) {
+        return ieee754.read(array, offset, true, 63, this.len);
+    },
+    put(array, offset, value) {
+        ieee754.write(array, value, offset, true, 63, this.len);
+        return offset + this.len;
+    }
+};
+/**
+ * Ignore a given number of bytes
+ */
+export class IgnoreType {
+    /**
+     * @param len number of bytes to ignore
+     */
+    constructor(len) {
+        this.len = len;
+    }
+    // ToDo: don't read, but skip data
+    get(_array, _off) {
+    }
+}
+export class Uint8ArrayType {
+    constructor(len) {
+        this.len = len;
+    }
+    get(array, offset) {
+        return array.subarray(offset, offset + this.len);
+    }
+}
+/**
+ * Consume a fixed number of bytes from the stream and return a string with a specified encoding.
+ * Supports all encodings supported by TextDecoder, plus 'windows-1252'.
+ */
+export class StringType {
+    constructor(len, encoding) {
+        this.len = len;
+        this.encoding = encoding;
+    }
+    get(data, offset = 0) {
+        const bytes = data.subarray(offset, offset + this.len);
+        return textDecode(bytes, this.encoding);
+    }
+}
+/**
+ * ANSI Latin 1 String using Windows-1252 (Code Page 1252)
+ * Windows-1252 is a superset of ISO 8859-1 / Latin-1.
+ */
+export class AnsiStringType extends StringType {
+    constructor(len) {
+        super(len, 'windows-1252');
+    }
+}