@rowsncolumns/toolkit 24.5.18 → 24.5.19

package/dist/esm/excel-parser/plugins/xlsb/index.js

@@ -2,7 +2,9 @@ import { getCellXfsKey, ssfFormat, uuid } from "@rowsncolumns/utils";
 import { IndexedColors } from "@rowsncolumns/utils";
 import { XMLParser } from "fast-xml-parser";
 import { get } from "lodash-es";
-import { parseRgce } from "./rgce-parser";
+import { namedRangesForDefinedName } from "../../defined-names";
+import { isBuiltinPrintName } from "../../../print-settings";
+import { decodeRgce, parseRgce, quoteSheetName, RgceUnsupportedError, } from "./rgce-parser";
 import { StreamingZipParser } from "../../zip-parser-streaming";
 import { createFilterSpecsFromAutoFilter, createSortSpecsFromSortState, excelColumnWidthToPixels, getRangeFromAddressRef, hiddenFilterButtonColumns, parseTableColumnTotals, } from "../../helpers";
 import { defaultSpreadsheetTheme } from "../../theme-default";
@@ -57,6 +59,7 @@ const RT = {
     BrtSupBookSrc: 0x0163,
     BrtSupSelf: 0x0165,
     BrtSupSame: 0x0166,
+    BrtSupAddin: 0x029b,
     BrtExternSheet: 0x016a,
     BrtDrawing: 0x0226,
     BrtBeginAFilter: 0x00a1,
@@ -74,7 +77,10 @@ const RT = {
     BrtEndDVal: 0x0104,
     BrtWbProp: 0x0099,
     BrtCalcProp: 0x009d,
-    BrtShrFmla: 0x0018,
+    // [MS-XLSB] 2.3.2: BrtArrFmla 426, BrtShrFmla 427. A shared formula's
+    // cells each hold a PtgExp naming its first row.
+    BrtArrFmla: 0x01aa,
+    BrtShrFmla: 0x01ab,
     BrtCFRule: 0x01df,
     BrtDVal: 0x0103,
 };
@@ -238,38 +244,31 @@ const parseBrtExternSheet = (payload) => {
     }
     return [];
 };
+const emptyFormulaDecodeStats = () => ({
+    decoded: 0,
+    unsupported: 0,
+    reasons: {},
+    definedNames: { decoded: 0, unsupported: 0 },
+});
+const PTG_EXP = 0x01;
+/** A PtgExp: the token and the shared formula's first row (4 bytes). */
+const PTG_EXP_LENGTH = 5;
+const readUInt32 = (bytes, at) => new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(at, true);
 const parseBrtShrFmla = (payload) => {
+    // RfX (rwFirst, rwLast, colFirst, colLast: 4 bytes each), then the formula:
+    // cce (4 bytes) and cce bytes of tokens ([MS-XLSB] 2.4.758).
     if (payload.length < 20)
         return null;
-    const reader = new Reader(payload);
-    const startRowZero = reader.readUInt32LE();
-    const endRowZero = reader.readUInt32LE();
-    const startColZero = reader.readUInt32LE();
-    const endColZero = reader.readUInt32LE();
-    // cce can be preceded by small metadata in some files; try a few offsets.
-    const candidateOffsets = [16, 18, 20, 24];
-    let rgceBytes;
-    for (const offset of candidateOffsets) {
-        if (offset + 4 > payload.length)
-            continue;
-        const cce = new DataView(payload.buffer, payload.byteOffset + offset, 4).getUint32(0, true);
-        if (cce <= 0)
-            continue;
-        const start = offset + 4;
-        const end = start + cce;
-        if (end <= payload.length) {
-            rgceBytes = payload.subarray(start, end);
-            break;
-        }
-    }
-    if (!rgceBytes || rgceBytes.length === 0)
+    const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+    const cce = view.getUint32(16, true);
+    if (cce === 0 || 20 + cce > payload.length)
         return null;
     return {
-        startRow: startRowZero + 1,
-        endRow: endRowZero + 1,
-        startCol: startColZero + 1,
-        endCol: endColZero + 1,
-        rgceBytes,
+        startRow: view.getUint32(0, true) + 1,
+        endRow: view.getUint32(4, true) + 1,
+        startCol: view.getUint32(8, true) + 1,
+        endCol: view.getUint32(12, true) + 1,
+        rgceBytes: payload.subarray(20, 20 + cce),
     };
 };
 const parseWsView = (payload) => {
@@ -300,39 +299,46 @@ const parsePane = (payload) => {
         frozenRowCount: isFrozen && ySplit > 0 ? Math.round(ySplit) : 0,
     };
 };
-export const parseBrtNamePayload = (payload, resolveSheetNameByXti) => {
+export const readBrtName = (payload) => {
     try {
         const reader = new Reader(payload);
         const flags = reader.readUInt32LE();
-        const fHidden = (flags & 0x00000001) !== 0;
         reader.readUInt8(); // chKey
-        const itab = reader.readUInt32LE(); // sheet index (0xFFFFFFFF for workbook scope)
-        // Read the name string
-        if (reader.offset + 4 > payload.length) {
-            return null; // Not enough data
-        }
+        const itab = reader.readUInt32LE(); // 0xFFFFFFFF: workbook scope
+        if (reader.offset + 4 > payload.length)
+            return null;
         const name = reader.readXLWideString();
-        // NameParsedFormula: cce (UInt32) followed by cce bytes of Rgce
-        let formula = "";
+        // NameParsedFormula: cce (4 bytes) and cce bytes of tokens.
+        let rgce;
         if (reader.offset + 4 <= payload.length) {
             const cce = reader.readUInt32LE();
             if (cce > 0 && reader.offset + cce <= payload.length) {
-                const rgceBytes = payload.subarray(reader.offset, reader.offset + cce);
-                formula = parseRgce(rgceBytes, resolveSheetNameByXti);
+                rgce = payload.subarray(reader.offset, reader.offset + cce);
             }
         }
         return {
             name,
-            formula,
-            hidden: fHidden,
-            sheetIndex: itab === 0xffffffff ? undefined : itab,
+            hidden: (flags & 0x00000001) !== 0,
+            builtin: (flags & 0x00000020) !== 0,
+            ...(itab === 0xffffffff ? {} : { itab }),
+            ...(rgce ? { rgce } : {}),
         };
     }
-    catch (err) {
-        // If parsing fails, return null to skip this named range
+    catch {
         return null;
     }
 };
+export const parseBrtNamePayload = (payload, resolveSheetNameByXti) => {
+    const record = readBrtName(payload);
+    if (!record)
+        return null;
+    return {
+        name: record.name,
+        formula: record.rgce ? parseRgce(record.rgce, resolveSheetNameByXti) : "",
+        hidden: record.hidden,
+        sheetIndex: record.itab,
+    };
+};
 /**
  * Parse the `BrtWbProp` workbook-properties record (MS-XLSB 2.4.312).
  * The payload starts with a 32-bit flags field; `fDate1904` is bit 0 of the
@@ -506,7 +512,12 @@ const getNumberFormatType = (pattern) => {
         return "NUMBER";
     return "GENERAL";
 };
-const parseCellFromRecord = (type, payload, row, prevCol, resolveSheetNameByXti, resolveSharedFormula, parseFormula = true) => {
+const parseCellFromRecord = (type, payload, row, prevCol, 
+/**
+ * The formula text for a cell's tokens, or `undefined` to keep only its
+ * cached value. Omitted: formulas are not read.
+ */
+decodeFormula) => {
     if (row <= 0)
         return null;
     const reader = new Reader(payload);
@@ -548,68 +559,26 @@ const parseCellFromRecord = (type, payload, row, prevCol, resolveSheetNameByXti,
             value: "",
         };
     }
+    // CellParsedFormula ([MS-XLSB] 2.5.97.1): cce (4 bytes) and the tokens,
+    // then cb (4 bytes) and the tokens' extra data (a PtgExp's column).
     const readFormula = () => {
-        if (!parseFormula)
+        if (!decodeFormula)
             return undefined;
-        const candidateStarts = [
-            reader.offset - 2,
-            reader.offset,
-            reader.offset + 2,
-            reader.offset + 4,
-            reader.offset + 6,
-            reader.offset + 8,
-            reader.offset + 10,
-            reader.offset + 12,
-        ].filter((start, idx, arr) => start >= 0 && arr.indexOf(start) === idx);
-        const decodeAt = (start, cceSize) => {
-            if (cceSize === 4) {
-                if (start + 4 > payload.length)
-                    return undefined;
-                const cce = new DataView(payload.buffer, payload.byteOffset + start, 4).getUint32(0, true);
-                if (cce <= 0)
-                    return undefined;
-                const rgceStart = start + 4;
-                const rgceEnd = rgceStart + cce;
-                if (rgceEnd > payload.length)
-                    return undefined;
-                return payload.subarray(rgceStart, rgceEnd);
-            }
-            if (start + 2 > payload.length)
-                return undefined;
-            const cce = new DataView(payload.buffer, payload.byteOffset + start, 2).getUint16(0, true);
-            if (cce <= 0)
-                return undefined;
-            const rgceStart = start + 2;
-            const rgceEnd = rgceStart + cce;
-            if (rgceEnd > payload.length)
-                return undefined;
-            return payload.subarray(rgceStart, rgceEnd);
-        };
-        const tryResolve = (parsed) => {
-            const expMatch = parsed.match(/^__PTGEXP__:(\d+):(\d+)$/);
-            if (!expMatch)
-                return parsed;
-            if (!resolveSharedFormula)
-                return undefined;
-            const sourceRow = Number(expMatch[1]);
-            const sourceCol = Number(expMatch[2]);
-            return resolveSharedFormula(sourceRow, sourceCol, row, colZero + 1);
-        };
-        for (const start of candidateStarts) {
-            for (const cceSize of [4, 2]) {
-                const rgceBytes = decodeAt(start, cceSize);
-                if (!rgceBytes || rgceBytes.length === 0)
-                    continue;
-                const parsed = parseRgce(rgceBytes, resolveSheetNameByXti, { row, col: colZero + 1 }, true);
-                if (!parsed)
-                    continue;
-                const resolved = tryResolve(parsed);
-                if (resolved && resolved.length > 0) {
-                    return resolved;
-                }
+        if (reader.offset + 4 > payload.length)
+            return undefined;
+        const cce = reader.readUInt32LE();
+        if (cce === 0 || reader.offset + cce > payload.length)
+            return undefined;
+        const rgce = payload.subarray(reader.offset, reader.offset + cce);
+        reader.offset += cce;
+        let rgcb = new Uint8Array(0);
+        if (reader.offset + 4 <= payload.length) {
+            const cb = reader.readUInt32LE();
+            if (reader.offset + cb <= payload.length) {
+                rgcb = payload.subarray(reader.offset, reader.offset + cb);
             }
         }
-        return undefined;
+        return decodeFormula(rgce, { row, col: colZero + 1 }, rgcb);
     };
     if (type === RT.BrtFmlaNum) {
         const value = reader.readFloat64LE();
@@ -639,8 +608,7 @@ const parseCellFromRecord = (type, payload, row, prevCol, resolveSheetNameByXti,
     }
     if (type === RT.BrtFmlaBool) {
         const value = reader.readUInt8() !== 0;
-        reader.readUInt8(); // padding
-        reader.readUInt16LE(); // flags
+        reader.readUInt16LE(); // grbitFlags
         const formula = readFormula();
         return {
             row,
@@ -653,8 +621,7 @@ const parseCellFromRecord = (type, payload, row, prevCol, resolveSheetNameByXti,
     }
     if (type === RT.BrtFmlaError) {
         const value = reader.readUInt8();
-        reader.readUInt8(); // padding
-        reader.readUInt16LE(); // flags
+        reader.readUInt16LE(); // grbitFlags
         const formula = readFormula();
         return {
             row,
@@ -1189,6 +1156,15 @@ export class XlsbPlugin extends BaseWorkbookPlugin {
     calcProp = {};
     supportingLinks = [];
     externSheetRefs = [];
+    /** Every sheet in workbook order, very hidden ones included; `sheetId` only for imported ones. */
+    workbookSheets = [];
+    /** Every `BrtName` in record order (`null`: unreadable): a `PtgName` is a 1-based index into it. */
+    definedNames = [];
+    /** A name's expression by its 1-based index; `null` when it does not decode. */
+    definedNameExpressions = new Map();
+    /** `${itab}:${lower-cased name}` of every sheet-local name. */
+    sheetLocalNames = new Set();
+    formulaDecodeStats = emptyFormulaDecodeStats();
     use1904 = false;
     async load(buffer, password) {
         await this.zipParser.load(buffer, password);
@@ -1204,7 +1180,8 @@ export class XlsbPlugin extends BaseWorkbookPlugin {
         const records = readAllRecordHeaders(workbookBinary);
         const workbookRels = await this.loadWorkbookRelationships();
         const sheets = [];
-        const namedRanges = [];
+        const workbookSheets = [];
+        const definedNames = [];
         const supportingLinks = [];
         let externSheetRefs = [];
         for (const record of records) {
@@ -1213,15 +1190,19 @@ export class XlsbPlugin extends BaseWorkbookPlugin {
                 const parsed = parseBundleSheet(payload);
                 // Skip veryHidden sheets (hidden === 2) - these are internal sheets not meant for users
                 if (parsed.hidden === 2) {
+                    workbookSheets.push({ title: parsed.title });
                     continue;
                 }
                 const relTarget = workbookRels.get(parsed.rid);
                 const path = relTarget
                     ? resolveRelativePath("xl/workbook.bin", relTarget)
                     : undefined;
+                const sheetId = parsed.tabId || sheets.length + 1;
+                const title = parsed.title || `Sheet${sheets.length + 1}`;
                 sheets.push({
-                    sheetId: parsed.tabId || sheets.length + 1,
-                    title: parsed.title || `Sheet${sheets.length + 1}`,
+                    sheetId,
+                    title,
+                    workbookIndex: workbookSheets.length,
                     hidden: parsed.hidden === 1,
                     rid: parsed.rid,
                     path,
@@ -1232,6 +1213,7 @@ export class XlsbPlugin extends BaseWorkbookPlugin {
                     rowMetadata: [],
                     columnMetadata: [],
                 });
+                workbookSheets.push({ title, sheetId });
             }
             else if (record.type === RT.BrtSupSelf) {
                 supportingLinks.push("self");
@@ -1242,6 +1224,10 @@ export class XlsbPlugin extends BaseWorkbookPlugin {
             else if (record.type === RT.BrtSupBookSrc) {
                 supportingLinks.push("external");
             }
+            else if (record.type === RT.BrtSupAddin) {
+                // Counted so the XTIs after it index the right supporting link.
+                supportingLinks.push("addin");
+            }
             else if (record.type === RT.BrtExternSheet) {
                 const parsed = parseBrtExternSheet(payload);
                 if (parsed.length > 0) {
@@ -1249,10 +1235,9 @@ export class XlsbPlugin extends BaseWorkbookPlugin {
                 }
             }
             else if (record.type === RT.BrtName) {
-                const namedRange = this.parseBrtName(payload, sheets);
-                if (namedRange) {
-                    namedRanges.push(namedRange);
-                }
+                // Decoded once every sheet and name is known: a name may refer to
+                // sheets and names that come after it.
+                definedNames.push(readBrtName(payload));
             }
             else if (record.type === RT.BrtCalcProp) {
                 this.parseBrtCalcProp(payload);
@@ -1264,10 +1249,17 @@ export class XlsbPlugin extends BaseWorkbookPlugin {
                 }
             }
         }
-        this.namedRanges = namedRanges;
         this.supportingLinks = supportingLinks;
         this.externSheetRefs = externSheetRefs;
+        this.workbookSheets = workbookSheets;
+        this.definedNames = definedNames;
+        this.definedNameExpressions.clear();
+        this.sheetLocalNames = new Set(definedNames.flatMap((record) => record?.itab === undefined
+            ? []
+            : [`${record.itab}:${record.name.toLowerCase()}`]));
+        this.formulaDecodeStats = emptyFormulaDecodeStats();
         this.sheets = sheets;
+        this.namedRanges = this.buildNamedRanges();
         this.sharedStrings = await this.loadSharedStrings();
         this.styles = await this.loadStyles();
         this.theme = await this.loadTheme();
@@ -1682,7 +1674,7 @@ export class XlsbPlugin extends BaseWorkbookPlugin {
             }
             if (!isCellRecord(record.type))
                 continue;
-            const parsed = parseCellFromRecord(record.type, payload, currentRow, prevCol, (ixti) => this.resolveSheetNameByXti(ixti), undefined, false);
+            const parsed = parseCellFromRecord(record.type, payload, currentRow, prevCol);
             if (!parsed)
                 continue;
             prevCol = parsed.col - 1;
@@ -1711,25 +1703,128 @@ export class XlsbPlugin extends BaseWorkbookPlugin {
     getSheetNames() {
         return this.sheets.map((s) => s.title);
     }
-    resolveSheetNameByXti(ixti) {
-        const sheetNames = this.getSheetNames();
-        const fallback = sheetNames[ixti] ?? sheetNames[ixti - 1];
+    /**
+     * The imported sheet an XTI names, or `undefined` when a formula cannot
+     * name it exactly: another workbook, a span of sheets, a deleted or very
+     * hidden sheet.
+     */
+    sheetNameByXti(ixti) {
         const xti = this.externSheetRefs[ixti];
         if (!xti)
-            return fallback;
+            return undefined;
         const linkType = this.supportingLinks[xti.iSupBook];
-        if (linkType !== "self" && linkType !== "same") {
-            return fallback;
+        if (linkType !== "self" && linkType !== "same")
+            return undefined;
+        if (xti.itabFirst !== xti.itabLast)
+            return undefined;
+        const sheet = this.workbookSheets[xti.itabFirst];
+        return sheet?.sheetId === undefined ? undefined : sheet.title;
+    }
+    /**
+     * A defined name's expression (OOXML's spelling, no leading `=`), or
+     * `undefined` when it does not decode exactly — then no formula may refer
+     * to it either. `visiting` breaks names that refer to themselves.
+     */
+    definedNameExpression(index, visiting = new Set()) {
+        const known = this.definedNameExpressions.get(index);
+        if (known !== undefined)
+            return known ?? undefined;
+        const record = this.definedNames[index - 1];
+        if (!record?.rgce || visiting.has(index))
+            return undefined;
+        if (record.itab !== undefined &&
+            this.workbookSheets[record.itab]?.sheetId === undefined) {
+            this.definedNameExpressions.set(index, null);
+            return undefined;
+        }
+        visiting.add(index);
+        let expression = null;
+        try {
+            expression = decodeRgce(record.rgce, {
+                sheetName: (ixti) => this.sheetNameByXti(ixti),
+                definedName: (target) => this.definedNameIn(target, record.itab, visiting),
+            });
+        }
+        catch (error) {
+            if (!(error instanceof RgceUnsupportedError))
+                throw error;
         }
-        const first = xti.itabFirst;
-        const last = xti.itabLast;
-        if (first < 0 || first >= sheetNames.length)
-            return fallback;
-        if (last < 0 || last >= sheetNames.length)
-            return sheetNames[first];
-        if (first === last)
-            return sheetNames[first];
-        return `${sheetNames[first]}:${sheetNames[last]}`;
+        finally {
+            visiting.delete(index);
+        }
+        this.definedNameExpressions.set(index, expression);
+        return expression ?? undefined;
+    }
+    /**
+     * How a formula on the sheet at `formulaItab` (a name's own formula: the
+     * sheet it is local to) writes the name a `PtgName` points at: bare on its
+     * own sheet or for a workbook name, `Sheet!Name` elsewhere. `undefined`
+     * when the name does not survive the import, or when a local name of the
+     * same spelling would capture a bare workbook name.
+     */
+    definedNameIn(index, formulaItab, visiting) {
+        const record = this.definedNames[index - 1];
+        if (!record || record.builtin)
+            return undefined;
+        if (this.definedNameExpression(index, visiting) === undefined) {
+            return undefined;
+        }
+        if (record.itab === undefined) {
+            const shadowed = formulaItab !== undefined &&
+                this.sheetLocalNames.has(`${formulaItab}:${record.name.toLowerCase()}`);
+            return shadowed ? undefined : record.name;
+        }
+        if (record.itab === formulaItab)
+            return record.name;
+        const sheet = this.workbookSheets[record.itab];
+        return sheet?.sheetId === undefined
+            ? undefined
+            : `${quoteSheetName(sheet.title)}!${record.name}`;
+    }
+    /** Every name that decodes, the way the XLSX plugin reads `<definedName>`. */
+    buildNamedRanges() {
+        const sheetIdBySheetName = {};
+        for (const sheet of this.sheets) {
+            sheetIdBySheetName[sheet.title] = sheet.sheetId;
+        }
+        const namedRanges = [];
+        const counts = this.formulaDecodeStats.definedNames;
+        this.definedNames.forEach((record, at) => {
+            // Print areas and titles are sheet print facets, not user names.
+            const expression = record && !isBuiltinPrintName(record.name)
+                ? this.definedNameExpression(at + 1)
+                : undefined;
+            if (!record || expression === undefined) {
+                counts.unsupported += 1;
+                return;
+            }
+            counts.decoded += 1;
+            namedRanges.push(...namedRangesForDefinedName({
+                name: record.name,
+                expression,
+                hidden: record.hidden,
+                scopeSheetId: record.itab === undefined
+                    ? undefined
+                    : this.workbookSheets[record.itab]?.sheetId,
+                sheetIdBySheetName,
+            }));
+        });
+        return namedRanges;
+    }
+    getFormulaDecodeStats() {
+        return {
+            ...this.formulaDecodeStats,
+            reasons: { ...this.formulaDecodeStats.reasons },
+            definedNames: { ...this.formulaDecodeStats.definedNames },
+        };
+    }
+    countUnsupportedFormula(reason) {
+        const stats = this.formulaDecodeStats;
+        stats.unsupported += 1;
+        const key = reason in stats.reasons || Object.keys(stats.reasons).length < 32
+            ? reason
+            : "other";
+        stats.reasons[key] = (stats.reasons[key] ?? 0) + 1;
     }
     async getSheets(minRowCount = 0, minColumnCount = 0) {
         const tables = [];
@@ -1807,28 +1902,55 @@ export class XlsbPlugin extends BaseWorkbookPlugin {
                 continue;
             const binary = await this.zipParser.getBinary(sheet.path);
             const records = readAllRecordHeaders(binary);
-            const sharedFormulaBytes = new Map();
-            const sharedFormulaRanges = [];
-            // Pre-scan shared formulas so PtgExp can resolve even when BrtShrFmla
-            // appears later in the record stream.
+            // Shared formulas by their first cell: each cell of one holds a PtgExp
+            // naming that cell, and its BrtShrFmla may come after the first cell.
+            const sharedFormulas = new Map();
             for (const record of records) {
                 if (record.type !== RT.BrtShrFmla)
                     continue;
-                const payload = binary.subarray(record.dataOffset, record.nextOffset);
-                const parsedShared = parseBrtShrFmla(payload);
+                const parsedShared = parseBrtShrFmla(binary.subarray(record.dataOffset, record.nextOffset));
                 if (!parsedShared)
                     continue;
-                sharedFormulaBytes.set(`${parsedShared.startRow}:${parsedShared.startCol}`, parsedShared.rgceBytes);
-                sharedFormulaRanges.push(parsedShared);
+                sharedFormulas.set(`${parsedShared.startRow}:${parsedShared.startCol}`, parsedShared);
             }
+            const decodeFormula = (rgce, cell, rgcb) => {
+                let tokens = rgce;
+                if (rgce.length === PTG_EXP_LENGTH && rgce[0] === PTG_EXP) {
+                    // PtgExp: the shared formula's first row, its column in the extra data.
+                    const shared = rgcb.length >= 4
+                        ? sharedFormulas.get(`${readUInt32(rgce, 1) + 1}:${readUInt32(rgcb, 0) + 1}`)
+                        : undefined;
+                    if (!shared ||
+                        cell.row < shared.startRow ||
+                        cell.row > shared.endRow ||
+                        cell.col < shared.startCol ||
+                        cell.col > shared.endCol) {
+                        this.countUnsupportedFormula("array formula");
+                        return undefined;
+                    }
+                    tokens = shared.rgceBytes;
+                }
+                try {
+                    const formula = decodeRgce(tokens, {
+                        sheetName: (ixti) => this.sheetNameByXti(ixti),
+                        definedName: (index) => this.definedNameIn(index, sheet.workbookIndex),
+                        baseCell: cell,
+                    });
+                    this.formulaDecodeStats.decoded += 1;
+                    return formula;
+                }
+                catch (error) {
+                    if (!(error instanceof RgceUnsupportedError))
+                        throw error;
+                    this.countUnsupportedFormula(error.message);
+                    return undefined;
+                }
+            };
             let currentRow = 0;
             let prevCol = -1;
             const rows = new Map();
             for (const record of records) {
                 const payload = binary.subarray(record.dataOffset, record.nextOffset);
-                if (record.type === RT.BrtShrFmla) {
-                    continue;
-                }
                 if (record.type === RT.BrtRowHdr) {
                     const parsedRow = parseRowHeader(payload);
                     currentRow = parsedRow.row;
@@ -1840,36 +1962,9 @@ export class XlsbPlugin extends BaseWorkbookPlugin {
                 }
                 if (!isCellRecord(record.type))
                     continue;
-                const parsed = parseCellFromRecord(record.type, payload, currentRow, prevCol, (ixti) => this.resolveSheetNameByXti(ixti), (sourceRow, sourceCol, targetRow, targetCol) => {
-                    let rgce = sharedFormulaBytes.get(`${sourceRow}:${sourceCol}`);
-                    if (!rgce) {
-                        const sourceRange = sharedFormulaRanges.find((range) => sourceRow >= range.startRow &&
-                            sourceRow <= range.endRow &&
-                            sourceCol >= range.startCol &&
-                            sourceCol <= range.endCol);
-                        rgce = sourceRange?.rgceBytes;
-                    }
-                    if (!rgce)
-                        return undefined;
-                    return parseRgce(rgce, (ixti) => this.resolveSheetNameByXti(ixti), {
-                        row: targetRow,
-                        col: targetCol,
-                    }, true); // Enable debug logging
-                });
+                const parsed = parseCellFromRecord(record.type, payload, currentRow, prevCol, decodeFormula);
                 if (!parsed)
                     continue;
-                if (!parsed.formula && sharedFormulaRanges.length > 0) {
-                    const sharedRange = sharedFormulaRanges.find((range) => parsed.row >= range.startRow &&
-                        parsed.row <= range.endRow &&
-                        parsed.col >= range.startCol &&
-                        parsed.col <= range.endCol);
-                    if (sharedRange) {
-                        const resolved = parseRgce(sharedRange.rgceBytes, (ixti) => this.resolveSheetNameByXti(ixti), { row: parsed.row, col: parsed.col }, true);
-                        if (resolved) {
-                            parsed.formula = resolved;
-                        }
-                    }
-                }
                 prevCol = parsed.col - 1;
                 let row = rows.get(parsed.row);
                 if (!row) {
@@ -2295,40 +2390,6 @@ export class XlsbPlugin extends BaseWorkbookPlugin {
         }
         return validations;
     }
-    parseBrtName(payload, sheets) {
-        const parsed = parseBrtNamePayload(payload, (ixti) => this.resolveSheetNameByXti(ixti));
-        // Skip if parsing failed or hidden names
-        if (!parsed || parsed.hidden) {
-            return undefined;
-        }
-        // Try to parse the formula as a range reference
-        const gridRange = getRangeFromAddressRef(parsed.formula);
-        // Determine the sheet ID if this is a sheet-scoped name
-        let sheetId;
-        if (parsed.sheetIndex !== undefined && parsed.sheetIndex < sheets.length) {
-            sheetId = sheets[parsed.sheetIndex].sheetId;
-        }
-        // Create the NamedRange object
-        const namedRange = {
-            namedRangeId: uuid(),
-            name: parsed.name,
-        };
-        // Set either range or value depending on what we parsed
-        if (gridRange) {
-            // Convert GridRange to SheetRange by adding sheetId
-            // Use the sheet-scoped sheetId if available, otherwise use the first sheet
-            const rangeSheetId = sheetId ?? (sheets.length > 0 ? sheets[0].sheetId : 1);
-            namedRange.range = {
-                ...gridRange,
-                sheetId: rangeSheetId,
-            };
-        }
-        else if (parsed.formula) {
-            // If we can't parse it as a range, store it as a formula value
-            namedRange.value = parsed.formula;
-        }
-        return namedRange;
-    }
     parseBrtCalcProp(payload) {
         const parsed = parseBrtCalcPropPayload(payload);
         if (!parsed) {