@shbernal/ts-xlsx 3.1.0 → 3.2.0

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

@@ -2,18 +2,30 @@ import { type ClonePlan } from './clone.ts';
 import type { AssertNever } from './internal.ts';
 import { type Color } from './style.ts';
 import type { DifferentialStyle } from './workbook-styles.ts';
-/** How a {@link CfValueObject} reads its `value`: `ST_CfvoType` verbatim. */
-export type CfValueObjectType = 'num' | 'percent' | 'max' | 'min' | 'percentile' | 'formula';
+/**
+ * How a {@link CfValueObject} reads its `value`: `ST_CfvoType` verbatim, with the `autoMin` and
+ * `autoMax` the 2009 extension adds.
+ */
+export type CfValueObjectType = 'num' | 'percent' | 'max' | 'min' | 'percentile' | 'formula' | 'autoMin' | 'autoMax';
 /** Narrow a raw `<cfvo type>` token to a known {@link 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
  * `formula`, or the range's own `min`/`max` (which carry no value).
+ *
+ * `autoMin` and `autoMax` are the automatic anchors Excel 2010 gives a new data bar, and carry no value
+ * either. Only the extension form spells them, so a data bar using one is written with its extension,
+ * its classic element saying `min` or `max` in their place as Excel's does.
  */
 export interface CfValueObject {
     type: CfValueObjectType;
     value?: number | string;
+    /**
+     * Whether a value equal to this threshold reaches it. `false` makes an icon set's threshold a strict
+     * `>` rather than the `>=` the schema defaults to.
+     */
+    gte?: boolean;
 }
 /**
  * What a rule tests, as `<cfRule type>` carries it: `ST_CfType` verbatim.
@@ -40,21 +52,49 @@ export declare const isConditionalFormattingOperator: (value: string) => value i
 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 const isCfTimePeriod: (value: string) => value is CfTimePeriod;
+/**
+ * Which way a data bar grows, as `ST_DataBarDirection` enumerates it: `context` follows the sheet's
+ * reading direction.
+ */
+export type DataBarDirection = 'context' | 'leftToRight' | 'rightToLeft';
+/** Narrow a raw `<x14:dataBar direction>` token to a known {@link DataBarDirection}. */
+export declare const isDataBarDirection: (value: string) => value is DataBarDirection;
+/**
+ * Where a data bar draws the axis between its negative and positive bars, as `ST_DataBarAxisPosition`
+ * enumerates it: where the values put it, at the middle of the cell, or nowhere, which grows a
+ * negative bar the way a positive one grows.
+ */
+export type DataBarAxisPosition = 'automatic' | 'middle' | 'none';
+/** Narrow a raw `<x14:dataBar axisPosition>` token to a known {@link DataBarAxisPosition}. */
+export declare const isDataBarAxisPosition: (value: string) => value is DataBarAxisPosition;
 /**
  * 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.
  *
- * The 2009 extension adds three more families (`3Stars`, `3Triangles`, `5Boxes`) under its own
- * namespace. They are absent here because the classic `<iconSet>` element this list types cannot
- * carry them; a file using one states it in the extension, which the library round-trips verbatim.
+ * `3Stars`, `3Triangles` and `5Boxes` are the families the 2009 extension added. The classic
+ * `<iconSet>` element cannot name them, so a rule drawing from one is written in the extension form.
  */
-export type IconSetType = '3Arrows' | '3ArrowsGray' | '3Flags' | '3TrafficLights1' | '3TrafficLights2' | '3Signs' | '3Symbols' | '3Symbols2' | '4Arrows' | '4ArrowsGray' | '4RedToBlack' | '4Rating' | '4TrafficLights' | '5Arrows' | '5ArrowsGray' | '5Rating' | '5Quarters';
+export type IconSetType = '3Arrows' | '3ArrowsGray' | '3Flags' | '3TrafficLights1' | '3TrafficLights2' | '3Signs' | '3Symbols' | '3Symbols2' | '4Arrows' | '4ArrowsGray' | '4RedToBlack' | '4Rating' | '4TrafficLights' | '5Arrows' | '5ArrowsGray' | '5Rating' | '5Quarters' | '3Stars' | '3Triangles' | '5Boxes';
 /** Narrow a raw `<iconSet iconSet>` token to a known {@link IconSetType}. */
 export declare const isIconSetType: (value: string) => value is IconSetType;
+/** The families only the 2009 extension can name: a rule drawing from one is written there. */
+export declare function isExtensionIconSet(iconSet: IconSetType): boolean;
+/** The family a custom icon comes from: any {@link IconSetType}, or `NoIcons` for a threshold showing none. */
+export type CfIconSetType = IconSetType | 'NoIcons';
+/** Narrow a raw `<x14:cfIcon iconSet>` token to a known {@link CfIconSetType}. */
+export declare function isCfIconSetType(value: string): value is CfIconSetType;
+/** One threshold's icon in a custom icon set: icon number `iconId`, from 0, of the family `iconSet`. */
+export interface CfIcon {
+    iconSet: CfIconSetType;
+    iconId: number;
+}
 /**
  * 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
  * still preserves `type`, `priority`, `operator`, `formulae`, and `dxfId` across a round-trip.
+ *
+ * A data bar's facets marked as x14 properties have no place in the classic `<dataBar>` element, so a
+ * bar carrying any of them, or an automatic anchor, is written with a linked `<x14:dataBar>` as well.
  */
 export interface ConditionalFormattingRule {
     type: ConditionalFormattingType;
@@ -78,14 +118,48 @@ export interface ConditionalFormattingRule {
     color?: Color;
     /** A colorScale's colours, one per {@link cfvo}. */
     colors?: Color[];
-    /** A dataBar's gradient-fill flag. Lives only in the x14 extension, not the classic element. */
+    /** A dataBar's shortest bar, as a percentage of the cell. */
+    minLength?: number;
+    /** A dataBar's longest bar, as a percentage of the cell. */
+    maxLength?: number;
+    /** A dataBar's gradient-fill flag. An x14 property. */
     gradient?: boolean;
-    /** A dataBar's fill colour for negative values. An x14 extension property. */
+    /** Whether a dataBar has a border, in {@link borderColor}. An x14 property. */
+    border?: boolean;
+    /** A dataBar's border colour. An x14 property. */
+    borderColor?: Color;
+    /** Which way a dataBar grows. An x14 property. */
+    direction?: DataBarDirection;
+    /** A dataBar's fill colour for negative values. An x14 property. */
     negativeFillColor?: Color;
+    /** A dataBar's border colour for negative values. An x14 property. */
+    negativeBorderColor?: Color;
+    /**
+     * Whether a dataBar fills a negative bar in its positive colour rather than
+     * {@link negativeFillColor}. An x14 property.
+     */
+    negativeBarColorSameAsPositive?: boolean;
+    /**
+     * Whether a dataBar borders a negative bar in its positive border colour rather than
+     * {@link negativeBorderColor}. An x14 property.
+     */
+    negativeBarBorderColorSameAsPositive?: boolean;
+    /** Where a dataBar draws the axis between negative and positive bars. An x14 property. */
+    axisPosition?: DataBarAxisPosition;
     /** A dataBar's axis colour (the zero line between positive and negative bars). An x14 property. */
     axisColor?: Color;
     /** An iconSet's named icon family (e.g. `3TrafficLights1`). */
     iconSet?: IconSetType;
+    /**
+     * A custom iconSet's icons, one per {@link cfvo} threshold in order, each replacing the icon
+     * {@link iconSet} would show there. Only the extension form carries them, so a rule with icons is
+     * written in it.
+     */
+    icons?: CfIcon[];
+    /** iconSet: the icons in reverse order, the highest threshold showing the family's first icon. */
+    reverse?: boolean;
+    /** dataBar / iconSet: whether the cell still shows its value beside the bar or icon. */
+    showValue?: boolean;
     /** top10 rank cutoff. */
     rank?: number;
     /** top10: the rank is a percentage rather than a count. */
@@ -101,16 +175,30 @@ export interface ConditionalFormattingRule {
     /** timePeriod window (`today`, `lastWeek`, …). */
     timePeriod?: CfTimePeriod;
 }
-/** A set of rules bound to the range(s) they cover. `ref` is an OOXML `sqref`: one or more
+/**
+ * A set of rules bound to the range(s) they cover. `ref` is an OOXML `sqref`: one or more
  * space-separated areas (`"A1:C1 A3:C3 A5:C5"`), the shape Excel writes when one rule is applied to
- * several non-contiguous selections at once. */
+ * several non-contiguous selections at once.
+ *
+ * `extended` marks a set stored in the 2009 extension form (`<x14:conditionalFormatting>` inside the
+ * worksheet `<extLst>`), where Excel puts a rule whose formula reaches another sheet. The reader sets
+ * it for a set found in that form so a round-trip writes the set back there. A rule only that form can
+ * express, one drawing from a 2009 icon family or carrying custom icons, is written there whatever the
+ * flag says.
+ */
 export interface ConditionalFormatting {
     ref: string;
     rules: ConditionalFormattingRule[];
+    extended?: boolean;
 }
 /** A defensive deep copy, so a stored conditional formatting never aliases the caller's object nor
  * any of its nested arrays (rules, formulae, cfvo, colours) or the differential style. */
 export declare function cloneConditionalFormatting(cf: ConditionalFormatting): ConditionalFormatting;
+/**
+ * Whether a rule needs the extension form: it names a family or custom icons the classic element has
+ * no way to spell.
+ */
+export declare function ruleNeedsExtension(rule: ConditionalFormattingRule): boolean;
 declare const RULE_CLONE: ClonePlan<ConditionalFormattingRule>;
 export type EveryRuleFieldIsCloned = AssertNever<Exclude<keyof Required<ConditionalFormattingRule>, keyof typeof RULE_CLONE>>;
 declare const STYLE_CLONE: ClonePlan<DifferentialStyle>;

package/dist/core/conditional-formatting.js

@@ -8,6 +8,8 @@ export const isCfValueObjectType = tokenSet({
     min: true,
     percentile: true,
     formula: true,
+    autoMin: true,
+    autoMax: true,
 });
 export const isConditionalFormattingType = tokenSet({
     expression: true,
@@ -55,6 +57,16 @@ export const isCfTimePeriod = tokenSet({
     lastWeek: true,
     nextWeek: true,
 });
+export const isDataBarDirection = tokenSet({
+    context: true,
+    leftToRight: true,
+    rightToLeft: true,
+});
+export const isDataBarAxisPosition = tokenSet({
+    automatic: true,
+    middle: true,
+    none: true,
+});
 export const isIconSetType = tokenSet({
     '3Arrows': true,
     '3ArrowsGray': true,
@@ -73,9 +85,26 @@ export const isIconSetType = tokenSet({
     '5ArrowsGray': true,
     '5Rating': true,
     '5Quarters': true,
+    '3Stars': true,
+    '3Triangles': true,
+    '5Boxes': true,
 });
+export function isExtensionIconSet(iconSet) {
+    return iconSet === '3Stars' || iconSet === '3Triangles' || iconSet === '5Boxes';
+}
+export function isCfIconSetType(value) {
+    return value === 'NoIcons' || isIconSetType(value);
+}
 export function cloneConditionalFormatting(cf) {
-    return { ref: cf.ref, rules: cf.rules.map(cloneRule) };
+    const copy = { ref: cf.ref, rules: cf.rules.map(cloneRule) };
+    if (cf.extended !== undefined)
+        copy.extended = cf.extended;
+    return copy;
+}
+export function ruleNeedsExtension(rule) {
+    return (rule.type === 'iconSet' &&
+        ((rule.iconSet !== undefined && isExtensionIconSet(rule.iconSet)) ||
+            (rule.icons !== undefined && rule.icons.length > 0)));
 }
 const RULE_CLONE = {
     type: 'value',
@@ -89,10 +118,22 @@ const RULE_CLONE = {
     cfvo: 'records',
     color: 'record',
     colors: 'records',
+    minLength: 'value',
+    maxLength: 'value',
     gradient: 'value',
+    border: 'value',
+    borderColor: 'record',
+    direction: 'value',
     negativeFillColor: 'record',
+    negativeBorderColor: 'record',
+    negativeBarColorSameAsPositive: 'value',
+    negativeBarBorderColorSameAsPositive: 'value',
+    axisPosition: 'value',
     axisColor: 'record',
     iconSet: 'value',
+    icons: 'records',
+    reverse: 'value',
+    showValue: 'value',
     rank: 'value',
     percent: 'value',
     bottom: 'value',

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

@@ -35,6 +35,11 @@ export declare class DataValidationOverlay {
      * inside a deleted span is dropped with them.
      */
     shift(splice: AxisSplice): void;
+    /**
+     * Rewrite every rule's formula operands through `rewrite`, keeping a rule whose operands did not
+     * change as the same object. A numeric operand is not a formula and passes through.
+     */
+    mapFormulas(rewrite: (formula: string) => string): void;
     /** Drop every validation, leaving the overlay empty. */
     clear(): void;
 }

package/dist/core/data-validation-overlay.js

@@ -43,6 +43,21 @@ export class DataValidationOverlay {
         replaceContents(this.#entries, entries);
         replaceContents(this.#rects, rects);
     }
+    mapFormulas(rewrite) {
+        for (const [index, entry] of this.#entries.entries()) {
+            const formulae = entry.rule.formulae;
+            if (formulae === undefined)
+                continue;
+            const next = formulae.map((operand) => typeof operand === 'string' ? rewrite(operand) : operand);
+            if (next.every((operand, i) => operand === formulae[i]))
+                continue;
+            const rule = { ...entry.rule, formulae: next };
+            this.#entries[index] = { ...entry, rule };
+            const indexed = this.#rects[index];
+            if (indexed !== undefined)
+                this.#rects[index] = { rects: indexed.rects, rule };
+        }
+    }
     clear() {
         this.#entries.length = 0;
         this.#rects.length = 0;

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

@@ -15,6 +15,14 @@ export declare const isDataValidationOperator: (value: string) => value is DataV
 export type DataValidationErrorStyle = 'stop' | 'warning' | 'information';
 /** Narrow a raw `<dataValidation errorStyle>` token to a known {@link DataValidationErrorStyle}. */
 export declare const isDataValidationErrorStyle: (value: string) => value is DataValidationErrorStyle;
+/**
+ * How the input method editor behaves while a covered cell is edited. Only an East Asian input method
+ * acts on it: `hiragana`, the katakana, alpha and hangul widths switch its mode, `on` and `off` turn it
+ * on and off, `disabled` turns it off and keeps it off, and `noControl` leaves it as the user had it.
+ */
+export type DataValidationImeMode = 'noControl' | 'off' | 'on' | 'disabled' | 'hiragana' | 'fullKatakana' | 'halfKatakana' | 'fullAlpha' | 'halfAlpha' | 'fullHangul' | 'halfHangul';
+/** Narrow a raw `<dataValidation imeMode>` token to a known {@link DataValidationImeMode}. */
+export declare const isDataValidationImeMode: (value: string) => value is DataValidationImeMode;
 /** 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. */
@@ -23,9 +31,17 @@ export interface DataValidation {
     operator?: DataValidationOperator;
     formulae?: (string | number)[];
     allowBlank?: boolean;
+    /**
+     * Hide the in-cell dropdown arrow of a `list` rule while still enforcing the list, the usual way to
+     * validate against a list without offering a picker. Stored as `showDropDown="1"`, an attribute
+     * whose name says the opposite of what it does.
+     */
+    suppressDropDown?: boolean;
     showInputMessage?: boolean;
     showErrorMessage?: boolean;
     errorStyle?: DataValidationErrorStyle;
+    /** How the input method editor behaves in a covered cell; absent leaves it as the user had it. */
+    imeMode?: DataValidationImeMode;
     error?: string;
     errorTitle?: string;
     prompt?: string;

package/dist/core/data-validation.js

@@ -25,14 +25,29 @@ export const isDataValidationErrorStyle = tokenSet({
     warning: true,
     information: true,
 });
+export const isDataValidationImeMode = tokenSet({
+    noControl: true,
+    off: true,
+    on: true,
+    disabled: true,
+    hiragana: true,
+    fullKatakana: true,
+    halfKatakana: true,
+    fullAlpha: true,
+    halfAlpha: true,
+    fullHangul: true,
+    halfHangul: true,
+});
 const RULE_CLONE = {
     type: 'value',
     operator: 'value',
     formulae: 'values',
     allowBlank: 'value',
+    suppressDropDown: 'value',
     showInputMessage: 'value',
     showErrorMessage: 'value',
     errorStyle: 'value',
+    imeMode: 'value',
     error: 'value',
     errorTitle: 'value',
     prompt: 'value',

package/dist/core/date-format.js

@@ -48,7 +48,8 @@ function formatRuns(code) {
             continue;
         }
         const fraction = /^\.0+/.exec(code.slice(i));
-        if (fraction !== null && runs.at(-1)?.text === 's') {
+        const previous = runs.at(-1);
+        if (fraction !== null && previous?.kind === 'placeholder' && previous.text === 's') {
             runs.push({ kind: 'placeholder', text: '.0', count: fraction[0].length - 1 });
             i += fraction[0].length - 1;
             continue;
@@ -64,8 +65,12 @@ function formatRuns(code) {
         }
         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;
+            const token = meridiem[0];
+            if (token.length === 3)
+                runs.push({ kind: 'placeholder', text: 'a/p', count: 3, written: token });
+            else
+                runs.push({ kind: 'placeholder', text: 'am/pm', count: token.length });
+            i += token.length - 1;
             continue;
         }
         literal(ch);
@@ -100,7 +105,7 @@ export function formatSerialDate(date, code, utc) {
     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 twelveHour = runs.some((run) => run.kind === 'placeholder' && (run.text === 'am/pm' || run.text === 'a/p'));
     const hour = twelveHour ? hour24 % 12 || 12 : hour24;
     const pad = (value, width) => String(value).padStart(width, '0');
     let out = '';
@@ -152,6 +157,11 @@ export function formatSerialDate(date, code, utc) {
             case 'am/pm':
                 out += hour24 < 12 ? 'AM' : 'PM';
                 break;
+            case 'a/p': {
+                const written = run.written ?? 'A/P';
+                out += hour24 < 12 ? written.charAt(0) : written.charAt(2);
+                break;
+            }
             default:
                 break;
         }

package/dist/core/date.js

@@ -7,7 +7,7 @@ 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;
+    return Math.floor(days) <= PHANTOM_SERIAL ? days - 1 : days;
 }
 export function serialToDate(serial, epoch) {
     if (epoch === 1904)

package/dist/core/formula-references.d.ts

@@ -0,0 +1,26 @@
+import type { AxisSplice } from './grid-shift.ts';
+/**
+ * Shift every relative reference in a formula by `colDelta` columns and `rowDelta` rows, leaving
+ * absolute (`$`-anchored) axes fixed. This is how a shared-formula clone recovers its own formula from
+ * the master's: a master `A1*2` shared one row down reads back as `A2*2`, `$A$1*B1` shared one row and
+ * one column across as `$A$1*C2`, and `COUNTIF(A:A,A1)` shared one column right as `COUNTIF(B:B,B1)`.
+ * Whole-column and whole-row ranges shift at each relative end, as cells do. String literals,
+ * single-quoted sheet names, and bracketed structured references are copied verbatim, and a
+ * sheet-qualified reference shifts while its sheet name is untouched. Function names and defined names
+ * are not reference-shaped, so they pass through.
+ */
+export declare function translateFormula(formula: string, colDelta: number, rowDelta: number): string;
+/** A splice as a formula sees it: which sheet's lines moved, and how. */
+export interface SheetSplice {
+    /** The spliced sheet's name, matched in any case. */
+    readonly sheet: string;
+    readonly splice: AxisSplice;
+}
+/**
+ * Rewrite a formula's references for a splice of `edit.sheet`. `home` is the sheet the formula belongs
+ * to, whose name an unqualified reference means; `undefined` for a formula that has none, such as a
+ * workbook-scoped defined name, whose references to a sheet are always qualified.
+ *
+ * Returns the formula unchanged, as the same string, when nothing in it moved.
+ */
+export declare function spliceFormula(formula: string, home: string | undefined, edit: SheetSplice): string;

package/dist/core/formula-references.js

@@ -0,0 +1,173 @@
+import { MAX_COLUMN, MAX_ROW, numberToColumn, tryColumnToNumber } from './address.js';
+import { scanFormula, skipOpaque } from './formula-scan.js';
+import { REF_ERROR } from './value.js';
+const SHIFTABLE_REFERENCE = /(?<![A-Za-z0-9_.])(?:(\$?)([A-Z]{1,3}):(\$?)([A-Z]{1,3})|(\$?)([0-9]{1,7}):(\$?)([0-9]{1,7})|(\$?)([A-Z]{1,3})(\$?)([0-9]{1,7}))(?![A-Za-z0-9_.!(])/g;
+export function translateFormula(formula, colDelta, rowDelta) {
+    if (colDelta === 0 && rowDelta === 0)
+        return formula;
+    const column = (anchor, letters) => {
+        const decoded = tryColumnToNumber(letters);
+        if (decoded === undefined)
+            return undefined;
+        const col = anchor === '$' ? decoded : decoded + colDelta;
+        return col < 1 || col > MAX_COLUMN ? undefined : `${anchor}${numberToColumn(col)}`;
+    };
+    const row = (anchor, digits) => {
+        const index = anchor === '$' ? Number(digits) : Number(digits) + rowDelta;
+        return index < 1 || index > MAX_ROW ? undefined : `${anchor}${index}`;
+    };
+    const range = (first, last) => first === undefined || last === undefined ? REF_ERROR : `${first}:${last}`;
+    return scanFormula(formula, (code) => code.replace(SHIFTABLE_REFERENCE, (_match, firstColumnAnchor, firstColumn, lastColumnAnchor, lastColumn, firstRowAnchor, firstRow, lastRowAnchor, lastRow, cellColumnAnchor, cellColumn, cellRowAnchor, cellRow) => {
+        if (firstColumn !== undefined && lastColumn !== undefined) {
+            return range(column(firstColumnAnchor ?? '', firstColumn), column(lastColumnAnchor ?? '', lastColumn));
+        }
+        if (firstRow !== undefined && lastRow !== undefined) {
+            return range(row(firstRowAnchor ?? '', firstRow), row(lastRowAnchor ?? '', lastRow));
+        }
+        const shiftedColumn = column(cellColumnAnchor ?? '', cellColumn ?? '');
+        const shiftedRow = row(cellRowAnchor ?? '', cellRow ?? '');
+        return shiftedColumn === undefined || shiftedRow === undefined
+            ? REF_ERROR
+            : `${shiftedColumn}${shiftedRow}`;
+    }));
+}
+const REFERENCE = /(?:(\$?)([A-Z]{1,3})(\$?)(\d{1,7}):(\$?)([A-Z]{1,3})(\$?)(\d{1,7})|(\$?)([A-Z]{1,3})(\$?)(\d{1,7})|(\$?)([A-Z]{1,3}):(\$?)([A-Z]{1,3})|(\$?)(\d{1,7}):(\$?)(\d{1,7}))(?![\p{L}\p{N}_.(![])/uy;
+const NAME_CHAR = /[\p{L}\p{N}_.\\]/u;
+export function spliceFormula(formula, home, edit) {
+    const target = edit.sheet.toLowerCase();
+    const homeIsTarget = home !== undefined && home.toLowerCase() === target;
+    let out = '';
+    let i = 0;
+    const n = formula.length;
+    const atTokenStart = (index) => index === 0 || !NAME_CHAR.test(formula[index - 1] ?? '');
+    const reference = (moves) => {
+        REFERENCE.lastIndex = i;
+        const match = REFERENCE.exec(formula);
+        if (match === null)
+            return false;
+        out += moves ? moved(match, edit.splice) : match[0];
+        i = REFERENCE.lastIndex;
+        return true;
+    };
+    while (i < n) {
+        const ch = formula[i] ?? '';
+        if (ch === '"') {
+            const end = skipOpaque(formula, i);
+            out += formula.slice(i, end);
+            i = end;
+            continue;
+        }
+        if (ch === '[') {
+            const end = skipOpaque(formula, i);
+            out += formula.slice(i, end);
+            i = end;
+            const name = nameRun(formula, i);
+            if (name > i && formula[name] === '!') {
+                out += formula.slice(i, name + 1);
+                i = name + 1;
+                reference(false);
+            }
+            continue;
+        }
+        if (ch === "'") {
+            const end = skipOpaque(formula, i);
+            const quoted = formula.slice(i + 1, end - 1).replaceAll("''", "'");
+            out += formula.slice(i, end);
+            i = end;
+            if (formula[i] !== '!')
+                continue;
+            out += '!';
+            i += 1;
+            reference(!quoted.includes(':') && !quoted.includes('[') && quoted.toLowerCase() === target);
+            continue;
+        }
+        if (atTokenStart(i) && NAME_CHAR.test(ch)) {
+            const end = nameRun(formula, i);
+            const next = formula[end];
+            if (next === '!') {
+                out += formula.slice(i, end + 1);
+                const name = formula.slice(i, end);
+                i = end + 1;
+                reference(name.toLowerCase() === target);
+                continue;
+            }
+            if (next === ':') {
+                const last = nameRun(formula, end + 1);
+                if (last > end + 1 && formula[last] === '!') {
+                    out += formula.slice(i, last + 1);
+                    i = last + 1;
+                    reference(false);
+                    continue;
+                }
+            }
+            if (reference(homeIsTarget))
+                continue;
+            out += formula.slice(i, end);
+            i = end;
+            continue;
+        }
+        if (atTokenStart(i) && ch === '$' && reference(homeIsTarget))
+            continue;
+        out += ch;
+        i += 1;
+    }
+    return out === formula ? formula : out;
+}
+function nameRun(formula, start) {
+    let j = start;
+    while (j < formula.length && NAME_CHAR.test(formula[j] ?? ''))
+        j += 1;
+    return j;
+}
+function moved(match, splice) {
+    const g = (index) => match[index] ?? '';
+    const ends = match[2] !== undefined
+        ? [
+            [g(1), g(2), g(3), g(4)],
+            [g(5), g(6), g(7), g(8)],
+        ]
+        : match[10] !== undefined
+            ? [[g(9), g(10), g(11), g(12)]]
+            : match[14] !== undefined
+                ? [
+                    [g(13), g(14), '', ''],
+                    [g(15), g(16), '', ''],
+                ]
+                : [
+                    ['', '', g(17), g(18)],
+                    ['', '', g(19), g(20)],
+                ];
+    const rows = splice.axis === 'row';
+    const lines = ends.map(([, letters = '', , digits = '']) => (rows ? digits : letters));
+    if (lines.includes(''))
+        return match[0];
+    const [first = 0, last = first] = lines.map((line) => (rows ? Number(line) : columnOf(line)));
+    const edges = movedEdges(Math.min(first, last), Math.max(first, last), splice, rows ? MAX_ROW : MAX_COLUMN);
+    if (edges === undefined)
+        return REF_ERROR;
+    const placed = first <= last ? edges : [edges[1], edges[0]];
+    return ends
+        .map(([columnAnchor = '', letters = '', rowAnchor = '', digits = ''], i) => {
+        const at = placed[i] ?? 0;
+        return rows
+            ? `${columnAnchor}${letters}${rowAnchor}${at}`
+            : `${columnAnchor}${numberToColumn(at)}${rowAnchor}${digits}`;
+    })
+        .join(':');
+}
+function columnOf(letters) {
+    return tryColumnToNumber(letters) ?? MAX_COLUMN + 1;
+}
+function movedEdges(lo, hi, splice, bound) {
+    if (hi > bound)
+        return [lo, hi];
+    const { start, count, delta } = splice;
+    const end = start + count;
+    if (lo >= start && hi < end)
+        return undefined;
+    const top = lo < start ? lo : lo < end ? end + delta : lo + delta;
+    const bottom = hi < start ? hi : hi < end ? start - 1 : hi + delta;
+    if (top > bound)
+        return undefined;
+    return [top, Math.min(bottom, bound)];
+}

package/dist/core/formula-scan.d.ts

@@ -0,0 +1,2 @@
+export declare function skipOpaque(formula: string, index: number): number;
+export declare function scanFormula(formula: string, transform: (code: string) => string): string;

package/dist/core/formula-scan.js

@@ -0,0 +1,58 @@
+export function skipOpaque(formula, index) {
+    const opener = formula[index];
+    const n = formula.length;
+    if (opener === '"' || opener === "'") {
+        let j = index + 1;
+        while (j < n) {
+            if (formula[j] === opener) {
+                if (formula[j + 1] === opener) {
+                    j += 2;
+                    continue;
+                }
+                return j + 1;
+            }
+            j += 1;
+        }
+        return n;
+    }
+    if (opener === '[') {
+        let depth = 0;
+        let j = index;
+        while (j < n) {
+            const ch = formula[j];
+            if (ch === "'") {
+                j += 2;
+                continue;
+            }
+            if (ch === '[')
+                depth += 1;
+            else if (ch === ']') {
+                depth -= 1;
+                if (depth === 0)
+                    return j + 1;
+            }
+            j += 1;
+        }
+        return n;
+    }
+    return index;
+}
+export function scanFormula(formula, transform) {
+    let out = '';
+    let codeStart = 0;
+    let i = 0;
+    const n = formula.length;
+    while (i < n) {
+        const past = skipOpaque(formula, i);
+        if (past > i) {
+            out += transform(formula.slice(codeStart, i));
+            out += formula.slice(i, past);
+            i = past;
+            codeStart = past;
+        }
+        else {
+            i += 1;
+        }
+    }
+    return out + transform(formula.slice(codeStart));
+}