@shbernal/ts-xlsx 3.0.0 → 3.1.0

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);

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

@@ -99,15 +99,19 @@ export interface WorksheetImages {
     readonly background: WorkbookImage | undefined;
 }
 /**
- * The id under which `image` is already registered in `media`, or `undefined` if it is not.
+ * A picture's content identity as a map key: its kind, its length, and a digest of its bytes.
  *
- * Content-addressed rather than reference-addressed: two byte-identical pictures are one picture,
- * however they reached the registry. This is what keeps repeated imports from growing the media
- * list without bound (the same logo carried onto twenty sheets registers once), and it is why the
- * comparison is over bytes rather than object identity, which a picture arriving from another
- * workbook would never satisfy.
+ * **Content-addressed, not reference-addressed.** Two byte-identical pictures are one picture,
+ * however they reached the registry. That is what keeps repeated imports from growing the media list
+ * without bound, so the same logo carried onto twenty sheets registers once, and it is why identity
+ * cannot be object identity: a picture arriving from another workbook would never satisfy that.
  *
- * The length check comes first and short-circuits, so pictures of different sizes never reach the
- * byte loop; only same-extension, same-length candidates are compared in full.
+ * **A key rather than a scan**, which is the part that changed. The comparison used to walk the whole
+ * media list byte by byte per candidate, and importing a sheet's pictures asks it once per anchored
+ * image, so merging a workbook of fifty distinct megabyte images compared bytes fifty times over
+ * fifty candidates. The workbook indexes each picture as it is registered instead.
+ *
+ * SHA-512 rather than a cheap checksum because a collision here silently substitutes one picture for
+ * another; the length is in the key as well, so a collision would have to match that too.
  */
-export declare function findRegisteredImage(media: readonly WorkbookImage[], image: WorkbookImage): number | undefined;
+export declare function imageContentKey(image: WorkbookImage): string;

package/dist/core/image.js

@@ -1,3 +1,5 @@
+import { hex } from '../hex.js';
+import { sha512 } from '../sha512.js';
 import { tokenSet } from '../token-set.js';
 export const PX_TO_EMU = 9525;
 export const isImageEditAs = tokenSet({ oneCell: true, twoCell: true, absolute: true });
@@ -40,9 +42,9 @@ export function normalizeImageExtension(extension, data) {
     }
     return sniffImageExtension(data);
 }
-export function findRegisteredImage(media, image) {
-    const index = media.findIndex((held) => held.extension === image.extension &&
-        held.data.length === image.data.length &&
-        held.data.every((byte, i) => byte === image.data[i]));
-    return index === -1 ? undefined : index;
+export function imageContentKey(image) {
+    let digest = '';
+    for (const byte of sha512(image.data))
+        digest += hex(byte, 2);
+    return `${image.extension}:${image.data.length}:${digest}`;
 }

package/dist/core/internal.d.ts

@@ -1,6 +1,12 @@
 /**
- * Keys the codec-only operations on `Workbook` and `Worksheet` (see `WorkbookInternals` /
- * `WorksheetInternals`, declared beside their classes).
+ * Keys the operations the library's own machinery may perform on a published class and a caller may
+ * not (see `WorkbookInternals` / `WorksheetInternals`, declared beside their classes).
+ *
+ * Not only the model: `WorksheetStreamWriter` hangs its construction and its row-flush plumbing off
+ * the same key, on the static side and the instance side respectively, because that class has the
+ * identical problem one layer up. Its constructor took the writer's style registry and its
+ * `flushedSheet()` returned the writer's flushed-row record, so seven internal types were named by a
+ * published signature and none of them was a type a consumer could write down.
  */
 export declare const INTERNAL: unique symbol;
 /**

package/dist/core/limits.d.ts

@@ -28,3 +28,26 @@ export declare const MAX_ROW_HEIGHT = 409.5;
  * value for it is a bug rather than a shortcut.
  */
 export declare const MAX_COLUMN_WIDTH = 255;
+/**
+ * The longest sheet name Excel accepts, in UTF-16 code units. A longer one is refused outright rather
+ * than truncated: a truncated name silently collides with its neighbours.
+ */
+export declare const MAX_SHEET_NAME_LENGTH = 31;
+/**
+ * The characters Excel forbids anywhere in a sheet name. A name may also not begin or end with an
+ * apostrophe, which this pattern does not express because the position is what makes it illegal: a
+ * sheet-qualified reference quotes the name with apostrophes, so one at either edge cannot be told
+ * from the quoting.
+ */
+export declare const INVALID_SHEET_NAME_CHARS: RegExp;
+/** The longest table name Excel accepts, in UTF-16 code units. */
+export declare const MAX_TABLE_NAME_LENGTH = 255;
+/**
+ * Excel's table-name grammar: start with a letter, underscore, or backslash; every later character a
+ * letter, digit, period, or underscore. Unicode letters and digits are allowed.
+ *
+ * Excel additionally forbids a name that *is* a cell reference (`A1`, `R1C1`), which this pattern
+ * deliberately does not: the regression corpus treats cell-reference-shaped names like `T1` as valid
+ * table names, so enforcing that rule would reject a fixture the contract accepts.
+ */
+export declare const TABLE_NAME_PATTERN: RegExp;

package/dist/core/limits.js

@@ -1,2 +1,6 @@
 export const MAX_ROW_HEIGHT = 409.5;
 export const MAX_COLUMN_WIDTH = 255;
+export const MAX_SHEET_NAME_LENGTH = 31;
+export const INVALID_SHEET_NAME_CHARS = /[*?:\\/[\]]/;
+export const MAX_TABLE_NAME_LENGTH = 255;
+export const TABLE_NAME_PATTERN = /^[\p{L}\\_][\p{L}\p{N}._]*$/u;

package/dist/core/merge.d.ts

@@ -1,5 +1,6 @@
 import { type GridRect } from './address.ts';
 import type { Cell } from './cell.ts';
+import { type AxisSplice } from './grid-shift.ts';
 /** A merged region, as the {@link GridRect} every range-shaped thing in the library is. */
 export type MergeRect = GridRect;
 /**
@@ -15,12 +16,12 @@ export declare function clearCoveredValues(rows: Map<number, Map<number, Cell>>,
  * that can exist contributes no rectangle, the reader's rule for every other foreign attribute. */
 export declare function decodeSqrefRects(sqref: string): MergeRect[];
 /**
- * Re-anchor an OOXML `sqref` through a splice of `count` lines at `start` on `axis`, the inverse of
- * {@link decodeSqrefRects}. Returns `undefined` when the splice deleted every area the `sqref` named:
- * an empty `sqref` is not writable, so the entry holding it goes too.
+ * Re-anchor an OOXML `sqref` through a splice, the inverse of {@link decodeSqrefRects}. Returns
+ * `undefined` when the splice deleted every area the `sqref` named: an empty `sqref` is not
+ * writable, so the entry holding it goes too.
  *
  * Each space-separated area shifts on its own, and one the splice does not move is returned as the
  * *original text*. That matters for a file the library did not author: `B:B` and `B1:B1048576` decode
  * identically, so a re-encode would rewrite a foreign spelling and cost the byte-clean round trip.
  */
-export declare function shiftSqref(sqref: string, axis: 'row' | 'col', start: number, count: number, delta: number): string | undefined;
+export declare function shiftSqref(sqref: string, splice: AxisSplice): string | undefined;

package/dist/core/merge.js

@@ -1,16 +1,15 @@
 import { encodeCornerRef, tryDecodeRange } from './address.js';
-import { isDeletedSpan, shiftIndex } from './grid-shift.js';
+import { shiftSpan } from './grid-shift.js';
 export function clearCoveredValues(rows, rect) {
-    for (let row = rect.top; row <= rect.bottom; row++) {
-        const cols = rows.get(row);
-        if (cols === undefined)
+    for (const [row, cols] of rows) {
+        if (row < rect.top || row > rect.bottom)
             continue;
-        for (let col = rect.left; col <= rect.right; col++) {
+        for (const [col, covered] of cols) {
+            if (col < rect.left || col > rect.right)
+                continue;
             if (row === rect.top && col === rect.left)
                 continue;
-            const covered = cols.get(col);
-            if (covered !== undefined)
-                covered.value = null;
+            covered.value = null;
         }
     }
 }
@@ -32,33 +31,33 @@ export function decodeSqrefRects(sqref) {
     }
     return rects;
 }
-export function shiftSqref(sqref, axis, start, count, delta) {
+export function shiftSqref(sqref, splice) {
     const areas = [];
     for (const area of sqref.split(/\s+/)) {
         if (area === '')
             continue;
-        const shifted = shiftSqrefArea(area, axis, start, count, delta);
+        const shifted = shiftSqrefArea(area, splice);
         if (shifted !== undefined)
             areas.push(shifted);
     }
     return areas.length > 0 ? areas.join(' ') : undefined;
 }
-function shiftSqrefArea(area, axis, start, count, delta) {
+function shiftSqrefArea(area, splice) {
     const decoded = tryDecodeRange(area);
     if (decoded === undefined)
         return area;
     const { top, left, bottom, right } = decoded;
-    const [lo, hi] = axis === 'row' ? [top, bottom] : [left, right];
+    const rowAxis = splice.axis === 'row';
+    const [lo, hi] = rowAxis ? [top, bottom] : [left, right];
     if (lo === undefined || hi === undefined)
         return area;
-    if (isDeletedSpan(lo, hi, start, count))
+    const moved = shiftSpan(lo, hi, splice);
+    if (moved === undefined)
         return undefined;
-    const movedLo = shiftIndex(lo, start, count, delta, axis);
-    const movedHi = shiftIndex(hi, start, count, delta, axis);
-    if (movedLo === lo && movedHi === hi)
+    if (moved.lo === lo && moved.hi === hi)
         return area;
-    const [tl, br] = axis === 'row'
-        ? [encodeCornerRef(left, movedLo), encodeCornerRef(right, movedHi)]
-        : [encodeCornerRef(movedLo, top), encodeCornerRef(movedHi, bottom)];
+    const [tl, br] = rowAxis
+        ? [encodeCornerRef(left, moved.lo), encodeCornerRef(right, moved.hi)]
+        : [encodeCornerRef(moved.lo, top), encodeCornerRef(moved.hi, bottom)];
     return area.includes(':') ? `${tl}:${br}` : tl;
 }