@shbernal/ts-xlsx 1.2.0 → 2.0.0

package/dist/io/opc/zip-mtime.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Modification time stamped on every zip entry, so package bytes depend on the workbook alone.
+ * Encodes as 2001-01-01 12:00:00 in the DOS date field on any machine, in any timezone.
+ */
+export declare const FIXED_ENTRY_MTIME: number;

package/dist/io/opc/zip-mtime.js

@@ -0,0 +1 @@
+export const FIXED_ENTRY_MTIME = new Date(2001, 0, 1, 12, 0, 0, 0).getTime();

package/dist/io/style/xf-style.d.ts

@@ -1,12 +1,12 @@
 import { type Cell } from '../../core/cell.ts';
-import type { CellStyle, Font, NamedCellStyle } from '../../core/style.ts';
+import { type Border, type CellStyle, type Fill, type Font, type NamedCellStyle } from '../../core/style.ts';
 /**
  * What an xf resolves to: the {@link CellStyle} facet tuple, plus the two flags an xf carries that
  * are not facets. Absent facets stay undefined, matching the contract that an unset facet is simply
  * not present on the reconstructed cell.
  *
  * It *derives* the facets rather than listing them, so a seventh facet added to `CellStyle` reaches
- * both readers the moment it joins. Re-declaring them here — the shape this replaced — meant a new
+ * both readers the moment it joins. Re-declaring them here, the shape this replaced, meant a new
  * facet silently stopped at the model and never appeared in a file we read back.
  */
 export interface XfStyle extends CellStyle {
@@ -21,7 +21,7 @@ export interface StyleTable {
     readonly cellXfs: ReadonlyArray<XfStyle>;
     readonly namedStyles: ReadonlyArray<NamedCellStyle>;
     /**
-     * Font id 0 — the workbook's declared default font, the face every cell naming no font renders in.
+     * Font id 0: the workbook's declared default font, the face every cell naming no font renders in.
      * Surfaced separately from the fonts it was flattened onto because it is workbook-level state, not a
      * cell format: a re-write must emit *this* face as font 0 rather than an assumed Calibri, or every
      * empty cell changes face and every character-unit column width changes meaning. Absent when the
@@ -31,17 +31,49 @@ export interface StyleTable {
 }
 /**
  * The format code a number-format id denotes: the file's own `<numFmt>`/`BrtFmt` declaration if it
- * has one, else the built-in Excel defines for that id. Id 0 is General — the absence of a format —
+ * has one, else the built-in Excel defines for that id. Id 0 is General, the absence of a format,
  * and resolves to nothing so an ordinary cell carries no `numFmt`.
  */
 export declare function numFmtCodeFor(id: number, custom: ReadonlyMap<number, string>): string | undefined;
 /**
- * Apply a resolved xf's non-value facets to a cell — the six {@link CellStyle} facets through the
+ * Apply a resolved xf's non-value facets to a cell: the six {@link CellStyle} facets through the
  * shared {@link applyCellStyle}, plus the two links that live on the xf itself rather than in the
  * facet tuple (`quotePrefix`, and the `xfId` pointer into the named-style layer).
  *
  * Shared by every path that commits a cell: the XML reader's ordinary and shared-formula-clone paths,
- * and the BIFF12 reader — so a styled cell keeps its look regardless of which serialisation it came
+ * and the BIFF12 reader, so a styled cell keeps its look regardless of which serialisation it came
  * from, and the two cannot drift on what "applying a style" means.
  */
 export declare function applyXfToCell(cell: Cell, style: XfStyle | undefined): void;
+/**
+ * A `<cellStyle>` / `BrtStyle` label: the name and builtinId that title one `cellStyleXfs` entry,
+ * keyed to that entry's index.
+ */
+export interface StyleLabel {
+    readonly xfId: number;
+    readonly name?: string;
+    readonly builtinId?: number;
+}
+/** The sub-tables an xf resolves its facet ids against, in whichever spelling the codec parsed them. */
+export interface XfDeps {
+    readonly fonts: ReadonlyArray<Font | undefined>;
+    readonly fills: ReadonlyArray<Fill | undefined>;
+    readonly borders: ReadonlyArray<Border | undefined>;
+    readonly numFmtCodes: ReadonlyMap<number, string>;
+}
+/**
+ * Turn the four tables a style-sheet parse yields into the {@link StyleTable} both codecs hand back:
+ * layer each direct xf over the named style it links to, title the named layer with its labels, and
+ * carry font 0 out as the workbook default.
+ *
+ * A facet the direct xf sets wins; one it leaves unset falls through to the named base; and the
+ * `xfId` link is carried through so a re-write keeps it. None of that depends on whether the tables
+ * were parsed out of `xl/styles.xml` or `xl/styles.bin`, which is the point of stating it once: the
+ * two readers used to hold a copy each, cross-referenced by a comment saying they agreed.
+ */
+export declare function resolveStyleTable(tables: {
+    readonly directXfs: ReadonlyArray<XfStyle>;
+    readonly namedXfs: ReadonlyArray<XfStyle>;
+    readonly labels: ReadonlyArray<StyleLabel>;
+    readonly fonts: ReadonlyArray<Font | undefined>;
+}): StyleTable;

package/dist/io/style/xf-style.js

@@ -1,5 +1,6 @@
 import { applyCellStyle } from '../../core/cell.js';
 import { NAMED_STYLE_ID } from '../../core/internal.js';
+import { assignStyleFacets, } from '../../core/style.js';
 const BUILTIN_NUMFMTS = new Map([
     [1, '0'],
     [2, '0.00'],
@@ -62,3 +63,24 @@ export function applyXfToCell(cell, style) {
     if (style.xfId !== undefined)
         cell[NAMED_STYLE_ID] = style.xfId;
 }
+export function resolveStyleTable(tables) {
+    const { directXfs, namedXfs, labels, fonts } = tables;
+    const cellXfs = directXfs.map((xf) => {
+        if (xf.xfId === undefined)
+            return xf;
+        const named = namedXfs[xf.xfId];
+        return named === undefined ? xf : { ...named, ...xf };
+    });
+    const namedStyles = namedXfs.map((xf, index) => {
+        const label = labels.find((entry) => entry.xfId === index);
+        const style = {};
+        assignStyleFacets(style, xf);
+        if (label?.name !== undefined)
+            style.name = label.name;
+        if (label?.builtinId !== undefined)
+            style.builtinId = label.builtinId;
+        return style;
+    });
+    const defaultFont = fonts[0];
+    return defaultFont === undefined ? { cellXfs, namedStyles } : { cellXfs, namedStyles, defaultFont };
+}

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

@@ -1,6 +1,6 @@
 import { XlsxError } from '../../errors.ts';
 /**
- * Thrown when an `.xlsb` package's binary BIFF12 content cannot be parsed — a record whose declared
+ * Thrown when an `.xlsb` package's binary BIFF12 content cannot be parsed: a record whose declared
  * size runs past the end of its part, a truncated record header, or a structure that does not conform
  * to [MS-XLSB].
  *

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

@@ -7,16 +7,16 @@ export interface ExternSheetRef {
 }
 /** The workbook-level tables a formula's references and names resolve through. */
 export interface FormulaScope {
-    /** Sheet names in workbook (tab) order — what an `Xti`'s sheet indices point into. */
+    /** Sheet names in workbook (tab) order: what an `Xti`'s sheet indices point into. */
     readonly sheetNames: readonly string[];
     /** The `BrtExternSheet` table, indexed by a 3-D token's `ixti`. */
     readonly externSheets: readonly ExternSheetRef[];
     /** The index of the supporting book that is this workbook, or `undefined` when the file declares a
      * supporting book this reader does not recognise. A workbook with no external links declares
-     * exactly one — itself — so this is the ordinary case; anything else leaves the indices untrustworthy
+     * exactly one, itself, so this is the ordinary case; anything else leaves the indices untrustworthy
      * and no 3-D reference resolves, which drops those formulas rather than naming the wrong sheet. */
     readonly selfSupBook: number | undefined;
-    /** Every `BrtName` in file order, function placeholders included — a `PtgName` cites one by
+    /** Every `BrtName` in file order, function placeholders included. A `PtgName` cites one by
      * **1-based** index, so filtering this list would misaddress every name reference. */
     readonly names: readonly string[];
 }
@@ -28,7 +28,7 @@ export interface FormulaAnchor {
 }
 /**
  * Decode a `CellParsedFormula`'s token stream into formula text, in the same on-disk spelling the XML
- * form writes into `<f>` — `_xlfn.`-prefixed function names included, so the caller applies the same
+ * form writes into `<f>`, `_xlfn.`-prefixed function names included, so the caller applies the same
  * `unmangleFunctions` normalisation to either serialisation.
  *
  * @param rgce the token stream.

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

@@ -7,7 +7,7 @@ export interface CellHeader {
     /** Zero-based index into the style sheet's cell-XF collection. */
     readonly styleIndex: number;
 }
-/** An `UncheckedRfX` ([MS-XLSB] 2.5.155) cell range — all four bounds zero-based and inclusive. */
+/** An `UncheckedRfX` ([MS-XLSB] 2.5.155) cell range, all four bounds zero-based and inclusive. */
 export interface RangeBounds {
     readonly rowFirst: number;
     readonly rowLast: number;
@@ -18,7 +18,7 @@ export interface RangeBounds {
  * A bounds-checked cursor over one record's payload.
  *
  * Each accessor advances the cursor by exactly the bytes it consumed, so a record is decoded by
- * naming its fields in order. Reading past the payload throws {@link XlsbParseError} — a record that
+ * naming its fields in order. Reading past the payload throws {@link XlsbParseError}: a record that
  * is shorter than its own definition is a malformed file, not a case to guess through.
  */
 export declare class RecordReader {
@@ -28,10 +28,10 @@ export declare class RecordReader {
     get remaining(): number;
     /** Whether the whole payload has been consumed. */
     get done(): boolean;
-    /** Advance past `count` bytes without decoding them — a reserved or unmodelled field. */
+    /** Advance past `count` bytes without decoding them: a reserved or unmodelled field. */
     skip(count: number): void;
     /**
-     * The next `count` bytes as a **view**, for a field whose own decoding happens elsewhere — a formula
+     * The next `count` bytes as a **view**, for a field whose own decoding happens elsewhere: a formula
      * token stream, whose meaning depends on workbook tables this record knows nothing about. A view
      * rather than a copy for the same reason a record's payload is one: the declared length comes from
      * the file, so it must bound a read, never an allocation.
@@ -46,7 +46,7 @@ export declare class RecordReader {
     f64(): number;
     /**
      * An `RkNumber` ([MS-XLSB] 2.5.122): a number packed into 32 bits. Two flag bits steal the low end
-     * of the word — `fInt` says the remaining 30 bits are a signed integer rather than the *high* 30
+     * of the word: `fInt` says the remaining 30 bits are a signed integer rather than the *high* 30
      * bits of a double whose low 34 bits are zero, and `fX100` says the result was scaled up by 100 to
      * keep two decimal places in the integer form. It exists because most real spreadsheet numbers are
      * small integers or two-decimal currency, and this stores them in half the bytes of a double.
@@ -55,7 +55,7 @@ export declare class RecordReader {
     /** An `XLWideString` ([MS-XLSB] 2.5.169): a 4-byte character count then that many UTF-16LE units. */
     wideString(): string;
     /**
-     * A UTF-16 string whose character count is 16-bit rather than 32-bit — the form used *inside* a
+     * A UTF-16 string whose character count is 16-bit rather than 32-bit: the form used *inside* a
      * formula token stream (`PtgStr`, and the string elements of an array constant), where a 4-byte
      * count on every literal would be pure overhead.
      */
@@ -64,7 +64,7 @@ export declare class RecordReader {
     nullableWideString(): string | undefined;
     /**
      * A `RichStr` ([MS-XLSB] 2.5.124): a string that may carry per-run formatting and phonetic guides.
-     * Only the text is returned — the run and phonetic tails are left unread, which is safe because the
+     * Only the text is returned; the run and phonetic tails are left unread, which is safe because the
      * record's framing (not this cursor) bounds where the payload ends.
      */
     richString(): string;
@@ -77,7 +77,7 @@ export declare class RecordReader {
      *
      * The four encodings are mutually exclusive and the type tag picks which of the payload's fields
      * carry meaning; the rest are explicitly undefined. An *automatic* colour (type 0) names nothing at
-     * all, and reads back as no colour — the same absence the XML reader produces for `<color auto="1"/>`,
+     * all, and reads back as no colour: the same absence the XML reader produces for `<color auto="1"/>`,
      * so a cell whose font colour was never set does not gain one on read.
      */
     color(): Color | undefined;

package/dist/io/xlsb/ptg-functions.d.ts

@@ -5,7 +5,7 @@ export declare function functionNameFor(index: number): string | undefined;
 /**
  * How many arguments a fixed-arity function takes, or `undefined` for one whose argument count varies.
  *
- * A `PtgFunc` token states only *which* function is called, never with how many arguments — it is the
+ * A `PtgFunc` token states only *which* function is called, never with how many arguments: it is the
  * token Excel emits precisely because the count is implied by the function. So decoding `ROUND(A1,2)`
  * back from its two operands and one call token is impossible without this: the arity is the only
  * thing that says which operands on the stack belong to the call. (`PtgFuncVar` carries its own count

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

@@ -1,5 +1,4 @@
-import { assignStyleFacets } from '../../core/style.js';
-import { numFmtCodeFor } from '../style/xf-style.js';
+import { numFmtCodeFor, resolveStyleTable, } from '../style/xf-style.js';
 import { RecordReader } from './primitives.js';
 import { readRecords } from './record-stream.js';
 import { BRT } from './record-types.js';
@@ -74,24 +73,7 @@ export function parseStyleTable(part) {
                 break;
         }
     }
-    const cellXfs = directXfs.map((xf) => {
-        if (xf.xfId === undefined)
-            return xf;
-        const named = namedXfs[xf.xfId];
-        return named === undefined ? xf : { ...named, ...xf };
-    });
-    const namedStyles = namedXfs.map((xf, index) => {
-        const label = labels.find((entry) => entry.xfId === index);
-        const style = {};
-        assignStyleFacets(style, xf);
-        if (label?.name !== undefined)
-            style.name = label.name;
-        if (label?.builtinId !== undefined)
-            style.builtinId = label.builtinId;
-        return style;
-    });
-    const defaultFont = fonts[0];
-    return defaultFont === undefined ? { cellXfs, namedStyles } : { cellXfs, namedStyles, defaultFont };
+    return resolveStyleTable({ directXfs, namedXfs, labels, fonts });
 }
 function readXf(reader, deps, isDirect) {
     const parent = reader.u16();

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

@@ -5,10 +5,10 @@ export declare const XLSB_WORKBOOK_PART = "xl/workbook.bin";
 /**
  * Read an `.xlsb` (binary BIFF12) package into a {@link Workbook}.
  *
- * @throws {UnsupportedFormatError} if the input is not an `.xlsb` package — a legacy `.xls`
+ * @throws {UnsupportedFormatError} if the input is not an `.xlsb` package: a legacy `.xls`
  *   (`.format === 'xls'`), an XML `.xlsx` or unrecognised blob (`'unknown'`).
  * @throws {XlsbParseError} if a binary part is malformed.
- * @throws {PackageReadError} if the input is a ZIP that cannot be unpacked — a corrupt or
+ * @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;

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

@@ -6,6 +6,9 @@ import { type SharedString } from './cell-value.ts';
 import { RunAccumulator } from './rich-runs.ts';
 export declare class CellAccumulator {
     #private;
+    constructor(options: {
+        readonly richRuns: boolean;
+    });
     /** 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. */
@@ -14,12 +17,28 @@ export declare class CellAccumulator {
     get col(): number;
     /** The rich-text run accumulator, driven by the surrounding parser's `<r>`/`<rPr>` handling. */
     get runs(): RunAccumulator;
-    beginCell(attrs: XmlAttributes): void;
-    beginFormula(attrs: XmlAttributes, selfClosing: boolean): void;
-    setFormula(text: string): void;
-    setValue(text: string): void;
-    beginInlineString(): void;
-    appendText(text: string, inInlineString: boolean): void;
+    /**
+     * 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.
+     */
+    get capturedText(): string;
+    /** Gather the current element's text for the caller's own use, the way `<v>` and `<t>` do. */
+    capture(): 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.
+     */
+    openElement(local: string, attrs: XmlAttributes, selfClosing: boolean): boolean;
+    /** Feed one run of character data. Ignored unless something is capturing. */
+    appendChunk(chunk: string): void;
+    /**
+     * Drive one element close. `'cell'` means a `</c>` closed and the caller should commit the
+     * gathered cell, which is the one step the two readers do differently; `'claimed'` means the
+     * machine handled it; `'other'` leaves it to the caller. Capture always ends here, as it does on
+     * every close in both readers.
+     */
+    closeElement(local: string): 'cell' | 'claimed' | 'other';
     finalize(sheet: Worksheet, sharedStrings: readonly SharedString[], style: XfStyle | undefined): void;
     decode(sharedStrings: readonly SharedString[], style: XfStyle | undefined): CellValue;
 }

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

@@ -1,6 +1,6 @@
 import { decodeAddress, encodeAddress } from '../../core/address.js';
 import { translateFormula, unmangleFunctions } from '../../core/formula.js';
-import { boolPresent } from '../../xml/xml-read.js';
+import { boolStrict, decodeSpreadsheetText, numInteger, } from '../../xml/xml-read.js';
 import { applyXfToCell } from '../style/xf-style.js';
 import { decodeCellContent, decodeFormulaResult, } from './cell-value.js';
 import { RunAccumulator } from './rich-runs.js';
@@ -21,6 +21,13 @@ export class CellAccumulator {
     #hasValue = false;
     #runs = new RunAccumulator();
     #masters = new Map();
+    #inInlineString = false;
+    #capture = false;
+    #text = '';
+    #richRuns;
+    constructor(options) {
+        this.#richRuns = options.richRuns;
+    }
     get ref() {
         return this.#ref;
     }
@@ -33,16 +40,17 @@ export class CellAccumulator {
     get runs() {
         return this.#runs;
     }
-    beginCell(attrs) {
+    #beginCell(attrs) {
         this.#ref = attrs.r ?? '';
         this.#type = attrs.t ?? '';
-        this.#style = attrs.s !== undefined ? Number(attrs.s) : -1;
-        this.#col = this.#ref === '' ? -1 : (decodeAddress(this.#ref).col ?? -1);
-        this.#row = this.#ref === '' ? -1 : (decodeAddress(this.#ref).row ?? -1);
+        this.#style = numInteger(attrs.s, 0) ?? -1;
+        const decoded = this.#ref === '' ? undefined : decodeAddress(this.#ref);
+        this.#col = decoded?.col ?? -1;
+        this.#row = decoded?.row ?? -1;
         this.#formula = '';
         this.#valueText = '';
         this.#inlineText = '';
-        this.#runs.reset();
+        this.#runs.beginContainer();
         this.#hasFormula = false;
         this.#hasValue = false;
         this.#formulaShared = false;
@@ -50,9 +58,9 @@ export class CellAccumulator {
         this.#sharedClone = false;
         this.#dataTable = null;
     }
-    beginFormula(attrs, selfClosing) {
+    #beginFormula(attrs, selfClosing) {
         this.#formulaShared = attrs.t === 'shared';
-        this.#formulaSi = attrs.si !== undefined ? Number(attrs.si) : -1;
+        this.#formulaSi = numInteger(attrs.si, 0) ?? -1;
         if (selfClosing && this.#formulaShared)
             this.#sharedClone = true;
         if (attrs.t === 'dataTable' && attrs.ref !== undefined) {
@@ -65,41 +73,120 @@ export class CellAccumulator {
             };
         }
     }
-    setFormula(text) {
+    #setFormula(text) {
         this.#formula = text;
         this.#hasFormula = true;
     }
-    setValue(text) {
+    #setValue(text) {
         this.#valueText = text;
         this.#hasValue = true;
     }
-    beginInlineString() {
+    #beginInlineString() {
         this.#inlineText = '';
-        this.#runs.reset();
+        this.#runs.beginContainer();
+    }
+    #appendText(text) {
+        const decoded = decodeSpreadsheetText(text);
+        if (!this.#runs.appendText(decoded) && this.#inInlineString)
+            this.#inlineText += decoded;
+    }
+    get capturedText() {
+        return this.#text;
+    }
+    capture() {
+        this.#capture = true;
     }
-    appendText(text, inInlineString) {
-        if (!this.#runs.appendText(text) && inInlineString)
-            this.#inlineText += text;
+    openElement(local, attrs, selfClosing) {
+        this.#text = '';
+        this.#capture = false;
+        switch (local) {
+            case 'c':
+                this.#beginCell(attrs);
+                return true;
+            case 'is':
+                this.#inInlineString = true;
+                this.#beginInlineString();
+                return true;
+            case 'f':
+                this.#capture = !selfClosing;
+                this.#beginFormula(attrs, selfClosing);
+                return true;
+            case 'v':
+                this.#capture = !selfClosing;
+                return true;
+            case 't':
+                this.#capture = true;
+                return true;
+            case 'r':
+                if (!this.#richRuns)
+                    return false;
+                if (this.#inInlineString)
+                    this.#runs.beginRun();
+                return true;
+            case 'rPr':
+                if (!this.#richRuns)
+                    return false;
+                this.#runs.beginProperties();
+                return true;
+            default:
+                return false;
+        }
+    }
+    appendChunk(chunk) {
+        if (this.#capture)
+            this.#text += chunk;
+    }
+    closeElement(local) {
+        const verdict = this.#closeElement(local);
+        this.#capture = false;
+        return verdict;
+    }
+    #closeElement(local) {
+        switch (local) {
+            case 'f':
+                this.#setFormula(this.#text);
+                return 'claimed';
+            case 'v':
+                this.#setValue(this.#text);
+                return 'claimed';
+            case 't':
+                this.#appendText(this.#text);
+                return 'claimed';
+            case 'r':
+                if (!this.#richRuns)
+                    return 'other';
+                this.#runs.endRun();
+                return 'claimed';
+            case 'is':
+                this.#inInlineString = false;
+                return 'claimed';
+            case 'c':
+                return 'cell';
+            default:
+                return 'other';
+        }
     }
     finalize(sheet, sharedStrings, style) {
         if (this.#ref === '')
             return;
+        const value = this.#resolveValue(sharedStrings, style);
+        const cell = sheet.getCell(this.#ref);
+        applyXfToCell(cell, style);
+        cell.value = value;
+    }
+    #resolveValue(sharedStrings, style) {
         if (this.#dataTable !== null) {
-            const value = {
+            return {
                 shareType: 'dataTable',
                 ref: this.#dataTable.ref,
-                ...(boolPresent(this.#dataTable.dt2D ?? '0') ? { dataTable2D: true } : {}),
-                ...(boolPresent(this.#dataTable.dtr ?? '0') ? { dataTableRow: true } : {}),
+                ...(boolStrict(this.#dataTable.dt2D) ? { dataTable2D: true } : {}),
+                ...(boolStrict(this.#dataTable.dtr) ? { dataTableRow: true } : {}),
                 ...(this.#dataTable.r1 !== undefined ? { r1: this.#dataTable.r1 } : {}),
                 ...(this.#dataTable.r2 !== undefined ? { r2: this.#dataTable.r2 } : {}),
                 ...(this.#hasValue
                     ? { result: decodeFormulaResult(this.#type, this.#valueText, style?.numFmt) }
                     : {}),
             };
-            const cell = sheet.getCell(this.#ref);
-            applyXfToCell(cell, style);
-            cell.value = value;
-            return;
         }
         if (this.#hasFormula && this.#formulaShared && this.#formulaSi >= 0) {
             this.#masters.set(this.#formulaSi, { formula: this.#formula, col: this.#col, row: this.#row });
@@ -108,22 +195,16 @@ export class CellAccumulator {
             const master = this.#masters.get(this.#formulaSi);
             if (master !== undefined) {
                 const translated = translateFormula(master.formula, this.#col - master.col, this.#row - master.row);
-                const value = {
+                return {
                     sharedFormula: encodeAddress(master.col, master.row),
                     formula: unmangleFunctions(translated),
                     ...(this.#hasValue
                         ? { result: decodeFormulaResult(this.#type, this.#valueText, style?.numFmt) }
                         : {}),
                 };
-                const cell = sheet.getCell(this.#ref);
-                applyXfToCell(cell, style);
-                cell.value = value;
-                return;
             }
         }
-        const cell = sheet.getCell(this.#ref);
-        applyXfToCell(cell, style);
-        cell.value = this.decode(sharedStrings, style);
+        return this.decode(sharedStrings, style);
     }
     decode(sharedStrings, style) {
         const raw = {

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

@@ -1,7 +1,7 @@
 import { type CellValue, type FormulaResult, type RichTextRun, type RichTextValue } from '../../core/value.ts';
 /**
  * One entry of the shared-strings pool. A `<si>` built from a bare `<t>` is a plain string; a `<si>`
- * built from `<r>` runs is rich text — so a `t="s"` cell can resolve to either kind, and rich text
+ * built from `<r>` runs is rich text, so a `t="s"` cell can resolve to either kind, and rich text
  * that Excel pooled reads back with its per-run formatting intact rather than flattened to text.
  */
 export type SharedString = string | RichTextValue;
@@ -26,7 +26,7 @@ export interface RawCell {
  */
 export declare function decodeCellContent(raw: RawCell, sharedStrings: readonly SharedString[], numFmt: string | undefined): CellValue;
 /** Decode a formula's cached `<v>` result by its `t` type, coercing a numeric result under a date
- * `numFmt` to a {@link Date} exactly as a bare numeric cell is — so a date-valued formula result
+ * `numFmt` to a {@link Date} exactly as a bare numeric cell is, so a date-valued formula result
  * (e.g. `TODAY()`) reads back as a Date, not a serial. Shared by the buffered reader's shared-formula
  * clone resolution, which caches a result the same way a plain formula cell does. */
 export declare function decodeFormulaResult(type: string, valueText: string, numFmt?: string): FormulaResult;

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

@@ -1,7 +1,7 @@
 import { isDateFormat, serialToDate } from '../../core/date.js';
 import { unmangleFunctions } from '../../core/formula.js';
 import { isErrorCode, } from '../../core/value.js';
-import { boolStrict } from '../../xml/xml-read.js';
+import { boolStrict, decodeSpreadsheetText } from '../../xml/xml-read.js';
 export function decodeCellContent(raw, sharedStrings, numFmt) {
     if (raw.hasFormula) {
         const stored = unmangleFunctions(raw.formula);
@@ -21,7 +21,7 @@ function decodeValue(type, valueText, inlineText, hasValue, sharedStrings) {
         case 'inlineStr':
             return inlineText;
         case 'str':
-            return valueText;
+            return decodeSpreadsheetText(valueText);
         case 'd':
             return valueText === '' ? null : new Date(valueText);
         case 's': {
@@ -45,7 +45,7 @@ export function decodeFormulaResult(type, valueText, numFmt) {
 function decodeResult(type, valueText) {
     switch (type) {
         case 'str':
-            return valueText;
+            return decodeSpreadsheetText(valueText);
         case 'b':
             return boolStrict(valueText);
         case 'e':

package/dist/io/xlsx/color-xml.js

@@ -1,9 +1,9 @@
-import { AuthoringError } from '../../errors.js';
+import { numFinite, numInteger } from '../../xml/xml-read.js';
 function normalizeArgb(argb) {
     const hex = argb.startsWith('#') ? argb.slice(1) : argb;
     const rgb = hex.length === 6 ? `FF${hex}` : hex;
     if (!/^[0-9a-fA-F]{8}$/.test(rgb)) {
-        throw new AuthoringError(`Invalid ARGB colour ${JSON.stringify(argb)}: expected 6 or 8 hexadecimal digits`);
+        throw new SyntaxError(`Invalid ARGB colour ${JSON.stringify(argb)}: expected 6 or 8 hexadecimal digits`);
     }
     return rgb;
 }
@@ -23,20 +23,14 @@ export function parseColor(attrs) {
     const color = {};
     if (attrs.rgb !== undefined)
         color.argb = attrs.rgb;
-    if (attrs.theme !== undefined) {
-        const theme = Number(attrs.theme);
-        if (Number.isInteger(theme))
-            color.theme = theme;
-    }
-    if (attrs.tint !== undefined) {
-        const tint = Number(attrs.tint);
-        if (Number.isFinite(tint))
-            color.tint = tint;
-    }
-    if (attrs.indexed !== undefined) {
-        const indexed = Number(attrs.indexed);
-        if (Number.isInteger(indexed))
-            color.indexed = indexed;
-    }
+    const theme = numInteger(attrs.theme, 0);
+    if (theme !== undefined)
+        color.theme = theme;
+    const tint = numFinite(attrs.tint);
+    if (tint !== undefined)
+        color.tint = tint;
+    const indexed = numInteger(attrs.indexed, 0);
+    if (indexed !== undefined)
+        color.indexed = indexed;
     return color;
 }