@shbernal/ts-xlsx 2.1.0 → 3.1.0

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,6 @@ 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;
 };

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,6 @@ export const BRT = {
     EndExternals: 354,
     SupSelf: 357,
     ExternSheet: 362,
-    WsProp: 147,
-    WsDim: 148,
     WsFmtInfo: 485,
-    BeginSheetData: 145,
-    EndSheetData: 146,
     ArrFmla: 426,
 };

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

@@ -1,19 +1,26 @@
+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-read.ts';
+import { type XmlAttributes } from '../../xml/xml-scan.ts';
 import { type XfStyle } from '../style/xf-style.ts';
 import { type SharedString } from './cell-value.ts';
 export declare class CellAccumulator {
     #private;
     constructor(options: {
         readonly richRuns: boolean;
+        readonly dateEpoch: DateEpoch;
     });
     /** 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;
+    /**
+     * Open a `<row>`: the cells that follow belong to it, and the next one with no `r` of its own is
+     * its first column. Both readers call this where they already tell the style resolver a row opened.
+     */
+    openRow(number: number): 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.

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

@@ -1,15 +1,17 @@
-import { encodeAddress, tryDecodeCellRef } from '../../core/address.js';
+import { encodeAddress, MAX_COLUMN, tryDecodeCellRef } from '../../core/address.js';
 import { translateFormula, unmangleFunctions } from '../../core/formula.js';
-import { boolStrict, numInteger } from '../../xml/xml-read.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 class CellAccumulator {
     #ref = '';
     #type = '';
     #style = -1;
     #col = -1;
     #row = -1;
+    #nextCol = 1;
     #formula = '';
     #formulaShared = false;
     #formulaSi = -1;
@@ -22,8 +24,10 @@ export class CellAccumulator {
     #masters = new Map();
     #capture = false;
     #text = '';
+    #dateEpoch;
     constructor(options) {
         this.#runs = new RunAccumulator({ container: 'is', readRuns: options.richRuns });
+        this.#dateEpoch = options.dateEpoch;
     }
     get ref() {
         return this.#ref;
@@ -34,13 +38,14 @@ export class CellAccumulator {
     get col() {
         return this.#col;
     }
+    openRow(number) {
+        this.#row = number;
+        this.#nextCol = 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.#placeCell(attrs.r);
         this.#formula = '';
         this.#valueText = '';
         this.#runs.beginContainer();
@@ -51,6 +56,24 @@ export class CellAccumulator {
         this.#sharedClone = false;
         this.#dataTable = null;
     }
+    #placeCell(ref) {
+        const decoded = ref === undefined ? undefined : tryDecodeCellRef(ref);
+        if (decoded !== undefined) {
+            this.#ref = ref ?? '';
+            this.#col = decoded.col;
+            this.#row = decoded.row;
+        }
+        else if (ref === undefined && this.#row > 0 && 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';
         this.#formulaSi = numInteger(attrs.si, 0) ?? -1;
@@ -165,7 +188,7 @@ export class CellAccumulator {
     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);
         return result === undefined ? {} : { result };
     }
     decode(sharedStrings, style) {
@@ -178,6 +201,6 @@ export class CellAccumulator {
             inlineText: this.#runs.plainText,
             richTextRuns: this.#runs.runs,
         };
-        return decodeCellContent(raw, sharedStrings, style?.numFmt);
+        return decodeCellContent(raw, sharedStrings, style?.numFmt, this.#dateEpoch);
     }
 }

package/dist/io/xlsx/cell-style-resolution.d.ts

@@ -0,0 +1,25 @@
+/** The attributes this resolver reads, the subset both readers' scanners already hand it. */
+interface StyleAttributes {
+    readonly [key: string]: string | undefined;
+}
+/**
+ * The cell → row → column style resolution for one worksheet, fed by the same elements in the same
+ * order both readers already visit them: `<col>` before any cell references it, `<row>` before its
+ * own cells.
+ */
+export declare class CellStyleResolver {
+    #private;
+    /** Record a `<col min max style>` span's default for the columns it covers. */
+    noteColumnSpan(first: number, last: number, attrs: StyleAttributes): void;
+    /** Open a `<row>`, taking the format it declares for its own bare cells. */
+    openRow(attrs: StyleAttributes): void;
+    /** Close the row, so a cell outside one never inherits the last row's format. */
+    closeRow(): void;
+    /**
+     * The `xfStyles` index a cell's format resolves to, or `-1` when nothing declares one. A row's
+     * format applies only when the row is marked `customFormat`; without that flag the `s` on a `<row>`
+     * describes the row itself and is not inherited by its cells.
+     */
+    indexFor(col: number, cellStyleIndex: number): number;
+}
+export {};

package/dist/io/xlsx/cell-style-resolution.js

@@ -0,0 +1,29 @@
+import { numInteger } from '../../xml/xml-attrs.js';
+import { boolStrict } from '../../xml/xml-scan.js';
+export class CellStyleResolver {
+    #columnStyle = new Map();
+    #rowStyle = -1;
+    #rowCustomFormat = false;
+    noteColumnSpan(first, last, attrs) {
+        const styleIndex = numInteger(attrs.style, 0) ?? -1;
+        if (styleIndex < 0)
+            return;
+        for (let index = first; index <= last; index++)
+            this.#columnStyle.set(index, styleIndex);
+    }
+    openRow(attrs) {
+        this.#rowStyle = numInteger(attrs.s, 0) ?? -1;
+        this.#rowCustomFormat = boolStrict(attrs.customFormat);
+    }
+    closeRow() {
+        this.#rowStyle = -1;
+        this.#rowCustomFormat = false;
+    }
+    indexFor(col, cellStyleIndex) {
+        if (cellStyleIndex >= 0)
+            return cellStyleIndex;
+        if (this.#rowCustomFormat && this.#rowStyle >= 0)
+            return this.#rowStyle;
+        return this.#columnStyle.get(col) ?? -1;
+    }
+}

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

@@ -1,3 +1,4 @@
+import { type DateEpoch } from '../../core/date.ts';
 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>`
@@ -22,11 +23,12 @@ export interface RawCell {
  * Decode a gathered cell into its model value. A formula cell becomes a `{formula, result?}`
  * object (the on-disk `_xlfn.`/`_xlpm.` mangling stripped back to the readable name); a plain
  * numeric cell under a date number format becomes a {@link Date}; everything else decodes by its
- * `t` type. `numFmt` is the cell's resolved number-format code, used only for date detection.
+ * `t` type. `numFmt` is the cell's resolved number-format code, used only for date detection, and
+ * `epoch` the workbook's date system, which is what a serial under such a format counts from.
  */
-export declare function decodeCellContent(raw: RawCell, sharedStrings: readonly SharedString[], numFmt: string | undefined): CellValue;
+export declare function decodeCellContent(raw: RawCell, sharedStrings: readonly SharedString[], numFmt: string | undefined, epoch: DateEpoch): 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
  * (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 | undefined;
+export declare function decodeFormulaResult(type: string, valueText: string, numFmt: string | undefined, epoch: DateEpoch): FormulaResult | undefined;

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

@@ -1,20 +1,21 @@
-import { isDateFormat, serialToDate } from '../../core/date.js';
+import { coerceDateSerial, parseDateText } from '../../core/date.js';
 import { unmangleFunctions } from '../../core/formula.js';
 import { isErrorCode, } from '../../core/value.js';
-import { boolStrict, decodeSpreadsheetText, numFinite } from '../../xml/xml-read.js';
-export function decodeCellContent(raw, sharedStrings, numFmt) {
+import { decodeSpreadsheetText, numFinite, numInteger } from '../../xml/xml-attrs.js';
+import { boolStrict } from '../../xml/xml-scan.js';
+export function decodeCellContent(raw, sharedStrings, numFmt, epoch) {
     if (raw.hasFormula) {
         const stored = unmangleFunctions(raw.formula);
-        const result = raw.hasValue ? decodeFormulaResult(raw.type, raw.valueText, numFmt) : undefined;
+        const result = raw.hasValue
+            ? decodeFormulaResult(raw.type, raw.valueText, numFmt, epoch)
+            : undefined;
         return result === undefined ? { formula: stored } : { formula: stored, result };
     }
     if (raw.type === 'inlineStr' && raw.richTextRuns !== undefined && raw.richTextRuns.length > 0) {
         return { richText: raw.richTextRuns };
     }
     const value = decodeValue(raw.type, raw.valueText, raw.inlineText, raw.hasValue, sharedStrings);
-    return typeof value === 'number' && numFmt !== undefined && isDateFormat(numFmt)
-        ? serialToDate(value)
-        : value;
+    return coerceDateSerial(value, numFmt, epoch);
 }
 function decodeValue(type, valueText, inlineText, hasValue, sharedStrings) {
     switch (type) {
@@ -23,10 +24,10 @@ function decodeValue(type, valueText, inlineText, hasValue, sharedStrings) {
         case 'str':
             return decodeSpreadsheetText(valueText);
         case 'd':
-            return valueText === '' ? null : new Date(valueText);
+            return parseDateText(valueText);
         case 's': {
-            const index = Number(valueText);
-            return Number.isInteger(index) ? (sharedStrings[index] ?? '') : '';
+            const index = numInteger(valueText, 0);
+            return index === undefined ? '' : (sharedStrings[index] ?? '');
         }
         case 'b':
             return boolStrict(valueText);
@@ -39,11 +40,8 @@ function decodeValue(type, valueText, inlineText, hasValue, sharedStrings) {
         }
     }
 }
-export function decodeFormulaResult(type, valueText, numFmt) {
-    const result = decodeResult(type, valueText);
-    return typeof result === 'number' && numFmt !== undefined && isDateFormat(numFmt)
-        ? serialToDate(result)
-        : result;
+export function decodeFormulaResult(type, valueText, numFmt, epoch) {
+    return coerceDateSerial(decodeResult(type, valueText), numFmt, epoch);
 }
 function decodeResult(type, valueText) {
     switch (type) {

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

@@ -1,10 +1,11 @@
 import { parseArgb } from '../../core/style.js';
-import { numFinite, numInteger } from '../../xml/xml-read.js';
+import { quoted } from '../../errors.js';
+import { numFinite, numInteger } from '../../xml/xml-attrs.js';
 import { numberText } from '../../xml/xml.js';
 function normalizeArgb(argb) {
     const rgb = parseArgb(argb);
     if (rgb === undefined) {
-        throw new SyntaxError(`Invalid ARGB colour ${JSON.stringify(argb)}: expected 6 or 8 hexadecimal digits`);
+        throw new SyntaxError(`Invalid ARGB colour ${quoted(argb)}: expected 6 or 8 hexadecimal digits`);
     }
     return rgb;
 }

package/dist/io/xlsx/column-budget.d.ts

@@ -0,0 +1,26 @@
+import { type XmlAttributes } from '../../xml/xml-scan.ts';
+/**
+ * A per-sheet allowance of column touches, spent by each `<col>` span the reader applies.
+ *
+ * A span past the allowance is truncated, and one starting past it is dropped, rather than the read
+ * being refused: that is the stance both readers already take on an out-of-grid span, and it means a
+ * hostile file loses formatting it could not have meant while a real one is untouched.
+ */
+export declare class ColumnRecordBudget {
+    #private;
+    /** The last column of `[first, last]` this sheet can still afford, or `undefined` when none is. */
+    take(first: number, last: number): number | undefined;
+}
+/**
+ * The columns a `<col min max>` element actually applies to, or `undefined` for one that applies to
+ * none: unreadable bounds, a span starting past the grid, or a budget already spent.
+ *
+ * Beside the budget because the two decisions are one decision. Both readers had their own copy, and
+ * the copies had already drifted: one tested `min > MAX_COLUMN` and the other did not, which happened
+ * not to matter only because `budget.take` returns `undefined` when `first > last` - an accident of
+ * this class's contract rather than an agreement between the readers.
+ */
+export declare function takeColumnSpan(attrs: XmlAttributes, budget: ColumnRecordBudget): {
+    first: number;
+    last: number;
+} | undefined;

package/dist/io/xlsx/column-budget.js

@@ -0,0 +1,22 @@
+import { MAX_COLUMN } from '../../core/address.js';
+import { numInteger } from '../../xml/xml-attrs.js';
+import {} from '../../xml/xml-scan.js';
+const MAX_COLUMN_RECORD_TOUCHES = MAX_COLUMN * 4;
+export class ColumnRecordBudget {
+    #remaining = MAX_COLUMN_RECORD_TOUCHES;
+    take(first, last) {
+        if (this.#remaining <= 0 || first > last)
+            return undefined;
+        const affordable = Math.min(last, first + this.#remaining - 1);
+        this.#remaining -= affordable - first + 1;
+        return affordable;
+    }
+}
+export function takeColumnSpan(attrs, budget) {
+    const first = numInteger(attrs.min, 1);
+    const declared = numInteger(attrs.max, 1);
+    if (first === undefined || declared === undefined || first > MAX_COLUMN)
+        return undefined;
+    const last = budget.take(first, Math.min(declared, MAX_COLUMN));
+    return last === undefined ? undefined : { first, last };
+}

package/dist/io/xlsx/comments.d.ts

@@ -1,6 +1,8 @@
+import type { Cell } from '../../core/cell.ts';
 import type { CommentThread } from '../../core/comment-thread.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
-/** A comment bound for `comments{n}.xml`, paired with the coordinates the VML anchor needs. */
+/** A comment bound for `comments{n}.xml`, paired with the coordinates the VML anchor needs.
+ */
 export interface CommentCell {
     readonly ref: string;
     /** 1-based row of the commented cell. */
@@ -28,7 +30,9 @@ export interface CommentCell {
  * Ordered by cell, row-major, the way Excel writes the list, so a fallback lands interleaved among the
  * notes rather than appended after them, and the VML shapes follow the same order.
  */
-export declare function collectComments(sheet: Worksheet, threads: readonly CommentThread[]): CommentCell[];
+export declare function collectComments(cells: Iterable<Cell>, threads: readonly CommentThread[], alreadyCollected?: readonly CommentCell[]): CommentCell[];
+/** The notes among a run of cells, for a writer that must ask before the cells are evicted. */
+export declare function collectNotes(cells: Iterable<Cell>): CommentCell[];
 /**
  * The `xl/comments{n}.xml` part.
  *

package/dist/io/xlsx/comments.js

@@ -1,19 +1,32 @@
 import { tryDecodeCellRef } from '../../core/address.js';
-import { decodeSpreadsheetText, localName, numInteger, parseXml } from '../../xml/xml-read.js';
+import { decodeSpreadsheetText, numInteger } from '../../xml/xml-attrs.js';
+import { parseXml, TextCapture } from '../../xml/xml-read.js';
+import { localName } from '../../xml/xml-scan.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) {
+export function collectComments(cells, threads, alreadyCollected = []) {
     const fallbacks = threadFallbacks(threads);
     const anchored = new Set(fallbacks.map((fallback) => fallback.ref));
-    const comments = [...fallbacks];
-    for (const { cells } of sheet.rows()) {
-        for (const cell of cells) {
-            if (cell.note === undefined || anchored.has(cell.address))
-                continue;
-            comments.push({ ref: cell.address, row: cell.row, col: cell.col, text: cell.note });
-        }
+    const comments = [...fallbacks, ...alreadyCollected];
+    for (const cell of cells) {
+        if (cell.note === undefined || anchored.has(cell.address))
+            continue;
+        comments.push(noteOn(cell, cell.note));
+    }
+    return comments
+        .filter((comment) => comment.threadId !== undefined || !anchored.has(comment.ref))
+        .sort((a, b) => a.row - b.row || a.col - b.col);
+}
+export function collectNotes(cells) {
+    const notes = [];
+    for (const cell of cells) {
+        if (cell.note !== undefined)
+            notes.push(noteOn(cell, cell.note));
     }
-    return comments.sort((a, b) => a.row - b.row || a.col - b.col);
+    return notes;
+}
+function noteOn(cell, text) {
+    return { ref: cell.address, row: cell.row, col: cell.col, text };
 }
 function threadFallbacks(threads) {
     const fallbacks = [];
@@ -75,13 +88,14 @@ const VML_HEADER = '<xml xmlns:v="urn:schemas-microsoft-com:vml" ' +
     '<v:shapetype id="_x0000_t202" coordsize="21600,21600" o:spt="202" ' +
     'path="m,l,21600r21600,l21600,xe"><v:stroke joinstyle="miter"/>' +
     '<v:path gradientshapeok="t" o:connecttype="rect"/></v:shapetype>';
+const FIRST_SHAPE_ID = 1025;
 export function vmlDrawingXml(comments) {
     const shapes = comments
         .map((comment, i) => {
         const row0 = comment.row - 1;
         const col0 = comment.col - 1;
         const anchor = `${col0 + 1}, 15, ${row0}, 2, ${col0 + 3}, 15, ${row0 + 4}, 4`;
-        return (`<v:shape id="_x0000_s${1025 + i}" type="#_x0000_t202" ` +
+        return (`<v:shape id="_x0000_s${FIRST_SHAPE_ID + i}" type="#_x0000_t202" ` +
             'style="position:absolute;margin-left:59.25pt;margin-top:1.5pt;width:108pt;height:59.25pt;' +
             `z-index:${i + 1};visibility:hidden" fillcolor="#ffffe1" o:insetmode="auto">` +
             '<v:fill color2="#ffffe1"/><v:shadow on="t" color="black" obscured="t"/>' +
@@ -94,50 +108,41 @@ export function vmlDrawingXml(comments) {
         .join('');
     return `${VML_HEADER}${shapes}</xml>`;
 }
-const COMMENT_EMPTY_CLOSES = new Set(['author']);
+const COMMENT_EMPTY_CLOSES = new Set(['author', 'text']);
 const THREAD_AUTHOR_PREFIX = 'tc=';
 export function parseComments(xml) {
     const comments = new Map();
     const authors = [];
     let currentRef;
     let currentAuthorId;
-    let capture;
-    let buffer = '';
+    const capture = new TextCapture(['author', 'text']);
+    let body = '';
     parseXml(xml, {
-        onOpen(name, attrs) {
+        onOpen(name, attrs, selfClosing) {
             const local = localName(name);
             if (local === 'comment') {
                 currentRef = attrs.ref;
                 currentAuthorId = attrs.authorId;
-                buffer = '';
-            }
-            else if (local === 'author') {
-                capture = 'author';
-                buffer = '';
-            }
-            else if (local === 'text') {
-                capture = 'text';
+                body = '';
             }
+            capture.open(local, selfClosing);
         },
         onText(text) {
-            if (capture !== undefined)
-                buffer += text;
+            capture.text(text);
         },
         onClose(name) {
             const local = localName(name);
+            const text = capture.close(local);
             if (local === 'author') {
-                authors.push(buffer);
-                capture = undefined;
-                buffer = '';
+                authors.push(text ?? '');
             }
             else if (local === 'text') {
-                buffer = decodeSpreadsheetText(buffer);
-                capture = undefined;
+                body = decodeSpreadsheetText(text ?? '');
             }
             else if (local === 'comment' && currentRef !== undefined) {
                 const threadId = threadIdOf(authors[numInteger(currentAuthorId, 0) ?? -1]);
                 comments.set(currentRef, {
-                    text: buffer,
+                    text: body,
                     ...(threadId !== undefined ? { threadId } : {}),
                 });
                 currentRef = undefined;

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

@@ -1,11 +1,15 @@
-import { type ConditionalFormatting } from '../../core/conditional-formatting.ts';
+import { type ConditionalFormatting, type ConditionalFormattingRule } from '../../core/conditional-formatting.ts';
+import { type CollectingPass } from '../../xml/xml-read.ts';
 import type { StyleRegistry } from './styles.ts';
+/** Each extended data bar's link id, keyed by rule identity: the one map both passes are handed. */
+export type DataBarExtLinks = ReadonlyMap<ConditionalFormattingRule, string>;
+export declare function dataBarExtLinks(formattings: readonly ConditionalFormatting[]): DataBarExtLinks;
 /**
  * Serialise every conditional formatting on a sheet into its `<conditionalFormatting>` blocks, in
  * insertion order. Returns '' when the sheet has none. A rule missing a `priority` is assigned the
  * next free one, so the output always satisfies Excel's requirement that every cfRule carry one.
  */
-export declare function conditionalFormattingsXml(formattings: readonly ConditionalFormatting[], styles: StyleRegistry): string;
+export declare function conditionalFormattingsXml(formattings: readonly ConditionalFormatting[], styles: StyleRegistry, extLinks: DataBarExtLinks): string;
 /**
  * The worksheet `<extLst>` `<ext>` carrying the x14 data-bar extensions, or '' when no data bar needs
  * one. Each extension's `<x14:cfRule id>` is read from the same {@link dataBarExtLinks} map the classic
@@ -13,16 +17,16 @@ export declare function conditionalFormattingsXml(formattings: readonly Conditio
  * (no `<extLst>` wrapper) so the worksheet serialiser can gather it into a single `<extLst>` beside the
  * data-validation extension.
  */
-export declare function conditionalFormattingsExtXml(formattings: readonly ConditionalFormatting[]): string;
+export declare function conditionalFormattingsExtXml(formattings: readonly ConditionalFormatting[], extLinks: DataBarExtLinks): string;
 /**
- * Parse a worksheet's conditional formatting into the model. The classic `<conditionalFormatting>`
+ * A pass reading a worksheet's conditional formatting into the model. The classic `<conditionalFormatting>`
  * blocks supply every rule; the x14 extension (`<x14:conditionalFormatting>` inside `<extLst>`) is
  * read only to enrich a classic data bar with the facets the classic element cannot carry (the
  * gradient flag and the negative-fill and axis colours) matched by the shared id the two ends link
  * on. An extension rule with no classic counterpart (a rule that lives only in x14) is ignored, so it
  * is never half-read into a broken classic rule.
  */
-export declare function parseConditionalFormattings(xml: string): ConditionalFormatting[];
+export declare function conditionalFormattingPass(): CollectingPass<ConditionalFormatting[]>;
 /**
  * Extract the differential-style (`<dxf>`) fragments from styles.xml, each verbatim. Preserving the
  * raw XML, rather than reparsing and re-serialising, is what keeps a foreign dxf's number format a