@shbernal/ts-xlsx 3.0.0 → 3.2.0

package/dist/core/grid-edits.js

@@ -1,43 +1,62 @@
-import { decodeRange, encodeAddress, tryDecodeCellRef } from './address.js';
+import { boundedRect, decodeRange, encodeAddress, encodeRange, encodeRect, tryDecodeCellRef, tryDecodeRange, } from './address.js';
 import { shiftAutoFilter } from './autofilter.js';
 import { Cell, copyCellContent } from './cell.js';
 import { replaceContents } from './containers.js';
-import { isDeletedSpan, shiftIndex } from './grid-shift.js';
+import { spliceFormula, translateFormula } from './formula-references.js';
+import { isDeletedSpan, shiftIndex, shiftPoint, shiftRect } from './grid-shift.js';
 import { isOneCellAnchor } from './image.js';
-import { isSharedFormulaValue } from './value.js';
+import { INTERNAL } from './internal.js';
+import { splicePivotSource } from './pivot-table.js';
+import { positionalPlacements } from './row-input.js';
+import { isArrayFormulaValue, isDataTableFormulaValue, isFormulaValue, isSharedFormulaValue, } from './value.js';
 export class GridEdits {
     #rows;
     #rowProperties;
     #columns;
     #merges;
-    #mergeRects;
     #tables;
+    #pivotTables;
+    #loadedPivotTables;
     #images;
     #dataValidations;
     #conditionalFormattings;
+    #hyperlinks;
     #comments;
+    #rowBreaks;
+    #columnBreaks;
     #autoFilter;
+    #sheetName;
+    #formulaHost;
     constructor(storage) {
         this.#rows = storage.rows;
         this.#rowProperties = storage.rowProperties;
         this.#columns = storage.columns;
         this.#merges = storage.merges;
-        this.#mergeRects = storage.mergeRects;
         this.#tables = storage.tables;
+        this.#pivotTables = storage.pivotTables;
+        this.#loadedPivotTables = storage.loadedPivotTables;
         this.#images = storage.images;
         this.#dataValidations = storage.dataValidations;
         this.#conditionalFormattings = storage.conditionalFormattings;
+        this.#hyperlinks = storage.hyperlinks;
         this.#comments = storage.comments;
+        this.#rowBreaks = storage.rowBreaks;
+        this.#columnBreaks = storage.columnBreaks;
         this.#autoFilter = storage.autoFilter;
+        this.#sheetName = storage.sheetName;
+        this.#formulaHost = storage.formulaHost;
     }
     spliceRows(start, count, inserted) {
-        const delta = inserted.length - count;
+        const splice = { axis: 'row', start, count, delta: inserted.length - count };
+        this.#moveFormulaReferences(splice);
         const shifted = new Map();
         for (const [row, cols] of this.#rows) {
             if (row < start)
                 shifted.set(row, cols);
-            else if (row >= start + count)
-                shifted.set(row + delta, this.#relocateRow(cols, row + delta));
+            else if (row >= start + count) {
+                const dest = shiftIndex(row, splice);
+                shifted.set(dest, this.#relocateRow(cols, dest));
+            }
         }
         inserted.forEach((cols, i) => {
             shifted.set(start + i, this.#relocateRow(cols, start + i));
@@ -45,15 +64,12 @@ export class GridEdits {
         this.#rows.clear();
         for (const [row, cols] of shifted)
             this.#rows.set(row, cols);
-        this.#shiftLineProperties(this.#rowProperties, start, count, delta);
-        this.#shiftMerges('row', start, count, delta);
-        this.#shiftTables('row', start, count, delta);
-        this.#shiftImages('row', start, count, delta);
-        this.#reanchorSharedFormulas('row', start, count, delta);
-        this.#shiftRangeBoundOverlays('row', start, count, delta);
+        this.#shiftAnchored(splice, this.#rowProperties);
     }
     spliceColumns(start, count, inserts) {
-        const delta = inserts.length - count;
+        const splice = { axis: 'col', start, count, delta: inserts.length - count };
+        this.#moveFormulaReferences(splice);
+        const shiftedRows = new Map();
         for (const [row, cols] of this.#rows) {
             const shifted = new Map();
             for (const [col, cell] of cols) {
@@ -61,38 +77,141 @@ export class GridEdits {
                     shifted.set(col, cell);
                 }
                 else if (col >= start + count) {
-                    const dest = col + delta;
+                    const dest = shiftIndex(col, splice);
                     const moved = new Cell(row, dest);
                     copyCellContent(cell, moved);
                     shifted.set(dest, moved);
                 }
             }
-            inserts.forEach((values, i) => {
-                const value = values[row - 1];
-                if (value !== undefined) {
-                    const cell = new Cell(row, start + i);
-                    cell.value = value;
-                    shifted.set(start + i, cell);
+            shiftedRows.set(row, shifted);
+        }
+        inserts.forEach((values, i) => {
+            for (const [row, value] of positionalPlacements(values)) {
+                const cell = new Cell(row, start + i);
+                cell.value = value;
+                let cols = shiftedRows.get(row);
+                if (cols === undefined) {
+                    cols = new Map();
+                    shiftedRows.set(row, cols);
+                }
+                cols.set(start + i, cell);
+            }
+        });
+        for (const [row, cols] of shiftedRows)
+            this.#rows.set(row, cols);
+        this.#shiftAnchored(splice, this.#columns);
+    }
+    #moveFormulaReferences(splice) {
+        const edit = { sheet: this.#sheetName(), splice };
+        this.spliceFormulas(edit);
+        this.#formulaHost()?.(edit);
+    }
+    spliceFormulas(edit) {
+        const home = this.#sheetName();
+        const { splice } = edit;
+        const rewrite = (formula) => spliceFormula(formula, home, edit);
+        const cellsMove = home.toLowerCase() === edit.sheet.toLowerCase();
+        const after = (cell) => {
+            if (!cellsMove)
+                return cell;
+            return splice.axis === 'row'
+                ? { col: cell.col, row: shiftIndex(cell.row, splice) }
+                : { col: shiftIndex(cell.col, splice), row: cell.row };
+        };
+        const taken = (cell) => {
+            const line = splice.axis === 'row' ? cell.row : cell.col;
+            return cellsMove && isDeletedSpan(line, line, splice);
+        };
+        const masters = new Map();
+        for (const cols of this.#rows.values()) {
+            for (const cell of cols.values()) {
+                const value = cell.value;
+                if (isArrayFormulaValue(value)) {
+                    const rewritten = rewrite(value.formula);
+                    if (rewritten !== value.formula)
+                        cell.value = { ...value, formula: rewritten };
+                    continue;
                 }
-            });
-            this.#rows.set(row, shifted);
+                if (!isFormulaValue(value))
+                    continue;
+                masters.set(encodeAddress(cell.col, cell.row), {
+                    cell,
+                    formula: value.formula,
+                    rewritten: rewrite(value.formula),
+                });
+            }
         }
-        this.#shiftLineProperties(this.#columns, start, count, delta);
-        this.#shiftMerges('col', start, count, delta);
-        this.#shiftTables('col', start, count, delta);
-        this.#shiftImages('col', start, count, delta);
-        this.#reanchorSharedFormulas('col', start, count, delta);
-        this.#shiftRangeBoundOverlays('col', start, count, delta);
-    }
-    #shiftRangeBoundOverlays(axis, start, count, delta) {
-        this.#dataValidations.shift(axis, start, count, delta);
-        this.#conditionalFormattings.shift(axis, start, count, delta);
-        this.#comments.shift(axis, start, count, delta);
-        const filter = this.#autoFilter.get();
-        if (filter !== undefined) {
-            this.#autoFilter.set(shiftAutoFilter(filter, axis, start, count, delta));
+        for (const cols of this.#rows.values()) {
+            for (const cell of cols.values()) {
+                const value = cell.value;
+                if (!isSharedFormulaValue(value))
+                    continue;
+                const master = masters.get(value.sharedFormula);
+                if (master === undefined) {
+                    if (value.formula === undefined)
+                        continue;
+                    const rewritten = rewrite(value.formula);
+                    if (rewritten !== value.formula)
+                        cell.value = { ...value, formula: rewritten };
+                    continue;
+                }
+                const source = value.formula ??
+                    translateFormula(master.formula, cell.col - master.cell.col, cell.row - master.cell.row);
+                const rewritten = rewrite(source);
+                const from = after(master.cell);
+                const to = after(cell);
+                const described = !taken(master.cell) &&
+                    translateFormula(master.rewritten, to.col - from.col, to.row - from.row) === rewritten;
+                if (described) {
+                    if (value.formula !== undefined && rewritten !== value.formula) {
+                        cell.value = { ...value, formula: rewritten };
+                    }
+                    continue;
+                }
+                cell.value =
+                    value.result === undefined
+                        ? { formula: rewritten }
+                        : { formula: rewritten, result: value.result };
+            }
+        }
+        for (const { cell, formula, rewritten } of masters.values()) {
+            const value = cell.value;
+            if (rewritten !== formula && isFormulaValue(value))
+                cell.value = { ...value, formula: rewritten };
+        }
+        this.#dataValidations.mapFormulas(rewrite);
+        this.#conditionalFormattings.mapFormulas(rewrite);
+        for (const table of this.#tables)
+            table[INTERNAL].rewriteFormulas(rewrite);
+        for (const pivot of this.#pivotTables)
+            pivot[INTERNAL].spliceSource(edit);
+        for (const [index, loaded] of this.#loadedPivotTables.entries()) {
+            const { source } = loaded;
+            if (source.kind !== 'worksheet' || source.inAnotherWorkbook)
+                continue;
+            const ref = splicePivotSource(source.sheet, source.ref, edit);
+            if (ref !== source.ref)
+                this.#loadedPivotTables[index] = { ...loaded, source: { ...source, ref } };
         }
     }
+    #shiftAnchored(splice, lineProperties) {
+        this.#shiftLineProperties(lineProperties, splice);
+        this.#shiftPageBreaks(splice);
+        this.#shiftMerges(splice);
+        this.#shiftTables(splice);
+        this.#shiftImages(splice);
+        this.#reanchorValueReferences(splice);
+        this.#shiftRangeBoundOverlays(splice);
+    }
+    #shiftRangeBoundOverlays(splice) {
+        this.#dataValidations.shift(splice);
+        this.#conditionalFormattings.shift(splice);
+        this.#hyperlinks.shift(splice);
+        this.#comments.shift(splice);
+        const filter = this.#autoFilter.get();
+        if (filter !== undefined)
+            this.#autoFilter.set(shiftAutoFilter(filter, splice));
+    }
     #relocateRow(cols, destRow) {
         const moved = new Map();
         for (const [col, cell] of cols) {
@@ -107,80 +226,128 @@ export class GridEdits {
         }
         return moved;
     }
-    #reanchorSharedFormulas(axis, start, count, delta) {
+    #reanchorValueReferences(splice) {
         for (const cols of this.#rows.values()) {
             for (const cell of cols.values()) {
                 const value = cell.value;
-                if (!isSharedFormulaValue(value))
-                    continue;
-                const master = tryDecodeCellRef(value.sharedFormula);
-                if (master === undefined)
-                    continue;
-                const anchored = axis === 'row'
-                    ? encodeAddress(master.col, shiftIndex(master.row, start, count, delta, 'row'))
-                    : encodeAddress(shiftIndex(master.col, start, count, delta, 'col'), master.row);
-                if (anchored === value.sharedFormula)
-                    continue;
-                const reanchored = { ...value, sharedFormula: anchored };
-                cell.value = reanchored;
+                const moved = reanchoredValue(value, splice);
+                if (moved !== value)
+                    cell.value = moved;
             }
         }
     }
-    #shiftLineProperties(map, start, count, delta) {
+    #shiftLineProperties(map, splice) {
         const shifted = new Map();
         for (const [index, value] of map) {
-            if (index < start)
-                shifted.set(index, value);
-            else if (index >= start + count)
-                shifted.set(index + delta, value);
+            if (isDeletedSpan(index, index, splice))
+                continue;
+            shifted.set(shiftIndex(index, splice), value);
         }
         map.clear();
         for (const [index, value] of shifted)
             map.set(index, value);
     }
-    #shiftMerges(axis, start, count, delta) {
-        const shift = (v) => shiftIndex(v, start, count, delta, axis);
+    #shiftPageBreaks(splice) {
+        const breaks = splice.axis === 'row' ? this.#rowBreaks : this.#columnBreaks;
+        const moved = breaks.flatMap((brk) => {
+            const line = brk.id + 1;
+            if (isDeletedSpan(line, line, splice))
+                return [];
+            const id = shiftIndex(line, splice) - 1;
+            return [id === brk.id ? brk : { ...brk, id }];
+        });
+        replaceContents(breaks, moved);
+    }
+    #shiftMerges(splice) {
         const merges = [];
         const rects = [];
-        for (const range of this.#merges) {
-            const { top, left, bottom, right } = decodeRange(range);
-            if (top === undefined || left === undefined || bottom === undefined || right === undefined) {
+        for (const range of this.#merges.ranges) {
+            const decoded = boundedRect(decodeRange(range));
+            if (decoded === undefined) {
                 merges.push(range);
                 continue;
             }
-            const [lo, hi] = axis === 'row' ? [top, bottom] : [left, right];
-            if (isDeletedSpan(lo, hi, start, count))
+            const rect = shiftRect(decoded, splice);
+            if (rect === undefined)
                 continue;
-            const rect = axis === 'row'
-                ? { top: shift(top), left, bottom: shift(bottom), right }
-                : { top, left: shift(left), bottom, right: shift(right) };
             rects.push(rect);
-            merges.push(`${encodeAddress(rect.left, rect.top)}:${encodeAddress(rect.right, rect.bottom)}`);
+            merges.push(encodeRect(rect));
         }
-        replaceContents(this.#merges, merges);
-        replaceContents(this.#mergeRects, rects);
+        this.#merges.replaceAll(merges, rects);
     }
-    #shiftTables(axis, start, count, delta) {
-        const survivors = this.#tables.filter((table) => axis === 'row'
-            ? table.shiftRows(start, count, delta)
-            : table.shiftColumns(start, count, delta));
+    #shiftTables(splice) {
+        const survivors = this.#tables.filter((table) => splice.axis === 'row' ? table.shiftRows(splice) : table.shiftColumns(splice));
         replaceContents(this.#tables, survivors);
     }
-    #shiftImages(axis, start, count, delta) {
-        const shiftPoint = (point) => {
-            const zeroBased = axis === 'row' ? point.row : point.col;
-            const shifted = shiftIndex(zeroBased + 1, start, count, delta, axis) - 1;
+    #shiftImages(splice) {
+        const shiftAnchor = (point) => {
+            const zeroBased = splice.axis === 'row' ? point.row : point.col;
+            const shifted = shiftIndex(zeroBased + 1, splice) - 1;
             if (shifted === zeroBased)
                 return point;
-            return axis === 'row' ? { ...point, row: shifted } : { ...point, col: shifted };
+            return splice.axis === 'row' ? { ...point, row: shifted } : { ...point, col: shifted };
         };
         const moved = this.#images.map((image) => {
-            const from = shiftPoint(image.anchor.from);
+            const from = shiftAnchor(image.anchor.from);
             const anchor = isOneCellAnchor(image.anchor)
                 ? { ...image.anchor, from }
-                : { ...image.anchor, from, to: shiftPoint(image.anchor.to) };
-            return { imageId: image.imageId, anchor };
+                : { ...image.anchor, from, to: shiftAnchor(image.anchor.to) };
+            return { ...image, anchor };
         });
         replaceContents(this.#images, moved);
     }
 }
+function reanchoredValue(value, splice) {
+    if (isSharedFormulaValue(value)) {
+        const master = tryDecodeCellRef(value.sharedFormula);
+        if (master === undefined)
+            return value;
+        const anchored = splice.axis === 'row'
+            ? encodeAddress(master.col, shiftIndex(master.row, splice))
+            : encodeAddress(shiftIndex(master.col, splice), master.row);
+        return anchored === value.sharedFormula ? value : { ...value, sharedFormula: anchored };
+    }
+    if (isArrayFormulaValue(value)) {
+        const ref = shiftedRange(value.ref, splice) ?? value.ref;
+        return ref === value.ref ? value : { ...value, ref };
+    }
+    if (isDataTableFormulaValue(value)) {
+        const ref = shiftedRange(value.ref, splice) ?? value.ref;
+        const r1 = inputAfter(value.r1, value.r1Deleted, splice);
+        const r2 = inputAfter(value.r2, value.r2Deleted, splice);
+        if (ref === value.ref && r1.same && r2.same)
+            return value;
+        return {
+            ...value,
+            ref,
+            ...(r1.ref === undefined ? {} : { r1: r1.ref }),
+            ...(r2.ref === undefined ? {} : { r2: r2.ref }),
+            ...(r1.deleted ? { r1Deleted: true } : {}),
+            ...(r2.deleted ? { r2Deleted: true } : {}),
+        };
+    }
+    return value;
+}
+function shiftedRange(ref, splice) {
+    const decoded = tryDecodeRange(ref);
+    const rect = decoded === undefined ? undefined : boundedRect(decoded);
+    if (rect === undefined)
+        return ref;
+    const moved = shiftRect(rect, splice);
+    if (moved === undefined)
+        return undefined;
+    return sameRect(moved, rect) ? ref : encodeRange(moved);
+}
+function inputAfter(ref, deleted, splice) {
+    const cell = ref === undefined || deleted === true ? undefined : tryDecodeCellRef(ref);
+    if (cell === undefined)
+        return { ref, deleted: deleted === true, same: true };
+    const moved = shiftPoint(cell, splice);
+    if (moved === undefined)
+        return { ref, deleted: true, same: false };
+    const same = moved.row === cell.row && moved.col === cell.col;
+    return { ref: same ? ref : encodeAddress(moved.col, moved.row), deleted: false, same };
+}
+function sameRect(a, b) {
+    return a.top === b.top && a.left === b.left && a.bottom === b.bottom && a.right === b.right;
+}

package/dist/core/grid-shift.d.ts

@@ -1,19 +1,68 @@
+import { type CellPosition, type GridRect } from './address.ts';
 /**
- * Where a 1-based coordinate on `axis` lands after `count` lines are deleted at `start` and the
- * replacement lines shift what follows by `delta`: before the edit it stays put, at or after the
- * edited span it shifts, and inside a deleted span it clamps to the cut line. The clamp is the best
- * effort for a geometry straddling the cut; a caller that must instead *drop* what a delete swallowed
- * whole tests {@link isDeletedSpan} first.
+ * One structural edit to an axis: `count` lines removed at the 1-based `start`, with everything
+ * after the removed span moved by `delta`. `delta` is the *net* movement, so a pure insert of two
+ * lines is `{count: 0, delta: 2}` and a pure delete of three is `{count: 3, delta: -3}`.
+ *
+ * The four travel as one value because they describe one edit, and because three of them are
+ * `number`: passed positionally, two adjacent ones transposed compiles, typechecks, lints, and moves
+ * a merge, a dropdown, a highlight or a comment anchor onto cells the author never chose -- silently,
+ * since nothing about the resulting file is malformed. A named field cannot be transposed.
+ */
+export interface AxisSplice {
+    /** The axis the lines were spliced on. */
+    readonly axis: 'row' | 'col';
+    /** 1-based first line of the removed span. */
+    readonly start: number;
+    /** How many lines were removed. */
+    readonly count: number;
+    /** Net movement of every line after the removed span. */
+    readonly delta: number;
+}
+/**
+ * Where a 1-based coordinate on the spliced axis lands: before the edit it stays put, at or after
+ * the edited span it shifts by `delta`, and inside a deleted span it clamps to the cut line. The
+ * clamp is the best effort for a geometry straddling the cut; a caller that must instead *drop*
+ * what a delete swallowed whole tests {@link isDeletedSpan} first.
  *
  * A shift never leaves the grid: the result is clamped to the axis's last line, so a region already
  * touching the bottom (or the right edge) keeps its edge there instead of naming a line the format
  * has no room for. That shrinks such a region by what it could not move, which is the lesser of the
  * two evils and is what Excel does to the same region on the same edit.
  */
-export declare function shiftIndex(v: number, start: number, count: number, delta: number, axis: 'row' | 'col'): number;
+export declare function shiftIndex(v: number, splice: AxisSplice): number;
 /**
- * Whether the inclusive span `lo..hi` lies entirely within the `count` lines deleted at `start`: the
- * test that separates "this moved" from "this is gone". A single coordinate is the degenerate span
+ * Whether the inclusive span `lo..hi` lies entirely within the deleted lines: the test that
+ * separates "this moved" from "this is gone". A single coordinate is the degenerate span
  * `lo === hi`.
  */
-export declare function isDeletedSpan(lo: number, hi: number, start: number, count: number): boolean;
+export declare function isDeletedSpan(lo: number, hi: number, splice: AxisSplice): boolean;
+/**
+ * Both edges of a region's span on the spliced axis, moved together, or `undefined` when the delete
+ * swallowed the span whole. The two answers are exclusive on purpose: a span straddling the cut
+ * clamps and survives, one wholly inside it is dropped, and a caller must not clamp its way out of
+ * a drop.
+ *
+ * The one-axis form, for a region whose *other* axis is not a number the caller holds -- a `sqref`
+ * area may be unbounded across the axis it is not being spliced on, and re-encoding it as bounded
+ * would rewrite the file's own spelling. Callers holding a real rectangle want {@link shiftRect}.
+ */
+export declare function shiftSpan(lo: number, hi: number, splice: AxisSplice): {
+    lo: number;
+    hi: number;
+} | undefined;
+/**
+ * A rectangle re-anchored through the splice, or `undefined` when the delete swallowed it whole.
+ * The unspliced axis passes through untouched; both edges of the spliced axis move and clamp.
+ *
+ * This projection -- pick the spliced axis's two edges out of the rectangle, ask whether they
+ * survived, move them, put the rectangle back together -- is the shape every range-bound thing in
+ * the model re-anchors by, and writing it per caller is how the axis ternary gets inverted in one
+ * of them.
+ */
+export declare function shiftRect(rect: GridRect, splice: AxisSplice): GridRect | undefined;
+/**
+ * The degenerate one-coordinate form of {@link shiftRect}: a cell that moves, or `undefined` when
+ * the delete took the line it sat on. The coordinate off the spliced axis passes through.
+ */
+export declare function shiftPoint(point: CellPosition, splice: AxisSplice): CellPosition | undefined;

package/dist/core/grid-shift.js

@@ -1,8 +1,30 @@
 import { MAX_COLUMN, MAX_ROW } from './address.js';
-export function shiftIndex(v, start, count, delta, axis) {
+export function shiftIndex(v, splice) {
+    const { start, count, delta } = splice;
     const moved = v < start ? v : v >= start + count ? v + delta : start;
-    return Math.min(moved, axis === 'row' ? MAX_ROW : MAX_COLUMN);
+    return Math.min(moved, splice.axis === 'row' ? MAX_ROW : MAX_COLUMN);
 }
-export function isDeletedSpan(lo, hi, start, count) {
-    return lo >= start && hi < start + count;
+export function isDeletedSpan(lo, hi, splice) {
+    return lo >= splice.start && hi < splice.start + splice.count;
+}
+export function shiftSpan(lo, hi, splice) {
+    if (isDeletedSpan(lo, hi, splice))
+        return undefined;
+    return { lo: shiftIndex(lo, splice), hi: shiftIndex(hi, splice) };
+}
+export function shiftRect(rect, splice) {
+    const rowAxis = splice.axis === 'row';
+    const moved = shiftSpan(rowAxis ? rect.top : rect.left, rowAxis ? rect.bottom : rect.right, splice);
+    if (moved === undefined)
+        return undefined;
+    return rowAxis
+        ? { ...rect, top: moved.lo, bottom: moved.hi }
+        : { ...rect, left: moved.lo, right: moved.hi };
+}
+export function shiftPoint(point, splice) {
+    const line = splice.axis === 'row' ? point.row : point.col;
+    if (isDeletedSpan(line, line, splice))
+        return undefined;
+    const moved = shiftIndex(line, splice);
+    return splice.axis === 'row' ? { col: point.col, row: moved } : { col: moved, row: point.row };
 }

package/dist/core/hyperlink.d.ts

@@ -0,0 +1,39 @@
+import { type AxisSplice } from './grid-shift.ts';
+/** A hyperlink and the cells it covers. */
+export interface Hyperlink {
+    /** The cells the link covers: one cell (`'B2'`) or a rectangle of cells (`'D1:H1'`). */
+    readonly ref: string;
+    /**
+     * Where the link goes: a URL or a path, or a `#`-prefixed place in this workbook such as
+     * `#Summary!A1` or `#TaxRate`.
+     */
+    readonly target: string;
+    /** The text shown when the pointer rests on the link. */
+    readonly tooltip?: string;
+}
+/** The links on one sheet, in the order they were added, each with the rectangle it covers. */
+export declare class HyperlinkOverlay {
+    #private;
+    /**
+     * Add a link, replacing one over the same cells. The `ref` is stored in its canonical spelling.
+     *
+     * @throws {SyntaxError} if `ref` is not a reference.
+     * @throws {AuthoringError} if `ref` names a whole row or column rather than cells.
+     */
+    add(link: Hyperlink): void;
+    /** Remove the link whose `ref` names exactly these cells, and report whether there was one. */
+    remove(ref: string): boolean;
+    /** The links on the sheet, in the order they were added. */
+    get entries(): readonly Hyperlink[];
+    /** The link covering the 1-based `col`/`row`, the last added of any that do, or `undefined`. */
+    at(col: number, row: number): Hyperlink | undefined;
+    /**
+     * Move every link through a row or column splice. A link grows when lines are inserted inside it and
+     * shrinks when some of its lines are deleted, and one the delete takes whole goes with it.
+     */
+    shift(splice: AxisSplice): void;
+    /** Give row `to` a copy of every link that lies wholly within row `from`, as a row copy does. */
+    copyRow(from: number, to: number): void;
+    /** Drop every link, leaving the overlay empty. */
+    clear(): void;
+}