xlvane 1.2.1 → 1.2.3

package/dist/{rows-IWKIxHt9.js → rows-DnlfBgme.js}

@@ -1,4 +1,4 @@
-import { $ as fillXml, At as EMPTY_STYLES, B as tokenize, Bt as resolveLimits, Cn as encodeXstring, Ct as relationshipsPartName, Ft as normalizeStyle, G as DEFAULT_FONT, H as X14_DV_URI, I as WarningCollector, It as stableKey, J as borderXml, Lt as isDateFormat, M as openZip, Mt as READING_ORDERS, Nt as checkStyleCount, On as XlvError, Pt as mergeStyles, Rt as DEFAULT_READ_LIMITS, Sn as parseXml, St as openPackage, Tn as escapeText, Tt as zipNameToPartName, V as X14_CF_URI, Vt as suggest, _ as isoDate, _n as childrenNamed, an as MAX_COLUMNS, at as reusableBuiltinNumFmt, b as readWorkbook, bn as decodeXml, bt as parseIsoDateTime, cn as formatCellRef, dn as parseRange, et as fontXml, f as createWorkbook, ft as stringItemXml, gn as childNamed, h as detectHeader, i as readOptions, in as relationshipTypes, jt as parseStyles, ln as formatRange, m as writeWorkbook, mt as textElement, n as oneOfOption, nn as SML_NS, on as MAX_ROWS, q as attr, r as openInput, rn as classifyRelationship, sn as columnLetters, t as booleanOption, tn as REL_NS, tt as formatNumber, un as parseCellRef, vn as parseXmlTree, vt as writeZip, wn as escapeAttr, wt as partKey, x as toBytes, xn as normalizeLineEnds, xt as parseSharedStrings, z as shiftFormula, zt as checkOutputPositions } from "./options-Ba1iWD-Z.js";
+import { $ as fillXml, B as tokenize, Bt as checkKeyText, Cn as normalizeLineEnds, Ct as relationshipsPartName, Dn as escapeAttr, En as encodeXstring, Ft as mergeStyles, G as DEFAULT_FONT, H as X14_DV_URI, Ht as resolveLimits, I as WarningCollector, It as normalizeStyle, J as borderXml, Lt as stableKey, M as openZip, Mt as parseStyles, Nt as READING_ORDERS, On as escapeText, Pt as checkStyleCount, Rt as isDateFormat, Sn as decodeXml, St as openPackage, Tt as zipNameToPartName, Ut as suggest, V as X14_CF_URI, Vt as checkOutputPositions, _ as isoDate, an as classifyRelationship, at as reusableBuiltinNumFmt, b as readWorkbook, bn as parseXmlTree, bt as parseIsoDateTime, cn as MAX_ROWS, dn as formatRange, et as fontXml, f as createWorkbook, fn as parseCellRef, ft as stringItemXml, h as detectHeader, i as readOptions, in as SML_NS, jn as XlvError, jt as EMPTY_STYLES, ln as columnLetters, m as writeWorkbook, mt as textElement, n as oneOfOption, on as relationshipTypes, pn as parseRange, q as attr, r as openInput, rn as REL_NS, sn as MAX_COLUMNS, t as booleanOption, tt as formatNumber, un as formatCellRef, vn as childNamed, vt as writeZip, wn as parseXml, wt as partKey, x as toBytes, xt as parseSharedStrings, yn as childrenNamed, z as shiftFormula, zt as DEFAULT_READ_LIMITS } from "./options-Cw7OraxE.js";
 // src/table.ts
 const READ_OPTIONS = [
 	"sheet",
@@ -199,6 +199,7 @@ function prepare(input, options) {
 	let cellCount = 0;
 	for (const cells of byRow.values()) cellCount += cells.size;
 	checkOutputPositions(numbers.length * columns.length, cellCount, limits.maxCells, "The table", sheet.name);
+	checkKeyText(columns, numbers.length, limits.maxSharedStringChars, sheet.name);
 	for (const r of numbers) {
 		const cells = byRow.get(r);
 		if (skipEmpty && (cells === void 0 || [...cells.values()].every((c) => c.value === null))) continue;
@@ -241,7 +242,7 @@ function toIssue(issue, row, columns) {
 		return typeof key === "number" ? key : String(key);
 	});
 	const first = path[0];
-	const column = typeof first === "string" ? columns.find((c) => c.key === first) : void 0;
+	const column = typeof first === "string" ? columns.get(first) : void 0;
 	return {
 		row,
 		cell: column === void 0 ? null : formatCellRef(row, column.col),
@@ -254,9 +255,11 @@ function collect(prepared, results) {
 	const rows = [];
 	const rowNumbers = [];
 	const issues = [];
+	const byKey = /* @__PURE__ */ new Map();
+	for (const c of prepared.columns) if (!byKey.has(c.key)) byKey.set(c.key, c);
 	results.forEach((result, i) => {
 		const row = prepared.rowNumbers[i] ?? 0;
-		if (result.issues) for (const issue of result.issues) issues.push(toIssue(issue, row, prepared.columns));
+		if (result.issues) for (const issue of result.issues) issues.push(toIssue(issue, row, byKey));
 		else {
 			rows.push(result.value);
 			rowNumbers.push(row);
@@ -359,7 +362,8 @@ const WRITE_OPTIONS = [
 	"columns",
 	"sheet",
 	"preset",
-	"dateSystem"
+	"dateSystem",
+	"maxCells"
 ];
 /** Header style of the `report` preset (D-304). */
 const REPORT_HEADER = {
@@ -478,11 +482,22 @@ function addTableSheet(workbook, rows, options) {
 	columns.forEach((column, c) => {
 		if (hasHeader && column.header !== "") sheet.set(formatCellRef(1, c + 1), column.header, preset === "report" ? REPORT_HEADER : void 0);
 	});
+	const formatted = [];
+	columns.forEach((column, c) => {
+		if (column.numFmt !== void 0) formatted.push(c);
+	});
+	const columnsOfKey = /* @__PURE__ */ new Map();
+	if (!arrays) columns.forEach((column, c) => {
+		const list = columnsOfKey.get(column.key);
+		if (list === void 0) columnsOfKey.set(column.key, [c]);
+		else list.push(c);
+	});
+	let cells = hasHeader ? columns.filter((c) => c.header !== "").length : 0;
+	const hasOwn = (o, key) => Object.prototype.hasOwnProperty.call(o, key);
 	rows.forEach((row, i) => {
 		const r = i + 1 + offset;
-		columns.forEach((column, c) => {
-			const record = row;
-			const raw = arrays ? row[c] : Object.prototype.hasOwnProperty.call(record, column.key) ? record[column.key] : void 0;
+		const put = (c, raw) => {
+			const column = columns[c];
 			const value = raw === void 0 ? null : raw;
 			if (!(value === null || typeof value === "number" || typeof value === "string" || typeof value === "boolean" || value instanceof Date)) throw tableError(`Row ${String(i + 1)}, column "${column.key}" holds ${Array.isArray(value) ? "an array" : typeof value}, which is not a cell value.`, "Cell values are numbers, strings, booleans, Dates or null. Convert nested data first, for example with JSON.stringify.", {
 				row: r,
@@ -491,8 +506,29 @@ function addTableSheet(workbook, rows, options) {
 			if (value === null && column.numFmt === void 0) return;
 			sheet.set(formatCellRef(r, c + 1), value, column.numFmt === void 0 ? void 0 : { numFmt: column.numFmt });
 			widths[c] = Math.max(widths[c] ?? 0, displayLength(value));
-		});
+			cells++;
+		};
+		if (arrays) {
+			const values = row;
+			const n = Math.min(values.length, columns.length);
+			for (let c = 0; c < n; c++) put(c, values[c]);
+			for (const c of formatted) if (c >= n) put(c, void 0);
+			return;
+		}
+		const record = row;
+		const own = Object.getOwnPropertyNames(record);
+		if (own.length >= columns.length) {
+			for (let c = 0; c < columns.length; c++) put(c, hasOwn(record, columns[c].key) ? record[columns[c].key] : void 0);
+			return;
+		}
+		const visit = [];
+		for (const key of own) for (const c of columnsOfKey.get(key) ?? []) visit.push(c);
+		for (const c of formatted) if (!hasOwn(record, columns[c].key)) visit.push(c);
+		visit.sort((x, y) => x - y);
+		for (const c of visit) put(c, hasOwn(record, columns[c].key) ? record[columns[c].key] : void 0);
 	});
+	const maxCells = options.get("maxCells");
+	checkOutputPositions((rows.length + offset) * columns.length, cells, typeof maxCells === "number" ? maxCells : DEFAULT_READ_LIMITS.maxCells, "The table", sheet.name, "The rows are spread over far more columns than they fill, for example after one row with many keys or a long first CSV line. Write fewer columns (the \"columns\" option), split the data over several tables, or raise the \"maxCells\" option for a trusted sparse table.");
 	columns.forEach((column, c) => {
 		if (column.width !== void 0) sheet.column(c + 1, { width: column.width });
 		else if (preset === "report") sheet.column(c + 1, { width: Math.min(MAX_FITTED_WIDTH, Math.max(MIN_WIDTH, (widths[c] ?? 0) + 2)) });
@@ -524,6 +560,11 @@ function addTableSheet(workbook, rows, options) {
 */
 function writeTable(rows, options) {
 	const o = readOptions(options, WRITE_OPTIONS, "writeTable options");
+	const maxCells = o.get("maxCells");
+	if (maxCells !== void 0 && (typeof maxCells !== "number" || !(maxCells > 0))) throw new XlvError("XLV_E_INVALID_OPTION", "The option \"maxCells\" must be a positive number.", {
+		hint: "For example { maxCells: 20_000_000 }, or Infinity.",
+		details: { option: "maxCells" }
+	});
 	const dateSystem = o.get("dateSystem");
 	const workbook = createWorkbook(dateSystem === void 0 ? void 0 : { dateSystem });
 	addTableSheet(workbook, rows, o);
@@ -578,6 +619,21 @@ const INJECTION_START = /* @__PURE__ */ new Set([
 	"﹣",
 	"﹫"
 ]);
+/** Signs that start a formula: refused as the delimiter while formulas are escaped (D-J01). */
+const FORMULA_SIGNS = /* @__PURE__ */ new Set([
+	"=",
+	"+",
+	"-",
+	"@",
+	"＝",
+	"＋",
+	"－",
+	"＠",
+	"﹦",
+	"﹢",
+	"﹣",
+	"﹫"
+]);
 /** Whether text starting with `c` is escaped: one of INJECTION_START or a C0 control (NUL included). */
 const injectionStart = (c) => INJECTION_START.has(c) || c.charCodeAt(0) < 32;
 /**
@@ -615,6 +671,10 @@ function toCSV(input, options) {
 	const newline = oneOfOption("newline", o.get("newline"), ["\r\n", "\n"], "\r\n");
 	const bom = booleanOption("bom", o.get("bom"), false);
 	const injection = oneOfOption("formulaInjection", o.get("formulaInjection"), ["escape", "off"], "escape");
+	if (injection === "escape" && FORMULA_SIGNS.has(delimiter)) throw new XlvError("XLV_E_INVALID_OPTION", `The delimiter "${delimiter}" starts a formula, so lines with an empty first field would run as formulas.`, {
+		hint: "Use \",\" (default), \";\", \"|\" or \"\\t\", or pass formulaInjection: \"off\" for a trusted consumer.",
+		details: { option: "delimiter" }
+	});
 	const limits = resolveLimits(o.get("limits"));
 	const sheet = pickSheet(openInput(input, o.get("limits"), o.get("onWarning")), o.get("sheet"));
 	let startRow = 1;
@@ -913,6 +973,7 @@ function fromCSV(input, options) {
 	const workbook = createWorkbook(dateSystem === void 0 ? void 0 : { dateSystem });
 	const tableOptions = /* @__PURE__ */ new Map([["sheet", o.get("sheet") ?? "Sheet1"], ["preset", oneOfOption("preset", o.get("preset"), ["plain", "report"], "plain")]]);
 	if (columns) tableOptions.set("columns", columns);
+	tableOptions.set("maxCells", maxCells);
 	addTableSheet(workbook, rows, tableOptions);
 	return writeWorkbook(workbook);
 }
@@ -928,13 +989,30 @@ function toDiffCell(cell, styles) {
 	if (styles) out.style = cell.style;
 	return out;
 }
-function sameCell(a, b, styles) {
+/**
+* Compares styles by their stable key, computed once per style object: the reader shares one
+* frozen object per style, so a sheet of a million cells needs a few keys, not two per cell.
+*/
+function styleComparer() {
+	const keys = /* @__PURE__ */ new Map();
+	const keyOf = (style) => {
+		if (typeof style !== "object" || style === null) return stableKey(style);
+		let key = keys.get(style);
+		if (key === void 0) {
+			key = stableKey(style);
+			keys.set(style, key);
+		}
+		return key;
+	};
+	return (a, b) => a === b || keyOf(a) === keyOf(b);
+}
+function sameCell(a, b, sameStyle) {
 	if (a.type !== b.type) return false;
 	const av = a.value instanceof Date ? a.value.getTime() : a.value;
 	const bv = b.value instanceof Date ? b.value.getTime() : b.value;
 	if (!Object.is(av, bv)) return false;
 	if ((a.formula?.text ?? null) !== (b.formula?.text ?? null)) return false;
-	return !styles || stableKey(a.style) === stableKey(b.style);
+	return sameStyle === null || sameStyle(a.style, b.style);
 }
 /**
 * Compares two workbooks: added and removed sheets (by name), visibility changes, and cells
@@ -983,44 +1061,45 @@ function diff(a, b, options) {
 	summary.sheetsAdded = sheetsAdded.length;
 	summary.sheetsRemoved = sheetsRemoved.length;
 	const sheets = [];
+	const sameStyle = styles ? styleComparer() : null;
 	for (const after of second.sheets) {
 		const before = firstNames.get(after.name);
 		if (!before) continue;
 		const fromFirst = [];
 		const fromSecond = [];
 		let count = 0;
-		const record = (list, row, col, change) => {
+		const record = (list, row, col, kind, change) => {
 			count++;
-			if (change.kind === "added") summary.cellsAdded++;
-			else if (change.kind === "removed") summary.cellsRemoved++;
+			if (kind === "added") summary.cellsAdded++;
+			else if (kind === "removed") summary.cellsRemoved++;
 			else summary.cellsChanged++;
 			if (list.length < maxCells) list.push({
 				row,
 				col,
-				change
+				change: change()
 			});
 		};
 		for (const cell of before.cells()) {
 			const other = after.cell(cell.ref);
-			if (other === void 0) record(fromFirst, cell.row, cell.col, {
+			if (other === void 0) record(fromFirst, cell.row, cell.col, "removed", () => ({
 				ref: cell.ref,
 				kind: "removed",
 				before: toDiffCell(cell, styles),
 				after: null
-			});
-			else if (!sameCell(cell, other, styles)) record(fromFirst, cell.row, cell.col, {
+			}));
+			else if (!sameCell(cell, other, sameStyle)) record(fromFirst, cell.row, cell.col, "changed", () => ({
 				ref: cell.ref,
 				kind: "changed",
 				before: toDiffCell(cell, styles),
 				after: toDiffCell(other, styles)
-			});
+			}));
 		}
-		for (const cell of after.cells()) if (before.cell(cell.ref) === void 0) record(fromSecond, cell.row, cell.col, {
+		for (const cell of after.cells()) if (before.cell(cell.ref) === void 0) record(fromSecond, cell.row, cell.col, "added", () => ({
 			ref: cell.ref,
 			kind: "added",
 			before: null,
 			after: toDiffCell(cell, styles)
-		});
+		}));
 		const stateChanged = before.state !== after.state;
 		if (count === 0 && !stateChanged) continue;
 		summary.sheetsChanged++;
@@ -1771,7 +1850,9 @@ function editSheetXml(text, part, sheet, planned, limits) {
 	for (const list of byRow.values()) list.sort((a, b) => a.col - b.col);
 	const forceRefs = rows.some((r) => !r.hasR);
 	const emitted = /* @__PURE__ */ new Set();
-	const pending = [...byRow.keys()].filter((n) => !rows.some((r) => r.number === n)).sort((a, b) => a - b);
+	const existingRows = new Set(rows.map((r) => r.number));
+	const pending = [...byRow.keys()].filter((n) => !existingRows.has(n)).sort((a, b) => a - b);
+	let next = 0;
 	const p = (xml) => withPrefix(xml, prefix);
 	const newRow = (n) => {
 		const cells = (byRow.get(n) ?? []).filter((c) => c.xml !== null).map((c) => p(c.xml ?? "")).join("");
@@ -1779,7 +1860,7 @@ function editSheetXml(text, part, sheet, planned, limits) {
 	};
 	let inner = "";
 	for (const row of rows) {
-		while (pending.length > 0 && (pending[0] ?? 0) < row.number) inner += newRow(pending.shift() ?? 0);
+		while (next < pending.length && (pending[next] ?? 0) < row.number) inner += newRow(pending[next++] ?? 0);
 		const edits = byRow.get(row.number);
 		const needsRefs = forceRefs || row.cells.some((c) => !c.hasR);
 		if (!edits && row.hasR && !needsRefs) {
@@ -1803,7 +1884,7 @@ function editSheetXml(text, part, sheet, planned, limits) {
 		while (k < toInsert.length) body += p(toInsert[k++]?.xml ?? "");
 		inner += row.element.start.empty ? `${openTag(tag)}${body}</${row.element.start.qname}>` : `${tag}${body}${text.slice(row.element.end.start, row.element.end.end)}`;
 	}
-	while (pending.length > 0) inner += newRow(pending.shift() ?? 0);
+	while (next < pending.length) inner += newRow(pending[next++] ?? 0);
 	const changes = [];
 	if (sheetData.start.empty) changes.push([
 		sheetData.start.start,

package/dist/{stream-write-BGuUjlXo.js → stream-write-DWD8Pflj.js}

@@ -1,4 +1,4 @@
-import { $t as metricsOf, A as limitExceeded, Bt as resolveLimits, C as Bytes, D as TAIL_BYTES, Dt as normalizeTable, E as NotLoaded, Et as TABLE_CONTENT_TYPE, F as validateLocalHeaders, Ft as normalizeStyle, Ht as printNames, I as WarningCollector, Jt as DRAWING_CONTENT_TYPE, K as SheetRels, L as sheetNotFound, N as readCentralDirectory, O as checkSource$1, On as XlvError, Ot as checkDefinedName, P as unsupported, Q as createSharedStrings, R as createWorksheetParser, Rt as DEFAULT_READ_LIMITS, S as workbookPartsToLoad, St as openPackage, T as HEAD_BYTES, Ut as printXml, Wt as sheetProtectionXml, X as cellXml, Xt as MediaParts, Y as buildStyles, Yt as IMAGE_CONTENT_TYPES, Z as contentTypesXml, Zt as drawingParts, _ as isoDate, _t as FormulaGroups, a as DATE_FORMAT, an as MAX_COLUMNS, cn as formatCellRef, ct as sheetHead, d as convertCellInput, dt as sheetTail, en as resolveImage, f as createWorkbook, fn as APP_PROPERTIES_PART, gt as workbookXml, h as detectHeader, hn as corePropertiesXml, ht as workbookRelsXml, i as readOptions, it as noteParts, j as locateCentralDirectory, k as corrupt, kt as checkUniqueName, lt as sheetRelsPartName, mn as appPropertiesXml, n as oneOfOption, nt as hyperlinksXml, o as DATE_TIME_FORMAT, on as MAX_ROWS, ot as rootRelsXml, p as sortedNotes, pn as CORE_PROPERTIES_PART, pt as tableParts, rn as classifyRelationship, rt as nameTitles, sn as columnLetters, st as rowStart, u as checkBookViews, ut as sheetRulesXml, v as analyzeWorkbook, w as CORRUPT_HINT, wt as partKey, y as readNotes, yn as createXmlByteStreamParser, yt as crc32, zt as checkOutputPositions } from "./options-Ba1iWD-Z.js";
+import { $t as drawingParts, A as limitExceeded, At as nameScopeKey, Bt as checkKeyText, C as Bytes, Ct as relationshipsPartName, D as TAIL_BYTES, Dt as normalizeTable, E as NotLoaded, Et as TABLE_CONTENT_TYPE, F as validateLocalHeaders, Gt as printXml, Ht as resolveLimits, I as WarningCollector, It as normalizeStyle, K as SheetRels, Kt as sheetProtectionXml, L as sheetNotFound, N as readCentralDirectory, O as checkSource$1, Ot as checkDefinedName, P as unsupported, Q as createSharedStrings, Qt as MediaParts, R as createWorksheetParser, S as workbookPartsToLoad, St as openPackage, T as HEAD_BYTES, Tn as clip, Tt as zipNameToPartName, Vt as checkOutputPositions, Wt as printNames, X as cellXml, Xt as DRAWING_CONTENT_TYPE, Y as buildStyles, Z as contentTypesXml, Zt as IMAGE_CONTENT_TYPES, _ as isoDate, _n as corePropertiesXml, _t as FormulaGroups, a as DATE_FORMAT, an as classifyRelationship, cn as MAX_ROWS, ct as sheetHead, d as convertCellInput, dt as sheetTail, f as createWorkbook, gn as appPropertiesXml, gt as workbookXml, h as detectHeader, hn as CORE_PROPERTIES_PART, ht as workbookRelsXml, i as readOptions, it as noteParts, j as locateCentralDirectory, jn as XlvError, k as corrupt, kt as checkUniqueName, ln as columnLetters, lt as sheetRelsPartName, mn as APP_PROPERTIES_PART, n as oneOfOption, nn as resolveImage, nt as hyperlinksXml, o as DATE_TIME_FORMAT, ot as rootRelsXml, p as sortedNotes, pt as tableParts, rt as nameTitles, sn as MAX_COLUMNS, st as rowStart, tn as metricsOf, u as checkBookViews, un as formatCellRef, ut as sheetRulesXml, v as analyzeWorkbook, w as CORRUPT_HINT, wt as partKey, xn as createXmlByteStreamParser, y as readNotes, yt as crc32, zt as DEFAULT_READ_LIMITS } from "./options-Cw7OraxE.js";
 import { Deflate, Inflate } from "fflate";
 // src/zip/stream.ts
 /**
@@ -396,7 +396,8 @@ function createZipStream(entries, level = 6) {
 // src/stream-read.ts
 const GiB = 1073741824;
 /**
-* Limits that differ in streaming mode (D-401): `maxCells` does not apply, and single parts may
+* Limits that differ in streaming mode (D-401): `maxCells` does not apply (but one `<row>` element
+* may hold at most 16 384 cells, D-J01), and single parts may
 * decompress to 4 GiB (8 GiB in total). All other `DEFAULT_READ_LIMITS` stay.
 *
 * @example
@@ -423,32 +424,69 @@ var PreloadedZip = class {
 	entries;
 	bytesRead = 0;
 	data = /* @__PURE__ */ new Map();
+	/**
+	* ZIP entries by the part name they map to, as openPackage maps them: percent-encoded
+	* non-ASCII characters of an item name are decoded (Part 2 §7.3.5; F-OPC-12).
+	*/
+	byPart = /* @__PURE__ */ new Map();
 	constructor(zip, maxBufferedBytes) {
 		this.zip = zip;
 		this.maxBufferedBytes = maxBufferedBytes;
 		this.entries = zip.entries;
+		for (const entry of zip.entries) {
+			if (entry.name.endsWith("/")) continue;
+			const key = partKey(zipNameToPartName(entry.name));
+			if (!this.byPart.has(key)) this.byPart.set(key, entry);
+		}
 	}
-	async load(names) {
-		for (const name of names) {
-			const entry = this.zip.find(name);
+	/** The ZIP entry that stores a part, or undefined. */
+	entryOf(partName) {
+		return this.byPart.get(partKey(partName));
+	}
+	async load(entries) {
+		for (const entry of entries) {
 			if (entry === void 0 || this.data.has(entry.name)) continue;
 			const bytes = await this.zip.read(entry, this.maxBufferedBytes);
 			this.data.set(entry.name, bytes);
 			this.bytesRead += bytes.length;
 		}
 	}
+	/** Loads the parts with these names that exist. */
+	async loadParts(partNames) {
+		await this.load([...partNames].map((name) => this.entryOf(name)));
+	}
+	/** Loads the Relationships parts of these sources (null: the package) that exist. */
+	async loadRelationships(sources) {
+		await this.loadParts([...sources].map(relationshipsPartName));
+	}
 	find(name) {
 		return this.zip.find(name);
 	}
 	read(entry) {
 		const name = typeof entry === "string" ? this.zip.find(entry)?.name ?? entry : entry.name;
 		const bytes = this.data.get(name);
-		if (bytes === void 0) throw new Error(`internal: ZIP entry "${name}" was not preloaded`);
+		if (bytes === void 0) throw new XlvError("XLV_E_INTERNAL", `The ZIP entry "${clip(name)}" was read before it was loaded.`, {
+			location: { part: `/${clip(name)}` },
+			hint: "This is a bug in xlvane. Please report it, with the file if you can share it; readWorkbook reads the file meanwhile."
+		});
 		return bytes;
 	}
 };
-function zipName(partName) {
-	return partName.slice(1);
+/**
+* The internal targets of the workbook part's relationships: the sheets among them, whose
+* Relationships parts analyzeWorkbook reads. Only these, and not every .rels entry of the ZIP,
+* are loaded (D-H01).
+*/
+function workbookTargets(pkg, workbookPart) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const rel of pkg.relationships(workbookPart)) {
+		const key = partKey(rel.target);
+		if (rel.external || seen.has(key) || !pkg.hasPart(rel.target)) continue;
+		seen.add(key);
+		out.push(rel.target);
+	}
+	return out;
 }
 function checkSource(source) {
 	if (source instanceof Uint8Array || source instanceof ArrayBuffer) return source;
@@ -486,9 +524,15 @@ async function openWorkbookStream(source, options) {
 	});
 	const zip = await openZipSource(input, limits);
 	const preloaded = new PreloadedZip(zip, userLimits?.maxEntryBytes ?? DEFAULT_READ_LIMITS.maxEntryBytes);
-	await preloaded.load(zip.entries.filter((e) => e.name.toLowerCase() === "[content_types].xml" || e.name.toLowerCase().endsWith(".rels")).map((e) => e.name));
+	await preloaded.load(zip.entries.filter((e) => e.name.toLowerCase() === "[content_types].xml"));
+	await preloaded.loadRelationships([null]);
 	const pkg = openPackage(preloaded, limits);
-	await preloaded.load(workbookPartsToLoad(pkg).map(zipName));
+	const workbookPart = pkg.relationships(null).find((r) => !r.external && classifyRelationship(r.type)?.name === "officeDocument")?.target;
+	if (workbookPart !== void 0) {
+		await preloaded.loadRelationships([workbookPart]);
+		await preloaded.loadParts(workbookPartsToLoad(pkg));
+		await preloaded.loadRelationships(workbookTargets(pkg, workbookPart));
+	}
 	const warnings = new WarningCollector();
 	const info = analyzeWorkbook(pkg, limits, warnings);
 	const formatCache = /* @__PURE__ */ new Map();
@@ -504,7 +548,7 @@ async function openWorkbookStream(source, options) {
 		const cached = noteCache.get(entry.part);
 		if (cached !== void 0) return cached;
 		const parts = pkg.relationships(entry.part).filter((r) => !r.external && ["comments", "vmlDrawing"].includes(classifyRelationship(r.type)?.name ?? "") && pkg.hasPart(r.target) && !entry.foreignParts.has(partKey(r.target)));
-		if (parts.length > 0) await preloaded.load(parts.map((r) => zipName(r.target)));
+		if (parts.length > 0) await preloaded.loadParts(parts.map((r) => r.target));
 		const notes = Object.freeze(readNotes(pkg, entry.part, entry.name, limits, warnings, entry.foreignParts));
 		noteCache.set(entry.part, notes);
 		return notes;
@@ -553,7 +597,15 @@ async function openWorkbookStream(source, options) {
 			part,
 			limits
 		});
-		const reader = zip.stream(zipName(part)).getReader();
+		const stored = preloaded.entryOf(part);
+		if (stored === void 0) throw new XlvError("XLV_E_PART_MISSING", `The part ${clip(part)} of sheet "${entry.name}" is not in the archive.`, {
+			location: {
+				part: clip(part),
+				sheet: entry.name
+			},
+			hint: "The workbook is incomplete. Re-save it in a spreadsheet application."
+		});
+		const reader = zip.stream(stored).getReader();
 		try {
 			for (;;) {
 				const { done, value } = await reader.read();
@@ -640,6 +692,7 @@ async function* readTableStream(source, options) {
 	const limits = o.get("limits");
 	const book = await openWorkbookStream(source, limits === void 0 ? void 0 : { limits });
 	const outputCells = limits?.maxCells ?? DEFAULT_READ_LIMITS.maxCells;
+	const keyTextLimit = limits?.maxSharedStringChars ?? DEFAULT_READ_LIMITS.maxSharedStringChars;
 	const sheetName = o.get("sheet") ?? (book.sheets.find((s) => s.kind === "worksheet" && s.state === "visible") ?? book.sheets[0])?.name;
 	if (sheetName === void 0) return;
 	const buffered = [];
@@ -692,6 +745,16 @@ async function* readTableStream(source, options) {
 	};
 	let positions = 0;
 	let cellsRead = 0;
+	let byKey = null;
+	let byKeyOf = null;
+	const columnOf = (cols, key) => {
+		if (byKey === null || byKeyOf !== cols) {
+			byKey = /* @__PURE__ */ new Map();
+			for (const c of cols) if (!byKey.has(c.key)) byKey.set(c.key, c);
+			byKeyOf = cols;
+		}
+		return byKey.get(key);
+	};
 	const emit = async (r, cols) => {
 		if (headerRow !== null && r.number <= headerRow) return null;
 		cellsRead += r.cells.length;
@@ -699,6 +762,7 @@ async function* readTableStream(source, options) {
 		checkOutputPositions(positions, cellsRead, outputCells, "The table", sheetName);
 		const byCol = new Map(r.cells.map((c) => [c.col, c]));
 		if (cols.every((c) => byCol.get(c.col)?.value == null)) return null;
+		checkKeyText(cols, 1, keyTextLimit, sheetName);
 		const row = {};
 		for (const c of cols) setOwn(row, c.key, value(byCol.get(c.col)));
 		if (schema === void 0) return {
@@ -717,7 +781,7 @@ async function* readTableStream(source, options) {
 				const key = typeof seg === "object" && seg !== null ? seg.key : seg;
 				return typeof key === "number" ? key : String(key);
 			});
-			const column = typeof path[0] === "string" ? cols.find((c) => c.key === path[0]) : void 0;
+			const column = typeof path[0] === "string" ? columnOf(cols, path[0]) : void 0;
 			return {
 				row: r.number,
 				cell: column ? formatCellRef(r.number, column.col) : null,
@@ -833,6 +897,7 @@ function writeWorkbookStream(options) {
 		details: { option: "definedNames" }
 	});
 	const names = [];
+	const nameKeys = /* @__PURE__ */ new Map();
 	rawNames.forEach((raw, i) => {
 		const r = readOptions(raw, [
 			"name",
@@ -843,8 +908,9 @@ function writeWorkbookStream(options) {
 		], `definedNames[${String(i)}]`);
 		const { name, refersTo, ...rest } = Object.fromEntries(r);
 		const n = checkDefinedName(name, refersTo, rest, null);
-		checkUniqueName(n, names);
+		checkUniqueName(n, nameKeys);
 		names.push(n);
+		nameKeys.set(nameScopeKey(n), n);
 	});
 	const addNames = () => {
 		for (const n of names) book.defineName(n.name, n.refersTo, {
@@ -942,7 +1008,7 @@ function writeWorkbookStream(options) {
 		for (const v of listOf("tables", "{ name: \"Sales\", ref: \"A1:B10\", columns: [{ name: \"Region\" }, { name: \"Revenue\" }] }")) {
 			const t = normalizeTable(v, sheet.name, true);
 			book.checkTable(t, sheet);
-			sheet.tableList.push(t);
+			sheet.pushTable(t);
 		}
 		const merges = s.get("merges");
 		if (merges !== void 0) {

package/dist/{stream-write-BVaFkgwO.d.ts → stream-write-y52KUDW8.d.ts}

@@ -3587,9 +3587,13 @@ declare class NewSheet {
   private readonly priorities;
   /** @internal Protection, page setup, headers and footers, page breaks, print area and titles. */
   print: SheetPrintData;
-  /** @internal Tables in the order they were added (TD-01). */
+  /** @internal Tables in the order they were added (TD-01); add them with {@link NewSheet.pushTable}. */
   readonly tableList: NormalizedTable[];
   private count;
+  private readonly mergeIndex;
+  private mergesIndexed;
+  private readonly tableIndex;
+  private tablesIndexed;
   /** @internal Use {@link NewWorkbook.addSheet}. */
   constructor(name: string, state: SheetState, book: NewWorkbook, sheetId?: number | null);
   /** Number of cells that have a value or a style. */
@@ -3682,6 +3686,12 @@ declare class NewSheet {
    * ```
    */
   merge(range: string): this;
+  /** @internal Whether `range` shares a cell with a merged range of the sheet. */
+  overlapsMerge(range: CellRange): boolean;
+  /** @internal Whether `range` shares a cell with a table of the sheet. */
+  overlapsTable(range: CellRange): boolean;
+  /** @internal Adds a table checked by {@link NewWorkbook.checkTable} to the sheet. */
+  pushTable(t: NormalizedTable): void;
   /**
    * Freezes the top rows and left columns so that they stay visible when scrolling. Pass
    * `{ rows: 0, cols: 0 }` to remove the frozen panes.
@@ -3969,6 +3979,18 @@ declare class NewWorkbook {
   readonly properties: WorkbookProperties;
   private readonly list;
   private readonly names;
+  /** Sheets by lower-case name. */
+  private readonly sheetsByName;
+  /** Sheet names as given, in sheet order. */
+  private readonly sheetNames;
+  /** Sheets by the sheetId given to addSheet. */
+  private readonly sheetsById;
+  /** Defined names by nameScopeKey. */
+  private readonly namesByScope;
+  /** Lower-case defined names, of any scope. */
+  private readonly lowerNames;
+  /** Lower-case names and display names of the tables of all sheets. */
+  private readonly tableNames;
   private readonly styleIds;
   private readonly styleList;
   /** @internal `workbookProtection`, set by {@link NewWorkbook.protect}. */
@@ -4068,6 +4090,8 @@ declare class NewWorkbook {
    * ```
    */
   defineName(name: string, refersTo: string, options?: DefinedNameOptions): this;
+  /** @internal Records the names of a table added to a sheet ({@link NewSheet.pushTable}). */
+  tableAdded(t: NormalizedTable): void;
   /**
    * @internal Checks that a table's names are unique in the workbook (tables and defined names,
    * ignoring case; Part 1 §18.5.1.2) and that it overlaps no table or merged range of its sheet.
@@ -4499,6 +4523,12 @@ interface WriteTableOptions {
   readonly preset?: "report" | "plain";
   /** Date system of the new workbook. Default `"1900"`. */
   readonly dateSystem?: DateSystem;
+  /**
+   * Bounds the sheet: at most `max(maxCells, 16 × cells written)` positions (rows × columns), so
+   * a few values spread over many rows and columns are refused with `XLV_E_LIMIT_EXCEEDED`.
+   * Default 5 000 000, the `maxCells` read limit; raise it for a large sparse table.
+   */
+  readonly maxCells?: number;
 }
 /**
  * Writes rows as a formatted XLSX table and returns the file's bytes. Rows are objects (keys
@@ -4635,14 +4665,15 @@ interface WorkbookStream {
 interface OpenWorkbookStreamOptions {
   /**
    * Read limits. Streaming defaults differ from `DEFAULT_READ_LIMITS`: `maxCells` does not apply
-   * (memory does not grow with cells), `maxEntryBytes` is 4 GiB for worksheets (inflated piece by
+   * (memory does not grow with cells; one `<row>` element may hold at most 16 384 cells), `maxEntryBytes` is 4 GiB for worksheets (inflated piece by
    * piece) and `maxTotalBytes` 8 GiB. Parts held in memory whole (shared strings, styles, the
    * workbook, relationships, notes) keep the batch bound of 256 MiB unless `maxEntryBytes` is given.
    */
   readonly limits?: Partial<ReadLimits>;
 }
 /**
- * Limits that differ in streaming mode (D-401): `maxCells` does not apply, and single parts may
+ * Limits that differ in streaming mode (D-401): `maxCells` does not apply (but one `<row>` element
+ * may hold at most 16 384 cells, D-J01), and single parts may
  * decompress to 4 GiB (8 GiB in total). All other `DEFAULT_READ_LIMITS` stay.
  *
  * @example

package/docs/errors.md

@@ -95,9 +95,13 @@ Some limits also bound work derived from a small file (1.1.1, D-H01):
 
 - `maxCells` (`details.limit` `maxCells`, `details.value` the budget): `toCSV`, `readTable`, `toJSON`, `readTableStream`, `xlvane read` and `xlvane convert` write at most `max(maxCells, 16 × cells read)` positions (rows × columns of the output), so a few cells far apart cannot make them produce a value for every position between; `@xlvane/compat`'s `xlsx.load` creates at most as many cells for merged ranges, tables and column definitions, and looks up at most 64 Mi rows (or 16 per cell read) for row settings up to the sheets' dimensions. Pass a smaller `range`, or raise `maxCells` for a trusted file.
 - `maxXmlTextLength`: also the length of an XML comment or processing instruction.
-- `maxSharedStringChars`: also the text of shared formulas, counted apart from shared strings: the length of each sharing cell's formula, as moved to that cell.
+- `maxSharedStringChars`: also the text of shared formulas, counted apart from shared strings: the length of each sharing cell's formula, as moved to that cell. From 1.2.3 (D-J01) also the header names that `readTable`, `toJSON` and `readTableStream` repeat in every row object: the sum of the key lengths times the number of rows (a long header over many rows would otherwise make JSON text far larger than the file); `readTableStream` counts one row at a time.
 
-The MCP server (`@xlvane/mcp`) returns it as a tool error for a file larger than `--max-file-size` (`details.limit` `maxFileBytes`) and for a result longer than `--max-response-chars` (`details.limit` `maxResponseChars`; `read_table` instead returns the rows that fit).
+From 1.2.3 (D-J01):
+
+- `maxCells`: `fromCSV`, `fromJSON` and `writeTable` write at most `max(maxCells, 16 × cells written)` positions (rows × columns), so one very wide row followed by many short ones cannot make them visit every position; each takes a `maxCells` option (default 5 000 000). While streaming, one `<row>` element may hold at most 16 384 cells (`details.value` 16384), the most a row can have, because its cells are held until the element ends. `@xlvane/compat` `xlsx.load` also counts the cells of defined names against its budget, and its `xlsx.read`, `csv.read` and `stream.xlsx.WorkbookReader` stop collecting a stream after `maxInputBytes` (256 MiB; `details.limit` `maxInputBytes`).
+
+The MCP server (`@xlvane/mcp`) returns it as a tool error for a file larger than `--max-file-size` (`details.limit` `maxFileBytes`; `convert` to JSON stops building the text at that size), for a workbook with more cells than `--max-cells` (`details.limit` `maxCells`) and for a result longer than `--max-response-chars` (`details.limit` `maxResponseChars`; `read_table` instead returns the rows that fit). `xlvane convert` to JSON returns it when the text would be longer than a JavaScript string can be.
 
 `fromCSV` (and `xlvane convert`/`create` with CSV input) throws it for text with more fields than `maxCells` (default 5 000 000, `details.limit` `maxCells`), more than 16 384 fields on a line or more than 1 048 576 lines.
 

package/docs/exceljs-compat.md

@@ -38,7 +38,7 @@ Status: **supported** means the same behaviour as exceljs for the cases covered
 | `xlsx.write(stream)` | supported | | `lib/xlsx/xlsx.js` L643 |
 | `xlsx.createInputStream()` | supported | Throws the deprecation error, as in exceljs 4. | `lib/xlsx/xlsx.js` L238 |
 | `csv.read(stream, options)`, `csv.readFile(path, options)` | supported | Adds a worksheet, with exceljs's options (`sheetName`, `dateFormats`, `map`, `parserOptions`: `delimiter`, `quote`, `escape`, `trim`/`ltrim`/`rtrim`, `ignoreEmpty`, `comment`, `skipLines`, `skipRows`, `maxRows`, `headers`, `renameHeaders`, `encoding`) and its default conversion of fields (X4-23), on xlvane's own parser (no fast-csv). Accepts a Node.js readable stream, a Web `ReadableStream` or any (async) iterable of strings or bytes. Differences: text of white space only stays text (exceljs reads `' '` as 0), `-Infinity` stays text (it cannot be stored), a leading byte order mark is dropped (exceljs keeps it in the first field), `headers: true` skips the header line (exceljs throws `data.map is not a function`), a missing file or a malformed line throws `XLV_E_FILE_READ` / `XLV_E_CSV_MALFORMED`. `readFile` needs `node:fs` (Node.js, Bun, Deno). Dates are parsed as dayjs 1.11 customParseFormat parses them in strict mode (D-E06): letters that are no token, such as an unbracketed `T` or `dddd`, are skipped, and each token is searched in the rest of the text. An unclosed quote is reported on the line where it opens; a `quote` or `escape` longer than one character throws `XLV_E_INVALID_OPTION`. | `lib/csv/csv.js` L32–98 |
-| `csv.write(stream, options)`, `csv.writeFile(path, options)`, `csv.writeBuffer(options)` | supported | Writes one worksheet with exceljs's options (`sheetName`, `sheetId`, `dateFormat`, `dateUTC`, `map`, `includeEmptyRows`, `encoding`, `formatterOptions`: `delimiter`, `rowDelimiter`, `quote`, `escape`, `quoteColumns`, `headers`, `writeHeaders`, `includeEndRowDelimiter`, `writeBOM`) and fast-csv's quoting (X4-24); the cross-check sample gives the same text as exceljs 4.4.0. Differences: text that starts with `=`, `+`, `-`, `@`, tab, CR, LF or another control character, or with a full-width or small form of these signs, is written with a leading `'` (CSV injection, docs/facts/csv.md CSV-10, CSV-12; `formulaInjection: "off"` writes it unchanged, as exceljs); a formula result of 0 or `false` is written (exceljs writes an empty field), a date result is formatted as a date and an error result as its text; one blank line per missing row also before the first row (exceljs writes one too few there); a `sheetName` or `sheetId` that does not exist throws `XLV_E_SHEET_NOT_FOUND` (exceljs writes an empty file); header names in `formatterOptions.headers` are escaped like values. With `headers`, an array row gives one field per header (longer rows cut, shorter ones end in empty fields), as fast-csv writes it; `dateFormat: ''` uses the default format, as dayjs does (D-E06). `writeFile` writes `utf8`, `utf16le` or `latin1` and needs `node:fs`. | `lib/csv/csv.js` L109–186 |
+| `csv.write(stream, options)`, `csv.writeFile(path, options)`, `csv.writeBuffer(options)` | supported | Writes one worksheet with exceljs's options (`sheetName`, `sheetId`, `dateFormat`, `dateUTC`, `map`, `includeEmptyRows`, `encoding`, `formatterOptions`: `delimiter`, `rowDelimiter`, `quote`, `escape`, `quoteColumns`, `headers`, `writeHeaders`, `includeEndRowDelimiter`, `writeBOM`) and fast-csv's quoting (X4-24); the cross-check sample gives the same text as exceljs 4.4.0. Differences: text that starts with `=`, `+`, `-`, `@`, tab, CR, LF or another control character, or with a full-width or small form of these signs, is written with a leading `'` (CSV injection, docs/facts/csv.md CSV-10, CSV-12; `formulaInjection: "off"` writes it unchanged, as exceljs); a formula result of 0 or `false` is written (exceljs writes an empty field), a date result is formatted as a date and an error result as its text; one blank line per missing row also before the first row (exceljs writes one too few there); a `sheetName` or `sheetId` that does not exist throws `XLV_E_SHEET_NOT_FOUND` (exceljs writes an empty file); header names in `formatterOptions.headers` are escaped like values. With `headers`, an array row gives one field per header (longer rows cut, shorter ones end in empty fields), as fast-csv writes it; `dateFormat: ''` uses the default format, as dayjs does (D-E06). `writeFile` writes `utf8`, `utf16le` or `latin1` and needs `node:fs`; with `latin1` characters above U+00FF are written as `?` (Node.js, and so exceljs, keeps only their low byte, which can turn U+013D into `=`), and formatter options with such characters throw `XLV_E_INVALID_OPTION`. While formulas are escaped (the default), a `delimiter` holding a formula sign (`=`, `+`, `-`, `@`, their full-width or small forms) or a control character (a lone tab is allowed), a `rowDelimiter` other than `\n`, `\r\n` or `\r`, a `quote` other than `"` or `false`, an `escape` other than the quote, and with `quote: false` a field that starts with `"` throw `XLV_E_INVALID_OPTION`, because a standard CSV reader would otherwise get a field starting with a formula (docs/facts/csv.md CSV-13); `formulaInjection: "off"` writes them as exceljs does. | `lib/csv/csv.js` L109–186 |
 | `csv.createInputStream()` | supported | Throws the deprecation error, as in exceljs 4. | `lib/csv/csv.js` L101 |
 | `definedNames` (`add`, `addEx`, `remove`, `removeEx`, `removeAllNames`, `forEach`, `getNames`, `getNamesEx`, `getRanges`, `getMatrix`, `model`) | supported | As in exceljs, a name is a set of cells, written as rectangles with absolute references and no sheet scope; on reading, names that are not cell ranges (constants, formulas, `#REF!`) and the sheet scope (`localSheetId`) are dropped. Built-in `_xlnm.` names are not listed: print areas and titles are read into `pageSetup`, as in exceljs, and xlvane writes the autofilter name itself. Names exceljs accepts but Excel does not (for example `A1` or names starting with `_xl`) throw `XLV_E_INVALID_DEFINED_NAME` when the workbook is written. | `lib/doc/defined-names.js`; `lib/xlsx/xform/book/defined-name-xform.js`; `lib/xlsx/xform/book/workbook-xform.js` L187 |
 | `addImage(image)`, `getImage(id)` | supported | PNG, JPEG and GIF given as `buffer`, `base64` (a data URL is accepted, as in exceljs) or `filename`; the format is recognised from the bytes, `extension` is kept but not used (exceljs writes `image/jpg` for `extension: 'jpg'`). As in exceljs, a `filename` is read when the workbook is written (`xlsx.writeBuffer`/`writeFile`/`write` and the streaming `WorkbookWriter`), so a missing file fails there; outside Node.js, Bun and Deno it gives `XLV_E_NOT_SUPPORTED`. Other formats throw `XLV_E_INVALID_IMAGE`. Read back, each image part is one media entry `{ type, name, extension, buffer }`, `buffer` a `Uint8Array`. Identical images are stored once, with one relationship per drawing (exceljs writes one per use). | `lib/doc/workbook.js` L142–151; `lib/xlsx/xlsx.js` L421–442 (L426–429: `filename` read at write) |
@@ -179,7 +179,7 @@ A workbook loaded with `xlsx.load()` is written again by `xlsx.writeBuffer()` (`
 - `row.destroy()` and `cell.destroy()` do nothing; the row or cell stays usable (exceljs deletes its internals).
 - Errors found while writing name the worksheet and, for cell values and styles, the cell (`error.location`).
 - `worksheet.tables` and `dataValidations.model` have no prototype: keys such as `constructor` or `__proto__` are plain entries.
-- CSV writing: a field whose first character after any NUL characters is a formula character is escaped (NULs are removed when writing); with `formatterOptions.quote: false`, a field with CR, LF or the delimiter throws `XLV_E_INVALID_OPTION` (fast-csv writes it and the CSV then has other fields or rows). CSV reading: fields such as `constructor` or `__proto__` stay text.
+- CSV writing: a field whose first character after any NUL characters is a formula character is escaped (NULs are removed when writing); options that would get around the escape are refused (CSV-13); `latin1` output writes characters above U+00FF as `?`; `csv.read` stops collecting input after 256 MiB (`XLV_E_LIMIT_EXCEEDED`, `maxInputBytes`); with `formatterOptions.quote: false`, a field with CR, LF or the delimiter throws `XLV_E_INVALID_OPTION` (fast-csv writes it and the CSV then has other fields or rows). CSV reading: fields such as `constructor` or `__proto__` stay text.
 
 ## Known differences found by the cross-check