@xlvane/compat 1.2.3 → 1.3.1

package/dist/index.js

@@ -773,6 +773,67 @@ const BUILTIN_CODES = /* @__PURE__ */ new Map([
 	["##0.0E+0", 48],
 	["@", 49]
 ]);
+const DAY_MS = 864e5;
+/** exceljs's serial 0 in the 1900 date system (lib/utils/utils.js L55-61: 25569 days before 1970). */
+const EPOCH_1899_12_30 = Date.UTC(1899, 11, 30);
+/** Serial 0 of the core's Transitional 1900 system for 1900-01-01 to 1900-02-28 (D-112). */
+const EPOCH_1899_12_31 = Date.UTC(1899, 11, 31);
+const EPOCH_1904_01_01 = Date.UTC(1904, 0, 1);
+const TIME_1900_01_01 = Date.UTC(1900, 0, 1);
+const MIN_DATE_TIME = (/* @__PURE__ */ new Date(0)).setUTCFullYear(1, 0, 1);
+const MAX_DATE_TIME = Date.UTC(9999, 11, 31, 23, 59, 59, 999);
+/**
+* The serial exceljs writes for a Date from 1899-12-30 to the end of 1899 in the 1900 date system
+* (time-only values such as `new Date(Date.UTC(1899, 11, 30, 13, 20))`): `25569 + ms / 86400000`
+* (lib/utils/utils.js L55-57 `dateToExcel`). The core refuses these dates, so they are written
+* as numbers with the cell's date format. `undefined` for other values.
+*/
+function earlyDateSerial(v, date1904) {
+	if (date1904 || !(v instanceof Date)) return void 0;
+	const t = v.getTime();
+	return t >= EPOCH_1899_12_30 && t < TIME_1900_01_01 ? (t - EPOCH_1899_12_30) / DAY_MS : void 0;
+}
+/**
+* exceljs's test for a date format (lib/utils/utils.js L140-151 `isDateFmt`): after removing the
+* parts in brackets and in double quotes, the format has one of the letters y, m, d, h, M, s, b.
+* It also takes upper-case formats such as `DD.MM.YYYY`, which the core does not.
+*/
+function isExcelJsDateFormat(fmt) {
+	if (!fmt) return false;
+	return /[ymdhMsb]/.test(fmt.replace(/\[[^\]]*]/g, "").replace(/"[^"]*"/g, ""));
+}
+/**
+* A serial as a Date, as the core converts it (D-112), except that a serial below 1 in the
+* Transitional 1900 system counts from 1899-12-30 as in exceljs (F6). `null` where the core has no
+* Date either (serial 60, negative serials, outside 0001-9999).
+*/
+function serialToDate(serial, dates) {
+	if (!Number.isFinite(serial) || Math.abs(serial) > 3e6) return null;
+	const ms = Math.round(serial * DAY_MS);
+	let time;
+	if (dates.date1904) time = EPOCH_1904_01_01 + ms;
+	else if (dates.strict) time = EPOCH_1899_12_30 + ms;
+	else if (ms < 0) return null;
+	else if (ms < DAY_MS) time = EPOCH_1899_12_30 + ms;
+	else if (ms < 60 * DAY_MS) time = EPOCH_1899_12_31 + ms;
+	else if (ms < 61 * DAY_MS) return null;
+	else time = EPOCH_1899_12_30 + ms;
+	return time < MIN_DATE_TIME || time > MAX_DATE_TIME ? null : new Date(time);
+}
+/**
+* A plain value read by the core as exceljs gives it: a time-only Date of the Transitional 1900
+* system (which the core places on 1899-12-31, D-112) on 1899-12-30, as exceljs's `excelToDate`
+* (lib/utils/utils.js L58-61) does (F6); and, when `dateFormat` is set, a number whose format
+* exceljs takes for a date (`isExcelJsDateFormat`) as a Date (F7).
+*/
+function readValueOut(value, numFmt, dates, dateFormat = true) {
+	if (value instanceof Date) {
+		const t = value.getTime();
+		return !dates.date1904 && !dates.strict && t < TIME_1900_01_01 ? /* @__PURE__ */ new Date(t - DAY_MS) : value;
+	}
+	if (dateFormat && typeof value === "number" && isExcelJsDateFormat(numFmt)) return serialToDate(value, dates) ?? value;
+	return value;
+}
 function colorIn(c, where) {
 	if (c === void 0 || c === null) return void 0;
 	if (typeof c.argb === "string") return c.argb;
@@ -973,14 +1034,16 @@ function isRecord$1(v) {
 	return typeof v === "object" && v !== null && !(v instanceof Date) && !Array.isArray(v);
 }
 /** The `result` part of a formula value for the writer. */
-function resultIn(r) {
+function resultIn(r, date1904 = false) {
 	if (r === void 0 || r === null) return {};
+	const serial = earlyDateSerial(r, date1904);
+	if (serial !== void 0) return { result: serial };
 	if (isRecord$1(r) && typeof r["error"] === "string") return { result: { error: r["error"] } };
 	return { result: r };
 }
 /** The cached result of a formula as a plain value (`null` without one). */
-function resultValue(r) {
-	return resultIn(r).result ?? null;
+function resultValue(r, date1904) {
+	return resultIn(r, date1904).result ?? null;
 }
 /**
 * The range of each shared formula of a worksheet, by master address, as exceljs computes it on
@@ -1095,9 +1158,11 @@ function overlapCounts(queries, set) {
 	return counts;
 }
 /** Converts a cell value for the writer; a `{ text, hyperlink }` value gives its text (the link is {@link linkIn}). */
-function valueIn(cell, sharedRanges) {
+function valueIn(cell, sharedRanges, date1904 = false) {
 	const v = cell.value;
 	if (v === null || v === void 0) return null;
+	const serial = earlyDateSerial(v, date1904);
+	if (serial !== void 0) return serial;
 	if (typeof v === "string" || typeof v === "number" || typeof v === "boolean" || v instanceof Date) return v;
 	if (isRecord$1(v)) {
 		if (cell.type === ValueType.Hyperlink) {
@@ -1109,19 +1174,19 @@ function valueIn(cell, sharedRanges) {
 			const master = v["sharedFormula"].replace(/\$/g, "").toUpperCase();
 			if (sharedRanges === void 0 || sharedRanges.has(master)) return {
 				sharedFormula: master,
-				...resultIn(v["result"])
+				...resultIn(v["result"], date1904)
 			};
 			const text = cell.formula;
 			if (text !== void 0) return {
 				formula: text,
-				...resultIn(v["result"])
+				...resultIn(v["result"], date1904)
 			};
-			return resultValue(v["result"]);
+			return resultValue(v["result"], date1904);
 		}
 		if (typeof v["formula"] === "string") {
 			const base = {
 				formula: v["formula"],
-				...resultIn(v["result"])
+				...resultIn(v["result"], date1904)
 			};
 			if (v["shareType"] === "array" && typeof v["ref"] === "string") return {
 				...base,
@@ -1379,7 +1444,8 @@ function sameBytes(a, b) {
 function toNewWorkbook(sheets, date1904, meta = {}) {
 	const book = createWorkbook({
 		...date1904 ? { dateSystem: "1904" } : {},
-		...meta.properties ? { properties: meta.properties } : {}
+		...meta.properties ? { properties: meta.properties } : {},
+		...meta.defaultFont ? { defaultFont: meta.defaultFont } : {}
 	});
 	if (sheets.length === 0) notSupported("Writing a workbook without worksheets");
 	const coreImages = /* @__PURE__ */ new Map();
@@ -1426,31 +1492,76 @@ function toNewWorkbook(sheets, date1904, meta = {}) {
 			if (options) sheet.column(column.number, options);
 		});
 		const styleCache = /* @__PURE__ */ new Map();
+		const partsCache = /* @__PURE__ */ new Map();
+		const byParts = (s) => {
+			const parts = [
+				s.numFmt,
+				s.font,
+				s.fill,
+				s.border,
+				s.alignment,
+				s.protection
+			];
+			let level = partsCache;
+			for (let i = 0; i < parts.length - 1; i++) {
+				let next = level.get(parts[i]);
+				if (!next) level.set(parts[i], next = /* @__PURE__ */ new Map());
+				level = next;
+			}
+			let c = level.get(parts[parts.length - 1]);
+			if (!c) level.set(parts[parts.length - 1], c = styleIn(s));
+			return c;
+		};
 		const styleOf = (s) => {
 			let c = styleCache.get(s);
 			if (!c) {
-				c = styleIn(s);
+				c = byParts(s);
 				styleCache.set(s, c);
 			}
 			return c;
 		};
+		const styleFor = (cell) => {
+			if (!useStyles) return isDateCell(cell) ? { numFmt: 14 } : {};
+			const master = cell._master;
+			const style = master !== null && cell.style !== master.style && sameStyle(cell.style, master.style) ? master.style : cell.style;
+			return cellStyleIn(cell, styleOf(style));
+		};
+		const blocks = mergeBlocks(ws);
 		ws._rows.forEach((row) => {
 			if (!row) return;
-			if (row.height !== void 0 || row.hidden || row.outlineLevel) sheet.row(row.number, {
+			const style = rowStyleIn(row, useStyles, styleOf);
+			if (row.height !== void 0 || row.hidden || row.outlineLevel || style) sheet.row(row.number, {
+				...style ? { style } : {},
 				...row.height === void 0 ? {} : { height: row.height },
 				...row.hidden ? { hidden: true } : {},
 				...row.outlineLevel ? { outlineLevel: row.outlineLevel } : {},
 				...row.collapsed ? { collapsed: true } : {}
 			});
 			row._cells.forEach((cell) => {
-				if (cell) at(ws.name, cell.address, () => writeCell(cell));
+				if (!cell) return;
+				if (cell._master !== null && blocks.covers(cell)) {
+					if (cell.note !== void 0) at(ws.name, cell.address, () => {
+						const note = noteIn(cell);
+						if (note) sheet.note(cell.address, note);
+					});
+				} else at(ws.name, cell.address, () => writeCell(cell));
 			});
 		});
+		for (const m of blocks.blocks) {
+			const style = at(ws.name, m.cell.address, () => styleFor(m.cell));
+			if (Object.keys(style).length === 0) continue;
+			const width = m.right - m.left + 1;
+			const step = Math.max(1, Math.floor(MERGE_STYLE_BLOCK / width));
+			for (let top = m.top; top <= m.bottom; top += step) {
+				const bottom = Math.min(m.bottom, top + step - 1);
+				sheet.style(`${columnLetter(m.left)}${String(top)}:${columnLetter(m.right)}${String(bottom)}`, style);
+			}
+		}
 		function writeCell(cell) {
 			const note = noteIn(cell);
 			if (note) sheet.note(cell.address, note);
-			const style = useStyles ? cellStyleIn(cell, styleOf(cell.style)) : isDateCell(cell) ? { numFmt: 14 } : {};
-			const value = cell.type === ValueType.Merge ? null : valueIn(cell, sharedRanges);
+			const style = styleFor(cell);
+			const value = cell.type === ValueType.Merge ? null : valueIn(cell, sharedRanges, date1904);
 			if (value === null && Object.keys(style).length === 0) return;
 			sheet.set(cell.address, value, style);
 			const link = cell.type === ValueType.Merge ? null : linkIn(cell);
@@ -1486,6 +1597,127 @@ function toNewWorkbook(sheets, date1904, meta = {}) {
 	return book;
 }
 /**
+* The part of a file's default font (font 0) that the writer accepts as `defaultFont`: parts it
+* refuses (a name of more than 31 characters or an empty one, a size outside 1 to 409.55 points)
+* are left out, so that a loaded workbook can always be written again, as with 1.3.0 and exceljs,
+* which writes its own Calibri 11 as font 0. `null` when nothing of it is accepted.
+*/
+function writableDefaultFont(font) {
+	if (!font) return null;
+	const out = { ...font };
+	for (let tries = Object.keys(out).length; tries >= 0; tries--) {
+		if (Object.keys(out).length === 0) return null;
+		try {
+			createWorkbook({ defaultFont: out });
+			return out;
+		} catch (error) {
+			const property = error instanceof XlvError ? error.details["property"] : void 0;
+			const key = typeof property === "string" && property.startsWith("font.") ? property.slice(5).split(".")[0] : void 0;
+			if (error instanceof XlvError && error.code === "XLV_E_INVALID_STYLE" && key !== void 0 && key in out) delete out[key];
+			else return null;
+		}
+	}
+	return null;
+}
+/**
+* The row style to write for a row (F3), as exceljs writes it: row@s with customFormat="1"
+* (row-xform.js L19-23, L44-47), with styles only, and only for a row that exceljs writes at all,
+* one with a height or cells (lib/doc/row.js L333-364). `undefined` when there is none.
+*/
+function rowStyleIn(row, useStyles, convert = styleIn) {
+	if (!useStyles || row.height === void 0 && !row._cells.some((c) => c !== void 0)) return void 0;
+	const style = convert(row.style);
+	return Object.keys(style).length > 0 ? style : void 0;
+}
+/** Cells styled by one `sheet.style` call for a merged range: at most what the core styles at once. */
+const MERGE_STYLE_BLOCK = 1048576;
+/**
+* Whether two exceljs styles are equal: the same object (as `mergeCells` shares the master's),
+* parts that are the same objects (a column style given to new cells), or equal plain data (styles
+* read from a file). Parts that are `undefined` count as missing.
+*/
+function sameStyle(a, b) {
+	if (a === b) return true;
+	const x = a;
+	const y = b;
+	for (const k in x) if (!samePlain(x[k], y[k], 0)) return false;
+	for (const k in y) if (x[k] === void 0 && y[k] !== void 0) return false;
+	return true;
+}
+/** Whether two styles read by the core are the same data (F3, F4: a row or column style against xf 0). */
+function sameStyleData(a, b) {
+	return samePlain(a, b, 0);
+}
+/** Deep equality of plain style data (objects, arrays and primitives), to a bounded depth. */
+function samePlain(a, b, depth) {
+	if (a === b) return true;
+	if (depth > 8 || a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+	if (Array.isArray(a) !== Array.isArray(b) || a instanceof Date || b instanceof Date) return false;
+	const x = a;
+	const y = b;
+	const keys = Object.keys(x);
+	if (keys.length !== Object.keys(y).length) return false;
+	for (const k of keys) if (!Object.prototype.hasOwnProperty.call(y, k) || !samePlain(x[k], y[k], depth + 1)) return false;
+	return true;
+}
+/**
+* The other cells of the merged ranges, styled in blocks instead of one by one (K2, F2): in each
+* column of a range, runs of rows whose cells exist, belong to the range's master and have equal
+* styles (the object `mergeCells` shares with them, as in exceljs, a column's or row's style
+* parts, or equal data read from a file), joined across columns while the runs are the same
+* (review of 1.3.1: cells of a styled column or row that differ from the master were written one
+* by one). The master itself is written as a cell. `covers` tells whether a cell is styled by a
+* block; only its note is then written on its own (K3).
+*/
+function mergeBlocks(ws) {
+	const blocks = [];
+	const masters = /* @__PURE__ */ new Set();
+	for (const m of ws._merges.values()) {
+		const master = ws.findCell(m.top, m.left);
+		if (!master) continue;
+		masters.add(master);
+		let open = [];
+		const close = (right) => {
+			for (const o of open) blocks.push({
+				cell: o.run.cell,
+				top: o.run.top,
+				bottom: o.run.bottom,
+				left: o.left,
+				right
+			});
+		};
+		for (let c = m.left; c <= m.right; c++) {
+			const runs = [];
+			let run = null;
+			for (let r = m.top; r <= m.bottom; r++) {
+				const cell = r === m.top && c === m.left ? void 0 : ws.findRow(r)?.findCell(c);
+				if (!cell || cell._master !== master) {
+					run = null;
+					continue;
+				}
+				if (run && sameStyle(cell.style, run.cell.style)) run.bottom = r;
+				else runs.push(run = {
+					top: r,
+					bottom: r,
+					cell
+				});
+			}
+			if (!(open.length === runs.length && runs.every((x, i) => x.top === open[i].run.top && x.bottom === open[i].run.bottom && sameStyle(x.cell.style, open[i].run.cell.style)))) {
+				close(c - 1);
+				open = runs.map((x) => ({
+					run: x,
+					left: c
+				}));
+			}
+		}
+		close(m.right);
+	}
+	return {
+		blocks,
+		covers: (cell) => cell._master !== null && masters.has(cell._master)
+	};
+}
+/**
 * The validations, conditional formats, protection and printing settings of a worksheet in the
 * form of the core API (D-C06). exceljs always writes page margins and page setup
 * (worksheet-xform.js L337–339), so `pageSetup` is always given.
@@ -1598,6 +1830,18 @@ function viewOut(view, freeze) {
 	};
 }
 /**
+* Whether a formula read by xlvane has text, without making the core build it: the core moves a
+* shared master's text to a dependent only when the dependent's `text` is read (a getter), and
+* gives `null` (a plain value) when it cannot move it. Reading the text of every dependent made a
+* small file with a huge master and many dependents exhaust memory (K2), and exceljs reads a
+* dependent as `{ sharedFormula }` without its text anyway.
+*/
+function hasFormulaText(f) {
+	const d = Object.getOwnPropertyDescriptor(f, "text");
+	if (d !== void 0 && d.get !== void 0) return true;
+	return f.text !== null;
+}
+/**
 * A formula read by xlvane in exceljs's shape (cell-xform.js L460–470; X4-29): a shared-formula
 * master `{ formula, result, ref, shareType: 'shared' }`, a dependent `{ sharedFormula: master,
 * result }` (its `cell.formula` is translated), an array formula `{ formula, result, ref,
@@ -2858,6 +3102,56 @@ function notSupported(feature) {
 		details: { feature }
 	});
 }
+/**
+* The shared-formula text moved per workbook (K4 S1, D-K04). A move costs time in proportion to the
+* master's length, and the load-time budget is spent once, so a 4 KB file whose 1 000 000-character
+* master is shared with 250 cells took about 47 s to read every dependent's formula once. Two
+* budgets, counting the master's text read plus the moved text built for each `cell.formula` that
+* is not kept yet:
+* - every move: 512 Mi characters, the default `maxSharedStringChars` with which xlvane's
+*   `readWorkbook` expands shared formulas, so a workbook the core reads is read here too;
+* - moves of masters longer than 8192 characters, the longest formula Office writes ([MS-OI29500]
+*   §2.1.1085 a): 32 Mi characters, so such a master stops after a few moves.
+*/
+const SHARED_FORMULA_TEXT = 536870912;
+const LONG_SHARED_FORMULA_TEXT = 33554432;
+const LONG_FORMULA = 8192;
+/** Characters moved in all and for long masters, per workbook (a `Worksheet.workbook`). */
+const sharedFormulaSpent = /* @__PURE__ */ new WeakMap();
+/**
+* @internal Moves the text of a shared-formula master at `master` to `row`/`col` of `sheet` with
+* `shiftFormula`, counted against the workbook's shared-formula budgets; `undefined` when the
+* formula cannot be moved. Throws `XLV_E_LIMIT_EXCEEDED` before a move that would pass one.
+*/
+function moveSharedFormula(workbook, sheet, text, master, row, col) {
+	let spent = sharedFormulaSpent.get(workbook);
+	if (spent === void 0) sharedFormulaSpent.set(workbook, spent = {
+		chars: 0,
+		long: 0
+	});
+	const cost = 2 * text.length;
+	const long = text.length > LONG_FORMULA;
+	const limit = long && spent.long + cost > LONG_SHARED_FORMULA_TEXT ? LONG_SHARED_FORMULA_TEXT : spent.chars + cost > SHARED_FORMULA_TEXT ? SHARED_FORMULA_TEXT : null;
+	if (limit !== null) {
+		const cell = `${columnLetter(col)}${String(row)}`;
+		throw new XlvError("XLV_E_LIMIT_EXCEEDED", `Moving the shared formula of ${columnLetter(master.col)}${String(master.row)} (${String(text.length)} characters) to ${cell} of worksheet "${sheet}" would bring the shared-formula text moved in this workbook past ${String(limit)} characters.`, {
+			location: {
+				sheet,
+				cell
+			},
+			hint: "The workbook shares very long formulas with many cells. Read the dependents' cached result (cell.result) instead of cell.formula, or read the file with xlvane's readWorkbook, whose shared-formula text is limited by limits.maxSharedStringChars.",
+			details: {
+				limit: "sharedFormulaText",
+				value: limit
+			}
+		});
+	}
+	const moved = shiftFormula(text, row - master.row, col - master.col);
+	const used = text.length + (moved?.length ?? 0);
+	spent.chars += used;
+	if (long) spent.long += used;
+	return moved ?? void 0;
+}
 /** Column letters for a 1-based number (A … XFD). */
 function columnLetter(n) {
 	let s = "";
@@ -2902,7 +3196,7 @@ function typeOf(value) {
 	if (value instanceof Date) return ValueType.Date;
 	if (isRecord(value)) {
 		if (value["text"] && value["hyperlink"]) return ValueType.Hyperlink;
-		if (value["formula"] || value["sharedFormula"]) return ValueType.Formula;
+		if (value["sharedFormula"] || value["formula"]) return ValueType.Formula;
 		if (value["richText"]) return ValueType.RichText;
 		if (value["sharedString"]) return ValueType.SharedString;
 		if (value["error"]) return ValueType.Error;
@@ -2951,14 +3245,19 @@ var Cell = class {
 	_master = null;
 	/** @internal Number of merged ranges this cell is the master of. */
 	_mergeCount = 0;
+	/** The moved formula of a `{ sharedFormula }` value, and what it was moved from (see `formula`). */
+	_moved = void 0;
 	/** @internal Use `worksheet.getCell()`. */
 	constructor(_row, _col) {
 		this._row = _row;
 		this._col = _col;
-		const column = _row.worksheet.findColumn(_col);
-		this.style = {
-			...column?.style,
-			...withoutEmpty(_row.style)
+		this.style = this._rowColumnStyle();
+	}
+	/** The style a new cell takes: row style wins over column style, part by part (lib/doc/cell.js L99-119 `_mergeStyle`). */
+	_rowColumnStyle() {
+		return {
+			...this._row.worksheet.findColumn(this._col)?.style,
+			...withoutEmpty(this._row.style)
 		};
 	}
 	get worksheet() {
@@ -3036,20 +3335,52 @@ var Cell = class {
 		const v = this.value;
 		if (!isRecord(v)) return void 0;
 		if (typeof v["formula"] === "string") return v["formula"];
-		if (typeof v["sharedFormula"] === "string") {
-			const masterRef = v["sharedFormula"].replace(/\$/g, "");
+		const shared = v["sharedFormula"];
+		if (typeof shared === "string") {
+			const masterRef = shared.replace(/\$/g, "");
 			const master = this.worksheet.findCell(masterRef);
-			const text = master?.formula;
-			if (!master || text === void 0 || master === this) return void 0;
-			return shiftFormula(text, this.row - master.row, this.col - master.col) ?? void 0;
+			let text;
+			let at;
+			if (!master) {
+				text = this.worksheet._sharedMasters?.get(masterRef.toUpperCase());
+				if (text === void 0) return void 0;
+				at = decodeAddress(masterRef);
+			} else {
+				if (master === this) return void 0;
+				text = master.formula;
+				if (text === void 0) return void 0;
+				at = {
+					row: master.row,
+					col: master.col
+				};
+			}
+			const kept = this._moved;
+			if (kept !== void 0 && kept.value === v && kept.shared === shared && kept.master === text && kept.masterRow === at.row && kept.masterCol === at.col && kept.row === this.row && kept.col === this.col) return kept.text;
+			const moved = moveSharedFormula(this.worksheet.workbook, this.worksheet.name, text, at, this.row, this.col);
+			this._moved = {
+				value: v,
+				shared,
+				master: text,
+				masterRow: at.row,
+				masterCol: at.col,
+				row: this.row,
+				col: this.col,
+				text: moved
+			};
+			return moved;
 		}
 	}
-	/** `FormulaType.Shared` for a `{ sharedFormula }` value, `Master` for other formulas, otherwise `None` (lib/doc/cell.js L807). */
+	/**
+	* `FormulaType.Shared` for a `{ sharedFormula }` value, `Master` for other formulas, and
+	* `undefined` for a cell without a formula and for a merged cell other than the top-left one,
+	* as in exceljs, where only the formula value has a `formulaType` (lib/doc/cell.js L264-266,
+	* L807-815; exceljs's declaration says `FormulaType` all the same).
+	*/
 	get formulaType() {
-		const v = this.value;
-		if (!isRecord(v)) return FormulaType.None;
+		const v = this._master ? null : this.value;
+		if (!isRecord(v)) return void 0;
 		if (typeof v["sharedFormula"] === "string") return FormulaType.Shared;
-		return typeof v["formula"] === "string" ? FormulaType.Master : FormulaType.None;
+		return typeof v["formula"] === "string" ? FormulaType.Master : void 0;
 	}
 	get result() {
 		const v = this.value;
@@ -3224,6 +3555,15 @@ var Cell = class {
 	_unmerge() {
 		this._master = null;
 	}
+	/**
+	* @internal As exceljs `cell.unmerge()` (lib/doc/cell.js L177-183): a cell merged into another
+	* one gets the row and column style again, instead of the master's.
+	*/
+	_unmergeResetStyle() {
+		if (this._master === null) return;
+		this._master = null;
+		this.style = this._rowColumnStyle();
+	}
 };
 function withoutEmpty(style) {
 	const out = {};
@@ -3601,11 +3941,11 @@ var Column = class {
 		this._hidden = !!value.hidden;
 		this._outlineLevel = value.outlineLevel ?? 0;
 	}
-	/** Cell values of this column by row number (index 0 unused). */
+	/** Cell values of this column by row number (index 0 unused); empty cells are left out (lib/doc/column.js L179-187). */
 	get values() {
 		const out = [];
 		this.eachCell((cell, r) => {
-			out[r] = cell.value;
+			if (cell.type !== ValueType.Null) out[r] = cell.value;
 		});
 		return out;
 	}
@@ -3620,8 +3960,7 @@ var Column = class {
 		const includeEmpty = typeof options === "object" && options !== null && options.includeEmpty === true;
 		if (!cb) return;
 		this.worksheet.eachRow({ includeEmpty }, (row, r) => {
-			const cell = includeEmpty ? row.getCell(this.number) : row.findCell(this.number);
-			if (cell && (includeEmpty || cell.type !== ValueType.Null)) cb(cell, r);
+			cb(row.getCell(this.number), r);
 		});
 	}
 	applyStyle(name, value) {
@@ -3782,6 +4121,11 @@ var Worksheet = class {
 	_columns = [];
 	/** @internal */
 	_merges = new MergeMap();
+	/**
+	* @internal Formulas of shared-formula masters by address, for the dependents of a worksheet
+	* whose rows are not kept (stream.xlsx.WorkbookReader), so `cell.formula` can move them (K2).
+	*/
+	_sharedMasters = void 0;
 	/** The cells covered by `_merges` (row × 16 385 + column), valid while `_mergedVersion` equals `_merges.version`. */
 	_mergedCells = /* @__PURE__ */ new Set();
 	_mergedVersion = -1;
@@ -4179,8 +4523,9 @@ var Worksheet = class {
 	}
 	/**
 	* @internal Merges a range without the overlap check of `mergeCells`. Cells keep their own
-	* style, except those for which `takeMasterStyle` returns true (cells inserted inside the range),
-	* which get a copy of the master's style; style objects are never shared.
+	* style object (the master's, when `mergeCells` shared it with them), except those for which
+	* `takeMasterStyle` returns true (cells inserted inside the range), which get a copy of the
+	* master's style.
 	*/
 	_mergeRange(range, takeMasterStyle = () => false) {
 		const master = this.getCell(range.top, range.left);
@@ -4492,7 +4837,7 @@ var Worksheet = class {
 			if (r === range.top && c === range.left) continue;
 			const cell = this.getCell(r, c);
 			cell._merge(master);
-			if (!this._mergeKeepStyle) cell.style = { ...master.style };
+			if (!this._mergeKeepStyle) cell.style = master.style;
 		}
 		master._mergeCount++;
 		this._merges.set(`${columnLetter(range.left)}${String(range.top)}`, range);
@@ -4511,7 +4856,7 @@ var Worksheet = class {
 	unMergeCells(...args) {
 		const range = parseRangeArgs(args);
 		for (const [key, m] of this._merges) if (range.top <= m.bottom && m.top <= range.bottom && range.left <= m.right && m.left <= range.right) {
-			for (let r = m.top; r <= m.bottom; r++) for (let c = m.left; c <= m.right; c++) this.findCell(r, c)?._unmerge();
+			for (let r = m.top; r <= m.bottom; r++) for (let c = m.left; c <= m.right; c++) this.findCell(r, c)?._unmergeResetStyle();
 			const master = this.findCell(m.top, m.left);
 			if (master) master._mergeCount = Math.max(0, master._mergeCount - 1);
 			this._merges.delete(key);
@@ -4698,8 +5043,12 @@ const INJECTION_START = /* @__PURE__ */ new Set([
 	"﹦",
 	"﹢",
 	"﹣",
-	"﹫"
+	"﹫",
+	"",
+	"￾"
 ]);
+/** Characters a field is quoted for while formulas are escaped, whatever the delimiter: other applications may split on them (K2). */
+const COMMON_DELIMITERS = ",;	|";
 function invalid(name, message, hint) {
 	return new XlvError("XLV_E_INVALID_OPTION", message, {
 		hint,
@@ -4985,9 +5334,41 @@ function malformed(line, message) {
 		details: { line }
 	});
 }
-/** Splits CSV text into rows of fields as fast-csv 4.3 does with the given parser options. */
-function parseCsv(text, o) {
-	const rows = [];
+/** Rows and columns of a worksheet (Part 1 §18.3.1.73, ST_CellRef up to XFD1048576). */
+const MAX_SHEET_ROWS = 1048576;
+const MAX_SHEET_COLUMNS = 16384;
+/** Fields added to the worksheet in total, as the core's `maxCells` read limit (K3). */
+const MAX_CSV_CELLS = DEFAULT_READ_LIMITS.maxCells;
+function tooMany(what, line) {
+	if (what === "cells") return new XlvError("XLV_E_LIMIT_EXCEEDED", `CSV line ${String(line)}: the CSV has more than ${String(MAX_CSV_CELLS)} fields in the rows read, the most csv.read adds to a worksheet.`, {
+		location: { line },
+		hint: "Split the CSV file into smaller parts, read only part of it with parserOptions.maxRows or skipRows, or read it with the core fromCSV, whose maxCells option can be raised for a trusted file.",
+		details: {
+			limit: "maxCells",
+			value: MAX_CSV_CELLS,
+			line
+		}
+	});
+	const rows = what === "rows";
+	const max = rows ? MAX_SHEET_ROWS : MAX_SHEET_COLUMNS;
+	return new XlvError("XLV_E_LIMIT_EXCEEDED", `CSV line ${String(line)}: ${rows ? `the CSV has more than ${String(max)} rows` : `the row has more than ${String(max)} fields`}, more than a worksheet can hold.`, {
+		location: { line },
+		hint: rows ? "Split the CSV file into parts of at most 1048576 rows, or read only part of it with parserOptions.maxRows." : "Split the CSV file into parts of at most 16384 columns, or check the delimiter (parserOptions.delimiter).",
+		details: {
+			limit: rows ? "maxRows" : "maxColumns",
+			value: max,
+			line
+		}
+	});
+}
+/**
+* The rows of CSV text, split as fast-csv 4.3 does with the given parser options, one at a time:
+* the rows that `ignoreEmpty`, the header, `skipRows` and `maxRows` drop are left out. More than
+* 1 048 576 rows, or a row of more than 16 384 fields, throw `XLV_E_LIMIT_EXCEEDED` as soon as
+* they are reached, because a worksheet cannot hold them (K2); so do more than 5 000 000 fields
+* in the rows given (`DEFAULT_READ_LIMITS.maxCells`, K3).
+*/
+function* csvRows(text, o) {
 	let at = 0;
 	let line = 1;
 	const n = text.length;
@@ -4996,6 +5377,10 @@ function parseCsv(text, o) {
 		if (text[i] === "\r" && text[i + 1] === "\n") return i + 2;
 		return i < n ? i + 1 : i;
 	};
+	const trim = (f) => o.trim ? f.trim() : o.ltrim ? f.trimStart() : o.rtrim ? f.trimEnd() : f;
+	let kept = 0;
+	let emitted = 0;
+	let cells = 0;
 	for (let k = 0; k < o.skipLines && at < n; k++) {
 		while (!atLineEnd(at)) at++;
 		at = skipLineEnd(at);
@@ -5008,38 +5393,52 @@ function parseCsv(text, o) {
 			line++;
 			continue;
 		}
+		const rowLine = line;
 		const fields = [];
+		let quoted = false;
+		let extra = 0;
+		let extraText = false;
+		const push = (field) => {
+			if (fields.length < MAX_SHEET_COLUMNS) fields.push(field);
+			else {
+				extra++;
+				if (field.trim() !== "") extraText = true;
+			}
+		};
 		for (;;) {
 			let start = at;
 			while (start < n && (text[start] === " " || text[start] === "	") && text[start] !== o.delimiter) start++;
 			if (o.quote !== "" && text[start] === o.quote) {
+				quoted = true;
 				let value = "";
 				let i = start + 1;
+				let from = i;
 				const opened = line;
 				for (;;) {
 					if (i >= n) throw malformed(opened, `missing closing ${o.quote} for the field that starts here.`);
 					const ch = text[i];
 					if (ch === o.escape && text[i + 1] === o.quote) {
-						value += o.quote;
+						value += text.slice(from, i) + o.quote;
 						i += 2;
+						from = i;
 						continue;
 					}
 					if (ch === o.quote) {
+						value += text.slice(from, i);
 						i++;
 						break;
 					}
 					if (ch === "\n") line++;
-					value += ch;
 					i++;
 				}
 				while (i < n && (text[i] === " " || text[i] === "	") && text[i] !== o.delimiter) i++;
 				if (i < n && text[i] !== o.delimiter && text[i] !== "\n" && text[i] !== "\r") throw malformed(line, `unexpected text after the closing ${o.quote}.`);
-				fields.push(value);
+				push(value);
 				at = i;
 			} else {
 				let i = at;
 				while (i < n && text[i] !== o.delimiter && text[i] !== "\n" && text[i] !== "\r") i++;
-				fields.push(text.slice(at, i));
+				push(text.slice(at, i));
 				at = i;
 			}
 			if (at < n && text[at] === o.delimiter) {
@@ -5050,15 +5449,31 @@ function parseCsv(text, o) {
 		}
 		at = skipLineEnd(at);
 		line++;
-		const row = fields.length === 1 && fields[0].trim() === "" ? [""] : fields;
-		rows.push(row.map((f) => o.trim ? f.trim() : o.ltrim ? f.trimStart() : o.rtrim ? f.trimEnd() : f));
-	}
-	let out = rows;
-	if (o.ignoreEmpty) out = out.filter((r) => r.some((f) => f.trim() !== ""));
-	if (o.skipHeader) out = out.slice(1);
-	if (o.skipRows > 0) out = out.slice(o.skipRows);
-	if (o.maxRows > 0) out = out.slice(0, o.maxRows);
-	return out;
+		const row = fields.length === 1 && !quoted && fields[0].trim() === "" ? [] : fields;
+		if (o.ignoreEmpty && !extraText && row.every((f) => f.trim() === "")) continue;
+		kept++;
+		if (o.skipHeader && kept === 1) continue;
+		if (kept - (o.skipHeader ? 1 : 0) <= o.skipRows) continue;
+		if (o.maxRows > 0 && emitted >= o.maxRows) continue;
+		if (extra > 0) throw tooMany("columns", rowLine);
+		if (++emitted > MAX_SHEET_ROWS) throw tooMany("rows", rowLine);
+		cells += row.length;
+		if (cells > MAX_CSV_CELLS) throw tooMany("cells", rowLine);
+		yield {
+			fields: row.map(trim),
+			line: rowLine
+		};
+	}
+}
+/** The delimiters and line-break characters in `text`: at least the number of fields less one. */
+function fieldEnds(text, delimiter) {
+	const d = delimiter.charCodeAt(0);
+	let n = 0;
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c === d || c === 10 || c === 13) n++;
+	}
+	return n;
 }
 /**
 * exceljs's default conversion of a CSV field (lib/csv/csv.js L57–83), with two fixes: text of
@@ -5078,7 +5493,7 @@ function csvValue(datum, dateFormats) {
 	if (special !== void 0) return typeof special === "object" ? { ...special } : special;
 	return datum;
 }
-function formatterOptions(raw) {
+function formatterOptions(raw, escapeFormulas) {
 	const o = raw ?? {};
 	const delimiter = typeof o["delimiter"] === "string" ? o["delimiter"] : ",";
 	const rowDelimiter = typeof o["rowDelimiter"] === "string" ? o["rowDelimiter"] : "\n";
@@ -5086,20 +5501,49 @@ function formatterOptions(raw) {
 	const quote = q === false ? "" : q === true || q === void 0 ? "\"" : String(q);
 	const escape = typeof o["escape"] === "string" ? o["escape"] : quote;
 	const escapeRe = (s) => s.replace(/[\\^$.*+?()[\]{}|-]/g, "\\$&");
+	const transform = o["transform"];
+	if (transform && typeof transform !== "function") throw invalid("formatterOptions.transform", "The option \"transform\" must be a function.", "Pass a function that takes a row and returns the row to write.");
+	if (o["BOM"] !== void 0 && o["BOM"] !== "") throw new XlvError("XLV_E_NOT_SUPPORTED", "formatterOptions.BOM other than \"\\uFEFF\" is not supported.", {
+		hint: "Leave BOM out; writeBOM: true writes the byte order mark U+FEFF.",
+		details: { option: "BOM" }
+	});
+	const quoteColumns = o["quoteColumns"] ?? false;
 	return {
 		delimiter,
 		rowDelimiter,
 		quote,
 		escapedQuote: `${escape}${quote}`,
-		quoteColumns: o["quoteColumns"] ?? false,
-		headers: Array.isArray(o["headers"]) && o["writeHeaders"] !== false ? o["headers"].map(String) : null,
+		quoteColumns,
+		quoteHeaders: o["quoteHeaders"] === void 0 ? quoteColumns : o["quoteHeaders"],
+		headers: Array.isArray(o["headers"]) ? o["headers"].map(String) : null,
+		shouldWriteHeaders: !!o["headers"] && !!(o["writeHeaders"] ?? true),
+		alwaysWriteHeaders: o["alwaysWriteHeaders"] === true,
+		transform: typeof transform === "function" ? transform : void 0,
 		includeEndRowDelimiter: o["includeEndRowDelimiter"] === true,
 		writeBOM: o["writeBOM"] === true,
-		escapeChars: new RegExp(`[${escapeRe(delimiter)}${escapeRe(rowDelimiter)}|\\r|\\n]`)
+		escapeChars: new RegExp(`[${escapeRe(delimiter)}${escapeRe(rowDelimiter)}|\\r|\\n${escapeFormulas ? escapeRe(COMMON_DELIMITERS) : ""}]`),
+		strictQuoting: escapeFormulas
 	};
 }
-/** One field as fast-csv FieldFormatter.format writes it. */
-function formatField(value, index, f, forceQuote) {
+/**
+* Whether an application that splits `text` at a comma, ";", tab or "|" would get a field that
+* starts like a formula: one of those characters followed by a formula sign, a control character
+* or a byte order mark, after any spaces or tabs and an opening double quote (K2).
+*/
+function splitStartsFormula(text) {
+	for (let i = 0; i < text.length; i++) {
+		if (!COMMON_DELIMITERS.includes(text[i])) continue;
+		let j = i + 1;
+		while (text[j] === " " || text[j] === "	") j++;
+		if (text[j] === "\"") j++;
+		while (text[j] === " ") j++;
+		const c = text[j];
+		if (c !== void 0 && (INJECTION_START.has(c) || c.charCodeAt(0) < 32)) return true;
+	}
+	return false;
+}
+/** One field as fast-csv FieldFormatter.format writes it; `quoteThis`: quoteColumns or quoteHeaders asks for quotes, or the escape. */
+function formatField(value, index, f, quoteThis) {
 	const text = `${value === null || value === void 0 ? "" : String(value)}`.replace(/\0/g, "");
 	if (f.quote === "" && (/[\r\n]/.test(text) || f.delimiter !== "" && text.includes(f.delimiter))) throw new XlvError("XLV_E_INVALID_OPTION", `Field ${String(index + 1)} contains a line break or the delimiter, which cannot be written with quote: false.`, {
 		hint: "Leave formatterOptions.quote at its default (\") so such fields are quoted, or remove the line breaks from the value.",
@@ -5108,9 +5552,14 @@ function formatField(value, index, f, forceQuote) {
 			field: index + 1
 		}
 	});
+	if (f.quote === "" && f.strictQuoting && splitStartsFormula(text)) throw new XlvError("XLV_E_INVALID_OPTION", `Field ${String(index + 1)} has a comma, ";", tab or "|" followed by a formula sign, which an application splitting on that character reads as a formula; it cannot be written with quote: false.`, {
+		hint: "Leave formatterOptions.quote at its default (\") so such fields are quoted, or pass formulaInjection: \"off\" for a trusted consumer.",
+		details: {
+			option: "quote",
+			field: index + 1
+		}
+	});
 	if (f.quote !== "" && text.includes(f.quote)) return `${f.quote}${text.split(f.quote).join(f.escapedQuote)}${f.quote}`;
-	const q = f.quoteColumns;
-	const quoteThis = forceQuote || q === true || Array.isArray(q) && q[index] === true;
 	if (text.search(f.escapeChars) !== -1 || quoteThis) return `${f.quote}${text}${f.quote}`;
 	return text;
 }
@@ -5127,7 +5576,7 @@ function defaultWriteMap(dateFormat, dateUTC) {
 		if (typeof value === "object") {
 			const v = value;
 			if (v["text"] || v["hyperlink"]) return v["hyperlink"] || v["text"] || "";
-			if (v["formula"] || v["sharedFormula"] || "result" in v) {
+			if (v["sharedFormula"] || v["formula"] || "result" in v) {
 				const result = v["result"];
 				if (result === void 0 || result === null) return "";
 				if (result instanceof Date) return date(result);
@@ -5140,15 +5589,165 @@ function defaultWriteMap(dateFormat, dateUTC) {
 		return value;
 	};
 }
+/** The output encoding for the `encoding` option (an unsupported one is refused when encoding). */
+function outputEncoding(encoding) {
+	const e = (encoding ?? "").toLowerCase();
+	if (e === "latin1" || e === "binary") return "latin1";
+	if (e === "utf16le" || e === "utf-16le" || e === "ucs2" || e === "ucs-2") return "utf16le";
+	return "utf8";
+}
+/** Leading UTF-8 sequences of U+FF1D, U+FF0B, U+FF0D, U+FF20, U+FE66, U+FE62, U+FE63, U+FE6B. */
+const UTF8_FORMULA_SIGNS = [
+	[
+		239,
+		188,
+		157
+	],
+	[
+		239,
+		188,
+		139
+	],
+	[
+		239,
+		188,
+		141
+	],
+	[
+		239,
+		188,
+		160
+	],
+	[
+		239,
+		185,
+		166
+	],
+	[
+		239,
+		185,
+		162
+	],
+	[
+		239,
+		185,
+		163
+	],
+	[
+		239,
+		185,
+		171
+	]
+];
+/**
+* Whether the first bytes of a field, as latin1 or UTF-16LE writes it, are a byte order mark
+* (EF BB BF, FF FE, FE FF), which makes a reader decode the rest of the file in that encoding
+* and drop the mark, or the UTF-8 form of a full-width or small formula sign, which a reader that
+* guesses UTF-8 shows as one (K2). `prefix` holds bytes written before the field (latin1 writes
+* the `writeBOM` mark U+FEFF as the single byte FF). UTF-16LE bytes are taken without their NUL
+* bytes, as an 8-bit reader that drops them reads them (K3); a sequence that holds no NUL byte is
+* the same either way.
+*/
+function encodedStartIsUnsafe(text, encoding, prefix) {
+	if (encoding === "utf8") return false;
+	const bytes = [...prefix];
+	for (let i = 0; bytes.length < 3 && i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (encoding === "latin1") bytes.push(c & 255);
+		else for (const b of [c & 255, c >> 8]) if (b !== 0) bytes.push(b);
+	}
+	const starts = (lead) => lead.every((b, i) => bytes[i] === b);
+	return starts([
+		239,
+		187,
+		191
+	]) || starts([255, 254]) || starts([254, 255]) || UTF8_FORMULA_SIGNS.some(starts);
+}
+/** Bytes that end a field or a row for a reader of the 8-bit text, whatever its delimiter. */
+const BYTE_BREAKS = /* @__PURE__ */ new Set([
+	44,
+	59,
+	9,
+	124,
+	13,
+	10
+]);
+/** Whether the 8-bit text `view` has a formula start at `i`: "=", or spaces or tabs, a quote and "=". */
+function viewFormulaAt(view, i) {
+	if (view[i] === "=") return true;
+	let j = i;
+	while (view[j] === " " || view[j] === "	") j++;
+	return view[j] === "\"" && view[j + 1] === "=";
+}
+/**
+* Whether the UTF-16LE bytes of `text` without NULs start a formula (see {@link viewFormulaAt})
+* because of a character above U+00FF, such as U+3D00 (00 3D) or U+4E3D (3D 4E). Starts made only
+* of characters up to U+00FF are the same text in both readings and are checked as text.
+*/
+function utf16StartsFormula(text) {
+	let view = "";
+	let foreign = false;
+	let lead = 0;
+	let blank = true;
+	for (let i = 0; i < text.length && view.length - lead < 2; i++) {
+		const c = text.charCodeAt(i);
+		if (c > 255) foreign = true;
+		for (const b of c > 255 ? [c & 255, c >> 8] : [c]) {
+			if (b === 0) continue;
+			view += String.fromCharCode(b);
+			if (blank && (b === 32 || b === 9)) lead++;
+			else blank = false;
+		}
+	}
+	return foreign && viewFormulaAt(view, 0);
+}
+/** The UTF-16LE bytes of a written field without NULs, and whether characters above U+00FF give a break or a quote among them. */
+function utf16View(written, delimiter) {
+	let view = "";
+	let foreignBreak = false;
+	let foreignQuote = false;
+	for (let i = 0; i < written.length; i++) {
+		const c = written.charCodeAt(i);
+		for (const b of c > 255 ? [c & 255, c >> 8] : [c]) {
+			if (b === 0) continue;
+			if (c > 255) {
+				if (b === 34) foreignQuote = true;
+				else if (BYTE_BREAKS.has(b) || delimiter.includes(String.fromCharCode(b))) foreignBreak = true;
+			}
+			view += String.fromCharCode(b);
+		}
+	}
+	return {
+		view,
+		foreignBreak,
+		foreignQuote
+	};
+}
+/** Whether the 8-bit text `view` has a delimiter (`delimiter` or a common one) or a line break followed by a formula start. */
+function viewSplitStartsFormula(view, delimiter) {
+	for (let i = 0; i < view.length; i++) {
+		if (BYTE_BREAKS.has(view.charCodeAt(i)) && viewFormulaAt(view, i + 1)) return true;
+		if (view.startsWith(delimiter, i) && viewFormulaAt(view, i + delimiter.length)) return true;
+	}
+	return false;
+}
+/** Column letters of a 1-based column number. */
+function columnName(n) {
+	let s = "";
+	for (let c = n; c > 0; c = Math.floor((c - 1) / 26)) s = String.fromCharCode(65 + (c - 1) % 26) + s;
+	return s;
+}
 /**
-* The CSV text of a worksheet, as exceljs `csv.write` gives it.
+* The CSV text of a worksheet, as exceljs `csv.write` gives it, for output in `encoding`.
 *
 * @internal
 */
-function worksheetCsv(sheet, options, latin1 = false) {
-	const f = formatterOptions(options.formatterOptions);
+async function worksheetCsv(sheet, options, encoding = "utf8") {
 	const injection = options.formulaInjection ?? "escape";
 	if (injection !== "escape" && injection !== "off") throw invalid("formulaInjection", "The option \"formulaInjection\" must be \"escape\" or \"off\".", "Use \"escape\" (default) or \"off\".");
+	const f = formatterOptions(options.formatterOptions, injection === "escape");
+	const latin1 = encoding === "latin1";
+	const sheetName = sheet?.name ?? "";
 	if (latin1) {
 		for (const [name, value] of [
 			["delimiter", f.delimiter],
@@ -5159,6 +5758,10 @@ function worksheetCsv(sheet, options, latin1 = false) {
 	}
 	if (injection === "escape") {
 		const off = "or pass formulaInjection: \"off\" for a trusted consumer.";
+		if (f.delimiter === "") throw invalid("delimiter", "The delimiter is empty, so the fields of a row run together and the text of one field could complete a formula or a byte order mark begun by the one before.", `Use "," (default), ";", "|" or "\\t", ${off}`);
+		if (encoding !== "utf8") {
+			for (const [name, value] of [["delimiter", f.delimiter], ["rowDelimiter", f.rowDelimiter]]) if (/[^\u0000-\u007f]/.test(value)) throw invalid(name, `The option "${name}" (${JSON.stringify(value)}) has characters other than ASCII, whose ${encoding} bytes could join the bytes of the fields around them into a byte order mark or a formula sign.`, `Use ASCII characters with encoding "${encoding}" (for example "," or ";"), write UTF-8 (the default encoding), ${off}`);
+		}
 		if (f.delimiter !== "	" && [...f.delimiter].some((c) => INJECTION_START.has(c) || c.charCodeAt(0) < 32)) throw invalid("delimiter", `The delimiter ${JSON.stringify(f.delimiter)} holds a formula sign or a control character, so a line could start with a formula.`, `Use "," (default), ";", "|" or "\\t", ${off}`);
 		if (![
 			"\n",
@@ -5170,8 +5773,34 @@ function worksheetCsv(sheet, options, latin1 = false) {
 	}
 	/** The text latin1 will write: characters above U+00FF as "?". */
 	const narrow = (out) => latin1 && typeof out === "string" ? out.replace(/[^\u0000-\u00ff]/g, "?") : out;
-	/** A formatted field, refused if a standard reader would take its leading quote as quoting. */
-	const field = (out, index, force) => {
+	const utf16 = encoding === "utf16le" && injection === "escape";
+	const marked = injection === "escape" && (utf16 || latin1 && f.writeBOM);
+	/** A quote may be taken differently by a reader of the 8-bit text from here on (K3). */
+	let quoteShifted = false;
+	const unsafeField = (index, row, reason, hint) => {
+		const cell = `${columnName(index + 1)}${String(row)}`;
+		return new XlvError("XLV_E_INVALID_OPTION", `The text of ${row === 0 ? `header ${String(index + 1)}` : `cell ${cell}`} cannot be written safely as ${encoding}: ${reason}`, {
+			location: row === 0 ? { sheet: sheetName } : {
+				sheet: sheetName,
+				cell
+			},
+			hint,
+			details: {
+				option: "encoding",
+				field: index + 1,
+				row
+			}
+		});
+	};
+	/**
+	* A formatted field, refused if a standard reader would take its leading quote as quoting, or
+	* if a reader of the output as 8-bit text that drops NUL bytes (LibreOffice) would split it
+	* before a formula start: in utf16le output, when characters above U+00FF give a delimiter,
+	* line break or quote there, when an earlier quote of that kind may shift the quoting, or for
+	* the first field after a mark that reader keeps (K3). `row` is the row number, 0 for the header
+	* line; `atStart`: the field is the first one of the file.
+	*/
+	const field = (out, index, force, row, atStart) => {
 		const text = formatField(out, index, f, force);
 		if (injection === "escape" && f.quote !== "\"" && text.startsWith("\"")) throw new XlvError("XLV_E_INVALID_OPTION", `Field ${String(index + 1)} starts with a double quote, which a standard CSV reader takes as quoting when formatterOptions.quote is not '"'.`, {
 			hint: "Leave formatterOptions.quote at its default (\"), or pass formulaInjection: \"off\" for a trusted consumer.",
@@ -5180,43 +5809,114 @@ function worksheetCsv(sheet, options, latin1 = false) {
 				field: index + 1
 			}
 		});
+		const first = marked && atStart;
+		if (first || quoteShifted || utf16 && /[^\u0000-\u00ff]/.test(text)) {
+			const { view, foreignBreak, foreignQuote } = utf16 ? utf16View(text, f.delimiter) : {
+				view: text,
+				foreignBreak: false,
+				foreignQuote: false
+			};
+			if ((first || foreignBreak || foreignQuote || quoteShifted) && viewSplitStartsFormula(view, f.delimiter)) throw first ? unsafeField(index, row, `the file starts with ${utf16 ? "the UTF-16LE byte order mark (FF FE)" : "the byte FF (writeBOM)"}, which LibreOffice keeps when it reads the file as 8-bit text, so the opening quote of this first field is not taken as quoting and its delimiter or line break followed by "=" starts a formula.`, utf16 ? "Write UTF-8 (the default encoding), move this text out of the first cell, or pass formulaInjection: \"off\" for a trusted consumer." : "Leave formatterOptions.writeBOM off with latin1, write UTF-8, or pass formulaInjection: \"off\" for a trusted consumer.") : utf16 ? unsafeField(index, row, "read as 8-bit text without its NUL bytes, as LibreOffice reads UTF-16LE CSV files, its bytes hold a delimiter or a line break followed by \"=\", which starts a formula there.", "Write UTF-8 (the default encoding), or pass formulaInjection: \"off\" for a trusted consumer.") : unsafeField(index, row, "the first field, after the byte FF of writeBOM, is split by LibreOffice, which may then take the quotes after it differently, and this field holds a delimiter or a line break followed by \"=\".", "Leave formatterOptions.writeBOM off with latin1, write UTF-8, or pass formulaInjection: \"off\" for a trusted consumer.");
+			if (foreignQuote || first && ([...view].some((c) => BYTE_BREAKS.has(c.charCodeAt(0))) || view.includes(f.delimiter))) quoteShifted = true;
+		}
 		return text;
 	};
 	const map = options.map ?? defaultWriteMap(options.dateFormat, options.dateUTC === true);
 	const includeEmptyRows = options.includeEmptyRows === void 0 || options.includeEmptyRows;
 	const lines = [];
-	const escape = (raw) => {
-		const out = narrow(raw);
+	const escape = (raw, atStart) => {
+		const out = narrow(raw === null || raw === void 0 || typeof raw === "number" || typeof raw === "boolean" || typeof raw === "bigint" || typeof raw === "string" ? raw : String(raw));
 		if (injection !== "escape" || typeof out !== "string") return [out, false];
-		const first = out.replace(/\0/g, "")[0];
-		return first !== void 0 && (INJECTION_START.has(first) || first.charCodeAt(0) < 32) ? [`'${out}`, f.quote !== ""] : [out, false];
+		const text = out.replace(/\0/g, "");
+		const first = text[0];
+		if (first === void 0) return [out, false];
+		return INJECTION_START.has(first) || first.charCodeAt(0) < 32 || encodedStartIsUnsafe(text, encoding, atStart && f.writeBOM && latin1 ? [255] : []) || utf16 && utf16StartsFormula(text) ? [`'${out}`, f.quote !== ""] : [out, false];
+	};
+	/** RowFormatter `headers`: given, or taken from the first row written (L109-124). */
+	let headers = f.headers;
+	/** FieldFormatter `_headers`, by which an object of quoteColumns or quoteHeaders is looked up. */
+	let fieldHeaders = f.headers;
+	let hasWrittenHeaders = false;
+	const own = (o, key) => Object.prototype.hasOwnProperty.call(o, key);
+	const shouldQuote = (index, isHeader) => {
+		const config = isHeader ? f.quoteHeaders : f.quoteColumns;
+		if (typeof config === "boolean") return config;
+		if (Array.isArray(config)) return Boolean(config[index]);
+		if (fieldHeaders !== null && config !== null && typeof config === "object") {
+			const key = String(fieldHeaders[index]);
+			return own(config, key) && Boolean(config[key]);
+		}
+		return false;
+	};
+	const formatColumns = (columns, isHeader, rowNumber) => {
+		const fields = [];
+		for (let i = 0; i < columns.length; i++) {
+			if (!(i in columns)) {
+				fields.push("");
+				continue;
+			}
+			const atStart = lines.length === 0 && i === 0;
+			const [out, force] = escape(columns[i], atStart);
+			fields.push(field(out, i, force || shouldQuote(i, isHeader), isHeader ? 0 : rowNumber, atStart));
+		}
+		lines.push(fields.join(f.delimiter));
+	};
+	const isHashArray = (row) => Array.isArray(row) && Array.isArray(row[0]) && row[0].length === 2;
+	const gatherHeaders = (row) => isHashArray(row) ? row.map((it) => it[0]) : Array.isArray(row) ? row : Object.keys(Object(row));
+	const gatherColumns = (row, names) => {
+		if (!Array.isArray(row)) {
+			const o = Object(row);
+			return names.map((h) => own(o, String(h)) ? o[String(h)] : void 0);
+		}
+		if (isHashArray(row)) return names.map((_h, i) => row[i] ? row[i][1] : "");
+		if (!f.shouldWriteHeaders) return row;
+		return names.map((_h, i) => row[i]);
+	};
+	const formatRow = (row, rowNumber) => {
+		if (!row) return;
+		let formatRowColumns = true;
+		if (headers === null) {
+			headers = gatherHeaders(row);
+			fieldHeaders = headers;
+			if (f.shouldWriteHeaders) formatRowColumns = !(Array.isArray(row) && !isHashArray(row));
+		}
+		if (f.shouldWriteHeaders && !hasWrittenHeaders) {
+			formatColumns(headers, true, 0);
+			hasWrittenHeaders = true;
+		}
+		if (formatRowColumns) formatColumns(gatherColumns(row, headers), false, rowNumber);
+	};
+	const transform = f.transform;
+	const transformed = (row) => {
+		if (!transform) return row;
+		if (transform.length === 1) return transform(row);
+		return new Promise((resolve, reject) => {
+			transform(row, (error, out) => error ? reject(error instanceof Error ? error : new Error(String(error))) : resolve(out));
+		});
 	};
-	if (f.headers) lines.push(f.headers.map((h, i) => {
-		const [out, force] = escape(h);
-		return field(out, i, force);
-	}).join(f.delimiter));
 	if (sheet) {
-		let lastRow = 0;
+		const rows = [];
 		sheet.eachRow((row, rowNumber) => {
-			if (includeEmptyRows) while (++lastRow < rowNumber) lines.push("");
-			let values = row.values.slice(1);
-			if (f.headers) values = f.headers.map((_h, i) => values[i]);
-			const fields = [];
-			for (let i = 0; i < values.length; i++) {
-				if (!(i in values)) {
-					fields.push("");
-					continue;
-				}
-				const [out, force] = escape(map(values[i], i));
-				fields.push(field(out, i, force));
+			rows.push([rowNumber, row]);
+		});
+		let lastRow = f.shouldWriteHeaders && f.headers === null && rows.length > 0 ? rows[0][0] - 1 : 0;
+		for (const [rowNumber, row] of rows) {
+			if (includeEmptyRows) while (++lastRow < rowNumber) {
+				const out = transformed([]);
+				formatRow(out instanceof Promise ? await out : out, lastRow);
 			}
-			lines.push(fields.join(f.delimiter));
+			const out = transformed(row.values.slice(1).map((v, i) => map(v, i)));
+			formatRow(out instanceof Promise ? await out : out, rowNumber);
 			lastRow = rowNumber;
-		});
+		}
+	}
+	if (f.alwaysWriteHeaders && lines.length === 0) {
+		if (!headers) throw invalid("formatterOptions.alwaysWriteHeaders", "alwaysWriteHeaders is set, but no header names are given in formatterOptions.headers.", "Pass formatterOptions.headers as an array of names, or leave alwaysWriteHeaders out.");
+		formatColumns(headers, true, 0);
 	}
 	let text = lines.join(f.rowDelimiter);
 	if (f.includeEndRowDelimiter) text += f.rowDelimiter;
-	return (f.writeBOM ? "" : "") + text;
+	return (f.writeBOM || utf16 ? "" : "") + text;
 }
 function encode(text, encoding) {
 	const e = (encoding ?? "utf8").toLowerCase();
@@ -5237,9 +5937,22 @@ function encode(text, encoding) {
 	}
 	throw invalid("encoding", `The encoding "${encoding ?? ""}" is not supported.`, "Use \"utf8\" (default), \"utf16le\" or \"latin1\".");
 }
+/**
+* Node.js's 'latin1' (alias 'binary'), which fast-csv's StringDecoder uses
+* (`@fast-csv/parse/build/src/CsvParserStream.js` L20): each byte is the code point of the same
+* value. The WHATWG label 'latin1' of `TextDecoder` is windows-1252 instead (bytes 80-9F become
+* other characters, for example 80 the euro sign), so it is not used (F10).
+*/
+const latin1Decoder = { decode(input) {
+	if (!input) return "";
+	let out = "";
+	for (let i = 0; i < input.length; i += 8192) out += String.fromCharCode(...input.subarray(i, i + 8192));
+	return out;
+} };
 function decoderFor(encoding) {
 	const e = encoding.toLowerCase();
-	const label = e === "utf8" ? "utf-8" : e === "ucs2" || e === "ucs-2" || e === "utf16le" ? "utf-16le" : e === "binary" ? "latin1" : e;
+	if (e === "latin1" || e === "binary") return latin1Decoder;
+	const label = e === "utf8" ? "utf-8" : e === "ucs2" || e === "ucs-2" || e === "utf16le" ? "utf-16le" : e;
 	try {
 		return new TextDecoder(label);
 	} catch {
@@ -5358,10 +6071,16 @@ var CsvIO = class {
 	async read(stream, options = {}) {
 		const worksheet = this.workbook.addWorksheet(options.sheetName);
 		const parser = parserOptions(options.parserOptions);
-		const rows = parseCsv(await readText(stream, parser.encoding), parser);
+		const text = await readText(stream, parser.encoding);
 		const formats = options.dateFormats ?? DEFAULT_DATE_FORMATS;
 		const map = options.map ?? ((datum) => csvValue(datum, formats));
-		for (const row of rows) worksheet.addRow(row.map((datum, i) => map(datum, i)));
+		if (text.length >= MAX_CSV_CELLS && fieldEnds(text, parser.delimiter) >= MAX_CSV_CELLS) try {
+			const rows = csvRows(text, parser);
+			while (rows.next().done !== true);
+		} catch (error) {
+			if (error instanceof XlvError && error.code === "XLV_E_LIMIT_EXCEEDED" && error.details?.limit === "maxCells") throw error;
+		}
+		for (const row of csvRows(text, parser)) worksheet.addRow(row.fields.map((datum, i) => map(datum, i)));
 		return worksheet;
 	}
 	/** Reads a CSV file (Node.js, Bun, Deno) into a new worksheet. */
@@ -5385,12 +6104,11 @@ var CsvIO = class {
 	}
 	/** Writes a worksheet as CSV to a stream and ends it. */
 	async write(stream, options = {}) {
-		await writeTo(stream, encode(this.text(options), "utf8"));
+		await writeTo(stream, encode(await this.text(options), "utf8"));
 	}
 	/** Writes a worksheet to a CSV file (Node.js, Bun, Deno), replacing it. */
 	async writeFile(path, options = {}) {
-		const e = (options.encoding ?? "").toLowerCase();
-		const bytes = encode(this.text(options, e === "latin1" || e === "binary"), options.encoding);
+		const bytes = encode(await this.text(options, outputEncoding(options.encoding)), options.encoding);
 		const fs = await nodeFs("writeFile");
 		try {
 			await fs.writeFile(path, bytes);
@@ -5408,13 +6126,13 @@ var CsvIO = class {
 	}
 	/** The CSV of a worksheet as bytes (a Buffer in Node.js), UTF-8 encoded. */
 	async writeBuffer(options = {}) {
-		return asBuffer$1(encode(this.text(options), "utf8"));
+		return asBuffer$1(encode(await this.text(options), "utf8"));
 	}
 	/** Removed in exceljs 4 (it throws there too); use `read`. */
 	createInputStream() {
 		throw new Error("`CSV#createInputStream` is deprecated. You should use `CSV#read` instead. This method will be removed in version 5.0. Please follow upgrade instruction: https://github.com/exceljs/exceljs/blob/master/UPGRADE-4.0.md");
 	}
-	text(options, latin1 = false) {
+	async text(options, encoding = "utf8") {
 		const key = options.sheetName || options.sheetId;
 		const sheet = this.workbook.getWorksheet(key);
 		if (key !== void 0 && !sheet) throw new XlvError("XLV_E_SHEET_NOT_FOUND", `The workbook has no worksheet ${typeof key === "string" ? `named "${key}"` : `with id ${String(key)}`}.`, {
@@ -5422,7 +6140,7 @@ var CsvIO = class {
 			hint: `Available worksheets: ${this.workbook.worksheets.map((w) => `"${w.name}"`).join(", ") || "none"}.`,
 			details: { available: this.workbook.worksheets.map((w) => w.name) }
 		});
-		return worksheetCsv(sheet, options, latin1);
+		return worksheetCsv(sheet, options, encoding);
 	}
 };
 // src/defined-names.ts
@@ -5951,9 +6669,11 @@ var XlsxIO = class {
 	}
 	book(options) {
 		const useStyles = options?.useStyles !== false;
+		const font = this.workbook._defaultFont;
 		return toNewWorkbook(this.workbook.worksheets, this.workbook._date1904, {
 			...this.workbook._meta(),
-			useStyles
+			useStyles,
+			...font ? { defaultFont: font } : {}
 		});
 	}
 	bytes(options) {
@@ -6044,6 +6764,8 @@ var Workbook = class {
 			calcProperties: this.calcProperties
 		};
 	}
+	/** @internal The default font (font 0) of the file this workbook was loaded from, written again (F4); `null` for a workbook made in code. */
+	_defaultFont = null;
 	/** @internal */
 	get _date1904() {
 		return this.properties.date1904 === true;
@@ -6271,6 +6993,10 @@ var Workbook = class {
 		const use = (node) => !ignore.has(node);
 		let cellsRead = 0;
 		for (const s of read.sheets) cellsRead += s.cellCount;
+		const dates = {
+			date1904: read.dateSystem === "1904",
+			strict: read.conformance === "strict"
+		};
 		const budget = Math.max(DEFAULT_READ_LIMITS.maxCells, 16 * cellsRead);
 		let spent = 0;
 		const spend = (positions, what, sheet) => {
@@ -6286,6 +7012,23 @@ var Workbook = class {
 				}
 			});
 		};
+		const mergeBudget = Math.max(MERGED_CELLS_BUDGET, cellsRead);
+		let merged = 0;
+		const spendMerge = (positions, ref, sheet) => {
+			merged += positions;
+			if (merged <= mergeBudget) return;
+			throw new XlvError("XLV_E_LIMIT_EXCEEDED", `The merged range ${ref} of worksheet "${sheet}" would bring the merged cells past ${String(mergeBudget)} for ${String(cellsRead)} cells in the file.`, {
+				location: {
+					sheet,
+					cell: ref
+				},
+				hint: "The file merges far more cells than it holds. Load it with ignoreNodes: [\"mergeCells\"] to skip merged ranges, or read it with xlvane's readWorkbook, which does not create these cells.",
+				details: {
+					limit: "mergedCells",
+					value: mergeBudget
+				}
+			});
+		};
 		const rowBudget = Math.max(67108864, 16 * cellsRead);
 		const validations = validationBudget();
 		let rowsLooked = 0;
@@ -6310,6 +7053,27 @@ var Workbook = class {
 			}
 		}
 		this._clearSheets();
+		const font0 = writableDefaultFont(read.defaultFont);
+		this._defaultFont = font0;
+		const fileStyle = (style, numFmt, styled = Object.keys(style).length > 0) => styleOut(styled && font0 && !style.font ? {
+			...style,
+			font: font0
+		} : style, numFmt);
+		const lineFormat = (style) => typeof style.numFmt === "string" ? style.numFmt : null;
+		let xf0;
+		const defaultXf = () => {
+			if (xf0 !== void 0) return xf0;
+			xf0 = null;
+			for (const sheet of read.sheets) {
+				if (sheet.kind !== "worksheet") continue;
+				for (const cell of sheet.cells()) if (cell.styleIndex === 0) return xf0 = cell.style;
+			}
+			return xf0;
+		};
+		const lineStyle = (style) => {
+			const zero = defaultXf();
+			return zero && sameStyleData(style, zero) ? {} : fileStyle(style, lineFormat(style));
+		};
 		if (read.dateSystem === "1904") this.properties.date1904 = true;
 		else delete this.properties.date1904;
 		const p = read.properties;
@@ -6371,7 +7135,7 @@ var Workbook = class {
 					if (c.width !== null) column.width = c.width;
 					if (c.hidden) column.hidden = true;
 					if (c.outlineLevel) column.outlineLevel = c.outlineLevel;
-					if (c.style) column.style = styleOut(c.style, typeof c.style.numFmt === "string" ? c.style.numFmt : null);
+					if (c.style) column.style = lineStyle(c.style);
 				}
 			}
 			if (use("sheetFormatPr") || use("sheetPr")) {
@@ -6391,14 +7155,14 @@ var Workbook = class {
 			}
 			let lastRow = 0;
 			for (const cell of use("sheetData") ? s.styledCells() : []) {
-				ws.getCell(cell.row, cell.col).style = styleOut(cell.style, cell.numFmt);
+				ws.getCell(cell.row, cell.col).style = fileStyle(cell.style, cell.numFmt, cell.styleIndex > 0);
 				if (cell.row > lastRow) lastRow = cell.row;
 			}
 			for (const cell of use("sheetData") ? s.cells() : []) {
 				const target = ws.getCell(cell.row, cell.col);
 				let value;
-				const plain = cell.type === "error" ? { error: cell.value } : cell.value;
-				if (cell.formula && cell.formula.text !== null) value = formulaOut(cell.formula, plain, cell.ref, masters);
+				const plain = cell.type === "error" ? { error: cell.value } : readValueOut(cell.value, cell.numFmt, dates);
+				if (cell.formula && hasFormulaText(cell.formula)) value = formulaOut(cell.formula, plain, cell.ref, masters);
 				else value = cell.richText ? richTextOut(cell.richText) : plain;
 				const h = cell.hyperlink;
 				if (h && use("hyperlinks") && (h.target !== null || h.location !== null && h.location !== "")) {
@@ -6414,7 +7178,7 @@ var Workbook = class {
 					};
 				}
 				target.value = value;
-				target.style = styleOut(cell.style, cell.numFmt);
+				target.style = fileStyle(cell.style, cell.numFmt, cell.styleIndex > 0);
 				if (cell.row > lastRow) lastRow = cell.row;
 			}
 			const dim = /(\d+)$/.exec(s.dimension ?? "");
@@ -6432,6 +7196,7 @@ var Workbook = class {
 				const info = s.rowInfo(r);
 				if (!info) continue;
 				const row = ws.getRow(r);
+				if (info.style && use("sheetData")) row.style = lineStyle(info.style);
 				if (info.height !== null) row.height = Math.min(info.height, 409.5);
 				if (info.hidden) row.hidden = true;
 				if (info.outlineLevel) row.outlineLevel = info.outlineLevel;
@@ -6440,8 +7205,9 @@ var Workbook = class {
 			for (const m of use("mergeCells") ? s.merges : []) {
 				if (!m.includes(":")) continue;
 				spend(areaOf(m), "A merged range", s.name);
+				spendMerge(areaOf(m), m, s.name);
 				try {
-					ws.mergeCells(m);
+					ws.mergeCellsWithoutStyle(m);
 				} catch (error) {
 					if (error instanceof XlvError || !(error instanceof Error) || error.message !== "Cannot merge already merged cells") throw error;
 					const other = mergeOverlapping(ws, m);
@@ -6483,6 +7249,8 @@ var Workbook = class {
 		}
 	}
 };
+/** Merged cells `xlsx.load` creates at most for a file with fewer cells (one whole column; K2). */
+const MERGED_CELLS_BUDGET = 1048576;
 /**
 * @internal The chunks of an input stream, read until it ends. Reading stops with
 * XLV_E_LIMIT_EXCEEDED as soon as the chunks pass maxInputBytes, the size the core reads at most,
@@ -6571,7 +7339,7 @@ function streamValueIn(cell, masters) {
 	const v = cell.value;
 	if (v !== null && typeof v === "object" && !Array.isArray(v) && !(v instanceof Date)) {
 		const r = v;
-		if (typeof r["formula"] === "string" && r["shareType"] !== "array" && typeof r["ref"] === "string") {
+		if (typeof r["ref"] === "string" && r["shareType"] !== "array" && typeof r["formula"] === "string") {
 			masters.set(cell.address, {
 				formula: r["formula"],
 				row: cell.row,
@@ -6805,8 +7573,10 @@ var WorksheetWriter = class extends Worksheet {
 			if (styles[i] !== void 0) styled = true;
 		});
 		for (let i = 0; i < values.length; i++) if (values[i] === void 0) values[i] = null;
+		const rowStyle = rowStyleIn(row, this.writer._useStyles);
 		this.rowsOut.push({
 			values,
+			...rowStyle ? { rowStyle } : {},
 			...styled ? { styles } : {},
 			...links.length > 0 ? { hyperlinks: links } : {},
 			...notes.length > 0 ? { notes } : {},
@@ -7178,6 +7948,44 @@ var WorksheetReader = class extends Emitter {
 	}
 };
 /**
+* The value of a shared-formula dependent read by the streaming reader: `{ sharedFormula: master,
+* result }`, as exceljs's xlsx.load gives it, with a non-enumerable `formula` that moves the
+* master's text (`masters`, by address) to `row`/`col` when it is first read. The master's row is
+* not kept, so a sheet the value is copied into (stream.xlsx.WorkbookWriter, whose committed rows
+* are dropped) can write this formula instead of looking the master up (K3); reading the rows
+* alone builds no moved texts (K2). Setting `formula` replaces it with an ordinary property. A move
+* counts against the shared-formula budget of `workbook`, as `cell.formula` does (K4 S1).
+*/
+function sharedDependent(master, result, masters, row, col, workbook, sheet) {
+	const value = {
+		sharedFormula: master,
+		...result
+	};
+	let moved;
+	let built = false;
+	Object.defineProperty(value, "formula", {
+		configurable: true,
+		enumerable: false,
+		get() {
+			if (!built) {
+				const text = masters.get(master);
+				moved = text === void 0 ? void 0 : moveSharedFormula(workbook, sheet, text, decodeAddress(master), row, col);
+				built = true;
+			}
+			return moved;
+		},
+		set(formula) {
+			Object.defineProperty(this, "formula", {
+				value: formula,
+				writable: true,
+				enumerable: true,
+				configurable: true
+			});
+		}
+	});
+	return value;
+}
+/**
 * The streaming reader of exceljs (`ExcelJS.stream.xlsx.WorkbookReader`): iterate worksheets
 * and their rows with `for await`, or call `read()` and listen to `worksheet`, `end`,
 * `finished` and `error` events (and `entry` with `entries: 'emit'`). Rows are not kept.
@@ -7213,6 +8021,10 @@ var WorkbookReader = class extends Emitter {
 	async *parse(input, options) {
 		if (options) this.options = readerOptions(options);
 		const book = await this.open(input ?? this.input);
+		const dates = {
+			date1904: book.dateSystem === "1904",
+			strict: book.conformance === "strict"
+		};
 		if (this.options.entries === "emit") this.emit("entry", { type: "workbook" });
 		if (this.options.worksheets === "ignore") return;
 		const host = new Workbook();
@@ -7227,16 +8039,32 @@ var WorkbookReader = class extends Emitter {
 			});
 			const sheet = host._addReadWorksheet(host.nextId, info.name, { state: info.state });
 			const name = info.name;
+			const masters = /* @__PURE__ */ new Map();
+			const kept = /* @__PURE__ */ new Map();
+			sheet._sharedMasters = kept;
 			const rows = async function* () {
 				for await (const r of book.rows(name)) {
 					const row = sheet.getRow(r.number);
+					if (styles && r.style) row.style = styleOut(r.style, typeof r.style.numFmt === "string" ? r.style.numFmt : null);
 					for (const cell of r.cells) {
-						const plain = cell.type === "error" ? { error: cell.value } : cell.value;
+						const plain = cell.type === "error" ? { error: cell.value } : readValueOut(cell.value, cell.numFmt, dates, !cell.formula);
 						const target = row.getCell(cell.col);
-						target.value = cell.formula && cell.formula.text !== null ? plain === null ? { formula: cell.formula.text } : {
-							formula: cell.formula.text,
-							result: plain
-						} : cell.richText ? richTextOut(cell.richText) : plain;
+						const f = cell.formula;
+						const result = plain === null ? {} : { result: plain };
+						let value;
+						if (f && f.kind === "shared" && f.sharedIndex !== null && f.ref === null && masters.has(f.sharedIndex) && hasFormulaText(f)) value = sharedDependent(masters.get(f.sharedIndex), result, kept, r.number, cell.col, host, name);
+						else if (f && hasFormulaText(f)) {
+							const text = f.text ?? "";
+							if (f.kind === "shared" && f.sharedIndex !== null && f.ref !== null) {
+								masters.set(f.sharedIndex, cell.ref);
+								kept.set(cell.ref, text);
+							}
+							value = {
+								formula: text,
+								...result
+							};
+						} else value = cell.richText ? richTextOut(cell.richText) : plain;
+						target.value = value;
 						if (styles) target.style = styleOut(cell.style, cell.numFmt);
 					}
 					for (const cell of r.styledCells) {