@cj-tech-master/excelts 4.2.1-canary.20260111102127.f808a37 → 4.2.1

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

@@ -27,7 +27,6 @@ export declare class Readable<T = Uint8Array> extends EventEmitter {
     private _bufferSize;
     private _reading;
     private _ended;
-    private _endEmitted;
     private _destroyed;
     private _errored;
     private _closed;
@@ -72,7 +71,6 @@ export declare class Readable<T = Uint8Array> extends EventEmitter {
      * Push data to the stream (when using controllable stream)
      */
     push(chunk: T | null): boolean;
-    private _emitEndOnce;
     /**
      * Put a chunk back at the front of the buffer
      * Note: unshift is allowed even after end, as it's used to put back already read data
@@ -160,8 +158,7 @@ export declare class Readable<T = Uint8Array> extends EventEmitter {
     private _startReading;
     /**
      * Async iterator support
-     * Uses a unified event-queue iterator with simple backpressure.
-     * This matches Node's behavior more closely (iterator drives flowing mode).
+     * Uses Web Stream reader for non-push mode, event-based for push mode
      */
     [Symbol.asyncIterator](): AsyncIterableIterator<T>;
     /**
@@ -288,12 +285,10 @@ export declare class Writable<T = Uint8Array> extends EventEmitter {
     private _closed;
     private _pendingWrites;
     private _writableLength;
-    private _needDrain;
     private _corked;
     private _corkedChunks;
     private _defaultEncoding;
     private _aborted;
-    private _ownsStream;
     private _writeFunc?;
     private _finalFunc?;
     readonly objectMode: boolean;
@@ -403,46 +398,53 @@ export declare function normalizeWritable<T = Uint8Array>(stream: WritableLike |
  * A wrapper around Web TransformStream that provides Node.js-like API
  */
 export declare class Transform<TInput = Uint8Array, TOutput = Uint8Array> extends EventEmitter {
+    private _stream;
     /** @internal - for pipe() support */
     readonly _readable: Readable<TOutput>;
     /** @internal - for pipe() support */
     readonly _writable: Writable<TInput>;
     readonly objectMode: boolean;
-    private _destroyed;
     private _ended;
+    private _destroyed;
     private _errored;
-    private _dataForwardingSetup;
-    private _endTimer;
-    private _webStream;
-    private _sideForwardingCleanup;
-    private _transformImpl;
-    private _flushImpl;
+    private _pushBuffer;
+    private _transformController;
+    private _pendingEndWrites;
+    private _endPending;
     /**
-     * Push data to the readable side (Node.js compatibility).
-     * Intended to be called from within transform/flush.
+     * Push data to the readable side (Node.js compatibility)
+     * Can be called from within transform callback
      */
     push(chunk: TOutput | null): boolean;
     constructor(options?: TransformStreamOptions & {
         transform?: ((chunk: TInput) => TOutput | Promise<TOutput>) | ((this: Transform<TInput, TOutput>, chunk: TInput, encoding: string, callback: (error?: Error | null, data?: TOutput) => void) => void);
         flush?: (() => TOutput | void | Promise<TOutput | void>) | ((this: Transform<TInput, TOutput>, callback: (error?: Error | null, data?: TOutput) => void) => void);
     });
-    private _setupSideForwarding;
-    private _scheduleEnd;
-    private _emitErrorOnce;
-    private _hasSubclassTransform;
-    private _hasSubclassFlush;
-    private _runTransform;
-    private _runFlush;
+    private _dataForwardingSetup;
     /**
-     * Override on() to lazily forward readable 'data' events.
-     * Avoids starting flowing mode unless requested.
+     * Override on to start flowing when data listener is added
      */
     on(event: string | symbol, listener: (...args: any[]) => void): this;
+    /** @internal - whether we have a data event consumer */
+    private _hasDataConsumer;
     /**
-     * Write to the writable side
+     * Write data to the transform stream
+     * Note: Automatically starts consuming readable if no consumer to allow
+     * transform function to execute (Web Streams backpressure compatibility)
      */
     write(chunk: TInput, callback?: (error?: Error | null) => void): boolean;
     write(chunk: TInput, encoding?: string, callback?: (error?: Error | null) => void): boolean;
+    /** @internal - whether we're auto-consuming the readable */
+    private _readableConsuming;
+    /** @internal - buffer for auto-consumed data */
+    private _autoConsumedBuffer;
+    private _autoConsumedBufferIndex;
+    /** @internal - whether auto-consume has ended */
+    private _autoConsumeEnded;
+    /** @internal - promise that resolves when auto-consume finishes */
+    private _autoConsumePromise;
+    /** @internal - auto-consume readable to allow transform to execute */
+    private _startAutoConsume;
     /**
      * End the transform stream
      * Delays closing to allow writes during data events to complete
@@ -454,8 +456,10 @@ export declare class Transform<TInput = Uint8Array, TOutput = Uint8Array> extend
      * Read from the transform stream
      */
     read(size?: number): TOutput | null;
+    /** @internal - list of piped destinations for forwarding auto-consumed data */
+    private _pipeDestinations;
     /**
-     * Pipe readable side to destination
+     * Pipe to another stream (writable, transform, or duplex)
      */
     pipe<W extends Writable<TOutput> | Transform<TOutput, any> | Duplex<any, TOutput>>(destination: W): W;
     /**
@@ -550,7 +554,6 @@ export declare class Duplex<TRead = Uint8Array, TWrite = Uint8Array> extends Eve
         writable: WritableStream<W>;
     };
     private _dataForwardingSetup;
-    private _sideForwardingCleanup;
     constructor(options?: DuplexStreamOptions & {
         allowHalfOpen?: boolean;
         objectMode?: boolean;
@@ -558,7 +561,6 @@ export declare class Duplex<TRead = Uint8Array, TWrite = Uint8Array> extends Eve
         write?: (this: Duplex<TRead, TWrite>, chunk: TWrite, encoding: string, callback: (error?: Error | null) => void) => void;
         final?: (this: Duplex<TRead, TWrite>, callback: (error?: Error | null) => void) => void;
     });
-    private _setupSideForwarding;
     /**
      * Override on() to set up data forwarding lazily
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cj-tech-master/excelts",
-  "version": "4.2.1-canary.20260111102127.f808a37",
+  "version": "4.2.1",
   "description": "TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.",
   "type": "module",
   "publishConfig": {
@@ -44,10 +44,6 @@
         "default": "./dist/cjs/index.js"
       }
     },
-    "./browser": {
-      "types": "./dist/browser/index.browser.d.ts",
-      "default": "./dist/browser/index.browser.js"
-    },
     "./package.json": "./package.json"
   },
   "files": [

package/dist/browser/modules/archive/internal/byte-queue.d.ts

@@ -1,33 +0,0 @@
-export declare class ByteQueue {
-    private static readonly EMPTY;
-    private _chunks;
-    private _headOffset;
-    private _length;
-    private _cachedView;
-    private _cachedLength;
-    constructor(initial?: Uint8Array);
-    get length(): number;
-    isEmpty(): boolean;
-    view(): Uint8Array;
-    reset(data?: Uint8Array): void;
-    append(chunk: Uint8Array): void;
-    read(length: number): Uint8Array;
-    /**
-     * Return a list of chunk views totaling `length` bytes without consuming.
-     *
-     * This avoids materializing a contiguous buffer for streaming write paths.
-     */
-    peekChunks(length: number): Uint8Array[];
-    discard(length: number): void;
-    /**
-     * Find the first index of `pattern` within the queue.
-     *
-     * This avoids materializing a contiguous `view()` for common small patterns
-     * (ZIP signatures are typically 2-4 bytes).
-     */
-    indexOfPattern(pattern: Uint8Array, startIndex?: number): number;
-    /** Peek a little-endian uint32 at `offset` without consuming bytes. Returns null if not enough bytes. */
-    peekUint32LE(offset: number): number | null;
-    /** Peek a single byte at `offset` without consuming bytes. */
-    peekByte(offset: number): number;
-}

package/dist/browser/modules/archive/internal/byte-queue.js

@@ -1,407 +0,0 @@
-import { indexOfUint8ArrayPattern } from "../utils/bytes.js";
-export class ByteQueue {
-    constructor(initial) {
-        // Store data as immutable chunks to avoid copying on append.
-        this._chunks = [];
-        this._headOffset = 0;
-        this._length = 0;
-        // Lazily materialized contiguous view (used only by callers that require a single buffer).
-        this._cachedView = null;
-        this._cachedLength = 0;
-        if (initial && initial.length > 0) {
-            this.reset(initial);
-        }
-    }
-    get length() {
-        return this._length;
-    }
-    isEmpty() {
-        return this.length === 0;
-    }
-    view() {
-        if (this._length === 0) {
-            return ByteQueue.EMPTY;
-        }
-        // Fast path: single chunk.
-        if (this._chunks.length === 1) {
-            const c = this._chunks[0];
-            return c.subarray(this._headOffset, this._headOffset + this._length);
-        }
-        if (this._cachedView && this._cachedLength === this._length) {
-            return this._cachedView;
-        }
-        const out = new Uint8Array(this._length);
-        let offset = 0;
-        for (let i = 0; i < this._chunks.length; i++) {
-            const c = this._chunks[i];
-            const start = i === 0 ? this._headOffset : 0;
-            const end = i === this._chunks.length - 1 ? start + (this._length - offset) : c.length;
-            out.set(c.subarray(start, end), offset);
-            offset += end - start;
-            if (offset >= out.length) {
-                break;
-            }
-        }
-        this._cachedView = out;
-        this._cachedLength = this._length;
-        return out;
-    }
-    reset(data) {
-        this._cachedView = null;
-        this._cachedLength = 0;
-        this._chunks = [];
-        this._headOffset = 0;
-        this._length = 0;
-        if (!data || data.length === 0) {
-            return;
-        }
-        // Keep a private copy to ensure future writes cannot mutate the source.
-        const copy = new Uint8Array(data.length);
-        copy.set(data);
-        this._chunks = [copy];
-        this._headOffset = 0;
-        this._length = copy.length;
-    }
-    append(chunk) {
-        if (chunk.length === 0) {
-            return;
-        }
-        this._cachedView = null;
-        this._cachedLength = 0;
-        this._chunks.push(chunk);
-        this._length += chunk.length;
-    }
-    read(length) {
-        if (length <= 0) {
-            return new Uint8Array(0);
-        }
-        if (length > this._length) {
-            throw new RangeError("ByteQueue: read beyond available data");
-        }
-        this._cachedView = null;
-        this._cachedLength = 0;
-        if (this._chunks.length === 1) {
-            const c = this._chunks[0];
-            const start = this._headOffset;
-            const end = start + length;
-            const out = c.subarray(start, end);
-            this._headOffset = end;
-            this._length -= length;
-            if (this._length === 0) {
-                this._chunks = [];
-                this._headOffset = 0;
-            }
-            else if (this._headOffset >= c.length) {
-                this._chunks.shift();
-                this._headOffset = 0;
-            }
-            return out;
-        }
-        // Slow path: spans multiple chunks, copy into a single output buffer.
-        const out = new Uint8Array(length);
-        let outOffset = 0;
-        let remaining = length;
-        while (remaining > 0) {
-            const c = this._chunks[0];
-            const start = this._headOffset;
-            const available = c.length - start;
-            const toCopy = Math.min(available, remaining);
-            out.set(c.subarray(start, start + toCopy), outOffset);
-            outOffset += toCopy;
-            remaining -= toCopy;
-            this._headOffset += toCopy;
-            this._length -= toCopy;
-            if (this._headOffset >= c.length) {
-                this._chunks.shift();
-                this._headOffset = 0;
-            }
-        }
-        if (this._length === 0) {
-            this._chunks = [];
-            this._headOffset = 0;
-        }
-        return out;
-    }
-    /**
-     * Return a list of chunk views totaling `length` bytes without consuming.
-     *
-     * This avoids materializing a contiguous buffer for streaming write paths.
-     */
-    peekChunks(length) {
-        if (length <= 0) {
-            return [];
-        }
-        if (length > this._length) {
-            throw new RangeError("ByteQueue: peek beyond available data");
-        }
-        // Fast path: single chunk.
-        if (this._chunks.length === 1) {
-            const c = this._chunks[0];
-            const start = this._headOffset;
-            return [c.subarray(start, start + length)];
-        }
-        const parts = [];
-        let remaining = length;
-        for (let i = 0; i < this._chunks.length && remaining > 0; i++) {
-            const c = this._chunks[i];
-            const start = i === 0 ? this._headOffset : 0;
-            const avail = c.length - start;
-            if (avail <= 0) {
-                continue;
-            }
-            const toTake = Math.min(avail, remaining);
-            parts.push(c.subarray(start, start + toTake));
-            remaining -= toTake;
-        }
-        return parts;
-    }
-    discard(length) {
-        if (length <= 0) {
-            return;
-        }
-        if (length >= this._length) {
-            this._chunks = [];
-            this._headOffset = 0;
-            this._length = 0;
-            this._cachedView = null;
-            this._cachedLength = 0;
-            return;
-        }
-        this._cachedView = null;
-        this._cachedLength = 0;
-        let remaining = length;
-        while (remaining > 0) {
-            const c = this._chunks[0];
-            const start = this._headOffset;
-            const available = c.length - start;
-            const toDrop = Math.min(available, remaining);
-            this._headOffset += toDrop;
-            this._length -= toDrop;
-            remaining -= toDrop;
-            if (this._headOffset >= c.length) {
-                this._chunks.shift();
-                this._headOffset = 0;
-            }
-        }
-        if (this._length === 0) {
-            this._chunks = [];
-            this._headOffset = 0;
-        }
-    }
-    /**
-     * Find the first index of `pattern` within the queue.
-     *
-     * This avoids materializing a contiguous `view()` for common small patterns
-     * (ZIP signatures are typically 2-4 bytes).
-     */
-    indexOfPattern(pattern, startIndex = 0) {
-        const patLen = pattern.length;
-        if (patLen === 0) {
-            return 0;
-        }
-        const len = this._length;
-        if (patLen > len) {
-            return -1;
-        }
-        let start = startIndex | 0;
-        if (start < 0) {
-            start = 0;
-        }
-        if (start > len - patLen) {
-            return -1;
-        }
-        // Fast path: single chunk.
-        if (this._chunks.length === 1) {
-            const c = this._chunks[0];
-            const base = this._headOffset;
-            const view = c.subarray(base, base + len);
-            // Delegate to native indexOf checks for 1..4 bytes.
-            if (patLen === 1) {
-                return view.indexOf(pattern[0], start);
-            }
-            return indexOfUint8ArrayPattern(view, pattern, start);
-        }
-        // Multi-chunk: optimize only for very common small patterns.
-        if (patLen > 4) {
-            // Rare: materialize view.
-            const v = this.view();
-            return indexOfUint8ArrayPattern(v, pattern, start);
-        }
-        const b0 = pattern[0];
-        const b1 = patLen >= 2 ? pattern[1] : 0;
-        const b2 = patLen >= 3 ? pattern[2] : 0;
-        const b3 = patLen >= 4 ? pattern[3] : 0;
-        const chunks = this._chunks;
-        const peekByteAcrossChunks = (chunkIndex, absoluteIndex) => {
-            let ci = chunkIndex;
-            let idx = absoluteIndex;
-            while (ci < chunks.length) {
-                const c = chunks[ci];
-                if (idx < c.length) {
-                    return c[idx] | 0;
-                }
-                idx -= c.length;
-                ci++;
-            }
-            return null;
-        };
-        let globalBase = 0;
-        for (let ci = 0; ci < chunks.length; ci++) {
-            const c = chunks[ci];
-            const chunkOffset = ci === 0 ? this._headOffset : 0;
-            const chunkLen = c.length - chunkOffset;
-            if (chunkLen <= 0) {
-                continue;
-            }
-            const chunkStartGlobal = globalBase;
-            const chunkEndGlobal = chunkStartGlobal + chunkLen;
-            // Compute local start for this chunk.
-            const localStart = start <= chunkStartGlobal
-                ? chunkOffset
-                : start >= chunkEndGlobal
-                    ? c.length
-                    : chunkOffset + (start - chunkStartGlobal);
-            if (localStart > c.length - 1) {
-                globalBase += chunkLen;
-                continue;
-            }
-            const lastLocal = c.length - 1;
-            let i = c.indexOf(b0, localStart);
-            while (i !== -1 && i <= lastLocal) {
-                const globalPos = chunkStartGlobal + (i - chunkOffset);
-                if (globalPos > len - patLen) {
-                    return -1;
-                }
-                if (patLen === 1) {
-                    return globalPos;
-                }
-                // Fast path: match stays fully inside the current chunk.
-                // Avoid calling peekByte() which walks the chunk list per byte.
-                const staysInChunk = i + patLen <= c.length;
-                if (staysInChunk) {
-                    if (c[i + 1] !== b1) {
-                        i = c.indexOf(b0, i + 1);
-                        continue;
-                    }
-                    if (patLen === 2) {
-                        return globalPos;
-                    }
-                    if (c[i + 2] !== b2) {
-                        i = c.indexOf(b0, i + 1);
-                        continue;
-                    }
-                    if (patLen === 3) {
-                        return globalPos;
-                    }
-                    if (c[i + 3] !== b3) {
-                        i = c.indexOf(b0, i + 1);
-                        continue;
-                    }
-                    return globalPos;
-                }
-                // Slow path: pattern spans chunks.
-                const b1v = peekByteAcrossChunks(ci, i + 1);
-                if (b1v === null || b1v !== b1) {
-                    i = c.indexOf(b0, i + 1);
-                    continue;
-                }
-                if (patLen === 2) {
-                    return globalPos;
-                }
-                const b2v = peekByteAcrossChunks(ci, i + 2);
-                if (b2v === null || b2v !== b2) {
-                    i = c.indexOf(b0, i + 1);
-                    continue;
-                }
-                if (patLen === 3) {
-                    return globalPos;
-                }
-                const b3v = peekByteAcrossChunks(ci, i + 3);
-                if (b3v === null || b3v !== b3) {
-                    i = c.indexOf(b0, i + 1);
-                    continue;
-                }
-                return globalPos;
-            }
-            globalBase += chunkLen;
-        }
-        return -1;
-    }
-    /** Peek a little-endian uint32 at `offset` without consuming bytes. Returns null if not enough bytes. */
-    peekUint32LE(offset) {
-        const off = offset | 0;
-        if (off < 0 || off + 4 > this._length) {
-            return null;
-        }
-        // Try to read contiguously from a single chunk to avoid 4x chunk-walk.
-        const chunks = this._chunks;
-        let remaining = off;
-        for (let i = 0; i < chunks.length; i++) {
-            const c = chunks[i];
-            const start = i === 0 ? this._headOffset : 0;
-            const avail = c.length - start;
-            if (remaining < avail) {
-                const idx = start + remaining;
-                if (idx + 4 <= c.length) {
-                    const b0 = c[idx] | 0;
-                    const b1 = c[idx + 1] | 0;
-                    const b2 = c[idx + 2] | 0;
-                    const b3 = c[idx + 3] | 0;
-                    return (b0 | (b1 << 8) | (b2 << 16) | (b3 << 24)) >>> 0;
-                }
-                // Cross-chunk read (rare): walk forward across chunks once.
-                const b0 = c[idx] | 0;
-                let b1 = 0;
-                let b2 = 0;
-                let b3 = 0;
-                let ci = i;
-                let pos = idx + 1;
-                for (let k = 1; k < 4; k++) {
-                    while (ci < chunks.length) {
-                        const cc = chunks[ci];
-                        if (pos < cc.length) {
-                            const v = cc[pos] | 0;
-                            if (k === 1) {
-                                b1 = v;
-                            }
-                            else if (k === 2) {
-                                b2 = v;
-                            }
-                            else {
-                                b3 = v;
-                            }
-                            pos++;
-                            break;
-                        }
-                        ci++;
-                        pos = 0;
-                    }
-                }
-                return (b0 | (b1 << 8) | (b2 << 16) | (b3 << 24)) >>> 0;
-            }
-            remaining -= avail;
-        }
-        // Should be unreachable due to bounds check above.
-        return null;
-    }
-    /** Peek a single byte at `offset` without consuming bytes. */
-    peekByte(offset) {
-        const off = offset | 0;
-        if (off < 0 || off >= this._length) {
-            throw new RangeError("ByteQueue: peek beyond available data");
-        }
-        let remaining = off;
-        for (let i = 0; i < this._chunks.length; i++) {
-            const c = this._chunks[i];
-            const start = i === 0 ? this._headOffset : 0;
-            const avail = c.length - start;
-            if (remaining < avail) {
-                return c[start + remaining] | 0;
-            }
-            remaining -= avail;
-        }
-        // Should be unreachable.
-        throw new RangeError("ByteQueue: peek beyond available data");
-    }
-}
-ByteQueue.EMPTY = new Uint8Array(0);

package/dist/browser/modules/archive/io/archive-sink.d.ts

@@ -1,9 +0,0 @@
-export type ArchiveSink = WritableStream<Uint8Array> | {
-    write(chunk: Uint8Array): any;
-    end?(cb?: any): any;
-    on?(event: string, listener: (...args: any[]) => void): any;
-    once?(event: string, listener: (...args: any[]) => void): any;
-};
-export declare function isWritableStream(value: unknown): value is WritableStream<Uint8Array>;
-export declare function pipeIterableToSink(iterable: AsyncIterable<Uint8Array>, sink: ArchiveSink): Promise<void>;
-export declare function collect(iterable: AsyncIterable<Uint8Array>): Promise<Uint8Array>;

package/dist/browser/modules/archive/io/archive-sink.js

@@ -1,77 +0,0 @@
-export function isWritableStream(value) {
-    return !!value && typeof value === "object" && typeof value.getWriter === "function";
-}
-function once(emitter, event) {
-    return new Promise((resolve, reject) => {
-        const onError = (err) => {
-            cleanup();
-            reject(err instanceof Error ? err : new Error(String(err)));
-        };
-        const onDone = () => {
-            cleanup();
-            resolve();
-        };
-        const cleanup = () => {
-            emitter.off?.("error", onError);
-            emitter.off?.(event, onDone);
-            emitter.removeListener?.("error", onError);
-            emitter.removeListener?.(event, onDone);
-        };
-        emitter.on?.("error", onError);
-        emitter.on?.(event, onDone);
-    });
-}
-export async function pipeIterableToSink(iterable, sink) {
-    if (isWritableStream(sink)) {
-        const writer = sink.getWriter();
-        try {
-            for await (const chunk of iterable) {
-                await writer.write(chunk);
-            }
-            await writer.close();
-        }
-        finally {
-            try {
-                writer.releaseLock();
-            }
-            catch {
-                // Ignore
-            }
-        }
-        return;
-    }
-    // Node-style Writable
-    for await (const chunk of iterable) {
-        const ok = sink.write(chunk);
-        if (ok === false && typeof sink.once === "function") {
-            await once(sink, "drain");
-        }
-    }
-    if (typeof sink.end === "function") {
-        sink.end();
-    }
-    if (typeof sink.once === "function") {
-        await Promise.race([once(sink, "finish"), once(sink, "close")]);
-    }
-}
-export async function collect(iterable) {
-    const chunks = [];
-    let total = 0;
-    for await (const chunk of iterable) {
-        chunks.push(chunk);
-        total += chunk.length;
-    }
-    if (chunks.length === 0) {
-        return new Uint8Array(0);
-    }
-    if (chunks.length === 1) {
-        return chunks[0];
-    }
-    const out = new Uint8Array(total);
-    let offset = 0;
-    for (const chunk of chunks) {
-        out.set(chunk, offset);
-        offset += chunk.length;
-    }
-    return out;
-}

package/dist/browser/modules/archive/io/archive-source.d.ts

@@ -1,8 +0,0 @@
-export type ArchiveSource = Uint8Array | ArrayBuffer | string | Blob | AsyncIterable<unknown> | ReadableStream<unknown> | {
-    [Symbol.asyncIterator](): AsyncIterator<unknown>;
-};
-export declare function isReadableStream(value: unknown): value is ReadableStream<unknown>;
-export declare function isAsyncIterable(value: unknown): value is AsyncIterable<unknown>;
-export declare function toUint8ArraySync(source: Uint8Array | ArrayBuffer | string): Uint8Array;
-export declare function toUint8Array(source: Uint8Array | ArrayBuffer | string | Blob): Promise<Uint8Array>;
-export declare function toAsyncIterable(source: ArchiveSource): AsyncIterable<Uint8Array>;