@devmm/puredocs-excel-formula 1.0.0

package/dist/index.js

@@ -0,0 +1,2905 @@
+import { toOADate, fromOADate, parseCellRef, cellRefFromRowCol } from '@devmm/puredocs-excel';
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value2) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value2);
+var __privateSet = (obj, member, value2, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value2), value2);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value2) {
+    __privateSet(obj, member, value2);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var FormulaError = /* @__PURE__ */ ((FormulaError2) => {
+  FormulaError2[FormulaError2["None"] = 0] = "None";
+  FormulaError2[FormulaError2["Null"] = 1] = "Null";
+  FormulaError2[FormulaError2["Div0"] = 2] = "Div0";
+  FormulaError2[FormulaError2["Value"] = 3] = "Value";
+  FormulaError2[FormulaError2["Ref"] = 4] = "Ref";
+  FormulaError2[FormulaError2["Name"] = 5] = "Name";
+  FormulaError2[FormulaError2["Num"] = 6] = "Num";
+  FormulaError2[FormulaError2["NA"] = 7] = "NA";
+  FormulaError2[FormulaError2["Calc"] = 8] = "Calc";
+  FormulaError2[FormulaError2["Spill"] = 9] = "Spill";
+  return FormulaError2;
+})(FormulaError || {});
+var _num, _obj;
+var _FormulaValue = class _FormulaValue {
+  constructor(kind, num4 = 0, obj, errorCode = 0 /* None */) {
+    /** Numeric payload (also used for boolean: 1=true, 0=false). */
+    __privateAdd(this, _num);
+    /** String or ArrayValue payload. */
+    __privateAdd(this, _obj);
+    this.kind = kind;
+    __privateSet(this, _num, num4);
+    __privateSet(this, _obj, obj);
+    this.errorCode = errorCode;
+  }
+  // ── Static factories ─────────────────────────────────────────────────────
+  static number(v) {
+    if (v === 0) return _FormulaValue.zero;
+    if (v === 1) return _FormulaValue.one;
+    return new _FormulaValue("number", v);
+  }
+  static text(v) {
+    if (v === "") return _FormulaValue.emptyString;
+    return new _FormulaValue("text", 0, v);
+  }
+  static boolean(v) {
+    return v ? _FormulaValue.true_ : _FormulaValue.false_;
+  }
+  static error(e) {
+    switch (e) {
+      case 2 /* Div0 */:
+        return _FormulaValue.errorDiv0;
+      case 3 /* Value */:
+        return _FormulaValue.errorValue;
+      case 4 /* Ref */:
+        return _FormulaValue.errorRef;
+      case 5 /* Name */:
+        return _FormulaValue.errorName;
+      case 7 /* NA */:
+        return _FormulaValue.errorNA;
+      case 6 /* Num */:
+        return _FormulaValue.errorNum;
+      case 1 /* Null */:
+        return _FormulaValue.errorNull;
+      default:
+        return new _FormulaValue("error", 0, void 0, e);
+    }
+  }
+  static array(a) {
+    return new _FormulaValue("array", 0, a);
+  }
+  // ── Type checks ──────────────────────────────────────────────────────────
+  get isBlank() {
+    return this.kind === "blank";
+  }
+  get isNumber() {
+    return this.kind === "number";
+  }
+  get isText() {
+    return this.kind === "text";
+  }
+  get isBoolean() {
+    return this.kind === "boolean";
+  }
+  get isError() {
+    return this.kind === "error";
+  }
+  get isArray() {
+    return this.kind === "array";
+  }
+  get isNumeric() {
+    return this.kind === "number" || this.kind === "boolean" || this.kind === "blank";
+  }
+  // ── Value accessors ──────────────────────────────────────────────────────
+  get numberValue() {
+    return __privateGet(this, _num);
+  }
+  get textValue() {
+    return __privateGet(this, _obj) ?? "";
+  }
+  get booleanValue() {
+    return __privateGet(this, _num) !== 0;
+  }
+  get arrayVal() {
+    return __privateGet(this, _obj) ?? ArrayValue.empty;
+  }
+  // ── Coercion (Excel semantics, no exceptions) ─────────────────────────────
+  coerceToNumber() {
+    switch (this.kind) {
+      case "number":
+        return this;
+      case "blank":
+        return _FormulaValue.zero;
+      case "boolean":
+        return _FormulaValue.number(__privateGet(this, _num));
+      case "error":
+        return this;
+      case "text": {
+        const n = parseFloat(this.textValue);
+        return isNaN(n) ? _FormulaValue.errorValue : _FormulaValue.number(n);
+      }
+      default:
+        return _FormulaValue.errorValue;
+    }
+  }
+  tryAsDouble() {
+    switch (this.kind) {
+      case "number":
+        return { ok: true, value: __privateGet(this, _num) };
+      case "blank":
+        return { ok: true, value: 0 };
+      case "boolean":
+        return { ok: true, value: __privateGet(this, _num) };
+      case "text": {
+        const n = parseFloat(this.textValue);
+        return isNaN(n) ? { ok: false } : { ok: true, value: n };
+      }
+      default:
+        return { ok: false };
+    }
+  }
+  coerceToBool() {
+    switch (this.kind) {
+      case "boolean":
+        return this;
+      case "number":
+        return _FormulaValue.boolean(__privateGet(this, _num) !== 0);
+      case "blank":
+        return _FormulaValue.false_;
+      case "error":
+        return this;
+      case "text": {
+        const u = this.textValue.toUpperCase();
+        if (u === "TRUE") return _FormulaValue.true_;
+        if (u === "FALSE") return _FormulaValue.false_;
+        return _FormulaValue.errorValue;
+      }
+      default:
+        return _FormulaValue.errorValue;
+    }
+  }
+  asText() {
+    switch (this.kind) {
+      case "text":
+        return this.textValue;
+      case "number":
+        return String(__privateGet(this, _num));
+      case "boolean":
+        return __privateGet(this, _num) !== 0 ? "TRUE" : "FALSE";
+      case "blank":
+        return "";
+      case "error":
+        return _FormulaValue.errorToString(this.errorCode);
+      default:
+        return "";
+    }
+  }
+  // ── Comparison (Excel semantics) ─────────────────────────────────────────
+  static areEqual(a, b) {
+    if (a.isBlank && b.isBlank) return true;
+    if (a.isBlank) {
+      if (b.isNumber) return Math.abs(b.numberValue) < 1e-10;
+      if (b.isText) return b.textValue === "";
+      if (b.isBoolean) return !b.booleanValue;
+      return false;
+    }
+    if (b.isBlank) return _FormulaValue.areEqual(b, a);
+    if (a.kind !== b.kind) return false;
+    switch (a.kind) {
+      case "number":
+        return Math.abs(__privateGet(a, _num) - __privateGet(b, _num)) < 1e-10;
+      case "boolean":
+        return __privateGet(a, _num) === __privateGet(b, _num);
+      case "text":
+        return a.textValue.toUpperCase() === b.textValue.toUpperCase();
+      default:
+        return false;
+    }
+  }
+  /** Excel-compatible sort order: Number/Blank < Text < Boolean. */
+  static compare(a, b) {
+    const order = (v) => v.kind === "boolean" ? 2 : v.isText ? 1 : 0;
+    const oa = order(a), ob = order(b);
+    if (oa !== ob) return oa - ob;
+    switch (oa) {
+      case 0:
+        return (a.isBlank ? 0 : a.numberValue) - (b.isBlank ? 0 : b.numberValue);
+      case 1:
+        return a.textValue.toUpperCase() < b.textValue.toUpperCase() ? -1 : a.textValue.toUpperCase() > b.textValue.toUpperCase() ? 1 : 0;
+      case 2:
+        return __privateGet(a, _num) - __privateGet(b, _num);
+      default:
+        return 0;
+    }
+  }
+  // ── Error helpers ─────────────────────────────────────────────────────────
+  static errorToString(e) {
+    const map = {
+      [0 /* None */]: "",
+      [1 /* Null */]: "#NULL!",
+      [2 /* Div0 */]: "#DIV/0!",
+      [3 /* Value */]: "#VALUE!",
+      [4 /* Ref */]: "#REF!",
+      [5 /* Name */]: "#NAME?",
+      [6 /* Num */]: "#NUM!",
+      [7 /* NA */]: "#N/A",
+      [8 /* Calc */]: "#CALC!",
+      [9 /* Spill */]: "#SPILL!"
+    };
+    return map[e] ?? "#ERROR!";
+  }
+  static errorFromString(s) {
+    const map = {
+      "#NULL!": 1 /* Null */,
+      "#DIV/0!": 2 /* Div0 */,
+      "#VALUE!": 3 /* Value */,
+      "#REF!": 4 /* Ref */,
+      "#NAME?": 5 /* Name */,
+      "#NUM!": 6 /* Num */,
+      "#N/A": 7 /* NA */,
+      "#CALC!": 8 /* Calc */,
+      "#SPILL!": 9 /* Spill */
+    };
+    return map[s] ?? 3 /* Value */;
+  }
+  // ── JS interop ────────────────────────────────────────────────────────────
+  static fromObjectSync(value2) {
+    if (value2 === null || value2 === void 0) return _FormulaValue.blank;
+    if (typeof value2 === "number") return isNaN(value2) ? _FormulaValue.errorValue : _FormulaValue.number(value2);
+    if (typeof value2 === "boolean") return _FormulaValue.boolean(value2);
+    if (typeof value2 === "string") return value2 === "" ? _FormulaValue.blank : _FormulaValue.text(value2);
+    if (value2 instanceof Date) {
+      return _FormulaValue.number(toOADate(value2));
+    }
+    return _FormulaValue.text(String(value2));
+  }
+  toObject() {
+    switch (this.kind) {
+      case "number":
+        return __privateGet(this, _num);
+      case "text":
+        return this.textValue;
+      case "boolean":
+        return this.booleanValue;
+      case "blank":
+        return null;
+      case "error":
+        return _FormulaValue.errorToString(this.errorCode);
+      case "array":
+        return this.arrayVal.toObjectArray();
+      default:
+        return null;
+    }
+  }
+  toString() {
+    return this.asText();
+  }
+};
+_num = new WeakMap();
+_obj = new WeakMap();
+// ── Cached singletons ────────────────────────────────────────────────────
+_FormulaValue.blank = new _FormulaValue("blank");
+_FormulaValue.zero = new _FormulaValue("number", 0);
+_FormulaValue.one = new _FormulaValue("number", 1);
+_FormulaValue.true_ = new _FormulaValue("boolean", 1);
+_FormulaValue.false_ = new _FormulaValue("boolean", 0);
+_FormulaValue.emptyString = new _FormulaValue("text", 0, "");
+_FormulaValue.errorDiv0 = new _FormulaValue("error", 0, void 0, 2 /* Div0 */);
+_FormulaValue.errorValue = new _FormulaValue("error", 0, void 0, 3 /* Value */);
+_FormulaValue.errorRef = new _FormulaValue("error", 0, void 0, 4 /* Ref */);
+_FormulaValue.errorName = new _FormulaValue("error", 0, void 0, 5 /* Name */);
+_FormulaValue.errorNA = new _FormulaValue("error", 0, void 0, 7 /* NA */);
+_FormulaValue.errorNum = new _FormulaValue("error", 0, void 0, 6 /* Num */);
+_FormulaValue.errorNull = new _FormulaValue("error", 0, void 0, 1 /* Null */);
+var FormulaValue = _FormulaValue;
+var _data;
+var _ArrayValue = class _ArrayValue {
+  constructor(rows2, columns2) {
+    __privateAdd(this, _data);
+    this.rows = rows2;
+    this.columns = columns2;
+    __privateSet(this, _data, new Array(rows2 * columns2).fill(FormulaValue.blank));
+  }
+  get length() {
+    return __privateGet(this, _data).length;
+  }
+  get(row2, col) {
+    if (row2 < 0 || row2 >= this.rows || col < 0 || col >= this.columns) {
+      return FormulaValue.errorRef;
+    }
+    return __privateGet(this, _data)[row2 * this.columns + col];
+  }
+  set(row2, col, value2) {
+    if (row2 >= 0 && row2 < this.rows && col >= 0 && col < this.columns) {
+      __privateGet(this, _data)[row2 * this.columns + col] = value2;
+    }
+  }
+  getFlat(index) {
+    return index >= 0 && index < __privateGet(this, _data).length ? __privateGet(this, _data)[index] : FormulaValue.errorRef;
+  }
+  setFlat(index, value2) {
+    if (index >= 0 && index < __privateGet(this, _data).length) {
+      __privateGet(this, _data)[index] = value2;
+    }
+  }
+  /** Iterate all values in row-major order. */
+  values() {
+    return __privateGet(this, _data);
+  }
+  toObjectArray() {
+    return __privateGet(this, _data).map((v) => v.toObject());
+  }
+  /** Create from a flat array (single column). */
+  static fromFlat(values) {
+    const arr = new _ArrayValue(values.length, 1);
+    values.forEach((v, i) => arr.setFlat(i, v));
+    return arr;
+  }
+  /** Create a 1×1 array wrapping a scalar value (for broadcasting). */
+  static fromScalar(value2) {
+    const arr = new _ArrayValue(1, 1);
+    arr.setFlat(0, value2);
+    return arr;
+  }
+  /** Element-wise broadcasting operation (mirrors ArrayValue.Broadcast in C#). */
+  static broadcast(a, b, op) {
+    const rows2 = Math.max(a.rows, b.rows);
+    const cols = Math.max(a.columns, b.columns);
+    if (a.rows !== 1 && b.rows !== 1 && a.rows !== b.rows || a.columns !== 1 && b.columns !== 1 && a.columns !== b.columns) {
+      const err = new _ArrayValue(rows2, cols);
+      for (let i = 0; i < err.length; i++) err.setFlat(i, FormulaValue.errorValue);
+      return err;
+    }
+    const result = new _ArrayValue(rows2, cols);
+    for (let r = 0; r < rows2; r++) {
+      for (let c = 0; c < cols; c++) {
+        const av = a.get(r < a.rows ? r : 0, c < a.columns ? c : 0);
+        const bv = b.get(r < b.rows ? r : 0, c < b.columns ? c : 0);
+        result.set(r, c, op(av, bv));
+      }
+    }
+    return result;
+  }
+  /** Implicit intersection: reduce array to scalar based on formula position. */
+  implicitIntersect(formulaRow, formulaCol, rangeStartRow, rangeStartCol) {
+    if (this.rows === 1 && this.columns === 1) return this.get(0, 0);
+    if (this.columns === 1) {
+      const offset2 = formulaRow - rangeStartRow;
+      return offset2 >= 0 && offset2 < this.rows ? this.get(offset2, 0) : FormulaValue.errorValue;
+    }
+    if (this.rows === 1) {
+      const offset2 = formulaCol - rangeStartCol;
+      return offset2 >= 0 && offset2 < this.columns ? this.get(0, offset2) : FormulaValue.errorValue;
+    }
+    const ro = formulaRow - rangeStartRow;
+    const co = formulaCol - rangeStartCol;
+    return ro >= 0 && ro < this.rows && co >= 0 && co < this.columns ? this.get(ro, co) : FormulaValue.errorValue;
+  }
+  transpose() {
+    const result = new _ArrayValue(this.columns, this.rows);
+    for (let r = 0; r < this.rows; r++) {
+      for (let c = 0; c < this.columns; c++) {
+        result.set(c, r, this.get(r, c));
+      }
+    }
+    return result;
+  }
+};
+_data = new WeakMap();
+_ArrayValue.empty = new _ArrayValue(0, 0);
+var ArrayValue = _ArrayValue;
+
+// src/formula-token.ts
+var TokenType = /* @__PURE__ */ ((TokenType2) => {
+  TokenType2[TokenType2["Number"] = 0] = "Number";
+  TokenType2[TokenType2["String"] = 1] = "String";
+  TokenType2[TokenType2["Boolean"] = 2] = "Boolean";
+  TokenType2[TokenType2["CellReference"] = 3] = "CellReference";
+  TokenType2[TokenType2["Colon"] = 4] = "Colon";
+  TokenType2[TokenType2["Function"] = 5] = "Function";
+  TokenType2[TokenType2["LeftParen"] = 6] = "LeftParen";
+  TokenType2[TokenType2["RightParen"] = 7] = "RightParen";
+  TokenType2[TokenType2["Comma"] = 8] = "Comma";
+  TokenType2[TokenType2["Plus"] = 9] = "Plus";
+  TokenType2[TokenType2["Minus"] = 10] = "Minus";
+  TokenType2[TokenType2["Multiply"] = 11] = "Multiply";
+  TokenType2[TokenType2["Divide"] = 12] = "Divide";
+  TokenType2[TokenType2["Power"] = 13] = "Power";
+  TokenType2[TokenType2["Percent"] = 14] = "Percent";
+  TokenType2[TokenType2["Ampersand"] = 15] = "Ampersand";
+  TokenType2[TokenType2["Equal"] = 16] = "Equal";
+  TokenType2[TokenType2["NotEqual"] = 17] = "NotEqual";
+  TokenType2[TokenType2["LessThan"] = 18] = "LessThan";
+  TokenType2[TokenType2["LessThanOrEqual"] = 19] = "LessThanOrEqual";
+  TokenType2[TokenType2["GreaterThan"] = 20] = "GreaterThan";
+  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";
+  return TokenType2;
+})(TokenType || {});
+function makeToken(type, value2, position) {
+  return { type, value: value2, position };
+}
+
+// src/formula-lexer.ts
+var FormulaException = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FormulaException";
+  }
+};
+var KNOWN_ERRORS = /* @__PURE__ */ new Set([
+  "#NULL!",
+  "#DIV/0!",
+  "#VALUE!",
+  "#REF!",
+  "#NAME?",
+  "#NUM!",
+  "#N/A",
+  "#CALC!",
+  "#SPILL!"
+]);
+var _formula, _pos, _FormulaLexer_instances, readNextToken_fn, readString_fn, readErrorLiteral_fn, readQuotedSheetRef_fn, readNumber_fn, readIdentifier_fn, readCellRefChars_fn, readOperator_fn, skipWhitespace_fn;
+var FormulaLexer = class {
+  constructor(formula) {
+    __privateAdd(this, _FormulaLexer_instances);
+    __privateAdd(this, _formula);
+    __privateAdd(this, _pos, 0);
+    if (!formula) throw new FormulaException("Formula cannot be empty.");
+    __privateSet(this, _formula, formula);
+  }
+  tokenize() {
+    __privateSet(this, _pos, 0);
+    const tokens = [];
+    while (__privateGet(this, _pos) < __privateGet(this, _formula).length) {
+      __privateMethod(this, _FormulaLexer_instances, skipWhitespace_fn).call(this);
+      if (__privateGet(this, _pos) >= __privateGet(this, _formula).length) break;
+      const token = __privateMethod(this, _FormulaLexer_instances, readNextToken_fn).call(this);
+      if (token) tokens.push(token);
+    }
+    tokens.push(makeToken(27 /* EOF */, "", __privateGet(this, _pos)));
+    return tokens;
+  }
+};
+_formula = new WeakMap();
+_pos = new WeakMap();
+_FormulaLexer_instances = new WeakSet();
+// ── Private tokenisers ─────────────────────────────────────────────────────
+readNextToken_fn = function() {
+  const c = __privateGet(this, _formula)[__privateGet(this, _pos)];
+  if (c === '"') return __privateMethod(this, _FormulaLexer_instances, readString_fn).call(this);
+  if (c === "#") return __privateMethod(this, _FormulaLexer_instances, readErrorLiteral_fn).call(this);
+  if (c === "'") return __privateMethod(this, _FormulaLexer_instances, readQuotedSheetRef_fn).call(this);
+  if (c === "." && __privateGet(this, _pos) + 1 < __privateGet(this, _formula).length && /\d/.test(__privateGet(this, _formula)[__privateGet(this, _pos) + 1])) {
+    return __privateMethod(this, _FormulaLexer_instances, readNumber_fn).call(this);
+  }
+  if (/\d/.test(c)) return __privateMethod(this, _FormulaLexer_instances, readNumber_fn).call(this);
+  if (/[a-zA-Z_$]/.test(c)) return __privateMethod(this, _FormulaLexer_instances, readIdentifier_fn).call(this);
+  return __privateMethod(this, _FormulaLexer_instances, readOperator_fn).call(this);
+};
+readString_fn = function() {
+  const start = __privateWrapper(this, _pos)._++;
+  let value2 = "";
+  while (__privateGet(this, _pos) < __privateGet(this, _formula).length) {
+    const ch = __privateGet(this, _formula)[__privateGet(this, _pos)];
+    if (ch === '"') {
+      __privateWrapper(this, _pos)._++;
+      if (__privateGet(this, _formula)[__privateGet(this, _pos)] === '"') {
+        value2 += '"';
+        __privateWrapper(this, _pos)._++;
+      } else return makeToken(1 /* String */, value2, start);
+    } else {
+      value2 += ch;
+      __privateWrapper(this, _pos)._++;
+    }
+  }
+  throw new FormulaException(`Unterminated string at position ${start}.`);
+};
+readErrorLiteral_fn = function() {
+  const start = __privateGet(this, _pos);
+  let raw = "#";
+  __privateWrapper(this, _pos)._++;
+  while (__privateGet(this, _pos) < __privateGet(this, _formula).length) {
+    const ch = __privateGet(this, _formula)[__privateGet(this, _pos)];
+    if (/[a-zA-Z0-9/]/.test(ch) || ch === "!" || ch === "?") {
+      raw += ch;
+      __privateWrapper(this, _pos)._++;
+      if (ch === "!" || ch === "?") break;
+    } else break;
+  }
+  const upper2 = raw.toUpperCase();
+  if (!KNOWN_ERRORS.has(upper2)) {
+    throw new FormulaException(`Unknown error literal "${raw}" at position ${start}.`);
+  }
+  return makeToken(26 /* ErrorLiteral */, upper2, start);
+};
+readQuotedSheetRef_fn = function() {
+  const start = __privateWrapper(this, _pos)._++;
+  let sheetName = "";
+  while (__privateGet(this, _pos) < __privateGet(this, _formula).length) {
+    const ch = __privateGet(this, _formula)[__privateGet(this, _pos)];
+    if (ch === "'") {
+      __privateWrapper(this, _pos)._++;
+      if (__privateGet(this, _formula)[__privateGet(this, _pos)] === "'") {
+        sheetName += "'";
+        __privateWrapper(this, _pos)._++;
+      } else {
+        if (__privateGet(this, _formula)[__privateGet(this, _pos)] !== "!") {
+          throw new FormulaException(`Expected '!' after quoted sheet name at position ${start}.`);
+        }
+        __privateWrapper(this, _pos)._++;
+        const cellRef = __privateMethod(this, _FormulaLexer_instances, readCellRefChars_fn).call(this);
+        return makeToken(22 /* SheetReference */, `${sheetName}!${cellRef}`, start);
+      }
+    } else {
+      sheetName += ch;
+      __privateWrapper(this, _pos)._++;
+    }
+  }
+  throw new FormulaException(`Unterminated quoted sheet name at position ${start}.`);
+};
+readNumber_fn = function() {
+  const start = __privateGet(this, _pos);
+  let raw = "";
+  let hasDot = false;
+  let hasE = false;
+  while (__privateGet(this, _pos) < __privateGet(this, _formula).length) {
+    const ch = __privateGet(this, _formula)[__privateGet(this, _pos)];
+    if (/\d/.test(ch)) {
+      raw += ch;
+      __privateWrapper(this, _pos)._++;
+    } else if (ch === "." && !hasDot && !hasE) {
+      hasDot = true;
+      raw += ch;
+      __privateWrapper(this, _pos)._++;
+    } else if ((ch === "e" || ch === "E") && !hasE && raw.length > 0) {
+      hasE = true;
+      raw += ch;
+      __privateWrapper(this, _pos)._++;
+      if (__privateGet(this, _formula)[__privateGet(this, _pos)] === "+" || __privateGet(this, _formula)[__privateGet(this, _pos)] === "-") {
+        raw += __privateGet(this, _formula)[__privateWrapper(this, _pos)._++];
+      }
+    } else break;
+  }
+  return makeToken(0 /* Number */, raw, start);
+};
+readIdentifier_fn = function() {
+  const start = __privateGet(this, _pos);
+  let raw = "";
+  while (__privateGet(this, _pos) < __privateGet(this, _formula).length) {
+    const ch = __privateGet(this, _formula)[__privateGet(this, _pos)];
+    if (/[a-zA-Z0-9_$.]/.test(ch)) {
+      raw += ch;
+      __privateWrapper(this, _pos)._++;
+    } else break;
+  }
+  let upper2 = raw.toUpperCase();
+  if (upper2.startsWith("_XLFN.")) {
+    raw = raw.slice(6);
+    upper2 = upper2.slice(6);
+  }
+  if (upper2 === "TRUE") return makeToken(2 /* Boolean */, "TRUE", start);
+  if (upper2 === "FALSE") return makeToken(2 /* Boolean */, "FALSE", start);
+  if (__privateGet(this, _formula)[__privateGet(this, _pos)] === "!") {
+    __privateWrapper(this, _pos)._++;
+    const cellRef = __privateMethod(this, _FormulaLexer_instances, readCellRefChars_fn).call(this);
+    return makeToken(22 /* SheetReference */, `${raw}!${cellRef}`, start);
+  }
+  __privateMethod(this, _FormulaLexer_instances, skipWhitespace_fn).call(this);
+  if (__privateGet(this, _formula)[__privateGet(this, _pos)] === "(") {
+    return makeToken(5 /* Function */, upper2, start);
+  }
+  const stripped = raw.replace(/\$/g, "");
+  if (isCellRef(stripped)) return makeToken(3 /* CellReference */, stripped, start);
+  return makeToken(23 /* NamedRange */, raw, start);
+};
+readCellRefChars_fn = function() {
+  let ref = "";
+  while (__privateGet(this, _pos) < __privateGet(this, _formula).length) {
+    const ch = __privateGet(this, _formula)[__privateGet(this, _pos)];
+    if (/[a-zA-Z0-9$]/.test(ch)) {
+      ref += ch;
+      __privateWrapper(this, _pos)._++;
+    } else break;
+  }
+  return ref.replace(/\$/g, "");
+};
+readOperator_fn = function() {
+  const start = __privateGet(this, _pos);
+  const ch = __privateGet(this, _formula)[__privateWrapper(this, _pos)._++];
+  switch (ch) {
+    case "(":
+      return makeToken(6 /* LeftParen */, "(", start);
+    case ")":
+      return makeToken(7 /* RightParen */, ")", start);
+    case ",":
+      return makeToken(8 /* Comma */, ",", start);
+    case ":":
+      return makeToken(4 /* Colon */, ":", start);
+    case "+":
+      return makeToken(9 /* Plus */, "+", start);
+    case "-":
+      return makeToken(10 /* Minus */, "-", start);
+    case "*":
+      return makeToken(11 /* Multiply */, "*", start);
+    case "/":
+      return makeToken(12 /* Divide */, "/", start);
+    case "^":
+      return makeToken(13 /* Power */, "^", start);
+    case "%":
+      return makeToken(14 /* Percent */, "%", start);
+    case "&":
+      return makeToken(15 /* Ampersand */, "&", start);
+    case "=":
+      return makeToken(16 /* Equal */, "=", start);
+    case "@":
+      return makeToken(25 /* AtSign */, "@", start);
+    case "!":
+      return makeToken(24 /* Exclamation */, "!", start);
+    case "<":
+      if (__privateGet(this, _formula)[__privateGet(this, _pos)] === ">") {
+        __privateWrapper(this, _pos)._++;
+        return makeToken(17 /* NotEqual */, "<>", start);
+      }
+      if (__privateGet(this, _formula)[__privateGet(this, _pos)] === "=") {
+        __privateWrapper(this, _pos)._++;
+        return makeToken(19 /* LessThanOrEqual */, "<=", start);
+      }
+      return makeToken(18 /* LessThan */, "<", start);
+    case ">":
+      if (__privateGet(this, _formula)[__privateGet(this, _pos)] === "=") {
+        __privateWrapper(this, _pos)._++;
+        return makeToken(21 /* GreaterThanOrEqual */, ">=", start);
+      }
+      return makeToken(20 /* GreaterThan */, ">", start);
+    default:
+      throw new FormulaException(`Unexpected character '${ch}' at position ${start}.`);
+  }
+};
+skipWhitespace_fn = function() {
+  while (__privateGet(this, _pos) < __privateGet(this, _formula).length && /\s/.test(__privateGet(this, _formula)[__privateGet(this, _pos)])) {
+    __privateWrapper(this, _pos)._++;
+  }
+};
+function isCellRef(s) {
+  if (s.length < 2) return false;
+  let i = 0;
+  while (i < s.length && /[a-zA-Z]/.test(s[i])) i++;
+  if (i === 0 || i >= s.length) return false;
+  while (i < s.length && /\d/.test(s[i])) i++;
+  return i === s.length;
+}
+
+// src/formula-node.ts
+var FormulaNode = class {
+};
+var NumberNode = class extends FormulaNode {
+  constructor(value2) {
+    super();
+    this.value = value2;
+  }
+  evaluate() {
+    return FormulaValue.number(this.value);
+  }
+};
+var StringNode = class extends FormulaNode {
+  constructor(value2) {
+    super();
+    this.value = value2;
+  }
+  evaluate() {
+    return FormulaValue.text(this.value);
+  }
+};
+var BooleanNode = class extends FormulaNode {
+  constructor(value2) {
+    super();
+    this.value = value2;
+  }
+  evaluate() {
+    return FormulaValue.boolean(this.value);
+  }
+};
+var ErrorNode = class extends FormulaNode {
+  constructor(errorValue) {
+    super();
+    this.errorValue = errorValue;
+  }
+  evaluate() {
+    return this.errorValue;
+  }
+};
+var BlankNode = class extends FormulaNode {
+  evaluate() {
+    return FormulaValue.blank;
+  }
+};
+var CellReferenceNode = class extends FormulaNode {
+  constructor(reference) {
+    super();
+    this.reference = reference;
+  }
+  evaluate(ctx) {
+    return ctx.getCellValue(this.reference);
+  }
+};
+var RangeReferenceNode = class extends FormulaNode {
+  constructor(startRef, endRef) {
+    super();
+    this.startRef = startRef;
+    this.endRef = endRef;
+  }
+  evaluate(ctx) {
+    return ctx.getRangeValues(this.startRef, this.endRef);
+  }
+};
+var SheetCellReferenceNode = class extends FormulaNode {
+  constructor(sheetName, cellReference) {
+    super();
+    this.sheetName = sheetName;
+    this.cellReference = cellReference;
+  }
+  evaluate(ctx) {
+    return ctx.getSheetCellValue(this.sheetName, this.cellReference);
+  }
+};
+var SheetRangeReferenceNode = class extends FormulaNode {
+  constructor(sheetName, startRef, endRef) {
+    super();
+    this.sheetName = sheetName;
+    this.startRef = startRef;
+    this.endRef = endRef;
+  }
+  evaluate(ctx) {
+    return ctx.getSheetRangeValues(this.sheetName, this.startRef, this.endRef);
+  }
+};
+var NamedRangeNode = class extends FormulaNode {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  evaluate(ctx) {
+    return ctx.resolveNamedRange(this.name);
+  }
+};
+var BinaryOperator = /* @__PURE__ */ ((BinaryOperator2) => {
+  BinaryOperator2[BinaryOperator2["Add"] = 0] = "Add";
+  BinaryOperator2[BinaryOperator2["Subtract"] = 1] = "Subtract";
+  BinaryOperator2[BinaryOperator2["Multiply"] = 2] = "Multiply";
+  BinaryOperator2[BinaryOperator2["Divide"] = 3] = "Divide";
+  BinaryOperator2[BinaryOperator2["Power"] = 4] = "Power";
+  BinaryOperator2[BinaryOperator2["Concatenate"] = 5] = "Concatenate";
+  BinaryOperator2[BinaryOperator2["Equal"] = 6] = "Equal";
+  BinaryOperator2[BinaryOperator2["NotEqual"] = 7] = "NotEqual";
+  BinaryOperator2[BinaryOperator2["LessThan"] = 8] = "LessThan";
+  BinaryOperator2[BinaryOperator2["LessThanOrEqual"] = 9] = "LessThanOrEqual";
+  BinaryOperator2[BinaryOperator2["GreaterThan"] = 10] = "GreaterThan";
+  BinaryOperator2[BinaryOperator2["GreaterThanOrEqual"] = 11] = "GreaterThanOrEqual";
+  return BinaryOperator2;
+})(BinaryOperator || {});
+var UnaryOperator = /* @__PURE__ */ ((UnaryOperator2) => {
+  UnaryOperator2[UnaryOperator2["Negate"] = 0] = "Negate";
+  UnaryOperator2[UnaryOperator2["Plus"] = 1] = "Plus";
+  UnaryOperator2[UnaryOperator2["Percent"] = 2] = "Percent";
+  return UnaryOperator2;
+})(UnaryOperator || {});
+var _BinaryOpNode_instances, evalScalar_fn;
+var BinaryOpNode = class extends FormulaNode {
+  constructor(left2, op, right2) {
+    super();
+    this.left = left2;
+    this.op = op;
+    this.right = right2;
+    __privateAdd(this, _BinaryOpNode_instances);
+  }
+  evaluate(ctx) {
+    const l = this.left.evaluate(ctx);
+    const r = this.right.evaluate(ctx);
+    if (l.isArray || r.isArray) {
+      const la = l.isArray ? l.arrayVal : ArrayValue.fromScalar(l);
+      const ra = r.isArray ? r.arrayVal : ArrayValue.fromScalar(r);
+      return FormulaValue.array(
+        ArrayValue.broadcast(la, ra, (a, b) => __privateMethod(this, _BinaryOpNode_instances, evalScalar_fn).call(this, a, b))
+      );
+    }
+    return __privateMethod(this, _BinaryOpNode_instances, evalScalar_fn).call(this, l, r);
+  }
+};
+_BinaryOpNode_instances = new WeakSet();
+evalScalar_fn = function(l, r) {
+  const op = this.op;
+  if (op === 6 /* Equal */) return FormulaValue.boolean(FormulaValue.areEqual(l, r));
+  if (op === 7 /* NotEqual */) return FormulaValue.boolean(!FormulaValue.areEqual(l, r));
+  if (op === 8 /* LessThan */) return FormulaValue.boolean(FormulaValue.compare(l, r) < 0);
+  if (op === 9 /* LessThanOrEqual */) return FormulaValue.boolean(FormulaValue.compare(l, r) <= 0);
+  if (op === 10 /* GreaterThan */) return FormulaValue.boolean(FormulaValue.compare(l, r) > 0);
+  if (op === 11 /* GreaterThanOrEqual */) return FormulaValue.boolean(FormulaValue.compare(l, r) >= 0);
+  if (op === 5 /* Concatenate */) {
+    if (l.isError) return l;
+    if (r.isError) return r;
+    return FormulaValue.text(l.asText() + r.asText());
+  }
+  const ln2 = l.coerceToNumber();
+  if (ln2.isError) return ln2;
+  const rn = r.coerceToNumber();
+  if (rn.isError) return rn;
+  const lv = ln2.numberValue;
+  const rv = rn.numberValue;
+  switch (op) {
+    case 0 /* Add */:
+      return FormulaValue.number(lv + rv);
+    case 1 /* Subtract */:
+      return FormulaValue.number(lv - rv);
+    case 2 /* Multiply */:
+      return FormulaValue.number(lv * rv);
+    case 3 /* Divide */:
+      if (rv === 0) return FormulaValue.errorDiv0;
+      return FormulaValue.number(lv / rv);
+    case 4 /* Power */:
+      return FormulaValue.number(Math.pow(lv, rv));
+    default:
+      return FormulaValue.errorValue;
+  }
+};
+var UnaryOpNode = class extends FormulaNode {
+  constructor(op, operand) {
+    super();
+    this.op = op;
+    this.operand = operand;
+  }
+  evaluate(ctx) {
+    const val = this.operand.evaluate(ctx);
+    if (this.op === 1 /* Plus */) {
+      return val.coerceToNumber();
+    }
+    if (this.op === 0 /* Negate */) {
+      const n = val.coerceToNumber();
+      if (n.isError) return n;
+      return FormulaValue.number(-n.numberValue);
+    }
+    if (this.op === 2 /* Percent */) {
+      const n = val.coerceToNumber();
+      if (n.isError) return n;
+      return FormulaValue.number(n.numberValue / 100);
+    }
+    return FormulaValue.errorValue;
+  }
+};
+var ImplicitIntersectionNode = class extends FormulaNode {
+  constructor(inner) {
+    super();
+    this.inner = inner;
+  }
+  evaluate(ctx) {
+    const val = this.inner.evaluate(ctx);
+    if (!val.isArray) return val;
+    return val.arrayVal.implicitIntersect(ctx.formulaRow, ctx.formulaCol, 0, 0);
+  }
+};
+var FunctionCallNode = class extends FormulaNode {
+  constructor(functionName, args) {
+    super();
+    this.functionName = functionName;
+    this.args = args;
+  }
+  evaluate(ctx) {
+    return ctx.evaluateFunction(this.functionName, this.args);
+  }
+};
+
+// 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 FormulaParser = class {
+  constructor(tokens) {
+    __privateAdd(this, _FormulaParser_instances);
+    __privateAdd(this, _tokens);
+    __privateAdd(this, _pos2, 0);
+    __privateSet(this, _tokens, tokens);
+  }
+  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 */) {
+      throw new FormulaException(
+        `Unexpected token '${__privateGet(this, _FormulaParser_instances, current_get).value}' at position ${__privateGet(this, _FormulaParser_instances, current_get).position}.`
+      );
+    }
+    return node;
+  }
+};
+_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 };
+};
+advance_fn = function() {
+  const t = __privateGet(this, _FormulaParser_instances, current_get);
+  __privateWrapper(this, _pos2)._++;
+  return t;
+};
+expect_fn = function(type) {
+  if (__privateGet(this, _FormulaParser_instances, current_get).type !== type) {
+    throw new FormulaException(
+      `Expected token type ${type} but got ${__privateGet(this, _FormulaParser_instances, current_get).type} ('${__privateGet(this, _FormulaParser_instances, current_get).value}') at position ${__privateGet(this, _FormulaParser_instances, current_get).position}.`
+    );
+  }
+  return __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+};
+// ── Precedence levels ──────────────────────────────────────────────────────
+parseComparison_fn = function() {
+  let left2 = __privateMethod(this, _FormulaParser_instances, parseConcatenation_fn).call(this);
+  while (true) {
+    const op = comparisonOp(__privateGet(this, _FormulaParser_instances, current_get).type);
+    if (op === null) break;
+    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+    left2 = new BinaryOpNode(left2, op, __privateMethod(this, _FormulaParser_instances, parseConcatenation_fn).call(this));
+  }
+  return left2;
+};
+parseConcatenation_fn = function() {
+  let left2 = __privateMethod(this, _FormulaParser_instances, parseAddSub_fn).call(this);
+  while (__privateGet(this, _FormulaParser_instances, current_get).type === 15 /* Ampersand */) {
+    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+    left2 = new BinaryOpNode(left2, 5 /* Concatenate */, __privateMethod(this, _FormulaParser_instances, parseAddSub_fn).call(this));
+  }
+  return left2;
+};
+parseAddSub_fn = function() {
+  let left2 = __privateMethod(this, _FormulaParser_instances, parseMulDiv_fn).call(this);
+  while (true) {
+    const t = __privateGet(this, _FormulaParser_instances, current_get).type;
+    if (t !== 9 /* Plus */ && t !== 10 /* Minus */) break;
+    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+    const op = t === 9 /* Plus */ ? 0 /* Add */ : 1 /* Subtract */;
+    left2 = new BinaryOpNode(left2, op, __privateMethod(this, _FormulaParser_instances, parseMulDiv_fn).call(this));
+  }
+  return left2;
+};
+parseMulDiv_fn = function() {
+  let left2 = __privateMethod(this, _FormulaParser_instances, parseUnary_fn).call(this);
+  while (true) {
+    const t = __privateGet(this, _FormulaParser_instances, current_get).type;
+    if (t !== 11 /* Multiply */ && t !== 12 /* Divide */) break;
+    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+    const op = t === 11 /* Multiply */ ? 2 /* Multiply */ : 3 /* Divide */;
+    left2 = new BinaryOpNode(left2, op, __privateMethod(this, _FormulaParser_instances, parseUnary_fn).call(this));
+  }
+  return left2;
+};
+parseUnary_fn = function() {
+  if (__privateGet(this, _FormulaParser_instances, current_get).type === 10 /* Minus */) {
+    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+    return new UnaryOpNode(0 /* Negate */, __privateMethod(this, _FormulaParser_instances, parsePower_fn).call(this));
+  }
+  if (__privateGet(this, _FormulaParser_instances, current_get).type === 9 /* Plus */) {
+    __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 */) {
+    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+    return new ImplicitIntersectionNode(__privateMethod(this, _FormulaParser_instances, parsePower_fn).call(this));
+  }
+  return __privateMethod(this, _FormulaParser_instances, parsePower_fn).call(this);
+};
+parsePower_fn = function() {
+  const left2 = __privateMethod(this, _FormulaParser_instances, parsePercent_fn).call(this);
+  if (__privateGet(this, _FormulaParser_instances, current_get).type === 13 /* Power */) {
+    __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+    return new BinaryOpNode(left2, 4 /* Power */, __privateMethod(this, _FormulaParser_instances, parseUnary_fn).call(this));
+  }
+  return left2;
+};
+parsePercent_fn = function() {
+  let node = __privateMethod(this, _FormulaParser_instances, parsePrimary_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;
+};
+parsePrimary_fn = function() {
+  const token = __privateGet(this, _FormulaParser_instances, current_get);
+  switch (token.type) {
+    case 0 /* Number */: {
+      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+      const n = parseFloat(token.value);
+      if (isNaN(n)) throw new FormulaException(`Invalid number: ${token.value}`);
+      return new NumberNode(n);
+    }
+    case 1 /* String */:
+      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+      return new StringNode(token.value);
+    case 2 /* Boolean */:
+      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+      return new BooleanNode(token.value === "TRUE");
+    case 26 /* ErrorLiteral */:
+      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+      return new ErrorNode(FormulaValue.error(FormulaValue.errorFromString(token.value)));
+    case 3 /* CellReference */: {
+      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+      if (__privateGet(this, _FormulaParser_instances, current_get).type === 4 /* Colon */) {
+        __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+        const end = __privateMethod(this, _FormulaParser_instances, expect_fn).call(this, 3 /* CellReference */);
+        return new RangeReferenceNode(token.value, end.value);
+      }
+      return new CellReferenceNode(token.value);
+    }
+    case 22 /* SheetReference */: {
+      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+      const parts = token.value.split("!");
+      const sheetName = parts[0];
+      const cellRef = parts[1] ?? "";
+      if (__privateGet(this, _FormulaParser_instances, current_get).type === 4 /* Colon */) {
+        __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+        const end = __privateMethod(this, _FormulaParser_instances, expect_fn).call(this, 3 /* CellReference */);
+        return new SheetRangeReferenceNode(sheetName, cellRef, end.value);
+      }
+      return new SheetCellReferenceNode(sheetName, cellRef);
+    }
+    case 23 /* NamedRange */:
+      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+      return new NamedRangeNode(token.value);
+    case 5 /* Function */:
+      return __privateMethod(this, _FormulaParser_instances, parseFunction_fn).call(this);
+    case 6 /* LeftParen */: {
+      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+      const expr = __privateMethod(this, _FormulaParser_instances, parseComparison_fn).call(this);
+      __privateMethod(this, _FormulaParser_instances, expect_fn).call(this, 7 /* RightParen */);
+      return expr;
+    }
+    default:
+      throw new FormulaException(
+        `Unexpected token '${token.value}' (type ${token.type}) at position ${token.position}.`
+      );
+  }
+};
+parseFunction_fn = function() {
+  const nameToken = __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+  __privateMethod(this, _FormulaParser_instances, expect_fn).call(this, 6 /* LeftParen */);
+  const args = [];
+  if (__privateGet(this, _FormulaParser_instances, current_get).type !== 7 /* RightParen */) {
+    if (__privateGet(this, _FormulaParser_instances, current_get).type === 8 /* Comma */) {
+      args.push(new BlankNode());
+    } else {
+      args.push(__privateMethod(this, _FormulaParser_instances, parseComparison_fn).call(this));
+    }
+    while (__privateGet(this, _FormulaParser_instances, current_get).type === 8 /* Comma */) {
+      __privateMethod(this, _FormulaParser_instances, advance_fn).call(this);
+      if (__privateGet(this, _FormulaParser_instances, current_get).type === 8 /* Comma */ || __privateGet(this, _FormulaParser_instances, current_get).type === 7 /* RightParen */) {
+        args.push(new BlankNode());
+      } else {
+        args.push(__privateMethod(this, _FormulaParser_instances, parseComparison_fn).call(this));
+      }
+    }
+  }
+  __privateMethod(this, _FormulaParser_instances, expect_fn).call(this, 7 /* RightParen */);
+  return new FunctionCallNode(nameToken.value.toUpperCase(), args);
+};
+function comparisonOp(type) {
+  switch (type) {
+    case 16 /* Equal */:
+      return 6 /* Equal */;
+    case 17 /* NotEqual */:
+      return 7 /* NotEqual */;
+    case 18 /* LessThan */:
+      return 8 /* LessThan */;
+    case 19 /* LessThanOrEqual */:
+      return 9 /* LessThanOrEqual */;
+    case 20 /* GreaterThan */:
+      return 10 /* GreaterThan */;
+    case 21 /* GreaterThanOrEqual */:
+      return 11 /* GreaterThanOrEqual */;
+    default:
+      return null;
+  }
+}
+
+// src/functions/math-functions.ts
+function registerMath(r) {
+  r.register("SUM", sum, 1);
+  r.register("AVERAGE", average, 1);
+  r.register("MIN", min, 1);
+  r.register("MAX", max, 1);
+  r.register("COUNT", count, 1);
+  r.register("COUNTA", countA, 1);
+  r.register("COUNTBLANK", countBlank, 1, 1);
+  r.register("COUNTIF", countIf, 2, 2);
+  r.register("SUMIF", sumIf, 2, 3);
+  r.register("AVERAGEIF", averageIf, 2, 3);
+  r.register("PRODUCT", product, 1);
+  r.register("SUMPRODUCT", sumProduct, 1);
+  r.register("ABS", abs, 1, 1);
+  r.register("ROUND", round, 2, 2);
+  r.register("ROUNDUP", roundUp, 2, 2);
+  r.register("ROUNDDOWN", roundDown, 2, 2);
+  r.register("CEILING", ceiling, 2, 2);
+  r.register("CEILING.MATH", ceiling, 2, 2);
+  r.register("FLOOR", floor, 2, 2);
+  r.register("FLOOR.MATH", floor, 2, 2);
+  r.register("INT", int_, 1, 1);
+  r.register("TRUNC", trunc, 1, 2);
+  r.register("MOD", mod, 2, 2);
+  r.register("QUOTIENT", quotient, 2, 2);
+  r.register("POWER", power, 2, 2);
+  r.register("SQRT", sqrt, 1, 1);
+  r.register("SIGN", sign, 1, 1);
+  r.register("PI", pi, 0, 0);
+  r.register("RAND", rand, 0, 0, true);
+  r.register("RANDBETWEEN", randBetween, 2, 2, true);
+  r.register("LOG", log, 1, 2);
+  r.register("LOG10", log10, 1, 1);
+  r.register("LN", ln, 1, 1);
+  r.register("EXP", exp, 1, 1);
+  r.register("FACT", fact, 1, 1);
+  r.register("COMBIN", combin, 2, 2);
+}
+function sum(a, c) {
+  const r = FormulaHelper.collectNumbers(a, c);
+  if (!r.ok) return r.error;
+  return FormulaValue.number(r.values.reduce((s, n) => s + n, 0));
+}
+function average(a, c) {
+  const r = FormulaHelper.collectNumbers(a, c);
+  if (!r.ok) return r.error;
+  if (r.values.length === 0) return FormulaValue.errorDiv0;
+  return FormulaValue.number(r.values.reduce((s, n) => s + n, 0) / r.values.length);
+}
+function min(a, c) {
+  const r = FormulaHelper.collectNumbers(a, c);
+  if (!r.ok) return r.error;
+  return r.values.length === 0 ? FormulaValue.zero : FormulaValue.number(Math.min(...r.values));
+}
+function max(a, c) {
+  const r = FormulaHelper.collectNumbers(a, c);
+  if (!r.ok) return r.error;
+  return r.values.length === 0 ? FormulaValue.zero : FormulaValue.number(Math.max(...r.values));
+}
+function count(a, c) {
+  const flat = FormulaHelper.flattenArgs(a, c);
+  let n = 0;
+  for (const v of flat) {
+    if (v.isNumber || v.isText && !isNaN(parseFloat(v.textValue))) n++;
+  }
+  return FormulaValue.number(n);
+}
+function countA(a, c) {
+  return FormulaValue.number(FormulaHelper.flattenArgs(a, c).filter((v) => !v.isBlank).length);
+}
+function countBlank(a, c) {
+  const v = a[0].evaluate(c);
+  if (!v.isArray) return FormulaValue.number(v.isBlank ? 1 : 0);
+  let n = 0;
+  for (const item of v.arrayVal.values()) if (item.isBlank) n++;
+  return FormulaValue.number(n);
+}
+function countIf(a, c) {
+  const range = a[0].evaluate(c);
+  if (range.isError) return range;
+  const crit = a[1].evaluate(c);
+  if (crit.isError) return crit;
+  const criteria = crit.asText();
+  if (!range.isArray) return FormulaValue.number(FormulaHelper.matchesCriteria(range, criteria) ? 1 : 0);
+  let n = 0;
+  for (const item of range.arrayVal.values()) {
+    if (!item.isBlank && FormulaHelper.matchesCriteria(item, criteria)) n++;
+  }
+  return FormulaValue.number(n);
+}
+function sumIf(a, c) {
+  const range = a[0].evaluate(c);
+  if (range.isError) return range;
+  const crit = a[1].evaluate(c);
+  if (crit.isError) return crit;
+  const criteria = crit.asText();
+  const sumRange = a.length > 2 ? a[2].evaluate(c) : range;
+  if (sumRange.isError) return sumRange;
+  if (!range.isArray) {
+    if (FormulaHelper.matchesCriteria(range, criteria)) {
+      const r = sumRange.tryAsDouble();
+      return r.ok ? FormulaValue.number(r.value) : FormulaValue.zero;
+    }
+    return FormulaValue.zero;
+  }
+  const rangeArr = range.arrayVal;
+  const sumArr = sumRange.isArray ? sumRange.arrayVal : null;
+  let total = 0;
+  for (let i = 0; i < rangeArr.length; i++) {
+    const rv = rangeArr.getFlat(i);
+    if (rv.isBlank) continue;
+    if (FormulaHelper.matchesCriteria(rv, criteria)) {
+      const sv = sumArr ? sumArr.getFlat(i) : rangeArr.getFlat(i);
+      const r = sv.tryAsDouble();
+      if (r.ok) total += r.value;
+    }
+  }
+  return FormulaValue.number(total);
+}
+function averageIf(a, c) {
+  const range = a[0].evaluate(c);
+  if (range.isError) return range;
+  const crit = a[1].evaluate(c);
+  if (crit.isError) return crit;
+  const criteria = crit.asText();
+  const avgRange = a.length > 2 ? a[2].evaluate(c) : range;
+  if (avgRange.isError) return avgRange;
+  if (!range.isArray) {
+    if (!FormulaHelper.matchesCriteria(range, criteria)) return FormulaValue.errorDiv0;
+    const r = avgRange.tryAsDouble();
+    return r.ok ? FormulaValue.number(r.value) : FormulaValue.errorDiv0;
+  }
+  const rangeArr = range.arrayVal;
+  const avgArr = avgRange.isArray ? avgRange.arrayVal : null;
+  let total = 0, cnt = 0;
+  for (let i = 0; i < rangeArr.length; i++) {
+    const rv = rangeArr.getFlat(i);
+    if (rv.isBlank) continue;
+    if (FormulaHelper.matchesCriteria(rv, criteria)) {
+      const sv = avgArr ? avgArr.getFlat(i) : rangeArr.getFlat(i);
+      const r = sv.tryAsDouble();
+      if (r.ok) {
+        total += r.value;
+        cnt++;
+      }
+    }
+  }
+  return cnt === 0 ? FormulaValue.errorDiv0 : FormulaValue.number(total / cnt);
+}
+function product(a, c) {
+  const r = FormulaHelper.collectNumbers(a, c);
+  if (!r.ok) return r.error;
+  return FormulaValue.number(r.values.reduce((p, n) => p * n, 1));
+}
+function sumProduct(a, c) {
+  const arrays = a.map((arg) => arg.evaluate(c));
+  for (const v of arrays) if (v.isError) return v;
+  const first = arrays[0];
+  const len2 = first.isArray ? first.arrayVal.length : 1;
+  let total = 0;
+  for (let i = 0; i < len2; i++) {
+    let prod = 1;
+    for (const v of arrays) {
+      const item = v.isArray ? v.arrayVal.getFlat(i) : v;
+      const r = item.tryAsDouble();
+      if (!r.ok) {
+        prod = 0;
+        break;
+      }
+      prod *= r.value;
+    }
+    total += prod;
+  }
+  return FormulaValue.number(total);
+}
+function abs(a, c) {
+  const r = FormulaHelper.evalDouble(a[0], c);
+  return r.ok ? FormulaValue.number(Math.abs(r.value)) : r.error;
+}
+function round(a, c) {
+  const n = FormulaHelper.evalDouble(a[0], c);
+  if (!n.ok) return n.error;
+  const d = FormulaHelper.evalDouble(a[1], c);
+  if (!d.ok) return d.error;
+  const factor = Math.pow(10, Math.round(d.value));
+  return FormulaValue.number(Math.round(n.value * factor) / factor);
+}
+function roundUp(a, c) {
+  const n = FormulaHelper.evalDouble(a[0], c);
+  if (!n.ok) return n.error;
+  const d = FormulaHelper.evalDouble(a[1], c);
+  if (!d.ok) return d.error;
+  const factor = Math.pow(10, Math.round(d.value));
+  return FormulaValue.number(Math.ceil(n.value * factor) / factor);
+}
+function roundDown(a, c) {
+  const n = FormulaHelper.evalDouble(a[0], c);
+  if (!n.ok) return n.error;
+  const d = FormulaHelper.evalDouble(a[1], c);
+  if (!d.ok) return d.error;
+  const factor = Math.pow(10, Math.round(d.value));
+  return FormulaValue.number(Math.floor(n.value * factor) / factor);
+}
+function ceiling(a, c) {
+  const n = FormulaHelper.evalDouble(a[0], c);
+  if (!n.ok) return n.error;
+  const s = FormulaHelper.evalDouble(a[1], c);
+  if (!s.ok) return s.error;
+  if (s.value === 0) return FormulaValue.zero;
+  return FormulaValue.number(Math.ceil(n.value / s.value) * s.value);
+}
+function floor(a, c) {
+  const n = FormulaHelper.evalDouble(a[0], c);
+  if (!n.ok) return n.error;
+  const s = FormulaHelper.evalDouble(a[1], c);
+  if (!s.ok) return s.error;
+  if (s.value === 0) return FormulaValue.zero;
+  return FormulaValue.number(Math.floor(n.value / s.value) * s.value);
+}
+function int_(a, c) {
+  const r = FormulaHelper.evalDouble(a[0], c);
+  return r.ok ? FormulaValue.number(Math.floor(r.value)) : r.error;
+}
+function trunc(a, c) {
+  const n = FormulaHelper.evalDouble(a[0], c);
+  if (!n.ok) return n.error;
+  let digits = 0;
+  if (a.length > 1) {
+    const d = FormulaHelper.evalDouble(a[1], c);
+    if (!d.ok) return d.error;
+    digits = Math.round(d.value);
+  }
+  const factor = Math.pow(10, digits);
+  return FormulaValue.number(Math.trunc(n.value * factor) / factor);
+}
+function mod(a, c) {
+  const n = FormulaHelper.evalDouble(a[0], c);
+  if (!n.ok) return n.error;
+  const d = FormulaHelper.evalDouble(a[1], c);
+  if (!d.ok) return d.error;
+  if (d.value === 0) return FormulaValue.errorDiv0;
+  return FormulaValue.number(n.value - d.value * Math.floor(n.value / d.value));
+}
+function quotient(a, c) {
+  const n = FormulaHelper.evalDouble(a[0], c);
+  if (!n.ok) return n.error;
+  const d = FormulaHelper.evalDouble(a[1], c);
+  if (!d.ok) return d.error;
+  if (d.value === 0) return FormulaValue.errorDiv0;
+  return FormulaValue.number(Math.trunc(n.value / d.value));
+}
+function power(a, c) {
+  const b = FormulaHelper.evalDouble(a[0], c);
+  if (!b.ok) return b.error;
+  const e = FormulaHelper.evalDouble(a[1], c);
+  if (!e.ok) return e.error;
+  return FormulaValue.number(Math.pow(b.value, e.value));
+}
+function sqrt(a, c) {
+  const r = FormulaHelper.evalDouble(a[0], c);
+  if (!r.ok) return r.error;
+  if (r.value < 0) return FormulaValue.errorNum;
+  return FormulaValue.number(Math.sqrt(r.value));
+}
+function sign(a, c) {
+  const r = FormulaHelper.evalDouble(a[0], c);
+  return r.ok ? FormulaValue.number(Math.sign(r.value)) : r.error;
+}
+function pi() {
+  return FormulaValue.number(Math.PI);
+}
+function rand() {
+  return FormulaValue.number(Math.random());
+}
+function randBetween(a, c) {
+  const lo = FormulaHelper.evalDouble(a[0], c);
+  if (!lo.ok) return lo.error;
+  const hi = FormulaHelper.evalDouble(a[1], c);
+  if (!hi.ok) return hi.error;
+  return FormulaValue.number(Math.floor(lo.value + Math.random() * (hi.value - lo.value + 1)));
+}
+function log(a, c) {
+  const n = FormulaHelper.evalDouble(a[0], c);
+  if (!n.ok) return n.error;
+  if (n.value <= 0) return FormulaValue.errorNum;
+  let base = 10;
+  if (a.length > 1) {
+    const b = FormulaHelper.evalDouble(a[1], c);
+    if (!b.ok) return b.error;
+    base = b.value;
+  }
+  if (base <= 0 || base === 1) return FormulaValue.errorNum;
+  return FormulaValue.number(Math.log(n.value) / Math.log(base));
+}
+function log10(a, c) {
+  const r = FormulaHelper.evalDouble(a[0], c);
+  if (!r.ok) return r.error;
+  if (r.value <= 0) return FormulaValue.errorNum;
+  return FormulaValue.number(Math.log10(r.value));
+}
+function ln(a, c) {
+  const r = FormulaHelper.evalDouble(a[0], c);
+  if (!r.ok) return r.error;
+  if (r.value <= 0) return FormulaValue.errorNum;
+  return FormulaValue.number(Math.log(r.value));
+}
+function exp(a, c) {
+  const r = FormulaHelper.evalDouble(a[0], c);
+  return r.ok ? FormulaValue.number(Math.exp(r.value)) : r.error;
+}
+function fact(a, c) {
+  const r = FormulaHelper.evalDouble(a[0], c);
+  if (!r.ok) return r.error;
+  const n = Math.round(r.value);
+  if (n < 0) return FormulaValue.errorNum;
+  if (n > 170) return FormulaValue.errorNum;
+  let f = 1;
+  for (let i = 2; i <= n; i++) f *= i;
+  return FormulaValue.number(f);
+}
+function combin(a, c) {
+  const n = FormulaHelper.evalDouble(a[0], c);
+  if (!n.ok) return n.error;
+  const k = FormulaHelper.evalDouble(a[1], c);
+  if (!k.ok) return k.error;
+  const N = Math.round(n.value);
+  const K = Math.round(k.value);
+  if (N < 0 || K < 0 || K > N) return FormulaValue.errorNum;
+  let result = 1;
+  for (let i = 0; i < K; i++) result = result * (N - i) / (i + 1);
+  return FormulaValue.number(Math.round(result));
+}
+function registerText(r) {
+  r.register("LEFT", left, 1, 2);
+  r.register("RIGHT", right, 1, 2);
+  r.register("MID", mid, 3, 3);
+  r.register("LEN", len, 1, 1);
+  r.register("UPPER", upper, 1, 1);
+  r.register("LOWER", lower, 1, 1);
+  r.register("PROPER", proper, 1, 1);
+  r.register("TRIM", trim, 1, 1);
+  r.register("CLEAN", clean, 1, 1);
+  r.register("SUBSTITUTE", substitute, 3, 4);
+  r.register("REPLACE", replace, 4, 4);
+  r.register("CONCATENATE", concatenate, 1);
+  r.register("CONCAT", concatenate, 1);
+  r.register("TEXTJOIN", textJoin, 3);
+  r.register("TEXT", text_, 2, 2);
+  r.register("VALUE", value, 1, 1);
+  r.register("FIND", find, 2, 3);
+  r.register("SEARCH", search, 2, 3);
+  r.register("REPT", rept, 2, 2);
+  r.register("EXACT", exact, 2, 2);
+  r.register("CHAR", char_, 1, 1);
+  r.register("CODE", code, 1, 1);
+  r.register("T", t_, 1, 1);
+}
+function str(a, c, idx) {
+  const r = FormulaHelper.evalString(a[idx], c);
+  return r.ok ? { ok: true, s: r.value } : { ok: false, e: r.error };
+}
+function num(a, c, idx) {
+  const r = FormulaHelper.evalDouble(a[idx], c);
+  return r.ok ? { ok: true, n: r.value } : { ok: false, e: r.error };
+}
+function left(a, c) {
+  const s = str(a, c, 0);
+  if (!s.ok) return s.e;
+  let n = 1;
+  if (a.length > 1) {
+    const r = num(a, c, 1);
+    if (!r.ok) return r.e;
+    n = Math.round(r.n);
+  }
+  if (n < 0) return FormulaValue.errorValue;
+  return FormulaValue.text(s.s.slice(0, n));
+}
+function right(a, c) {
+  const s = str(a, c, 0);
+  if (!s.ok) return s.e;
+  let n = 1;
+  if (a.length > 1) {
+    const r = num(a, c, 1);
+    if (!r.ok) return r.e;
+    n = Math.round(r.n);
+  }
+  if (n < 0) return FormulaValue.errorValue;
+  return FormulaValue.text(n >= s.s.length ? s.s : s.s.slice(-n));
+}
+function mid(a, c) {
+  const s = str(a, c, 0);
+  if (!s.ok) return s.e;
+  const sv = num(a, c, 1);
+  if (!sv.ok) return sv.e;
+  const nv = num(a, c, 2);
+  if (!nv.ok) return nv.e;
+  const start = Math.round(sv.n) - 1;
+  const count2 = Math.round(nv.n);
+  if (start < 0 || count2 < 0) return FormulaValue.errorValue;
+  return FormulaValue.text(s.s.slice(start, start + count2));
+}
+function len(a, c) {
+  const s = str(a, c, 0);
+  if (!s.ok) return s.e;
+  return FormulaValue.number(s.s.length);
+}
+function upper(a, c) {
+  const s = str(a, c, 0);
+  if (!s.ok) return s.e;
+  return FormulaValue.text(s.s.toUpperCase());
+}
+function lower(a, c) {
+  const s = str(a, c, 0);
+  if (!s.ok) return s.e;
+  return FormulaValue.text(s.s.toLowerCase());
+}
+function proper(a, c) {
+  const s = str(a, c, 0);
+  if (!s.ok) return s.e;
+  let capitalise = true;
+  let result = "";
+  for (const ch of s.s) {
+    result += capitalise ? ch.toUpperCase() : ch.toLowerCase();
+    capitalise = !/[a-zA-Z]/.test(ch);
+  }
+  return FormulaValue.text(result);
+}
+function trim(a, c) {
+  const s = str(a, c, 0);
+  if (!s.ok) return s.e;
+  return FormulaValue.text(s.s.trim().replace(/\s+/g, " "));
+}
+function clean(a, c) {
+  const s = str(a, c, 0);
+  if (!s.ok) return s.e;
+  return FormulaValue.text([...s.s].filter((ch) => ch.charCodeAt(0) >= 32).join(""));
+}
+function substitute(a, c) {
+  const s = str(a, c, 0);
+  if (!s.ok) return s.e;
+  const old = str(a, c, 1);
+  if (!old.ok) return old.e;
+  const nw = str(a, c, 2);
+  if (!nw.ok) return nw.e;
+  if (a.length > 3) {
+    const iv = num(a, c, 3);
+    if (!iv.ok) return iv.e;
+    const inst = Math.round(iv.n);
+    let count2 = 0, pos = 0, result = "";
+    while (pos < s.s.length) {
+      const idx = s.s.indexOf(old.s, pos);
+      if (idx < 0) {
+        result += s.s.slice(pos);
+        break;
+      }
+      count2++;
+      if (count2 === inst) {
+        result += s.s.slice(pos, idx) + nw.s;
+        pos = idx + old.s.length;
+        result += s.s.slice(pos);
+        break;
+      }
+      result += s.s.slice(pos, idx + old.s.length);
+      pos = idx + old.s.length;
+    }
+    return FormulaValue.text(result);
+  }
+  return FormulaValue.text(s.s.split(old.s).join(nw.s));
+}
+function replace(a, c) {
+  const s = str(a, c, 0);
+  if (!s.ok) return s.e;
+  const sv = num(a, c, 1);
+  if (!sv.ok) return sv.e;
+  const nv = num(a, c, 2);
+  if (!nv.ok) return nv.e;
+  const nw = str(a, c, 3);
+  if (!nw.ok) return nw.e;
+  const start = Math.max(0, Math.round(sv.n) - 1);
+  const count2 = Math.max(0, Math.round(nv.n));
+  return FormulaValue.text(s.s.slice(0, start) + nw.s + s.s.slice(start + count2));
+}
+function concatenate(a, c) {
+  let result = "";
+  for (const arg of a) {
+    const v = arg.evaluate(c);
+    if (v.isError) return v;
+    result += v.asText();
+  }
+  return FormulaValue.text(result);
+}
+function textJoin(a, c) {
+  const delim = str(a, c, 0);
+  if (!delim.ok) return delim.e;
+  const ignV = a[1].evaluate(c);
+  if (ignV.isError) return ignV;
+  const ignoreEmpty = ignV.coerceToBool().booleanValue;
+  const parts = [];
+  for (let i = 2; i < a.length; i++) {
+    const v = a[i].evaluate(c);
+    if (v.isError) return v;
+    if (v.isArray) {
+      for (const item of v.arrayVal.values()) {
+        const t = item.asText();
+        if (!ignoreEmpty || t !== "") parts.push(t);
+      }
+    } else {
+      const t = v.asText();
+      if (!ignoreEmpty || t !== "") parts.push(t);
+    }
+  }
+  const result = parts.join(delim.s);
+  if (result.length > 32767) return FormulaValue.errorValue;
+  return FormulaValue.text(result);
+}
+function text_(a, c) {
+  const n = FormulaHelper.evalDouble(a[0], c);
+  if (!n.ok) return n.error;
+  const f = str(a, c, 1);
+  if (!f.ok) return f.e;
+  try {
+    return FormulaValue.text(formatNumber(n.value, f.s));
+  } catch {
+    return FormulaValue.errorValue;
+  }
+}
+function formatNumber(value2, fmt) {
+  if (fmt === "0") return String(Math.round(value2));
+  if (fmt === "0.00") return value2.toFixed(2);
+  if (fmt === "#,##0") return Math.round(value2).toLocaleString("en-US");
+  if (fmt === "#,##0.00") return value2.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+  if (fmt === "0%") return `${Math.round(value2 * 100)}%`;
+  if (fmt === "0.00%") return `${(value2 * 100).toFixed(2)}%`;
+  if (/[yYmMdD]/.test(fmt)) {
+    try {
+      const date = fromOADate(value2);
+      return date.toLocaleDateString();
+    } catch {
+    }
+  }
+  return String(value2);
+}
+function value(a, c) {
+  const s = str(a, c, 0);
+  if (!s.ok) return s.e;
+  const n = parseFloat(s.s.replace(/,/g, "").replace(/%$/, (m) => {
+    return m ? String(parseFloat(s.s) / 100) : "";
+  }));
+  if (isNaN(n)) return FormulaValue.errorValue;
+  return FormulaValue.number(n);
+}
+function find(a, c) {
+  const needle = str(a, c, 0);
+  if (!needle.ok) return needle.e;
+  const haystack = str(a, c, 1);
+  if (!haystack.ok) return haystack.e;
+  let start = 0;
+  if (a.length > 2) {
+    const r = num(a, c, 2);
+    if (!r.ok) return r.e;
+    start = Math.round(r.n) - 1;
+  }
+  const idx = haystack.s.indexOf(needle.s, start);
+  return idx < 0 ? FormulaValue.errorValue : FormulaValue.number(idx + 1);
+}
+function search(a, c) {
+  const needle = str(a, c, 0);
+  if (!needle.ok) return needle.e;
+  const haystack = str(a, c, 1);
+  if (!haystack.ok) return haystack.e;
+  let start = 0;
+  if (a.length > 2) {
+    const r = num(a, c, 2);
+    if (!r.ok) return r.e;
+    start = Math.round(r.n) - 1;
+  }
+  const idx = haystack.s.toLowerCase().indexOf(needle.s.toLowerCase(), start);
+  return idx < 0 ? FormulaValue.errorValue : FormulaValue.number(idx + 1);
+}
+function rept(a, c) {
+  const s = str(a, c, 0);
+  if (!s.ok) return s.e;
+  const n = num(a, c, 1);
+  if (!n.ok) return n.e;
+  const count2 = Math.round(n.n);
+  if (count2 < 0) return FormulaValue.errorValue;
+  return FormulaValue.text(s.s.repeat(count2));
+}
+function exact(a, c) {
+  const s1 = str(a, c, 0);
+  if (!s1.ok) return s1.e;
+  const s2 = str(a, c, 1);
+  if (!s2.ok) return s2.e;
+  return FormulaValue.boolean(s1.s === s2.s);
+}
+function char_(a, c) {
+  const r = num(a, c, 0);
+  if (!r.ok) return r.e;
+  const code2 = Math.round(r.n);
+  if (code2 < 1 || code2 > 255) return FormulaValue.errorValue;
+  return FormulaValue.text(String.fromCharCode(code2));
+}
+function code(a, c) {
+  const s = str(a, c, 0);
+  if (!s.ok) return s.e;
+  if (s.s.length === 0) return FormulaValue.errorValue;
+  return FormulaValue.number(s.s.charCodeAt(0));
+}
+function t_(a, c) {
+  const v = a[0].evaluate(c);
+  return v.isText ? v : FormulaValue.emptyString;
+}
+
+// src/functions/logical-functions.ts
+function registerLogical(r) {
+  r.register("IF", if_, 2, 3);
+  r.register("AND", and, 1);
+  r.register("OR", or, 1);
+  r.register("NOT", not, 1, 1);
+  r.register("XOR", xor, 1);
+  r.register("IFERROR", ifError, 2, 2);
+  r.register("IFNA", ifNa, 2, 2);
+  r.register("IFS", ifs, 2);
+  r.register("SWITCH", switch_, 3);
+  r.register("TRUE", trueFn, 0, 0);
+  r.register("FALSE", falseFn, 0, 0);
+}
+function if_(a, c) {
+  const cond = a[0].evaluate(c);
+  if (cond.isError) return cond;
+  const b = cond.coerceToBool();
+  if (b.isError) return b;
+  return b.booleanValue ? a[1].evaluate(c) : a.length > 2 ? a[2].evaluate(c) : FormulaValue.false_;
+}
+function and(a, c) {
+  let hasValue = false;
+  for (const arg of a) {
+    const v = arg.evaluate(c);
+    if (v.isError) return v;
+    if (v.isArray) {
+      for (const item of v.arrayVal.values()) {
+        if (item.isBlank) continue;
+        if (item.isError) return item;
+        hasValue = true;
+        const bv = item.coerceToBool();
+        if (bv.isError) return bv;
+        if (!bv.booleanValue) return FormulaValue.false_;
+      }
+    } else {
+      if (v.isBlank) {
+        hasValue = true;
+        continue;
+      }
+      hasValue = true;
+      const bv = v.coerceToBool();
+      if (bv.isError) return bv;
+      if (!bv.booleanValue) return FormulaValue.false_;
+    }
+  }
+  return hasValue ? FormulaValue.true_ : FormulaValue.errorValue;
+}
+function or(a, c) {
+  let hasValue = false;
+  for (const arg of a) {
+    const v = arg.evaluate(c);
+    if (v.isError) return v;
+    if (v.isArray) {
+      for (const item of v.arrayVal.values()) {
+        if (item.isBlank) continue;
+        if (item.isError) return item;
+        hasValue = true;
+        const bv = item.coerceToBool();
+        if (bv.isError) return bv;
+        if (bv.booleanValue) return FormulaValue.true_;
+      }
+    } else {
+      if (v.isBlank) {
+        hasValue = true;
+        continue;
+      }
+      hasValue = true;
+      const bv = v.coerceToBool();
+      if (bv.isError) return bv;
+      if (bv.booleanValue) return FormulaValue.true_;
+    }
+  }
+  return hasValue ? FormulaValue.false_ : FormulaValue.errorValue;
+}
+function not(a, c) {
+  const v = a[0].evaluate(c);
+  if (v.isError) return v;
+  const bv = v.coerceToBool();
+  if (bv.isError) return bv;
+  return FormulaValue.boolean(!bv.booleanValue);
+}
+function xor(a, c) {
+  let trueCount = 0;
+  for (const arg of a) {
+    const v = arg.evaluate(c);
+    if (v.isError) return v;
+    const bv = v.coerceToBool();
+    if (bv.isError) return bv;
+    if (bv.booleanValue) trueCount++;
+  }
+  return FormulaValue.boolean(trueCount % 2 === 1);
+}
+function ifError(a, c) {
+  const v = a[0].evaluate(c);
+  return v.isError ? a[1].evaluate(c) : v;
+}
+function ifNa(a, c) {
+  const v = a[0].evaluate(c);
+  return v.isError && v.errorCode === 7 /* NA */ ? a[1].evaluate(c) : v;
+}
+function ifs(a, c) {
+  for (let i = 0; i + 1 < a.length; i += 2) {
+    const cond = a[i].evaluate(c);
+    if (cond.isError) return cond;
+    const bv = cond.coerceToBool();
+    if (bv.isError) return bv;
+    if (bv.booleanValue) return a[i + 1].evaluate(c);
+  }
+  return FormulaValue.errorNA;
+}
+function switch_(a, c) {
+  const expr = a[0].evaluate(c);
+  if (expr.isError) return expr;
+  for (let i = 1; i + 1 < a.length; i += 2) {
+    const cv = a[i].evaluate(c);
+    if (cv.isError) return cv;
+    if (FormulaValue.areEqual(expr, cv)) return a[i + 1].evaluate(c);
+  }
+  return a.length % 2 === 0 ? a[a.length - 1].evaluate(c) : FormulaValue.errorNA;
+}
+function trueFn() {
+  return FormulaValue.true_;
+}
+function falseFn() {
+  return FormulaValue.false_;
+}
+
+// src/functions/date-functions.ts
+var OA_EPOCH_MS = Date.UTC(1899, 11, 30, 0, 0, 0, 0);
+var MS_PER_DAY = 864e5;
+function toOA(date) {
+  return (Date.UTC(
+    date.getFullYear(),
+    date.getMonth(),
+    date.getDate(),
+    date.getHours(),
+    date.getMinutes(),
+    date.getSeconds()
+  ) - OA_EPOCH_MS) / MS_PER_DAY;
+}
+function fromOA(oa) {
+  const ms = OA_EPOCH_MS + oa * MS_PER_DAY;
+  const d = new Date(ms);
+  return new Date(
+    d.getUTCFullYear(),
+    d.getUTCMonth(),
+    d.getUTCDate(),
+    d.getUTCHours(),
+    d.getUTCMinutes(),
+    d.getUTCSeconds()
+  );
+}
+function registerDate(r) {
+  r.register("NOW", now, 0, 0, true);
+  r.register("TODAY", today, 0, 0, true);
+  r.register("DATE", date_, 3, 3);
+  r.register("YEAR", year, 1, 1);
+  r.register("MONTH", month, 1, 1);
+  r.register("DAY", day, 1, 1);
+  r.register("HOUR", hour, 1, 1);
+  r.register("MINUTE", minute, 1, 1);
+  r.register("SECOND", second, 1, 1);
+  r.register("DATEVALUE", dateValue, 1, 1);
+  r.register("DAYS", days, 2, 2);
+  r.register("EDATE", edate, 2, 2);
+  r.register("EOMONTH", eomonth, 2, 2);
+  r.register("WEEKDAY", weekday, 1, 2);
+  r.register("WEEKNUM", weeknum, 1, 2);
+  r.register("NETWORKDAYS", networkdays, 2, 3);
+  r.register("DATEDIF", datedif, 3, 3);
+}
+function evalDate(a, c, idx) {
+  const r = FormulaHelper.evalDouble(a[idx], c);
+  if (!r.ok) return r;
+  try {
+    return { ok: true, date: fromOA(r.value) };
+  } catch {
+    return { ok: false, error: FormulaValue.errorValue };
+  }
+}
+function now() {
+  return FormulaValue.number(toOA(/* @__PURE__ */ new Date()));
+}
+function today() {
+  const d = /* @__PURE__ */ new Date();
+  return FormulaValue.number(toOA(new Date(d.getFullYear(), d.getMonth(), d.getDate())));
+}
+function date_(a, c) {
+  const y = FormulaHelper.evalDouble(a[0], c);
+  if (!y.ok) return y.error;
+  const m = FormulaHelper.evalDouble(a[1], c);
+  if (!m.ok) return m.error;
+  const d = FormulaHelper.evalDouble(a[2], c);
+  if (!d.ok) return d.error;
+  try {
+    return FormulaValue.number(toOA(new Date(Math.round(y.value), Math.round(m.value) - 1, Math.round(d.value))));
+  } catch {
+    return FormulaValue.errorValue;
+  }
+}
+function year(a, c) {
+  const r = evalDate(a, c, 0);
+  return r.ok ? FormulaValue.number(r.date.getFullYear()) : r.error;
+}
+function month(a, c) {
+  const r = evalDate(a, c, 0);
+  return r.ok ? FormulaValue.number(r.date.getMonth() + 1) : r.error;
+}
+function day(a, c) {
+  const r = evalDate(a, c, 0);
+  return r.ok ? FormulaValue.number(r.date.getDate()) : r.error;
+}
+function hour(a, c) {
+  const r = evalDate(a, c, 0);
+  return r.ok ? FormulaValue.number(r.date.getHours()) : r.error;
+}
+function minute(a, c) {
+  const r = evalDate(a, c, 0);
+  return r.ok ? FormulaValue.number(r.date.getMinutes()) : r.error;
+}
+function second(a, c) {
+  const r = evalDate(a, c, 0);
+  return r.ok ? FormulaValue.number(r.date.getSeconds()) : r.error;
+}
+function dateValue(a, c) {
+  const r = FormulaHelper.evalString(a[0], c);
+  if (!r.ok) return r.error;
+  const d = new Date(r.value);
+  if (isNaN(d.getTime())) return FormulaValue.errorValue;
+  return FormulaValue.number(toOA(d));
+}
+function days(a, c) {
+  const d1 = evalDate(a, c, 0);
+  if (!d1.ok) return d1.error;
+  const d2 = evalDate(a, c, 1);
+  if (!d2.ok) return d2.error;
+  return FormulaValue.number(Math.round((d1.date.getTime() - d2.date.getTime()) / MS_PER_DAY));
+}
+function edate(a, c) {
+  const d = evalDate(a, c, 0);
+  if (!d.ok) return d.error;
+  const m = FormulaHelper.evalDouble(a[1], c);
+  if (!m.ok) return m.error;
+  const result = new Date(d.date.getFullYear(), d.date.getMonth() + Math.round(m.value), d.date.getDate());
+  return isNaN(result.getTime()) ? FormulaValue.errorNum : FormulaValue.number(toOA(result));
+}
+function eomonth(a, c) {
+  const d = evalDate(a, c, 0);
+  if (!d.ok) return d.error;
+  const m = FormulaHelper.evalDouble(a[1], c);
+  if (!m.ok) return m.error;
+  const target = new Date(d.date.getFullYear(), d.date.getMonth() + Math.round(m.value) + 1, 0);
+  return isNaN(target.getTime()) ? FormulaValue.errorNum : FormulaValue.number(toOA(target));
+}
+function weekday(a, c) {
+  const d = evalDate(a, c, 0);
+  if (!d.ok) return d.error;
+  let type = 1;
+  if (a.length > 1) {
+    const r = FormulaHelper.evalDouble(a[1], c);
+    if (!r.ok) return r.error;
+    type = Math.round(r.value);
+  }
+  const dow = d.date.getDay();
+  switch (type) {
+    case 1:
+      return FormulaValue.number(dow === 0 ? 1 : dow + 1);
+    // Sun=1
+    case 2:
+      return FormulaValue.number(dow === 0 ? 7 : dow);
+    // Mon=1
+    case 3:
+      return FormulaValue.number(dow === 0 ? 6 : dow - 1);
+    // Mon=0
+    default:
+      return FormulaValue.errorNum;
+  }
+}
+function weeknum(a, c) {
+  const d = evalDate(a, c, 0);
+  if (!d.ok) return d.error;
+  const jan1 = new Date(d.date.getFullYear(), 0, 1);
+  const days_ = Math.floor((d.date.getTime() - jan1.getTime()) / MS_PER_DAY);
+  return FormulaValue.number(Math.ceil((days_ + jan1.getDay() + 1) / 7));
+}
+function networkdays(a, c) {
+  const start = evalDate(a, c, 0);
+  if (!start.ok) return start.error;
+  const end = evalDate(a, c, 1);
+  if (!end.ok) return end.error;
+  const holidays = /* @__PURE__ */ new Set();
+  if (a.length > 2) {
+    const hv = a[2].evaluate(c);
+    if (hv.isError) return hv;
+    const items = hv.isArray ? [...hv.arrayVal.values()] : [hv];
+    for (const item of items) {
+      if (item.isBlank) continue;
+      const r = item.tryAsDouble();
+      if (!r.ok) return FormulaValue.errorValue;
+      holidays.add(Math.floor(r.value));
+    }
+  }
+  const dir = start.date <= end.date ? 1 : -1;
+  let count2 = 0;
+  const cur = new Date(start.date);
+  while (dir > 0 ? cur <= end.date : cur >= end.date) {
+    const dow = cur.getDay();
+    const oa = Math.floor(toOA(cur));
+    if (dow !== 0 && dow !== 6 && !holidays.has(oa)) count2++;
+    cur.setDate(cur.getDate() + dir);
+  }
+  return FormulaValue.number(count2 * dir);
+}
+function datedif(a, c) {
+  const start = evalDate(a, c, 0);
+  if (!start.ok) return start.error;
+  const end = evalDate(a, c, 1);
+  if (!end.ok) return end.error;
+  const unit = FormulaHelper.evalString(a[2], c);
+  if (!unit.ok) return unit.error;
+  const s = start.date, e = end.date;
+  if (s > e) return FormulaValue.errorNum;
+  switch (unit.value.toUpperCase()) {
+    case "Y":
+      return FormulaValue.number(e.getFullYear() - s.getFullYear() - (e.getMonth() < s.getMonth() || e.getMonth() === s.getMonth() && e.getDate() < s.getDate() ? 1 : 0));
+    case "M":
+      return FormulaValue.number((e.getFullYear() - s.getFullYear()) * 12 + e.getMonth() - s.getMonth() - (e.getDate() < s.getDate() ? 1 : 0));
+    case "D":
+      return FormulaValue.number(Math.round((e.getTime() - s.getTime()) / MS_PER_DAY));
+    case "MD":
+      return FormulaValue.number(e.getDate() >= s.getDate() ? e.getDate() - s.getDate() : new Date(s.getFullYear(), s.getMonth() + 1, 0).getDate() - s.getDate() + e.getDate());
+    case "YM":
+      return FormulaValue.number((e.getMonth() - s.getMonth() + 12) % 12 - (e.getDate() < s.getDate() ? 1 : 0));
+    case "YD": {
+      const sameYearEnd = new Date(e.getFullYear(), s.getMonth(), s.getDate());
+      return FormulaValue.number(Math.round((e.getTime() - sameYearEnd.getTime()) / MS_PER_DAY));
+    }
+    default:
+      return FormulaValue.errorNum;
+  }
+}
+function registerLookup(r) {
+  r.register("VLOOKUP", vlookup, 3, 4);
+  r.register("HLOOKUP", hlookup, 3, 4);
+  r.register("INDEX", index_, 2, 3);
+  r.register("MATCH", match, 2, 3);
+  r.register("CHOOSE", choose, 2);
+  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);
+}
+function num2(a, c, i) {
+  const r = FormulaHelper.evalDouble(a[i], c);
+  return r.ok ? { ok: true, n: r.value } : { ok: false, e: r.error };
+}
+function vlookup(a, c) {
+  const lookupVal = a[0].evaluate(c);
+  if (lookupVal.isError) return lookupVal;
+  const tableVal = a[1].evaluate(c);
+  if (tableVal.isError) return tableVal;
+  if (!tableVal.isArray) return FormulaValue.errorRef;
+  const ci = num2(a, c, 2);
+  if (!ci.ok) return ci.e;
+  const colIdx = Math.round(ci.n) - 1;
+  let exactMatch = true;
+  if (a.length > 3) {
+    const mv = a[3].evaluate(c);
+    if (mv.isError) return mv;
+    exactMatch = !mv.coerceToBool().booleanValue;
+  }
+  const tbl = tableVal.arrayVal;
+  if (colIdx < 0 || colIdx >= tbl.columns) return FormulaValue.errorRef;
+  if (exactMatch) {
+    for (let r = 0; r < tbl.rows; r++) {
+      if (FormulaValue.areEqual(tbl.get(r, 0), lookupVal)) return tbl.get(r, colIdx);
+    }
+    return FormulaValue.errorNA;
+  }
+  let best = -1;
+  for (let r = 0; r < tbl.rows; r++) {
+    if (FormulaValue.compare(tbl.get(r, 0), lookupVal) <= 0) best = r;
+    else break;
+  }
+  return best >= 0 ? tbl.get(best, colIdx) : FormulaValue.errorNA;
+}
+function hlookup(a, c) {
+  const lookupVal = a[0].evaluate(c);
+  if (lookupVal.isError) return lookupVal;
+  const tableVal = a[1].evaluate(c);
+  if (tableVal.isError) return tableVal;
+  if (!tableVal.isArray) return FormulaValue.errorRef;
+  const ri = num2(a, c, 2);
+  if (!ri.ok) return ri.e;
+  const rowIdx = Math.round(ri.n) - 1;
+  let exactMatch = true;
+  if (a.length > 3) {
+    const mv = a[3].evaluate(c);
+    if (mv.isError) return mv;
+    exactMatch = !mv.coerceToBool().booleanValue;
+  }
+  const tbl = tableVal.arrayVal;
+  if (rowIdx < 0 || rowIdx >= tbl.rows) return FormulaValue.errorRef;
+  if (exactMatch) {
+    for (let col = 0; col < tbl.columns; col++) {
+      if (FormulaValue.areEqual(tbl.get(0, col), lookupVal)) return tbl.get(rowIdx, col);
+    }
+    return FormulaValue.errorNA;
+  }
+  let best = -1;
+  for (let col = 0; col < tbl.columns; col++) {
+    if (FormulaValue.compare(tbl.get(0, col), lookupVal) <= 0) best = col;
+    else break;
+  }
+  return best >= 0 ? tbl.get(rowIdx, best) : FormulaValue.errorNA;
+}
+function index_(a, c) {
+  const arrVal = a[0].evaluate(c);
+  if (arrVal.isError) return arrVal;
+  const rv = num2(a, c, 1);
+  if (!rv.ok) return rv.e;
+  const rowIdx = Math.round(rv.n) - 1;
+  let colIdx = 0;
+  if (a.length > 2) {
+    const cv = num2(a, c, 2);
+    if (!cv.ok) return cv.e;
+    colIdx = Math.round(cv.n) - 1;
+  }
+  if (!arrVal.isArray) return rowIdx === 0 && colIdx === 0 ? arrVal : FormulaValue.errorRef;
+  const arr = arrVal.arrayVal;
+  if (rowIdx < 0 || rowIdx >= arr.rows || colIdx < 0 || colIdx >= arr.columns) {
+    return FormulaValue.errorRef;
+  }
+  return arr.get(rowIdx, colIdx);
+}
+function match(a, c) {
+  const lookupVal = a[0].evaluate(c);
+  if (lookupVal.isError) return lookupVal;
+  const arrVal = a[1].evaluate(c);
+  if (arrVal.isError) return arrVal;
+  let matchType = 1;
+  if (a.length > 2) {
+    const r = num2(a, c, 2);
+    if (!r.ok) return r.e;
+    matchType = Math.round(r.n);
+  }
+  if (!arrVal.isArray) {
+    return FormulaValue.areEqual(arrVal, lookupVal) ? FormulaValue.one : FormulaValue.errorNA;
+  }
+  const arr = arrVal.arrayVal;
+  const len2 = arr.length;
+  if (matchType === 0) {
+    for (let i = 0; i < len2; i++) {
+      if (FormulaValue.areEqual(arr.getFlat(i), lookupVal)) return FormulaValue.number(i + 1);
+    }
+    return FormulaValue.errorNA;
+  }
+  if (matchType === 1) {
+    let best2 = -1;
+    for (let i = 0; i < len2; i++) {
+      if (FormulaValue.compare(arr.getFlat(i), lookupVal) <= 0) best2 = i;
+      else break;
+    }
+    return best2 >= 0 ? FormulaValue.number(best2 + 1) : FormulaValue.errorNA;
+  }
+  let best = -1;
+  for (let i = 0; i < len2; i++) {
+    if (FormulaValue.compare(arr.getFlat(i), lookupVal) >= 0) best = i;
+    else break;
+  }
+  return best >= 0 ? FormulaValue.number(best + 1) : FormulaValue.errorNA;
+}
+function choose(a, c) {
+  const iv = num2(a, c, 0);
+  if (!iv.ok) return iv.e;
+  const idx = Math.round(iv.n);
+  if (idx < 1 || idx >= a.length) return FormulaValue.errorValue;
+  return a[idx].evaluate(c);
+}
+function row(a, c) {
+  if (a.length === 0) return FormulaValue.number(c.formulaRow || 1);
+  const node = a[0];
+  if (node instanceof CellReferenceNode) {
+    return FormulaValue.number(parseCellRef(node.reference).row);
+  }
+  if (node instanceof RangeReferenceNode) {
+    return FormulaValue.number(parseCellRef(node.startRef).row);
+  }
+  return FormulaValue.errorValue;
+}
+function column(a, c) {
+  if (a.length === 0) return FormulaValue.number(c.formulaCol || 1);
+  const node = a[0];
+  if (node instanceof CellReferenceNode) {
+    return FormulaValue.number(parseCellRef(node.reference).column);
+  }
+  if (node instanceof RangeReferenceNode) {
+    return FormulaValue.number(parseCellRef(node.startRef).column);
+  }
+  return FormulaValue.errorValue;
+}
+function rows(a, c) {
+  if (a[0] instanceof RangeReferenceNode) {
+    const b = c.getRangeBounds(a[0].startRef, a[0].endRef);
+    return FormulaValue.number(b.endRow - b.startRow + 1);
+  }
+  const v = a[0].evaluate(c);
+  return v.isArray ? FormulaValue.number(v.arrayVal.rows) : FormulaValue.one;
+}
+function columns(a, c) {
+  if (a[0] instanceof RangeReferenceNode) {
+    const b = c.getRangeBounds(a[0].startRef, a[0].endRef);
+    return FormulaValue.number(b.endCol - b.startCol + 1);
+  }
+  const v = a[0].evaluate(c);
+  return v.isArray ? FormulaValue.number(v.arrayVal.columns) : FormulaValue.one;
+}
+function offset(a, c) {
+  const baseNode = a[0];
+  let baseRef;
+  if (baseNode instanceof CellReferenceNode) baseRef = baseNode.reference;
+  else if (baseNode instanceof RangeReferenceNode) baseRef = baseNode.startRef;
+  else return FormulaValue.errorValue;
+  const base = parseCellRef(baseRef);
+  const ro = FormulaHelper.evalDouble(a[1], c);
+  if (!ro.ok) return ro.error;
+  const co = FormulaHelper.evalDouble(a[2], c);
+  if (!co.ok) return co.error;
+  const newRow = base.row + Math.round(ro.value);
+  const newCol = base.column + Math.round(co.value);
+  if (newRow < 1 || newCol < 1) return FormulaValue.errorRef;
+  let height = 1, width = 1;
+  if (a.length > 3) {
+    const h = FormulaHelper.evalDouble(a[3], c);
+    if (!h.ok) return h.error;
+    height = Math.round(h.value);
+  }
+  if (a.length > 4) {
+    const w = FormulaHelper.evalDouble(a[4], c);
+    if (!w.ok) return w.error;
+    width = Math.round(w.value);
+  }
+  if (height === 1 && width === 1) return c.getCellValue(cellRefFromRowCol(newRow, newCol));
+  return c.getRangeValues(
+    cellRefFromRowCol(newRow, newCol),
+    cellRefFromRowCol(newRow + height - 1, newCol + width - 1)
+  );
+}
+
+// src/functions/statistical-functions.ts
+function registerStatistical(r) {
+  r.register("MEDIAN", median, 1);
+  r.register("MODE", mode, 1);
+  r.register("MODE.SNGL", mode, 1);
+  r.register("STDEV", stdev, 1);
+  r.register("STDEV.S", stdev, 1);
+  r.register("STDEVP", stdevp, 1);
+  r.register("STDEV.P", stdevp, 1);
+  r.register("VAR", var_, 1);
+  r.register("VAR.S", var_, 1);
+  r.register("VARP", varp, 1);
+  r.register("VAR.P", varp, 1);
+  r.register("LARGE", large, 2, 2);
+  r.register("SMALL", small, 2, 2);
+  r.register("RANK", rank, 2, 3);
+  r.register("RANK.EQ", rank, 2, 3);
+  r.register("PERCENTILE", percentile, 2, 2);
+  r.register("PERCENTILE.INC", percentile, 2, 2);
+  r.register("MAXIFS", maxIfs, 3);
+  r.register("MINIFS", minIfs, 3);
+}
+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);
+}
+function numsFromArray(v) {
+  if (v.isArray) {
+    return [...v.arrayVal.values()].filter((i) => i.isNumber).map((i) => i.numberValue);
+  }
+  return v.isNumber ? [v.numberValue] : [];
+}
+function num3(a, c, i) {
+  const r = FormulaHelper.evalDouble(a[i], c);
+  return r.ok ? { ok: true, n: r.value } : { ok: false, e: r.error };
+}
+function median(a, c) {
+  const r = FormulaHelper.collectNumbers(a, c);
+  if (!r.ok) return r.error;
+  if (r.values.length === 0) return FormulaValue.errorNum;
+  const sorted = [...r.values].sort((a2, b) => a2 - b);
+  const mid2 = sorted.length >> 1;
+  return FormulaValue.number(
+    sorted.length % 2 === 0 ? (sorted[mid2 - 1] + sorted[mid2]) / 2 : sorted[mid2]
+  );
+}
+function mode(a, c) {
+  const r = FormulaHelper.collectNumbers(a, c);
+  if (!r.ok) return r.error;
+  if (r.values.length === 0) return FormulaValue.errorNA;
+  const freq = /* @__PURE__ */ new Map();
+  let maxCnt = 0;
+  for (const n of r.values) {
+    const cnt = (freq.get(n) ?? 0) + 1;
+    freq.set(n, cnt);
+    if (cnt > maxCnt) maxCnt = cnt;
+  }
+  if (maxCnt === 1) return FormulaValue.errorNA;
+  for (const n of r.values) {
+    if ((freq.get(n) ?? 0) === maxCnt) return FormulaValue.number(n);
+  }
+  return FormulaValue.errorNA;
+}
+function stdev(a, c) {
+  const r = FormulaHelper.collectNumbers(a, c);
+  if (!r.ok) return r.error;
+  if (r.values.length < 2) return FormulaValue.errorDiv0;
+  return FormulaValue.number(Math.sqrt(variance(r.values, false)));
+}
+function stdevp(a, c) {
+  const r = FormulaHelper.collectNumbers(a, c);
+  if (!r.ok) return r.error;
+  if (r.values.length === 0) return FormulaValue.errorDiv0;
+  return FormulaValue.number(Math.sqrt(variance(r.values, true)));
+}
+function var_(a, c) {
+  const r = FormulaHelper.collectNumbers(a, c);
+  if (!r.ok) return r.error;
+  if (r.values.length < 2) return FormulaValue.errorDiv0;
+  return FormulaValue.number(variance(r.values, false));
+}
+function varp(a, c) {
+  const r = FormulaHelper.collectNumbers(a, c);
+  if (!r.ok) return r.error;
+  if (r.values.length === 0) return FormulaValue.errorDiv0;
+  return FormulaValue.number(variance(r.values, true));
+}
+function large(a, c) {
+  const arrV = a[0].evaluate(c);
+  if (arrV.isError) return arrV;
+  const kv = num3(a, c, 1);
+  if (!kv.ok) return kv.e;
+  const nums = numsFromArray(arrV).sort((a2, b) => b - a2);
+  const k = Math.round(kv.n);
+  if (k < 1 || k > nums.length) return FormulaValue.errorNum;
+  return FormulaValue.number(nums[k - 1]);
+}
+function small(a, c) {
+  const arrV = a[0].evaluate(c);
+  if (arrV.isError) return arrV;
+  const kv = num3(a, c, 1);
+  if (!kv.ok) return kv.e;
+  const nums = numsFromArray(arrV).sort((a2, b) => a2 - b);
+  const k = Math.round(kv.n);
+  if (k < 1 || k > nums.length) return FormulaValue.errorNum;
+  return FormulaValue.number(nums[k - 1]);
+}
+function rank(a, c) {
+  const nv = FormulaHelper.evalDouble(a[0], c);
+  if (!nv.ok) return nv.error;
+  const arrV = a[1].evaluate(c);
+  if (arrV.isError) return arrV;
+  let order = 0;
+  if (a.length > 2) {
+    const ov = num3(a, c, 2);
+    if (!ov.ok) return ov.e;
+    order = Math.round(ov.n);
+  }
+  const nums = numsFromArray(arrV).sort((a2, b) => order === 0 ? b - a2 : a2 - b);
+  const idx = nums.indexOf(nv.value);
+  return idx < 0 ? FormulaValue.errorNA : FormulaValue.number(idx + 1);
+}
+function percentile(a, c) {
+  const arrV = a[0].evaluate(c);
+  if (arrV.isError) return arrV;
+  const kv = FormulaHelper.evalDouble(a[1], c);
+  if (!kv.ok) return kv.error;
+  if (kv.value < 0 || kv.value > 1) return FormulaValue.errorNum;
+  const nums = numsFromArray(arrV).sort((a2, b) => a2 - b);
+  if (nums.length === 0) return FormulaValue.errorNum;
+  const n = (nums.length - 1) * kv.value;
+  const lo = Math.floor(n), hi = Math.ceil(n);
+  if (lo === hi) return FormulaValue.number(nums[lo]);
+  return FormulaValue.number(nums[lo] + (nums[hi] - nums[lo]) * (n - lo));
+}
+function maxIfs(a, c) {
+  return ifsAggregate(a, c, "max");
+}
+function minIfs(a, c) {
+  return ifsAggregate(a, c, "min");
+}
+function ifsAggregate(a, c, mode2) {
+  if (a.length < 3 || (a.length - 1) % 2 !== 0) return FormulaValue.errorValue;
+  const mainRange = a[0].evaluate(c);
+  if (mainRange.isError) return mainRange;
+  if (!mainRange.isArray) return FormulaValue.errorValue;
+  const arr = mainRange.arrayVal;
+  const len2 = arr.length;
+  const mask = new Uint8Array(len2).fill(1);
+  for (let p = 1; p + 1 < a.length; p += 2) {
+    const cr = a[p].evaluate(c);
+    if (cr.isError) return cr;
+    const criteria = a[p + 1].evaluate(c).asText();
+    const crArr = cr.isArray ? cr.arrayVal : null;
+    for (let i = 0; i < len2; i++) {
+      if (!mask[i]) continue;
+      const cv = crArr ? crArr.getFlat(i) : cr;
+      if (!FormulaHelper.matchesCriteria(cv, criteria)) mask[i] = 0;
+    }
+  }
+  let result = mode2 === "max" ? -Infinity : Infinity;
+  let found = false;
+  for (let i = 0; i < len2; i++) {
+    if (!mask[i]) continue;
+    const r = arr.getFlat(i).tryAsDouble();
+    if (!r.ok) continue;
+    if (mode2 === "max" ? r.value > result : r.value < result) {
+      result = r.value;
+      found = true;
+    }
+  }
+  return found ? FormulaValue.number(result) : FormulaValue.zero;
+}
+
+// src/functions/info-functions.ts
+function registerInfo(r) {
+  r.register("ISBLANK", isBlank, 1, 1);
+  r.register("ISNUMBER", isNumber, 1, 1);
+  r.register("ISTEXT", isText, 1, 1);
+  r.register("ISERROR", isError, 1, 1);
+  r.register("ISERR", isErr, 1, 1);
+  r.register("ISLOGICAL", isLogical, 1, 1);
+  r.register("ISNA", isNa, 1, 1);
+  r.register("ISNONTEXT", isNonText, 1, 1);
+  r.register("NA", na, 0, 0);
+  r.register("TYPE", type_, 1, 1);
+  r.register("N", n_, 1, 1);
+  r.register("ISODD", isOdd, 1, 1);
+  r.register("ISEVEN", isEven, 1, 1);
+  r.register("ERROR.TYPE", errorType, 1, 1);
+}
+function isBlank(a, c) {
+  return FormulaValue.boolean(a[0].evaluate(c).isBlank);
+}
+function isNumber(a, c) {
+  return FormulaValue.boolean(a[0].evaluate(c).isNumber);
+}
+function isText(a, c) {
+  const v = a[0].evaluate(c);
+  return FormulaValue.boolean(v.isText && v.textValue.length > 0);
+}
+function isError(a, c) {
+  return FormulaValue.boolean(a[0].evaluate(c).isError);
+}
+function isErr(a, c) {
+  const v = a[0].evaluate(c);
+  return FormulaValue.boolean(v.isError && v.errorCode !== 7 /* NA */);
+}
+function isLogical(a, c) {
+  return FormulaValue.boolean(a[0].evaluate(c).isBoolean);
+}
+function isNa(a, c) {
+  const v = a[0].evaluate(c);
+  return FormulaValue.boolean(v.isError && v.errorCode === 7 /* NA */);
+}
+function isNonText(a, c) {
+  return FormulaValue.boolean(!a[0].evaluate(c).isText);
+}
+function na() {
+  return FormulaValue.errorNA;
+}
+function type_(a, c) {
+  const v = a[0].evaluate(c);
+  const t = v.isNumber || v.isBlank ? 1 : v.isText ? 2 : v.isBoolean ? 4 : v.isError ? 16 : v.isArray ? 64 : 1;
+  return FormulaValue.number(t);
+}
+function n_(a, c) {
+  const v = a[0].evaluate(c);
+  if (v.isNumber) return v;
+  if (v.isBoolean) return FormulaValue.number(v.booleanValue ? 1 : 0);
+  return FormulaValue.zero;
+}
+function isOdd(a, c) {
+  const r = FormulaHelper.evalDouble(a[0], c);
+  if (!r.ok) return r.error;
+  return FormulaValue.boolean(Math.abs(Math.trunc(r.value)) % 2 === 1);
+}
+function isEven(a, c) {
+  const r = FormulaHelper.evalDouble(a[0], c);
+  if (!r.ok) return r.error;
+  return FormulaValue.boolean(Math.trunc(r.value) % 2 === 0);
+}
+function errorType(a, c) {
+  const v = a[0].evaluate(c);
+  if (!v.isError) return FormulaValue.errorNA;
+  const map = {
+    [1 /* Null */]: 1,
+    [2 /* Div0 */]: 2,
+    [3 /* Value */]: 3,
+    [4 /* Ref */]: 4,
+    [5 /* Name */]: 5,
+    [6 /* Num */]: 6,
+    [7 /* NA */]: 7
+  };
+  return FormulaValue.number(map[v.errorCode] ?? 7);
+}
+
+// src/function-registry.ts
+var _default, _functions, _FunctionRegistry_instances, registerBuiltIns_fn;
+var _FunctionRegistry = class _FunctionRegistry {
+  constructor() {
+    __privateAdd(this, _FunctionRegistry_instances);
+    __privateAdd(this, _functions, /* @__PURE__ */ new Map());
+  }
+  /** Lazily-created default registry with all built-in functions registered. */
+  static get default() {
+    var _a;
+    if (!__privateGet(_FunctionRegistry, _default)) {
+      __privateSet(_FunctionRegistry, _default, new _FunctionRegistry());
+      __privateMethod(_a = __privateGet(_FunctionRegistry, _default), _FunctionRegistry_instances, registerBuiltIns_fn).call(_a);
+    }
+    return __privateGet(_FunctionRegistry, _default);
+  }
+  /** Registers a function. Name is normalised to UPPERCASE. */
+  register(name, handler, minArgs = 0, maxArgs = -1, isVolatile = false) {
+    __privateGet(this, _functions).set(name.toUpperCase(), {
+      name: name.toUpperCase(),
+      minArgs,
+      maxArgs,
+      isVolatile,
+      handler
+    });
+  }
+  /** Executes a function by name with argument validation. */
+  execute(name, args, ctx) {
+    const def = __privateGet(this, _functions).get(name.toUpperCase());
+    if (!def) return FormulaValue.errorName;
+    if (args.length < def.minArgs) return FormulaValue.errorValue;
+    if (def.maxArgs >= 0 && args.length > def.maxArgs) return FormulaValue.errorValue;
+    try {
+      return def.handler(args, ctx);
+    } catch {
+      return FormulaValue.errorValue;
+    }
+  }
+  /** Returns true if the named function is volatile (NOW, RAND, etc.). */
+  isVolatile(name) {
+    return __privateGet(this, _functions).get(name.toUpperCase())?.isVolatile ?? false;
+  }
+  /** Returns true if the function is registered. */
+  has(name) {
+    return __privateGet(this, _functions).has(name.toUpperCase());
+  }
+};
+_default = new WeakMap();
+_functions = new WeakMap();
+_FunctionRegistry_instances = new WeakSet();
+registerBuiltIns_fn = function() {
+  registerMath(this);
+  registerText(this);
+  registerLogical(this);
+  registerDate(this);
+  registerLookup(this);
+  registerStatistical(this);
+  registerInfo(this);
+};
+__privateAdd(_FunctionRegistry, _default);
+var FunctionRegistry = _FunctionRegistry;
+var FormulaHelper;
+((FormulaHelper2) => {
+  function evalDouble(node, ctx) {
+    const v = node.evaluate(ctx);
+    if (v.isError) return { ok: false, error: v };
+    const r = v.tryAsDouble();
+    if (!r.ok) return { ok: false, error: FormulaValue.errorValue };
+    return { ok: true, value: r.value };
+  }
+  FormulaHelper2.evalDouble = evalDouble;
+  function evalString(node, ctx) {
+    const v = node.evaluate(ctx);
+    if (v.isError) return { ok: false, error: v };
+    return { ok: true, value: v.asText() };
+  }
+  FormulaHelper2.evalString = evalString;
+  function collectNumbers(args, ctx) {
+    const nums = [];
+    for (const arg of args) {
+      const v = arg.evaluate(ctx);
+      if (v.isError) return { ok: false, error: v };
+      if (v.isArray) {
+        for (const item of v.arrayVal.values()) {
+          if (item.isBlank || item.isText) continue;
+          if (item.isError) return { ok: false, error: item };
+          const r = item.tryAsDouble();
+          if (r.ok) nums.push(r.value);
+        }
+      } else if (!v.isBlank && !v.isText) {
+        const r = v.tryAsDouble();
+        if (!r.ok) return { ok: false, error: FormulaValue.errorValue };
+        nums.push(r.value);
+      }
+    }
+    return { ok: true, values: nums };
+  }
+  FormulaHelper2.collectNumbers = collectNumbers;
+  function flattenArgs(args, ctx) {
+    const result = [];
+    for (const arg of args) {
+      const v = arg.evaluate(ctx);
+      if (v.isArray) {
+        for (const item of v.arrayVal.values()) result.push(item);
+      } else {
+        result.push(v);
+      }
+    }
+    return result;
+  }
+  FormulaHelper2.flattenArgs = flattenArgs;
+  function matchesCriteria(value2, criteria) {
+    criteria = criteria.trim();
+    const opMatch = /^(>=|<=|<>|>|<|=)(.*)$/.exec(criteria);
+    if (opMatch) {
+      const op = opMatch[1];
+      const rhs = opMatch[2];
+      const rhsVal = parseFloat(rhs);
+      const rhsNum = isNaN(rhsVal) ? null : rhsVal;
+      const cmp = rhsNum !== null ? FormulaValue.compare(value2, FormulaValue.number(rhsNum)) : FormulaValue.compare(value2, FormulaValue.text(rhs));
+      switch (op) {
+        case ">":
+          return cmp > 0;
+        case ">=":
+          return cmp >= 0;
+        case "<":
+          return cmp < 0;
+        case "<=":
+          return cmp <= 0;
+        case "<>":
+          return !FormulaValue.areEqual(value2, rhsNum !== null ? FormulaValue.number(rhsNum) : FormulaValue.text(rhs));
+        case "=":
+          return FormulaValue.areEqual(value2, rhsNum !== null ? FormulaValue.number(rhsNum) : FormulaValue.text(rhs));
+      }
+    }
+    if (criteria.includes("*") || criteria.includes("?")) {
+      const pattern = wildcardToRegex(criteria);
+      return pattern.test(value2.asText());
+    }
+    const num4 = parseFloat(criteria);
+    if (!isNaN(num4)) {
+      return FormulaValue.areEqual(value2, FormulaValue.number(num4));
+    }
+    return value2.asText().toUpperCase() === criteria.toUpperCase();
+  }
+  FormulaHelper2.matchesCriteria = matchesCriteria;
+  function wildcardToRegex(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`, "i");
+  }
+})(FormulaHelper || (FormulaHelper = {}));
+
+// src/formula-context.ts
+var _sheet, _functions2, _evaluating;
+var _FormulaContext = class _FormulaContext {
+  constructor(sheet, formulaRow = 0, formulaCol = 0, evaluating, registry) {
+    __privateAdd(this, _sheet);
+    __privateAdd(this, _functions2);
+    __privateAdd(this, _evaluating);
+    __privateSet(this, _sheet, sheet);
+    this.formulaRow = formulaRow;
+    this.formulaCol = formulaCol;
+    __privateSet(this, _evaluating, evaluating ?? /* @__PURE__ */ new Set());
+    __privateSet(this, _functions2, registry ?? FunctionRegistry.default);
+  }
+  get worksheet() {
+    return __privateGet(this, _sheet);
+  }
+  // ── Cell/Range resolution ─────────────────────────────────────────────────
+  getCellValue(cellReference) {
+    const norm = cellReference.replace(/\$/g, "").toUpperCase();
+    if (__privateGet(this, _evaluating).has(norm)) return FormulaValue.errorRef;
+    __privateGet(this, _evaluating).add(norm);
+    try {
+      const raw = __privateGet(this, _sheet).getCellValue(cellReference);
+      return FormulaValue.fromObjectSync(raw);
+    } finally {
+      __privateGet(this, _evaluating).delete(norm);
+    }
+  }
+  getRangeValues(startRef, endRef) {
+    const s = parseCellRef(startRef);
+    const e = parseCellRef(endRef);
+    const rows2 = e.row - s.row + 1;
+    const cols = e.column - s.column + 1;
+    const arr = new ArrayValue(rows2, cols);
+    for (let r = 0; r < rows2; r++) {
+      for (let c = 0; c < cols; c++) {
+        const ref = cellRefFromRowCol(s.row + r, s.column + c);
+        arr.set(r, c, this.getCellValue(ref));
+      }
+    }
+    return FormulaValue.array(arr);
+  }
+  getSheetCellValue(sheetName, cellReference) {
+    if (!this.workbook) return FormulaValue.errorRef;
+    try {
+      const sheet = this.workbook.getWorksheet(sheetName);
+      const ctx = new _FormulaContext(sheet, this.formulaRow, this.formulaCol, __privateGet(this, _evaluating), __privateGet(this, _functions2));
+      ctx.workbook = this.workbook;
+      return ctx.getCellValue(cellReference);
+    } catch {
+      return FormulaValue.errorRef;
+    }
+  }
+  getSheetRangeValues(sheetName, startRef, endRef) {
+    if (!this.workbook) return FormulaValue.errorRef;
+    try {
+      const sheet = this.workbook.getWorksheet(sheetName);
+      const ctx = new _FormulaContext(sheet, this.formulaRow, this.formulaCol, __privateGet(this, _evaluating), __privateGet(this, _functions2));
+      ctx.workbook = this.workbook;
+      return ctx.getRangeValues(startRef, endRef);
+    } catch {
+      return FormulaValue.errorRef;
+    }
+  }
+  resolveNamedRange(_name) {
+    return FormulaValue.errorName;
+  }
+  getRangeBounds(startRef, endRef) {
+    const s = parseCellRef(startRef);
+    const e = parseCellRef(endRef);
+    return { startRow: s.row, startCol: s.column, endRow: e.row, endCol: e.column };
+  }
+  // ── Function dispatch ─────────────────────────────────────────────────────
+  evaluateFunction(name, args) {
+    return __privateGet(this, _functions2).execute(name, args, this);
+  }
+};
+_sheet = new WeakMap();
+_functions2 = new WeakMap();
+_evaluating = new WeakMap();
+var FormulaContext = _FormulaContext;
+
+// src/lru-cache.ts
+var _map, _capacity, _hits, _misses, _evictions;
+var LruCache = class {
+  constructor(capacity) {
+    __privateAdd(this, _map);
+    __privateAdd(this, _capacity);
+    __privateAdd(this, _hits, 0);
+    __privateAdd(this, _misses, 0);
+    __privateAdd(this, _evictions, 0);
+    if (capacity <= 0) throw new RangeError("LruCache capacity must be > 0.");
+    __privateSet(this, _capacity, capacity);
+    __privateSet(this, _map, /* @__PURE__ */ new Map());
+  }
+  get capacity() {
+    return __privateGet(this, _capacity);
+  }
+  get size() {
+    return __privateGet(this, _map).size;
+  }
+  get hits() {
+    return __privateGet(this, _hits);
+  }
+  get misses() {
+    return __privateGet(this, _misses);
+  }
+  get evictions() {
+    return __privateGet(this, _evictions);
+  }
+  get hitRate() {
+    const total = __privateGet(this, _hits) + __privateGet(this, _misses);
+    return total === 0 ? 0 : __privateGet(this, _hits) / total;
+  }
+  /**
+   * Returns the value for key, or undefined if not present.
+   * Moves the accessed key to the "most recently used" end.
+   */
+  get(key) {
+    const value2 = __privateGet(this, _map).get(key);
+    if (value2 === void 0) {
+      __privateWrapper(this, _misses)._++;
+      return void 0;
+    }
+    __privateGet(this, _map).delete(key);
+    __privateGet(this, _map).set(key, value2);
+    __privateWrapper(this, _hits)._++;
+    return value2;
+  }
+  /**
+   * Inserts or updates a key-value pair.
+   * Evicts the least-recently-used entry if over capacity.
+   */
+  set(key, value2) {
+    if (__privateGet(this, _map).has(key)) {
+      __privateGet(this, _map).delete(key);
+    } else if (__privateGet(this, _map).size >= __privateGet(this, _capacity)) {
+      const oldest = __privateGet(this, _map).keys().next().value;
+      __privateGet(this, _map).delete(oldest);
+      __privateWrapper(this, _evictions)._++;
+    }
+    __privateGet(this, _map).set(key, value2);
+  }
+  /** Removes a key from the cache. Returns true if it existed. */
+  delete(key) {
+    return __privateGet(this, _map).delete(key);
+  }
+  /** Returns true if the key is present (does NOT update LRU order). */
+  has(key) {
+    return __privateGet(this, _map).has(key);
+  }
+  /** Removes all entries and resets statistics. */
+  clear() {
+    __privateGet(this, _map).clear();
+    __privateSet(this, _hits, __privateSet(this, _misses, __privateSet(this, _evictions, 0)));
+  }
+  /** Resizes the cache, evicting oldest entries if necessary. */
+  resize(newCapacity) {
+    if (newCapacity <= 0) throw new RangeError("Capacity must be > 0.");
+    __privateSet(this, _capacity, newCapacity);
+    while (__privateGet(this, _map).size > newCapacity) {
+      const oldest = __privateGet(this, _map).keys().next().value;
+      __privateGet(this, _map).delete(oldest);
+      __privateWrapper(this, _evictions)._++;
+    }
+  }
+};
+_map = new WeakMap();
+_capacity = new WeakMap();
+_hits = new WeakMap();
+_misses = new WeakMap();
+_evictions = new WeakMap();
+
+// src/formula-evaluator.ts
+var DEFAULT_CACHE_CAPACITY = 1e4;
+var astCache = new LruCache(DEFAULT_CACHE_CAPACITY);
+function parseFormula(formula) {
+  const stripped = formula.startsWith("=") ? formula.slice(1) : formula;
+  const cached = astCache.get(stripped);
+  if (cached !== void 0) return cached;
+  const lexer = new FormulaLexer(stripped);
+  const tokens = lexer.tokenize();
+  const ast = new FormulaParser(tokens).parse();
+  astCache.set(stripped, ast);
+  return ast;
+}
+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;
+    return ast.evaluate(ctx);
+  } catch {
+    return FormulaValue.errorValue;
+  }
+}
+function clearAstCache() {
+  astCache.clear();
+}
+function getAstCacheStats() {
+  return {
+    size: astCache.size,
+    hits: astCache.hits,
+    misses: astCache.misses,
+    hitRate: astCache.hitRate
+  };
+}
+function setAstCacheCapacity(capacity) {
+  astCache.resize(capacity);
+}
+
+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 };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map