@office-open/xlsx 0.9.8 → 0.10.1

package/dist/comments-CIu-wLTT.mjs

@@ -0,0 +1,1727 @@
+import { attr, attrMeasure, attrNum, attrs, attrsRaw, escapeXml, findChild, selfCloseElement, textOf } from "@office-open/xml";
+import { derivePasswordHash } from "@office-open/core";
+//#region src/parts/shared-strings.ts
+/**
+* Build rich text run properties XML (CT_RPrElt).
+* Exported for reuse by Comments and other components.
+*/
+function buildRPrXml(pr) {
+	if (!pr) return "";
+	const parts = [];
+	if (pr.font) parts.push(`<rFont val="${escapeXml(pr.font)}"/>`);
+	if (pr.charset !== void 0) parts.push(`<charset val="${pr.charset}"/>`);
+	if (pr.family !== void 0) parts.push(`<family val="${pr.family}"/>`);
+	if (pr.bold) parts.push("<b/>");
+	if (pr.italic) parts.push("<i/>");
+	if (pr.strike) parts.push("<strike/>");
+	if (pr.outline) parts.push("<outline/>");
+	if (pr.shadow) parts.push("<shadow/>");
+	if (pr.condense) parts.push("<condense/>");
+	if (pr.extend) parts.push("<extend/>");
+	if (pr.color) {
+		const rgb = pr.color.length === 6 ? `FF${pr.color}` : pr.color;
+		parts.push(`<color rgb="${escapeXml(rgb)}"/>`);
+	}
+	if (pr.size !== void 0) parts.push(`<sz val="${pr.size}"/>`);
+	if (pr.underline) if (pr.underline === "none") parts.push("<u/>");
+	else parts.push(`<u val="${pr.underline}"/>`);
+	if (pr.vertAlign) parts.push(`<vertAlign val="${pr.vertAlign}"/>`);
+	if (pr.scheme) parts.push(`<scheme val="${pr.scheme}"/>`);
+	return parts.length > 0 ? `<rPr>${parts.join("")}</rPr>` : "";
+}
+/** Build a CT_Rst XML string from RichTextOptions. */
+function buildRstXml$1(rst) {
+	const parts = [];
+	if (rst.runs && rst.runs.length > 0) for (const run of rst.runs) {
+		const rPr = buildRPrXml(run.properties);
+		parts.push(`<r>${rPr}<t>${escapeXml(run.text)}</t></r>`);
+	}
+	else if (rst.text !== void 0) parts.push(`<t>${escapeXml(rst.text)}</t>`);
+	if (rst.phonetics) for (const ph of rst.phonetics) parts.push(`<rPh sb="${ph.sb}" eb="${ph.eb}"><t>${escapeXml(ph.text)}</t></rPh>`);
+	return parts.join("");
+}
+var SharedStrings = class {
+	entries = [];
+	/** Dedup map for plain strings only. Rich text is not deduped. */
+	indexMap = /* @__PURE__ */ new Map();
+	/**
+	* Register a plain string and return its index.
+	* Returns existing index if the string is already registered.
+	*/
+	register(s) {
+		const existing = this.indexMap.get(s);
+		if (existing !== void 0) return existing;
+		const idx = this.entries.length;
+		this.entries.push(s);
+		this.indexMap.set(s, idx);
+		return idx;
+	}
+	/**
+	* Register a rich text entry and return its index.
+	* Rich text is not deduped (each call creates a new entry).
+	*/
+	registerRich(rst) {
+		const idx = this.entries.length;
+		this.entries.push(rst);
+		return idx;
+	}
+	/**
+	* Bulk-load parsed template entries, preserving their original indices so
+	* existing cell references stay valid. Plain strings populate the dedup map
+	* (first occurrence wins); rich-text entries are appended unchanged.
+	*
+	* Used by patch to extend an existing workbook's shared strings, so appended
+	* worksheets continue registering strings at the correct offset.
+	*/
+	loadEntries(entries) {
+		for (const entry of entries) {
+			const idx = this.entries.length;
+			this.entries.push(entry);
+			if (typeof entry === "string" && !this.indexMap.has(entry)) this.indexMap.set(entry, idx);
+		}
+	}
+	get count() {
+		return this.entries.length;
+	}
+	/** Return a serializable snapshot for the descriptor. */
+	toDescriptorOptions() {
+		return {
+			entries: this.entries,
+			uniqueCount: this.indexMap.size
+		};
+	}
+	/** Serialize to xl/sharedStrings.xml content (without XML declaration). */
+	serialize() {
+		const p = ["<sst xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\"", ` count="${this.entries.length}" uniqueCount="${this.indexMap.size}">`];
+		for (const entry of this.entries) if (typeof entry === "string") p.push(`<si><t>${escapeXml(entry)}</t></si>`);
+		else p.push(`<si>${buildRstXml$1(entry)}</si>`);
+		p.push("</sst>");
+		return p.join("");
+	}
+};
+const sharedStringsDesc = {
+	kind: "custom",
+	stringify(opts, _ctx) {
+		if (opts.entries.length === 0) return void 0;
+		const p = ["<sst xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\"", ` count="${opts.entries.length}" uniqueCount="${opts.uniqueCount}">`];
+		for (const entry of opts.entries) if (typeof entry === "string") p.push(`<si><t>${escapeXml(entry)}</t></si>`);
+		else p.push(`<si>${buildRstXml$1(entry)}</si>`);
+		p.push("</sst>");
+		return p.join("");
+	},
+	parse(el, _ctx) {
+		const entries = [];
+		for (const si of el.elements ?? []) {
+			if (si.name !== "si") continue;
+			const t = findChild(si, "t");
+			if (t) {
+				entries.push(textOf(t) ?? "");
+				continue;
+			}
+			const runs = [];
+			for (const r of si.elements ?? []) {
+				if (r.name !== "r") continue;
+				const rt = findChild(r, "t");
+				if (rt) {
+					const rPrEl = findChild(r, "rPr");
+					const run = { text: textOf(rt) ?? "" };
+					if (rPrEl) run.properties = parseRPr(rPrEl);
+					runs.push(run);
+				}
+			}
+			const phonetics = [];
+			for (const rPh of si.elements ?? []) {
+				if (rPh.name !== "rPh") continue;
+				const sb = attrNum(rPh, "sb") ?? 0;
+				const eb = attrNum(rPh, "eb") ?? 0;
+				const rPhT = findChild(rPh, "t");
+				phonetics.push({
+					sb,
+					eb,
+					text: rPhT ? textOf(rPhT) ?? "" : ""
+				});
+			}
+			if (runs.length > 0) {
+				const entry = { runs };
+				if (phonetics.length > 0) entry.phonetics = phonetics;
+				entries.push(entry);
+			}
+		}
+		return {
+			entries,
+			uniqueCount: entries.length
+		};
+	}
+};
+/** Parse CT_RPrElt (run properties inside shared strings r element). */
+function parseRPr(el) {
+	const result = {};
+	for (const child of el.elements ?? []) switch (child.name) {
+		case "rFont":
+			result.font = attr(child, "val") ?? void 0;
+			break;
+		case "charset":
+			result.charset = attrNum(child, "val");
+			break;
+		case "family":
+			result.family = attrNum(child, "val");
+			break;
+		case "b":
+			result.bold = attr(child, "val") !== "0";
+			break;
+		case "i":
+			result.italic = attr(child, "val") !== "0";
+			break;
+		case "strike":
+			result.strike = true;
+			break;
+		case "outline":
+			result.outline = true;
+			break;
+		case "shadow":
+			result.shadow = true;
+			break;
+		case "condense":
+			result.condense = true;
+			break;
+		case "extend":
+			result.extend = true;
+			break;
+		case "color": {
+			const rgb = attr(child, "rgb");
+			if (rgb) result.color = rgb.length === 8 ? rgb.slice(2) : rgb;
+			else {
+				const indexed = attrNum(child, "indexed");
+				if (indexed !== void 0) result.color = String(indexed);
+				else {
+					const theme = attr(child, "theme");
+					if (theme !== void 0) result.color = `theme:${theme}`;
+				}
+			}
+			break;
+		}
+		case "sz":
+			result.size = attrNum(child, "val");
+			break;
+		case "u":
+			result.underline = attr(child, "val") ?? true;
+			break;
+		case "vertAlign":
+			result.vertAlign = attr(child, "val") ?? void 0;
+			break;
+		case "scheme":
+			result.scheme = attr(child, "val") ?? void 0;
+			break;
+	}
+	return result;
+}
+//#endregion
+//#region src/parts/worksheet.ts
+/**
+* Worksheet XML generation — pure functions for xl/worksheets/sheet{n}.xml.
+*
+* All interfaces and the zero-allocation string concatenation fast path
+* are preserved. The `Worksheet` class has been replaced by `buildWorksheetXml()`.
+*
+* @module
+*/
+/** Cell formula type (maps to ST_CellFormulaType). */
+const FormulaType = {
+	NORMAL: "normal",
+	ARRAY: "array",
+	SHARED: "shared"
+};
+const worksheetDesc = {
+	kind: "custom",
+	/**
+	* NOT intended for direct use by the compiler.
+	* The compiler calls `stringifyWorksheet(opts, ctx)` instead, which has
+	* access to the SharedStrings and Styles accumulators.
+	* This method exists to satisfy the CustomDescriptor interface for the read path.
+	*/
+	stringify(_opts, _ctx) {
+		throw new Error("Use stringifyWorksheet(opts, ctx) for the write path. worksheetDesc.stringify() is not supported.");
+	},
+	parse(el, ctx) {
+		const result = {};
+		let pageSetUpPrCache;
+		const strings = ctx && "sharedStrings" in ctx ? ctx.sharedStrings : [];
+		const sheetPrEl = findChild(el, "sheetPr");
+		if (sheetPrEl) {
+			const sp = {};
+			if (attr(sheetPrEl, "syncHorizontal") === "1") sp.syncHorizontal = true;
+			if (attr(sheetPrEl, "syncVertical") === "1") sp.syncVertical = true;
+			if (attr(sheetPrEl, "syncRef")) sp.syncRef = attr(sheetPrEl, "syncRef");
+			if (attr(sheetPrEl, "transitionEvaluation") === "1") sp.transitionEvaluation = true;
+			if (attr(sheetPrEl, "transitionEntry") === "1") sp.transitionEntry = true;
+			if (attr(sheetPrEl, "published") === "1") sp.published = true;
+			if (attr(sheetPrEl, "filterMode") === "1") sp.filterMode = true;
+			if (attr(sheetPrEl, "enableFormatConditionsCalculation") === "1") sp.enableFormatConditionsCalculation = true;
+			const outlinePr = findChild(sheetPrEl, "outlinePr");
+			if (outlinePr) {
+				if (attr(outlinePr, "applyStyles") === "1") sp.outlineApplyStyles = true;
+				if (attr(outlinePr, "showOutlineSymbols") === "0") sp.outlineShowSymbols = false;
+				if (attr(outlinePr, "summaryBelow") === "0") sp.outlineSummaryBelow = false;
+				if (attr(outlinePr, "summaryRight") === "0") sp.outlineSummaryRight = false;
+			}
+			const pageSetUpPr = findChild(sheetPrEl, "pageSetUpPr");
+			if (pageSetUpPr) {
+				const psup = {};
+				if (attr(pageSetUpPr, "fitToPage") === "1") psup.fitToPage = true;
+				if (attr(pageSetUpPr, "autoPageBreaks") === "1") psup.autoPageBreaks = true;
+				if (Object.keys(psup).length > 0) pageSetUpPrCache = psup;
+			}
+			if (Object.keys(sp).length > 0) result.sheetPr = sp;
+			const tabColorEl = findChild(sheetPrEl, "tabColor");
+			if (tabColorEl) {
+				const tc = {};
+				if (attr(tabColorEl, "rgb")) tc.rgb = attr(tabColorEl, "rgb");
+				if (attrNum(tabColorEl, "theme") !== void 0) tc.theme = attrNum(tabColorEl, "theme");
+				if (attrNum(tabColorEl, "tint") !== void 0) tc.tint = attrNum(tabColorEl, "tint");
+				if (attrNum(tabColorEl, "indexed") !== void 0) tc.indexed = attrNum(tabColorEl, "indexed");
+				result.tabColor = tc;
+			}
+		}
+		const sheetViewsEl = findChild(el, "sheetViews");
+		if (sheetViewsEl) {
+			const svEl = findChild(sheetViewsEl, "sheetView");
+			if (svEl) {
+				const sv = {};
+				if (attr(svEl, "showGridLines") === "0") sv.showGridLines = false;
+				if (attr(svEl, "showRowColHeaders") === "0") sv.showRowColHeaders = false;
+				if (attr(svEl, "showZeros") === "0") sv.showZeros = false;
+				const zs = attrNum(svEl, "zoomScale");
+				if (zs !== void 0) sv.zoomScale = zs;
+				if (attr(svEl, "tabSelected") !== void 0) sv.tabSelected = attr(svEl, "tabSelected") !== "0";
+				if (attr(svEl, "rightToLeft") === "1") sv.rightToLeft = true;
+				if (attr(svEl, "windowProtection") === "1") sv.windowProtection = true;
+				if (attr(svEl, "showFormulas") === "1") sv.showFormulas = true;
+				if (attr(svEl, "showRuler") === "0") sv.showRuler = false;
+				if (attr(svEl, "showOutlineSymbols") === "0") sv.showOutlineSymbols = false;
+				if (attr(svEl, "defaultGridColor") === "0") sv.defaultGridColor = false;
+				if (attr(svEl, "showWhiteSpace") === "0") sv.showWhiteSpace = false;
+				if (attr(svEl, "view")) sv.view = attr(svEl, "view");
+				const colorId = attrNum(svEl, "colorId");
+				if (colorId !== void 0) sv.colorId = colorId;
+				const zsn = attrNum(svEl, "zoomScaleNormal");
+				if (zsn !== void 0) sv.zoomScaleNormal = zsn;
+				const zssl = attrNum(svEl, "zoomScaleSheetLayoutView");
+				if (zssl !== void 0) sv.zoomScaleSheetLayoutView = zssl;
+				const zspl = attrNum(svEl, "zoomScalePageLayoutView");
+				if (zspl !== void 0) sv.zoomScalePageLayoutView = zspl;
+				result.sheetView = sv;
+				const paneEl = findChild(svEl, "pane");
+				if (paneEl && attr(paneEl, "state") === "frozen") {
+					const fp = {};
+					const ys = attrNum(paneEl, "ySplit");
+					if (ys && ys > 0) fp.row = ys;
+					const xs = attrNum(paneEl, "xSplit");
+					if (xs && xs > 0) fp.col = xs;
+					if (Object.keys(fp).length > 0) result.freezePanes = fp;
+				}
+			}
+		}
+		const sfpEl = findChild(el, "sheetFormatPr");
+		if (sfpEl) {
+			const sfp = {};
+			const bcw = attrNum(sfpEl, "baseColWidth");
+			if (bcw !== void 0) sfp.baseColWidth = bcw;
+			const dcw = attrNum(sfpEl, "defaultColWidth");
+			if (dcw !== void 0) sfp.defaultColWidth = dcw;
+			const drh = attrNum(sfpEl, "defaultRowHeight");
+			if (drh !== void 0) sfp.defaultRowHeight = drh;
+			if (attr(sfpEl, "zeroHeight") === "1") sfp.zeroHeight = true;
+			if (attr(sfpEl, "thickTop") === "1") sfp.thickTop = true;
+			if (attr(sfpEl, "thickBottom") === "1") sfp.thickBottom = true;
+			const olr = attrNum(sfpEl, "outlineLevelRow");
+			if (olr !== void 0) sfp.outlineLevelRow = olr;
+			const olc = attrNum(sfpEl, "outlineLevelCol");
+			if (olc !== void 0) sfp.outlineLevelCol = olc;
+			result.sheetFormatPr = sfp;
+		}
+		const colsEl = findChild(el, "cols");
+		if (colsEl) {
+			const columns = [];
+			for (const colEl of colsEl.elements ?? []) {
+				if (colEl.name !== "col") continue;
+				const col = {};
+				col.min = attrNum(colEl, "min") ?? 0;
+				col.max = attrNum(colEl, "max") ?? 0;
+				const w = attrNum(colEl, "width");
+				if (w !== void 0) col.width = w;
+				if (attr(colEl, "hidden") === "1") col.hidden = true;
+				if (attr(colEl, "customWidth") === "1") col.customWidth = true;
+				const ol = attrNum(colEl, "outlineLevel");
+				if (ol !== void 0) col.outlineLevel = ol;
+				if (attr(colEl, "collapsed") === "1") col.collapsed = true;
+				if (attr(colEl, "bestFit") === "1") col.bestFit = true;
+				if (attr(colEl, "phonetic") === "1") col.phonetic = true;
+				columns.push(col);
+			}
+			if (columns.length > 0) result.columns = columns;
+		}
+		const protEl = findChild(el, "sheetProtection");
+		if (protEl?.attributes) {
+			const prot = {};
+			if (attr(protEl, "password")) prot.password = attr(protEl, "password");
+			if (attr(protEl, "algorithmName")) prot.algorithmName = attr(protEl, "algorithmName");
+			if (attr(protEl, "hashValue")) prot.hashValue = attr(protEl, "hashValue");
+			if (attr(protEl, "saltValue")) prot.saltValue = attr(protEl, "saltValue");
+			if (attrNum(protEl, "spinCount") !== void 0) prot.spinCount = attrNum(protEl, "spinCount");
+			if (attr(protEl, "sheet") === "1") prot.sheet = true;
+			if (attr(protEl, "objects") === "1") prot.objects = true;
+			if (attr(protEl, "scenarios") === "1") prot.scenarios = true;
+			if (attr(protEl, "formatCells") === "0") prot.formatCells = false;
+			if (attr(protEl, "formatColumns") === "0") prot.formatColumns = false;
+			if (attr(protEl, "formatRows") === "0") prot.formatRows = false;
+			if (attr(protEl, "insertColumns") === "0") prot.insertColumns = false;
+			if (attr(protEl, "insertRows") === "0") prot.insertRows = false;
+			if (attr(protEl, "insertHyperlinks") === "0") prot.insertHyperlinks = false;
+			if (attr(protEl, "deleteColumns") === "0") prot.deleteColumns = false;
+			if (attr(protEl, "deleteRows") === "0") prot.deleteRows = false;
+			if (attr(protEl, "selectLockedCells") === "1") prot.selectLockedCells = true;
+			if (attr(protEl, "sort") === "0") prot.sort = false;
+			if (attr(protEl, "autoFilter") === "0") prot.autoFilter = false;
+			if (attr(protEl, "pivotTables") === "0") prot.pivotTables = false;
+			if (attr(protEl, "selectUnlockedCells") === "1") prot.selectUnlockedCells = true;
+			result.protection = prot;
+		}
+		const prEl = findChild(el, "protectedRanges");
+		if (prEl) {
+			const ranges = [];
+			for (const rEl of prEl.elements ?? []) {
+				if (rEl.name !== "protectedRange") continue;
+				const r = {};
+				r.sqref = attr(rEl, "sqref") ?? "";
+				r.name = attr(rEl, "name") ?? "";
+				if (attr(rEl, "password")) r.password = attr(rEl, "password");
+				if (attr(rEl, "algorithmName")) r.algorithmName = attr(rEl, "algorithmName");
+				if (attr(rEl, "hashValue")) r.hashValue = attr(rEl, "hashValue");
+				if (attr(rEl, "saltValue")) r.saltValue = attr(rEl, "saltValue");
+				if (attrNum(rEl, "spinCount") !== void 0) r.spinCount = attrNum(rEl, "spinCount");
+				const sdEl = findChild(rEl, "securityDescriptor");
+				if (sdEl) r.securityDescriptor = textOf(sdEl);
+				ranges.push(r);
+			}
+			if (ranges.length > 0) result.protectedRanges = ranges;
+		}
+		const afEl = findChild(el, "autoFilter");
+		if (afEl) result.autoFilter = attr(afEl, "ref") ?? "";
+		const mcEl = findChild(el, "mergeCells");
+		if (mcEl) {
+			const merges = [];
+			for (const mEl of mcEl.elements ?? []) {
+				if (mEl.name !== "mergeCell") continue;
+				const parts = (attr(mEl, "ref") ?? "").split(":");
+				if (parts.length === 2) {
+					const from = parseCellRef(parts[0]);
+					const to = parseCellRef(parts[1]);
+					if (from && to) merges.push({
+						from,
+						to
+					});
+				}
+			}
+			if (merges.length > 0) result.mergeCells = merges;
+		}
+		const cfEls = el.elements?.filter((e) => e.name === "conditionalFormatting") ?? [];
+		if (cfEls.length > 0) {
+			const cfs = [];
+			for (const cfEl of cfEls) {
+				const sqref = attr(cfEl, "sqref") ?? "";
+				const rules = [];
+				for (const ruleEl of cfEl.elements ?? []) {
+					if (ruleEl.name !== "cfRule") continue;
+					const rule = {};
+					rule.type = attr(ruleEl, "type");
+					rule.priority = attrNum(ruleEl, "priority") ?? 1;
+					if (attr(ruleEl, "operator")) rule.operator = attr(ruleEl, "operator");
+					const dxfId = attrNum(ruleEl, "dxfId");
+					if (dxfId !== void 0) rule.dxfId = dxfId;
+					if (attr(ruleEl, "stopIfTrue") === "1") rule.stopIfTrue = true;
+					if (attr(ruleEl, "timePeriod")) rule.timePeriod = attr(ruleEl, "timePeriod");
+					const rank = attrNum(ruleEl, "rank");
+					if (rank !== void 0) rule.rank = rank;
+					if (attr(ruleEl, "equalAverage") === "1") rule.equalAverage = true;
+					const csEl = findChild(ruleEl, "colorScale");
+					if (csEl) {
+						const cfvo = [];
+						const colors = [];
+						for (const child of csEl.elements ?? []) {
+							if (child.name === "cfvo") cfvo.push(parseCfvo(child));
+							if (child.name === "color") {
+								const rgb = attr(child, "rgb");
+								if (rgb) colors.push(rgb.length === 8 ? rgb.slice(2) : rgb);
+							}
+						}
+						rule.colorScale = {
+							cfvo,
+							colors
+						};
+					}
+					const dbEl = findChild(ruleEl, "dataBar");
+					if (dbEl) {
+						const cfvo = [];
+						let color = "";
+						for (const child of dbEl.elements ?? []) {
+							if (child.name === "cfvo") cfvo.push(parseCfvo(child));
+							if (child.name === "color") {
+								const rgb = attr(child, "rgb");
+								if (rgb) color = rgb.length === 8 ? rgb.slice(2) : rgb;
+							}
+						}
+						rule.dataBar = {
+							cfvo,
+							color
+						};
+					}
+					const isEl = findChild(ruleEl, "iconSet");
+					if (isEl) {
+						const cfvo = [];
+						for (const child of isEl.elements ?? []) if (child.name === "cfvo") cfvo.push(parseCfvo(child));
+						const iconSet = { cfvo };
+						if (attr(isEl, "iconSet")) iconSet.iconSet = attr(isEl, "iconSet");
+						if (attr(isEl, "showValue") === "0") iconSet.showValue = false;
+						if (attr(isEl, "percent") === "0") iconSet.percent = false;
+						if (attr(isEl, "reverse") === "1") iconSet.reverse = true;
+						rule.iconSet = iconSet;
+					}
+					const formulas = [];
+					for (const child of ruleEl.elements ?? []) if (child.name === "formula") formulas.push(textOf(child) ?? "");
+					if (formulas.length > 0) rule.formulas = formulas;
+					rules.push(rule);
+				}
+				cfs.push({
+					sqref,
+					rules
+				});
+			}
+			result.conditionalFormats = cfs;
+		}
+		const dvEl = findChild(el, "dataValidations");
+		if (dvEl) {
+			const dvs = [];
+			for (const dEl of dvEl.elements ?? []) {
+				if (dEl.name !== "dataValidation") continue;
+				const dv = {};
+				dv.sqref = attr(dEl, "sqref") ?? "";
+				if (attr(dEl, "type")) dv.type = attr(dEl, "type");
+				if (attr(dEl, "operator")) dv.operator = attr(dEl, "operator");
+				if (attr(dEl, "allowBlank") === "1") dv.allowBlank = true;
+				if (attr(dEl, "showErrorMessage") === "1") dv.showErrorMessage = true;
+				if (attr(dEl, "showInputMessage") === "1") dv.showInputMessage = true;
+				if (attr(dEl, "errorTitle")) dv.errorTitle = attr(dEl, "errorTitle");
+				if (attr(dEl, "error")) dv.error = attr(dEl, "error");
+				if (attr(dEl, "promptTitle")) dv.promptTitle = attr(dEl, "promptTitle");
+				if (attr(dEl, "prompt")) dv.prompt = attr(dEl, "prompt");
+				if (attr(dEl, "errorStyle")) dv.errorStyle = attr(dEl, "errorStyle");
+				if (attr(dEl, "imeMode")) dv.imeMode = attr(dEl, "imeMode");
+				if (attr(dEl, "showDropDown") === "1") dv.showDropDown = true;
+				const f1El = findChild(dEl, "formula1");
+				if (f1El) dv.formula1 = textOf(f1El);
+				const f2El = findChild(dEl, "formula2");
+				if (f2El) dv.formula2 = textOf(f2El);
+				dvs.push(dv);
+			}
+			result.dataValidations = dvs;
+		}
+		const hlEl = findChild(el, "hyperlinks");
+		if (hlEl) {
+			const hyperlinks = [];
+			for (const hEl of hlEl.elements ?? []) {
+				if (hEl.name !== "hyperlink") continue;
+				const hl = {};
+				hl.cell = attr(hEl, "ref") ?? "";
+				const rId = hEl.attributes?.["r:id"];
+				const location = attr(hEl, "location");
+				if (rId) hl.target = {
+					type: "external",
+					url: rId
+				};
+				else if (location) hl.target = {
+					type: "internal",
+					location
+				};
+				if (attr(hEl, "tooltip")) hl.tooltip = attr(hEl, "tooltip");
+				if (attr(hEl, "display")) hl.display = attr(hEl, "display");
+				hyperlinks.push(hl);
+			}
+			result.hyperlinks = hyperlinks;
+		}
+		const poEl = findChild(el, "printOptions");
+		if (poEl) {
+			const po = {};
+			if (attr(poEl, "horizontalCentered") === "1") po.horizontalCentered = true;
+			if (attr(poEl, "verticalCentered") === "1") po.verticalCentered = true;
+			if (attr(poEl, "headings") === "1") po.headings = true;
+			if (attr(poEl, "gridLines") === "1") po.gridLines = true;
+			if (attr(poEl, "gridLinesSet") === "0") po.gridLinesSet = false;
+			result.printOptions = po;
+		}
+		const psEl = findChild(el, "pageSetup");
+		if (psEl) {
+			const ps = {};
+			const pz = attrNum(psEl, "paperSize");
+			if (pz !== void 0) ps.paperSize = pz;
+			const ph = attrMeasure(psEl, "paperHeight");
+			if (ph !== void 0) ps.paperHeight = ph;
+			const pw = attrMeasure(psEl, "paperWidth");
+			if (pw !== void 0) ps.paperWidth = pw;
+			if (attr(psEl, "orientation")) ps.orientation = attr(psEl, "orientation");
+			const sc = attrNum(psEl, "scale");
+			if (sc !== void 0) ps.scale = sc;
+			const ftw = attrNum(psEl, "fitToWidth");
+			if (ftw !== void 0) ps.fitToWidth = ftw;
+			const fth = attrNum(psEl, "fitToHeight");
+			if (fth !== void 0) ps.fitToHeight = fth;
+			if (attr(psEl, "pageOrder")) ps.pageOrder = attr(psEl, "pageOrder");
+			if (attr(psEl, "useFirstPageNumber") === "1") ps.useFirstPageNumber = true;
+			const fpn = attrNum(psEl, "firstPageNumber");
+			if (fpn !== void 0) ps.firstPageNumber = fpn;
+			if (pageSetUpPrCache) Object.assign(ps, pageSetUpPrCache);
+			result.pageSetup = ps;
+		} else if (pageSetUpPrCache) result.pageSetup = pageSetUpPrCache;
+		const hfEl = findChild(el, "headerFooter");
+		if (hfEl) {
+			const hf = {};
+			if (attr(hfEl, "differentOddEven") === "1") hf.differentOddEven = true;
+			if (attr(hfEl, "differentFirst") === "1") hf.differentFirst = true;
+			if (attr(hfEl, "scaleWithDoc") === "0") hf.scaleWithDoc = false;
+			if (attr(hfEl, "alignWithMargins") === "0") hf.alignWithMargins = false;
+			const oh = findChild(hfEl, "oddHeader");
+			if (oh) hf.oddHeader = textOf(oh);
+			const of2 = findChild(hfEl, "oddFooter");
+			if (of2) hf.oddFooter = textOf(of2);
+			const eh = findChild(hfEl, "evenHeader");
+			if (eh) hf.evenHeader = textOf(eh);
+			const ef = findChild(hfEl, "evenFooter");
+			if (ef) hf.evenFooter = textOf(ef);
+			const fh = findChild(hfEl, "firstHeader");
+			if (fh) hf.firstHeader = textOf(fh);
+			const ff = findChild(hfEl, "firstFooter");
+			if (ff) hf.firstFooter = textOf(ff);
+			result.headerFooter = hf;
+		}
+		const ieEl = findChild(el, "ignoredErrors");
+		if (ieEl) {
+			const errors = [];
+			for (const eEl of ieEl.elements ?? []) {
+				if (eEl.name !== "ignoredError") continue;
+				const ie = {};
+				ie.sqref = attr(eEl, "sqref") ?? "";
+				if (attr(eEl, "evalError") === "1") ie.evalError = true;
+				if (attr(eEl, "twoDigitTextYear") === "1") ie.twoDigitTextYear = true;
+				if (attr(eEl, "numberStoredAsText") === "1") ie.numberStoredAsText = true;
+				if (attr(eEl, "formula") === "1") ie.formula = true;
+				if (attr(eEl, "formulaRange") === "1") ie.formulaRange = true;
+				if (attr(eEl, "unlockedFormula") === "1") ie.unlockedFormula = true;
+				if (attr(eEl, "emptyCellReference") === "1") ie.emptyCellReference = true;
+				if (attr(eEl, "listDataValidation") === "1") ie.listDataValidation = true;
+				if (attr(eEl, "calculatedColumn") === "1") ie.calculatedColumn = true;
+				errors.push(ie);
+			}
+			result.ignoredErrors = errors;
+		}
+		const ppEl = findChild(el, "phoneticPr");
+		if (ppEl) {
+			const pp = {};
+			pp.fontId = attrNum(ppEl, "fontId") ?? 0;
+			if (attr(ppEl, "type")) pp.type = attr(ppEl, "type");
+			if (attr(ppEl, "alignment")) pp.alignment = attr(ppEl, "alignment");
+			result.phoneticPr = pp;
+		}
+		const scEl = findChild(el, "sheetCalcPr");
+		if (scEl) {
+			const sc = {};
+			if (attr(scEl, "fullCalcOnLoad") === "1") sc.fullCalcOnLoad = true;
+			result.sheetCalcPr = sc;
+		}
+		const sheetDataEl = findChild(el, "sheetData");
+		if (sheetDataEl) {
+			const rows = [];
+			for (const rowEl of sheetDataEl.elements ?? []) {
+				if (rowEl.name !== "row") continue;
+				const row = {};
+				const rowNumber = attrNum(rowEl, "r");
+				if (rowNumber !== void 0) row.rowNumber = rowNumber;
+				const ht = attrNum(rowEl, "ht");
+				if (ht !== void 0) row.height = ht;
+				if (attr(rowEl, "hidden") === "1") row.hidden = true;
+				if (attr(rowEl, "spans")) row.spans = attr(rowEl, "spans");
+				if (attr(rowEl, "customFormat") === "1") row.customFormat = true;
+				if (attr(rowEl, "thickTop") === "1") row.thickTop = true;
+				if (attr(rowEl, "thickBot") === "1") row.thickBot = true;
+				if (attr(rowEl, "ph") === "1") row.ph = true;
+				const cells = [];
+				for (const cellEl of rowEl.elements ?? []) {
+					if (cellEl.name !== "c") continue;
+					const cell = {};
+					const ref = attr(cellEl, "r");
+					if (ref) cell.reference = ref;
+					const type = attr(cellEl, "t");
+					const styleIdx = attrNum(cellEl, "s");
+					if (styleIdx !== void 0) {
+						const resolved = ctx && "resolveStyle" in ctx ? ctx.resolveStyle(styleIdx) : void 0;
+						if (resolved) cell.style = resolved;
+						else cell.styleIndex = styleIdx;
+					}
+					const vEl = findChild(cellEl, "v");
+					const isEl = findChild(cellEl, "is");
+					if (type === "s" && vEl) cell.value = strings[parseInt(textOf(vEl) ?? "", 10)] ?? "";
+					else if (type === "b" && vEl) cell.value = textOf(vEl) === "1";
+					else if (type === "inlineStr" && isEl) cell.value = textOf(findChild(isEl, "t")) ?? "";
+					else if (vEl) {
+						const raw = textOf(vEl) ?? "";
+						const num = Number(raw);
+						cell.value = isNaN(num) ? raw : num;
+					}
+					const fEl = findChild(cellEl, "f");
+					if (fEl) {
+						const formula = { formula: textOf(fEl) ?? "" };
+						const ft = attr(fEl, "t");
+						if (ft && ft !== "normal") formula.type = ft;
+						const fRef = attr(fEl, "ref");
+						if (fRef) formula.reference = fRef;
+						const fSi = attrNum(fEl, "si");
+						if (fSi !== void 0) formula.sharedIndex = fSi;
+						if (attr(fEl, "aca") === "1") formula.aca = true;
+						if (attr(fEl, "ca") === "1") formula.ca = true;
+						if (attr(fEl, "bx") === "1") formula.bx = true;
+						cell.formula = formula;
+					}
+					cells.push(cell);
+				}
+				row.cells = cells;
+				rows.push(row);
+			}
+			if (rows.length > 0) result.rows = rows;
+		}
+		return result;
+	}
+};
+/**
+* Build the complete worksheet XML string.
+*
+* Zero-allocation fast path: directly concatenates XML string,
+* bypassing the IXmlableObject intermediate tree entirely.
+*/
+function stringifyWorksheet(opts, ctx) {
+	const sharedStrings = ctx.sharedStrings;
+	const styles = ctx.styles;
+	const rows = opts.rows ?? [];
+	const columns = opts.columns ?? [];
+	const mergeCells = opts.mergeCells ?? [];
+	const protectedRanges = opts.protectedRanges ?? [];
+	const ignoredErrors = opts.ignoredErrors ?? [];
+	const rowBreaks = opts.rowBreaks ?? [];
+	const colBreaks = opts.colBreaks ?? [];
+	const customSheetViews = opts.customSheetViews ?? [];
+	const cellWatches = opts.cellWatches ?? [];
+	const controls = opts.controls ?? [];
+	const customProperties = opts.customProperties ?? [];
+	const oleObjects = opts.oleObjects ?? [];
+	const webPublishItems = opts.webPublishItems ?? [];
+	const p = ["<worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" mc:Ignorable=\"x14ac xr xr2 xr3\" xmlns:x14ac=\"http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac\" xmlns:xr=\"http://schemas.microsoft.com/office/spreadsheetml/2014/revision\" xmlns:xr2=\"http://schemas.microsoft.com/office/spreadsheetml/2015/revision2\" xmlns:xr3=\"http://schemas.microsoft.com/office/spreadsheetml/2016/revision3\">"];
+	const hasTabColor = !!opts.tabColor;
+	const hasOutline = columns.some((c) => c.outlineLevel !== void 0);
+	const sp = opts.sheetPr;
+	const hasSheetPrAttrs = sp && (sp.syncHorizontal || sp.syncVertical || sp.syncRef || sp.transitionEvaluation || sp.transitionEntry || sp.published || sp.filterMode || sp.enableFormatConditionsCalculation);
+	const hasPageSetUpPr = !!opts.pageSetup?.fitToWidth || !!opts.pageSetup?.fitToHeight || !!opts.pageSetup?.autoPageBreaks;
+	if (hasTabColor || hasOutline || hasSheetPrAttrs || hasPageSetUpPr) {
+		const prParts = [];
+		const prAttrs = {};
+		if (sp?.syncHorizontal) prAttrs.syncHorizontal = 1;
+		if (sp?.syncVertical) prAttrs.syncVertical = 1;
+		if (sp?.syncRef) prAttrs.syncRef = sp.syncRef;
+		if (sp?.transitionEvaluation) prAttrs.transitionEvaluation = 1;
+		if (sp?.transitionEntry) prAttrs.transitionEntry = 1;
+		if (sp?.published) prAttrs.published = 1;
+		if (sp?.filterMode) prAttrs.filterMode = 1;
+		if (sp?.enableFormatConditionsCalculation) prAttrs.enableFormatConditionsCalculation = 1;
+		if (opts.tabColor) {
+			const tc = opts.tabColor;
+			const tcAttrs = {};
+			if (tc.rgb) tcAttrs.rgb = tc.rgb;
+			if (tc.theme !== void 0) tcAttrs.theme = tc.theme;
+			if (tc.tint !== void 0) tcAttrs.tint = tc.tint;
+			if (tc.indexed !== void 0) tcAttrs.indexed = tc.indexed;
+			prParts.push(`<tabColor${attrs(tcAttrs)}/>`);
+		}
+		if (hasOutline) {
+			const outAttrs = {
+				summaryBelow: 1,
+				summaryRight: 1
+			};
+			if (sp?.outlineSummaryBelow === false) outAttrs.summaryBelow = 0;
+			if (sp?.outlineSummaryRight === false) outAttrs.summaryRight = 0;
+			if (sp?.outlineApplyStyles) outAttrs.applyStyles = 1;
+			if (sp?.outlineShowSymbols === false) outAttrs.showOutlineSymbols = 0;
+			prParts.push(`<outlinePr${attrs(outAttrs)}/>`);
+		}
+		if (opts.pageSetup?.fitToWidth || opts.pageSetup?.fitToHeight || opts.pageSetup?.autoPageBreaks) {
+			const psupAttrs = {};
+			if (opts.pageSetup?.fitToWidth || opts.pageSetup?.fitToHeight) psupAttrs.fitToPage = 1;
+			if (opts.pageSetup?.autoPageBreaks) psupAttrs.autoPageBreaks = 1;
+			prParts.push(`<pageSetUpPr${attrs(psupAttrs)}/>`);
+		}
+		const prAttrStr = Object.keys(prAttrs).length > 0 ? attrs(prAttrs) : "";
+		p.push(`<sheetPr${prAttrStr}>${prParts.join("")}</sheetPr>`);
+	}
+	const maxRow = rows.length;
+	let maxCol = 0;
+	for (const row of rows) if (row.cells && row.cells.length > maxCol) maxCol = row.cells.length;
+	if (maxRow > 0 && maxCol > 0) {
+		const dimRef = `A1:${defaultCellRef(maxRow, maxCol)}`;
+		p.push(`<dimension ref="${dimRef}"/>`);
+	}
+	const pivotSelXml = opts.sheetView?.pivotSelections ? opts.sheetView.pivotSelections.map((ps) => buildPivotSelectionXml(ps)).join("") : "";
+	if (opts.freezePanes) {
+		const fp = opts.freezePanes;
+		const ySplit = fp.row ? fp.row : 0;
+		const xSplit = fp.col ? fp.col : 0;
+		const topLeftCell = defaultCellRef(fp.row ? fp.row + 1 : 1, fp.col ? fp.col + 1 : 1);
+		const activePane = ySplit > 0 && xSplit > 0 ? "bottomRight" : ySplit > 0 ? "bottomLeft" : "topRight";
+		const svAttrs = buildSheetViewAttrs(opts.sheetView);
+		p.push(`<sheetViews><sheetView${svAttrs}>`, `<pane ySplit="${ySplit}" xSplit="${xSplit}" topLeftCell="${topLeftCell}" activePane="${activePane}" state="frozen"/>`, opts.selection ? buildSelectionXml(opts.selection) : "", pivotSelXml, "</sheetView></sheetViews>");
+	} else {
+		const svAttrs = buildSheetViewAttrs(opts.sheetView);
+		const innerXml = (opts.selection ? buildSelectionXml(opts.selection) : "") + pivotSelXml;
+		if (innerXml) p.push(`<sheetViews><sheetView${svAttrs}>${innerXml}</sheetView></sheetViews>`);
+		else p.push(`<sheetViews><sheetView${svAttrs}/></sheetViews>`);
+	}
+	if (opts.sheetFormatPr) {
+		const sfp = opts.sheetFormatPr;
+		const sfpAttrs = {};
+		if (sfp.baseColWidth !== void 0) sfpAttrs.baseColWidth = sfp.baseColWidth;
+		if (sfp.defaultColWidth !== void 0) sfpAttrs.defaultColWidth = sfp.defaultColWidth;
+		sfpAttrs.defaultRowHeight = sfp.defaultRowHeight ?? 15;
+		if (sfp.zeroHeight) sfpAttrs.zeroHeight = 1;
+		if (sfp.thickTop) sfpAttrs.thickTop = 1;
+		if (sfp.thickBottom) sfpAttrs.thickBottom = 1;
+		if (sfp.outlineLevelRow !== void 0) sfpAttrs.outlineLevelRow = sfp.outlineLevelRow;
+		if (sfp.outlineLevelCol !== void 0) sfpAttrs.outlineLevelCol = sfp.outlineLevelCol;
+		p.push(`<sheetFormatPr${attrs(sfpAttrs)}/>`);
+	} else p.push("<sheetFormatPr defaultRowHeight=\"15\"/>");
+	if (columns.length > 0) {
+		p.push("<cols>");
+		for (const col of columns) {
+			const colAttrs = {
+				min: col.min,
+				max: col.max
+			};
+			if (col.width !== void 0) {
+				colAttrs.width = col.width;
+				colAttrs.customWidth = 1;
+			}
+			if (col.hidden) colAttrs.hidden = 1;
+			if (col.outlineLevel !== void 0) colAttrs.outlineLevel = col.outlineLevel;
+			if (col.collapsed) colAttrs.collapsed = 1;
+			if (col.bestFit) colAttrs.bestFit = 1;
+			if (col.phonetic) colAttrs.phonetic = 1;
+			p.push(selfCloseElement("col", attrs(colAttrs)));
+		}
+		p.push("</cols>");
+	}
+	p.push("<sheetData>");
+	for (let i = 0; i < rows.length; i++) {
+		const rowOpts = rows[i];
+		const rowNumber = rowOpts.rowNumber ?? i + 1;
+		const rowAttrs = { r: rowNumber };
+		if (rowOpts.height !== void 0) {
+			rowAttrs.ht = rowOpts.height;
+			rowAttrs.customHeight = 1;
+		}
+		if (rowOpts.hidden) rowAttrs.hidden = 1;
+		if (rowOpts.spans) rowAttrs.spans = rowOpts.spans;
+		if (rowOpts.customFormat) rowAttrs.customFormat = 1;
+		if (rowOpts.thickTop) rowAttrs.thickTop = 1;
+		if (rowOpts.thickBot) rowAttrs.thickBot = 1;
+		if (rowOpts.ph) rowAttrs.ph = 1;
+		if (rowOpts.cells) {
+			p.push(`<row${attrsRaw(rowAttrs)}>`);
+			for (let j = 0; j < rowOpts.cells.length; j++) {
+				const cell = rowOpts.cells[j];
+				const cellStr = buildCellString(cell.reference ?? defaultCellRef(rowNumber, j + 1), cell, sharedStrings, styles);
+				if (cellStr) p.push(cellStr);
+			}
+			p.push("</row>");
+		} else p.push(`<row${attrsRaw(rowAttrs)}/>`);
+	}
+	p.push("</sheetData>");
+	if (opts.sheetCalcPr) {
+		const scAttrs = [];
+		if (opts.sheetCalcPr.fullCalcOnLoad) scAttrs.push("fullCalcOnLoad=\"1\"");
+		p.push(`<sheetCalcPr${scAttrs.length ? " " + scAttrs.join(" ") : ""}/>`);
+	}
+	if (rowBreaks.length > 0) {
+		const brkParts = rowBreaks.map((b) => {
+			const bAttrs = { id: b.id };
+			if (b.min !== void 0) bAttrs.min = b.min;
+			if (b.max !== void 0) bAttrs.max = b.max;
+			if (b.manual) bAttrs.man = 1;
+			if (b.pivot) bAttrs.pt = 1;
+			return `<brk${attrs(bAttrs)}/>`;
+		});
+		p.push(`<rowBreaks count="${rowBreaks.length}" manualBreakCount="${rowBreaks.filter((b) => b.manual).length}">${brkParts.join("")}</rowBreaks>`);
+	}
+	if (colBreaks.length > 0) {
+		const brkParts = colBreaks.map((b) => {
+			const bAttrs = { id: b.id };
+			if (b.min !== void 0) bAttrs.min = b.min;
+			if (b.max !== void 0) bAttrs.max = b.max;
+			if (b.manual) bAttrs.man = 1;
+			if (b.pivot) bAttrs.pt = 1;
+			return `<brk${attrs(bAttrs)}/>`;
+		});
+		p.push(`<colBreaks count="${colBreaks.length}" manualBreakCount="${colBreaks.filter((b) => b.manual).length}">${brkParts.join("")}</colBreaks>`);
+	}
+	if (customProperties.length > 0) {
+		const cpParts = ["<customProperties>"];
+		for (const cp of customProperties) cpParts.push(`<customPr name="${escapeXml(cp.name)}" r:id="${escapeXml(cp.rId)}"/>`);
+		cpParts.push("</customProperties>");
+		p.push(cpParts.join(""));
+	}
+	if (opts.oleSize) p.push(`<oleSize ref="${escapeXml(opts.oleSize)}"/>`);
+	if (customSheetViews.length > 0) {
+		p.push("<customSheetViews>");
+		for (const csv of customSheetViews) {
+			const csvAttrs = { guid: csv.guid };
+			if (csv.scale !== void 0) csvAttrs.scale = csv.scale;
+			if (csv.showPageBreaks) csvAttrs.showPageBreaks = 1;
+			if (csv.showFormulas) csvAttrs.showFormulas = 1;
+			if (csv.showGridLines === false) csvAttrs.showGridLines = 0;
+			if (csv.showRowColHeaders === false) csvAttrs.showRowCol = 0;
+			if (csv.outlineSymbols === false) csvAttrs.outlineSymbols = 0;
+			if (csv.zeroValues === false) csvAttrs.zeroValues = 0;
+			if (csv.fitToPage) csvAttrs.fitToPage = 1;
+			if (csv.printArea) csvAttrs.printArea = 1;
+			if (csv.filter) csvAttrs.filter = 1;
+			if (csv.showAutoFilter) csvAttrs.showAutoFilter = 1;
+			if (csv.hiddenRows) csvAttrs.hiddenRows = 1;
+			if (csv.hiddenColumns) csvAttrs.hiddenColumns = 1;
+			if (csv.state && csv.state !== "visible") csvAttrs.state = csv.state;
+			if (csv.filterUnique) csvAttrs.filterUnique = 1;
+			if (csv.view && csv.view !== "normal") csvAttrs.view = csv.view;
+			p.push(`<customSheetView${attrs(csvAttrs)}/>`);
+		}
+		p.push("</customSheetViews>");
+	}
+	if (cellWatches.length > 0) {
+		p.push("<cellWatches>");
+		for (const cw of cellWatches) p.push(`<cellWatch r="${escapeXml(cw.r)}"/>`);
+		p.push("</cellWatches>");
+	}
+	if (opts.dataConsolidate) {
+		const dc = opts.dataConsolidate;
+		const dcAttrs = {};
+		if (dc.function && dc.function !== "sum") dcAttrs.function = dc.function;
+		if (dc.topLabels) dcAttrs.topLabels = 1;
+		if (dc.leftLabels) dcAttrs.leftLabels = 1;
+		if (dc.startLabels) dcAttrs.startLabels = 1;
+		if (dc.link) dcAttrs.link = 1;
+		const refsInner = dc.refs?.map((r) => `<dataRef ref="${escapeXml(r)}"/>`).join("") ?? "";
+		const refsXml = refsInner ? `<dataRefs>${refsInner}</dataRefs>` : "";
+		if (refsXml || Object.keys(dcAttrs).length > 0) p.push(`<dataConsolidate${attrs(dcAttrs)}>${refsXml}</dataConsolidate>`);
+	}
+	if (opts.protection) {
+		const prot = opts.protection;
+		const protAttrs = {};
+		if (prot.password) protAttrs.password = hashPassword(prot.password);
+		let derived;
+		if (prot.password !== void 0 && prot.hashValue === void 0) derived = derivePasswordHash(prot.password);
+		protAttrs.algorithmName = prot.algorithmName ?? derived?.algorithmName;
+		protAttrs.hashValue = prot.hashValue ?? derived?.hashValue;
+		protAttrs.saltValue = prot.saltValue ?? derived?.saltValue;
+		if (prot.spinCount !== void 0) protAttrs.spinCount = prot.spinCount;
+		else if (derived) protAttrs.spinCount = derived.spinCount;
+		if (prot.sheet) protAttrs.sheet = 1;
+		if (prot.objects) protAttrs.objects = 1;
+		if (prot.scenarios) protAttrs.scenarios = 1;
+		if (prot.formatCells === false) protAttrs.formatCells = 0;
+		if (prot.formatColumns === false) protAttrs.formatColumns = 0;
+		if (prot.formatRows === false) protAttrs.formatRows = 0;
+		if (prot.insertColumns === false) protAttrs.insertColumns = 0;
+		if (prot.insertRows === false) protAttrs.insertRows = 0;
+		if (prot.insertHyperlinks === false) protAttrs.insertHyperlinks = 0;
+		if (prot.deleteColumns === false) protAttrs.deleteColumns = 0;
+		if (prot.deleteRows === false) protAttrs.deleteRows = 0;
+		if (prot.selectLockedCells) protAttrs.selectLockedCells = 1;
+		if (prot.sort === false) protAttrs.sort = 0;
+		if (prot.autoFilter === false) protAttrs.autoFilter = 0;
+		if (prot.pivotTables === false) protAttrs.pivotTables = 0;
+		if (prot.selectUnlockedCells) protAttrs.selectUnlockedCells = 1;
+		p.push(selfCloseElement("sheetProtection", attrs(protAttrs)));
+	}
+	if (protectedRanges.length > 0) {
+		const prParts = ["<protectedRanges>"];
+		for (const pr of protectedRanges) {
+			const prAttrs = {
+				name: pr.name,
+				sqref: pr.sqref
+			};
+			if (pr.password) prAttrs.password = hashPassword(pr.password);
+			let prDerived;
+			if (pr.password !== void 0 && pr.hashValue === void 0) prDerived = derivePasswordHash(pr.password);
+			prAttrs.algorithmName = pr.algorithmName ?? prDerived?.algorithmName;
+			prAttrs.hashValue = pr.hashValue ?? prDerived?.hashValue;
+			prAttrs.saltValue = pr.saltValue ?? prDerived?.saltValue;
+			if (pr.spinCount !== void 0) prAttrs.spinCount = pr.spinCount;
+			else if (prDerived) prAttrs.spinCount = prDerived.spinCount;
+			if (!!pr.securityDescriptor) prParts.push(`<protectedRange${attrs(prAttrs)}><securityDescriptor>${escapeXml(pr.securityDescriptor)}</securityDescriptor></protectedRange>`);
+			else prParts.push(selfCloseElement("protectedRange", attrs(prAttrs)));
+		}
+		prParts.push("</protectedRanges>");
+		p.push(prParts.join(""));
+	}
+	if (opts.scenarios) {
+		const scParts = ["<scenarios"];
+		const scAttrs = {};
+		if (opts.scenarios.current !== void 0) scAttrs.current = opts.scenarios.current;
+		if (opts.scenarios.show !== void 0) scAttrs.show = opts.scenarios.show;
+		scParts[0] = `<scenarios${attrs(scAttrs)}>`;
+		for (const scenario of opts.scenarios.scenarios) {
+			const sAttrs = { name: scenario.name };
+			if (scenario.count !== void 0) sAttrs.count = scenario.count;
+			if (scenario.user) sAttrs.user = scenario.user;
+			if (scenario.comment) sAttrs.comment = scenario.comment;
+			if (scenario.hidden) sAttrs.hidden = true;
+			if (scenario.locked) sAttrs.locked = true;
+			const sParts = [`<scenario${attrs(sAttrs)}>`];
+			for (const cell of scenario.inputCells) {
+				const icAttrs = {
+					r: cell.r,
+					val: String(cell.val)
+				};
+				if (cell.deleted) icAttrs.deleted = true;
+				if (cell.undone) icAttrs.undone = true;
+				sParts.push(`<inputCells${attrs(icAttrs)}/>`);
+			}
+			sParts.push("</scenario>");
+			scParts.push(sParts.join(""));
+		}
+		scParts.push("</scenarios>");
+		p.push(scParts.join(""));
+	}
+	if (opts.autoFilter) if (typeof opts.autoFilter === "string") p.push(selfCloseElement("autoFilter", attrs({ ref: opts.autoFilter })));
+	else {
+		const af = opts.autoFilter;
+		const inner = [];
+		for (const t10 of af.top10 ?? []) {
+			const fcAttrs = { colId: t10.colId };
+			if (t10.hiddenButton) fcAttrs.hiddenButton = 1;
+			if (t10.showButton === false) fcAttrs.showButton = 0;
+			const t10Attrs = { val: t10.val };
+			if (t10.top === false) t10Attrs.top = 0;
+			if (t10.percent) t10Attrs.percent = 1;
+			if (t10.filterVal !== void 0) t10Attrs.filterVal = t10.filterVal;
+			inner.push(`<filterColumn${attrs(fcAttrs)}><top10${attrs(t10Attrs)}/></filterColumn>`);
+		}
+		for (const cf of af.customFilters ?? []) {
+			const fcAttrs = { colId: cf.colId };
+			if (cf.hiddenButton) fcAttrs.hiddenButton = 1;
+			if (cf.showButton === false) fcAttrs.showButton = 0;
+			const cfAttrs = {};
+			if (cf.and) cfAttrs.and = 1;
+			const filters = [];
+			if (cf.val !== void 0) {
+				const fAttrs = { val: cf.val };
+				if (cf.operator) fAttrs.operator = cf.operator;
+				filters.push(selfCloseElement("customFilter", attrs(fAttrs)));
+			}
+			if (cf.val2 !== void 0) filters.push(selfCloseElement("customFilter", attrs({ val: cf.val2 })));
+			if (filters.length > 0) inner.push(`<filterColumn${attrs(fcAttrs)}><customFilters${attrs(cfAttrs)}>${filters.join("")}</customFilters></filterColumn>`);
+		}
+		for (const fi of af.filters ?? []) {
+			const fcAttrs = { colId: fi.colId };
+			const filtersAttrs = {};
+			if (fi.blank) filtersAttrs.blank = 1;
+			if (fi.calendarType) filtersAttrs.calendarType = fi.calendarType;
+			const valParts = (fi.values ?? []).map((v) => `<filter val="${escapeXml(v)}"/>`);
+			inner.push(`<filterColumn${attrs(fcAttrs)}><filters${attrs(filtersAttrs)}>${valParts.join("")}</filters></filterColumn>`);
+		}
+		if (af.sort && af.sort.length > 0) {
+			const sortParts = [];
+			for (const sc of af.sort) {
+				const scAttrs = { ref: sc.ref };
+				if (sc.descending) scAttrs.descending = 1;
+				if (sc.sortBy) scAttrs.sortBy = sc.sortBy;
+				if (sc.customList) scAttrs.customList = sc.customList;
+				if (sc.iconId !== void 0) scAttrs.iconId = sc.iconId;
+				sortParts.push(selfCloseElement("sortCondition", attrs(scAttrs)));
+			}
+			const ssAttrs = { ref: af.ref };
+			if (af.sortState?.columnSort) ssAttrs.columnSort = 1;
+			if (af.sortState?.caseSensitive) ssAttrs.caseSensitive = 1;
+			if (af.sortState?.sortMethod) ssAttrs.sortMethod = af.sortState.sortMethod;
+			inner.push(`<sortState${attrs(ssAttrs)}>${sortParts.join("")}</sortState>`);
+		}
+		for (const cf of af.colorFilters ?? []) {
+			const cfAttrs = {};
+			if (cf.dxfId !== void 0) cfAttrs.dxfId = cf.dxfId;
+			if (cf.cellColor === false) cfAttrs.cellColor = 0;
+			inner.push(`<filterColumn colId="${cf.colId}"><colorFilter${attrs(cfAttrs)}/></filterColumn>`);
+		}
+		for (const if_ of af.iconFilters ?? []) {
+			const ifAttrs = { iconSet: if_.iconSet };
+			if (if_.iconId !== void 0) ifAttrs.iconId = if_.iconId;
+			inner.push(`<filterColumn colId="${if_.colId}"><iconFilter${attrs(ifAttrs)}/></filterColumn>`);
+		}
+		for (const df of af.dynamicFilters ?? []) {
+			const dfAttrs = { type: df.type };
+			if (df.val !== void 0) dfAttrs.val = df.val;
+			if (df.maxVal !== void 0) dfAttrs.maxVal = df.maxVal;
+			if (df.valIso !== void 0) dfAttrs.valIso = df.valIso;
+			if (df.maxValIso !== void 0) dfAttrs.maxValIso = df.maxValIso;
+			inner.push(`<filterColumn colId="${df.colId}"><dynamicFilter${attrs(dfAttrs)}/></filterColumn>`);
+		}
+		for (const dg of af.dateGroupItems ?? []) {
+			const dgAttrs = { dateTimeGrouping: dg.dateTimeGrouping };
+			if (dg.year !== void 0) dgAttrs.year = dg.year;
+			if (dg.month !== void 0) dgAttrs.month = dg.month;
+			if (dg.day !== void 0) dgAttrs.day = dg.day;
+			if (dg.hour !== void 0) dgAttrs.hour = dg.hour;
+			if (dg.minute !== void 0) dgAttrs.minute = dg.minute;
+			if (dg.second !== void 0) dgAttrs.second = dg.second;
+			inner.push(`<filterColumn colId="${dg.colId}"><dateGroupItem${attrs(dgAttrs)}/></filterColumn>`);
+		}
+		if (inner.length > 0) p.push(`<autoFilter ref="${af.ref}">`, ...inner, "</autoFilter>");
+		else p.push(selfCloseElement("autoFilter", attrs({ ref: af.ref })));
+	}
+	if (mergeCells.length > 0) {
+		p.push(`<mergeCells count="${mergeCells.length}">`);
+		for (const mc of mergeCells) {
+			const fromRef = defaultCellRef(mc.from.row, mc.from.col);
+			const toRef = defaultCellRef(mc.to.row, mc.to.col);
+			p.push(selfCloseElement("mergeCell", attrs({ ref: `${fromRef}:${toRef}` })));
+		}
+		p.push("</mergeCells>");
+	}
+	if (opts.phoneticPr) {
+		const pp = opts.phoneticPr;
+		const ppAttrs = { fontId: pp.fontId };
+		if (pp.type && pp.type !== "fullwidthKatakana") ppAttrs.type = pp.type;
+		if (pp.alignment && pp.alignment !== "left") ppAttrs.alignment = pp.alignment;
+		p.push(selfCloseElement("phoneticPr", attrs(ppAttrs)));
+	}
+	const conditionalFormats = opts.conditionalFormats ?? [];
+	if (conditionalFormats.length > 0) for (const cf of conditionalFormats) {
+		p.push(`<conditionalFormatting sqref="${cf.sqref}">`);
+		for (let ri = 0; ri < cf.rules.length; ri++) {
+			const rule = cf.rules[ri];
+			const ruleAttrs = {
+				type: rule.type,
+				priority: rule.priority ?? ri + 1
+			};
+			if (rule.operator) ruleAttrs.operator = rule.operator;
+			if (rule.dxfId !== void 0) ruleAttrs.dxfId = rule.dxfId;
+			if (rule.stopIfTrue) ruleAttrs.stopIfTrue = 1;
+			if (rule.timePeriod) ruleAttrs.timePeriod = rule.timePeriod;
+			if (rule.rank !== void 0) ruleAttrs.rank = rule.rank;
+			if (rule.equalAverage) ruleAttrs.equalAverage = 1;
+			if (rule.type === "colorScale" && rule.colorScale) {
+				const cs = rule.colorScale;
+				const inner = [];
+				for (const v of cs.cfvo) inner.push(buildCfvoXml(v));
+				for (const c of cs.colors) inner.push(`<color rgb="FF${c}"/>`);
+				p.push(`<cfRule${attrs(ruleAttrs)}><colorScale>${inner.join("")}</colorScale></cfRule>`);
+			} else if (rule.type === "dataBar" && rule.dataBar) {
+				const db = rule.dataBar;
+				const inner = [];
+				for (const v of db.cfvo) inner.push(buildCfvoXml(v));
+				inner.push(`<color rgb="FF${db.color}"/>`);
+				const dbAttrs = {};
+				if (db.minLength !== void 0 && db.minLength !== 10) dbAttrs.minLength = db.minLength;
+				if (db.maxLength !== void 0 && db.maxLength !== 90) dbAttrs.maxLength = db.maxLength;
+				if (db.showValue === false) dbAttrs.showValue = 0;
+				const attrStr = Object.keys(dbAttrs).length > 0 ? attrs(dbAttrs) : "";
+				p.push(`<cfRule${attrs(ruleAttrs)}><dataBar${attrStr}>${inner.join("")}</dataBar></cfRule>`);
+			} else if (rule.type === "iconSet" && rule.iconSet) {
+				const is = rule.iconSet;
+				const inner = [];
+				for (const v of is.cfvo) inner.push(buildCfvoXml(v));
+				const isAttrs = {};
+				if (is.iconSet !== void 0 && is.iconSet !== "3TrafficLights1") isAttrs.iconSet = is.iconSet;
+				if (is.showValue === false) isAttrs.showValue = 0;
+				if (is.percent === false) isAttrs.percent = 0;
+				if (is.reverse) isAttrs.reverse = 1;
+				const attrStr = Object.keys(isAttrs).length > 0 ? attrs(isAttrs) : "";
+				p.push(`<cfRule${attrs(ruleAttrs)}><iconSet${attrStr}>${inner.join("")}</iconSet></cfRule>`);
+			} else if (rule.formulas && rule.formulas.length > 0) {
+				const formulaParts = rule.formulas.map((f) => `<formula>${escapeXml(f)}</formula>`);
+				p.push(`<cfRule${attrs(ruleAttrs)}>`, ...formulaParts, "</cfRule>");
+			} else p.push(selfCloseElement("cfRule", attrs(ruleAttrs)));
+		}
+		p.push("</conditionalFormatting>");
+	}
+	const dataValidations = opts.dataValidations ?? [];
+	if (dataValidations.length > 0) {
+		const dvContainerAttrs = { count: dataValidations.length };
+		if (opts.dataValidationsDisablePrompts) dvContainerAttrs.disablePrompts = 1;
+		p.push(`<dataValidations${attrs(dvContainerAttrs)}>`);
+		for (const dv of dataValidations) {
+			const dvAttrs = { sqref: dv.sqref };
+			if (dv.type && dv.type !== "none") dvAttrs.type = dv.type;
+			if (dv.operator) dvAttrs.operator = dv.operator;
+			if (dv.allowBlank) dvAttrs.allowBlank = 1;
+			if (dv.showErrorMessage) dvAttrs.showErrorMessage = 1;
+			if (dv.showInputMessage) dvAttrs.showInputMessage = 1;
+			if (dv.errorTitle) dvAttrs.errorTitle = dv.errorTitle;
+			if (dv.error) dvAttrs.error = dv.error;
+			if (dv.promptTitle) dvAttrs.promptTitle = dv.promptTitle;
+			if (dv.prompt) dvAttrs.prompt = dv.prompt;
+			if (dv.errorStyle) dvAttrs.errorStyle = dv.errorStyle;
+			if (dv.imeMode) dvAttrs.imeMode = dv.imeMode;
+			if (dv.showDropDown) dvAttrs.showDropDown = 1;
+			const inner = [];
+			if (dv.formula1 !== void 0) inner.push(`<formula1>${escapeXml(dv.formula1)}</formula1>`);
+			if (dv.formula2 !== void 0) inner.push(`<formula2>${escapeXml(dv.formula2)}</formula2>`);
+			if (inner.length > 0) p.push(`<dataValidation${attrs(dvAttrs)}>`, ...inner, "</dataValidation>");
+			else p.push(selfCloseElement("dataValidation", attrs(dvAttrs)));
+		}
+		p.push("</dataValidations>");
+	}
+	const hyperlinks = opts.hyperlinks ?? [];
+	if (hyperlinks.length > 0) {
+		p.push("<hyperlinks>");
+		let hlIdx = 0;
+		for (const hl of hyperlinks) {
+			const hlAttrs = { ref: hl.cell };
+			if (hl.target.type === "external") {
+				hlIdx++;
+				hlAttrs["r:id"] = `rId${hlIdx}`;
+			} else hlAttrs.location = hl.target.location;
+			if (hl.tooltip) hlAttrs.tooltip = hl.tooltip;
+			if (hl.display) hlAttrs.display = hl.display;
+			p.push(selfCloseElement("hyperlink", attrs(hlAttrs)));
+		}
+		p.push("</hyperlinks>");
+	}
+	if (opts.printOptions) {
+		const po = opts.printOptions;
+		const poAttrs = {};
+		if (po.horizontalCentered) poAttrs.horizontalCentered = 1;
+		if (po.verticalCentered) poAttrs.verticalCentered = 1;
+		if (po.headings) poAttrs.headings = 1;
+		if (po.gridLines) poAttrs.gridLines = 1;
+		if (po.gridLinesSet === false) poAttrs.gridLinesSet = 0;
+		p.push(selfCloseElement("printOptions", attrs(poAttrs)));
+	}
+	p.push("<pageMargins left=\"0.75\" right=\"0.75\" top=\"1\" bottom=\"1\" header=\"0.5\" footer=\"0.5\"/>");
+	if (opts.pageSetup) {
+		const ps = opts.pageSetup;
+		const psAttrs = {};
+		if (ps.paperSize !== void 0) psAttrs.paperSize = ps.paperSize;
+		if (ps.orientation && ps.orientation !== "default") psAttrs.orientation = ps.orientation;
+		if (ps.scale !== void 0) psAttrs.scale = ps.scale;
+		if (ps.fitToWidth !== void 0) psAttrs.fitToWidth = ps.fitToWidth;
+		if (ps.fitToHeight !== void 0) psAttrs.fitToHeight = ps.fitToHeight;
+		if (ps.pageOrder && ps.pageOrder !== "downThenOver") psAttrs.pageOrder = ps.pageOrder;
+		if (ps.useFirstPageNumber) psAttrs.useFirstPageNumber = 1;
+		if (ps.firstPageNumber !== void 0) psAttrs.firstPageNumber = ps.firstPageNumber;
+		if (ps.paperHeight !== void 0) psAttrs.paperHeight = ps.paperHeight;
+		if (ps.paperWidth !== void 0) psAttrs.paperWidth = ps.paperWidth;
+		if (ps.usePrinterDefaults) psAttrs.usePrinterDefaults = 1;
+		if (ps.blackAndWhite) psAttrs.blackAndWhite = 1;
+		if (ps.draft) psAttrs.draft = 1;
+		if (ps.cellComments && ps.cellComments !== "none") psAttrs.cellComments = ps.cellComments;
+		if (ps.errors && ps.errors !== "displayed") psAttrs.errors = ps.errors;
+		p.push(selfCloseElement("pageSetup", attrs(psAttrs)));
+	}
+	if (opts.headerFooter) {
+		const hf = opts.headerFooter;
+		const hfAttrs = {};
+		if (hf.differentOddEven) hfAttrs.differentOddEven = 1;
+		if (hf.differentFirst) hfAttrs.differentFirst = 1;
+		if (hf.scaleWithDoc === false) hfAttrs.scaleWithDoc = 0;
+		if (hf.alignWithMargins === false) hfAttrs.alignWithMargins = 0;
+		const inner = [];
+		if (hf.oddHeader) inner.push(`<oddHeader>${escapeXml(hf.oddHeader)}</oddHeader>`);
+		if (hf.oddFooter) inner.push(`<oddFooter>${escapeXml(hf.oddFooter)}</oddFooter>`);
+		if (hf.evenHeader) inner.push(`<evenHeader>${escapeXml(hf.evenHeader)}</evenHeader>`);
+		if (hf.evenFooter) inner.push(`<evenFooter>${escapeXml(hf.evenFooter)}</evenFooter>`);
+		if (hf.firstHeader) inner.push(`<firstHeader>${escapeXml(hf.firstHeader)}</firstHeader>`);
+		if (hf.firstFooter) inner.push(`<firstFooter>${escapeXml(hf.firstFooter)}</firstFooter>`);
+		if (inner.length > 0) p.push(`<headerFooter${attrs(hfAttrs)}>`, ...inner, "</headerFooter>");
+		else if (hfAttrs.differentOddEven || hfAttrs.differentFirst) p.push(selfCloseElement("headerFooter", attrs(hfAttrs)));
+	}
+	if (opts.drawingHF) {
+		const dhf = opts.drawingHF;
+		const dhfAttrs = { "r:id": dhf.rId };
+		if (dhf.lho !== void 0) dhfAttrs.lho = dhf.lho;
+		if (dhf.lhe !== void 0) dhfAttrs.lhe = dhf.lhe;
+		if (dhf.lhf !== void 0) dhfAttrs.lhf = dhf.lhf;
+		if (dhf.cho !== void 0) dhfAttrs.cho = dhf.cho;
+		if (dhf.che !== void 0) dhfAttrs.che = dhf.che;
+		if (dhf.chf !== void 0) dhfAttrs.chf = dhf.chf;
+		if (dhf.rho !== void 0) dhfAttrs.rho = dhf.rho;
+		if (dhf.rhe !== void 0) dhfAttrs.rhe = dhf.rhe;
+		if (dhf.rhf !== void 0) dhfAttrs.rhf = dhf.rhf;
+		if (dhf.lfo !== void 0) dhfAttrs.lfo = dhf.lfo;
+		if (dhf.lfe !== void 0) dhfAttrs.lfe = dhf.lfe;
+		if (dhf.lff !== void 0) dhfAttrs.lff = dhf.lff;
+		if (dhf.cfo !== void 0) dhfAttrs.cfo = dhf.cfo;
+		if (dhf.cfe !== void 0) dhfAttrs.cfe = dhf.cfe;
+		if (dhf.cff !== void 0) dhfAttrs.cff = dhf.cff;
+		if (dhf.rfo !== void 0) dhfAttrs.rfo = dhf.rfo;
+		if (dhf.rfe !== void 0) dhfAttrs.rfe = dhf.rfe;
+		if (dhf.rff !== void 0) dhfAttrs.rff = dhf.rff;
+		p.push(selfCloseElement("drawingHF", attrs(dhfAttrs)));
+	}
+	if (opts.legacyDrawingHF) p.push(`<legacyDrawingHF r:id="${escapeXml(opts.legacyDrawingHF)}"/>`);
+	if (ignoredErrors.length > 0) {
+		const ieParts = ["<ignoredErrors>"];
+		for (const ie of ignoredErrors) {
+			const ieAttrs = { sqref: ie.sqref };
+			if (ie.evalError) ieAttrs.evalError = 1;
+			if (ie.twoDigitTextYear) ieAttrs.twoDigitTextYear = 1;
+			if (ie.numberStoredAsText) ieAttrs.numberStoredAsText = 1;
+			if (ie.formula) ieAttrs.formula = 1;
+			if (ie.formulaRange) ieAttrs.formulaRange = 1;
+			if (ie.unlockedFormula) ieAttrs.unlockedFormula = 1;
+			if (ie.emptyCellReference) ieAttrs.emptyCellReference = 1;
+			if (ie.listDataValidation) ieAttrs.listDataValidation = 1;
+			if (ie.calculatedColumn) ieAttrs.calculatedColumn = 1;
+			ieParts.push(selfCloseElement("ignoredError", attrs(ieAttrs)));
+		}
+		ieParts.push("</ignoredErrors>");
+		p.push(ieParts.join(""));
+	}
+	if (opts.backgroundImage) p.push("<!--BACKGROUND_PICTURE-->");
+	if (oleObjects.length > 0) {
+		const oleParts = ["<oleObjects>"];
+		for (const ole of oleObjects) {
+			const oleAttrs = [`shapeId="${ole.shapeId}"`];
+			if (ole.progId) oleAttrs.push(`progId="${escapeXml(ole.progId)}"`);
+			if (ole.dvAspect && ole.dvAspect !== "DVASPECT_CONTENT") oleAttrs.push(`dvAspect="${ole.dvAspect}"`);
+			if (ole.link) oleAttrs.push(`link="${escapeXml(ole.link)}"`);
+			if (ole.oleUpdate) oleAttrs.push(`oleUpdate="${ole.oleUpdate}"`);
+			if (ole.autoLoad) oleAttrs.push("autoLoad=\"1\"");
+			if (ole.rId) oleAttrs.push(`r:id="${escapeXml(ole.rId)}"`);
+			if (ole.objectPr) {
+				const opr = ole.objectPr;
+				const oprAttrs = [];
+				if (opr.locked === false) oprAttrs.push("locked=\"0\"");
+				if (opr.defaultSize === false) oprAttrs.push("defaultSize=\"0\"");
+				if (opr.print === false) oprAttrs.push("print=\"0\"");
+				if (opr.disabled) oprAttrs.push("disabled=\"1\"");
+				if (opr.uiObject) oprAttrs.push("uiObject=\"1\"");
+				if (opr.autoFill === false) oprAttrs.push("autoFill=\"0\"");
+				if (opr.autoLine === false) oprAttrs.push("autoLine=\"0\"");
+				if (opr.autoPict === false) oprAttrs.push("autoPict=\"0\"");
+				if (opr.macro) oprAttrs.push(`macro="${escapeXml(opr.macro)}"`);
+				if (opr.altText) oprAttrs.push(`altText="${escapeXml(opr.altText)}"`);
+				if (opr.dde) oprAttrs.push("dde=\"1\"");
+				if (opr.rId) oprAttrs.push(`r:id="${escapeXml(opr.rId)}"`);
+				oleParts.push(`<oleObject ${oleAttrs.join(" ")}><objectPr${oprAttrs.length ? " " + oprAttrs.join(" ") : ""}/></oleObject>`);
+			} else oleParts.push(`<oleObject ${oleAttrs.join(" ")}/>`);
+		}
+		oleParts.push("</oleObjects>");
+		p.push(oleParts.join(""));
+	}
+	if (controls.length > 0) {
+		const ctrlParts = ["<controls>"];
+		for (const c of controls) {
+			const cAttrs = [`shapeId="${c.shapeId}"`, `r:id="${escapeXml(c.rId)}"`];
+			if (c.name) cAttrs.push(`name="${escapeXml(c.name)}"`);
+			const prAttrs = [];
+			if (c.locked === false) prAttrs.push("locked=\"0\"");
+			if (c.uiObject) prAttrs.push("uiObject=\"1\"");
+			if (c.recalcAlways) prAttrs.push("recalcAlways=\"1\"");
+			if (c.linkedCell) prAttrs.push(`linkedCell="${escapeXml(c.linkedCell)}"`);
+			if (c.listFillRange) prAttrs.push(`listFillRange="${escapeXml(c.listFillRange)}"`);
+			if (c.cf) prAttrs.push(`cf="${escapeXml(c.cf)}"`);
+			if (prAttrs.length > 0) ctrlParts.push(`<control ${cAttrs.join(" ")}><controlPr${prAttrs.length ? " " + prAttrs.join(" ") : ""}/></control>`);
+			else ctrlParts.push(`<control ${cAttrs.join(" ")}/>`);
+		}
+		ctrlParts.push("</controls>");
+		p.push(ctrlParts.join(""));
+	}
+	if (webPublishItems.length > 0) {
+		const wpParts = [`<webPublishItems count="${webPublishItems.length}">`];
+		for (const wpi of webPublishItems) {
+			const wpiAttrs = [
+				`id="${wpi.id}"`,
+				`divId="${escapeXml(wpi.divId)}"`,
+				`sourceType="${wpi.sourceType}"`,
+				`destinationFile="${escapeXml(wpi.destinationFile)}"`
+			];
+			if (wpi.sourceRef) wpiAttrs.push(`sourceRef="${escapeXml(wpi.sourceRef)}"`);
+			if (wpi.sourceObject) wpiAttrs.push(`sourceObject="${escapeXml(wpi.sourceObject)}"`);
+			if (wpi.title) wpiAttrs.push(`title="${escapeXml(wpi.title)}"`);
+			if (wpi.autoRepublish) wpiAttrs.push("autoRepublish=\"1\"");
+			wpParts.push(`<webPublishItem ${wpiAttrs.join(" ")}/>`);
+		}
+		wpParts.push("</webPublishItems>");
+		p.push(wpParts.join(""));
+	}
+	if (opts.ext) p.push(`<extLst>${opts.ext}</extLst>`);
+	p.push("</worksheet>");
+	return p.join("");
+}
+function buildCfvoXml(cfvo) {
+	const a = { type: cfvo.type };
+	if (cfvo.val !== void 0) a.val = cfvo.val;
+	if (cfvo.gte === false) a.gte = 0;
+	return `<cfvo${attrs(a)}/>`;
+}
+function buildSheetViewAttrs(sv) {
+	const svMap = { workbookViewId: 0 };
+	if (sv?.tabSelected !== void 0) svMap.tabSelected = sv.tabSelected ? 1 : 0;
+	else svMap.tabSelected = 1;
+	if (sv?.showGridLines === false) svMap.showGridLines = 0;
+	if (sv?.showRowColHeaders === false) svMap.showRowColHeaders = 0;
+	if (sv?.showZeros === false) svMap.showZeros = 0;
+	if (sv?.zoomScale !== void 0) svMap.zoomScale = sv.zoomScale;
+	if (sv?.rightToLeft) svMap.rightToLeft = 1;
+	if (sv?.windowProtection) svMap.windowProtection = 1;
+	if (sv?.showFormulas) svMap.showFormulas = 1;
+	if (sv?.showRuler === false) svMap.showRuler = 0;
+	if (sv?.showOutlineSymbols === false) svMap.showOutlineSymbols = 0;
+	if (sv?.defaultGridColor === false) svMap.defaultGridColor = 0;
+	if (sv?.showWhiteSpace === false) svMap.showWhiteSpace = 0;
+	if (sv?.view) svMap.view = sv.view;
+	if (sv?.colorId !== void 0) svMap.colorId = sv.colorId;
+	if (sv?.zoomScaleNormal !== void 0) svMap.zoomScaleNormal = sv.zoomScaleNormal;
+	if (sv?.zoomScaleSheetLayoutView !== void 0) svMap.zoomScaleSheetLayoutView = sv.zoomScaleSheetLayoutView;
+	if (sv?.zoomScalePageLayoutView !== void 0) svMap.zoomScalePageLayoutView = sv.zoomScalePageLayoutView;
+	return attrs(svMap);
+}
+function buildSelectionXml(sel) {
+	const selAttrs = {};
+	if (sel.pane) selAttrs.pane = sel.pane;
+	if (sel.activeCell) selAttrs.activeCell = sel.activeCell;
+	if (sel.activeCellId !== void 0) selAttrs.activeCellId = sel.activeCellId;
+	if (sel.sqref) selAttrs.sqref = sel.sqref;
+	return `<selection${attrs(selAttrs)}/>`;
+}
+function buildPivotSelectionXml(_ps) {
+	return "";
+}
+function hashPassword(password) {
+	let hash = 0;
+	for (let i = 0; i < password.length; i++) {
+		const c = password.charCodeAt(i);
+		hash = (hash >> 14 & 1) + (hash << 1 & 32767);
+		hash ^= c;
+		hash = hash & 16384 ? hash ^ 1 : hash;
+	}
+	hash = (hash >> 14 & 1) + (hash << 1 & 32767);
+	hash = (hash >> 14 & 1) + (hash << 1 & 32767);
+	hash ^= password.length;
+	return hash.toString(16).toUpperCase().padStart(4, "0");
+}
+function buildFormulaString(fOpts) {
+	const fAttrs = {};
+	if (fOpts.type && fOpts.type !== FormulaType.NORMAL) fAttrs.t = fOpts.type;
+	if (fOpts.reference) fAttrs.ref = fOpts.reference;
+	if (fOpts.sharedIndex !== void 0) fAttrs.si = fOpts.sharedIndex;
+	if (fOpts.aca) fAttrs.aca = 1;
+	if (fOpts.dt2D) fAttrs.dt2D = 1;
+	if (fOpts.dtr) fAttrs.dtr = 1;
+	if (fOpts.del1) fAttrs.del1 = 1;
+	if (fOpts.del2) fAttrs.del2 = 1;
+	if (fOpts.r1) fAttrs.r1 = fOpts.r1;
+	if (fOpts.r2) fAttrs.r2 = fOpts.r2;
+	if (fOpts.ca) fAttrs.ca = 1;
+	if (fOpts.bx) fAttrs.bx = 1;
+	if (fOpts.formula !== void 0 && fOpts.formula !== "") return `<f${attrs(fAttrs)}>${escapeXml(fOpts.formula)}</f>`;
+	if (Object.keys(fAttrs).length > 0) return selfCloseElement("f", attrs(fAttrs));
+	return "";
+}
+function buildCellString(ref, cell, sharedStrings, styles) {
+	const cellAttrs = { r: ref };
+	if (cell.style !== void 0 && styles) cellAttrs.s = styles.register(cell.style);
+	else if (cell.styleIndex !== void 0) cellAttrs.s = cell.styleIndex;
+	const value = cell.value;
+	if (cell.formula) {
+		const fStr = buildFormulaString(cell.formula);
+		let vStr = "";
+		if (value === null || value === void 0) return `<c${attrsRaw(cellAttrs)}>${fStr}</c>`;
+		if (typeof value === "number") vStr = `<v>${value}</v>`;
+		else if (typeof value === "boolean") {
+			cellAttrs.t = "b";
+			vStr = `<v>${value ? 1 : 0}</v>`;
+		} else if (typeof value === "string") {
+			cellAttrs.t = "str";
+			vStr = `<v>${escapeXml(value)}</v>`;
+		} else if (value instanceof Date) vStr = `<v>${dateToSerialNumber(value)}</v>`;
+		if (vStr) return `<c${attrsRaw(cellAttrs)}>${fStr}${vStr}</c>`;
+		return `<c${attrsRaw(cellAttrs)}>${fStr}</c>`;
+	}
+	if (value === null || value === void 0) {
+		if (cell.styleIndex !== void 0) return selfCloseElement("c", attrsRaw(cellAttrs));
+		return "";
+	}
+	if (typeof value === "object" && !(value instanceof Date)) {
+		if (sharedStrings) {
+			cellAttrs.t = "s";
+			const idx = sharedStrings.registerRich(value);
+			return `<c${attrsRaw(cellAttrs)}><v>${idx}</v></c>`;
+		}
+		cellAttrs.t = "inlineStr";
+		return `<c${attrsRaw(cellAttrs)}><is>${buildRstXml$1(value)}</is></c>`;
+	}
+	if (typeof value === "string") {
+		if (sharedStrings) {
+			cellAttrs.t = "s";
+			const idx = sharedStrings.register(value);
+			return `<c${attrsRaw(cellAttrs)}><v>${idx}</v></c>`;
+		}
+		cellAttrs.t = "inlineStr";
+		return `<c${attrsRaw(cellAttrs)}><is><t>${escapeXml(value)}</t></is></c>`;
+	}
+	if (typeof value === "number") return `<c${attrsRaw(cellAttrs)}><v>${value}</v></c>`;
+	if (typeof value === "boolean") {
+		cellAttrs.t = "b";
+		return `<c${attrsRaw(cellAttrs)}><v>${value ? 1 : 0}</v></c>`;
+	}
+	if (value instanceof Date) {
+		const serial = dateToSerialNumber(value);
+		return `<c${attrsRaw(cellAttrs)}><v>${serial}</v></c>`;
+	}
+	return "";
+}
+function defaultCellRef(row, col) {
+	return columnToLetter(col) + row;
+}
+function columnToLetter(col) {
+	let result = "";
+	let n = col;
+	while (n > 0) {
+		const remainder = (n - 1) % 26;
+		result = String.fromCharCode(65 + remainder) + result;
+		n = Math.floor((n - 1) / 26);
+	}
+	return result;
+}
+function dateToSerialNumber(date) {
+	const epoch = new Date(1899, 11, 30);
+	return (date.getTime() - epoch.getTime()) / 864e5;
+}
+function parseCfvo(el) {
+	const result = {};
+	result.type = attr(el, "type") ?? "num";
+	const val = attr(el, "val");
+	if (val !== void 0) result.val = isNaN(Number(val)) ? val : Number(val);
+	if (attr(el, "gte") === "0") result.gte = false;
+	return result;
+}
+function parseCellRef(ref) {
+	const match = ref.match(/^([A-Z]+)(\d+)$/);
+	if (!match) return void 0;
+	const colStr = match[1];
+	const row = parseInt(match[2], 10);
+	let col = 0;
+	for (let i = 0; i < colStr.length; i++) col = col * 26 + (colStr.charCodeAt(i) - 64);
+	return {
+		row,
+		col
+	};
+}
+//#endregion
+//#region src/parts/comments.ts
+const commentsDesc = {
+	kind: "custom",
+	stringify(opts, _ctx) {
+		if (opts.comments.length === 0) return void 0;
+		const authors = collectAuthors(opts.comments);
+		const p = [`<comments xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing">`, `<authors>`];
+		for (const author of authors) p.push(`<author>${escapeXml(author)}</author>`);
+		p.push("</authors><commentList>");
+		for (const entry of opts.comments) {
+			const authorId = authors.indexOf(entry.author);
+			const textXml = typeof entry.text === "string" ? `<t>${escapeXml(entry.text)}</t>` : buildRstXml(entry.text);
+			const commentPrXml = entry.commentPr ? buildCommentPrXml(entry.commentPr) : "";
+			p.push(`<comment ref="${entry.cell}" authorId="${authorId}"><text>${textXml}</text>${commentPrXml}</comment>`);
+		}
+		p.push("</commentList></comments>");
+		return p.join("");
+	},
+	parse(el, _ctx) {
+		const comments = [];
+		const authors = [];
+		const authorsEl = findChild(el, "authors");
+		if (authorsEl) {
+			for (const a of authorsEl.elements ?? []) if (a.name === "author") authors.push(textOf(a) ?? "");
+		}
+		const listEl = findChild(el, "commentList");
+		if (listEl) for (const c of listEl.elements ?? []) {
+			if (c.name !== "comment") continue;
+			const ref = attr(c, "ref") ?? "";
+			const authorId = Number(attr(c, "authorId") ?? 0);
+			const textEl = findChild(c, "text");
+			const text = textEl ? parseRst(textEl) : "";
+			const commentPrEl = findChild(c, "commentPr");
+			const comment = {
+				cell: ref,
+				author: authors[authorId] ?? "",
+				text
+			};
+			if (commentPrEl) comment.commentPr = parseCommentPr(commentPrEl);
+			comments.push(comment);
+		}
+		return { comments };
+	}
+};
+const vmlNotesDesc = {
+	kind: "custom",
+	stringify(opts, _ctx) {
+		if (opts.comments.length === 0) return void 0;
+		const p = [
+			"<xml xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:x=\"urn:schemas-microsoft-com:office:excel\">",
+			"<o:shapelayout v:ext=\"edit\"><o:idmap v:ext=\"edit\" data=\"1\"/></o:shapelayout>",
+			"<v:shapetype id=\"_x0000_t202\" coordsize=\"21600,21600\" o:spt=\"202\" path=\"m,l,21600r21600,l21600,xe\">",
+			"<v:stroke joinstyle=\"miter\"/>",
+			"<v:path gradientshapeok=\"t\" o:connecttype=\"rect\"/>",
+			"</v:shapetype>"
+		];
+		for (let i = 0; i < opts.comments.length; i++) {
+			const c = opts.comments[i];
+			const { col, row } = cellRefToVmlCoords(c.cell);
+			const anchor = `${col}, 0, ${row}, 0, ${col + 2}, 0, ${row + 2}, 0`;
+			p.push(`<v:shape id="_x0000_s${1025 + i}" type="#_x0000_t202" style="position:absolute;margin-left:59.25pt;margin-top:1.5pt;width:108pt;height:59.25pt;z-index:1;visibility:hidden" fillcolor="infoBackground [80]" strokecolor="none [81]" o:insetmode="auto">`, `<v:fill color2="infoBackground [80]"/>`, `<v:shadow color="none [81]" obscured="t"/>`, `<v:path o:connecttype="none"/>`, `<v:textbox style="mso-direction-alt:auto"><div style="text-align:left"></div></v:textbox>`, `<x:ClientData ObjectType="Note"><x:MoveWithCells/><x:SizeWithCells/>`, `<x:Anchor>${anchor}</x:Anchor>`, `<x:AutoFill>False</x:AutoFill>`, `<x:Row>${row}</x:Row>`, `<x:Column>${col}</x:Column>`, `</x:ClientData>`, `</v:shape>`);
+		}
+		p.push("</xml>");
+		return p.join("");
+	},
+	parse(_el, _ctx) {
+		return { comments: [] };
+	}
+};
+function collectAuthors(comments) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const entry of comments) if (!seen.has(entry.author)) {
+		seen.add(entry.author);
+		result.push(entry.author);
+	}
+	return result.length > 0 ? result : [""];
+}
+/** Serialize CT_CommentPr. anchor is required (CT_ObjectAnchor), defaults to empty. */
+function buildCommentPrXml(pr) {
+	const attrs = [];
+	if (pr.locked !== void 0) attrs.push(`locked="${pr.locked ? 1 : 0}"`);
+	if (pr.defaultSize !== void 0) attrs.push(`defaultSize="${pr.defaultSize ? 1 : 0}"`);
+	if (pr.print !== void 0) attrs.push(`print="${pr.print ? 1 : 0}"`);
+	if (pr.disabled !== void 0) attrs.push(`disabled="${pr.disabled ? 1 : 0}"`);
+	if (pr.autoFill !== void 0) attrs.push(`autoFill="${pr.autoFill ? 1 : 0}"`);
+	if (pr.autoLine !== void 0) attrs.push(`autoLine="${pr.autoLine ? 1 : 0}"`);
+	if (pr.altText !== void 0) attrs.push(`altText="${escapeXml(pr.altText)}"`);
+	if (pr.textHAlign !== void 0) attrs.push(`textHAlign="${pr.textHAlign}"`);
+	if (pr.textVAlign !== void 0) attrs.push(`textVAlign="${pr.textVAlign}"`);
+	if (pr.lockText !== void 0) attrs.push(`lockText="${pr.lockText ? 1 : 0}"`);
+	if (pr.justLastX !== void 0) attrs.push(`justLastX="${pr.justLastX ? 1 : 0}"`);
+	if (pr.autoScale !== void 0) attrs.push(`autoScale="${pr.autoScale ? 1 : 0}"`);
+	return `<commentPr ${attrs.join(" ")}>${buildAnchorXml(pr.anchor)}</commentPr>`;
+}
+/** Serialize CT_ObjectAnchor. from/to/ext are optional in the XSD; attributes required. */
+function buildAnchorXml(anchor) {
+	return `<xdr:anchor moveWithCells="${anchor?.moveWithCells ? 1 : 0}" sizeWithCells="${anchor?.sizeWithCells ? 1 : 0}"/>`;
+}
+function parseCommentPr(el) {
+	const pr = {};
+	const locked = attr(el, "locked");
+	if (locked !== void 0) pr.locked = locked === "1";
+	const defaultSize = attr(el, "defaultSize");
+	if (defaultSize !== void 0) pr.defaultSize = defaultSize === "1";
+	const print = attr(el, "print");
+	if (print !== void 0) pr.print = print === "1";
+	const disabled = attr(el, "disabled");
+	if (disabled !== void 0) pr.disabled = disabled === "1";
+	const autoFill = attr(el, "autoFill");
+	if (autoFill !== void 0) pr.autoFill = autoFill === "1";
+	const autoLine = attr(el, "autoLine");
+	if (autoLine !== void 0) pr.autoLine = autoLine === "1";
+	const altText = attr(el, "altText");
+	if (altText !== void 0) pr.altText = altText;
+	const textHAlign = attr(el, "textHAlign");
+	if (textHAlign !== void 0) pr.textHAlign = textHAlign;
+	const textVAlign = attr(el, "textVAlign");
+	if (textVAlign !== void 0) pr.textVAlign = textVAlign;
+	const lockText = attr(el, "lockText");
+	if (lockText !== void 0) pr.lockText = lockText === "1";
+	const justLastX = attr(el, "justLastX");
+	if (justLastX !== void 0) pr.justLastX = justLastX === "1";
+	const autoScale = attr(el, "autoScale");
+	if (autoScale !== void 0) pr.autoScale = autoScale === "1";
+	const anchorEl = findChild(el, "xdr:anchor");
+	if (anchorEl) pr.anchor = parseAnchor(anchorEl);
+	return pr;
+}
+function parseAnchor(el) {
+	return {
+		moveWithCells: attr(el, "moveWithCells") === "1",
+		sizeWithCells: attr(el, "sizeWithCells") === "1"
+	};
+}
+function cellRefToVmlCoords(ref) {
+	let i = 0;
+	while (i < ref.length && ref.charCodeAt(i) >= 65 && ref.charCodeAt(i) <= 90) i++;
+	let col = 0;
+	for (let j = 0; j < i; j++) col = col * 26 + (ref.charCodeAt(j) - 64);
+	return {
+		col: col - 1,
+		row: parseInt(ref.slice(i), 10) - 1
+	};
+}
+/** Build rich text (CT_Rst) XML from runs. */
+function buildRstXml(rst) {
+	const runs = rst.runs ?? [];
+	const parts = [];
+	for (const run of runs) {
+		const props = run.properties;
+		if (!props) {
+			parts.push(`<r><t>${escapeXml(run.text)}</t></r>`);
+			continue;
+		}
+		const rPr = [];
+		if (props.bold) rPr.push("<b/>");
+		if (props.italic) rPr.push("<i/>");
+		if (props.underline) rPr.push(`<u val="${props.underline}"/>`);
+		if (props.strike) rPr.push("<strike/>");
+		if (props.size) rPr.push(`<sz val="${props.size}"/>`);
+		if (props.color) rPr.push(`<color rgb="${props.color}"/>`);
+		if (props.font) rPr.push(`<rFont val="${props.font}"/>`);
+		const rPrXml = rPr.length ? `<rPr>${rPr.join("")}</rPr>` : "";
+		parts.push(`<r>${rPrXml}<t>${escapeXml(run.text)}</t></r>`);
+	}
+	return parts.join("");
+}
+/** Parse rich text element into a plain string or rich runs. */
+function parseRst(textEl) {
+	const runs = [];
+	const parts = [];
+	let hasRuns = false;
+	for (const child of textEl.elements ?? []) if (child.name === "t") parts.push(textOf(child) ?? "");
+	else if (child.name === "r") {
+		hasRuns = true;
+		const t = findChild(child, "t");
+		const run = { text: t ? textOf(t) ?? "" : "" };
+		const rPr = findChild(child, "rPr");
+		if (rPr) {
+			const props = {};
+			if (findChild(rPr, "b")) props.bold = true;
+			if (findChild(rPr, "i")) props.italic = true;
+			const uEl = findChild(rPr, "u");
+			if (uEl) props.underline = attr(uEl, "val") ?? "single";
+			if (findChild(rPr, "strike")) props.strike = true;
+			const szEl = findChild(rPr, "sz");
+			if (szEl) {
+				const sz = Number(attr(szEl, "val"));
+				if (!Number.isNaN(sz)) props.size = sz;
+			}
+			const colorEl = findChild(rPr, "color");
+			if (colorEl && attr(colorEl, "rgb")) props.color = attr(colorEl, "rgb");
+			const rFontEl = findChild(rPr, "rFont");
+			if (rFontEl && attr(rFontEl, "val")) props.font = attr(rFontEl, "val");
+			run.properties = props;
+		}
+		runs.push(run);
+	}
+	if (hasRuns) return { runs };
+	return parts.join("");
+}
+//#endregion
+export { SharedStrings as a, worksheetDesc as i, vmlNotesDesc as n, sharedStringsDesc as o, stringifyWorksheet as r, commentsDesc as t };
+
+//# sourceMappingURL=comments-CIu-wLTT.mjs.map