@cj-tech-master/excelts 7.0.0 → 7.0.1

package/dist/iife/excelts.iife.js

@@ -1,5 +1,5 @@
 /*!
-* @cj-tech-master/excelts v7.0.0
+* @cj-tech-master/excelts v7.0.1
 * TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.
 * (c) 2026 cjnoname
 * Released under the MIT License
@@ -36002,6 +36002,40 @@ self.onmessage = async function(event) {
 	}
 	//#endregion
 	//#region src/modules/archive/unzip/stream.base.ts
+	/**
+	* 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 finished(entry, { readable: false });
+		} catch (err) {
+			if (!isPrematureCloseError(err)) throw err;
+		}
+	}
 	const DEFAULT_UNZIP_STREAM_HIGH_WATER_MARK = 256 * 1024;
 	function autodrain(stream) {
 		const draining = stream.pipe(new Transform({ transform(_chunk, _encoding, callback) {
@@ -36061,6 +36095,7 @@ self.onmessage = async function(event) {
 			let available = source.getLength();
 			if (available === 0) source.maybeReleaseWriteCallback?.();
 			while (available > 0) {
+				let pendingCandidate = false;
 				while (true) {
 					const idx = scanner.find(source);
 					if (idx === -1) break;
@@ -36108,10 +36143,41 @@ self.onmessage = async function(event) {
 						continue;
 					}
 					scanner.searchFrom = idx;
+					pendingCandidate = true;
+					if (source.isFinished() && idx + 16 <= available) {
+						const descriptorCompressedSize = source.peekUint32LE(idx + 8);
+						const expectedCompressedSize = bytesEmitted + idx >>> 0;
+						if (descriptorCompressedSize !== null && descriptorCompressedSize === expectedCompressedSize) {
+							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;
 				}
-				scanner.onNoMatch(available);
-				const flushLen = Math.max(0, available - keepTailBytes);
+				if (!pendingCandidate) scanner.onNoMatch(available);
+				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);
@@ -36241,7 +36307,7 @@ self.onmessage = async function(event) {
 				}
 			}
 			if (!skipping) inflater.end();
-			await finished(entry, { readable: false });
+			await awaitEntryCompletion(entry);
 		} finally {
 			inflater.removeListener("error", onError);
 			entry.removeListener("error", onError);
@@ -36308,7 +36374,7 @@ self.onmessage = async function(event) {
 		if (sizesTrusted && fileSizeKnown && inflateRawSync && needsInflate && compressedSize <= thresholdBytes && uncompressedSize <= thresholdBytes) {
 			const decompressedData = inflateRawSync(await io.pull(compressedSize));
 			entry.end(decompressedData);
-			await finished(entry, { readable: false });
+			await awaitEntryCompletion(entry);
 			return;
 		}
 		const inflater = needsInflate ? inflateFactory() : new PassThrough({ highWaterMark: DEFAULT_UNZIP_STREAM_HIGH_WATER_MARK });
@@ -36320,7 +36386,15 @@ self.onmessage = async function(event) {
 			}
 			return;
 		}
-		await pipeline(io.streamUntilDataDescriptor(), inflater, entry);
+		try {
+			await pipeline(io.streamUntilDataDescriptor(), inflater, entry);
+		} catch (pipelineErr) {
+			if (!isPrematureCloseError(pipelineErr)) throw pipelineErr;
+			try {
+				entry.size = (await readDataDescriptor(async (l) => io.pull(l))).uncompressedSize ?? 0;
+			} catch {}
+			return;
+		}
 		entry.size = (await readDataDescriptor(async (l) => io.pull(l))).uncompressedSize ?? 0;
 	}
 	//#endregion
@@ -36702,7 +36776,18 @@ onmessage = async (ev) => {
 				this.finished = false;
 				this._driverState = {};
 				this._parsingDone = Promise.resolve();
+				this._parserDoneFlag = false;
+				this._parserError = null;
+				this._parserDeferred = null;
+				this._parserDonePromise = null;
+				this._entryQueue = [];
+				this._entryWaiter = null;
+				this._entriesDone = false;
 				this._opts = opts;
+				this.on("error", (err) => {
+					this._rejectParserDeferred(err);
+					this._closeEntryQueue(err);
+				});
 				const hi = Math.max(64 * 1024, opts.inputHighWaterMarkBytes ?? 2 * 1024 * 1024);
 				const lo = Math.max(32 * 1024, opts.inputLowWaterMarkBytes ?? Math.floor(hi / 4));
 				this._inputHighWaterMarkBytes = hi;
@@ -36722,19 +36807,17 @@ onmessage = async (ev) => {
 					},
 					pushEntry: (entry) => {
 						this.push(entry);
+						this._enqueueEntry(entry);
+					},
+					pushEntryIfPiped: (_entry) => {
+						this._enqueueEntry(_entry);
 					},
-					pushEntryIfPiped: (_entry) => {},
 					emitCrxHeader: (header) => {
 						this.crxHeader = header;
 						this.emit("crx-header", header);
 					},
 					emitError: (err) => {
 						this.__emittedError = err;
-						if (this._writeCb) {
-							const cb = this._writeCb;
-							this._writeCb = void 0;
-							cb(err);
-						}
 						this.emit("error", err);
 					},
 					emitClose: () => {
@@ -36753,11 +36836,21 @@ onmessage = async (ev) => {
 						return createInflateRawFn();
 					};
 					this._parsingDone = runParseLoop(this._opts, io, emitter, inflateFactory, this._driverState);
-					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");
 					});
 				});
@@ -37009,11 +37102,92 @@ onmessage = async (ev) => {
 				});
 			}
 			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;
+			}
+			_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);
+				}
+			}
+			_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: void 0,
+						done: true
+					});
+				}
+			}
+			[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: void 0,
+								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: void 0,
+							done: true
+						});
+					},
+					[Symbol.asyncIterator]() {
+						return iterator;
+					}
+				};
+				return iterator;
 			}
 		};
 	}