xls-codec 0.0.0 → 1.0.1

package/dist/workbook/globals.cjs

@@ -0,0 +1,106 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_biff_record_types = require("../biff/record-types.cjs");
+const require_biff_records = require("../biff/records.cjs");
+const require_number_format = require("../number-format.cjs");
+const require_biff_cursor = require("../biff/cursor.cjs");
+const require_biff_strings = require("../biff/strings.cjs");
+//#region src/workbook/globals.ts
+/** [MS-XLS] 2.4.28's own hsState values; 0x01 is Hidden and 0x02 Very Hidden. */
+const HIDDEN_STATE_MASK = 3;
+const HIDDEN_STATE_VISIBLE = 0;
+/** A cell format's fStyle bit within the XF record's third 16-bit field. */
+const XF_FLAG_STYLE = 4;
+/** An SST declaring more unique strings than the record could possibly carry is malformed; a string is at minimum three bytes (cch, flags) so this bounds the loop against the actual data. */
+const MIN_SST_ENTRY_BYTES = 3;
+/** Reads the globals substream's records into the tables the sheet reader needs. */
+function readWorkbookGlobals(records) {
+	const sheets = [];
+	const cellFormats = [];
+	const customFormats = /* @__PURE__ */ new Map();
+	let sharedStrings = [];
+	let date1904 = false;
+	for (const record of records) switch (record.type) {
+		case 133:
+			sheets.push(readBoundSheet(record));
+			break;
+		case 252:
+			sharedStrings = readSharedStrings(record);
+			break;
+		case require_biff_record_types.RECORD_FORMAT: {
+			const format = readFormat(record);
+			customFormats.set(format.id, format.code);
+			break;
+		}
+		case 224:
+			cellFormats.push(readCellFormat(record));
+			break;
+		case 34: date1904 = readDate1904(record);
+	}
+	const numberFormats = new Map(require_number_format.BUILTIN_NUMBER_FORMATS);
+	for (const [id, code] of customFormats) numberFormats.set(id, code);
+	return {
+		sheets,
+		sharedStrings,
+		cellFormats,
+		numberFormats,
+		date1904
+	};
+}
+/** BoundSheet8 ([MS-XLS] 2.4.28): a four-byte stream position, a byte of hidden state, a byte of sheet type, then the name as a ShortXLUnicodeString. */
+function readBoundSheet(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	const bofPosition = cursor.u32();
+	const state = cursor.u8();
+	const sheetType = cursor.u8();
+	return {
+		name: require_biff_strings.readShortXLUnicodeString(cursor),
+		hidden: (state & HIDDEN_STATE_MASK) !== HIDDEN_STATE_VISIBLE,
+		sheetType,
+		bofPosition
+	};
+}
+/** SST ([MS-XLS] 2.4.265): a total reference count, a unique-string count, then that many XLUnicodeRichExtendedStrings -- packed, with no offsets, so a single mis-sized string desynchronises every string after it. This is why the string reader consumes each one's trailing formatting-run and phonetic payloads exactly rather than ignoring them. */
+function readSharedStrings(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	cursor.i32();
+	const uniqueCount = cursor.i32();
+	if (uniqueCount < 0) throw new require_biff_records.BiffFormatError(`SST declares a negative unique-string count (${uniqueCount})`);
+	const totalBytes = record.blocks.reduce((sum, block) => sum + block.length, 0);
+	if (uniqueCount * MIN_SST_ENTRY_BYTES > totalBytes) throw new require_biff_records.BiffFormatError(`SST declares ${uniqueCount} unique strings, more than its ${totalBytes} bytes could carry`);
+	const strings = [];
+	for (let index = 0; index < uniqueCount; index += 1) strings.push(require_biff_strings.readRichExtendedString(cursor));
+	return strings;
+}
+/** Format ([MS-XLS] 2.4.126): a two-byte identifier then the format string as an XLUnicodeString. */
+function readFormat(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	return {
+		id: cursor.u16(),
+		code: require_biff_strings.readXLUnicodeString(cursor)
+	};
+}
+/** XF ([MS-XLS] 2.4.353): a font index, a number-format identifier, then a flags field whose fStyle bit says whether the trailing payload is a CellXF or a StyleXF. */
+function readCellFormat(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	return {
+		fontIndex: cursor.u16(),
+		formatId: cursor.u16(),
+		isStyle: (cursor.u16() & XF_FLAG_STYLE) !== 0
+	};
+}
+/** Date1904 ([MS-XLS] 2.4.77): a two-byte boolean. */
+function readDate1904(record) {
+	return new require_biff_cursor.BlockCursor(record.blocks).u16() !== 0;
+}
+/**
+* The number-format code a cell's own XF index resolves to, or undefined when it resolves to none.
+*
+* Undefined is a real answer rather than a failure: [MS-XLS] permits an XF to name a reserved identifier that no built-in code covers, and ContentSheetCell's own numberFormatCode is documented as absent for a cell with no producer-declared format -- never a fabricated empty string or a silently substituted General.
+*/
+function formatCodeOf(globals, xfIndex) {
+	const format = globals.cellFormats[xfIndex];
+	return format === void 0 ? void 0 : globals.numberFormats.get(format.formatId);
+}
+//#endregion
+exports.formatCodeOf = formatCodeOf;
+exports.readWorkbookGlobals = readWorkbookGlobals;

package/dist/workbook/globals.d.cts

@@ -0,0 +1,45 @@
+import { RecordGroup } from "../biff/substreams.cjs";
+//#region src/workbook/globals.d.ts
+/** One sheet, as its BoundSheet8 record describes it ([MS-XLS] 2.4.28). */
+interface SheetEntry {
+  /** The sheet's name, from stName. */
+  readonly name: string;
+  /** True for both the Hidden and Very Hidden states -- the schema's own ContentSheet has no place for either, so the distinction is not carried further. */
+  readonly hidden: boolean;
+  /** The dt field: 0x00 worksheet or dialog sheet, 0x01 macro sheet, 0x02 chart sheet, 0x06 VBA module. */
+  readonly sheetType: number;
+  /** lbPlyPos: the byte offset, within the workbook stream, of this sheet's own BOF record. */
+  readonly bofPosition: number;
+}
+/** One XF record's fixed prefix ([MS-XLS] 2.4.353). Only the fields the value path needs are carried: the trailing CellXF/StyleXF payload holds alignment, fill, and border properties whose colours are palette indices needing the Palette record to resolve, which this package does not yet read. */
+interface CellFormat {
+  /** ifnt: the index of the Font record this format uses. */
+  readonly fontIndex: number;
+  /** ifmt: the number-format identifier, resolved against the Format records and the built-in table. */
+  readonly formatId: number;
+  /** fStyle: true when this record describes a cell STYLE rather than a cell format. */
+  readonly isStyle: boolean;
+}
+/** Everything the globals substream contributes to reading the sheets that follow it. */
+interface WorkbookGlobals {
+  /** The sheets, in BoundSheet8 order -- which is the workbook's own tab order, and not necessarily the order the substreams appear in the stream. */
+  readonly sheets: readonly SheetEntry[];
+  /** The shared string table, indexed by a LabelSst record's isst. */
+  readonly sharedStrings: readonly string[];
+  /** The XF table, indexed by a cell's own ixfe. */
+  readonly cellFormats: readonly CellFormat[];
+  /** Number-format codes by identifier: the file's own Format records laid over the built-in table. */
+  readonly numberFormats: ReadonlyMap<number, string>;
+  /** Whether serials count from the 1904 epoch rather than the 1900 one ([MS-XLS] 2.4.77). */
+  readonly date1904: boolean;
+}
+/** Reads the globals substream's records into the tables the sheet reader needs. */
+declare function readWorkbookGlobals(records: readonly RecordGroup[]): WorkbookGlobals;
+/**
+ * The number-format code a cell's own XF index resolves to, or undefined when it resolves to none.
+ *
+ * Undefined is a real answer rather than a failure: [MS-XLS] permits an XF to name a reserved identifier that no built-in code covers, and ContentSheetCell's own numberFormatCode is documented as absent for a cell with no producer-declared format -- never a fabricated empty string or a silently substituted General.
+ */
+declare function formatCodeOf(globals: WorkbookGlobals, xfIndex: number): string | undefined;
+//#endregion
+export { CellFormat, SheetEntry, WorkbookGlobals, formatCodeOf, readWorkbookGlobals };

package/dist/workbook/globals.d.ts

@@ -0,0 +1,45 @@
+import { RecordGroup } from "../biff/substreams.js";
+//#region src/workbook/globals.d.ts
+/** One sheet, as its BoundSheet8 record describes it ([MS-XLS] 2.4.28). */
+interface SheetEntry {
+  /** The sheet's name, from stName. */
+  readonly name: string;
+  /** True for both the Hidden and Very Hidden states -- the schema's own ContentSheet has no place for either, so the distinction is not carried further. */
+  readonly hidden: boolean;
+  /** The dt field: 0x00 worksheet or dialog sheet, 0x01 macro sheet, 0x02 chart sheet, 0x06 VBA module. */
+  readonly sheetType: number;
+  /** lbPlyPos: the byte offset, within the workbook stream, of this sheet's own BOF record. */
+  readonly bofPosition: number;
+}
+/** One XF record's fixed prefix ([MS-XLS] 2.4.353). Only the fields the value path needs are carried: the trailing CellXF/StyleXF payload holds alignment, fill, and border properties whose colours are palette indices needing the Palette record to resolve, which this package does not yet read. */
+interface CellFormat {
+  /** ifnt: the index of the Font record this format uses. */
+  readonly fontIndex: number;
+  /** ifmt: the number-format identifier, resolved against the Format records and the built-in table. */
+  readonly formatId: number;
+  /** fStyle: true when this record describes a cell STYLE rather than a cell format. */
+  readonly isStyle: boolean;
+}
+/** Everything the globals substream contributes to reading the sheets that follow it. */
+interface WorkbookGlobals {
+  /** The sheets, in BoundSheet8 order -- which is the workbook's own tab order, and not necessarily the order the substreams appear in the stream. */
+  readonly sheets: readonly SheetEntry[];
+  /** The shared string table, indexed by a LabelSst record's isst. */
+  readonly sharedStrings: readonly string[];
+  /** The XF table, indexed by a cell's own ixfe. */
+  readonly cellFormats: readonly CellFormat[];
+  /** Number-format codes by identifier: the file's own Format records laid over the built-in table. */
+  readonly numberFormats: ReadonlyMap<number, string>;
+  /** Whether serials count from the 1904 epoch rather than the 1900 one ([MS-XLS] 2.4.77). */
+  readonly date1904: boolean;
+}
+/** Reads the globals substream's records into the tables the sheet reader needs. */
+declare function readWorkbookGlobals(records: readonly RecordGroup[]): WorkbookGlobals;
+/**
+ * The number-format code a cell's own XF index resolves to, or undefined when it resolves to none.
+ *
+ * Undefined is a real answer rather than a failure: [MS-XLS] permits an XF to name a reserved identifier that no built-in code covers, and ContentSheetCell's own numberFormatCode is documented as absent for a cell with no producer-declared format -- never a fabricated empty string or a silently substituted General.
+ */
+declare function formatCodeOf(globals: WorkbookGlobals, xfIndex: number): string | undefined;
+//#endregion
+export { CellFormat, SheetEntry, WorkbookGlobals, formatCodeOf, readWorkbookGlobals };

package/dist/workbook/globals.js

@@ -0,0 +1,104 @@
+import { RECORD_FORMAT } from "../biff/record-types.js";
+import { BiffFormatError } from "../biff/records.js";
+import { BUILTIN_NUMBER_FORMATS } from "../number-format.js";
+import { BlockCursor } from "../biff/cursor.js";
+import { readRichExtendedString, readShortXLUnicodeString, readXLUnicodeString } from "../biff/strings.js";
+//#region src/workbook/globals.ts
+/** [MS-XLS] 2.4.28's own hsState values; 0x01 is Hidden and 0x02 Very Hidden. */
+const HIDDEN_STATE_MASK = 3;
+const HIDDEN_STATE_VISIBLE = 0;
+/** A cell format's fStyle bit within the XF record's third 16-bit field. */
+const XF_FLAG_STYLE = 4;
+/** An SST declaring more unique strings than the record could possibly carry is malformed; a string is at minimum three bytes (cch, flags) so this bounds the loop against the actual data. */
+const MIN_SST_ENTRY_BYTES = 3;
+/** Reads the globals substream's records into the tables the sheet reader needs. */
+function readWorkbookGlobals(records) {
+	const sheets = [];
+	const cellFormats = [];
+	const customFormats = /* @__PURE__ */ new Map();
+	let sharedStrings = [];
+	let date1904 = false;
+	for (const record of records) switch (record.type) {
+		case 133:
+			sheets.push(readBoundSheet(record));
+			break;
+		case 252:
+			sharedStrings = readSharedStrings(record);
+			break;
+		case RECORD_FORMAT: {
+			const format = readFormat(record);
+			customFormats.set(format.id, format.code);
+			break;
+		}
+		case 224:
+			cellFormats.push(readCellFormat(record));
+			break;
+		case 34: date1904 = readDate1904(record);
+	}
+	const numberFormats = new Map(BUILTIN_NUMBER_FORMATS);
+	for (const [id, code] of customFormats) numberFormats.set(id, code);
+	return {
+		sheets,
+		sharedStrings,
+		cellFormats,
+		numberFormats,
+		date1904
+	};
+}
+/** BoundSheet8 ([MS-XLS] 2.4.28): a four-byte stream position, a byte of hidden state, a byte of sheet type, then the name as a ShortXLUnicodeString. */
+function readBoundSheet(record) {
+	const cursor = new BlockCursor(record.blocks);
+	const bofPosition = cursor.u32();
+	const state = cursor.u8();
+	const sheetType = cursor.u8();
+	return {
+		name: readShortXLUnicodeString(cursor),
+		hidden: (state & HIDDEN_STATE_MASK) !== HIDDEN_STATE_VISIBLE,
+		sheetType,
+		bofPosition
+	};
+}
+/** SST ([MS-XLS] 2.4.265): a total reference count, a unique-string count, then that many XLUnicodeRichExtendedStrings -- packed, with no offsets, so a single mis-sized string desynchronises every string after it. This is why the string reader consumes each one's trailing formatting-run and phonetic payloads exactly rather than ignoring them. */
+function readSharedStrings(record) {
+	const cursor = new BlockCursor(record.blocks);
+	cursor.i32();
+	const uniqueCount = cursor.i32();
+	if (uniqueCount < 0) throw new BiffFormatError(`SST declares a negative unique-string count (${uniqueCount})`);
+	const totalBytes = record.blocks.reduce((sum, block) => sum + block.length, 0);
+	if (uniqueCount * MIN_SST_ENTRY_BYTES > totalBytes) throw new BiffFormatError(`SST declares ${uniqueCount} unique strings, more than its ${totalBytes} bytes could carry`);
+	const strings = [];
+	for (let index = 0; index < uniqueCount; index += 1) strings.push(readRichExtendedString(cursor));
+	return strings;
+}
+/** Format ([MS-XLS] 2.4.126): a two-byte identifier then the format string as an XLUnicodeString. */
+function readFormat(record) {
+	const cursor = new BlockCursor(record.blocks);
+	return {
+		id: cursor.u16(),
+		code: readXLUnicodeString(cursor)
+	};
+}
+/** XF ([MS-XLS] 2.4.353): a font index, a number-format identifier, then a flags field whose fStyle bit says whether the trailing payload is a CellXF or a StyleXF. */
+function readCellFormat(record) {
+	const cursor = new BlockCursor(record.blocks);
+	return {
+		fontIndex: cursor.u16(),
+		formatId: cursor.u16(),
+		isStyle: (cursor.u16() & XF_FLAG_STYLE) !== 0
+	};
+}
+/** Date1904 ([MS-XLS] 2.4.77): a two-byte boolean. */
+function readDate1904(record) {
+	return new BlockCursor(record.blocks).u16() !== 0;
+}
+/**
+* The number-format code a cell's own XF index resolves to, or undefined when it resolves to none.
+*
+* Undefined is a real answer rather than a failure: [MS-XLS] permits an XF to name a reserved identifier that no built-in code covers, and ContentSheetCell's own numberFormatCode is documented as absent for a cell with no producer-declared format -- never a fabricated empty string or a silently substituted General.
+*/
+function formatCodeOf(globals, xfIndex) {
+	const format = globals.cellFormats[xfIndex];
+	return format === void 0 ? void 0 : globals.numberFormats.get(format.formatId);
+}
+//#endregion
+export { formatCodeOf, readWorkbookGlobals };

package/dist/workbook/sheet.cjs

@@ -0,0 +1,372 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../biff/record-types.cjs");
+const require_biff_records = require("../biff/records.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");
+const require_biff_rk = require("../biff/rk.cjs");
+const require_units = require("../units.cjs");
+//#region src/workbook/sheet.ts
+/** Row record flag bits, in the 32-bit field following unused1 ([MS-XLS] 2.4.221). */
+const ROW_FLAG_HIDDEN = 32;
+/** fUnsynced: the row height was set manually. When clear the height is the sheet default rather than a per-row declaration. */
+const ROW_FLAG_UNSYNCED = 64;
+/** ColInfo flag bits ([MS-XLS] 2.4.53). */
+const COLINFO_FLAG_HIDDEN = 1;
+/** A FormulaValue whose fExprO field is this is not an Xnum but a tagged non-numeric value ([MS-XLS] 2.5.133). */
+const FORMULA_VALUE_TAGGED = 65535;
+/** The tag byte's own vocabulary in that case. */
+const FORMULA_VALUE_STRING = 0;
+const FORMULA_VALUE_BOOLEAN = 1;
+const FORMULA_VALUE_ERROR = 2;
+const FORMULA_VALUE_BLANK = 3;
+/** MulRk carries rw, colFirst, N six-byte RkRecs, then colLast; MulBlank the same with two-byte ixfe entries. */
+const MUL_FIXED_BYTES = 6;
+const MULRK_ENTRY_BYTES = 6;
+const MULBLANK_ENTRY_BYTES = 2;
+/** Reads one worksheet substream's records. */
+function readSheetRecords(records, sharedStrings) {
+	const cells = [];
+	const rows = [];
+	const columns = [];
+	const merges = [];
+	let usedRange;
+	for (let index = 0; index < records.length; index += 1) {
+		const record = records[index];
+		if (record === void 0) continue;
+		switch (record.type) {
+			case 512:
+				usedRange = readDimensions(record);
+				break;
+			case 520:
+				rows.push(readRow(record));
+				break;
+			case 125:
+				columns.push(...readColInfo(record));
+				break;
+			case 229:
+				merges.push(...readMergeCells(record));
+				break;
+			case 513:
+				cells.push(readBlank(record));
+				break;
+			case 190:
+				cells.push(...readMulBlank(record));
+				break;
+			case 638:
+				cells.push(readRk(record));
+				break;
+			case 189:
+				cells.push(...readMulRk(record));
+				break;
+			case 515:
+				cells.push(readNumber(record));
+				break;
+			case 517: {
+				const cell = readBoolErr(record);
+				if (cell !== void 0) cells.push(cell);
+				break;
+			}
+			case 253:
+				cells.push(readLabelSst(record, sharedStrings));
+				break;
+			case 516:
+				cells.push(readLabel(record));
+				break;
+			case 6: cells.push(readFormula(record, stringResultAfter(records, index)));
+		}
+	}
+	return usedRange === void 0 ? {
+		cells,
+		rows,
+		columns,
+		merges
+	} : {
+		cells,
+		rows,
+		columns,
+		merges,
+		usedRange
+	};
+}
+/**
+* Finds the String record carrying a Formula's cached string result, if it has one.
+*
+* [MS-XLS] 2.5.133 says the String "immediately follows" the Formula, but the FORMULA production of [MS-XLS] 2.1.7.20.6 is wider than that -- `[Uncalced] Formula [Array / Table / ShrFmla / SUB] [String *Continue]` -- so an array formula, a data table, or a member of a shared-formula run puts one record in between. Skipping exactly those three finds the String in both shapes; anything else ends the search, so a Formula with no string result never reaches past its own cell into the next one's records.
+*/
+function stringResultAfter(records, formulaIndex) {
+	for (let index = formulaIndex + 1; index < records.length; index += 1) {
+		const candidate = records[index];
+		if (candidate === void 0) return;
+		if (candidate.type === 519) return candidate;
+		if (candidate.type !== 545 && candidate.type !== 566 && candidate.type !== 1212) return;
+	}
+}
+/** Dimensions ([MS-XLS] 2.4.90): a four-byte first row, a four-byte past-the-end row, a two-byte first column, and a two-byte past-the-end column. */
+function readDimensions(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	const rwMic = cursor.u32();
+	const rwMac = cursor.u32();
+	const colMic = cursor.u16();
+	const colMac = cursor.u16();
+	if (rwMac === 0 || colMac === 0) return;
+	return {
+		startRow: rwMic,
+		startColumn: colMic,
+		endRow: rwMac - 1,
+		endColumn: colMac - 1
+	};
+}
+/** Row ([MS-XLS] 2.4.221): sixteen bytes, of which this reader uses the index, the height, and the hidden and manually-set flags. */
+function readRow(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	const index = cursor.u16();
+	cursor.skip(4);
+	const heightTwips = cursor.u16();
+	cursor.skip(4);
+	const flags = cursor.u8();
+	const hidden = (flags & ROW_FLAG_HIDDEN) !== 0;
+	const declared = (flags & ROW_FLAG_UNSYNCED) !== 0;
+	const heightPt = require_units.twipsToPoints(heightTwips);
+	return declared && heightPt > 0 ? {
+		index,
+		heightPt,
+		hidden
+	} : {
+		index,
+		hidden
+	};
+}
+/** ColInfo ([MS-XLS] 2.4.53): one record covering an inclusive RANGE of columns, so it expands to one entry per column it names. */
+function readColInfo(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	const first = cursor.u16();
+	const last = cursor.u16();
+	const coldx = cursor.u16();
+	cursor.skip(2);
+	const hidden = (cursor.u16() & COLINFO_FLAG_HIDDEN) !== 0;
+	const widthPt = require_units.columnWidthToPoints(coldx);
+	const columns = [];
+	const end = Math.min(last, 255);
+	for (let index = first; index <= end; index += 1) columns.push(widthPt > 0 ? {
+		index,
+		widthPt,
+		hidden
+	} : {
+		index,
+		hidden
+	});
+	return columns;
+}
+/** MergeCells ([MS-XLS] 2.4.168): a count then that many Ref8 structures ([MS-XLS] 2.5.208), each an inclusive row and column range. */
+function readMergeCells(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	const count = cursor.u16();
+	const ranges = [];
+	for (let index = 0; index < count; index += 1) {
+		const startRow = cursor.u16();
+		const endRow = cursor.u16();
+		const startColumn = cursor.u16();
+		const endColumn = cursor.u16();
+		ranges.push({
+			startRow,
+			startColumn,
+			endRow,
+			endColumn
+		});
+	}
+	return ranges;
+}
+/** The Cell structure ([MS-XLS] 2.5.19) every single-cell record opens with. */
+function readCellHeader(cursor) {
+	return {
+		row: cursor.u16(),
+		column: cursor.u16(),
+		xfIndex: cursor.u16()
+	};
+}
+function readBlank(record) {
+	return {
+		...readCellHeader(new require_biff_cursor.BlockCursor(record.blocks)),
+		value: { kind: "blank" },
+		fromFormula: false
+	};
+}
+/** MulBlank ([MS-XLS] 2.4.174): a run of blank cells in one row, each with its own format index. The entry count is derived from the record's own length rather than from colLast, which sits AFTER the variable-length array. */
+function readMulBlank(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	const row = cursor.u16();
+	const first = cursor.u16();
+	const count = mulEntryCount(record, MULBLANK_ENTRY_BYTES);
+	const cells = [];
+	for (let offset = 0; offset < count; offset += 1) cells.push({
+		row,
+		column: first + offset,
+		xfIndex: cursor.u16(),
+		value: { kind: "blank" },
+		fromFormula: false
+	});
+	return cells;
+}
+function readRk(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	return {
+		row: cursor.u16(),
+		column: cursor.u16(),
+		xfIndex: cursor.u16(),
+		value: {
+			kind: "number",
+			value: require_biff_rk.decodeRkNumber(cursor.u32())
+		},
+		fromFormula: false
+	};
+}
+/** MulRk ([MS-XLS] 2.4.175): a run of RK-encoded numeric cells in one row, each an RkRec ([MS-XLS] 2.5.218) of a format index and an RK word. */
+function readMulRk(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	const row = cursor.u16();
+	const first = cursor.u16();
+	const count = mulEntryCount(record, MULRK_ENTRY_BYTES);
+	const cells = [];
+	for (let offset = 0; offset < count; offset += 1) {
+		const xfIndex = cursor.u16();
+		cells.push({
+			row,
+			column: first + offset,
+			xfIndex,
+			value: {
+				kind: "number",
+				value: require_biff_rk.decodeRkNumber(cursor.u32())
+			},
+			fromFormula: false
+		});
+	}
+	return cells;
+}
+/** 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 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;
+}
+function readNumber(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	return {
+		...readCellHeader(cursor),
+		value: {
+			kind: "number",
+			value: cursor.f64()
+		},
+		fromFormula: false
+	};
+}
+/** BoolErr ([MS-XLS] 2.4.24): a Cell then a Bes ([MS-XLS] 2.5.10), whose second byte says whether the first is a boolean or an error code. An error code the specification does not define yields no cell at all rather than a fabricated spelling. */
+function readBoolErr(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	const header = readCellHeader(cursor);
+	const value = cursor.u8();
+	if (!(cursor.u8() !== 0)) return {
+		...header,
+		value: {
+			kind: "boolean",
+			value: value !== 0
+		},
+		fromFormula: false
+	};
+	const text = require_biff_errors.errorTextOf(value);
+	return text === void 0 ? void 0 : {
+		...header,
+		value: {
+			kind: "error",
+			value: text
+		},
+		fromFormula: false
+	};
+}
+/** LabelSst ([MS-XLS] 2.4.149): a Cell then a four-byte index into the shared string table. An index the table does not hold yields an empty string rather than throwing, since one dangling index should not fail a whole workbook. */
+function readLabelSst(record, sharedStrings) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	const header = readCellHeader(cursor);
+	const index = cursor.u32();
+	return {
+		...header,
+		value: {
+			kind: "string",
+			value: sharedStrings[index] ?? ""
+		},
+		fromFormula: false
+	};
+}
+/**
+* Label ([MS-XLS] 2.4.148): a Cell then an inline XLUnicodeString.
+*
+* In BIFF8 proper a string cell is a LabelSst indexing the shared string table, and [MS-XLS] documents this record in its charting sense. It is read as a string cell anyway because the layout is identical either way and third-party producers -- and files converted up from BIFF5, where Label WAS the string cell record -- still emit it in a worksheet's cell table, where reading it costs nothing and skipping it would silently drop real text.
+*/
+function readLabel(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	return {
+		...readCellHeader(cursor),
+		value: {
+			kind: "string",
+			value: require_biff_strings.readXLUnicodeString(cursor)
+		},
+		fromFormula: false
+	};
+}
+/**
+* Formula ([MS-XLS] 2.4.127): a Cell, an eight-byte FormulaValue, flags, a calculation cache, then the compiled expression.
+*
+* Only the cached VALUE is read. The expression is a CellParsedFormula -- a compiled Ptg token stream rather than text -- and turning one back into a formula string means implementing the whole Ptg vocabulary plus shared-formula and external-reference resolution, which is its own substantial piece of work. So the cell's displayed value is correct and its `formula` field stays absent, rather than a plausible-looking expression being invented for it.
+*/
+function readFormula(record, next) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	const header = readCellHeader(cursor);
+	const bytes = cursor.take(8);
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	if (!(view.getUint16(6, true) === FORMULA_VALUE_TAGGED)) return {
+		...header,
+		value: {
+			kind: "number",
+			value: view.getFloat64(0, true)
+		},
+		fromFormula: true
+	};
+	return {
+		...header,
+		value: taggedFormulaValue(view, next),
+		fromFormula: true
+	};
+}
+/** 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)) {
+		case FORMULA_VALUE_STRING:
+			if (next?.type !== 519) return {
+				kind: "string",
+				value: ""
+			};
+			return {
+				kind: "string",
+				value: require_biff_strings.readXLUnicodeString(new require_biff_cursor.BlockCursor(next.blocks))
+			};
+		case FORMULA_VALUE_BOOLEAN: return {
+			kind: "boolean",
+			value: view.getUint8(2) !== 0
+		};
+		case FORMULA_VALUE_ERROR: {
+			const text = require_biff_errors.errorTextOf(view.getUint8(2));
+			return text === void 0 ? { kind: "blank" } : {
+				kind: "error",
+				value: text
+			};
+		}
+		case FORMULA_VALUE_BLANK: return {
+			kind: "string",
+			value: ""
+		};
+		default: return { kind: "blank" };
+	}
+}
+//#endregion
+exports.readSheetRecords = readSheetRecords;