@shbernal/ts-xlsx 2.0.0 → 3.0.0

package/README.md

@@ -9,6 +9,8 @@
 A TypeScript-first library for reading and writing spreadsheet documents
 (`.xlsx` / OOXML, and CSV) — synchronous, `Uint8Array`-native, and dependency-lean.
 
+**[Documentation, guide and a browser playground](https://shbernal.github.io/ts-xlsx/)**
+
 > **Status — 1.0.0, the first release.**
 > `ts-xlsx` began as a hard fork of [ExcelJS](https://github.com/exceljs/exceljs)
 > and has been rebuilt from the ground up into a modern, strict-TypeScript library.
@@ -130,10 +132,12 @@ import {
   readXlsx, writeXlsx,        // buffered .xlsx  (Uint8Array ⇄ Workbook)
   readSheetRows,              // stream one sheet's rows, bounded memory
   readWorkbookStream,         // stream every sheet, rows one at a time
-  WorkbookStreamWriter,       // write a workbook incrementally, bounded memory
   readCsv, writeCsv,          // CSV as Uint8Array
   writeCsvText,               // CSV as a string
 } from '@shbernal/ts-xlsx';
+// The streaming writer opens files and pipes Node streams, so it is the one Node-only face
+// and lives behind its own subpath — which is what keeps everything above browser-safe:
+import {WorkbookStreamWriter} from '@shbernal/ts-xlsx/node';
 
 // Bounded-memory extraction — the whole workbook is never materialized:
 for (const row of readSheetRows(bytes, {sheet: 'People'})) {
@@ -189,18 +193,24 @@ on — a Lambda with no bundler, a service that only classifies failures:
 
 | Import from | You get | It loads |
 | --- | --- | --- |
-| `@shbernal/ts-xlsx` | everything | 902 KB |
-| `@shbernal/ts-xlsx/core` | `Workbook`, `Worksheet`, `Cell`, styles, values, addresses | 332 KB |
-| `@shbernal/ts-xlsx/xlsx` | `readXlsx`, `writeXlsx`/`writeXlsxAsync`, the streaming pair, VBA part edits | 887 KB |
-| `@shbernal/ts-xlsx/xlsb` | `readXlsb` | 469 KB |
-| `@shbernal/ts-xlsx/csv` | `readCsv`, `writeCsv`, `writeCsvText` | 341 KB |
-| `@shbernal/ts-xlsx/vba` | `parseVbaProject`, `addVbaReference`, `removeVbaModule` | 73 KB |
-| `@shbernal/ts-xlsx/customui` | `parseCustomUi` and the ribbon types | 26 KB |
-| `@shbernal/ts-xlsx/errors` | every error class the library throws | 12 KB |
+| `@shbernal/ts-xlsx` | everything except the streaming writer | 501 KB |
+| `@shbernal/ts-xlsx/core` | `Workbook`, `Worksheet`, `Cell`, styles, values, addresses | 185 KB |
+| `@shbernal/ts-xlsx/xlsx` | `readXlsx`, `writeXlsx`/`writeXlsxAsync`, the streaming reader, VBA part edits | 490 KB |
+| `@shbernal/ts-xlsx/xlsb` | `readXlsb` | 256 KB |
+| `@shbernal/ts-xlsx/csv` | `readCsv`, `writeCsv`, `writeCsvText` | 191 KB |
+| `@shbernal/ts-xlsx/node` | `WorkbookStreamWriter` and the rest of the streaming writer | 358 KB |
+| `@shbernal/ts-xlsx/vba` | `parseVbaProject`, `addVbaReference`, `removeVbaModule` | 46 KB |
+| `@shbernal/ts-xlsx/customui` | `parseCustomUi` and the ribbon types | 15 KB |
+| `@shbernal/ts-xlsx/errors` | every error class the library throws | 3 KB |
+
+`/node` is the only one the root specifier does not carry, and the reason is its imports
+rather than its size: it reaches `node:fs` and `node:stream`, and every other entry reaches
+no Node built-in at all, which is what makes them bundle for a browser with nothing to
+configure ([ADR-0040](docs/decisions/0040-the-browser-boundary-is-an-entry-point.md)).
 
 Every error class lives in `/errors` and nowhere else, because a container-level failure
 belongs to no single codec — `readXlsx` and `readXlsb` both raise `UnsupportedFormatError`.
-Catching and classifying therefore costs 12 KB, not a parser.
+Catching and classifying therefore costs 3 KB, not a parser.
 
 `/xlsx` is barely cheaper than the whole package, and that is honest rather than a defect:
 `readXlsx` sniffs the bytes and hands a binary package to the BIFF12 reader, so the `.xlsb`

package/dist/bytes.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Join byte chunks into one buffer.
+ *
+ * Both parameters exist to avoid work the caller has already done. `size` is the total length when
+ * the caller knows it, as a reader draining a length-prefixed stream does, which skips a pass over
+ * the chunks. A lone chunk is handed straight back rather than copied, which is the common case on
+ * the inflate path, where a part that fits in one chunk would otherwise be duplicated in memory the
+ * moment it is read.
+ *
+ * The returned buffer therefore aliases the caller's chunk when there is exactly one. Every caller
+ * here is a reader assembling bytes it then only reads, so this is sound; a caller that means to
+ * mutate the result must copy it.
+ */
+export declare function concat(chunks: readonly Uint8Array[], size?: number): Uint8Array;
+/**
+ * Standard base64 of `bytes`, padded with `=`.
+ *
+ * Spelled out rather than delegated because both platform routes are unavailable here: `Buffer` is
+ * a Node global, which is exactly what a browser-safe module may not reach for, and `btoa` is
+ * declared deprecated in Node's types (so the `no-deprecated` lint rule rejects it) and takes a
+ * binary string rather than bytes anyway. The one caller encodes a 16-byte salt and a 64-byte
+ * hash, so the loop below is not on any path where its cost is measurable.
+ */
+export declare function toBase64(bytes: Uint8Array): string;

package/dist/bytes.js

@@ -0,0 +1,34 @@
+export function concat(chunks, size) {
+    const first = chunks[0];
+    if (chunks.length === 1 && first !== undefined)
+        return first;
+    let total = size;
+    if (total === undefined) {
+        total = 0;
+        for (const chunk of chunks)
+            total += chunk.length;
+    }
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return out;
+}
+const BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+export function toBase64(bytes) {
+    let out = '';
+    for (let i = 0; i < bytes.length; i += 3) {
+        const a = bytes[i] ?? 0;
+        const b = bytes[i + 1] ?? 0;
+        const c = bytes[i + 2] ?? 0;
+        const triple = (a << 16) | (b << 8) | c;
+        const remaining = bytes.length - i;
+        out += BASE64_ALPHABET.charAt((triple >>> 18) & 63);
+        out += BASE64_ALPHABET.charAt((triple >>> 12) & 63);
+        out += remaining > 1 ? BASE64_ALPHABET.charAt((triple >>> 6) & 63) : '=';
+        out += remaining > 2 ? BASE64_ALPHABET.charAt(triple & 63) : '=';
+    }
+    return out;
+}

package/dist/core/address.d.ts

@@ -52,10 +52,21 @@ export interface RangeAddress {
     /** Canonical `tl:br` form: `"A1:B2"`, `"1:1"` (rows), `"A:A"` (columns). */
     readonly dimensions: string;
 }
-/** Convert a 1-based column number to its letters (`1 → "A"`, `27 → "AA"`). */
+/** Convert a 1-based column number to its letters (`1 → "A"`, `27 → "AA"`).
+ *
+ * @throws {RangeError} unless `n` is an integer in `1..MAX_COLUMN`. */
 export declare function numberToColumn(n: number): string;
 /** Convert column letters to a 1-based number (`"A" → 1`, `"AA" → 27`). */
 export declare function columnToNumber(letters: string): number;
+/**
+ * One corner of a range, as its reference text. An axis the corner omits contributes nothing, so a
+ * whole-row corner spells `6` and a whole-column one spells `B`, rather than acquiring the other
+ * axis from a sentinel. That is the honesty rule this module's header states, and letting an absent
+ * axis decay into text is exactly how `"$undefined$1"` and `"NaN:NaN"` used to reach a file.
+ *
+ * The unbounded counterpart to {@link encodeAddress}, which names one cell and so requires both.
+ */
+export declare function encodeCornerRef(col: number | undefined, row: number | undefined): string;
 /**
  * Decode a single cell/row/column reference into `{address, col, row}`. Anchoring
  * `$` signs are accepted and dropped; an absent axis is `undefined`.
@@ -81,11 +92,22 @@ export interface CellPosition {
 export declare function decodeCellRef(reference: string): CellPosition;
 /**
  * {@link decodeCellRef} for a reference that came out of a file rather than out of a caller:
- * `undefined` for anything that does not name one cell, whether it is a range, a bare row or
- * column, or outright garbage. A foreign producer writes all four, and none of them is worth
- * throwing over when the reading code's answer is simply "then there is nothing here".
+ * `undefined` for anything that does not name one cell that can exist: a range, a bare row or
+ * column, a position off the grid (`A0`, `XFE1`), or outright garbage. A foreign producer writes
+ * all of them, and none is worth throwing over when the reading code's answer is simply "then
+ * there is nothing here".
  */
 export declare function tryDecodeCellRef(reference: string): CellPosition | undefined;
+/**
+ * {@link decodeRange} for a reference that came out of a file: `undefined` for anything that does
+ * not name a region that can exist. The sibling of {@link tryDecodeCellRef} on the other arity: a
+ * `ref` or one area of a `sqref` is as likely to be malformed as a cell's `r`, and the reader's
+ * answer to both is the same one.
+ *
+ * An axis neither endpoint mentions stays `undefined`, exactly as in `decodeRange`: a whole-column
+ * range is unbounded, not unreadable, and a caller that needs a bounded rectangle says so itself.
+ */
+export declare function tryDecodeRange(reference: string): RangeAddress | undefined;
 /**
  * Decode a range reference (`A1:B2`, `$1:$1`, `Sheet1!$A:$A`) into its corners and
  * canonical dimensions. A single reference collapses to a degenerate range whose

package/dist/core/address.js

@@ -16,9 +16,7 @@ export function rectsOverlap(a, b) {
 const SINGLE_REF = /^\$?([A-Z]*)\$?(\d*)$/;
 const SHEET_PREFIX = /^(?:(?:'((?:[^']|'')*)')|([^'!]+))!(.*)$/;
 export function numberToColumn(n) {
-    if (!Number.isInteger(n) || n < 1 || n > MAX_COLUMN) {
-        throw new RangeError(`column ${n} is out of bounds: Excel supports 1..${MAX_COLUMN}`);
-    }
+    assertColumnInBounds(n);
     let letters = '';
     let remaining = n;
     while (remaining > 0) {
@@ -45,12 +43,11 @@ export function columnToNumber(letters) {
     }
     return n;
 }
+export function encodeCornerRef(col, row) {
+    return `${col !== undefined ? numberToColumn(col) : ''}${row !== undefined ? row : ''}`;
+}
 function makeCellAddress(col, row) {
-    return {
-        address: `${col !== undefined ? numberToColumn(col) : ''}${row !== undefined ? row : ''}`,
-        col,
-        row,
-    };
+    return { address: encodeCornerRef(col, row), col, row };
 }
 export function decodeAddress(reference) {
     const match = SINGLE_REF.exec(reference);
@@ -73,13 +70,28 @@ export function decodeCellRef(reference) {
     }
     return { col, row };
 }
+function rowCanExist(row) {
+    return row === undefined || (Number.isInteger(row) && row >= 1 && row <= MAX_ROW);
+}
 export function tryDecodeCellRef(reference) {
+    let position;
+    try {
+        position = decodeCellRef(reference);
+    }
+    catch {
+        return undefined;
+    }
+    return rowCanExist(position.row) ? position : undefined;
+}
+export function tryDecodeRange(reference) {
+    let range;
     try {
-        return decodeCellRef(reference);
+        range = decodeRange(reference);
     }
     catch {
         return undefined;
     }
+    return rowCanExist(range.top) && rowCanExist(range.bottom) ? range : undefined;
 }
 export function decodeRange(reference) {
     const prefix = SHEET_PREFIX.exec(reference);

package/dist/core/autofilter.d.ts

@@ -43,7 +43,7 @@ export interface CustomFilterPredicate {
 }
 export type CustomFilterOperator = 'equal' | 'notEqual' | 'lessThan' | 'lessThanOrEqual' | 'greaterThan' | 'greaterThanOrEqual';
 /** Narrow a raw `operator` attribute to a known {@link CustomFilterOperator}. */
-export declare function isCustomFilterOperator(value: string): value is CustomFilterOperator;
+export declare const isCustomFilterOperator: (value: string) => value is CustomFilterOperator;
 /**
  * Validate and normalise a settable autofilter into its canonical stored form. A bare range string
  * is the common case (dropdowns, no criteria); an {@link AutoFilter} object carries per-column
@@ -53,3 +53,14 @@ export declare function isCustomFilterOperator(value: string): value is CustomFi
  * here, so load never trips these guards.)
  */
 export declare function canonicalizeAutoFilter(input: string | AutoFilter): AutoFilter;
+/**
+ * Re-anchor a filter through a splice of `count` lines at `start` on `axis`, or drop it (`undefined`)
+ * when the splice deleted every line it covered.
+ *
+ * A row splice only moves the range. A column splice moves its left edge too, and a criterion is
+ * addressed by its offset from that edge rather than by an absolute column, so every offset is
+ * re-measured against the new edge and a criterion whose column was deleted goes with the column.
+ * Left alone, those offsets would keep their old numbers and silently re-point each filter at a
+ * neighbouring column.
+ */
+export declare function shiftAutoFilter(filter: AutoFilter, axis: 'row' | 'col', start: number, count: number, delta: number): AutoFilter | undefined;

package/dist/core/autofilter.js

@@ -1,16 +1,15 @@
 import { AuthoringError } from '../errors.js';
-import { decodeRange } from './address.js';
-const CUSTOM_FILTER_OPERATORS = new Set([
-    'equal',
-    'notEqual',
-    'lessThan',
-    'lessThanOrEqual',
-    'greaterThan',
-    'greaterThanOrEqual',
-]);
-export function isCustomFilterOperator(value) {
-    return CUSTOM_FILTER_OPERATORS.has(value);
-}
+import { tokenSet } from '../token-set.js';
+import { decodeRange, encodeAddress } from './address.js';
+import { isDeletedSpan, shiftIndex } from './grid-shift.js';
+export const isCustomFilterOperator = tokenSet({
+    equal: true,
+    notEqual: true,
+    lessThan: true,
+    lessThanOrEqual: true,
+    greaterThan: true,
+    greaterThanOrEqual: true,
+});
 export function canonicalizeAutoFilter(input) {
     const ref = typeof input === 'string' ? input : input.ref;
     const { top, left, bottom, right, dimensions } = decodeRange(ref);
@@ -37,3 +36,27 @@ function canonicalizeColumn(column, width) {
     }
     return column;
 }
+export function shiftAutoFilter(filter, axis, start, count, delta) {
+    const { top, left, bottom, right } = decodeRange(filter.ref);
+    if (top === undefined || left === undefined || bottom === undefined || right === undefined) {
+        return filter;
+    }
+    const [lo, hi] = axis === 'row' ? [top, bottom] : [left, right];
+    if (isDeletedSpan(lo, hi, start, count))
+        return undefined;
+    const movedLo = shiftIndex(lo, start, count, delta, axis);
+    const movedHi = shiftIndex(hi, start, count, delta, axis);
+    if (axis === 'row') {
+        const ref = `${encodeAddress(left, movedLo)}:${encodeAddress(right, movedHi)}`;
+        return { ref, columns: filter.columns };
+    }
+    const ref = `${encodeAddress(movedLo, top)}:${encodeAddress(movedHi, bottom)}`;
+    const columns = [];
+    for (const column of filter.columns) {
+        const absolute = left + column.colId;
+        if (isDeletedSpan(absolute, absolute, start, count))
+            continue;
+        columns.push({ ...column, colId: shiftIndex(absolute, start, count, delta, axis) - movedLo });
+    }
+    return { ref, columns };
+}

package/dist/core/axis-handle.d.ts

@@ -0,0 +1,8 @@
+export declare abstract class AxisHandle<P extends object> {
+    /** This position's format record, or `undefined` when it has none. Never fabricates one. */
+    protected abstract propertiesOf(): P | undefined;
+    /** This position's format record, created if it does not exist yet. */
+    protected abstract ensureProperties(): P;
+    protected read<K extends keyof P>(key: K): P[K] | undefined;
+    protected write<K extends keyof P>(key: K, value: P[K]): void;
+}

package/dist/core/axis-handle.js

@@ -0,0 +1,14 @@
+export class AxisHandle {
+    read(key) {
+        return this.propertiesOf()?.[key];
+    }
+    write(key, value) {
+        if (value === undefined) {
+            const properties = this.propertiesOf();
+            if (properties !== undefined)
+                delete properties[key];
+            return;
+        }
+        this.ensureProperties()[key] = value;
+    }
+}

package/dist/core/cell.d.ts

@@ -138,6 +138,30 @@ export declare class Cell {
     get note(): string | undefined;
     set note(note: string | undefined);
 }
+/**
+ * Whether a cell carries formatting of its own: one of the {@link CellStyle} facets, the quote-prefix
+ * flag, or a link to a named style. Driven by {@link CELL_STYLE_FACETS}, so a facet added to the
+ * tuple reaches every "is this cell blank" decision without anyone remembering to widen a literal.
+ *
+ * Row- and column-inherited formatting is not the cell's own and does not count. Neither does a
+ * note: it lives in the comments part, not the cell's `<c>` element, so a writer deciding whether an
+ * empty cell needs serialising asks exactly this. A caller asking whether the cell is *used* wants
+ * {@link cellCarriesContent}, which is this plus the value and the note.
+ */
+export declare function cellHasOwnStyle(cell: Cell): boolean;
+/**
+ * Whether a cell carries anything at all: a value, formatting of its own, or a note. This is the
+ * used-range test, the "carrying anything (data or its own formatting)" that `rowCount` and
+ * `columnCount` promise, and it is deliberately wider than "holds a value": someone who pre-formats
+ * an empty band has
+ * laid claim to those cells, and an append that treats them as free ground writes over the layout
+ * they just built; someone who notes an empty cell has put content in it by the note's own
+ * definition.
+ *
+ * A cell merely materialised by `getCell` and then left alone carries nothing, which is what keeps
+ * reading a far address from growing the sheet.
+ */
+export declare function cellCarriesContent(cell: Cell): boolean;
 export declare function applyCellStyle(cell: Cell, style: Readonly<CellStyle>): void;
 export declare function copyCellContent(source: CellModel, target: Cell): void;
 export declare function cellToModel(cell: Cell): CellModel;

package/dist/core/cell.js

@@ -1,6 +1,6 @@
 import { assertColumnInBounds, assertRowInBounds, encodeAddress } from './address.js';
 import { NAMED_STYLE_ID } from './internal.js';
-import { assignStyleFacets, } from './style.js';
+import { assignStyleFacets, CELL_STYLE_FACETS, } from './style.js';
 import { cellValueToText, coerceCellValue, detectValueType, } from './value.js';
 export class Cell {
     row;
@@ -106,6 +106,14 @@ export class Cell {
         this.#note = note;
     }
 }
+export function cellHasOwnStyle(cell) {
+    return (CELL_STYLE_FACETS.some((facet) => cell[facet] !== undefined) ||
+        cell.quotePrefix === true ||
+        cell[NAMED_STYLE_ID] !== undefined);
+}
+export function cellCarriesContent(cell) {
+    return cell.value !== null || cell.note !== undefined || cellHasOwnStyle(cell);
+}
 export function applyCellStyle(cell, style) {
     assignStyleFacets(cell, style);
 }

package/dist/core/color-resolution.d.ts

@@ -1,4 +1,4 @@
-import type { Color } from './style.ts';
+import { type Color } from './style.ts';
 import { type ThemeColorScheme } from './theme.ts';
 /**
  * The built-in indexed colour palette (ECMA-376 §18.8.27), by index. Entries 0–7 duplicate 8–15, a

package/dist/core/color-resolution.js

@@ -1,3 +1,4 @@
+import { parseArgb } from './style.js';
 import { DEFAULT_THEME_COLOR_SCHEME, THEME_COLOR_SLOTS } from './theme.js';
 export const DEFAULT_INDEXED_COLORS = [
     '00000000', '00FFFFFF', '00FF0000', '0000FF00', '000000FF', '00FFFF00', '00FF00FF', '0000FFFF',
@@ -19,9 +20,12 @@ export function resolveColor(color, context = {}) {
         return base;
     return applyTint(base, tint);
 }
+function resolveArgb(value) {
+    return parseArgb(value)?.toUpperCase();
+}
 function resolveBase(color, context) {
     if (color.argb !== undefined)
-        return normalizeArgb(color.argb);
+        return resolveArgb(color.argb);
     if (color.theme !== undefined) {
         const slot = THEME_COLOR_SLOTS[color.theme];
         if (slot === undefined)
@@ -38,16 +42,11 @@ function resolveBase(color, context) {
             : DEFAULT_INDEXED_COLORS[color.indexed];
         if (entry === undefined)
             return undefined;
-        const normalized = normalizeArgb(entry);
-        return normalized === undefined ? undefined : `FF${normalized.slice(2)}`;
+        const parsed = resolveArgb(entry);
+        return parsed === undefined ? undefined : `FF${parsed.slice(2)}`;
     }
     return undefined;
 }
-function normalizeArgb(value) {
-    const hex = value.startsWith('#') ? value.slice(1) : value;
-    const argb = hex.length === 6 ? `FF${hex}` : hex;
-    return /^[0-9a-fA-F]{8}$/.test(argb) ? argb.toUpperCase() : undefined;
-}
 export function applyTint(argb, tint) {
     const alpha = argb.slice(0, 2);
     const r = Number.parseInt(argb.slice(2, 4), 16) / 255;

package/dist/core/column.d.ts

@@ -1,9 +1,10 @@
+import { AxisHandle } from './axis-handle.ts';
 import type { Cell } from './cell.ts';
 import { type AssertNever } from './internal.ts';
 import type { Alignment, Border, Fill, Font, Protection } from './style.ts';
 import type { CellValue } from './value.ts';
 import type { ColumnProperties, Worksheet } from './worksheet.ts';
-export declare class Column {
+export declare class Column extends AxisHandle<ColumnProperties> {
     #private;
     /** 1-based column index. Fixed for this handle's lifetime. */
     readonly index: number;
@@ -18,6 +19,8 @@ export declare class Column {
      * is formatted, and they create the record on first write.
      */
     get properties(): Readonly<ColumnProperties> | undefined;
+    protected propertiesOf(): ColumnProperties | undefined;
+    protected ensureProperties(): ColumnProperties;
     /**
      * Stable key naming this column so a keyed-object row (see {@link Worksheet.addRow}) can place a
      * value under it by name rather than position. In-memory only: never serialized to OOXML.

package/dist/core/column.js

@@ -1,9 +1,11 @@
 import { assertColumnInBounds, encodeAddress, numberToColumn } from './address.js';
+import { AxisHandle } from './axis-handle.js';
 import { INTERNAL } from './internal.js';
-export class Column {
+export class Column extends AxisHandle {
     #sheet;
     index;
     constructor(sheet, index) {
+        super();
         assertColumnInBounds(index);
         this.#sheet = sheet;
         this.index = index;
@@ -12,73 +14,79 @@ export class Column {
         return numberToColumn(this.index);
     }
     get properties() {
+        return this.propertiesOf();
+    }
+    propertiesOf() {
         return this.#sheet[INTERNAL].columnPropertiesOf(this.index);
     }
+    ensureProperties() {
+        return this.#sheet[INTERNAL].ensureColumnProperties(this.index);
+    }
     get key() {
-        return this.#read('key');
+        return this.read('key');
     }
     set key(key) {
-        this.#write('key', key);
+        this.write('key', key);
     }
     get width() {
-        return this.#read('width');
+        return this.read('width');
     }
     set width(width) {
-        this.#write('width', width);
+        this.write('width', width);
     }
     get hidden() {
-        return this.#read('hidden');
+        return this.read('hidden');
     }
     set hidden(hidden) {
-        this.#write('hidden', hidden);
+        this.write('hidden', hidden);
     }
     get outlineLevel() {
-        return this.#read('outlineLevel');
+        return this.read('outlineLevel');
     }
     set outlineLevel(outlineLevel) {
-        this.#write('outlineLevel', outlineLevel);
+        this.write('outlineLevel', outlineLevel);
     }
     get collapsed() {
-        return this.#read('collapsed');
+        return this.read('collapsed');
     }
     set collapsed(collapsed) {
-        this.#write('collapsed', collapsed);
+        this.write('collapsed', collapsed);
     }
     get fill() {
-        return this.#read('fill');
+        return this.read('fill');
     }
     set fill(fill) {
-        this.#write('fill', fill);
+        this.write('fill', fill);
     }
     get numFmt() {
-        return this.#read('numFmt');
+        return this.read('numFmt');
     }
     set numFmt(numFmt) {
-        this.#write('numFmt', numFmt);
+        this.write('numFmt', numFmt);
     }
     get font() {
-        return this.#read('font');
+        return this.read('font');
     }
     set font(font) {
-        this.#write('font', font);
+        this.write('font', font);
     }
     get border() {
-        return this.#read('border');
+        return this.read('border');
     }
     set border(border) {
-        this.#write('border', border);
+        this.write('border', border);
     }
     get alignment() {
-        return this.#read('alignment');
+        return this.read('alignment');
     }
     set alignment(alignment) {
-        this.#write('alignment', alignment);
+        this.write('alignment', alignment);
     }
     get protection() {
-        return this.#read('protection');
+        return this.read('protection');
     }
     set protection(protection) {
-        this.#write('protection', protection);
+        this.write('protection', protection);
     }
     getCell(row) {
         return this.#sheet.getCell(encodeAddress(this.index, row));
@@ -98,16 +106,4 @@ export class Column {
                 this.getCell(index + 1).value = value;
         });
     }
-    #read(key) {
-        return this.#sheet[INTERNAL].columnPropertiesOf(this.index)?.[key];
-    }
-    #write(key, value) {
-        if (value === undefined) {
-            const properties = this.#sheet[INTERNAL].columnPropertiesOf(this.index);
-            if (properties !== undefined)
-                delete properties[key];
-            return;
-        }
-        this.#sheet[INTERNAL].ensureColumnProperties(this.index)[key] = value;
-    }
 }

package/dist/core/conditional-formatting-overlay.d.ts

@@ -10,6 +10,11 @@ export declare class ConditionalFormattingOverlay {
     add(formatting: ConditionalFormatting): void;
     /** The conditional formattings on this sheet, each bound to its target range, in insertion order. */
     get entries(): readonly ConditionalFormatting[];
+    /**
+     * Re-anchor every rule set through a row or column splice, so a highlight keeps covering the cells
+     * it was written for. A rule set whose every target area fell inside a deleted span goes with them.
+     */
+    shift(axis: 'row' | 'col', start: number, count: number, delta: number): void;
     /** Drop every conditional formatting, leaving the overlay empty. */
     clear(): void;
 }

package/dist/core/conditional-formatting-overlay.js

@@ -1,4 +1,6 @@
 import { cloneConditionalFormatting } from './conditional-formatting.js';
+import { replaceContents } from './containers.js';
+import { shiftSqref } from './merge.js';
 export class ConditionalFormattingOverlay {
     #entries = [];
     add(formatting) {
@@ -7,6 +9,15 @@ export class ConditionalFormattingOverlay {
     get entries() {
         return this.#entries;
     }
+    shift(axis, start, count, delta) {
+        const entries = [];
+        for (const entry of this.#entries) {
+            const ref = shiftSqref(entry.ref, axis, start, count, delta);
+            if (ref !== undefined)
+                entries.push({ ...entry, ref });
+        }
+        replaceContents(this.#entries, entries);
+    }
     clear() {
         this.#entries.length = 0;
     }