@shbernal/ts-xlsx 2.1.0 → 3.0.0

package/dist/core/used-extent.js

@@ -0,0 +1,102 @@
+import { cellCarriesContent } from './cell.js';
+function rowIsUsed(cols) {
+    for (const cell of cols.values()) {
+        if (cellCarriesContent(cell))
+            return true;
+    }
+    return false;
+}
+export class UsedExtent {
+    #storage;
+    #topRowKey = 0;
+    #topColumnKey = 0;
+    #topDeclaredRow = 0;
+    #topDeclaredColumn = 0;
+    #stale = false;
+    constructor(storage) {
+        this.#storage = storage;
+    }
+    noteCell(row, col) {
+        if (row > this.#topRowKey)
+            this.#topRowKey = row;
+        if (col > this.#topColumnKey)
+            this.#topColumnKey = col;
+    }
+    noteDeclaredRow(row) {
+        if (row > this.#topDeclaredRow)
+            this.#topDeclaredRow = row;
+    }
+    noteDeclaredColumn(col) {
+        if (col > this.#topDeclaredColumn)
+            this.#topDeclaredColumn = col;
+    }
+    noteMerge(rect) {
+        this.noteDeclaredRow(rect.bottom);
+        this.noteDeclaredColumn(rect.right);
+    }
+    invalidate() {
+        this.#stale = true;
+    }
+    reset() {
+        this.#topRowKey = 0;
+        this.#topColumnKey = 0;
+        this.#topDeclaredRow = 0;
+        this.#topDeclaredColumn = 0;
+        this.#stale = false;
+    }
+    get lastRow() {
+        this.#refresh();
+        if (this.#topRowKey <= this.#topDeclaredRow)
+            return this.#topDeclaredRow;
+        const top = this.#storage.rows.get(this.#topRowKey);
+        if (top !== undefined && rowIsUsed(top))
+            return this.#topRowKey;
+        let last = this.#topDeclaredRow;
+        for (const [number, cols] of this.#storage.rows) {
+            if (number > last && rowIsUsed(cols))
+                last = number;
+        }
+        return last;
+    }
+    get lastColumn() {
+        this.#refresh();
+        if (this.#topColumnKey <= this.#topDeclaredColumn)
+            return this.#topDeclaredColumn;
+        for (const cols of this.#storage.rows.values()) {
+            const cell = cols.get(this.#topColumnKey);
+            if (cell !== undefined && cellCarriesContent(cell))
+                return this.#topColumnKey;
+        }
+        let last = this.#topDeclaredColumn;
+        for (const cols of this.#storage.rows.values()) {
+            for (const [col, cell] of cols) {
+                if (col > last && cellCarriesContent(cell))
+                    last = col;
+            }
+        }
+        return last;
+    }
+    #refresh() {
+        if (!this.#stale)
+            return;
+        this.#stale = false;
+        this.#topRowKey = 0;
+        this.#topColumnKey = 0;
+        this.#topDeclaredRow = 0;
+        this.#topDeclaredColumn = 0;
+        for (const [number, cols] of this.#storage.rows) {
+            if (number > this.#topRowKey)
+                this.#topRowKey = number;
+            for (const col of cols.keys()) {
+                if (col > this.#topColumnKey)
+                    this.#topColumnKey = col;
+            }
+        }
+        for (const number of this.#storage.rowProperties.keys())
+            this.noteDeclaredRow(number);
+        for (const index of this.#storage.columns.keys())
+            this.noteDeclaredColumn(index);
+        for (const rect of this.#storage.mergeRects)
+            this.noteMerge(rect);
+    }
+}

package/dist/core/worksheet.d.ts

@@ -24,7 +24,7 @@ import type { CellValue } from './value.ts';
  */
 export type Visibility = 'visible' | 'hidden' | 'veryHidden';
 /** Narrow a raw `<sheet state>` or `<workbookView visibility>` token to a known {@link Visibility}. */
-export declare function isVisibility(value: string): value is Visibility;
+export declare const isVisibility: (value: string) => value is Visibility;
 export interface WorksheetState {
     /** Sheet visibility, as Excel models it. Defaults to `visible`. */
     readonly state: Visibility;
@@ -276,14 +276,21 @@ export declare class Worksheet {
      * or 0 for an empty sheet. Spans gaps: a value in row 5 makes this 5 even if rows 2–4
      * are empty. This is the used-range extent, not a populated-row tally (see
      * {@link actualRowCount}).
+     *
+     * *Carrying anything* is deliberately wide: a value, a cell's own style facet, quote-prefix flag
+     * or named-style link, a note, a row height or outline level, or a merge reaching down. Styling a
+     * band of empty rows is how a template is laid out, so those rows are used and {@link addRow}
+     * appends past them. A cell merely materialised by {@link getCell} and left untouched carries
+     * nothing, so reading a far address never grows the sheet.
      */
     get rowCount(): number;
     /** The number of rows that hold at least one non-empty cell, ignoring gaps and formatting-only rows. */
     get actualRowCount(): number;
     /**
-     * The 1-based index of the last column carrying anything (a non-empty cell or its own format
+     * The 1-based index of the last column carrying anything (a used cell or the column's own format
      * properties), or 0 for an empty sheet. The used-range width, mirroring {@link rowCount} for the
-     * other axis: a value in column E makes this 5 even if columns B–D are empty.
+     * other axis, down to what *carrying anything* means: a value in column E makes this 5 even if
+     * columns B–D are empty, and a column holding nothing but a styled empty cell is still used.
      */
     get columnCount(): number;
     /**
@@ -548,9 +555,13 @@ export declare class Worksheet {
     /**
      * Copy the row at the 1-based `start`, `options.count` times (default 1). With `options.insert`
      * (the default) the copies are inserted directly after the source, shifting the rows below, and
-     * any merged range there, down by `count`; otherwise the copies overwrite the rows immediately
-     * below without shifting. Each copy is a faithful duplicate of the source's values and per-cell
-     * styles, and carries no merge of its own, so a range can be merged onto a duplicated row afterwards.
+     * any merged range there, down by `count`; otherwise the copies *replace* the rows immediately
+     * below without shifting. A destination row is not overlaid but wholly re-made, so a cell it held
+     * in a column the source leaves empty is dropped, exactly as it would be with a shifting insert.
+     *
+     * Each copy is a faithful duplicate of the source: its cell values, its per-cell styles, and its
+     * row properties (height, hidden, outline level, row fill). It carries no merge of its own, so a
+     * range can be merged onto a duplicated row afterwards.
      *
      * @throws {RangeError} if `start` is not a positive integer or `count` is negative.
      */

package/dist/core/worksheet.js

@@ -1,5 +1,6 @@
 import { AuthoringError } from '../errors.js';
-import { decodeCellRef, decodeRange, encodeAddress, rectsOverlap, tryDecodeCellRef, } from './address.js';
+import { tokenSet } from '../token-set.js';
+import { decodeCellRef, decodeRange, encodeAddress, tryDecodeCellRef } from './address.js';
 import { canonicalizeAutoFilter } from './autofilter.js';
 import { applyCellStyle, Cell, copyCellContent } from './cell.js';
 import { Column } from './column.js';
@@ -7,20 +8,19 @@ import { ConditionalFormattingOverlay } from './conditional-formatting-overlay.j
 import { DataValidationOverlay } from './data-validation-overlay.js';
 import { GridEdits } from './grid-edits.js';
 import { INTERNAL } from './internal.js';
-import { clearCoveredValues, masterOf } from './merge.js';
+import { MergeIndex } from './merge-index.js';
+import { clearCoveredValues } from './merge.js';
 import { PivotTable } from './pivot-table.js';
 import { deriveCredential, } from './protection.js';
 import { Range, rangeFrom } from './range.js';
 import { buildRowCells, positionalPlacements, rowPlacements } from './row-input.js';
 import { Row } from './row.js';
 import { Table } from './table.js';
+import { UsedExtent } from './used-extent.js';
 import { WorksheetComments } from './worksheet-comments.js';
 import { WORKSHEET_MODEL_FACETS } from './worksheet-model.js';
 import { WorksheetPictures } from './worksheet-pictures.js';
-const VISIBILITIES = { visible: true, hidden: true, veryHidden: true };
-export function isVisibility(value) {
-    return Object.hasOwn(VISIBILITIES, value);
-}
+export const isVisibility = tokenSet({ visible: true, hidden: true, veryHidden: true });
 export class Worksheet {
     name;
     id;
@@ -54,10 +54,19 @@ export class Worksheet {
     #protection;
     #autoFilter;
     #edits;
+    #extent;
+    #mergeIndex;
     constructor(name, id, state = 'visible') {
         this.name = name;
         this.id = id;
         this.state = state;
+        this.#mergeIndex = new MergeIndex(this.#mergeRects);
+        this.#extent = new UsedExtent({
+            rows: this.#rows,
+            rowProperties: this.#rowProperties,
+            columns: this.#columns,
+            mergeRects: this.#mergeRects,
+        });
         this.#edits = new GridEdits({
             rows: this.#rows,
             rowProperties: this.#rowProperties,
@@ -79,7 +88,7 @@ export class Worksheet {
     }
     getCell(reference) {
         const { col, row } = decodeCellRef(reference);
-        const master = masterOf(this.#mergeRects, row, col);
+        const master = this.#mergeIndex.masterOf(row, col);
         return this.#cellAt(master.row, master.col);
     }
     hasCell(row, col) {
@@ -97,30 +106,17 @@ export class Worksheet {
         return new Range(this, referenceOrTop, left ?? 0, bottom ?? 0, right ?? 0);
     }
     get rowCount() {
-        let last = 0;
-        for (const [number, cols] of this.#rows) {
-            if (number > last && this.#rowHasContent(cols))
-                last = number;
-        }
-        for (const number of this.#rowProperties.keys()) {
-            if (number > last)
-                last = number;
-        }
-        for (const rect of this.#mergeRects) {
-            if (rect.bottom > last)
-                last = rect.bottom;
-        }
-        return last;
+        return this.#extent.lastRow;
     }
     get actualRowCount() {
         let count = 0;
         for (const cols of this.#rows.values()) {
-            if (this.#rowHasContent(cols))
+            if (this.#rowIsPopulated(cols))
                 count++;
         }
         return count;
     }
-    #rowHasContent(cols) {
+    #rowIsPopulated(cols) {
         for (const cell of cols.values()) {
             if (cell.value !== null)
                 return true;
@@ -128,22 +124,7 @@ export class Worksheet {
         return false;
     }
     get columnCount() {
-        let last = 0;
-        for (const cols of this.#rows.values()) {
-            for (const [col, cell] of cols) {
-                if (cell.value !== null && col > last)
-                    last = col;
-            }
-        }
-        for (const index of this.#columns.keys()) {
-            if (index > last)
-                last = index;
-        }
-        for (const rect of this.#mergeRects) {
-            if (rect.right > last)
-                last = rect.right;
-        }
-        return last;
+        return this.#extent.lastColumn;
     }
     get usedRange() {
         const bottom = this.rowCount;
@@ -231,11 +212,12 @@ export class Worksheet {
         const { top, left, bottom, right } = decodeRange(range);
         if (top !== undefined && left !== undefined && bottom !== undefined && right !== undefined) {
             const rect = { top, left, bottom, right };
-            const clash = this.#mergeRects.find((existing) => rectsOverlap(existing, rect));
-            if (clash) {
+            if (this.#mergeIndex.overlapping(rect) !== undefined) {
                 throw new AuthoringError(`merged range "${range}" overlaps an existing merged region`);
             }
             this.#mergeRects.push(rect);
+            this.#mergeIndex.note(rect);
+            this.#extent.noteMerge(rect);
             clearCoveredValues(this.#rows, rect);
         }
         this.#merges.push(range);
@@ -257,8 +239,11 @@ export class Worksheet {
         const { top, left, bottom, right } = decodeRange(range);
         if (top !== undefined && left !== undefined && bottom !== undefined && right !== undefined) {
             const rectIndex = this.#mergeRects.findIndex((r) => r.top === top && r.left === left && r.bottom === bottom && r.right === right);
-            if (rectIndex !== -1)
+            if (rectIndex !== -1) {
                 this.#mergeRects.splice(rectIndex, 1);
+                this.#mergeIndex.invalidate();
+                this.#extent.invalidate();
+            }
         }
         return true;
     }
@@ -282,6 +267,8 @@ export class Worksheet {
         assertStartAndCount('splice', 'row', start, count);
         const inserted = inserts.map((values, i) => buildRowCells(start + i, values, this.#columns));
         this.#edits.spliceRows(start, count, inserted);
+        this.#mergeIndex.invalidate();
+        this.#extent.invalidate();
     }
     insertRow(pos, values) {
         this.spliceRows(pos, 0, values);
@@ -323,6 +310,7 @@ export class Worksheet {
         const { count = 1, insert = true } = options;
         assertStartAndCount('duplicate', 'row', start, count);
         const source = this.#rows.get(start);
+        const sourceProperties = this.#rowProperties.get(start);
         const snapshot = (destRow) => {
             const row = new Map();
             if (source) {
@@ -334,18 +322,30 @@ export class Worksheet {
             }
             return row;
         };
+        const copyProperties = (destRow) => {
+            if (sourceProperties === undefined)
+                this.#rowProperties.delete(destRow);
+            else
+                this.#rowProperties.set(destRow, { ...sourceProperties });
+        };
         if (insert) {
             const copies = Array.from({ length: count }, () => snapshot(start));
             this.#edits.spliceRows(start + 1, 0, copies);
+            this.#mergeIndex.invalidate();
         }
         else {
             for (let i = 1; i <= count; i++)
                 this.#rows.set(start + i, snapshot(start + i));
         }
+        for (let i = 1; i <= count; i++)
+            copyProperties(start + i);
+        this.#extent.invalidate();
     }
     spliceColumns(start, count, ...inserts) {
         assertStartAndCount('splice', 'column', start, count);
         this.#edits.spliceColumns(start, count, inserts);
+        this.#mergeIndex.invalidate();
+        this.#extent.invalidate();
     }
     insertColumn(pos, values) {
         this.spliceColumns(pos, 0, values);
@@ -379,6 +379,8 @@ export class Worksheet {
         this.#dataValidations.clear();
         this.#conditionalFormattings.clear();
         this.#tables.length = 0;
+        this.#mergeIndex.invalidate();
+        this.#extent.reset();
     }
     set model(model) {
         this.#resetContent();
@@ -412,12 +414,14 @@ export class Worksheet {
             cell = new Cell(row, col);
             cols.set(col, cell);
         }
+        this.#extent.noteCell(row, col);
         return cell;
     }
     [INTERNAL] = {
         evictRow: (number) => {
             this.#rows.delete(number);
             this.#rowProperties.delete(number);
+            this.#extent.invalidate();
         },
         addLoadedPivotTable: (pivot) => {
             this.#loadedPivotTables.push(pivot);
@@ -439,6 +443,7 @@ export class Worksheet {
                 properties = {};
                 this.#rowProperties.set(number, properties);
             }
+            this.#extent.noteDeclaredRow(number);
             return properties;
         },
         rowCells: (number) => {
@@ -452,6 +457,7 @@ export class Worksheet {
                 properties = {};
                 this.#columns.set(index, properties);
             }
+            this.#extent.noteDeclaredColumn(index);
             return properties;
         },
         columnCells: (index) => {

package/dist/customui/ribbon.js

@@ -1,5 +1,6 @@
 import { strFromU8 } from 'fflate';
-import { boolStrict, localName, xmlEvents } from '../xml/xml-read.js';
+import { tokenSet } from '../token-set.js';
+import { boolStrict, localName, xmlEvents } from '../xml/xml-scan.js';
 import { CustomUiParseError } from './errors.js';
 export const CUSTOMUI_2006_NAMESPACE = 'http://schemas.microsoft.com/office/2006/01/customui';
 export const CUSTOMUI_2009_NAMESPACE = 'http://schemas.microsoft.com/office/2009/07/customui';
@@ -9,7 +10,7 @@ export function isCustomUiRelType(type) {
     return type.endsWith('/ui/extensibility');
 }
 const MAX_DEPTH = 256;
-const KNOWN_KINDS = {
+const isKnownControlKind = tokenSet({
     button: true,
     toggleButton: true,
     checkBox: true,
@@ -28,10 +29,7 @@ const KNOWN_KINDS = {
     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;

package/dist/io/opc/inflate.js

@@ -3,7 +3,7 @@ import { concat } from '../../bytes.js';
 import { PackageReadError } from './errors.js';
 const INPUT_SLICE = 1 << 14;
 export function inflatePackage(data, cap) {
-    const files = {};
+    const files = Object.create(null);
     let total = 0;
     let failure;
     const unzip = new Unzip((file) => {

package/dist/io/opc/part-paths.d.ts

@@ -2,3 +2,4 @@ export declare const THEME_PART_PATH = "xl/theme/theme1.xml";
 export declare function extensionOf(partPath: string): string;
 export declare function relsPathFor(partPath: string): string;
 export declare function relativePartPath(fromPath: string, toPath: string): string;
+export declare function resolveRelativePart(basePart: string, target: string): string;

package/dist/io/opc/part-paths.js

@@ -22,3 +22,18 @@ export function relativePartPath(fromPath, toPath) {
     const up = fromDir.length - common;
     return [...Array(up).fill('..'), ...toSegments.slice(common)].join('/');
 }
+export function resolveRelativePart(basePart, target) {
+    if (target.startsWith('/'))
+        return target.slice(1);
+    const baseDir = basePart.slice(0, basePart.lastIndexOf('/') + 1);
+    const out = [];
+    for (const segment of `${baseDir}${target}`.split('/')) {
+        if (segment === '' || segment === '.')
+            continue;
+        if (segment === '..')
+            out.pop();
+        else
+            out.push(segment);
+    }
+    return out.join('/');
+}

package/dist/io/opc/read-opc.d.ts

@@ -6,12 +6,31 @@ export interface PackageAccessors {
     /** A part's raw bytes, or undefined when the package holds no such part. */
     partBytes: (path: string) => Uint8Array | undefined;
 }
+/** A spreadsheet package opened for reading: inflated under the read bound, its parts bound to
+ * accessors, and its XML office document read if it has one. */
+export interface OpenedSpreadsheet {
+    /** The inflated parts, for a reader that hands the whole package on to another codec. */
+    readonly files: Record<string, Uint8Array>;
+    readonly pkg: PackageAccessors;
+    /** `xl/workbook.xml`, or undefined when the package carries no XML office document (a `.xlsb`
+     * carries `xl/workbook.bin` instead). Each entry point answers that case for itself: they
+     * genuinely want different answers, and the difference is documented where they diverge. */
+    readonly workbookXml: string | undefined;
+}
+/**
+ * Open a spreadsheet package: the six-step preamble every reader shares, and in particular the two
+ * decisions worth having exactly one of. The inflate bound is a security decision (an unbounded
+ * inflate is a zip bomb) and "does this package carry an XML office document" is the dispatch
+ * decision between the two codecs, so neither should be restated once per entry point.
+ *
+ * It deliberately stops short of the shared strings and the style table: those are codec-specific
+ * (`xl/sharedStrings.xml` against BIFF12's own record stream), and lifting them here would put
+ * SpreadsheetML knowledge into the container layer.
+ */
+export declare function openSpreadsheetPackage(data: Uint8Array, maxUncompressedBytes: number | undefined): OpenedSpreadsheet;
 export declare function packageAccessors(files: Record<string, Uint8Array>): PackageAccessors;
 export declare function relationshipTargetByType(xml: string, suffix: string): string | undefined;
 export declare function relationshipTargetsByType(xml: string, suffix: string): string[];
-export declare function resolveRelativePart(basePart: string, target: string): string;
-export declare function resolveWorkbookPart(target: string): string;
-export declare function parseRelationships(xml: string): Map<string, string>;
 export interface RelationshipRecord {
     readonly id: string;
     readonly type: string;

package/dist/io/opc/read-opc.js

@@ -1,6 +1,13 @@
 import { strFromU8 } from 'fflate';
 import { openElements } from '../../xml/xml-read.js';
-import { extensionOf, relsPathFor } from './part-paths.js';
+import { extensionOf, relsPathFor, resolveRelativePart } from './part-paths.js';
+import { DEFAULT_MAX_UNCOMPRESSED } from './read-options.js';
+import { inflateSpreadsheetPackage } from './sniff-format.js';
+export function openSpreadsheetPackage(data, maxUncompressedBytes) {
+    const files = inflateSpreadsheetPackage(data, maxUncompressedBytes ?? DEFAULT_MAX_UNCOMPRESSED);
+    const pkg = packageAccessors(files);
+    return { files, pkg, workbookXml: pkg.partText('xl/workbook.xml') };
+}
 export function packageAccessors(files) {
     return {
         partText: (path) => {
@@ -10,48 +17,13 @@ export function packageAccessors(files) {
         partBytes: (path) => files[path],
     };
 }
-function matchesType(attrs, suffix) {
-    return (attrs.Type !== undefined && attrs.Target !== undefined && attrs.Type.endsWith(`/${suffix}`));
-}
 export function relationshipTargetByType(xml, suffix) {
     return relationshipTargetsByType(xml, suffix)[0];
 }
 export function relationshipTargetsByType(xml, suffix) {
-    const targets = [];
-    for (const { attrs } of openElements(xml, 'Relationship')) {
-        if (matchesType(attrs, suffix))
-            targets.push(attrs.Target);
-    }
-    return targets;
-}
-export function resolveRelativePart(basePart, target) {
-    if (target.startsWith('/'))
-        return target.slice(1);
-    const baseDir = basePart.slice(0, basePart.lastIndexOf('/') + 1);
-    const out = [];
-    for (const segment of `${baseDir}${target}`.split('/')) {
-        if (segment === '' || segment === '.')
-            continue;
-        if (segment === '..')
-            out.pop();
-        else
-            out.push(segment);
-    }
-    return out.join('/');
-}
-export function resolveWorkbookPart(target) {
-    if (target.startsWith('/'))
-        return target.slice(1);
-    return `xl/${target.replace(/^\.\//, '')}`;
-}
-export function parseRelationships(xml) {
-    const rels = new Map();
-    for (const { attrs } of openElements(xml, 'Relationship')) {
-        if (attrs.Id !== undefined && attrs.Target !== undefined) {
-            rels.set(attrs.Id, attrs.Target);
-        }
-    }
-    return rels;
+    return parseRelationshipRecords(xml)
+        .filter((record) => record.type.endsWith(`/${suffix}`))
+        .map((record) => record.target);
 }
 export function parseRelationshipRecords(xml) {
     const records = [];

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

@@ -13,14 +13,9 @@ export declare function relationship(id: string, type: string, target: string, o
     external?: boolean;
 }): string;
 export declare function relationshipsPart(relationships: readonly string[]): string;
-export declare function preservedRelsXml(rels: readonly {
-    id: string;
-    type: string;
-    target: string;
-    external?: boolean;
-}[]): string;
 export declare function relsPartXml(rels: readonly {
     id: string;
     type: string;
     target: string;
+    external?: boolean;
 }[]): string;

package/dist/io/opc/rels.js

@@ -8,9 +8,6 @@ export function relationship(id, type, target, options) {
 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, rel.target, rel.external ? { external: true } : {})));
-}
 export function relsPartXml(rels) {
-    return relationshipsPart(rels.map((rel) => relationship(rel.id, rel.type, rel.target)));
+    return relationshipsPart(rels.map((rel) => relationship(rel.id, rel.type, rel.target, rel.external ? { external: true } : {})));
 }

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

@@ -1,5 +1,5 @@
 import { type Cell } from '../../core/cell.ts';
-import { type Border, type CellStyle, type Fill, type Font, type NamedCellStyle } from '../../core/style.ts';
+import { type Border, type CellStyle, type Fill, type Font, type NamedCellStyle, type TableStyleTable } 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
@@ -33,7 +33,31 @@ export interface StyleTable {
      * file declares no font table.
      */
     readonly defaultFont?: Font;
+    /**
+     * The stylesheet's preserved sub-tables, captured verbatim in the same scan that read the xfs: the
+     * differential styles a conditional format's `dxfId` indexes, a custom indexed palette, the
+     * author's recent-colour swatches, and the custom table-style definitions.
+     *
+     * They ride here rather than being extracted separately because they come out of the same part,
+     * and the reader that wanted them four more times over that part is what this replaced. Each is
+     * raw source text: re-parsing and re-serialising is exactly what would cost a foreign `<dxf>` its
+     * number format on a round trip.
+     */
+    readonly preserved: PreservedStyleTables;
+}
+/** The stylesheet content the model does not interpret and re-emits byte for byte. */
+export interface PreservedStyleTables {
+    readonly dxfs: readonly string[];
+    readonly indexedColors: readonly string[];
+    readonly mruColors: readonly string[];
+    readonly tableStyles: TableStyleTable;
 }
+/** The preserved sub-tables of a stylesheet that carries none: a package with no `styles.xml`, and
+ * the BIFF12 stylesheet, whose binary records hold no verbatim XML there would be anything to keep. */
+export declare const NO_PRESERVED_STYLE_TABLES: PreservedStyleTables;
+/** The xf layer of a stylesheet: what {@link resolveStyleTable} assembles out of the format tables,
+ * before the verbatim sub-tables that ride alongside it in a {@link StyleTable}. */
+export type ResolvedXfTables = Omit<StyleTable, 'preserved'>;
 /**
  * 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,
@@ -81,4 +105,4 @@ export declare function resolveStyleTable(tables: {
     readonly namedXfs: ReadonlyArray<XfStyle>;
     readonly labels: ReadonlyArray<StyleLabel>;
     readonly fonts: ReadonlyArray<Font | undefined>;
-}): StyleTable;
+}): ResolvedXfTables;

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

@@ -1,6 +1,12 @@
 import { applyCellStyle } from '../../core/cell.js';
 import { NAMED_STYLE_ID } from '../../core/internal.js';
 import { assignStyleFacets, } from '../../core/style.js';
+export const NO_PRESERVED_STYLE_TABLES = {
+    dxfs: [],
+    indexedColors: [],
+    mruColors: [],
+    tableStyles: { styles: [] },
+};
 const BUILTIN_NUMFMTS = new Map([
     [1, '0'],
     [2, '0.00'],

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

@@ -1,4 +1,4 @@
-import { numFmtCodeFor, resolveStyleTable, } from '../style/xf-style.js';
+import { numFmtCodeFor, NO_PRESERVED_STYLE_TABLES, resolveStyleTable, } from '../style/xf-style.js';
 import { RecordReader } from './primitives.js';
 import { readRecords } from './record-stream.js';
 import { BRT } from './record-types.js';
@@ -22,7 +22,7 @@ const COLLECTION_ENDS = new Set([
 ]);
 export function parseStyleTable(part) {
     if (part === undefined)
-        return { cellXfs: [], namedStyles: [] };
+        return { cellXfs: [], namedStyles: [], preserved: NO_PRESERVED_STYLE_TABLES };
     const numFmtCodes = new Map();
     const fonts = [];
     const fills = [];
@@ -73,7 +73,10 @@ export function parseStyleTable(part) {
                 break;
         }
     }
-    return resolveStyleTable({ directXfs, namedXfs, labels, fonts });
+    return {
+        ...resolveStyleTable({ directXfs, namedXfs, labels, fonts }),
+        preserved: NO_PRESERVED_STYLE_TABLES,
+    };
 }
 function readXf(reader, deps, isDirect) {
     const parent = reader.u16();