@shbernal/ts-xlsx 3.0.0 → 3.2.0

package/dist/io/xlsb/read.js

@@ -1,74 +1,99 @@
-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';
-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 = {}) {
-    return readXlsbPackage(openSpreadsheetPackage(data, options.maxUncompressedBytes).files);
+    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 = readPartRelationships(XLSB_WORKBOOK_PART, partText);
-    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 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));
         if (part !== undefined)
-            parseWorksheet(part, sheet, sharedStrings, cellXfs, scope);
+            parseWorksheet(part, {
+                sheet,
+                sharedStrings,
+                xfStyles: cellXfs,
+                scope,
+                dateEpoch: declaration.dateEpoch,
+                definedNames: namesInWorkbook,
+                cellMetadata,
+            });
+    }
+    for (const defined of definedNames(declaration, scope, namesInWorkbook)) {
+        admitting(() => {
+            workbook.defineName(defined);
+        });
     }
-    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));
@@ -78,8 +103,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';
@@ -90,9 +121,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() });
     }
@@ -117,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)
@@ -129,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-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;
+        },
+    };
+}

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

@@ -16,7 +16,6 @@ export declare const BRT: {
     readonly ColInfo: 60;
     readonly MergeCell: 176;
     readonly SSTItem: 19;
-    readonly BeginSst: 159;
     readonly EndSst: 160;
     readonly Fmt: 44;
     readonly Font: 43;
@@ -38,6 +37,7 @@ export declare const BRT: {
     readonly EndCellXFs: 618;
     readonly BeginStyles: 619;
     readonly EndStyles: 620;
+    readonly WbProp: 153;
     readonly BundleSh: 156;
     readonly BeginBundleShs: 143;
     readonly EndBundleShs: 144;
@@ -46,10 +46,19 @@ export declare const BRT: {
     readonly EndExternals: 354;
     readonly SupSelf: 357;
     readonly ExternSheet: 362;
-    readonly WsProp: 147;
-    readonly WsDim: 148;
     readonly WsFmtInfo: 485;
-    readonly BeginSheetData: 145;
-    readonly EndSheetData: 146;
     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

@@ -15,7 +15,6 @@ export const BRT = {
     ColInfo: 60,
     MergeCell: 176,
     SSTItem: 19,
-    BeginSst: 159,
     EndSst: 160,
     Fmt: 44,
     Font: 43,
@@ -37,6 +36,7 @@ export const BRT = {
     EndCellXFs: 618,
     BeginStyles: 619,
     EndStyles: 620,
+    WbProp: 153,
     BundleSh: 156,
     BeginBundleShs: 143,
     EndBundleShs: 144,
@@ -45,10 +45,19 @@ export const BRT = {
     EndExternals: 354,
     SupSelf: 357,
     ExternSheet: 362,
-    WsProp: 147,
-    WsDim: 148,
     WsFmtInfo: 485,
-    BeginSheetData: 145,
-    EndSheetData: 146,
     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,
 };

package/dist/io/xlsb/sheet-protection.d.ts

@@ -0,0 +1,20 @@
+import type { AssertNever } from '../../core/internal.ts';
+import { type SheetProtection, type SheetProtectionFlags } from '../../core/protection.ts';
+import type { RecordReader } from './primitives.ts';
+declare const FLAGS_IN_RECORD_ORDER: readonly ["objects", "scenarios", "formatCells", "formatColumns", "formatRows", "insertColumns", "insertRows", "insertHyperlinks", "deleteColumns", "deleteRows", "selectLockedCells", "sort", "autoFilter", "pivotTables", "selectUnlockedCells"];
+/**
+ * The half of the proof an ordered list owes: `satisfies` covers "no invented flag", this covers "no
+ * omission". A flag left out here would be read at the wrong offset along with every flag after it.
+ */
+export type EveryProtectionFlagHasARecordSlot = AssertNever<Exclude<keyof SheetProtectionFlags, (typeof FLAGS_IN_RECORD_ORDER)[number]>>;
+/** What a worksheet's protection records say, gathered as they arrive. */
+export declare class SheetProtectionRecords {
+    #private;
+    /** Read a `BrtSheetProtection`. */
+    legacy(reader: RecordReader): void;
+    /** Read a `BrtSheetProtectionIso`. */
+    iso(reader: RecordReader): void;
+    /** The protection the records described, or `undefined` for a sheet that is not protected. */
+    result(): SheetProtection | undefined;
+}
+export {};

package/dist/io/xlsb/sheet-protection.js

@@ -0,0 +1,60 @@
+import { toBase64 } from '../../bytes.js';
+import { SHEET_PROTECTION_FLAGS, } from '../../core/protection.js';
+import { hex } from '../../hex.js';
+const FLAGS_IN_RECORD_ORDER = [
+    'objects',
+    'scenarios',
+    'formatCells',
+    'formatColumns',
+    'formatRows',
+    'insertColumns',
+    'insertRows',
+    'insertHyperlinks',
+    'deleteColumns',
+    'deleteRows',
+    'selectLockedCells',
+    'sort',
+    'autoFilter',
+    'pivotTables',
+    'selectUnlockedCells',
+];
+const ALLOWED_BY_DEFAULT = new Map(SHEET_PROTECTION_FLAGS.map(({ key, defaultForbidden }) => [key, !defaultForbidden]));
+export class SheetProtectionRecords {
+    #locked = false;
+    #flags = {};
+    #legacyPasswordHash;
+    #credential;
+    legacy(reader) {
+        const protpwd = reader.u16();
+        this.#readFlags(reader);
+        this.#legacyPasswordHash = protpwd === 0 ? undefined : hex(protpwd, 4);
+    }
+    iso(reader) {
+        const spinCount = reader.u32();
+        this.#readFlags(reader);
+        const hashValue = toBase64(reader.bytes(reader.u32()));
+        const saltValue = toBase64(reader.bytes(reader.u32()));
+        this.#credential = { algorithmName: reader.wideString(), hashValue, saltValue, spinCount };
+    }
+    result() {
+        if (!this.#locked)
+            return undefined;
+        return {
+            flags: this.#flags,
+            ...(this.#credential === undefined ? {} : { credential: this.#credential }),
+            ...(this.#legacyPasswordHash === undefined
+                ? {}
+                : { legacyPasswordHash: this.#legacyPasswordHash }),
+        };
+    }
+    #readFlags(reader) {
+        this.#locked = reader.u32() !== 0;
+        const flags = {};
+        for (const key of FLAGS_IN_RECORD_ORDER) {
+            const allowed = reader.u32() !== 0;
+            if (allowed !== ALLOWED_BY_DEFAULT.get(key))
+                flags[key] = allowed;
+        }
+        this.#flags = flags;
+    }
+}

package/dist/io/xlsx/cell-accumulator.d.ts

@@ -1,30 +1,46 @@
+import type { DateEpoch } from '../../core/date.ts';
 import type { CellValue } from '../../core/value.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
 import { type XmlAttributes } from '../../xml/xml-scan.ts';
+import type { CellMetadataIndex } from '../cell-metadata/metadata.ts';
 import { type XfStyle } from '../style/xf-style.ts';
 import { type SharedString } from './cell-value.ts';
+/**
+ * The worksheet-body elements both readers expand from `<x/>` into an open and a close, so each
+ * commits from its close alone. A formatted-but-empty `<c/>` finalises once there, and a self-closing
+ * `<row/>` closes its row, where the streamer yields it and both readers end its style and its cells:
+ * a producer may write `<row r="2" hidden="1"/>`, and with no close the streamer lost the row and its
+ * `hidden` flag. The text-bearing `<f/>`/`<v/>`/`<t/>` stay out, so an empty one never commits text.
+ */
+export declare const WORKSHEET_BODY_EMPTY_CLOSES: ReadonlySet<string>;
 export declare class CellAccumulator {
     #private;
     constructor(options: {
-        readonly richRuns: boolean;
+        readonly dateEpoch: DateEpoch;
+        readonly definedNames: ReadonlySet<string>;
+        readonly cellMetadata: CellMetadataIndex;
     });
     /** This cell's `<c r>` address (`"B3"`), or '' when it carried none. */
     get ref(): string;
     /** This cell's own `<c s>` style index, or -1 when it carries none. */
     get styleIndex(): number;
-    /** This cell's 1-based column, or -1 when its address was absent or unparseable. */
+    /** This cell's 1-based column, or -1 when its address was unparseable. */
     get col(): number;
     /**
-     * The text gathered since the current element opened. A caller reads it for the elements it
-     * captures itself (see {@link capture}); the machine reads it for its own.
+     * Open a `<row>`: the cells that follow belong to it, and the next one with no `r` of its own is
+     * its first column. A row past the grid opens no row, so none of its cells is placed, not even one
+     * whose own `r` names an in-grid cell. Both readers call this where they already tell the style
+     * resolver a row opened.
      */
-    get capturedText(): string;
-    /** Gather the current element's text for the caller's own use, the way `<v>` and `<t>` do. */
-    capture(): void;
+    openRow(number: number, inGrid: boolean): void;
+    /** Whether an in-grid `<row>` is open. */
+    get rowOpen(): boolean;
+    /** Close the `<row>`: a `<c>` before the next one belongs to no row and is not placed. */
+    closeRow(): void;
     /**
      * Drive one element open, and return whether it was one of the cell machine's own. Every open
      * resets the capture state first, which is true of both readers and of every element, not just
-     * these; a caller that captures its own text calls {@link capture} after this returns.
+     * these. A caller gathering text of its own uses a `TextCapture`, not this machine's buffer.
      */
     openElement(local: string, attrs: XmlAttributes, selfClosing: boolean): boolean;
     /** Feed one run of character data. Ignored unless something is capturing. */
@@ -37,6 +53,5 @@ export declare class CellAccumulator {
      */
     closeElement(local: string): 'cell' | 'claimed' | 'other';
     finalize(sheet: Worksheet, sharedStrings: readonly SharedString[], style: XfStyle | undefined): void;
-    private cachedResult;
     decode(sharedStrings: readonly SharedString[], style: XfStyle | undefined): CellValue;
 }

package/dist/io/xlsx/cell-accumulator.js

@@ -1,20 +1,28 @@
-import { encodeAddress, tryDecodeCellRef } from '../../core/address.js';
-import { translateFormula, unmangleFunctions } from '../../core/formula.js';
-import { boolStrict, numInteger } from '../../xml/xml-scan.js';
+import { encodeAddress, encodeRange, MAX_COLUMN, tryDecodeAnchoredRange, tryDecodeCellRef, } from '../../core/address.js';
+import { translateFormula } from '../../core/formula-references.js';
+import { unmangleFunctions } from '../../core/formula.js';
+import { numInteger } from '../../xml/xml-attrs.js';
+import { boolStrict } from '../../xml/xml-scan.js';
 import { applyXfToCell } from '../style/xf-style.js';
 import { decodeCellContent, decodeFormulaResult, } from './cell-value.js';
-import { RunAccumulator } from './rich-runs.js';
+import { RunAccumulator } from './read-rich-runs.js';
+export const WORKSHEET_BODY_EMPTY_CLOSES = new Set(['c', 'row']);
 export class CellAccumulator {
     #ref = '';
     #type = '';
     #style = -1;
     #col = -1;
     #row = -1;
+    #cellMetadataBlock = -1;
+    #valueMetadataBlock = -1;
+    #rowOpen = false;
+    #nextCol = 1;
     #formula = '';
     #formulaShared = false;
     #formulaSi = -1;
     #sharedClone = false;
     #dataTable = null;
+    #arrayRef = undefined;
     #valueText = '';
     #hasFormula = false;
     #hasValue = false;
@@ -22,8 +30,14 @@ export class CellAccumulator {
     #masters = new Map();
     #capture = false;
     #text = '';
+    #dateEpoch;
+    #definedNames;
+    #cellMetadata;
     constructor(options) {
-        this.#runs = new RunAccumulator({ container: 'is', readRuns: options.richRuns });
+        this.#runs = new RunAccumulator({ container: 'is', readRuns: true });
+        this.#dateEpoch = options.dateEpoch;
+        this.#definedNames = options.definedNames;
+        this.#cellMetadata = options.cellMetadata;
     }
     get ref() {
         return this.#ref;
@@ -34,13 +48,24 @@ export class CellAccumulator {
     get col() {
         return this.#col;
     }
+    openRow(number, inGrid) {
+        this.#rowOpen = inGrid;
+        this.#row = inGrid ? number : -1;
+        this.#nextCol = 1;
+    }
+    get rowOpen() {
+        return this.#rowOpen;
+    }
+    closeRow() {
+        this.#rowOpen = false;
+        this.#row = -1;
+    }
     #beginCell(attrs) {
         this.#type = attrs.t ?? '';
         this.#style = numInteger(attrs.s, 0) ?? -1;
-        const decoded = tryDecodeCellRef(attrs.r ?? '');
-        this.#ref = decoded === undefined ? '' : (attrs.r ?? '');
-        this.#col = decoded?.col ?? -1;
-        this.#row = decoded?.row ?? -1;
+        this.#cellMetadataBlock = numInteger(attrs.cm, 1) ?? -1;
+        this.#valueMetadataBlock = numInteger(attrs.vm, 1) ?? -1;
+        this.#placeCell(attrs.r);
         this.#formula = '';
         this.#valueText = '';
         this.#runs.beginContainer();
@@ -50,6 +75,25 @@ export class CellAccumulator {
         this.#formulaSi = -1;
         this.#sharedClone = false;
         this.#dataTable = null;
+        this.#arrayRef = undefined;
+    }
+    #placeCell(ref) {
+        const decoded = this.#rowOpen && ref !== undefined ? tryDecodeCellRef(ref) : undefined;
+        if (decoded !== undefined) {
+            this.#ref = ref ?? '';
+            this.#col = decoded.col;
+            this.#row = decoded.row;
+        }
+        else if (ref === undefined && this.#rowOpen && this.#nextCol <= MAX_COLUMN) {
+            this.#col = this.#nextCol;
+            this.#ref = encodeAddress(this.#col, this.#row);
+        }
+        else {
+            this.#ref = '';
+            this.#col = -1;
+        }
+        if (this.#col > 0)
+            this.#nextCol = this.#col + 1;
     }
     #beginFormula(attrs, selfClosing) {
         this.#formulaShared = attrs.t === 'shared';
@@ -63,8 +107,15 @@ export class CellAccumulator {
                 dtr: attrs.dtr,
                 r1: attrs.r1,
                 r2: attrs.r2,
+                del1: attrs.del1,
+                del2: attrs.del2,
             };
         }
+        if (attrs.t === 'array' && attrs.ref !== undefined && this.#col > 0) {
+            const range = tryDecodeAnchoredRange(attrs.ref, this.#col, this.#row);
+            if (range !== undefined)
+                this.#arrayRef = encodeRange(range);
+        }
     }
     #setFormula(text) {
         this.#formula = text;
@@ -74,12 +125,6 @@ export class CellAccumulator {
         this.#valueText = text;
         this.#hasValue = true;
     }
-    get capturedText() {
-        return this.#text;
-    }
-    capture() {
-        this.#capture = true;
-    }
     openElement(local, attrs, selfClosing) {
         this.#text = '';
         this.#capture = false;
@@ -95,6 +140,8 @@ export class CellAccumulator {
                 return true;
             case 'v':
                 this.#capture = !selfClosing;
+                if (selfClosing)
+                    this.#setValue('');
                 return true;
             default:
                 return false;
@@ -143,7 +190,9 @@ export class CellAccumulator {
                 ...(boolStrict(this.#dataTable.dtr) ? { dataTableRow: true } : {}),
                 ...(this.#dataTable.r1 !== undefined ? { r1: this.#dataTable.r1 } : {}),
                 ...(this.#dataTable.r2 !== undefined ? { r2: this.#dataTable.r2 } : {}),
-                ...this.cachedResult(style),
+                ...(boolStrict(this.#dataTable.del1) ? { r1Deleted: true } : {}),
+                ...(boolStrict(this.#dataTable.del2) ? { r2Deleted: true } : {}),
+                ...this.#cachedResult(style),
             };
         }
         if (this.#hasFormula && this.#formulaShared && this.#formulaSi >= 0) {
@@ -155,17 +204,17 @@ export class CellAccumulator {
                 const translated = translateFormula(master.formula, this.#col - master.col, this.#row - master.row);
                 return {
                     sharedFormula: encodeAddress(master.col, master.row),
-                    formula: unmangleFunctions(translated),
-                    ...this.cachedResult(style),
+                    formula: unmangleFunctions(translated, this.#definedNames),
+                    ...this.#cachedResult(style),
                 };
             }
         }
         return this.decode(sharedStrings, style);
     }
-    cachedResult(style) {
+    #cachedResult(style) {
         if (!this.#hasValue)
             return {};
-        const result = decodeFormulaResult(this.#type, this.#valueText, style?.numFmt);
+        const result = decodeFormulaResult(this.#type, this.#valueText, style?.numFmt, this.#dateEpoch, this.#cellMetadata.valueErrors.get(this.#valueMetadataBlock));
         return result === undefined ? {} : { result };
     }
     decode(sharedStrings, style) {
@@ -173,11 +222,15 @@ export class CellAccumulator {
             type: this.#type,
             hasFormula: this.#hasFormula,
             formula: this.#formula,
+            arrayRef: this.#arrayRef,
+            dynamicArray: this.#cellMetadata.dynamicArrayCells.has(this.#cellMetadataBlock),
+            valueError: this.#cellMetadata.valueErrors.get(this.#valueMetadataBlock),
             hasValue: this.#hasValue,
             valueText: this.#valueText,
+            hasInlineString: this.#runs.opened,
             inlineText: this.#runs.plainText,
             richTextRuns: this.#runs.runs,
         };
-        return decodeCellContent(raw, sharedStrings, style?.numFmt);
+        return decodeCellContent(raw, sharedStrings, style?.numFmt, this.#dateEpoch, this.#definedNames);
     }
 }