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

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

@@ -27,6 +27,7 @@ export declare class Readable<T = Uint8Array> extends EventEmitter {
     private _bufferSize;
     private _reading;
     private _ended;
+    private _endEmitted;
     private _destroyed;
     private _errored;
     private _closed;
@@ -71,6 +72,7 @@ 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
@@ -158,7 +160,8 @@ export declare class Readable<T = Uint8Array> extends EventEmitter {
     private _startReading;
     /**
      * Async iterator support
-     * Uses Web Stream reader for non-push mode, event-based for push mode
+     * Uses a unified event-queue iterator with simple backpressure.
+     * This matches Node's behavior more closely (iterator drives flowing mode).
      */
     [Symbol.asyncIterator](): AsyncIterableIterator<T>;
     /**
@@ -285,10 +288,12 @@ 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;
@@ -398,53 +403,46 @@ 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 _ended;
     private _destroyed;
+    private _ended;
     private _errored;
-    private _pushBuffer;
-    private _transformController;
-    private _pendingEndWrites;
-    private _endPending;
+    private _dataForwardingSetup;
+    private _endTimer;
+    private _webStream;
+    private _sideForwardingCleanup;
+    private _transformImpl;
+    private _flushImpl;
     /**
-     * Push data to the readable side (Node.js compatibility)
-     * Can be called from within transform callback
+     * Push data to the readable side (Node.js compatibility).
+     * Intended to be called from within transform/flush.
      */
     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 _dataForwardingSetup;
+    private _setupSideForwarding;
+    private _scheduleEnd;
+    private _emitErrorOnce;
+    private _hasSubclassTransform;
+    private _hasSubclassFlush;
+    private _runTransform;
+    private _runFlush;
     /**
-     * Override on to start flowing when data listener is added
+     * Override on() to lazily forward readable 'data' events.
+     * Avoids starting flowing mode unless requested.
      */
     on(event: string | symbol, listener: (...args: any[]) => void): this;
-    /** @internal - whether we have a data event consumer */
-    private _hasDataConsumer;
     /**
-     * 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 to the writable side
      */
     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
@@ -456,10 +454,8 @@ 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 to another stream (writable, transform, or duplex)
+     * Pipe readable side to destination
      */
     pipe<W extends Writable<TOutput> | Transform<TOutput, any> | Duplex<any, TOutput>>(destination: W): W;
     /**
@@ -554,6 +550,7 @@ export declare class Duplex<TRead = Uint8Array, TWrite = Uint8Array> extends Eve
         writable: WritableStream<W>;
     };
     private _dataForwardingSetup;
+    private _sideForwardingCleanup;
     constructor(options?: DuplexStreamOptions & {
         allowHalfOpen?: boolean;
         objectMode?: boolean;
@@ -561,6 +558,7 @@ 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.0-canary.20260110111632.c88c61c",
+  "version": "4.2.1-canary.20260111102127.f808a37",
   "description": "TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.",
   "type": "module",
   "publishConfig": {
@@ -44,6 +44,10 @@
         "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/byte-queue.d.ts

@@ -1,18 +0,0 @@
-export declare class ByteQueue {
-    private static readonly EMPTY;
-    private _buf;
-    private _start;
-    private _end;
-    private _cachedView;
-    private _cachedBuf;
-    private _cachedStart;
-    private _cachedEnd;
-    constructor(initial?: Uint8Array);
-    get length(): number;
-    isEmpty(): boolean;
-    view(): Uint8Array;
-    reset(data?: Uint8Array): void;
-    append(chunk: Uint8Array): void;
-    read(length: number): Uint8Array;
-    discard(length: number): void;
-}

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

@@ -1,125 +0,0 @@
-export class ByteQueue {
-    constructor(initial) {
-        this._start = 0;
-        this._end = 0;
-        this._cachedView = null;
-        this._cachedBuf = null;
-        this._cachedStart = 0;
-        this._cachedEnd = 0;
-        this._buf = new Uint8Array(0);
-        if (initial && initial.length > 0) {
-            this.reset(initial);
-        }
-    }
-    get length() {
-        return this._end - this._start;
-    }
-    isEmpty() {
-        return this.length === 0;
-    }
-    view() {
-        if (this._start === this._end) {
-            return ByteQueue.EMPTY;
-        }
-        if (this._cachedView &&
-            this._cachedBuf === this._buf &&
-            this._cachedStart === this._start &&
-            this._cachedEnd === this._end) {
-            return this._cachedView;
-        }
-        const view = this._buf.subarray(this._start, this._end);
-        this._cachedView = view;
-        this._cachedBuf = this._buf;
-        this._cachedStart = this._start;
-        this._cachedEnd = this._end;
-        return view;
-    }
-    reset(data) {
-        this._cachedView = null;
-        this._cachedBuf = null;
-        if (!data || data.length === 0) {
-            this._buf = ByteQueue.EMPTY;
-            this._start = 0;
-            this._end = 0;
-            return;
-        }
-        // Keep a private copy to ensure future writes cannot mutate the source.
-        const copy = new Uint8Array(data.length);
-        copy.set(data);
-        this._buf = copy;
-        this._start = 0;
-        this._end = copy.length;
-    }
-    append(chunk) {
-        if (chunk.length === 0) {
-            return;
-        }
-        this._cachedView = null;
-        this._cachedBuf = null;
-        const unread = this.length;
-        // Fast path: enough tail room.
-        if (this._end + chunk.length <= this._buf.length) {
-            this._buf.set(chunk, this._end);
-            this._end += chunk.length;
-            return;
-        }
-        // Allocate a new buffer and copy unread bytes (never compacts in-place).
-        const required = unread + chunk.length;
-        const nextSize = this._buf.length === 0 ? required : Math.max(this._buf.length * 2, required);
-        const next = new Uint8Array(nextSize);
-        if (unread > 0) {
-            next.set(this._buf.subarray(this._start, this._end), 0);
-        }
-        next.set(chunk, unread);
-        this._buf = next;
-        this._start = 0;
-        this._end = required;
-    }
-    read(length) {
-        if (length <= 0) {
-            return new Uint8Array(0);
-        }
-        if (length > this.length) {
-            throw new RangeError("ByteQueue: read beyond available data");
-        }
-        // Return a view for performance.
-        // To keep this safe for async consumers, we must ensure we never write into
-        // the same backing buffer again after it becomes fully consumed.
-        const out = this._buf.subarray(this._start, this._start + length);
-        this._start += length;
-        this._cachedView = null;
-        this._cachedBuf = null;
-        if (this._start === this._end) {
-            // Release backing storage to avoid reusing memory that might still be
-            // referenced by previously returned views.
-            this._buf = ByteQueue.EMPTY;
-            this._start = 0;
-            this._end = 0;
-        }
-        return out;
-    }
-    discard(length) {
-        if (length <= 0) {
-            return;
-        }
-        if (length >= this.length) {
-            // Release backing storage for the same reason as read(): previously
-            // returned views may still be referenced by consumers.
-            this._buf = ByteQueue.EMPTY;
-            this._start = 0;
-            this._end = 0;
-            this._cachedView = null;
-            this._cachedBuf = null;
-            return;
-        }
-        this._start += length;
-        this._cachedView = null;
-        this._cachedBuf = null;
-        if (this._start === this._end) {
-            this._buf = ByteQueue.EMPTY;
-            this._start = 0;
-            this._end = 0;
-        }
-    }
-}
-ByteQueue.EMPTY = new Uint8Array(0);