@devmm/puredocs-excel-formula 1.0.0 → 1.0.1

package/dist/index.js

@@ -1,4 +1,4 @@
-import { toOADate, fromOADate, parseCellRef, cellRefFromRowCol } from '@devmm/puredocs-excel';
+import { toOADate, fromOADate, columnLetter, parseCellRef, cellRefFromRowCol } from '@devmm/puredocs-excel';
 
 var __typeError = (msg) => {
   throw TypeError(msg);
@@ -29,15 +29,21 @@ var FormulaError = /* @__PURE__ */ ((FormulaError2) => {
   FormulaError2[FormulaError2["Spill"] = 9] = "Spill";
   return FormulaError2;
 })(FormulaError || {});
+var TailCall = class {
+  constructor(lambda, args) {
+    this.lambda = lambda;
+    this.args = args;
+  }
+};
 var _num, _obj;
 var _FormulaValue = class _FormulaValue {
-  constructor(kind, num4 = 0, obj, errorCode = 0 /* None */) {
+  constructor(kind, num5 = 0, obj, errorCode = 0 /* None */) {
     /** Numeric payload (also used for boolean: 1=true, 0=false). */
     __privateAdd(this, _num);
-    /** String or ArrayValue payload. */
+    /** String, ArrayValue, or LambdaLike payload. */
     __privateAdd(this, _obj);
     this.kind = kind;
-    __privateSet(this, _num, num4);
+    __privateSet(this, _num, num5);
     __privateSet(this, _obj, obj);
     this.errorCode = errorCode;
   }
@@ -77,6 +83,9 @@ var _FormulaValue = class _FormulaValue {
   static array(a) {
     return new _FormulaValue("array", 0, a);
   }
+  static lambda(fn) {
+    return new _FormulaValue("lambda", 0, fn);
+  }
   // ── Type checks ──────────────────────────────────────────────────────────
   get isBlank() {
     return this.kind === "blank";
@@ -96,6 +105,9 @@ var _FormulaValue = class _FormulaValue {
   get isArray() {
     return this.kind === "array";
   }
+  get isLambda() {
+    return this.kind === "lambda";
+  }
   get isNumeric() {
     return this.kind === "number" || this.kind === "boolean" || this.kind === "blank";
   }
@@ -112,6 +124,9 @@ var _FormulaValue = class _FormulaValue {
   get arrayVal() {
     return __privateGet(this, _obj) ?? ArrayValue.empty;
   }
+  get lambdaVal() {
+    return __privateGet(this, _obj);
+  }
   // ── Coercion (Excel semantics, no exceptions) ─────────────────────────────
   coerceToNumber() {
     switch (this.kind) {
@@ -179,6 +194,8 @@ var _FormulaValue = class _FormulaValue {
         return "";
       case "error":
         return _FormulaValue.errorToString(this.errorCode);
+      case "lambda":
+        return _FormulaValue.errorToString(8 /* Calc */);
       default:
         return "";
     }
@@ -276,6 +293,8 @@ var _FormulaValue = class _FormulaValue {
         return _FormulaValue.errorToString(this.errorCode);
       case "array":
         return this.arrayVal.toObjectArray();
+      case "lambda":
+        return _FormulaValue.errorToString(8 /* Calc */);
       default:
         return null;
     }
@@ -424,10 +443,11 @@ var TokenType = /* @__PURE__ */ ((TokenType2) => {
   TokenType2[TokenType2["GreaterThanOrEqual"] = 21] = "GreaterThanOrEqual";
   TokenType2[TokenType2["SheetReference"] = 22] = "SheetReference";
   TokenType2[TokenType2["NamedRange"] = 23] = "NamedRange";
-  TokenType2[TokenType2["Exclamation"] = 24] = "Exclamation";
-  TokenType2[TokenType2["AtSign"] = 25] = "AtSign";
-  TokenType2[TokenType2["ErrorLiteral"] = 26] = "ErrorLiteral";
-  TokenType2[TokenType2["EOF"] = 27] = "EOF";
+  TokenType2[TokenType2["SpillReference"] = 24] = "SpillReference";
+  TokenType2[TokenType2["Exclamation"] = 25] = "Exclamation";
+  TokenType2[TokenType2["AtSign"] = 26] = "AtSign";
+  TokenType2[TokenType2["ErrorLiteral"] = 27] = "ErrorLiteral";
+  TokenType2[TokenType2["EOF"] = 28] = "EOF";
   return TokenType2;
 })(TokenType || {});
 function makeToken(type, value2, position) {
@@ -470,7 +490,7 @@ var FormulaLexer = class {
       const token = __privateMethod(this, _FormulaLexer_instances, readNextToken_fn).call(this);
       if (token) tokens.push(token);
     }
-    tokens.push(makeToken(27 /* EOF */, "", __privateGet(this, _pos)));
+    tokens.push(makeToken(28 /* EOF */, "", __privateGet(this, _pos)));
     return tokens;
   }
 };
@@ -524,7 +544,7 @@ readErrorLiteral_fn = function() {
   if (!KNOWN_ERRORS.has(upper2)) {
     throw new FormulaException(`Unknown error literal "${raw}" at position ${start}.`);
   }
-  return makeToken(26 /* ErrorLiteral */, upper2, start);
+  return makeToken(27 /* ErrorLiteral */, upper2, start);
 };
 readQuotedSheetRef_fn = function() {
   const start = __privateWrapper(this, _pos)._++;
@@ -603,7 +623,13 @@ readIdentifier_fn = function() {
     return makeToken(5 /* Function */, upper2, start);
   }
   const stripped = raw.replace(/\$/g, "");
-  if (isCellRef(stripped)) return makeToken(3 /* CellReference */, stripped, start);
+  if (isCellRef(stripped)) {
+    if (__privateGet(this, _formula)[__privateGet(this, _pos)] === "#") {
+      __privateWrapper(this, _pos)._++;
+      return makeToken(24 /* SpillReference */, stripped, start);
+    }
+    return makeToken(3 /* CellReference */, stripped, start);
+  }
   return makeToken(23 /* NamedRange */, raw, start);
 };
 readCellRefChars_fn = function() {
@@ -646,9 +672,9 @@ readOperator_fn = function() {
     case "=":
       return makeToken(16 /* Equal */, "=", start);
     case "@":
-      return makeToken(25 /* AtSign */, "@", start);
+      return makeToken(26 /* AtSign */, "@", start);
     case "!":
-      return makeToken(24 /* Exclamation */, "!", start);
+      return makeToken(25 /* Exclamation */, "!", start);
     case "<":
       if (__privateGet(this, _formula)[__privateGet(this, _pos)] === ">") {
         __privateWrapper(this, _pos)._++;
@@ -685,6 +711,15 @@ function isCellRef(s) {
 
 // src/formula-node.ts
 var FormulaNode = class {
+  /**
+   * Evaluates this node in tail position. Returns a TailCall when the node's
+   * value is a call to a lambda in tail position (so the caller's trampoline can
+   * iterate without growing the stack); otherwise the final value. The default
+   * is a plain evaluate — only control-flow and call nodes override it.
+   */
+  evaluateTail(ctx) {
+    return this.evaluate(ctx);
+  }
 };
 var NumberNode = class extends FormulaNode {
   constructor(value2) {
@@ -776,6 +811,15 @@ var NamedRangeNode = class extends FormulaNode {
     return ctx.resolveNamedRange(this.name);
   }
 };
+var SpillReferenceNode = class extends FormulaNode {
+  constructor(anchorRef) {
+    super();
+    this.anchorRef = anchorRef;
+  }
+  evaluate(ctx) {
+    return ctx.resolveSpillRange(this.anchorRef);
+  }
+};
 var BinaryOperator = /* @__PURE__ */ ((BinaryOperator2) => {
   BinaryOperator2[BinaryOperator2["Add"] = 0] = "Add";
   BinaryOperator2[BinaryOperator2["Subtract"] = 1] = "Subtract";
@@ -899,10 +943,85 @@ var FunctionCallNode = class extends FormulaNode {
   evaluate(ctx) {
     return ctx.evaluateFunction(this.functionName, this.args);
   }
+  evaluateTail(ctx) {
+    const name = this.functionName;
+    const a = this.args;
+    switch (name) {
+      case "IF": {
+        const cond = a[0].evaluate(ctx);
+        if (cond.isError) return cond;
+        const b = cond.coerceToBool();
+        if (b.isError) return b;
+        if (b.booleanValue) return a[1].evaluateTail(ctx);
+        return a.length > 2 ? a[2].evaluateTail(ctx) : FormulaValue.false_;
+      }
+      case "IFS": {
+        for (let i = 0; i + 1 < a.length; i += 2) {
+          const cond = a[i].evaluate(ctx);
+          if (cond.isError) return cond;
+          const b = cond.coerceToBool();
+          if (b.isError) return b;
+          if (b.booleanValue) return a[i + 1].evaluateTail(ctx);
+        }
+        return FormulaValue.errorNA;
+      }
+      case "IFERROR": {
+        const v = a[0].evaluate(ctx);
+        return v.isError ? a[1].evaluateTail(ctx) : v;
+      }
+      case "IFNA": {
+        const v = a[0].evaluate(ctx);
+        return v.isError && v.errorCode === 7 /* NA */ ? a[1].evaluateTail(ctx) : v;
+      }
+      case "LET": {
+        if (a.length < 3 || a.length % 2 === 0) break;
+        const bindings = /* @__PURE__ */ new Map();
+        ctx.pushScope(bindings);
+        try {
+          for (let i = 0; i < a.length - 1; i += 2) {
+            const nn = a[i];
+            if (!(nn instanceof NamedRangeNode)) return FormulaValue.errorValue;
+            const val = a[i + 1].evaluate(ctx);
+            if (val.isError) return val;
+            bindings.set(nn.name.toUpperCase(), val);
+          }
+          return a[a.length - 1].evaluateTail(ctx);
+        } finally {
+          ctx.popScope();
+        }
+      }
+    }
+    if (!ctx.hasFunction(name)) {
+      const named = ctx.resolveNamedRange(name);
+      if (named.isLambda) {
+        return new TailCall(named.lambdaVal, a.map((arg2) => arg2.evaluate(ctx)));
+      }
+    }
+    return this.evaluate(ctx);
+  }
+};
+var CallNode = class extends FormulaNode {
+  constructor(callee, args) {
+    super();
+    this.callee = callee;
+    this.args = args;
+  }
+  evaluate(ctx) {
+    const fn = this.callee.evaluate(ctx);
+    if (fn.isError) return fn;
+    if (!fn.isLambda) return FormulaValue.errorValue;
+    return fn.lambdaVal.call(this.args.map((a) => a.evaluate(ctx)));
+  }
+  evaluateTail(ctx) {
+    const fn = this.callee.evaluate(ctx);
+    if (fn.isError) return fn;
+    if (!fn.isLambda) return FormulaValue.errorValue;
+    return new TailCall(fn.lambdaVal, this.args.map((a) => a.evaluate(ctx)));
+  }
 };
 
 // src/formula-parser.ts
-var _tokens, _pos2, _FormulaParser_instances, current_get, advance_fn, expect_fn, parseComparison_fn, parseConcatenation_fn, parseAddSub_fn, parseMulDiv_fn, parseUnary_fn, parsePower_fn, parsePercent_fn, parsePrimary_fn, parseFunction_fn;
+var _tokens, _pos2, _FormulaParser_instances, current_get, advance_fn, expect_fn, parseComparison_fn, parseConcatenation_fn, parseAddSub_fn, parseMulDiv_fn, parseUnary_fn, parsePower_fn, parsePercent_fn, parsePostfix_fn, parsePrimary_fn, parseFunction_fn, parseArgList_fn;
 var FormulaParser = class {
   constructor(tokens) {
     __privateAdd(this, _FormulaParser_instances);
@@ -913,7 +1032,7 @@ var FormulaParser = class {
   parse() {
     __privateSet(this, _pos2, 0);
     const node = __privateMethod(this, _FormulaParser_instances, parseComparison_fn).call(this);
-    if (__privateGet(this, _FormulaParser_instances, current_get).type !== 27 /* EOF */) {
+    if (__privateGet(this, _FormulaParser_instances, current_get).type !== 28 /* EOF */) {
       throw new FormulaException(
         `Unexpected token '${__privateGet(this, _FormulaParser_instances, current_get).value}' at position ${__privateGet(this, _FormulaParser_instances, current_get).position}.`
       );
@@ -925,7 +1044,7 @@ _tokens = new WeakMap();
 _pos2 = new WeakMap();
 _FormulaParser_instances = new WeakSet();
 current_get = function() {
-  return __privateGet(this, _tokens)[__privateGet(this, _pos2)] ?? { type: 27 /* EOF */, value: "", position: -1 };
+  return __privateGet(this, _tokens)[__privateGet(this, _pos2)] ?? { type: 28 /* EOF */, value: "", position: -1 };
 };
 advance_fn = function() {
   const t = __privateGet(this, _FormulaParser_instances, current_get);
@@ -990,7 +1109,7 @@ parseUnary_fn = function() {
     __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
     return new UnaryOpNode(1 /* Plus */, __privateMethod(this, _FormulaParser_instances, parsePower_fn).call(this));
   }
-  if (__privateGet(this, _FormulaParser_instances, current_get).type === 25 /* AtSign */) {
+  if (__privateGet(this, _FormulaParser_instances, current_get).type === 26 /* AtSign */) {
     __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
     return new ImplicitIntersectionNode(__privateMethod(this, _FormulaParser_instances, parsePower_fn).call(this));
   }
@@ -1005,13 +1124,22 @@ parsePower_fn = function() {
   return left2;
 };
 parsePercent_fn = function() {
-  let node = __privateMethod(this, _FormulaParser_instances, parsePrimary_fn).call(this);
+  let node = __privateMethod(this, _FormulaParser_instances, parsePostfix_fn).call(this);
   while (__privateGet(this, _FormulaParser_instances, current_get).type === 14 /* Percent */) {
     __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
     node = new UnaryOpNode(2 /* Percent */, node);
   }
   return node;
 };
+/** Handles postfix call syntax on an expression, e.g. LAMBDA(x,x+1)(5). */
+parsePostfix_fn = function() {
+  let node = __privateMethod(this, _FormulaParser_instances, parsePrimary_fn).call(this);
+  while (__privateGet(this, _FormulaParser_instances, current_get).type === 6 /* LeftParen */) {
+    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+    node = new CallNode(node, __privateMethod(this, _FormulaParser_instances, parseArgList_fn).call(this));
+  }
+  return node;
+};
 parsePrimary_fn = function() {
   const token = __privateGet(this, _FormulaParser_instances, current_get);
   switch (token.type) {
@@ -1027,7 +1155,7 @@ parsePrimary_fn = function() {
     case 2 /* Boolean */:
       __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
       return new BooleanNode(token.value === "TRUE");
-    case 26 /* ErrorLiteral */:
+    case 27 /* ErrorLiteral */:
       __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
       return new ErrorNode(FormulaValue.error(FormulaValue.errorFromString(token.value)));
     case 3 /* CellReference */: {
@@ -1054,6 +1182,9 @@ parsePrimary_fn = function() {
     case 23 /* NamedRange */:
       __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
       return new NamedRangeNode(token.value);
+    case 24 /* SpillReference */:
+      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+      return new SpillReferenceNode(token.value);
     case 5 /* Function */:
       return __privateMethod(this, _FormulaParser_instances, parseFunction_fn).call(this);
     case 6 /* LeftParen */: {
@@ -1071,6 +1202,10 @@ parsePrimary_fn = function() {
 parseFunction_fn = function() {
   const nameToken = __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
   __privateMethod(this, _FormulaParser_instances, expect_fn).call(this, 6 /* LeftParen */);
+  return new FunctionCallNode(nameToken.value.toUpperCase(), __privateMethod(this, _FormulaParser_instances, parseArgList_fn).call(this));
+};
+/** Parses a comma-separated argument list up to and including the ')'. */
+parseArgList_fn = function() {
   const args = [];
   if (__privateGet(this, _FormulaParser_instances, current_get).type !== 7 /* RightParen */) {
     if (__privateGet(this, _FormulaParser_instances, current_get).type === 8 /* Comma */) {
@@ -1088,7 +1223,7 @@ parseFunction_fn = function() {
     }
   }
   __privateMethod(this, _FormulaParser_instances, expect_fn).call(this, 7 /* RightParen */);
-  return new FunctionCallNode(nameToken.value.toUpperCase(), args);
+  return args;
 };
 function comparisonOp(type) {
   switch (type) {
@@ -1119,10 +1254,14 @@ function registerMath(r) {
   r.register("COUNTA", countA, 1);
   r.register("COUNTBLANK", countBlank, 1, 1);
   r.register("COUNTIF", countIf, 2, 2);
+  r.register("COUNTIFS", countIfs, 2);
   r.register("SUMIF", sumIf, 2, 3);
+  r.register("SUMIFS", sumIfs, 3);
   r.register("AVERAGEIF", averageIf, 2, 3);
+  r.register("AVERAGEIFS", averageIfs, 3);
   r.register("PRODUCT", product, 1);
   r.register("SUMPRODUCT", sumProduct, 1);
+  r.register("SUMSQ", sumSq, 1);
   r.register("ABS", abs, 1, 1);
   r.register("ROUND", round, 2, 2);
   r.register("ROUNDUP", roundUp, 2, 2);
@@ -1147,6 +1286,114 @@ function registerMath(r) {
   r.register("EXP", exp, 1, 1);
   r.register("FACT", fact, 1, 1);
   r.register("COMBIN", combin, 2, 2);
+  r.register("SIN", unary(Math.sin), 1, 1);
+  r.register("COS", unary(Math.cos), 1, 1);
+  r.register("TAN", unary(Math.tan), 1, 1);
+  r.register("ASIN", asin, 1, 1);
+  r.register("ACOS", acos, 1, 1);
+  r.register("ATAN", unary(Math.atan), 1, 1);
+  r.register("ATAN2", atan2, 2, 2);
+  r.register("SINH", unary(Math.sinh), 1, 1);
+  r.register("COSH", unary(Math.cosh), 1, 1);
+  r.register("TANH", unary(Math.tanh), 1, 1);
+  r.register("DEGREES", unary((r2d) => r2d * 180 / Math.PI), 1, 1);
+  r.register("RADIANS", unary((d) => d * Math.PI / 180), 1, 1);
+}
+function valueAt(v, i) {
+  return v.isArray ? v.arrayVal.getFlat(i) : v;
+}
+function lengthOf(v) {
+  return v.isArray ? v.arrayVal.length : 1;
+}
+function computeIfsMask(a, c, startIdx, len2) {
+  const mask = new Uint8Array(len2).fill(1);
+  for (let p = startIdx; p + 1 < a.length; p += 2) {
+    const cr = a[p].evaluate(c);
+    if (cr.isError) return { ok: false, error: cr };
+    const crit = a[p + 1].evaluate(c);
+    if (crit.isError) return { ok: false, error: crit };
+    const critText = crit.asText();
+    for (let i = 0; i < len2; i++) {
+      if (!mask[i]) continue;
+      if (!FormulaHelper.matchesCriteria(valueAt(cr, i), critText)) mask[i] = 0;
+    }
+  }
+  return { ok: true, mask };
+}
+function sumIfs(a, c) {
+  if (a.length < 3 || a.length % 2 === 0) return FormulaValue.errorValue;
+  const sumRange = a[0].evaluate(c);
+  if (sumRange.isError) return sumRange;
+  const len2 = lengthOf(sumRange);
+  const m = computeIfsMask(a, c, 1, len2);
+  if (!m.ok) return m.error;
+  let total = 0;
+  for (let i = 0; i < len2; i++) {
+    if (!m.mask[i]) continue;
+    const r = valueAt(sumRange, i).tryAsDouble();
+    if (r.ok) total += r.value;
+  }
+  return FormulaValue.number(total);
+}
+function countIfs(a, c) {
+  if (a.length < 2 || a.length % 2 !== 0) return FormulaValue.errorValue;
+  const first = a[0].evaluate(c);
+  if (first.isError) return first;
+  const len2 = lengthOf(first);
+  const m = computeIfsMask(a, c, 0, len2);
+  if (!m.ok) return m.error;
+  let n = 0;
+  for (let i = 0; i < len2; i++) if (m.mask[i]) n++;
+  return FormulaValue.number(n);
+}
+function averageIfs(a, c) {
+  if (a.length < 3 || a.length % 2 === 0) return FormulaValue.errorValue;
+  const avgRange = a[0].evaluate(c);
+  if (avgRange.isError) return avgRange;
+  const len2 = lengthOf(avgRange);
+  const m = computeIfsMask(a, c, 1, len2);
+  if (!m.ok) return m.error;
+  let total = 0, cnt = 0;
+  for (let i = 0; i < len2; i++) {
+    if (!m.mask[i]) continue;
+    const r = valueAt(avgRange, i).tryAsDouble();
+    if (r.ok) {
+      total += r.value;
+      cnt++;
+    }
+  }
+  return cnt === 0 ? FormulaValue.errorDiv0 : FormulaValue.number(total / cnt);
+}
+function sumSq(a, c) {
+  const r = FormulaHelper.collectNumbers(a, c);
+  if (!r.ok) return r.error;
+  return FormulaValue.number(r.values.reduce((s, n) => s + n * n, 0));
+}
+function unary(fn) {
+  return (a, c) => {
+    const r = FormulaHelper.evalDouble(a[0], c);
+    return r.ok ? FormulaValue.number(fn(r.value)) : r.error;
+  };
+}
+function asin(a, c) {
+  const r = FormulaHelper.evalDouble(a[0], c);
+  if (!r.ok) return r.error;
+  if (r.value < -1 || r.value > 1) return FormulaValue.errorNum;
+  return FormulaValue.number(Math.asin(r.value));
+}
+function acos(a, c) {
+  const r = FormulaHelper.evalDouble(a[0], c);
+  if (!r.ok) return r.error;
+  if (r.value < -1 || r.value > 1) return FormulaValue.errorNum;
+  return FormulaValue.number(Math.acos(r.value));
+}
+function atan2(a, c) {
+  const x = FormulaHelper.evalDouble(a[0], c);
+  if (!x.ok) return x.error;
+  const y = FormulaHelper.evalDouble(a[1], c);
+  if (!y.ok) return y.error;
+  if (x.value === 0 && y.value === 0) return FormulaValue.errorDiv0;
+  return FormulaValue.number(Math.atan2(y.value, x.value));
 }
 function sum(a, c) {
   const r = FormulaHelper.collectNumbers(a, c);
@@ -1265,7 +1512,7 @@ function product(a, c) {
   return FormulaValue.number(r.values.reduce((p, n) => p * n, 1));
 }
 function sumProduct(a, c) {
-  const arrays = a.map((arg) => arg.evaluate(c));
+  const arrays = a.map((arg2) => arg2.evaluate(c));
   for (const v of arrays) if (v.isError) return v;
   const first = arrays[0];
   const len2 = first.isArray ? first.arrayVal.length : 1;
@@ -1466,6 +1713,8 @@ function registerText(r) {
   r.register("CHAR", char_, 1, 1);
   r.register("CODE", code, 1, 1);
   r.register("T", t_, 1, 1);
+  r.register("TEXTBEFORE", textBefore, 2, 3);
+  r.register("TEXTAFTER", textAfter, 2, 3);
 }
 function str(a, c, idx) {
   const r = FormulaHelper.evalString(a[idx], c);
@@ -1594,8 +1843,8 @@ function replace(a, c) {
 }
 function concatenate(a, c) {
   let result = "";
-  for (const arg of a) {
-    const v = arg.evaluate(c);
+  for (const arg2 of a) {
+    const v = arg2.evaluate(c);
     if (v.isError) return v;
     result += v.asText();
   }
@@ -1722,6 +1971,45 @@ function t_(a, c) {
   const v = a[0].evaluate(c);
   return v.isText ? v : FormulaValue.emptyString;
 }
+function textBefore(a, c) {
+  return textSplitAt(a, c, "before");
+}
+function textAfter(a, c) {
+  return textSplitAt(a, c, "after");
+}
+function textSplitAt(a, c, mode2) {
+  const s = str(a, c, 0);
+  if (!s.ok) return s.e;
+  const d = str(a, c, 1);
+  if (!d.ok) return d.e;
+  let instance = 1;
+  if (a.length > 2) {
+    const r = num(a, c, 2);
+    if (!r.ok) return r.e;
+    instance = Math.trunc(r.n);
+  }
+  if (instance === 0) return FormulaValue.errorValue;
+  const text = s.s;
+  const delim = d.s;
+  if (delim === "") {
+    return FormulaValue.text(mode2 === "before" ? "" : text);
+  }
+  const positions = [];
+  let from = 0;
+  for (; ; ) {
+    const idx = text.indexOf(delim, from);
+    if (idx === -1) break;
+    positions.push(idx);
+    from = idx + delim.length;
+  }
+  if (positions.length === 0) return FormulaValue.errorNA;
+  const nth = instance > 0 ? instance - 1 : positions.length + instance;
+  if (nth < 0 || nth >= positions.length) return FormulaValue.errorNA;
+  const pos = positions[nth];
+  return FormulaValue.text(
+    mode2 === "before" ? text.slice(0, pos) : text.slice(pos + delim.length)
+  );
+}
 
 // src/functions/logical-functions.ts
 function registerLogical(r) {
@@ -1746,8 +2034,8 @@ function if_(a, c) {
 }
 function and(a, c) {
   let hasValue = false;
-  for (const arg of a) {
-    const v = arg.evaluate(c);
+  for (const arg2 of a) {
+    const v = arg2.evaluate(c);
     if (v.isError) return v;
     if (v.isArray) {
       for (const item of v.arrayVal.values()) {
@@ -1773,8 +2061,8 @@ function and(a, c) {
 }
 function or(a, c) {
   let hasValue = false;
-  for (const arg of a) {
-    const v = arg.evaluate(c);
+  for (const arg2 of a) {
+    const v = arg2.evaluate(c);
     if (v.isError) return v;
     if (v.isArray) {
       for (const item of v.arrayVal.values()) {
@@ -1807,8 +2095,8 @@ function not(a, c) {
 }
 function xor(a, c) {
   let trueCount = 0;
-  for (const arg of a) {
-    const v = arg.evaluate(c);
+  for (const arg2 of a) {
+    const v = arg2.evaluate(c);
     if (v.isError) return v;
     const bv = v.coerceToBool();
     if (bv.isError) return bv;
@@ -2068,14 +2356,17 @@ function datedif(a, c) {
 function registerLookup(r) {
   r.register("VLOOKUP", vlookup, 3, 4);
   r.register("HLOOKUP", hlookup, 3, 4);
+  r.register("LOOKUP", lookup, 2, 3);
   r.register("INDEX", index_, 2, 3);
   r.register("MATCH", match, 2, 3);
   r.register("CHOOSE", choose, 2);
+  r.register("ADDRESS", address, 2, 5);
   r.register("ROW", row, 0, 1);
   r.register("COLUMN", column, 0, 1);
   r.register("ROWS", rows, 1, 1);
   r.register("COLUMNS", columns, 1, 1);
   r.register("OFFSET", offset, 3, 5, true);
+  r.register("INDIRECT", indirect, 1, 2, true);
 }
 function num2(a, c, i) {
   const r = FormulaHelper.evalDouble(a[i], c);
@@ -2204,6 +2495,86 @@ function choose(a, c) {
   if (idx < 1 || idx >= a.length) return FormulaValue.errorValue;
   return a[idx].evaluate(c);
 }
+function approxMatchFlat(arr, lookupVal) {
+  let best = -1;
+  for (let i = 0; i < arr.length; i++) {
+    if (FormulaValue.compare(arr.getFlat(i), lookupVal) <= 0) best = i;
+    else break;
+  }
+  return best;
+}
+function lookup(a, c) {
+  const lookupVal = a[0].evaluate(c);
+  if (lookupVal.isError) return lookupVal;
+  const vecVal = a[1].evaluate(c);
+  if (vecVal.isError) return vecVal;
+  if (a.length > 2) {
+    const resVal = a[2].evaluate(c);
+    if (resVal.isError) return resVal;
+    const vecArr = vecVal.isArray ? vecVal.arrayVal : ArrayValue.fromScalar(vecVal);
+    const idx = approxMatchFlat(vecArr, lookupVal);
+    if (idx < 0) return FormulaValue.errorNA;
+    if (resVal.isArray) return resVal.arrayVal.getFlat(idx);
+    return idx === 0 ? resVal : FormulaValue.errorNA;
+  }
+  if (!vecVal.isArray) {
+    return FormulaValue.areEqual(vecVal, lookupVal) ? vecVal : FormulaValue.errorNA;
+  }
+  const arr = vecVal.arrayVal;
+  if (arr.columns >= arr.rows) {
+    let best2 = -1;
+    for (let col = 0; col < arr.columns; col++) {
+      if (FormulaValue.compare(arr.get(0, col), lookupVal) <= 0) best2 = col;
+      else break;
+    }
+    return best2 >= 0 ? arr.get(arr.rows - 1, best2) : FormulaValue.errorNA;
+  }
+  let best = -1;
+  for (let r = 0; r < arr.rows; r++) {
+    if (FormulaValue.compare(arr.get(r, 0), lookupVal) <= 0) best = r;
+    else break;
+  }
+  return best >= 0 ? arr.get(best, arr.columns - 1) : FormulaValue.errorNA;
+}
+function address(a, c) {
+  const rn = num2(a, c, 0);
+  if (!rn.ok) return rn.e;
+  const cn = num2(a, c, 1);
+  if (!cn.ok) return cn.e;
+  const row2 = Math.round(rn.n);
+  const col = Math.round(cn.n);
+  if (row2 < 1 || col < 1) return FormulaValue.errorValue;
+  let absNum = 1;
+  if (a.length > 2) {
+    const r = num2(a, c, 2);
+    if (!r.ok) return r.e;
+    absNum = Math.round(r.n);
+  }
+  if (absNum < 1 || absNum > 4) return FormulaValue.errorValue;
+  let a1 = true;
+  if (a.length > 3) {
+    const v = a[3].evaluate(c);
+    if (v.isError) return v;
+    a1 = v.isBlank ? true : v.coerceToBool().booleanValue;
+  }
+  let sheetPrefix = "";
+  if (a.length > 4) {
+    const s = FormulaHelper.evalString(a[4], c);
+    if (!s.ok) return s.error;
+    if (s.value !== "") sheetPrefix = `${s.value}!`;
+  }
+  const rowAbs = absNum === 1 || absNum === 2;
+  const colAbs = absNum === 1 || absNum === 3;
+  let ref;
+  if (a1) {
+    ref = `${colAbs ? "$" : ""}${columnLetter(col)}${rowAbs ? "$" : ""}${row2}`;
+  } else {
+    const rPart = rowAbs ? `R${row2}` : `R[${row2}]`;
+    const cPart = colAbs ? `C${col}` : `C[${col}]`;
+    ref = `${rPart}${cPart}`;
+  }
+  return FormulaValue.text(`${sheetPrefix}${ref}`);
+}
 function row(a, c) {
   if (a.length === 0) return FormulaValue.number(c.formulaRow || 1);
   const node = a[0];
@@ -2242,6 +2613,61 @@ function columns(a, c) {
   const v = a[0].evaluate(c);
   return v.isArray ? FormulaValue.number(v.arrayVal.columns) : FormulaValue.one;
 }
+function indirect(a, c) {
+  const s = FormulaHelper.evalString(a[0], c);
+  if (!s.ok) return s.error;
+  let a1 = true;
+  if (a.length > 1) {
+    const v = a[1].evaluate(c);
+    if (v.isError) return v;
+    a1 = v.isBlank ? true : v.coerceToBool().booleanValue;
+  }
+  const text = s.value.trim();
+  if (text === "") return FormulaValue.errorRef;
+  let sheet;
+  let body = text;
+  const bang = text.lastIndexOf("!");
+  if (bang >= 0) {
+    sheet = text.slice(0, bang).replace(/^'|'$/g, "");
+    body = text.slice(bang + 1);
+  }
+  const colon = body.indexOf(":");
+  try {
+    if (colon >= 0) {
+      const start = toA1(body.slice(0, colon), a1, c);
+      const end = toA1(body.slice(colon + 1), a1, c);
+      if (start === null || end === null) return FormulaValue.errorRef;
+      return sheet !== void 0 ? c.getSheetRangeValues(sheet, start, end) : c.getRangeValues(start, end);
+    }
+    const cell = toA1(body, a1, c);
+    if (cell === null) return FormulaValue.errorRef;
+    return sheet !== void 0 ? c.getSheetCellValue(sheet, cell) : c.getCellValue(cell);
+  } catch {
+    return FormulaValue.errorRef;
+  }
+}
+function toA1(ref, a1, c) {
+  const r = ref.trim();
+  if (a1) {
+    try {
+      const { row: row3, column: column2 } = parseCellRef(r);
+      return cellRefFromRowCol(row3, column2);
+    } catch {
+      return null;
+    }
+  }
+  const m = /^R(\[-?\d+\]|\d+)?C(\[-?\d+\]|\d+)?$/i.exec(r);
+  if (!m) return null;
+  const axis = (part, base) => {
+    if (part === void 0) return base;
+    if (part.startsWith("[")) return base + parseInt(part.slice(1, -1), 10);
+    return parseInt(part, 10);
+  };
+  const row2 = axis(m[1], c.formulaRow || 1);
+  const col = axis(m[2], c.formulaCol || 1);
+  if (row2 === null || col === null || row2 < 1 || col < 1) return null;
+  return cellRefFromRowCol(row2, col);
+}
 function offset(a, c) {
   const baseNode = a[0];
   let baseRef;
@@ -2298,8 +2724,8 @@ function registerStatistical(r) {
 }
 function variance(nums, population) {
   const mean = nums.reduce((s, n) => s + n, 0) / nums.length;
-  const sumSq = nums.reduce((s, n) => s + (n - mean) ** 2, 0);
-  return sumSq / (population ? nums.length : nums.length - 1);
+  const sumSq2 = nums.reduce((s, n) => s + (n - mean) ** 2, 0);
+  return sumSq2 / (population ? nums.length : nums.length - 1);
 }
 function numsFromArray(v) {
   if (v.isArray) {
@@ -2532,6 +2958,627 @@ function errorType(a, c) {
   return FormulaValue.number(map[v.errorCode] ?? 7);
 }
 
+// src/functions/finance-functions.ts
+function registerFinance(r) {
+  r.register("PMT", pmt, 3, 5);
+  r.register("FV", fv, 3, 5);
+  r.register("PV", pv, 3, 5);
+  r.register("NPV", npv, 2);
+  r.register("IRR", irr, 1, 2);
+}
+function arg(a, c, idx, dflt) {
+  if (idx >= a.length) return { ok: true, n: dflt };
+  const r = FormulaHelper.evalDouble(a[idx], c);
+  return r.ok ? { ok: true, n: r.value } : { ok: false, e: r.error };
+}
+function pmt(a, c) {
+  const rate = arg(a, c, 0, 0);
+  if (!rate.ok) return rate.e;
+  const nper = arg(a, c, 1, 0);
+  if (!nper.ok) return nper.e;
+  const pvv = arg(a, c, 2, 0);
+  if (!pvv.ok) return pvv.e;
+  const fvv = arg(a, c, 3, 0);
+  if (!fvv.ok) return fvv.e;
+  const type = arg(a, c, 4, 0);
+  if (!type.ok) return type.e;
+  const r = rate.n, n = nper.n, present = pvv.n, future = fvv.n, t = type.n;
+  if (n === 0) return FormulaValue.errorNum;
+  if (r === 0) return FormulaValue.number(-(present + future) / n);
+  const pow = Math.pow(1 + r, n);
+  let payment = (-future - present * pow) * r / (pow - 1);
+  if (t === 1) payment /= 1 + r;
+  return FormulaValue.number(payment);
+}
+function fv(a, c) {
+  const rate = arg(a, c, 0, 0);
+  if (!rate.ok) return rate.e;
+  const nper = arg(a, c, 1, 0);
+  if (!nper.ok) return nper.e;
+  const pmtv = arg(a, c, 2, 0);
+  if (!pmtv.ok) return pmtv.e;
+  const pvv = arg(a, c, 3, 0);
+  if (!pvv.ok) return pvv.e;
+  const type = arg(a, c, 4, 0);
+  if (!type.ok) return type.e;
+  const r = rate.n, n = nper.n, payment = pmtv.n, present = pvv.n, t = type.n;
+  if (r === 0) return FormulaValue.number(-(present + payment * n));
+  const pow = Math.pow(1 + r, n);
+  return FormulaValue.number(-(present * pow + payment * (1 + r * t) * (pow - 1) / r));
+}
+function pv(a, c) {
+  const rate = arg(a, c, 0, 0);
+  if (!rate.ok) return rate.e;
+  const nper = arg(a, c, 1, 0);
+  if (!nper.ok) return nper.e;
+  const pmtv = arg(a, c, 2, 0);
+  if (!pmtv.ok) return pmtv.e;
+  const fvv = arg(a, c, 3, 0);
+  if (!fvv.ok) return fvv.e;
+  const type = arg(a, c, 4, 0);
+  if (!type.ok) return type.e;
+  const r = rate.n, n = nper.n, payment = pmtv.n, future = fvv.n, t = type.n;
+  if (r === 0) return FormulaValue.number(-(future + payment * n));
+  const pow = Math.pow(1 + r, n);
+  return FormulaValue.number(-(future + payment * (1 + r * t) * (pow - 1) / r) / pow);
+}
+function npv(a, c) {
+  const rate = FormulaHelper.evalDouble(a[0], c);
+  if (!rate.ok) return rate.error;
+  if (rate.value === -1) return FormulaValue.errorDiv0;
+  const flows = FormulaHelper.collectNumbers(a.slice(1), c);
+  if (!flows.ok) return flows.error;
+  let total = 0;
+  for (let i = 0; i < flows.values.length; i++) {
+    total += flows.values[i] / Math.pow(1 + rate.value, i + 1);
+  }
+  return FormulaValue.number(total);
+}
+function irr(a, c) {
+  const flowsRes = FormulaHelper.collectNumbers([a[0]], c);
+  if (!flowsRes.ok) return flowsRes.error;
+  const flows = flowsRes.values;
+  if (flows.length < 2) return FormulaValue.errorNum;
+  let guess = 0.1;
+  if (a.length > 1) {
+    const g = FormulaHelper.evalDouble(a[1], c);
+    if (!g.ok) return g.error;
+    guess = g.value;
+  }
+  const npvAt = (rate2) => {
+    let sum2 = 0;
+    for (let i = 0; i < flows.length; i++) sum2 += flows[i] / Math.pow(1 + rate2, i);
+    return sum2;
+  };
+  let rate = guess;
+  for (let iter = 0; iter < 100; iter++) {
+    const f = npvAt(rate);
+    if (Math.abs(f) < 1e-7) return FormulaValue.number(rate);
+    const h = 1e-6;
+    const deriv = (npvAt(rate + h) - f) / h;
+    if (deriv === 0) break;
+    const next = rate - f / deriv;
+    if (!isFinite(next) || next <= -1) break;
+    if (Math.abs(next - rate) < 1e-9) {
+      rate = next;
+      break;
+    }
+    rate = next;
+  }
+  if (Math.abs(npvAt(rate)) < 1e-6) return FormulaValue.number(rate);
+  return FormulaValue.errorNum;
+}
+
+// src/functions/meta-functions.ts
+var MAX_TAIL_ITERATIONS = 1e7;
+function registerMeta(r) {
+  r.register("LET", let_, 3);
+  r.register("LAMBDA", lambda_, 1);
+  r.register("MAP", map_, 2);
+  r.register("REDUCE", reduce_, 3, 3);
+  r.register("SCAN", scan_, 3, 3);
+  r.register("BYROW", byRow, 2, 2);
+  r.register("BYCOL", byCol, 2, 2);
+}
+var asArray = (v) => v.isArray ? v.arrayVal : ArrayValue.fromScalar(v);
+function let_(a, c) {
+  if (a.length < 3 || a.length % 2 === 0) return FormulaValue.errorValue;
+  const bindings = /* @__PURE__ */ new Map();
+  c.pushScope(bindings);
+  try {
+    for (let i = 0; i < a.length - 1; i += 2) {
+      const nameNode = a[i];
+      if (!(nameNode instanceof NamedRangeNode)) return FormulaValue.errorValue;
+      const value2 = a[i + 1].evaluate(c);
+      if (value2.isError) return value2;
+      bindings.set(nameNode.name.toUpperCase(), value2);
+    }
+    return a[a.length - 1].evaluate(c);
+  } finally {
+    c.popScope();
+  }
+}
+function lambda_(a, c) {
+  const paramNodes = a.slice(0, -1);
+  const body = a[a.length - 1];
+  const params = [];
+  for (const p of paramNodes) {
+    if (!(p instanceof NamedRangeNode)) return FormulaValue.errorValue;
+    params.push(p.name.toUpperCase());
+  }
+  const ctx = c;
+  const lambda = {
+    arity: params.length,
+    // One tail-aware evaluation of the body: binds params, then evaluates in
+    // tail mode so a self/other tail call surfaces as a TailCall.
+    step(args) {
+      const bindings = /* @__PURE__ */ new Map();
+      params.forEach((p, i) => bindings.set(p, args[i] ?? FormulaValue.blank));
+      ctx.pushScope(bindings);
+      try {
+        return body.evaluateTail(ctx);
+      } finally {
+        ctx.popScope();
+      }
+    },
+    // Run to completion. Tail calls iterate here (O(1) stack); only non-tail
+    // recursion re-enters call() and is bounded by the recursion guard.
+    call(args) {
+      const guard = ctx.recursionGuard;
+      if (guard) {
+        if (guard.depth >= guard.max) return FormulaValue.errorNum;
+        guard.depth++;
+      }
+      try {
+        let current = lambda;
+        let currentArgs = args;
+        for (let iter = 0; ; iter++) {
+          if (iter > MAX_TAIL_ITERATIONS) return FormulaValue.errorNum;
+          const r = current.step ? current.step(currentArgs) : current.call(currentArgs);
+          if (r instanceof TailCall) {
+            current = r.lambda;
+            currentArgs = r.args;
+            continue;
+          }
+          return r;
+        }
+      } finally {
+        if (guard) guard.depth--;
+      }
+    }
+  };
+  return FormulaValue.lambda(lambda);
+}
+function lambdaArg(node, c) {
+  const v = node.evaluate(c);
+  if (v.isError) return { ok: false, e: v };
+  if (!v.isLambda) return { ok: false, e: FormulaValue.errorValue };
+  return { ok: true, fn: v.lambdaVal };
+}
+function map_(a, c) {
+  const fn = lambdaArg(a[a.length - 1], c);
+  if (!fn.ok) return fn.e;
+  const arrays = a.slice(0, -1).map((n) => asArray(n.evaluate(c)));
+  if (arrays.length === 0) return FormulaValue.errorValue;
+  const rows2 = arrays[0].rows, cols = arrays[0].columns;
+  const out = new ArrayValue(rows2, cols);
+  for (let r = 0; r < rows2; r++) {
+    for (let col = 0; col < cols; col++) {
+      out.set(r, col, fn.fn.call(arrays.map((ar) => ar.get(r, col))));
+    }
+  }
+  return FormulaValue.array(out);
+}
+function reduce_(a, c) {
+  let acc = a[0].evaluate(c);
+  if (acc.isError) return acc;
+  const arr = asArray(a[1].evaluate(c));
+  const fn = lambdaArg(a[2], c);
+  if (!fn.ok) return fn.e;
+  for (const v of arr.values()) {
+    acc = fn.fn.call([acc, v]);
+    if (acc.isError) return acc;
+  }
+  return acc;
+}
+function scan_(a, c) {
+  let acc = a[0].evaluate(c);
+  if (acc.isError) return acc;
+  const arr = asArray(a[1].evaluate(c));
+  const fn = lambdaArg(a[2], c);
+  if (!fn.ok) return fn.e;
+  const out = new ArrayValue(arr.rows, arr.columns);
+  for (let r = 0; r < arr.rows; r++) {
+    for (let col = 0; col < arr.columns; col++) {
+      acc = fn.fn.call([acc, arr.get(r, col)]);
+      out.set(r, col, acc);
+    }
+  }
+  return FormulaValue.array(out);
+}
+function byRow(a, c) {
+  const arr = asArray(a[0].evaluate(c));
+  const fn = lambdaArg(a[1], c);
+  if (!fn.ok) return fn.e;
+  const out = new ArrayValue(arr.rows, 1);
+  for (let r = 0; r < arr.rows; r++) {
+    const row2 = new ArrayValue(1, arr.columns);
+    for (let col = 0; col < arr.columns; col++) row2.set(0, col, arr.get(r, col));
+    out.set(r, 0, fn.fn.call([FormulaValue.array(row2)]));
+  }
+  return FormulaValue.array(out);
+}
+function byCol(a, c) {
+  const arr = asArray(a[0].evaluate(c));
+  const fn = lambdaArg(a[1], c);
+  if (!fn.ok) return fn.e;
+  const out = new ArrayValue(1, arr.columns);
+  for (let col = 0; col < arr.columns; col++) {
+    const column2 = new ArrayValue(arr.rows, 1);
+    for (let r = 0; r < arr.rows; r++) column2.set(r, 0, arr.get(r, col));
+    out.set(0, col, fn.fn.call([FormulaValue.array(column2)]));
+  }
+  return FormulaValue.array(out);
+}
+function registerAggregate(r) {
+  r.register("SUBTOTAL", subtotal, 2);
+  r.register("AGGREGATE", aggregate, 3);
+}
+function collectValues(a, c, startIdx, opts) {
+  const out = [];
+  const ws = c.worksheet;
+  for (let i = startIdx; i < a.length; i++) {
+    const node = a[i];
+    if (node instanceof RangeReferenceNode) {
+      const b = c.getRangeBounds(node.startRef, node.endRef);
+      for (let row2 = b.startRow; row2 <= b.endRow; row2++) {
+        if (opts.excludeHidden && ws.isRowHidden?.(row2)) continue;
+        for (let col = b.startCol; col <= b.endCol; col++) {
+          const ref = cellRefFromRowCol(row2, col);
+          if (opts.nestedPattern) {
+            const f = ws.getCellFormula?.(ref);
+            if (f && opts.nestedPattern.test(f)) continue;
+          }
+          const v = c.getCellValue(ref);
+          if (v.isError) {
+            if (opts.ignoreErrors) continue;
+            return { ok: false, error: v };
+          }
+          out.push(v);
+        }
+      }
+    } else {
+      const v = node.evaluate(c);
+      if (v.isError) {
+        if (opts.ignoreErrors) continue;
+        return { ok: false, error: v };
+      }
+      if (v.isArray) {
+        for (const item of v.arrayVal.values()) {
+          if (item.isError) {
+            if (opts.ignoreErrors) continue;
+            return { ok: false, error: item };
+          }
+          out.push(item);
+        }
+      } else {
+        out.push(v);
+      }
+    }
+  }
+  return { ok: true, values: out };
+}
+function applyAggregate(fn, values, extra) {
+  const nums = [];
+  let countA2 = 0;
+  for (const v of values) {
+    if (!v.isBlank) countA2++;
+    const r = v.tryAsDouble();
+    if (r.ok && !v.isText && !v.isBlank) nums.push(r.value);
+  }
+  const sum2 = () => nums.reduce((s, n) => s + n, 0);
+  const avg = () => nums.length ? sum2() / nums.length : NaN;
+  const variance2 = (sample) => {
+    const n = nums.length;
+    if (sample ? n < 2 : n < 1) return NaN;
+    const m = avg();
+    const ss = nums.reduce((s, x) => s + (x - m) ** 2, 0);
+    return ss / (sample ? n - 1 : n);
+  };
+  const sorted = () => [...nums].sort((x, y) => x - y);
+  switch (fn) {
+    case 1:
+      return isNaN(avg()) ? FormulaValue.errorDiv0 : FormulaValue.number(avg());
+    case 2:
+      return FormulaValue.number(nums.length);
+    // COUNT
+    case 3:
+      return FormulaValue.number(countA2);
+    // COUNTA
+    case 4:
+      return nums.length ? FormulaValue.number(Math.max(...nums)) : FormulaValue.zero;
+    case 5:
+      return nums.length ? FormulaValue.number(Math.min(...nums)) : FormulaValue.zero;
+    case 6:
+      return FormulaValue.number(nums.reduce((p, n) => p * n, 1));
+    // PRODUCT
+    case 7: {
+      const v = variance2(true);
+      return isNaN(v) ? FormulaValue.errorDiv0 : FormulaValue.number(Math.sqrt(v));
+    }
+    // STDEV.S
+    case 8: {
+      const v = variance2(false);
+      return isNaN(v) ? FormulaValue.errorDiv0 : FormulaValue.number(Math.sqrt(v));
+    }
+    // STDEV.P
+    case 9:
+      return FormulaValue.number(sum2());
+    // SUM
+    case 10: {
+      const v = variance2(true);
+      return isNaN(v) ? FormulaValue.errorDiv0 : FormulaValue.number(v);
+    }
+    // VAR.S
+    case 11: {
+      const v = variance2(false);
+      return isNaN(v) ? FormulaValue.errorDiv0 : FormulaValue.number(v);
+    }
+    // VAR.P
+    // AGGREGATE-only selectors:
+    case 12: {
+      const s = sorted();
+      const m = s.length;
+      if (!m) return FormulaValue.errorNum;
+      const mid2 = Math.floor(m / 2);
+      return FormulaValue.number(m % 2 ? s[mid2] : (s[mid2 - 1] + s[mid2]) / 2);
+    }
+    // MEDIAN
+    case 14: {
+      const s = sorted();
+      const k = Math.round(extra ?? 0);
+      return k >= 1 && k <= s.length ? FormulaValue.number(s[s.length - k]) : FormulaValue.errorNum;
+    }
+    case 15: {
+      const s = sorted();
+      const k = Math.round(extra ?? 0);
+      return k >= 1 && k <= s.length ? FormulaValue.number(s[k - 1]) : FormulaValue.errorNum;
+    }
+    default:
+      return FormulaValue.errorValue;
+  }
+}
+function subtotal(a, c) {
+  const fnVal = a[0].evaluate(c);
+  if (fnVal.isError) return fnVal;
+  const raw = fnVal.tryAsDouble();
+  if (!raw.ok) return FormulaValue.errorValue;
+  const code2 = Math.round(raw.value);
+  const excludeHidden = code2 >= 101 && code2 <= 111;
+  const fn = excludeHidden ? code2 - 100 : code2;
+  if (fn < 1 || fn > 11) return FormulaValue.errorValue;
+  const collected = collectValues(a, c, 1, {
+    excludeHidden,
+    nestedPattern: /^\s*SUBTOTAL\s*\(/i,
+    ignoreErrors: false
+  });
+  if (!collected.ok) return collected.error;
+  return applyAggregate(fn, collected.values);
+}
+function aggregate(a, c) {
+  const fnVal = a[0].evaluate(c);
+  if (fnVal.isError) return fnVal;
+  const optVal = a[1].evaluate(c);
+  if (optVal.isError) return optVal;
+  const fnR = fnVal.tryAsDouble();
+  const optR = optVal.tryAsDouble();
+  if (!fnR.ok || !optR.ok) return FormulaValue.errorValue;
+  const fn = Math.round(fnR.value);
+  const option = Math.round(optR.value);
+  if (fn < 1 || fn > 19) return FormulaValue.errorValue;
+  const excludeHidden = option === 1 || option === 3 || option === 5 || option === 7;
+  const ignoreErrors = option === 2 || option === 3 || option === 6 || option === 7;
+  const ignoreNested = option <= 3 || option === 5 || option === 7;
+  let extra;
+  let endIdx = a.length;
+  if (fn === 14 || fn === 15) {
+    const kVal = a[a.length - 1].evaluate(c);
+    const kR = kVal.tryAsDouble();
+    if (!kR.ok) return FormulaValue.errorValue;
+    extra = kR.value;
+    endIdx = a.length - 1;
+  }
+  const collected = collectValues(a.slice(0, endIdx), c, 2, {
+    excludeHidden,
+    nestedPattern: ignoreNested ? /^\s*(SUBTOTAL|AGGREGATE)\s*\(/i : null,
+    ignoreErrors
+  });
+  if (!collected.ok) return collected.error;
+  return applyAggregate(fn, collected.values, extra);
+}
+
+// src/functions/array-functions.ts
+function registerArray(r) {
+  r.register("TRANSPOSE", transpose, 1, 1);
+  r.register("SEQUENCE", sequence, 1, 4);
+  r.register("UNIQUE", unique, 1, 3);
+  r.register("SORT", sort, 1, 4);
+  r.register("FILTER", filter, 2, 3);
+  r.register("MMULT", mmult, 2, 2);
+  r.register("TEXTSPLIT", textSplit, 2, 6);
+}
+var asArray2 = (v) => v.isArray ? v.arrayVal : ArrayValue.fromScalar(v);
+function fromRows(rows2) {
+  const nr = rows2.length;
+  const nc = nr > 0 ? rows2[0].length : 0;
+  const arr = new ArrayValue(nr, nc);
+  for (let r = 0; r < nr; r++) for (let c = 0; c < nc; c++) arr.set(r, c, rows2[r][c]);
+  return FormulaValue.array(arr);
+}
+function toRows(arr) {
+  const rows2 = [];
+  for (let r = 0; r < arr.rows; r++) {
+    const row2 = [];
+    for (let c = 0; c < arr.columns; c++) row2.push(arr.get(r, c));
+    rows2.push(row2);
+  }
+  return rows2;
+}
+var num4 = (a, c, i, dflt) => {
+  if (i >= a.length) return { ok: true, n: dflt };
+  const r = FormulaHelper.evalDouble(a[i], c);
+  return r.ok ? { ok: true, n: r.value } : { ok: false, e: r.error };
+};
+function transpose(a, c) {
+  const v = a[0].evaluate(c);
+  if (v.isError) return v;
+  return FormulaValue.array(asArray2(v).transpose());
+}
+function sequence(a, c) {
+  const rows2 = num4(a, c, 0, 1);
+  if (!rows2.ok) return rows2.e;
+  const cols = num4(a, c, 1, 1);
+  if (!cols.ok) return cols.e;
+  const start = num4(a, c, 2, 1);
+  if (!start.ok) return start.e;
+  const step = num4(a, c, 3, 1);
+  if (!step.ok) return step.e;
+  const R = Math.trunc(rows2.n), C = Math.trunc(cols.n);
+  if (R < 1 || C < 1) return FormulaValue.errorValue;
+  const arr = new ArrayValue(R, C);
+  for (let r = 0; r < R; r++) {
+    for (let col = 0; col < C; col++) {
+      arr.set(r, col, FormulaValue.number(start.n + (r * C + col) * step.n));
+    }
+  }
+  return FormulaValue.array(arr);
+}
+function rowsEqual(x, y) {
+  if (x.length !== y.length) return false;
+  for (let i = 0; i < x.length; i++) if (!FormulaValue.areEqual(x[i], y[i])) return false;
+  return true;
+}
+function unique(a, c) {
+  const v = a[0].evaluate(c);
+  if (v.isError) return v;
+  const byCol2 = a.length > 1 ? a[1].evaluate(c).coerceToBool().booleanValue : false;
+  const exactlyOnce = a.length > 2 ? a[2].evaluate(c).coerceToBool().booleanValue : false;
+  let rows2 = toRows(byCol2 ? asArray2(v).transpose() : asArray2(v));
+  const counts = rows2.map((r) => rows2.filter((o) => rowsEqual(o, r)).length);
+  const seen = [];
+  const result = [];
+  rows2.forEach((r, i) => {
+    if (seen.some((o) => rowsEqual(o, r))) return;
+    seen.push(r);
+    if (exactlyOnce && counts[i] > 1) return;
+    result.push(r);
+  });
+  if (result.length === 0) return FormulaValue.error(8 /* Calc */);
+  const out = fromRows(result);
+  return byCol2 ? FormulaValue.array(out.arrayVal.transpose()) : out;
+}
+function sort(a, c) {
+  const v = a[0].evaluate(c);
+  if (v.isError) return v;
+  const sortIndex = num4(a, c, 1, 1);
+  if (!sortIndex.ok) return sortIndex.e;
+  const sortOrder = num4(a, c, 2, 1);
+  if (!sortOrder.ok) return sortOrder.e;
+  const byCol2 = a.length > 3 ? a[3].evaluate(c).coerceToBool().booleanValue : false;
+  const base = byCol2 ? asArray2(v).transpose() : asArray2(v);
+  const rows2 = toRows(base);
+  const idx = Math.trunc(sortIndex.n) - 1;
+  const dir = sortOrder.n < 0 ? -1 : 1;
+  if (rows2.length > 0 && (idx < 0 || idx >= rows2[0].length)) return FormulaValue.errorValue;
+  const sorted = rows2.map((r, i) => ({ r, i })).sort((x, y) => {
+    const cmp = FormulaValue.compare(x.r[idx], y.r[idx]) * dir;
+    return cmp !== 0 ? cmp : x.i - y.i;
+  }).map((o) => o.r);
+  const out = fromRows(sorted);
+  return byCol2 ? FormulaValue.array(out.arrayVal.transpose()) : out;
+}
+function filter(a, c) {
+  const v = a[0].evaluate(c);
+  if (v.isError) return v;
+  const inc = a[1].evaluate(c);
+  if (inc.isError) return inc;
+  const arr = asArray2(v);
+  const incArr = asArray2(inc);
+  const perRow = incArr.rows === arr.rows && incArr.columns === 1;
+  const perCol = incArr.columns === arr.columns && incArr.rows === 1;
+  if (!perRow && !perCol) return FormulaValue.errorValue;
+  const keptRows = [];
+  if (perRow) {
+    for (let r = 0; r < arr.rows; r++) {
+      if (!incArr.get(r, 0).coerceToBool().booleanValue) continue;
+      const row2 = [];
+      for (let col = 0; col < arr.columns; col++) row2.push(arr.get(r, col));
+      keptRows.push(row2);
+    }
+  } else {
+    const keepCols = [];
+    for (let col = 0; col < arr.columns; col++) {
+      if (incArr.get(0, col).coerceToBool().booleanValue) keepCols.push(col);
+    }
+    for (let r = 0; r < arr.rows; r++) {
+      keptRows.push(keepCols.map((col) => arr.get(r, col)));
+    }
+    if (keepCols.length === 0) keptRows.length = 0;
+  }
+  if (keptRows.length === 0 || keptRows[0] && keptRows[0].length === 0) {
+    return a.length > 2 ? a[2].evaluate(c) : FormulaValue.error(8 /* Calc */);
+  }
+  return fromRows(keptRows);
+}
+function mmult(a, c) {
+  const av = a[0].evaluate(c);
+  if (av.isError) return av;
+  const bv = a[1].evaluate(c);
+  if (bv.isError) return bv;
+  const A = asArray2(av), B = asArray2(bv);
+  if (A.columns !== B.rows) return FormulaValue.errorValue;
+  const out = new ArrayValue(A.rows, B.columns);
+  for (let i = 0; i < A.rows; i++) {
+    for (let j = 0; j < B.columns; j++) {
+      let sum2 = 0;
+      for (let k = 0; k < A.columns; k++) {
+        const x = A.get(i, k).tryAsDouble();
+        const y = B.get(k, j).tryAsDouble();
+        if (!x.ok || !y.ok) return FormulaValue.errorValue;
+        sum2 += x.value * y.value;
+      }
+      out.set(i, j, FormulaValue.number(sum2));
+    }
+  }
+  return FormulaValue.array(out);
+}
+function textSplit(a, c) {
+  const t = FormulaHelper.evalString(a[0], c);
+  if (!t.ok) return t.error;
+  const colD = FormulaHelper.evalString(a[1], c);
+  if (!colD.ok) return colD.error;
+  let rowD = "";
+  if (a.length > 2) {
+    const rd = a[2].evaluate(c);
+    if (rd.isError) return rd;
+    if (!rd.isBlank) {
+      const r = FormulaHelper.evalString(a[2], c);
+      if (!r.ok) return r.error;
+      rowD = r.value;
+    }
+  }
+  const split = (s, d) => d === "" ? [s] : s.split(d);
+  const lines = rowD ? split(t.value, rowD) : [t.value];
+  const grid = lines.map((line) => split(line, colD.value));
+  const width = grid.reduce((m, r) => Math.max(m, r.length), 0);
+  const rows2 = grid.map((r) => {
+    const row2 = [];
+    for (let i = 0; i < width; i++) row2.push(FormulaValue.text(r[i] ?? ""));
+    return row2;
+  });
+  return fromRows(rows2);
+}
+
 // src/function-registry.ts
 var _default, _functions, _FunctionRegistry_instances, registerBuiltIns_fn;
 var _FunctionRegistry = class _FunctionRegistry {
@@ -2590,6 +3637,10 @@ registerBuiltIns_fn = function() {
   registerLookup(this);
   registerStatistical(this);
   registerInfo(this);
+  registerFinance(this);
+  registerMeta(this);
+  registerAggregate(this);
+  registerArray(this);
 };
 __privateAdd(_FunctionRegistry, _default);
 var FunctionRegistry = _FunctionRegistry;
@@ -2611,8 +3662,8 @@ var FormulaHelper;
   FormulaHelper2.evalString = evalString;
   function collectNumbers(args, ctx) {
     const nums = [];
-    for (const arg of args) {
-      const v = arg.evaluate(ctx);
+    for (const arg2 of args) {
+      const v = arg2.evaluate(ctx);
       if (v.isError) return { ok: false, error: v };
       if (v.isArray) {
         for (const item of v.arrayVal.values()) {
@@ -2632,8 +3683,8 @@ var FormulaHelper;
   FormulaHelper2.collectNumbers = collectNumbers;
   function flattenArgs(args, ctx) {
     const result = [];
-    for (const arg of args) {
-      const v = arg.evaluate(ctx);
+    for (const arg2 of args) {
+      const v = arg2.evaluate(ctx);
       if (v.isArray) {
         for (const item of v.arrayVal.values()) result.push(item);
       } else {
@@ -2671,9 +3722,9 @@ var FormulaHelper;
       const pattern = wildcardToRegex(criteria);
       return pattern.test(value2.asText());
     }
-    const num4 = parseFloat(criteria);
-    if (!isNaN(num4)) {
-      return FormulaValue.areEqual(value2, FormulaValue.number(num4));
+    const num5 = parseFloat(criteria);
+    if (!isNaN(num5)) {
+      return FormulaValue.areEqual(value2, FormulaValue.number(num5));
     }
     return value2.asText().toUpperCase() === criteria.toUpperCase();
   }
@@ -2685,18 +3736,33 @@ var FormulaHelper;
 })(FormulaHelper || (FormulaHelper = {}));
 
 // src/formula-context.ts
-var _sheet, _functions2, _evaluating;
+var _sheet, _functions2, _evaluating, _scopes, _FormulaContext_instances, lookupScope_fn;
 var _FormulaContext = class _FormulaContext {
   constructor(sheet, formulaRow = 0, formulaCol = 0, evaluating, registry) {
+    __privateAdd(this, _FormulaContext_instances);
     __privateAdd(this, _sheet);
     __privateAdd(this, _functions2);
     __privateAdd(this, _evaluating);
+    /**
+     * Lexical scope stack for LET/LAMBDA local names. Each frame maps an
+     * upper-cased local name to its value. Names resolve innermost-first and take
+     * precedence over workbook defined names.
+     */
+    __privateAdd(this, _scopes, []);
     __privateSet(this, _sheet, sheet);
     this.formulaRow = formulaRow;
     this.formulaCol = formulaCol;
     __privateSet(this, _evaluating, evaluating ?? /* @__PURE__ */ new Set());
     __privateSet(this, _functions2, registry ?? FunctionRegistry.default);
   }
+  /** Pushes a new binding frame (used by LET/LAMBDA). */
+  pushScope(bindings) {
+    __privateGet(this, _scopes).push(bindings);
+  }
+  /** Pops the innermost binding frame. */
+  popScope() {
+    __privateGet(this, _scopes).pop();
+  }
   get worksheet() {
     return __privateGet(this, _sheet);
   }
@@ -2748,8 +3814,21 @@ var _FormulaContext = class _FormulaContext {
       return FormulaValue.errorRef;
     }
   }
-  resolveNamedRange(_name) {
-    return FormulaValue.errorName;
+  resolveNamedRange(name) {
+    const scoped = __privateMethod(this, _FormulaContext_instances, lookupScope_fn).call(this, name);
+    if (scoped !== void 0) return scoped;
+    return this.nameResolver ? this.nameResolver(name) : FormulaValue.errorName;
+  }
+  /**
+   * Resolves a spill-range reference (A1#) to the array spilling from the anchor
+   * cell. Requires the worksheet to expose getSpillRange; otherwise #REF!.
+   */
+  resolveSpillRange(anchorRef) {
+    const spillRef = __privateGet(this, _sheet).getSpillRange?.(anchorRef);
+    if (!spillRef) return FormulaValue.errorRef;
+    const colon = spillRef.indexOf(":");
+    if (colon < 0) return this.getCellValue(spillRef);
+    return this.getRangeValues(spillRef.slice(0, colon), spillRef.slice(colon + 1));
   }
   getRangeBounds(startRef, endRef) {
     const s = parseCellRef(startRef);
@@ -2757,13 +3836,34 @@ var _FormulaContext = class _FormulaContext {
     return { startRow: s.row, startCol: s.column, endRow: e.row, endCol: e.column };
   }
   // ── Function dispatch ─────────────────────────────────────────────────────
+  /** True if a built-in function with this name is registered. */
+  hasFunction(name) {
+    return __privateGet(this, _functions2).has(name);
+  }
   evaluateFunction(name, args) {
+    if (!__privateGet(this, _functions2).has(name)) {
+      const named = this.resolveNamedRange(name);
+      if (named.isLambda) {
+        return named.lambdaVal.call(args.map((a) => a.evaluate(this)));
+      }
+    }
     return __privateGet(this, _functions2).execute(name, args, this);
   }
 };
 _sheet = new WeakMap();
 _functions2 = new WeakMap();
 _evaluating = new WeakMap();
+_scopes = new WeakMap();
+_FormulaContext_instances = new WeakSet();
+lookupScope_fn = function(name) {
+  if (__privateGet(this, _scopes).length === 0) return void 0;
+  const key = name.toUpperCase();
+  for (let i = __privateGet(this, _scopes).length - 1; i >= 0; i--) {
+    const v = __privateGet(this, _scopes)[i].get(key);
+    if (v !== void 0) return v;
+  }
+  return void 0;
+};
 var FormulaContext = _FormulaContext;
 
 // src/lru-cache.ts
@@ -2870,16 +3970,63 @@ function parseFormula(formula) {
   astCache.set(stripped, ast);
   return ast;
 }
+var DEFAULT_LAMBDA_DEPTH = 1024;
+function buildContext(sheet, opts) {
+  const evaluating = opts.evaluating ?? /* @__PURE__ */ new Set();
+  const ctx = new FormulaContext(
+    sheet,
+    opts.formulaRow ?? 0,
+    opts.formulaCol ?? 0,
+    evaluating
+  );
+  ctx.recursionGuard = opts.recursionGuard ?? { depth: 0, max: DEFAULT_LAMBDA_DEPTH };
+  const wb = opts.workbook;
+  if (wb) {
+    ctx.workbook = wb;
+    if (typeof wb.getDefinedName === "function") {
+      const resolving = opts.resolvingNames ?? /* @__PURE__ */ new Set();
+      const resolved = opts.resolvedNames ?? /* @__PURE__ */ new Map();
+      const guard = ctx.recursionGuard;
+      ctx.nameResolver = (name) => resolveName(name, sheet, wb, evaluating, resolving, resolved, guard);
+    }
+  }
+  return ctx;
+}
+function resolveName(name, sheet, workbook, evaluating, resolving, resolved, recursionGuard) {
+  const key = `${sheet.name}\0${name.toUpperCase()}`;
+  const cached = resolved.get(key);
+  if (cached !== void 0) return cached;
+  if (resolving.has(key)) return FormulaValue.errorRef;
+  const refersTo = workbook.getDefinedName(name, sheet.name);
+  if (refersTo == null || refersTo === "") return FormulaValue.errorName;
+  resolving.add(key);
+  try {
+    const ast = parseFormula(refersTo);
+    const ctx = buildContext(sheet, {
+      workbook,
+      evaluating,
+      resolvingNames: resolving,
+      resolvedNames: resolved,
+      recursionGuard
+    });
+    const value2 = ast.evaluate(ctx);
+    if (value2.isLambda) resolved.set(key, value2);
+    return value2;
+  } catch {
+    return FormulaValue.errorName;
+  } finally {
+    resolving.delete(key);
+  }
+}
 function evaluateFormula(formula, sheet, options) {
   if (!formula) return FormulaValue.blank;
   try {
     const ast = parseFormula(formula);
-    const ctx = new FormulaContext(
-      sheet,
-      options?.formulaRow ?? 0,
-      options?.formulaCol ?? 0
-    );
-    if (options?.workbook) ctx.workbook = options.workbook;
+    const ctx = buildContext(sheet, {
+      workbook: options?.workbook,
+      formulaRow: options?.formulaRow,
+      formulaCol: options?.formulaCol
+    });
     return ast.evaluate(ctx);
   } catch {
     return FormulaValue.errorValue;
@@ -2899,7 +4046,439 @@ function getAstCacheStats() {
 function setAstCacheCapacity(capacity) {
   astCache.resize(capacity);
 }
+function extractReferences(ast, formulaSheet, registry = FunctionRegistry.default, resolveName2) {
+  const refs = [];
+  let volatile = false;
+  const seenNames = /* @__PURE__ */ new Set();
+  const cell = (sheet, ref) => {
+    const { row: row2, column: column2 } = parseCellRef(ref);
+    return { sheet: sheet.toUpperCase(), startRow: row2, startCol: column2, endRow: row2, endCol: column2 };
+  };
+  const range = (sheet, startRef, endRef) => {
+    const s = parseCellRef(startRef);
+    const e = parseCellRef(endRef);
+    return {
+      sheet: sheet.toUpperCase(),
+      startRow: Math.min(s.row, e.row),
+      startCol: Math.min(s.column, e.column),
+      endRow: Math.max(s.row, e.row),
+      endCol: Math.max(s.column, e.column)
+    };
+  };
+  const walk = (node) => {
+    if (node instanceof CellReferenceNode) {
+      refs.push(cell(formulaSheet, node.reference));
+    } else if (node instanceof RangeReferenceNode) {
+      refs.push(range(formulaSheet, node.startRef, node.endRef));
+    } else if (node instanceof SheetCellReferenceNode) {
+      refs.push(cell(node.sheetName, node.cellReference));
+    } else if (node instanceof SheetRangeReferenceNode) {
+      refs.push(range(node.sheetName, node.startRef, node.endRef));
+    } else if (node instanceof NamedRangeNode) {
+      expandName(node.name);
+    } else if (node instanceof SpillReferenceNode) {
+      refs.push(cell(formulaSheet, node.anchorRef));
+    } else if (node instanceof FunctionCallNode) {
+      if (registry.isVolatile(node.functionName)) volatile = true;
+      for (const arg2 of node.args) walk(arg2);
+    } else if (node instanceof BinaryOpNode) {
+      walk(node.left);
+      walk(node.right);
+    } else if (node instanceof UnaryOpNode) {
+      walk(node.operand);
+    } else if (node instanceof ImplicitIntersectionNode) {
+      walk(node.inner);
+    }
+  };
+  const expandName = (name) => {
+    if (!resolveName2) return;
+    const key = name.toUpperCase();
+    if (seenNames.has(key)) return;
+    seenNames.add(key);
+    const refersTo = resolveName2(name, formulaSheet);
+    if (!refersTo) return;
+    try {
+      walk(parseFormula(refersTo));
+    } catch {
+    }
+  };
+  walk(ast);
+  return { refs, volatile };
+}
+function refContains(ref, sheet, row2, col) {
+  return ref.sheet === sheet && row2 >= ref.startRow && row2 <= ref.endRow && col >= ref.startCol && col <= ref.endCol;
+}
+
+// src/recalc-engine.ts
+function createWorkbookRecalcModel(workbook) {
+  return {
+    getCellValue: (sheet, ref) => workbook.getWorksheet(sheet).getCellValue(ref),
+    setCellValue: (sheet, ref, value2) => {
+      workbook.getWorksheet(sheet).getCell(ref).setComputedValue(value2);
+    },
+    setCellFormula: (sheet, ref, formula) => {
+      workbook.getWorksheet(sheet).getCell(ref).setFormula(formula);
+    },
+    clearCell: (sheet, ref) => {
+      workbook.getWorksheet(sheet).getCell(ref).clear();
+    },
+    setCellArrayRef: (sheet, ref, spillRef) => {
+      workbook.getWorksheet(sheet).getCell(ref).setArrayRef(spillRef);
+    },
+    getCellFormula: (sheet, ref) => workbook.getWorksheet(sheet).getCellFormula?.(ref) ?? null,
+    getSpillRange: (sheet, ref) => workbook.getWorksheet(sheet).getSpillRange?.(ref) ?? null,
+    isRowHidden: (sheet, row2) => workbook.getWorksheet(sheet).isRowHidden?.(row2) ?? false,
+    getDefinedName: (name, sheet) => workbook.getDefinedName(name, sheet)
+  };
+}
+var normSheet = (s) => s.toUpperCase();
+var normRef = (r) => r.replace(/\$/g, "").toUpperCase();
+var keyOf = (sheet, ref) => `${normSheet(sheet)}!${normRef(ref)}`;
+function parseKey(key) {
+  const bang = key.indexOf("!");
+  const sheet = key.slice(0, bang);
+  const ref = key.slice(bang + 1);
+  const { row: row2, column: column2 } = parseCellRef(ref);
+  return { sheet, ref, row: row2, col: column2 };
+}
+var _model, _registry, _formulas, _sheetNames, _spills, _spillOwner, _RecalcEngine_instances, rememberSheet_fn, recalcFrom_fn, dependentClosure_fn, directDependents_fn, evaluatePass_fn, writeResult_fn, isOccupied_fn, clearSpill_fn, evaluateFormulaValue_fn, sheetLike_fn, buildWorkbookLike_fn;
+var RecalcEngine = class {
+  constructor(model, registry = FunctionRegistry.default) {
+    __privateAdd(this, _RecalcEngine_instances);
+    __privateAdd(this, _model);
+    __privateAdd(this, _registry);
+    __privateAdd(this, _formulas, /* @__PURE__ */ new Map());
+    /** upper-cased sheet key → original casing, for case-correct model I/O. */
+    __privateAdd(this, _sheetNames, /* @__PURE__ */ new Map());
+    /** anchor cellKey → set of spilled (non-anchor) cellKeys it currently owns. */
+    __privateAdd(this, _spills, /* @__PURE__ */ new Map());
+    /** spilled cellKey → the anchor cellKey that owns it. */
+    __privateAdd(this, _spillOwner, /* @__PURE__ */ new Map());
+    __privateSet(this, _model, model);
+    __privateSet(this, _registry, registry);
+  }
+  // ── Registration ─────────────────────────────────────────────────────────────
+  /**
+   * Registers (or replaces) a formula for a cell and recalculates that cell and
+   * everything downstream of it. Returns the recomputed cells in the order they
+   * were evaluated. The leading '=' of the formula is optional.
+   */
+  setCellFormula(sheet, ref, formula) {
+    if (!formula) throw new Error("Formula cannot be empty.");
+    const text = formula.startsWith("=") ? formula.slice(1) : formula;
+    const s = normSheet(sheet);
+    const r = normRef(ref);
+    const { row: row2, column: column2 } = parseCellRef(r);
+    const ast = parseFormula(text);
+    const { refs, volatile } = extractReferences(
+      ast,
+      s,
+      __privateGet(this, _registry),
+      __privateGet(this, _model).getDefinedName ? (n, sh) => __privateGet(this, _model).getDefinedName(n, sh) : void 0
+    );
+    __privateMethod(this, _RecalcEngine_instances, rememberSheet_fn).call(this, sheet);
+    __privateGet(this, _formulas).set(keyOf(s, r), {
+      sheet: s,
+      sheetName: sheet,
+      ref: r,
+      row: row2,
+      col: column2,
+      formula: text,
+      refs,
+      volatile
+    });
+    __privateGet(this, _model).setCellFormula?.(sheet, r, text);
+    return __privateMethod(this, _RecalcEngine_instances, recalcFrom_fn).call(this, [{ sheet: s, row: row2, col: column2 }], keyOf(s, r));
+  }
+  /**
+   * Removes a formula from a cell and recalculates its dependents (which may now
+   * read a plain input value instead). Returns the recomputed dependent cells.
+   */
+  clearCellFormula(sheet, ref) {
+    const s = normSheet(sheet);
+    const r = normRef(ref);
+    const existed = __privateGet(this, _formulas).delete(keyOf(s, r));
+    if (!existed) return [];
+    __privateGet(this, _model).clearCell?.(sheet, r);
+    const { row: row2, column: column2 } = parseCellRef(r);
+    return __privateMethod(this, _RecalcEngine_instances, recalcFrom_fn).call(this, [{ sheet: s, row: row2, col: column2 }]);
+  }
+  /**
+   * Writes a raw input value to a cell and recalculates every formula that
+   * depends on it. Use this for non-formula edits so dependents stay current.
+   */
+  setCellValue(sheet, ref, value2) {
+    __privateMethod(this, _RecalcEngine_instances, rememberSheet_fn).call(this, sheet);
+    const s = normSheet(sheet);
+    const r = normRef(ref);
+    __privateGet(this, _model).setCellValue(sheet, r, value2);
+    const { row: row2, column: column2 } = parseCellRef(r);
+    return __privateMethod(this, _RecalcEngine_instances, recalcFrom_fn).call(this, [{ sheet: s, row: row2, col: column2 }]);
+  }
+  /**
+   * Signals that a cell changed by some external means (the model was already
+   * updated) and recalculates its dependents.
+   */
+  onCellChanged(sheet, ref) {
+    __privateMethod(this, _RecalcEngine_instances, rememberSheet_fn).call(this, sheet);
+    const s = normSheet(sheet);
+    const r = normRef(ref);
+    const { row: row2, column: column2 } = parseCellRef(r);
+    return __privateMethod(this, _RecalcEngine_instances, recalcFrom_fn).call(this, [{ sheet: s, row: row2, col: column2 }]);
+  }
+  /** Recalculates every registered formula in dependency order. */
+  recalcAll() {
+    return __privateMethod(this, _RecalcEngine_instances, evaluatePass_fn).call(this, [...__privateGet(this, _formulas).values()]).results;
+  }
+  /** The precedents recorded for a formula cell (mainly for tests/inspection). */
+  getPrecedents(sheet, ref) {
+    return __privateGet(this, _formulas).get(keyOf(sheet, ref))?.refs ?? [];
+  }
+};
+_model = new WeakMap();
+_registry = new WeakMap();
+_formulas = new WeakMap();
+_sheetNames = new WeakMap();
+_spills = new WeakMap();
+_spillOwner = new WeakMap();
+_RecalcEngine_instances = new WeakSet();
+rememberSheet_fn = function(name) {
+  __privateGet(this, _sheetNames).set(normSheet(name), name);
+};
+// ── Internals ────────────────────────────────────────────────────────────────
+/**
+ * Recomputes formulas affected by the given changed cells, to a fixpoint.
+ *
+ * A single topological pass is not enough once dynamic arrays exist: a
+ * formula that spills changes cells the graph could not know about until the
+ * array was computed, and those cells may have their own dependents. So we
+ * evaluate a pass, collect every cell whose value actually changed (formula
+ * outputs plus spilled/cleared cells), then recompute the dependents of those
+ * cells, repeating until nothing new is affected (bounded for safety).
+ */
+recalcFrom_fn = function(seeds, includeKey) {
+  const results = [];
+  const evaluated = /* @__PURE__ */ new Set();
+  let pending = __privateMethod(this, _RecalcEngine_instances, dependentClosure_fn).call(this, seeds, evaluated);
+  for (const e of __privateGet(this, _formulas).values()) {
+    if (e.volatile) pending.set(keyOf(e.sheet, e.ref), e);
+  }
+  if (includeKey) {
+    const self = __privateGet(this, _formulas).get(includeKey);
+    if (self) pending.set(includeKey, self);
+  }
+  let guard = 0;
+  const maxIterations = __privateGet(this, _formulas).size + 8;
+  while (pending.size > 0 && guard++ <= maxIterations) {
+    const { results: passResults, changed } = __privateMethod(this, _RecalcEngine_instances, evaluatePass_fn).call(this, [...pending.values()]);
+    results.push(...passResults);
+    for (const k of pending.keys()) evaluated.add(k);
+    pending = __privateMethod(this, _RecalcEngine_instances, dependentClosure_fn).call(this, changed, evaluated);
+  }
+  return results;
+};
+/** Formula entries (not yet evaluated) whose precedents include one of the cells. */
+dependentClosure_fn = function(cells, evaluated) {
+  const out = /* @__PURE__ */ new Map();
+  const queue = [...cells];
+  while (queue.length > 0) {
+    const cell = queue.shift();
+    for (const dep of __privateMethod(this, _RecalcEngine_instances, directDependents_fn).call(this, cell)) {
+      const k = keyOf(dep.sheet, dep.ref);
+      if (out.has(k) || evaluated.has(k)) continue;
+      out.set(k, dep);
+      queue.push({ sheet: dep.sheet, row: dep.row, col: dep.col });
+    }
+  }
+  return out;
+};
+/** Formula entries whose precedents include the given cell. */
+directDependents_fn = function(cell) {
+  const out = [];
+  for (const e of __privateGet(this, _formulas).values()) {
+    if (e.refs.some((ref) => refContains(ref, cell.sheet, cell.row, cell.col))) out.push(e);
+  }
+  return out;
+};
+/**
+ * Topologically sorts the given entries and evaluates them, writing results
+ * (scalars or spilled arrays) back to the model. Returns the results and the
+ * flat list of cells whose value changed. Entries left in a cycle are #REF!.
+ */
+evaluatePass_fn = function(entries) {
+  const inSet = /* @__PURE__ */ new Map();
+  for (const e of entries) inSet.set(keyOf(e.sheet, e.ref), e);
+  const indegree = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const k of inSet.keys()) {
+    indegree.set(k, 0);
+    dependents.set(k, []);
+  }
+  for (const e of entries) {
+    const depKey = keyOf(e.sheet, e.ref);
+    for (const [pk, pe] of inSet) {
+      if (pk === depKey) continue;
+      if (e.refs.some((ref) => refContains(ref, pe.sheet, pe.row, pe.col))) {
+        dependents.get(pk).push(depKey);
+        indegree.set(depKey, indegree.get(depKey) + 1);
+      }
+    }
+  }
+  const ready = [];
+  for (const [k, d] of indegree) if (d === 0) ready.push(k);
+  const order = [];
+  while (ready.length > 0) {
+    const k = ready.shift();
+    order.push(k);
+    for (const d of dependents.get(k)) {
+      indegree.set(d, indegree.get(d) - 1);
+      if (indegree.get(d) === 0) ready.push(d);
+    }
+  }
+  const results = [];
+  const changed = [];
+  const emitted = new Set(order);
+  for (const k of order) {
+    const e = inSet.get(k);
+    const { result, changed: c } = __privateMethod(this, _RecalcEngine_instances, writeResult_fn).call(this, e);
+    results.push(result);
+    changed.push(...c);
+  }
+  for (const [k, e] of inSet) {
+    if (emitted.has(k)) continue;
+    __privateMethod(this, _RecalcEngine_instances, clearSpill_fn).call(this, keyOf(e.sheet, e.ref), changed);
+    const value2 = FormulaValue.errorRef.toObject();
+    __privateGet(this, _model).setCellValue(e.sheetName, e.ref, value2);
+    changed.push({ sheet: e.sheet, row: e.row, col: e.col });
+    results.push({ sheet: e.sheetName, ref: e.ref, value: value2, circular: true });
+  }
+  return { results, changed };
+};
+/**
+ * Evaluates one formula and writes its result. Scalars go to the anchor cell.
+ * Arrays spill across a block anchored at the formula cell: on a collision
+ * with existing content the anchor becomes #SPILL! and nothing spills; when
+ * an array shrinks, previously-spilled cells it no longer covers are cleared.
+ */
+writeResult_fn = function(e) {
+  const anchorKey = keyOf(e.sheet, e.ref);
+  const fv2 = __privateMethod(this, _RecalcEngine_instances, evaluateFormulaValue_fn).call(this, e);
+  const changed = [];
+  const prevSpill = __privateGet(this, _spills).get(anchorKey) ?? /* @__PURE__ */ new Set();
+  if (!fv2.isArray) {
+    __privateMethod(this, _RecalcEngine_instances, clearSpill_fn).call(this, anchorKey, changed);
+    __privateGet(this, _model).setCellArrayRef?.(e.sheetName, e.ref, null);
+    const value2 = fv2.toObject();
+    __privateGet(this, _model).setCellValue(e.sheetName, e.ref, value2);
+    changed.push({ sheet: e.sheet, row: e.row, col: e.col });
+    return { result: { sheet: e.sheetName, ref: e.ref, value: value2 }, changed };
+  }
+  const arr = fv2.arrayVal;
+  const rows2 = arr.rows, cols = arr.columns;
+  let collides = false;
+  for (let dr = 0; dr < rows2 && !collides; dr++) {
+    for (let dc = 0; dc < cols && !collides; dc++) {
+      if (dr === 0 && dc === 0) continue;
+      const r = e.row + dr, c = e.col + dc;
+      const cellKey = keyOf(e.sheet, cellRefFromRowCol(r, c));
+      if (__privateMethod(this, _RecalcEngine_instances, isOccupied_fn).call(this, cellKey, e.sheetName, cellRefFromRowCol(r, c), anchorKey, prevSpill)) {
+        collides = true;
+      }
+    }
+  }
+  if (collides) {
+    __privateMethod(this, _RecalcEngine_instances, clearSpill_fn).call(this, anchorKey, changed);
+    __privateGet(this, _model).setCellArrayRef?.(e.sheetName, e.ref, null);
+    const value2 = FormulaValue.error(9 /* Spill */).toObject();
+    __privateGet(this, _model).setCellValue(e.sheetName, e.ref, value2);
+    changed.push({ sheet: e.sheet, row: e.row, col: e.col });
+    return { result: { sheet: e.sheetName, ref: e.ref, value: value2 }, changed };
+  }
+  const newSpill = /* @__PURE__ */ new Set();
+  for (let dr = 0; dr < rows2; dr++) {
+    for (let dc = 0; dc < cols; dc++) {
+      const r = e.row + dr, c = e.col + dc;
+      const ref = cellRefFromRowCol(r, c);
+      __privateGet(this, _model).setCellValue(e.sheetName, ref, arr.get(dr, dc).toObject());
+      changed.push({ sheet: e.sheet, row: r, col: c });
+      if (dr !== 0 || dc !== 0) {
+        const cellKey = keyOf(e.sheet, ref);
+        newSpill.add(cellKey);
+        __privateGet(this, _spillOwner).set(cellKey, anchorKey);
+      }
+    }
+  }
+  for (const oldKey of prevSpill) {
+    if (newSpill.has(oldKey)) continue;
+    const cell = parseKey(oldKey);
+    __privateGet(this, _model).setCellValue(__privateGet(this, _sheetNames).get(cell.sheet) ?? cell.sheet, cell.ref, null);
+    __privateGet(this, _spillOwner).delete(oldKey);
+    changed.push({ sheet: cell.sheet, row: cell.row, col: cell.col });
+  }
+  __privateGet(this, _spills).set(anchorKey, newSpill);
+  const spillRef = `${e.ref}:${cellRefFromRowCol(e.row + rows2 - 1, e.col + cols - 1)}`;
+  __privateGet(this, _model).setCellArrayRef?.(e.sheetName, e.ref, spillRef);
+  return {
+    result: { sheet: e.sheetName, ref: e.ref, value: arr.get(0, 0).toObject(), spill: { rows: rows2, cols } },
+    changed
+  };
+};
+/** Whether a target cell already holds content that blocks a spill. */
+isOccupied_fn = function(cellKey, sheetName, ref, anchorKey, prevSpill) {
+  if (__privateGet(this, _formulas).has(cellKey) && cellKey !== anchorKey) return true;
+  const owner = __privateGet(this, _spillOwner).get(cellKey);
+  if (owner && owner !== anchorKey) return true;
+  if (prevSpill.has(cellKey)) return false;
+  const v = __privateGet(this, _model).getCellValue(sheetName, ref);
+  return v !== null && v !== void 0 && v !== "";
+};
+/** Clears an anchor's spilled cells (not the anchor itself) and forgets them. */
+clearSpill_fn = function(anchorKey, changed) {
+  const spill = __privateGet(this, _spills).get(anchorKey);
+  if (!spill) return;
+  for (const cellKey of spill) {
+    const cell = parseKey(cellKey);
+    __privateGet(this, _model).setCellValue(__privateGet(this, _sheetNames).get(cell.sheet) ?? cell.sheet, cell.ref, null);
+    __privateGet(this, _spillOwner).delete(cellKey);
+    changed.push({ sheet: cell.sheet, row: cell.row, col: cell.col });
+  }
+  __privateGet(this, _spills).delete(anchorKey);
+};
+evaluateFormulaValue_fn = function(e) {
+  const wb = __privateMethod(this, _RecalcEngine_instances, buildWorkbookLike_fn).call(this);
+  const ws = __privateMethod(this, _RecalcEngine_instances, sheetLike_fn).call(this, e.sheetName);
+  return evaluateFormula(e.formula, ws, {
+    workbook: wb,
+    formulaRow: e.row,
+    formulaCol: e.col
+  });
+};
+sheetLike_fn = function(sheetName) {
+  return {
+    name: sheetName,
+    getCellValue: (ref) => __privateGet(this, _model).getCellValue(sheetName, ref),
+    isRowHidden: __privateGet(this, _model).isRowHidden ? (row2) => __privateGet(this, _model).isRowHidden(sheetName, row2) : void 0,
+    getCellFormula: __privateGet(this, _model).getCellFormula ? (ref) => __privateGet(this, _model).getCellFormula(sheetName, ref) : void 0,
+    getSpillRange: __privateGet(this, _model).getSpillRange ? (ref) => __privateGet(this, _model).getSpillRange(sheetName, ref) : void 0
+  };
+};
+buildWorkbookLike_fn = function() {
+  const self = this;
+  return {
+    get worksheets() {
+      return [...__privateGet(self, _sheetNames).values()].map((n) => {
+        var _a;
+        return __privateMethod(_a = self, _RecalcEngine_instances, sheetLike_fn).call(_a, n);
+      });
+    },
+    getWorksheet: (name) => {
+      var _a;
+      return __privateMethod(_a = self, _RecalcEngine_instances, sheetLike_fn).call(_a, name);
+    },
+    getDefinedName: __privateGet(this, _model).getDefinedName ? (name, sheet) => __privateGet(this, _model).getDefinedName(name, sheet) : void 0
+  };
+};
 
-export { ArrayValue, BinaryOpNode, BinaryOperator, BlankNode, BooleanNode, CellReferenceNode, ErrorNode, FormulaContext, FormulaError, FormulaException, FormulaHelper, FormulaLexer, FormulaNode, FormulaParser, FormulaValue, FunctionCallNode, FunctionRegistry, ImplicitIntersectionNode, LruCache, NamedRangeNode, NumberNode, RangeReferenceNode, SheetCellReferenceNode, SheetRangeReferenceNode, StringNode, TokenType, UnaryOpNode, UnaryOperator, clearAstCache, evaluateFormula, getAstCacheStats, parseFormula, registerDate, registerInfo, registerLogical, registerLookup, registerMath, registerStatistical, registerText, setAstCacheCapacity };
+export { ArrayValue, BinaryOpNode, BinaryOperator, BlankNode, BooleanNode, CallNode, CellReferenceNode, ErrorNode, FormulaContext, FormulaError, FormulaException, FormulaHelper, FormulaLexer, FormulaNode, FormulaParser, FormulaValue, FunctionCallNode, FunctionRegistry, ImplicitIntersectionNode, LruCache, NamedRangeNode, NumberNode, RangeReferenceNode, RecalcEngine, SheetCellReferenceNode, SheetRangeReferenceNode, SpillReferenceNode, StringNode, TokenType, UnaryOpNode, UnaryOperator, clearAstCache, createWorkbookRecalcModel, evaluateFormula, extractReferences, getAstCacheStats, parseFormula, refContains, registerAggregate, registerArray, registerDate, registerFinance, registerInfo, registerLogical, registerLookup, registerMath, registerMeta, registerStatistical, registerText, setAstCacheCapacity };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map