@shbernal/ts-xlsx 2.1.0 → 3.1.0

package/dist/io/xlsb/read-styles.js

@@ -1,28 +1,20 @@
-import { numFmtCodeFor, resolveStyleTable, } from '../style/xf-style.js';
+import { ALIGNMENT_FACETS, FILL_PATTERNS_IN_SCHEMA_ORDER, } from '../../core/style.js';
+import { numFmtCodeFor, NO_PRESERVED_STYLE_TABLES, protectionFrom, resolveStyleTable, } from '../style/xf-style.js';
 import { RecordReader } from './primitives.js';
-import { readRecords } from './record-stream.js';
+import { blockTracker, readRecords } from './record-stream.js';
 import { BRT } from './record-types.js';
-const COLLECTION_STARTS = new Map([
-    [BRT.BeginFmts, 'fmts'],
-    [BRT.BeginFonts, 'fonts'],
-    [BRT.BeginFills, 'fills'],
-    [BRT.BeginBorders, 'borders'],
-    [BRT.BeginCellStyleXFs, 'cellStyleXfs'],
-    [BRT.BeginCellXFs, 'cellXfs'],
-    [BRT.BeginStyles, 'styles'],
-]);
-const COLLECTION_ENDS = new Set([
-    BRT.EndFmts,
-    BRT.EndFonts,
-    BRT.EndFills,
-    BRT.EndBorders,
-    BRT.EndCellStyleXFs,
-    BRT.EndCellXFs,
-    BRT.EndStyles,
-]);
+const COLLECTIONS = [
+    [BRT.BeginFmts, BRT.EndFmts, 'fmts'],
+    [BRT.BeginFonts, BRT.EndFonts, 'fonts'],
+    [BRT.BeginFills, BRT.EndFills, 'fills'],
+    [BRT.BeginBorders, BRT.EndBorders, 'borders'],
+    [BRT.BeginCellStyleXFs, BRT.EndCellStyleXFs, 'cellStyleXfs'],
+    [BRT.BeginCellXFs, BRT.EndCellXFs, 'cellXfs'],
+    [BRT.BeginStyles, BRT.EndStyles, 'styles'],
+];
 export function parseStyleTable(part) {
     if (part === undefined)
-        return { cellXfs: [], namedStyles: [] };
+        return { cellXfs: [], namedStyles: [], preserved: NO_PRESERVED_STYLE_TABLES };
     const numFmtCodes = new Map();
     const fonts = [];
     const fills = [];
@@ -30,50 +22,46 @@ export function parseStyleTable(part) {
     const namedXfs = [];
     const directXfs = [];
     const labels = [];
-    let collection;
+    const blocks = blockTracker(COLLECTIONS);
     for (const record of readRecords(part)) {
-        if (COLLECTION_ENDS.has(record.type)) {
-            collection = undefined;
+        if (blocks.boundary(record.type))
             continue;
-        }
-        const started = COLLECTION_STARTS.get(record.type);
-        if (started !== undefined) {
-            collection = started;
-            continue;
-        }
         const reader = new RecordReader(record.data);
         switch (record.type) {
             case BRT.Fmt:
-                if (collection === 'fmts')
+                if (blocks.isOpen('fmts'))
                     numFmtCodes.set(reader.u16(), reader.wideString());
                 break;
             case BRT.Font:
-                if (collection === 'fonts')
+                if (blocks.isOpen('fonts'))
                     fonts.push(readFont(reader));
                 break;
             case BRT.Fill:
-                if (collection === 'fills')
+                if (blocks.isOpen('fills'))
                     fills.push(readFill(reader));
                 break;
             case BRT.Border:
-                if (collection === 'borders')
+                if (blocks.isOpen('borders'))
                     borders.push(readBorder(reader));
                 break;
             case BRT.XF:
-                if (collection === 'cellXfs' || collection === 'cellStyleXfs') {
+                if (blocks.isOpen('cellXfs') || blocks.isOpen('cellStyleXfs')) {
                     const deps = { fonts, fills, borders, numFmtCodes };
-                    (collection === 'cellXfs' ? directXfs : namedXfs).push(readXf(reader, deps, collection === 'cellXfs'));
+                    (blocks.isOpen('cellXfs') ? directXfs : namedXfs).push(readXf(reader, deps, blocks.isOpen('cellXfs')));
                 }
                 break;
             case BRT.Style:
-                if (collection === 'styles')
+                if (blocks.isOpen('styles'))
                     labels.push(readStyleLabel(reader));
                 break;
             default:
                 break;
         }
     }
-    return resolveStyleTable({ directXfs, namedXfs, labels, fonts });
+    return {
+        ...resolveStyleTable({ directXfs, namedXfs, labels, fonts }),
+        preserved: NO_PRESERVED_STYLE_TABLES,
+    };
 }
 function readXf(reader, deps, isDirect) {
     const parent = reader.u16();
@@ -107,34 +95,33 @@ function readXf(reader, deps, isDirect) {
     return draft;
 }
 const NOT_A_CELL_XF = 0xffff;
+const BIFF12_ALIGNMENT = {
+    horizontal: ({ flags }) => {
+        const value = HORIZONTAL_ALIGNMENTS[flags & 0b111];
+        return value === undefined ? {} : { horizontal: value };
+    },
+    vertical: ({ flags }) => {
+        const value = VERTICAL_ALIGNMENTS[(flags >> 3) & 0b111];
+        return value === undefined ? {} : { vertical: value };
+    },
+    textRotation: ({ rotation }) => (rotation === 0 ? {} : { textRotation: rotation }),
+    wrapText: ({ flags }) => ((flags & 0x0040) === 0 ? {} : { wrapText: true }),
+    indent: ({ indent }) => (indent === 0 ? {} : { indent }),
+    shrinkToFit: ({ flags }) => ((flags & 0x0100) === 0 ? {} : { shrinkToFit: true }),
+    readingOrder: ({ flags }) => {
+        const value = (flags >> 10) & 0b11;
+        return value === 0 ? {} : { readingOrder: value };
+    },
+};
 function readAlignment(flags, rotation, indent) {
+    const bits = { flags, rotation, indent };
     const out = {};
-    const horizontal = HORIZONTAL_ALIGNMENTS[flags & 0b111];
-    if (horizontal !== undefined)
-        out.horizontal = horizontal;
-    const vertical = VERTICAL_ALIGNMENTS[(flags >> 3) & 0b111];
-    if (vertical !== undefined)
-        out.vertical = vertical;
-    if (rotation !== 0)
-        out.textRotation = rotation;
-    if ((flags & 0x0040) !== 0)
-        out.wrapText = true;
-    if (indent !== 0)
-        out.indent = indent;
-    if ((flags & 0x0100) !== 0)
-        out.shrinkToFit = true;
-    const readingOrder = (flags >> 10) & 0b11;
-    if (readingOrder !== 0)
-        out.readingOrder = readingOrder;
+    for (const facet of ALIGNMENT_FACETS)
+        Object.assign(out, BIFF12_ALIGNMENT[facet.key](bits));
     return Object.keys(out).length > 0 ? out : undefined;
 }
 function readProtection(flags) {
-    const out = {};
-    if ((flags & 0x1000) === 0)
-        out.locked = false;
-    if ((flags & 0x2000) !== 0)
-        out.hidden = true;
-    return Object.keys(out).length > 0 ? out : undefined;
+    return protectionFrom({ locked: (flags & 0x1000) !== 0, hidden: (flags & 0x2000) !== 0 });
 }
 const HORIZONTAL_ALIGNMENTS = [
     undefined,
@@ -205,7 +192,8 @@ const UNDERLINE_STYLES = new Map([
     [0x22, 'doubleAccounting'],
 ]);
 function readFill(reader) {
-    const pattern = FILL_PATTERNS[reader.u32()];
+    const raw = FILL_PATTERNS_IN_SCHEMA_ORDER[reader.u32()];
+    const pattern = raw === 'none' ? undefined : raw;
     if (pattern === undefined)
         return undefined;
     const fgColor = notSentinel(reader.color(), AUTOMATIC_FOREGROUND);
@@ -222,27 +210,6 @@ const AUTOMATIC_BACKGROUND = 65;
 function notSentinel(color, sentinel) {
     return color?.indexed === sentinel ? undefined : color;
 }
-const FILL_PATTERNS = [
-    undefined,
-    'solid',
-    'mediumGray',
-    'darkGray',
-    'lightGray',
-    'darkHorizontal',
-    'darkVertical',
-    'darkDown',
-    'darkUp',
-    'darkGrid',
-    'darkTrellis',
-    'lightHorizontal',
-    'lightVertical',
-    'lightDown',
-    'lightUp',
-    'lightGrid',
-    'lightTrellis',
-    'gray125',
-    'gray0625',
-];
 function readBorder(reader) {
     const flags = reader.u8();
     const top = readEdge(reader);

package/dist/io/xlsb/read-worksheet.d.ts

@@ -1,3 +1,4 @@
+import { type DateEpoch } from '../../core/date.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
 import { type XfStyle } from '../style/xf-style.ts';
 import { type FormulaScope } from './formula.ts';
@@ -6,4 +7,22 @@ import { type FormulaScope } from './formula.ts';
  * non-empty cell with the style its index resolves to in `xfStyles` and, for a formula cell, the text
  * its token stream decodes to through `scope`.
  */
-export declare function parseWorksheet(part: Uint8Array, sheet: Worksheet, sharedStrings: readonly string[], xfStyles: ReadonlyArray<XfStyle>, scope: FormulaScope): void;
+export declare function parseWorksheet(part: Uint8Array, context: WorksheetReadContext): void;
+/**
+ * What reading a worksheet part needs around it: the sheet being filled and the three tables its
+ * records resolve through, plus the date system a serial under a date format counts from.
+ *
+ * One value rather than five positional arguments, two of them arrays and two of those `readonly
+ * string[]`/`ReadonlyArray<XfStyle>` -- a run whose order the call site cannot be read against, on a
+ * reader that decides what every cell in the sheet says. It is also exactly the half of
+ * {@link CellRecordContext} that does not change between records, which is why that one extends it
+ * and the record loop spreads this one into it.
+ */
+export interface WorksheetReadContext {
+    readonly sheet: Worksheet;
+    readonly sharedStrings: readonly string[];
+    readonly xfStyles: ReadonlyArray<XfStyle>;
+    readonly scope: FormulaScope;
+    /** The workbook's date system, from `BrtWbProp`: what a serial under a date format counts from. */
+    readonly dateEpoch: DateEpoch;
+}

package/dist/io/xlsb/read-worksheet.js

@@ -1,5 +1,5 @@
-import { encodeAddress, MAX_COLUMN } from '../../core/address.js';
-import { isDateFormat, serialToDate } from '../../core/date.js';
+import { encodeAddress, encodeRect, MAX_COLUMN_INDEX, MAX_ROW_INDEX } from '../../core/address.js';
+import { coerceDateSerial } from '../../core/date.js';
 import { unmangleFunctions } from '../../core/formula.js';
 import { assignStyleFacets } from '../../core/style.js';
 import { applyXfToCell } from '../style/xf-style.js';
@@ -7,23 +7,31 @@ import { decodeFormula, formulaAnchor } from './formula.js';
 import { errorCodeFor, RecordReader } from './primitives.js';
 import { readRecords } from './record-stream.js';
 import { BRT } from './record-types.js';
-const CELL_RECORDS = new Set([
-    BRT.CellBlank,
-    BRT.CellRk,
-    BRT.CellError,
-    BRT.CellBool,
-    BRT.CellReal,
-    BRT.CellSt,
-    BRT.CellIsst,
-    BRT.CellRString,
+const value = (read) => ({
+    kind: 'value',
+    read,
+});
+const formula = (read) => ({ kind: 'formula', read });
+const CELL_RECORDS = new Map([
+    [BRT.CellBlank, value(() => null)],
+    [BRT.CellRk, value((r, c) => asNumberOrDate(r.rk(), c.numFmt, c.epoch))],
+    [BRT.CellReal, value((r, c) => asNumberOrDate(r.f64(), c.numFmt, c.epoch))],
+    [BRT.CellBool, value((r) => r.u8() !== 0)],
+    [BRT.CellError, value((r) => errorValueOrNull(r.u8()))],
+    [BRT.CellSt, value((r) => r.wideString())],
+    [BRT.CellRString, value((r) => r.richString())],
+    [BRT.CellIsst, value((r, c) => c.sharedStrings[r.u32()] ?? '')],
+    [BRT.FmlaNum, formula((r, c) => asNumberOrDate(r.f64(), c.numFmt, c.epoch))],
+    [BRT.FmlaBool, formula((r) => r.u8() !== 0)],
+    [BRT.FmlaError, formula((r) => errorValueOrNull(r.u8()) ?? undefined)],
+    [BRT.FmlaString, formula((r) => r.wideString())],
 ]);
-const FORMULA_RECORDS = new Set([
-    BRT.FmlaString,
-    BRT.FmlaNum,
-    BRT.FmlaBool,
-    BRT.FmlaError,
-]);
-export function parseWorksheet(part, sheet, sharedStrings, xfStyles, scope) {
+function errorValueOrNull(code) {
+    const error = errorCodeFor(code);
+    return error === undefined ? null : { error };
+}
+export function parseWorksheet(part, context) {
+    const { sheet, xfStyles, scope } = context;
     let row = -1;
     let rowStyle = -1;
     const columnStyle = new Map();
@@ -31,6 +39,7 @@ export function parseWorksheet(part, sheet, sharedStrings, xfStyles, scope) {
     const groups = new Map();
     const deferred = [];
     for (const record of readRecords(part)) {
+        const cellRecord = CELL_RECORDS.get(record.type);
         const reader = new RecordReader(record.data);
         if (record.type === BRT.WsFmtInfo) {
             reader.skip(6);
@@ -47,7 +56,12 @@ export function parseWorksheet(part, sheet, sharedStrings, xfStyles, scope) {
         else if (record.type === BRT.MergeCell) {
             const { rowFirst, rowLast, colFirst, colLast } = reader.range();
             if (inGrid(colFirst, rowFirst) && inGrid(colLast, rowLast)) {
-                sheet.mergeCells(`${encodeAddress(colFirst + 1, rowFirst + 1)}:${encodeAddress(colLast + 1, rowLast + 1)}`);
+                sheet.mergeCells(encodeRect({
+                    top: rowFirst + 1,
+                    left: colFirst + 1,
+                    bottom: rowLast + 1,
+                    right: colLast + 1,
+                }));
             }
         }
         else if (record.type === BRT.ArrFmla) {
@@ -58,36 +72,10 @@ export function parseWorksheet(part, sheet, sharedStrings, xfStyles, scope) {
                 rgcb: reader.bytes(reader.u32()),
             });
         }
-        else if ((CELL_RECORDS.has(record.type) || FORMULA_RECORDS.has(record.type)) && row > 0) {
-            const { column, styleIndex } = reader.cell();
-            if (!inGrid(column, row - 1))
-                continue;
-            const resolved = styleIndex > 0 ? styleIndex : rowStyle >= 0 ? rowStyle : (columnStyle.get(column) ?? -1);
-            const style = resolved >= 0 ? xfStyles[resolved] : xfStyles[0];
-            const cell = sheet.getCell(encodeAddress(column + 1, row));
-            applyXfToCell(cell, style);
-            if (!FORMULA_RECORDS.has(record.type)) {
-                cell.value = decodeCell(record.type, reader, sharedStrings, style?.numFmt);
-                continue;
-            }
-            const result = cachedResult(record.type, reader, style?.numFmt);
-            reader.skip(2);
-            const rgce = reader.bytes(reader.u32());
-            const rgcb = reader.bytes(reader.u32());
-            const anchor = formulaAnchor(rgce, rgcb);
-            if (anchor === undefined) {
-                cell.value = formulaValue(decodeFormula(rgce, rgcb, scope), result);
-            }
-            else {
-                deferred.push({
-                    cell,
-                    row: row - 1,
-                    column,
-                    anchorRow: anchor.row,
-                    anchorColumn: anchor.column,
-                    result,
-                });
-            }
+        else if (cellRecord !== undefined) {
+            const member = readCellRecord(cellRecord, reader, { ...context, row, rowStyle, columnStyle });
+            if (member !== undefined)
+                deferred.push(member);
         }
     }
     for (const member of deferred) {
@@ -99,6 +87,40 @@ export function parseWorksheet(part, sheet, sharedStrings, xfStyles, scope) {
                 : formulaValue(decodeFormula(group.rgce, group.rgcb, scope), member.result);
     }
 }
+function readCellRecord(record, reader, context) {
+    const { sheet, sharedStrings, xfStyles, scope, dateEpoch, row, rowStyle, columnStyle } = context;
+    if (row <= 0)
+        return undefined;
+    const { column, styleIndex } = reader.cell();
+    if (!inGrid(column, row - 1))
+        return undefined;
+    const resolved = styleIndex > 0 ? styleIndex : rowStyle >= 0 ? rowStyle : (columnStyle.get(column) ?? -1);
+    const style = resolved >= 0 ? xfStyles[resolved] : xfStyles[0];
+    const cell = sheet.getCell(encodeAddress(column + 1, row));
+    applyXfToCell(cell, style);
+    const ctx = { sharedStrings, numFmt: style?.numFmt, epoch: dateEpoch };
+    if (record.kind === 'value') {
+        cell.value = record.read(reader, ctx);
+        return undefined;
+    }
+    const result = record.read(reader, ctx);
+    reader.skip(2);
+    const rgce = reader.bytes(reader.u32());
+    const rgcb = reader.bytes(reader.u32());
+    const anchor = formulaAnchor(rgce, rgcb);
+    if (anchor === undefined) {
+        cell.value = formulaValue(decodeFormula(rgce, rgcb, scope), result);
+        return undefined;
+    }
+    return {
+        cell,
+        row: row - 1,
+        column,
+        anchorRow: anchor.row,
+        anchorColumn: anchor.column,
+        result,
+    };
+}
 function groupKey(row, column) {
     return `${row}:${column}`;
 }
@@ -108,49 +130,11 @@ function formulaValue(formula, result) {
     const stored = unmangleFunctions(formula);
     return result === undefined ? { formula: stored } : { formula: stored, result };
 }
-function cachedResult(type, reader, numFmt) {
-    switch (type) {
-        case BRT.FmlaNum:
-            return asNumberOrDate(reader.f64(), numFmt);
-        case BRT.FmlaBool:
-            return reader.u8() !== 0;
-        case BRT.FmlaError: {
-            const error = errorCodeFor(reader.u8());
-            return error === undefined ? undefined : { error };
-        }
-        default:
-            return reader.wideString();
-    }
-}
-const MAX_ROW_INDEX = 1048575;
-const MAX_COLUMN_INDEX = MAX_COLUMN - 1;
 function inGrid(column, row) {
     return column >= 0 && column <= MAX_COLUMN_INDEX && row >= 0 && row <= MAX_ROW_INDEX;
 }
-function decodeCell(type, reader, sharedStrings, numFmt) {
-    switch (type) {
-        case BRT.CellRk:
-            return asNumberOrDate(reader.rk(), numFmt);
-        case BRT.CellReal:
-            return asNumberOrDate(reader.f64(), numFmt);
-        case BRT.CellBool:
-            return reader.u8() !== 0;
-        case BRT.CellError: {
-            const error = errorCodeFor(reader.u8());
-            return error === undefined ? null : { error };
-        }
-        case BRT.CellSt:
-            return reader.wideString();
-        case BRT.CellRString:
-            return reader.richString();
-        case BRT.CellIsst:
-            return sharedStrings[reader.u32()] ?? '';
-        default:
-            return null;
-    }
-}
-function asNumberOrDate(value, numFmt) {
-    return numFmt !== undefined && isDateFormat(numFmt) ? serialToDate(value) : value;
+function asNumberOrDate(value, numFmt, epoch) {
+    return coerceDateSerial(value, numFmt, epoch);
 }
 function applyRow(reader, sheet, defaultRowHeight) {
     const index = reader.u32();

package/dist/io/xlsb/read.d.ts

@@ -1,5 +1,5 @@
 import { Workbook } from '../../core/workbook.ts';
-import { type ReadXlsxOptions } from '../opc/read-options.ts';
+import type { ReadPackageOptions } from '../opc/read-options.ts';
 /** The office-document part every `.xlsb` package is entered through. */
 export declare const XLSB_WORKBOOK_PART = "xl/workbook.bin";
 /**
@@ -11,10 +11,13 @@ export declare const XLSB_WORKBOOK_PART = "xl/workbook.bin";
  * @throws {PackageReadError} if the input is a ZIP that cannot be unpacked: a corrupt or
  *   truncated archive, or one exceeding the inflate bound (a probable zip bomb).
  */
-export declare function readXlsb(data: Uint8Array, options?: ReadXlsxOptions): Workbook;
+export declare function readXlsb(data: Uint8Array, options?: ReadPackageOptions): Workbook;
 /**
  * Build the model from an already-inflated `.xlsb` package. Separate from {@link readXlsb} so the
  * `.xlsx` reader can hand over a package it has already inflated and classified, rather than
  * inflating the same bytes twice.
+ *
+ * `documentPath` is where the package's own `_rels/.rels` says its workbook lives; it defaults to the
+ * conventional path for a caller holding nothing but the parts.
  */
-export declare function readXlsbPackage(files: Record<string, Uint8Array>): Workbook;
+export declare function readXlsbPackage(files: Record<string, Uint8Array>, documentPath?: string): Workbook;

package/dist/io/xlsb/read.js

@@ -1,36 +1,40 @@
 import { unmangleFunctions } from '../../core/formula.js';
 import { INTERNAL } from '../../core/internal.js';
 import { Workbook } from '../../core/workbook.js';
+import { quoted } from '../../errors.js';
 import { UnsupportedFormatError } from '../opc/errors.js';
-import { packageAccessors, parseRelationships, resolveWorkbookPart } from '../opc/read-opc.js';
-import { DEFAULT_MAX_UNCOMPRESSED } from '../opc/read-options.js';
-import { inflateSpreadsheetPackage } from '../opc/sniff-format.js';
+import { openSpreadsheetPackage, packageAccessors, readPartRelationships } from '../opc/read-opc.js';
+import { XlsbParseError } from './errors.js';
 import { decodeFormula } from './formula.js';
 import { RecordReader } from './primitives.js';
 import { parseSharedStrings } from './read-shared-strings.js';
 import { parseStyleTable } from './read-styles.js';
 import { parseWorksheet } from './read-worksheet.js';
-import { readRecords } from './record-stream.js';
+import { blockTracker, readRecords } from './record-stream.js';
 import { BRT } from './record-types.js';
 export const XLSB_WORKBOOK_PART = 'xl/workbook.bin';
 export function readXlsb(data, options = {}) {
-    const cap = options.maxUncompressedBytes ?? DEFAULT_MAX_UNCOMPRESSED;
-    return readXlsbPackage(inflateSpreadsheetPackage(data, cap));
+    const { files, documentPath, workbookXml } = openSpreadsheetPackage(data, options.maxUncompressedBytes);
+    if (workbookXml !== undefined) {
+        throw new UnsupportedFormatError('unknown', `not a valid .xlsb package: its office document ${quoted(documentPath)} is XML, not the binary ${XLSB_WORKBOOK_PART} a .xlsb carries; read it with readXlsx`);
+    }
+    return readXlsbPackage(files, documentPath);
 }
-export function readXlsbPackage(files) {
+export function readXlsbPackage(files, documentPath = XLSB_WORKBOOK_PART) {
     const { partText, partBytes } = packageAccessors(files);
-    const workbookPart = partBytes(XLSB_WORKBOOK_PART);
+    const workbookPart = partBytes(documentPath);
     if (workbookPart === undefined) {
-        throw new UnsupportedFormatError('unknown', `not a valid .xlsb package: ${XLSB_WORKBOOK_PART} is missing`);
+        throw new UnsupportedFormatError('unknown', `not a valid .xlsb package: ${quoted(documentPath)} is missing`);
     }
-    const rels = parseRelationships(partText('xl/_rels/workbook.bin.rels') ?? '');
-    const sharedStrings = parseSharedStrings(partBytes('xl/sharedStrings.bin'));
-    const { cellXfs, namedStyles, defaultFont } = parseStyleTable(partBytes('xl/styles.bin'));
+    const rels = readPartRelationships(documentPath, partText, partBytes);
+    const sharedStrings = parseSharedStrings(rels.relatedBytes('sharedStrings') ?? partBytes('xl/sharedStrings.bin'));
+    const { cellXfs, namedStyles, defaultFont } = parseStyleTable(rels.relatedBytes('styles') ?? partBytes('xl/styles.bin'));
     const workbook = new Workbook();
     if (namedStyles.length > 1)
         workbook[INTERNAL].restoreNamedStyles(namedStyles);
     workbook[INTERNAL].restoreDefaultFont(defaultFont);
     const declaration = readWorkbookPart(workbookPart);
+    workbook.dateEpoch = declaration.dateEpoch;
     const scope = {
         sheetNames: declaration.sheets.map((sheet) => sheet.name),
         externSheets: declaration.externSheets,
@@ -39,39 +43,45 @@ export function readXlsbPackage(files) {
     };
     for (const declared of declaration.sheets) {
         const sheet = workbook.addWorksheet(declared.name, { state: declared.state });
-        const target = declared.relId === undefined ? undefined : rels.get(declared.relId);
-        const part = target === undefined ? undefined : partBytes(resolveWorkbookPart(target));
+        const target = declared.relId === undefined ? undefined : rels.byId(declared.relId)?.target;
+        const part = target === undefined ? undefined : partBytes(rels.pathOf(target));
         if (part !== undefined)
-            parseWorksheet(part, sheet, sharedStrings, cellXfs, scope);
+            parseWorksheet(part, {
+                sheet,
+                sharedStrings,
+                xfStyles: cellXfs,
+                scope,
+                dateEpoch: declaration.dateEpoch,
+            });
     }
     for (const defined of definedNames(declaration, scope))
         workbook.defineName(defined);
     return workbook;
 }
+const WORKBOOK_BLOCKS = [
+    [BRT.BeginBundleShs, BRT.EndBundleShs, 'bundle'],
+    [BRT.BeginExternals, BRT.EndExternals, 'externals'],
+];
 function readWorkbookPart(part) {
     const sheets = [];
     const names = [];
     let externSheets = [];
-    let inBundle = false;
-    let inExternals = false;
+    const blocks = blockTracker(WORKBOOK_BLOCKS);
     let supportingBooks = 0;
     let selfSupBook;
+    let dateEpoch = 1900;
     for (const record of readRecords(part)) {
-        if (record.type === BRT.BeginBundleShs)
-            inBundle = true;
-        else if (record.type === BRT.EndBundleShs)
-            inBundle = false;
-        else if (record.type === BRT.BundleSh && inBundle)
+        if (blocks.boundary(record.type))
+            continue;
+        if (record.type === BRT.WbProp)
+            dateEpoch = readDateEpoch(record.data);
+        else if (record.type === BRT.BundleSh && blocks.isOpen('bundle'))
             sheets.push(readSheet(record.data));
-        else if (record.type === BRT.BeginExternals)
-            inExternals = true;
-        else if (record.type === BRT.EndExternals)
-            inExternals = false;
         else if (record.type === BRT.ExternSheet)
             externSheets = readExternSheets(record.data);
         else if (record.type === BRT.SupSelf)
             selfSupBook = supportingBooks++;
-        else if (inExternals)
+        else if (blocks.isOpen('externals'))
             supportingBooks++;
         else if (record.type === BRT.Name)
             names.push(readName(record.data));
@@ -81,8 +91,14 @@ function readWorkbookPart(part) {
         names,
         externSheets,
         selfSupBook: supportingBooks === 1 ? selfSupBook : undefined,
+        dateEpoch,
     };
 }
+function readDateEpoch(data) {
+    if (data.length < 4)
+        return 1900;
+    return (new RecordReader(data).u32() & 1) === 0 ? 1900 : 1904;
+}
 function readSheet(data) {
     const reader = new RecordReader(data);
     const state = SHEET_STATES[reader.u32()] ?? 'visible';
@@ -93,9 +109,11 @@ function readSheet(data) {
 function readExternSheets(data) {
     const reader = new RecordReader(data);
     const count = reader.u32();
+    if (count * XTI_BYTES > reader.remaining) {
+        throw new XlsbParseError(`BIFF12 externSheet table declares ${count} entries needing ${count * XTI_BYTES} bytes but ` +
+            `only ${reader.remaining} remain in the record`);
+    }
     const entries = [];
-    if (count * XTI_BYTES > reader.remaining)
-        return entries;
     for (let index = 0; index < count; index++) {
         entries.push({ supBook: reader.u32(), firstSheet: reader.i32(), lastSheet: reader.i32() });
     }

package/dist/io/xlsb/record-stream.d.ts

@@ -12,3 +12,33 @@ export interface BiffRecord {
  *   end of the part.
  */
 export declare function readRecords(part: Uint8Array): Generator<BiffRecord>;
+/**
+ * Track which `Begin…`/`End…` blocks a BIFF12 record stream is currently inside.
+ *
+ * BIFF12 is flat: a collection is a `BeginFonts` record, its members, then `EndFonts`, and a reader
+ * has to carry that state itself. Two readers here did, and only one did it legibly. The style reader
+ * kept an explicit collection with start and end tables; the workbook reader re-solved it with loose
+ * booleans in an if-else chain whose *ordering was load-bearing and unstated*: move the `EndExternals`
+ * arm below the catch-all that counts records inside the externals block and the count silently goes
+ * wrong. Answering "is this record a block boundary" separately from "what does this record mean"
+ * removes that constraint rather than documenting it.
+ *
+ * Each end names the block it closes, so an `EndFonts` cannot close `<fills>` the way a bare set of
+ * end markers allowed. Blocks are tracked independently, so two that a damaged file interleaves stay
+ * separate rather than one clearing the other.
+ *
+ * A block is declared as one `[start, end, block]` triple rather than as an entry in a start table
+ * and a matching entry in an end table. The two-table form let a caller pair `BeginFills` with
+ * `EndFonts` in a way that compiles and reads plausibly, which is the very mistake the paragraph
+ * above says this exists to prevent.
+ */
+export declare function blockTracker<T>(blocks: readonly (readonly [number, number, T])[]): BlockTracker<T>;
+export interface BlockTracker<T> {
+    /** Whether the stream is currently inside `block`. */
+    isOpen(block: T): boolean;
+    /**
+     * Take a record's type as a possible block boundary, returning whether it was one. A boundary
+     * carries no content of its own, so a caller that gets `true` skips the record entirely.
+     */
+    boundary(type: number): boolean;
+}

package/dist/io/xlsb/record-stream.js

@@ -26,3 +26,23 @@ function byteAt(part, index) {
         throw new XlsbParseError('truncated BIFF12 record header');
     return value;
 }
+export function blockTracker(blocks) {
+    const starts = new Map(blocks.map(([start, , block]) => [start, block]));
+    const ends = new Map(blocks.map(([, end, block]) => [end, block]));
+    const open = new Set();
+    return {
+        isOpen: (block) => open.has(block),
+        boundary(type) {
+            const ended = ends.get(type);
+            if (ended !== undefined) {
+                open.delete(ended);
+                return true;
+            }
+            const started = starts.get(type);
+            if (started === undefined)
+                return false;
+            open.add(started);
+            return true;
+        },
+    };
+}