xls-codec 0.0.0 → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joseph Mearman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,128 @@
+# xls-codec
+
+[![GitHub](https://img.shields.io/badge/GitHub-181717?logo=github&logoColor=white)](https://github.com/ExaDev/documents.js/tree/main/packages/xls-codec) [![npm](https://img.shields.io/badge/npm-CB3837?logo=npm&logoColor=white)](https://www.npmjs.com/package/xls-codec) [![npm version](https://img.shields.io/npm/v/xls-codec)](https://www.npmjs.com/package/xls-codec) [![CI](https://img.shields.io/github/actions/workflow/status/ExaDev/documents.js/ci.yml?branch=main)](https://github.com/ExaDev/documents.js/actions)
+
+> Hand-written reader for the legacy Excel Binary File Format (`.xls`, BIFF8) as specified by [MS-XLS], mapping a workbook's record stream onto the same `document-schema.js` spreadsheet model `ooxml.js`'s xlsx support and `odf.js`'s ods support target. Worker-isomorphic: the same code runs under Node and inside a Cloudflare Workers isolate.
+
+A `.xls` file is not one format but two nested ones. The outer container is an [MS-CFB] compound file — the same "filesystem in a file" that carries `.doc` and `.ppt` — holding a stream named `Workbook`. Inside that stream is BIFF8: a flat sequence of records, each a two-byte type, a two-byte size, and that many bytes of data, organised into substreams delimited by `BOF`/`EOF`. This package leaves the outer layer to [`archive-codec`](../archive-codec/README.md)'s bounded CFB reader and implements the inner one, from the record framing up to a `ContentDocument`.
+
+## Status
+
+Under active development, **read-only**. Built and shipped:
+
+- **Record framing** (`src/biff/records.ts`) — the three-component record structure of [MS-XLS] 2.1.4, with the 8224-byte data ceiling enforced and every malformed stream thrown on rather than silently truncated.
+- **Continuation-aware cursor and strings** (`src/biff/cursor.ts`, `src/biff/strings.ts`) — `Continue` records ([MS-XLS] 2.4.58) joined per the rules of the record being continued, including the case a naive reader gets wrong: an `XLUnicodeRichExtendedString` ([MS-XLS] 2.5.293) resuming after a boundary re-states its own `fHighByte` flag, which may differ from the flag the string started with. All three string shapes (`XLUnicodeString`, `ShortXLUnicodeString`, `XLUnicodeRichExtendedString`) are read.
+- **Workbook globals** (`src/workbook/globals.ts`) — `BoundSheet8` (sheet names, tab order, hidden state, type, and substream offsets), `SST` with its `Continue` chain, `Format` (custom number-format codes), `XF`'s fixed prefix (font index, format identifier, style flag), and `Date1904`.
+- **Worksheet substreams** (`src/workbook/sheet.ts`) — `Dimensions`, `Row` (height and hidden state), `ColInfo` (width and hidden state, expanded across the column range it covers), `MergeCells`, and the whole cell-value family: `Blank`, `MulBlank`, `RK`, `MulRk`, `Number`, `BoolErr`, `LabelSst`, `Label`, and `Formula` with its `String` result record.
+- **Number-format classification and date serials** (`src/number-format.ts`, `src/serial.ts`) — what turns a bare number into the schema's own `percentage`/`currency`/`date`/`time`/`dateTime` value kinds, honouring the workbook's own epoch flag and refusing the 1900 system's phantom leap day.
+- **Schema mapping** (`src/content.ts`) — `readXlsContent` produces a `ContentDocument` of `kind: 'spreadsheet'`, and `readXls` the tree-form `DocumentTree`, in the same shape `readXlsxContent`/`readXlsx` produce: sparse 0-based cells, `displayText` on every cell, merged ranges as `colSpan`/`rowSpan` on the anchor cell, and the producer's raw format code kept alongside the classified value.
+
+### Not built yet
+
+**The write path**, which is the substantial one. A conformant workbook has to emit a `BOF` history block, a complete `XF`/`Font`/`Format` table with the fifteen mandatory style records preceding any cell format, an `Index`/`DBCell` row-block lookup structure whose file offsets must agree with where the records actually land, and a compound-file _writer_ (`archive-codec` reads [MS-CFB] but does not write it). Shipping a plausible-looking writer that produced files Excel rejects would be worse than shipping none. Tracked on [#815](https://github.com/ExaDev/documents.js/issues/815).
+
+Read-side gaps, each deliberate rather than overlooked:
+
+- **Formula expressions.** A `Formula` record's cached _result_ is read, so a formula cell shows the right value, but `ContentSheetCell.formula` stays absent. BIFF8 stores the expression as a compiled `Ptg` token stream rather than as text, and recovering it means implementing the whole `Ptg` vocabulary plus shared-formula (`ShrFmla`) and external-reference (`SupBook`/`ExternSheet`) resolution.
+- **Cell decoration** — fill, borders, and alignment from `XF`'s trailing `CellXF` payload, whose colours are palette indices needing the `Palette` record and the default colour table to resolve. `Font` records are not read either: `ContentSheetCell` has no cell-level font field, and `ooxml.js`'s xlsx reader likewise maps only the number format and decoration from a cell format.
+- **Print settings** are emitted as Excel's documented "Normal" preset rather than read from the file. The real values need `Setup` (including its paper-size code table), the four margin records, `PrintGrid`, and `PrintRowCol`.
+- **Workbook metadata** — `metadata` is empty. Title, author, and dates live in the `\x05SummaryInformation` property-set stream ([MS-OSHARED]), a different format from BIFF8 sitting beside it in the same container.
+- **Not read at all:** charts, drawings and images, cell comments (`Note`/`Txo`), data validation, conditional formatting, and defined names (`Lbl`).
+- **Encrypted workbooks** are refused rather than mis-read: a `FilePass` record means every record after it is ciphertext.
+
+This package is also not yet wired into `documents.js`'s conversion registry — it stands alone.
+
+## Getting started
+
+Requires Node.js `>=20` and pnpm `11.6.0`.
+
+```sh
+pnpm install
+pnpm build          # tsdown -> dist/ (ESM + CJS + .d.ts, one file set per src module)
+pnpm typecheck      # tsc -p tsconfig.json && tsc -p tsconfig.node.json (dual tsconfig)
+pnpm lint           # eslint . --fix --cache --max-warnings 0
+pnpm test           # vitest run --project unit
+pnpm test:watch     # vitest --project unit
+pnpm test:workers   # vitest run --config vitest.workers.config.ts, inside a real Cloudflare Workers (workerd) isolate
+pnpm test:smoke     # builds dist/, then loads the built ESM and CJS barrels and every advertised deep import
+```
+
+## Usage
+
+```ts
+import { isXlsFile, readXls, readXlsContent } from "xls-codec";
+
+const bytes = new Uint8Array(await file.arrayBuffer());
+
+if (isXlsFile(bytes)) {
+  const content = readXlsContent(bytes); // ContentDocument, kind: 'spreadsheet'
+  const tree = readXls(bytes); // DocumentTree, the same read decomposed
+}
+```
+
+`readXlsContent` mirrors `ooxml.js`'s `readXlsxContent` deliberately, down to returning a `ContentDocument` rather than a bare `{ metadata, sheets }` object, so a caller can hold either behind one type. The difference is the input: an `.xls` has no `Package` equivalent to decode first, so these take the file's raw bytes and select the `Workbook` stream themselves.
+
+The record layer is exported in its own right, for a caller inspecting a workbook rather than converting it:
+
+```ts
+import { readRecords, readWorkbookStream } from "xls-codec";
+
+const stream = readWorkbookStream(bytes); // the raw BIFF8 record stream out of the compound file
+for (const rec of readRecords(stream)) {
+  console.log(rec.type.toString(16), rec.data.length);
+}
+```
+
+### Microsoft Works spreadsheets (`.xlr`)
+
+Works 9's `.xlr` is BIFF8 in the same compound-file container, carrying the identical `Workbook` stream alongside a Works-specific `WksSSWorkBook` stream ([SheetJS format notes](https://docs.sheetjs.com/docs/miscellany/formats/)). Because this package selects the `Workbook` stream by name and ignores every other stream in the container, an `.xlr` reads through exactly the same path with no special-casing; `isXlsFile` accepts one, and there is a test pinning that.
+
+## Architecture
+
+Layered bottom-up, each layer testable against hand-built byte sequences taken from the spec's own field-layout tables:
+
+- **`src/biff/record-types.ts`** — the record type numbers, each cited to [MS-XLS] 2.3.1's own enumeration rather than copied from another implementation.
+- **`src/biff/records.ts`** — the record framing, and nothing above it. Deliberately does not merge `Continue` records: whether a continuation's bytes simply append or re-state a flag byte first is decided by the record being continued, so the blocks are reported as written.
+- **`src/biff/cursor.ts`** — a field cursor over one record's blocks that reads across a continuation boundary transparently while keeping the boundary observable, which is exactly what the string reader needs.
+- **`src/biff/strings.ts`**, **`src/biff/rk.ts`**, **`src/biff/errors.ts`** — the shared value encodings: the three string shapes, the `RkNumber` packed-numeric encoding, and the `BErr` error-value vocabulary.
+- **`src/workbook/globals.ts`**, **`src/workbook/sheet.ts`** — the two substream readers, each walking the record sequence its ABNF in [MS-XLS] 2.1.7.20.3 / 2.1.7.20.5 defines.
+- **`src/number-format.ts`**, **`src/serial.ts`** — number-format classification and date-serial conversion, the two pieces of xlsx semantics BIFF8 shares because ECMA-376 inherited them from BIFF.
+- **`src/content.ts`** — the mapping onto `document-schema.js`.
+
+### Deliberately not depended on
+
+No third-party spreadsheet or compound-file library — not `xlsx`/SheetJS, `exceljs`, or `cfb` — enforced by an ESLint `no-restricted-imports` rule in this package's own config. The format is implemented against its published Open Specification, and the compound-file layer comes from `archive-codec`, a sibling in this workspace.
+
+## Conventions
+
+- Worker-isomorphic (see the [family-wide convention](../../README.md#conventions)): runtime `src/` must not import `node:*`, a bare Node builtin, or use the `Buffer` global — enforced by a `no-restricted-imports`/`no-restricted-globals` ESLint rule and exercised in CI by running a test suite inside an actual `workerd` isolate (`pnpm test:workers`). Test files under `src/**/*.test.ts` and `src/test-support/` are exempt and may use Node APIs for fixtures.
+- Only `src/index.ts` may be named `index.*` — a custom ESLint rule (`local/no-non-barrel-index`) rejects any other module using an `index` basename, since that would be a hidden entry point the `exports` map in `package.json` doesn't advertise.
+- Every record layout is cited to its own [MS-XLS] section, by URL, at the point it is read. A field offset with no citation is a field offset nobody can check.
+
+## Install
+
+```sh
+pnpm add xls-codec
+# or
+npm install xls-codec
+```
+
+## Release and publishing
+
+Release, CI, and commit-message conventions are all workspace-wide, not package-local — see the [monorepo root README](../../README.md#releases) for the mechanism (topological per-package `semantic-release` via `@exadev/semantic-release-workspace`, OIDC trusted npm publishing, automatic sibling dependency-range rewriting) and its [post-release republishing and attestation](../../README.md#releases) note on the restored GitHub Packages mirrors, npm aliases, and SBOM/provenance signing.
+
+## Contributing
+
+Conventional Commits, enforced workspace-wide by commitlint through a root `commit-msg` hook. Work inside `packages/xls-codec/`; see [CONTRIBUTING.md](../../CONTRIBUTING.md) for the shared git hooks and history conventions.
+
+## References
+
+- [MS-XLS]: [Excel Binary File Format (.xls) Structure](https://learn.microsoft.com/en-us/openspecs/office_file_formats/ms-xls/cd03cb5f-ca02-4934-a391-bb674cb8aa06) — the specification this package implements.
+- [MS-CFB]: [Compound File Binary File Format](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-cfb/53989ce4-7b05-4f8d-829b-d08d6148375b) — the container, read through `archive-codec`.
+- [archive-codec](../archive-codec/README.md) — the bounded CFB reader this package selects the `Workbook` stream through.
+- [document-schema.js](../document-schema.js/README.md) — the `ContentDocument`/`ContentSheet`/`ContentSheetCell` vocabulary this package maps onto, and the `assembleTree` transform behind `readXls`.
+- [ooxml.js](../ooxml.js/README.md) — the sibling reading `.xlsx`, BIFF8's successor, onto the same schema.
+
+## License
+
+MIT

package/dist/biff/cursor.cjs

@@ -0,0 +1,73 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_biff_records = require("./records.cjs");
+//#region src/biff/cursor.ts
+var BlockCursor = class {
+	blocks;
+	blockIndex = 0;
+	offset = 0;
+	constructor(blocks) {
+		this.blocks = blocks;
+		this.settle();
+	}
+	/** Advances past any exhausted or empty blocks, so the cursor always rests either on a readable byte or past the end of the last block. A Continue carrying no data is legal and must not read as the end of the record. */
+	settle() {
+		while (this.blockIndex < this.blocks.length && this.offset >= (this.blocks[this.blockIndex]?.length ?? 0)) {
+			this.blockIndex += 1;
+			this.offset = 0;
+		}
+	}
+	nextByte(context) {
+		this.settle();
+		const block = this.blocks[this.blockIndex];
+		if (block === void 0) throw new require_biff_records.BiffFormatError(`${context} runs past the end of the record data`);
+		const byte = block[this.offset];
+		if (byte === void 0) throw new require_biff_records.BiffFormatError(`${context} runs past the end of the record data`);
+		this.offset += 1;
+		return byte;
+	}
+	/** Whether any unread byte remains, in this block or a later one. */
+	hasMore() {
+		this.settle();
+		return this.blockIndex < this.blocks.length;
+	}
+	/** How many unread bytes remain in the block the cursor currently rests in -- the distance to the next continuation boundary, which a string's character run must not cross without consuming a new flag byte. */
+	remainingInBlock() {
+		this.settle();
+		const block = this.blocks[this.blockIndex];
+		return block === void 0 ? 0 : block.length - this.offset;
+	}
+	/** The index of the block the cursor currently rests in, so a caller can detect that a read crossed into a new one. */
+	blockPosition() {
+		this.settle();
+		return this.blockIndex;
+	}
+	u8() {
+		return this.nextByte("u8");
+	}
+	u16() {
+		return this.nextByte("u16") | this.nextByte("u16") << 8;
+	}
+	u32() {
+		return this.u16() + this.u16() * 65536;
+	}
+	i32() {
+		return this.u32() | 0;
+	}
+	/** An Xnum ([MS-XLS] 2.5.342): a little-endian IEEE 754 double. */
+	f64() {
+		const raw = this.take(8);
+		return new DataView(raw.buffer, raw.byteOffset, raw.byteLength).getFloat64(0, true);
+	}
+	/** The next `count` bytes, copied out. Spans block boundaries. */
+	take(count) {
+		const out = new Uint8Array(count);
+		for (let index = 0; index < count; index += 1) out[index] = this.nextByte(`${count}-byte run`);
+		return out;
+	}
+	/** Advances `count` bytes without materialising them -- for a field this package reads past rather than reads. */
+	skip(count) {
+		for (let index = 0; index < count; index += 1) this.nextByte(`${count}-byte skip`);
+	}
+};
+//#endregion
+exports.BlockCursor = BlockCursor;

package/dist/biff/cursor.d.cts

@@ -0,0 +1,28 @@
+//#region src/biff/cursor.d.ts
+declare class BlockCursor {
+  private readonly blocks;
+  private blockIndex;
+  private offset;
+  constructor(blocks: readonly Uint8Array<ArrayBuffer>[]);
+  /** Advances past any exhausted or empty blocks, so the cursor always rests either on a readable byte or past the end of the last block. A Continue carrying no data is legal and must not read as the end of the record. */
+  private settle;
+  private nextByte;
+  /** Whether any unread byte remains, in this block or a later one. */
+  hasMore(): boolean;
+  /** How many unread bytes remain in the block the cursor currently rests in -- the distance to the next continuation boundary, which a string's character run must not cross without consuming a new flag byte. */
+  remainingInBlock(): number;
+  /** The index of the block the cursor currently rests in, so a caller can detect that a read crossed into a new one. */
+  blockPosition(): number;
+  u8(): number;
+  u16(): number;
+  u32(): number;
+  i32(): number;
+  /** An Xnum ([MS-XLS] 2.5.342): a little-endian IEEE 754 double. */
+  f64(): number;
+  /** The next `count` bytes, copied out. Spans block boundaries. */
+  take(count: number): Uint8Array<ArrayBuffer>;
+  /** Advances `count` bytes without materialising them -- for a field this package reads past rather than reads. */
+  skip(count: number): void;
+}
+//#endregion
+export { BlockCursor };

package/dist/biff/cursor.d.ts

@@ -0,0 +1,28 @@
+//#region src/biff/cursor.d.ts
+declare class BlockCursor {
+  private readonly blocks;
+  private blockIndex;
+  private offset;
+  constructor(blocks: readonly Uint8Array<ArrayBuffer>[]);
+  /** Advances past any exhausted or empty blocks, so the cursor always rests either on a readable byte or past the end of the last block. A Continue carrying no data is legal and must not read as the end of the record. */
+  private settle;
+  private nextByte;
+  /** Whether any unread byte remains, in this block or a later one. */
+  hasMore(): boolean;
+  /** How many unread bytes remain in the block the cursor currently rests in -- the distance to the next continuation boundary, which a string's character run must not cross without consuming a new flag byte. */
+  remainingInBlock(): number;
+  /** The index of the block the cursor currently rests in, so a caller can detect that a read crossed into a new one. */
+  blockPosition(): number;
+  u8(): number;
+  u16(): number;
+  u32(): number;
+  i32(): number;
+  /** An Xnum ([MS-XLS] 2.5.342): a little-endian IEEE 754 double. */
+  f64(): number;
+  /** The next `count` bytes, copied out. Spans block boundaries. */
+  take(count: number): Uint8Array<ArrayBuffer>;
+  /** Advances `count` bytes without materialising them -- for a field this package reads past rather than reads. */
+  skip(count: number): void;
+}
+//#endregion
+export { BlockCursor };

package/dist/biff/cursor.js

@@ -0,0 +1,72 @@
+import { BiffFormatError } from "./records.js";
+//#region src/biff/cursor.ts
+var BlockCursor = class {
+	blocks;
+	blockIndex = 0;
+	offset = 0;
+	constructor(blocks) {
+		this.blocks = blocks;
+		this.settle();
+	}
+	/** Advances past any exhausted or empty blocks, so the cursor always rests either on a readable byte or past the end of the last block. A Continue carrying no data is legal and must not read as the end of the record. */
+	settle() {
+		while (this.blockIndex < this.blocks.length && this.offset >= (this.blocks[this.blockIndex]?.length ?? 0)) {
+			this.blockIndex += 1;
+			this.offset = 0;
+		}
+	}
+	nextByte(context) {
+		this.settle();
+		const block = this.blocks[this.blockIndex];
+		if (block === void 0) throw new BiffFormatError(`${context} runs past the end of the record data`);
+		const byte = block[this.offset];
+		if (byte === void 0) throw new BiffFormatError(`${context} runs past the end of the record data`);
+		this.offset += 1;
+		return byte;
+	}
+	/** Whether any unread byte remains, in this block or a later one. */
+	hasMore() {
+		this.settle();
+		return this.blockIndex < this.blocks.length;
+	}
+	/** How many unread bytes remain in the block the cursor currently rests in -- the distance to the next continuation boundary, which a string's character run must not cross without consuming a new flag byte. */
+	remainingInBlock() {
+		this.settle();
+		const block = this.blocks[this.blockIndex];
+		return block === void 0 ? 0 : block.length - this.offset;
+	}
+	/** The index of the block the cursor currently rests in, so a caller can detect that a read crossed into a new one. */
+	blockPosition() {
+		this.settle();
+		return this.blockIndex;
+	}
+	u8() {
+		return this.nextByte("u8");
+	}
+	u16() {
+		return this.nextByte("u16") | this.nextByte("u16") << 8;
+	}
+	u32() {
+		return this.u16() + this.u16() * 65536;
+	}
+	i32() {
+		return this.u32() | 0;
+	}
+	/** An Xnum ([MS-XLS] 2.5.342): a little-endian IEEE 754 double. */
+	f64() {
+		const raw = this.take(8);
+		return new DataView(raw.buffer, raw.byteOffset, raw.byteLength).getFloat64(0, true);
+	}
+	/** The next `count` bytes, copied out. Spans block boundaries. */
+	take(count) {
+		const out = new Uint8Array(count);
+		for (let index = 0; index < count; index += 1) out[index] = this.nextByte(`${count}-byte run`);
+		return out;
+	}
+	/** Advances `count` bytes without materialising them -- for a field this package reads past rather than reads. */
+	skip(count) {
+		for (let index = 0; index < count; index += 1) this.nextByte(`${count}-byte skip`);
+	}
+};
+//#endregion
+export { BlockCursor };

package/dist/biff/errors.cjs

@@ -0,0 +1,18 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/biff/errors.ts
+const ERROR_TEXT = /* @__PURE__ */ new Map([
+	[0, "#NULL!"],
+	[7, "#DIV/0!"],
+	[15, "#VALUE!"],
+	[23, "#REF!"],
+	[29, "#NAME?"],
+	[36, "#NUM!"],
+	[42, "#N/A"],
+	[43, "#GETTING_DATA"]
+]);
+/** The displayed spelling of a BIFF8 error code, or undefined for a code [MS-XLS] does not define -- which the caller degrades rather than guessing a spelling for. */
+function errorTextOf(code) {
+	return ERROR_TEXT.get(code);
+}
+//#endregion
+exports.errorTextOf = errorTextOf;

package/dist/biff/errors.d.cts

@@ -0,0 +1,5 @@
+//#region src/biff/errors.d.ts
+/** The displayed spelling of a BIFF8 error code, or undefined for a code [MS-XLS] does not define -- which the caller degrades rather than guessing a spelling for. */
+declare function errorTextOf(code: number): string | undefined;
+//#endregion
+export { errorTextOf };

package/dist/biff/errors.d.ts

@@ -0,0 +1,5 @@
+//#region src/biff/errors.d.ts
+/** The displayed spelling of a BIFF8 error code, or undefined for a code [MS-XLS] does not define -- which the caller degrades rather than guessing a spelling for. */
+declare function errorTextOf(code: number): string | undefined;
+//#endregion
+export { errorTextOf };

package/dist/biff/errors.js

@@ -0,0 +1,17 @@
+//#region src/biff/errors.ts
+const ERROR_TEXT = /* @__PURE__ */ new Map([
+	[0, "#NULL!"],
+	[7, "#DIV/0!"],
+	[15, "#VALUE!"],
+	[23, "#REF!"],
+	[29, "#NAME?"],
+	[36, "#NUM!"],
+	[42, "#N/A"],
+	[43, "#GETTING_DATA"]
+]);
+/** The displayed spelling of a BIFF8 error code, or undefined for a code [MS-XLS] does not define -- which the caller degrades rather than guessing a spelling for. */
+function errorTextOf(code) {
+	return ERROR_TEXT.get(code);
+}
+//#endregion
+export { errorTextOf };

package/dist/biff/record-types.cjs

@@ -0,0 +1,108 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/biff/record-types.ts
+/** Marks the beginning of a substream and names its document type ([MS-XLS] 2.4.21). */
+const RECORD_BOF = 2057;
+/** Marks the end of a substream ([MS-XLS] 2.4.103). */
+const RECORD_EOF = 10;
+/** Carries the overflow of a preceding record whose data exceeds what one record can hold ([MS-XLS] 2.4.58). */
+const RECORD_CONTINUE = 60;
+/** One per sheet: its name, hidden state, type, and the stream offset of its own BOF ([MS-XLS] 2.4.28). */
+const RECORD_BOUNDSHEET8 = 133;
+/** The shared string table every LabelSst cell indexes into ([MS-XLS] 2.4.265). */
+const RECORD_SST = 252;
+/** A custom number-format code and the identifier cells reference it by ([MS-XLS] 2.4.126). */
+const RECORD_FORMAT = 1054;
+/** A cell or cell-style extended format record ([MS-XLS] 2.4.353). */
+const RECORD_XF = 224;
+/** A font definition, referenced by index from an XF ([MS-XLS] 2.4.122). */
+const RECORD_FONT = 49;
+/** Which of the two date epochs this workbook's serials count from ([MS-XLS] 2.4.77). */
+const RECORD_DATE1904 = 34;
+/** Present only in an encrypted workbook, where every record after it is ciphertext ([MS-XLS] 2.4.117). */
+const RECORD_FILEPASS = 47;
+/** The sheet's used range ([MS-XLS] 2.4.90). */
+const RECORD_DIMENSIONS = 512;
+/** A single row's height, hidden state, and formatting ([MS-XLS] 2.4.221). */
+const RECORD_ROW = 520;
+/** Column width, hidden state, and default format for a range of columns ([MS-XLS] 2.4.53). */
+const RECORD_COLINFO = 125;
+/** The sheet's default column width, in whole character widths ([MS-XLS] 2.4.89). */
+const RECORD_DEFCOLWIDTH = 85;
+/** The sheet's default row height ([MS-XLS] 2.4.87). */
+const RECORD_DEFAULTROWHEIGHT = 549;
+/** Merged cell ranges ([MS-XLS] 2.4.168). */
+const RECORD_MERGECELLS = 229;
+/** An empty cell carrying only formatting ([MS-XLS] 2.4.20). */
+const RECORD_BLANK = 513;
+/** A run of empty cells in one row ([MS-XLS] 2.4.174). */
+const RECORD_MULBLANK = 190;
+/** A cell holding an RK-encoded number ([MS-XLS] 2.4.220). */
+const RECORD_RK = 638;
+/** A run of RK-encoded numeric cells in one row ([MS-XLS] 2.4.175). */
+const RECORD_MULRK = 189;
+/** A cell holding an IEEE 754 double ([MS-XLS] 2.4.180). */
+const RECORD_NUMBER = 515;
+/** A cell holding a boolean or an error value ([MS-XLS] 2.4.24). */
+const RECORD_BOOLERR = 517;
+/** A cell holding a string by index into the shared string table ([MS-XLS] 2.4.149). */
+const RECORD_LABELSST = 253;
+/** A cell holding an inline string ([MS-XLS] 2.4.148). See the reader's own note on why BIFF8 still meets this in the wild. */
+const RECORD_LABEL = 516;
+/** A cell holding a formula, its cached result, and its parsed expression ([MS-XLS] 2.4.127). */
+const RECORD_FORMULA = 6;
+/** The string result of the Formula record preceding it ([MS-XLS] 2.4.268). */
+const RECORD_STRING = 519;
+/** The expression of an array formula, following the Formula record of its top-left cell ([MS-XLS] 2.4.4). */
+const RECORD_ARRAY = 545;
+/** A data-table definition following a Formula record ([MS-XLS] 2.4.334). */
+const RECORD_TABLE = 566;
+/** The shared expression a run of Formula records refers to ([MS-XLS] 2.4.260). */
+const RECORD_SHRFMLA = 1212;
+/** The workbook globals substream. */
+const BOF_TYPE_WORKBOOK = 5;
+/** A worksheet or dialog sheet substream. */
+const BOF_TYPE_WORKSHEET = 16;
+/** A chart sheet substream. */
+const BOF_TYPE_CHART = 32;
+/** A macro sheet substream. */
+const BOF_TYPE_MACRO = 64;
+/** The BIFF version every BOF in a BIFF8 workbook stream declares ([MS-XLS] 2.4.21: "The value MUST be 0x0600"). */
+const BIFF8_VERSION = 1536;
+/** [MS-XLS] 2.1.4: "The record size ... MUST be less than or equal to 8224." The ceiling a writer splits a record at, and the bound a reader can sanity-check a declared size against. */
+const MAX_RECORD_DATA_SIZE = 8224;
+//#endregion
+exports.BIFF8_VERSION = BIFF8_VERSION;
+exports.BOF_TYPE_CHART = BOF_TYPE_CHART;
+exports.BOF_TYPE_MACRO = BOF_TYPE_MACRO;
+exports.BOF_TYPE_WORKBOOK = BOF_TYPE_WORKBOOK;
+exports.BOF_TYPE_WORKSHEET = BOF_TYPE_WORKSHEET;
+exports.MAX_RECORD_DATA_SIZE = MAX_RECORD_DATA_SIZE;
+exports.RECORD_ARRAY = RECORD_ARRAY;
+exports.RECORD_BLANK = RECORD_BLANK;
+exports.RECORD_BOF = RECORD_BOF;
+exports.RECORD_BOOLERR = RECORD_BOOLERR;
+exports.RECORD_BOUNDSHEET8 = RECORD_BOUNDSHEET8;
+exports.RECORD_COLINFO = RECORD_COLINFO;
+exports.RECORD_CONTINUE = RECORD_CONTINUE;
+exports.RECORD_DATE1904 = RECORD_DATE1904;
+exports.RECORD_DEFAULTROWHEIGHT = RECORD_DEFAULTROWHEIGHT;
+exports.RECORD_DEFCOLWIDTH = RECORD_DEFCOLWIDTH;
+exports.RECORD_DIMENSIONS = RECORD_DIMENSIONS;
+exports.RECORD_EOF = RECORD_EOF;
+exports.RECORD_FILEPASS = RECORD_FILEPASS;
+exports.RECORD_FONT = RECORD_FONT;
+exports.RECORD_FORMAT = RECORD_FORMAT;
+exports.RECORD_FORMULA = RECORD_FORMULA;
+exports.RECORD_LABEL = RECORD_LABEL;
+exports.RECORD_LABELSST = RECORD_LABELSST;
+exports.RECORD_MERGECELLS = RECORD_MERGECELLS;
+exports.RECORD_MULBLANK = RECORD_MULBLANK;
+exports.RECORD_MULRK = RECORD_MULRK;
+exports.RECORD_NUMBER = RECORD_NUMBER;
+exports.RECORD_RK = RECORD_RK;
+exports.RECORD_ROW = RECORD_ROW;
+exports.RECORD_SHRFMLA = RECORD_SHRFMLA;
+exports.RECORD_SST = RECORD_SST;
+exports.RECORD_STRING = RECORD_STRING;
+exports.RECORD_TABLE = RECORD_TABLE;
+exports.RECORD_XF = RECORD_XF;

package/dist/biff/record-types.d.cts

@@ -0,0 +1,73 @@
+//#region src/biff/record-types.d.ts
+/** Marks the beginning of a substream and names its document type ([MS-XLS] 2.4.21). */
+declare const RECORD_BOF = 2057;
+/** Marks the end of a substream ([MS-XLS] 2.4.103). */
+declare const RECORD_EOF = 10;
+/** Carries the overflow of a preceding record whose data exceeds what one record can hold ([MS-XLS] 2.4.58). */
+declare const RECORD_CONTINUE = 60;
+/** One per sheet: its name, hidden state, type, and the stream offset of its own BOF ([MS-XLS] 2.4.28). */
+declare const RECORD_BOUNDSHEET8 = 133;
+/** The shared string table every LabelSst cell indexes into ([MS-XLS] 2.4.265). */
+declare const RECORD_SST = 252;
+/** A custom number-format code and the identifier cells reference it by ([MS-XLS] 2.4.126). */
+declare const RECORD_FORMAT = 1054;
+/** A cell or cell-style extended format record ([MS-XLS] 2.4.353). */
+declare const RECORD_XF = 224;
+/** A font definition, referenced by index from an XF ([MS-XLS] 2.4.122). */
+declare const RECORD_FONT = 49;
+/** Which of the two date epochs this workbook's serials count from ([MS-XLS] 2.4.77). */
+declare const RECORD_DATE1904 = 34;
+/** Present only in an encrypted workbook, where every record after it is ciphertext ([MS-XLS] 2.4.117). */
+declare const RECORD_FILEPASS = 47;
+/** The sheet's used range ([MS-XLS] 2.4.90). */
+declare const RECORD_DIMENSIONS = 512;
+/** A single row's height, hidden state, and formatting ([MS-XLS] 2.4.221). */
+declare const RECORD_ROW = 520;
+/** Column width, hidden state, and default format for a range of columns ([MS-XLS] 2.4.53). */
+declare const RECORD_COLINFO = 125;
+/** The sheet's default column width, in whole character widths ([MS-XLS] 2.4.89). */
+declare const RECORD_DEFCOLWIDTH = 85;
+/** The sheet's default row height ([MS-XLS] 2.4.87). */
+declare const RECORD_DEFAULTROWHEIGHT = 549;
+/** Merged cell ranges ([MS-XLS] 2.4.168). */
+declare const RECORD_MERGECELLS = 229;
+/** An empty cell carrying only formatting ([MS-XLS] 2.4.20). */
+declare const RECORD_BLANK = 513;
+/** A run of empty cells in one row ([MS-XLS] 2.4.174). */
+declare const RECORD_MULBLANK = 190;
+/** A cell holding an RK-encoded number ([MS-XLS] 2.4.220). */
+declare const RECORD_RK = 638;
+/** A run of RK-encoded numeric cells in one row ([MS-XLS] 2.4.175). */
+declare const RECORD_MULRK = 189;
+/** A cell holding an IEEE 754 double ([MS-XLS] 2.4.180). */
+declare const RECORD_NUMBER = 515;
+/** A cell holding a boolean or an error value ([MS-XLS] 2.4.24). */
+declare const RECORD_BOOLERR = 517;
+/** A cell holding a string by index into the shared string table ([MS-XLS] 2.4.149). */
+declare const RECORD_LABELSST = 253;
+/** A cell holding an inline string ([MS-XLS] 2.4.148). See the reader's own note on why BIFF8 still meets this in the wild. */
+declare const RECORD_LABEL = 516;
+/** A cell holding a formula, its cached result, and its parsed expression ([MS-XLS] 2.4.127). */
+declare const RECORD_FORMULA = 6;
+/** The string result of the Formula record preceding it ([MS-XLS] 2.4.268). */
+declare const RECORD_STRING = 519;
+/** The expression of an array formula, following the Formula record of its top-left cell ([MS-XLS] 2.4.4). */
+declare const RECORD_ARRAY = 545;
+/** A data-table definition following a Formula record ([MS-XLS] 2.4.334). */
+declare const RECORD_TABLE = 566;
+/** The shared expression a run of Formula records refers to ([MS-XLS] 2.4.260). */
+declare const RECORD_SHRFMLA = 1212;
+/** The workbook globals substream. */
+declare const BOF_TYPE_WORKBOOK = 5;
+/** A worksheet or dialog sheet substream. */
+declare const BOF_TYPE_WORKSHEET = 16;
+/** A chart sheet substream. */
+declare const BOF_TYPE_CHART = 32;
+/** A macro sheet substream. */
+declare const BOF_TYPE_MACRO = 64;
+/** The BIFF version every BOF in a BIFF8 workbook stream declares ([MS-XLS] 2.4.21: "The value MUST be 0x0600"). */
+declare const BIFF8_VERSION = 1536;
+/** [MS-XLS] 2.1.4: "The record size ... MUST be less than or equal to 8224." The ceiling a writer splits a record at, and the bound a reader can sanity-check a declared size against. */
+declare const MAX_RECORD_DATA_SIZE = 8224;
+//#endregion
+export { 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 };