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

package/dist/esm/modules/stream/internal/event-utils.js

@@ -0,0 +1,40 @@
+/**
+ * Small event utilities for Node-style emitters.
+ *
+ * Prefer keeping this separate from the main stream implementation so other
+ * modules (e.g. archive) can reuse it without pulling in the whole stream API.
+ */
+function off(emitter, event, listener) {
+    if (typeof emitter.off === "function") {
+        emitter.off(event, listener);
+    }
+    else if (typeof emitter.removeListener === "function") {
+        emitter.removeListener(event, listener);
+    }
+}
+/**
+ * Resolve when an emitter fires `event`, reject on `error`.
+ */
+export function onceEvent(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 = () => {
+            off(emitter, "error", onError);
+            off(emitter, event, onDone);
+        };
+        if (typeof emitter.once === "function") {
+            emitter.once("error", onError);
+            emitter.once(event, onDone);
+            return;
+        }
+        emitter.on?.("error", onError);
+        emitter.on?.(event, onDone);
+    });
+}

package/dist/esm/modules/stream/internal/type-guards.js

@@ -0,0 +1,24 @@
+/**
+ * Lightweight runtime type guards shared across modules.
+ *
+ * Keep this file dependency-free to maximize deduping in bundled builds.
+ */
+export function isReadableStream(value) {
+    return !!value && typeof value === "object" && typeof value.getReader === "function";
+}
+export function isWritableStream(value) {
+    return !!value && typeof value === "object" && typeof value.getWriter === "function";
+}
+export function isAsyncIterable(value) {
+    return (!!value &&
+        (typeof value === "object" || typeof value === "function") &&
+        typeof value[Symbol.asyncIterator] === "function");
+}
+export function isTransformStream(value) {
+    return (!!value &&
+        typeof value === "object" &&
+        !!value.readable &&
+        !!value.writable &&
+        isReadableStream(value.readable) &&
+        isWritableStream(value.writable));
+}

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

@@ -5,36 +5,41 @@
  * Works identically in both browser and Node.js environments.
  */
 import { EventEmitter } from "./event-emitter.js";
-import { concatUint8Arrays } from "./shared.js";
+const EMPTY_U8 = new Uint8Array(0);
 /**
  * Browser-compatible Pull Stream - Read data from buffer on demand with pattern matching
  */
 export class PullStream extends EventEmitter {
     constructor(_options = {}) {
         super();
-        // Use chunked buffer storage to avoid repeated concat
-        this._bufferChunks = [];
-        this._totalLength = 0;
+        // Single growable buffer with read/write cursors.
+        // IMPORTANT: never mutate bytes that have already been returned via subarray
+        // (to keep views stable). When we need to reclaim prefix space, we allocate
+        // a new buffer and copy the remaining bytes.
+        this._buffer = new Uint8Array(0);
+        this._bufferReadIndex = 0;
+        this._bufferWriteIndex = 0;
         this.finished = false;
         this._destroyed = false;
     }
-    // Consolidate chunks into single buffer when needed
+    // Maintain legacy protected accessor for subclasses.
+    // Returned value is a view of the readable region.
     get buffer() {
-        const len = this._bufferChunks.length;
-        if (len === 0) {
-            return new Uint8Array(0);
+        if (this._bufferReadIndex === this._bufferWriteIndex) {
+            return EMPTY_U8;
         }
-        if (len === 1) {
-            return this._bufferChunks[0];
-        }
-        // Consolidate multiple chunks
-        const buf = concatUint8Arrays(this._bufferChunks);
-        this._bufferChunks = [buf];
-        return buf;
+        return this._buffer.subarray(this._bufferReadIndex, this._bufferWriteIndex);
     }
     set buffer(buf) {
-        this._bufferChunks = buf.length > 0 ? [buf] : [];
-        this._totalLength = buf.length;
+        if (buf.length === 0) {
+            this._buffer = EMPTY_U8;
+            this._bufferReadIndex = 0;
+            this._bufferWriteIndex = 0;
+            return;
+        }
+        this._buffer = buf;
+        this._bufferReadIndex = 0;
+        this._bufferWriteIndex = buf.length;
     }
     /**
      * Write data to the stream
@@ -44,8 +49,38 @@ export class PullStream extends EventEmitter {
             this.emit("error", new Error("Cannot write to destroyed stream"));
             return false;
         }
-        this._bufferChunks.push(chunk);
-        this._totalLength += chunk.length;
+        const chunkLen = chunk.length;
+        if (chunkLen === 0) {
+            this.emit("chunk");
+            return true;
+        }
+        // Fast path: first write can reuse caller buffer without copy.
+        if (this._buffer.length === 0) {
+            this._buffer = chunk;
+            this._bufferReadIndex = 0;
+            this._bufferWriteIndex = chunkLen;
+            this.emit("chunk");
+            return true;
+        }
+        const required = this._bufferWriteIndex + chunkLen;
+        if (required <= this._buffer.length) {
+            this._buffer.set(chunk, this._bufferWriteIndex);
+            this._bufferWriteIndex += chunkLen;
+            this.emit("chunk");
+            return true;
+        }
+        // Need a new buffer. We keep previously returned views stable by allocating.
+        const remaining = this._bufferWriteIndex - this._bufferReadIndex;
+        const nextLength = remaining + chunkLen;
+        const prevCap = this._buffer.length;
+        // Grow exponentially to avoid O(n^2) copying on many small writes.
+        const nextCap = Math.max(nextLength, prevCap > 0 ? prevCap * 2 : 1024);
+        const next = new Uint8Array(nextCap);
+        next.set(this._buffer.subarray(this._bufferReadIndex, this._bufferWriteIndex), 0);
+        next.set(chunk, remaining);
+        this._buffer = next;
+        this._bufferReadIndex = 0;
+        this._bufferWriteIndex = nextLength;
         this.emit("chunk");
         return true;
     }
@@ -69,8 +104,9 @@ export class PullStream extends EventEmitter {
             return;
         }
         this._destroyed = true;
-        this._bufferChunks = [];
-        this._totalLength = 0;
+        this._buffer = EMPTY_U8;
+        this._bufferReadIndex = 0;
+        this._bufferWriteIndex = 0;
         if (error) {
             this.emit("error", error);
         }
@@ -95,19 +131,32 @@ export class PullStream extends EventEmitter {
                     reject(new Error("Stream destroyed"));
                     return;
                 }
-                // Use _totalLength for fast check before consolidating
-                if (this._totalLength >= size) {
-                    const buf = this.buffer;
-                    const result = buf.subarray(0, size);
-                    this.buffer = buf.subarray(size);
+                if (size === 0) {
+                    resolve(this._buffer.subarray(this._bufferReadIndex, this._bufferReadIndex));
+                    return;
+                }
+                const available = this._bufferWriteIndex - this._bufferReadIndex;
+                if (available >= size) {
+                    const start = this._bufferReadIndex;
+                    const end = start + size;
+                    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;
+                    }
                     resolve(result);
                     return;
                 }
                 if (this.finished) {
                     // Return whatever we have
-                    const result = this.buffer;
-                    this._bufferChunks = [];
-                    this._totalLength = 0;
+                    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;
                     resolve(result);
                     return;
                 }
@@ -124,21 +173,36 @@ export class PullStream extends EventEmitter {
                     reject(new Error("Stream destroyed"));
                     return;
                 }
-                const buf = this.buffer;
-                const matchIndex = this._indexOf(buf, pattern);
-                if (matchIndex !== -1) {
-                    this._match = matchIndex;
-                    const endIndex = includePattern ? matchIndex + pattern.length : matchIndex;
-                    const result = buf.subarray(0, endIndex);
-                    this.buffer = buf.subarray(includePattern ? endIndex : matchIndex + pattern.length);
+                // Match empty pattern without consuming anything.
+                if (pattern.length === 0) {
+                    this._match = 0;
+                    resolve(this._buffer.subarray(this._bufferReadIndex, this._bufferReadIndex));
+                    return;
+                }
+                const matchIndexAbs = this._indexOf(this._buffer, this._bufferReadIndex, this._bufferWriteIndex, pattern);
+                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;
+                    }
                     resolve(result);
                     return;
                 }
                 if (this.finished) {
                     // Pattern not found, return everything
-                    const result = buf;
-                    this._bufferChunks = [];
-                    this._totalLength = 0;
+                    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;
                     resolve(result);
                     return;
                 }
@@ -158,7 +222,7 @@ export class PullStream extends EventEmitter {
      * Get remaining buffer length
      */
     get length() {
-        return this._totalLength;
+        return this._bufferWriteIndex - this._bufferReadIndex;
     }
     /**
      * Check if stream is finished
@@ -175,13 +239,13 @@ export class PullStream extends EventEmitter {
     /**
      * Find pattern in Uint8Array (like Buffer.indexOf)
      */
-    _indexOf(haystack, needle, start = 0) {
+    _indexOf(haystack, start, end, needle) {
         const needleLen = needle.length;
         if (needleLen === 0) {
             return start;
         }
-        const haystackLen = haystack.length;
-        if (needleLen > haystackLen) {
+        const haystackLen = end;
+        if (needleLen > haystackLen - start) {
             return -1;
         }
         const first = needle[0];

package/dist/esm/modules/stream/shared.js

@@ -54,7 +54,7 @@ export function uint8ArrayToString(arr, encoding) {
 /**
  * Concatenate multiple Uint8Arrays efficiently
  */
-export function concatUint8Arrays(arrays) {
+export function concatUint8Arrays(arrays, totalLength) {
     const len = arrays.length;
     if (len === 0) {
         return new Uint8Array(0);
@@ -63,9 +63,12 @@ export function concatUint8Arrays(arrays) {
         return arrays[0];
     }
     // Calculate total length with for loop for better performance
-    let totalLength = 0;
-    for (let i = 0; i < len; i++) {
-        totalLength += arrays[i].length;
+    if (totalLength === undefined) {
+        let sum = 0;
+        for (let i = 0; i < len; i++) {
+            sum += arrays[i].length;
+        }
+        totalLength = sum;
     }
     const result = new Uint8Array(totalLength);
     let offset = 0;