@shbernal/ts-xlsx 2.0.0 → 2.1.0

package/dist/customui/ribbon.js

@@ -9,26 +9,29 @@ export function isCustomUiRelType(type) {
     return type.endsWith('/ui/extensibility');
 }
 const MAX_DEPTH = 256;
-const KNOWN_KINDS = new Set([
-    'button',
-    'toggleButton',
-    'checkBox',
-    'editBox',
-    'dropDown',
-    'comboBox',
-    'gallery',
-    'menu',
-    'dynamicMenu',
-    'splitButton',
-    'buttonGroup',
-    'box',
-    'labelControl',
-    'separator',
-    'menuSeparator',
-    'dialogBoxLauncher',
-    'control',
-    'item',
-]);
+const KNOWN_KINDS = {
+    button: true,
+    toggleButton: true,
+    checkBox: true,
+    editBox: true,
+    dropDown: true,
+    comboBox: true,
+    gallery: true,
+    menu: true,
+    dynamicMenu: true,
+    splitButton: true,
+    buttonGroup: true,
+    box: true,
+    labelControl: true,
+    separator: true,
+    menuSeparator: true,
+    dialogBoxLauncher: true,
+    control: true,
+    item: true,
+};
+function isKnownControlKind(local) {
+    return Object.hasOwn(KNOWN_KINDS, local);
+}
 export function parseCustomUi(input) {
     const xml = typeof input === 'string' ? input : strFromU8(input);
     let root;
@@ -79,9 +82,7 @@ function toGroup(groupEl) {
     };
 }
 function toControl(el) {
-    const kind = KNOWN_KINDS.has(el.local)
-        ? el.local
-        : 'unknown';
+    const kind = isKnownControlKind(el.local) ? el.local : 'unknown';
     return {
         kind,
         ...identity(el.attrs),

package/dist/entries/core.d.ts

@@ -4,11 +4,11 @@ export { Cell } from '../core/cell.ts';
 export { applyTint, type ColorResolutionContext, DEFAULT_INDEXED_COLORS, resolveColor, SYSTEM_INDEXED_COLORS, } from '../core/color-resolution.ts';
 export { Column } from '../core/column.ts';
 export type { Comment, CommentThread, Mention, MentionRef, Person } from '../core/comment-thread.ts';
-export type { CfValueObject, ConditionalFormatting, ConditionalFormattingRule, } from '../core/conditional-formatting.ts';
+export type { CfTimePeriod, CfValueObject, CfValueObjectType, ConditionalFormatting, ConditionalFormattingOperator, ConditionalFormattingRule, ConditionalFormattingType, IconSetType, } from '../core/conditional-formatting.ts';
 export type { DataValidation, DataValidationEntry, DataValidationErrorStyle, DataValidationOperator, DataValidationType, } from '../core/data-validation.ts';
 export { type AnchoredImage, type AnchorPoint, type Extent, type ImageAnchor, type ImageEditAs, isOneCellAnchor, type OneCellAnchor, type PortableImage, PX_TO_EMU, type TwoCellAnchor, type WorkbookImage, type WorksheetImages, } from '../core/image.ts';
 export { MAX_COLUMN_WIDTH, MAX_ROW_HEIGHT } from '../core/limits.ts';
-export type { HeaderFooter, PageBreak, PageMargins, PageSetup, PrintOptions, } from '../core/page-setup.ts';
+export type { HeaderFooter, PageBreak, PageMargins, PageOrder, PageOrientation, PageSetup, PrintOptions, } from '../core/page-setup.ts';
 export { type ParsedPivotField, type ParsedPivotSource, type ParsedPivotTable, type PivotCacheField, type PivotItem, type PivotMetric, type PivotNumericSummary, type PivotRecordCell, type PivotSourceKind, PivotTable, type PivotTableOptions, } from '../core/pivot-table.ts';
 export type { PreservedPart, PreservedRelationship, PreservedRootReference, PreservedWorksheetReference, } from '../core/preserved.ts';
 export type { SheetProtection, SheetProtectionCredential, SheetProtectionFlags, SheetProtectionOptions, } from '../core/protection.ts';
@@ -22,4 +22,4 @@ export { DEFAULT_THEME_COLOR_SCHEME, DEFAULT_THEME_FONTS, THEME_COLOR_SLOTS, typ
 export { type CellValue, cellValueToText, coerceCellValue, type DataTableFormulaValue, detectValueType, ERROR_CODES, type ErrorCode, type ErrorValue, type FormulaResult, type FormulaValue, type HyperlinkValue, isDataTableFormulaValue, isErrorCode, isErrorValue, isFormulaValue, isHyperlinkValue, isRichTextValue, isSharedFormulaValue, type RichTextRun, type RichTextValue, richTextToPlain, type SharedFormulaValue, ValueType, } from '../core/value.ts';
 export { type AddImageOptions, type AddWorksheetOptions, DEFAULT_WORKBOOK_VIEW, type DefinedName, type PreservedWorkbookReference, Workbook, type WorkbookProperties, type WorkbookView, } from '../core/workbook.ts';
 export type { WorkbookProtection, WorkbookProtectionCredentialAttr, } from '../core/workbook-protection.ts';
-export { type CellModel, type ColumnProperties, type OutlineProperties, type RowInput, type RowProperties, type SheetView, Worksheet, type WorksheetModel, type WorksheetProperties, type WorksheetState, } from '../core/worksheet.ts';
+export { type CellModel, type ColumnProperties, type OutlineProperties, type RowInput, type RowProperties, type SheetView, type Visibility, Worksheet, type WorksheetModel, type WorksheetProperties, type WorksheetState, } from '../core/worksheet.ts';

package/dist/entries/csv.d.ts

@@ -1,2 +1,2 @@
 export { type CsvReadOptions, readCsv } from '../io/csv/read.ts';
-export { type CsvWriteOptions, writeCsv, writeCsvText } from '../io/csv/write.ts';
+export { type CsvEncoding, type CsvWriteOptions, writeCsv, writeCsvText } from '../io/csv/write.ts';

package/dist/entries/node-unavailable.d.ts

@@ -0,0 +1,15 @@
+/** Not available outside Node; see {@link WorkbookStreamWriter}. */
+export declare class StreamedRow {
+    constructor();
+}
+/** Not available outside Node; see {@link WorkbookStreamWriter}. */
+export declare class WorksheetStreamWriter {
+    constructor();
+}
+/**
+ * Not available outside Node. The streaming writer needs `node:fs` and `node:stream`; in a browser,
+ * build the workbook in memory and call `writeXlsx`.
+ */
+export declare class WorkbookStreamWriter {
+    constructor();
+}

package/dist/entries/node-unavailable.js

@@ -0,0 +1,20 @@
+const WHY = 'the streaming writer opens files and pipes Node streams, which a browser has neither of. ' +
+    'Use writeXlsx (or writeXlsxAsync), which produce the same package as bytes.';
+function unavailable(name) {
+    throw new Error(`ts-xlsx: ${name} is not available in this environment: ${WHY}`);
+}
+export class StreamedRow {
+    constructor() {
+        unavailable('StreamedRow');
+    }
+}
+export class WorksheetStreamWriter {
+    constructor() {
+        unavailable('WorksheetStreamWriter');
+    }
+}
+export class WorkbookStreamWriter {
+    constructor() {
+        unavailable('WorkbookStreamWriter');
+    }
+}

package/dist/entries/node.d.ts

@@ -0,0 +1 @@
+export { type CalcProperties, StreamedRow, WorkbookStreamWriter, type WorkbookStreamWriterOptions, WorksheetStreamWriter, } from '../io/xlsx/write-stream.ts';

package/dist/entries/node.js

@@ -0,0 +1 @@
+export { StreamedRow, WorkbookStreamWriter, WorksheetStreamWriter, } from '../io/xlsx/write-stream.js';

package/dist/entries/xlsx.d.ts

@@ -3,4 +3,3 @@ export { type ReadXlsxOptions, readXlsx } from '../io/xlsx/read.ts';
 export { type ReadSheetRowsOptions, readSheetRows, readWorkbookStream, } from '../io/xlsx/read-rows.ts';
 export { DEFAULT_THEME_XML, parseThemeColorScheme, parseThemeFontScheme, } from '../io/xlsx/theme-xml.ts';
 export { type WriteOptions, writeXlsx, writeXlsxAsync } from '../io/xlsx/write.ts';
-export { type CalcProperties, StreamedRow, WorkbookStreamWriter, type WorkbookStreamWriterOptions, WorksheetStreamWriter, } from '../io/xlsx/write-stream.ts';

package/dist/entries/xlsx.js

@@ -3,4 +3,3 @@ export { readXlsx } from '../io/xlsx/read.js';
 export { readSheetRows, readWorkbookStream, } from '../io/xlsx/read-rows.js';
 export { DEFAULT_THEME_XML, parseThemeColorScheme, parseThemeFontScheme, } from '../io/xlsx/theme-xml.js';
 export { writeXlsx, writeXlsxAsync } from '../io/xlsx/write.js';
-export { StreamedRow, WorkbookStreamWriter, WorksheetStreamWriter, } from '../io/xlsx/write-stream.js';

package/dist/io/csv/read.js

@@ -1,6 +1,6 @@
 import { Workbook } from '../../core/workbook.js';
 export function readCsv(input, options = {}) {
-    const text = stripBom(typeof input === 'string' ? input : Buffer.from(input).toString('utf8'));
+    const text = stripBom(typeof input === 'string' ? input : new TextDecoder('utf-8', { ignoreBOM: true }).decode(input));
     const delimiter = options.delimiter ?? ',';
     if (delimiter.length !== 1) {
         throw new RangeError(`CSV delimiter must be a single character, got ${JSON.stringify(delimiter)}`);

package/dist/io/csv/write.d.ts

@@ -1,5 +1,15 @@
 import { type CellValue } from '../../core/value.ts';
 import type { Workbook } from '../../core/workbook.ts';
+/**
+ * A byte encoding {@link writeCsv} can produce, spelled the way Node's `Buffer` spells it and
+ * meaning the same bytes.
+ *
+ * Named here rather than taken from Node's `BufferEncoding`, which is what this option used to be:
+ * that type is part of `@types/node`, so it made a browser consumer's public API surface depend on
+ * Node's types, and it offered `base64` and `hex` as if they were output encodings for a text
+ * format. The list is what a CSV consumer actually asks for.
+ */
+export type CsvEncoding = 'ascii' | 'latin1' | 'ucs-2' | 'ucs2' | 'utf-8' | 'utf-16le' | 'utf16le' | 'utf8';
 export interface CsvWriteOptions {
     /** Which worksheet to write; defaults to the first. A name matching no sheet throws rather than
      * silently emitting an empty file. */
@@ -14,7 +24,7 @@ export interface CsvWriteOptions {
     /** Render Date cells in UTC rather than the runner's local time. */
     readonly dateUTC?: boolean;
     /** Byte encoding for {@link writeCsv}; defaults to `"utf8"`. */
-    readonly encoding?: BufferEncoding;
+    readonly encoding?: CsvEncoding;
     /** Prepend a UTF-8 byte-order mark (applies only to UTF-8); defaults to `true` for UTF-8. */
     readonly bom?: boolean;
     /** Per-field transform replacing the default value rendering; receives the cell's value (`null`
@@ -28,6 +38,6 @@ export declare function writeCsvText(workbook: Workbook, options?: CsvWriteOptio
  * The CSV bytes of one worksheet in the requested encoding, with a UTF-8 BOM by default.
  *
  * @throws {AuthoringError} if a field holds an unpaired surrogate and the encoding is UTF-8, which
- * cannot represent one. The alternative is `Buffer.from`'s silent U+FFFD substitution.
+ * cannot represent one. The alternative is a silent U+FFFD substitution.
  */
 export declare function writeCsv(workbook: Workbook, options?: CsvWriteOptions): Uint8Array;

package/dist/io/csv/write.js

@@ -30,10 +30,10 @@ export function writeCsv(workbook, options = {}) {
     const utf8 = isUtf8(encoding);
     if (utf8)
         assertEncodable(text);
-    const body = Buffer.from(text, encoding);
+    const body = encode(text, encoding);
     const wantBom = options.bom ?? utf8;
     if (!wantBom || !utf8)
-        return Uint8Array.from(body);
+        return body;
     const out = new Uint8Array(UTF8_BOM.length + body.length);
     out.set(UTF8_BOM, 0);
     out.set(body, UTF8_BOM.length);
@@ -42,6 +42,21 @@ export function writeCsv(workbook, options = {}) {
 function isUtf8(encoding) {
     return encoding === 'utf8' || encoding === 'utf-8';
 }
+function encode(text, encoding) {
+    if (isUtf8(encoding))
+        return new TextEncoder().encode(text);
+    if (encoding === 'ascii' || encoding === 'latin1') {
+        const bytes = new Uint8Array(text.length);
+        for (let i = 0; i < text.length; i++)
+            bytes[i] = text.charCodeAt(i) & 0xff;
+        return bytes;
+    }
+    const bytes = new Uint8Array(text.length * 2);
+    const view = new DataView(bytes.buffer);
+    for (let i = 0; i < text.length; i++)
+        view.setUint16(i * 2, text.charCodeAt(i), true);
+    return bytes;
+}
 function assertEncodable(text) {
     const found = LONE_SURROGATE.exec(text);
     if (found === null)

package/dist/io/opc/inflate.js

@@ -1,4 +1,5 @@
 import { Unzip, UnzipInflate } from 'fflate';
+import { concat } from '../../bytes.js';
 import { PackageReadError } from './errors.js';
 const INPUT_SLICE = 1 << 14;
 export function inflatePackage(data, cap) {
@@ -23,7 +24,7 @@ export function inflatePackage(data, cap) {
             chunks.push(chunk);
             size += chunk.length;
             if (final)
-                files[file.name] = join(chunks, size);
+                files[file.name] = concat(chunks, size);
         };
         try {
             file.start();
@@ -43,14 +44,3 @@ export function inflatePackage(data, cap) {
         throw failure;
     return files;
 }
-function join(chunks, size) {
-    if (chunks.length === 1)
-        return chunks[0];
-    const out = new Uint8Array(size);
-    let at = 0;
-    for (const chunk of chunks) {
-        out.set(chunk, at);
-        at += chunk.length;
-    }
-    return out;
-}

package/dist/io/opc/rels.d.ts

@@ -1,3 +1,14 @@
+/**
+ * A single `<Relationship>`. An `external` target lives outside the package (a hyperlink URL), so the
+ * element carries `TargetMode="External"`; a package-internal target (the default) omits it.
+ *
+ * All three values are escaped here, unconditionally. The obligation used to sit in a comment saying
+ * the caller escaped a target it did not control, which made the safety of this function a property
+ * of its call sites rather than of itself, on the one boundary in the tree where `xml.ts` says that is
+ * explicitly not how it is done. Escaping a writer-controlled package path is the identity, so the
+ * generated chains emit the same bytes and the guarantee holds by construction instead of by
+ * inspecting every caller. `TargetMode` stays a fixed token, not a value.
+ */
 export declare function relationship(id: string, type: string, target: string, options?: {
     external?: boolean;
 }): string;

package/dist/io/opc/rels.js

@@ -2,13 +2,14 @@ import { escapeAttr, XML_DECLARATION } from '../../xml/xml.js';
 import { PKG_RELS_NS } from './namespaces.js';
 export function relationship(id, type, target, options) {
     const mode = options?.external ? ' TargetMode="External"' : '';
-    return `<Relationship Id="${id}" Type="${type}" Target="${target}"${mode}/>`;
+    return (`<Relationship Id="${escapeAttr(id)}" Type="${escapeAttr(type)}" ` +
+        `Target="${escapeAttr(target)}"${mode}/>`);
 }
 export function relationshipsPart(relationships) {
     return `${XML_DECLARATION}<Relationships xmlns="${PKG_RELS_NS}">${relationships.join('')}</Relationships>`;
 }
 export function preservedRelsXml(rels) {
-    return relationshipsPart(rels.map((rel) => relationship(rel.id, rel.type, escapeAttr(rel.target), rel.external ? { external: true } : {})));
+    return relationshipsPart(rels.map((rel) => relationship(rel.id, rel.type, rel.target, rel.external ? { external: true } : {})));
 }
 export function relsPartXml(rels) {
     return relationshipsPart(rels.map((rel) => relationship(rel.id, rel.type, rel.target)));

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

@@ -6,10 +6,15 @@ import { type Border, type CellStyle, type Fill, type Font, type NamedCellStyle
  * 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
+ * every codec 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.
+ *
+ * Read-only throughout: an xf is a resolved snapshot, assembled once and then only consulted. Both
+ * readers already build theirs through an explicitly-mutable draft (`{-readonly [K in keyof
+ * XfStyle]?: …}`), so the constraint costs nothing and stops a consumer editing a table entry that
+ * other cells share.
  */
-export interface XfStyle extends CellStyle {
+export interface XfStyle extends Readonly<CellStyle> {
     readonly quotePrefix?: boolean;
     /** The `xfId` link into the named-style layer (`cellStyleXfs`); absent for the Normal default (0). */
     readonly xfId?: number;

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

@@ -71,8 +71,13 @@ export function resolveStyleTable(tables) {
         const named = namedXfs[xf.xfId];
         return named === undefined ? xf : { ...named, ...xf };
     });
+    const labelsByXfId = new Map();
+    for (const label of labels) {
+        if (!labelsByXfId.has(label.xfId))
+            labelsByXfId.set(label.xfId, label);
+    }
     const namedStyles = namedXfs.map((xf, index) => {
-        const label = labels.find((entry) => entry.xfId === index);
+        const label = labelsByXfId.get(index);
         const style = {};
         assignStyleFacets(style, xf);
         if (label?.name !== undefined)

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

@@ -3,7 +3,6 @@ import type { Worksheet } from '../../core/worksheet.ts';
 import { type XmlAttributes } from '../../xml/xml-read.ts';
 import { type XfStyle } from '../style/xf-style.ts';
 import { type SharedString } from './cell-value.ts';
-import { RunAccumulator } from './rich-runs.ts';
 export declare class CellAccumulator {
     #private;
     constructor(options: {
@@ -15,8 +14,6 @@ export declare class CellAccumulator {
     get styleIndex(): number;
     /** This cell's 1-based column, or -1 when its address was absent or unparseable. */
     get col(): number;
-    /** The rich-text run accumulator, driven by the surrounding parser's `<r>`/`<rPr>` handling. */
-    get runs(): RunAccumulator;
     /**
      * 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.
@@ -40,5 +37,6 @@ 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,6 +1,6 @@
-import { decodeAddress, encodeAddress } from '../../core/address.js';
+import { encodeAddress, tryDecodeCellRef } from '../../core/address.js';
 import { translateFormula, unmangleFunctions } from '../../core/formula.js';
-import { boolStrict, decodeSpreadsheetText, numInteger, } from '../../xml/xml-read.js';
+import { boolStrict, 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';
@@ -16,17 +16,14 @@ export class CellAccumulator {
     #sharedClone = false;
     #dataTable = null;
     #valueText = '';
-    #inlineText = '';
     #hasFormula = false;
     #hasValue = false;
-    #runs = new RunAccumulator();
+    #runs;
     #masters = new Map();
-    #inInlineString = false;
     #capture = false;
     #text = '';
-    #richRuns;
     constructor(options) {
-        this.#richRuns = options.richRuns;
+        this.#runs = new RunAccumulator({ container: 'is', readRuns: options.richRuns });
     }
     get ref() {
         return this.#ref;
@@ -37,19 +34,15 @@ export class CellAccumulator {
     get col() {
         return this.#col;
     }
-    get runs() {
-        return this.#runs;
-    }
     #beginCell(attrs) {
-        this.#ref = attrs.r ?? '';
         this.#type = attrs.t ?? '';
         this.#style = numInteger(attrs.s, 0) ?? -1;
-        const decoded = this.#ref === '' ? undefined : decodeAddress(this.#ref);
+        const decoded = tryDecodeCellRef(attrs.r ?? '');
+        this.#ref = decoded === undefined ? '' : (attrs.r ?? '');
         this.#col = decoded?.col ?? -1;
         this.#row = decoded?.row ?? -1;
         this.#formula = '';
         this.#valueText = '';
-        this.#inlineText = '';
         this.#runs.beginContainer();
         this.#hasFormula = false;
         this.#hasValue = false;
@@ -81,15 +74,6 @@ export class CellAccumulator {
         this.#valueText = text;
         this.#hasValue = true;
     }
-    #beginInlineString() {
-        this.#inlineText = '';
-        this.#runs.beginContainer();
-    }
-    #appendText(text) {
-        const decoded = decodeSpreadsheetText(text);
-        if (!this.#runs.appendText(decoded) && this.#inInlineString)
-            this.#inlineText += decoded;
-    }
     get capturedText() {
         return this.#text;
     }
@@ -99,14 +83,12 @@ export class CellAccumulator {
     openElement(local, attrs, selfClosing) {
         this.#text = '';
         this.#capture = false;
+        if (this.#runs.open(local, attrs, selfClosing))
+            return true;
         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);
@@ -114,25 +96,12 @@ export class CellAccumulator {
             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) {
+        this.#runs.text(chunk);
         if (this.#capture)
             this.#text += chunk;
     }
@@ -142,6 +111,8 @@ export class CellAccumulator {
         return verdict;
     }
     #closeElement(local) {
+        if (this.#runs.close(local) !== 'other')
+            return 'claimed';
         switch (local) {
             case 'f':
                 this.#setFormula(this.#text);
@@ -149,17 +120,6 @@ export class CellAccumulator {
             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:
@@ -183,9 +143,7 @@ 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.#hasValue
-                    ? { result: decodeFormulaResult(this.#type, this.#valueText, style?.numFmt) }
-                    : {}),
+                ...this.cachedResult(style),
             };
         }
         if (this.#hasFormula && this.#formulaShared && this.#formulaSi >= 0) {
@@ -198,14 +156,18 @@ export class CellAccumulator {
                 return {
                     sharedFormula: encodeAddress(master.col, master.row),
                     formula: unmangleFunctions(translated),
-                    ...(this.#hasValue
-                        ? { result: decodeFormulaResult(this.#type, this.#valueText, style?.numFmt) }
-                        : {}),
+                    ...this.cachedResult(style),
                 };
             }
         }
         return this.decode(sharedStrings, style);
     }
+    cachedResult(style) {
+        if (!this.#hasValue)
+            return {};
+        const result = decodeFormulaResult(this.#type, this.#valueText, style?.numFmt);
+        return result === undefined ? {} : { result };
+    }
     decode(sharedStrings, style) {
         const raw = {
             type: this.#type,
@@ -213,7 +175,7 @@ export class CellAccumulator {
             formula: this.#formula,
             hasValue: this.#hasValue,
             valueText: this.#valueText,
-            inlineText: this.#inlineText,
+            inlineText: this.#runs.plainText,
             richTextRuns: this.#runs.runs,
         };
         return decodeCellContent(raw, sharedStrings, style?.numFmt);

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

@@ -29,4 +29,4 @@ export declare function decodeCellContent(raw: RawCell, sharedStrings: readonly
  * `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;
+export declare function decodeFormulaResult(type: string, valueText: string, numFmt?: string): FormulaResult | undefined;

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, decodeSpreadsheetText } from '../../xml/xml-read.js';
+import { boolStrict, decodeSpreadsheetText, numFinite } from '../../xml/xml-read.js';
 export function decodeCellContent(raw, sharedStrings, numFmt) {
     if (raw.hasFormula) {
         const stored = unmangleFunctions(raw.formula);
@@ -32,8 +32,11 @@ function decodeValue(type, valueText, inlineText, hasValue, sharedStrings) {
             return boolStrict(valueText);
         case 'e':
             return isErrorCode(valueText) ? { error: valueText } : valueText;
-        default:
-            return hasValue ? Number(valueText) : null;
+        default: {
+            if (!hasValue)
+                return null;
+            return numFinite(valueText) ?? null;
+        }
     }
 }
 export function decodeFormulaResult(type, valueText, numFmt) {
@@ -51,6 +54,6 @@ function decodeResult(type, valueText) {
         case 'e':
             return isErrorCode(valueText) ? { error: valueText } : valueText;
         default:
-            return Number(valueText);
+            return numFinite(valueText);
     }
 }

package/dist/io/xlsx/color-xml.d.ts

@@ -1,4 +1,4 @@
-import type { Color } from '../../core/style.ts';
+import { type Color } from '../../core/style.ts';
 /** Serialise a {@link Color} as the attribute list a `<color>`-shaped element carries. */
 export declare function colorAttrs(color: Color): string;
 export declare function parseColor(attrs: {

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

@@ -1,8 +1,9 @@
+import { parseArgb } from '../../core/style.js';
 import { numFinite, numInteger } from '../../xml/xml-read.js';
+import { numberText } from '../../xml/xml.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)) {
+    const rgb = parseArgb(argb);
+    if (rgb === undefined) {
         throw new SyntaxError(`Invalid ARGB colour ${JSON.stringify(argb)}: expected 6 or 8 hexadecimal digits`);
     }
     return rgb;
@@ -12,11 +13,11 @@ export function colorAttrs(color) {
     if (color.argb !== undefined)
         parts.push(`rgb="${normalizeArgb(color.argb)}"`);
     if (color.theme !== undefined)
-        parts.push(`theme="${color.theme}"`);
+        parts.push(`theme="${numberText(color.theme)}"`);
     if (color.tint !== undefined)
-        parts.push(`tint="${color.tint}"`);
+        parts.push(`tint="${numberText(color.tint)}"`);
     if (color.indexed !== undefined)
-        parts.push(`indexed="${color.indexed}"`);
+        parts.push(`indexed="${numberText(color.indexed)}"`);
     return parts.join(' ');
 }
 export function parseColor(attrs) {

package/dist/io/xlsx/comments.js

@@ -1,6 +1,6 @@
 import { tryDecodeCellRef } from '../../core/address.js';
 import { decodeSpreadsheetText, localName, numInteger, parseXml } from '../../xml/xml-read.js';
-import { escapeAttr, escapeText, textElement, XML_DECLARATION } from '../../xml/xml.js';
+import { escapeText, textAttr, textElement, XML_DECLARATION } from '../../xml/xml.js';
 import { MARKUP_COMPATIBILITY_NS, REVISION_NS, SPREADSHEETML_NS } from './namespaces.js';
 export function collectComments(sheet, threads) {
     const fallbacks = threadFallbacks(threads);
@@ -56,7 +56,7 @@ export function commentsXml(comments) {
         .map((comment) => {
         const { threadId } = comment;
         const authorId = threadId === undefined ? noteAuthorId : authorIdByThreadId.get(threadId);
-        const uid = threadId === undefined ? '' : ` xr:uid="${escapeAttr(threadId)}"`;
+        const uid = textAttr('xr:uid', threadId);
         return (`<comment ref="${comment.ref}" authorId="${authorId}"${uid}>` +
             `<text><r>${textElement(comment.text)}</r></text>` +
             '</comment>');
@@ -161,6 +161,8 @@ export function applyNotes(sheet, comments) {
     for (const [ref, comment] of comments) {
         if (comment.threadId !== undefined && headIds.has(comment.threadId))
             continue;
+        if (tryDecodeCellRef(ref) === undefined)
+            continue;
         sheet.getCell(ref).note = comment.text;
     }
 }

package/dist/io/xlsx/conditional-formatting.d.ts

@@ -1,4 +1,4 @@
-import type { ConditionalFormatting } from '../../core/conditional-formatting.ts';
+import { type ConditionalFormatting } from '../../core/conditional-formatting.ts';
 import type { StyleRegistry } from './styles.ts';
 /**
  * Serialise every conditional formatting on a sheet into its `<conditionalFormatting>` blocks, in