@office-kit/xlsx 0.8.0

package/dist/streaming.mjs

@@ -0,0 +1,612 @@
+import { i as OpenXmlIoError, o as OpenXmlSchemaError } from "./exceptions-D-CFwxgm.mjs";
+import { s as coordinateToTuple } from "./coordinate-96Ecci4d.mjs";
+import { t as ERROR_CODES } from "./inference-B3ES3KEJ.mjs";
+import { n as escapeXmlAttr } from "./escape-DFTE7ZJc.mjs";
+import { _ as ARC_WORKBOOK_RELS, a as findChildren, c as ARC_CONTENT_TYPES, f as ARC_ROOT_RELS, ft as SHEET_MAIN_NS, g as ARC_WORKBOOK, i as findChild, lt as REL_NS, m as ARC_STYLE, p as ARC_SHARED_STRINGS, pt as STYLES_TYPE, ut as SHARED_STRINGS_TYPE, wt as XLSX_TYPE, yt as WORKSHEET_TYPE } from "./tree-Bbs1C8Rc.mjs";
+import { _ as serializeCell, t as stylesheetToBytes } from "./stylesheet-writer-C2eRmn22.mjs";
+import { t as parseXml } from "./parser-DuLejQy1.mjs";
+import { Q as findById, a as makeManifest, n as addOverride, nt as relsFromBytes, o as manifestFromBytes, rt as relsToBytes, s as manifestToBytes, t as addDefault, tt as makeRelationships } from "./manifest-Dps1-OpP.mjs";
+import { A as sharedStringsToBytes, D as parseSharedStringsXml, E as makeSharedStrings, S as validateSheetTitle } from "./workbook-HGYNRBlV.mjs";
+import { at as addNumFmt, et as addBorder, ft as makeStylesheet, it as addFont, nt as addCellXf, ot as defaultCellXf, rt as addFill } from "./cell-style-BEDjMX1y.mjs";
+import { n as resolveRelTarget, r as parseStylesheetXml } from "./load-D5cbhoGx.mjs";
+import { t as openZip } from "./reader-D1fNW9k1.mjs";
+import { t as createZipWriter } from "./writer-DspzfkNA.mjs";
+import { n as iterParse, t as utf8ByteLength } from "./utf8-D91g1XTG.mjs";
+//#region src/streaming/read-only.ts
+const SHEET_TAG = `{${SHEET_MAIN_NS}}sheet`;
+const SHEETS_TAG = `{${SHEET_MAIN_NS}}sheets`;
+const parseSheetList = (workbookXml, workbookPath, archive) => {
+	const sheetsEl = findChild(parseXml(workbookXml), SHEETS_TAG);
+	if (!sheetsEl) return [];
+	const wbRelsPath = relsPathFor(workbookPath);
+	const wbRels = archive.has(wbRelsPath) ? relsFromBytes(archive.read(wbRelsPath)) : { rels: [] };
+	const out = [];
+	for (const sheet of findChildren(sheetsEl, SHEET_TAG)) {
+		const name = sheet.attrs["name"];
+		const rId = sheet.attrs[`{${REL_NS}}id`];
+		if (!name || !rId) continue;
+		const rel = findById(wbRels, rId);
+		if (!rel) continue;
+		const partPath = resolveRelTarget(workbookPath, rel.target);
+		out.push({
+			name,
+			rId,
+			partPath
+		});
+	}
+	return out;
+};
+const 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 localName = (qname) => {
+	const i = qname.lastIndexOf("}");
+	return i < 0 ? qname : qname.slice(i + 1);
+};
+const decodeCellValue = (t, vText, inlineText, sst) => {
+	switch (t) {
+		case "n": return vText !== void 0 && vText !== "" ? Number.parseFloat(vText) : null;
+		case "s": {
+			if (vText === void 0) return null;
+			const idx = Number.parseInt(vText, 10);
+			if (!Number.isInteger(idx) || idx < 0 || idx >= sst.length) return null;
+			return sst[idx] ?? null;
+		}
+		case "b": return vText === "1";
+		case "e":
+			if (!vText || !ERROR_CODES.has(vText)) return null;
+			return {
+				kind: "error",
+				code: vText
+			};
+		case "str": return vText ?? "";
+		case "inlineStr": return inlineText ?? "";
+		default: return vText !== void 0 && vText !== "" ? Number.parseFloat(vText) : null;
+	}
+};
+/**
+* SAX-iterate `<sheetData>/<row>/<c>` events out of the worksheet bytes (or a
+* stream that yields them), yielding one `ReadOnlyCell[]` per row that matches
+* `opts`.
+*/
+async function* iterSheetRows(sheetInput, sst, opts) {
+	const minRow = opts.minRow ?? 1;
+	const maxRow = opts.maxRow ?? Number.POSITIVE_INFINITY;
+	const minCol = opts.minCol ?? 1;
+	const maxCol = opts.maxCol ?? Number.POSITIVE_INFINITY;
+	let inSheetData = false;
+	let currentRow = -1;
+	let currentCells = [];
+	let cellOpen = false;
+	let cellRow = 0;
+	let cellCol = 0;
+	let cellType = "n";
+	let cellStyleId = 0;
+	let inV = false;
+	let vText = "";
+	let inIs = false;
+	let inIsT = false;
+	let isText = "";
+	for await (const ev of iterParse(sheetInput)) {
+		const e = ev;
+		if (e.kind === "start") {
+			const local = localName(e.name);
+			if (!inSheetData) {
+				if (local === "sheetData") inSheetData = true;
+				continue;
+			}
+			switch (local) {
+				case "row": {
+					e.attrs;
+					const rRaw = e.attrs["r"];
+					currentRow = rRaw ? Number.parseInt(rRaw, 10) : currentRow + 1;
+					currentCells = [];
+					break;
+				}
+				case "c": {
+					if (currentRow < 0) break;
+					if (currentRow < minRow || currentRow > maxRow) break;
+					cellOpen = true;
+					cellType = e.attrs["t"] ?? "n";
+					const sRaw = e.attrs["s"];
+					cellStyleId = sRaw ? Number.parseInt(sRaw, 10) || 0 : 0;
+					const ref = e.attrs["r"];
+					if (ref) {
+						const tup = coordinateToTuple(ref);
+						cellRow = tup.row;
+						cellCol = tup.col;
+					} else {
+						cellRow = currentRow;
+						cellCol = (currentCells[currentCells.length - 1]?.col ?? 0) + 1;
+					}
+					vText = "";
+					isText = "";
+					break;
+				}
+				case "v":
+					if (cellOpen) inV = true;
+					break;
+				case "is":
+					if (cellOpen) inIs = true;
+					break;
+				case "t":
+					if (inIs) inIsT = true;
+					break;
+				default: break;
+			}
+			continue;
+		}
+		if (e.kind === "text") {
+			if (inV) vText += e.text;
+			else if (inIsT) isText += e.text;
+			continue;
+		}
+		const local = localName(e.name);
+		if (!inSheetData) continue;
+		switch (local) {
+			case "sheetData":
+				inSheetData = false;
+				return;
+			case "row":
+				if (currentRow >= minRow && currentRow <= maxRow && currentCells.length > 0) yield currentCells;
+				if (currentRow > maxRow) {
+					inSheetData = false;
+					return;
+				}
+				currentRow = -1;
+				currentCells = [];
+				break;
+			case "c":
+				if (cellOpen && cellCol >= minCol && cellCol <= maxCol && cellRow >= minRow && cellRow <= maxRow) {
+					const value = decodeCellValue(cellType, vText, isText, sst);
+					currentCells.push({
+						row: cellRow,
+						col: cellCol,
+						value,
+						styleId: cellStyleId
+					});
+				}
+				cellOpen = false;
+				break;
+			case "v":
+				inV = false;
+				break;
+			case "is":
+				inIs = false;
+				break;
+			case "t":
+				if (inIs) inIsT = false;
+				break;
+			default: break;
+		}
+	}
+}
+/**
+* Build a sorted `[rowNum, byteOffset]` index for every `<row r="N">`
+* occurrence in a worksheet's bytes. Pure byte-level scan (no SAX), cheap
+* relative to the per-cell SAX walk: ~50 ns per row on M-series Node 22.
+*
+* `sheetDataEnd` is the byte offset of `</sheetData>` so callers can clip the
+* slice that gets handed to saxes.
+*/
+const buildRowOffsetIndex = (bytes) => {
+	const out = [];
+	let sheetDataEnd = -1;
+	let i = 0;
+	while (i < bytes.length) {
+		if (bytes[i] !== 60) {
+			i++;
+			continue;
+		}
+		if (sheetDataEnd < 0 && bytes[i + 1] === 47 && bytes[i + 2] === 115 && bytes[i + 3] === 104 && bytes[i + 4] === 101 && bytes[i + 5] === 101 && bytes[i + 6] === 116 && bytes[i + 7] === 68 && bytes[i + 8] === 97 && bytes[i + 9] === 116 && bytes[i + 10] === 97 && bytes[i + 11] === 62) {
+			sheetDataEnd = i;
+			break;
+		}
+		if (bytes[i + 1] !== 114 || bytes[i + 2] !== 111 || bytes[i + 3] !== 119) {
+			i++;
+			continue;
+		}
+		const next = bytes[i + 4];
+		if (next !== 32 && next !== 9 && next !== 10 && next !== 13 && next !== 62 && next !== 47) {
+			i++;
+			continue;
+		}
+		const start = i;
+		let j = i + 4;
+		while (j < bytes.length && bytes[j] !== 62) j++;
+		if (j >= bytes.length) break;
+		const attrsBuf = bytes.subarray(start + 4, j);
+		const attrs = new TextDecoder("ascii", { fatal: false }).decode(attrsBuf);
+		const m = /\sr="(\d+)"/.exec(attrs);
+		if (m?.[1]) {
+			const row = Number.parseInt(m[1], 10);
+			if (Number.isInteger(row)) out.push({
+				row,
+				offset: start
+			});
+		}
+		i = j + 1;
+	}
+	if (sheetDataEnd < 0) sheetDataEnd = bytes.length;
+	return {
+		index: out,
+		sheetDataEnd
+	};
+};
+/**
+* Binary-search the row index for the first entry with `row >= target`. Returns
+* -1 when every recorded row is below the target.
+*/
+const firstRowAtOrAfter = (index, target) => {
+	let lo = 0;
+	let hi = index.length;
+	while (lo < hi) {
+		const mid = lo + hi >>> 1;
+		const entry = index[mid];
+		if (!entry || entry.row < target) lo = mid + 1;
+		else hi = mid;
+	}
+	return lo < index.length ? lo : -1;
+};
+/**
+* Slice a worksheet's bytes to start at the row at index `idxPos` of the
+* row-offset index, wrapping the result with a synthetic `<sheetData>` envelope
+* so saxes parses it in the right namespace.
+*/
+const SHEET_DATA_OPEN = `<?xml version="1.0" encoding="UTF-8"?><sheetData xmlns="${SHEET_MAIN_NS}">`;
+const SHEET_DATA_CLOSE = `</sheetData>`;
+const sliceFromRow = (bytes, fromOffset, sheetDataEnd) => {
+	const prefix = new TextEncoder().encode(SHEET_DATA_OPEN);
+	const suffix = new TextEncoder().encode(SHEET_DATA_CLOSE);
+	const middle = bytes.subarray(fromOffset, sheetDataEnd);
+	const out = new Uint8Array(prefix.length + middle.length + suffix.length);
+	out.set(prefix, 0);
+	out.set(middle, prefix.length);
+	out.set(suffix, prefix.length + middle.length);
+	return out;
+};
+/**
+* Factory: build a {@link ReadOnlyWorksheet} bound to a single worksheet part
+* inside an opened archive. SAX iteration runs lazily — `iterRows` re-reads the
+* part bytes each time so the caller can iterate the same sheet repeatedly
+* without keeping a buffered decoder around.
+*
+* For `iterRows({ minRow > 1 })`, a row-offset index is built lazily on first
+* use and cached; subsequent band queries jump straight to the byte offset of
+* the first matching row instead of SAX-walking the entire `<sheetData>`.
+*/
+const makeStreamingReadOnlyWorksheet = (title, archive, partPath, sst) => {
+	let cached;
+	const ensureIndex = (bytes) => {
+		if (!cached) cached = buildRowOffsetIndex(bytes);
+		return cached;
+	};
+	const iterRows = (opts = {}) => {
+		const minRow = opts.minRow ?? 1;
+		if (minRow <= 1) return iterSheetRows(archive.readStream(partPath), sst, opts);
+		const bytes = archive.read(partPath);
+		const { index, sheetDataEnd } = ensureIndex(bytes);
+		if (index.length === 0) return iterSheetRows(bytes, sst, opts);
+		const pos = firstRowAtOrAfter(index, minRow);
+		if (pos < 0) return (async function* () {})();
+		const target = index[pos];
+		if (!target) return iterSheetRows(bytes, sst, opts);
+		return iterSheetRows(sliceFromRow(bytes, target.offset, sheetDataEnd), sst, opts);
+	};
+	const iterValues = async function* (opts = {}) {
+		for await (const row of iterRows(opts)) yield row.map((c) => c.value);
+	};
+	return {
+		title,
+		iterRows,
+		iterValues
+	};
+};
+/**
+* Factory: build a {@link ReadOnlyWorkbook} from an opened archive + pre-parsed
+* sheet list / styles / shared strings. Per the project-wide "no classes" rule
+* (CLAUDE.md), the workbook is a plain object closing over the archive handle.
+*/
+const makeStreamingReadOnlyWorkbook = (sheetNames, styles, archive, entries, sst) => ({
+	sheetNames,
+	styles,
+	openWorksheet(name) {
+		const entry = entries.get(name);
+		if (!entry) throw new OpenXmlSchemaError(`loadWorkbookStream: no worksheet named "${name}"`);
+		return makeStreamingReadOnlyWorksheet(name, archive, entry.partPath, sst);
+	},
+	async close() {
+		archive.close();
+	}
+});
+/** Open an xlsx for read-only streaming access. */
+async function loadWorkbookStream(source, opts = {}) {
+	const archive = await openZip(source, opts.decompressionLimits === void 0 ? {} : { decompressionLimits: opts.decompressionLimits });
+	if (!archive.has("[Content_Types].xml")) throw new OpenXmlSchemaError(`loadWorkbookStream: missing "${ARC_CONTENT_TYPES}"`);
+	manifestFromBytes(archive.read(ARC_CONTENT_TYPES));
+	if (!archive.has(ARC_ROOT_RELS)) throw new OpenXmlSchemaError(`loadWorkbookStream: missing "${ARC_ROOT_RELS}"`);
+	const officeDocRel = relsFromBytes(archive.read(ARC_ROOT_RELS)).rels.find((r) => r.type === `${REL_NS}/officeDocument`);
+	if (!officeDocRel) throw new OpenXmlSchemaError(`loadWorkbookStream: no officeDocument relationship in root rels`);
+	const workbookPath = resolveRelTarget("", officeDocRel.target);
+	if (!archive.has(workbookPath)) throw new OpenXmlSchemaError(`loadWorkbookStream: workbook part "${workbookPath}" missing`);
+	const sheetEntries = parseSheetList(archive.read(workbookPath), workbookPath, archive);
+	const entryMap = /* @__PURE__ */ new Map();
+	for (const e of sheetEntries) entryMap.set(e.name, e);
+	let sst = {
+		entries: [],
+		index: /* @__PURE__ */ new Map()
+	};
+	if (archive.has(ARC_SHARED_STRINGS)) sst = parseSharedStringsXml(archive.read(ARC_SHARED_STRINGS));
+	let styles = makeStylesheet();
+	if (archive.has(ARC_STYLE)) styles = parseStylesheetXml(archive.read(ARC_STYLE));
+	return makeStreamingReadOnlyWorkbook(sheetEntries.map((e) => e.name), styles, archive, entryMap, sst.entries.map((e) => typeof e === "string" ? e : e.runs.map((r) => r.text).join("")));
+}
+//#endregion
+//#region src/streaming/write-only.ts
+const escapeAttr = escapeXmlAttr;
+const validateTitle = (title, taken) => {
+	const reason = validateSheetTitle(title);
+	if (reason) throw new OpenXmlIoError(`Worksheet title "${title}": ${reason}`);
+	if (taken.has(title.toLowerCase())) throw new OpenXmlIoError(`Worksheet title "${title}" is already in use`);
+};
+/** Allocate a CellXf id for a style spec. Mirrors cell-style.ts but works directly on the pool. */
+const allocateXfId = (ss, style) => {
+	let xf = {
+		fontId: 0,
+		fillId: 0,
+		borderId: 0,
+		numFmtId: 0
+	};
+	if (style.font !== void 0) xf = {
+		...xf,
+		fontId: addFont(ss, style.font),
+		applyFont: true
+	};
+	if (style.fill !== void 0) xf = {
+		...xf,
+		fillId: addFill(ss, style.fill),
+		applyFill: true
+	};
+	if (style.border !== void 0) xf = {
+		...xf,
+		borderId: addBorder(ss, style.border),
+		applyBorder: true
+	};
+	if (style.numberFormat !== void 0) xf = {
+		...xf,
+		numFmtId: addNumFmt(ss, style.numberFormat),
+		applyNumberFormat: true
+	};
+	if (style.alignment !== void 0) xf = {
+		...xf,
+		alignment: style.alignment,
+		applyAlignment: true
+	};
+	if (style.protection !== void 0) xf = {
+		...xf,
+		protection: style.protection,
+		applyProtection: true
+	};
+	return addCellXf(ss, xf);
+};
+/**
+* Flush threshold for the worksheet's pending-row text buffer. Smaller values
+* minimise heap; larger values amortise the TextEncoder + push overhead. 64 KB
+* is a sweet spot — heap stays low and per-row JS work is dominated by the
+* actual XML construction, not flushing.
+*/
+const FLUSH_THRESHOLD_BYTES = 64 * 1024;
+/**
+* Factory: build a {@link WriteOnlyWorksheet} that closes over the shared
+* {@link WorkbookState}. Per the project-wide "no classes" rule (CLAUDE.md) the
+* worksheet is a plain object holding the row buffer + column-width map in
+* closure state.
+*
+* The worksheet streams its `<sheetData>` body chunk-by-chunk through the ZIP
+* writer's `addStreamingEntry` API, so the heap footprint stays at one ~64 KB
+* pending text buffer plus deflate scratch — no Cell objects, no all-rows
+* accumulation. The XML envelope (decl / worksheet open / cols / sheetData
+* open) flushes on the first `appendRow` (or `close()` if the sheet is empty);
+* column widths staged via `setColumnWidth` *must* land before the first row.
+*/
+const makeWriteOnlyWorksheet = (state, title, sheetId) => {
+	let nextRow = 1;
+	let closed = false;
+	let headerFlushed = false;
+	const columnWidths = /* @__PURE__ */ new Map();
+	const dummyCtx = {
+		sharedStrings: state.sst,
+		rels: makeRelationships()
+	};
+	const encoder = new TextEncoder();
+	const stream = state.writer.addStreamingEntry(`xl/worksheets/sheet${sheetId}.xml`);
+	let pendingText = "";
+	let pendingBytes = 0;
+	const writeText = (text) => {
+		pendingText += text;
+		pendingBytes += utf8ByteLength(text);
+		if (pendingBytes >= FLUSH_THRESHOLD_BYTES) {
+			stream.write(encoder.encode(pendingText));
+			pendingText = "";
+			pendingBytes = 0;
+		}
+	};
+	const flushHeader = () => {
+		if (headerFlushed) return;
+		headerFlushed = true;
+		let header = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
+		header += `<worksheet xmlns="${SHEET_MAIN_NS}" xmlns:r="${REL_NS}">`;
+		if (columnWidths.size > 0) {
+			header += "<cols>";
+			const sorted = [...columnWidths.entries()].sort((a, b) => a[0] - b[0]);
+			for (const [col, width] of sorted) header += `<col min="${col}" max="${col}" width="${width}" customWidth="1"/>`;
+			header += "</cols>";
+		}
+		header += "<sheetData>";
+		writeText(header);
+	};
+	const appendRow = async (row) => {
+		if (closed) throw new OpenXmlIoError("appendRow: worksheet already closed");
+		flushHeader();
+		const r = nextRow++;
+		let xml = `<row r="${r}">`;
+		for (let i = 0; i < row.length; i++) {
+			const item = row[i];
+			if (item === void 0 || item === null) continue;
+			const col = i + 1;
+			let value;
+			let style;
+			if (item !== null && typeof item === "object" && "value" in item) {
+				const wrapped = item;
+				value = wrapped.value;
+				style = wrapped.style;
+			} else value = item;
+			const styleId = style ? allocateXfId(state.styles, style) : 0;
+			xml += serializeCell({
+				row: r,
+				col,
+				value,
+				styleId
+			}, dummyCtx);
+		}
+		xml += "</row>";
+		writeText(xml);
+	};
+	const setColumnWidth = (col, width) => {
+		if (closed) throw new OpenXmlIoError("setColumnWidth: worksheet already closed");
+		if (headerFlushed) throw new OpenXmlIoError("setColumnWidth: must be called before the first appendRow — column widths are emitted as part of the worksheet header");
+		columnWidths.set(col, width);
+	};
+	const close = async () => {
+		if (closed) return;
+		closed = true;
+		flushHeader();
+		writeText("</sheetData></worksheet>");
+		if (pendingText.length > 0) {
+			stream.write(encoder.encode(pendingText));
+			pendingText = "";
+			pendingBytes = 0;
+		}
+		await stream.end();
+		state.sheets.push({
+			title,
+			sheetId
+		});
+		state.hasOpenWorksheet = false;
+	};
+	return {
+		title,
+		appendRow,
+		setColumnWidth,
+		close
+	};
+};
+/**
+* Factory: build a {@link WriteOnlyWorkbook} from a sink. State lives in a
+* closure rather than on a class instance per the project-wide "no classes"
+* rule (CLAUDE.md).
+*/
+const makeWriteOnlyWorkbook = (sink) => {
+	const styles = makeStylesheet();
+	addCellXf(styles, defaultCellXf());
+	const state = {
+		styles,
+		sst: makeSharedStrings(),
+		sheets: [],
+		finalised: false,
+		hasOpenWorksheet: false,
+		writer: createZipWriter(sink)
+	};
+	const addWorksheet = async (title) => {
+		if (state.finalised) throw new OpenXmlIoError("addWorksheet: workbook already finalised");
+		if (state.hasOpenWorksheet) throw new OpenXmlIoError("addWorksheet: previous worksheet still open — call close() before opening the next one");
+		validateTitle(title, new Set(state.sheets.map((s) => s.title.toLowerCase())));
+		state.hasOpenWorksheet = true;
+		return makeWriteOnlyWorksheet(state, title, state.sheets.length + 1);
+	};
+	const finalize = async () => {
+		if (state.finalised) throw new OpenXmlIoError("finalize: already finalised");
+		if (state.hasOpenWorksheet) throw new OpenXmlIoError("finalize: a worksheet is still open — call close() before finalising");
+		state.finalised = true;
+		const writer = state.writer;
+		try {
+			await finalizeImpl(state, writer);
+		} catch (err) {
+			writer.abort(err);
+			throw err;
+		}
+	};
+	const abort = (cause) => {
+		if (state.finalised) return;
+		state.finalised = true;
+		state.writer.abort(cause);
+	};
+	return {
+		addWorksheet,
+		finalize,
+		abort
+	};
+};
+async function finalizeImpl(state, writer) {
+	await writer.addEntry(ARC_STYLE, stylesheetToBytes(state.styles));
+	if (state.sst.entries.length > 0) await writer.addEntry(ARC_SHARED_STRINGS, sharedStringsToBytes(state.sst));
+	const workbookXml = serializeWorkbookXml(state.sheets);
+	await writer.addEntry(ARC_WORKBOOK, new TextEncoder().encode(workbookXml));
+	const wbRels = makeRelationships();
+	state.sheets.forEach((s, i) => {
+		wbRels.rels.push({
+			id: `rId${i + 1}`,
+			type: `${REL_NS}/worksheet`,
+			target: `worksheets/sheet${s.sheetId}.xml`
+		});
+	});
+	if (state.sst.entries.length > 0) wbRels.rels.push({
+		id: `rId${wbRels.rels.length + 1}`,
+		type: `${REL_NS}/sharedStrings`,
+		target: "sharedStrings.xml"
+	});
+	wbRels.rels.push({
+		id: `rId${wbRels.rels.length + 1}`,
+		type: `${REL_NS}/styles`,
+		target: "styles.xml"
+	});
+	await writer.addEntry(ARC_WORKBOOK_RELS, relsToBytes(wbRels));
+	const rootRels = makeRelationships();
+	rootRels.rels.push({
+		id: "rId1",
+		type: `${REL_NS}/officeDocument`,
+		target: "xl/workbook.xml"
+	});
+	await writer.addEntry(ARC_ROOT_RELS, relsToBytes(rootRels));
+	const manifest = makeManifest();
+	addDefault(manifest, "rels", "application/vnd.openxmlformats-package.relationships+xml");
+	addDefault(manifest, "xml", "application/xml");
+	addOverride(manifest, `/${ARC_WORKBOOK}`, XLSX_TYPE);
+	for (const s of state.sheets) addOverride(manifest, `/xl/worksheets/sheet${s.sheetId}.xml`, WORKSHEET_TYPE);
+	addOverride(manifest, `/${ARC_STYLE}`, STYLES_TYPE);
+	if (state.sst.entries.length > 0) addOverride(manifest, `/${ARC_SHARED_STRINGS}`, SHARED_STRINGS_TYPE);
+	await writer.addEntry(ARC_CONTENT_TYPES, manifestToBytes(manifest));
+	await writer.finalize();
+}
+const serializeWorkbookXml = (sheets) => {
+	const parts = [
+		"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>",
+		`<workbook xmlns="${SHEET_MAIN_NS}" xmlns:r="${REL_NS}">`,
+		"<sheets>"
+	];
+	sheets.forEach((s, i) => {
+		parts.push(`<sheet name="${escapeAttr(s.title)}" sheetId="${s.sheetId}" r:id="rId${i + 1}"/>`);
+	});
+	parts.push("</sheets></workbook>");
+	return parts.join("");
+};
+/** Open a workbook for streaming write-only output. */
+async function createWriteOnlyWorkbook(sink, _opts = {}) {
+	return makeWriteOnlyWorkbook(sink);
+}
+//#endregion
+export { createWriteOnlyWorkbook, loadWorkbookStream };
+
+//# sourceMappingURL=streaming.mjs.map