@bilig/formula 0.7.8 → 0.8.1

package/dist/translation.js

@@ -1,37 +1,13 @@
-import { ErrorCode, FormulaMode } from '@bilig/protocol';
-import { formatRangeAddress, parseCellAddress, parseRangeAddress } from './addressing.js';
-import { compileFormulaAst, } from './compiler.js';
+import { FormulaMode } from '@bilig/protocol';
+import { parseRangeAddress } from './addressing.js';
 import { parseFormula } from './parser.js';
-const CELL_REF_RE = /^(\$?)([A-Z]+)(\$?)([1-9][0-9]*)$/;
-const COLUMN_REF_RE = /^(\$?)([A-Z]+)$/;
-const ROW_REF_RE = /^(\$?)([1-9][0-9]*)$/;
-const BINARY_PRECEDENCE = {
-    '=': 1,
-    '<>': 1,
-    '>': 1,
-    '>=': 1,
-    '<': 1,
-    '<=': 1,
-    '&': 2,
-    '+': 3,
-    '-': 3,
-    '*': 4,
-    '/': 4,
-    '^': 5,
-};
-function assertNever(value) {
-    throw new Error(`Unexpected value: ${String(value)}`);
-}
-const ERROR_LITERAL_TEXT = {
-    [ErrorCode.Ref]: '#REF!',
-    [ErrorCode.Name]: '#NAME?',
-    [ErrorCode.Div0]: '#DIV/0!',
-    [ErrorCode.NA]: '#N/A',
-    [ErrorCode.Value]: '#VALUE!',
-    [ErrorCode.Cycle]: '#CYCLE!',
-    [ErrorCode.Spill]: '#SPILL!',
-    [ErrorCode.Blocked]: '#BLOCKED!',
-};
+import { serializeFormula } from './formula-serializer.js';
+import { buildRelativeFormulaTemplateAstKey } from './formula-template-key.js';
+import { renameCompiledFormulaSheetReferenceMetadata as renameCompiledFormulaSheetReferenceMetadataImpl, renameCompiledFormulaSheetReferenceMetadataInPlace as renameCompiledFormulaSheetReferenceMetadataInPlaceImpl, renameCompiledFormulaSheetReferences as renameCompiledFormulaSheetReferencesImpl, renameFormulaSheetReferences as renameFormulaSheetReferencesImpl, } from './formula-sheet-rename.js';
+import { buildTranslatedCellReferenceMap, buildTranslatedRangeReferenceMap, formatParsedCellReference, formatParsedDependencyReference, formatParsedLocalCellReference, formatParsedRangeReference, translatedCellInstructionKey, translatedRangeInstructionKey, translateCellReference, translateColumnReference, translateParsedCellReference, translateParsedDependencyReference, translateParsedRangeReference, translateQualifiedCellReference, translateQualifiedDependencyReference, translateQualifiedRangeReference, translateRangeAddress, translateRowReference, } from './formula-reference-translation.js';
+import { quoteSheetNameIfNeeded } from './translation-reference-utils.js';
+export { rewriteAddressForStructuralTransform, rewriteCompiledFormulaForStructuralTransform, rewriteFormulaForStructuralTransform, rewriteRangeForStructuralTransform, } from './formula-structural-rewrite.js';
+export { serializeFormula } from './formula-serializer.js';
 export function translateFormulaReferences(source, rowDelta, colDelta) {
     const ast = parseFormula(source);
     return serializeFormula(translateNode(ast, rowDelta, colDelta));
@@ -40,7 +16,7 @@ export function buildRelativeFormulaTemplateKey(source, ownerRow, ownerCol) {
     return buildRelativeFormulaTemplateKeyFromAst(parseFormula(source), ownerRow, ownerCol);
 }
 export function buildRelativeFormulaTemplateKeyFromAst(node, ownerRow, ownerCol) {
-    return buildRelativeFormulaTemplateKeyInternal(node, ownerRow, ownerCol);
+    return buildRelativeFormulaTemplateAstKey(node, ownerRow, ownerCol);
 }
 export function canTranslateCompiledFormulaWithoutAst(compiled) {
     return ((compiled.symbolicRanges.length === 0 || compiled.directAggregateCandidate !== undefined) &&
@@ -110,220 +86,17 @@ export function translateCompiledFormula(compiled, rowDelta, colDelta, sourceOve
         },
     };
 }
-export function rewriteFormulaForStructuralTransform(source, ownerSheetName, targetSheetName, transform) {
-    const ast = parseFormula(source);
-    return serializeFormula(rewriteNodeForStructuralTransform(ast, ownerSheetName, targetSheetName, transform));
-}
-export function rewriteCompiledFormulaForStructuralTransform(compiled, ownerSheetName, targetSheetName, transform) {
-    const currentAst = compiled.astMatchesSource === false ? parseFormula(compiled.source) : compiled.ast;
-    const currentOptimizedAst = compiled.astMatchesSource === false ? currentAst : compiled.optimizedAst === compiled.ast ? currentAst : compiled.optimizedAst;
-    const rewrittenAst = rewriteNodeForStructuralTransform(currentAst, ownerSheetName, targetSheetName, transform);
-    const rewrittenOptimizedAst = currentOptimizedAst === currentAst
-        ? rewrittenAst
-        : rewriteNodeForStructuralTransform(currentOptimizedAst, ownerSheetName, targetSheetName, transform);
-    const source = serializeFormula(rewrittenAst);
-    if (!nodeStructuralShapeEqual(currentOptimizedAst, rewrittenOptimizedAst)) {
-        return {
-            source,
-            compiled: compileFormulaAst(source, rewrittenOptimizedAst, {
-                originalAst: rewrittenAst,
-                symbolicNames: compiled.symbolicNames,
-                symbolicTables: compiled.symbolicTables,
-                symbolicSpills: compiled.symbolicSpills,
-            }),
-            reusedProgram: false,
-        };
-    }
-    return {
-        source,
-        compiled: {
-            ...compiled,
-            source,
-            ast: rewrittenAst,
-            optimizedAst: rewrittenOptimizedAst,
-            astMatchesSource: true,
-            deps: compiled.deps.map((dependency) => rewriteQualifiedDependencyReference(dependency, ownerSheetName, targetSheetName, transform)),
-            symbolicRefs: compiled.symbolicRefs.map((ref) => rewriteQualifiedCellReference(ref, ownerSheetName, targetSheetName, transform)),
-            symbolicRanges: compiled.symbolicRanges.map((range) => rewriteQualifiedRangeReference(range, ownerSheetName, targetSheetName, transform)),
-            jsPlan: compiled.jsPlan.map((instruction) => rewriteJsPlanInstruction(instruction, ownerSheetName, targetSheetName, transform)),
-            ...(compiled.parsedDeps
-                ? {
-                    parsedDeps: compiled.parsedDeps.map((dependency) => rewriteParsedDependencyReference(dependency, ownerSheetName, targetSheetName, transform)),
-                }
-                : {}),
-            ...(compiled.parsedSymbolicRefs
-                ? {
-                    parsedSymbolicRefs: compiled.parsedSymbolicRefs.map((ref) => rewriteParsedCellReference(ref, ownerSheetName, targetSheetName, transform)),
-                }
-                : {}),
-            ...(compiled.parsedSymbolicRanges
-                ? {
-                    parsedSymbolicRanges: compiled.parsedSymbolicRanges.map((range) => rewriteParsedRangeReference(range, ownerSheetName, targetSheetName, transform)),
-                }
-                : {}),
-        },
-        reusedProgram: true,
-    };
-}
 export function renameFormulaSheetReferences(source, oldSheetName, newSheetName) {
-    const ast = parseFormula(source);
-    return serializeFormula(renameNodeSheetReferences(ast, oldSheetName, newSheetName));
+    return renameFormulaSheetReferencesImpl(source, oldSheetName, newSheetName);
 }
 export function renameCompiledFormulaSheetReferences(compiled, oldSheetName, newSheetName) {
-    const currentAst = compiled.astMatchesSource === false ? parseFormula(compiled.source) : compiled.ast;
-    const currentOptimizedAst = compiled.astMatchesSource === false ? currentAst : compiled.optimizedAst === compiled.ast ? currentAst : compiled.optimizedAst;
-    const renamedAst = renameNodeSheetReferences(currentAst, oldSheetName, newSheetName);
-    const renamedOptimizedAst = currentOptimizedAst === currentAst ? renamedAst : renameNodeSheetReferences(currentOptimizedAst, oldSheetName, newSheetName);
-    const source = serializeFormula(renamedAst);
-    return {
-        source,
-        compiled: {
-            ...compiled,
-            source,
-            ast: renamedAst,
-            optimizedAst: renamedOptimizedAst,
-            astMatchesSource: true,
-            deps: compiled.deps.map((dependency) => renameQualifiedReferenceSheet(dependency, oldSheetName, newSheetName)),
-            ...(compiled.parsedDeps
-                ? {
-                    parsedDeps: compiled.parsedDeps.map((dependency) => renameParsedDependencySheet(dependency, oldSheetName, newSheetName)),
-                }
-                : {}),
-            jsPlan: renameJsPlanSheetReferences(compiled.jsPlan, oldSheetName, newSheetName),
-            symbolicRefs: compiled.symbolicRefs.map((reference) => renameQualifiedReferenceSheet(reference, oldSheetName, newSheetName)),
-            ...(compiled.parsedSymbolicRefs
-                ? {
-                    parsedSymbolicRefs: compiled.parsedSymbolicRefs.map((reference) => renameParsedCellReferenceSheet(reference, oldSheetName, newSheetName)),
-                }
-                : {}),
-            symbolicRanges: compiled.symbolicRanges.map((reference) => renameQualifiedReferenceSheet(reference, oldSheetName, newSheetName)),
-            ...(compiled.parsedSymbolicRanges
-                ? {
-                    parsedSymbolicRanges: compiled.parsedSymbolicRanges.map((reference) => renameParsedRangeReferenceSheet(reference, oldSheetName, newSheetName)),
-                }
-                : {}),
-        },
-        reusedProgram: true,
-    };
-}
-function renameArraySheetReferences(values, rename) {
-    let changed = false;
-    const next = values.map((value) => {
-        const renamed = rename(value);
-        if (renamed !== value) {
-            changed = true;
-        }
-        return renamed;
-    });
-    return { values: next, changed };
+    return renameCompiledFormulaSheetReferencesImpl(compiled, oldSheetName, newSheetName);
 }
 export function renameCompiledFormulaSheetReferenceMetadata(compiled, oldSheetName, newSheetName) {
-    const deps = renameArraySheetReferences(compiled.deps, (dependency) => renameQualifiedReferenceSheet(dependency, oldSheetName, newSheetName));
-    const symbolicRefs = renameArraySheetReferences(compiled.symbolicRefs, (reference) => renameQualifiedReferenceSheet(reference, oldSheetName, newSheetName));
-    const symbolicRanges = renameArraySheetReferences(compiled.symbolicRanges, (reference) => renameQualifiedReferenceSheet(reference, oldSheetName, newSheetName));
-    const parsedDeps = compiled.parsedDeps
-        ? renameArraySheetReferences(compiled.parsedDeps, (dependency) => renameParsedDependencySheet(dependency, oldSheetName, newSheetName))
-        : undefined;
-    const parsedSymbolicRefs = compiled.parsedSymbolicRefs
-        ? renameArraySheetReferences(compiled.parsedSymbolicRefs, (reference) => renameParsedCellReferenceSheet(reference, oldSheetName, newSheetName))
-        : undefined;
-    const parsedSymbolicRanges = compiled.parsedSymbolicRanges
-        ? renameArraySheetReferences(compiled.parsedSymbolicRanges, (reference) => renameParsedRangeReferenceSheet(reference, oldSheetName, newSheetName))
-        : undefined;
-    const jsPlan = renameJsPlanSheetReferences(compiled.jsPlan, oldSheetName, newSheetName);
-    return {
-        compiled: {
-            ...compiled,
-            astMatchesSource: false,
-            deps: deps.values,
-            ...(parsedDeps ? { parsedDeps: parsedDeps.values } : {}),
-            jsPlan,
-            symbolicRefs: symbolicRefs.values,
-            ...(parsedSymbolicRefs ? { parsedSymbolicRefs: parsedSymbolicRefs.values } : {}),
-            symbolicRanges: symbolicRanges.values,
-            ...(parsedSymbolicRanges ? { parsedSymbolicRanges: parsedSymbolicRanges.values } : {}),
-        },
-        sourceChanged: deps.changed ||
-            symbolicRefs.changed ||
-            symbolicRanges.changed ||
-            (parsedDeps?.changed ?? false) ||
-            (parsedSymbolicRefs?.changed ?? false) ||
-            (parsedSymbolicRanges?.changed ?? false),
-    };
+    return renameCompiledFormulaSheetReferenceMetadataImpl(compiled, oldSheetName, newSheetName);
 }
 export function renameCompiledFormulaSheetReferenceMetadataInPlace(compiled, oldSheetName, newSheetName) {
-    let sourceChanged = false;
-    const renameStringArrayInPlace = (values) => {
-        for (let index = 0; index < values.length; index += 1) {
-            const value = values[index];
-            const renamed = renameQualifiedReferenceSheet(value, oldSheetName, newSheetName);
-            if (renamed !== value) {
-                values[index] = renamed;
-                sourceChanged = true;
-            }
-        }
-    };
-    renameStringArrayInPlace(compiled.deps);
-    renameStringArrayInPlace(compiled.symbolicRefs);
-    renameStringArrayInPlace(compiled.symbolicRanges);
-    compiled.parsedDeps?.forEach((dependency) => {
-        const previousSheetName = dependency.sheetName;
-        if (previousSheetName === oldSheetName) {
-            dependency.sheetName = newSheetName;
-            sourceChanged = true;
-        }
-    });
-    compiled.parsedSymbolicRefs?.forEach((reference) => {
-        if (reference.sheetName === oldSheetName) {
-            reference.sheetName = newSheetName;
-            sourceChanged = true;
-        }
-    });
-    compiled.parsedSymbolicRanges?.forEach((reference) => {
-        if (reference.sheetName === oldSheetName) {
-            reference.sheetName = newSheetName;
-            sourceChanged = true;
-        }
-    });
-    if (compiled.jsPlan.length > 0) {
-        compiled.jsPlan = renameJsPlanSheetReferences(compiled.jsPlan, oldSheetName, newSheetName);
-    }
-    if (sourceChanged) {
-        compiled.astMatchesSource = false;
-    }
-    return sourceChanged;
-}
-export function rewriteAddressForStructuralTransform(address, transform) {
-    const parsed = parseCellReferenceParts(address);
-    if (!parsed) {
-        throw new Error(`Invalid cell reference '${address}'`);
-    }
-    const nextRow = transform.axis === 'row' ? mapPointIndex(parsed.row, transform) : parsed.row;
-    const nextCol = transform.axis === 'column' ? mapPointIndex(parsed.col, transform) : parsed.col;
-    if (nextRow === undefined || nextCol === undefined) {
-        return undefined;
-    }
-    return formatCellReference(parsed, nextRow, nextCol);
-}
-export function rewriteRangeForStructuralTransform(startAddress, endAddress, transform) {
-    const start = parseCellReferenceParts(startAddress);
-    const end = parseCellReferenceParts(endAddress);
-    if (!start || !end) {
-        throw new Error(`Invalid range reference '${startAddress}:${endAddress}'`);
-    }
-    const nextRows = transform.axis === 'row'
-        ? mapInterval(Math.min(start.row, end.row), Math.max(start.row, end.row), transform)
-        : { start: Math.min(start.row, end.row), end: Math.max(start.row, end.row) };
-    const nextCols = transform.axis === 'column'
-        ? mapInterval(Math.min(start.col, end.col), Math.max(start.col, end.col), transform)
-        : { start: Math.min(start.col, end.col), end: Math.max(start.col, end.col) };
-    if (!nextRows || !nextCols) {
-        return undefined;
-    }
-    return {
-        startAddress: formatCellReference(start, nextRows.start, nextCols.start),
-        endAddress: formatCellReference(end, nextRows.end, nextCols.end),
-    };
+    return renameCompiledFormulaSheetReferenceMetadataInPlaceImpl(compiled, oldSheetName, newSheetName);
 }
 function translateNode(node, rowDelta, colDelta) {
     switch (node.kind) {
@@ -392,754 +165,6 @@ function translateNode(node, rowDelta, colDelta) {
             };
     }
 }
-function buildRelativeFormulaTemplateKeyInternal(node, ownerRow, ownerCol) {
-    switch (node.kind) {
-        case 'NumberLiteral':
-            return `n:${node.value}`;
-        case 'BooleanLiteral':
-            return node.value ? 'b:1' : 'b:0';
-        case 'StringLiteral':
-            return `s:${JSON.stringify(node.value)}`;
-        case 'ErrorLiteral':
-            return `e:${node.code}`;
-        case 'NameRef':
-            return `name:${node.name}`;
-        case 'StructuredRef':
-            return `table:${node.tableName}[${node.columnName}]`;
-        case 'CellRef':
-            return `cell:${templateSheetKey(node.sheetName)}:${buildRelativeCellReferenceKey(node.ref, ownerRow, ownerCol)}`;
-        case 'SpillRef':
-            return `spill:${templateSheetKey(node.sheetName)}:${buildRelativeCellReferenceKey(node.ref, ownerRow, ownerCol)}`;
-        case 'ColumnRef':
-            return `col:${templateSheetKey(node.sheetName)}:${buildRelativeAxisReferenceKey(node.ref, ownerCol, 'column')}`;
-        case 'RowRef':
-            return `row:${templateSheetKey(node.sheetName)}:${buildRelativeAxisReferenceKey(node.ref, ownerRow, 'row')}`;
-        case 'RangeRef':
-            return `range:${node.refKind}:${templateSheetKey(node.sheetName)}:${buildRelativeRangeReferenceKey(node, ownerRow, ownerCol)}`;
-        case 'UnaryExpr':
-            return `unary:${node.operator}:${buildRelativeFormulaTemplateKeyInternal(node.argument, ownerRow, ownerCol)}`;
-        case 'BinaryExpr':
-            return `binary:${node.operator}:${buildRelativeFormulaTemplateKeyInternal(node.left, ownerRow, ownerCol)}:${buildRelativeFormulaTemplateKeyInternal(node.right, ownerRow, ownerCol)}`;
-        case 'CallExpr':
-            return `call:${node.callee}:${node.args.map((arg) => buildRelativeFormulaTemplateKeyInternal(arg, ownerRow, ownerCol)).join('|')}`;
-        case 'InvokeExpr':
-            return `invoke:${buildRelativeFormulaTemplateKeyInternal(node.callee, ownerRow, ownerCol)}:${node.args.map((arg) => buildRelativeFormulaTemplateKeyInternal(arg, ownerRow, ownerCol)).join('|')}`;
-    }
-}
-function rewriteNodeForStructuralTransform(node, ownerSheetName, targetSheetName, transform) {
-    switch (node.kind) {
-        case 'NumberLiteral':
-        case 'BooleanLiteral':
-        case 'StringLiteral':
-        case 'ErrorLiteral':
-        case 'NameRef':
-        case 'StructuredRef':
-            return node;
-        case 'CellRef':
-            return rewriteCellLikeNode(node, ownerSheetName, targetSheetName, transform);
-        case 'SpillRef':
-            return rewriteCellLikeNode(node, ownerSheetName, targetSheetName, transform);
-        case 'ColumnRef':
-            if (!targetsSheet(node.sheetName, ownerSheetName, targetSheetName) || transform.axis !== 'column') {
-                return node;
-            }
-            return rewriteAxisNode(node, transform);
-        case 'RowRef':
-            if (!targetsSheet(node.sheetName, ownerSheetName, targetSheetName) || transform.axis !== 'row') {
-                return node;
-            }
-            return rewriteAxisNode(node, transform);
-        case 'RangeRef':
-            return rewriteRangeNode(node, ownerSheetName, targetSheetName, transform);
-        case 'UnaryExpr':
-            return {
-                ...node,
-                argument: rewriteNodeForStructuralTransform(node.argument, ownerSheetName, targetSheetName, transform),
-            };
-        case 'BinaryExpr':
-            return {
-                ...node,
-                left: rewriteNodeForStructuralTransform(node.left, ownerSheetName, targetSheetName, transform),
-                right: rewriteNodeForStructuralTransform(node.right, ownerSheetName, targetSheetName, transform),
-            };
-        case 'CallExpr':
-            return {
-                ...node,
-                args: node.args.map((arg) => rewriteNodeForStructuralTransform(arg, ownerSheetName, targetSheetName, transform)),
-            };
-        case 'InvokeExpr':
-            return {
-                ...node,
-                callee: rewriteNodeForStructuralTransform(node.callee, ownerSheetName, targetSheetName, transform),
-                args: node.args.map((arg) => rewriteNodeForStructuralTransform(arg, ownerSheetName, targetSheetName, transform)),
-            };
-    }
-}
-function templateSheetKey(sheetName) {
-    return sheetName === undefined ? '.' : JSON.stringify(sheetName);
-}
-function buildRelativeCellReferenceKey(ref, ownerRow, ownerCol) {
-    const parsed = parseCellReferenceParts(ref);
-    if (!parsed) {
-        return `invalid:${ref}`;
-    }
-    const colKey = parsed.colAbsolute ? `ac${parsed.col}` : `rc${parsed.col - ownerCol}`;
-    const rowKey = parsed.rowAbsolute ? `ar${parsed.row}` : `rr${parsed.row - ownerRow}`;
-    return `${colKey}:${rowKey}`;
-}
-function buildRelativeAxisReferenceKey(ref, ownerIndex, kind) {
-    const parsed = parseAxisReferenceParts(ref, kind);
-    if (!parsed) {
-        return `invalid:${ref}`;
-    }
-    return parsed.absolute ? `a${parsed.index}` : `r${parsed.index - ownerIndex}`;
-}
-function buildRelativeRangeReferenceKey(node, ownerRow, ownerCol) {
-    switch (node.refKind) {
-        case 'cells':
-            return `${buildRelativeCellReferenceKey(node.start, ownerRow, ownerCol)}:${buildRelativeCellReferenceKey(node.end, ownerRow, ownerCol)}`;
-        case 'rows':
-            return `${buildRelativeAxisReferenceKey(node.start, ownerRow, 'row')}:${buildRelativeAxisReferenceKey(node.end, ownerRow, 'row')}`;
-        case 'cols':
-            return `${buildRelativeAxisReferenceKey(node.start, ownerCol, 'column')}:${buildRelativeAxisReferenceKey(node.end, ownerCol, 'column')}`;
-    }
-}
-function nodeStructuralShapeEqual(left, right) {
-    if (left.kind !== right.kind) {
-        return false;
-    }
-    switch (left.kind) {
-        case 'NumberLiteral':
-            return right.kind === 'NumberLiteral' && left.value === right.value;
-        case 'BooleanLiteral':
-            return right.kind === 'BooleanLiteral' && left.value === right.value;
-        case 'StringLiteral':
-            return right.kind === 'StringLiteral' && left.value === right.value;
-        case 'ErrorLiteral':
-            return right.kind === 'ErrorLiteral' && left.code === right.code;
-        case 'NameRef':
-            return right.kind === 'NameRef' && left.name === right.name;
-        case 'StructuredRef':
-            return right.kind === 'StructuredRef' && left.tableName === right.tableName && left.columnName === right.columnName;
-        case 'CellRef':
-        case 'SpillRef':
-        case 'ColumnRef':
-        case 'RowRef':
-            return true;
-        case 'RangeRef':
-            return right.kind === 'RangeRef' && left.refKind === right.refKind;
-        case 'UnaryExpr':
-            return right.kind === 'UnaryExpr' && left.operator === right.operator && nodeStructuralShapeEqual(left.argument, right.argument);
-        case 'BinaryExpr':
-            return (right.kind === 'BinaryExpr' &&
-                left.operator === right.operator &&
-                nodeStructuralShapeEqual(left.left, right.left) &&
-                nodeStructuralShapeEqual(left.right, right.right));
-        case 'CallExpr':
-            return (right.kind === 'CallExpr' &&
-                left.callee === right.callee &&
-                left.args.length === right.args.length &&
-                left.args.every((arg, index) => nodeStructuralShapeEqual(arg, right.args[index])));
-        case 'InvokeExpr':
-            return (right.kind === 'InvokeExpr' &&
-                left.args.length === right.args.length &&
-                nodeStructuralShapeEqual(left.callee, right.callee) &&
-                left.args.every((arg, index) => nodeStructuralShapeEqual(arg, right.args[index])));
-    }
-}
-function renameNodeSheetReferences(node, oldSheetName, newSheetName) {
-    switch (node.kind) {
-        case 'NumberLiteral':
-        case 'BooleanLiteral':
-        case 'StringLiteral':
-        case 'ErrorLiteral':
-        case 'NameRef':
-        case 'StructuredRef':
-            return node;
-        case 'CellRef':
-        case 'SpillRef':
-        case 'RowRef':
-        case 'ColumnRef':
-        case 'RangeRef':
-            return {
-                ...node,
-                ...(node.sheetName === oldSheetName ? { sheetName: newSheetName } : {}),
-            };
-        case 'UnaryExpr':
-            return {
-                ...node,
-                argument: renameNodeSheetReferences(node.argument, oldSheetName, newSheetName),
-            };
-        case 'BinaryExpr':
-            return {
-                ...node,
-                left: renameNodeSheetReferences(node.left, oldSheetName, newSheetName),
-                right: renameNodeSheetReferences(node.right, oldSheetName, newSheetName),
-            };
-        case 'CallExpr':
-            return {
-                ...node,
-                args: node.args.map((arg) => renameNodeSheetReferences(arg, oldSheetName, newSheetName)),
-            };
-        case 'InvokeExpr':
-            return {
-                ...node,
-                callee: renameNodeSheetReferences(node.callee, oldSheetName, newSheetName),
-                args: node.args.map((arg) => renameNodeSheetReferences(arg, oldSheetName, newSheetName)),
-            };
-    }
-}
-function renameQualifiedReferenceSheet(reference, oldSheetName, newSheetName) {
-    const oldPrefix = `${quoteSheetNameIfNeeded(oldSheetName)}!`;
-    if (!reference.startsWith(oldPrefix)) {
-        return reference;
-    }
-    return `${quoteSheetNameIfNeeded(newSheetName)}!${reference.slice(oldPrefix.length)}`;
-}
-function renameParsedCellReferenceSheet(reference, oldSheetName, newSheetName) {
-    return reference.sheetName === oldSheetName ? { ...reference, sheetName: newSheetName } : reference;
-}
-function renameParsedRangeReferenceSheet(reference, oldSheetName, newSheetName) {
-    return reference.sheetName === oldSheetName
-        ? {
-            ...reference,
-            sheetName: newSheetName,
-            address: formatQualifiedRangeReference(newSheetName, reference.startAddress, reference.endAddress),
-        }
-        : reference;
-}
-function renameParsedDependencySheet(dependency, oldSheetName, newSheetName) {
-    return dependency.kind === 'cell'
-        ? renameParsedCellReferenceSheet(dependency, oldSheetName, newSheetName)
-        : renameParsedRangeReferenceSheet(dependency, oldSheetName, newSheetName);
-}
-function renameReferenceOperandSheet(operand, oldSheetName, newSheetName) {
-    return operand?.sheetName === oldSheetName ? { ...operand, sheetName: newSheetName } : operand;
-}
-function renameJsPlanSheetReferences(plan, oldSheetName, newSheetName) {
-    return plan.map((instruction) => {
-        switch (instruction.opcode) {
-            case 'push-cell':
-            case 'push-range':
-            case 'lookup-exact-match':
-            case 'lookup-approximate-match':
-                return instruction.sheetName === oldSheetName ? { ...instruction, sheetName: newSheetName } : instruction;
-            case 'push-lambda':
-                return { ...instruction, body: renameJsPlanSheetReferences(instruction.body, oldSheetName, newSheetName) };
-            case 'call':
-                return instruction.argRefs
-                    ? {
-                        ...instruction,
-                        argRefs: instruction.argRefs.map((operand) => renameReferenceOperandSheet(operand, oldSheetName, newSheetName)),
-                    }
-                    : instruction;
-            case 'begin-scope':
-            case 'binary':
-            case 'bind-name':
-            case 'end-scope':
-            case 'invoke':
-            case 'jump':
-            case 'jump-if-false':
-            case 'push-boolean':
-            case 'push-error':
-            case 'push-name':
-            case 'push-number':
-            case 'push-string':
-            case 'return':
-            case 'unary':
-                return instruction;
-            default:
-                return instruction;
-        }
-    });
-}
-function rewriteCellLikeNode(node, ownerSheetName, targetSheetName, transform) {
-    if (!targetsSheet(node.sheetName, ownerSheetName, targetSheetName)) {
-        return node;
-    }
-    const parsed = parseCellReferenceParts(node.ref);
-    if (!parsed) {
-        return { kind: 'ErrorLiteral', code: ErrorCode.Ref };
-    }
-    const nextRow = transform.axis === 'row' ? mapPointIndex(parsed.row, transform) : parsed.row;
-    const nextCol = transform.axis === 'column' ? mapPointIndex(parsed.col, transform) : parsed.col;
-    if (nextRow === undefined || nextCol === undefined) {
-        return { kind: 'ErrorLiteral', code: ErrorCode.Ref };
-    }
-    return {
-        ...node,
-        ref: formatCellReference(parsed, nextRow, nextCol),
-    };
-}
-function rewriteAxisNode(node, transform) {
-    const parsed = parseAxisReferenceParts(node.ref, node.kind === 'RowRef' ? 'row' : 'column');
-    if (!parsed) {
-        return { kind: 'ErrorLiteral', code: ErrorCode.Ref };
-    }
-    const nextIndex = mapPointIndex(parsed.index, transform);
-    if (nextIndex === undefined) {
-        return { kind: 'ErrorLiteral', code: ErrorCode.Ref };
-    }
-    return {
-        ...node,
-        ref: formatAxisReference(parsed.absolute, nextIndex, node.kind === 'RowRef' ? 'row' : 'column'),
-    };
-}
-function rewriteRangeNode(node, ownerSheetName, targetSheetName, transform) {
-    if (!targetsSheet(node.sheetName, ownerSheetName, targetSheetName)) {
-        return node;
-    }
-    if ((node.refKind === 'rows' && transform.axis === 'column') || (node.refKind === 'cols' && transform.axis === 'row')) {
-        return node;
-    }
-    if (node.refKind === 'cells') {
-        const start = parseCellReferenceParts(node.start);
-        const end = parseCellReferenceParts(node.end);
-        if (!start || !end) {
-            return { kind: 'ErrorLiteral', code: ErrorCode.Ref };
-        }
-        const nextRows = transform.axis === 'row'
-            ? mapInterval(Math.min(start.row, end.row), Math.max(start.row, end.row), transform)
-            : { start: Math.min(start.row, end.row), end: Math.max(start.row, end.row) };
-        const nextCols = transform.axis === 'column'
-            ? mapInterval(Math.min(start.col, end.col), Math.max(start.col, end.col), transform)
-            : { start: Math.min(start.col, end.col), end: Math.max(start.col, end.col) };
-        if (!nextRows || !nextCols) {
-            return { kind: 'ErrorLiteral', code: ErrorCode.Ref };
-        }
-        return {
-            ...node,
-            start: formatCellReference(start, nextRows.start, nextCols.start),
-            end: formatCellReference(end, nextRows.end, nextCols.end),
-        };
-    }
-    const start = parseAxisReferenceParts(node.start, node.refKind === 'rows' ? 'row' : 'column');
-    const end = parseAxisReferenceParts(node.end, node.refKind === 'rows' ? 'row' : 'column');
-    if (!start || !end) {
-        return { kind: 'ErrorLiteral', code: ErrorCode.Ref };
-    }
-    const nextInterval = mapInterval(Math.min(start.index, end.index), Math.max(start.index, end.index), transform);
-    if (!nextInterval) {
-        return { kind: 'ErrorLiteral', code: ErrorCode.Ref };
-    }
-    return {
-        ...node,
-        start: formatAxisReference(start.absolute, nextInterval.start, node.refKind === 'rows' ? 'row' : 'column'),
-        end: formatAxisReference(end.absolute, nextInterval.end, node.refKind === 'rows' ? 'row' : 'column'),
-    };
-}
-function rewriteParsedCellReference(reference, ownerSheetName, targetSheetName, transform) {
-    const sheetName = reference.sheetName ?? ownerSheetName;
-    if (sheetName !== targetSheetName) {
-        return reference;
-    }
-    const nextAddress = rewriteAddressForStructuralTransform(reference.address, transform);
-    if (!nextAddress) {
-        return reference;
-    }
-    const parsed = parseCellAddress(nextAddress, sheetName);
-    return {
-        ...reference,
-        address: parsed.text,
-        ...(reference.sheetName !== undefined ? { sheetName: parsed.sheetName } : {}),
-        ...(reference.row !== undefined ? { row: parsed.row } : {}),
-        ...(reference.col !== undefined ? { col: parsed.col } : {}),
-    };
-}
-function rewriteParsedRangeReference(reference, ownerSheetName, targetSheetName, transform) {
-    const explicitSheetName = reference.sheetName;
-    if (!targetsSheet(explicitSheetName, ownerSheetName, targetSheetName)) {
-        return reference;
-    }
-    const nextRange = rewriteRangeAddressForStructuralTransform(parseRangeAddress(formatQualifiedRangeReference(explicitSheetName, reference.startAddress, reference.endAddress)), transform);
-    if (!nextRange) {
-        return reference;
-    }
-    const bounds = nextRange.kind === 'cells'
-        ? {
-            startRow: nextRange.start.row,
-            endRow: nextRange.end.row,
-            startCol: nextRange.start.col,
-            endCol: nextRange.end.col,
-        }
-        : nextRange.kind === 'rows'
-            ? {
-                startRow: nextRange.start.row,
-                endRow: nextRange.end.row,
-                startCol: 0,
-                endCol: 0,
-            }
-            : {
-                startRow: 0,
-                endRow: 0,
-                startCol: nextRange.start.col,
-                endCol: nextRange.end.col,
-            };
-    return {
-        ...reference,
-        address: formatQualifiedRangeReference(explicitSheetName, nextRange.start.text, nextRange.end.text),
-        refKind: nextRange.kind,
-        startAddress: nextRange.start.text,
-        endAddress: nextRange.end.text,
-        ...bounds,
-    };
-}
-function rewriteParsedDependencyReference(reference, ownerSheetName, targetSheetName, transform) {
-    return reference.kind === 'cell'
-        ? rewriteParsedCellReference(reference, ownerSheetName, targetSheetName, transform)
-        : rewriteParsedRangeReference(reference, ownerSheetName, targetSheetName, transform);
-}
-function translateParsedCellReference(reference, rowDelta, colDelta) {
-    const parts = reference.rowAbsolute !== undefined && reference.colAbsolute !== undefined && reference.row !== undefined && reference.col !== undefined
-        ? {
-            row: reference.row,
-            col: reference.col,
-            rowAbsolute: reference.rowAbsolute,
-            colAbsolute: reference.colAbsolute,
-        }
-        : parseCellReferenceParts(reference.address);
-    if (!parts) {
-        return reference;
-    }
-    const nextRow = parts.rowAbsolute ? parts.row : parts.row + rowDelta;
-    const nextCol = parts.colAbsolute ? parts.col : parts.col + colDelta;
-    const nextLocalAddress = formatCellReference(parts, nextRow, nextCol);
-    const nextAddress = reference.explicitSheet || reference.sheetName !== undefined
-        ? formatQualifiedCellReference(reference.sheetName, nextLocalAddress)
-        : nextLocalAddress;
-    return {
-        ...reference,
-        address: nextAddress,
-        ...(reference.sheetName !== undefined ? { sheetName: reference.sheetName } : {}),
-        ...(reference.explicitSheet !== undefined ? { explicitSheet: reference.explicitSheet } : {}),
-        ...(reference.row !== undefined ? { row: nextRow } : {}),
-        ...(reference.col !== undefined ? { col: nextCol } : {}),
-        ...(reference.rowAbsolute !== undefined ? { rowAbsolute: parts.rowAbsolute } : {}),
-        ...(reference.colAbsolute !== undefined ? { colAbsolute: parts.colAbsolute } : {}),
-    };
-}
-function translateParsedRangeReference(reference, rowDelta, colDelta) {
-    const nextRange = translateParsedRangeReferenceInfo(reference, rowDelta, colDelta);
-    const bounds = nextRange.refKind === 'cells'
-        ? {
-            startRow: nextRange.startRow,
-            endRow: nextRange.endRow,
-            startCol: nextRange.startCol,
-            endCol: nextRange.endCol,
-        }
-        : nextRange.refKind === 'rows'
-            ? {
-                startRow: nextRange.startRow,
-                endRow: nextRange.endRow,
-                startCol: 0,
-                endCol: 0,
-            }
-            : {
-                startRow: 0,
-                endRow: 0,
-                startCol: nextRange.startCol,
-                endCol: nextRange.endCol,
-            };
-    return {
-        ...reference,
-        address: formatParsedRangeReference(nextRange),
-        refKind: nextRange.refKind,
-        startAddress: nextRange.startAddress,
-        endAddress: nextRange.endAddress,
-        ...bounds,
-        ...(reference.explicitSheet !== undefined ? { explicitSheet: reference.explicitSheet } : {}),
-    };
-}
-function translateParsedDependencyReference(reference, rowDelta, colDelta) {
-    return reference.kind === 'cell'
-        ? translateParsedCellReference(reference, rowDelta, colDelta)
-        : translateParsedRangeReference(reference, rowDelta, colDelta);
-}
-function translateQualifiedCellReference(raw, rowDelta, colDelta) {
-    const explicitlyQualified = raw.includes('!');
-    const parsed = parseCellAddress(raw);
-    const nextAddress = translateCellReference(parsed.text, rowDelta, colDelta);
-    return explicitlyQualified ? formatQualifiedCellReference(parsed.sheetName, nextAddress) : nextAddress;
-}
-function formatParsedCellReference(reference) {
-    const localAddress = formatParsedLocalCellReference(reference);
-    return reference.explicitSheet || reference.sheetName !== undefined
-        ? formatQualifiedCellReference(reference.sheetName, localAddress)
-        : localAddress;
-}
-function formatParsedLocalCellReference(reference) {
-    const parts = reference.row !== undefined && reference.col !== undefined && reference.rowAbsolute !== undefined && reference.colAbsolute !== undefined
-        ? {
-            row: reference.row,
-            col: reference.col,
-            rowAbsolute: reference.rowAbsolute,
-            colAbsolute: reference.colAbsolute,
-        }
-        : parseCellReferenceParts(reference.address);
-    if (!parts) {
-        return stripSheetQualifier(reference.address);
-    }
-    return formatCellReference(parts, parts.row, parts.col);
-}
-function formatParsedRangeReference(reference) {
-    return formatQualifiedRangeReference(reference.explicitSheet ? reference.sheetName : undefined, reference.startAddress, reference.endAddress);
-}
-function stripSheetQualifier(reference) {
-    const bang = reference.lastIndexOf('!');
-    return bang === -1 ? reference : reference.slice(bang + 1);
-}
-function translatedCellInstructionKey(sheetName, address) {
-    return `${sheetName ?? ''}\t${address}`;
-}
-function translatedRangeInstructionKey(sheetName, refKind, start, end) {
-    return `${sheetName ?? ''}\t${refKind}\t${start}\t${end}`;
-}
-function buildTranslatedCellReferenceMap(original, translated) {
-    const output = new Map();
-    if (!original || !translated || original.length !== translated.length) {
-        return output;
-    }
-    for (let index = 0; index < original.length; index += 1) {
-        const source = original[index];
-        const target = translated[index];
-        if (!source || !target) {
-            continue;
-        }
-        output.set(translatedCellInstructionKey(source.sheetName, formatParsedLocalCellReference(source)), target);
-    }
-    return output;
-}
-function buildTranslatedRangeReferenceMap(original, translated) {
-    const output = new Map();
-    if (!original || !translated || original.length !== translated.length) {
-        return output;
-    }
-    for (let index = 0; index < original.length; index += 1) {
-        const source = original[index];
-        const target = translated[index];
-        if (!source || !target) {
-            continue;
-        }
-        output.set(translatedRangeInstructionKey(source.sheetName, source.refKind, source.startAddress, source.endAddress), target);
-    }
-    return output;
-}
-function formatParsedDependencyReference(reference) {
-    return reference.kind === 'cell' ? formatParsedCellReference(reference) : formatParsedRangeReference(reference);
-}
-function translateQualifiedDependencyReference(raw, rowDelta, colDelta) {
-    if (!raw.includes(':')) {
-        return translateQualifiedCellReference(raw, rowDelta, colDelta);
-    }
-    return translateQualifiedRangeReference(raw, rowDelta, colDelta);
-}
-function translateQualifiedRangeReference(raw, rowDelta, colDelta) {
-    const explicitlyQualified = raw.includes('!');
-    const parsed = parseRangeAddress(raw);
-    const nextRange = translateRangeAddress(parsed, rowDelta, colDelta);
-    if (explicitlyQualified) {
-        return formatRangeAddress(nextRange);
-    }
-    return `${nextRange.start.text}:${nextRange.end.text}`;
-}
-function translateRangeAddress(range, rowDelta, colDelta) {
-    switch (range.kind) {
-        case 'cells': {
-            const startAddress = translateCellReference(range.start.text, rowDelta, colDelta);
-            const endAddress = translateCellReference(range.end.text, rowDelta, colDelta);
-            return parseRangeAddress(formatQualifiedRangeReference(range.sheetName, startAddress, endAddress));
-        }
-        case 'rows': {
-            const start = translateRowReference(range.start.text, rowDelta);
-            const end = translateRowReference(range.end.text, rowDelta);
-            return parseRangeAddress(formatQualifiedRangeReference(range.sheetName, start, end));
-        }
-        case 'cols': {
-            const start = translateColumnReference(range.start.text, colDelta);
-            const end = translateColumnReference(range.end.text, colDelta);
-            return parseRangeAddress(formatQualifiedRangeReference(range.sheetName, start, end));
-        }
-    }
-}
-function translateParsedRangeReferenceInfo(reference, rowDelta, colDelta) {
-    if (reference.refKind === 'cells') {
-        const startRow = (reference.startRowAbsolute ?? false) ? reference.startRow : reference.startRow + rowDelta;
-        const endRow = (reference.endRowAbsolute ?? false) ? reference.endRow : reference.endRow + rowDelta;
-        const startCol = (reference.startColAbsolute ?? false) ? reference.startCol : reference.startCol + colDelta;
-        const endCol = (reference.endColAbsolute ?? false) ? reference.endCol : reference.endCol + colDelta;
-        const startAddress = formatCellReference({
-            row: reference.startRow,
-            col: reference.startCol,
-            rowAbsolute: reference.startRowAbsolute ?? false,
-            colAbsolute: reference.startColAbsolute ?? false,
-        }, startRow, startCol);
-        const endAddress = formatCellReference({
-            row: reference.endRow,
-            col: reference.endCol,
-            rowAbsolute: reference.endRowAbsolute ?? false,
-            colAbsolute: reference.endColAbsolute ?? false,
-        }, endRow, endCol);
-        return {
-            ...reference,
-            startAddress,
-            endAddress,
-            startRow,
-            endRow,
-            startCol,
-            endCol,
-        };
-    }
-    if (reference.refKind === 'rows') {
-        const startRow = (reference.startRowAbsolute ?? false) ? reference.startRow : reference.startRow + rowDelta;
-        const endRow = (reference.endRowAbsolute ?? false) ? reference.endRow : reference.endRow + rowDelta;
-        return {
-            ...reference,
-            startAddress: formatAxisReference(reference.startRowAbsolute ?? false, startRow, 'row'),
-            endAddress: formatAxisReference(reference.endRowAbsolute ?? false, endRow, 'row'),
-            startRow,
-            endRow,
-            startCol: 0,
-            endCol: 0,
-        };
-    }
-    const startCol = (reference.startColAbsolute ?? false) ? reference.startCol : reference.startCol + colDelta;
-    const endCol = (reference.endColAbsolute ?? false) ? reference.endCol : reference.endCol + colDelta;
-    return {
-        ...reference,
-        startAddress: formatAxisReference(reference.startColAbsolute ?? false, startCol, 'column'),
-        endAddress: formatAxisReference(reference.endColAbsolute ?? false, endCol, 'column'),
-        startRow: 0,
-        endRow: 0,
-        startCol,
-        endCol,
-    };
-}
-function rewriteQualifiedCellReference(raw, ownerSheetName, targetSheetName, transform) {
-    const explicitlyQualified = raw.includes('!');
-    const parsed = parseCellAddress(raw, ownerSheetName);
-    if (parsed.sheetName !== targetSheetName) {
-        return raw;
-    }
-    const nextAddress = rewriteAddressForStructuralTransform(parsed.text, transform);
-    if (!nextAddress) {
-        return raw;
-    }
-    return explicitlyQualified ? formatQualifiedCellReference(parsed.sheetName, nextAddress) : nextAddress;
-}
-function rewriteQualifiedDependencyReference(raw, ownerSheetName, targetSheetName, transform) {
-    if (!raw.includes(':')) {
-        return rewriteQualifiedCellReference(raw, ownerSheetName, targetSheetName, transform);
-    }
-    return rewriteQualifiedRangeReference(raw, ownerSheetName, targetSheetName, transform);
-}
-function rewriteQualifiedRangeReference(raw, ownerSheetName, targetSheetName, transform) {
-    const explicitlyQualified = raw.includes('!');
-    const parsed = parseRangeAddress(raw, ownerSheetName);
-    const sheetName = parsed.sheetName ?? ownerSheetName;
-    if (sheetName !== targetSheetName) {
-        return raw;
-    }
-    const nextRange = rewriteRangeAddressForStructuralTransform(parsed, transform);
-    if (!nextRange) {
-        return raw;
-    }
-    if (explicitlyQualified) {
-        return formatRangeAddress(nextRange);
-    }
-    return `${nextRange.start.text}:${nextRange.end.text}`;
-}
-function rewriteRangeAddressForStructuralTransform(range, transform) {
-    switch (range.kind) {
-        case 'cells': {
-            const nextRange = rewriteRangeForStructuralTransform(range.start.text, range.end.text, transform);
-            if (!nextRange) {
-                return undefined;
-            }
-            return parseRangeAddress(formatQualifiedRangeReference(range.sheetName, nextRange.startAddress, nextRange.endAddress));
-        }
-        case 'rows':
-            if (transform.axis !== 'row') {
-                return range;
-            }
-            return rewriteAxisRangeAddress(range, transform);
-        case 'cols':
-            if (transform.axis !== 'column') {
-                return range;
-            }
-            return rewriteAxisRangeAddress(range, transform);
-    }
-}
-function rewriteAxisRangeAddress(range, transform) {
-    const startIndex = range.kind === 'rows' ? range.start.row : range.start.col;
-    const endIndex = range.kind === 'rows' ? range.end.row : range.end.col;
-    const nextInterval = mapInterval(startIndex, endIndex, transform);
-    if (!nextInterval) {
-        return undefined;
-    }
-    const prefix = range.sheetName ? `${quoteSheetNameIfNeeded(range.sheetName)}!` : '';
-    const startText = range.kind === 'rows' ? formatAxisReference(false, nextInterval.start, 'row') : formatAxisReference(false, nextInterval.start, 'column');
-    const endText = range.kind === 'rows' ? formatAxisReference(false, nextInterval.end, 'row') : formatAxisReference(false, nextInterval.end, 'column');
-    return parseRangeAddress(`${prefix}${startText}:${endText}`);
-}
-function rewriteJsPlanInstruction(instruction, ownerSheetName, targetSheetName, transform) {
-    switch (instruction.opcode) {
-        case 'push-cell':
-            return {
-                ...instruction,
-                address: rewriteReferenceOperandAddress(instruction.sheetName, instruction.address, ownerSheetName, targetSheetName, transform),
-            };
-        case 'push-range': {
-            const nextRange = rewritePlanRangeInstruction(instruction.sheetName, instruction.start, instruction.end, instruction.refKind, ownerSheetName, targetSheetName, transform);
-            return nextRange ? { ...instruction, ...nextRange } : instruction;
-        }
-        case 'lookup-exact-match':
-        case 'lookup-approximate-match': {
-            const nextRange = rewritePlanRangeInstruction(instruction.sheetName, instruction.start, instruction.end, instruction.refKind, ownerSheetName, targetSheetName, transform);
-            if (!nextRange) {
-                return instruction;
-            }
-            const parsed = parseRangeAddress(formatQualifiedRangeReference(instruction.sheetName, nextRange.start, nextRange.end));
-            if (parsed.kind !== 'cells') {
-                return instruction;
-            }
-            return {
-                ...instruction,
-                ...nextRange,
-                startRow: parsed.start.row,
-                endRow: parsed.end.row,
-                startCol: parsed.start.col,
-                endCol: parsed.end.col,
-            };
-        }
-        case 'call':
-            return instruction.argRefs
-                ? {
-                    ...instruction,
-                    argRefs: instruction.argRefs.map((argRef) => argRef ? rewriteReferenceOperand(argRef, ownerSheetName, targetSheetName, transform) : argRef),
-                }
-                : instruction;
-        case 'push-lambda':
-            return {
-                ...instruction,
-                body: instruction.body.map((step) => rewriteJsPlanInstruction(step, ownerSheetName, targetSheetName, transform)),
-            };
-        case 'push-number':
-        case 'push-boolean':
-        case 'push-string':
-        case 'push-error':
-        case 'push-name':
-        case 'unary':
-        case 'binary':
-        case 'invoke':
-        case 'begin-scope':
-        case 'bind-name':
-        case 'end-scope':
-        case 'jump-if-false':
-        case 'jump':
-        case 'return':
-            return instruction;
-    }
-}
 function translateJsPlanInstruction(instruction, rowDelta, colDelta) {
     switch (instruction.opcode) {
         case 'push-cell':
@@ -1262,27 +287,6 @@ function translateJsPlanInstructionWithoutAst(instruction, translatedCellMap, tr
             return instruction;
     }
 }
-function rewriteReferenceOperand(operand, ownerSheetName, targetSheetName, transform) {
-    switch (operand.kind) {
-        case 'cell':
-            return operand.address
-                ? {
-                    ...operand,
-                    address: rewriteReferenceOperandAddress(operand.sheetName, operand.address, ownerSheetName, targetSheetName, transform),
-                }
-                : operand;
-        case 'range': {
-            if (!operand.start || !operand.end || !operand.refKind) {
-                return operand;
-            }
-            const nextRange = rewritePlanRangeInstruction(operand.sheetName, operand.start, operand.end, operand.refKind, ownerSheetName, targetSheetName, transform);
-            return nextRange ? { ...operand, ...nextRange } : operand;
-        }
-        case 'row':
-        case 'col':
-            return operand;
-    }
-}
 function translateReferenceOperand(operand, rowDelta, colDelta) {
     switch (operand.kind) {
         case 'cell':
@@ -1349,37 +353,6 @@ function translateReferenceOperandWithoutAst(operand, translatedCellMap, transla
             return translateReferenceOperand(operand, rowDelta, colDelta);
     }
 }
-function rewriteReferenceOperandAddress(explicitSheetName, address, ownerSheetName, targetSheetName, transform) {
-    if ((explicitSheetName ?? ownerSheetName) !== targetSheetName) {
-        return address;
-    }
-    return rewriteAddressForStructuralTransform(address, transform) ?? address;
-}
-function rewritePlanRangeInstruction(explicitSheetName, start, end, refKind, ownerSheetName, targetSheetName, transform) {
-    if ((explicitSheetName ?? ownerSheetName) !== targetSheetName) {
-        return undefined;
-    }
-    if (refKind === 'cells') {
-        const nextRange = rewriteRangeForStructuralTransform(start, end, transform);
-        return nextRange
-            ? {
-                start: nextRange.startAddress,
-                end: nextRange.endAddress,
-            }
-            : undefined;
-    }
-    if ((refKind === 'rows' && transform.axis !== 'row') || (refKind === 'cols' && transform.axis !== 'column')) {
-        return undefined;
-    }
-    const parsed = parseRangeAddress(formatQualifiedRangeReference(explicitSheetName, start, end));
-    const nextRange = rewriteRangeAddressForStructuralTransform(parsed, transform);
-    return nextRange
-        ? {
-            start: nextRange.start.text,
-            end: nextRange.end.text,
-        }
-        : undefined;
-}
 function translatePlanRangeInstruction(explicitSheetName, start, end, rowDelta, colDelta) {
     const parsed = parseRangeAddress(formatQualifiedRangeReference(explicitSheetName, start, end));
     const nextRange = translateRangeAddress(parsed, rowDelta, colDelta);
@@ -1388,267 +361,8 @@ function translatePlanRangeInstruction(explicitSheetName, start, end, rowDelta,
         end: nextRange.end.text,
     };
 }
-function formatQualifiedCellReference(sheetName, address) {
-    if (!sheetName) {
-        return address;
-    }
-    const parsed = parseCellAddress(address, sheetName);
-    return `${quoteSheetNameIfNeeded(sheetName)}!${parsed.text}`;
-}
 function formatQualifiedRangeReference(sheetName, start, end) {
     const prefix = sheetName ? `${quoteSheetNameIfNeeded(sheetName)}!` : '';
     return `${prefix}${start}:${end}`;
 }
-function translateCellReference(ref, rowDelta, colDelta) {
-    const parsed = parseCellReferenceParts(ref);
-    if (!parsed) {
-        throw new Error(`Invalid cell reference '${ref}'`);
-    }
-    const nextCol = parsed.colAbsolute ? parsed.col : parsed.col + colDelta;
-    const nextRow = parsed.rowAbsolute ? parsed.row : parsed.row + rowDelta;
-    if (nextCol < 0 || nextRow < 0) {
-        throw new Error(`Translated reference moved outside worksheet bounds: ${ref}`);
-    }
-    return formatCellReference(parsed, nextRow, nextCol);
-}
-function translateColumnReference(ref, colDelta) {
-    const parsed = parseAxisReferenceParts(ref, 'column');
-    if (!parsed) {
-        throw new Error(`Invalid column reference '${ref}'`);
-    }
-    const nextCol = parsed.absolute ? parsed.index : parsed.index + colDelta;
-    if (nextCol < 0) {
-        throw new Error(`Translated reference moved outside worksheet bounds: ${ref}`);
-    }
-    return formatAxisReference(parsed.absolute, nextCol, 'column');
-}
-function translateRowReference(ref, rowDelta) {
-    const parsed = parseAxisReferenceParts(ref, 'row');
-    if (!parsed) {
-        throw new Error(`Invalid row reference '${ref}'`);
-    }
-    const nextRow = parsed.absolute ? parsed.index : parsed.index + rowDelta;
-    if (nextRow < 0) {
-        throw new Error(`Translated reference moved outside worksheet bounds: ${ref}`);
-    }
-    return formatAxisReference(parsed.absolute, nextRow, 'row');
-}
-export function serializeFormula(node, parentPrecedence = 0, parentAssociativity = null) {
-    switch (node.kind) {
-        case 'NumberLiteral':
-            return String(node.value);
-        case 'BooleanLiteral':
-            return node.value ? 'TRUE' : 'FALSE';
-        case 'StringLiteral':
-            return `"${node.value.replaceAll('"', '""')}"`;
-        case 'ErrorLiteral':
-            return ERROR_LITERAL_TEXT[node.code] ?? '#ERROR!';
-        case 'NameRef':
-            return node.name;
-        case 'StructuredRef':
-            return `${node.tableName}[${node.columnName}]`;
-        case 'CellRef':
-            return `${formatSheetPrefix(node.sheetName)}${node.ref}`;
-        case 'SpillRef':
-            return `${formatSheetPrefix(node.sheetName)}${node.ref}#`;
-        case 'ColumnRef':
-            return `${formatSheetPrefix(node.sheetName)}${node.ref}`;
-        case 'RowRef':
-            return `${formatSheetPrefix(node.sheetName)}${node.ref}`;
-        case 'RangeRef':
-            return `${formatSheetPrefix(node.sheetName)}${node.start}:${node.end}`;
-        case 'UnaryExpr':
-            return `${node.operator}${serializeFormula(node.argument, 6)}`;
-        case 'CallExpr':
-            return `${node.callee}(${node.args.map((arg) => serializeFormula(arg)).join(',')})`;
-        case 'InvokeExpr': {
-            const callee = node.callee.kind === 'CallExpr' || node.callee.kind === 'InvokeExpr'
-                ? serializeFormula(node.callee)
-                : `(${serializeFormula(node.callee)})`;
-            return `${callee}(${node.args.map((arg) => serializeFormula(arg)).join(',')})`;
-        }
-        case 'BinaryExpr': {
-            const precedence = BINARY_PRECEDENCE[node.operator];
-            const isRightAssociative = node.operator === '^';
-            const left = serializeFormula(node.left, precedence, 'left');
-            const right = serializeFormula(node.right, precedence, 'right');
-            const output = `${left}${node.operator}${right}`;
-            const needsParens = precedence < parentPrecedence ||
-                (precedence === parentPrecedence &&
-                    ((parentAssociativity === 'left' && isRightAssociative) || (parentAssociativity === 'right' && !isRightAssociative)));
-            return needsParens ? `(${output})` : output;
-        }
-    }
-}
-function formatSheetPrefix(sheetName) {
-    if (!sheetName) {
-        return '';
-    }
-    return `${quoteSheetNameIfNeeded(sheetName)}!`;
-}
-function quoteSheetNameIfNeeded(sheetName) {
-    return /^[A-Za-z0-9_.$]+$/.test(sheetName) ? sheetName : `'${sheetName.replaceAll("'", "''")}'`;
-}
-function columnToIndex(column) {
-    let value = 0;
-    for (const char of column) {
-        value = value * 26 + (char.charCodeAt(0) - 64);
-    }
-    return value - 1;
-}
-function indexToColumn(index) {
-    let current = index + 1;
-    let output = '';
-    while (current > 0) {
-        const remainder = (current - 1) % 26;
-        output = String.fromCharCode(65 + remainder) + output;
-        current = Math.floor((current - 1) / 26);
-    }
-    return output;
-}
-function targetsSheet(explicitSheetName, ownerSheetName, targetSheetName) {
-    return (explicitSheetName ?? ownerSheetName) === targetSheetName;
-}
-function parseCellReferenceParts(ref) {
-    const match = CELL_REF_RE.exec(ref.toUpperCase());
-    if (!match) {
-        return undefined;
-    }
-    const [, colAbsolute, columnText, rowAbsolute, rowText] = match;
-    return {
-        colAbsolute: colAbsolute === '$',
-        rowAbsolute: rowAbsolute === '$',
-        col: columnToIndex(columnText),
-        row: Number.parseInt(rowText, 10) - 1,
-    };
-}
-function formatCellReference(parts, row, col) {
-    return `${parts.colAbsolute ? '$' : ''}${indexToColumn(col)}${parts.rowAbsolute ? '$' : ''}${row + 1}`;
-}
-function parseAxisReferenceParts(ref, kind) {
-    const match = (kind === 'row' ? ROW_REF_RE : COLUMN_REF_RE).exec(ref.toUpperCase());
-    if (!match) {
-        return undefined;
-    }
-    return kind === 'row'
-        ? {
-            absolute: match[1] === '$',
-            index: Number.parseInt(match[2], 10) - 1,
-        }
-        : {
-            absolute: match[1] === '$',
-            index: columnToIndex(match[2]),
-        };
-}
-function formatAxisReference(absolute, index, kind) {
-    const prefix = absolute ? '$' : '';
-    return kind === 'row' ? `${prefix}${index + 1}` : `${prefix}${indexToColumn(index)}`;
-}
-function mapPointIndex(index, transform) {
-    switch (transform.kind) {
-        case 'insert':
-            return index >= transform.start ? index + transform.count : index;
-        case 'delete':
-            if (index < transform.start) {
-                return index;
-            }
-            if (index >= transform.start + transform.count) {
-                return index - transform.count;
-            }
-            return undefined;
-        case 'move':
-            if (transform.target < transform.start) {
-                if (index >= transform.target && index < transform.start) {
-                    return index + transform.count;
-                }
-            }
-            else if (transform.target > transform.start) {
-                if (index >= transform.start + transform.count && index < transform.target + transform.count) {
-                    return index - transform.count;
-                }
-            }
-            if (index >= transform.start && index < transform.start + transform.count) {
-                return transform.target + (index - transform.start);
-            }
-            return index;
-        default:
-            return assertNever(transform);
-    }
-}
-function mapInterval(start, end, transform) {
-    switch (transform.kind) {
-        case 'insert': {
-            if (transform.start <= start) {
-                return { start: start + transform.count, end: end + transform.count };
-            }
-            if (transform.start <= end) {
-                return { start, end: end + transform.count };
-            }
-            return { start, end };
-        }
-        case 'delete': {
-            const deleteEnd = transform.start + transform.count - 1;
-            if (deleteEnd < start) {
-                return { start: start - transform.count, end: end - transform.count };
-            }
-            if (transform.start > end) {
-                return { start, end };
-            }
-            const survivingStart = start < transform.start ? start : deleteEnd + 1;
-            const survivingEnd = end > deleteEnd ? end : transform.start - 1;
-            if (survivingStart > survivingEnd) {
-                return undefined;
-            }
-            const nextStart = mapPointIndex(survivingStart, transform);
-            const nextEnd = mapPointIndex(survivingEnd, transform);
-            return nextStart === undefined || nextEnd === undefined ? undefined : { start: nextStart, end: nextEnd };
-        }
-        case 'move': {
-            const segments = transform.target < transform.start
-                ? [
-                    { start: 0, end: transform.target - 1, delta: 0 },
-                    { start: transform.target, end: transform.start - 1, delta: transform.count },
-                    {
-                        start: transform.start,
-                        end: transform.start + transform.count - 1,
-                        delta: transform.target - transform.start,
-                    },
-                    { start: transform.start + transform.count, end: Number.MAX_SAFE_INTEGER, delta: 0 },
-                ]
-                : [
-                    { start: 0, end: transform.start - 1, delta: 0 },
-                    {
-                        start: transform.start,
-                        end: transform.start + transform.count - 1,
-                        delta: transform.target - transform.start,
-                    },
-                    {
-                        start: transform.start + transform.count,
-                        end: transform.target + transform.count - 1,
-                        delta: -transform.count,
-                    },
-                    { start: transform.target + transform.count, end: Number.MAX_SAFE_INTEGER, delta: 0 },
-                ];
-            let nextStart;
-            let nextEnd;
-            segments.forEach((segment) => {
-                const overlapStart = Math.max(start, segment.start);
-                const overlapEnd = Math.min(end, segment.end);
-                if (overlapStart > overlapEnd) {
-                    return;
-                }
-                const mappedStart = overlapStart + segment.delta;
-                const mappedEnd = overlapEnd + segment.delta;
-                nextStart = nextStart === undefined ? mappedStart : Math.min(nextStart, mappedStart);
-                nextEnd = nextEnd === undefined ? mappedEnd : Math.max(nextEnd, mappedEnd);
-            });
-            if (nextStart === undefined || nextEnd === undefined) {
-                return undefined;
-            }
-            return { start: nextStart, end: nextEnd };
-        }
-        default:
-            return assertNever(transform);
-    }
-}
 //# sourceMappingURL=translation.js.map