@shbernal/ts-xlsx 2.1.0 → 3.0.0

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

package/dist/core/autofilter.js

@@ -1,17 +1,15 @@
 import { AuthoringError } from '../errors.js';
+import { tokenSet } from '../token-set.js';
 import { decodeRange, encodeAddress } from './address.js';
 import { isDeletedSpan, shiftIndex } from './grid-shift.js';
-const CUSTOM_FILTER_OPERATORS = {
+export const isCustomFilterOperator = tokenSet({
     equal: true,
     notEqual: true,
     lessThan: true,
     lessThanOrEqual: true,
     greaterThan: true,
     greaterThanOrEqual: true,
-};
-export function isCustomFilterOperator(value) {
-    return Object.hasOwn(CUSTOM_FILTER_OPERATORS, value);
-}
+});
 export function canonicalizeAutoFilter(input) {
     const ref = typeof input === 'string' ? input : input.ref;
     const { top, left, bottom, right, dimensions } = decodeRange(ref);

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/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.d.ts

@@ -2,7 +2,7 @@ import type { Color, DifferentialStyle } from './style.ts';
 /** How a {@link CfValueObject} reads its `value`: `ST_CfvoType` verbatim. */
 export type CfValueObjectType = 'num' | 'percent' | 'max' | 'min' | 'percentile' | 'formula';
 /** Narrow a raw `<cfvo type>` token to a known {@link CfValueObjectType}. */
-export declare function isCfValueObjectType(value: string): value is CfValueObjectType;
+export declare const isCfValueObjectType: (value: string) => value is CfValueObjectType;
 /**
  * One anchor of a colour-scale, data-bar, or icon-set scale: a "conditional format value object".
  * `type` names how `value` is read: a literal `num`, a `percent`/`percentile` of the range, a
@@ -22,7 +22,7 @@ export interface CfValueObject {
  */
 export type ConditionalFormattingType = 'expression' | 'cellIs' | 'colorScale' | 'dataBar' | 'iconSet' | 'top10' | 'uniqueValues' | 'duplicateValues' | 'containsText' | 'notContainsText' | 'beginsWith' | 'endsWith' | 'containsBlanks' | 'notContainsBlanks' | 'containsErrors' | 'notContainsErrors' | 'timePeriod' | 'aboveAverage';
 /** Narrow a raw `<cfRule type>` token to a known {@link ConditionalFormattingType}. */
-export declare function isConditionalFormattingType(value: string): value is ConditionalFormattingType;
+export declare const isConditionalFormattingType: (value: string) => value is ConditionalFormattingType;
 /**
  * How a `cellIs` or text rule compares, as `ST_ConditionalFormattingOperator` enumerates it.
  *
@@ -32,11 +32,11 @@ export declare function isConditionalFormattingType(value: string): value is Con
  */
 export type ConditionalFormattingOperator = 'lessThan' | 'lessThanOrEqual' | 'equal' | 'notEqual' | 'greaterThanOrEqual' | 'greaterThan' | 'between' | 'notBetween' | 'containsText' | 'notContains' | 'beginsWith' | 'endsWith';
 /** Narrow a raw `<cfRule operator>` token to a known {@link ConditionalFormattingOperator}. */
-export declare function isConditionalFormattingOperator(value: string): value is ConditionalFormattingOperator;
+export declare const isConditionalFormattingOperator: (value: string) => value is ConditionalFormattingOperator;
 /** The window a `timePeriod` rule matches against, relative to the day the sheet is recalculated. */
 export type CfTimePeriod = 'today' | 'yesterday' | 'tomorrow' | 'last7Days' | 'thisMonth' | 'lastMonth' | 'nextMonth' | 'thisWeek' | 'lastWeek' | 'nextWeek';
 /** Narrow a raw `<cfRule timePeriod>` token to a known {@link CfTimePeriod}. */
-export declare function isCfTimePeriod(value: string): value is CfTimePeriod;
+export declare const isCfTimePeriod: (value: string) => value is CfTimePeriod;
 /**
  * The named icon family an `iconSet` rule draws from, as `ST_IconSetType` enumerates it. The leading
  * digit is the number of icons, which is also how many {@link CfValueObject} anchors the rule needs.
@@ -47,7 +47,7 @@ export declare function isCfTimePeriod(value: string): value is CfTimePeriod;
  */
 export type IconSetType = '3Arrows' | '3ArrowsGray' | '3Flags' | '3TrafficLights1' | '3TrafficLights2' | '3Signs' | '3Symbols' | '3Symbols2' | '4Arrows' | '4ArrowsGray' | '4RedToBlack' | '4Rating' | '4TrafficLights' | '5Arrows' | '5ArrowsGray' | '5Rating' | '5Quarters';
 /** Narrow a raw `<iconSet iconSet>` token to a known {@link IconSetType}. */
-export declare function isIconSetType(value: string): value is IconSetType;
+export declare const isIconSetType: (value: string) => value is IconSetType;
 /**
  * A single conditional-formatting rule. `type` is the OOXML cfRule type; the remaining fields carry
  * the operands that type needs and are absent otherwise. A rule the library does not model in depth

package/dist/core/conditional-formatting.js

@@ -1,15 +1,13 @@
-const CF_VALUE_OBJECT_TYPES = {
+import { tokenSet } from '../token-set.js';
+export const isCfValueObjectType = tokenSet({
     num: true,
     percent: true,
     max: true,
     min: true,
     percentile: true,
     formula: true,
-};
-export function isCfValueObjectType(value) {
-    return Object.hasOwn(CF_VALUE_OBJECT_TYPES, value);
-}
-const CONDITIONAL_FORMATTING_TYPES = {
+});
+export const isConditionalFormattingType = tokenSet({
     expression: true,
     cellIs: true,
     colorScale: true,
@@ -28,11 +26,8 @@ const CONDITIONAL_FORMATTING_TYPES = {
     notContainsErrors: true,
     timePeriod: true,
     aboveAverage: true,
-};
-export function isConditionalFormattingType(value) {
-    return Object.hasOwn(CONDITIONAL_FORMATTING_TYPES, value);
-}
-const CONDITIONAL_FORMATTING_OPERATORS = {
+});
+export const isConditionalFormattingOperator = tokenSet({
     lessThan: true,
     lessThanOrEqual: true,
     equal: true,
@@ -45,11 +40,8 @@ const CONDITIONAL_FORMATTING_OPERATORS = {
     notContains: true,
     beginsWith: true,
     endsWith: true,
-};
-export function isConditionalFormattingOperator(value) {
-    return Object.hasOwn(CONDITIONAL_FORMATTING_OPERATORS, value);
-}
-const CF_TIME_PERIODS = {
+});
+export const isCfTimePeriod = tokenSet({
     today: true,
     yesterday: true,
     tomorrow: true,
@@ -60,11 +52,8 @@ const CF_TIME_PERIODS = {
     thisWeek: true,
     lastWeek: true,
     nextWeek: true,
-};
-export function isCfTimePeriod(value) {
-    return Object.hasOwn(CF_TIME_PERIODS, value);
-}
-const ICON_SET_TYPES = {
+});
+export const isIconSetType = tokenSet({
     '3Arrows': true,
     '3ArrowsGray': true,
     '3Flags': true,
@@ -82,10 +71,7 @@ const ICON_SET_TYPES = {
     '5ArrowsGray': true,
     '5Rating': true,
     '5Quarters': true,
-};
-export function isIconSetType(value) {
-    return Object.hasOwn(ICON_SET_TYPES, value);
-}
+});
 export function cloneConditionalFormatting(cf) {
     return { ref: cf.ref, rules: cf.rules.map(cloneRule) };
 }

package/dist/core/data-validation.d.ts

@@ -3,16 +3,16 @@
  * bound a typed value (`whole`/`decimal`/`date`/`time`/`textLength`). */
 export type DataValidationType = 'none' | 'list' | 'whole' | 'decimal' | 'date' | 'time' | 'textLength' | 'custom';
 /** Narrow a raw `<dataValidation type>` token to a known {@link DataValidationType}. */
-export declare function isDataValidationType(value: string): value is DataValidationType;
+export declare const isDataValidationType: (value: string) => value is DataValidationType;
 /** How a typed validation compares its operand(s). Absent on a `list`/`custom` rule; defaults to
  * `between` on a typed rule (the value Excel omits from the XML). */
 export type DataValidationOperator = 'between' | 'notBetween' | 'equal' | 'notEqual' | 'greaterThan' | 'lessThan' | 'greaterThanOrEqual' | 'lessThanOrEqual';
 /** Narrow a raw `<dataValidation operator>` token to a known {@link DataValidationOperator}. */
-export declare function isDataValidationOperator(value: string): value is DataValidationOperator;
+export declare const isDataValidationOperator: (value: string) => value is DataValidationOperator;
 /** How Excel reacts to input that fails the rule. */
 export type DataValidationErrorStyle = 'stop' | 'warning' | 'information';
 /** Narrow a raw `<dataValidation errorStyle>` token to a known {@link DataValidationErrorStyle}. */
-export declare function isDataValidationErrorStyle(value: string): value is DataValidationErrorStyle;
+export declare const isDataValidationErrorStyle: (value: string) => value is DataValidationErrorStyle;
 /** One validation rule. `formulae` holds the operand(s), `formula1` then optional `formula2`: a
  * numeric literal is stored as a number, while a cell reference, defined name, or list source keeps
  * its verbatim string. */

package/dist/core/data-validation.js

@@ -1,4 +1,5 @@
-const DATA_VALIDATION_TYPES = {
+import { tokenSet } from '../token-set.js';
+export const isDataValidationType = tokenSet({
     none: true,
     list: true,
     whole: true,
@@ -7,11 +8,8 @@ const DATA_VALIDATION_TYPES = {
     time: true,
     textLength: true,
     custom: true,
-};
-export function isDataValidationType(value) {
-    return Object.hasOwn(DATA_VALIDATION_TYPES, value);
-}
-const DATA_VALIDATION_OPERATORS = {
+});
+export const isDataValidationOperator = tokenSet({
     between: true,
     notBetween: true,
     equal: true,
@@ -20,18 +18,12 @@ const DATA_VALIDATION_OPERATORS = {
     lessThan: true,
     greaterThanOrEqual: true,
     lessThanOrEqual: true,
-};
-export function isDataValidationOperator(value) {
-    return Object.hasOwn(DATA_VALIDATION_OPERATORS, value);
-}
-const DATA_VALIDATION_ERROR_STYLES = {
+});
+export const isDataValidationErrorStyle = tokenSet({
     stop: true,
     warning: true,
     information: true,
-};
-export function isDataValidationErrorStyle(value) {
-    return Object.hasOwn(DATA_VALIDATION_ERROR_STYLES, value);
-}
+});
 export function cloneDataValidation(rule) {
     return {
         ...rule,

package/dist/core/image.d.ts

@@ -18,7 +18,7 @@ export declare const PX_TO_EMU = 9525;
  * defaults to `oneCell` when the attribute is omitted. */
 export type ImageEditAs = 'oneCell' | 'twoCell' | 'absolute';
 /** Narrow a raw `<xdr:twoCellAnchor editAs>` token to a known {@link ImageEditAs}. */
-export declare function isImageEditAs(value: string): value is ImageEditAs;
+export declare const isImageEditAs: (value: string) => value is ImageEditAs;
 /** A fixed image size in EMUs: the extent of a one-cell anchor, which pixel dimensions convert into
  * via {@link PX_TO_EMU}. */
 export interface Extent {

package/dist/core/image.js

@@ -1,8 +1,6 @@
+import { tokenSet } from '../token-set.js';
 export const PX_TO_EMU = 9525;
-const IMAGE_EDIT_AS = { oneCell: true, twoCell: true, absolute: true };
-export function isImageEditAs(value) {
-    return Object.hasOwn(IMAGE_EDIT_AS, value);
-}
+export const isImageEditAs = tokenSet({ oneCell: true, twoCell: true, absolute: true });
 export function isOneCellAnchor(anchor) {
     return 'ext' in anchor;
 }

package/dist/core/merge-index.d.ts

@@ -0,0 +1,31 @@
+import { type GridRect } from './address.ts';
+import type { MergeRect } from './merge.ts';
+/**
+ * A row-banded index over a sheet's merged regions. Holds the region list by reference and never
+ * mutates it: the sheet stays the owner, reports what it adds, and says when it has rewritten the
+ * list wholesale (a splice, an unmerge, a model assignment), which the index answers by rebuilding
+ * on the next query rather than by tracking the edit.
+ */
+export declare class MergeIndex {
+    #private;
+    constructor(rects: readonly MergeRect[]);
+    /** Note a region added to the list. Ignored while stale: the rebuild reads the list itself. */
+    note(rect: MergeRect): void;
+    /** Report that the region list has been rewritten from outside this index. */
+    invalidate(): void;
+    /**
+     * The region overlapping `rect`, or `undefined` when the rectangle is free. Which of several
+     * overlapping regions is returned is unspecified beyond being one of them; a sheet admits no
+     * overlap, so at most one ever applies.
+     */
+    overlapping(rect: GridRect): MergeRect | undefined;
+    /**
+     * Resolve a position to the top-left of the merged region covering it, or to itself when no region
+     * does. Only fully-bounded regions participate: an unbounded whole-row/column merge carries no
+     * rectangle and so resolves nothing.
+     */
+    masterOf(row: number, col: number): {
+        row: number;
+        col: number;
+    };
+}

package/dist/core/merge-index.js

@@ -0,0 +1,60 @@
+import { rectsOverlap } from './address.js';
+const BAND_ROWS = 64;
+function bandOf(row) {
+    return Math.floor(row / BAND_ROWS);
+}
+export class MergeIndex {
+    #rects;
+    #bands = new Map();
+    #tallest = 0;
+    #stale = true;
+    constructor(rects) {
+        this.#rects = rects;
+    }
+    note(rect) {
+        if (!this.#stale)
+            this.#place(rect);
+    }
+    invalidate() {
+        this.#stale = true;
+    }
+    overlapping(rect) {
+        this.#refresh();
+        const first = bandOf(Math.max(1, rect.top - this.#tallest + 1));
+        const last = bandOf(rect.bottom);
+        for (let band = first; band <= last; band++) {
+            const bucket = this.#bands.get(band);
+            if (bucket === undefined)
+                continue;
+            for (const candidate of bucket) {
+                if (rectsOverlap(candidate, rect))
+                    return candidate;
+            }
+        }
+        return undefined;
+    }
+    masterOf(row, col) {
+        const covering = this.overlapping({ top: row, left: col, bottom: row, right: col });
+        return covering === undefined ? { row, col } : { row: covering.top, col: covering.left };
+    }
+    #place(rect) {
+        const height = rect.bottom - rect.top + 1;
+        if (height > this.#tallest)
+            this.#tallest = height;
+        const band = bandOf(rect.top);
+        const bucket = this.#bands.get(band);
+        if (bucket === undefined)
+            this.#bands.set(band, [rect]);
+        else
+            bucket.push(rect);
+    }
+    #refresh() {
+        if (!this.#stale)
+            return;
+        this.#stale = false;
+        this.#bands = new Map();
+        this.#tallest = 0;
+        for (const rect of this.#rects)
+            this.#place(rect);
+    }
+}

package/dist/core/merge.d.ts

@@ -2,16 +2,6 @@ import { type GridRect } from './address.ts';
 import type { Cell } from './cell.ts';
 /** A merged region, as the {@link GridRect} every range-shaped thing in the library is. */
 export type MergeRect = GridRect;
-/**
- * Resolve a position to the master (top-left) of the merged region covering it, or to itself when no
- * region does. First covering region wins; `Worksheet.mergeCells` rejects overlaps, so at most one
- * region ever applies. Only fully-bounded rects participate: an unbounded whole-row/column merge
- * carries no rect and so resolves nothing.
- */
-export declare function masterOf(rects: readonly MergeRect[], row: number, col: number): {
-    row: number;
-    col: number;
-};
 /**
  * Drop any value already sitting in a merge's covered non-anchor cells, keeping only the top-left
  * anchor, the collapse Excel performs on merge. A leftover covered value would serialise as a

package/dist/core/merge.js

@@ -1,13 +1,5 @@
 import { encodeCornerRef, tryDecodeRange } from './address.js';
 import { isDeletedSpan, shiftIndex } from './grid-shift.js';
-export function masterOf(rects, row, col) {
-    for (const rect of rects) {
-        if (row >= rect.top && row <= rect.bottom && col >= rect.left && col <= rect.right) {
-            return { row: rect.top, col: rect.left };
-        }
-    }
-    return { row, col };
-}
 export function clearCoveredValues(rows, rect) {
     for (let row = rect.top; row <= rect.bottom; row++) {
         const cols = rows.get(row);