@psnext/slingcli 2.4.20260520-3 → 2.4.20260520-5

package/node_modules/strtok3/lib/BufferTokenizer.d.ts

@@ -1,29 +0,0 @@
-import type { ITokenizerOptions, IReadChunkOptions, IRandomAccessFileInfo, IRandomAccessTokenizer } from './types.js';
-import { AbstractTokenizer } from './AbstractTokenizer.js';
-export declare class BufferTokenizer extends AbstractTokenizer implements IRandomAccessTokenizer {
-    private uint8Array;
-    fileInfo: IRandomAccessFileInfo;
-    /**
-     * Construct BufferTokenizer
-     * @param uint8Array - Uint8Array to tokenize
-     * @param options Tokenizer options
-     */
-    constructor(uint8Array: Uint8Array, options?: ITokenizerOptions);
-    /**
-     * Read buffer from tokenizer
-     * @param uint8Array - Uint8Array to tokenize
-     * @param options - Read behaviour options
-     * @returns {Promise<number>}
-     */
-    readBuffer(uint8Array: Uint8Array, options?: IReadChunkOptions): Promise<number>;
-    /**
-     * Peek (read ahead) buffer from tokenizer
-     * @param uint8Array
-     * @param options - Read behaviour options
-     * @returns {Promise<number>}
-     */
-    peekBuffer(uint8Array: Uint8Array, options?: IReadChunkOptions): Promise<number>;
-    close(): Promise<void>;
-    supportsRandomAccess(): boolean;
-    setPosition(position: number): void;
-}

package/node_modules/strtok3/lib/BufferTokenizer.js

@@ -1,52 +0,0 @@
-import { EndOfStreamError } from './stream/index.js';
-import { AbstractTokenizer } from './AbstractTokenizer.js';
-export class BufferTokenizer extends AbstractTokenizer {
-    /**
-     * Construct BufferTokenizer
-     * @param uint8Array - Uint8Array to tokenize
-     * @param options Tokenizer options
-     */
-    constructor(uint8Array, options) {
-        super(options);
-        this.uint8Array = uint8Array;
-        this.fileInfo = { ...options?.fileInfo ?? {}, ...{ size: uint8Array.length } };
-    }
-    /**
-     * Read buffer from tokenizer
-     * @param uint8Array - Uint8Array to tokenize
-     * @param options - Read behaviour options
-     * @returns {Promise<number>}
-     */
-    async readBuffer(uint8Array, options) {
-        if (options?.position) {
-            this.position = options.position;
-        }
-        const bytesRead = await this.peekBuffer(uint8Array, options);
-        this.position += bytesRead;
-        return bytesRead;
-    }
-    /**
-     * Peek (read ahead) buffer from tokenizer
-     * @param uint8Array
-     * @param options - Read behaviour options
-     * @returns {Promise<number>}
-     */
-    async peekBuffer(uint8Array, options) {
-        const normOptions = this.normalizeOptions(uint8Array, options);
-        const bytes2read = Math.min(this.uint8Array.length - normOptions.position, normOptions.length);
-        if ((!normOptions.mayBeLess) && bytes2read < normOptions.length) {
-            throw new EndOfStreamError();
-        }
-        uint8Array.set(this.uint8Array.subarray(normOptions.position, normOptions.position + bytes2read));
-        return bytes2read;
-    }
-    close() {
-        return super.close();
-    }
-    supportsRandomAccess() {
-        return true;
-    }
-    setPosition(position) {
-        this.position = position;
-    }
-}

package/node_modules/strtok3/lib/FileTokenizer.d.ts

@@ -1,37 +0,0 @@
-import { AbstractTokenizer } from './AbstractTokenizer.js';
-import type { IRandomAccessTokenizer, IRandomAccessFileInfo, IReadChunkOptions, ITokenizerOptions } from './types.js';
-import { type FileHandle } from 'node:fs/promises';
-interface IFileTokenizerOptions extends ITokenizerOptions {
-    /**
-     * Pass additional file information to the tokenizer
-     */
-    fileInfo: IRandomAccessFileInfo;
-}
-export declare class FileTokenizer extends AbstractTokenizer implements IRandomAccessTokenizer {
-    private fileHandle;
-    fileInfo: IRandomAccessFileInfo;
-    /**
-     * Create tokenizer from provided file path
-     * @param sourceFilePath File path
-     */
-    static fromFile(sourceFilePath: string): Promise<FileTokenizer>;
-    protected constructor(fileHandle: FileHandle, options: IFileTokenizerOptions);
-    /**
-     * Read buffer from file
-     * @param uint8Array - Uint8Array to write result to
-     * @param options - Read behaviour options
-     * @returns Promise number of bytes read
-     */
-    readBuffer(uint8Array: Uint8Array, options?: IReadChunkOptions): Promise<number>;
-    /**
-     * Peek buffer from file
-     * @param uint8Array - Uint8Array (or Buffer) to write data to
-     * @param options - Read behaviour options
-     * @returns Promise number of bytes read
-     */
-    peekBuffer(uint8Array: Uint8Array, options?: IReadChunkOptions): Promise<number>;
-    close(): Promise<void>;
-    setPosition(position: number): void;
-    supportsRandomAccess(): boolean;
-}
-export {};

package/node_modules/strtok3/lib/FileTokenizer.js

@@ -1,61 +0,0 @@
-import { AbstractTokenizer } from './AbstractTokenizer.js';
-import { EndOfStreamError } from './stream/index.js';
-import { open as fsOpen } from 'node:fs/promises';
-export class FileTokenizer extends AbstractTokenizer {
-    /**
-     * Create tokenizer from provided file path
-     * @param sourceFilePath File path
-     */
-    static async fromFile(sourceFilePath) {
-        const fileHandle = await fsOpen(sourceFilePath, 'r');
-        const stat = await fileHandle.stat();
-        return new FileTokenizer(fileHandle, { fileInfo: { path: sourceFilePath, size: stat.size } });
-    }
-    constructor(fileHandle, options) {
-        super(options);
-        this.fileHandle = fileHandle;
-        this.fileInfo = options.fileInfo;
-    }
-    /**
-     * Read buffer from file
-     * @param uint8Array - Uint8Array to write result to
-     * @param options - Read behaviour options
-     * @returns Promise number of bytes read
-     */
-    async readBuffer(uint8Array, options) {
-        const normOptions = this.normalizeOptions(uint8Array, options);
-        this.position = normOptions.position;
-        if (normOptions.length === 0)
-            return 0;
-        const res = await this.fileHandle.read(uint8Array, 0, normOptions.length, normOptions.position);
-        this.position += res.bytesRead;
-        if (res.bytesRead < normOptions.length && (!options || !options.mayBeLess)) {
-            throw new EndOfStreamError();
-        }
-        return res.bytesRead;
-    }
-    /**
-     * Peek buffer from file
-     * @param uint8Array - Uint8Array (or Buffer) to write data to
-     * @param options - Read behaviour options
-     * @returns Promise number of bytes read
-     */
-    async peekBuffer(uint8Array, options) {
-        const normOptions = this.normalizeOptions(uint8Array, options);
-        const res = await this.fileHandle.read(uint8Array, 0, normOptions.length, normOptions.position);
-        if ((!normOptions.mayBeLess) && res.bytesRead < normOptions.length) {
-            throw new EndOfStreamError();
-        }
-        return res.bytesRead;
-    }
-    async close() {
-        await this.fileHandle.close();
-        return super.close();
-    }
-    setPosition(position) {
-        this.position = position;
-    }
-    supportsRandomAccess() {
-        return true;
-    }
-}

package/node_modules/strtok3/lib/ReadStreamTokenizer.d.ts

@@ -1,34 +0,0 @@
-import { AbstractTokenizer } from './AbstractTokenizer.js';
-import { type IStreamReader } from './stream/index.js';
-import type { IFileInfo, IReadChunkOptions, ITokenizerOptions } from './types.js';
-export declare class ReadStreamTokenizer extends AbstractTokenizer {
-    private streamReader;
-    fileInfo: IFileInfo;
-    /**
-     * Constructor
-     * @param streamReader stream-reader to read from
-     * @param options Tokenizer options
-     */
-    constructor(streamReader: IStreamReader, options?: ITokenizerOptions);
-    /**
-     * Read buffer from tokenizer
-     * @param uint8Array - Target Uint8Array to fill with data read from the tokenizer-stream
-     * @param options - Read behaviour options
-     * @returns Promise with number of bytes read
-     */
-    readBuffer(uint8Array: Uint8Array, options?: IReadChunkOptions): Promise<number>;
-    /**
-     * Peek (read ahead) buffer from tokenizer
-     * @param uint8Array - Uint8Array (or Buffer) to write data to
-     * @param options - Read behaviour options
-     * @returns Promise with number of bytes peeked
-     */
-    peekBuffer(uint8Array: Uint8Array, options?: IReadChunkOptions): Promise<number>;
-    /**
-     * @param length Number of bytes to ignore. Must be ≥ 0.
-     */
-    ignore(length: number): Promise<number>;
-    abort(): Promise<void>;
-    close(): Promise<void>;
-    supportsRandomAccess(): boolean;
-}

package/node_modules/strtok3/lib/ReadStreamTokenizer.js

@@ -1,107 +0,0 @@
-import { AbstractTokenizer } from './AbstractTokenizer.js';
-import { EndOfStreamError } from './stream/index.js';
-const maxBufferSize = 256000;
-export class ReadStreamTokenizer extends AbstractTokenizer {
-    /**
-     * Constructor
-     * @param streamReader stream-reader to read from
-     * @param options Tokenizer options
-     */
-    constructor(streamReader, options) {
-        super(options);
-        this.streamReader = streamReader;
-        this.fileInfo = options?.fileInfo ?? {};
-    }
-    /**
-     * Read buffer from tokenizer
-     * @param uint8Array - Target Uint8Array to fill with data read from the tokenizer-stream
-     * @param options - Read behaviour options
-     * @returns Promise with number of bytes read
-     */
-    async readBuffer(uint8Array, options) {
-        const normOptions = this.normalizeOptions(uint8Array, options);
-        const skipBytes = normOptions.position - this.position;
-        if (skipBytes > 0) {
-            await this.ignore(skipBytes);
-            return this.readBuffer(uint8Array, options);
-        }
-        if (skipBytes < 0) {
-            throw new Error('`options.position` must be equal or greater than `tokenizer.position`');
-        }
-        if (normOptions.length === 0) {
-            return 0;
-        }
-        const bytesRead = await this.streamReader.read(uint8Array.subarray(0, normOptions.length), normOptions.mayBeLess);
-        this.position += bytesRead;
-        if ((!options || !options.mayBeLess) && bytesRead < normOptions.length) {
-            throw new EndOfStreamError();
-        }
-        return bytesRead;
-    }
-    /**
-     * Peek (read ahead) buffer from tokenizer
-     * @param uint8Array - Uint8Array (or Buffer) to write data to
-     * @param options - Read behaviour options
-     * @returns Promise with number of bytes peeked
-     */
-    async peekBuffer(uint8Array, options) {
-        const normOptions = this.normalizeOptions(uint8Array, options);
-        let bytesRead = 0;
-        if (normOptions.position) {
-            const skipBytes = normOptions.position - this.position;
-            if (skipBytes > 0) {
-                const skipBuffer = new Uint8Array(normOptions.length + skipBytes);
-                bytesRead = await this.peekBuffer(skipBuffer, { mayBeLess: normOptions.mayBeLess });
-                uint8Array.set(skipBuffer.subarray(skipBytes));
-                return bytesRead - skipBytes;
-            }
-            if (skipBytes < 0) {
-                throw new Error('Cannot peek from a negative offset in a stream');
-            }
-        }
-        if (normOptions.length > 0) {
-            try {
-                bytesRead = await this.streamReader.peek(uint8Array.subarray(0, normOptions.length), normOptions.mayBeLess);
-            }
-            catch (err) {
-                if (options?.mayBeLess && err instanceof EndOfStreamError) {
-                    return 0;
-                }
-                throw err;
-            }
-            if ((!normOptions.mayBeLess) && bytesRead < normOptions.length) {
-                throw new EndOfStreamError();
-            }
-        }
-        return bytesRead;
-    }
-    /**
-     * @param length Number of bytes to ignore. Must be ≥ 0.
-     */
-    async ignore(length) {
-        if (length < 0) {
-            throw new RangeError('ignore length must be ≥ 0 bytes');
-        }
-        const bufSize = Math.min(maxBufferSize, length);
-        const buf = new Uint8Array(bufSize);
-        let totBytesRead = 0;
-        while (totBytesRead < length) {
-            const remaining = length - totBytesRead;
-            const bytesRead = await this.readBuffer(buf, { length: Math.min(bufSize, remaining) });
-            if (bytesRead < 0) {
-                return bytesRead;
-            }
-            totBytesRead += bytesRead;
-        }
-        return totBytesRead;
-    }
-    abort() {
-        return this.streamReader.abort();
-    }
-    async close() {
-        return this.streamReader.close();
-    }
-    supportsRandomAccess() {
-        return false;
-    }
-}

package/node_modules/strtok3/lib/core.d.ts

@@ -1,40 +0,0 @@
-import type { Readable } from 'node:stream';
-import { type AnyWebByteStream } from './stream/index.js';
-import { ReadStreamTokenizer } from './ReadStreamTokenizer.js';
-import { BufferTokenizer } from './BufferTokenizer.js';
-import type { ITokenizerOptions } from './types.js';
-import { BlobTokenizer } from './BlobTokenizer.js';
-export { EndOfStreamError, AbortError, type AnyWebByteStream } from './stream/index.js';
-export type { ITokenizer, IRandomAccessTokenizer, IFileInfo, IRandomAccessFileInfo, ITokenizerOptions, IReadChunkOptions, OnClose } from './types.js';
-export type { IToken, IGetToken } from '@tokenizer/token';
-export { AbstractTokenizer } from './AbstractTokenizer.js';
-/**
- * Construct ReadStreamTokenizer from given Stream.
- * Will set fileSize, if provided given Stream has set the .path property/
- * @param stream - Read from Node.js Stream.Readable
- * @param options - Tokenizer options
- * @returns ReadStreamTokenizer
- */
-export declare function fromStream(stream: Readable, options?: ITokenizerOptions): ReadStreamTokenizer;
-/**
- * Construct ReadStreamTokenizer from given ReadableStream (WebStream API).
- * Will set fileSize, if provided given Stream has set the .path property/
- * @param webStream - Read from Node.js Stream.Readable (must be a byte stream)
- * @param options - Tokenizer options
- * @returns ReadStreamTokenizer
- */
-export declare function fromWebStream(webStream: AnyWebByteStream, options?: ITokenizerOptions): ReadStreamTokenizer;
-/**
- * Construct ReadStreamTokenizer from given Buffer.
- * @param uint8Array - Uint8Array to tokenize
- * @param options - Tokenizer options
- * @returns BufferTokenizer
- */
-export declare function fromBuffer(uint8Array: Uint8Array, options?: ITokenizerOptions): BufferTokenizer;
-/**
- * Construct ReadStreamTokenizer from given Blob.
- * @param blob - Uint8Array to tokenize
- * @param options - Tokenizer options
- * @returns BufferTokenizer
- */
-export declare function fromBlob(blob: Blob, options?: ITokenizerOptions): BlobTokenizer;

package/node_modules/strtok3/lib/core.js

@@ -1,62 +0,0 @@
-import { StreamReader, makeWebStreamReader } from './stream/index.js';
-import { ReadStreamTokenizer } from './ReadStreamTokenizer.js';
-import { BufferTokenizer } from './BufferTokenizer.js';
-import { BlobTokenizer } from './BlobTokenizer.js';
-export { EndOfStreamError, AbortError } from './stream/index.js';
-export { AbstractTokenizer } from './AbstractTokenizer.js';
-/**
- * Construct ReadStreamTokenizer from given Stream.
- * Will set fileSize, if provided given Stream has set the .path property/
- * @param stream - Read from Node.js Stream.Readable
- * @param options - Tokenizer options
- * @returns ReadStreamTokenizer
- */
-export function fromStream(stream, options) {
-    const streamReader = new StreamReader(stream);
-    const _options = options ?? {};
-    const chainedClose = _options.onClose;
-    _options.onClose = async () => {
-        await streamReader.close();
-        if (chainedClose) {
-            return chainedClose();
-        }
-    };
-    return new ReadStreamTokenizer(streamReader, _options);
-}
-/**
- * Construct ReadStreamTokenizer from given ReadableStream (WebStream API).
- * Will set fileSize, if provided given Stream has set the .path property/
- * @param webStream - Read from Node.js Stream.Readable (must be a byte stream)
- * @param options - Tokenizer options
- * @returns ReadStreamTokenizer
- */
-export function fromWebStream(webStream, options) {
-    const webStreamReader = makeWebStreamReader(webStream);
-    const _options = options ?? {};
-    const chainedClose = _options.onClose;
-    _options.onClose = async () => {
-        await webStreamReader.close();
-        if (chainedClose) {
-            return chainedClose();
-        }
-    };
-    return new ReadStreamTokenizer(webStreamReader, _options);
-}
-/**
- * Construct ReadStreamTokenizer from given Buffer.
- * @param uint8Array - Uint8Array to tokenize
- * @param options - Tokenizer options
- * @returns BufferTokenizer
- */
-export function fromBuffer(uint8Array, options) {
-    return new BufferTokenizer(uint8Array, options);
-}
-/**
- * Construct ReadStreamTokenizer from given Blob.
- * @param blob - Uint8Array to tokenize
- * @param options - Tokenizer options
- * @returns BufferTokenizer
- */
-export function fromBlob(blob, options) {
-    return new BlobTokenizer(blob, options);
-}

package/node_modules/strtok3/lib/index.d.ts

@@ -1,16 +0,0 @@
-import type { Readable } from 'node:stream';
-import type { ReadStreamTokenizer } from './ReadStreamTokenizer.js';
-import { type ITokenizerOptions } from './core.js';
-import { FileTokenizer } from "./FileTokenizer.js";
-export { FileTokenizer } from './FileTokenizer.js';
-export * from './core.js';
-export type { IToken, IGetToken } from '@tokenizer/token';
-/**
- * Construct ReadStreamTokenizer from given Stream.
- * Will set fileSize, if provided given Stream has set the .path property.
- * @param stream - Node.js Stream.Readable
- * @param options - Pass additional file information to the tokenizer
- * @returns Tokenizer
- */
-export declare function fromStream(stream: Readable, options?: ITokenizerOptions): Promise<ReadStreamTokenizer>;
-export declare const fromFile: typeof FileTokenizer.fromFile;

package/node_modules/strtok3/lib/index.js

@@ -1,22 +0,0 @@
-import { stat as fsStat } from 'node:fs/promises';
-import { fromStream as coreFromStream } from './core.js';
-import { FileTokenizer } from "./FileTokenizer.js";
-export { FileTokenizer } from './FileTokenizer.js';
-export * from './core.js';
-/**
- * Construct ReadStreamTokenizer from given Stream.
- * Will set fileSize, if provided given Stream has set the .path property.
- * @param stream - Node.js Stream.Readable
- * @param options - Pass additional file information to the tokenizer
- * @returns Tokenizer
- */
-export async function fromStream(stream, options) {
-    const rst = coreFromStream(stream, options);
-    if (stream.path) {
-        const stat = await fsStat(stream.path);
-        rst.fileInfo.path = stream.path;
-        rst.fileInfo.size = stat.size;
-    }
-    return rst;
-}
-export const fromFile = FileTokenizer.fromFile;

package/node_modules/strtok3/lib/stream/AbstractStreamReader.d.ts

@@ -1,54 +0,0 @@
-export interface IStreamReader {
-    /**
-     * Peak ahead (peek) from stream. Subsequent read or peeks will return the same data.
-     * @param uint8Array - Uint8Array (or Buffer) to store data read from stream in
-     * @param mayBeLess - Allow the read to complete, without the buffer being fully filled (length may be smaller)
-     * @returns Number of bytes peeked. If `maybeLess` is set, this shall be the `uint8Array.length`.
-     */
-    peek(uint8Array: Uint8Array, mayBeLess?: boolean): Promise<number>;
-    /**
-     * Read from stream the stream.
-     * @param uint8Array - Uint8Array (or Buffer) to store data read from stream in
-     * @param mayBeLess - Allow the read to complete, without the buffer being fully filled (length may be smaller)
-     * @returns Number of actually bytes read. If `maybeLess` is set, this shall be the `uint8Array.length`.
-     */
-    read(uint8Array: Uint8Array, mayBeLess?: boolean): Promise<number>;
-    close(): Promise<void>;
-    /**
-     * Abort any active asynchronous operation are active, abort those before they may have completed.
-     */
-    abort(): Promise<void>;
-}
-export declare abstract class AbstractStreamReader implements IStreamReader {
-    protected endOfStream: boolean;
-    protected interrupted: boolean;
-    /**
-     * Store peeked data
-     * @type {Array}
-     */
-    protected peekQueue: Uint8Array[];
-    peek(uint8Array: Uint8Array, mayBeLess?: boolean): Promise<number>;
-    read(buffer: Uint8Array, mayBeLess?: boolean): Promise<number>;
-    /**
-     * Read chunk from stream
-     * @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
-     * @returns Number of bytes read
-     */
-    protected readFromPeekBuffer(buffer: Uint8Array): number;
-    readRemainderFromStream(buffer: Uint8Array, mayBeLess: boolean): Promise<number>;
-    /**
-     * 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 synchronous operations
-     */
-    abstract close(): Promise<void>;
-    /**
-     * Abort any active asynchronous operation are active, abort those before they may have completed.
-     */
-    abstract abort(): Promise<void>;
-}

package/node_modules/strtok3/lib/stream/AbstractStreamReader.js

@@ -1,71 +0,0 @@
-import { EndOfStreamError, AbortError } from "./Errors.js";
-export class AbstractStreamReader {
-    constructor() {
-        this.endOfStream = false;
-        this.interrupted = false;
-        /**
-         * Store peeked data
-         * @type {Array}
-         */
-        this.peekQueue = [];
-    }
-    async peek(uint8Array, mayBeLess = false) {
-        const bytesRead = await this.read(uint8Array, mayBeLess);
-        this.peekQueue.push(uint8Array.subarray(0, bytesRead)); // Put read data back to peek buffer
-        return bytesRead;
-    }
-    async read(buffer, mayBeLess = false) {
-        if (buffer.length === 0) {
-            return 0;
-        }
-        let bytesRead = this.readFromPeekBuffer(buffer);
-        if (!this.endOfStream) {
-            bytesRead += await this.readRemainderFromStream(buffer.subarray(bytesRead), mayBeLess);
-        }
-        if (bytesRead === 0 && !mayBeLess) {
-            throw new EndOfStreamError();
-        }
-        return bytesRead;
-    }
-    /**
-     * Read chunk from stream
-     * @param buffer - Target Uint8Array (or Buffer) to store data read from stream in
-     * @returns Number of bytes read
-     */
-    readFromPeekBuffer(buffer) {
-        let remaining = buffer.length;
-        let bytesRead = 0;
-        // consume peeked data first
-        while (this.peekQueue.length > 0 && remaining > 0) {
-            const peekData = this.peekQueue.pop(); // Front of queue
-            if (!peekData)
-                throw new Error('peekData should be defined');
-            const lenCopy = Math.min(peekData.length, remaining);
-            buffer.set(peekData.subarray(0, lenCopy), bytesRead);
-            bytesRead += lenCopy;
-            remaining -= lenCopy;
-            if (lenCopy < peekData.length) {
-                // remainder back to queue
-                this.peekQueue.push(peekData.subarray(lenCopy));
-            }
-        }
-        return bytesRead;
-    }
-    async readRemainderFromStream(buffer, mayBeLess) {
-        let bytesRead = 0;
-        // Continue reading from stream if required
-        while (bytesRead < buffer.length && !this.endOfStream) {
-            if (this.interrupted) {
-                throw new AbortError();
-            }
-            const chunkLen = await this.readFromStream(buffer.subarray(bytesRead), mayBeLess);
-            if (chunkLen === 0)
-                break;
-            bytesRead += chunkLen;
-        }
-        if (!mayBeLess && bytesRead < buffer.length) {
-            throw new EndOfStreamError();
-        }
-        return bytesRead;
-    }
-}

package/node_modules/strtok3/lib/stream/Deferred.d.ts

@@ -1,6 +0,0 @@
-export declare class Deferred<T> {
-    promise: Promise<T>;
-    resolve: (value: T) => void;
-    reject: (reason: Error) => void;
-    constructor();
-}

package/node_modules/strtok3/lib/stream/Deferred.js

@@ -1,10 +0,0 @@
-export class Deferred {
-    constructor() {
-        this.resolve = () => null;
-        this.reject = () => null;
-        this.promise = new Promise((resolve, reject) => {
-            this.reject = reject;
-            this.resolve = resolve;
-        });
-    }
-}

package/node_modules/strtok3/lib/stream/Errors.d.ts

@@ -1,10 +0,0 @@
-export declare const defaultMessages = "End-Of-Stream";
-/**
- * Thrown on read operation of the end of file or stream has been reached
- */
-export declare class EndOfStreamError extends Error {
-    constructor();
-}
-export declare class AbortError extends Error {
-    constructor(message?: string);
-}

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

@@ -1,16 +0,0 @@
-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";
-    }
-}

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

@@ -1,29 +0,0 @@
-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>;
-}