@cj-tech-master/excelts 7.0.0 → 7.0.1

package/dist/cjs/modules/archive/unzip/stream.base.js

@@ -11,6 +11,46 @@ const byte_queue_1 = require("../shared/byte-queue.js");
 const bytes_1 = require("../shared/bytes.js");
 const text_1 = require("../shared/text.js");
 const pattern_scanner_1 = require("./pattern-scanner.js");
+/**
+ * Returns true when `err` is the Node.js ERR_STREAM_PREMATURE_CLOSE error.
+ *
+ * This error is emitted by `finished()` / `pipeline()` when a stream is
+ * destroyed before it has properly ended (e.g. a consumer breaks out of a
+ * `for await` loop, or the entry PassThrough is destroyed by an external
+ * consumer). In the context of ZIP parsing, a premature close on an *entry*
+ * stream is not a fatal error — the parse loop only needs to advance the ZIP
+ * cursor past the entry's compressed data.
+ */
+function isPrematureCloseError(err) {
+    if (!(err instanceof Error)) {
+        return false;
+    }
+    return err.code === "ERR_STREAM_PREMATURE_CLOSE" || err.message === "Premature close";
+}
+/**
+ * Wait for an entry's writable side to finish, tolerating premature close.
+ *
+ * The parse loop calls this after pumping all compressed data into an entry.
+ * It ensures the decompressed data has been flushed through the inflater →
+ * entry pipeline before advancing the ZIP cursor.
+ *
+ * If the consumer has already destroyed / autodraining the entry (e.g. early
+ * break, external destroy, Readable.from() wrapper), `finished()` rejects
+ * with ERR_STREAM_PREMATURE_CLOSE. This is not an error for the parse loop
+ * — the compressed data has been fully read from the ZIP cursor, so we
+ * can safely continue.
+ */
+async function awaitEntryCompletion(entry) {
+    try {
+        await (0, _stream_1.finished)(entry, { readable: false });
+    }
+    catch (err) {
+        if (!isPrematureCloseError(err)) {
+            throw err;
+        }
+        // Entry was destroyed/autodraining — treat as normal completion.
+    }
+}
 const parser_core_1 = require("./parser-core.js");
 exports.DEFAULT_UNZIP_STREAM_HIGH_WATER_MARK = 256 * 1024;
 function autodrain(stream) {
@@ -423,6 +463,7 @@ function streamUntilValidatedDataDescriptor(options) {
         }
         while (available > 0) {
             // Try to find and validate a descriptor candidate.
+            let pendingCandidate = false;
             while (true) {
                 const idx = scanner.find(source);
                 if (idx === -1) {
@@ -480,15 +521,67 @@ function streamUntilValidatedDataDescriptor(options) {
                     scanner.searchFrom = idx + 1;
                     continue;
                 }
-                // Not enough bytes to validate yet. Re-check this candidate once more bytes arrive.
+                // Not enough bytes to validate yet. Re-check this candidate once
+                // more bytes arrive. Mark as pending so we don't accidentally
+                // advance searchFrom past it via onNoMatch().
                 scanner.searchFrom = idx;
+                pendingCandidate = true;
+                // If the source is finished (no more bytes will arrive), attempt a
+                // relaxed validation: accept the descriptor without checking the
+                // next-record signature. This handles the case where the descriptor
+                // is at the very end of the available data (e.g. the last entry in
+                // the ZIP, or the next-record header hasn't been fully buffered yet
+                // due to extreme input fragmentation).
+                if (source.isFinished() && idx + 16 <= available) {
+                    const descriptorCompressedSize = source.peekUint32LE(idx + 8);
+                    const expectedCompressedSize = (bytesEmitted + idx) >>> 0;
+                    if (descriptorCompressedSize !== null &&
+                        descriptorCompressedSize === expectedCompressedSize) {
+                        // Descriptor compressed size matches — accept it.
+                        if (idx > 0) {
+                            if (source.peekChunks && source.discard) {
+                                const parts = source.peekChunks(idx);
+                                let written = 0;
+                                for (const part of parts) {
+                                    output.write(part);
+                                    written += part.length;
+                                }
+                                if (written > 0) {
+                                    source.discard(written);
+                                    bytesEmitted += written;
+                                    scanner.onConsume(written);
+                                }
+                            }
+                            else {
+                                output.write(source.read(idx));
+                                bytesEmitted += idx;
+                                scanner.onConsume(idx);
+                            }
+                        }
+                        done = true;
+                        source.maybeReleaseWriteCallback?.();
+                        cleanup();
+                        output.end();
+                        return;
+                    }
+                }
                 break;
             }
-            // No validated match yet.
-            scanner.onNoMatch(available);
+            // Only advance the scanner's search cursor when there is no pending
+            // candidate waiting for more bytes. Without this guard, onNoMatch()
+            // would move searchFrom past the candidate, causing it to be skipped
+            // and the entry data to be flushed — leading to FILE_ENDED.
+            if (!pendingCandidate) {
+                scanner.onNoMatch(available);
+            }
             // Flush most of the buffered data but keep a tail so a potential signature
             // split across chunks can still be detected/validated.
-            const flushLen = Math.max(0, available - keepTailBytes);
+            // When a pending candidate exists, do NOT flush past it.
+            let maxFlush = available - keepTailBytes;
+            if (pendingCandidate) {
+                maxFlush = Math.min(maxFlush, scanner.searchFrom);
+            }
+            const flushLen = Math.max(0, maxFlush);
             if (flushLen > 0) {
                 if (source.peekChunks && source.discard) {
                     const parts = source.peekChunks(flushLen);
@@ -681,7 +774,7 @@ async function pumpKnownCompressedSizeToEntry(io, inflater, entry, compressedSiz
             inflater.end();
         }
         // Wait for all writes to complete (not for consumption).
-        await (0, _stream_1.finished)(entry, { readable: false });
+        await awaitEntryCompletion(entry);
     }
     finally {
         inflater.removeListener("error", onError);
@@ -795,8 +888,8 @@ async function readFileRecord(opts, io, emitter, inflateFactory, state, threshol
         const compressedData = await io.pull(compressedSize);
         const decompressedData = inflateRawSync(compressedData);
         entry.end(decompressedData);
-        // Wait for entry stream write to complete (not for read/consume)
-        await (0, _stream_1.finished)(entry, { readable: false });
+        // Wait for entry stream write to complete (not for read/consume).
+        await awaitEntryCompletion(entry);
         return;
     }
     const inflater = needsInflate
@@ -815,7 +908,30 @@ async function readFileRecord(opts, io, emitter, inflateFactory, state, threshol
         }
         return;
     }
-    await (0, _stream_1.pipeline)(io.streamUntilDataDescriptor(), inflater, entry);
+    // pipeline() destroys all streams if any stream errors or closes early.
+    // If the entry was destroyed by the consumer, pipeline rejects with
+    // ERR_STREAM_PREMATURE_CLOSE. This typically happens when the entry's
+    // writable side is force-destroyed and the entire parse operation is
+    // being torn down (abort/error).
+    try {
+        await (0, _stream_1.pipeline)(io.streamUntilDataDescriptor(), inflater, entry);
+    }
+    catch (pipelineErr) {
+        if (!isPrematureCloseError(pipelineErr)) {
+            throw pipelineErr;
+        }
+        // Entry was destroyed — attempt to read the data descriptor; if it
+        // fails (cursor misaligned), swallow the error since the entry was
+        // abandoned and the operation is ending.
+        try {
+            const dd = await (0, parser_core_1.readDataDescriptor)(async (l) => io.pull(l));
+            entry.size = dd.uncompressedSize ?? 0;
+        }
+        catch {
+            // Cursor misaligned — not recoverable but not worth surfacing.
+        }
+        return;
+    }
     const dd = await (0, parser_core_1.readDataDescriptor)(async (l) => io.pull(l));
     entry.size = dd.uncompressedSize ?? 0;
 }

package/dist/cjs/modules/archive/unzip/stream.browser.js

@@ -493,7 +493,26 @@ function createParseClass(createInflateRawFn) {
             this.finished = false;
             this._driverState = {};
             this._parsingDone = Promise.resolve();
+            // ---------------------------------------------------------------
+            // Parser completion — explicit deferred, independent of stream
+            // lifecycle events. Mirrors the Node.js Parse implementation.
+            // ---------------------------------------------------------------
+            this._parserDoneFlag = false;
+            this._parserError = null;
+            this._parserDeferred = null;
+            this._parserDonePromise = null;
+            // ---------------------------------------------------------------
+            // Entry queue — custom [Symbol.asyncIterator] reads from here.
+            // ---------------------------------------------------------------
+            this._entryQueue = [];
+            this._entryWaiter = null;
+            this._entriesDone = false;
             this._opts = opts;
+            // Route error events to the parser deferred.
+            this.on("error", (err) => {
+                this._rejectParserDeferred(err);
+                this._closeEntryQueue(err);
+            });
             // Default values are intentionally conservative to avoid memory spikes
             // when parsing large archives under slow consumers.
             const hi = Math.max(64 * 1024, opts.inputHighWaterMarkBytes ?? 2 * 1024 * 1024);
@@ -515,10 +534,13 @@ function createParseClass(createInflateRawFn) {
                 },
                 pushEntry: (entry) => {
                     this.push(entry);
+                    this._enqueueEntry(entry);
                 },
                 // Browser version historically only pushed entries when forceStream=true.
                 // Keep this behavior to avoid changing stream piping semantics.
                 pushEntryIfPiped: (_entry) => {
+                    // Always feed the entry queue regardless of pipe state.
+                    this._enqueueEntry(_entry);
                     return;
                 },
                 emitCrxHeader: (header) => {
@@ -527,12 +549,6 @@ function createParseClass(createInflateRawFn) {
                 },
                 emitError: (err) => {
                     this.__emittedError = err;
-                    // Ensure upstream writers don't hang waiting for a deferred write callback.
-                    if (this._writeCb) {
-                        const cb = this._writeCb;
-                        this._writeCb = undefined;
-                        cb(err);
-                    }
                     this.emit("error", err);
                 },
                 emitClose: () => {
@@ -561,11 +577,22 @@ function createParseClass(createInflateRawFn) {
                 this._parsingDone = (0, stream_base_1.runParseLoop)(this._opts, io, emitter, inflateFactory, this._driverState
                 // No inflateRawSync - always use streaming DecompressionStream in browser
                 );
-                this._parsingDone.catch((e) => {
+                this._parsingDone.then(() => {
+                    if (this.__emittedError) {
+                        this._rejectParserDeferred(this.__emittedError);
+                        this._closeEntryQueue(this.__emittedError);
+                    }
+                    else {
+                        this._resolveParserDeferred();
+                        this._closeEntryQueue();
+                    }
+                }, (e) => {
                     if (!this.__emittedError || this.__emittedError !== e) {
                         this.__emittedError = e;
                         this.emit("error", e);
                     }
+                    this._rejectParserDeferred(e);
+                    this._closeEntryQueue(e);
                     this.emit("close");
                 });
             });
@@ -869,11 +896,99 @@ function createParseClass(createInflateRawFn) {
             });
         }
         promise() {
-            return new Promise((resolve, reject) => {
-                this.on("finish", resolve);
-                this.on("end", resolve);
-                this.on("error", reject);
+            if (this._parserDoneFlag) {
+                return this._parserError ? Promise.reject(this._parserError) : Promise.resolve();
+            }
+            if (this._parserDonePromise) {
+                return this._parserDonePromise;
+            }
+            this._parserDonePromise = new Promise((resolve, reject) => {
+                this._parserDeferred = { resolve, reject };
             });
+            return this._parserDonePromise;
+        }
+        // ---------------------------------------------------------------
+        // Parser completion deferred
+        // ---------------------------------------------------------------
+        _resolveParserDeferred() {
+            if (this._parserDoneFlag) {
+                return;
+            }
+            this._parserDoneFlag = true;
+            if (this._parserDeferred) {
+                const { resolve } = this._parserDeferred;
+                this._parserDeferred = null;
+                resolve();
+            }
+        }
+        _rejectParserDeferred(err) {
+            if (this._parserDoneFlag) {
+                return;
+            }
+            this._parserDoneFlag = true;
+            this._parserError = err;
+            if (this._parserDeferred) {
+                const { reject } = this._parserDeferred;
+                this._parserDeferred = null;
+                reject(err);
+            }
+        }
+        // ---------------------------------------------------------------
+        // Entry queue management
+        // ---------------------------------------------------------------
+        _enqueueEntry(entry) {
+            if (this._entryWaiter) {
+                const { resolve } = this._entryWaiter;
+                this._entryWaiter = null;
+                resolve({ value: entry, done: false });
+            }
+            else {
+                this._entryQueue.push(entry);
+            }
+        }
+        _closeEntryQueue(err) {
+            this._entriesDone = true;
+            if (this._entryWaiter) {
+                const waiter = this._entryWaiter;
+                this._entryWaiter = null;
+                if (err) {
+                    waiter.reject(err);
+                }
+                else {
+                    waiter.resolve({ value: undefined, done: true });
+                }
+            }
+        }
+        // ---------------------------------------------------------------
+        // Custom async iterator
+        // ---------------------------------------------------------------
+        [Symbol.asyncIterator]() {
+            const iterator = {
+                next: () => {
+                    if (this._entryQueue.length > 0) {
+                        return Promise.resolve({ value: this._entryQueue.shift(), done: false });
+                    }
+                    if (this._entriesDone) {
+                        if (this._parserError) {
+                            return Promise.reject(this._parserError);
+                        }
+                        return Promise.resolve({ value: undefined, done: true });
+                    }
+                    return new Promise((resolve, reject) => {
+                        this._entryWaiter = { resolve, reject };
+                    });
+                },
+                return: () => {
+                    this._entriesDone = true;
+                    this._entryQueue.length = 0;
+                    this._entryWaiter = null;
+                    return Promise.resolve({ value: undefined, done: true });
+                },
+                [Symbol.asyncIterator]() {
+                    return iterator;
+                }
+            };
+            return iterator;
         }
     };
 }

package/dist/cjs/modules/archive/unzip/stream.js

@@ -21,29 +21,38 @@ function createParseClass(createInflateRawFn) {
         constructor(opts = {}) {
             super(opts);
             this._driverState = {};
-            this._done = false;
-            this._doneError = null;
-            this._donePromise = null;
-            this._doneDeferred = null;
+            // ---------------------------------------------------------------
+            // Parser completion — explicit deferred, independent of stream
+            // lifecycle events (close / end). This avoids races between
+            // push(null) and close that cause ERR_STREAM_PREMATURE_CLOSE in
+            // Node.js's default Readable async iterator.
+            // ---------------------------------------------------------------
+            this._parserDone = false;
+            this._parserError = null;
+            this._parserDeferred = null;
+            this._parserDonePromise = null;
+            // ---------------------------------------------------------------
+            // Entry queue — custom [Symbol.asyncIterator] reads from here
+            // instead of relying on Readable's default objectMode iterator
+            // (which uses finished() internally and races with close).
+            // ---------------------------------------------------------------
+            this._entryQueue = [];
+            this._entryWaiter = null;
+            /** True once the parser has finished producing entries. */
+            this._entriesDone = false;
             this._opts = opts;
-            // Latch completion early to avoid missing terminal events, but do NOT
-            // create a Promise eagerly (it can reject unhandled in tests/consumers
-            // that never call `promise()`).
-            const onDone = () => this._latchDone();
-            const onError = (err) => this._latchError(err);
-            this.on("close", onDone);
-            this.on("end", onDone);
-            this.on("error", onError);
+            // Always listen for error events to prevent Node.js from treating
+            // them as uncaught exceptions. Route them to the parser deferred.
+            this.on("error", (err) => {
+                this._rejectParser(err);
+                this._closeEntryQueue(err);
+            });
             const io = {
                 pull: async (length) => this.pull(length),
                 pullUntil: async (pattern, includeEof) => this.pull(pattern, includeEof),
                 stream: (length) => this.stream(length),
                 streamUntilDataDescriptor: () => this._streamUntilValidatedDataDescriptor(),
                 setDone: () => {
-                    // If the parser reaches EOF without consuming all buffered bytes,
-                    // there may still be an in-flight writable callback waiting on
-                    // `_maybeReleaseWriteCallback()`. Release it to avoid deadlocks in
-                    // callers that await `write(..., cb)`.
                     this._maybeReleaseWriteCallback();
                     this.end();
                     this.push(null);
@@ -54,36 +63,119 @@ function createParseClass(createInflateRawFn) {
                     this.emit("entry", entry);
                 },
                 pushEntry: (entry) => {
+                    // Feed the legacy Readable objectMode side (for pipe / data consumers).
                     this.push(entry);
+                    // Also feed the custom entry queue (for our async iterator).
+                    this._enqueueEntry(entry);
                 },
                 pushEntryIfPiped: (entry) => {
                     const state = this._readableState;
                     if (state.pipesCount || (state.pipes && state.pipes.length)) {
                         this.push(entry);
                     }
+                    // Always feed the entry queue regardless of pipe state.
+                    this._enqueueEntry(entry);
                 },
                 emitCrxHeader: header => {
                     this.crxHeader = header;
                     this.emit("crx-header", header);
                 },
                 emitError: err => {
+                    this.__emittedError = err;
                     this.emit("error", err);
                 },
                 emitClose: () => {
                     this.emit("close");
                 }
             };
-            // Parse records as data arrives. Only emit `close` when parsing is complete.
-            (0, stream_base_1.runParseLoop)(this._opts, io, emitter, createInflateRawFn, this._driverState, (data) => zlib_1.default.inflateRawSync(data)).catch((e) => {
+            // Parse records as data arrives.
+            (0, stream_base_1.runParseLoop)(this._opts, io, emitter, createInflateRawFn, this._driverState, (data) => zlib_1.default.inflateRawSync(data)).then(() => {
+                // If an error was emitted during parsing (e.g. invalid signature),
+                // the parse loop returns normally but we should reject.
+                if (this.__emittedError) {
+                    this._rejectParser(this.__emittedError);
+                    this._closeEntryQueue(this.__emittedError);
+                }
+                else {
+                    this._resolveParser();
+                    this._closeEntryQueue();
+                }
+            }, (e) => {
                 if (!this.__emittedError || this.__emittedError !== e) {
                     this.emit("error", e);
                 }
-                // Best-effort: ensure upstream writers don't hang waiting for a
-                // deferred write callback if parsing terminates early.
                 this._maybeReleaseWriteCallback();
+                this._rejectParser(e);
+                this._closeEntryQueue(e);
                 this.emit("close");
             });
         }
+        // ---------------------------------------------------------------
+        // Entry queue management
+        // ---------------------------------------------------------------
+        _enqueueEntry(entry) {
+            if (this._entryWaiter) {
+                // A consumer is already waiting — deliver immediately.
+                const { resolve } = this._entryWaiter;
+                this._entryWaiter = null;
+                resolve({ value: entry, done: false });
+            }
+            else {
+                this._entryQueue.push(entry);
+            }
+        }
+        _closeEntryQueue(err) {
+            this._entriesDone = true;
+            if (this._entryWaiter) {
+                const waiter = this._entryWaiter;
+                this._entryWaiter = null;
+                if (err) {
+                    waiter.reject(err);
+                }
+                else {
+                    waiter.resolve({ value: undefined, done: true });
+                }
+            }
+        }
+        // ---------------------------------------------------------------
+        // Custom async iterator — bypasses Node Readable's default
+        // iterator which uses finished() and races with close.
+        // ---------------------------------------------------------------
+        // Override the default Readable async iterator with our custom entry-queue
+        // based iterator. This avoids Node.js's Readable default iterator which uses
+        // finished() internally and races with the close event.
+        //
+        // We cast through `any` because ES2024+ AsyncIterator requires
+        // [Symbol.asyncDispose] which AsyncIterableIterator doesn't include,
+        // and we don't need disposal semantics here.
+        [Symbol.asyncIterator]() {
+            const iterator = {
+                next: () => {
+                    if (this._entryQueue.length > 0) {
+                        return Promise.resolve({ value: this._entryQueue.shift(), done: false });
+                    }
+                    if (this._entriesDone) {
+                        if (this._parserError) {
+                            return Promise.reject(this._parserError);
+                        }
+                        return Promise.resolve({ value: undefined, done: true });
+                    }
+                    return new Promise((resolve, reject) => {
+                        this._entryWaiter = { resolve, reject };
+                    });
+                },
+                return: () => {
+                    this._entriesDone = true;
+                    this._entryQueue.length = 0;
+                    this._entryWaiter = null;
+                    return Promise.resolve({ value: undefined, done: true });
+                },
+                [Symbol.asyncIterator]() {
+                    return iterator;
+                }
+            };
+            return iterator;
+        }
         /**
          * Stream file data until we reach a DATA_DESCRIPTOR record boundary.
          */
@@ -106,52 +198,52 @@ function createParseClass(createInflateRawFn) {
                 dataDescriptorSignature
             });
         }
-        promise() {
-            if (this._done) {
-                return this._doneError ? Promise.reject(this._doneError) : Promise.resolve();
-            }
-            if (this._donePromise) {
-                return this._donePromise;
-            }
-            this._donePromise = new Promise((resolve, reject) => {
-                this._doneDeferred = { resolve, reject };
-            });
-            return this._donePromise;
-        }
-        _latchDone() {
-            if (this._done) {
-                return;
-            }
-            this._done = true;
-            const deferred = this._doneDeferred;
-            this._doneDeferred = null;
-            if (!deferred) {
+        // ---------------------------------------------------------------
+        // Parser completion deferred
+        // ---------------------------------------------------------------
+        _resolveParser() {
+            if (this._parserDone) {
                 return;
             }
-            try {
-                deferred.resolve();
-            }
-            catch {
-                // ignore
+            this._parserDone = true;
+            if (this._parserDeferred) {
+                const { resolve } = this._parserDeferred;
+                this._parserDeferred = null;
+                resolve();
             }
         }
-        _latchError(err) {
-            if (this._done) {
+        _rejectParser(err) {
+            if (this._parserDone) {
                 return;
             }
-            this._done = true;
-            this._doneError = err;
-            const deferred = this._doneDeferred;
-            this._doneDeferred = null;
-            if (!deferred) {
-                return;
+            this._parserDone = true;
+            this._parserError = err;
+            if (this._parserDeferred) {
+                const { reject } = this._parserDeferred;
+                this._parserDeferred = null;
+                reject(err);
             }
-            try {
-                deferred.reject(err);
+        }
+        /**
+         * Returns a promise that resolves when the parser has finished
+         * processing all ZIP records, or rejects on parse error.
+         *
+         * This is driven by an internal deferred that is resolved/rejected
+         * directly by the parse loop — it does NOT depend on stream
+         * lifecycle events (close / end), avoiding the
+         * ERR_STREAM_PREMATURE_CLOSE race.
+         */
+        promise() {
+            if (this._parserDone) {
+                return this._parserError ? Promise.reject(this._parserError) : Promise.resolve();
             }
-            catch {
-                // ignore
+            if (this._parserDonePromise) {
+                return this._parserDonePromise;
             }
+            this._parserDonePromise = new Promise((resolve, reject) => {
+                this._parserDeferred = { resolve, reject };
+            });
+            return this._parserDonePromise;
         }
     };
 }