@office-kit/xlsx 0.8.0

package/dist/load-D5cbhoGx.mjs

@@ -0,0 +1,1069 @@
+import { o as OpenXmlSchemaError } from "./exceptions-D-CFwxgm.mjs";
+import { h as loadImage } from "./drawing-BxzLuryn.mjs";
+import { At as parseQName, a as findChildren, c as ARC_CONTENT_TYPES, f as ARC_ROOT_RELS, ft as SHEET_MAIN_NS, g as ARC_WORKBOOK, h as ARC_THEME, i as findChild, jt as qname, l as ARC_CORE, lt as REL_NS, m as ARC_STYLE, p as ARC_SHARED_STRINGS, s as ARC_APP, u as ARC_CUSTOM } from "./tree-Bbs1C8Rc.mjs";
+import { C as isChartExBytes, D as parseChartXml, E as findUserShapesRId, a as parseCommentsXml, b as parseUserShapesXml, c as NumberFormatSchema, d as BorderSchema, f as AlignmentSchema, g as parseChartsheetXml, l as FontSchema, m as parseDrawingXml, n as parseTableXml, s as ProtectionSchema, u as fillFromTree, w as parseChartExXml, y as parseWorksheetXml } from "./stylesheet-writer-C2eRmn22.mjs";
+import { t as parseXml } from "./parser-DuLejQy1.mjs";
+import { t as fromTree } from "./serialize-55EnT30e.mjs";
+import { B as corePropsFromBytes, Q as findById, _ as customPropsFromBytes, c as extendedPropsFromBytes, et as indexRelsById, nt as relsFromBytes, o as manifestFromBytes } from "./manifest-Dps1-OpP.mjs";
+import { D as parseSharedStringsXml, r as createWorkbook } from "./workbook-HGYNRBlV.mjs";
+import { Zt as stableStringify, ft as makeStylesheet } from "./cell-style-BEDjMX1y.mjs";
+import { a as makeDefinedName } from "./defined-names-CviWmtQg.mjs";
+import { t as openZip } from "./reader-D1fNW9k1.mjs";
+//#region src/styles/stylesheet-reader.ts
+const STYLESHEET_TAG = qname(SHEET_MAIN_NS, "styleSheet");
+const FONTS_TAG = qname(SHEET_MAIN_NS, "fonts");
+const FILLS_TAG = qname(SHEET_MAIN_NS, "fills");
+const BORDERS_TAG = qname(SHEET_MAIN_NS, "borders");
+const NUMFMTS_TAG = qname(SHEET_MAIN_NS, "numFmts");
+const NUMFMT_TAG = qname(SHEET_MAIN_NS, "numFmt");
+const CELLXFS_TAG = qname(SHEET_MAIN_NS, "cellXfs");
+const CELLSTYLEXFS_TAG = qname(SHEET_MAIN_NS, "cellStyleXfs");
+const CELLSTYLES_TAG = qname(SHEET_MAIN_NS, "cellStyles");
+const CELLSTYLE_TAG = qname(SHEET_MAIN_NS, "cellStyle");
+const DXFS_TAG = qname(SHEET_MAIN_NS, "dxfs");
+const DXF_TAG = qname(SHEET_MAIN_NS, "dxf");
+const XF_TAG = qname(SHEET_MAIN_NS, "xf");
+const FONT_TAG = qname(SHEET_MAIN_NS, "font");
+const FILL_TAG = qname(SHEET_MAIN_NS, "fill");
+const BORDER_TAG = qname(SHEET_MAIN_NS, "border");
+const NUMFMT_INNER_TAG = qname(SHEET_MAIN_NS, "numFmt");
+const ALIGNMENT_TAG = qname(SHEET_MAIN_NS, "alignment");
+const PROTECTION_TAG = qname(SHEET_MAIN_NS, "protection");
+/**
+* Parse `xl/styles.xml` and return a fully-populated {@link Stylesheet}. Slot
+* ordering is preserved verbatim; the dedup index Maps are rebuilt after the
+* fact so future `addFont` / `addCellXf` calls keep working.
+*/
+function parseStylesheetXml(bytes) {
+	const root = parseXml(bytes);
+	if (root.name !== STYLESHEET_TAG) throw new OpenXmlSchemaError(`parseStylesheetXml: root is "${root.name}", expected styleSheet`);
+	const ss = makeStylesheet();
+	ss.fonts.length = 0;
+	ss.fills.length = 0;
+	ss.borders.length = 0;
+	for (const fontEl of findInSection(root, FONTS_TAG, FONT_TAG)) ss.fonts.push(fromTree(fontEl, FontSchema));
+	for (const fillEl of findInSection(root, FILLS_TAG, FILL_TAG)) ss.fills.push(fillFromTree(fillEl));
+	for (const borderEl of findInSection(root, BORDERS_TAG, BORDER_TAG)) ss.borders.push(fromTree(borderEl, BorderSchema));
+	for (const numFmtEl of findInSection(root, NUMFMTS_TAG, NUMFMT_TAG)) {
+		const nf = parseNumFmt(numFmtEl);
+		ss.numFmts.set(nf.numFmtId, nf.formatCode);
+	}
+	for (const xfEl of findInSection(root, CELLSTYLEXFS_TAG, XF_TAG)) ss.cellStyleXfs.push(parseCellXf(xfEl));
+	for (const xfEl of findInSection(root, CELLXFS_TAG, XF_TAG)) ss.cellXfs.push(parseCellXf(xfEl));
+	const cellStylesEl = findChild(root, CELLSTYLES_TAG);
+	if (cellStylesEl) {
+		const named = [];
+		for (const cs of findChildren(cellStylesEl, CELLSTYLE_TAG)) {
+			const name = cs.attrs["name"];
+			const xfId = parseIntAttr(cs.attrs["xfId"], "xfId");
+			if (name === void 0 || xfId === void 0) continue;
+			const entry = {
+				name,
+				xfId,
+				...cs.attrs["builtinId"] !== void 0 ? { builtinId: parseIntAttr(cs.attrs["builtinId"], "builtinId") ?? 0 } : {},
+				...cs.attrs["iLevel"] !== void 0 ? { iLevel: parseIntAttr(cs.attrs["iLevel"], "iLevel") ?? 0 } : {},
+				...parseBoolAttr(cs.attrs["hidden"]) === true ? { hidden: true } : {},
+				...parseBoolAttr(cs.attrs["customBuiltin"]) === true ? { customBuiltin: true } : {}
+			};
+			named.push(entry);
+		}
+		if (named.length > 0) {
+			ss.namedStyles = named;
+			ss._namedStyleByName = new Map(named.map((n) => [n.name, n]));
+		}
+	}
+	const dxfsEl = findChild(root, DXFS_TAG);
+	if (dxfsEl) {
+		const dxfs = [];
+		for (const dxfEl of findChildren(dxfsEl, DXF_TAG)) {
+			const fontEl = findChild(dxfEl, FONT_TAG);
+			const numFmtEl = findChild(dxfEl, NUMFMT_INNER_TAG);
+			const fillEl = findChild(dxfEl, FILL_TAG);
+			const alignmentEl = findChild(dxfEl, ALIGNMENT_TAG);
+			const borderEl = findChild(dxfEl, BORDER_TAG);
+			const protectionEl = findChild(dxfEl, PROTECTION_TAG);
+			const dxf = {
+				...fontEl ? { font: fromTree(fontEl, FontSchema) } : {},
+				...numFmtEl ? { numFmt: fromTree(numFmtEl, NumberFormatSchema) } : {},
+				...fillEl ? { fill: fillFromTree(fillEl) } : {},
+				...alignmentEl ? { alignment: fromTree(alignmentEl, AlignmentSchema) } : {},
+				...borderEl ? { border: fromTree(borderEl, BorderSchema) } : {},
+				...protectionEl ? { protection: fromTree(protectionEl, ProtectionSchema) } : {}
+			};
+			dxfs.push(Object.freeze(dxf));
+		}
+		if (dxfs.length > 0) {
+			const w = ss;
+			w.dxfs = dxfs;
+			w._dxfIdByKey = new Map(dxfs.map((d, i) => [stableStringify(d), i]));
+		}
+	}
+	rebuildIndexes(ss);
+	return ss;
+}
+/** Drill from `<styleSheet>` into a numbered section and yield every matching child. */
+function findInSection(root, sectionTag, itemTag) {
+	const section = findChild(root, sectionTag);
+	if (!section) return [];
+	return findChildren(section, itemTag);
+}
+const parseNumFmt = (node) => {
+	const idAttr = node.attrs["numFmtId"];
+	const code = node.attrs["formatCode"];
+	if (idAttr === void 0) throw new OpenXmlSchemaError("styles: <numFmt> missing @numFmtId");
+	if (code === void 0) throw new OpenXmlSchemaError(`styles: <numFmt numFmtId="${idAttr}"> missing @formatCode`);
+	const numFmtId = Number.parseInt(idAttr, 10);
+	if (!Number.isInteger(numFmtId) || numFmtId < 0) throw new OpenXmlSchemaError(`styles: <numFmt numFmtId="${idAttr}"> is not a non-negative integer`);
+	return {
+		numFmtId,
+		formatCode: code
+	};
+};
+const parseIntAttr = (raw, label) => {
+	if (raw === void 0) return void 0;
+	const n = Number.parseInt(raw, 10);
+	if (!Number.isInteger(n) || n < 0) throw new OpenXmlSchemaError(`styles: <xf ${label}="${raw}"> is not a non-negative integer`);
+	return n;
+};
+const parseBoolAttr = (raw) => {
+	if (raw === void 0) return void 0;
+	if (raw === "1" || raw === "true") return true;
+	if (raw === "0" || raw === "false") return false;
+};
+const parseCellXf = (node) => {
+	const fontId = parseIntAttr(node.attrs["fontId"], "fontId") ?? 0;
+	const fillId = parseIntAttr(node.attrs["fillId"], "fillId") ?? 0;
+	const borderId = parseIntAttr(node.attrs["borderId"], "borderId") ?? 0;
+	const numFmtId = parseIntAttr(node.attrs["numFmtId"], "numFmtId") ?? 0;
+	const xfId = parseIntAttr(node.attrs["xfId"], "xfId");
+	const applyFont = parseBoolAttr(node.attrs["applyFont"]);
+	const applyFill = parseBoolAttr(node.attrs["applyFill"]);
+	const applyBorder = parseBoolAttr(node.attrs["applyBorder"]);
+	const applyNumberFormat = parseBoolAttr(node.attrs["applyNumberFormat"]);
+	const applyAlignment = parseBoolAttr(node.attrs["applyAlignment"]);
+	const applyProtection = parseBoolAttr(node.attrs["applyProtection"]);
+	const pivotButton = parseBoolAttr(node.attrs["pivotButton"]);
+	const quotePrefix = parseBoolAttr(node.attrs["quotePrefix"]);
+	const alignmentEl = findChild(node, ALIGNMENT_TAG);
+	const protectionEl = findChild(node, PROTECTION_TAG);
+	return {
+		fontId,
+		fillId,
+		borderId,
+		numFmtId,
+		...xfId !== void 0 ? { xfId } : {},
+		...alignmentEl ? { alignment: fromTree(alignmentEl, AlignmentSchema) } : {},
+		...protectionEl ? { protection: fromTree(protectionEl, ProtectionSchema) } : {},
+		...applyFont !== void 0 ? { applyFont } : {},
+		...applyFill !== void 0 ? { applyFill } : {},
+		...applyBorder !== void 0 ? { applyBorder } : {},
+		...applyNumberFormat !== void 0 ? { applyNumberFormat } : {},
+		...applyAlignment !== void 0 ? { applyAlignment } : {},
+		...applyProtection !== void 0 ? { applyProtection } : {},
+		...pivotButton !== void 0 ? { pivotButton } : {},
+		...quotePrefix !== void 0 ? { quotePrefix } : {}
+	};
+};
+/** Repopulate the `_*IdByKey` maps from the freshly-loaded pool entries. */
+function rebuildIndexes(ss) {
+	ss._fontIdByKey = buildKeyIndex(ss.fonts);
+	ss._fillIdByKey = buildKeyIndex(ss.fills);
+	ss._borderIdByKey = buildKeyIndex(ss.borders);
+	ss._xfIdByKey = buildKeyIndex(ss.cellXfs);
+	ss._styleXfIdByKey = buildKeyIndex(ss.cellStyleXfs);
+	ss._numFmtIdByCode = /* @__PURE__ */ new Map();
+	for (const [id, code] of ss.numFmts) ss._numFmtIdByCode.set(code, id);
+}
+const buildKeyIndex = (arr) => {
+	const m = /* @__PURE__ */ new Map();
+	for (let i = 0; i < arr.length; i++) {
+		const key = stableStringify(arr[i]);
+		if (!m.has(key)) m.set(key, i);
+	}
+	return m;
+};
+//#endregion
+//#region src/io/load.ts
+/** Office Document relationship type — the package-root pointer to `xl/workbook.xml`. */
+const OFFICE_DOC_REL_TYPE = `${REL_NS}/officeDocument`;
+/**
+* Resolve an OPC relationship target against its source part path.
+*
+* - Targets starting with `/` are package-absolute.
+* - Otherwise the target is relative to the source part's parent directory.
+* - `..` segments collapse normally.
+*/
+function resolveRelTarget(sourcePartPath, target) {
+	if (target.startsWith("/")) return target.slice(1);
+	const lastSlash = sourcePartPath.lastIndexOf("/");
+	return normalizePath((lastSlash >= 0 ? sourcePartPath.slice(0, lastSlash + 1) : "") + target);
+}
+function normalizePath(path) {
+	const segments = path.split("/");
+	const out = [];
+	for (const seg of segments) {
+		if (seg === "" || seg === ".") continue;
+		if (seg === "..") {
+			out.pop();
+			continue;
+		}
+		out.push(seg);
+	}
+	return out.join("/");
+}
+/** Sibling rels-part path for a given part. `xl/workbook.xml` → `xl/_rels/workbook.xml.rels`. */
+function relsPathFor(partPath) {
+	const i = partPath.lastIndexOf("/");
+	if (i < 0) return `_rels/${partPath}.rels`;
+	return `${partPath.slice(0, i)}/_rels/${partPath.slice(i + 1)}.rels`;
+}
+const SHEET_TAG = `{${SHEET_MAIN_NS}}sheet`;
+const SHEETS_TAG = `{${SHEET_MAIN_NS}}sheets`;
+const DEFINED_NAMES_TAG = `{${SHEET_MAIN_NS}}definedNames`;
+const DEFINED_NAME_TAG = `{${SHEET_MAIN_NS}}definedName`;
+const RID_ATTR = `{${REL_NS}}id`;
+/** Extract the `<definedNames>/<definedName>` entries from a parsed `xl/workbook.xml`. */
+function parseDefinedNames(workbookRoot) {
+	const wrapper = findChild(workbookRoot, DEFINED_NAMES_TAG);
+	if (!wrapper) return [];
+	const out = [];
+	for (const node of findChildren(wrapper, DEFINED_NAME_TAG)) {
+		const name = node.attrs["name"];
+		if (!name) throw new OpenXmlSchemaError("workbook.xml: <definedName> is missing 'name'");
+		const opts = {
+			name,
+			value: node.text ?? ""
+		};
+		const scopeAttr = node.attrs["localSheetId"];
+		if (scopeAttr !== void 0) {
+			const scope = Number.parseInt(scopeAttr, 10);
+			if (Number.isInteger(scope) && scope >= 0) opts.scope = scope;
+		}
+		if (node.attrs["hidden"] === "1" || node.attrs["hidden"] === "true") opts.hidden = true;
+		if (node.attrs["comment"] !== void 0) opts.comment = node.attrs["comment"];
+		out.push(makeDefinedName(opts));
+	}
+	return out;
+}
+const WORKBOOK_PR_TAG = `{${SHEET_MAIN_NS}}workbookPr`;
+const WORKBOOK_PROTECTION_TAG = `{${SHEET_MAIN_NS}}workbookProtection`;
+const BOOK_VIEWS_TAG = `{${SHEET_MAIN_NS}}bookViews`;
+const WORKBOOK_VIEW_TAG = `{${SHEET_MAIN_NS}}workbookView`;
+const CUSTOM_WORKBOOK_VIEWS_TAG = `{${SHEET_MAIN_NS}}customWorkbookViews`;
+const CUSTOM_WORKBOOK_VIEW_TAG = `{${SHEET_MAIN_NS}}customWorkbookView`;
+const CALC_PR_TAG = `{${SHEET_MAIN_NS}}calcPr`;
+const FILE_VERSION_TAG = `{${SHEET_MAIN_NS}}fileVersion`;
+const FILE_SHARING_TAG = `{${SHEET_MAIN_NS}}fileSharing`;
+const OLE_SIZE_TAG = `{${SHEET_MAIN_NS}}oleSize`;
+const FILE_RECOVERY_PR_TAG = `{${SHEET_MAIN_NS}}fileRecoveryPr`;
+const PIVOT_CACHES_TAG = `{${SHEET_MAIN_NS}}pivotCaches`;
+const PIVOT_CACHE_TAG = `{${SHEET_MAIN_NS}}pivotCache`;
+const EXTERNAL_REFERENCES_TAG = `{${SHEET_MAIN_NS}}externalReferences`;
+const EXTERNAL_REFERENCE_TAG = `{${SHEET_MAIN_NS}}externalReference`;
+const SMART_TAG_PR_TAG = `{${SHEET_MAIN_NS}}smartTagPr`;
+const SMART_TAG_TYPES_TAG = `{${SHEET_MAIN_NS}}smartTagTypes`;
+const SMART_TAG_TYPE_TAG = `{${SHEET_MAIN_NS}}smartTagType`;
+const FUNCTION_GROUPS_TAG = `{${SHEET_MAIN_NS}}functionGroups`;
+const FUNCTION_GROUP_TAG = `{${SHEET_MAIN_NS}}functionGroup`;
+/**
+* Parse the `<workbookPr date1904>` flag. Mac-origin workbooks set
+* `date1904="true"`; everything else uses the Windows 1900 epoch. The value
+* drives Date / Duration cell serial conversion in worksheet/writer.ts and
+* reader.ts.
+*/
+function parseDate1904(workbookRoot) {
+	const pr = findChild(workbookRoot, WORKBOOK_PR_TAG);
+	if (!pr) return false;
+	const v = pr.attrs["date1904"];
+	return v === "1" || v === "true";
+}
+/** Extract the `<sheets>/<sheet>` entries from a parsed `xl/workbook.xml`. */
+function parseSheetEntries(workbookRoot) {
+	const sheets = findChild(workbookRoot, SHEETS_TAG);
+	if (!sheets) return [];
+	const out = [];
+	for (const node of findChildren(sheets, SHEET_TAG)) {
+		const name = node.attrs["name"];
+		const sheetIdAttr = node.attrs["sheetId"];
+		const rId = node.attrs[RID_ATTR];
+		if (!name) throw new OpenXmlSchemaError("workbook.xml: <sheet> is missing 'name'");
+		if (!sheetIdAttr) throw new OpenXmlSchemaError(`workbook.xml: <sheet name="${name}"> is missing 'sheetId'`);
+		if (!rId) throw new OpenXmlSchemaError(`workbook.xml: <sheet name="${name}"> is missing 'r:id'`);
+		const sheetId = Number.parseInt(sheetIdAttr, 10);
+		if (!Number.isInteger(sheetId) || sheetId < 1) throw new OpenXmlSchemaError(`workbook.xml: <sheet name="${name}"> sheetId "${sheetIdAttr}" is not a positive integer`);
+		const stateAttr = node.attrs["state"];
+		let state = "visible";
+		if (stateAttr === "hidden" || stateAttr === "veryHidden") state = stateAttr;
+		out.push({
+			name,
+			sheetId,
+			rId,
+			state
+		});
+	}
+	return out;
+}
+/**
+* Load a workbook from any {@link XlsxSource}. Currently produces a scaffold
+* Workbook: each Worksheet is empty (no cells / styles / shared strings / theme
+* yet). The next phase-3 iterations layer those in atop the same skeleton.
+*/
+async function loadWorkbook(source, opts = {}) {
+	const archive = await openZip(source, opts.decompressionLimits === void 0 ? {} : { decompressionLimits: opts.decompressionLimits });
+	try {
+		return loadWorkbookFromArchive(archive);
+	} finally {
+		archive.close();
+	}
+}
+/** Internal: same as {@link loadWorkbook} but operating on an already-opened archive. */
+function loadWorkbookFromArchive(archive) {
+	if (!archive.has("[Content_Types].xml")) throw new OpenXmlSchemaError(`loadWorkbook: missing "${ARC_CONTENT_TYPES}"`);
+	const manifest = manifestFromBytes(archive.read(ARC_CONTENT_TYPES));
+	if (!archive.has(ARC_ROOT_RELS)) throw new OpenXmlSchemaError(`loadWorkbook: missing "${ARC_ROOT_RELS}"`);
+	const officeRel = relsFromBytes(archive.read(ARC_ROOT_RELS)).rels.find((r) => r.type === OFFICE_DOC_REL_TYPE);
+	if (!officeRel) throw new OpenXmlSchemaError("loadWorkbook: root rels missing officeDocument relationship");
+	const workbookPath = resolveRelTarget("", officeRel.target);
+	if (workbookPath !== ARC_WORKBOOK) {
+		if (!archive.has(workbookPath)) throw new OpenXmlSchemaError(`loadWorkbook: workbook part "${workbookPath}" not found in archive`);
+	}
+	const wbRoot = parseXml(archive.read(workbookPath));
+	if (parseQName(wbRoot.name).local !== "workbook") throw new OpenXmlSchemaError(`loadWorkbook: ${workbookPath} root is "${wbRoot.name}", expected workbook`);
+	const sheetEntries = parseSheetEntries(wbRoot);
+	const definedNamesFromXml = parseDefinedNames(wbRoot);
+	const wbRelsPath = relsPathFor(workbookPath);
+	if (sheetEntries.length > 0 && !archive.has(wbRelsPath)) throw new OpenXmlSchemaError(`loadWorkbook: workbook has sheets but rels part "${wbRelsPath}" is missing`);
+	const wbRels = archive.has(wbRelsPath) ? relsFromBytes(archive.read(wbRelsPath)) : { rels: [] };
+	let sharedStrings;
+	if (archive.has(ARC_SHARED_STRINGS)) sharedStrings = parseSharedStringsXml(archive.read(ARC_SHARED_STRINGS));
+	else {
+		const sstRel = wbRels.rels.find((r) => r.type === `${REL_NS}/sharedStrings`);
+		if (sstRel) {
+			const sstPath = resolveRelTarget(workbookPath, sstRel.target);
+			if (archive.has(sstPath)) sharedStrings = parseSharedStringsXml(archive.read(sstPath));
+		}
+	}
+	const sst = (sharedStrings?.entries ?? []).map((e) => typeof e === "string" ? e : e.runs.map((r) => r.text).join(""));
+	let styles;
+	if (archive.has(ARC_STYLE)) styles = parseStylesheetXml(archive.read(ARC_STYLE));
+	else {
+		const stylesRel = wbRels.rels.find((r) => r.type === `${REL_NS}/styles`);
+		if (stylesRel) {
+			const stylesPath = resolveRelTarget(workbookPath, stylesRel.target);
+			if (archive.has(stylesPath)) styles = parseStylesheetXml(archive.read(stylesPath));
+		}
+	}
+	const properties = archive.has(ARC_CORE) ? corePropsFromBytes(archive.read(ARC_CORE)) : void 0;
+	const appProperties = archive.has(ARC_APP) ? extendedPropsFromBytes(archive.read(ARC_APP)) : void 0;
+	const customProperties = archive.has(ARC_CUSTOM) ? customPropsFromBytes(archive.read(ARC_CUSTOM)) : void 0;
+	const themeXml = (() => {
+		if (archive.has(ARC_THEME)) return archive.read(ARC_THEME);
+		const themeRel = wbRels.rels.find((r) => r.type === `${REL_NS}/theme`);
+		if (themeRel) {
+			const themePath = resolveRelTarget(workbookPath, themeRel.target);
+			if (archive.has(themePath)) return archive.read(themePath);
+		}
+	})();
+	const wb = createWorkbook({ date1904: parseDate1904(wbRoot) });
+	if (styles) wb.styles = styles;
+	if (properties) wb.properties = properties;
+	if (appProperties) wb.appProperties = appProperties;
+	if (customProperties) wb.customProperties = customProperties;
+	if (themeXml) wb.themeXml = themeXml;
+	if (definedNamesFromXml.length > 0) wb.definedNames = definedNamesFromXml;
+	const seenTitles = /* @__PURE__ */ new Set();
+	for (const entry of sheetEntries) {
+		if (seenTitles.has(entry.name)) throw new OpenXmlSchemaError(`loadWorkbook: duplicate sheet name "${entry.name}"`);
+		seenTitles.add(entry.name);
+		const rel = findById(wbRels, entry.rId);
+		if (!rel) throw new OpenXmlSchemaError(`loadWorkbook: sheet "${entry.name}" rId "${entry.rId}" has no matching rels entry`);
+		const sheetPath = resolveRelTarget(workbookPath, rel.target);
+		if (!archive.has(sheetPath)) throw new OpenXmlSchemaError(`loadWorkbook: sheet part "${sheetPath}" not found in archive`);
+		const sheetRelsPath = relsPathFor(sheetPath);
+		const sheetRels = archive.has(sheetRelsPath) ? relsFromBytes(archive.read(sheetRelsPath)) : void 0;
+		const sheetRelsById = sheetRels ? indexRelsById(sheetRels) : void 0;
+		const loadTable = sheetRelsById ? (relId) => {
+			const tRel = sheetRelsById.get(relId);
+			if (!tRel) return void 0;
+			const tablePath = resolveRelTarget(sheetPath, tRel.target);
+			if (!archive.has(tablePath)) return void 0;
+			return parseTableXml(archive.read(tablePath));
+		} : void 0;
+		const loadComments = sheetRelsById ? (relId) => {
+			const cRel = sheetRelsById.get(relId);
+			if (!cRel) return void 0;
+			const cPath = resolveRelTarget(sheetPath, cRel.target);
+			if (!archive.has(cPath)) return void 0;
+			return parseCommentsXml(archive.read(cPath));
+		} : void 0;
+		const loadDrawing = sheetRelsById ? (relId) => {
+			const dRel = sheetRelsById.get(relId);
+			if (!dRel) return void 0;
+			const dPath = resolveRelTarget(sheetPath, dRel.target);
+			if (!archive.has(dPath)) return void 0;
+			const drawing = parseDrawingXml(archive.read(dPath));
+			const dRelsPath = relsPathFor(dPath);
+			if (archive.has(dRelsPath)) {
+				const dRelsById = indexRelsById(relsFromBytes(archive.read(dRelsPath)));
+				for (const item of drawing.items) if (item.content.kind === "chart") {
+					const chartRId = item.content.chart.rId;
+					if (!chartRId) continue;
+					const chartRel = dRelsById.get(chartRId);
+					if (!chartRel) continue;
+					const chartPath = resolveRelTarget(dPath, chartRel.target);
+					if (archive.has(chartPath)) {
+						const chartBytes = archive.read(chartPath);
+						if (isChartExBytes(chartBytes)) item.content.chart.cxSpace = parseChartExXml(chartBytes);
+						else {
+							const space = parseChartXml(chartBytes);
+							const userShapesRId = findUserShapesRId(chartBytes);
+							if (userShapesRId) {
+								const chartRelsPath = relsPathFor(chartPath);
+								if (archive.has(chartRelsPath)) {
+									const usRel = indexRelsById(relsFromBytes(archive.read(chartRelsPath))).get(userShapesRId);
+									if (usRel) {
+										const usPath = resolveRelTarget(chartPath, usRel.target);
+										if (archive.has(usPath)) try {
+											space.userShapes = parseUserShapesXml(archive.read(usPath));
+										} catch {}
+									}
+								}
+							}
+							item.content.chart.space = space;
+						}
+					}
+				} else if (item.content.kind === "picture") {
+					const picRId = item.content.picture.rId;
+					if (!picRId) continue;
+					const picRel = dRelsById.get(picRId);
+					if (!picRel) continue;
+					const imgPath = resolveRelTarget(dPath, picRel.target);
+					if (archive.has(imgPath)) try {
+						item.content.picture.image = loadImage(archive.read(imgPath));
+					} catch {}
+				}
+			}
+			return drawing;
+		} : void 0;
+		if (rel.type === `${REL_NS}/chartsheet`) {
+			const chartsheet = parseChartsheetXml(archive.read(sheetPath), entry.name);
+			if (sheetRels) {
+				const drawingRel = sheetRels.rels.find((r) => r.type === `${REL_NS}/drawing`);
+				if (drawingRel && loadDrawing) {
+					const d = loadDrawing(drawingRel.id);
+					if (d) chartsheet.drawing = d;
+				}
+			}
+			const ref = {
+				kind: "chartsheet",
+				sheet: chartsheet,
+				sheetId: entry.sheetId,
+				state: entry.state,
+				rId: entry.rId
+			};
+			wb.sheets.push(ref);
+			continue;
+		}
+		const ws = parseWorksheetXml(archive.read(sheetPath), entry.name, {
+			sharedStrings: sst,
+			...sheetRels ? { rels: sheetRels } : {},
+			...loadTable ? { loadTable } : {},
+			...loadComments ? { loadComments } : {},
+			...loadDrawing ? { loadDrawing } : {}
+		});
+		if (sheetRels) {
+			const extras = captureSheetRelsExtras(sheetRels);
+			if (extras.length > 0) ws.relsExtras = extras;
+		}
+		const ref = {
+			kind: "worksheet",
+			sheet: ws,
+			sheetId: entry.sheetId,
+			state: entry.state,
+			rId: entry.rId
+		};
+		wb.sheets.push(ref);
+	}
+	captureWorkbookXmlExtras(wbRoot, wb);
+	captureWorkbookRelsExtras(wbRels, wb);
+	capturePassthrough(archive, manifest, wb);
+	return wb;
+}
+const SHEET_MODELED_REL_TYPES = new Set([
+	`${REL_NS}/hyperlink`,
+	`${REL_NS}/table`,
+	`${REL_NS}/comments`,
+	`${REL_NS}/vmlDrawing`,
+	`${REL_NS}/drawing`
+]);
+/**
+* Capture per-sheet rels entries that don't match a modeled type. The writer
+* re-emits these verbatim alongside the freshly allocated modeled rels so
+* captured passthrough parts (pivotTable / queryTable / slicer /
+* printerSettings / oleObject / customProperty / threadedComment) remain
+* reachable from the worksheet after a round-trip.
+*/
+function captureSheetRelsExtras(sheetRels) {
+	const extras = [];
+	for (const rel of sheetRels.rels) {
+		if (SHEET_MODELED_REL_TYPES.has(rel.type)) continue;
+		extras.push({
+			id: rel.id,
+			type: rel.type,
+			target: rel.target
+		});
+	}
+	return extras;
+}
+/**
+* Walk top-level children of `<workbook>` and split anything that isn't
+* `<sheets>` or `<definedNames>` into the before/after halves the writer
+* inserts around the modeled elements. Order is preserved within each half so
+* things like `<fileVersion>`, `<workbookPr>`, `<bookViews>`, `<calcPr>`,
+* `<pivotCaches>`, `<extLst>` round-trip in document order.
+*/
+function captureWorkbookXmlExtras(wbRoot, wb) {
+	const beforeSheets = [];
+	const afterSheets = [];
+	let seenSheets = false;
+	for (const child of wbRoot.children) {
+		if (child.name === SHEETS_TAG) {
+			seenSheets = true;
+			continue;
+		}
+		if (child.name === DEFINED_NAMES_TAG) continue;
+		if (child.name === WORKBOOK_PROTECTION_TAG) {
+			wb.workbookProtection = parseWorkbookProtection(child);
+			continue;
+		}
+		if (child.name === WORKBOOK_PR_TAG) {
+			const wp = parseWorkbookProperties(child);
+			if (wp) wb.workbookProperties = wp;
+			continue;
+		}
+		if (child.name === FILE_SHARING_TAG) {
+			const fs = {};
+			const a = child.attrs;
+			const flag = (raw) => {
+				if (raw === "1" || raw === "true") return true;
+				if (raw === "0" || raw === "false") return false;
+			};
+			const ror = flag(a["readOnlyRecommended"]);
+			if (ror !== void 0) fs.readOnlyRecommended = ror;
+			if (a["userName"] !== void 0) fs.userName = a["userName"];
+			if (a["reservationPassword"] !== void 0) fs.reservationPassword = a["reservationPassword"];
+			if (a["algorithmName"] !== void 0) fs.algorithmName = a["algorithmName"];
+			if (a["hashValue"] !== void 0) fs.hashValue = a["hashValue"];
+			if (a["saltValue"] !== void 0) fs.saltValue = a["saltValue"];
+			if (a["spinCount"] !== void 0) {
+				const n = Number.parseInt(a["spinCount"], 10);
+				if (Number.isInteger(n)) fs.spinCount = n;
+			}
+			if (Object.keys(fs).length > 0) wb.fileSharing = fs;
+			continue;
+		}
+		if (child.name === FILE_VERSION_TAG) {
+			const fv = {};
+			if (child.attrs["appName"] !== void 0) fv.appName = child.attrs["appName"];
+			if (child.attrs["lastEdited"] !== void 0) fv.lastEdited = child.attrs["lastEdited"];
+			if (child.attrs["lowestEdited"] !== void 0) fv.lowestEdited = child.attrs["lowestEdited"];
+			if (child.attrs["rupBuild"] !== void 0) fv.rupBuild = child.attrs["rupBuild"];
+			if (child.attrs["codeName"] !== void 0) fv.codeName = child.attrs["codeName"];
+			if (Object.keys(fv).length > 0) wb.fileVersion = fv;
+			continue;
+		}
+		if (child.name === BOOK_VIEWS_TAG) {
+			const views = [];
+			for (const v of findChildren(child, WORKBOOK_VIEW_TAG)) views.push(parseWorkbookView(v));
+			if (views.length > 0) wb.bookViews = views;
+			continue;
+		}
+		if (child.name === CUSTOM_WORKBOOK_VIEWS_TAG) {
+			const cws = [];
+			for (const v of findChildren(child, CUSTOM_WORKBOOK_VIEW_TAG)) {
+				const parsed = parseCustomWorkbookView(v);
+				if (parsed) cws.push(parsed);
+			}
+			if (cws.length > 0) wb.customWorkbookViews = cws;
+			continue;
+		}
+		if (child.name === CALC_PR_TAG) {
+			const cp = parseCalcProperties(child);
+			if (cp) wb.calcProperties = cp;
+			continue;
+		}
+		if (child.name === OLE_SIZE_TAG) {
+			const ref = child.attrs["ref"];
+			if (ref) wb.oleSize = ref;
+			continue;
+		}
+		if (child.name === SMART_TAG_PR_TAG) {
+			const out = {};
+			const a = child.attrs;
+			if (a["embed"] === "1" || a["embed"] === "true") out.embed = true;
+			else if (a["embed"] === "0" || a["embed"] === "false") out.embed = false;
+			if (a["show"] === "all" || a["show"] === "noIndicator") out.show = a["show"];
+			if (Object.keys(out).length > 0) wb.smartTagPr = out;
+			continue;
+		}
+		if (child.name === SMART_TAG_TYPES_TAG) {
+			const tags = [];
+			for (const t of findChildren(child, SMART_TAG_TYPE_TAG)) {
+				const entry = {};
+				if (t.attrs["namespaceUri"] !== void 0) entry.namespaceUri = t.attrs["namespaceUri"];
+				if (t.attrs["name"] !== void 0) entry.name = t.attrs["name"];
+				if (t.attrs["url"] !== void 0) entry.url = t.attrs["url"];
+				if (Object.keys(entry).length > 0) tags.push(entry);
+			}
+			if (tags.length > 0) wb.smartTagTypes = tags;
+			continue;
+		}
+		if (child.name === FUNCTION_GROUPS_TAG) {
+			const fg = { groups: [] };
+			const bicgRaw = child.attrs["builtInGroupCount"];
+			if (bicgRaw !== void 0) {
+				const n = Number.parseInt(bicgRaw, 10);
+				if (Number.isInteger(n)) fg.builtInGroupCount = n;
+			}
+			for (const g of findChildren(child, FUNCTION_GROUP_TAG)) {
+				const name = g.attrs["name"];
+				if (name) fg.groups.push({ name });
+			}
+			if (fg.groups.length > 0 || fg.builtInGroupCount !== void 0) wb.functionGroups = fg;
+			continue;
+		}
+		if (child.name === EXTERNAL_REFERENCES_TAG) {
+			const refs = [];
+			for (const er of findChildren(child, EXTERNAL_REFERENCE_TAG)) {
+				const rId = er.attrs[`{${REL_NS}}id`];
+				if (rId) refs.push({ rId });
+			}
+			if (refs.length > 0) wb.externalReferences = refs;
+			continue;
+		}
+		if (child.name === PIVOT_CACHES_TAG) {
+			const caches = [];
+			for (const pc of findChildren(child, PIVOT_CACHE_TAG)) {
+				const cacheIdAttr = pc.attrs["cacheId"];
+				const rId = pc.attrs[`{${REL_NS}}id`];
+				if (cacheIdAttr === void 0 || !rId) continue;
+				const cacheId = Number.parseInt(cacheIdAttr, 10);
+				if (!Number.isInteger(cacheId)) continue;
+				caches.push({
+					cacheId,
+					rId
+				});
+			}
+			if (caches.length > 0) wb.pivotCaches = caches;
+			continue;
+		}
+		if (child.name === FILE_RECOVERY_PR_TAG) {
+			const fp = {};
+			const a = child.attrs;
+			const flag = (raw) => {
+				if (raw === "1" || raw === "true") return true;
+				if (raw === "0" || raw === "false") return false;
+			};
+			const ar = flag(a["autoRecover"]);
+			if (ar !== void 0) fp.autoRecover = ar;
+			const cs = flag(a["crashSave"]);
+			if (cs !== void 0) fp.crashSave = cs;
+			const del = flag(a["dataExtractLoad"]);
+			if (del !== void 0) fp.dataExtractLoad = del;
+			const rl = flag(a["repairLoad"]);
+			if (rl !== void 0) fp.repairLoad = rl;
+			if (Object.keys(fp).length > 0) wb.fileRecoveryPr = fp;
+			continue;
+		}
+		if (seenSheets) afterSheets.push(child);
+		else beforeSheets.push(child);
+	}
+	if (beforeSheets.length > 0 || afterSheets.length > 0) wb.workbookXmlExtras = {
+		beforeSheets,
+		afterSheets
+	};
+}
+const SHOW_OBJECTS_MODES = [
+	"all",
+	"placeholders",
+	"none"
+];
+const UPDATE_LINKS_MODES = [
+	"userSet",
+	"never",
+	"always"
+];
+const parseWorkbookProperties = (node) => {
+	const out = {};
+	const a = node.attrs;
+	const flag = (raw) => {
+		if (raw === "1" || raw === "true") return true;
+		if (raw === "0" || raw === "false") return false;
+	};
+	const intAttr = (k) => {
+		if (a[k] === void 0) return void 0;
+		const n = Number.parseInt(a[k], 10);
+		return Number.isInteger(n) ? n : void 0;
+	};
+	for (const k of [
+		"date1904",
+		"dateCompatibility",
+		"showBorderUnselectedTables",
+		"filterPrivacy",
+		"promptedSolutions",
+		"showInkAnnotation",
+		"backupFile",
+		"saveExternalLinkValues",
+		"hidePivotFieldList",
+		"showPivotChartFilter",
+		"allowRefreshQuery",
+		"publishItems",
+		"checkCompatibility",
+		"autoCompressPictures",
+		"refreshAllConnections"
+	]) {
+		const v = flag(a[k]);
+		if (v !== void 0) out[k] = v;
+	}
+	const showObjects = a["showObjects"];
+	if (showObjects && SHOW_OBJECTS_MODES.includes(showObjects)) out.showObjects = showObjects;
+	const updateLinks = a["updateLinks"];
+	if (updateLinks && UPDATE_LINKS_MODES.includes(updateLinks)) out.updateLinks = updateLinks;
+	if (a["codeName"] !== void 0) out.codeName = a["codeName"];
+	const dtv = intAttr("defaultThemeVersion");
+	if (dtv !== void 0) out.defaultThemeVersion = dtv;
+	return Object.keys(out).length > 0 ? out : void 0;
+};
+const CALC_MODES = [
+	"manual",
+	"auto",
+	"autoNoTable"
+];
+const REF_MODES = ["A1", "R1C1"];
+const parseCalcProperties = (node) => {
+	const out = {};
+	const a = node.attrs;
+	const flag = (raw) => {
+		if (raw === "1" || raw === "true") return true;
+		if (raw === "0" || raw === "false") return false;
+	};
+	const intAttr = (k) => {
+		if (a[k] === void 0) return void 0;
+		const n = Number.parseInt(a[k], 10);
+		return Number.isInteger(n) ? n : void 0;
+	};
+	const floatAttr = (k) => {
+		if (a[k] === void 0) return void 0;
+		const n = Number.parseFloat(a[k]);
+		return Number.isFinite(n) ? n : void 0;
+	};
+	const calcId = intAttr("calcId");
+	if (calcId !== void 0) out.calcId = calcId;
+	const calcMode = a["calcMode"];
+	if (calcMode && CALC_MODES.includes(calcMode)) out.calcMode = calcMode;
+	const fcol = flag(a["fullCalcOnLoad"]);
+	if (fcol !== void 0) out.fullCalcOnLoad = fcol;
+	const refMode = a["refMode"];
+	if (refMode && REF_MODES.includes(refMode)) out.refMode = refMode;
+	const iterate = flag(a["iterate"]);
+	if (iterate !== void 0) out.iterate = iterate;
+	const iterateCount = intAttr("iterateCount");
+	if (iterateCount !== void 0) out.iterateCount = iterateCount;
+	const iterateDelta = floatAttr("iterateDelta");
+	if (iterateDelta !== void 0) out.iterateDelta = iterateDelta;
+	const fullPrecision = flag(a["fullPrecision"]);
+	if (fullPrecision !== void 0) out.fullPrecision = fullPrecision;
+	const calcCompleted = flag(a["calcCompleted"]);
+	if (calcCompleted !== void 0) out.calcCompleted = calcCompleted;
+	const calcOnSave = flag(a["calcOnSave"]);
+	if (calcOnSave !== void 0) out.calcOnSave = calcOnSave;
+	const concurrentCalc = flag(a["concurrentCalc"]);
+	if (concurrentCalc !== void 0) out.concurrentCalc = concurrentCalc;
+	const concurrentManualCount = intAttr("concurrentManualCount");
+	if (concurrentManualCount !== void 0) out.concurrentManualCount = concurrentManualCount;
+	const forceFullCalc = flag(a["forceFullCalc"]);
+	if (forceFullCalc !== void 0) out.forceFullCalc = forceFullCalc;
+	return Object.keys(out).length > 0 ? out : void 0;
+};
+const SHOW_COMMENTS_MODES = [
+	"commNone",
+	"commIndicator",
+	"commIndAndComment"
+];
+const SHOW_OBJECTS_CV_MODES = [
+	"all",
+	"placeholders",
+	"none"
+];
+const parseCustomWorkbookView = (node) => {
+	const a = node.attrs;
+	const name = a["name"];
+	const guid = a["guid"];
+	if (!name || !guid) return void 0;
+	const flag = (raw) => {
+		if (raw === "1" || raw === "true") return true;
+		if (raw === "0" || raw === "false") return false;
+	};
+	const intAttr = (k) => {
+		if (a[k] === void 0) return void 0;
+		const n = Number.parseInt(a[k], 10);
+		return Number.isInteger(n) ? n : void 0;
+	};
+	const out = {
+		name,
+		guid,
+		windowWidth: intAttr("windowWidth") ?? 0,
+		windowHeight: intAttr("windowHeight") ?? 0,
+		activeSheetId: intAttr("activeSheetId") ?? 0
+	};
+	for (const k of [
+		"autoUpdate",
+		"changesSavedWin",
+		"onlySync",
+		"personalView",
+		"includePrintSettings",
+		"includeHiddenRowCol",
+		"maximized",
+		"minimized",
+		"showHorizontalScroll",
+		"showVerticalScroll",
+		"showSheetTabs",
+		"showFormulaBar",
+		"showStatusbar"
+	]) {
+		const v = flag(a[k]);
+		if (v !== void 0) out[k] = v;
+	}
+	for (const k of [
+		"mergeInterval",
+		"xWindow",
+		"yWindow",
+		"tabRatio"
+	]) {
+		const v = intAttr(k);
+		if (v !== void 0) out[k] = v;
+	}
+	const sc = a["showComments"];
+	if (sc && SHOW_COMMENTS_MODES.includes(sc)) out.showComments = sc;
+	const so = a["showObjects"];
+	if (so && SHOW_OBJECTS_CV_MODES.includes(so)) out.showObjects = so;
+	return out;
+};
+const VISIBILITIES = [
+	"visible",
+	"hidden",
+	"veryHidden"
+];
+const parseWorkbookView = (node) => {
+	const out = {};
+	const a = node.attrs;
+	const flag = (raw) => {
+		if (raw === "1" || raw === "true") return true;
+		if (raw === "0" || raw === "false") return false;
+	};
+	const intAttr = (k) => {
+		if (a[k] === void 0) return void 0;
+		const n = Number.parseInt(a[k], 10);
+		return Number.isInteger(n) ? n : void 0;
+	};
+	const visibility = a["visibility"];
+	if (visibility && VISIBILITIES.includes(visibility)) out.visibility = visibility;
+	const minimized = flag(a["minimized"]);
+	if (minimized !== void 0) out.minimized = minimized;
+	const shScroll = flag(a["showHorizontalScroll"]);
+	if (shScroll !== void 0) out.showHorizontalScroll = shScroll;
+	const svScroll = flag(a["showVerticalScroll"]);
+	if (svScroll !== void 0) out.showVerticalScroll = svScroll;
+	const sst = flag(a["showSheetTabs"]);
+	if (sst !== void 0) out.showSheetTabs = sst;
+	const xWindow = intAttr("xWindow");
+	if (xWindow !== void 0) out.xWindow = xWindow;
+	const yWindow = intAttr("yWindow");
+	if (yWindow !== void 0) out.yWindow = yWindow;
+	const ww = intAttr("windowWidth");
+	if (ww !== void 0) out.windowWidth = ww;
+	const wh = intAttr("windowHeight");
+	if (wh !== void 0) out.windowHeight = wh;
+	const tr = intAttr("tabRatio");
+	if (tr !== void 0) out.tabRatio = tr;
+	const fs = intAttr("firstSheet");
+	if (fs !== void 0) out.firstSheet = fs;
+	const at = intAttr("activeTab");
+	if (at !== void 0) out.activeTab = at;
+	const adg = flag(a["autoFilterDateGrouping"]);
+	if (adg !== void 0) out.autoFilterDateGrouping = adg;
+	return out;
+};
+const parseWorkbookProtection = (node) => {
+	const out = {};
+	const a = node.attrs;
+	const flag = (raw) => {
+		if (raw === "1" || raw === "true") return true;
+		if (raw === "0" || raw === "false") return false;
+	};
+	if (a["workbookPassword"] !== void 0) out.workbookPassword = a["workbookPassword"];
+	if (a["workbookPasswordCharacterSet"] !== void 0) out.workbookPasswordCharacterSet = a["workbookPasswordCharacterSet"];
+	if (a["workbookAlgorithmName"] !== void 0) out.workbookAlgorithmName = a["workbookAlgorithmName"];
+	if (a["workbookHashValue"] !== void 0) out.workbookHashValue = a["workbookHashValue"];
+	if (a["workbookSaltValue"] !== void 0) out.workbookSaltValue = a["workbookSaltValue"];
+	if (a["workbookSpinCount"] !== void 0) {
+		const n = Number.parseInt(a["workbookSpinCount"], 10);
+		if (Number.isInteger(n)) out.workbookSpinCount = n;
+	}
+	if (a["revisionsPassword"] !== void 0) out.revisionsPassword = a["revisionsPassword"];
+	if (a["revisionsPasswordCharacterSet"] !== void 0) out.revisionsPasswordCharacterSet = a["revisionsPasswordCharacterSet"];
+	if (a["revisionsAlgorithmName"] !== void 0) out.revisionsAlgorithmName = a["revisionsAlgorithmName"];
+	if (a["revisionsHashValue"] !== void 0) out.revisionsHashValue = a["revisionsHashValue"];
+	if (a["revisionsSaltValue"] !== void 0) out.revisionsSaltValue = a["revisionsSaltValue"];
+	if (a["revisionsSpinCount"] !== void 0) {
+		const n = Number.parseInt(a["revisionsSpinCount"], 10);
+		if (Number.isInteger(n)) out.revisionsSpinCount = n;
+	}
+	const ls = flag(a["lockStructure"]);
+	if (ls !== void 0) out.lockStructure = ls;
+	const lw = flag(a["lockWindows"]);
+	if (lw !== void 0) out.lockWindows = lw;
+	const lr = flag(a["lockRevision"]);
+	if (lr !== void 0) out.lockRevision = lr;
+	return out;
+};
+/**
+* Capture workbook-rels entries that don't match a modeled type so the writer
+* can re-emit them with their original Id (and any captured `<pivotCaches
+* r:id="…"/>` etc. still resolves after a round-trip). Modeled non-sheet rels
+* (sst / styles / theme / vbaProject) keep their original Id via
+* `wb.workbookRelOriginalIds` so the writer can prefer those over freshly
+* allocated ones.
+*/
+function captureWorkbookRelsExtras(wbRels, wb) {
+	const SHEET_RELS = new Set([`${REL_NS}/worksheet`, `${REL_NS}/chartsheet`]);
+	const original = {};
+	const extras = [];
+	for (const rel of wbRels.rels) {
+		if (SHEET_RELS.has(rel.type)) continue;
+		if (rel.type === `${REL_NS}/sharedStrings`) {
+			original.sharedStrings = rel.id;
+			continue;
+		}
+		if (rel.type === `${REL_NS}/styles`) {
+			original.styles = rel.id;
+			continue;
+		}
+		if (rel.type === `${REL_NS}/theme`) {
+			original.theme = rel.id;
+			continue;
+		}
+		if (rel.type === `${REL_NS}/vbaProject`) {
+			original.vbaProject = rel.id;
+			continue;
+		}
+		extras.push({
+			id: rel.id,
+			type: rel.type,
+			target: rel.target
+		});
+	}
+	if (Object.keys(original).length > 0) wb.workbookRelOriginalIds = original;
+	if (extras.length > 0) wb.workbookRelsExtras = extras;
+}
+const PASSTHROUGH_PREFIXES = [
+	"xl/activeX/",
+	"xl/ctrlProps/",
+	"xl/embeddings/",
+	"xl/externalLinks/",
+	"xl/model/",
+	"xl/persons/",
+	"xl/pivotCache/",
+	"xl/pivotTables/",
+	"xl/printerSettings/",
+	"xl/queryTables/",
+	"xl/richData/",
+	"xl/slicerCaches/",
+	"xl/slicers/",
+	"xl/threadedComments/",
+	"xl/timelineCaches/",
+	"xl/timelines/",
+	"xl/workbookCache/",
+	"customUI/",
+	"customXml/"
+];
+/**
+* Excel emits both form-control VMLs and comment VMLs at
+* `xl/drawings/vmlDrawingN.vml`. Filename alone can't tell them apart, but
+* ECMA-376 §17.18.51 requires comment shapes to carry `<x:ClientData
+* ObjectType="Note">`, so a byte-search for that marker decides which path the
+* file belongs on:
+*
+*  - With marker → comment VML; the comments writer regenerates
+* these from `Worksheet.legacyComments`, so we must not capture them as
+* passthrough (would duplicate the entry on save).
+*  - Without marker → control / OLE / shape VML; capture as
+* passthrough so form controls survive load → save → load.
+*/
+const COMMENT_VML_MARKER = "ObjectType=\"Note\"";
+const LATIN1_DECODER = new TextDecoder("latin1");
+const isVmlDrawing = (path) => path.startsWith("xl/drawings/") && path.endsWith(".vml");
+const containsCommentMarker = (bytes) => LATIN1_DECODER.decode(bytes).includes(COMMENT_VML_MARKER);
+/**
+* Top-level xl/*.xml files that aren't modeled but Excel relies on (or
+* harmlessly preserves). Captured by exact path; their content types come
+* through the manifest Override map.
+*
+* - `xl/calcChain.xml`     — calculation order hint (Excel rebuilds
+* it on first open if missing, but losing it forces a full recalc).
+* - `xl/connections.xml`   — external data connection metadata.
+* - `xl/persons/`          — threaded-comment author registry
+* (Excel 365). Captured under the prefix list below.
+* - `xl/metadata.xml`      — Excel 365 dynamic-array cell metadata.
+* - `xl/SheetMetadata.xml` — variant casing of the same.
+*/
+const PASSTHROUGH_EXACT_PATHS = new Set([
+	"xl/calcChain.xml",
+	"xl/connections.xml",
+	"xl/metadata.xml",
+	"xl/SheetMetadata.xml",
+	"docProps/thumbnail.jpeg",
+	"docProps/thumbnail.jpg",
+	"docProps/thumbnail.png",
+	"docProps/thumbnail.wmf",
+	"docProps/thumbnail.emf"
+]);
+const isPassthroughPath = (path, bytes) => {
+	if (PASSTHROUGH_EXACT_PATHS.has(path)) return true;
+	if (PASSTHROUGH_PREFIXES.some((p) => path.startsWith(p))) return true;
+	if (isVmlDrawing(path) && bytes) return !containsCommentMarker(bytes);
+	return false;
+};
+/**
+* Walk the archive after the modeled parts are loaded and capture any remaining
+* content into `wb.passthrough`. The dedicated VBA project binaries land on
+* their own slots so the writer can promote the workbook content type to xlsm.
+*/
+function capturePassthrough(archive, manifest, wb) {
+	const overrides = /* @__PURE__ */ new Map();
+	for (const o of manifest.overrides) overrides.set(o.partName.replace(/^\//, ""), o.contentType);
+	for (const path of archive.list()) {
+		if (path === "xl/vbaProject.bin") {
+			wb.vbaProject = archive.read(path);
+			continue;
+		}
+		if (path === "xl/vbaProjectSignature.bin") {
+			wb.vbaSignature = archive.read(path);
+			continue;
+		}
+		let cached;
+		if (isVmlDrawing(path)) cached = archive.read(path);
+		if (!isPassthroughPath(path, cached)) continue;
+		if (!wb.passthrough) wb.passthrough = /* @__PURE__ */ new Map();
+		wb.passthrough.set(path, cached ?? archive.read(path));
+		const ct = overrides.get(path);
+		if (ct !== void 0) {
+			if (!wb.passthroughContentTypes) wb.passthroughContentTypes = /* @__PURE__ */ new Map();
+			wb.passthroughContentTypes.set(path, ct);
+		}
+	}
+}
+//#endregion
+export { resolveRelTarget as n, parseStylesheetXml as r, loadWorkbook as t };
+
+//# sourceMappingURL=load-D5cbhoGx.mjs.map