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

package/dist/iife/excelts.iife.js

@@ -1,5 +1,5 @@
 /*!
- * @cj-tech-master/excelts v4.2.1-canary.20260111102127.f808a37
+ * @cj-tech-master/excelts v4.2.1-canary.20260112134913.a3cecdd
  * TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.
  * (c) 2026 cjnoname
  * Released under the MIT License
@@ -3303,12 +3303,15 @@ var ExcelTS = (function(exports) {
 	/**
 	* Concatenate multiple Uint8Arrays efficiently
 	*/
-	function concatUint8Arrays$2(arrays) {
+	function concatUint8Arrays$2(arrays, totalLength) {
 		const len = arrays.length;
 		if (len === 0) return new Uint8Array(0);
 		if (len === 1) return arrays[0];
-		let totalLength = 0;
-		for (let i = 0; i < len; i++) totalLength += arrays[i].length;
+		if (totalLength === void 0) {
+			let sum = 0;
+			for (let i = 0; i < len; i++) sum += arrays[i].length;
+			totalLength = sum;
+		}
 		const result = new Uint8Array(totalLength);
 		let offset = 0;
 		for (let i = 0; i < len; i++) {
@@ -3319,6 +3322,26 @@ var ExcelTS = (function(exports) {
 		return result;
 	}
 
+//#endregion
+//#region src/modules/stream/internal/type-guards.ts
+/**
+	* Lightweight runtime type guards shared across modules.
+	*
+	* Keep this file dependency-free to maximize deduping in bundled builds.
+	*/
+	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);
+	}
+
 //#endregion
 //#region src/modules/stream/streams.browser.ts
 	const removeEmitterListener = (emitter, event, listener) => {
@@ -5128,9 +5151,6 @@ var ExcelTS = (function(exports) {
 			});
 		}
 	};
-	const isReadableStream$1 = (value) => !!value && typeof value === "object" && typeof value.getReader === "function";
-	const isWritableStream$1 = (value) => !!value && typeof value === "object" && typeof value.getWriter === "function";
-	const isTransformStream = (value) => !!value && typeof value === "object" && !!value.readable && !!value.writable && isReadableStream$1(value.readable) && isWritableStream$1(value.writable);
 	const isPipelineOptions = (value) => {
 		if (!value || typeof value !== "object") return false;
 		if (typeof value.pipe === "function" || typeof value.write === "function" || typeof value.end === "function" || typeof value.getReader === "function" || typeof value.getWriter === "function") return false;
@@ -5139,8 +5159,8 @@ var ExcelTS = (function(exports) {
 	const toBrowserPipelineStream = (stream) => {
 		if (stream instanceof Readable || stream instanceof Writable || stream instanceof Transform || stream instanceof Duplex) return stream;
 		if (isTransformStream(stream)) return Transform.fromWeb(stream);
-		if (isReadableStream$1(stream)) return Readable.fromWeb(stream);
-		if (isWritableStream$1(stream)) return Writable.fromWeb(stream);
+		if (isReadableStream(stream)) return Readable.fromWeb(stream);
+		if (isWritableStream(stream)) return Writable.fromWeb(stream);
 		return stream;
 	};
 	/**
@@ -5568,8 +5588,8 @@ var ExcelTS = (function(exports) {
 					footer: .3
 				},
 				orientation: "portrait",
-				horizontalDpi: 4294967295,
-				verticalDpi: 4294967295,
+				horizontalDpi: void 0,
+				verticalDpi: void 0,
 				fitToPage: !!(options.pageSetup && (options.pageSetup.fitToWidth || options.pageSetup.fitToHeight) && !options.pageSetup.scale),
 				pageOrder: "downThenOver",
 				blackAndWhite: false,
@@ -12295,13 +12315,19 @@ var ExcelTS = (function(exports) {
 		get tag() {
 			return "pageSetup";
 		}
+		_dpiToXml(value) {
+			if (value === void 0) return;
+			if (!Number.isFinite(value)) return;
+			if (value === 4294967295) return;
+			return value;
+		}
 		render(xmlStream, model) {
 			if (model) {
 				const attributes = {
 					paperSize: model.paperSize,
 					orientation: model.orientation,
-					horizontalDpi: model.horizontalDpi,
-					verticalDpi: model.verticalDpi,
+					horizontalDpi: this._dpiToXml(model.horizontalDpi),
+					verticalDpi: this._dpiToXml(model.verticalDpi),
 					pageOrder: pageOrderToXml(model.pageOrder),
 					blackAndWhite: booleanToXml$1(model.blackAndWhite),
 					draft: booleanToXml$1(model.draft),
@@ -13797,6 +13823,9 @@ var ExcelTS = (function(exports) {
 			options.merges = new Merges();
 			model.hyperlinks = options.hyperlinks = [];
 			model.comments = options.comments = [];
+			if (model.formControls && model.formControls.length > 0) {
+				if (!model.views || model.views.length === 0) model.views = [{ workbookViewId: 0 }];
+			}
 			options.formulae = {};
 			options.siFormulae = 0;
 			this.map.cols.prepare(model.cols, options);
@@ -13921,11 +13950,32 @@ var ExcelTS = (function(exports) {
 				});
 			});
 			if (model.formControls && model.formControls.length > 0) {
+				let { drawing } = model;
+				if (!drawing) {
+					drawing = model.drawing = {
+						rId: nextRid(rels),
+						name: `drawing${++options.drawingsCount}`,
+						anchors: [],
+						rels: []
+					};
+					options.drawings.push(drawing);
+					rels.push({
+						Id: drawing.rId,
+						Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing",
+						Target: drawingRelTargetFromWorksheet(drawing.name)
+					});
+				}
 				if (model.comments.length === 0) rels.push({
 					Id: nextRid(rels),
 					Type: RelType.VmlDrawing,
 					Target: vmlDrawingRelTargetFromWorksheet(model.id)
 				});
+				const toNativePos = (p) => ({
+					nativeCol: p.col,
+					nativeColOff: p.colOff,
+					nativeRow: p.row,
+					nativeRowOff: p.rowOff
+				});
 				for (const control of model.formControls) {
 					const globalCtrlPropId = options.formControlRefs.length + 1;
 					control.ctrlPropId = globalCtrlPropId;
@@ -13937,13 +13987,35 @@ var ExcelTS = (function(exports) {
 						Target: ctrlPropRelTargetFromWorksheet(globalCtrlPropId)
 					});
 					options.formControlRefs.push(globalCtrlPropId);
+					const defaultName = `Check Box ${Math.max(1, control.shapeId - 1024)}`;
+					drawing.anchors.push({
+						range: {
+							editAs: "absolute",
+							tl: toNativePos(control.tl),
+							br: toNativePos(control.br)
+						},
+						alternateContent: { requires: "a14" },
+						shape: {
+							cNvPrId: control.shapeId,
+							name: control.name || defaultName,
+							hidden: true,
+							spid: `_x0000_s${control.shapeId}`,
+							text: control.text
+						}
+					});
 				}
 			}
 			this.map.extLst.prepare(model, options);
 		}
 		render(xmlStream, model) {
 			xmlStream.openXml(XmlStream.StdDocAttributes);
-			xmlStream.openNode("worksheet", WorkSheetXform.WORKSHEET_ATTRIBUTES);
+			const worksheetAttrs = { ...WorkSheetXform.WORKSHEET_ATTRIBUTES };
+			if (model.formControls && model.formControls.length > 0) {
+				worksheetAttrs["xmlns:x14"] = "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main";
+				worksheetAttrs["xmlns:xdr"] = "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing";
+				worksheetAttrs["mc:Ignorable"] = `${worksheetAttrs["mc:Ignorable"]} x14`;
+			}
+			xmlStream.openNode("worksheet", worksheetAttrs);
 			const sheetFormatPropertiesModel = model.properties ? {
 				defaultRowHeight: model.properties.defaultRowHeight,
 				dyDescent: model.properties.dyDescent,
@@ -13984,18 +14056,57 @@ var ExcelTS = (function(exports) {
 			this.map.colBreaks.render(xmlStream, model.colBreaks);
 			this.map.drawing.render(xmlStream, model.drawing);
 			this.map.picture.render(xmlStream, model.background);
-			this.map.tableParts.render(xmlStream, model.tables);
+			if (model.rels) model.rels.forEach((rel) => {
+				if (rel.Type === RelType.VmlDrawing) xmlStream.leafNode("legacyDrawing", { "r:id": rel.Id });
+			});
 			if (model.formControls && model.formControls.length > 0) {
+				xmlStream.openNode("mc:AlternateContent");
+				xmlStream.openNode("mc:Choice", { Requires: "x14" });
 				xmlStream.openNode("controls");
-				for (const control of model.formControls) if (control.ctrlPropRelId) xmlStream.leafNode("control", {
-					shapeId: control.shapeId,
-					"r:id": control.ctrlPropRelId
-				});
+				for (const control of model.formControls) {
+					if (!control.ctrlPropRelId) continue;
+					const defaultName = `Check Box ${Math.max(1, control.shapeId - 1024)}`;
+					xmlStream.openNode("mc:AlternateContent");
+					xmlStream.openNode("mc:Choice", { Requires: "x14" });
+					xmlStream.openNode("control", {
+						shapeId: control.shapeId,
+						"r:id": control.ctrlPropRelId,
+						name: control.name || defaultName
+					});
+					xmlStream.openNode("controlPr", {
+						locked: 0,
+						defaultSize: 0,
+						print: control.print ? 1 : 0,
+						autoFill: 0,
+						autoLine: 0,
+						autoPict: 0
+					});
+					xmlStream.openNode("anchor");
+					xmlStream.openNode("from");
+					xmlStream.leafNode("xdr:col", void 0, control.tl.col);
+					xmlStream.leafNode("xdr:colOff", void 0, control.tl.colOff);
+					xmlStream.leafNode("xdr:row", void 0, control.tl.row);
+					xmlStream.leafNode("xdr:rowOff", void 0, control.tl.rowOff);
+					xmlStream.closeNode();
+					xmlStream.openNode("to");
+					xmlStream.leafNode("xdr:col", void 0, control.br.col);
+					xmlStream.leafNode("xdr:colOff", void 0, control.br.colOff);
+					xmlStream.leafNode("xdr:row", void 0, control.br.row);
+					xmlStream.leafNode("xdr:rowOff", void 0, control.br.rowOff);
+					xmlStream.closeNode();
+					xmlStream.closeNode();
+					xmlStream.closeNode();
+					xmlStream.closeNode();
+					xmlStream.closeNode();
+					xmlStream.leafNode("mc:Fallback");
+					xmlStream.closeNode();
+				}
+				xmlStream.closeNode();
+				xmlStream.closeNode();
+				xmlStream.leafNode("mc:Fallback");
 				xmlStream.closeNode();
 			}
-			if (model.rels) model.rels.forEach((rel) => {
-				if (rel.Type === RelType.VmlDrawing) xmlStream.leafNode("legacyDrawing", { "r:id": rel.Id });
-			});
+			this.map.tableParts.render(xmlStream, model.tables);
 			this.map.extLst.render(xmlStream, model);
 			xmlStream.closeNode();
 		}
@@ -14640,6 +14751,134 @@ var ExcelTS = (function(exports) {
 		}
 	};
 
+//#endregion
+//#region src/modules/excel/xlsx/xform/drawing/sp-xform.ts
+	var SpXform = class extends BaseXform {
+		get tag() {
+			return "xdr:sp";
+		}
+		render(xmlStream, model) {
+			if (!model) return;
+			xmlStream.openNode(this.tag, {
+				macro: "",
+				textlink: ""
+			});
+			xmlStream.openNode("xdr:nvSpPr");
+			xmlStream.openNode("xdr:cNvPr", {
+				id: model.cNvPrId,
+				name: model.name,
+				hidden: model.hidden ? "1" : void 0
+			});
+			xmlStream.openNode("a:extLst");
+			xmlStream.openNode("a:ext", { uri: "{63B3BB69-23CF-44E3-9099-C40C66FF867C}" });
+			xmlStream.leafNode("a14:compatExt", {
+				spid: model.spid,
+				"xmlns:a14": "http://schemas.microsoft.com/office/drawing/2010/main"
+			}, void 0);
+			xmlStream.closeNode();
+			xmlStream.closeNode();
+			xmlStream.closeNode();
+			xmlStream.leafNode("xdr:cNvSpPr");
+			xmlStream.closeNode();
+			xmlStream.openNode("xdr:spPr", { bwMode: "auto" });
+			xmlStream.openNode("a:xfrm");
+			xmlStream.leafNode("a:off", {
+				x: 0,
+				y: 0
+			});
+			xmlStream.leafNode("a:ext", {
+				cx: 0,
+				cy: 0
+			});
+			xmlStream.closeNode();
+			xmlStream.openNode("a:prstGeom", { prst: "rect" });
+			xmlStream.leafNode("a:avLst");
+			xmlStream.closeNode();
+			xmlStream.leafNode("a:noFill");
+			xmlStream.openNode("a:ln");
+			xmlStream.leafNode("a:noFill");
+			xmlStream.closeNode();
+			xmlStream.openNode("a:extLst");
+			xmlStream.openNode("a:ext", { uri: "{909E8E84-426E-40DD-AFC4-6F175D3DCCD1}" });
+			xmlStream.openNode("a14:hiddenFill", { "xmlns:a14": "http://schemas.microsoft.com/office/drawing/2010/main" });
+			xmlStream.openNode("a:solidFill");
+			xmlStream.leafNode("a:srgbClr", { val: "F0F0F0" });
+			xmlStream.closeNode();
+			xmlStream.closeNode();
+			xmlStream.closeNode();
+			xmlStream.openNode("a:ext", { uri: "{91240B29-F687-4F45-9708-019B960494DF}" });
+			xmlStream.openNode("a14:hiddenLine", {
+				w: 9525,
+				"xmlns:a14": "http://schemas.microsoft.com/office/drawing/2010/main"
+			});
+			xmlStream.openNode("a:solidFill");
+			xmlStream.leafNode("a:srgbClr", { val: "000000" });
+			xmlStream.closeNode();
+			xmlStream.leafNode("a:miter", { lim: 8e5 });
+			xmlStream.leafNode("a:headEnd");
+			xmlStream.leafNode("a:tailEnd");
+			xmlStream.closeNode();
+			xmlStream.closeNode();
+			xmlStream.closeNode();
+			xmlStream.closeNode();
+			xmlStream.openNode("xdr:txBody");
+			xmlStream.leafNode("a:bodyPr", {
+				vertOverflow: "clip",
+				wrap: "square",
+				lIns: 18288,
+				tIns: 18288,
+				rIns: 0,
+				bIns: 18288,
+				anchor: "ctr",
+				upright: 1
+			});
+			xmlStream.leafNode("a:lstStyle");
+			xmlStream.openNode("a:p");
+			xmlStream.openNode("a:pPr", {
+				algn: "l",
+				rtl: 0
+			});
+			xmlStream.leafNode("a:defRPr", { sz: 1e3 });
+			xmlStream.closeNode();
+			xmlStream.openNode("a:r");
+			xmlStream.openNode("a:rPr", {
+				lang: "en-US",
+				sz: 800,
+				b: 0,
+				i: 0,
+				u: "none",
+				strike: "noStrike",
+				baseline: 0
+			});
+			xmlStream.openNode("a:solidFill");
+			xmlStream.leafNode("a:srgbClr", { val: "000000" });
+			xmlStream.closeNode();
+			xmlStream.leafNode("a:latin", {
+				typeface: "Tahoma",
+				pitchFamily: 2,
+				charset: 0
+			});
+			xmlStream.leafNode("a:ea", {
+				typeface: "Tahoma",
+				pitchFamily: 2,
+				charset: 0
+			});
+			xmlStream.leafNode("a:cs", {
+				typeface: "Tahoma",
+				pitchFamily: 2,
+				charset: 0
+			});
+			xmlStream.closeNode();
+			xmlStream.openNode("a:t");
+			xmlStream.writeText(model.text ?? "");
+			xmlStream.closeNode();
+			xmlStream.closeNode();
+			xmlStream.closeNode();
+			xmlStream.closeNode();
+			xmlStream.closeNode();
+		}
+	};
+
 //#endregion
 //#region src/modules/excel/xlsx/xform/drawing/two-cell-anchor-xform.ts
 	var TwoCellAnchorXform = class extends BaseCellAnchorXform {
@@ -14649,6 +14888,7 @@ var ExcelTS = (function(exports) {
 				"xdr:from": new CellPositionXform({ tag: "xdr:from" }),
 				"xdr:to": new CellPositionXform({ tag: "xdr:to" }),
 				"xdr:pic": new PicXform(),
+				"xdr:sp": new SpXform(),
 				"xdr:clientData": new StaticXform({ tag: "xdr:clientData" })
 			};
 		}
@@ -14656,15 +14896,29 @@ var ExcelTS = (function(exports) {
 			return "xdr:twoCellAnchor";
 		}
 		prepare(model, options) {
-			this.map["xdr:pic"].prepare(model.picture, options);
+			if (model.picture) this.map["xdr:pic"].prepare(model.picture, options);
 		}
 		render(xmlStream, model) {
+			const wrapAlternateContent = !!model.alternateContent;
+			if (wrapAlternateContent) {
+				xmlStream.openNode("mc:AlternateContent", { "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006" });
+				xmlStream.openNode("mc:Choice", {
+					Requires: model.alternateContent?.requires,
+					...model.alternateContent?.requires === "a14" ? { "xmlns:a14": "http://schemas.microsoft.com/office/drawing/2010/main" } : {}
+				});
+			}
 			xmlStream.openNode(this.tag, { editAs: model.range.editAs || "oneCell" });
 			this.map["xdr:from"].render(xmlStream, model.range.tl);
 			this.map["xdr:to"].render(xmlStream, model.range.br);
-			this.map["xdr:pic"].render(xmlStream, model.picture);
+			if (model.picture) this.map["xdr:pic"].render(xmlStream, model.picture);
+			else if (model.shape) this.map["xdr:sp"].render(xmlStream, model.shape);
 			this.map["xdr:clientData"].render(xmlStream, {});
 			xmlStream.closeNode();
+			if (wrapAlternateContent) {
+				xmlStream.closeNode();
+				xmlStream.leafNode("mc:Fallback");
+				xmlStream.closeNode();
+			}
 		}
 		parseClose(name) {
 			if (this.parser) {
@@ -16756,16 +17010,23 @@ var ExcelTS = (function(exports) {
 				xmlStream.closeNode();
 			}
 			xmlStream.openNode("x:ClientData", { ObjectType: "Checkbox" });
+			xmlStream.leafNode("x:MoveWithCells");
+			xmlStream.leafNode("x:SizeWithCells");
 			xmlStream.openNode("x:Anchor");
 			xmlStream.writeText(FormCheckbox.getVmlAnchor(control));
 			xmlStream.closeNode();
+			xmlStream.leafNode("x:Locked", void 0, "False");
+			xmlStream.leafNode("x:LockText", void 0, "True");
 			xmlStream.leafNode("x:PrintObject", void 0, control.print ? "True" : "False");
 			xmlStream.leafNode("x:AutoFill", void 0, "False");
 			xmlStream.leafNode("x:AutoLine", void 0, "False");
+			xmlStream.leafNode("x:TextHAlign", void 0, "Left");
 			xmlStream.leafNode("x:TextVAlign", void 0, "Center");
 			if (control.link) xmlStream.leafNode("x:FmlaLink", void 0, control.link);
 			if (control.noThreeD) xmlStream.leafNode("x:NoThreeD");
 			xmlStream.leafNode("x:Checked", void 0, String(FormCheckbox.getVmlCheckedValue(control)));
+			xmlStream.leafNode("x:Row", void 0, String(control.tl.row));
+			xmlStream.leafNode("x:Column", void 0, String(control.tl.col));
 			xmlStream.closeNode();
 			xmlStream.closeNode();
 		}
@@ -16823,6 +17084,14 @@ var ExcelTS = (function(exports) {
 	* that stores its properties like objectType, checked state, and linked cell.
 	*/
 	var CtrlPropXform = class extends BaseXform {
+		_checkedToXmlValue(checked) {
+			switch (checked) {
+				case "Checked": return "1";
+				case "Mixed": return "2";
+				case "Unchecked":
+				default: return "0";
+			}
+		}
 		get tag() {
 			return "formControlPr";
 		}
@@ -16831,7 +17100,7 @@ var ExcelTS = (function(exports) {
 			const attrs = {
 				xmlns: "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main",
 				objectType: "CheckBox",
-				checked: renderModel.checked,
+				checked: this._checkedToXmlValue(renderModel.checked),
 				lockText: "1"
 			};
 			if (renderModel.link) attrs.fmlaLink = renderModel.link;
@@ -18359,10 +18628,10 @@ var ExcelTS = (function(exports) {
 		}
 		/** Peek a little-endian uint32 at `offset` without consuming bytes. Returns null if not enough bytes. */
 		peekUint32LE(offset) {
-			const off = offset | 0;
-			if (off < 0 || off + 4 > this._length) return null;
+			const off$1 = offset | 0;
+			if (off$1 < 0 || off$1 + 4 > this._length) return null;
 			const chunks = this._chunks;
-			let remaining = off;
+			let remaining = off$1;
 			for (let i = 0; i < chunks.length; i++) {
 				const c = chunks[i];
 				const start = i === 0 ? this._headOffset : 0;
@@ -18403,9 +18672,9 @@ var ExcelTS = (function(exports) {
 		}
 		/** Peek a single byte at `offset` without consuming bytes. */
 		peekByte(offset) {
-			const off = offset | 0;
-			if (off < 0 || off >= this._length) throw new RangeError("ByteQueue: peek beyond available data");
-			let remaining = off;
+			const off$1 = offset | 0;
+			if (off$1 < 0 || off$1 >= this._length) throw new RangeError("ByteQueue: peek beyond available data");
+			let remaining = off$1;
 			for (let i = 0; i < this._chunks.length; i++) {
 				const c = this._chunks[i];
 				const start = i === 0 ? this._headOffset : 0;
@@ -21110,10 +21379,10 @@ var ExcelTS = (function(exports) {
 		}
 	};
 	function tzOffset(d) {
-		const off = -d.getTimezoneOffset();
-		const sign = off >= 0 ? "+" : "-";
-		const h = Math.abs(off) / 60 | 0;
-		const m = Math.abs(off) % 60;
+		const off$1 = -d.getTimezoneOffset();
+		const sign = off$1 >= 0 ? "+" : "-";
+		const h = Math.abs(off$1) / 60 | 0;
+		const m = Math.abs(off$1) % 60;
 		return `${sign}${PAD2[h]}:${PAD2[m]}`;
 	}
 	/**
@@ -26630,11 +26899,15 @@ onmessage = async (ev) => {
 	}
 
 //#endregion
-//#region src/modules/archive/io/archive-sink.ts
-	function isWritableStream(value) {
-		return !!value && typeof value === "object" && typeof value.getWriter === "function";
+//#region src/modules/stream/internal/event-utils.ts
+	function off(emitter, event, listener) {
+		if (typeof emitter.off === "function") emitter.off(event, listener);
+		else if (typeof emitter.removeListener === "function") emitter.removeListener(event, listener);
 	}
-	function once(emitter, event) {
+	/**
+	* Resolve when an emitter fires `event`, reject on `error`.
+	*/
+	function onceEvent(emitter, event) {
 		return new Promise((resolve, reject) => {
 			const onError = (err) => {
 				cleanup();
@@ -26645,15 +26918,21 @@ onmessage = async (ev) => {
 				resolve();
 			};
 			const cleanup = () => {
-				emitter.off?.("error", onError);
-				emitter.off?.(event, onDone);
-				emitter.removeListener?.("error", onError);
-				emitter.removeListener?.(event, onDone);
+				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);
 		});
 	}
+
+//#endregion
+//#region src/modules/archive/io/archive-sink.ts
 	async function pipeIterableToSink(iterable, sink) {
 		if (isWritableStream(sink)) {
 			const writer = sink.getWriter();
@@ -26667,9 +26946,9 @@ onmessage = async (ev) => {
 			}
 			return;
 		}
-		for await (const chunk of iterable) if (sink.write(chunk) === false && typeof sink.once === "function") await once(sink, "drain");
+		for await (const chunk of iterable) if (sink.write(chunk) === false && typeof sink.once === "function") await onceEvent(sink, "drain");
 		if (typeof sink.end === "function") sink.end();
-		if (typeof sink.once === "function") await Promise.race([once(sink, "finish"), once(sink, "close")]);
+		if (typeof sink.once === "function") await Promise.race([onceEvent(sink, "finish"), onceEvent(sink, "close")]);
 	}
 	async function collect(iterable) {
 		const chunks = [];
@@ -26678,25 +26957,11 @@ onmessage = async (ev) => {
 			chunks.push(chunk);
 			total += chunk.length;
 		}
-		if (chunks.length === 0) return new Uint8Array(0);
-		if (chunks.length === 1) return chunks[0];
-		const out = new Uint8Array(total);
-		let offset = 0;
-		for (const chunk of chunks) {
-			out.set(chunk, offset);
-			offset += chunk.length;
-		}
-		return out;
+		return concatUint8Arrays$2(chunks, total);
 	}
 
 //#endregion
 //#region src/modules/archive/io/archive-source.ts
-	function isReadableStream(value) {
-		return !!value && typeof value === "object" && typeof value.getReader === "function";
-	}
-	function isAsyncIterable(value) {
-		return !!value && (typeof value === "object" || typeof value === "function") && typeof value[Symbol.asyncIterator] === "function";
-	}
 	function normalizeChunk(value) {
 		if (!value) return null;
 		if (value instanceof Uint8Array) return value.length ? value : null;