@shbernal/ts-xlsx 2.1.0 → 3.1.0

package/dist/core/date-format.js

@@ -0,0 +1,160 @@
+const MONTH_NAMES = [
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December',
+];
+const WEEKDAY_NAMES = [
+    'Sunday',
+    'Monday',
+    'Tuesday',
+    'Wednesday',
+    'Thursday',
+    'Friday',
+    'Saturday',
+];
+function formatRuns(code) {
+    const runs = [];
+    const literal = (text) => {
+        if (text !== '')
+            runs.push({ kind: 'literal', text, count: text.length });
+    };
+    for (let i = 0; i < code.length; i++) {
+        const ch = code[i];
+        if (ch === ';')
+            break;
+        if (ch === '[') {
+            const end = code.indexOf(']', i);
+            i = end === -1 ? code.length : end;
+            continue;
+        }
+        if (ch === '"') {
+            const end = code.indexOf('"', i + 1);
+            literal(code.slice(i + 1, end === -1 ? code.length : end));
+            i = end === -1 ? code.length : end;
+            continue;
+        }
+        if (ch === '\\') {
+            literal(code[i + 1] ?? '');
+            i += 1;
+            continue;
+        }
+        const fraction = /^\.0+/.exec(code.slice(i));
+        if (fraction !== null && runs.at(-1)?.text === 's') {
+            runs.push({ kind: 'placeholder', text: '.0', count: fraction[0].length - 1 });
+            i += fraction[0].length - 1;
+            continue;
+        }
+        const lower = ch.toLowerCase();
+        if (lower === 'y' || lower === 'm' || lower === 'd' || lower === 'h' || lower === 's') {
+            let count = 1;
+            while (code[i + count]?.toLowerCase() === lower)
+                count += 1;
+            runs.push({ kind: 'placeholder', text: lower, count });
+            i += count - 1;
+            continue;
+        }
+        const meridiem = /^(AM\/PM|A\/P)/i.exec(code.slice(i));
+        if (meridiem !== null) {
+            runs.push({ kind: 'placeholder', text: 'am/pm', count: meridiem[0].length });
+            i += meridiem[0].length - 1;
+            continue;
+        }
+        literal(ch);
+    }
+    return runs;
+}
+function isMinuteRun(runs, index) {
+    for (let i = index - 1; i >= 0; i--) {
+        const run = runs[i];
+        if (run.kind === 'literal')
+            continue;
+        if (run.text === 'h')
+            return true;
+        break;
+    }
+    for (let i = index + 1; i < runs.length; i++) {
+        const run = runs[i];
+        if (run.kind === 'literal')
+            continue;
+        return run.text === 's';
+    }
+    return false;
+}
+export function formatSerialDate(date, code, utc) {
+    if (Number.isNaN(date.getTime()))
+        return '';
+    const runs = formatRuns(code);
+    const year = utc ? date.getUTCFullYear() : date.getFullYear();
+    const month = (utc ? date.getUTCMonth() : date.getMonth()) + 1;
+    const day = utc ? date.getUTCDate() : date.getDate();
+    const weekday = utc ? date.getUTCDay() : date.getDay();
+    const hour24 = utc ? date.getUTCHours() : date.getHours();
+    const minute = utc ? date.getUTCMinutes() : date.getMinutes();
+    const second = utc ? date.getUTCSeconds() : date.getSeconds();
+    const twelveHour = runs.some((run) => run.kind === 'placeholder' && run.text === 'am/pm');
+    const hour = twelveHour ? hour24 % 12 || 12 : hour24;
+    const pad = (value, width) => String(value).padStart(width, '0');
+    let out = '';
+    for (const [index, run] of runs.entries()) {
+        if (run.kind === 'literal') {
+            out += run.text;
+            continue;
+        }
+        switch (run.text) {
+            case 'y':
+                out += run.count <= 2 ? pad(year % 100, 2) : String(year);
+                break;
+            case 'm':
+                if (isMinuteRun(runs, index)) {
+                    out += run.count >= 2 ? pad(minute, 2) : String(minute);
+                }
+                else if (run.count >= 5) {
+                    out += MONTH_NAMES[month - 1][0];
+                }
+                else if (run.count === 4) {
+                    out += MONTH_NAMES[month - 1];
+                }
+                else if (run.count === 3) {
+                    out += MONTH_NAMES[month - 1].slice(0, 3);
+                }
+                else {
+                    out += run.count === 2 ? pad(month, 2) : String(month);
+                }
+                break;
+            case 'd':
+                if (run.count >= 4)
+                    out += WEEKDAY_NAMES[weekday];
+                else if (run.count === 3)
+                    out += WEEKDAY_NAMES[weekday].slice(0, 3);
+                else
+                    out += run.count === 2 ? pad(day, 2) : String(day);
+                break;
+            case 'h':
+                out += run.count >= 2 ? pad(hour, 2) : String(hour);
+                break;
+            case 's':
+                out += run.count >= 2 ? pad(second, 2) : String(second);
+                break;
+            case '.0': {
+                const digits = pad(utc ? date.getUTCMilliseconds() : date.getMilliseconds(), 3);
+                out += `.${(digits + '000').slice(0, run.count)}`;
+                break;
+            }
+            case 'am/pm':
+                out += hour24 < 12 ? 'AM' : 'PM';
+                break;
+            default:
+                break;
+        }
+    }
+    return out;
+}

package/dist/core/date.d.ts

@@ -1,20 +1,40 @@
+/**
+ * Which date system a workbook counts its serials in: the `date1904` flag of `<workbookPr>`.
+ *
+ * Carried as the epoch year rather than as a boolean because it is what every conversion here
+ * actually needs, and a boolean would mean a `? 1904 : 1900` at each of them: five chances to write
+ * the ternary backwards, on a value whose wrongness is silent by construction (a date read under the
+ * wrong system is still a perfectly good date, four years off).
+ */
+export type DateEpoch = 1900 | 1904;
 /**
  * The number format applied to a `Date` cell that carries no explicit format of its own,
  * so the value renders, and reads back, as a date rather than a bare serial number.
  */
 export declare const DEFAULT_DATE_NUMFMT = "yyyy-mm-dd";
 /**
- * Convert a JS `Date` to its 1900-system Excel serial, reproducing the phantom-leap-day
- * quirk so the value renders on the calendar date Excel would show. Fractional serials
- * carry the time of day. The caller must reject a non-finite (invalid) date before here.
+ * Convert a JS `Date` to its Excel serial under the workbook's date system, reproducing the
+ * phantom-leap-day quirk (1900 only) so the value renders on the calendar date Excel would show.
+ * Fractional serials carry the time of day. The caller must reject a non-finite (invalid) date
+ * before here.
+ */
+export declare function dateToSerial(date: Date, epoch: DateEpoch): number;
+/**
+ * Convert an Excel serial back to a UTC `Date` under the workbook's date system, accounting in the
+ * 1900 system for the phantom 1900-02-29 so serial 1 reads as 1900-01-01 (not 1899-12-31) and
+ * consecutive serials map to consecutive days.
  */
-export declare function dateToSerial(date: Date): number;
+export declare function serialToDate(serial: number, epoch: DateEpoch): Date;
 /**
- * Convert a 1900-system Excel serial back to a UTC `Date`, accounting for the phantom
- * 1900-02-29 so serial 1 reads as 1900-01-01 (not 1899-12-31) and consecutive serials
- * map to consecutive days.
+ * Parse a date-bearing text field (a Strict-mode `t="d"` cell value, a core-property timestamp) to a
+ * `Date`, or `null` when it carries nothing parseable.
+ *
+ * The `null` is the point. `new Date('not-a-date')` is a `Date` whose time is `NaN`: it satisfies
+ * `instanceof Date` and every guard downstream, survives into the model, and reaches serialisation,
+ * where it writes back as the literal string `Invalid Date` and loses the value for good. Dropping it
+ * at the boundary is the only reading that cannot lie.
  */
-export declare function serialToDate(serial: number): Date;
+export declare function parseDateText(text: string): Date | null;
 /**
  * Whether a number-format code renders its value as a date or time. A format is a date
  * format when, once its non-formatting sections are removed (bracketed color/locale/
@@ -23,3 +43,18 @@ export declare function serialToDate(serial: number): Date;
  * while `yyyy-mm-dd`, `dd/mm/yyyy`, and `[$-409]mmmm d, yyyy` are.
  */
 export declare function isDateFormat(code: string): boolean;
+/**
+ * Surface a number stored under a date format as a `Date`, and leave everything else alone.
+ *
+ * OOXML has no date type: a date is a number plus a number format that renders it as one, so this
+ * one test is what separates `45000` from `2023-03-15` across every reader. Only a plain number
+ * qualifies; a string, a boolean or a formula result of another kind under a date format keeps its
+ * own kind.
+ *
+ * One function rather than three copies of the test, because the corpus asserts the rule is identical
+ * across serialisations: the `.xlsb` reader, the `.xlsx` cell decoder and the cached formula-result
+ * decoder must all answer the same, and three spellings of one rule are three chances to disagree.
+ * The workbook's {@link DateEpoch} rides along for exactly that reason: it is the one input to this
+ * test that is not the cell's, and the three used to agree on the wrong answer for a 1904 file.
+ */
+export declare function coerceDateSerial<T>(value: T, numFmt: string | undefined, epoch: DateEpoch): T | Date;

package/dist/core/date.js

@@ -1,15 +1,26 @@
 const MS_PER_DAY = 86_400_000;
 const EPOCH_1900_UTC = Date.UTC(1899, 11, 30);
 const PHANTOM_SERIAL = 60;
+const EPOCH_1904_UTC = Date.UTC(1904, 0, 1);
 export const DEFAULT_DATE_NUMFMT = 'yyyy-mm-dd';
-export function dateToSerial(date) {
+export function dateToSerial(date, epoch) {
+    if (epoch === 1904)
+        return (date.getTime() - EPOCH_1904_UTC) / MS_PER_DAY;
     const days = (date.getTime() - EPOCH_1900_UTC) / MS_PER_DAY;
     return days <= PHANTOM_SERIAL ? days - 1 : days;
 }
-export function serialToDate(serial) {
+export function serialToDate(serial, epoch) {
+    if (epoch === 1904)
+        return new Date(EPOCH_1904_UTC + serial * MS_PER_DAY);
     const dayOffset = serial < PHANTOM_SERIAL ? serial + 1 : serial;
     return new Date(EPOCH_1900_UTC + dayOffset * MS_PER_DAY);
 }
+export function parseDateText(text) {
+    if (text === '')
+        return null;
+    const date = new Date(text);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
 export function isDateFormat(code) {
     const stripped = code
         .replace(/\[[^\]]*\]/g, '')
@@ -17,3 +28,8 @@ export function isDateFormat(code) {
         .replace(/\\./g, '');
     return /[ymdhs]/i.test(stripped);
 }
+export function coerceDateSerial(value, numFmt, epoch) {
+    return typeof value === 'number' && numFmt !== undefined && isDateFormat(numFmt)
+        ? serialToDate(value, epoch)
+        : value;
+}

package/dist/core/formula.d.ts

@@ -47,3 +47,29 @@ export declare function mangleFormula(formula: string): string;
  * sheet name is untouched. Function names and defined names carry no row digits, so they pass through.
  */
 export declare function translateFormula(formula: string, colDelta: number, rowDelta: number): string;
+/**
+ * A number as it appears *inside formula text*, which is not the same serialisation as an
+ * attribute's.
+ *
+ * Two divergences, both found as drift rather than designed. The exponent's case: Excel writes
+ * `1E+21` where JavaScript writes `1e+21`, so the same literal read back through the two codecs
+ * produced two different formula strings depending on which file it came from -- exactly the
+ * asymmetry `cell-value.ts` and `cell-accumulator.ts` were extracted to prevent. And the finiteness
+ * guard: the BIFF12 decoder had a private copy of this function with none, so a `PtgNum` whose eight
+ * bytes decode to an infinity produced the formula text `INFINITY`, which the writer then escaped as
+ * ordinary text into a package Excel reports as damaged.
+ *
+ * Here rather than in `xml/xml.ts` beside the attribute form, because formula text is not XML: the
+ * BIFF12 codec produces it too, and reaching the XML serialiser for it put the whole write half of
+ * that module into the closure of an entry that has no XML in it.
+ *
+ * @throws {AuthoringError} when the value is not finite.
+ */
+export declare function formulaNumberLiteral(value: number): string;
+/**
+ * Render a formula operand for serialisation: a number becomes its literal, a string is stripped of
+ * the single optional leading '=' an author may write (OOXML stores the expression without it, e.g.
+ * `=A1>0` on disk is `A1>0`). The result is unescaped: the caller escapes it for its target, whether
+ * that is element text or an attribute value.
+ */
+export declare function stripFormulaEquals(value: string | number): string;

package/dist/core/formula.js

@@ -1,5 +1,7 @@
-import { columnToNumber, numberToColumn } from './address.js';
+import { assertWritableNumber } from '../errors.js';
+import { MAX_COLUMN, MAX_ROW, numberToColumn, tryColumnToNumber } from './address.js';
 import { MODERN_FUNCTIONS } from './modern-functions.js';
+import { REF_ERROR } from './value.js';
 const XLFN = '_xlfn.';
 const XLPM = '_xlpm.';
 export function quoteSheetName(name, last) {
@@ -195,8 +197,22 @@ export function translateFormula(formula, colDelta, rowDelta) {
     if (colDelta === 0 && rowDelta === 0)
         return formula;
     return scanFormula(formula, (code) => code.replace(CELL_REFERENCE, (_match, colAbs, colLetters, rowAbs, rowDigits) => {
-        const col = colAbs === '$' ? colLetters : numberToColumn(columnToNumber(colLetters) + colDelta);
-        const row = rowAbs === '$' ? rowDigits : String(Number(rowDigits) + rowDelta);
-        return `${colAbs}${col}${rowAbs}${row}`;
+        const decoded = tryColumnToNumber(colLetters);
+        if (decoded === undefined)
+            return REF_ERROR;
+        const col = colAbs === '$' ? decoded : decoded + colDelta;
+        const row = rowAbs === '$' ? Number(rowDigits) : Number(rowDigits) + rowDelta;
+        if (col < 1 || col > MAX_COLUMN || row < 1 || row > MAX_ROW)
+            return REF_ERROR;
+        return `${colAbs}${numberToColumn(col)}${rowAbs}${row}`;
     }));
 }
+export function formulaNumberLiteral(value) {
+    assertWritableNumber(value);
+    return String(value).toUpperCase();
+}
+export function stripFormulaEquals(value) {
+    if (typeof value === 'number')
+        return formulaNumberLiteral(value);
+    return value.startsWith('=') ? value.slice(1) : value;
+}

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

@@ -3,10 +3,10 @@ import { Cell } from './cell.ts';
 import type { ConditionalFormattingOverlay } from './conditional-formatting-overlay.ts';
 import type { DataValidationOverlay } from './data-validation-overlay.ts';
 import { type AnchoredImage } from './image.ts';
-import type { MergeRect } from './merge.ts';
 import type { Table } from './table.ts';
 import { type CellValue } from './value.ts';
 import type { WorksheetComments } from './worksheet-comments.ts';
+import type { WorksheetMerges } from './worksheet-merges.ts';
 import type { ColumnProperties, RowProperties } from './worksheet.ts';
 /**
  * The sheet's autofilter, reached as a slot rather than held by reference like the containers beside
@@ -20,8 +20,7 @@ interface GridStorage {
     readonly rows: Map<number, Map<number, Cell>>;
     readonly rowProperties: Map<number, RowProperties>;
     readonly columns: Map<number, ColumnProperties>;
-    readonly merges: string[];
-    readonly mergeRects: MergeRect[];
+    readonly merges: WorksheetMerges;
     readonly tables: Table[];
     readonly images: AnchoredImage[];
     readonly dataValidations: DataValidationOverlay;

package/dist/core/grid-edits.js

@@ -1,16 +1,16 @@
-import { decodeRange, encodeAddress, tryDecodeCellRef } from './address.js';
+import { boundedRect, decodeRange, encodeAddress, encodeRect, tryDecodeCellRef } 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 { isDeletedSpan, shiftIndex, shiftRect } from './grid-shift.js';
 import { isOneCellAnchor } from './image.js';
+import { positionalPlacements } from './row-input.js';
 import { isSharedFormulaValue } from './value.js';
 export class GridEdits {
     #rows;
     #rowProperties;
     #columns;
     #merges;
-    #mergeRects;
     #tables;
     #images;
     #dataValidations;
@@ -22,7 +22,6 @@ export class GridEdits {
         this.#rowProperties = storage.rowProperties;
         this.#columns = storage.columns;
         this.#merges = storage.merges;
-        this.#mergeRects = storage.mergeRects;
         this.#tables = storage.tables;
         this.#images = storage.images;
         this.#dataValidations = storage.dataValidations;
@@ -31,13 +30,15 @@ export class GridEdits {
         this.#autoFilter = storage.autoFilter;
     }
     spliceRows(start, count, inserted) {
-        const delta = inserted.length - count;
+        const splice = { axis: 'row', start, count, delta: inserted.length - count };
         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 +46,16 @@ 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.#shiftLineProperties(this.#rowProperties, splice);
+        this.#shiftMerges(splice);
+        this.#shiftTables(splice);
+        this.#shiftImages(splice);
+        this.#reanchorSharedFormulas(splice);
+        this.#shiftRangeBoundOverlays(splice);
     }
     spliceColumns(start, count, inserts) {
-        const delta = inserts.length - count;
+        const splice = { axis: 'col', start, count, delta: inserts.length - count };
+        const shiftedRows = new Map();
         for (const [row, cols] of this.#rows) {
             const shifted = new Map();
             for (const [col, cell] of cols) {
@@ -61,37 +63,42 @@ 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);
-                }
-            });
-            this.#rows.set(row, shifted);
+            shiftedRows.set(row, shifted);
         }
-        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);
+        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.#shiftLineProperties(this.#columns, splice);
+        this.#shiftMerges(splice);
+        this.#shiftTables(splice);
+        this.#shiftImages(splice);
+        this.#reanchorSharedFormulas(splice);
+        this.#shiftRangeBoundOverlays(splice);
     }
-    #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);
+    #shiftRangeBoundOverlays(splice) {
+        this.#dataValidations.shift(splice);
+        this.#conditionalFormattings.shift(splice);
+        this.#comments.shift(splice);
         const filter = this.#autoFilter.get();
-        if (filter !== undefined) {
-            this.#autoFilter.set(shiftAutoFilter(filter, axis, start, count, delta));
-        }
+        if (filter !== undefined)
+            this.#autoFilter.set(shiftAutoFilter(filter, splice));
     }
     #relocateRow(cols, destRow) {
         const moved = new Map();
@@ -107,7 +114,7 @@ export class GridEdits {
         }
         return moved;
     }
-    #reanchorSharedFormulas(axis, start, count, delta) {
+    #reanchorSharedFormulas(splice) {
         for (const cols of this.#rows.values()) {
             for (const cell of cols.values()) {
                 const value = cell.value;
@@ -116,9 +123,9 @@ export class GridEdits {
                 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);
+                const anchored = splice.axis === 'row'
+                    ? encodeAddress(master.col, shiftIndex(master.row, splice))
+                    : encodeAddress(shiftIndex(master.col, splice), master.row);
                 if (anchored === value.sharedFormula)
                     continue;
                 const reanchored = { ...value, sharedFormula: anchored };
@@ -126,59 +133,51 @@ export class GridEdits {
             }
         }
     }
-    #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);
+    #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) };
+                : { ...image.anchor, from, to: shiftAnchor(image.anchor.to) };
             return { imageId: image.imageId, anchor };
         });
         replaceContents(this.#images, moved);