xls-codec 2.0.2 → 4.0.0

package/dist/workbook/sheet.cjs

@@ -3,6 +3,7 @@ require("../biff/record-types.cjs");
 const require_biff_records = require("../biff/records.cjs");
 const require_units = require("../units.cjs");
 const require_biff_print_setup = require("../biff/print-setup.cjs");
+const require_biff_substreams = require("../biff/substreams.cjs");
 const require_biff_cursor = require("../biff/cursor.cjs");
 const require_biff_strings = require("../biff/strings.cjs");
 const require_biff_errors = require("../biff/errors.cjs");
@@ -31,8 +32,80 @@ const EMPTY_FORMULA_SHEET_CONTEXT = {
 	sheets: [],
 	sheetRanges: []
 };
+/** The key collectFormulaGroups and its lookup agree on: a shared/array formula group's own base cell, the same (row, column) a PtgExp token elsewhere in the sheet points back to. */
+function groupKey(row, column) {
+	return `${row},${column}`;
+}
+/**
+* Walks every record once, looking for a Formula record immediately followed by a ShrFmla or Array record ([MS-XLS] 2.1.7.20.6's own FORMULA production, and 984826cc/c6ee7512's own "this record is preceded by a single Formula record"), and returns the shared/array expression each one carries, keyed by that Formula record's own cell -- the same (row, column) a PtgExp token names when it points back to this group (see readPtgExpBase, and readFormula below which performs the actual lookup).
+*
+* Built as a single upfront pass over the whole sheet rather than interleaved into readSheetRecords' own per-record loop: every Formula record that uses a shared/array formula (including the group's own base cell, which points at itself) needs this map already complete when it is reached, and although [MS-XLS] guarantees the base pair precedes every other use, resolving the whole map first removes that ordering as a correctness dependency rather than merely relying on it.
+*/
+function collectFormulaGroups(records) {
+	const groups = /* @__PURE__ */ new Map();
+	for (let index = 0; index < records.length; index += 1) {
+		const record = records[index];
+		const next = records[index + 1];
+		if (record === void 0 || next === void 0) continue;
+		if (record.type !== 6) continue;
+		if (next.type === 1212) collectFormulaGroup(groups, record, next, readShrFmlaGroup);
+		else if (next.type === 545) collectFormulaGroup(groups, record, next, readArrayGroup);
+	}
+	return groups;
+}
+/**
+* Reads one shared/array formula group and keys it by its base Formula record's own cell, degrading a malformed ShrFmla/Array record to "no group recovered for this base cell" rather than letting a BiffFormatError propagate out of collectFormulaGroups and abort the whole sheet read (and every other cell in it, formula or not). readCellHeader and readGroup (readShrFmlaGroup or readArrayGroup) between them make several cursor reads capable of raising that error, not only the final `cursor.take(cce)` that copies out rgce itself: an undersized record already runs out of bytes during readCellHeader's own Cell fields, or during readShrFmlaGroup/readArrayGroup's leading `cursor.skip` past their fixed header, or during the `cursor.u16()` that reads cce -- every one of those, like the `take`, is a plain read past this record's own declared bytes, and every one is caught here the same way. This is the same per-record boundary readSupBookSafely already draws for a malformed SupBook (workbook/globals.ts): before this reader ever walked a ShrFmla/Array record's own length fields, a malformed one had nothing here to trip over, so this is entirely new territory the read-every-record-once contract now needs to hold against. A cell whose Formula record points at this base through a PtgExp then resolves to no formula text at all -- exactly the same outcome "leaves formula absent for a PtgExp whose base cell has no matching ShrFmla/Array group" already documents for a dangling reference, since from resolveFormulaText's own vantage point the two cases are indistinguishable.
+*/
+function collectFormulaGroup(groups, record, next, readGroup) {
+	try {
+		const header = readCellHeader(new require_biff_cursor.BlockCursor(record.blocks));
+		groups.set(groupKey(header.row, header.column), readGroup(next));
+	} catch (error) {
+		if (!(error instanceof require_biff_records.BiffFormatError)) throw error;
+	}
+}
+/** ShrFmla ([MS-XLS] 984826cc): a RefU range (6 bytes, not needed here -- the group is looked up by its base cell's own coordinates, not by re-deriving them from this range), a reserved byte, a cUse byte, then a SharedParsedFormula (458bbec0): a two-byte cce and that many bytes of rgce. Its own rgce is forbidden from containing PtgArray ([MS-XLS] 458bbec0's own "MUST NOT contain... PtgArray"), so no rgcb is read here. */
+const SHRFMLA_HEADER_BYTES = 8;
+function readShrFmlaGroup(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	cursor.skip(SHRFMLA_HEADER_BYTES);
+	const cce = cursor.u16();
+	return {
+		kind: "shared",
+		rgce: cursor.take(cce)
+	};
+}
+/** Array ([MS-XLS] c6ee7512): a Ref range (6 bytes), a flags word (fAlwaysCalc plus reserved bits), four unused bytes, then an ArrayParsedFormula (242bcf20): a two-byte cce, that many bytes of rgce, and -- unlike ShrFmla's own SharedParsedFormula -- a real rgcb trailer, since an array formula's rgce CAN contain a PtgArray for an array-constant literal used within it (e.g. `{=A1:A3+{1;2;3}}`). rgcb's own length is never stated directly: it is whatever bytes remain in the record once the header and rgce are accounted for. */
+const ARRAY_HEADER_BYTES = 12;
+function readArrayGroup(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	cursor.skip(ARRAY_HEADER_BYTES);
+	const cce = cursor.u16();
+	const rgce = cursor.take(cce);
+	const rgcbLength = require_biff_substreams.recordByteLength(record) - (14 + cce);
+	if (rgcbLength <= 0) return {
+		kind: "array",
+		rgce,
+		rgcb: void 0
+	};
+	try {
+		return {
+			kind: "array",
+			rgce,
+			rgcb: cursor.take(rgcbLength)
+		};
+	} catch (error) {
+		if (!(error instanceof require_biff_records.BiffFormatError)) throw error;
+		return {
+			kind: "array",
+			rgce,
+			rgcb: void 0
+		};
+	}
+}
 /** Reads one worksheet substream's records. */
 function readSheetRecords(records, sharedStrings, formulaSheets = EMPTY_FORMULA_SHEET_CONTEXT) {
+	const formulaGroups = collectFormulaGroups(records);
 	const cells = [];
 	const rows = [];
 	const columns = [];
@@ -88,7 +161,7 @@ function readSheetRecords(records, sharedStrings, formulaSheets = EMPTY_FORMULA_
 				cells.push(readLabel(record));
 				break;
 			case 6:
-				cells.push(readFormula(record, stringResultAfter(records, index), formulaSheets));
+				cells.push(readFormula(record, stringResultAfter(records, index), formulaSheets, formulaGroups));
 				break;
 			case 161:
 				setup = readSetup(record);
@@ -345,7 +418,7 @@ function readMulRk(record) {
 }
 /** Both Mul records put colLast after their variable-length array, so the entry count follows from the record's own length: total = rw + colFirst + N*entry + colLast. */
 function mulEntryCount(record, entryBytes) {
-	const total = record.blocks.reduce((sum, block) => sum + block.length, 0);
+	const total = require_biff_substreams.recordByteLength(record);
 	const payload = total - MUL_FIXED_BYTES;
 	if (payload < 0 || payload % entryBytes !== 0) throw new require_biff_records.BiffFormatError(`multiple-cell record of ${total} bytes does not hold a whole number of ${entryBytes}-byte entries`);
 	return payload / entryBytes;
@@ -417,12 +490,14 @@ function readLabel(record) {
 /** The Formula record's own flags field ([MS-XLS] 2.4.127) and calculation cache, between the cached value and the compiled expression -- neither read for its own content; see the two-byte and four-byte skips in readFormula. */
 const FORMULA_FLAGS_BYTES = 2;
 const FORMULA_CALC_CACHE_BYTES = 4;
+/** The Cell (6 bytes) and FormulaValue (8 bytes) fields readFormula has already consumed by the time it reaches cce, plus the flags and calculation-cache fields above and the cce field itself (2 bytes) -- what's left of the record past `FORMULA_HEADER_BYTES + cce` is the CellParsedFormula's own rgcb trailer. */
+const FORMULA_HEADER_BYTES = 22;
 /**
-* Formula ([MS-XLS] 2.4.127): a Cell, an eight-byte FormulaValue, flags, a calculation cache, then a CellParsedFormula -- a two-byte cce followed by exactly that many bytes of compiled Ptg tokens ([MS-XLS] 2.5.198.3).
+* Formula ([MS-XLS] 2.4.127): a Cell, an eight-byte FormulaValue, flags, a calculation cache, then a CellParsedFormula -- a two-byte cce, that many bytes of compiled Ptg tokens ([MS-XLS] 2.5.198.3), and (whenever rgce contains a PtgArray -- an inline array-constant literal like `=SUM({1,2,3})`, unrelated to whether the cell itself is CSE-array-entered) an RgbExtra trailer of whatever bytes remain in the record.
 *
-* Both the cached value and the expression are read: the value from the FormulaValue exactly as before, and the expression by handing the token bytes to biff/ptg.ts's parseFormulaText, which resolves the whole Ptg vocabulary this reader supports and returns undefined for the constructs it does not (a shared formula, an array formula, a defined name, a natural-language reference, a genuinely external 3D reference -- see that module's own boundary). `formula` is attached only when it resolves; a cell it does not resolve for keeps exactly the behaviour this reader always had, its cached value present and `formula` absent.
+* Both the cached value and the expression are read: the value from the FormulaValue exactly as before, and the expression by resolveFormulaText below, which joins a lone PtgExp against the shared/array formula group collectFormulaGroups found for it and otherwise hands the token bytes straight to biff/ptg.ts's parseFormulaText. `formula` is attached only when it resolves; a cell it does not resolve for keeps exactly the behaviour this reader always had, its cached value present and `formula` absent.
 */
-function readFormula(record, next, formulaSheets) {
+function readFormula(record, next, formulaSheets, formulaGroups) {
 	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
 	const header = readCellHeader(cursor);
 	const bytes = cursor.take(8);
@@ -434,7 +509,18 @@ function readFormula(record, next, formulaSheets) {
 	cursor.skip(FORMULA_FLAGS_BYTES);
 	cursor.skip(FORMULA_CALC_CACHE_BYTES);
 	const cce = cursor.u16();
-	const formula = require_biff_ptg.parseFormulaText(cursor.take(cce), formulaSheets);
+	let rgce;
+	let rgcb;
+	try {
+		rgce = cursor.take(cce);
+		const rgcbLength = require_biff_substreams.recordByteLength(record) - (FORMULA_HEADER_BYTES + cce);
+		rgcb = rgcbLength > 0 ? cursor.take(rgcbLength) : void 0;
+	} catch (error) {
+		if (!(error instanceof require_biff_records.BiffFormatError)) throw error;
+		rgce = void 0;
+		rgcb = void 0;
+	}
+	const formula = rgce === void 0 ? void 0 : resolveFormulaText(rgce, rgcb, header, formulaSheets, formulaGroups);
 	return formula === void 0 ? {
 		...header,
 		value,
@@ -446,6 +532,23 @@ function readFormula(record, next, formulaSheets) {
 		formula
 	};
 }
+/**
+* A Formula record's rgce resolves one of three ways: a lone PtgExp pointing back to a shared-formula base cell, whose real expression (a ShrFmla's SharedParsedFormula) is expanded relative to THIS cell's own position; a lone PtgExp pointing back to an array-formula base cell, whose real expression (an Array's ArrayParsedFormula) is identical for every cell in the range and is returned as-is, with no CSE bracing (see ArrayFormulaGroup's own comment for why); or an ordinary rgce, handed to parseFormulaText as-is (with this record's own rgcb, for an inline array-constant literal). A PtgExp with no matching group -- a dangling or malformed reference this reader cannot join -- resolves to undefined exactly like any other unsupported construct.
+*
+* All three branches share the same hazard and are wrapped in one catch below: a token's own embedded length (a PtgStr's character count is the reachable case, [MS-XLS] 2.5.240's cch, read straight from the file with nothing to cross-check it against) can claim more bytes than the buffer parseFormulaText's cursor was actually handed, running that cursor past its end -- for the group-joining branches because `group.rgce` was extracted from a DIFFERENT, well-formed record whose own cce correctly bounds it, and for the ordinary-rgce branch because THIS record's own cce can just as easily be too short for the token it claims to end after (or a token inside an otherwise-correctly-bounded rgce can lie the same way `group.rgce`'s can). Neither case is a bug in this reader's own token walking; both are file-controlled malformed input, and left uncaught either would propagate out of readFormula and abort every other cell on the sheet along with the one cell whose formula this is -- exactly the failure collectFormulaGroup already prevents for a group whose OWN record is malformed, extended here to malformed token content reached through any of the three paths above.
+*/
+function resolveFormulaText(rgce, rgcb, header, formulaSheets, formulaGroups) {
+	const base = require_biff_ptg.readPtgExpBase(rgce);
+	try {
+		if (base === void 0) return require_biff_ptg.parseFormulaText(rgce, formulaSheets, { rgcb });
+		const group = formulaGroups.get(groupKey(base.row, base.column));
+		if (group === void 0) return;
+		return group.kind === "shared" ? require_biff_ptg.parseFormulaText(group.rgce, formulaSheets, { relativeTo: header }) : require_biff_ptg.parseFormulaText(group.rgce, formulaSheets, { rgcb: group.rgcb });
+	} catch (error) {
+		if (!(error instanceof require_biff_records.BiffFormatError)) throw error;
+		return;
+	}
+}
 /** The non-numeric readings of a FormulaValue ([MS-XLS] 2.5.133), selected by its first byte. */
 function taggedFormulaValue(view, next) {
 	switch (view.getUint8(0)) {

package/dist/workbook/sheet.d.cts

@@ -1,6 +1,6 @@
 import { n as SetupFields } from "../print-setup-B_ihDvm5.cjs";
-import { t as FormulaSheetContext } from "../ptg-B2K8t3js.cjs";
-import { t as RecordGroup } from "../substreams-Ddtvn_Vr.cjs";
+import { r as FormulaSheetContext } from "../ptg-CCBbJLZJ.cjs";
+import { t as RecordGroup } from "../substreams-Cpy5Fi3d.cjs";
 //#region src/workbook/sheet.d.ts
 /** A cell's value as its own record carries it, before number-format classification decides whether a number is really a date, a percentage, or an amount of money. */
 type RawCellValue = {
@@ -27,7 +27,7 @@ interface RawCell {
   readonly value: RawCellValue;
   /** True when the value is a Formula record's CACHED result rather than a literal. */
   readonly fromFormula: boolean;
-  /** The formula's own text, recovered from its compiled Ptg token stream ([MS-XLS] 2.5.198), when every token in it is one this reader resolves -- absent for a shared-formula member, an array formula, a defined-name or natural-language reference, or a 3D reference into a genuinely external workbook (see biff/ptg.ts). */
+  /** The formula's own text, recovered from its compiled Ptg token stream ([MS-XLS] 2.5.198), when every token in it is one this reader resolves -- absent for a defined-name or natural-language reference, or a data table (see biff/ptg.ts). */
   readonly formula?: string;
 }
 interface RawRow {

package/dist/workbook/sheet.d.ts

@@ -1,6 +1,6 @@
 import { n as SetupFields } from "../print-setup-B_ihDvm5.js";
-import { t as FormulaSheetContext } from "../ptg-B2K8t3js.js";
-import { t as RecordGroup } from "../substreams-D7dQiJbp.js";
+import { r as FormulaSheetContext } from "../ptg-CCBbJLZJ.js";
+import { t as RecordGroup } from "../substreams-CmyZMtuM.js";
 //#region src/workbook/sheet.d.ts
 /** A cell's value as its own record carries it, before number-format classification decides whether a number is really a date, a percentage, or an amount of money. */
 type RawCellValue = {
@@ -27,7 +27,7 @@ interface RawCell {
   readonly value: RawCellValue;
   /** True when the value is a Formula record's CACHED result rather than a literal. */
   readonly fromFormula: boolean;
-  /** The formula's own text, recovered from its compiled Ptg token stream ([MS-XLS] 2.5.198), when every token in it is one this reader resolves -- absent for a shared-formula member, an array formula, a defined-name or natural-language reference, or a 3D reference into a genuinely external workbook (see biff/ptg.ts). */
+  /** The formula's own text, recovered from its compiled Ptg token stream ([MS-XLS] 2.5.198), when every token in it is one this reader resolves -- absent for a defined-name or natural-language reference, or a data table (see biff/ptg.ts). */
   readonly formula?: string;
 }
 interface RawRow {

package/dist/workbook/sheet.js

@@ -2,10 +2,11 @@ import "../biff/record-types.js";
 import { BiffFormatError } from "../biff/records.js";
 import { columnWidthToPoints, inchesToPoints, twipsToPoints } from "../units.js";
 import { unpackSetupFlags } from "../biff/print-setup.js";
+import { recordByteLength } from "../biff/substreams.js";
 import { BlockCursor } from "../biff/cursor.js";
 import { readXLUnicodeString } from "../biff/strings.js";
 import { errorTextOf } from "../biff/errors.js";
-import { parseFormulaText } from "../biff/ptg.js";
+import { parseFormulaText, readPtgExpBase } from "../biff/ptg.js";
 import { decodeRkNumber } from "../biff/rk.js";
 //#region src/workbook/sheet.ts
 /** Row record flag bits, in the 32-bit field following unused1 ([MS-XLS] 2.4.221). */
@@ -30,8 +31,80 @@ const EMPTY_FORMULA_SHEET_CONTEXT = {
 	sheets: [],
 	sheetRanges: []
 };
+/** The key collectFormulaGroups and its lookup agree on: a shared/array formula group's own base cell, the same (row, column) a PtgExp token elsewhere in the sheet points back to. */
+function groupKey(row, column) {
+	return `${row},${column}`;
+}
+/**
+* Walks every record once, looking for a Formula record immediately followed by a ShrFmla or Array record ([MS-XLS] 2.1.7.20.6's own FORMULA production, and 984826cc/c6ee7512's own "this record is preceded by a single Formula record"), and returns the shared/array expression each one carries, keyed by that Formula record's own cell -- the same (row, column) a PtgExp token names when it points back to this group (see readPtgExpBase, and readFormula below which performs the actual lookup).
+*
+* Built as a single upfront pass over the whole sheet rather than interleaved into readSheetRecords' own per-record loop: every Formula record that uses a shared/array formula (including the group's own base cell, which points at itself) needs this map already complete when it is reached, and although [MS-XLS] guarantees the base pair precedes every other use, resolving the whole map first removes that ordering as a correctness dependency rather than merely relying on it.
+*/
+function collectFormulaGroups(records) {
+	const groups = /* @__PURE__ */ new Map();
+	for (let index = 0; index < records.length; index += 1) {
+		const record = records[index];
+		const next = records[index + 1];
+		if (record === void 0 || next === void 0) continue;
+		if (record.type !== 6) continue;
+		if (next.type === 1212) collectFormulaGroup(groups, record, next, readShrFmlaGroup);
+		else if (next.type === 545) collectFormulaGroup(groups, record, next, readArrayGroup);
+	}
+	return groups;
+}
+/**
+* Reads one shared/array formula group and keys it by its base Formula record's own cell, degrading a malformed ShrFmla/Array record to "no group recovered for this base cell" rather than letting a BiffFormatError propagate out of collectFormulaGroups and abort the whole sheet read (and every other cell in it, formula or not). readCellHeader and readGroup (readShrFmlaGroup or readArrayGroup) between them make several cursor reads capable of raising that error, not only the final `cursor.take(cce)` that copies out rgce itself: an undersized record already runs out of bytes during readCellHeader's own Cell fields, or during readShrFmlaGroup/readArrayGroup's leading `cursor.skip` past their fixed header, or during the `cursor.u16()` that reads cce -- every one of those, like the `take`, is a plain read past this record's own declared bytes, and every one is caught here the same way. This is the same per-record boundary readSupBookSafely already draws for a malformed SupBook (workbook/globals.ts): before this reader ever walked a ShrFmla/Array record's own length fields, a malformed one had nothing here to trip over, so this is entirely new territory the read-every-record-once contract now needs to hold against. A cell whose Formula record points at this base through a PtgExp then resolves to no formula text at all -- exactly the same outcome "leaves formula absent for a PtgExp whose base cell has no matching ShrFmla/Array group" already documents for a dangling reference, since from resolveFormulaText's own vantage point the two cases are indistinguishable.
+*/
+function collectFormulaGroup(groups, record, next, readGroup) {
+	try {
+		const header = readCellHeader(new BlockCursor(record.blocks));
+		groups.set(groupKey(header.row, header.column), readGroup(next));
+	} catch (error) {
+		if (!(error instanceof BiffFormatError)) throw error;
+	}
+}
+/** ShrFmla ([MS-XLS] 984826cc): a RefU range (6 bytes, not needed here -- the group is looked up by its base cell's own coordinates, not by re-deriving them from this range), a reserved byte, a cUse byte, then a SharedParsedFormula (458bbec0): a two-byte cce and that many bytes of rgce. Its own rgce is forbidden from containing PtgArray ([MS-XLS] 458bbec0's own "MUST NOT contain... PtgArray"), so no rgcb is read here. */
+const SHRFMLA_HEADER_BYTES = 8;
+function readShrFmlaGroup(record) {
+	const cursor = new BlockCursor(record.blocks);
+	cursor.skip(SHRFMLA_HEADER_BYTES);
+	const cce = cursor.u16();
+	return {
+		kind: "shared",
+		rgce: cursor.take(cce)
+	};
+}
+/** Array ([MS-XLS] c6ee7512): a Ref range (6 bytes), a flags word (fAlwaysCalc plus reserved bits), four unused bytes, then an ArrayParsedFormula (242bcf20): a two-byte cce, that many bytes of rgce, and -- unlike ShrFmla's own SharedParsedFormula -- a real rgcb trailer, since an array formula's rgce CAN contain a PtgArray for an array-constant literal used within it (e.g. `{=A1:A3+{1;2;3}}`). rgcb's own length is never stated directly: it is whatever bytes remain in the record once the header and rgce are accounted for. */
+const ARRAY_HEADER_BYTES = 12;
+function readArrayGroup(record) {
+	const cursor = new BlockCursor(record.blocks);
+	cursor.skip(ARRAY_HEADER_BYTES);
+	const cce = cursor.u16();
+	const rgce = cursor.take(cce);
+	const rgcbLength = recordByteLength(record) - (14 + cce);
+	if (rgcbLength <= 0) return {
+		kind: "array",
+		rgce,
+		rgcb: void 0
+	};
+	try {
+		return {
+			kind: "array",
+			rgce,
+			rgcb: cursor.take(rgcbLength)
+		};
+	} catch (error) {
+		if (!(error instanceof BiffFormatError)) throw error;
+		return {
+			kind: "array",
+			rgce,
+			rgcb: void 0
+		};
+	}
+}
 /** Reads one worksheet substream's records. */
 function readSheetRecords(records, sharedStrings, formulaSheets = EMPTY_FORMULA_SHEET_CONTEXT) {
+	const formulaGroups = collectFormulaGroups(records);
 	const cells = [];
 	const rows = [];
 	const columns = [];
@@ -87,7 +160,7 @@ function readSheetRecords(records, sharedStrings, formulaSheets = EMPTY_FORMULA_
 				cells.push(readLabel(record));
 				break;
 			case 6:
-				cells.push(readFormula(record, stringResultAfter(records, index), formulaSheets));
+				cells.push(readFormula(record, stringResultAfter(records, index), formulaSheets, formulaGroups));
 				break;
 			case 161:
 				setup = readSetup(record);
@@ -344,7 +417,7 @@ function readMulRk(record) {
 }
 /** Both Mul records put colLast after their variable-length array, so the entry count follows from the record's own length: total = rw + colFirst + N*entry + colLast. */
 function mulEntryCount(record, entryBytes) {
-	const total = record.blocks.reduce((sum, block) => sum + block.length, 0);
+	const total = recordByteLength(record);
 	const payload = total - MUL_FIXED_BYTES;
 	if (payload < 0 || payload % entryBytes !== 0) throw new BiffFormatError(`multiple-cell record of ${total} bytes does not hold a whole number of ${entryBytes}-byte entries`);
 	return payload / entryBytes;
@@ -416,12 +489,14 @@ function readLabel(record) {
 /** The Formula record's own flags field ([MS-XLS] 2.4.127) and calculation cache, between the cached value and the compiled expression -- neither read for its own content; see the two-byte and four-byte skips in readFormula. */
 const FORMULA_FLAGS_BYTES = 2;
 const FORMULA_CALC_CACHE_BYTES = 4;
+/** The Cell (6 bytes) and FormulaValue (8 bytes) fields readFormula has already consumed by the time it reaches cce, plus the flags and calculation-cache fields above and the cce field itself (2 bytes) -- what's left of the record past `FORMULA_HEADER_BYTES + cce` is the CellParsedFormula's own rgcb trailer. */
+const FORMULA_HEADER_BYTES = 22;
 /**
-* Formula ([MS-XLS] 2.4.127): a Cell, an eight-byte FormulaValue, flags, a calculation cache, then a CellParsedFormula -- a two-byte cce followed by exactly that many bytes of compiled Ptg tokens ([MS-XLS] 2.5.198.3).
+* Formula ([MS-XLS] 2.4.127): a Cell, an eight-byte FormulaValue, flags, a calculation cache, then a CellParsedFormula -- a two-byte cce, that many bytes of compiled Ptg tokens ([MS-XLS] 2.5.198.3), and (whenever rgce contains a PtgArray -- an inline array-constant literal like `=SUM({1,2,3})`, unrelated to whether the cell itself is CSE-array-entered) an RgbExtra trailer of whatever bytes remain in the record.
 *
-* Both the cached value and the expression are read: the value from the FormulaValue exactly as before, and the expression by handing the token bytes to biff/ptg.ts's parseFormulaText, which resolves the whole Ptg vocabulary this reader supports and returns undefined for the constructs it does not (a shared formula, an array formula, a defined name, a natural-language reference, a genuinely external 3D reference -- see that module's own boundary). `formula` is attached only when it resolves; a cell it does not resolve for keeps exactly the behaviour this reader always had, its cached value present and `formula` absent.
+* Both the cached value and the expression are read: the value from the FormulaValue exactly as before, and the expression by resolveFormulaText below, which joins a lone PtgExp against the shared/array formula group collectFormulaGroups found for it and otherwise hands the token bytes straight to biff/ptg.ts's parseFormulaText. `formula` is attached only when it resolves; a cell it does not resolve for keeps exactly the behaviour this reader always had, its cached value present and `formula` absent.
 */
-function readFormula(record, next, formulaSheets) {
+function readFormula(record, next, formulaSheets, formulaGroups) {
 	const cursor = new BlockCursor(record.blocks);
 	const header = readCellHeader(cursor);
 	const bytes = cursor.take(8);
@@ -433,7 +508,18 @@ function readFormula(record, next, formulaSheets) {
 	cursor.skip(FORMULA_FLAGS_BYTES);
 	cursor.skip(FORMULA_CALC_CACHE_BYTES);
 	const cce = cursor.u16();
-	const formula = parseFormulaText(cursor.take(cce), formulaSheets);
+	let rgce;
+	let rgcb;
+	try {
+		rgce = cursor.take(cce);
+		const rgcbLength = recordByteLength(record) - (FORMULA_HEADER_BYTES + cce);
+		rgcb = rgcbLength > 0 ? cursor.take(rgcbLength) : void 0;
+	} catch (error) {
+		if (!(error instanceof BiffFormatError)) throw error;
+		rgce = void 0;
+		rgcb = void 0;
+	}
+	const formula = rgce === void 0 ? void 0 : resolveFormulaText(rgce, rgcb, header, formulaSheets, formulaGroups);
 	return formula === void 0 ? {
 		...header,
 		value,
@@ -445,6 +531,23 @@ function readFormula(record, next, formulaSheets) {
 		formula
 	};
 }
+/**
+* A Formula record's rgce resolves one of three ways: a lone PtgExp pointing back to a shared-formula base cell, whose real expression (a ShrFmla's SharedParsedFormula) is expanded relative to THIS cell's own position; a lone PtgExp pointing back to an array-formula base cell, whose real expression (an Array's ArrayParsedFormula) is identical for every cell in the range and is returned as-is, with no CSE bracing (see ArrayFormulaGroup's own comment for why); or an ordinary rgce, handed to parseFormulaText as-is (with this record's own rgcb, for an inline array-constant literal). A PtgExp with no matching group -- a dangling or malformed reference this reader cannot join -- resolves to undefined exactly like any other unsupported construct.
+*
+* All three branches share the same hazard and are wrapped in one catch below: a token's own embedded length (a PtgStr's character count is the reachable case, [MS-XLS] 2.5.240's cch, read straight from the file with nothing to cross-check it against) can claim more bytes than the buffer parseFormulaText's cursor was actually handed, running that cursor past its end -- for the group-joining branches because `group.rgce` was extracted from a DIFFERENT, well-formed record whose own cce correctly bounds it, and for the ordinary-rgce branch because THIS record's own cce can just as easily be too short for the token it claims to end after (or a token inside an otherwise-correctly-bounded rgce can lie the same way `group.rgce`'s can). Neither case is a bug in this reader's own token walking; both are file-controlled malformed input, and left uncaught either would propagate out of readFormula and abort every other cell on the sheet along with the one cell whose formula this is -- exactly the failure collectFormulaGroup already prevents for a group whose OWN record is malformed, extended here to malformed token content reached through any of the three paths above.
+*/
+function resolveFormulaText(rgce, rgcb, header, formulaSheets, formulaGroups) {
+	const base = readPtgExpBase(rgce);
+	try {
+		if (base === void 0) return parseFormulaText(rgce, formulaSheets, { rgcb });
+		const group = formulaGroups.get(groupKey(base.row, base.column));
+		if (group === void 0) return;
+		return group.kind === "shared" ? parseFormulaText(group.rgce, formulaSheets, { relativeTo: header }) : parseFormulaText(group.rgce, formulaSheets, { rgcb: group.rgcb });
+	} catch (error) {
+		if (!(error instanceof BiffFormatError)) throw error;
+		return;
+	}
+}
 /** The non-numeric readings of a FormulaValue ([MS-XLS] 2.5.133), selected by its first byte. */
 function taggedFormulaValue(view, next) {
 	switch (view.getUint8(0)) {

package/dist/write.cjs

@@ -90,9 +90,18 @@ function buildPalettePlan(sheets) {
 		const hex = (0, document_schema_js.colorToRgbHex)(color);
 		if (!colorByHex.has(hex)) colorByHex.set(hex, color);
 	};
+	const recordFill = (fill) => {
+		if (fill === void 0) return;
+		if (fill.kind === "solid") {
+			record(fill.color);
+			return;
+		}
+		record(fill.foregroundColor);
+		record(fill.backgroundColor);
+	};
 	for (const sheet of sheets) for (const cell of sheet.cells) {
 		if (!require_written_cells.writesCellRecord(cell)) continue;
-		record(cell.background);
+		recordFill(cell.background);
 		record(cell.borders?.left?.color);
 		record(cell.borders?.right?.color);
 		record(cell.borders?.top?.color);
@@ -149,12 +158,36 @@ function resolveWriteEdge(border, icvOf) {
 		icv: icvOf(border.color)
 	};
 }
+/** A ContentCellFill's own fillPattern/fillForegroundIcv/fillBackgroundIcv triple, resolved for whichever of 'solid'/'pattern' the cell states -- undefined input resolves to FLSNULL with both colours Automatic, matching the pre-#951 undecorated case exactly. A 'pattern' fill leaving one of its own colours unstated writes that colour Automatic too, the inverse of xf-colors.ts's own resolveFillBackground treating an unresolvable icv the same way on read. */
+function resolveFillFields(fill, icvOf) {
+	if (fill === void 0) return {
+		fillPattern: 0,
+		fillForegroundIcv: 64,
+		fillBackgroundIcv: 65
+	};
+	switch (fill.kind) {
+		case "solid": return {
+			fillPattern: 1,
+			fillForegroundIcv: icvOf(fill.color),
+			fillBackgroundIcv: 65
+		};
+		case "pattern": {
+			const fillPattern = require_biff_xf_colors.PATTERN_TYPE_TO_FILL_PATTERN.get(fill.patternType);
+			if (fillPattern === void 0) throw new require_biff_write_errors.BiffWriteError(`xls-codec cannot write a '${fill.patternType}' cell fill: [MS-XLS]'s own FillPattern enumeration has no member for it, that pattern name belonging only to WordprocessingML's ST_Shd half of ContentCellPatternType's shared vocabulary`);
+			return {
+				fillPattern,
+				fillForegroundIcv: fill.foregroundColor === void 0 ? 64 : icvOf(fill.foregroundColor),
+				fillBackgroundIcv: fill.backgroundColor === void 0 ? 65 : icvOf(fill.backgroundColor)
+			};
+		}
+		default: throw new require_biff_write_errors.BiffWriteError(`xls-codec cannot write a cell fill with kind '${(0, document_schema_js.unrecognizedFillKind)(fill)}': ContentCellFillSchema's discriminated union only defines 'solid' and 'pattern'`);
+	}
+}
 /** A cell's own decoration, resolved into the raw XfDecorationFields the CellXF payload packs -- undefined for a cell with neither a background nor any border, so it shares the workbook's plain undecorated XF exactly as it did before decoration existed. The "has decoration at all" question is written-cells.ts's, since the writer's own record-emission predicate turns on the identical answer. */
 function resolveDecorationForCell(cell, icvOf) {
 	if (!require_written_cells.cellCarriesFormatting(cell)) return;
 	return {
-		fillPattern: cell.background === void 0 ? 0 : 1,
-		fillForegroundIcv: cell.background === void 0 ? 64 : icvOf(cell.background),
+		...resolveFillFields(cell.background, icvOf),
 		left: resolveWriteEdge(cell.borders?.left, icvOf),
 		right: resolveWriteEdge(cell.borders?.right, icvOf),
 		top: resolveWriteEdge(cell.borders?.top, icvOf),
@@ -165,7 +198,7 @@ function resolveDecorationForCell(cell, icvOf) {
 function signatureOfCellXf(formatId, alignment, verticalAlignment, decoration) {
 	let signature = `f${formatId}|a${alignment ?? ""}|v${verticalAlignment ?? ""}`;
 	if (decoration === void 0) return signature;
-	signature += `|p${decoration.fillPattern}:${decoration.fillForegroundIcv}|l${decoration.left.style}:${decoration.left.icv}|r${decoration.right.style}:${decoration.right.icv}|t${decoration.top.style}:${decoration.top.icv}|b${decoration.bottom.style}:${decoration.bottom.icv}`;
+	signature += `|p${decoration.fillPattern}:${decoration.fillForegroundIcv}:${decoration.fillBackgroundIcv}|l${decoration.left.style}:${decoration.left.icv}|r${decoration.right.style}:${decoration.right.icv}|t${decoration.top.style}:${decoration.top.icv}|b${decoration.bottom.style}:${decoration.bottom.icv}`;
 	return signature;
 }
 /**

package/dist/write.js

@@ -1,5 +1,5 @@
 import { SUMMARY_INFORMATION_STREAM } from "./container.js";
-import { DEFAULT_PALETTE_HEX_TO_ICV, borderStyleTokenFor } from "./biff/xf-colors.js";
+import { DEFAULT_PALETTE_HEX_TO_ICV, PATTERN_TYPE_TO_FILL_PATTERN, borderStyleTokenFor } from "./biff/xf-colors.js";
 import { BiffWriteError } from "./biff/write-errors.js";
 import { printNameEntriesFor } from "./workbook/print-names.js";
 import { layoutMetadataToSummaryInformation as layoutMetadataToSummaryInformation$1 } from "./metadata.js";
@@ -7,7 +7,7 @@ import { GENERAL_CELL_XF_INDEX, buildWorkbookGlobals } from "./workbook/globals-
 import { cellCarriesFormatting, writesCellRecord } from "./written-cells.js";
 import { buildWorksheetSubstream } from "./workbook/sheet-writer.js";
 import { hasSummaryInformationFields, writeCompoundFile, writeSummaryInformationStream } from "archive-codec";
-import { colorToRgbHex, flattenTree } from "document-schema.js";
+import { colorToRgbHex, flattenTree, unrecognizedFillKind } from "document-schema.js";
 import { BUILTIN_NUMBER_FORMATS } from "excel-number-format";
 //#region src/write.ts
 const WORKBOOK_STREAM_NAME = "Workbook";
@@ -89,9 +89,18 @@ function buildPalettePlan(sheets) {
 		const hex = colorToRgbHex(color);
 		if (!colorByHex.has(hex)) colorByHex.set(hex, color);
 	};
+	const recordFill = (fill) => {
+		if (fill === void 0) return;
+		if (fill.kind === "solid") {
+			record(fill.color);
+			return;
+		}
+		record(fill.foregroundColor);
+		record(fill.backgroundColor);
+	};
 	for (const sheet of sheets) for (const cell of sheet.cells) {
 		if (!writesCellRecord(cell)) continue;
-		record(cell.background);
+		recordFill(cell.background);
 		record(cell.borders?.left?.color);
 		record(cell.borders?.right?.color);
 		record(cell.borders?.top?.color);
@@ -148,12 +157,36 @@ function resolveWriteEdge(border, icvOf) {
 		icv: icvOf(border.color)
 	};
 }
+/** A ContentCellFill's own fillPattern/fillForegroundIcv/fillBackgroundIcv triple, resolved for whichever of 'solid'/'pattern' the cell states -- undefined input resolves to FLSNULL with both colours Automatic, matching the pre-#951 undecorated case exactly. A 'pattern' fill leaving one of its own colours unstated writes that colour Automatic too, the inverse of xf-colors.ts's own resolveFillBackground treating an unresolvable icv the same way on read. */
+function resolveFillFields(fill, icvOf) {
+	if (fill === void 0) return {
+		fillPattern: 0,
+		fillForegroundIcv: 64,
+		fillBackgroundIcv: 65
+	};
+	switch (fill.kind) {
+		case "solid": return {
+			fillPattern: 1,
+			fillForegroundIcv: icvOf(fill.color),
+			fillBackgroundIcv: 65
+		};
+		case "pattern": {
+			const fillPattern = PATTERN_TYPE_TO_FILL_PATTERN.get(fill.patternType);
+			if (fillPattern === void 0) throw new BiffWriteError(`xls-codec cannot write a '${fill.patternType}' cell fill: [MS-XLS]'s own FillPattern enumeration has no member for it, that pattern name belonging only to WordprocessingML's ST_Shd half of ContentCellPatternType's shared vocabulary`);
+			return {
+				fillPattern,
+				fillForegroundIcv: fill.foregroundColor === void 0 ? 64 : icvOf(fill.foregroundColor),
+				fillBackgroundIcv: fill.backgroundColor === void 0 ? 65 : icvOf(fill.backgroundColor)
+			};
+		}
+		default: throw new BiffWriteError(`xls-codec cannot write a cell fill with kind '${unrecognizedFillKind(fill)}': ContentCellFillSchema's discriminated union only defines 'solid' and 'pattern'`);
+	}
+}
 /** A cell's own decoration, resolved into the raw XfDecorationFields the CellXF payload packs -- undefined for a cell with neither a background nor any border, so it shares the workbook's plain undecorated XF exactly as it did before decoration existed. The "has decoration at all" question is written-cells.ts's, since the writer's own record-emission predicate turns on the identical answer. */
 function resolveDecorationForCell(cell, icvOf) {
 	if (!cellCarriesFormatting(cell)) return;
 	return {
-		fillPattern: cell.background === void 0 ? 0 : 1,
-		fillForegroundIcv: cell.background === void 0 ? 64 : icvOf(cell.background),
+		...resolveFillFields(cell.background, icvOf),
 		left: resolveWriteEdge(cell.borders?.left, icvOf),
 		right: resolveWriteEdge(cell.borders?.right, icvOf),
 		top: resolveWriteEdge(cell.borders?.top, icvOf),
@@ -164,7 +197,7 @@ function resolveDecorationForCell(cell, icvOf) {
 function signatureOfCellXf(formatId, alignment, verticalAlignment, decoration) {
 	let signature = `f${formatId}|a${alignment ?? ""}|v${verticalAlignment ?? ""}`;
 	if (decoration === void 0) return signature;
-	signature += `|p${decoration.fillPattern}:${decoration.fillForegroundIcv}|l${decoration.left.style}:${decoration.left.icv}|r${decoration.right.style}:${decoration.right.icv}|t${decoration.top.style}:${decoration.top.icv}|b${decoration.bottom.style}:${decoration.bottom.icv}`;
+	signature += `|p${decoration.fillPattern}:${decoration.fillForegroundIcv}:${decoration.fillBackgroundIcv}|l${decoration.left.style}:${decoration.left.icv}|r${decoration.right.style}:${decoration.right.icv}|t${decoration.top.style}:${decoration.top.icv}|b${decoration.bottom.style}:${decoration.bottom.icv}`;
 	return signature;
 }
 /**

package/dist/{xf-colors-CpykR3B9.d.ts → xf-colors--5oxSeI1.d.ts}

@@ -1,10 +1,12 @@
 import { t as BlockCursor } from "./cursor-VMtw9uVP.js";
-import { Alignment, Color, ContentBorder } from "document-schema.js";
+import { Alignment, Color, ContentBorder, ContentCellFill, ContentCellPatternType } from "document-schema.js";
 //#region src/biff/xf-colors.d.ts
 /** FLSNULL: no fill pattern -- the cell's fill colour fields carry no meaning. */
 declare const FILL_PATTERN_NONE = 0;
-/** FLSSOLID: a solid fill, the only pattern this package maps onto ContentSheetCell.background -- "If this value is 1 ... then only icvFore is rendered" ([MS-XLS] CellXF). Every other pattern (50%/75%/25% gray, the stripe and crosshatch families, ...) is a real information-loss case this reader does not approximate: see resolveFillBackground below. */
+/** FLSSOLID: a solid fill -- "If this value is 1 ... then only icvFore is rendered" ([MS-XLS] CellXF). */
 declare const FILL_PATTERN_SOLID = 1;
+/** The inverse of FILL_PATTERN_TO_PATTERN_TYPE, built from it rather than restated by hand so the two can never drift apart. Every ContentCellPatternType this package's own writer is ever asked to state has an entry, since the SpreadsheetML half of the shared vocabulary is exactly FILL_PATTERN_TO_PATTERN_TYPE's own value set -- the WordprocessingML-only members (the percentN family and the stripe/cross families ST_Shd names) are absent, FillPattern having no equivalent for them at all. */
+declare const PATTERN_TYPE_TO_FILL_PATTERN: ReadonlyMap<ContentCellPatternType, number>;
 /** alc (a CellXF/StyleXF payload's word1, bits 0-2) -> ContentSheetCell.alignment, or undefined for ALCGEN (the value-kind default this field being absent already requests) and for the three HorizAlign members (ALCFILL/ALCCONTCTR/ALCDIST) Alignment has no member for -- matching ooxml.js's readHorizontalAlignment policy of only the four direct members surviving. */
 declare function resolveHorizontalAlignment(alc: number): Alignment | undefined;
 /** ContentSheetCell.alignment -> the alc token to pack into word1 -- undefined maps to ALCGEN, the "use the value-kind default" token every genuinely unaligned cell already carried before this module modelled alignment at all. */
@@ -56,12 +58,17 @@ interface XfBorderEdge {
 declare function resolveBorderEdge(edge: XfBorderEdge, palette: readonly Color[] | undefined): ContentBorder | undefined;
 /** The inverse of resolveBorderEdge's style resolution: picks the BorderStyle token carrying a ContentBorder's own pattern at the closest named weight, bucketing a solid/dashed border's widthPt back to a weight through document-schema.js's own shared quantisation -- the same one resolveBorderEdge's widths came out of, and the same one ooxml.js's borderToXlsxStyle buckets xlsx's string tokens through. */
 declare function borderStyleTokenFor(border: ContentBorder): number;
-/** A solid fill's own foreground colour resolved to a real background, or undefined for every other FillPattern value -- FLSNULL (no fill at all) and every pattern beyond solid (50%/75%/25% gray, the stripe and crosshatch family) alike. A non-solid pattern is a real information-loss case rather than an oversight: ContentSheetCell.background models one flat colour, and approximating a striped or crosshatched fill as its foreground colour alone would misrepresent what the cell actually shows -- see xls-codec's README for this package's own stated judgment call. */
-declare function resolveFillBackground(fillPattern: number, foregroundIcv: number, palette: readonly Color[] | undefined): Color | undefined;
-/** Every decoration field the trailing payload's word2/word3/word4 carry ([MS-XLS] 2.4.353's own CellXF/StyleXF "Data" field), read or write side alike: which fill pattern (if any) and its foreground colour, and each of the four sides' own border style plus colour. Diagonal borders (dgDiag/grbitDiag/icvDiag) are out of this package's scope -- ContentCellBordersSchema has no diagonal member -- and are always read as absent / always written as none. */
+/**
+ * Resolves a cell's own FillPattern/icvFore/icvBack triple to a real ContentCellFill (ExaDev/documents.js#951), or undefined for FLSNULL (no fill at all), for a reserved/unrecognised FillPattern value, or for FLSSOLID when its own icvFore does not resolve to a fixed RGB value (an "Automatic" or otherwise unmapped icv, which leaves nothing to state a solid fill's colour as).
+ *
+ * FLSSOLID resolves to a 'solid' fill of icvFore alone -- "If this value is 1 ... then only icvFore is rendered" ([MS-XLS] CellXF), so icvBack carries no meaning for it and is never consulted. Every other named FillPattern resolves to a real 'pattern' fill via FILL_PATTERN_TO_PATTERN_TYPE, carrying whichever of icvFore/icvBack resolves to a real colour (either may be an "Automatic" icv this package cannot express as a fixed RGB value, matching ContentCellFillSchema's own "a colour can defer instead of asserting" convention).
+ */
+declare function resolveFillBackground(fillPattern: number, foregroundIcv: number, backgroundIcv: number, palette: readonly Color[] | undefined): ContentCellFill | undefined;
+/** Every decoration field the trailing payload's word2/word3/word4 carry ([MS-XLS] 2.4.353's own CellXF/StyleXF "Data" field), read or write side alike: which fill pattern (if any) and its foreground/background colours, and each of the four sides' own border style plus colour. fillBackgroundIcv carries no meaning for a solid fill (icvFore alone is rendered) but is real for every other named pattern, where it is the colour the pattern's gaps show through. Diagonal borders (dgDiag/grbitDiag/icvDiag) are out of this package's scope -- ContentCellBordersSchema has no diagonal member -- and are always read as absent / always written as none. */
 interface XfDecorationFields {
   readonly fillPattern: number;
   readonly fillForegroundIcv: number;
+  readonly fillBackgroundIcv: number;
   readonly left: XfBorderEdge;
   readonly right: XfBorderEdge;
   readonly top: XfBorderEdge;
@@ -88,4 +95,4 @@ declare function readLongRgbColor(cursor: BlockCursor): Color;
 /** The inverse of readLongRgbColor: a colour's own red/green/blue/reserved bytes, rounded to the nearest byte (the same rounding colorToRgbHex applies) -- exact for any colour this package itself constructed via rgbHexToColor, which is what write.ts's own palette-colour interning does. */
 declare function longRgbBytesOf(color: Color): readonly [number, number, number, number];
 //#endregion
-export { readLongRgbColor as A, XfAlignmentFields as C, horizAlignTokenFor as D, borderStyleTokenFor as E, resolveVerticalAlignment as F, unpackXfAlignment as I, unpackXfDecoration as L, resolveFillBackground as M, resolveHorizontalAlignment as N, longRgbBytesOf as O, resolveIcvColor as P, vertAlignTokenFor as R, UNDECORATED_XF_FIELDS as S, XfDecorationFields as T, FILL_PATTERN_SOLID as _, BORDER_STYLE_DOUBLE as a, PALETTE_BASE_ICV as b, BORDER_STYLE_MEDIUM_DASHDOT as c, BORDER_STYLE_NONE as d, BORDER_STYLE_SLANT_DASHDOT as f, FILL_PATTERN_NONE as g, DEFAULT_PALETTE_HEX_TO_ICV as h, BORDER_STYLE_DOTTED as i, resolveBorderEdge as j, packXfDecorationWords as k, BORDER_STYLE_MEDIUM_DASHDOTDOT as l, BORDER_STYLE_THIN as m, BORDER_STYLE_DASHDOTDOT as n, BORDER_STYLE_HAIR as o, BORDER_STYLE_THICK as p, BORDER_STYLE_DASHED as r, BORDER_STYLE_MEDIUM as s, BORDER_STYLE_DASHDOT as t, BORDER_STYLE_MEDIUM_DASHED as u, ICV_AUTOMATIC_BACKGROUND as v, XfBorderEdge as w, PALETTE_ENTRY_COUNT as x, ICV_AUTOMATIC_FOREGROUND as y };
+export { packXfDecorationWords as A, UNDECORATED_XF_FIELDS as C, borderStyleTokenFor as D, XfDecorationFields as E, resolveIcvColor as F, resolveVerticalAlignment as I, unpackXfAlignment as L, resolveBorderEdge as M, resolveFillBackground as N, horizAlignTokenFor as O, resolveHorizontalAlignment as P, unpackXfDecoration as R, PATTERN_TYPE_TO_FILL_PATTERN as S, XfBorderEdge as T, FILL_PATTERN_SOLID as _, BORDER_STYLE_DOUBLE as a, PALETTE_BASE_ICV as b, BORDER_STYLE_MEDIUM_DASHDOT as c, BORDER_STYLE_NONE as d, BORDER_STYLE_SLANT_DASHDOT as f, FILL_PATTERN_NONE as g, DEFAULT_PALETTE_HEX_TO_ICV as h, BORDER_STYLE_DOTTED as i, readLongRgbColor as j, longRgbBytesOf as k, BORDER_STYLE_MEDIUM_DASHDOTDOT as l, BORDER_STYLE_THIN as m, BORDER_STYLE_DASHDOTDOT as n, BORDER_STYLE_HAIR as o, BORDER_STYLE_THICK as p, BORDER_STYLE_DASHED as r, BORDER_STYLE_MEDIUM as s, BORDER_STYLE_DASHDOT as t, BORDER_STYLE_MEDIUM_DASHED as u, ICV_AUTOMATIC_BACKGROUND as v, XfAlignmentFields as w, PALETTE_ENTRY_COUNT as x, ICV_AUTOMATIC_FOREGROUND as y, vertAlignTokenFor as z };