@office-kit/xlsx 0.8.0

package/dist/workbook-HGYNRBlV.mjs

@@ -0,0 +1,636 @@
+import { o as OpenXmlSchemaError } from "./exceptions-D-CFwxgm.mjs";
+import { m as parseSheetRange, s as coordinateToTuple } from "./coordinate-96Ecci4d.mjs";
+import { h as isFormulaValue } from "./cell-D9CaNKnU.mjs";
+import { t as makeChartsheet } from "./chartsheet-C3-tqkPy.mjs";
+import { a as makeChartDrawingItem, d as makeAbsoluteAnchor, o as makeDrawing } from "./drawing-BxzLuryn.mjs";
+import { i as unescapeCellString, n as escapeXmlAttr, r as escapeXmlText, t as escapeCellString } from "./escape-DFTE7ZJc.mjs";
+import { a as findChildren, ft as SHEET_MAIN_NS, i as findChild, jt as qname } from "./tree-Bbs1C8Rc.mjs";
+import { t as parseXml } from "./parser-DuLejQy1.mjs";
+import { Cn as parseRange, D as getCellHyperlink, Dn as rangeToString, E as getCellComment, L as getMergedRangeAt, Tn as rangeContainsCell, _ as countCellsByKind, at as makeWorksheet, bn as multiCellRangeContainsCell, nn as colorToHex, u as classifyCellValue, w as getCell, xt as setCellByCoord } from "./worksheet-CmCNoIgD.mjs";
+import { _ as getCellNumberFormat, ft as makeStylesheet, g as getCellFont, h as getCellFill, m as getCellBorder, p as getCellAlignment, v as getCellProtection } from "./cell-style-BEDjMX1y.mjs";
+//#region src/workbook/shared-strings.ts
+const SST_TAG = `{${SHEET_MAIN_NS}}sst`;
+const SI_TAG = `{${SHEET_MAIN_NS}}si`;
+const T_TAG = `{${SHEET_MAIN_NS}}t`;
+const R_TAG = `{${SHEET_MAIN_NS}}r`;
+function makeSharedStrings() {
+	return {
+		entries: [],
+		index: /* @__PURE__ */ new Map()
+	};
+}
+/**
+* Insert a string and return its index. Idempotent: calling with the same value
+* twice gives the same index. Empty strings are deduped just like everything
+* else.
+*/
+function addSharedString(table, value) {
+	const cached = table.index.get(value);
+	if (cached !== void 0) return cached;
+	const id = table.entries.length;
+	table.entries.push(value);
+	table.index.set(value, id);
+	return id;
+}
+/** Look up a shared-string index by its literal text. Returns `undefined` for unknown values. */
+function getSharedStringIndex(table, value) {
+	return table.index.get(value);
+}
+/**
+* Read a shared-string by its 0-based index. Returns `undefined` for
+* out-of-range. Rich-text entries surface their concatenated plain text so
+* callers that want only the textual body don't need to know about the
+* discriminated union.
+*/
+function getSharedStringAt(table, index) {
+	const entry = table.entries[index];
+	if (entry === void 0) return void 0;
+	if (typeof entry === "string") return entry;
+	return entry.runs.map((r) => r.text).join("");
+}
+/** Number of unique entries in the SST. */
+function sharedStringCount(table) {
+	return table.entries.length;
+}
+/** Concatenate every `<t>` text node found inside an arbitrary XmlNode tree. */
+const collectText = (node) => {
+	if (node.children.length === 1) {
+		const only = node.children[0];
+		if (only && only.name === T_TAG) return unescapeCellString(only.text ?? "");
+	}
+	let out = "";
+	for (const child of node.children) if (child.name === T_TAG) out += child.text ?? "";
+	else if (child.name === R_TAG) {
+		const t = findChild(child, T_TAG);
+		if (t?.text) out += t.text;
+	}
+	return unescapeCellString(out);
+};
+/**
+* Parse a `xl/sharedStrings.xml` payload. Returns the table directly (rather
+* than just the array) so the worksheet writer can keep appending to it without
+* rebuilding the index.
+*
+* Rich-text runs are preserved as their full per-run formatting so
+* round-tripping a file with rich text doesn't drop the styling.
+*/
+function parseSharedStringsXml(bytes) {
+	const root = parseXml(bytes);
+	if (root.name !== SST_TAG) throw new OpenXmlSchemaError(`parseSharedStringsXml: root is "${root.name}", expected sst`);
+	const table = makeSharedStrings();
+	for (const si of findChildren(root, SI_TAG)) {
+		const entry = parseSi(si);
+		const id = table.entries.length;
+		table.entries.push(entry);
+		if (typeof entry === "string" && !table.index.has(entry)) table.index.set(entry, id);
+	}
+	return table;
+}
+const parseSi = (si) => {
+	const runEls = findChildren(si, R_TAG);
+	if (runEls.length > 0) {
+		const runs = [];
+		for (const rEl of runEls) {
+			const text = unescapeCellString(findChild(rEl, T_TAG)?.text ?? "");
+			const rPrEl = findChild(rEl, qname(SHEET_MAIN_NS, "rPr"));
+			const font = rPrEl ? parseRunPr(rPrEl) : void 0;
+			runs.push(font !== void 0 ? {
+				text,
+				font
+			} : { text });
+		}
+		return {
+			kind: "rich-text",
+			runs: Object.freeze(runs)
+		};
+	}
+	return collectText(si);
+};
+const parseRunPr = (rPr) => {
+	const f = {};
+	for (const child of rPr.children) {
+		const local = child.name.replace(/^\{[^}]+\}/, "");
+		const valAttr = child.attrs["val"];
+		switch (local) {
+			case "rFont":
+			case "name":
+				if (valAttr !== void 0) f.name = valAttr;
+				break;
+			case "sz":
+				if (valAttr !== void 0) f.sz = Number.parseFloat(valAttr);
+				break;
+			case "b":
+				f.b = valAttr === void 0 ? true : valAttr !== "0" && valAttr !== "false";
+				break;
+			case "i":
+				f.i = valAttr === void 0 ? true : valAttr !== "0" && valAttr !== "false";
+				break;
+			case "u":
+				f.u = valAttr ?? "single";
+				break;
+			case "strike":
+				f.strike = valAttr === void 0 ? true : valAttr !== "0" && valAttr !== "false";
+				break;
+			case "vertAlign":
+				if (valAttr !== void 0) f.vertAlign = valAttr;
+				break;
+			case "family":
+				if (valAttr !== void 0) f.family = Number.parseInt(valAttr, 10);
+				break;
+			case "charset":
+				if (valAttr !== void 0) f.charset = Number.parseInt(valAttr, 10);
+				break;
+			case "scheme":
+				if (valAttr !== void 0) f.scheme = valAttr;
+				break;
+			case "color": {
+				const c = {};
+				if (child.attrs["rgb"] !== void 0) c.rgb = child.attrs["rgb"];
+				if (child.attrs["theme"] !== void 0) c.theme = Number.parseInt(child.attrs["theme"], 10);
+				if (child.attrs["indexed"] !== void 0) c.indexed = Number.parseInt(child.attrs["indexed"], 10);
+				if (child.attrs["tint"] !== void 0) c.tint = Number.parseFloat(child.attrs["tint"]);
+				if (child.attrs["auto"] !== void 0) c.auto = child.attrs["auto"] === "1" || child.attrs["auto"] === "true";
+				f.color = c;
+				break;
+			}
+		}
+	}
+	return Object.keys(f).length === 0 ? void 0 : Object.freeze(f);
+};
+const XML_HEADER = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
+/**
+* Serialise a SharedStringsTable to its OOXML bytes. The `count` attribute
+* tracks total references (we don't know that here so we report the same as
+* `uniqueCount` — readers tolerate the discrepancy and Excel ignores `count` in
+* practice). `uniqueCount` always matches `entries.length`.
+*/
+function sharedStringsToBytes(table) {
+	return new TextEncoder().encode(serializeSharedStrings(table));
+}
+function serializeSharedStrings(table) {
+	const total = table.entries.length;
+	const parts = [XML_HEADER, `<sst xmlns="${SHEET_MAIN_NS}" count="${total}" uniqueCount="${total}">`];
+	for (const value of table.entries) parts.push(serializeSi(value));
+	parts.push("</sst>");
+	return parts.join("");
+}
+const serializeSi = (value) => {
+	if (typeof value === "string") return `<si><t${value.length > 0 && (value[0] === " " || value[value.length - 1] === " " || /[\t\n]/.test(value)) ? " xml:space=\"preserve\"" : ""}>${escapeXmlText(escapeCellString(value))}</t></si>`;
+	return `<si>${serializeRichTextRuns(value.runs)}</si>`;
+};
+/**
+* Serialise a sequence of `<r>...<r>` runs — shared by the SST `<si>` writer
+* and the worksheet's inline-string (`t="inlineStr"`) cell writer.
+*/
+function serializeRichTextRuns(runs) {
+	const parts = [];
+	for (const run of runs) {
+		parts.push("<r>");
+		if (run.font) parts.push(serializeInlineFont(run.font));
+		const text = run.text;
+		const tAttr = text.length > 0 && (text[0] === " " || text[text.length - 1] === " " || /[\t\n]/.test(text)) ? " xml:space=\"preserve\"" : "";
+		parts.push(`<t${tAttr}>${escapeXmlText(escapeCellString(text))}</t>`);
+		parts.push("</r>");
+	}
+	return parts.join("");
+}
+const serializeInlineFont = (f) => {
+	const parts = ["<rPr>"];
+	if (f.name !== void 0) parts.push(`<rFont val="${escapeXmlAttr(f.name)}"/>`);
+	if (f.charset !== void 0) parts.push(`<charset val="${f.charset}"/>`);
+	if (f.family !== void 0) parts.push(`<family val="${f.family}"/>`);
+	if (f.b) parts.push("<b/>");
+	if (f.i) parts.push("<i/>");
+	if (f.strike) parts.push("<strike/>");
+	if (f.outline) parts.push("<outline/>");
+	if (f.shadow) parts.push("<shadow/>");
+	if (f.condense) parts.push("<condense/>");
+	if (f.extend) parts.push("<extend/>");
+	if (f.color) parts.push(serializeRunColor(f.color));
+	if (f.sz !== void 0) parts.push(`<sz val="${f.sz}"/>`);
+	if (f.u) parts.push(`<u val="${f.u}"/>`);
+	if (f.vertAlign) parts.push(`<vertAlign val="${f.vertAlign}"/>`);
+	if (f.scheme) parts.push(`<scheme val="${f.scheme}"/>`);
+	parts.push("</rPr>");
+	return parts.join("");
+};
+const serializeRunColor = (c) => {
+	const attrs = [];
+	if (c.rgb !== void 0) attrs.push(`rgb="${escapeXmlAttr(c.rgb)}"`);
+	else if (c.theme !== void 0) attrs.push(`theme="${c.theme}"`);
+	else if (c.indexed !== void 0) attrs.push(`indexed="${c.indexed}"`);
+	else if (c.auto !== void 0) attrs.push(`auto="${c.auto ? "1" : "0"}"`);
+	if (c.tint !== void 0) attrs.push(`tint="${c.tint}"`);
+	if (attrs.length === 0) {
+		const hex = colorToHex(c);
+		if (hex !== void 0) attrs.push(`rgb="${hex}"`);
+	}
+	return `<color${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""}/>`;
+};
+//#endregion
+//#region src/workbook/workbook.ts
+/** Build an empty Workbook ready to host worksheets. */
+function createWorkbook(opts) {
+	return {
+		sheets: [],
+		activeSheetIndex: 0,
+		styles: makeStylesheet(),
+		date1904: opts?.date1904 ?? false,
+		authors: [],
+		definedNames: []
+	};
+}
+/**
+* Validate a sheet title against Excel's character + length rules. Returns the
+* reason string when the title is rejected; `undefined` when valid. The same
+* rules apply to worksheets and chartsheets.
+*
+* Rules:
+*  - Type must be `string`; non-empty; length ≤ 31.
+*  - May not contain any of `:`, `\`, `/`, `?`, `*`, `[`, `]`.
+*  - May not start or end with an apostrophe `'`.
+*  - May not be the literal `"History"` (case-insensitive — Excel
+* reserves that name for the change-tracking sheet).
+*
+* Uniqueness is **not** checked here; pass through `addWorksheet` /
+* `renameSheet` for the workbook-aware duplicate check.
+*/
+function validateSheetTitle(title) {
+	if (typeof title !== "string") return "must be a string";
+	if (title.length === 0) return "must be 1..31 chars";
+	if (title.length > 31) return "must be 1..31 chars";
+	if (/[:\\/?*[\]]/.test(title)) return "must not contain : \\ / ? * [ ]";
+	if (title.startsWith("'") || title.endsWith("'")) return "must not start or end with an apostrophe";
+	if (title.toLowerCase() === "history") return "\"History\" is reserved by Excel";
+}
+const validateUniqueTitle = (wb, title, ignoreIndex) => {
+	const reason = validateSheetTitle(title);
+	if (reason) throw new OpenXmlSchemaError(`Worksheet title "${title}": ${reason}`);
+	const lower = title.toLowerCase();
+	for (let i = 0; i < wb.sheets.length; i++) {
+		if (i === ignoreIndex) continue;
+		const s = wb.sheets[i];
+		if (s && s.sheet.title.toLowerCase() === lower) throw new OpenXmlSchemaError(`Worksheet title "${title}" is already in use`);
+	}
+};
+const allocateSheetId = (wb) => {
+	const used = /* @__PURE__ */ new Set();
+	for (const s of wb.sheets) used.add(s.sheetId);
+	let n = 1;
+	while (used.has(n)) n++;
+	return n;
+};
+/** Add a Worksheet to the Workbook. Returns the sheet for further population. */
+function addWorksheet(wb, title, opts) {
+	validateUniqueTitle(wb, title);
+	const sheet = makeWorksheet(title);
+	const ref = {
+		kind: "worksheet",
+		sheet,
+		sheetId: allocateSheetId(wb),
+		state: opts?.state ?? "visible"
+	};
+	if (opts?.index === void 0) wb.sheets.push(ref);
+	else {
+		if (opts.index < 0 || opts.index > wb.sheets.length) throw new OpenXmlSchemaError(`addWorksheet: index ${opts.index} out of range`);
+		wb.sheets.splice(opts.index, 0, ref);
+	}
+	return sheet;
+}
+/** Look up a Worksheet by title. Returns undefined for missing names or chartsheets. */
+function getSheet(wb, title) {
+	for (const s of wb.sheets) if (s.kind === "worksheet" && s.sheet.title === title) return s.sheet;
+}
+/** Look up a Chartsheet by title. Returns undefined for missing names or worksheets. */
+function getChartsheet(wb, title) {
+	for (const s of wb.sheets) if (s.kind === "chartsheet" && s.sheet.title === title) return s.sheet;
+}
+/** Add a Chartsheet to the Workbook. Returns the chartsheet for further population. */
+function addChartsheet(wb, title, opts) {
+	validateUniqueTitle(wb, title);
+	const cs = makeChartsheet(title);
+	if (opts?.chart) cs.drawing = makeDrawing([makeChartDrawingItem(makeAbsoluteAnchor({
+		x: 0,
+		y: 0,
+		cx: 9144e3,
+		cy: 6858e3
+	}), opts.chart)]);
+	const ref = {
+		kind: "chartsheet",
+		sheet: cs,
+		sheetId: allocateSheetId(wb),
+		state: opts?.state ?? "visible"
+	};
+	if (opts?.index === void 0) wb.sheets.push(ref);
+	else {
+		if (opts.index < 0 || opts.index > wb.sheets.length) throw new OpenXmlSchemaError(`addChartsheet: index ${opts.index} out of range`);
+		wb.sheets.splice(opts.index, 0, ref);
+	}
+	return cs;
+}
+/** All worksheet titles, in display order. */
+function sheetNames(wb) {
+	return wb.sheets.map((s) => s.sheet.title);
+}
+/** Remove a sheet by title. No-op if the title is not registered. */
+function removeSheet(wb, title) {
+	const i = wb.sheets.findIndex((s) => s.sheet.title === title);
+	if (i < 0) return;
+	wb.sheets.splice(i, 1);
+	if (wb.activeSheetIndex >= wb.sheets.length) wb.activeSheetIndex = Math.max(0, wb.sheets.length - 1);
+}
+/** Set the active sheet by title; throws on unknown title. */
+function setActiveSheet(wb, title) {
+	const i = wb.sheets.findIndex((s) => s.sheet.title === title);
+	if (i < 0) throw new OpenXmlSchemaError(`setActiveSheet: no sheet named "${title}"`);
+	wb.activeSheetIndex = i;
+}
+/**
+* Rename a sheet from `oldTitle` to `newTitle`. Throws if no sheet matches
+* `oldTitle`, or if `newTitle` collides with an existing sheet (Excel requires
+* sheet names to be unique within a workbook).
+*/
+function renameSheet(wb, oldTitle, newTitle) {
+	const i = wb.sheets.findIndex((s) => s.sheet.title === oldTitle);
+	if (i < 0) throw new OpenXmlSchemaError(`renameSheet: no sheet named "${oldTitle}"`);
+	if (oldTitle === newTitle) return;
+	validateUniqueTitle(wb, newTitle, i);
+	const ref = wb.sheets[i];
+	if (ref) ref.sheet.title = newTitle;
+}
+/**
+* Set the visibility state on a sheet by title. Throws on unknown title.
+* Refuses to hide the last visible sheet: an .xlsx with every sheet hidden
+* fails to open in Excel ("Excel cannot use the object linking and embedding
+* features because no sheet is visible"). Catching it here keeps the
+* workbook recoverable instead of producing a save Excel will reject.
+*/
+function setSheetState(wb, title, state) {
+	const ref = wb.sheets.find((s) => s.sheet.title === title);
+	if (!ref) throw new OpenXmlSchemaError(`setSheetState: no sheet named "${title}"`);
+	if (ref.state === state) return;
+	if (state !== "visible" && ref.state === "visible") {
+		let otherVisible = false;
+		for (const candidate of wb.sheets) if (candidate !== ref && candidate.state === "visible") {
+			otherVisible = true;
+			break;
+		}
+		if (!otherVisible) throw new OpenXmlSchemaError(`setSheetState: cannot hide "${title}" — it's the last visible sheet, and Excel refuses to open a workbook with every sheet hidden. Make another sheet visible first (or call showSheet()).`);
+	}
+	ref.state = state;
+}
+/** Look up the current visibility state. Throws on unknown title. */
+function getSheetState(wb, title) {
+	const ref = wb.sheets.find((s) => s.sheet.title === title);
+	if (!ref) throw new OpenXmlSchemaError(`getSheetState: no sheet named "${title}"`);
+	return ref.state;
+}
+/**
+* Move a sheet to a new tab-strip position. `toIndex` is clamped to `[0,
+* sheets.length - 1]`. Adjusts `activeSheetIndex` so the same sheet stays
+* active across the move.
+*/
+function moveSheet(wb, title, toIndex) {
+	const from = wb.sheets.findIndex((s) => s.sheet.title === title);
+	if (from < 0) throw new OpenXmlSchemaError(`moveSheet: no sheet named "${title}"`);
+	if (!Number.isInteger(toIndex)) throw new OpenXmlSchemaError(`moveSheet: toIndex must be an integer; got ${toIndex}`);
+	const dest = Math.max(0, Math.min(wb.sheets.length - 1, toIndex));
+	if (from === dest) return;
+	const wasActive = wb.activeSheetIndex === from;
+	const [moved] = wb.sheets.splice(from, 1);
+	if (moved) wb.sheets.splice(dest, 0, moved);
+	if (wasActive) wb.activeSheetIndex = dest;
+	else {
+		let cur = wb.activeSheetIndex;
+		if (from < cur) cur -= 1;
+		if (dest <= cur) cur += 1;
+		wb.activeSheetIndex = Math.max(0, Math.min(wb.sheets.length - 1, cur));
+	}
+}
+function getWorkbookStats(wb) {
+	let worksheetCount = 0;
+	let chartsheetCount = 0;
+	let cellCount = 0;
+	let formulaCount = 0;
+	let commentCount = 0;
+	let hyperlinkCount = 0;
+	let mergedRangeCount = 0;
+	let tableCount = 0;
+	for (const ref of wb.sheets) if (ref.kind === "worksheet") {
+		worksheetCount++;
+		const ws = ref.sheet;
+		for (const rowMap of ws.rows.values()) for (const cell of rowMap.values()) {
+			cellCount++;
+			if (isFormulaValue(cell.value)) formulaCount++;
+		}
+		commentCount += ws.legacyComments.length;
+		hyperlinkCount += ws.hyperlinks.length;
+		mergedRangeCount += ws.mergedCells.length;
+		tableCount += ws.tables.length;
+	} else chartsheetCount++;
+	return {
+		worksheetCount,
+		chartsheetCount,
+		cellCount,
+		formulaCount,
+		commentCount,
+		hyperlinkCount,
+		mergedRangeCount,
+		tableCount,
+		definedNameCount: wb.definedNames.length,
+		customPropertyCount: wb.customProperties?.properties.length ?? 0
+	};
+}
+/**
+* Workbook-wide value-kind histogram. Sums {@link countCellsByKind} across
+* every Worksheet (chartsheets contribute no cells). Buckets have the same
+* shape as the per-worksheet result; an empty workbook returns all-zero counts.
+*/
+function getWorkbookCellsByKind(wb) {
+	const out = {
+		null: 0,
+		string: 0,
+		number: 0,
+		boolean: 0,
+		date: 0,
+		duration: 0,
+		error: 0,
+		"rich-text": 0,
+		formula: 0
+	};
+	for (const ws of iterWorksheets(wb)) {
+		const partial = countCellsByKind(ws);
+		out.null += partial.null;
+		out.string += partial.string;
+		out.number += partial.number;
+		out.boolean += partial.boolean;
+		out.date += partial.date;
+		out.duration += partial.duration;
+		out.error += partial.error;
+		out["rich-text"] += partial["rich-text"];
+		out.formula += partial.formula;
+	}
+	return out;
+}
+/**
+* Resolve a sheet-qualified A1 address (`'Sheet1!A1'`) to its Cell, or
+* `undefined` when the cell isn't materialised. Throws on malformed addresses,
+* missing sheets, or range inputs.
+*/
+function getCellAtAddress(wb, address) {
+	const { sheet: sheetTitle, range } = parseSheetRange(address);
+	if (range.includes(":")) throw new OpenXmlSchemaError(`getCellAtAddress: address "${address}" refers to a range, not a single cell`);
+	const ws = getSheet(wb, sheetTitle);
+	if (!ws) throw new OpenXmlSchemaError(`getCellAtAddress: sheet "${sheetTitle}" not found`);
+	const { col, row } = coordinateToTuple(range);
+	return getCell(ws, row, col);
+}
+/**
+* Set a single cell by sheet-qualified A1 address. Throws on malformed
+* addresses, missing sheets, or range inputs.
+*/
+function setCellAtAddress(wb, address, value) {
+	const { sheet: sheetTitle, range } = parseSheetRange(address);
+	if (range.includes(":")) throw new OpenXmlSchemaError(`setCellAtAddress: address "${address}" refers to a range, not a single cell`);
+	const ws = getSheet(wb, sheetTitle);
+	if (!ws) throw new OpenXmlSchemaError(`setCellAtAddress: sheet "${sheetTitle}" not found`);
+	return setCellByCoord(ws, range, value);
+}
+function describeWorkbook(wb) {
+	let worksheetCount = 0;
+	let chartsheetCount = 0;
+	let cellCount = 0;
+	let formulaCount = 0;
+	let commentCount = 0;
+	let hyperlinkCount = 0;
+	let mergedRangeCount = 0;
+	let tableCount = 0;
+	const cellsByKind = {
+		null: 0,
+		string: 0,
+		number: 0,
+		boolean: 0,
+		date: 0,
+		duration: 0,
+		error: 0,
+		"rich-text": 0,
+		formula: 0
+	};
+	const sheets = wb.sheets.map((ref) => {
+		if (ref.kind === "chartsheet") {
+			chartsheetCount++;
+			return {
+				title: ref.sheet.title,
+				kind: "chartsheet",
+				state: ref.state,
+				cellCount: 0,
+				formulaCount: 0,
+				tableCount: 0,
+				drawingItemCount: ref.sheet.drawing?.items.length ?? 0
+			};
+		}
+		worksheetCount++;
+		const ws = ref.sheet;
+		let sheetCellCount = 0;
+		let sheetFormulaCount = 0;
+		for (const rowMap of ws.rows.values()) for (const cell of rowMap.values()) {
+			sheetCellCount++;
+			const bucket = classifyCellValue(cell.value);
+			cellsByKind[bucket]++;
+			if (isFormulaValue(cell.value)) sheetFormulaCount++;
+		}
+		cellCount += sheetCellCount;
+		formulaCount += sheetFormulaCount;
+		commentCount += ws.legacyComments.length;
+		hyperlinkCount += ws.hyperlinks.length;
+		mergedRangeCount += ws.mergedCells.length;
+		tableCount += ws.tables.length;
+		return {
+			title: ws.title,
+			kind: "worksheet",
+			state: ref.state,
+			cellCount: sheetCellCount,
+			formulaCount: sheetFormulaCount,
+			tableCount: ws.tables.length,
+			drawingItemCount: ws.drawing?.items.length ?? 0
+		};
+	});
+	return {
+		worksheetCount,
+		chartsheetCount,
+		cellCount,
+		formulaCount,
+		commentCount,
+		hyperlinkCount,
+		mergedRangeCount,
+		tableCount,
+		definedNameCount: wb.definedNames.length,
+		customPropertyCount: wb.customProperties?.properties.length ?? 0,
+		cellsByKind,
+		sheets
+	};
+}
+function getCellSummary(wb, sheetTitle, ref) {
+	const ws = getSheet(wb, sheetTitle);
+	if (!ws) throw new OpenXmlSchemaError(`getCellSummary: sheet "${sheetTitle}" not found`);
+	const { col, row } = coordinateToTuple(ref);
+	const cell = getCell(ws, row, col);
+	const probe = cell ?? {
+		row,
+		col,
+		value: null,
+		styleId: 0
+	};
+	const merged = getMergedRangeAt(ws, row, col);
+	const inTables = [];
+	for (const t of ws.tables) if (rangeContainsCell(parseRange(t.ref), row, col)) inTables.push(t.displayName);
+	let inDv = 0;
+	for (const dv of ws.dataValidations) if (multiCellRangeContainsCell(dv.sqref, row, col)) inDv++;
+	let inCf = 0;
+	for (const cf of ws.conditionalFormatting) if (multiCellRangeContainsCell(cf.sqref, row, col)) inCf++;
+	return {
+		ref,
+		sheet: sheetTitle,
+		exists: cell !== void 0,
+		value: cell?.value,
+		styleId: probe.styleId,
+		font: getCellFont(wb, probe),
+		fill: getCellFill(wb, probe),
+		border: getCellBorder(wb, probe),
+		alignment: getCellAlignment(wb, probe),
+		protection: getCellProtection(wb, probe),
+		numberFormat: getCellNumberFormat(wb, probe),
+		hyperlink: cell ? getCellHyperlink(ws, cell) : void 0,
+		comment: cell ? getCellComment(ws, cell) : void 0,
+		mergedRange: merged ? rangeToString(merged) : void 0,
+		inTables,
+		inDataValidations: inDv,
+		inConditionalFormatting: inCf
+	};
+}
+/**
+* Iterate over every Worksheet in the workbook (skips chartsheets). Yields each
+* worksheet in tab-strip order.
+*/
+function* iterWorksheets(wb) {
+	for (const ref of wb.sheets) if (ref.kind === "worksheet") yield ref.sheet;
+}
+/** Currently active sheet (worksheet only), or undefined if the active slot is empty or a chartsheet. */
+function getActiveSheet(wb) {
+	const ref = wb.sheets[wb.activeSheetIndex];
+	return ref?.kind === "worksheet" ? ref.sheet : void 0;
+}
+/** Read-only view onto the customXml/* pass-through parts. */
+function listCustomXmlParts(wb) {
+	if (!wb.passthrough) return [];
+	const out = [];
+	for (const [path, content] of wb.passthrough) if (path.startsWith("customXml/")) out.push({
+		path,
+		content
+	});
+	return out;
+}
+//#endregion
+export { sharedStringsToBytes as A, addSharedString as C, parseSharedStringsXml as D, makeSharedStrings as E, serializeRichTextRuns as O, validateSheetTitle as S, getSharedStringIndex as T, renameSheet as _, getActiveSheet as a, setSheetState as b, getChartsheet as c, getWorkbookCellsByKind as d, getWorkbookStats as f, removeSheet as g, moveSheet as h, describeWorkbook as i, sharedStringCount as k, getSheet as l, listCustomXmlParts as m, addWorksheet as n, getCellAtAddress as o, iterWorksheets as p, createWorkbook as r, getCellSummary as s, addChartsheet as t, getSheetState as u, setActiveSheet as v, getSharedStringAt as w, sheetNames as x, setCellAtAddress as y };
+
+//# sourceMappingURL=workbook-HGYNRBlV.mjs.map