@shbernal/ts-xlsx 3.1.0 → 3.2.0

package/dist/io/style/cell-style-resolution.js

@@ -0,0 +1,30 @@
+export class CellStyleResolver {
+    #columnStyle = new Map();
+    #rowStyle = -1;
+    noteColumnSpan(first, last, styleIndex) {
+        if (styleIndex < 0)
+            return;
+        for (let index = first; index <= last; index++)
+            this.#columnStyle.set(index, styleIndex);
+    }
+    openRow(styleIndex, customFormat) {
+        this.#rowStyle = customFormat ? styleIndex : -1;
+    }
+    closeRow() {
+        this.#rowStyle = -1;
+    }
+    styleFor(col, cellStyleIndex, xfStyles) {
+        const index = this.#indexFor(col, cellStyleIndex);
+        return xfStyles[index < 0 ? 0 : index];
+    }
+    declaresFormat(col, cellStyleIndex) {
+        return this.#indexFor(col, cellStyleIndex) >= 0;
+    }
+    #indexFor(col, cellStyleIndex) {
+        if (cellStyleIndex >= 0)
+            return cellStyleIndex;
+        if (this.#rowStyle >= 0)
+            return this.#rowStyle;
+        return this.#columnStyle.get(col) ?? -1;
+    }
+}

package/dist/io/xlsb/formula.js

@@ -22,7 +22,7 @@ function decodeTokens(rgce, rgcb, scope) {
         stack,
         scope,
         push: (text) => {
-            if (text === undefined)
+            if (text === undefined || text.length > MAX_DECODED_FORMULA_LENGTH)
                 return false;
             stack.push(text);
             return true;
@@ -81,7 +81,7 @@ function step(ptg, decode) {
         case PTG.Num:
             return push(numberLiteral(tokens.f64()));
         default:
-            return ptg >= CLASSED_TOKEN_FLOOR
+            return ptg >= CLASSED_TOKEN_FLOOR && ptg <= CLASSED_TOKEN_CEILING
                 ? operand((ptg & CLASSED_TOKEN_MASK) | CLASSED_TOKEN_FLOOR, decode)
                 : false;
     }
@@ -299,7 +299,9 @@ const PTG = {
     AreaErr3d: 0x3d,
 };
 const CLASSED_TOKEN_FLOOR = 0x20;
+const CLASSED_TOKEN_CEILING = 0x7f;
 const CLASSED_TOKEN_MASK = 0x1f;
+const MAX_DECODED_FORMULA_LENGTH = 4 * 8_192;
 const ATTR_CHOOSE = 0x04;
 const ATTR_SUM = 0x10;
 const FUNCVAR_PARAM_MASK = 0x7f;

package/dist/io/xlsb/ptg-functions.js

@@ -398,6 +398,116 @@ const RUNS = [
             ['RTD', 'variadic'],
         ],
     ],
+    [
+        0x017c,
+        [
+            ['CUBEVALUE', 'variadic'],
+            ['CUBEMEMBER', 'variadic'],
+            ['CUBEMEMBERPROPERTY', 3],
+            ['CUBERANKEDMEMBER', 'variadic'],
+            ['HEX2BIN', 'variadic'],
+            ['HEX2DEC', 1],
+            ['HEX2OCT', 'variadic'],
+            ['DEC2BIN', 'variadic'],
+            ['DEC2HEX', 'variadic'],
+            ['DEC2OCT', 'variadic'],
+            ['OCT2BIN', 'variadic'],
+            ['OCT2HEX', 'variadic'],
+            ['OCT2DEC', 1],
+            ['BIN2DEC', 1],
+            ['BIN2OCT', 'variadic'],
+            ['BIN2HEX', 'variadic'],
+            ['IMSUB', 2],
+            ['IMDIV', 2],
+            ['IMPOWER', 2],
+            ['IMABS', 1],
+            ['IMSQRT', 1],
+            ['IMLN', 1],
+            ['IMLOG2', 1],
+            ['IMLOG10', 1],
+            ['IMSIN', 1],
+            ['IMCOS', 1],
+            ['IMEXP', 1],
+            ['IMARGUMENT', 1],
+            ['IMCONJUGATE', 1],
+            ['IMAGINARY', 1],
+            ['IMREAL', 1],
+            ['COMPLEX', 'variadic'],
+            ['IMSUM', 'variadic'],
+            ['IMPRODUCT', 'variadic'],
+            ['SERIESSUM', 4],
+            ['FACTDOUBLE', 1],
+            ['SQRTPI', 1],
+            ['QUOTIENT', 2],
+            ['DELTA', 'variadic'],
+            ['GESTEP', 'variadic'],
+            ['ISEVEN', 1],
+            ['ISODD', 1],
+            ['MROUND', 2],
+            ['ERF', 'variadic'],
+            ['ERFC', 1],
+            ['BESSELJ', 2],
+            ['BESSELK', 2],
+            ['BESSELY', 2],
+            ['BESSELI', 2],
+            ['XIRR', 'variadic'],
+            ['XNPV', 3],
+            ['PRICEMAT', 'variadic'],
+            ['YIELDMAT', 'variadic'],
+            ['INTRATE', 'variadic'],
+            ['RECEIVED', 'variadic'],
+            ['DISC', 'variadic'],
+            ['PRICEDISC', 'variadic'],
+            ['YIELDDISC', 'variadic'],
+            ['TBILLEQ', 3],
+            ['TBILLPRICE', 3],
+            ['TBILLYIELD', 3],
+            ['PRICE', 'variadic'],
+            ['YIELD', 'variadic'],
+            ['DOLLARDE', 2],
+            ['DOLLARFR', 2],
+            ['NOMINAL', 2],
+            ['EFFECT', 2],
+            ['CUMPRINC', 6],
+            ['CUMIPMT', 6],
+            ['EDATE', 2],
+            ['EOMONTH', 2],
+            ['YEARFRAC', 'variadic'],
+            ['COUPDAYBS', 'variadic'],
+            ['COUPDAYS', 'variadic'],
+            ['COUPDAYSNC', 'variadic'],
+            ['COUPNCD', 'variadic'],
+            ['COUPNUM', 'variadic'],
+            ['COUPPCD', 'variadic'],
+            ['DURATION', 'variadic'],
+            ['MDURATION', 'variadic'],
+            ['ODDLPRICE', 'variadic'],
+            ['ODDLYIELD', 'variadic'],
+            ['ODDFPRICE', 'variadic'],
+            ['ODDFYIELD', 'variadic'],
+            ['RANDBETWEEN', 2],
+            ['WEEKNUM', 'variadic'],
+            ['AMORDEGRC', 'variadic'],
+            ['AMORLINC', 'variadic'],
+            ['CONVERT', 3],
+            ['ACCRINT', 'variadic'],
+            ['ACCRINTM', 'variadic'],
+            ['WORKDAY', 'variadic'],
+            ['NETWORKDAYS', 'variadic'],
+            ['GCD', 'variadic'],
+            ['MULTINOMIAL', 'variadic'],
+            ['LCM', 'variadic'],
+            ['FVSCHEDULE', 2],
+            ['CUBEKPIMEMBER', 'variadic'],
+            ['CUBESET', 'variadic'],
+            ['CUBESETCOUNT', 1],
+            ['IFERROR', 2],
+            ['COUNTIFS', 'variadic'],
+            ['SUMIFS', 'variadic'],
+            ['AVERAGEIF', 'variadic'],
+            ['AVERAGEIFS', 'variadic'],
+        ],
+    ],
 ];
 const TABLE = [];
 for (const [start, entries] of RUNS) {

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-worksheet.d.ts

@@ -1,5 +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';
 /**
@@ -25,4 +26,9 @@ export interface WorksheetReadContext {
     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,12 +1,17 @@
-import { encodeAddress, encodeRect, MAX_COLUMN_INDEX, MAX_ROW_INDEX } from '../../core/address.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';
+import { SheetProtectionRecords } from './sheet-protection.js';
 const value = (read) => ({
     kind: 'value',
     read,
@@ -14,30 +19,33 @@ const 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.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) => errorValueOrNull(r.u8()))],
+    [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) => asNumberOrDate(r.f64(), c.numFmt, c.epoch))],
+    [BRT.FmlaNum, formula((r, c) => coerceDateSerial(r.f64(), c.numFmt, c.epoch))],
     [BRT.FmlaBool, formula((r) => r.u8() !== 0)],
-    [BRT.FmlaError, formula((r) => errorValueOrNull(r.u8()) ?? undefined)],
+    [BRT.FmlaError, formula((r, c) => errorOf(r.u8(), c.valueError) ?? undefined)],
     [BRT.FmlaString, formula((r) => r.wideString())],
 ]);
-function errorValueOrNull(code) {
-    const error = errorCodeFor(code);
+function errorOf(code, valueError) {
+    const error = valueError ?? errorCodeFor(code);
     return error === undefined ? null : { error };
 }
 export function parseWorksheet(part, context) {
-    const { sheet, xfStyles, scope } = 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);
@@ -46,59 +54,100 @@ export function parseWorksheet(part, context) {
             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(encodeRect({
+                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 (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, rowStyle, columnStyle });
+            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, row, rowStyle, columnStyle } = 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 resolved = styleIndex > 0 ? styleIndex : rowStyle >= 0 ? rowStyle : (columnStyle.get(column) ?? -1);
-    const style = resolved >= 0 ? xfStyles[resolved] : xfStyles[0];
+    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 };
+    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;
@@ -109,7 +158,7 @@ function readCellRecord(record, reader, context) {
     const rgcb = reader.bytes(reader.u32());
     const anchor = formulaAnchor(rgce, rgcb);
     if (anchor === undefined) {
-        cell.value = formulaValue(decodeFormula(rgce, rgcb, scope), result);
+        cell.value = formulaValue(decodeFormula(rgce, rgcb, scope), result, definedNames);
         return undefined;
     }
     return {
@@ -119,23 +168,32 @@ function readCellRecord(record, reader, context) {
         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 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 }),
+    };
+}
 function inGrid(column, row) {
     return column >= 0 && column <= MAX_COLUMN_INDEX && row >= 0 && row <= MAX_ROW_INDEX;
 }
-function asNumberOrDate(value, numFmt, epoch) {
-    return coerceDateSerial(value, numFmt, epoch);
-}
 function applyRow(reader, sheet, defaultRowHeight) {
     const index = reader.u32();
     const styleIndex = reader.u32();
@@ -143,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) {
@@ -156,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;
@@ -164,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();
@@ -177,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;
@@ -191,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.js

@@ -1,12 +1,16 @@
-import { unmangleFunctions } from '../../core/formula.js';
+import { definedNameKeys, unmangleFunctions } from '../../core/formula.js';
 import { INTERNAL } from '../../core/internal.js';
 import { Workbook } from '../../core/workbook.js';
 import { quoted } from '../../errors.js';
+import { indexCellMetadata } from '../cell-metadata/metadata.js';
+import { parseRichValueErrors } from '../cell-metadata/rich-values.js';
 import { UnsupportedFormatError } from '../opc/errors.js';
 import { openSpreadsheetPackage, packageAccessors, readPartRelationships } from '../opc/read-opc.js';
+import { admitting, repairedSheetNames } from '../read-policy/read-repair.js';
 import { XlsbParseError } from './errors.js';
 import { decodeFormula } from './formula.js';
 import { RecordReader } from './primitives.js';
+import { parseMetadataPart } from './read-metadata.js';
 import { parseSharedStrings } from './read-shared-strings.js';
 import { parseStyleTable } from './read-styles.js';
 import { parseWorksheet } from './read-worksheet.js';
@@ -35,13 +39,16 @@ export function readXlsbPackage(files, documentPath = XLSB_WORKBOOK_PART) {
     workbook[INTERNAL].restoreDefaultFont(defaultFont);
     const declaration = readWorkbookPart(workbookPart);
     workbook.dateEpoch = declaration.dateEpoch;
+    const sheets = repairedSheetNames(declaration.sheets);
     const scope = {
-        sheetNames: declaration.sheets.map((sheet) => sheet.name),
+        sheetNames: sheets.map((sheet) => sheet.name),
         externSheets: declaration.externSheets,
         selfSupBook: declaration.selfSupBook,
         names: declaration.names.map((name) => name.name),
     };
-    for (const declared of declaration.sheets) {
+    const namesInWorkbook = definedNameKeys(declaration.names.filter(isWorkbookName));
+    const cellMetadata = indexCellMetadata(parseMetadataPart(rels.relatedBytes('sheetMetadata')), parseRichValueErrors(rels.relatedText('rdRichValueStructure') ?? '', rels.relatedText('rdRichValue') ?? ''));
+    for (const declared of sheets) {
         const sheet = workbook.addWorksheet(declared.name, { state: declared.state });
         const target = declared.relId === undefined ? undefined : rels.byId(declared.relId)?.target;
         const part = target === undefined ? undefined : partBytes(rels.pathOf(target));
@@ -52,10 +59,15 @@ export function readXlsbPackage(files, documentPath = XLSB_WORKBOOK_PART) {
                 xfStyles: cellXfs,
                 scope,
                 dateEpoch: declaration.dateEpoch,
+                definedNames: namesInWorkbook,
+                cellMetadata,
             });
     }
-    for (const defined of definedNames(declaration, scope))
-        workbook.defineName(defined);
+    for (const defined of definedNames(declaration, scope, namesInWorkbook)) {
+        admitting(() => {
+            workbook.defineName(defined);
+        });
+    }
     return workbook;
 }
 const WORKBOOK_BLOCKS = [
@@ -138,10 +150,10 @@ function readName(data) {
 }
 const GLOBAL_NAME_SCOPE = 0xffffffff;
 const NAME_IS_FUNCTION = 0x00000002;
-function definedNames(declaration, scope) {
+function definedNames(declaration, scope, namesInWorkbook) {
     const names = [];
     for (const declared of declaration.names) {
-        if (declared.isFunction || declared.name === FILTER_DATABASE_NAME)
+        if (!isWorkbookName(declared))
             continue;
         const refersTo = decodeFormula(declared.rgce, declared.rgcb, scope);
         if (refersTo === undefined)
@@ -150,10 +162,16 @@ function definedNames(declaration, scope) {
         names.push({
             name: declared.name,
             ...(sheet === undefined ? {} : { scope: sheet }),
-            refersTo: unmangleFunctions(refersTo),
+            refersTo: unmangleFunctions(refersTo, namesInWorkbook),
         });
     }
     return names;
 }
+function isWorkbookName(declared) {
+    return (!declared.isFunction &&
+        !FORMULA_PLACEHOLDER_NAME.test(declared.name) &&
+        declared.name !== FILTER_DATABASE_NAME);
+}
+const FORMULA_PLACEHOLDER_NAME = /^_xl(?:fn|pm|eta)\./;
 const FILTER_DATABASE_NAME = '_xlnm._FilterDatabase';
 const SHEET_STATES = ['visible', 'hidden', 'veryHidden'];

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

@@ -48,4 +48,17 @@ export declare const BRT: {
     readonly ExternSheet: 362;
     readonly WsFmtInfo: 485;
     readonly ArrFmla: 426;
+    readonly SheetProtection: 535;
+    readonly SheetProtectionIso: 678;
+    readonly CellMeta: 49;
+    readonly ValueMeta: 50;
+    readonly Mdtinfo: 335;
+    readonly BeginEsfmd: 339;
+    readonly EndEsfmd: 340;
+    readonly BeginFmd: 52;
+    readonly BeginEsmdb: 337;
+    readonly EndEsmdb: 338;
+    readonly Mdb: 51;
+    readonly DynamicArrayProperties: 4097;
+    readonly RichValueBlock: 5003;
 };

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

@@ -47,4 +47,17 @@ export const BRT = {
     ExternSheet: 362,
     WsFmtInfo: 485,
     ArrFmla: 426,
+    SheetProtection: 535,
+    SheetProtectionIso: 678,
+    CellMeta: 49,
+    ValueMeta: 50,
+    Mdtinfo: 335,
+    BeginEsfmd: 339,
+    EndEsfmd: 340,
+    BeginFmd: 52,
+    BeginEsmdb: 337,
+    EndEsmdb: 338,
+    Mdb: 51,
+    DynamicArrayProperties: 4097,
+    RichValueBlock: 5003,
 };