@cj-tech-master/excelts 4.2.1 → 4.2.2

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

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onceEvent = onceEvent;
+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`.
+ */
+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/cjs/modules/stream/internal/type-guards.js

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

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

@@ -8,36 +8,41 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PullStream = void 0;
 const event_emitter_1 = require("./event-emitter.js");
-const shared_1 = require("./shared.js");
+const EMPTY_U8 = new Uint8Array(0);
 /**
  * Browser-compatible Pull Stream - Read data from buffer on demand with pattern matching
  */
 class PullStream extends event_emitter_1.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 = (0, shared_1.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
@@ -47,8 +52,38 @@ class PullStream extends event_emitter_1.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;
     }
@@ -72,8 +107,9 @@ class PullStream extends event_emitter_1.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);
         }
@@ -98,19 +134,32 @@ class PullStream extends event_emitter_1.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;
                 }
@@ -127,21 +176,36 @@ class PullStream extends event_emitter_1.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;
                 }
@@ -161,7 +225,7 @@ class PullStream extends event_emitter_1.EventEmitter {
      * Get remaining buffer length
      */
     get length() {
-        return this._totalLength;
+        return this._bufferWriteIndex - this._bufferReadIndex;
     }
     /**
      * Check if stream is finished
@@ -178,13 +242,13 @@ class PullStream extends event_emitter_1.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/cjs/modules/stream/shared.js

@@ -66,7 +66,7 @@ function uint8ArrayToString(arr, encoding) {
 /**
  * Concatenate multiple Uint8Arrays efficiently
  */
-function concatUint8Arrays(arrays) {
+function concatUint8Arrays(arrays, totalLength) {
     const len = arrays.length;
     if (len === 0) {
         return new Uint8Array(0);
@@ -75,9 +75,12 @@ 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;