llonebot-dist 6.6.4

dist/node_modules/strtok3/lib/stream/Errors.js

@@ -0,0 +1,16 @@
+export const defaultMessages = 'End-Of-Stream';
+/**
+ * Thrown on read operation of the end of file or stream has been reached
+ */
+export class EndOfStreamError extends Error {
+    constructor() {
+        super(defaultMessages);
+        this.name = "EndOfStreamError";
+    }
+}
+export class AbortError extends Error {
+    constructor(message = "The operation was aborted") {
+        super(message);
+        this.name = "AbortError";
+    }
+}

dist/node_modules/strtok3/lib/stream/StreamReader.d.ts

@@ -0,0 +1,29 @@
+import type { Readable } from 'node:stream';
+import { AbstractStreamReader } from "./AbstractStreamReader.js";
+/**
+ * Node.js Readable Stream Reader
+ * Ref: https://nodejs.org/api/stream.html#readable-streams
+ */
+export declare class StreamReader extends AbstractStreamReader {
+    private s;
+    /**
+     * Deferred used for postponed read request (as not data is yet available to read)
+     */
+    private deferred;
+    constructor(s: Readable);
+    /**
+     * Read chunk from stream
+     * @param buffer Target Uint8Array (or Buffer) to store data read from stream in
+     * @param mayBeLess - If true, may fill the buffer partially
+     * @returns Number of bytes read
+     */
+    protected readFromStream(buffer: Uint8Array, mayBeLess: boolean): Promise<number>;
+    /**
+     * Process deferred read request
+     * @param request Deferred read request
+     */
+    private readDeferred;
+    private reject;
+    abort(): Promise<void>;
+    close(): Promise<void>;
+}

dist/node_modules/strtok3/lib/stream/StreamReader.js

@@ -0,0 +1,83 @@
+import { AbortError, } from './Errors.js';
+import { Deferred } from './Deferred.js';
+import { AbstractStreamReader } from "./AbstractStreamReader.js";
+/**
+ * Node.js Readable Stream Reader
+ * Ref: https://nodejs.org/api/stream.html#readable-streams
+ */
+export class StreamReader extends AbstractStreamReader {
+    constructor(s) {
+        super();
+        this.s = s;
+        /**
+         * Deferred used for postponed read request (as not data is yet available to read)
+         */
+        this.deferred = null;
+        if (!s.read || !s.once) {
+            throw new Error('Expected an instance of stream.Readable');
+        }
+        this.s.once('end', () => {
+            this.endOfStream = true;
+            if (this.deferred) {
+                this.deferred.resolve(0);
+            }
+        });
+        this.s.once('error', err => this.reject(err));
+        this.s.once('close', () => this.abort());
+    }
+    /**
+     * Read chunk from stream
+     * @param buffer Target Uint8Array (or Buffer) to store data read from stream in
+     * @param mayBeLess - If true, may fill the buffer partially
+     * @returns Number of bytes read
+     */
+    async readFromStream(buffer, mayBeLess) {
+        if (buffer.length === 0)
+            return 0;
+        const readBuffer = this.s.read(buffer.length);
+        if (readBuffer) {
+            buffer.set(readBuffer);
+            return readBuffer.length;
+        }
+        const request = {
+            buffer,
+            mayBeLess,
+            deferred: new Deferred()
+        };
+        this.deferred = request.deferred;
+        this.s.once('readable', () => {
+            this.readDeferred(request);
+        });
+        return request.deferred.promise;
+    }
+    /**
+     * Process deferred read request
+     * @param request Deferred read request
+     */
+    readDeferred(request) {
+        const readBuffer = this.s.read(request.buffer.length);
+        if (readBuffer) {
+            request.buffer.set(readBuffer);
+            request.deferred.resolve(readBuffer.length);
+            this.deferred = null;
+        }
+        else {
+            this.s.once('readable', () => {
+                this.readDeferred(request);
+            });
+        }
+    }
+    reject(err) {
+        this.interrupted = true;
+        if (this.deferred) {
+            this.deferred.reject(err);
+            this.deferred = null;
+        }
+    }
+    async abort() {
+        this.reject(new AbortError());
+    }
+    async close() {
+        return this.abort();
+    }
+}

dist/node_modules/strtok3/lib/stream/WebStreamByobReader.d.ts

@@ -0,0 +1,14 @@
+import { WebStreamReader } from './WebStreamReader.js';
+/**
+ * Read from a WebStream using a BYOB reader
+ * Reference: https://nodejs.org/api/webstreams.html#class-readablestreambyobreader
+ */
+export declare class WebStreamByobReader extends WebStreamReader {
+    /**
+     * Read from stream
+     * @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
+     * @param mayBeLess - If true, may fill the buffer partially
+     * @protected Bytes read
+     */
+    protected readFromStream(buffer: Uint8Array, mayBeLess: boolean): Promise<number>;
+}

dist/node_modules/strtok3/lib/stream/WebStreamByobReader.js

@@ -0,0 +1,27 @@
+import { WebStreamReader } from './WebStreamReader.js';
+/**
+ * Read from a WebStream using a BYOB reader
+ * Reference: https://nodejs.org/api/webstreams.html#class-readablestreambyobreader
+ */
+export class WebStreamByobReader extends WebStreamReader {
+    /**
+     * Read from stream
+     * @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
+     * @param mayBeLess - If true, may fill the buffer partially
+     * @protected Bytes read
+     */
+    async readFromStream(buffer, mayBeLess) {
+        if (buffer.length === 0)
+            return 0;
+        // @ts-ignore
+        const result = await this.reader.read(new Uint8Array(buffer.length), { min: mayBeLess ? undefined : buffer.length });
+        if (result.done) {
+            this.endOfStream = result.done;
+        }
+        if (result.value) {
+            buffer.set(result.value);
+            return result.value.length;
+        }
+        return 0;
+    }
+}

dist/node_modules/strtok3/lib/stream/WebStreamDefaultReader.d.ts

@@ -0,0 +1,19 @@
+import { AbstractStreamReader } from "./AbstractStreamReader.js";
+export declare class WebStreamDefaultReader extends AbstractStreamReader {
+    private reader;
+    private buffer;
+    constructor(reader: ReadableStreamDefaultReader<Uint8Array>);
+    /**
+     * Copy chunk to target, and store the remainder in this.buffer
+     */
+    private writeChunk;
+    /**
+     * Read from stream
+     * @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
+     * @param mayBeLess - If true, may fill the buffer partially
+     * @protected Bytes read
+     */
+    protected readFromStream(buffer: Uint8Array, mayBeLess: boolean): Promise<number>;
+    abort(): Promise<void>;
+    close(): Promise<void>;
+}

dist/node_modules/strtok3/lib/stream/WebStreamDefaultReader.js

@@ -0,0 +1,62 @@
+import { EndOfStreamError } from './Errors.js';
+import { AbstractStreamReader } from "./AbstractStreamReader.js";
+export class WebStreamDefaultReader extends AbstractStreamReader {
+    constructor(reader) {
+        super();
+        this.reader = reader;
+        this.buffer = null; // Internal buffer to store excess data
+    }
+    /**
+     * Copy chunk to target, and store the remainder in this.buffer
+     */
+    writeChunk(target, chunk) {
+        const written = Math.min(chunk.length, target.length);
+        target.set(chunk.subarray(0, written));
+        // Adjust the remainder of the buffer
+        if (written < chunk.length) {
+            this.buffer = chunk.subarray(written);
+        }
+        else {
+            this.buffer = null;
+        }
+        return written;
+    }
+    /**
+     * Read from stream
+     * @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
+     * @param mayBeLess - If true, may fill the buffer partially
+     * @protected Bytes read
+     */
+    async readFromStream(buffer, mayBeLess) {
+        if (buffer.length === 0)
+            return 0;
+        let totalBytesRead = 0;
+        // Serve from the internal buffer first
+        if (this.buffer) {
+            totalBytesRead += this.writeChunk(buffer, this.buffer);
+        }
+        // Continue reading from the stream if more data is needed
+        while (totalBytesRead < buffer.length && !this.endOfStream) {
+            const result = await this.reader.read();
+            if (result.done) {
+                this.endOfStream = true;
+                break;
+            }
+            if (result.value) {
+                totalBytesRead += this.writeChunk(buffer.subarray(totalBytesRead), result.value);
+            }
+        }
+        if (!mayBeLess && totalBytesRead === 0 && this.endOfStream) {
+            throw new EndOfStreamError();
+        }
+        return totalBytesRead;
+    }
+    abort() {
+        this.interrupted = true;
+        return this.reader.cancel();
+    }
+    async close() {
+        await this.abort();
+        this.reader.releaseLock();
+    }
+}

dist/node_modules/strtok3/lib/stream/WebStreamReader.d.ts

@@ -0,0 +1,14 @@
+import { AbstractStreamReader } from "./AbstractStreamReader.js";
+export declare abstract class WebStreamReader extends AbstractStreamReader {
+    protected reader: ReadableStreamDefaultReader | ReadableStreamBYOBReader;
+    constructor(reader: ReadableStreamDefaultReader | ReadableStreamBYOBReader);
+    /**
+     * Read from stream
+     * @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
+     * @param mayBeLess - If true, may fill the buffer partially
+     * @protected Bytes read
+     */
+    protected abstract readFromStream(buffer: Uint8Array, mayBeLess: boolean): Promise<number>;
+    abort(): Promise<void>;
+    close(): Promise<void>;
+}

dist/node_modules/strtok3/lib/stream/WebStreamReader.js

@@ -0,0 +1,13 @@
+import { AbstractStreamReader } from "./AbstractStreamReader.js";
+export class WebStreamReader extends AbstractStreamReader {
+    constructor(reader) {
+        super();
+        this.reader = reader;
+    }
+    async abort() {
+        return this.close();
+    }
+    async close() {
+        this.reader.releaseLock();
+    }
+}

dist/node_modules/strtok3/lib/stream/WebStreamReaderFactory.d.ts

@@ -0,0 +1,5 @@
+import type { ReadableStream as NodeReadableStream } from 'node:stream/web';
+import { WebStreamByobReader } from './WebStreamByobReader.js';
+import { WebStreamDefaultReader } from './WebStreamDefaultReader.js';
+export type AnyWebByteStream = NodeReadableStream<Uint8Array> | ReadableStream<Uint8Array>;
+export declare function makeWebStreamReader(stream: AnyWebByteStream): WebStreamByobReader | WebStreamDefaultReader;

dist/node_modules/strtok3/lib/stream/WebStreamReaderFactory.js

@@ -0,0 +1,19 @@
+import { WebStreamByobReader } from './WebStreamByobReader.js';
+import { WebStreamDefaultReader } from './WebStreamDefaultReader.js';
+export function makeWebStreamReader(stream) {
+    try {
+        const reader = stream.getReader({ mode: "byob" });
+        if (reader instanceof ReadableStreamDefaultReader) {
+            // Fallback to default reader in case `mode: byob` is ignored
+            return new WebStreamDefaultReader(reader);
+        }
+        return new WebStreamByobReader(reader);
+    }
+    catch (error) {
+        if (error instanceof TypeError) {
+            // Fallback to default reader in case `mode: byob` rejected by a `TypeError`
+            return new WebStreamDefaultReader(stream.getReader());
+        }
+        throw error;
+    }
+}

dist/node_modules/strtok3/lib/stream/index.d.ts

@@ -0,0 +1,6 @@
+export { AbortError, EndOfStreamError } from './Errors.js';
+export { StreamReader } from './StreamReader.js';
+export { WebStreamByobReader } from './WebStreamByobReader.js';
+export { WebStreamDefaultReader } from './WebStreamDefaultReader.js';
+export type { IStreamReader } from './AbstractStreamReader.js';
+export { type AnyWebByteStream, makeWebStreamReader } from './WebStreamReaderFactory.js';

dist/node_modules/strtok3/lib/stream/index.js

@@ -0,0 +1,5 @@
+export { AbortError, EndOfStreamError } from './Errors.js';
+export { StreamReader } from './StreamReader.js';
+export { WebStreamByobReader } from './WebStreamByobReader.js';
+export { WebStreamDefaultReader } from './WebStreamDefaultReader.js';
+export { makeWebStreamReader } from './WebStreamReaderFactory.js';

dist/node_modules/strtok3/lib/types.d.ts

@@ -0,0 +1,139 @@
+import type { IGetToken } from '@tokenizer/token';
+export interface IFileInfo {
+    /**
+     * File size in bytes
+     */
+    size?: number;
+    /**
+     * MIME-type of file
+     */
+    mimeType?: string;
+    /**
+     * File path
+     */
+    path?: string;
+    /**
+     * File URL
+     */
+    url?: string;
+}
+export interface IRandomAccessFileInfo extends IFileInfo {
+    /**
+     * File size in bytes
+     */
+    size: number;
+}
+export interface IReadChunkOptions {
+    /**
+     * Number of bytes to read.
+     */
+    length?: number;
+    /**
+     * Position where to begin reading from the file.
+     * Default it is `tokenizer.position`.
+     * Position may not be less than `tokenizer.position`, unless `supportsRandomAccess()` returns `true`.
+     */
+    position?: number;
+    /**
+     * If set, will not throw an EOF error if not all off the requested data could be read
+     */
+    mayBeLess?: boolean;
+}
+export interface IRandomAccessTokenizer extends ITokenizer {
+    /**
+     * Provide access to information of the underlying information stream or file.
+     */
+    fileInfo: IRandomAccessFileInfo;
+    /**
+     * Change the position (offset) of the tokenizer
+     * @param position New position
+     */
+    setPosition(position: number): void;
+}
+/**
+ * The tokenizer allows us to read or peek from the tokenizer-stream.
+ * The tokenizer-stream is an abstraction of a stream, file or Buffer.
+ */
+export interface ITokenizer {
+    /**
+     * Provide access to information of the underlying information stream or file.
+     */
+    readonly fileInfo: IFileInfo;
+    /**
+     * Offset in bytes (= number of bytes read) since beginning of file or stream
+     */
+    readonly position: number;
+    /**
+     * Peek (read ahead) buffer from tokenizer
+     * @param buffer - Target buffer to fill with data peek from the tokenizer-stream
+     * @param options - Read behaviour options
+     * @returns Promise with number of bytes read
+     */
+    peekBuffer(buffer: Uint8Array, options?: IReadChunkOptions): Promise<number>;
+    /**
+     * Peek (read ahead) buffer from tokenizer
+     * @param buffer - Target buffer to fill with data peeked from the tokenizer-stream
+     * @param options - Additional read options
+     * @returns Promise with number of bytes read
+     */
+    readBuffer(buffer: Uint8Array, options?: IReadChunkOptions): Promise<number>;
+    /**
+     * Peek a token from the tokenizer-stream.
+     * @param token - Token to peek from the tokenizer-stream.
+     * @param position - Offset where to begin reading within the file. If position is null, data will be read from the current file position.
+     * @param maybeless - If set, will not throw an EOF error if the less then the requested length could be read.
+     */
+    peekToken<T>(token: IGetToken<T>, position?: number | null, maybeless?: boolean): Promise<T>;
+    /**
+     * Read a token from the tokenizer-stream.
+     * @param token - Token to peek from the tokenizer-stream.
+     * @param position - Offset where to begin reading within the file. If position is null, data will be read from the current file position.
+     */
+    readToken<T>(token: IGetToken<T>, position?: number): Promise<T>;
+    /**
+     * Peek a numeric token from the stream
+     * @param token - Numeric token
+     * @returns Promise with number
+     */
+    peekNumber(token: IGetToken<number>): Promise<number>;
+    /**
+     * Read a numeric token from the stream
+     * @param token - Numeric token
+     * @returns Promise with number
+     */
+    readNumber(token: IGetToken<number>): Promise<number>;
+    /**
+     * Ignore given number of bytes
+     * @param length - Number of bytes ignored
+     */
+    ignore(length: number): Promise<number>;
+    /**
+     * Clean up resources.
+     * It does not close the stream for StreamReader, but is does close the file-descriptor.
+     */
+    close(): Promise<void>;
+    /**
+     * Abort pending asynchronous operations
+     */
+    abort(): Promise<void>;
+    /**
+     * Returns true when the underlying file supports random access
+     */
+    supportsRandomAccess(): boolean;
+}
+export type OnClose = () => Promise<void>;
+export interface ITokenizerOptions {
+    /**
+     * Pass additional file information to the tokenizer
+     */
+    fileInfo?: IFileInfo;
+    /**
+     * On tokenizer close handler
+     */
+    onClose?: OnClose;
+    /**
+     * Pass `AbortSignal` which can stop active async operations
+     * Ref: https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
+     */
+    abortSignal?: AbortSignal;
+}

dist/node_modules/strtok3/lib/types.js

@@ -0,0 +1 @@
+export {};

dist/node_modules/strtok3/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "strtok3",
+  "version": "10.3.4",
+  "description": "A promise based streaming tokenizer",
+  "author": {
+    "name": "Borewit",
+    "url": "https://github.com/Borewit"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/Borewit"
+  },
+  "scripts": {
+    "clean": "del-cli 'lib/**/*.js' 'lib/**/*.js.map' 'lib/**/*.d.ts' 'test/**/*.js' 'test/**/*.js.map'",
+    "compile-src": "tsc -p lib  --sourceMap false",
+    "compile-test": "tsc -p test",
+    "compile": "yarn run compile-src && yarn run compile-test",
+    "build": "yarn run clean && yarn run compile",
+    "prepublishOnly": "yarn run build",
+    "eslint": "eslint lib test",
+    "lint:md": "remark -u preset-lint-recommended .",
+    "lint:ts": "biome check",
+    "lint": "yarn run lint:md && yarn run lint:ts",
+    "fix": "yarn run biome lint --write",
+    "test": "mocha",
+    "bun:test": "bun run --bun test",
+    "test-coverage": "c8 yarn run test",
+    "send-codacy": "c8 report --reporter=text-lcov | codacy-coverage",
+    "start": "yarn run compile && yarn run lint && yarn run cover-test",
+    "update-biome": "yarn add -D --exact @biomejs/biome && npx @biomejs/biome migrate --write"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Borewit/strtok3.git"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "node": "./lib/index.js",
+      "default": "./lib/core.js"
+    },
+    "./core": "./lib/core.js"
+  },
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib/**/*.js",
+    "lib/**/*.d.ts"
+  ],
+  "bugs": {
+    "url": "https://github.com/Borewit/strtok3/issues"
+  },
+  "dependencies": {
+    "@tokenizer/token": "^0.3.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.1.2",
+    "@types/chai": "^5.2.2",
+    "@types/chai-as-promised": "^8.0.2",
+    "@types/debug": "^4.1.12",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^24.1.0",
+    "c8": "^10.1.3",
+    "chai": "^5.2.1",
+    "chai-as-promised": "^8.0.1",
+    "del-cli": "^6.0.0",
+    "mocha": "^11.7.1",
+    "node-readable-to-web-readable-stream": "^0.4.2",
+    "remark-cli": "^12.0.1",
+    "remark-preset-lint-recommended": "^7.0.1",
+    "token-types": "^6.0.4",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3",
+    "uint8array-extras": "^1.4.0"
+  },
+  "keywords": [
+    "tokenizer",
+    "reader",
+    "token",
+    "async",
+    "promise",
+    "parser",
+    "decoder",
+    "binary",
+    "endian",
+    "uint",
+    "stream",
+    "streaming"
+  ],
+  "packageManager": "yarn@4.9.2"
+}

dist/node_modules/token-types/LICENSE.txt

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright © 2025 Borewit
+
+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.