@bilig/formula 0.1.83 → 0.1.85

package/dist/compiler.js

@@ -1,43 +1,43 @@
-import { BuiltinId, FormulaMode, Opcode } from "@bilig/protocol";
-import { columnToIndex, formatRangeAddress, parseCellAddress, parseRangeAddress, } from "./addressing.js";
-import { getNativeGroupedArrayKind } from "./binder-wasm-rules.js";
-import { bindFormula, encodeBuiltin } from "./binder.js";
-import { lowerToPlan } from "./js-evaluator.js";
-import { optimizeFormula } from "./optimizer.js";
-import { parseFormula } from "./parser.js";
-import { rewriteSpecialCall } from "./special-call-rewrites.js";
+import { BuiltinId, FormulaMode, Opcode } from '@bilig/protocol';
+import { columnToIndex, formatRangeAddress, parseCellAddress, parseRangeAddress } from './addressing.js';
+import { getNativeGroupedArrayKind } from './binder-wasm-rules.js';
+import { bindFormula, encodeBuiltin } from './binder.js';
+import { lowerToPlan } from './js-evaluator.js';
+import { optimizeFormula } from './optimizer.js';
+import { parseFormula } from './parser.js';
+import { rewriteSpecialCall } from './special-call-rewrites.js';
 function encodeInstruction(opcode, operand = 0) {
     return (opcode << 24) | (operand & 0x00ff_ffff);
 }
 const SIMPLE_CELL_REF_RE = /^\$?[A-Z]+\$?[1-9][0-9]*$/;
 const SIMPLE_NUMBER_RE = /^[+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?$/;
 const SIMPLE_BINARY_RE = /^\s*(\$?[A-Z]+\$?[1-9][0-9]*|[+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?)\s*([+*])\s*(\$?[A-Z]+\$?[1-9][0-9]*|[+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?)\s*$/;
-const VOLATILE_BUILTINS = new Set(["TODAY", "NOW", "RAND", "RANDBETWEEN", "RANDARRAY"]);
+const VOLATILE_BUILTINS = new Set(['TODAY', 'NOW', 'RAND', 'RANDBETWEEN', 'RANDARRAY']);
 function producesSpillResult(node) {
     switch (node.kind) {
-        case "NumberLiteral":
-        case "BooleanLiteral":
-        case "StringLiteral":
-        case "ErrorLiteral":
-        case "NameRef":
-        case "StructuredRef":
-        case "CellRef":
-        case "SpillRef":
-        case "RowRef":
-        case "ColumnRef":
-        case "InvokeExpr":
+        case 'NumberLiteral':
+        case 'BooleanLiteral':
+        case 'StringLiteral':
+        case 'ErrorLiteral':
+        case 'NameRef':
+        case 'StructuredRef':
+        case 'CellRef':
+        case 'SpillRef':
+        case 'RowRef':
+        case 'ColumnRef':
+        case 'InvokeExpr':
             return false;
-        case "RangeRef":
+        case 'RangeRef':
             return true;
-        case "UnaryExpr":
+        case 'UnaryExpr':
             return producesSpillResult(node.argument);
-        case "BinaryExpr":
+        case 'BinaryExpr':
             return producesSpillResult(node.left) || producesSpillResult(node.right);
-        case "CallExpr":
-            if (node.callee.toUpperCase() === "CHOOSE") {
+        case 'CallExpr':
+            if (node.callee.toUpperCase() === 'CHOOSE') {
                 return node.args.slice(1).some((arg) => producesSpillResult(arg));
             }
-            if (node.callee.toUpperCase() === "TREND" || node.callee.toUpperCase() === "GROWTH") {
+            if (node.callee.toUpperCase() === 'TREND' || node.callee.toUpperCase() === 'GROWTH') {
                 const shapeArg = node.args[2] ?? node.args[1] ?? node.args[0];
                 if (shapeArg === undefined) {
                     return false;
@@ -45,58 +45,58 @@ function producesSpillResult(node) {
                 return producesSpillResult(shapeArg);
             }
             return [
-                "SEQUENCE",
-                "EXPAND",
-                "LINEST",
-                "LOGEST",
-                "OFFSET",
-                "TAKE",
-                "DROP",
-                "CHOOSECOLS",
-                "CHOOSEROWS",
-                "SORT",
-                "SORTBY",
-                "TOCOL",
-                "TOROW",
-                "WRAPROWS",
-                "WRAPCOLS",
-                "FILTER",
-                "UNIQUE",
-                "FREQUENCY",
-                "MODE.MULT",
-                "TEXTSPLIT",
-                "TRIMRANGE",
-                "GROUPBY",
-                "PIVOTBY",
-                "MAKEARRAY",
-                "MAP",
-                "SCAN",
-                "BYROW",
-                "BYCOL",
-                "RANDARRAY",
-                "MUNIT",
-                "MINVERSE",
-                "MMULT",
+                'SEQUENCE',
+                'EXPAND',
+                'LINEST',
+                'LOGEST',
+                'OFFSET',
+                'TAKE',
+                'DROP',
+                'CHOOSECOLS',
+                'CHOOSEROWS',
+                'SORT',
+                'SORTBY',
+                'TOCOL',
+                'TOROW',
+                'WRAPROWS',
+                'WRAPCOLS',
+                'FILTER',
+                'UNIQUE',
+                'FREQUENCY',
+                'MODE.MULT',
+                'TEXTSPLIT',
+                'TRIMRANGE',
+                'GROUPBY',
+                'PIVOTBY',
+                'MAKEARRAY',
+                'MAP',
+                'SCAN',
+                'BYROW',
+                'BYCOL',
+                'RANDARRAY',
+                'MUNIT',
+                'MINVERSE',
+                'MMULT',
             ].includes(node.callee.toUpperCase());
     }
 }
 function analyzeVolatileMetadata(node) {
     switch (node.kind) {
-        case "NumberLiteral":
-        case "BooleanLiteral":
-        case "StringLiteral":
-        case "ErrorLiteral":
-        case "NameRef":
-        case "StructuredRef":
-        case "CellRef":
-        case "SpillRef":
-        case "RowRef":
-        case "ColumnRef":
-        case "RangeRef":
+        case 'NumberLiteral':
+        case 'BooleanLiteral':
+        case 'StringLiteral':
+        case 'ErrorLiteral':
+        case 'NameRef':
+        case 'StructuredRef':
+        case 'CellRef':
+        case 'SpillRef':
+        case 'RowRef':
+        case 'ColumnRef':
+        case 'RangeRef':
             return { volatile: false, randCallCount: 0 };
-        case "UnaryExpr":
+        case 'UnaryExpr':
             return analyzeVolatileMetadata(node.argument);
-        case "BinaryExpr": {
+        case 'BinaryExpr': {
             const left = analyzeVolatileMetadata(node.left);
             const right = analyzeVolatileMetadata(node.right);
             return {
@@ -104,14 +104,14 @@ function analyzeVolatileMetadata(node) {
                 randCallCount: left.randCallCount + right.randCallCount,
             };
         }
-        case "CallExpr": {
+        case 'CallExpr': {
             const rewritten = rewriteSpecialCall(node);
             if (rewritten) {
                 return analyzeVolatileMetadata(rewritten);
             }
             const callee = node.callee.toUpperCase();
             let volatile = VOLATILE_BUILTINS.has(callee);
-            let randCallCount = callee === "RAND" ? 1 : 0;
+            let randCallCount = callee === 'RAND' ? 1 : 0;
             node.args.forEach((arg) => {
                 const child = analyzeVolatileMetadata(arg);
                 volatile = volatile || child.volatile;
@@ -119,7 +119,7 @@ function analyzeVolatileMetadata(node) {
             });
             return { volatile, randCallCount };
         }
-        case "InvokeExpr": {
+        case 'InvokeExpr': {
             const callee = analyzeVolatileMetadata(node.callee);
             const args = node.args.map(analyzeVolatileMetadata);
             return {
@@ -145,19 +145,19 @@ function emitRangeRef(node, state) {
     state.program.push(encodeInstruction(Opcode.PushRange, index));
 }
 function isCellRangeNode(node) {
-    if (node.kind !== "RangeRef") {
+    if (node.kind !== 'RangeRef') {
         return false;
     }
     try {
-        const sheetPrefix = node.sheetName ? `${node.sheetName}!` : "";
-        return parseRangeAddress(`${sheetPrefix}${node.start}:${node.end}`).kind === "cells";
+        const sheetPrefix = node.sheetName ? `${node.sheetName}!` : '';
+        return parseRangeAddress(`${sheetPrefix}${node.start}:${node.end}`).kind === 'cells';
     }
     catch {
         return false;
     }
 }
 function emitArgument(node, state) {
-    if (node.kind === "RangeRef") {
+    if (node.kind === 'RangeRef') {
         emitRangeRef(node, state);
         return 1;
     }
@@ -165,44 +165,39 @@ function emitArgument(node, state) {
     return 1;
 }
 const AXIS_AGGREGATE_CODES = new Map([
-    ["SUM", 1],
-    ["AVERAGE", 2],
-    ["AVG", 2],
-    ["MIN", 3],
-    ["MAX", 4],
-    ["COUNT", 5],
-    ["COUNTA", 6],
+    ['SUM', 1],
+    ['AVERAGE', 2],
+    ['AVG', 2],
+    ['MIN', 3],
+    ['MAX', 4],
+    ['COUNT', 5],
+    ['COUNTA', 6],
 ]);
 function getNativeAxisAggregateCode(node) {
-    if (node.kind !== "CallExpr" ||
-        node.callee.toUpperCase() !== "LAMBDA" ||
-        node.args.length !== 2) {
+    if (node.kind !== 'CallExpr' || node.callee.toUpperCase() !== 'LAMBDA' || node.args.length !== 2) {
         return null;
     }
     const [param, body] = node.args;
-    if (param?.kind !== "NameRef" || body?.kind !== "CallExpr" || body.args.length !== 1) {
+    if (param?.kind !== 'NameRef' || body?.kind !== 'CallExpr' || body.args.length !== 1) {
         return null;
     }
     const aggregateCode = AXIS_AGGREGATE_CODES.get(body.callee.toUpperCase());
     if (aggregateCode === undefined) {
         return null;
     }
-    return body.args[0]?.kind === "NameRef" &&
-        body.args[0].name.trim().toUpperCase() === param.name.trim().toUpperCase()
+    return body.args[0]?.kind === 'NameRef' && body.args[0].name.trim().toUpperCase() === param.name.trim().toUpperCase()
         ? aggregateCode
         : null;
 }
 function getNativeRunningFoldCode(node) {
-    if (node.kind !== "CallExpr" ||
-        node.callee.toUpperCase() !== "LAMBDA" ||
-        node.args.length !== 3) {
+    if (node.kind !== 'CallExpr' || node.callee.toUpperCase() !== 'LAMBDA' || node.args.length !== 3) {
         return null;
     }
     const [acc, value, body] = node.args;
-    if (acc?.kind !== "NameRef" || value?.kind !== "NameRef" || body?.kind !== "BinaryExpr") {
+    if (acc?.kind !== 'NameRef' || value?.kind !== 'NameRef' || body?.kind !== 'BinaryExpr') {
         return null;
     }
-    const foldCode = body.operator === "+" ? 1 : body.operator === "*" ? 2 : null;
+    const foldCode = body.operator === '+' ? 1 : body.operator === '*' ? 2 : null;
     if (foldCode === null) {
         return null;
     }
@@ -210,47 +205,44 @@ function getNativeRunningFoldCode(node) {
     const right = body.right;
     const accName = acc.name.trim().toUpperCase();
     const valueName = value.name.trim().toUpperCase();
-    return left.kind === "NameRef" &&
-        right.kind === "NameRef" &&
-        ((left.name.trim().toUpperCase() === accName &&
-            right.name.trim().toUpperCase() === valueName) ||
+    return left.kind === 'NameRef' &&
+        right.kind === 'NameRef' &&
+        ((left.name.trim().toUpperCase() === accName && right.name.trim().toUpperCase() === valueName) ||
             (left.name.trim().toUpperCase() === valueName && right.name.trim().toUpperCase() === accName))
         ? foldCode
         : null;
 }
 function isNativeMakearraySumLambda(node) {
-    if (node.kind !== "CallExpr" ||
-        node.callee.toUpperCase() !== "LAMBDA" ||
-        node.args.length !== 3) {
+    if (node.kind !== 'CallExpr' || node.callee.toUpperCase() !== 'LAMBDA' || node.args.length !== 3) {
         return false;
     }
     const [rowParam, colParam, body] = node.args;
-    if (rowParam?.kind !== "NameRef" || colParam?.kind !== "NameRef" || body?.kind !== "BinaryExpr") {
+    if (rowParam?.kind !== 'NameRef' || colParam?.kind !== 'NameRef' || body?.kind !== 'BinaryExpr') {
         return false;
     }
-    if (body.operator !== "+") {
+    if (body.operator !== '+') {
         return false;
     }
     const left = body.left;
     const right = body.right;
     const rowName = rowParam.name.trim().toUpperCase();
     const colName = colParam.name.trim().toUpperCase();
-    return (left.kind === "NameRef" &&
-        right.kind === "NameRef" &&
+    return (left.kind === 'NameRef' &&
+        right.kind === 'NameRef' &&
         ((left.name.trim().toUpperCase() === rowName && right.name.trim().toUpperCase() === colName) ||
             (left.name.trim().toUpperCase() === colName && right.name.trim().toUpperCase() === rowName)));
 }
 function emitNode(node, state) {
     switch (node.kind) {
-        case "NumberLiteral": {
+        case 'NumberLiteral': {
             const index = state.constants.push(node.value) - 1;
             state.program.push(encodeInstruction(Opcode.PushNumber, index));
             return;
         }
-        case "BooleanLiteral":
+        case 'BooleanLiteral':
             state.program.push(encodeInstruction(Opcode.PushBoolean, node.value ? 1 : 0));
             return;
-        case "StringLiteral":
+        case 'StringLiteral':
             {
                 let index = state.strings.indexOf(node.value);
                 if (index === -1)
@@ -258,48 +250,48 @@ function emitNode(node, state) {
                 state.program.push(encodeInstruction(Opcode.PushString, index));
             }
             return;
-        case "ErrorLiteral":
+        case 'ErrorLiteral':
             state.program.push(encodeInstruction(Opcode.PushError, node.code));
             return;
-        case "NameRef":
-        case "StructuredRef":
-        case "SpillRef":
-            throw new Error("Defined names are not supported on the wasm fast path");
-        case "CellRef": {
+        case 'NameRef':
+        case 'StructuredRef':
+        case 'SpillRef':
+            throw new Error('Defined names are not supported on the wasm fast path');
+        case 'CellRef': {
             emitCellRef(node.ref, node.sheetName, state);
             return;
         }
-        case "RangeRef":
+        case 'RangeRef':
             emitRangeRef(node, state);
             return;
-        case "RowRef":
-        case "ColumnRef":
-            throw new Error("Row and column references must appear inside a range");
-        case "UnaryExpr":
+        case 'RowRef':
+        case 'ColumnRef':
+            throw new Error('Row and column references must appear inside a range');
+        case 'UnaryExpr':
             emitNode(node.argument, state);
-            if (node.operator === "-") {
+            if (node.operator === '-') {
                 state.program.push(encodeInstruction(Opcode.Neg));
             }
             return;
-        case "BinaryExpr":
+        case 'BinaryExpr':
             emitNode(node.left, state);
             emitNode(node.right, state);
             state.program.push(encodeInstruction({
-                "+": Opcode.Add,
-                "-": Opcode.Sub,
-                "*": Opcode.Mul,
-                "/": Opcode.Div,
-                "^": Opcode.Pow,
-                "&": Opcode.Concat,
-                "=": Opcode.Eq,
-                "<>": Opcode.Neq,
-                ">": Opcode.Gt,
-                ">=": Opcode.Gte,
-                "<": Opcode.Lt,
-                "<=": Opcode.Lte,
+                '+': Opcode.Add,
+                '-': Opcode.Sub,
+                '*': Opcode.Mul,
+                '/': Opcode.Div,
+                '^': Opcode.Pow,
+                '&': Opcode.Concat,
+                '=': Opcode.Eq,
+                '<>': Opcode.Neq,
+                '>': Opcode.Gt,
+                '>=': Opcode.Gte,
+                '<': Opcode.Lt,
+                '<=': Opcode.Lte,
             }[node.operator]));
             return;
-        case "CallExpr":
+        case 'CallExpr':
             {
                 const rewritten = rewriteSpecialCall(node);
                 if (rewritten) {
@@ -308,22 +300,22 @@ function emitNode(node, state) {
                 }
                 const callee = node.callee.toUpperCase();
                 const nativeGroupedArrayKind = getNativeGroupedArrayKind(node);
-                if (nativeGroupedArrayKind === "groupby-sum-canonical") {
+                if (nativeGroupedArrayKind === 'groupby-sum-canonical') {
                     emitArgument(node.args[0], state);
                     emitArgument(node.args[1], state);
                     state.program.push(encodeInstruction(Opcode.CallBuiltin, (BuiltinId.GroupbySumCanonical << 8) | 2));
                     return;
                 }
-                if (nativeGroupedArrayKind === "pivotby-sum-canonical") {
+                if (nativeGroupedArrayKind === 'pivotby-sum-canonical') {
                     emitArgument(node.args[0], state);
                     emitArgument(node.args[1], state);
                     emitArgument(node.args[2], state);
                     state.program.push(encodeInstruction(Opcode.CallBuiltin, (BuiltinId.PivotbySumCanonical << 8) | 3));
                     return;
                 }
-                if (callee === "IF") {
+                if (callee === 'IF') {
                     if (node.args.length !== 3) {
-                        throw new Error("IF requires exactly three arguments on the wasm fast path");
+                        throw new Error('IF requires exactly three arguments on the wasm fast path');
                     }
                     emitNode(node.args[0], state);
                     const jumpIfFalseIndex = state.program.push(encodeInstruction(Opcode.JumpIfFalse, 0)) - 1;
@@ -336,27 +328,24 @@ function emitNode(node, state) {
                     state.program[jumpIndex] = encodeInstruction(Opcode.Jump, end);
                     return;
                 }
-                if ((callee === "BYROW" || callee === "BYCOL") && node.args.length === 2) {
+                if ((callee === 'BYROW' || callee === 'BYCOL') && node.args.length === 2) {
                     const lambda = node.args[1];
                     const aggregateCode = getNativeAxisAggregateCode(lambda);
                     if (aggregateCode !== null) {
                         const aggregateIndex = state.constants.push(aggregateCode) - 1;
                         state.program.push(encodeInstruction(Opcode.PushNumber, aggregateIndex));
                         emitArgument(node.args[0], state);
-                        state.program.push(encodeInstruction(Opcode.CallBuiltin, ((callee === "BYROW" ? BuiltinId.ByrowAggregate : BuiltinId.BycolAggregate) << 8) |
-                            2));
+                        state.program.push(encodeInstruction(Opcode.CallBuiltin, ((callee === 'BYROW' ? BuiltinId.ByrowAggregate : BuiltinId.BycolAggregate) << 8) | 2));
                         return;
                     }
                 }
-                if (callee === "MAKEARRAY" &&
-                    node.args.length === 3 &&
-                    isNativeMakearraySumLambda(node.args[2])) {
+                if (callee === 'MAKEARRAY' && node.args.length === 3 && isNativeMakearraySumLambda(node.args[2])) {
                     emitArgument(node.args[0], state);
                     emitArgument(node.args[1], state);
                     state.program.push(encodeInstruction(Opcode.CallBuiltin, (BuiltinId.MakearraySum << 8) | 2));
                     return;
                 }
-                if (callee === "REDUCE" || callee === "SCAN") {
+                if (callee === 'REDUCE' || callee === 'SCAN') {
                     const sourceArg = node.args.length === 3 ? node.args[1] : node.args[0];
                     const lambdaArg = node.args.length === 3 ? node.args[2] : node.args[1];
                     const initialArg = node.args.length === 3 ? node.args[0] : undefined;
@@ -370,7 +359,7 @@ function emitNode(node, state) {
                             argc += emitArgument(initialArg, state);
                         }
                         argc += emitArgument(sourceArg, state);
-                        state.program.push(encodeInstruction(Opcode.CallBuiltin, ((callee === "REDUCE"
+                        state.program.push(encodeInstruction(Opcode.CallBuiltin, ((callee === 'REDUCE'
                             ? foldCode === 1
                                 ? BuiltinId.ReduceSum
                                 : BuiltinId.ReduceProduct
@@ -383,10 +372,7 @@ function emitNode(node, state) {
                     }
                 }
                 const rangeArg = node.args[0];
-                if (callee === "PHONETIC" &&
-                    node.args.length === 1 &&
-                    rangeArg &&
-                    isCellRangeNode(rangeArg)) {
+                if (callee === 'PHONETIC' && node.args.length === 1 && rangeArg && isCellRangeNode(rangeArg)) {
                     emitCellRef(rangeArg.start, rangeArg.sheetName, state);
                     state.program.push(encodeInstruction(Opcode.CallBuiltin, (BuiltinId.Phonetic << 8) | 1));
                     return;
@@ -398,8 +384,8 @@ function emitNode(node, state) {
                 state.program.push(encodeInstruction(Opcode.CallBuiltin, (encodeBuiltin(callee) << 8) | argc));
             }
             return;
-        case "InvokeExpr":
-            throw new Error("Lambda invocation is not supported on the wasm fast path");
+        case 'InvokeExpr':
+            throw new Error('Lambda invocation is not supported on the wasm fast path');
     }
 }
 const CELL_REFERENCE_PARTS_RE = /^(\$?)([A-Z]+)(\$?)([1-9][0-9]*)$/i;
@@ -410,41 +396,41 @@ function computeMaxStackDepth(plan) {
     let max = 0;
     for (const instruction of plan) {
         switch (instruction.opcode) {
-            case "push-number":
-            case "push-boolean":
-            case "push-string":
-            case "push-error":
-            case "push-name":
-            case "push-cell":
-            case "push-range":
-            case "push-lambda":
+            case 'push-number':
+            case 'push-boolean':
+            case 'push-string':
+            case 'push-error':
+            case 'push-name':
+            case 'push-cell':
+            case 'push-range':
+            case 'push-lambda':
                 current += 1;
                 break;
-            case "lookup-exact-match":
-            case "lookup-approximate-match":
+            case 'lookup-exact-match':
+            case 'lookup-approximate-match':
                 break;
-            case "binary":
+            case 'binary':
                 current -= 1;
                 break;
-            case "call":
+            case 'call':
                 current -= instruction.argc;
                 current += 1;
                 break;
-            case "invoke":
+            case 'invoke':
                 current -= instruction.argc;
                 current += 1;
                 break;
-            case "jump-if-false":
+            case 'jump-if-false':
                 current -= 1;
                 break;
-            case "bind-name":
+            case 'bind-name':
                 current -= 1;
                 break;
-            case "unary":
-            case "begin-scope":
-            case "end-scope":
-            case "jump":
-            case "return":
+            case 'unary':
+            case 'begin-scope':
+            case 'end-scope':
+            case 'jump':
+            case 'return':
                 break;
         }
         max = Math.max(max, current);
@@ -455,20 +441,20 @@ function parseSimpleOperand(source) {
     const trimmed = source.trim();
     if (SIMPLE_CELL_REF_RE.test(trimmed)) {
         return {
-            kind: "CellRef",
+            kind: 'CellRef',
             ref: trimmed,
         };
     }
     if (SIMPLE_NUMBER_RE.test(trimmed)) {
         return {
-            kind: "NumberLiteral",
+            kind: 'NumberLiteral',
             value: Number(trimmed),
         };
     }
     return null;
 }
 function stripSheetQualifier(reference) {
-    const bang = reference.lastIndexOf("!");
+    const bang = reference.lastIndexOf('!');
     return bang === -1 ? reference.trim() : reference.slice(bang + 1).trim();
 }
 function parseCellReferenceParts(reference) {
@@ -480,23 +466,23 @@ function parseCellReferenceParts(reference) {
     return {
         row: Number.parseInt(rowText, 10) - 1,
         col: columnToIndex(columnText),
-        rowAbsolute: rowAbsolute === "$",
-        colAbsolute: colAbsolute === "$",
+        rowAbsolute: rowAbsolute === '$',
+        colAbsolute: colAbsolute === '$',
     };
 }
 function parseAxisReferenceParts(reference, kind) {
-    const match = (kind === "row" ? ROW_REFERENCE_PARTS_RE : COLUMN_REFERENCE_PARTS_RE).exec(stripSheetQualifier(reference));
+    const match = (kind === 'row' ? ROW_REFERENCE_PARTS_RE : COLUMN_REFERENCE_PARTS_RE).exec(stripSheetQualifier(reference));
     if (!match) {
         return undefined;
     }
-    return kind === "row"
+    return kind === 'row'
         ? {
             index: Number.parseInt(match[2], 10) - 1,
-            absolute: match[1] === "$",
+            absolute: match[1] === '$',
         }
         : {
             index: columnToIndex(match[2]),
-            absolute: match[1] === "$",
+            absolute: match[1] === '$',
         };
 }
 function buildParsedCellReferenceInfo(reference) {
@@ -505,7 +491,7 @@ function buildParsedCellReferenceInfo(reference) {
     return {
         address: reference,
         ...(parsedCell.sheetName !== undefined ? { sheetName: parsedCell.sheetName } : {}),
-        ...(reference.includes("!") ? { explicitSheet: true } : {}),
+        ...(reference.includes('!') ? { explicitSheet: true } : {}),
         row: parsedCell.row,
         col: parsedCell.col,
         ...(parts
@@ -518,14 +504,14 @@ function buildParsedCellReferenceInfo(reference) {
 }
 function buildParsedRangeReferenceInfo(reference) {
     const parsedRange = parseRangeAddress(reference);
-    const bounds = parsedRange.kind === "cells"
+    const bounds = parsedRange.kind === 'cells'
         ? {
             startRow: parsedRange.start.row,
             endRow: parsedRange.end.row,
             startCol: parsedRange.start.col,
             endCol: parsedRange.end.col,
         }
-        : parsedRange.kind === "rows"
+        : parsedRange.kind === 'rows'
             ? {
                 startRow: parsedRange.start.row,
                 endRow: parsedRange.end.row,
@@ -538,32 +524,32 @@ function buildParsedRangeReferenceInfo(reference) {
                 startCol: parsedRange.start.col,
                 endCol: parsedRange.end.col,
             };
-    const separator = reference.indexOf(":");
+    const separator = reference.indexOf(':');
     const rawStart = reference.slice(0, separator).trim();
     const rawEnd = reference.slice(separator + 1).trim();
-    const cellStart = parsedRange.kind === "cells" ? parseCellReferenceParts(rawStart) : undefined;
-    const cellEnd = parsedRange.kind === "cells" ? parseCellReferenceParts(rawEnd) : undefined;
-    const rowStart = parsedRange.kind === "rows" ? parseAxisReferenceParts(rawStart, "row") : undefined;
-    const rowEnd = parsedRange.kind === "rows" ? parseAxisReferenceParts(rawEnd, "row") : undefined;
-    const colStart = parsedRange.kind === "cols" ? parseAxisReferenceParts(rawStart, "column") : undefined;
-    const colEnd = parsedRange.kind === "cols" ? parseAxisReferenceParts(rawEnd, "column") : undefined;
+    const cellStart = parsedRange.kind === 'cells' ? parseCellReferenceParts(rawStart) : undefined;
+    const cellEnd = parsedRange.kind === 'cells' ? parseCellReferenceParts(rawEnd) : undefined;
+    const rowStart = parsedRange.kind === 'rows' ? parseAxisReferenceParts(rawStart, 'row') : undefined;
+    const rowEnd = parsedRange.kind === 'rows' ? parseAxisReferenceParts(rawEnd, 'row') : undefined;
+    const colStart = parsedRange.kind === 'cols' ? parseAxisReferenceParts(rawStart, 'column') : undefined;
+    const colEnd = parsedRange.kind === 'cols' ? parseAxisReferenceParts(rawEnd, 'column') : undefined;
     return {
         address: reference,
-        kind: "range",
+        kind: 'range',
         refKind: parsedRange.kind,
         ...(parsedRange.sheetName !== undefined ? { sheetName: parsedRange.sheetName } : {}),
-        ...(rawStart.includes("!") ? { explicitSheet: true } : {}),
+        ...(rawStart.includes('!') ? { explicitSheet: true } : {}),
         startAddress: parsedRange.start.text,
         endAddress: parsedRange.end.text,
         ...bounds,
-        ...(parsedRange.kind === "cells"
+        ...(parsedRange.kind === 'cells'
             ? {
                 startRowAbsolute: cellStart?.rowAbsolute ?? false,
                 endRowAbsolute: cellEnd?.rowAbsolute ?? false,
                 startColAbsolute: cellStart?.colAbsolute ?? false,
                 endColAbsolute: cellEnd?.colAbsolute ?? false,
             }
-            : parsedRange.kind === "rows"
+            : parsedRange.kind === 'rows'
                 ? {
                     startRowAbsolute: rowStart?.absolute ?? false,
                     endRowAbsolute: rowEnd?.absolute ?? false,
@@ -575,11 +561,11 @@ function buildParsedRangeReferenceInfo(reference) {
     };
 }
 function parseDependencyReference(reference) {
-    if (reference.includes(":")) {
+    if (reference.includes(':')) {
         return buildParsedRangeReferenceInfo(reference);
     }
     return {
-        kind: "cell",
+        kind: 'cell',
         ...buildParsedCellReferenceInfo(reference),
     };
 }
@@ -600,28 +586,28 @@ function buildSimpleCompiledFormula(source) {
         const index = refs.push(ref) - 1;
         parsedRefs.push(buildParsedCellReferenceInfo(ref));
         deps.push(ref);
-        parsedDeps.push({ kind: "cell", ...buildParsedCellReferenceInfo(ref) });
+        parsedDeps.push({ kind: 'cell', ...buildParsedCellReferenceInfo(ref) });
         return index;
     };
     const emitOperand = (operand, plan) => {
-        if (operand.kind === "CellRef") {
+        if (operand.kind === 'CellRef') {
             const index = registerCellRef(operand.ref);
             program.push(encodeInstruction(Opcode.PushCell, index));
-            plan.push({ opcode: "push-cell", address: operand.ref });
+            plan.push({ opcode: 'push-cell', address: operand.ref });
             return;
         }
-        if (operand.kind === "NumberLiteral") {
+        if (operand.kind === 'NumberLiteral') {
             const index = constants.push(operand.value) - 1;
             program.push(encodeInstruction(Opcode.PushNumber, index));
-            plan.push({ opcode: "push-number", value: operand.value });
+            plan.push({ opcode: 'push-number', value: operand.value });
             return;
         }
         throw new Error(`Unsupported simple operand '${operand.kind}'`);
     };
-    if (singleOperand?.kind === "CellRef") {
+    if (singleOperand?.kind === 'CellRef') {
         const jsPlan = [];
         emitOperand(singleOperand, jsPlan);
-        jsPlan.push({ opcode: "return" });
+        jsPlan.push({ opcode: 'return' });
         program.push(encodeInstruction(Opcode.Ret));
         return {
             id: 0,
@@ -660,15 +646,15 @@ function buildSimpleCompiledFormula(source) {
     if (!binaryMatch) {
         return null;
     }
-    const left = parseSimpleOperand(binaryMatch[1] ?? "");
+    const left = parseSimpleOperand(binaryMatch[1] ?? '');
     const operatorCandidate = binaryMatch[2];
-    const operator = operatorCandidate === "+" || operatorCandidate === "*" ? operatorCandidate : undefined;
-    const right = parseSimpleOperand(binaryMatch[3] ?? "");
+    const operator = operatorCandidate === '+' || operatorCandidate === '*' ? operatorCandidate : undefined;
+    const right = parseSimpleOperand(binaryMatch[3] ?? '');
     if (!left || !right || !operator) {
         return null;
     }
     const ast = {
-        kind: "BinaryExpr",
+        kind: 'BinaryExpr',
         operator,
         left,
         right,
@@ -676,9 +662,9 @@ function buildSimpleCompiledFormula(source) {
     const jsPlan = [];
     emitOperand(left, jsPlan);
     emitOperand(right, jsPlan);
-    jsPlan.push({ opcode: "binary", operator });
-    jsPlan.push({ opcode: "return" });
-    program.push(encodeInstruction(operator === "+" ? Opcode.Add : Opcode.Mul));
+    jsPlan.push({ opcode: 'binary', operator });
+    jsPlan.push({ opcode: 'return' });
+    program.push(encodeInstruction(operator === '+' ? Opcode.Add : Opcode.Mul));
     program.push(encodeInstruction(Opcode.Ret));
     return {
         id: 0,
@@ -714,31 +700,29 @@ function buildSimpleCompiledFormula(source) {
     };
 }
 function buildDirectAggregateCandidate(node, symbolicRanges) {
-    if (node.kind !== "CallExpr" || node.args.length !== 1) {
+    if (node.kind !== 'CallExpr' || node.args.length !== 1) {
         return undefined;
     }
     const callee = node.callee.trim().toUpperCase();
-    const aggregateKind = callee === "SUM"
-        ? "sum"
-        : callee === "COUNT"
-            ? "count"
-            : callee === "MIN"
-                ? "min"
-                : callee === "MAX"
-                    ? "max"
-                    : callee === "AVERAGE" || callee === "AVG"
-                        ? "average"
+    const aggregateKind = callee === 'SUM'
+        ? 'sum'
+        : callee === 'COUNT'
+            ? 'count'
+            : callee === 'MIN'
+                ? 'min'
+                : callee === 'MAX'
+                    ? 'max'
+                    : callee === 'AVERAGE' || callee === 'AVG'
+                        ? 'average'
                         : undefined;
     if (!aggregateKind) {
         return undefined;
     }
     const rangeNode = node.args[0];
-    if (!rangeNode || rangeNode.kind !== "RangeRef" || rangeNode.refKind !== "cells") {
+    if (!rangeNode || rangeNode.kind !== 'RangeRef' || rangeNode.refKind !== 'cells') {
         return undefined;
     }
-    const qualifiedRange = formatRangeAddress(parseRangeAddress(rangeNode.sheetName
-        ? `${rangeNode.sheetName}!${rangeNode.start}:${rangeNode.end}`
-        : `${rangeNode.start}:${rangeNode.end}`));
+    const qualifiedRange = formatRangeAddress(parseRangeAddress(rangeNode.sheetName ? `${rangeNode.sheetName}!${rangeNode.start}:${rangeNode.end}` : `${rangeNode.start}:${rangeNode.end}`));
     const symbolicRangeIndex = symbolicRanges.indexOf(qualifiedRange);
     if (symbolicRangeIndex === -1) {
         return undefined;