@xlvane/compat 1.3.0 → 1.3.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { StreamSheetSpec, Workbook as Workbook$1, WorkbookProperties as WorkbookProperties$1 } from "xlvane";
+import { FontStyle, StreamSheetSpec, Workbook as Workbook$1, WorkbookProperties as WorkbookProperties$1 } from "xlvane";
 /**
  * A cell location of a defined name, as exceljs keeps it.
  *
@@ -150,6 +150,8 @@ interface WorkbookMeta {
   readonly views?: readonly Record<string, unknown>[];
   /** `workbook.calcProperties`. */
   readonly calcProperties?: Record<string, unknown>;
+  /** The default font (font 0) of a loaded workbook (F4). */
+  readonly defaultFont?: FontStyle;
 }
 /**
  * Options of `xlsx.load`, `read` and `readFile`, as exceljs `XlsxReadOptions` (index.d.ts L1460;
@@ -287,6 +289,8 @@ export declare class Workbook {
   get definedNames(): DefinedNames;
   /** @internal The document properties and defined names to write, as exceljs `workbook.model`. */
   _meta(): WorkbookMeta;
+  /** @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: FontStyle | null;
   /** @internal */
   get _date1904(): boolean;
   private _byName;
@@ -405,7 +409,7 @@ interface CsvWriteOptions {
   map?(value: unknown, index: number): unknown;
   /** Blank lines for missing rows (default `true`). */
   includeEmptyRows?: boolean;
-  /** fast-csv formatter options: `delimiter`, `rowDelimiter`, `quote`, `escape`, `quoteColumns`, `headers`, `writeHeaders`, `includeEndRowDelimiter`, `writeBOM`. */
+  /** fast-csv formatter options: `delimiter`, `rowDelimiter`, `quote`, `escape`, `quoteColumns`, `quoteHeaders`, `headers`, `writeHeaders`, `alwaysWriteHeaders`, `includeEndRowDelimiter`, `writeBOM`, `transform`. */
   formatterOptions?: Record<string, unknown>;
   /**
    * `"escape"` (default): text that starts with `=`, `+`, `-`, `@`, tab, CR, LF or another
@@ -2460,6 +2464,8 @@ export declare class Cell {
   private _moved;
   /** @internal Use `worksheet.getCell()`. */
   constructor(_row: Row, _col: number);
+  /** The style a new cell takes: row style wins over column style, part by part (lib/doc/cell.js L99-119 `_mergeStyle`). */
+  private _rowColumnStyle;
   get worksheet(): Worksheet;
   get row(): number;
   get col(): number;
@@ -2482,7 +2488,12 @@ export declare class Cell {
    * this cell, as exceljs translates it (lib/doc/cell.js `_getTranslatedFormula`; X4-29).
    */
   get formula(): string | undefined;
-  /** `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(): FormulaType;
   get result(): unknown;
   get numFmt(): string | undefined;
@@ -2559,6 +2570,11 @@ export declare class Cell {
   _merge(master: Cell): void;
   /** @internal */
   _unmerge(): void;
+  /**
+   * @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(): void;
 }
 /**
  * A row, as exceljs `Row` (lib/doc/row.js).
@@ -2708,7 +2724,7 @@ export declare class Column {
   equivalentTo(other: Column): boolean;
   get defn(): ColumnDefn;
   set defn(value: ColumnDefn | undefined);
-  /** 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(): CellValue[];
   set values(values: CellValue[]);
   eachCell(options: {
@@ -2913,8 +2929,9 @@ export declare class Worksheet {
   }[], change: SpliceChange): void;
   /**
    * @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: {
     top: number;

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,19 +1492,46 @@ 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) => useStyles ? cellStyleIn(cell, styleOf(cell.style)) : isDateCell(cell) ? { numFmt: 14 } : {};
-		const uniform = uniformMerges(ws);
+		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 } : {},
@@ -1446,7 +1539,7 @@ function toNewWorkbook(sheets, date1904, meta = {}) {
 			});
 			row._cells.forEach((cell) => {
 				if (!cell) return;
-				if (cell._master !== null && uniform.masters.has(cell._master)) {
+				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);
@@ -1454,10 +1547,8 @@ function toNewWorkbook(sheets, date1904, meta = {}) {
 				} else at(ws.name, cell.address, () => writeCell(cell));
 			});
 		});
-		for (const m of uniform.ranges) {
-			const master = ws.findCell(m.top, m.left);
-			if (!master) continue;
-			const style = styleFor(master);
+		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));
@@ -1470,7 +1561,7 @@ function toNewWorkbook(sheets, date1904, meta = {}) {
 			const note = noteIn(cell);
 			if (note) sheet.note(cell.address, note);
 			const style = styleFor(cell);
-			const value = cell.type === ValueType.Merge ? null : valueIn(cell, sharedRanges);
+			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);
@@ -1505,53 +1596,125 @@ function toNewWorkbook(sheets, date1904, meta = {}) {
 	for (const d of meta.definedNames ?? []) book.defineName(d.name, d.ranges.join(","));
 	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 have the same parts (the same objects, as a merge's copies have). */
-function sameStyleParts(a, b) {
+/**
+* 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;
-	let n = 0;
-	for (const k in a) {
-		if (a[k] !== b[k]) return false;
-		n++;
-	}
-	for (const _ in b) n--;
-	return n === 0;
+	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 merged ranges of a worksheet whose other cells all exist, belong to the range's master and
-* carry the master's style (the copy `mergeCells` gives them, as in exceljs), and the masters all
-* of whose ranges are such. Their cells are written as the master's style over the range (K2),
-* and their notes one by one (K3).
+* 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 uniformMerges(ws) {
-	const ranges = [];
+function mergeBlocks(ws) {
+	const blocks = [];
 	const masters = /* @__PURE__ */ new Set();
-	const mixed = /* @__PURE__ */ new Set();
 	for (const m of ws._merges.values()) {
 		const master = ws.findCell(m.top, m.left);
 		if (!master) continue;
-		let ok = true;
-		for (let r = m.top; ok && r <= m.bottom; r++) {
-			const row = ws.findRow(r);
-			for (let c = m.left; c <= m.right; c++) {
-				if (r === m.top && c === m.left) continue;
-				const cell = row?.findCell(c);
-				if (!cell || cell._master !== master || !sameStyleParts(cell.style, master.style)) {
-					ok = false;
-					break;
+		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
+				}));
 			}
 		}
-		if (ok) {
-			ranges.push(m);
-			masters.add(master);
-		} else mixed.add(master);
+		close(m.right);
 	}
-	for (const master of mixed) masters.delete(master);
 	return {
-		ranges: ranges.filter((m) => masters.has(ws.findCell(m.top, m.left))),
-		masters
+		blocks,
+		covers: (cell) => cell._master !== null && masters.has(cell._master)
 	};
 }
 /**
@@ -3088,10 +3251,13 @@ var Cell = class {
 	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() {
@@ -3204,12 +3370,17 @@ var Cell = class {
 			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;
@@ -3384,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 = {};
@@ -3761,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;
 	}
@@ -3780,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) {
@@ -4344,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);
@@ -4657,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);
@@ -4676,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);
@@ -5215,6 +5395,7 @@ function* csvRows(text, o) {
 		}
 		const rowLine = line;
 		const fields = [];
+		let quoted = false;
 		let extra = 0;
 		let extraText = false;
 		const push = (field) => {
@@ -5228,6 +5409,7 @@ function* csvRows(text, o) {
 			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;
@@ -5267,7 +5449,7 @@ function* csvRows(text, o) {
 		}
 		at = skipLineEnd(at);
 		line++;
-		const row = fields.length === 1 && fields[0].trim() === "" ? [""] : fields;
+		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;
@@ -5319,13 +5501,24 @@ function formatterOptions(raw, escapeFormulas) {
 	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${escapeFormulas ? escapeRe(COMMON_DELIMITERS) : ""}]`),
@@ -5349,8 +5542,8 @@ function splitStartsFormula(text) {
 	}
 	return false;
 }
-/** One field as fast-csv FieldFormatter.format writes it. */
-function formatField(value, index, f, forceQuote) {
+/** 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.",
@@ -5367,8 +5560,6 @@ function formatField(value, index, f, forceQuote) {
 		}
 	});
 	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;
 }
@@ -5551,7 +5742,7 @@ function columnName(n) {
 *
 * @internal
 */
-function worksheetCsv(sheet, options, encoding = "utf8") {
+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");
@@ -5641,29 +5832,87 @@ function worksheetCsv(sheet, options, encoding = "utf8") {
 		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];
 	};
-	if (f.headers) lines.push(f.headers.map((h, i) => {
-		const [out, force] = escape(h, i === 0);
-		return field(out, i, force, 0, i === 0);
-	}).join(f.delimiter));
+	/** 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 (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 atStart = lines.length === 0 && i === 0;
-				const [out, force] = escape(map(values[i], i), atStart);
-				fields.push(field(out, i, force, rowNumber, atStart));
+			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;
@@ -5688,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 {
@@ -5842,11 +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 bytes = encode(this.text(options, outputEncoding(options.encoding)), 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);
@@ -5864,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, encoding = "utf8") {
+	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)}`}.`, {
@@ -6407,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) {
@@ -6500,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;
@@ -6727,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) => {
@@ -6783,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;
@@ -6844,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")) {
@@ -6864,13 +7155,13 @@ 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;
+				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;
@@ -6887,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 ?? "");
@@ -6905,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;
@@ -6915,7 +7207,7 @@ var Workbook = class {
 				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);
@@ -7281,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 } : {},
@@ -7727,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();
@@ -7747,8 +8045,9 @@ var WorkbookReader = class extends Emitter {
 			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);
 						const f = cell.formula;
 						const result = plain === null ? {} : { result: plain };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xlvane/compat",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "The commonly used exceljs 4.4.0 API on top of xlvane, for switching with one line in package.json.",
   "keywords": [
     "xlsx",
@@ -72,7 +72,7 @@
     "build": "tsdown"
   },
   "dependencies": {
-    "xlvane": "^1.3.0"
+    "xlvane": "^1.3.1"
   },
   "publishConfig": {
     "access": "public",