@cj-tech-master/excelts 4.2.0-canary.20260110080706.375ff37 → 4.2.0-canary.20260110111632.c88c61c

package/dist/esm/modules/excel/xlsx/xform/sheet/worksheet-xform.js

@@ -290,8 +290,10 @@ class WorkSheetXform extends BaseXform {
             for (const control of model.formControls) {
                 const globalCtrlPropId = options.formControlRefs.length + 1;
                 control.ctrlPropId = globalCtrlPropId;
+                const relId = nextRid(rels);
+                control.ctrlPropRelId = relId;
                 rels.push({
-                    Id: nextRid(rels),
+                    Id: relId,
                     Type: RelType.CtrlProp,
                     Target: ctrlPropRelTargetFromWorksheet(globalCtrlPropId)
                 });
@@ -354,15 +356,27 @@ class WorkSheetXform extends BaseXform {
         this.map.drawing.render(xmlStream, model.drawing); // Note: must be after rowBreaks/colBreaks
         this.map.picture.render(xmlStream, model.background); // Note: must be after drawing
         this.map.tableParts.render(xmlStream, model.tables);
-        this.map.extLst.render(xmlStream, model);
+        // Controls section for legacy form controls (checkboxes, etc.)
+        // Excel expects <controls> entries that reference ctrlProp relationships.
+        if (model.formControls && model.formControls.length > 0) {
+            xmlStream.openNode("controls");
+            for (const control of model.formControls) {
+                if (control.ctrlPropRelId) {
+                    xmlStream.leafNode("control", { shapeId: control.shapeId, "r:id": control.ctrlPropRelId });
+                }
+            }
+            xmlStream.closeNode();
+        }
         if (model.rels) {
-            // add a <legacyDrawing /> node for each comment
+            // Add a <legacyDrawing /> node for each VML drawing relationship (comments and/or form controls).
             model.rels.forEach(rel => {
                 if (rel.Type === RelType.VmlDrawing) {
                     xmlStream.leafNode("legacyDrawing", { "r:id": rel.Id });
                 }
             });
         }
+        // extLst should be the last element in the worksheet.
+        this.map.extLst.render(xmlStream, model);
         xmlStream.closeNode();
     }
     parseOpen(node) {

package/dist/esm/modules/stream/streams.browser.js

@@ -384,55 +384,58 @@ export class Readable extends EventEmitter {
         // causing `instanceof Transform/Writable/Duplex` to fail even when the object
         // is a valid destination.
         const dest = destination;
-        // Get the actual writable target.
-        // Prefer internal `_writable` (Transform/Duplex wrappers), else treat the destination as writable-like.
-        const candidate = dest?._writable ?? dest;
-        const hasWrite = typeof candidate?.write === "function";
-        const hasEnd = typeof candidate?.end === "function";
-        const hasOn = typeof candidate?.on === "function";
-        const hasOnce = typeof candidate?.once === "function";
-        const hasOff = typeof candidate?.off === "function";
-        if (!hasWrite || !hasEnd || (!hasOnce && !hasOn) || (!hasOff && !candidate?.removeListener)) {
+        // For event handling (drain, once, off), we need the object that emits events.
+        // For write/end, we must call the destination's own write()/end() methods,
+        // NOT the internal _writable, because Transform.write() has important logic
+        // (like auto-consume) that _writable.write() bypasses.
+        const eventTarget = dest;
+        const hasWrite = typeof dest?.write === "function";
+        const hasEnd = typeof dest?.end === "function";
+        const hasOn = typeof eventTarget?.on === "function";
+        const hasOnce = typeof eventTarget?.once === "function";
+        const hasOff = typeof eventTarget?.off === "function";
+        if (!hasWrite || !hasEnd || (!hasOnce && !hasOn) || (!hasOff && !eventTarget?.removeListener)) {
             throw new Error("Readable.pipe: invalid destination");
         }
-        const target = candidate;
-        this._pipeTo.push(target);
+        this._pipeTo.push(dest);
         // Create listeners that we can later remove
         const dataListener = (chunk) => {
-            const canWrite = target.write(chunk);
+            // Call destination's write() method (not internal _writable.write())
+            // This ensures Transform.write() logic runs properly
+            const canWrite = dest.write(chunk);
             if (!canWrite) {
                 this.pause();
-                if (typeof target.once === "function") {
-                    target.once("drain", () => this.resume());
+                if (typeof eventTarget.once === "function") {
+                    eventTarget.once("drain", () => this.resume());
                 }
                 else {
                     const resumeOnce = () => {
-                        if (typeof target.off === "function") {
-                            target.off("drain", resumeOnce);
+                        if (typeof eventTarget.off === "function") {
+                            eventTarget.off("drain", resumeOnce);
                         }
-                        else if (typeof target.removeListener === "function") {
-                            target.removeListener("drain", resumeOnce);
+                        else if (typeof eventTarget.removeListener === "function") {
+                            eventTarget.removeListener("drain", resumeOnce);
                         }
                         this.resume();
                     };
-                    target.on("drain", resumeOnce);
+                    eventTarget.on("drain", resumeOnce);
                 }
             }
         };
         const endListener = () => {
-            target.end();
+            dest.end();
         };
         const errorListener = (err) => {
-            if (typeof target.destroy === "function") {
-                target.destroy(err);
+            if (typeof dest.destroy === "function") {
+                dest.destroy(err);
             }
             else {
                 // Best-effort: forward error to the destination if it supports events.
-                target.emit?.("error", err);
+                eventTarget.emit?.("error", err);
             }
         };
         // Store listeners for later removal in unpipe
-        this._pipeListeners.set(target, {
+        this._pipeListeners.set(dest, {
             data: dataListener,
             end: endListener,
             error: errorListener
@@ -1358,6 +1361,8 @@ export class Transform extends EventEmitter {
         this._autoConsumeEnded = false;
         /** @internal - promise that resolves when auto-consume finishes */
         this._autoConsumePromise = null;
+        /** @internal - list of piped destinations for forwarding auto-consumed data */
+        this._pipeDestinations = [];
         this.objectMode = options?.objectMode ?? false;
         const userTransform = options?.transform;
         const userFlush = options?.flush;
@@ -1624,10 +1629,18 @@ export class Transform extends EventEmitter {
                 for await (const chunk of this._readable) {
                     // Buffer the data for later retrieval
                     this._autoConsumedBuffer.push(chunk);
+                    // Forward to any piped destinations
+                    for (const dest of this._pipeDestinations) {
+                        dest.write(chunk);
+                    }
                     // Also emit data event for listeners
                     this.emit("data", chunk);
                 }
                 this._autoConsumeEnded = true;
+                // End all piped destinations
+                for (const dest of this._pipeDestinations) {
+                    dest.end();
+                }
                 this.emit("end");
             }
             catch (err) {
@@ -1677,8 +1690,28 @@ export class Transform extends EventEmitter {
      * Pipe to another stream (writable, transform, or duplex)
      */
     pipe(destination) {
-        // Mark as having consumer to prevent auto-consume conflict
+        // Mark as having consumer to prevent new auto-consume from starting
         this._hasDataConsumer = true;
+        // Get the writable target - handle both Transform (with internal _writable) and plain Writable
+        const dest = destination;
+        const target = dest?._writable ?? dest;
+        // Register destination for forwarding
+        this._pipeDestinations.push(target);
+        // If auto-consume is running or has run, we need to handle buffered data ourselves
+        if (this._readableConsuming) {
+            // Forward any buffered data from auto-consume to the destination
+            for (let i = 0; i < this._autoConsumedBuffer.length; i++) {
+                target.write(this._autoConsumedBuffer[i]);
+            }
+            // If auto-consume has ended, end the destination too
+            if (this._autoConsumeEnded) {
+                target.end();
+            }
+            // Don't call _readable.pipe() - auto-consume already consumed _readable
+            // Future data will be forwarded via the 'data' event listener below
+            return destination;
+        }
+        // No auto-consume running - use normal pipe through _readable
         return this._readable.pipe(destination);
     }
     /**

package/dist/iife/excelts.iife.js

@@ -1,5 +1,5 @@
 /*!
- * @cj-tech-master/excelts v4.2.0-canary.20260110080706.375ff37
+ * @cj-tech-master/excelts v4.2.0-canary.20260110111632.c88c61c
  * TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.
  * (c) 2026 cjnoname
  * Released under the MIT License
@@ -2767,9 +2767,24 @@ var ExcelTS = (function(exports) {
 		_parseRange(range$1) {
 			let tl;
 			let br;
-			if (typeof range$1 === "string") {
+			if (typeof range$1 === "string") if (range$1.includes(":")) {
 				const decoded = colCache.decode(range$1);
-				if ("top" in decoded) {
+				if ("top" in decoded) if (decoded.left === decoded.right && decoded.top === decoded.bottom) {
+					const col = decoded.left - 1;
+					const row = decoded.top - 1;
+					tl = {
+						col,
+						colOff: DEFAULT_COL_OFF,
+						row,
+						rowOff: DEFAULT_ROW_OFF
+					};
+					br = {
+						col: col + 2,
+						colOff: DEFAULT_END_COL_OFF,
+						row: row + 1,
+						rowOff: DEFAULT_END_ROW_OFF
+					};
+				} else {
 					tl = {
 						col: decoded.left - 1,
 						colOff: DEFAULT_COL_OFF,
@@ -2782,7 +2797,8 @@ var ExcelTS = (function(exports) {
 						row: decoded.bottom - 1,
 						rowOff: DEFAULT_END_ROW_OFF
 					};
-				} else {
+				}
+				else {
 					tl = {
 						col: decoded.col - 1,
 						colOff: DEFAULT_COL_OFF,
@@ -2796,7 +2812,22 @@ var ExcelTS = (function(exports) {
 						rowOff: DEFAULT_END_ROW_OFF
 					};
 				}
-			} else if ("startCol" in range$1) {
+			} else {
+				const decoded = colCache.decodeAddress(range$1);
+				tl = {
+					col: decoded.col - 1,
+					colOff: DEFAULT_COL_OFF,
+					row: decoded.row - 1,
+					rowOff: DEFAULT_ROW_OFF
+				};
+				br = {
+					col: decoded.col + 1,
+					colOff: DEFAULT_END_COL_OFF,
+					row: decoded.row,
+					rowOff: DEFAULT_END_ROW_OFF
+				};
+			}
+			else if ("startCol" in range$1) {
 				tl = {
 					col: range$1.startCol,
 					colOff: range$1.startColOff ?? DEFAULT_COL_OFF,
@@ -3550,37 +3581,36 @@ var ExcelTS = (function(exports) {
 		*/
 		pipe(destination) {
 			const dest = destination;
-			const candidate = dest?._writable ?? dest;
-			const hasWrite = typeof candidate?.write === "function";
-			const hasEnd = typeof candidate?.end === "function";
-			const hasOn = typeof candidate?.on === "function";
-			const hasOnce = typeof candidate?.once === "function";
-			const hasOff = typeof candidate?.off === "function";
-			if (!hasWrite || !hasEnd || !hasOnce && !hasOn || !hasOff && !candidate?.removeListener) throw new Error("Readable.pipe: invalid destination");
-			const target = candidate;
-			this._pipeTo.push(target);
+			const eventTarget = dest;
+			const hasWrite = typeof dest?.write === "function";
+			const hasEnd = typeof dest?.end === "function";
+			const hasOn = typeof eventTarget?.on === "function";
+			const hasOnce = typeof eventTarget?.once === "function";
+			const hasOff = typeof eventTarget?.off === "function";
+			if (!hasWrite || !hasEnd || !hasOnce && !hasOn || !hasOff && !eventTarget?.removeListener) throw new Error("Readable.pipe: invalid destination");
+			this._pipeTo.push(dest);
 			const dataListener = (chunk) => {
-				if (!target.write(chunk)) {
+				if (!dest.write(chunk)) {
 					this.pause();
-					if (typeof target.once === "function") target.once("drain", () => this.resume());
+					if (typeof eventTarget.once === "function") eventTarget.once("drain", () => this.resume());
 					else {
 						const resumeOnce = () => {
-							if (typeof target.off === "function") target.off("drain", resumeOnce);
-							else if (typeof target.removeListener === "function") target.removeListener("drain", resumeOnce);
+							if (typeof eventTarget.off === "function") eventTarget.off("drain", resumeOnce);
+							else if (typeof eventTarget.removeListener === "function") eventTarget.removeListener("drain", resumeOnce);
 							this.resume();
 						};
-						target.on("drain", resumeOnce);
+						eventTarget.on("drain", resumeOnce);
 					}
 				}
 			};
 			const endListener = () => {
-				target.end();
+				dest.end();
 			};
 			const errorListener = (err) => {
-				if (typeof target.destroy === "function") target.destroy(err);
-				else target.emit?.("error", err);
+				if (typeof dest.destroy === "function") dest.destroy(err);
+				else eventTarget.emit?.("error", err);
 			};
-			this._pipeListeners.set(target, {
+			this._pipeListeners.set(dest, {
 				data: dataListener,
 				end: endListener,
 				error: errorListener
@@ -4299,6 +4329,7 @@ var ExcelTS = (function(exports) {
 			this._autoConsumedBufferIndex = 0;
 			this._autoConsumeEnded = false;
 			this._autoConsumePromise = null;
+			this._pipeDestinations = [];
 			this.objectMode = options?.objectMode ?? false;
 			const userTransform = options?.transform;
 			const userFlush = options?.flush;
@@ -4473,9 +4504,11 @@ var ExcelTS = (function(exports) {
 				try {
 					for await (const chunk of this._readable) {
 						this._autoConsumedBuffer.push(chunk);
+						for (const dest of this._pipeDestinations) dest.write(chunk);
 						this.emit("data", chunk);
 					}
 					this._autoConsumeEnded = true;
+					for (const dest of this._pipeDestinations) dest.end();
 					this.emit("end");
 				} catch (err) {
 					this.emit("error", err);
@@ -4509,6 +4542,14 @@ var ExcelTS = (function(exports) {
 		*/
 		pipe(destination) {
 			this._hasDataConsumer = true;
+			const dest = destination;
+			const target = dest?._writable ?? dest;
+			this._pipeDestinations.push(target);
+			if (this._readableConsuming) {
+				for (let i = 0; i < this._autoConsumedBuffer.length; i++) target.write(this._autoConsumedBuffer[i]);
+				if (this._autoConsumeEnded) target.end();
+				return destination;
+			}
 			return this._readable.pipe(destination);
 		}
 		/**
@@ -5008,6 +5049,68 @@ var ExcelTS = (function(exports) {
 		if (callback) promise.then(() => callback(null)).catch((err) => callback(err));
 		return promise;
 	}
+	/**
+	* Wait for a stream to finish, close, or error.
+	* Node.js compatible with support for options and callbacks.
+	*
+	* @example
+	* // Promise usage
+	* await finished(stream);
+	*
+	* @example
+	* // With options
+	* await finished(stream, { readable: false }); // Only wait for writable side
+	*
+	* @example
+	* // Callback usage
+	* finished(stream, (err) => {
+	*   if (err) console.error('Stream error', err);
+	* });
+	*/
+	function finished(stream, optionsOrCallback, callback) {
+		let options = {};
+		let cb;
+		if (typeof optionsOrCallback === "function") cb = optionsOrCallback;
+		else if (optionsOrCallback) {
+			options = optionsOrCallback;
+			cb = callback;
+		}
+		const promise = new Promise((resolve, reject) => {
+			const normalizedStream = toBrowserPipelineStream(stream);
+			let resolved = false;
+			const done = (err) => {
+				if (resolved) return;
+				resolved = true;
+				if (err && !options.error) reject(err);
+				else resolve();
+			};
+			if (options.signal) {
+				if (options.signal.aborted) {
+					done(/* @__PURE__ */ new Error("Aborted"));
+					return;
+				}
+				options.signal.addEventListener("abort", () => {
+					done(/* @__PURE__ */ new Error("Aborted"));
+				});
+			}
+			const checkReadable = options.readable !== false;
+			const checkWritable = options.writable !== false;
+			if (checkReadable && normalizedStream.readableEnded) {
+				done();
+				return;
+			}
+			if (checkWritable && normalizedStream.writableFinished) {
+				done();
+				return;
+			}
+			if (checkWritable) normalizedStream.on("finish", () => done());
+			if (checkReadable) normalizedStream.on("end", () => done());
+			normalizedStream.on("error", (err) => done(err));
+			normalizedStream.on("close", () => done());
+		});
+		if (cb) promise.then(() => cb(null)).catch((err) => cb(err));
+		return promise;
+	}
 
 //#endregion
 //#region src/modules/excel/utils/encryptor.browser.ts
@@ -13625,8 +13728,10 @@ var ExcelTS = (function(exports) {
 				for (const control of model.formControls) {
 					const globalCtrlPropId = options.formControlRefs.length + 1;
 					control.ctrlPropId = globalCtrlPropId;
+					const relId = nextRid(rels);
+					control.ctrlPropRelId = relId;
 					rels.push({
-						Id: nextRid(rels),
+						Id: relId,
 						Type: RelType.CtrlProp,
 						Target: ctrlPropRelTargetFromWorksheet(globalCtrlPropId)
 					});
@@ -13679,10 +13784,18 @@ var ExcelTS = (function(exports) {
 			this.map.drawing.render(xmlStream, model.drawing);
 			this.map.picture.render(xmlStream, model.background);
 			this.map.tableParts.render(xmlStream, model.tables);
-			this.map.extLst.render(xmlStream, model);
+			if (model.formControls && model.formControls.length > 0) {
+				xmlStream.openNode("controls");
+				for (const control of model.formControls) if (control.ctrlPropRelId) xmlStream.leafNode("control", {
+					shapeId: control.shapeId,
+					"r:id": control.ctrlPropRelId
+				});
+				xmlStream.closeNode();
+			}
 			if (model.rels) model.rels.forEach((rel) => {
 				if (rel.Type === RelType.VmlDrawing) xmlStream.leafNode("legacyDrawing", { "r:id": rel.Id });
 			});
+			this.map.extLst.render(xmlStream, model);
 			xmlStream.closeNode();
 		}
 		parseOpen(node) {
@@ -17886,17 +17999,10 @@ var ExcelTS = (function(exports) {
 	* Default threshold (in bytes) to choose the lower-overhead path.
 	*
 	* This is a performance knob, not a correctness requirement.
+	* Default: 8MB.
 	*/
 	const DEFAULT_COMPRESS_THRESHOLD_BYTES = 8 * 1024 * 1024;
 	/**
-	* Resolve the effective threshold bytes.
-	*/
-	function resolveCompressThresholdBytes(options) {
-		const value = options.thresholdBytes;
-		if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return DEFAULT_COMPRESS_THRESHOLD_BYTES;
-		return value;
-	}
-	/**
 	* Non-cached probe for CompressionStream("deflate-raw") support.
 	*
 	* Prefer this in code paths that want up-to-date environment checks
@@ -18775,12 +18881,16 @@ var ExcelTS = (function(exports) {
 	/**
 	* Decompress data using browser's native DecompressionStream or JS fallback
 	*
+	* Note: We always prefer native DecompressionStream when available because
+	* it's significantly faster than pure JS implementation, regardless of data size.
+	* The threshold is only useful for compression where the overhead matters more.
+	*
 	* @param data - Compressed data (deflate-raw format)
+	* @param options - Decompression options (kept for API parity; currently unused in browser)
 	* @returns Decompressed data
 	*/
 	async function decompress(data, options = {}) {
-		const thresholdBytes = resolveCompressThresholdBytes(options);
-		if (hasDeflateRawDecompressionStream() && data.byteLength > thresholdBytes) return decompressWithStream(data);
+		if (hasDeflateRawDecompressionStream()) return decompressWithStream(data);
 		return inflateRaw(data);
 	}
 	/**
@@ -19483,8 +19593,13 @@ var ExcelTS = (function(exports) {
 		queueMicrotask(pull);
 		return output;
 	}
+	/**
+	* Default threshold for small file optimization (5MB).
+	*/
+	const DEFAULT_PARSE_THRESHOLD_BYTES = 5 * 1024 * 1024;
 	const endDirectorySignature = writeUint32LE(END_OF_CENTRAL_DIR_SIG);
-	async function runParseLoop(opts, io, emitter, inflateFactory, state) {
+	async function runParseLoop(opts, io, emitter, inflateFactory, state, inflateRawSync) {
+		const thresholdBytes = opts.thresholdBytes ?? DEFAULT_PARSE_THRESHOLD_BYTES;
 		while (true) {
 			const sigBytes = await io.pull(4);
 			if (sigBytes.length === 0) {
@@ -19498,7 +19613,7 @@ var ExcelTS = (function(exports) {
 				continue;
 			}
 			if (signature === LOCAL_FILE_HEADER_SIG) {
-				await readFileRecord(opts, io, emitter, inflateFactory, state);
+				await readFileRecord(opts, io, emitter, inflateFactory, state, thresholdBytes, inflateRawSync);
 				continue;
 			}
 			if (signature === CENTRAL_DIR_HEADER_SIG) {
@@ -19524,7 +19639,7 @@ var ExcelTS = (function(exports) {
 			return;
 		}
 	}
-	async function readFileRecord(opts, io, emitter, inflateFactory, state) {
+	async function readFileRecord(opts, io, emitter, inflateFactory, state, thresholdBytes, inflateRawSync) {
 		const { vars: headerVars, fileNameBuffer, extraFieldData } = await readLocalFileHeader(async (l) => io.pull(l));
 		const vars = headerVars;
 		if (state.crxHeader) vars.crxHeader = state.crxHeader;
@@ -19564,6 +19679,15 @@ var ExcelTS = (function(exports) {
 			vars,
 			extraFields: entry.extraFields
 		});
+		const sizesTrusted = !hasDataDescriptorFlag(vars.flags);
+		const compressedSize = vars.compressedSize || 0;
+		const uncompressedSize = vars.uncompressedSize || 0;
+		if (sizesTrusted && fileSizeKnown && inflateRawSync && vars.compressionMethod !== 0 && !autodraining && compressedSize <= thresholdBytes && uncompressedSize <= thresholdBytes) {
+			const decompressedData = inflateRawSync(await io.pull(compressedSize));
+			entry.end(decompressedData);
+			await finished(entry, { readable: false });
+			return;
+		}
 		const inflater = vars.compressionMethod && !autodraining ? inflateFactory() : new PassThrough();
 		if (fileSizeKnown) {
 			await pipeline(io.stream(vars.compressedSize || 0), inflater, entry);