xls-codec 0.0.0 → 1.0.0

package/dist/content.js

@@ -0,0 +1,228 @@
+import "./biff/record-types.js";
+import { BiffFormatError, readRecords } from "./biff/records.js";
+import { readWorkbookStream } from "./container.js";
+import { groupRecords, splitSubstreams } from "./biff/substreams.js";
+import { classifyNumberFormat } from "./number-format.js";
+import { serialToIsoDate, serialToIsoDateTime, serialToIsoTime } from "./serial.js";
+import { formatCodeOf, readWorkbookGlobals } from "./workbook/globals.js";
+import { readSheetRecords } from "./workbook/sheet.js";
+import { PAGE_SIZE_LETTER, assembleTree } from "document-schema.js";
+//#region src/content.ts
+/** Which BoundSheet8 dt values name a sheet this reader maps. 0x00 is a worksheet or dialog sheet; macro sheets, chart sheets, and VBA modules carry no cell table for ContentSheet to hold. */
+const SHEET_TYPE_WORKSHEET = 0;
+/**
+* Print settings this package emits rather than reads.
+*
+* ContentSheetPrintSettings makes pageSize, margins, gridlines, headers, and pageOrder REQUIRED, so a sheet cannot be produced without them, and BIFF8 spreads the real values across the Setup, LeftMargin/RightMargin/TopMargin/BottomMargin, PrintGrid, and PrintRowCol records plus a paper-size code table. None of those is read yet, so these are Excel's own documented "Normal" preset -- the same constants ooxml.js falls back to for an xlsx carrying no pageMargins element -- and they are honest defaults rather than the file's own settings. Reading the real ones is tracked as remaining scope rather than guessed at from unverified field offsets.
+*/
+const POINTS_PER_INCH = 72;
+const DEFAULT_PRINT_SETTINGS = {
+	pageSize: PAGE_SIZE_LETTER,
+	margins: {
+		topPt: .75 * POINTS_PER_INCH,
+		rightPt: .7 * POINTS_PER_INCH,
+		bottomPt: .75 * POINTS_PER_INCH,
+		leftPt: .7 * POINTS_PER_INCH
+	},
+	gridlines: false,
+	headers: false,
+	pageOrder: "downThenOver"
+};
+/**
+* Reads a .xls file's bytes into a ContentDocument.
+*
+* The counterpart of ooxml.js's readXlsxContent, producing the same shape from the older format.
+*/
+function readXlsContent(bytes) {
+	const substreams = splitSubstreams(groupRecords(readRecords(readWorkbookStream(bytes))));
+	const globalsSubstream = substreams[0];
+	if (globalsSubstream === void 0) throw new BiffFormatError("workbook stream holds no substreams, so it carries no globals substream");
+	if (globalsSubstream.records.some((rec) => rec.type === 47)) throw new BiffFormatError("workbook is encrypted (its globals substream carries a FilePass record); this reader does not decrypt");
+	const globals = readWorkbookGlobals(globalsSubstream.records);
+	return {
+		kind: "spreadsheet",
+		metadata: {},
+		sheets: globals.sheets.filter((entry) => entry.sheetType === SHEET_TYPE_WORKSHEET).map((entry) => readSheet(entry, substreams, globals))
+	};
+}
+/** The tree-form read: readXlsContent composed with the schema's own structural transform, exactly as ooxml.js's readXlsx wraps readXlsxContent. */
+function readXls(bytes) {
+	return assembleTree(readXlsContent(bytes));
+}
+/**
+* Locates a sheet's own substream and maps it.
+*
+* The substream is found by the byte offset BoundSheet8's lbPlyPos names, not by position: the order sheets appear in the workbook (which is BoundSheet8 order, and therefore the order of `globals.sheets`) is not required to match the order their substreams were written in. A sheet whose substream cannot be found still produces a ContentSheet, empty -- losing the sheet entirely would be a worse answer than losing its cells, since its name and position are real information the workbook did state.
+*/
+function readSheet(entry, substreams, globals) {
+	const substream = substreams.find((candidate) => candidate.offset === entry.bofPosition && candidate.documentType === 16);
+	const raw = substream === void 0 ? {
+		cells: [],
+		rows: [],
+		columns: [],
+		merges: []
+	} : readSheetRecords(substream.records, globals.sharedStrings);
+	return {
+		name: entry.name,
+		cells: mapCells(raw, globals),
+		columns: mapColumns(raw),
+		rows: mapRows(raw),
+		images: [],
+		printSettings: DEFAULT_PRINT_SETTINGS
+	};
+}
+function mapRows(raw) {
+	const rows = [];
+	for (const row of raw.rows) {
+		if (row.heightPt === void 0 && !row.hidden) continue;
+		const entry = { index: row.index };
+		if (row.heightPt !== void 0) entry.heightPt = row.heightPt;
+		if (row.hidden) entry.hidden = true;
+		rows.push(entry);
+	}
+	return rows;
+}
+function mapColumns(raw) {
+	const columns = [];
+	for (const column of raw.columns) {
+		if (column.widthPt === void 0 && !column.hidden) continue;
+		const entry = { index: column.index };
+		if (column.widthPt !== void 0) entry.widthPt = column.widthPt;
+		if (column.hidden) entry.hidden = true;
+		columns.push(entry);
+	}
+	return columns;
+}
+/** Maps the raw cells, then stamps merged-range spans onto their anchor cells. */
+function mapCells(raw, globals) {
+	const cells = [];
+	for (const cell of raw.cells) {
+		const mapped = mapCell(cell, globals);
+		if (mapped !== void 0) cells.push(mapped);
+	}
+	applyMerges(cells, raw);
+	return cells;
+}
+/**
+* Maps one raw cell, or drops it.
+*
+* A blank cell carrying no merge is dropped: ContentSheet's cell array is documented as sparse, holding only cells with something to show, and a Blank or MulBlank record states formatting this reader does not map yet. Dropping it keeps the array honest rather than filling a sheet with thousands of empty entries -- applyMerges below re-materialises the few blanks that anchor a merged range.
+*/
+function mapCell(cell, globals) {
+	if (cell.value.kind === "blank") return;
+	const formatCode = formatCodeOf(globals, cell.xfIndex);
+	const value = resolveValue(cell, formatCode, globals.date1904);
+	const mapped = {
+		row: cell.row,
+		column: cell.column,
+		value,
+		displayText: displayTextOf(value)
+	};
+	if (formatCode !== void 0) mapped.numberFormatCode = formatCode;
+	return mapped;
+}
+/**
+* Resolves a raw value into a ContentCellValue, classifying a number through its own format code.
+*
+* This is where BIFF8's lack of temporal and percentage cell types is undone: every date, time, percentage, and currency amount is stored as a bare number, and only the format its XF points at says which. A format naming a date the calendar does not have (the 1900 system's phantom leap day, or a negative serial) degrades to the plain number rather than emitting an invalid ISO string.
+*/
+function resolveValue(cell, formatCode, date1904) {
+	if (cell.value.kind === "blank") return { kind: "empty" };
+	if (cell.value.kind !== "number") return cell.value;
+	const num = cell.value.value;
+	if (formatCode === void 0) return {
+		kind: "number",
+		value: num
+	};
+	const format = classifyNumberFormat(formatCode);
+	switch (format.kind) {
+		case "percentage": return {
+			kind: "percentage",
+			value: num
+		};
+		case "currency": return format.code === void 0 ? {
+			kind: "currency",
+			value: num
+		} : {
+			kind: "currency",
+			value: num,
+			currency: format.code
+		};
+		case "date": {
+			const iso = serialToIsoDate(num, date1904);
+			return iso === void 0 ? {
+				kind: "number",
+				value: num
+			} : {
+				kind: "date",
+				value: iso
+			};
+		}
+		case "time": {
+			const iso = serialToIsoTime(num);
+			return iso === void 0 ? {
+				kind: "number",
+				value: num
+			} : {
+				kind: "time",
+				value: iso
+			};
+		}
+		case "dateTime": {
+			const iso = serialToIsoDateTime(num, date1904);
+			return iso === void 0 ? {
+				kind: "number",
+				value: num
+			} : {
+				kind: "dateTime",
+				value: iso
+			};
+		}
+		default: return {
+			kind: "number",
+			value: num
+		};
+	}
+}
+/** The typed value's own spelling, matching ooxml.js's derivation exactly so the same cell reads identically from either format. Deliberately not the producer's rendered string: this package classifies number formats but does not render through them. */
+function displayTextOf(value) {
+	switch (value.kind) {
+		case "number":
+		case "percentage":
+		case "currency": return String(value.value);
+		case "boolean": return value.value ? "TRUE" : "FALSE";
+		case "date":
+		case "time":
+		case "dateTime":
+		case "string":
+		case "error": return value.value;
+		case "empty": return "";
+		default: return "";
+	}
+}
+/**
+* Stamps each merged range's span onto its anchor cell, materialising an empty anchor when the range's top-left cell had no value of its own.
+*
+* ContentSheetCell documents colSpan/rowSpan as belonging to the anchor cell alone, and only when greater than one. A merged range whose anchor is blank is common -- merging cells in Excel keeps only the top-left value, and a range merged over an empty cell has no value anywhere -- so the anchor is created here rather than left absent, which would lose the merge entirely.
+*/
+function applyMerges(cells, raw) {
+	for (const range of raw.merges) {
+		const rowSpan = range.endRow - range.startRow + 1;
+		const colSpan = range.endColumn - range.startColumn + 1;
+		if (rowSpan <= 1 && colSpan <= 1) continue;
+		let anchor = cells.find((cell) => cell.row === range.startRow && cell.column === range.startColumn);
+		if (anchor === void 0) {
+			anchor = {
+				row: range.startRow,
+				column: range.startColumn,
+				value: { kind: "empty" },
+				displayText: ""
+			};
+			cells.push(anchor);
+		}
+		if (colSpan > 1) anchor.colSpan = colSpan;
+		if (rowSpan > 1) anchor.rowSpan = rowSpan;
+	}
+}
+//#endregion
+export { readXls, readXlsContent };

package/dist/index.cjs

@@ -0,0 +1,74 @@
+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_container = require("./container.cjs");
+const require_biff_substreams = require("./biff/substreams.cjs");
+const require_number_format = require("./number-format.cjs");
+const require_serial = require("./serial.cjs");
+const require_biff_cursor = require("./biff/cursor.cjs");
+const require_biff_strings = require("./biff/strings.cjs");
+const require_workbook_globals = require("./workbook/globals.cjs");
+const require_biff_errors = require("./biff/errors.cjs");
+const require_biff_rk = require("./biff/rk.cjs");
+const require_units = require("./units.cjs");
+const require_workbook_sheet = require("./workbook/sheet.cjs");
+const require_content = require("./content.cjs");
+exports.BIFF8_VERSION = require_biff_record_types.BIFF8_VERSION;
+exports.BOF_TYPE_CHART = require_biff_record_types.BOF_TYPE_CHART;
+exports.BOF_TYPE_MACRO = require_biff_record_types.BOF_TYPE_MACRO;
+exports.BOF_TYPE_WORKBOOK = require_biff_record_types.BOF_TYPE_WORKBOOK;
+exports.BOF_TYPE_WORKSHEET = require_biff_record_types.BOF_TYPE_WORKSHEET;
+exports.BUILTIN_NUMBER_FORMATS = require_number_format.BUILTIN_NUMBER_FORMATS;
+exports.BiffFormatError = require_biff_records.BiffFormatError;
+exports.BlockCursor = require_biff_cursor.BlockCursor;
+exports.MAX_RECORD_DATA_SIZE = require_biff_record_types.MAX_RECORD_DATA_SIZE;
+exports.RECORD_ARRAY = require_biff_record_types.RECORD_ARRAY;
+exports.RECORD_BLANK = require_biff_record_types.RECORD_BLANK;
+exports.RECORD_BOF = require_biff_record_types.RECORD_BOF;
+exports.RECORD_BOOLERR = require_biff_record_types.RECORD_BOOLERR;
+exports.RECORD_BOUNDSHEET8 = require_biff_record_types.RECORD_BOUNDSHEET8;
+exports.RECORD_COLINFO = require_biff_record_types.RECORD_COLINFO;
+exports.RECORD_CONTINUE = require_biff_record_types.RECORD_CONTINUE;
+exports.RECORD_DATE1904 = require_biff_record_types.RECORD_DATE1904;
+exports.RECORD_DEFAULTROWHEIGHT = require_biff_record_types.RECORD_DEFAULTROWHEIGHT;
+exports.RECORD_DEFCOLWIDTH = require_biff_record_types.RECORD_DEFCOLWIDTH;
+exports.RECORD_DIMENSIONS = require_biff_record_types.RECORD_DIMENSIONS;
+exports.RECORD_EOF = require_biff_record_types.RECORD_EOF;
+exports.RECORD_FILEPASS = require_biff_record_types.RECORD_FILEPASS;
+exports.RECORD_FONT = require_biff_record_types.RECORD_FONT;
+exports.RECORD_FORMAT = require_biff_record_types.RECORD_FORMAT;
+exports.RECORD_FORMULA = require_biff_record_types.RECORD_FORMULA;
+exports.RECORD_LABEL = require_biff_record_types.RECORD_LABEL;
+exports.RECORD_LABELSST = require_biff_record_types.RECORD_LABELSST;
+exports.RECORD_MERGECELLS = require_biff_record_types.RECORD_MERGECELLS;
+exports.RECORD_MULBLANK = require_biff_record_types.RECORD_MULBLANK;
+exports.RECORD_MULRK = require_biff_record_types.RECORD_MULRK;
+exports.RECORD_NUMBER = require_biff_record_types.RECORD_NUMBER;
+exports.RECORD_RK = require_biff_record_types.RECORD_RK;
+exports.RECORD_ROW = require_biff_record_types.RECORD_ROW;
+exports.RECORD_SHRFMLA = require_biff_record_types.RECORD_SHRFMLA;
+exports.RECORD_SST = require_biff_record_types.RECORD_SST;
+exports.RECORD_STRING = require_biff_record_types.RECORD_STRING;
+exports.RECORD_TABLE = require_biff_record_types.RECORD_TABLE;
+exports.RECORD_XF = require_biff_record_types.RECORD_XF;
+exports.classifyNumberFormat = require_number_format.classifyNumberFormat;
+exports.columnWidthToPoints = require_units.columnWidthToPoints;
+exports.decodeRkNumber = require_biff_rk.decodeRkNumber;
+exports.errorTextOf = require_biff_errors.errorTextOf;
+exports.formatCodeOf = require_workbook_globals.formatCodeOf;
+exports.groupRecords = require_biff_substreams.groupRecords;
+exports.isXlsFile = require_container.isXlsFile;
+exports.readRecords = require_biff_records.readRecords;
+exports.readRichExtendedString = require_biff_strings.readRichExtendedString;
+exports.readSheetRecords = require_workbook_sheet.readSheetRecords;
+exports.readShortXLUnicodeString = require_biff_strings.readShortXLUnicodeString;
+exports.readWorkbookGlobals = require_workbook_globals.readWorkbookGlobals;
+exports.readWorkbookStream = require_container.readWorkbookStream;
+exports.readXLUnicodeString = require_biff_strings.readXLUnicodeString;
+exports.readXls = require_content.readXls;
+exports.readXlsContent = require_content.readXlsContent;
+exports.serialToIsoDate = require_serial.serialToIsoDate;
+exports.serialToIsoDateTime = require_serial.serialToIsoDateTime;
+exports.serialToIsoTime = require_serial.serialToIsoTime;
+exports.splitSubstreams = require_biff_substreams.splitSubstreams;
+exports.twipsToPoints = require_units.twipsToPoints;

package/dist/index.d.cts

@@ -0,0 +1,15 @@
+import { BlockCursor } from "./biff/cursor.cjs";
+import { errorTextOf } from "./biff/errors.cjs";
+import { BIFF8_VERSION, BOF_TYPE_CHART, BOF_TYPE_MACRO, BOF_TYPE_WORKBOOK, BOF_TYPE_WORKSHEET, MAX_RECORD_DATA_SIZE, RECORD_ARRAY, RECORD_BLANK, RECORD_BOF, RECORD_BOOLERR, RECORD_BOUNDSHEET8, RECORD_COLINFO, RECORD_CONTINUE, RECORD_DATE1904, RECORD_DEFAULTROWHEIGHT, RECORD_DEFCOLWIDTH, RECORD_DIMENSIONS, RECORD_EOF, RECORD_FILEPASS, RECORD_FONT, RECORD_FORMAT, RECORD_FORMULA, RECORD_LABEL, RECORD_LABELSST, RECORD_MERGECELLS, RECORD_MULBLANK, RECORD_MULRK, RECORD_NUMBER, RECORD_RK, RECORD_ROW, RECORD_SHRFMLA, RECORD_SST, RECORD_STRING, RECORD_TABLE, RECORD_XF } from "./biff/record-types.cjs";
+import { n as BiffRecord, r as readRecords, t as BiffFormatError } from "./records-DVIqXFKk.cjs";
+import { decodeRkNumber } from "./biff/rk.cjs";
+import { readRichExtendedString, readShortXLUnicodeString, readXLUnicodeString } from "./biff/strings.cjs";
+import { RecordGroup, Substream, groupRecords, splitSubstreams } from "./biff/substreams.cjs";
+import { isXlsFile, readWorkbookStream } from "./container.cjs";
+import { XlsContentDocument, readXls, readXlsContent } from "./content.cjs";
+import { BUILTIN_NUMBER_FORMATS, NumberFormatClass, classifyNumberFormat } from "./number-format.cjs";
+import { serialToIsoDate, serialToIsoDateTime, serialToIsoTime } from "./serial.cjs";
+import { columnWidthToPoints, twipsToPoints } from "./units.cjs";
+import { CellFormat, SheetEntry, WorkbookGlobals, formatCodeOf, readWorkbookGlobals } from "./workbook/globals.cjs";
+import { RawCell, RawCellValue, RawColumn, RawRange, RawRow, RawSheet, readSheetRecords } from "./workbook/sheet.cjs";
+export { BIFF8_VERSION, BOF_TYPE_CHART, BOF_TYPE_MACRO, BOF_TYPE_WORKBOOK, BOF_TYPE_WORKSHEET, BUILTIN_NUMBER_FORMATS, BiffFormatError, BiffRecord, BlockCursor, CellFormat, MAX_RECORD_DATA_SIZE, NumberFormatClass, RECORD_ARRAY, RECORD_BLANK, RECORD_BOF, RECORD_BOOLERR, RECORD_BOUNDSHEET8, RECORD_COLINFO, RECORD_CONTINUE, RECORD_DATE1904, RECORD_DEFAULTROWHEIGHT, RECORD_DEFCOLWIDTH, RECORD_DIMENSIONS, RECORD_EOF, RECORD_FILEPASS, RECORD_FONT, RECORD_FORMAT, RECORD_FORMULA, RECORD_LABEL, RECORD_LABELSST, RECORD_MERGECELLS, RECORD_MULBLANK, RECORD_MULRK, RECORD_NUMBER, RECORD_RK, RECORD_ROW, RECORD_SHRFMLA, RECORD_SST, RECORD_STRING, RECORD_TABLE, RECORD_XF, RawCell, RawCellValue, RawColumn, RawRange, RawRow, RawSheet, RecordGroup, SheetEntry, Substream, WorkbookGlobals, XlsContentDocument, classifyNumberFormat, columnWidthToPoints, decodeRkNumber, errorTextOf, formatCodeOf, groupRecords, isXlsFile, readRecords, readRichExtendedString, readSheetRecords, readShortXLUnicodeString, readWorkbookGlobals, readWorkbookStream, readXLUnicodeString, readXls, readXlsContent, serialToIsoDate, serialToIsoDateTime, serialToIsoTime, splitSubstreams, twipsToPoints };

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { BlockCursor } from "./biff/cursor.js";
+import { errorTextOf } from "./biff/errors.js";
+import { BIFF8_VERSION, BOF_TYPE_CHART, BOF_TYPE_MACRO, BOF_TYPE_WORKBOOK, BOF_TYPE_WORKSHEET, MAX_RECORD_DATA_SIZE, RECORD_ARRAY, RECORD_BLANK, RECORD_BOF, RECORD_BOOLERR, RECORD_BOUNDSHEET8, RECORD_COLINFO, RECORD_CONTINUE, RECORD_DATE1904, RECORD_DEFAULTROWHEIGHT, RECORD_DEFCOLWIDTH, RECORD_DIMENSIONS, RECORD_EOF, RECORD_FILEPASS, RECORD_FONT, RECORD_FORMAT, RECORD_FORMULA, RECORD_LABEL, RECORD_LABELSST, RECORD_MERGECELLS, RECORD_MULBLANK, RECORD_MULRK, RECORD_NUMBER, RECORD_RK, RECORD_ROW, RECORD_SHRFMLA, RECORD_SST, RECORD_STRING, RECORD_TABLE, RECORD_XF } from "./biff/record-types.js";
+import { n as BiffRecord, r as readRecords, t as BiffFormatError } from "./records-DVIqXFKk.js";
+import { decodeRkNumber } from "./biff/rk.js";
+import { readRichExtendedString, readShortXLUnicodeString, readXLUnicodeString } from "./biff/strings.js";
+import { RecordGroup, Substream, groupRecords, splitSubstreams } from "./biff/substreams.js";
+import { isXlsFile, readWorkbookStream } from "./container.js";
+import { XlsContentDocument, readXls, readXlsContent } from "./content.js";
+import { BUILTIN_NUMBER_FORMATS, NumberFormatClass, classifyNumberFormat } from "./number-format.js";
+import { serialToIsoDate, serialToIsoDateTime, serialToIsoTime } from "./serial.js";
+import { columnWidthToPoints, twipsToPoints } from "./units.js";
+import { CellFormat, SheetEntry, WorkbookGlobals, formatCodeOf, readWorkbookGlobals } from "./workbook/globals.js";
+import { RawCell, RawCellValue, RawColumn, RawRange, RawRow, RawSheet, readSheetRecords } from "./workbook/sheet.js";
+export { BIFF8_VERSION, BOF_TYPE_CHART, BOF_TYPE_MACRO, BOF_TYPE_WORKBOOK, BOF_TYPE_WORKSHEET, BUILTIN_NUMBER_FORMATS, BiffFormatError, BiffRecord, BlockCursor, CellFormat, MAX_RECORD_DATA_SIZE, NumberFormatClass, RECORD_ARRAY, RECORD_BLANK, RECORD_BOF, RECORD_BOOLERR, RECORD_BOUNDSHEET8, RECORD_COLINFO, RECORD_CONTINUE, RECORD_DATE1904, RECORD_DEFAULTROWHEIGHT, RECORD_DEFCOLWIDTH, RECORD_DIMENSIONS, RECORD_EOF, RECORD_FILEPASS, RECORD_FONT, RECORD_FORMAT, RECORD_FORMULA, RECORD_LABEL, RECORD_LABELSST, RECORD_MERGECELLS, RECORD_MULBLANK, RECORD_MULRK, RECORD_NUMBER, RECORD_RK, RECORD_ROW, RECORD_SHRFMLA, RECORD_SST, RECORD_STRING, RECORD_TABLE, RECORD_XF, RawCell, RawCellValue, RawColumn, RawRange, RawRow, RawSheet, RecordGroup, SheetEntry, Substream, WorkbookGlobals, XlsContentDocument, classifyNumberFormat, columnWidthToPoints, decodeRkNumber, errorTextOf, formatCodeOf, groupRecords, isXlsFile, readRecords, readRichExtendedString, readSheetRecords, readShortXLUnicodeString, readWorkbookGlobals, readWorkbookStream, readXLUnicodeString, readXls, readXlsContent, serialToIsoDate, serialToIsoDateTime, serialToIsoTime, splitSubstreams, twipsToPoints };

package/dist/index.js

@@ -0,0 +1,15 @@
+import { BIFF8_VERSION, BOF_TYPE_CHART, BOF_TYPE_MACRO, BOF_TYPE_WORKBOOK, BOF_TYPE_WORKSHEET, MAX_RECORD_DATA_SIZE, RECORD_ARRAY, RECORD_BLANK, RECORD_BOF, RECORD_BOOLERR, RECORD_BOUNDSHEET8, RECORD_COLINFO, RECORD_CONTINUE, RECORD_DATE1904, RECORD_DEFAULTROWHEIGHT, RECORD_DEFCOLWIDTH, RECORD_DIMENSIONS, RECORD_EOF, RECORD_FILEPASS, RECORD_FONT, RECORD_FORMAT, RECORD_FORMULA, RECORD_LABEL, RECORD_LABELSST, RECORD_MERGECELLS, RECORD_MULBLANK, RECORD_MULRK, RECORD_NUMBER, RECORD_RK, RECORD_ROW, RECORD_SHRFMLA, RECORD_SST, RECORD_STRING, RECORD_TABLE, RECORD_XF } from "./biff/record-types.js";
+import { BiffFormatError, readRecords } from "./biff/records.js";
+import { isXlsFile, readWorkbookStream } from "./container.js";
+import { groupRecords, splitSubstreams } from "./biff/substreams.js";
+import { BUILTIN_NUMBER_FORMATS, classifyNumberFormat } from "./number-format.js";
+import { serialToIsoDate, serialToIsoDateTime, serialToIsoTime } from "./serial.js";
+import { BlockCursor } from "./biff/cursor.js";
+import { readRichExtendedString, readShortXLUnicodeString, readXLUnicodeString } from "./biff/strings.js";
+import { formatCodeOf, readWorkbookGlobals } from "./workbook/globals.js";
+import { errorTextOf } from "./biff/errors.js";
+import { decodeRkNumber } from "./biff/rk.js";
+import { columnWidthToPoints, twipsToPoints } from "./units.js";
+import { readSheetRecords } from "./workbook/sheet.js";
+import { readXls, readXlsContent } from "./content.js";
+export { BIFF8_VERSION, BOF_TYPE_CHART, BOF_TYPE_MACRO, BOF_TYPE_WORKBOOK, BOF_TYPE_WORKSHEET, BUILTIN_NUMBER_FORMATS, BiffFormatError, BlockCursor, MAX_RECORD_DATA_SIZE, RECORD_ARRAY, RECORD_BLANK, RECORD_BOF, RECORD_BOOLERR, RECORD_BOUNDSHEET8, RECORD_COLINFO, RECORD_CONTINUE, RECORD_DATE1904, RECORD_DEFAULTROWHEIGHT, RECORD_DEFCOLWIDTH, RECORD_DIMENSIONS, RECORD_EOF, RECORD_FILEPASS, RECORD_FONT, RECORD_FORMAT, RECORD_FORMULA, RECORD_LABEL, RECORD_LABELSST, RECORD_MERGECELLS, RECORD_MULBLANK, RECORD_MULRK, RECORD_NUMBER, RECORD_RK, RECORD_ROW, RECORD_SHRFMLA, RECORD_SST, RECORD_STRING, RECORD_TABLE, RECORD_XF, classifyNumberFormat, columnWidthToPoints, decodeRkNumber, errorTextOf, formatCodeOf, groupRecords, isXlsFile, readRecords, readRichExtendedString, readSheetRecords, readShortXLUnicodeString, readWorkbookGlobals, readWorkbookStream, readXLUnicodeString, readXls, readXlsContent, serialToIsoDate, serialToIsoDateTime, serialToIsoTime, splitSubstreams, twipsToPoints };

package/dist/number-format.cjs

@@ -0,0 +1,298 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/number-format.ts
+/** Excel honours at most four sections (positive; negative; zero; text); a fifth is malformed and is dropped rather than guessed at. */
+const MAX_SECTIONS = 4;
+/** Mirrors String.prototype.charAt's past-the-end contract, but over a CODE POINT array, so a rare astral currency symbol stays one token instead of splitting into two lone surrogates. */
+function at(chars, index) {
+	return chars[index] ?? "";
+}
+function tokenize(formatCode) {
+	const chars = [...formatCode];
+	const tokens = [];
+	let index = 0;
+	while (index < chars.length) {
+		const char = at(chars, index);
+		if (char === "\"") {
+			let text = "";
+			index += 1;
+			while (index < chars.length && at(chars, index) !== "\"") {
+				text += at(chars, index);
+				index += 1;
+			}
+			index += 1;
+			tokens.push({
+				kind: "literal",
+				text
+			});
+			continue;
+		}
+		if (char === "\\" || char === "_" || char === "*") {
+			tokens.push({
+				kind: "literal",
+				text: at(chars, index + 1)
+			});
+			index += 2;
+			continue;
+		}
+		if (char === "[") {
+			let body = "";
+			index += 1;
+			while (index < chars.length && at(chars, index) !== "]") {
+				body += at(chars, index);
+				index += 1;
+			}
+			index += 1;
+			tokens.push({
+				kind: "bracket",
+				body
+			});
+			continue;
+		}
+		if (char === ";") {
+			tokens.push({ kind: "separator" });
+			index += 1;
+			continue;
+		}
+		tokens.push({
+			kind: "code",
+			char
+		});
+		index += 1;
+	}
+	return tokens;
+}
+/** Splits on separator tokens only: a ';' inside a quote or bracket was already consumed as part of that token, so it can never split a section here. */
+function splitSections(tokens) {
+	const sections = [];
+	let current = [];
+	for (const token of tokens) {
+		if (token.kind === "separator") {
+			sections.push(current);
+			current = [];
+			continue;
+		}
+		current.push(token);
+	}
+	sections.push(current);
+	return sections.slice(0, MAX_SECTIONS);
+}
+/** The Unicode Currency_Symbol category IS the definition of "this character means money", so it is tested directly rather than against a hand-listed subset that would omit whichever symbol a real file happens to use. */
+const CURRENCY_SYMBOL = /\p{Sc}/u;
+/** `[$GBP-809]` carries an ISO 4217 code; `[$£-809]` carries a display symbol instead. Only the three-ASCII-letter shape counts as a code, because ContentCellValue's `currency` field is documented as the ISO code and there is no faithful symbol-to-code mapping ('$' alone is USD, CAD, AUD and a dozen others). */
+function isIsoCurrencyCodeShape(marker) {
+	if (marker.length !== 3) return false;
+	for (const char of marker) {
+		const upper = char.toUpperCase();
+		if (upper < "A" || upper > "Z") return false;
+	}
+	return true;
+}
+/** An elapsed-time bucket is a bracket holding one repeated h/m/s and nothing else -- the marker that the value is a DURATION, which may legitimately exceed 24 hours, rather than a time of day. */
+function isElapsedBracketBody(body) {
+	let letter;
+	for (const char of body) {
+		const lower = char.toLowerCase();
+		if (letter === void 0) {
+			if (lower !== "h" && lower !== "m" && lower !== "s") return false;
+			letter = lower;
+		} else if (lower !== letter) return false;
+	}
+	return letter !== void 0;
+}
+function classifyBracket(body) {
+	if (body.startsWith("$")) {
+		const rest = body.slice(1);
+		const dashIndex = rest.indexOf("-");
+		const marker = dashIndex === -1 ? rest : rest.slice(0, dashIndex);
+		if (marker === "") return { kind: "none" };
+		return isIsoCurrencyCodeShape(marker) ? {
+			kind: "currency",
+			code: marker.toUpperCase()
+		} : { kind: "currency" };
+	}
+	return isElapsedBracketBody(body) ? { kind: "elapsed" } : { kind: "none" };
+}
+const AMPM_MARKERS = ["am/pm", "a/p"];
+const AMPM_LETTER = "ampm";
+function matchesAt(chars, index, marker) {
+	return [...marker].every((char, offset) => at(chars, index + offset).toLowerCase() === char);
+}
+function codeRunsOf(section) {
+	const chars = [];
+	for (const token of section) if (token.kind === "code") chars.push(token.char);
+	const runs = [];
+	let index = 0;
+	while (index < chars.length) {
+		const marker = AMPM_MARKERS.find((candidate) => matchesAt(chars, index, candidate));
+		if (marker !== void 0) {
+			runs.push({
+				letter: AMPM_LETTER,
+				length: marker.length
+			});
+			index += marker.length;
+			continue;
+		}
+		const char = at(chars, index).toLowerCase();
+		let length = 0;
+		while (index + length < chars.length && at(chars, index + length).toLowerCase() === char) length += 1;
+		runs.push({
+			letter: char,
+			length
+		});
+		index += length;
+	}
+	return runs;
+}
+/** The letters an ambiguous 'm' looks past its neighbours for. 'm' itself is excluded: an unresolved 'm' carries no information for resolving another, so `hh:mm:mm` resolves both against the 'hh'. */
+const RESOLVING_LETTERS = [
+	"y",
+	"d",
+	"h",
+	"s"
+];
+function nearestResolvingLetter(runs, from, step) {
+	for (let index = from + step; index >= 0 && index < runs.length; index += step) {
+		const run = runs[index];
+		if (run !== void 0 && RESOLVING_LETTERS.includes(run.letter)) return run.letter;
+	}
+}
+/** Excel's minutes-vs-months rule: 'm'/'mm' is minutes when the nearest preceding date/time code is an hour or the nearest following one is a second, and a month otherwise. 'mmm' and longer are always month names. This is what makes `yyyy-mm-dd hh:mm:ss` resolve its two identical 'mm' runs oppositely. */
+function monthRunIsMinutes(runs, index) {
+	return nearestResolvingLetter(runs, index, -1) === "h" || nearestResolvingLetter(runs, index, 1) === "s";
+}
+const PLAIN_NUMBER = { kind: "number" };
+/** Digit placeholders ('0' required, '#' suppressed, '?' space-padded), the decimal and thousands separators. Scientific notation's 'e' is handled at its own run, since a bare 'e' also occurs inside the literal word "General". */
+const NUMERIC_CODES = [
+	"0",
+	"#",
+	"?",
+	".",
+	","
+];
+function collectSignals(section) {
+	const signals = {
+		hasDate: false,
+		hasTime: false,
+		hasElapsed: false,
+		hasPercent: false,
+		hasNumeric: false,
+		hasText: false,
+		hasCurrency: false
+	};
+	for (const token of section) {
+		if (token.kind === "literal" && CURRENCY_SYMBOL.test(token.text)) signals.hasCurrency = true;
+		if (token.kind === "bracket") {
+			const meaning = classifyBracket(token.body);
+			if (meaning.kind === "elapsed") signals.hasElapsed = true;
+			if (meaning.kind === "currency") {
+				signals.hasCurrency = true;
+				if (signals.currencyCode === void 0 && meaning.code !== void 0) signals.currencyCode = meaning.code;
+			}
+		}
+	}
+	const runs = codeRunsOf(section);
+	runs.forEach((run, index) => {
+		if (run.letter === "y" || run.letter === "d") {
+			signals.hasDate = true;
+			return;
+		}
+		if (run.letter === "h" || run.letter === "s" || run.letter === AMPM_LETTER) {
+			signals.hasTime = true;
+			return;
+		}
+		if (run.letter === "m") {
+			if (run.length <= 2 && monthRunIsMinutes(runs, index)) signals.hasTime = true;
+			else signals.hasDate = true;
+			return;
+		}
+		if (run.letter === "e") {
+			const next = runs[index + 1];
+			signals.hasNumeric = signals.hasNumeric || next?.letter === "+" || next?.letter === "-";
+			return;
+		}
+		if (run.letter === "%") {
+			signals.hasPercent = true;
+			return;
+		}
+		if (run.letter === "@") {
+			signals.hasText = true;
+			return;
+		}
+		if (NUMERIC_CODES.includes(run.letter)) {
+			signals.hasNumeric = true;
+			return;
+		}
+		if (CURRENCY_SYMBOL.test(run.letter)) signals.hasCurrency = true;
+	});
+	return signals;
+}
+/** Precedence when a format carries several signals at once, most specific first: an elapsed-time bracket beats everything (the only marker separating a duration from a time of day); any date code beats any time code (a format with both is a genuine combined date-and-time); a percent sign beats a currency marker (`[$GBP-809]0.00%` is still a percentage); and a text placeholder only wins when the section has no numeric placeholder to be a number with. */
+function classifySection(section) {
+	const signals = collectSignals(section);
+	if (signals.hasElapsed) return { kind: "elapsedTime" };
+	if (signals.hasDate) return signals.hasTime ? { kind: "dateTime" } : { kind: "date" };
+	if (signals.hasTime) return { kind: "time" };
+	if (signals.hasPercent) return { kind: "percentage" };
+	if (signals.hasCurrency) {
+		const code = signals.currencyCode;
+		return code === void 0 ? { kind: "currency" } : {
+			kind: "currency",
+			code
+		};
+	}
+	if (signals.hasText && !signals.hasNumeric) return { kind: "text" };
+	return PLAIN_NUMBER;
+}
+/** Classifies a format code, reading the FIRST section only. Sections two through four are the negative/zero/text renderings of the same underlying value: they differ in colour, parentheses, and literal text, never in what kind of thing the cell holds, and a cell whose value happens to be negative must not classify differently from the identical cell holding a positive one. */
+function classifyNumberFormat(formatCode) {
+	const first = splitSections(tokenize(formatCode))[0];
+	return first === void 0 ? PLAIN_NUMBER : classifySection(first);
+}
+/**
+* The built-in format codes, which a file never writes into its own Format records and every reader is expected to know.
+*
+* [MS-XLS] 2.4.126 constrains a Format record's own ifmt to 5-8, 23-26, 41-44, 63-66, and 164-382, so an XF pointing at any other identifier resolves through this table instead. The codes are ECMA-376 Part 1 SS18.8.30's table, which BIFF8 and xlsx share.
+*
+* Ids 23-36 are deliberately absent: that table leaves them reserved, and inventing codes for them would fabricate a mapping no specification defines -- an XF pointing at one resolves to no code at all, which the caller reports as absent rather than silently substituting General. These strings are fed through the SAME classifyNumberFormat as a producer-declared code, never a second table of pre-decided kinds, so the two feeds cannot drift apart.
+*/
+const BUILTIN_NUMBER_FORMATS = /* @__PURE__ */ new Map([
+	[0, "General"],
+	[1, "0"],
+	[2, "0.00"],
+	[3, "#,##0"],
+	[4, "#,##0.00"],
+	[5, "$#,##0_);($#,##0)"],
+	[6, "$#,##0_);[Red]($#,##0)"],
+	[7, "$#,##0.00_);($#,##0.00)"],
+	[8, "$#,##0.00_);[Red]($#,##0.00)"],
+	[9, "0%"],
+	[10, "0.00%"],
+	[11, "0.00E+00"],
+	[12, "# ?/?"],
+	[13, "# ??/??"],
+	[14, "mm-dd-yy"],
+	[15, "d-mmm-yy"],
+	[16, "d-mmm"],
+	[17, "mmm-yy"],
+	[18, "h:mm AM/PM"],
+	[19, "h:mm:ss AM/PM"],
+	[20, "h:mm"],
+	[21, "h:mm:ss"],
+	[22, "m/d/yy h:mm"],
+	[37, "#,##0 ;(#,##0)"],
+	[38, "#,##0 ;[Red](#,##0)"],
+	[39, "#,##0.00;(#,##0.00)"],
+	[40, "#,##0.00;[Red](#,##0.00)"],
+	[41, "_(* #,##0_);_(* \\(#,##0\\);_(* \"-\"_);_(@_)"],
+	[42, "_(\"$\"* #,##0_);_(\"$\"* \\(#,##0\\);_(\"$\"* \"-\"_);_(@_)"],
+	[43, "_(* #,##0.00_);_(* \\(#,##0.00\\);_(* \"-\"??_);_(@_)"],
+	[44, "_(\"$\"* #,##0.00_);_(\"$\"* \\(#,##0.00\\);_(\"$\"* \"-\"??_);_(@_)"],
+	[45, "mm:ss"],
+	[46, "[h]:mm:ss"],
+	[47, "mmss.0"],
+	[48, "##0.0E+0"],
+	[49, "@"]
+]);
+//#endregion
+exports.BUILTIN_NUMBER_FORMATS = BUILTIN_NUMBER_FORMATS;
+exports.classifyNumberFormat = classifyNumberFormat;