@bilig/formula 0.1.83 → 0.1.84

package/dist/translation.js

@@ -1,36 +1,36 @@
-import { ErrorCode, FormulaMode } from "@bilig/protocol";
-import { formatRangeAddress, parseCellAddress, parseRangeAddress } from "./addressing.js";
-import { compileFormulaAst, } from "./compiler.js";
-import { parseFormula } from "./parser.js";
+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]+)$/;
 const ROW_REF_RE = /^(\$?)([1-9][0-9]*)$/;
 const BINARY_PRECEDENCE = {
-    "=": 1,
-    "<>": 1,
-    ">": 1,
-    ">=": 1,
-    "<": 1,
-    "<=": 1,
-    "&": 2,
-    "+": 3,
-    "-": 3,
-    "*": 4,
-    "/": 4,
-    "^": 5,
+    '=': 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!",
+    [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!',
 };
 export function translateFormulaReferences(source, rowDelta, colDelta) {
     const ast = parseFormula(source);
@@ -47,8 +47,7 @@ export function canTranslateCompiledFormulaWithoutAst(compiled) {
         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"));
+        !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));
@@ -74,17 +73,13 @@ export function translateCompiledFormulaWithoutAst(compiled, rowDelta, colDelta,
                 : compiled.jsPlan.map((instruction) => translateJsPlanInstructionWithoutAst(instruction, translatedCellMap, translatedRangeMap, rowDelta, colDelta)),
             ...(translatedParsedDeps ? { parsedDeps: translatedParsedDeps } : {}),
             ...(translatedParsedSymbolicRefs ? { parsedSymbolicRefs: translatedParsedSymbolicRefs } : {}),
-            ...(translatedParsedSymbolicRanges
-                ? { parsedSymbolicRanges: translatedParsedSymbolicRanges }
-                : {}),
+            ...(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 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));
@@ -106,9 +101,7 @@ export function translateCompiledFormula(compiled, rowDelta, colDelta, sourceOve
             jsPlan: compiled.jsPlan.map((instruction) => translateJsPlanInstruction(instruction, rowDelta, colDelta)),
             ...(translatedParsedDeps ? { parsedDeps: translatedParsedDeps } : {}),
             ...(translatedParsedSymbolicRefs ? { parsedSymbolicRefs: translatedParsedSymbolicRefs } : {}),
-            ...(translatedParsedSymbolicRanges
-                ? { parsedSymbolicRanges: translatedParsedSymbolicRanges }
-                : {}),
+            ...(translatedParsedSymbolicRanges ? { parsedSymbolicRanges: translatedParsedSymbolicRanges } : {}),
         },
     };
 }
@@ -118,11 +111,7 @@ export function rewriteFormulaForStructuralTransform(source, ownerSheetName, tar
 }
 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 currentOptimizedAst = compiled.astMatchesSource === false ? currentAst : compiled.optimizedAst === compiled.ast ? currentAst : compiled.optimizedAst;
     const rewrittenAst = rewriteNodeForStructuralTransform(currentAst, ownerSheetName, targetSheetName, transform);
     const rewrittenOptimizedAst = currentOptimizedAst === currentAst
         ? rewrittenAst
@@ -180,8 +169,8 @@ export function rewriteAddressForStructuralTransform(address, transform) {
     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;
+    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;
     }
@@ -193,10 +182,10 @@ export function rewriteRangeForStructuralTransform(startAddress, endAddress, tra
     if (!start || !end) {
         throw new Error(`Invalid range reference '${startAddress}:${endAddress}'`);
     }
-    const nextRows = transform.axis === "row"
+    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"
+    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) {
@@ -209,64 +198,64 @@ export function rewriteRangeForStructuralTransform(startAddress, endAddress, tra
 }
 function translateNode(node, rowDelta, colDelta) {
     switch (node.kind) {
-        case "NumberLiteral":
-        case "BooleanLiteral":
-        case "StringLiteral":
-        case "ErrorLiteral":
-        case "NameRef":
-        case "StructuredRef":
+        case 'NumberLiteral':
+        case 'BooleanLiteral':
+        case 'StringLiteral':
+        case 'ErrorLiteral':
+        case 'NameRef':
+        case 'StructuredRef':
             return node;
-        case "CellRef":
+        case 'CellRef':
             return {
                 ...node,
                 ref: translateCellReference(node.ref, rowDelta, colDelta),
             };
-        case "SpillRef":
+        case 'SpillRef':
             return {
                 ...node,
                 ref: translateCellReference(node.ref, rowDelta, colDelta),
             };
-        case "ColumnRef":
+        case 'ColumnRef':
             return {
                 ...node,
                 ref: translateColumnReference(node.ref, colDelta),
             };
-        case "RowRef":
+        case 'RowRef':
             return {
                 ...node,
                 ref: translateRowReference(node.ref, rowDelta),
             };
-        case "RangeRef":
+        case 'RangeRef':
             return {
                 ...node,
-                start: node.refKind === "cells"
+                start: node.refKind === 'cells'
                     ? translateCellReference(node.start, rowDelta, colDelta)
-                    : node.refKind === "cols"
+                    : node.refKind === 'cols'
                         ? translateColumnReference(node.start, colDelta)
                         : translateRowReference(node.start, rowDelta),
-                end: node.refKind === "cells"
+                end: node.refKind === 'cells'
                     ? translateCellReference(node.end, rowDelta, colDelta)
-                    : node.refKind === "cols"
+                    : node.refKind === 'cols'
                         ? translateColumnReference(node.end, colDelta)
                         : translateRowReference(node.end, rowDelta),
             };
-        case "UnaryExpr":
+        case 'UnaryExpr':
             return {
                 ...node,
                 argument: translateNode(node.argument, rowDelta, colDelta),
             };
-        case "BinaryExpr":
+        case 'BinaryExpr':
             return {
                 ...node,
                 left: translateNode(node.left, rowDelta, colDelta),
                 right: translateNode(node.right, rowDelta, colDelta),
             };
-        case "CallExpr":
+        case 'CallExpr':
             return {
                 ...node,
                 args: node.args.map((arg) => translateNode(arg, rowDelta, colDelta)),
             };
-        case "InvokeExpr":
+        case 'InvokeExpr':
             return {
                 ...node,
                 callee: translateNode(node.callee, rowDelta, colDelta),
@@ -276,82 +265,80 @@ function translateNode(node, rowDelta, colDelta) {
 }
 function buildRelativeFormulaTemplateKeyInternal(node, ownerRow, ownerCol) {
     switch (node.kind) {
-        case "NumberLiteral":
+        case 'NumberLiteral':
             return `n:${node.value}`;
-        case "BooleanLiteral":
-            return node.value ? "b:1" : "b:0";
-        case "StringLiteral":
+        case 'BooleanLiteral':
+            return node.value ? 'b:1' : 'b:0';
+        case 'StringLiteral':
             return `s:${JSON.stringify(node.value)}`;
-        case "ErrorLiteral":
+        case 'ErrorLiteral':
             return `e:${node.code}`;
-        case "NameRef":
+        case 'NameRef':
             return `name:${node.name}`;
-        case "StructuredRef":
+        case 'StructuredRef':
             return `table:${node.tableName}[${node.columnName}]`;
-        case "CellRef":
+        case 'CellRef':
             return `cell:${templateSheetKey(node.sheetName)}:${buildRelativeCellReferenceKey(node.ref, ownerRow, ownerCol)}`;
-        case "SpillRef":
+        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":
+        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":
+        case 'UnaryExpr':
             return `unary:${node.operator}:${buildRelativeFormulaTemplateKeyInternal(node.argument, ownerRow, ownerCol)}`;
-        case "BinaryExpr":
+        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("|")}`;
+        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":
+        case 'NumberLiteral':
+        case 'BooleanLiteral':
+        case 'StringLiteral':
+        case 'ErrorLiteral':
+        case 'NameRef':
+        case 'StructuredRef':
             return node;
-        case "CellRef":
+        case 'CellRef':
             return rewriteCellLikeNode(node, ownerSheetName, targetSheetName, transform);
-        case "SpillRef":
+        case 'SpillRef':
             return rewriteCellLikeNode(node, ownerSheetName, targetSheetName, transform);
-        case "ColumnRef":
-            if (!targetsSheet(node.sheetName, ownerSheetName, targetSheetName) ||
-                transform.axis !== "column") {
+        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") {
+        case 'RowRef':
+            if (!targetsSheet(node.sheetName, ownerSheetName, targetSheetName) || transform.axis !== 'row') {
                 return node;
             }
             return rewriteAxisNode(node, transform);
-        case "RangeRef":
+        case 'RangeRef':
             return rewriteRangeNode(node, ownerSheetName, targetSheetName, transform);
-        case "UnaryExpr":
+        case 'UnaryExpr':
             return {
                 ...node,
                 argument: rewriteNodeForStructuralTransform(node.argument, ownerSheetName, targetSheetName, transform),
             };
-        case "BinaryExpr":
+        case 'BinaryExpr':
             return {
                 ...node,
                 left: rewriteNodeForStructuralTransform(node.left, ownerSheetName, targetSheetName, transform),
                 right: rewriteNodeForStructuralTransform(node.right, ownerSheetName, targetSheetName, transform),
             };
-        case "CallExpr":
+        case 'CallExpr':
             return {
                 ...node,
                 args: node.args.map((arg) => rewriteNodeForStructuralTransform(arg, ownerSheetName, targetSheetName, transform)),
             };
-        case "InvokeExpr":
+        case 'InvokeExpr':
             return {
                 ...node,
                 callee: rewriteNodeForStructuralTransform(node.callee, ownerSheetName, targetSheetName, transform),
@@ -360,7 +347,7 @@ function rewriteNodeForStructuralTransform(node, ownerSheetName, targetSheetName
     }
 }
 function templateSheetKey(sheetName) {
-    return sheetName === undefined ? "." : JSON.stringify(sheetName);
+    return sheetName === undefined ? '.' : JSON.stringify(sheetName);
 }
 function buildRelativeCellReferenceKey(ref, ownerRow, ownerCol) {
     const parsed = parseCellReferenceParts(ref);
@@ -380,12 +367,12 @@ function buildRelativeAxisReferenceKey(ref, ownerIndex, kind) {
 }
 function buildRelativeRangeReferenceKey(node, ownerRow, ownerCol) {
     switch (node.refKind) {
-        case "cells":
+        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")}`;
+        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) {
@@ -393,43 +380,39 @@ function nodeStructuralShapeEqual(left, right) {
         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":
+        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" &&
+        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" &&
+        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" &&
+        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])));
@@ -437,39 +420,39 @@ function nodeStructuralShapeEqual(left, right) {
 }
 function renameNodeSheetReferences(node, oldSheetName, newSheetName) {
     switch (node.kind) {
-        case "NumberLiteral":
-        case "BooleanLiteral":
-        case "StringLiteral":
-        case "ErrorLiteral":
-        case "NameRef":
-        case "StructuredRef":
+        case 'NumberLiteral':
+        case 'BooleanLiteral':
+        case 'StringLiteral':
+        case 'ErrorLiteral':
+        case 'NameRef':
+        case 'StructuredRef':
             return node;
-        case "CellRef":
-        case "SpillRef":
-        case "RowRef":
-        case "ColumnRef":
-        case "RangeRef":
+        case 'CellRef':
+        case 'SpillRef':
+        case 'RowRef':
+        case 'ColumnRef':
+        case 'RangeRef':
             return {
                 ...node,
                 ...(node.sheetName === oldSheetName ? { sheetName: newSheetName } : {}),
             };
-        case "UnaryExpr":
+        case 'UnaryExpr':
             return {
                 ...node,
                 argument: renameNodeSheetReferences(node.argument, oldSheetName, newSheetName),
             };
-        case "BinaryExpr":
+        case 'BinaryExpr':
             return {
                 ...node,
                 left: renameNodeSheetReferences(node.left, oldSheetName, newSheetName),
                 right: renameNodeSheetReferences(node.right, oldSheetName, newSheetName),
             };
-        case "CallExpr":
+        case 'CallExpr':
             return {
                 ...node,
                 args: node.args.map((arg) => renameNodeSheetReferences(arg, oldSheetName, newSheetName)),
             };
-        case "InvokeExpr":
+        case 'InvokeExpr':
             return {
                 ...node,
                 callee: renameNodeSheetReferences(node.callee, oldSheetName, newSheetName),
@@ -483,12 +466,12 @@ function rewriteCellLikeNode(node, ownerSheetName, targetSheetName, transform) {
     }
     const parsed = parseCellReferenceParts(node.ref);
     if (!parsed) {
-        return { kind: "ErrorLiteral", code: ErrorCode.Ref };
+        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;
+    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 { kind: 'ErrorLiteral', code: ErrorCode.Ref };
     }
     return {
         ...node,
@@ -496,41 +479,40 @@ function rewriteCellLikeNode(node, ownerSheetName, targetSheetName, transform) {
     };
 }
 function rewriteAxisNode(node, transform) {
-    const parsed = parseAxisReferenceParts(node.ref, node.kind === "RowRef" ? "row" : "column");
+    const parsed = parseAxisReferenceParts(node.ref, node.kind === 'RowRef' ? 'row' : 'column');
     if (!parsed) {
-        return { kind: "ErrorLiteral", code: ErrorCode.Ref };
+        return { kind: 'ErrorLiteral', code: ErrorCode.Ref };
     }
     const nextIndex = mapPointIndex(parsed.index, transform);
     if (nextIndex === undefined) {
-        return { kind: "ErrorLiteral", code: ErrorCode.Ref };
+        return { kind: 'ErrorLiteral', code: ErrorCode.Ref };
     }
     return {
         ...node,
-        ref: formatAxisReference(parsed.absolute, nextIndex, node.kind === "RowRef" ? "row" : "column"),
+        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")) {
+    if ((node.refKind === 'rows' && transform.axis === 'column') || (node.refKind === 'cols' && transform.axis === 'row')) {
         return node;
     }
-    if (node.refKind === "cells") {
+    if (node.refKind === 'cells') {
         const start = parseCellReferenceParts(node.start);
         const end = parseCellReferenceParts(node.end);
         if (!start || !end) {
-            return { kind: "ErrorLiteral", code: ErrorCode.Ref };
+            return { kind: 'ErrorLiteral', code: ErrorCode.Ref };
         }
-        const nextRows = transform.axis === "row"
+        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"
+        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 { kind: 'ErrorLiteral', code: ErrorCode.Ref };
         }
         return {
             ...node,
@@ -538,19 +520,19 @@ function rewriteRangeNode(node, ownerSheetName, targetSheetName, transform) {
             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");
+    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 };
+        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 { 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"),
+        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) {
@@ -580,14 +562,14 @@ function rewriteParsedRangeReference(reference, ownerSheetName, targetSheetName,
     if (!nextRange) {
         return reference;
     }
-    const bounds = nextRange.kind === "cells"
+    const bounds = nextRange.kind === 'cells'
         ? {
             startRow: nextRange.start.row,
             endRow: nextRange.end.row,
             startCol: nextRange.start.col,
             endCol: nextRange.end.col,
         }
-        : nextRange.kind === "rows"
+        : nextRange.kind === 'rows'
             ? {
                 startRow: nextRange.start.row,
                 endRow: nextRange.end.row,
@@ -610,15 +592,12 @@ function rewriteParsedRangeReference(reference, ownerSheetName, targetSheetName,
     };
 }
 function rewriteParsedDependencyReference(reference, ownerSheetName, targetSheetName, transform) {
-    return reference.kind === "cell"
+    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
+    const parts = reference.rowAbsolute !== undefined && reference.colAbsolute !== undefined && reference.row !== undefined && reference.col !== undefined
         ? {
             row: reference.row,
             col: reference.col,
@@ -648,14 +627,14 @@ function translateParsedCellReference(reference, rowDelta, colDelta) {
 }
 function translateParsedRangeReference(reference, rowDelta, colDelta) {
     const nextRange = translateParsedRangeReferenceInfo(reference, rowDelta, colDelta);
-    const bounds = nextRange.refKind === "cells"
+    const bounds = nextRange.refKind === 'cells'
         ? {
             startRow: nextRange.startRow,
             endRow: nextRange.endRow,
             startCol: nextRange.startCol,
             endCol: nextRange.endCol,
         }
-        : nextRange.refKind === "rows"
+        : nextRange.refKind === 'rows'
             ? {
                 startRow: nextRange.startRow,
                 endRow: nextRange.endRow,
@@ -679,17 +658,15 @@ function translateParsedRangeReference(reference, rowDelta, colDelta) {
     };
 }
 function translateParsedDependencyReference(reference, rowDelta, colDelta) {
-    return reference.kind === "cell"
+    return reference.kind === 'cell'
         ? translateParsedCellReference(reference, rowDelta, colDelta)
         : translateParsedRangeReference(reference, rowDelta, colDelta);
 }
 function translateQualifiedCellReference(raw, rowDelta, colDelta) {
-    const explicitlyQualified = raw.includes("!");
+    const explicitlyQualified = raw.includes('!');
     const parsed = parseCellAddress(raw);
     const nextAddress = translateCellReference(parsed.text, rowDelta, colDelta);
-    return explicitlyQualified
-        ? formatQualifiedCellReference(parsed.sheetName, nextAddress)
-        : nextAddress;
+    return explicitlyQualified ? formatQualifiedCellReference(parsed.sheetName, nextAddress) : nextAddress;
 }
 function formatParsedCellReference(reference) {
     const localAddress = formatParsedLocalCellReference(reference);
@@ -698,10 +675,7 @@ function formatParsedCellReference(reference) {
         : localAddress;
 }
 function formatParsedLocalCellReference(reference) {
-    const parts = reference.row !== undefined &&
-        reference.col !== undefined &&
-        reference.rowAbsolute !== undefined &&
-        reference.colAbsolute !== undefined
+    const parts = reference.row !== undefined && reference.col !== undefined && reference.rowAbsolute !== undefined && reference.colAbsolute !== undefined
         ? {
             row: reference.row,
             col: reference.col,
@@ -718,14 +692,14 @@ function formatParsedRangeReference(reference) {
     return formatQualifiedRangeReference(reference.explicitSheet ? reference.sheetName : undefined, reference.startAddress, reference.endAddress);
 }
 function stripSheetQualifier(reference) {
-    const bang = reference.lastIndexOf("!");
+    const bang = reference.lastIndexOf('!');
     return bang === -1 ? reference : reference.slice(bang + 1);
 }
 function translatedCellInstructionKey(sheetName, address) {
-    return `${sheetName ?? ""}\t${address}`;
+    return `${sheetName ?? ''}\t${address}`;
 }
 function translatedRangeInstructionKey(sheetName, refKind, start, end) {
-    return `${sheetName ?? ""}\t${refKind}\t${start}\t${end}`;
+    return `${sheetName ?? ''}\t${refKind}\t${start}\t${end}`;
 }
 function buildTranslatedCellReferenceMap(original, translated) {
     const output = new Map();
@@ -758,18 +732,16 @@ function buildTranslatedRangeReferenceMap(original, translated) {
     return output;
 }
 function formatParsedDependencyReference(reference) {
-    return reference.kind === "cell"
-        ? formatParsedCellReference(reference)
-        : formatParsedRangeReference(reference);
+    return reference.kind === 'cell' ? formatParsedCellReference(reference) : formatParsedRangeReference(reference);
 }
 function translateQualifiedDependencyReference(raw, rowDelta, colDelta) {
-    if (!raw.includes(":")) {
+    if (!raw.includes(':')) {
         return translateQualifiedCellReference(raw, rowDelta, colDelta);
     }
     return translateQualifiedRangeReference(raw, rowDelta, colDelta);
 }
 function translateQualifiedRangeReference(raw, rowDelta, colDelta) {
-    const explicitlyQualified = raw.includes("!");
+    const explicitlyQualified = raw.includes('!');
     const parsed = parseRangeAddress(raw);
     const nextRange = translateRangeAddress(parsed, rowDelta, colDelta);
     if (explicitlyQualified) {
@@ -779,17 +751,17 @@ function translateQualifiedRangeReference(raw, rowDelta, colDelta) {
 }
 function translateRangeAddress(range, rowDelta, colDelta) {
     switch (range.kind) {
-        case "cells": {
+        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": {
+        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": {
+        case 'cols': {
             const start = translateColumnReference(range.start.text, colDelta);
             const end = translateColumnReference(range.end.text, colDelta);
             return parseRangeAddress(formatQualifiedRangeReference(range.sheetName, start, end));
@@ -797,7 +769,7 @@ function translateRangeAddress(range, rowDelta, colDelta) {
     }
 }
 function translateParsedRangeReferenceInfo(reference, rowDelta, colDelta) {
-    if (reference.refKind === "cells") {
+    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;
@@ -824,13 +796,13 @@ function translateParsedRangeReferenceInfo(reference, rowDelta, colDelta) {
             endCol,
         };
     }
-    if (reference.refKind === "rows") {
+    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"),
+            startAddress: formatAxisReference(reference.startRowAbsolute ?? false, startRow, 'row'),
+            endAddress: formatAxisReference(reference.endRowAbsolute ?? false, endRow, 'row'),
             startRow,
             endRow,
             startCol: 0,
@@ -841,8 +813,8 @@ function translateParsedRangeReferenceInfo(reference, rowDelta, 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"),
+        startAddress: formatAxisReference(reference.startColAbsolute ?? false, startCol, 'column'),
+        endAddress: formatAxisReference(reference.endColAbsolute ?? false, endCol, 'column'),
         startRow: 0,
         endRow: 0,
         startCol,
@@ -850,7 +822,7 @@ function translateParsedRangeReferenceInfo(reference, rowDelta, colDelta) {
     };
 }
 function rewriteQualifiedCellReference(raw, ownerSheetName, targetSheetName, transform) {
-    const explicitlyQualified = raw.includes("!");
+    const explicitlyQualified = raw.includes('!');
     const parsed = parseCellAddress(raw, ownerSheetName);
     if (parsed.sheetName !== targetSheetName) {
         return raw;
@@ -859,18 +831,16 @@ function rewriteQualifiedCellReference(raw, ownerSheetName, targetSheetName, tra
     if (!nextAddress) {
         return raw;
     }
-    return explicitlyQualified
-        ? formatQualifiedCellReference(parsed.sheetName, nextAddress)
-        : nextAddress;
+    return explicitlyQualified ? formatQualifiedCellReference(parsed.sheetName, nextAddress) : nextAddress;
 }
 function rewriteQualifiedDependencyReference(raw, ownerSheetName, targetSheetName, transform) {
-    if (!raw.includes(":")) {
+    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 explicitlyQualified = raw.includes('!');
     const parsed = parseRangeAddress(raw, ownerSheetName);
     const sheetName = parsed.sheetName ?? ownerSheetName;
     if (sheetName !== targetSheetName) {
@@ -887,60 +857,56 @@ function rewriteQualifiedRangeReference(raw, ownerSheetName, targetSheetName, tr
 }
 function rewriteRangeAddressForStructuralTransform(range, transform) {
     switch (range.kind) {
-        case "cells": {
+        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") {
+        case 'rows':
+            if (transform.axis !== 'row') {
                 return range;
             }
             return rewriteAxisRangeAddress(range, transform);
-        case "cols":
-            if (transform.axis !== "column") {
+        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 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");
+    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":
+        case 'push-cell':
             return {
                 ...instruction,
                 address: rewriteReferenceOperandAddress(instruction.sheetName, instruction.address, ownerSheetName, targetSheetName, transform),
             };
-        case "push-range": {
+        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": {
+        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") {
+            if (parsed.kind !== 'cells') {
                 return instruction;
             }
             return {
@@ -952,53 +918,51 @@ function rewriteJsPlanInstruction(instruction, ownerSheetName, targetSheetName,
                 endCol: parsed.end.col,
             };
         }
-        case "call":
+        case 'call':
             return instruction.argRefs
                 ? {
                     ...instruction,
-                    argRefs: instruction.argRefs.map((argRef) => argRef
-                        ? rewriteReferenceOperand(argRef, ownerSheetName, targetSheetName, transform)
-                        : argRef),
+                    argRefs: instruction.argRefs.map((argRef) => argRef ? rewriteReferenceOperand(argRef, ownerSheetName, targetSheetName, transform) : argRef),
                 }
                 : instruction;
-        case "push-lambda":
+        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":
+        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":
+        case 'push-cell':
             return {
                 ...instruction,
                 address: translateCellReference(instruction.address, rowDelta, colDelta),
             };
-        case "push-range": {
+        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": {
+        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") {
+            if (parsed.kind !== 'cells') {
                 return instruction;
             }
             return {
@@ -1010,38 +974,38 @@ function translateJsPlanInstruction(instruction, rowDelta, colDelta) {
                 endCol: parsed.end.col,
             };
         }
-        case "call":
+        case 'call':
             return instruction.argRefs
                 ? {
                     ...instruction,
-                    argRefs: instruction.argRefs.map((argRef) => argRef ? translateReferenceOperand(argRef, rowDelta, colDelta) : argRef),
+                    argRefs: instruction.argRefs.map((argRef) => (argRef ? translateReferenceOperand(argRef, rowDelta, colDelta) : argRef)),
                 }
                 : instruction;
-        case "push-lambda":
+        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":
+        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": {
+        case 'push-cell': {
             const translated = translatedCellMap.get(translatedCellInstructionKey(instruction.sheetName, instruction.address));
             return translated
                 ? {
@@ -1050,7 +1014,7 @@ function translateJsPlanInstructionWithoutAst(instruction, translatedCellMap, tr
                 }
                 : translateJsPlanInstruction(instruction, rowDelta, colDelta);
         }
-        case "push-range": {
+        case 'push-range': {
             const translated = translatedRangeMap.get(translatedRangeInstructionKey(instruction.sheetName, instruction.refKind, instruction.start, instruction.end));
             return translated
                 ? {
@@ -1060,10 +1024,10 @@ function translateJsPlanInstructionWithoutAst(instruction, translatedCellMap, tr
                 }
                 : translateJsPlanInstruction(instruction, rowDelta, colDelta);
         }
-        case "lookup-exact-match":
-        case "lookup-approximate-match": {
+        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") {
+            if (!translated || translated.refKind !== 'cells') {
                 return translateJsPlanInstruction(instruction, rowDelta, colDelta);
             }
             return {
@@ -1076,68 +1040,66 @@ function translateJsPlanInstructionWithoutAst(instruction, translatedCellMap, tr
                 endCol: translated.endCol,
             };
         }
-        case "call":
+        case 'call':
             return instruction.argRefs
                 ? {
                     ...instruction,
-                    argRefs: instruction.argRefs.map((argRef) => argRef
-                        ? translateReferenceOperandWithoutAst(argRef, translatedCellMap, translatedRangeMap, rowDelta, colDelta)
-                        : argRef),
+                    argRefs: instruction.argRefs.map((argRef) => argRef ? translateReferenceOperandWithoutAst(argRef, translatedCellMap, translatedRangeMap, rowDelta, colDelta) : argRef),
                 }
                 : instruction;
-        case "push-lambda":
+        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":
+        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":
+        case 'cell':
             return operand.address
                 ? {
                     ...operand,
                     address: rewriteReferenceOperandAddress(operand.sheetName, operand.address, ownerSheetName, targetSheetName, transform),
                 }
                 : operand;
-        case "range": {
+        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":
+        case 'row':
+        case 'col':
             return operand;
     }
 }
 function translateReferenceOperand(operand, rowDelta, colDelta) {
     switch (operand.kind) {
-        case "cell":
+        case 'cell':
             return operand.address
                 ? {
                     ...operand,
                     address: translateCellReference(operand.address, rowDelta, colDelta),
                 }
                 : operand;
-        case "range":
+        case 'range':
             if (!operand.start || !operand.end || !operand.refKind) {
                 return operand;
             }
@@ -1145,14 +1107,14 @@ function translateReferenceOperand(operand, rowDelta, colDelta) {
                 ...operand,
                 ...translatePlanRangeInstruction(operand.sheetName, operand.start, operand.end, rowDelta, colDelta),
             };
-        case "row":
+        case 'row':
             return operand.address
                 ? {
                     ...operand,
                     address: translateRowReference(operand.address, rowDelta),
                 }
                 : operand;
-        case "col":
+        case 'col':
             return operand.address
                 ? {
                     ...operand,
@@ -1163,7 +1125,7 @@ function translateReferenceOperand(operand, rowDelta, colDelta) {
 }
 function translateReferenceOperandWithoutAst(operand, translatedCellMap, translatedRangeMap, rowDelta, colDelta) {
     switch (operand.kind) {
-        case "cell": {
+        case 'cell': {
             if (!operand.address) {
                 return operand;
             }
@@ -1175,7 +1137,7 @@ function translateReferenceOperandWithoutAst(operand, translatedCellMap, transla
                 }
                 : translateReferenceOperand(operand, rowDelta, colDelta);
         }
-        case "range": {
+        case 'range': {
             if (!operand.start || !operand.end || !operand.refKind) {
                 return operand;
             }
@@ -1189,8 +1151,8 @@ function translateReferenceOperandWithoutAst(operand, translatedCellMap, transla
                 }
                 : translateReferenceOperand(operand, rowDelta, colDelta);
         }
-        case "row":
-        case "col":
+        case 'row':
+        case 'col':
             return translateReferenceOperand(operand, rowDelta, colDelta);
     }
 }
@@ -1204,7 +1166,7 @@ function rewritePlanRangeInstruction(explicitSheetName, start, end, refKind, own
     if ((explicitSheetName ?? ownerSheetName) !== targetSheetName) {
         return undefined;
     }
-    if (refKind === "cells") {
+    if (refKind === 'cells') {
         const nextRange = rewriteRangeForStructuralTransform(start, end, transform);
         return nextRange
             ? {
@@ -1213,8 +1175,7 @@ function rewritePlanRangeInstruction(explicitSheetName, start, end, refKind, own
             }
             : undefined;
     }
-    if ((refKind === "rows" && transform.axis !== "row") ||
-        (refKind === "cols" && transform.axis !== "column")) {
+    if ((refKind === 'rows' && transform.axis !== 'row') || (refKind === 'cols' && transform.axis !== 'column')) {
         return undefined;
     }
     const parsed = parseRangeAddress(formatQualifiedRangeReference(explicitSheetName, start, end));
@@ -1242,7 +1203,7 @@ function formatQualifiedCellReference(sheetName, address) {
     return `${quoteSheetNameIfNeeded(sheetName)}!${parsed.text}`;
 }
 function formatQualifiedRangeReference(sheetName, start, end) {
-    const prefix = sheetName ? `${quoteSheetNameIfNeeded(sheetName)}!` : "";
+    const prefix = sheetName ? `${quoteSheetNameIfNeeded(sheetName)}!` : '';
     return `${prefix}${start}:${end}`;
 }
 function translateCellReference(ref, rowDelta, colDelta) {
@@ -1258,7 +1219,7 @@ function translateCellReference(ref, rowDelta, colDelta) {
     return formatCellReference(parsed, nextRow, nextCol);
 }
 function translateColumnReference(ref, colDelta) {
-    const parsed = parseAxisReferenceParts(ref, "column");
+    const parsed = parseAxisReferenceParts(ref, 'column');
     if (!parsed) {
         throw new Error(`Invalid column reference '${ref}'`);
     }
@@ -1266,10 +1227,10 @@ function translateColumnReference(ref, colDelta) {
     if (nextCol < 0) {
         throw new Error(`Translated reference moved outside worksheet bounds: ${ref}`);
     }
-    return formatAxisReference(parsed.absolute, nextCol, "column");
+    return formatAxisReference(parsed.absolute, nextCol, 'column');
 }
 function translateRowReference(ref, rowDelta) {
-    const parsed = parseAxisReferenceParts(ref, "row");
+    const parsed = parseAxisReferenceParts(ref, 'row');
     if (!parsed) {
         throw new Error(`Invalid row reference '${ref}'`);
     }
@@ -1277,59 +1238,58 @@ function translateRowReference(ref, rowDelta) {
     if (nextRow < 0) {
         throw new Error(`Translated reference moved outside worksheet bounds: ${ref}`);
     }
-    return formatAxisReference(parsed.absolute, nextRow, "row");
+    return formatAxisReference(parsed.absolute, nextRow, 'row');
 }
 export function serializeFormula(node, parentPrecedence = 0, parentAssociativity = null) {
     switch (node.kind) {
-        case "NumberLiteral":
+        case 'NumberLiteral':
             return String(node.value);
-        case "BooleanLiteral":
-            return node.value ? "TRUE" : "FALSE";
-        case "StringLiteral":
+        case 'BooleanLiteral':
+            return node.value ? 'TRUE' : 'FALSE';
+        case 'StringLiteral':
             return `"${node.value.replaceAll('"', '""')}"`;
-        case "ErrorLiteral":
-            return ERROR_LITERAL_TEXT[node.code] ?? "#ERROR!";
-        case "NameRef":
+        case 'ErrorLiteral':
+            return ERROR_LITERAL_TEXT[node.code] ?? '#ERROR!';
+        case 'NameRef':
             return node.name;
-        case "StructuredRef":
+        case 'StructuredRef':
             return `${node.tableName}[${node.columnName}]`;
-        case "CellRef":
+        case 'CellRef':
             return `${formatSheetPrefix(node.sheetName)}${node.ref}`;
-        case "SpillRef":
+        case 'SpillRef':
             return `${formatSheetPrefix(node.sheetName)}${node.ref}#`;
-        case "ColumnRef":
+        case 'ColumnRef':
             return `${formatSheetPrefix(node.sheetName)}${node.ref}`;
-        case "RowRef":
+        case 'RowRef':
             return `${formatSheetPrefix(node.sheetName)}${node.ref}`;
-        case "RangeRef":
+        case 'RangeRef':
             return `${formatSheetPrefix(node.sheetName)}${node.start}:${node.end}`;
-        case "UnaryExpr":
+        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"
+        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(",")})`;
+            return `${callee}(${node.args.map((arg) => serializeFormula(arg)).join(',')})`;
         }
-        case "BinaryExpr": {
+        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 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)));
+                    ((parentAssociativity === 'left' && isRightAssociative) || (parentAssociativity === 'right' && !isRightAssociative)));
             return needsParens ? `(${output})` : output;
         }
     }
 }
 function formatSheetPrefix(sheetName) {
     if (!sheetName) {
-        return "";
+        return '';
     }
     return `${quoteSheetNameIfNeeded(sheetName)}!`;
 }
@@ -1345,7 +1305,7 @@ function columnToIndex(column) {
 }
 function indexToColumn(index) {
     let current = index + 1;
-    let output = "";
+    let output = '';
     while (current > 0) {
         const remainder = (current - 1) % 26;
         output = String.fromCharCode(65 + remainder) + output;
@@ -1363,39 +1323,39 @@ function parseCellReferenceParts(ref) {
     }
     const [, colAbsolute, columnText, rowAbsolute, rowText] = match;
     return {
-        colAbsolute: colAbsolute === "$",
-        rowAbsolute: rowAbsolute === "$",
+        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}`;
+    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());
+    const match = (kind === 'row' ? ROW_REF_RE : COLUMN_REF_RE).exec(ref.toUpperCase());
     if (!match) {
         return undefined;
     }
-    return kind === "row"
+    return kind === 'row'
         ? {
-            absolute: match[1] === "$",
+            absolute: match[1] === '$',
             index: Number.parseInt(match[2], 10) - 1,
         }
         : {
-            absolute: match[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)}`;
+    const prefix = absolute ? '$' : '';
+    return kind === 'row' ? `${prefix}${index + 1}` : `${prefix}${indexToColumn(index)}`;
 }
 function mapPointIndex(index, transform) {
     switch (transform.kind) {
-        case "insert":
+        case 'insert':
             return index >= transform.start ? index + transform.count : index;
-        case "delete":
+        case 'delete':
             if (index < transform.start) {
                 return index;
             }
@@ -1403,15 +1363,14 @@ function mapPointIndex(index, transform) {
                 return index - transform.count;
             }
             return undefined;
-        case "move":
+        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) {
+                if (index >= transform.start + transform.count && index < transform.target + transform.count) {
                     return index - transform.count;
                 }
             }
@@ -1425,7 +1384,7 @@ function mapPointIndex(index, transform) {
 }
 function mapInterval(start, end, transform) {
     switch (transform.kind) {
-        case "insert": {
+        case 'insert': {
             if (transform.start <= start) {
                 return { start: start + transform.count, end: end + transform.count };
             }
@@ -1434,7 +1393,7 @@ function mapInterval(start, end, transform) {
             }
             return { start, end };
         }
-        case "delete": {
+        case 'delete': {
             const deleteEnd = transform.start + transform.count - 1;
             if (deleteEnd < start) {
                 return { start: start - transform.count, end: end - transform.count };
@@ -1449,11 +1408,9 @@ function mapInterval(start, end, transform) {
             }
             const nextStart = mapPointIndex(survivingStart, transform);
             const nextEnd = mapPointIndex(survivingEnd, transform);
-            return nextStart === undefined || nextEnd === undefined
-                ? undefined
-                : { start: nextStart, end: nextEnd };
+            return nextStart === undefined || nextEnd === undefined ? undefined : { start: nextStart, end: nextEnd };
         }
-        case "move": {
+        case 'move': {
             const segments = transform.target < transform.start
                 ? [
                     { start: 0, end: transform.target - 1, delta: 0 },