@shbernal/ts-xlsx 3.0.0 → 3.2.0

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

@@ -0,0 +1,7 @@
+import { type WorkbookMetadata } from '../cell-metadata/metadata.ts';
+/**
+ * Read `xl/metadata.bin` as far as a cell's metadata indices reach into it.
+ *
+ * @throws {XlsbParseError} if a record the model reads is shorter than its fields.
+ */
+export declare function parseMetadataPart(part: Uint8Array | undefined): WorkbookMetadata;

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

@@ -0,0 +1,69 @@
+import { DYNAMIC_ARRAY_TYPE, NO_METADATA, RICH_VALUE_TYPE, } from '../cell-metadata/metadata.js';
+import { RecordReader } from './primitives.js';
+import { readRecords } from './record-stream.js';
+import { BRT } from './record-types.js';
+export function parseMetadataPart(part) {
+    if (part === undefined)
+        return NO_METADATA;
+    const typeNames = [];
+    const dynamicArrayBlocks = [];
+    const richValueBlocks = [];
+    const cellBlocks = [];
+    const valueBlocks = [];
+    let futureType;
+    let blocks;
+    for (const record of readRecords(part)) {
+        const reader = new RecordReader(record.data);
+        switch (record.type) {
+            case BRT.Mdtinfo:
+                reader.skip(8);
+                typeNames.push(reader.wideString());
+                break;
+            case BRT.BeginEsfmd:
+                reader.skip(4);
+                futureType = reader.wideString();
+                break;
+            case BRT.EndEsfmd:
+                futureType = undefined;
+                break;
+            case BRT.BeginFmd:
+                if (futureType === DYNAMIC_ARRAY_TYPE)
+                    dynamicArrayBlocks.push(false);
+                else if (futureType === RICH_VALUE_TYPE)
+                    richValueBlocks.push(-1);
+                break;
+            case BRT.DynamicArrayProperties:
+                if (futureType === DYNAMIC_ARRAY_TYPE && dynamicArrayBlocks.length > 0) {
+                    dynamicArrayBlocks[dynamicArrayBlocks.length - 1] = (reader.u8() & 1) !== 0;
+                }
+                break;
+            case BRT.RichValueBlock:
+                if (futureType === RICH_VALUE_TYPE && richValueBlocks.length > 0) {
+                    reader.skip(4);
+                    richValueBlocks[richValueBlocks.length - 1] = reader.u32();
+                }
+                break;
+            case BRT.BeginEsmdb:
+                reader.skip(4);
+                blocks = (reader.u32() & 1) !== 0 ? cellBlocks : valueBlocks;
+                break;
+            case BRT.EndEsmdb:
+                blocks = undefined;
+                break;
+            case BRT.Mdb:
+                blocks?.push(metadataRecords(reader));
+                break;
+            default:
+                break;
+        }
+    }
+    return { typeNames, dynamicArrayBlocks, richValueBlocks, cellBlocks, valueBlocks };
+}
+function metadataRecords(reader) {
+    const count = reader.u32();
+    const records = [];
+    while (records.length < count && reader.remaining >= 8) {
+        records.push({ type: reader.u32(), value: reader.u32() });
+    }
+    return records;
+}

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

@@ -1,25 +1,17 @@
-import { numFmtCodeFor, NO_PRESERVED_STYLE_TABLES, 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: [], preserved: NO_PRESERVED_STYLE_TABLES };
@@ -30,43 +22,36 @@ 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;
-            continue;
-        }
-        const started = COLLECTION_STARTS.get(record.type);
-        if (started !== undefined) {
-            collection = started;
+        if (blocks.boundary(record.type))
             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:
@@ -110,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,
@@ -208,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);
@@ -225,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,4 +1,6 @@
+import { type DateEpoch } from '../../core/date.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
+import type { CellMetadataIndex } from '../cell-metadata/metadata.ts';
 import { type XfStyle } from '../style/xf-style.ts';
 import { type FormulaScope } from './formula.ts';
 /**
@@ -6,4 +8,27 @@ 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;
+    /** Every name the workbook defines, as `definedNameKeys` spells them: whether a function a formula
+     * passes as a value sheds its `_xleta.` depends on them, as it does in the XML reader. */
+    readonly definedNames: ReadonlySet<string>;
+    /** What the workbook's cell and value metadata indices resolve to, read from its metadata part. */
+    readonly cellMetadata: CellMetadataIndex;
+}

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

@@ -1,157 +1,199 @@
-import { encodeAddress, MAX_COLUMN } from '../../core/address.js';
-import { isDateFormat, serialToDate } from '../../core/date.js';
+import { encodeAddress, encodeRange, encodeRect, MAX_COLUMN_INDEX, MAX_ROW_INDEX, } from '../../core/address.js';
+import { coerceDateSerial } from '../../core/date.js';
 import { unmangleFunctions } from '../../core/formula.js';
+import { INTERNAL } from '../../core/internal.js';
 import { assignStyleFacets } from '../../core/style.js';
+import { ColumnRecordBudget, clampColumnSpan } from '../read-policy/column-budget.js';
+import { admitArrayRanges, admitting } from '../read-policy/read-repair.js';
+import { CellStyleResolver } from '../style/cell-style-resolution.js';
 import { applyXfToCell } from '../style/xf-style.js';
 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,
+import { SheetProtectionRecords } from './sheet-protection.js';
+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) => coerceDateSerial(r.rk(), c.numFmt, c.epoch))],
+    [BRT.CellReal, value((r, c) => coerceDateSerial(r.f64(), c.numFmt, c.epoch))],
+    [BRT.CellBool, value((r) => r.u8() !== 0)],
+    [BRT.CellError, value((r, c) => errorOf(r.u8(), c.valueError))],
+    [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) => coerceDateSerial(r.f64(), c.numFmt, c.epoch))],
+    [BRT.FmlaBool, formula((r) => r.u8() !== 0)],
+    [BRT.FmlaError, formula((r, c) => errorOf(r.u8(), c.valueError) ?? 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 errorOf(code, valueError) {
+    const error = valueError ?? errorCodeFor(code);
+    return error === undefined ? null : { error };
+}
+export function parseWorksheet(part, context) {
+    const { sheet, xfStyles, scope, definedNames } = context;
     let row = -1;
-    let rowStyle = -1;
-    const columnStyle = new Map();
+    const styleResolution = new CellStyleResolver();
     let defaultRowHeight = -1;
     const groups = new Map();
     const deferred = [];
+    const columnBudget = new ColumnRecordBudget();
+    const protection = new SheetProtectionRecords();
+    let cellMeta = 0;
+    let valueMeta = 0;
     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);
             defaultRowHeight = reader.u16();
         }
         else if (record.type === BRT.ColInfo) {
-            applyColumn(reader, sheet, xfStyles, columnStyle);
+            applyColumn(reader, sheet, xfStyles, styleResolution, columnBudget);
         }
         else if (record.type === BRT.RowHdr) {
             const header = applyRow(reader, sheet, defaultRowHeight);
             row = header.row;
-            rowStyle = header.styleIndex;
+            styleResolution.openRow(header.styleIndex, header.customFormat);
         }
         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)}`);
+                const ref = encodeRect({
+                    top: rowFirst + 1,
+                    left: colFirst + 1,
+                    bottom: rowLast + 1,
+                    right: colLast + 1,
+                });
+                admitting(() => {
+                    sheet.mergeCells(ref);
+                });
             }
         }
+        else if (record.type === BRT.SheetProtection) {
+            protection.legacy(reader);
+        }
+        else if (record.type === BRT.SheetProtectionIso) {
+            protection.iso(reader);
+        }
         else if (record.type === BRT.ArrFmla) {
-            const { rowFirst, colFirst } = reader.range();
+            const { rowFirst, rowLast, colFirst, colLast } = reader.range();
             reader.skip(1);
+            const inGridRange = inGrid(colFirst, rowFirst) && inGrid(colLast, rowLast);
             groups.set(groupKey(rowFirst, colFirst), {
+                ref: inGridRange
+                    ? encodeRange({
+                        top: rowFirst + 1,
+                        left: colFirst + 1,
+                        bottom: rowLast + 1,
+                        right: colLast + 1,
+                    })
+                    : undefined,
                 rgce: reader.bytes(reader.u32()),
                 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 (record.type === BRT.CellMeta) {
+            cellMeta = reader.u32();
+        }
+        else if (record.type === BRT.ValueMeta) {
+            valueMeta = reader.u32();
+        }
+        else if (cellRecord !== undefined) {
+            const member = readCellRecord(cellRecord, reader, {
+                ...context,
+                row,
+                styleResolution,
+                cellMeta,
+                valueMeta,
+            });
+            cellMeta = 0;
+            valueMeta = 0;
+            if (member !== undefined)
+                deferred.push(member);
         }
     }
+    const protectedAs = protection.result();
+    if (protectedAs !== undefined)
+        sheet[INTERNAL].restoreProtection(protectedAs);
     for (const member of deferred) {
         const group = groups.get(groupKey(member.anchorRow, member.anchorColumn));
         const own = member.row === member.anchorRow && member.column === member.anchorColumn;
         member.cell.value =
             group === undefined || !own
                 ? (member.result ?? null)
-                : formulaValue(decodeFormula(group.rgce, group.rgcb, scope), member.result);
+                : arrayFormulaValue(decodeFormula(group.rgce, group.rgcb, scope), group.ref, member.result, definedNames, member.dynamic);
+    }
+    admitArrayRanges(sheet);
+}
+function readCellRecord(record, reader, context) {
+    const { sheet, sharedStrings, xfStyles, scope, dateEpoch, definedNames, row, styleResolution } = context;
+    const { cellMetadata, cellMeta, valueMeta } = context;
+    if (row <= 0)
+        return undefined;
+    const { column, styleIndex } = reader.cell();
+    if (!inGrid(column, row - 1))
+        return undefined;
+    const style = styleResolution.styleFor(column + 1, styleIndex > 0 ? styleIndex : -1, xfStyles);
+    const cell = sheet.getCell(encodeAddress(column + 1, row));
+    applyXfToCell(cell, style);
+    const ctx = {
+        sharedStrings,
+        numFmt: style?.numFmt,
+        epoch: dateEpoch,
+        valueError: cellMetadata.valueErrors.get(valueMeta),
+    };
+    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, definedNames);
+        return undefined;
     }
+    return {
+        cell,
+        row: row - 1,
+        column,
+        anchorRow: anchor.row,
+        anchorColumn: anchor.column,
+        result,
+        dynamic: cellMetadata.dynamicArrayCells.has(cellMeta),
+    };
 }
 function groupKey(row, column) {
     return `${row}:${column}`;
 }
-function formulaValue(formula, result) {
+function formulaValue(formula, result, definedNames) {
     if (formula === undefined)
         return result ?? null;
-    const stored = unmangleFunctions(formula);
+    const stored = unmangleFunctions(formula, definedNames);
     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();
-    }
+function arrayFormulaValue(formula, ref, result, definedNames, dynamic) {
+    if (formula === undefined || ref === undefined)
+        return formulaValue(formula, result, definedNames);
+    return {
+        shareType: 'array',
+        formula: unmangleFunctions(formula, definedNames),
+        ref,
+        ...(dynamic ? { dynamic: true } : {}),
+        ...(result === undefined ? {} : { result }),
+    };
 }
-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 applyRow(reader, sheet, defaultRowHeight) {
     const index = reader.u32();
     const styleIndex = reader.u32();
@@ -159,7 +201,7 @@ function applyRow(reader, sheet, defaultRowHeight) {
     reader.skip(1);
     const flags = reader.u8();
     if (index > MAX_ROW_INDEX)
-        return { row: -1, styleIndex: -1 };
+        return { row: -1, styleIndex: -1, customFormat: false };
     const row = index + 1;
     const handle = sheet.getRow(row);
     if ((flags & ROW_CUSTOM_HEIGHT) !== 0 || height !== defaultRowHeight) {
@@ -172,7 +214,7 @@ function applyRow(reader, sheet, defaultRowHeight) {
         handle.outlineLevel = outlineLevel;
     if ((flags & ROW_COLLAPSED) !== 0)
         handle.collapsed = true;
-    return { row, styleIndex: (flags & ROW_CUSTOM_FORMAT) !== 0 ? styleIndex : -1 };
+    return { row, styleIndex, customFormat: (flags & ROW_CUSTOM_FORMAT) !== 0 };
 }
 const TWIPS_PER_POINT = 20;
 const ROW_OUTLINE_LEVEL = 0b0000_0111;
@@ -180,7 +222,7 @@ const ROW_COLLAPSED = 0b0000_1000;
 const ROW_HIDDEN = 0b0001_0000;
 const ROW_CUSTOM_HEIGHT = 0b0010_0000;
 const ROW_CUSTOM_FORMAT = 0b0100_0000;
-function applyColumn(reader, sheet, xfStyles, columnStyle) {
+function applyColumn(reader, sheet, xfStyles, styleResolution, budget) {
     const first = reader.u32();
     const last = reader.u32();
     const width = reader.u32();
@@ -193,11 +235,11 @@ function applyColumn(reader, sheet, xfStyles, columnStyle) {
         (flags & (COLUMN_HIDDEN | COLUMN_CUSTOM_WIDTH | COLUMN_COLLAPSED)) === 0) {
         return;
     }
-    const lastInGrid = Math.min(last, MAX_COLUMN_INDEX);
-    if (first > lastInGrid)
+    const span = clampColumnSpan(first + 1, last + 1, budget);
+    if (span === undefined)
         return;
-    for (let index = first; index <= lastInGrid; index++) {
-        const column = sheet.getColumn(index + 1);
+    for (let index = span.first; index <= span.last; index++) {
+        const column = sheet.getColumn(index);
         column.width = width / COLUMN_WIDTH_UNITS;
         if ((flags & COLUMN_HIDDEN) !== 0)
             column.hidden = true;
@@ -207,9 +249,9 @@ function applyColumn(reader, sheet, xfStyles, columnStyle) {
             column.collapsed = true;
         if (style !== undefined)
             assignStyleFacets(column, style);
-        if (styleIndex > 0)
-            columnStyle.set(index, styleIndex);
     }
+    if (styleIndex > 0)
+        styleResolution.noteColumnSpan(span.first, span.last, styleIndex);
 }
 const COLUMN_WIDTH_UNITS = 256;
 const COLUMN_HIDDEN = 0b0000_0001;

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;