@cj-tech-master/excelts 5.1.18 → 6.0.0-beta.1

package/dist/browser/modules/stream/pull-stream.js

@@ -4,7 +4,8 @@
  * A stream that allows pulling data from internal buffer with pattern matching.
  * Works identically in both browser and Node.js environments.
  */
-import { EventEmitter } from "./event-emitter.js";
+import { EventEmitter } from "../../utils/event-emitter.js";
+import { uint8ArrayIndexOf } from "../../utils/binary.js";
 const EMPTY_U8 = new Uint8Array(0);
 /**
  * Browser-compatible Pull Stream - Read data from buffer on demand with pattern matching
@@ -22,6 +23,12 @@ export class PullStream extends EventEmitter {
         this.finished = false;
         this._destroyed = false;
     }
+    /** Reset the internal buffer to empty. */
+    _resetBuffer() {
+        this._buffer = EMPTY_U8;
+        this._bufferReadIndex = 0;
+        this._bufferWriteIndex = 0;
+    }
     // Maintain legacy protected accessor for subclasses.
     // Returned value is a view of the readable region.
     get buffer() {
@@ -32,9 +39,7 @@ export class PullStream extends EventEmitter {
     }
     set buffer(buf) {
         if (buf.length === 0) {
-            this._buffer = EMPTY_U8;
-            this._bufferReadIndex = 0;
-            this._bufferWriteIndex = 0;
+            this._resetBuffer();
             return;
         }
         this._buffer = buf;
@@ -88,6 +93,9 @@ export class PullStream extends EventEmitter {
      * Signal end of input
      */
     end(chunk) {
+        if (this._destroyed || this.finished) {
+            return;
+        }
         if (chunk !== undefined) {
             this.write(chunk);
         }
@@ -104,13 +112,17 @@ export class PullStream extends EventEmitter {
             return;
         }
         this._destroyed = true;
-        this._buffer = EMPTY_U8;
-        this._bufferReadIndex = 0;
-        this._bufferWriteIndex = 0;
-        if (error) {
-            this.emit("error", error);
-        }
-        this.emit("close");
+        this._resetBuffer();
+        // Wake up any pending pull() promises so they can see _destroyed and reject.
+        // This MUST be synchronous — pending pull() promises depend on immediate wakeup.
+        this.emit("chunk");
+        // Defer error/close emission via queueMicrotask to match Node.js process.nextTick behavior
+        queueMicrotask(() => {
+            if (error) {
+                this.emit("error", error);
+            }
+            this.emit("close");
+        });
     }
     pull(sizeOrPattern, includePattern) {
         if (typeof sizeOrPattern === "number") {
@@ -142,9 +154,7 @@ export class PullStream extends EventEmitter {
                     const result = this._buffer.subarray(start, end);
                     this._bufferReadIndex = end;
                     if (this._bufferReadIndex === this._bufferWriteIndex) {
-                        this._buffer = EMPTY_U8;
-                        this._bufferReadIndex = 0;
-                        this._bufferWriteIndex = 0;
+                        this._resetBuffer();
                     }
                     resolve(result);
                     return;
@@ -154,9 +164,7 @@ export class PullStream extends EventEmitter {
                     const result = this._bufferReadIndex === this._bufferWriteIndex
                         ? EMPTY_U8
                         : this._buffer.subarray(this._bufferReadIndex, this._bufferWriteIndex);
-                    this._buffer = EMPTY_U8;
-                    this._bufferReadIndex = 0;
-                    this._bufferWriteIndex = 0;
+                    this._resetBuffer();
                     resolve(result);
                     return;
                 }
@@ -168,41 +176,44 @@ export class PullStream extends EventEmitter {
     }
     _pullPattern(pattern, includePattern) {
         return new Promise((resolve, reject) => {
+            const patternLen = pattern.length;
+            // Track where the next scan should start to avoid re-scanning bytes
+            // that were already checked.  A match can straddle old and new data, so
+            // we back up by (patternLen - 1) when resuming.
+            let scanFrom = this._bufferReadIndex;
             const tryPull = () => {
                 if (this._destroyed) {
                     reject(new Error("Stream destroyed"));
                     return;
                 }
                 // Match empty pattern without consuming anything.
-                if (pattern.length === 0) {
+                if (patternLen === 0) {
                     this._match = 0;
                     resolve(this._buffer.subarray(this._bufferReadIndex, this._bufferReadIndex));
                     return;
                 }
-                const matchIndexAbs = this._indexOf(this._buffer, this._bufferReadIndex, this._bufferWriteIndex, pattern);
+                const matchIndexAbs = uint8ArrayIndexOf(this._buffer, pattern, scanFrom, this._bufferWriteIndex);
                 if (matchIndexAbs !== -1) {
                     this._match = matchIndexAbs - this._bufferReadIndex;
-                    const patternLen = pattern.length;
                     const resultEndAbs = includePattern ? matchIndexAbs + patternLen : matchIndexAbs;
                     const consumeTo = matchIndexAbs + patternLen;
                     const result = this._buffer.subarray(this._bufferReadIndex, resultEndAbs);
                     this._bufferReadIndex = consumeTo;
                     if (this._bufferReadIndex === this._bufferWriteIndex) {
-                        this._buffer = EMPTY_U8;
-                        this._bufferReadIndex = 0;
-                        this._bufferWriteIndex = 0;
+                        this._resetBuffer();
                     }
                     resolve(result);
                     return;
                 }
+                // No match yet — advance scanFrom so the next retry only scans new
+                // bytes (minus overlap for cross-boundary matches).
+                scanFrom = Math.max(this._bufferReadIndex, this._bufferWriteIndex - (patternLen - 1));
                 if (this.finished) {
                     // Pattern not found, return everything
                     const result = this._bufferReadIndex === this._bufferWriteIndex
                         ? EMPTY_U8
                         : this._buffer.subarray(this._bufferReadIndex, this._bufferWriteIndex);
-                    this._buffer = EMPTY_U8;
-                    this._bufferReadIndex = 0;
-                    this._bufferWriteIndex = 0;
+                    this._resetBuffer();
                     resolve(result);
                     return;
                 }
@@ -236,33 +247,4 @@ export class PullStream extends EventEmitter {
     get destroyed() {
         return this._destroyed;
     }
-    /**
-     * Find pattern in Uint8Array (like Buffer.indexOf)
-     */
-    _indexOf(haystack, start, end, needle) {
-        const needleLen = needle.length;
-        if (needleLen === 0) {
-            return start;
-        }
-        const haystackLen = end;
-        if (needleLen > haystackLen - start) {
-            return -1;
-        }
-        const first = needle[0];
-        const last = haystackLen - needleLen;
-        outer: for (let i = start; i <= last; i++) {
-            // Quick check first byte
-            if (haystack[i] !== first) {
-                continue;
-            }
-            // Check rest of pattern
-            for (let j = 1; j < needleLen; j++) {
-                if (haystack[i + j] !== needle[j]) {
-                    continue outer;
-                }
-            }
-            return i;
-        }
-        return -1;
-    }
 }

package/dist/browser/modules/stream/types.d.ts

@@ -5,32 +5,20 @@
  * These types provide a unified interface regardless of the underlying implementation.
  */
 /**
- * Options for creating readable streams
+ * Common options for creating streams (readable, writable, or transform)
  */
-export interface ReadableStreamOptions {
-    /** High water mark for backpressure (bytes) */
-    highWaterMark?: number;
-    /** Enable object mode (non-binary data) */
-    objectMode?: boolean;
-}
-/**
- * Options for creating writable streams
- */
-export interface WritableStreamOptions {
-    /** High water mark for backpressure (bytes) */
-    highWaterMark?: number;
-    /** Enable object mode (non-binary data) */
-    objectMode?: boolean;
-}
-/**
- * Options for creating transform streams
- */
-export interface TransformStreamOptions {
+export interface StreamOptions {
     /** High water mark for backpressure (bytes) */
     highWaterMark?: number;
     /** Enable object mode (non-binary data) */
     objectMode?: boolean;
 }
+/** Options for creating readable streams */
+export type ReadableStreamOptions = StreamOptions;
+/** Options for creating writable streams */
+export type WritableStreamOptions = StreamOptions;
+/** Options for creating transform streams */
+export type TransformStreamOptions = StreamOptions;
 /**
  * Options for creating duplex streams
  */
@@ -50,14 +38,18 @@ export interface DuplexStreamOptions {
     /** Enable object mode for write side */
     writableObjectMode?: boolean;
 }
+/**
+ * Callback for stream transform/flush operations
+ */
+export type StreamCallback<T = Uint8Array> = (error?: Error | null, data?: T) => void;
 /**
  * Callback for transform operations
  */
-export type TransformCallback<T = Uint8Array> = (error?: Error | null, data?: T) => void;
+export type TransformCallback<T = Uint8Array> = StreamCallback<T>;
 /**
  * Callback for flush operations
  */
-export type FlushCallback<T = Uint8Array> = (error?: Error | null, data?: T) => void;
+export type FlushCallback<T = Uint8Array> = StreamCallback<T>;
 /**
  * Callback for write operations
  */
@@ -70,6 +62,15 @@ export type DestroyCallback = (error?: Error | null) => void;
  * Event listener type
  */
 export type EventListener = (...args: any[]) => void;
+/**
+ * Minimal duck-typed emitter shape for utilities that accept any emitter-like object.
+ */
+export type EventEmitterLike = {
+    on?: (event: string, listener: (...args: any[]) => void) => any;
+    once?: (event: string, listener: (...args: any[]) => void) => any;
+    off?: (event: string, listener: (...args: any[]) => void) => any;
+    removeListener?: (event: string, listener: (...args: any[]) => void) => any;
+};
 /**
  * Common event emitter interface
  */
@@ -146,7 +147,7 @@ export interface IWritable<T = any> extends WritableLike {
  */
 export interface ITransform<TInput = any, TOutput = any> extends IReadable<TOutput>, IWritable<TInput> {
     _transform(chunk: TInput, encoding: string, callback: TransformCallback<TOutput>): void;
-    _flush(callback: FlushCallback<TOutput>): void;
+    _flush?(callback: FlushCallback<TOutput>): void;
 }
 /**
  * Common duplex stream interface
@@ -154,14 +155,9 @@ export interface ITransform<TInput = any, TOutput = any> extends IReadable<TOutp
 export interface IDuplex<TRead = any, TWrite = any> extends IReadable<TRead>, IWritable<TWrite> {
 }
 /**
- * Options for pull stream
+ * Options for pull stream (reserved for future use)
  */
-export interface PullStreamOptions {
-    /** Enable object mode */
-    objectMode?: boolean;
-    /** High water mark for internal buffer */
-    highWaterMark?: number;
-}
+export type PullStreamOptions = object;
 /**
  * Pull stream interface - allows pulling data on demand
  */
@@ -229,10 +225,3 @@ export interface DataChunk {
     copy(target: Uint8Array, targetOffset: number, offset: number, length: number): number;
     toUint8Array(): Uint8Array;
 }
-/**
- * Read-write buffer options
- */
-export interface ReadWriteBufferOptions {
-    /** Initial buffer size */
-    size?: number;
-}

package/dist/browser/modules/stream/utils.base.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Stream Utilities (shared base)
+ *
+ * Platform-independent helpers re-exported by both `utils.ts` (Node) and
+ * `utils.browser.ts`.  The two platform files supply the concrete
+ * `createReadableFromArray`, `createTransform` and `consumers` bindings.
+ */
+import type { IReadable, ITransform } from "./types.js";
+export interface UtilsDeps {
+    createReadableFromArray: <T>(data: T[], options?: {
+        objectMode?: boolean;
+    }) => IReadable<T>;
+    createTransform: <TIn, TOut>(fn: (chunk: TIn) => TOut | undefined | Promise<TOut | undefined>, options?: {
+        objectMode?: boolean;
+    }) => ITransform<TIn, TOut>;
+    consumers: {
+        text: (stream: AsyncIterable<Uint8Array>) => Promise<string>;
+        json: (stream: AsyncIterable<Uint8Array>) => Promise<unknown>;
+        buffer: (stream: AsyncIterable<Uint8Array>) => Promise<Uint8Array>;
+    };
+}
+export declare function collect<T>(stream: {
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}): Promise<T[]>;
+export declare function createText(deps: UtilsDeps): (stream: {
+    [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
+}) => Promise<string>;
+export declare function createJson(deps: UtilsDeps): <T = unknown>(stream: {
+    [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
+}) => Promise<T>;
+export declare function createBytes(deps: UtilsDeps): (stream: {
+    [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
+}) => Promise<Uint8Array>;
+export declare function createFromString(deps: UtilsDeps): (str: string) => IReadable<Uint8Array>;
+export declare function createFromJSON(deps: UtilsDeps): (data: unknown) => IReadable<Uint8Array>;
+export declare function createFromBytes(deps: UtilsDeps): (data: Uint8Array) => IReadable<Uint8Array>;
+export declare function createTransformHelper(deps: UtilsDeps): <TIn = Uint8Array, TOut = TIn>(fn: (chunk: TIn) => TOut | Promise<TOut>) => ITransform<TIn, TOut>;
+export declare function createFilter(deps: UtilsDeps): <T>(predicate: (chunk: T) => boolean | Promise<boolean>) => ITransform<T, T>;
+/**
+ * Type guard for browser ReadableStream-like objects.
+ * Re-exported from internal/type-guards for public API compatibility.
+ */
+export declare const isReadableStreamLike: (value: unknown) => value is {
+    getReader: () => any;
+};
+/**
+ * Convert a browser ReadableStream to an AsyncIterable.
+ * This is useful for consuming fetch response bodies in a streaming fashion.
+ *
+ * @example
+ * ```ts
+ * const response = await fetch(url);
+ * for await (const chunk of readableStreamToAsyncIterable(response.body)) {
+ *   // process chunk
+ * }
+ * ```
+ */
+export declare function readableStreamToAsyncIterable<T = Uint8Array>(stream: {
+    getReader: () => any;
+}): AsyncGenerator<T, void, unknown>;

package/dist/browser/modules/stream/utils.base.js

@@ -0,0 +1,123 @@
+/**
+ * Stream Utilities (shared base)
+ *
+ * Platform-independent helpers re-exported by both `utils.ts` (Node) and
+ * `utils.browser.ts`.  The two platform files supply the concrete
+ * `createReadableFromArray`, `createTransform` and `consumers` bindings.
+ */
+import { stringToUint8Array as _stringToUint8Array } from "../../utils/binary.js";
+import { isReadableStream } from "./internal/type-guards.js";
+// =============================================================================
+// High-Level Stream Consumers
+// =============================================================================
+export async function collect(stream) {
+    const result = [];
+    for await (const chunk of stream) {
+        result.push(chunk);
+    }
+    return result;
+}
+export function createText(deps) {
+    return async function text(stream) {
+        return deps.consumers.text(stream);
+    };
+}
+export function createJson(deps) {
+    return async function json(stream) {
+        return deps.consumers.json(stream);
+    };
+}
+export function createBytes(deps) {
+    return async function bytes(stream) {
+        return deps.consumers.buffer(stream);
+    };
+}
+// =============================================================================
+// Stream Factory Helpers
+// =============================================================================
+export function createFromString(deps) {
+    return function fromString(str) {
+        return deps.createReadableFromArray([_stringToUint8Array(str)], {
+            objectMode: false
+        });
+    };
+}
+export function createFromJSON(deps) {
+    const fromString = createFromString(deps);
+    return function fromJSON(data) {
+        return fromString(JSON.stringify(data));
+    };
+}
+export function createFromBytes(deps) {
+    return function fromBytes(data) {
+        return deps.createReadableFromArray([data], { objectMode: false });
+    };
+}
+export function createTransformHelper(deps) {
+    return function transform(fn) {
+        return deps.createTransform(fn);
+    };
+}
+export function createFilter(deps) {
+    return function filter(predicate) {
+        return deps.createTransform(async (chunk) => {
+            if (await predicate(chunk)) {
+                return chunk;
+            }
+            return undefined;
+        }, { objectMode: true });
+    };
+}
+// =============================================================================
+// ReadableStream Conversion
+// =============================================================================
+/**
+ * Type guard for browser ReadableStream-like objects.
+ * Re-exported from internal/type-guards for public API compatibility.
+ */
+export const isReadableStreamLike = isReadableStream;
+/**
+ * Convert a browser ReadableStream to an AsyncIterable.
+ * This is useful for consuming fetch response bodies in a streaming fashion.
+ *
+ * @example
+ * ```ts
+ * const response = await fetch(url);
+ * for await (const chunk of readableStreamToAsyncIterable(response.body)) {
+ *   // process chunk
+ * }
+ * ```
+ */
+export async function* readableStreamToAsyncIterable(stream) {
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const result = await reader.read();
+            if (result.done) {
+                return;
+            }
+            // Only yield defined, non-null values — avoids silently dropping
+            // falsy-but-valid values like 0 or "".
+            if (result.value !== undefined && result.value !== null) {
+                yield result.value;
+            }
+        }
+    }
+    finally {
+        // Cancel the reader before releasing the lock so the underlying stream
+        // can free resources (e.g. a fetch body).  Without cancel(), the stream
+        // stays in a "disturbed but not cancelled" state per the WHATWG spec.
+        try {
+            await reader.cancel?.();
+        }
+        catch {
+            // ignore
+        }
+        try {
+            reader.releaseLock?.();
+        }
+        catch {
+            // ignore
+        }
+    }
+}

package/dist/browser/modules/stream/utils.browser.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Stream Utilities (browser)
+ *
+ * Browser counterpart of `utils.ts`, selected automatically
+ * by the `preferBrowserFilesPlugin()` mechanism.
+ *
+ * All factory-produced helpers are lazily initialized on first call to avoid
+ * eagerly pulling in heavy stream class dependencies at import time.
+ */
+import { collect, isReadableStreamLike, readableStreamToAsyncIterable } from "./utils.base.js";
+export { collect, isReadableStreamLike, readableStreamToAsyncIterable };
+type AsyncIterableStream = {
+    [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
+};
+export declare function text(stream: AsyncIterableStream): Promise<string>;
+export declare function json<T = unknown>(stream: AsyncIterableStream): Promise<T>;
+export declare function bytes(stream: AsyncIterableStream): Promise<Uint8Array>;
+export declare function fromString(str: string): import("./types.js").IReadable<Uint8Array<ArrayBufferLike>>;
+export declare function fromJSON(data: unknown): import("./types.js").IReadable<Uint8Array<ArrayBufferLike>>;
+export declare function fromBytes(data: Uint8Array): import("./types.js").IReadable<Uint8Array<ArrayBufferLike>>;
+export declare function transform<TIn = Uint8Array, TOut = TIn>(fn: (chunk: TIn) => TOut | Promise<TOut>): import("./types.js").ITransform<TIn, TOut>;
+export declare function filter<T>(predicate: (chunk: T) => boolean | Promise<boolean>): import("./types.js").ITransform<T, T>;

package/dist/browser/modules/stream/utils.browser.js

@@ -0,0 +1,80 @@
+/**
+ * Stream Utilities (browser)
+ *
+ * Browser counterpart of `utils.ts`, selected automatically
+ * by the `preferBrowserFilesPlugin()` mechanism.
+ *
+ * All factory-produced helpers are lazily initialized on first call to avoid
+ * eagerly pulling in heavy stream class dependencies at import time.
+ */
+import { createReadableFromArray, createTransform } from "./browser/factories.js";
+import { consumers } from "./browser/utils.js";
+import { collect, createText, createJson, createBytes, createFromString, createFromJSON, createFromBytes, createTransformHelper, createFilter, isReadableStreamLike, readableStreamToAsyncIterable } from "./utils.base.js";
+let _deps = null;
+function getDeps() {
+    if (!_deps) {
+        _deps = {
+            createReadableFromArray,
+            createTransform: createTransform,
+            consumers
+        };
+    }
+    return _deps;
+}
+export { collect, isReadableStreamLike, readableStreamToAsyncIterable };
+let _text;
+export function text(stream) {
+    if (!_text) {
+        _text = createText(getDeps());
+    }
+    return _text(stream);
+}
+let _json;
+export function json(stream) {
+    if (!_json) {
+        _json = createJson(getDeps());
+    }
+    return _json(stream);
+}
+let _bytes;
+export function bytes(stream) {
+    if (!_bytes) {
+        _bytes = createBytes(getDeps());
+    }
+    return _bytes(stream);
+}
+let _fromString;
+export function fromString(str) {
+    if (!_fromString) {
+        _fromString = createFromString(getDeps());
+    }
+    return _fromString(str);
+}
+let _fromJSON;
+export function fromJSON(data) {
+    if (!_fromJSON) {
+        _fromJSON = createFromJSON(getDeps());
+    }
+    return _fromJSON(data);
+}
+let _fromBytes;
+export function fromBytes(data) {
+    if (!_fromBytes) {
+        _fromBytes = createFromBytes(getDeps());
+    }
+    return _fromBytes(data);
+}
+let _transform;
+export function transform(fn) {
+    if (!_transform) {
+        _transform = createTransformHelper(getDeps());
+    }
+    return _transform(fn);
+}
+let _filter;
+export function filter(predicate) {
+    if (!_filter) {
+        _filter = createFilter(getDeps());
+    }
+    return _filter(predicate);
+}

package/dist/browser/modules/stream/utils.d.ts

@@ -2,23 +2,22 @@
  * Stream Utilities
  *
  * Small, cross-platform helpers built on top of the platform stream
- * implementation selected by `./streams` (Node.js or browser).
+ * implementation. This file is swapped for `utils.browser.ts` in browser
+ * builds via the `preferBrowserFilesPlugin()` mechanism.
+ *
+ * All factory-produced helpers are lazily initialized on first call to avoid
+ * eagerly pulling in heavy stream class dependencies at import time.
  */
-import type { IReadable, ITransform } from "@stream/types";
-export declare function collect<T>(stream: {
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-}): Promise<T[]>;
-export declare function text(stream: {
-    [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
-}): Promise<string>;
-export declare function json<T = unknown>(stream: {
-    [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
-}): Promise<T>;
-export declare function bytes(stream: {
+import { collect, isReadableStreamLike, readableStreamToAsyncIterable } from "./utils.base.js";
+export { collect, isReadableStreamLike, readableStreamToAsyncIterable };
+type AsyncIterableStream = {
     [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
-}): Promise<Uint8Array>;
-export declare function fromString(str: string): IReadable<Uint8Array>;
-export declare function fromJSON(data: unknown): IReadable<Uint8Array>;
-export declare function fromBytes(data: Uint8Array): IReadable<Uint8Array>;
-export declare function transform<TIn = Uint8Array, TOut = TIn>(fn: (chunk: TIn) => TOut | Promise<TOut>): ITransform<TIn, TOut>;
-export declare function filter<T>(predicate: (chunk: T) => boolean | Promise<boolean>): ITransform<T, T>;
+};
+export declare function text(stream: AsyncIterableStream): Promise<string>;
+export declare function json<T = unknown>(stream: AsyncIterableStream): Promise<T>;
+export declare function bytes(stream: AsyncIterableStream): Promise<Uint8Array>;
+export declare function fromString(str: string): import("./types.js").IReadable<Uint8Array<ArrayBufferLike>>;
+export declare function fromJSON(data: unknown): import("./types.js").IReadable<Uint8Array<ArrayBufferLike>>;
+export declare function fromBytes(data: Uint8Array): import("./types.js").IReadable<Uint8Array<ArrayBufferLike>>;
+export declare function transform<TIn = Uint8Array, TOut = TIn>(fn: (chunk: TIn) => TOut | Promise<TOut>): import("./types.js").ITransform<TIn, TOut>;
+export declare function filter<T>(predicate: (chunk: T) => boolean | Promise<boolean>): import("./types.js").ITransform<T, T>;