@office-kit/xlsx 0.15.0 → 0.17.0

package/dist/streaming.mjs

@@ -1,42 +1,20 @@
 import { i as OpenXmlIoError, o as OpenXmlSchemaError } from "./exceptions-D-CFwxgm.mjs";
-import { s as coordinateToTuple } from "./coordinate-Bt5Gni2I.mjs";
+import { _ as rowNumberFromAttr, c as derivedRowNumber, s as coordinateToTuple } from "./coordinate-CxC88uBk.mjs";
 import { t as ERROR_CODES } from "./inference-BMvv9cUY.mjs";
-import { n as escapeXmlAttr } from "./escape-rnWSPpWY.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-BX-sRRVp.mjs";
-import { t as stylesheetToBytes, v as serializeCell } from "./stylesheet-writer-TxsinwbO.mjs";
+import { a as unescapeCellString, n as escapeXmlAttr } from "./escape-rA5UpibT.mjs";
+import { _ as ARC_WORKBOOK_RELS, c as ARC_CONTENT_TYPES, f as ARC_ROOT_RELS, ft as SHEET_MAIN_NS, g as ARC_WORKBOOK, 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-BX-sRRVp.mjs";
+import { t as stylesheetToBytes, v as serializeCell, x as parseCellNumber } from "./stylesheet-writer-BBYjNSMA.mjs";
 import { t as parseXml } from "./parser-By6RWZVW.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-pLmx7KYh.mjs";
-import { ct as buildXfPatch, ht as makeStylesheet, it as addCellXf, lt as defaultCellXf } from "./cell-style-CNsET6WU.mjs";
-import { D as makeSharedStrings, S as validateSheetTitle, j as sharedStringsToBytes, k as parseSharedStringsXml } from "./workbook-DQCslHzY.mjs";
-import { i as parseStylesheetXml, n as parseDate1904, r as resolveRelTarget } from "./load-CspGc399.mjs";
-import { t as openZip } from "./reader-DHMxLBQV.mjs";
+import { r as parseXsdBoolean } from "./serialize-Dmb6Vtt9.mjs";
+import { $ as findByType, 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-BHUYpjUG.mjs";
+import { ct as buildXfPatch, ht as makeStylesheet, it as addCellXf, lt as defaultCellXf } from "./cell-style-DjKKPWDL.mjs";
+import { A as serializeRichString, D as makeSharedStrings, S as validateSheetTitle, k as parseSharedStringsXml } from "./workbook-CMel6UcI.mjs";
+import { a as parseDate1904, c as resolveRelTarget, l as parseStylesheetXml, n as SHARED_STRINGS_PART, o as parseSheetEntries, r as STYLES_PART, s as readOptionalWorkbookPart, t as OFFICE_DOC_REL_TYPE } from "./load-DIdQ_zum.mjs";
+import { t as openZip } from "./reader-pC7bxYAs.mjs";
 import { t as utf8ByteLength } from "./utf8-OAkCDG5g.mjs";
 import { t as createZipWriter } from "./writer-C38RBZCy.mjs";
 import { t as iterParse } from "./iterparse-DZE0zy2M.mjs";
 //#region src/streaming/read-only.ts
-const SHEET_TAG = `{${SHEET_MAIN_NS}}sheet`;
-const SHEETS_TAG = `{${SHEET_MAIN_NS}}sheets`;
-const parseSheetList = (root, workbookPath, archive) => {
-	const sheetsEl = findChild(root, 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`;
@@ -46,16 +24,16 @@ const localName = (qname) => {
 	const i = qname.lastIndexOf("}");
 	return i < 0 ? qname : qname.slice(i + 1);
 };
-const decodeCellValue = (t, vText, inlineText, sst) => {
+const decodeCellValue = (t, vText, inlineText, sst, sheet, col, row) => {
 	switch (t) {
-		case "n": return vText !== void 0 && vText !== "" ? Number.parseFloat(vText) : null;
+		case "n": return parseCellNumber(vText, sheet, col, row);
 		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 "b": return parseXsdBoolean(vText) ?? null;
 		case "e":
 			if (!vText || !ERROR_CODES.has(vText)) return null;
 			return {
@@ -72,14 +50,28 @@ const decodeCellValue = (t, vText, inlineText, sst) => {
 * stream that yields them), yielding one `ReadOnlyCell[]` per row that matches
 * `opts`.
 */
-async function* iterSheetRows(sheetInput, sst, opts) {
+async function* iterSheetRows(title, 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 nextRow = 1;
 	let currentCells = [];
+	let nextCol = 1;
+	let pendingCells = [];
+	const settleRow = (row) => {
+		currentRow = row;
+		nextRow = Math.max(nextRow, row + 1);
+		if (row >= minRow && row <= maxRow) for (const cell of pendingCells) currentCells.push({
+			row,
+			col: cell.col,
+			value: decodeCellValue(cell.type, cell.text, cell.inline, sst, title, cell.col, row),
+			styleId: cell.styleId
+		});
+		pendingCells = [];
+	};
 	let cellOpen = false;
 	let cellRow = 0;
 	let cellCol = 0;
@@ -90,6 +82,7 @@ async function* iterSheetRows(sheetInput, sst, opts) {
 	let inIs = false;
 	let inIsT = false;
 	let isText = "";
+	let isRunText = "";
 	for await (const ev of iterParse(sheetInput)) {
 		const e = ev;
 		if (e.kind === "start") {
@@ -100,28 +93,35 @@ async function* iterSheetRows(sheetInput, sst, opts) {
 			}
 			switch (local) {
 				case "row": {
-					e.attrs;
 					const rRaw = e.attrs["r"];
-					currentRow = rRaw ? Number.parseInt(rRaw, 10) : currentRow + 1;
+					if (rRaw === void 0) currentRow = 0;
+					else {
+						currentRow = rowNumberFromAttr(rRaw, "loadWorkbookStream");
+						nextRow = Math.max(nextRow, currentRow + 1);
+					}
 					currentCells = [];
+					pendingCells = [];
+					nextCol = 1;
 					break;
 				}
 				case "c": {
 					if (currentRow < 0) break;
-					if (currentRow < minRow || currentRow > maxRow) break;
+					const ref = e.attrs["r"];
+					if (currentRow === 0 && ref) settleRow(coordinateToTuple(ref).row);
+					if (currentRow !== 0 && (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;
+						cellCol = nextCol;
 					}
+					nextCol = cellCol + 1;
 					vText = "";
 					isText = "";
 					break;
@@ -133,7 +133,10 @@ async function* iterSheetRows(sheetInput, sst, opts) {
 					if (cellOpen) inIs = true;
 					break;
 				case "t":
-					if (inIs) inIsT = true;
+					if (inIs) {
+						inIsT = true;
+						isRunText = "";
+					}
 					break;
 				default: break;
 			}
@@ -141,7 +144,7 @@ async function* iterSheetRows(sheetInput, sst, opts) {
 		}
 		if (e.kind === "text") {
 			if (inV) vText += e.text;
-			else if (inIsT) isText += e.text;
+			else if (inIsT) isRunText += e.text;
 			continue;
 		}
 		const local = localName(e.name);
@@ -151,6 +154,7 @@ async function* iterSheetRows(sheetInput, sst, opts) {
 				inSheetData = false;
 				return;
 			case "row":
+				if (currentRow === 0) settleRow(derivedRowNumber(nextRow, "loadWorkbookStream"));
 				if (currentRow >= minRow && currentRow <= maxRow && currentCells.length > 0) yield currentCells;
 				if (currentRow > maxRow) {
 					inSheetData = false;
@@ -160,8 +164,15 @@ async function* iterSheetRows(sheetInput, sst, opts) {
 				currentCells = [];
 				break;
 			case "c":
-				if (cellOpen && cellCol >= minCol && cellCol <= maxCol && cellRow >= minRow && cellRow <= maxRow) {
-					const value = decodeCellValue(cellType, vText, isText, sst);
+				if (cellOpen && cellRow === 0 && cellCol >= minCol && cellCol <= maxCol) pendingCells.push({
+					col: cellCol,
+					type: cellType,
+					text: vText,
+					inline: isText,
+					styleId: cellStyleId
+				});
+				else if (cellOpen && cellCol >= minCol && cellCol <= maxCol && cellRow >= minRow && cellRow <= maxRow) {
+					const value = decodeCellValue(cellType, vText, isText, sst, title, cellCol, cellRow);
 					currentCells.push({
 						row: cellRow,
 						col: cellCol,
@@ -178,7 +189,10 @@ async function* iterSheetRows(sheetInput, sst, opts) {
 				inIs = false;
 				break;
 			case "t":
-				if (inIs) inIsT = false;
+				if (inIsT) {
+					isText += unescapeCellString(isRunText);
+					inIsT = false;
+				}
 				break;
 			default: break;
 		}
@@ -187,7 +201,9 @@ async function* iterSheetRows(sheetInput, sst, opts) {
 const isXmlSpace = (b) => b === 32 || b === 9 || b === 10 || b === 13;
 /**
 * Read the `r="N"` row number out of a `<row …>` attribute region, scanning
-* bytes directly. Returns -1 when the attribute is absent or malformed.
+* bytes directly. Returns -1 when the attribute is absent, or holds anything
+* `parseRowNumberAttr` rejects: the two accept the same shapes, so the index
+* can never seek by a number the SAX walk reads differently.
 *
 * Decoding the region to a string and running a regex instead costs one
 * TextDecoder, one string and one match array per row, which on a million-row
@@ -197,9 +213,11 @@ const readRowAttr = (bytes, from, to) => {
 	for (let p = from; p + 3 < to; p++) {
 		if (!isXmlSpace(bytes[p])) continue;
 		if (bytes[p + 1] !== 114 || bytes[p + 2] !== 61 || bytes[p + 3] !== 34) continue;
+		let q = p + 4;
+		while (q < to && isXmlSpace(bytes[q])) q++;
+		if (bytes[q] === 43) q++;
 		let value = 0;
 		let digits = 0;
-		let q = p + 4;
 		while (q < to) {
 			const d = bytes[q];
 			if (d === void 0 || d < 48 || d > 57) break;
@@ -207,7 +225,8 @@ const readRowAttr = (bytes, from, to) => {
 			digits++;
 			q++;
 		}
-		if (digits > 0 && q < to && bytes[q] === 34) return value;
+		while (q < to && isXmlSpace(bytes[q])) q++;
+		if (digits > 0 && value >= 1 && value <= 1048576 && q < to && bytes[q] === 34) return value;
 	}
 	return -1;
 };
@@ -270,9 +289,14 @@ const findSheetDataTagEnd = (bytes) => {
 * `sheetDataEnd` is the byte offset of `</sheetData>` so callers can clip the
 * region that gets handed to saxes. `sheetDataTagEnd` includes the original
 * namespace-bearing ancestor tags, reused by {@link replayFromRow}.
+*
+* `hasUnnumberedRow` reports a `<row>` this scan cannot number, which makes the
+* whole sheet unseekable: a row without `@r` takes the row its first cell
+* names, and reading cell refs is the SAX walk's job.
 */
 const buildRowOffsetIndex = (bytes) => {
 	const out = [];
+	let hasUnnumberedRow = false;
 	let sheetDataEnd = -1;
 	let i = 0;
 	while (i < bytes.length) {
@@ -302,13 +326,15 @@ const buildRowOffsetIndex = (bytes) => {
 			row,
 			offset: start
 		});
+		else hasUnnumberedRow = true;
 		i = j + 1;
 	}
 	if (sheetDataEnd < 0) sheetDataEnd = bytes.length;
 	return {
 		index: out,
 		sheetDataEnd,
-		sheetDataTagEnd: findSheetDataTagEnd(bytes)
+		sheetDataTagEnd: findSheetDataTagEnd(bytes),
+		hasUnnumberedRow
 	};
 };
 /**
@@ -358,7 +384,9 @@ const replayFromRow = (bytes, sheetDataTagEnd, fromOffset, sheetDataEnd) => {
 * `iterRows({ minRow > 1 })` needs random access instead, so the first band
 * query inflates the part and indexes its row offsets, and holds both for the
 * life of the worksheet handle or until the workbook closes. Subsequent band
-* queries jump straight to the first matching row without inflating or scanning again.
+* queries jump straight to the first matching row without inflating or scanning
+* again. A sheet whose rows omit `@r` cannot be indexed by row number, so its
+* band queries keep streaming and hold nothing.
 */
 const makeStreamingReadOnlyWorksheet = (title, archive, partPath, sst, indexes) => {
 	const cacheKey = {};
@@ -366,9 +394,13 @@ const makeStreamingReadOnlyWorksheet = (title, archive, partPath, sst, indexes)
 		let cached = indexes.byWorksheet.get(cacheKey);
 		if (!cached) {
 			const bytes = archive.read(partPath);
-			cached = {
+			const { hasUnnumberedRow, index, sheetDataEnd, sheetDataTagEnd } = buildRowOffsetIndex(bytes);
+			cached = hasUnnumberedRow ? { seekable: false } : {
+				seekable: true,
 				bytes,
-				...buildRowOffsetIndex(bytes)
+				index,
+				sheetDataEnd,
+				sheetDataTagEnd
 			};
 			indexes.byWorksheet.set(cacheKey, cached);
 		}
@@ -376,14 +408,16 @@ const makeStreamingReadOnlyWorksheet = (title, archive, partPath, sst, indexes)
 	};
 	const iterRows = (opts = {}) => {
 		const minRow = opts.minRow ?? 1;
-		if (minRow <= 1) return iterSheetRows(archive.readStream(partPath), sst, opts);
-		const { bytes, index, sheetDataEnd, sheetDataTagEnd } = ensureIndexed();
-		if (index.length === 0 || sheetDataTagEnd < 0) return iterSheetRows(bytes, sst, opts);
+		if (minRow <= 1) return iterSheetRows(title, archive.readStream(partPath), sst, opts);
+		const seek = ensureIndexed();
+		if (!seek.seekable) return iterSheetRows(title, archive.readStream(partPath), sst, opts);
+		const { bytes, index, sheetDataEnd, sheetDataTagEnd } = seek;
+		if (index.length === 0 || sheetDataTagEnd < 0) return iterSheetRows(title, 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(replayFromRow(bytes, sheetDataTagEnd, target.offset, sheetDataEnd), sst, opts);
+		if (!target) return iterSheetRows(title, bytes, sst, opts);
+		return iterSheetRows(title, replayFromRow(bytes, sheetDataTagEnd, target.offset, sheetDataEnd), sst, opts);
 	};
 	const iterValues = async function* (opts = {}) {
 		for await (const row of iterRows(opts)) yield row.map((c) => c.value);
@@ -399,16 +433,16 @@ const makeStreamingReadOnlyWorksheet = (title, archive, partPath, sst, indexes)
 * 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, date1904, archive, entries, sst) => {
+const makeStreamingReadOnlyWorkbook = (sheetNames, styles, date1904, archive, partPathByName, sst) => {
 	const indexes = { byWorksheet: /* @__PURE__ */ new WeakMap() };
 	return {
 		sheetNames,
 		styles,
 		date1904,
 		openWorksheet(name) {
-			const entry = entries.get(name);
-			if (!entry) throw new OpenXmlSchemaError(`loadWorkbookStream: no worksheet named "${name}"`);
-			return makeStreamingReadOnlyWorksheet(name, archive, entry.partPath, sst, indexes);
+			const partPath = partPathByName.get(name);
+			if (partPath === void 0) throw new OpenXmlSchemaError(`loadWorkbookStream: no worksheet named "${name}"`);
+			return makeStreamingReadOnlyWorksheet(name, archive, partPath, sst, indexes);
 		},
 		async close() {
 			archive.close();
@@ -422,21 +456,94 @@ async function loadWorkbookStream(source, opts = {}) {
 	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`);
+	const officeDocRel = findByType(relsFromBytes(archive.read(ARC_ROOT_RELS)), OFFICE_DOC_REL_TYPE);
 	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 workbookRoot = parseXml(archive.read(workbookPath));
-	const sheetEntries = parseSheetList(workbookRoot, workbookPath, archive);
-	const entryMap = /* @__PURE__ */ new Map();
-	for (const e of sheetEntries) entryMap.set(e.name, e);
-	let sst = makeSharedStrings();
-	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, parseDate1904(workbookRoot), archive, entryMap, sst.entries.map((e) => typeof e === "string" ? e : e.runs.map((r) => r.text).join("")));
+	const declaredSheets = parseSheetEntries(workbookRoot);
+	const wbRelsPath = relsPathFor(workbookPath);
+	if (declaredSheets.length > 0 && !archive.has(wbRelsPath)) throw new OpenXmlSchemaError(`loadWorkbookStream: workbook has sheets but rels part "${wbRelsPath}" is missing`);
+	const wbRels = archive.has(wbRelsPath) ? relsFromBytes(archive.read(wbRelsPath)) : makeRelationships();
+	const partPathByName = /* @__PURE__ */ new Map();
+	for (const declared of declaredSheets) {
+		if (partPathByName.has(declared.name)) throw new OpenXmlSchemaError(`loadWorkbookStream: duplicate sheet name "${declared.name}"`);
+		const rel = findById(wbRels, declared.rId);
+		if (!rel) throw new OpenXmlSchemaError(`loadWorkbookStream: sheet "${declared.name}" rId "${declared.rId}" has no matching rels entry`);
+		partPathByName.set(declared.name, resolveRelTarget(workbookPath, rel.target));
+	}
+	const sstBytes = readOptionalWorkbookPart(archive, workbookPath, wbRels, SHARED_STRINGS_PART);
+	const sst = sstBytes === void 0 ? makeSharedStrings() : parseSharedStringsXml(sstBytes);
+	const stylesBytes = readOptionalWorkbookPart(archive, workbookPath, wbRels, STYLES_PART);
+	const styles = stylesBytes === void 0 ? makeStylesheet() : parseStylesheetXml(stylesBytes);
+	return makeStreamingReadOnlyWorkbook(declaredSheets.map((e) => e.name), styles, parseDate1904(workbookRoot), archive, partPathByName, sst.entries.map((e) => typeof e === "string" ? e : e.runs.map((r) => r.text).join("")));
 }
 //#endregion
+//#region src/streaming/string-table.ts
+const MAX_ENTRIES = 1e5;
+const MAX_PAYLOAD_BYTES = 8 * 1024 * 1024;
+const UTF16_BYTES_PER_UNIT = 2;
+const XML_CHUNK_UNITS = 16 * 1024;
+const createWriteOnlyStringTable = () => {
+	const entries = [];
+	const plainIndex = /* @__PURE__ */ new Map();
+	const richIndex = /* @__PURE__ */ new Map();
+	let payloadBytes = 0;
+	let full = false;
+	const serialize = (value) => {
+		const plain = typeof value === "string";
+		const key = plain ? value : serializeRichString(value);
+		const index = plain ? plainIndex : richIndex;
+		const cached = index.get(key);
+		if (cached !== void 0) return {
+			type: "s",
+			xml: `<v>${cached}</v>`
+		};
+		const body = plain ? serializeRichString(value) : key;
+		const bytes = (key.length + body.length) * UTF16_BYTES_PER_UNIT;
+		if (!full && entries.length < MAX_ENTRIES && payloadBytes + bytes <= MAX_PAYLOAD_BYTES) {
+			const id = entries.length;
+			entries.push(body);
+			index.set(key, id);
+			payloadBytes += bytes;
+			return {
+				type: "s",
+				xml: `<v>${id}</v>`
+			};
+		}
+		full = true;
+		return {
+			type: "inlineStr",
+			xml: `<is>${body}</is>`
+		};
+	};
+	const write = async (stream) => {
+		const encoder = new TextEncoder();
+		let pending = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><sst xmlns="${SHEET_MAIN_NS}" count="${entries.length}" uniqueCount="${entries.length}">`;
+		const append = (text) => {
+			pending += text;
+			while (pending.length >= XML_CHUNK_UNITS) {
+				let end = XML_CHUNK_UNITS;
+				const last = pending.charCodeAt(end - 1);
+				if (last >= 55296 && last <= 56319) end--;
+				stream.write(encoder.encode(pending.slice(0, end)));
+				pending = pending.slice(end);
+			}
+		};
+		for (const body of entries) append(`<si>${body}</si>`);
+		append("</sst>");
+		if (pending.length > 0) stream.write(encoder.encode(pending));
+		await stream.end();
+	};
+	return {
+		serialize,
+		write,
+		get size() {
+			return entries.length;
+		}
+	};
+};
+//#endregion
 //#region src/streaming/write-only.ts
 const escapeAttr = escapeXmlAttr;
 const validateTitle = (title, taken) => {
@@ -467,10 +574,10 @@ const FLUSH_THRESHOLD_BYTES = 64 * 1024;
 * 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);
+* writer's `addStreamingEntry` API. Row buffering stays at ~64 KB plus the
+* current row and deflate scratch; strings have a separate workbook-wide cap.
+* 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) => {
@@ -479,9 +586,8 @@ const makeWriteOnlyWorksheet = (state, title, sheetId) => {
 	let headerFlushed = false;
 	const columnWidths = /* @__PURE__ */ new Map();
 	const dummyCtx = {
-		sharedStrings: state.sst,
-		styles: state.styles,
-		rels: makeRelationships()
+		sharedStrings: makeSharedStrings(),
+		styles: state.styles
 	};
 	const encoder = new TextEncoder();
 	const stream = state.writer.addStreamingEntry(`xl/worksheets/sheet${sheetId}.xml`);
@@ -532,7 +638,7 @@ const makeWriteOnlyWorksheet = (state, title, sheetId) => {
 				col,
 				value,
 				styleId
-			}, dummyCtx);
+			}, dummyCtx, state.strings.serialize);
 		}
 		xml += "</row>";
 		writeText(xml);
@@ -576,7 +682,7 @@ const makeWriteOnlyWorkbook = (sink, zipOpts) => {
 	addCellXf(styles, defaultCellXf());
 	const state = {
 		styles,
-		sst: makeSharedStrings(),
+		strings: createWriteOnlyStringTable(),
 		sheets: [],
 		finalised: false,
 		hasOpenWorksheet: false,
@@ -616,7 +722,7 @@ const makeWriteOnlyWorkbook = (sink, zipOpts) => {
 };
 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));
+	if (state.strings.size > 0) await state.strings.write(writer.addStreamingEntry(ARC_SHARED_STRINGS));
 	const workbookXml = serializeWorkbookXml(state.sheets);
 	await writer.addEntry(ARC_WORKBOOK, new TextEncoder().encode(workbookXml));
 	const wbRels = makeRelationships();
@@ -627,7 +733,7 @@ async function finalizeImpl(state, writer) {
 			target: `worksheets/sheet${s.sheetId}.xml`
 		});
 	});
-	if (state.sst.entries.length > 0) wbRels.rels.push({
+	if (state.strings.size > 0) wbRels.rels.push({
 		id: `rId${wbRels.rels.length + 1}`,
 		type: `${REL_NS}/sharedStrings`,
 		target: "sharedStrings.xml"
@@ -651,7 +757,7 @@ async function finalizeImpl(state, writer) {
 	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);
+	if (state.strings.size > 0) addOverride(manifest, `/${ARC_SHARED_STRINGS}`, SHARED_STRINGS_TYPE);
 	await writer.addEntry(ARC_CONTENT_TYPES, manifestToBytes(manifest));
 	await writer.finalize();
 }