@bilig/formula 0.1.74 → 0.1.76

package/dist/translation.js

@@ -1,4 +1,6 @@
-import { ErrorCode } from "@bilig/protocol";
+import { ErrorCode, FormulaMode } from "@bilig/protocol";
+import { formatRangeAddress, parseCellAddress, parseRangeAddress } from "./addressing.js";
+import { compileFormulaAst, } from "./compiler.js";
 import { parseFormula } from "./parser.js";
 const CELL_REF_RE = /^(\$?)([A-Z]+)(\$?)([1-9][0-9]*)$/;
 const COLUMN_REF_RE = /^(\$?)([A-Z]+)$/;
@@ -34,10 +36,141 @@ export function translateFormulaReferences(source, rowDelta, colDelta) {
     const ast = parseFormula(source);
     return serializeFormula(translateNode(ast, rowDelta, colDelta));
 }
+export function buildRelativeFormulaTemplateKey(source, ownerRow, ownerCol) {
+    return buildRelativeFormulaTemplateKeyFromAst(parseFormula(source), ownerRow, ownerCol);
+}
+export function buildRelativeFormulaTemplateKeyFromAst(node, ownerRow, ownerCol) {
+    return buildRelativeFormulaTemplateKeyInternal(node, ownerRow, ownerCol);
+}
+export function canTranslateCompiledFormulaWithoutAst(compiled) {
+    return ((compiled.symbolicRanges.length === 0 || compiled.directAggregateCandidate !== undefined) &&
+        compiled.symbolicNames.length === 0 &&
+        compiled.symbolicTables.length === 0 &&
+        compiled.symbolicSpills.length === 0 &&
+        !compiled.jsPlan.some((instruction) => instruction.opcode === "lookup-exact-match" ||
+            instruction.opcode === "lookup-approximate-match"));
+}
+export function translateCompiledFormulaWithoutAst(compiled, rowDelta, colDelta, sourceOverride) {
+    const translatedParsedDeps = compiled.parsedDeps?.map((dependency) => translateParsedDependencyReference(dependency, rowDelta, colDelta));
+    const translatedParsedSymbolicRefs = compiled.parsedSymbolicRefs?.map((reference) => translateParsedCellReference(reference, rowDelta, colDelta));
+    const translatedParsedSymbolicRanges = compiled.parsedSymbolicRanges?.map((range) => translateParsedRangeReference(range, rowDelta, colDelta));
+    const source = sourceOverride ?? compiled.source;
+    const translatedCellMap = buildTranslatedCellReferenceMap(compiled.parsedSymbolicRefs, translatedParsedSymbolicRefs);
+    const translatedRangeMap = buildTranslatedRangeReferenceMap(compiled.parsedSymbolicRanges, translatedParsedSymbolicRanges);
+    return {
+        source,
+        compiled: {
+            ...compiled,
+            source,
+            astMatchesSource: false,
+            deps: translatedParsedDeps?.map((dependency) => formatParsedDependencyReference(dependency)) ??
+                compiled.deps.map((dependency) => translateQualifiedDependencyReference(dependency, rowDelta, colDelta)),
+            symbolicRefs: translatedParsedSymbolicRefs?.map((reference) => formatParsedCellReference(reference)) ??
+                compiled.symbolicRefs.map((ref) => translateQualifiedCellReference(ref, rowDelta, colDelta)),
+            symbolicRanges: translatedParsedSymbolicRanges?.map((range) => formatParsedRangeReference(range)) ??
+                compiled.symbolicRanges.map((range) => translateQualifiedRangeReference(range, rowDelta, colDelta)),
+            jsPlan: compiled.symbolicRanges.length === 0 && compiled.mode === FormulaMode.WasmFastPath
+                ? compiled.jsPlan
+                : compiled.jsPlan.map((instruction) => translateJsPlanInstructionWithoutAst(instruction, translatedCellMap, translatedRangeMap, rowDelta, colDelta)),
+            ...(translatedParsedDeps ? { parsedDeps: translatedParsedDeps } : {}),
+            ...(translatedParsedSymbolicRefs ? { parsedSymbolicRefs: translatedParsedSymbolicRefs } : {}),
+            ...(translatedParsedSymbolicRanges
+                ? { parsedSymbolicRanges: translatedParsedSymbolicRanges }
+                : {}),
+        },
+    };
+}
+export function translateCompiledFormula(compiled, rowDelta, colDelta, sourceOverride) {
+    const translatedAst = translateNode(compiled.ast, rowDelta, colDelta);
+    const translatedOptimizedAst = compiled.optimizedAst === compiled.ast
+        ? translatedAst
+        : translateNode(compiled.optimizedAst, rowDelta, colDelta);
+    const translatedParsedDeps = compiled.parsedDeps?.map((dependency) => translateParsedDependencyReference(dependency, rowDelta, colDelta));
+    const translatedParsedSymbolicRefs = compiled.parsedSymbolicRefs?.map((reference) => translateParsedCellReference(reference, rowDelta, colDelta));
+    const translatedParsedSymbolicRanges = compiled.parsedSymbolicRanges?.map((range) => translateParsedRangeReference(range, rowDelta, colDelta));
+    const source = sourceOverride ?? serializeFormula(translatedAst);
+    return {
+        source,
+        compiled: {
+            ...compiled,
+            source,
+            ast: translatedAst,
+            optimizedAst: translatedOptimizedAst,
+            astMatchesSource: true,
+            deps: translatedParsedDeps?.map((dependency) => formatParsedDependencyReference(dependency)) ??
+                compiled.deps.map((dependency) => translateQualifiedDependencyReference(dependency, rowDelta, colDelta)),
+            symbolicRefs: translatedParsedSymbolicRefs?.map((reference) => formatParsedCellReference(reference)) ??
+                compiled.symbolicRefs.map((ref) => translateQualifiedCellReference(ref, rowDelta, colDelta)),
+            symbolicRanges: translatedParsedSymbolicRanges?.map((range) => formatParsedRangeReference(range)) ??
+                compiled.symbolicRanges.map((range) => translateQualifiedRangeReference(range, rowDelta, colDelta)),
+            jsPlan: compiled.jsPlan.map((instruction) => translateJsPlanInstruction(instruction, rowDelta, colDelta)),
+            ...(translatedParsedDeps ? { parsedDeps: translatedParsedDeps } : {}),
+            ...(translatedParsedSymbolicRefs ? { parsedSymbolicRefs: translatedParsedSymbolicRefs } : {}),
+            ...(translatedParsedSymbolicRanges
+                ? { parsedSymbolicRanges: translatedParsedSymbolicRanges }
+                : {}),
+        },
+    };
+}
 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));
@@ -141,6 +274,40 @@ 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":
@@ -192,6 +359,82 @@ function rewriteNodeForStructuralTransform(node, ownerSheetName, targetSheetName
             };
     }
 }
+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":
@@ -310,6 +553,698 @@ function rewriteRangeNode(node, ownerSheetName, targetSheetName, transform) {
         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":
+            return {
+                ...instruction,
+                address: translateCellReference(instruction.address, rowDelta, colDelta),
+            };
+        case "push-range": {
+            const nextRange = translatePlanRangeInstruction(instruction.sheetName, instruction.start, instruction.end, rowDelta, colDelta);
+            return { ...instruction, ...nextRange };
+        }
+        case "lookup-exact-match":
+        case "lookup-approximate-match": {
+            const nextRange = translatePlanRangeInstruction(instruction.sheetName, instruction.start, instruction.end, rowDelta, colDelta);
+            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 ? translateReferenceOperand(argRef, rowDelta, colDelta) : argRef),
+                }
+                : instruction;
+        case "push-lambda":
+            return {
+                ...instruction,
+                body: instruction.body.map((step) => translateJsPlanInstruction(step, rowDelta, colDelta)),
+            };
+        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 translateJsPlanInstructionWithoutAst(instruction, translatedCellMap, translatedRangeMap, rowDelta, colDelta) {
+    switch (instruction.opcode) {
+        case "push-cell": {
+            const translated = translatedCellMap.get(translatedCellInstructionKey(instruction.sheetName, instruction.address));
+            return translated
+                ? {
+                    ...instruction,
+                    address: formatParsedLocalCellReference(translated),
+                }
+                : translateJsPlanInstruction(instruction, rowDelta, colDelta);
+        }
+        case "push-range": {
+            const translated = translatedRangeMap.get(translatedRangeInstructionKey(instruction.sheetName, instruction.refKind, instruction.start, instruction.end));
+            return translated
+                ? {
+                    ...instruction,
+                    start: translated.startAddress,
+                    end: translated.endAddress,
+                }
+                : translateJsPlanInstruction(instruction, rowDelta, colDelta);
+        }
+        case "lookup-exact-match":
+        case "lookup-approximate-match": {
+            const translated = translatedRangeMap.get(translatedRangeInstructionKey(instruction.sheetName, instruction.refKind, instruction.start, instruction.end));
+            if (!translated || translated.refKind !== "cells") {
+                return translateJsPlanInstruction(instruction, rowDelta, colDelta);
+            }
+            return {
+                ...instruction,
+                start: translated.startAddress,
+                end: translated.endAddress,
+                startRow: translated.startRow,
+                endRow: translated.endRow,
+                startCol: translated.startCol,
+                endCol: translated.endCol,
+            };
+        }
+        case "call":
+            return instruction.argRefs
+                ? {
+                    ...instruction,
+                    argRefs: instruction.argRefs.map((argRef) => argRef
+                        ? translateReferenceOperandWithoutAst(argRef, translatedCellMap, translatedRangeMap, rowDelta, colDelta)
+                        : argRef),
+                }
+                : instruction;
+        case "push-lambda":
+            return {
+                ...instruction,
+                body: instruction.body.map((step) => translateJsPlanInstructionWithoutAst(step, translatedCellMap, translatedRangeMap, rowDelta, colDelta)),
+            };
+        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 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":
+            return operand.address
+                ? {
+                    ...operand,
+                    address: translateCellReference(operand.address, rowDelta, colDelta),
+                }
+                : operand;
+        case "range":
+            if (!operand.start || !operand.end || !operand.refKind) {
+                return operand;
+            }
+            return {
+                ...operand,
+                ...translatePlanRangeInstruction(operand.sheetName, operand.start, operand.end, rowDelta, colDelta),
+            };
+        case "row":
+            return operand.address
+                ? {
+                    ...operand,
+                    address: translateRowReference(operand.address, rowDelta),
+                }
+                : operand;
+        case "col":
+            return operand.address
+                ? {
+                    ...operand,
+                    address: translateColumnReference(operand.address, colDelta),
+                }
+                : operand;
+    }
+}
+function translateReferenceOperandWithoutAst(operand, translatedCellMap, translatedRangeMap, rowDelta, colDelta) {
+    switch (operand.kind) {
+        case "cell": {
+            if (!operand.address) {
+                return operand;
+            }
+            const translated = translatedCellMap.get(translatedCellInstructionKey(operand.sheetName, operand.address));
+            return translated
+                ? {
+                    ...operand,
+                    address: formatParsedLocalCellReference(translated),
+                }
+                : translateReferenceOperand(operand, rowDelta, colDelta);
+        }
+        case "range": {
+            if (!operand.start || !operand.end || !operand.refKind) {
+                return operand;
+            }
+            const translated = translatedRangeMap.get(translatedRangeInstructionKey(operand.sheetName, operand.refKind, operand.start, operand.end));
+            return translated
+                ? {
+                    ...operand,
+                    start: translated.startAddress,
+                    end: translated.endAddress,
+                    refKind: translated.refKind,
+                }
+                : translateReferenceOperand(operand, rowDelta, colDelta);
+        }
+        case "row":
+        case "col":
+            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);
+    return {
+        start: nextRange.start.text,
+        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) {