@revisium/formula 0.8.0 → 0.10.0

package/dist/chunk-4FIOGFOL.cjs

@@ -1,1512 +0,0 @@
-'use strict';
-
-var ohm = require('ohm-js');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var ohm__namespace = /*#__PURE__*/_interopNamespace(ohm);
-
-// src/ohm/grammar/index.ts
-var grammarText = String.raw`Formula {
-  Expression = Ternary
-
-  // Ternary: condition ? then : else
-  Ternary
-    = LogicalOr "?" Ternary ":" Ternary  -- ternary
-    | LogicalOr
-
-  // Logical OR: a || b
-  LogicalOr
-    = LogicalOr "||" LogicalAnd  -- or
-    | LogicalAnd
-
-  // Logical AND: a && b
-  LogicalAnd
-    = LogicalAnd "&&" Equality  -- and
-    | Equality
-
-  // Equality: a == b, a != b
-  Equality
-    = Equality "==" Comparison  -- eq
-    | Equality "!=" Comparison  -- neq
-    | Comparison
-
-  // Comparison: a > b, a < b, a >= b, a <= b
-  Comparison
-    = Comparison ">=" Additive  -- gte
-    | Comparison "<=" Additive  -- lte
-    | Comparison ">" Additive   -- gt
-    | Comparison "<" Additive   -- lt
-    | Additive
-
-  // Additive: a + b, a - b
-  Additive
-    = Additive "+" Multiplicative  -- plus
-    | Additive "-" Multiplicative  -- minus
-    | Multiplicative
-
-  // Multiplicative: a * b, a / b, a % b
-  Multiplicative
-    = Multiplicative "*" Unary  -- times
-    | Multiplicative "/" Unary  -- div
-    | Multiplicative "%" Unary  -- mod
-    | Unary
-
-  // Unary: -a, !a
-  Unary
-    = "-" Unary  -- neg
-    | "!" Unary  -- not
-    | Postfix
-
-  // Postfix: function calls, property access, array access
-  Postfix
-    = Postfix "(" Arguments? ")"      -- call
-    | Postfix "." identifier          -- property
-    | Postfix "[" Expression "]"      -- index
-    | Postfix "[" "*" "]"             -- wildcard
-    | Primary
-
-  // Arguments for function calls
-  Arguments
-    = Expression ("," Expression)*
-
-  // Primary expressions
-  Primary
-    = "(" Expression ")"              -- paren
-    | "[" string "]"                  -- bracketedField
-    | number
-    | string
-    | boolean
-    | null
-    | rootPath
-    | relativePath
-    | contextToken
-    | identifier
-
-  // Literals
-  number
-    = "-"? digit+ "." digit+  -- float
-    | "-"? digit+             -- int
-
-  string
-    = "\"" doubleStringChar* "\""
-    | "'" singleStringChar* "'"
-
-  doubleStringChar
-    = ~("\"" | "\\") any  -- regular
-    | "\\" any            -- escape
-
-  singleStringChar
-    = ~("'" | "\\") any   -- regular
-    | "\\" any            -- escape
-
-  boolean
-    = "true" ~identifierPart   -- true
-    | "false" ~identifierPart  -- false
-
-  null = "null" ~identifierPart
-
-  // Identifiers and paths
-  identifier = ~reserved identifierStart identifierPart*
-
-  identifierStart = letter | "_"
-  identifierPart = letter | digit | "_"
-
-  // Special paths
-  rootPath = "/" identifierPart+
-
-  relativePathPrefix = ".." "/"
-  relativePath = relativePathPrefix+ identifierPart+
-
-  contextToken
-    = "@" identifierPart+   -- at
-    | "#" identifierPart+   -- hash
-
-  // Reserved words (cannot be used as identifiers)
-  reserved
-    = ("true" | "false" | "null") ~identifierPart
-
-  // Whitespace (implicit, Ohm handles automatically)
-}`;
-var grammar2 = ohm__namespace.grammar(grammarText);
-
-// src/ohm/semantics/index.ts
-function isSafePropertyName(name) {
-  return name !== "__proto__";
-}
-function childrenToAST(children) {
-  return children.filter((c) => "toAST" in c).map((c) => c.toAST());
-}
-function childrenDependencies(children) {
-  return children.filter((c) => "dependencies" in c).flatMap((c) => c.dependencies());
-}
-function childrenFeatures(children) {
-  return children.filter((c) => "features" in c).flatMap((c) => c.features());
-}
-var semantics = grammar2.createSemantics();
-semantics.addOperation("toAST", {
-  Expression(e) {
-    return e.toAST();
-  },
-  Ternary_ternary(cond, _q, cons, _c, alt) {
-    return {
-      type: "TernaryOp",
-      condition: cond.toAST(),
-      consequent: cons.toAST(),
-      alternate: alt.toAST()
-    };
-  },
-  Ternary(e) {
-    return e.toAST();
-  },
-  LogicalOr_or(left, _op, right) {
-    return {
-      type: "BinaryOp",
-      op: "||",
-      left: left.toAST(),
-      right: right.toAST()
-    };
-  },
-  LogicalOr(e) {
-    return e.toAST();
-  },
-  LogicalAnd_and(left, _op, right) {
-    return {
-      type: "BinaryOp",
-      op: "&&",
-      left: left.toAST(),
-      right: right.toAST()
-    };
-  },
-  LogicalAnd(e) {
-    return e.toAST();
-  },
-  Equality_eq(left, _op, right) {
-    return {
-      type: "BinaryOp",
-      op: "==",
-      left: left.toAST(),
-      right: right.toAST()
-    };
-  },
-  Equality_neq(left, _op, right) {
-    return {
-      type: "BinaryOp",
-      op: "!=",
-      left: left.toAST(),
-      right: right.toAST()
-    };
-  },
-  Equality(e) {
-    return e.toAST();
-  },
-  Comparison_gte(left, _op, right) {
-    return {
-      type: "BinaryOp",
-      op: ">=",
-      left: left.toAST(),
-      right: right.toAST()
-    };
-  },
-  Comparison_lte(left, _op, right) {
-    return {
-      type: "BinaryOp",
-      op: "<=",
-      left: left.toAST(),
-      right: right.toAST()
-    };
-  },
-  Comparison_gt(left, _op, right) {
-    return {
-      type: "BinaryOp",
-      op: ">",
-      left: left.toAST(),
-      right: right.toAST()
-    };
-  },
-  Comparison_lt(left, _op, right) {
-    return {
-      type: "BinaryOp",
-      op: "<",
-      left: left.toAST(),
-      right: right.toAST()
-    };
-  },
-  Comparison(e) {
-    return e.toAST();
-  },
-  Additive_plus(left, _op, right) {
-    return {
-      type: "BinaryOp",
-      op: "+",
-      left: left.toAST(),
-      right: right.toAST()
-    };
-  },
-  Additive_minus(left, _op, right) {
-    return {
-      type: "BinaryOp",
-      op: "-",
-      left: left.toAST(),
-      right: right.toAST()
-    };
-  },
-  Additive(e) {
-    return e.toAST();
-  },
-  Multiplicative_times(left, _op, right) {
-    return {
-      type: "BinaryOp",
-      op: "*",
-      left: left.toAST(),
-      right: right.toAST()
-    };
-  },
-  Multiplicative_div(left, _op, right) {
-    return {
-      type: "BinaryOp",
-      op: "/",
-      left: left.toAST(),
-      right: right.toAST()
-    };
-  },
-  Multiplicative_mod(left, _op, right) {
-    return {
-      type: "BinaryOp",
-      op: "%",
-      left: left.toAST(),
-      right: right.toAST()
-    };
-  },
-  Multiplicative(e) {
-    return e.toAST();
-  },
-  Unary_neg(_op, expr) {
-    return { type: "UnaryOp", op: "-", argument: expr.toAST() };
-  },
-  Unary_not(_op, expr) {
-    return { type: "UnaryOp", op: "!", argument: expr.toAST() };
-  },
-  Unary(e) {
-    return e.toAST();
-  },
-  Postfix_call(callee, _lp, args, _rp) {
-    const firstArg = args.children[0];
-    const argList = firstArg ? firstArg.toAST() : [];
-    return {
-      type: "CallExpression",
-      callee: callee.toAST(),
-      arguments: Array.isArray(argList) ? argList : [argList]
-    };
-  },
-  Postfix_property(obj, _dot, prop) {
-    return {
-      type: "MemberExpression",
-      object: obj.toAST(),
-      property: prop.sourceString
-    };
-  },
-  Postfix_index(obj, _lb, index, _rb) {
-    const indexAST = index.toAST();
-    if (indexAST.type === "StringLiteral") {
-      return {
-        type: "BracketedMemberExpression",
-        object: obj.toAST(),
-        property: indexAST.value
-      };
-    }
-    return {
-      type: "IndexExpression",
-      object: obj.toAST(),
-      index: indexAST
-    };
-  },
-  Postfix_wildcard(obj, _lb, _star, _rb) {
-    return {
-      type: "WildcardExpression",
-      object: obj.toAST()
-    };
-  },
-  Postfix(e) {
-    return e.toAST();
-  },
-  // Returns an array of arguments, not a single ASTNode
-  // @ts-expect-error - intentionally returns array for function arguments
-  Arguments(first, _comma, rest) {
-    return [first.toAST(), ...rest.children.map((c) => c.toAST())];
-  },
-  Primary_paren(_lp, expr, _rp) {
-    return expr.toAST();
-  },
-  Primary_bracketedField(_lb, str, _rb) {
-    const strAST = str.toAST();
-    return { type: "BracketedIdentifier", name: strAST.value };
-  },
-  Primary(e) {
-    return e.toAST();
-  },
-  number_float(_neg, _int, _dot, _frac) {
-    return {
-      type: "NumberLiteral",
-      value: Number.parseFloat(this.sourceString)
-    };
-  },
-  number_int(_neg, _digits) {
-    return {
-      type: "NumberLiteral",
-      value: Number.parseInt(this.sourceString, 10)
-    };
-  },
-  string(_open, chars, _close) {
-    const raw = chars.sourceString;
-    return { type: "StringLiteral", value: raw.replaceAll(/\\(.)/g, "$1") };
-  },
-  boolean_true(_) {
-    return { type: "BooleanLiteral", value: true };
-  },
-  boolean_false(_) {
-    return { type: "BooleanLiteral", value: false };
-  },
-  null(_) {
-    return { type: "NullLiteral" };
-  },
-  identifier(_start, _rest) {
-    return { type: "Identifier", name: this.sourceString };
-  },
-  rootPath(_slash, _path) {
-    return { type: "RootPath", path: this.sourceString };
-  },
-  relativePath(_dotSlashes, _parts) {
-    return { type: "RelativePath", path: this.sourceString };
-  },
-  contextToken_at(_at, _name) {
-    return { type: "ContextToken", name: this.sourceString };
-  },
-  contextToken_hash(_hash, _name) {
-    return { type: "ContextToken", name: this.sourceString };
-  },
-  // @ts-expect-error - _iter returns array for iteration nodes
-  _iter(...children) {
-    return childrenToAST(children);
-  },
-  _terminal() {
-    return { type: "Identifier", name: this.sourceString };
-  }
-});
-semantics.addOperation("dependencies", {
-  identifier(_start, _rest) {
-    return [this.sourceString];
-  },
-  Primary_bracketedField(_lb, _str, _rb) {
-    return [this.sourceString];
-  },
-  rootPath(_slash, _path) {
-    return [this.sourceString];
-  },
-  relativePath(_dotSlashes, _parts) {
-    return [this.sourceString];
-  },
-  contextToken_at(_at, _name) {
-    return [];
-  },
-  contextToken_hash(_hash, _name) {
-    return [];
-  },
-  Postfix_property(obj, _dot, prop) {
-    const objDeps = obj.dependencies();
-    if (objDeps.length === 1) {
-      return [`${objDeps[0]}.${prop.sourceString}`];
-    }
-    return objDeps;
-  },
-  Postfix_index(obj, _lb, index, _rb) {
-    const objDeps = obj.dependencies();
-    const indexNode = index.toAST();
-    if (indexNode.type === "StringLiteral") {
-      const strValue = indexNode.value;
-      const quote = this.sourceString.includes('"') ? '"' : "'";
-      if (objDeps.length === 1) {
-        return [`${objDeps[0]}[${quote}${strValue}${quote}]`];
-      }
-      return objDeps;
-    }
-    const getNumericIndex2 = (node) => {
-      if (node.type === "NumberLiteral") {
-        return node.value;
-      }
-      if (node.type === "UnaryOp" && node.op === "-" && node.argument.type === "NumberLiteral") {
-        return -node.argument.value;
-      }
-      return null;
-    };
-    const numericIndex = getNumericIndex2(indexNode);
-    if (objDeps.length === 1 && numericIndex !== null) {
-      return [`${objDeps[0]}[${numericIndex}]`];
-    }
-    return [...objDeps, ...index.dependencies()];
-  },
-  Postfix_wildcard(obj, _lb, _star, _rb) {
-    const objDeps = obj.dependencies();
-    if (objDeps.length === 1) {
-      return [`${objDeps[0]}[*]`];
-    }
-    return objDeps;
-  },
-  Postfix_call(callee, _lp, args, _rp) {
-    const calleeDeps = callee.dependencies();
-    const calleeAST = callee.toAST();
-    const argDeps = childrenDependencies(args.children);
-    if (calleeAST.type === "Identifier") {
-      return argDeps;
-    }
-    return [...calleeDeps, ...argDeps];
-  },
-  number_float(_neg, _int, _dot, _frac) {
-    return [];
-  },
-  number_int(_neg, _digits) {
-    return [];
-  },
-  string(_open, _chars, _close) {
-    return [];
-  },
-  boolean_true(_) {
-    return [];
-  },
-  boolean_false(_) {
-    return [];
-  },
-  null(_) {
-    return [];
-  },
-  _nonterminal(...children) {
-    return childrenDependencies(children);
-  },
-  _iter(...children) {
-    return childrenDependencies(children);
-  },
-  _terminal() {
-    return [];
-  }
-});
-var ARRAY_FUNCTIONS = /* @__PURE__ */ new Set([
-  "sum",
-  "avg",
-  "count",
-  "first",
-  "last",
-  "join",
-  "includes"
-]);
-semantics.addOperation("features", {
-  Primary_bracketedField(_lb, _str, _rb) {
-    return ["bracket_notation"];
-  },
-  rootPath(_slash, _path) {
-    const path = this.sourceString;
-    const features = ["root_path"];
-    if (path.includes(".")) {
-      features.push("nested_path");
-    }
-    return features;
-  },
-  relativePath(_dotSlashes, _parts) {
-    const path = this.sourceString;
-    const features = ["relative_path"];
-    const withoutPrefix = path.replace(/^(\.\.\/)+/, "");
-    if (withoutPrefix.includes(".")) {
-      features.push("nested_path");
-    }
-    return features;
-  },
-  contextToken_at(_at, _name) {
-    return ["context_token"];
-  },
-  contextToken_hash(_hash, _name) {
-    return ["context_token"];
-  },
-  Postfix_property(obj, _dot, _prop) {
-    const objFeatures = obj.features();
-    return [...objFeatures, "nested_path"];
-  },
-  Postfix_index(obj, _lb, index, _rb) {
-    const objFeatures = obj.features();
-    const indexFeatures = index.features();
-    const indexNode = index.toAST();
-    if (indexNode.type === "StringLiteral") {
-      return [...objFeatures, ...indexFeatures, "bracket_notation"];
-    }
-    return [...objFeatures, ...indexFeatures, "array_index"];
-  },
-  Postfix_wildcard(obj, _lb, _star, _rb) {
-    const objFeatures = obj.features();
-    return [...objFeatures, "array_wildcard"];
-  },
-  Postfix_call(callee, _lp, args, _rp) {
-    const calleeAST = callee.toAST();
-    const argFeatures = childrenFeatures(args.children);
-    if (calleeAST.type === "Identifier" && ARRAY_FUNCTIONS.has(calleeAST.name.toLowerCase())) {
-      return [...argFeatures, "array_function"];
-    }
-    return argFeatures;
-  },
-  _nonterminal(...children) {
-    return childrenFeatures(children);
-  },
-  _iter(...children) {
-    return childrenFeatures(children);
-  },
-  _terminal() {
-    return [];
-  }
-});
-var BUILTINS = {
-  // Logical
-  and: (a, b) => Boolean(a) && Boolean(b),
-  or: (a, b) => Boolean(a) || Boolean(b),
-  not: (a) => !a,
-  // String
-  concat: (...args) => args.map(String).join(""),
-  upper: (s) => String(s).toUpperCase(),
-  lower: (s) => String(s).toLowerCase(),
-  trim: (s) => String(s).trim(),
-  left: (s, n) => String(s).slice(0, Math.max(0, Math.floor(Number(n)))),
-  right: (s, n) => {
-    const str = String(s);
-    const count = Math.max(0, Math.floor(Number(n)));
-    return count === 0 ? "" : str.slice(-count);
-  },
-  replace: (s, search, repl) => String(s).replace(String(search), String(repl)),
-  tostring: String,
-  length: (s) => {
-    if (Array.isArray(s)) return s.length;
-    if (typeof s === "string") return s.length;
-    if (s !== null && typeof s === "object") return Object.keys(s).length;
-    return String(s).length;
-  },
-  contains: (s, search) => String(s).includes(String(search)),
-  startswith: (s, search) => String(s).startsWith(String(search)),
-  endswith: (s, search) => String(s).endsWith(String(search)),
-  join: (arr, sep) => {
-    if (!Array.isArray(arr)) return "";
-    if (sep === void 0 || sep === null) return arr.join(",");
-    if (typeof sep !== "string" && typeof sep !== "number") {
-      return arr.join(",");
-    }
-    return arr.join(String(sep));
-  },
-  // Numeric
-  tonumber: Number,
-  toboolean: Boolean,
-  isnull: (v) => v === null || v === void 0,
-  coalesce: (...args) => args.find((v) => v !== null && v !== void 0) ?? null,
-  round: (n, dec) => {
-    const factor = 10 ** (dec === void 0 ? 0 : Number(dec));
-    return Math.round(Number(n) * factor) / factor;
-  },
-  floor: (n) => Math.floor(Number(n)),
-  ceil: (n) => Math.ceil(Number(n)),
-  abs: (n) => Math.abs(Number(n)),
-  sqrt: (n) => Math.sqrt(Number(n)),
-  pow: (base, exp) => Math.pow(Number(base), Number(exp)),
-  min: (...args) => args.length === 0 ? Number.NaN : Math.min(...args.map(Number)),
-  max: (...args) => args.length === 0 ? Number.NaN : Math.max(...args.map(Number)),
-  log: (n) => Math.log(Number(n)),
-  log10: (n) => Math.log10(Number(n)),
-  exp: (n) => Math.exp(Number(n)),
-  sign: (n) => Math.sign(Number(n)),
-  // Array
-  sum: (arr) => Array.isArray(arr) ? arr.reduce((a, b) => a + Number(b), 0) : 0,
-  avg: (arr) => Array.isArray(arr) && arr.length > 0 ? arr.reduce((a, b) => a + Number(b), 0) / arr.length : 0,
-  count: (arr) => Array.isArray(arr) ? arr.length : 0,
-  first: (arr) => Array.isArray(arr) ? arr[0] : void 0,
-  last: (arr) => Array.isArray(arr) ? arr.at(-1) : void 0,
-  includes: (arr, val) => Array.isArray(arr) ? arr.includes(val) : false,
-  // Conditional
-  if: (cond, ifTrue, ifFalse) => cond ? ifTrue : ifFalse
-};
-function getByPath(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current === null || current === void 0) return void 0;
-    current = current[part];
-  }
-  return current;
-}
-semantics.addOperation("eval(ctx)", {
-  Expression(e) {
-    return e.eval(this.args.ctx);
-  },
-  Ternary_ternary(cond, _q, cons, _c, alt) {
-    return cond.eval(this.args.ctx) ? cons.eval(this.args.ctx) : alt.eval(this.args.ctx);
-  },
-  Ternary(e) {
-    return e.eval(this.args.ctx);
-  },
-  LogicalOr_or(left, _op, right) {
-    return left.eval(this.args.ctx) || right.eval(this.args.ctx);
-  },
-  LogicalOr(e) {
-    return e.eval(this.args.ctx);
-  },
-  LogicalAnd_and(left, _op, right) {
-    return left.eval(this.args.ctx) && right.eval(this.args.ctx);
-  },
-  LogicalAnd(e) {
-    return e.eval(this.args.ctx);
-  },
-  Equality_eq(left, _op, right) {
-    return left.eval(this.args.ctx) == right.eval(this.args.ctx);
-  },
-  Equality_neq(left, _op, right) {
-    return left.eval(this.args.ctx) != right.eval(this.args.ctx);
-  },
-  Equality(e) {
-    return e.eval(this.args.ctx);
-  },
-  Comparison_gte(left, _op, right) {
-    return left.eval(this.args.ctx) >= right.eval(this.args.ctx);
-  },
-  Comparison_lte(left, _op, right) {
-    return left.eval(this.args.ctx) <= right.eval(this.args.ctx);
-  },
-  Comparison_gt(left, _op, right) {
-    return left.eval(this.args.ctx) > right.eval(this.args.ctx);
-  },
-  Comparison_lt(left, _op, right) {
-    return left.eval(this.args.ctx) < right.eval(this.args.ctx);
-  },
-  Comparison(e) {
-    return e.eval(this.args.ctx);
-  },
-  Additive_plus(left, _op, right) {
-    const l = left.eval(this.args.ctx);
-    const r = right.eval(this.args.ctx);
-    if (typeof l === "string" || typeof r === "string") {
-      return String(l) + String(r);
-    }
-    return l + r;
-  },
-  Additive_minus(left, _op, right) {
-    return left.eval(this.args.ctx) - right.eval(this.args.ctx);
-  },
-  Additive(e) {
-    return e.eval(this.args.ctx);
-  },
-  Multiplicative_times(left, _op, right) {
-    return left.eval(this.args.ctx) * right.eval(this.args.ctx);
-  },
-  Multiplicative_div(left, _op, right) {
-    return left.eval(this.args.ctx) / right.eval(this.args.ctx);
-  },
-  Multiplicative_mod(left, _op, right) {
-    return left.eval(this.args.ctx) % right.eval(this.args.ctx);
-  },
-  Multiplicative(e) {
-    return e.eval(this.args.ctx);
-  },
-  Unary_neg(_op, expr) {
-    return -expr.eval(this.args.ctx);
-  },
-  Unary_not(_op, expr) {
-    return !expr.eval(this.args.ctx);
-  },
-  Unary(e) {
-    return e.eval(this.args.ctx);
-  },
-  Postfix_call(callee, _lp, args, _rp) {
-    const calleeAST = callee.toAST();
-    const getArgValues = () => {
-      const argsNode = args.children[0];
-      if (!argsNode) {
-        return [];
-      }
-      return argsNode.eval(this.args.ctx);
-    };
-    if (calleeAST.type === "Identifier") {
-      const fnName = calleeAST.name.toLowerCase();
-      const builtinFn = BUILTINS[fnName];
-      if (builtinFn) {
-        return builtinFn(...getArgValues());
-      }
-    }
-    const fn = callee.eval(this.args.ctx);
-    if (typeof fn === "function") {
-      return fn(...getArgValues());
-    }
-    const calleeName = calleeAST.type === "Identifier" ? calleeAST.name : "expression";
-    throw new Error(`'${calleeName}' is not a function`);
-  },
-  Postfix_property(obj, _dot, prop) {
-    const objVal = obj.eval(this.args.ctx);
-    return objVal?.[prop.sourceString];
-  },
-  Postfix_index(obj, _lb, index, _rb) {
-    const objVal = obj.eval(this.args.ctx);
-    const idx = index.eval(this.args.ctx);
-    if (typeof idx === "string") {
-      if (!isSafePropertyName(idx)) {
-        return void 0;
-      }
-      return objVal?.[idx];
-    }
-    const numIdx = idx;
-    if (numIdx < 0) {
-      return objVal?.[objVal.length + numIdx];
-    }
-    return objVal?.[numIdx];
-  },
-  Postfix_wildcard(obj, _lb, _star, _rb) {
-    return obj.eval(this.args.ctx);
-  },
-  Postfix(e) {
-    return e.eval(this.args.ctx);
-  },
-  Arguments(first, _comma, rest) {
-    return [
-      first.eval(this.args.ctx),
-      ...rest.children.map((c) => c.eval(this.args.ctx))
-    ];
-  },
-  Primary_paren(_lp, expr, _rp) {
-    return expr.eval(this.args.ctx);
-  },
-  Primary_bracketedField(_lb, str, _rb) {
-    const fieldName = str.eval(this.args.ctx);
-    if (!isSafePropertyName(fieldName)) {
-      return void 0;
-    }
-    return this.args.ctx[fieldName];
-  },
-  Primary(e) {
-    return e.eval(this.args.ctx);
-  },
-  number_float(_neg, _int, _dot, _frac) {
-    return Number.parseFloat(this.sourceString);
-  },
-  number_int(_neg, _digits) {
-    return Number.parseInt(this.sourceString, 10);
-  },
-  string(_open, chars, _close) {
-    return chars.sourceString.replaceAll(/\\(.)/g, "$1");
-  },
-  boolean_true(_) {
-    return true;
-  },
-  boolean_false(_) {
-    return false;
-  },
-  null(_) {
-    return null;
-  },
-  identifier(_start, _rest) {
-    const name = this.sourceString;
-    return this.args.ctx[name];
-  },
-  rootPath(_slash, _path) {
-    const fullPath = this.sourceString;
-    if (fullPath in this.args.ctx) {
-      return this.args.ctx[fullPath];
-    }
-    const parts = fullPath.slice(1).split(".");
-    const firstPart = parts[0];
-    if (!firstPart) return void 0;
-    const rootKey = "/" + firstPart;
-    let value = this.args.ctx[rootKey];
-    for (let i = 1; i < parts.length; i++) {
-      if (value === null || value === void 0) return void 0;
-      const part = parts[i];
-      if (!part) continue;
-      value = value[part];
-    }
-    return value;
-  },
-  relativePath(_dotSlashes, _parts) {
-    const fullPath = this.sourceString;
-    if (fullPath in this.args.ctx) {
-      return this.args.ctx[fullPath];
-    }
-    const path = fullPath.replace(/^(\.\.\/)+/, "");
-    return getByPath(this.args.ctx, path);
-  },
-  contextToken_at(_at, _name) {
-    return this.args.ctx[this.sourceString];
-  },
-  contextToken_hash(_hash, _name) {
-    return this.args.ctx[this.sourceString];
-  },
-  _nonterminal(...children) {
-    const ctx = this.args.ctx;
-    for (const child of children) {
-      if ("eval" in child) {
-        return child.eval(ctx);
-      }
-    }
-    return void 0;
-  },
-  _iter(...children) {
-    return children.map((c) => c.eval(this.args.ctx));
-  },
-  _terminal() {
-    return void 0;
-  }
-});
-
-// src/ohm/core/parser.ts
-function parseFormula(expression) {
-  const trimmed = expression.trim();
-  if (!trimmed) {
-    throw new Error("Empty expression");
-  }
-  const matchResult = grammar2.match(trimmed);
-  if (matchResult.failed()) {
-    throw new Error(matchResult.message ?? "Parse error");
-  }
-  const adapter = semantics(matchResult);
-  const ast = adapter.toAST();
-  const dependencies = [...new Set(adapter.dependencies())];
-  const allFeatures = adapter.features();
-  const features = [...new Set(allFeatures)];
-  const minVersion = features.length > 0 ? "1.1" : "1.0";
-  return { ast, dependencies, features, minVersion };
-}
-function validateSyntax(expression) {
-  const trimmed = expression.trim();
-  if (!trimmed) {
-    return { isValid: false, error: "Empty expression" };
-  }
-  const matchResult = grammar2.match(trimmed);
-  if (matchResult.failed()) {
-    const pos = matchResult.getRightmostFailurePosition?.();
-    return {
-      isValid: false,
-      error: matchResult.message ?? "Parse error",
-      position: pos
-    };
-  }
-  return { isValid: true };
-}
-function evaluate(expression, context) {
-  const trimmed = expression.trim();
-  if (!trimmed) {
-    throw new Error("Empty expression");
-  }
-  const matchResult = grammar2.match(trimmed);
-  if (matchResult.failed()) {
-    throw new Error(matchResult.message ?? "Parse error");
-  }
-  const safeContext = {};
-  for (const [key, value] of Object.entries(context)) {
-    if (typeof value !== "function") {
-      safeContext[key] = value;
-    }
-  }
-  return semantics(matchResult).eval(safeContext);
-}
-function parseCurrentPath(currentPath) {
-  const segments = [];
-  let current = "";
-  let inBracket = false;
-  for (const char of currentPath) {
-    if (char === "[") {
-      inBracket = true;
-      current += char;
-    } else if (char === "]") {
-      inBracket = false;
-      current += char;
-    } else if (char === "." && !inBracket) {
-      if (current) {
-        segments.push(current);
-        current = "";
-      }
-    } else {
-      current += char;
-    }
-  }
-  if (current) {
-    segments.push(current);
-  }
-  return segments;
-}
-function getValueByPath(data, path) {
-  const segments = parseCurrentPath(path);
-  let current = data;
-  for (const segment of segments) {
-    if (current === null || current === void 0) {
-      return void 0;
-    }
-    if (typeof current !== "object") {
-      return void 0;
-    }
-    const bracketMatch = /^([^[]+)\[(\d+)\]$/.exec(segment);
-    if (bracketMatch?.[1] && bracketMatch[2]) {
-      const fieldName = bracketMatch[1];
-      const index = Number.parseInt(bracketMatch[2], 10);
-      const arr = current[fieldName];
-      if (!Array.isArray(arr)) {
-        return void 0;
-      }
-      current = arr[index];
-    } else {
-      current = current[segment];
-    }
-  }
-  return current;
-}
-function extractRootField(fieldPath) {
-  const dotIndex = fieldPath.indexOf(".");
-  const bracketIndex = fieldPath.indexOf("[");
-  if (dotIndex === -1 && bracketIndex === -1) {
-    return fieldPath;
-  }
-  if (dotIndex === -1) {
-    return fieldPath.slice(0, bracketIndex);
-  }
-  if (bracketIndex === -1) {
-    return fieldPath.slice(0, dotIndex);
-  }
-  return fieldPath.slice(0, Math.min(dotIndex, bracketIndex));
-}
-function countParentLevels(path) {
-  let count = 0;
-  let remaining = path;
-  while (remaining.startsWith("../")) {
-    count++;
-    remaining = remaining.slice(3);
-  }
-  return count;
-}
-function getPathAfterParents(path) {
-  return path.replace(/^(\.\.\/)+/, "");
-}
-function resolveRelativePath(rootData, currentPath, relativePath) {
-  const parentLevels = countParentLevels(relativePath);
-  const fieldPath = getPathAfterParents(relativePath);
-  if (!currentPath) {
-    return getValueByPath(rootData, fieldPath);
-  }
-  const pathSegments = parseCurrentPath(currentPath);
-  const targetLevel = pathSegments.length - parentLevels;
-  if (targetLevel <= 0) {
-    return getValueByPath(rootData, fieldPath);
-  }
-  const basePath = pathSegments.slice(0, targetLevel).join(".");
-  const fullPath = basePath ? `${basePath}.${fieldPath}` : fieldPath;
-  return getValueByPath(rootData, fullPath);
-}
-function extractRelativeBase(relativePath) {
-  const pathAfterParents = getPathAfterParents(relativePath);
-  const baseField = extractRootField(pathAfterParents);
-  const prefix = relativePath.slice(
-    0,
-    relativePath.length - pathAfterParents.length
-  );
-  return prefix + baseField;
-}
-function buildPathReferences(rootData, dependencies, currentPath) {
-  const refs = {};
-  for (const dep of dependencies) {
-    if (dep.startsWith("/")) {
-      const fieldPath = dep.slice(1);
-      const rootField = extractRootField(fieldPath);
-      const contextKey = "/" + rootField;
-      if (!(contextKey in refs)) {
-        refs[contextKey] = getValueByPath(rootData, rootField);
-      }
-    } else if (dep.startsWith("../")) {
-      const contextKey = extractRelativeBase(dep);
-      if (!(contextKey in refs)) {
-        refs[contextKey] = resolveRelativePath(
-          rootData,
-          currentPath,
-          contextKey
-        );
-      }
-    }
-  }
-  return refs;
-}
-function evaluateWithContext(expression, options) {
-  const { rootData, itemData, currentPath } = options;
-  const trimmed = expression.trim();
-  if (!trimmed) {
-    throw new Error("Empty expression");
-  }
-  const parsed = parseFormula(trimmed);
-  const pathRefs = buildPathReferences(
-    rootData,
-    parsed.dependencies,
-    currentPath
-  );
-  const context = {
-    ...rootData,
-    ...itemData,
-    ...pathRefs
-  };
-  return evaluate(trimmed, context);
-}
-var ARITHMETIC_OPS = /* @__PURE__ */ new Set(["+", "-", "*", "/", "%"]);
-var COMPARISON_OPS = /* @__PURE__ */ new Set(["<", ">", "<=", ">=", "==", "!="]);
-var LOGICAL_OPS = /* @__PURE__ */ new Set(["&&", "||", "!"]);
-var NUMERIC_FUNCTIONS = /* @__PURE__ */ new Set([
-  "round",
-  "floor",
-  "ceil",
-  "abs",
-  "sqrt",
-  "pow",
-  "min",
-  "max",
-  "log",
-  "log10",
-  "exp",
-  "sign",
-  "sum",
-  "avg",
-  "count",
-  "tonumber",
-  "length"
-]);
-var STRING_FUNCTIONS = /* @__PURE__ */ new Set([
-  "concat",
-  "upper",
-  "lower",
-  "trim",
-  "left",
-  "right",
-  "replace",
-  "tostring",
-  "join"
-]);
-var BOOLEAN_FUNCTIONS = /* @__PURE__ */ new Set([
-  "and",
-  "or",
-  "not",
-  "contains",
-  "startswith",
-  "endswith",
-  "isnull",
-  "toboolean",
-  "includes"
-]);
-function getFieldType(path, fieldTypes) {
-  const rootField = path.split(".")[0]?.split("[")[0] || path;
-  const schemaType = fieldTypes[rootField];
-  if (schemaType === "number") return "number";
-  if (schemaType === "string") return "string";
-  if (schemaType === "boolean") return "boolean";
-  return "unknown";
-}
-function inferLiteralType(node) {
-  switch (node.type) {
-    case "NumberLiteral":
-      return "number";
-    case "BooleanLiteral":
-      return "boolean";
-    case "StringLiteral":
-      return "string";
-    case "NullLiteral":
-      return "unknown";
-    default:
-      return null;
-  }
-}
-function inferBinaryOpType(node, fieldTypes) {
-  const { op } = node;
-  if (op === "+") {
-    const leftType = inferTypeFromAST(node.left, fieldTypes);
-    const rightType = inferTypeFromAST(node.right, fieldTypes);
-    if (leftType === "string" || rightType === "string") return "string";
-    if (leftType === "unknown" || rightType === "unknown") return "unknown";
-    return "number";
-  }
-  if (ARITHMETIC_OPS.has(op)) return "number";
-  if (COMPARISON_OPS.has(op)) return "boolean";
-  if (LOGICAL_OPS.has(op)) return "boolean";
-  return "unknown";
-}
-function inferCallExpressionType(node, fieldTypes) {
-  const funcName = node.callee.type === "Identifier" ? node.callee.name.toLowerCase() : "";
-  if (NUMERIC_FUNCTIONS.has(funcName)) return "number";
-  if (STRING_FUNCTIONS.has(funcName)) return "string";
-  if (BOOLEAN_FUNCTIONS.has(funcName)) return "boolean";
-  if (funcName === "if" && node.arguments.length >= 3) {
-    const thenArg = node.arguments[1];
-    const elseArg = node.arguments[2];
-    if (thenArg && elseArg) {
-      const thenType = inferTypeFromAST(thenArg, fieldTypes);
-      const elseType = inferTypeFromAST(elseArg, fieldTypes);
-      if (thenType === elseType) return thenType;
-    }
-  }
-  return "unknown";
-}
-function inferTypeFromAST(node, fieldTypes) {
-  const literalType = inferLiteralType(node);
-  if (literalType !== null) return literalType;
-  switch (node.type) {
-    case "Identifier":
-      return getFieldType(node.name, fieldTypes);
-    case "RootPath":
-    case "RelativePath":
-    case "ContextToken":
-    case "IndexExpression":
-    case "WildcardExpression":
-      return "unknown";
-    case "MemberExpression": {
-      const objectType = inferTypeFromAST(node.object, fieldTypes);
-      if (objectType !== "unknown") return objectType;
-      if (node.object.type === "Identifier") {
-        return getFieldType(`${node.object.name}.${node.property}`, fieldTypes);
-      }
-      return "unknown";
-    }
-    case "BinaryOp":
-      return inferBinaryOpType(node, fieldTypes);
-    case "UnaryOp": {
-      if (node.op === "-") return "number";
-      if (node.op === "!") return "boolean";
-      return "unknown";
-    }
-    case "TernaryOp": {
-      const thenType = inferTypeFromAST(node.consequent, fieldTypes);
-      const elseType = inferTypeFromAST(node.alternate, fieldTypes);
-      return thenType === elseType ? thenType : "unknown";
-    }
-    case "CallExpression":
-      return inferCallExpressionType(node, fieldTypes);
-    default:
-      return "unknown";
-  }
-}
-function inferFormulaType(expression, fieldTypes = {}) {
-  const trimmed = expression.trim();
-  if (!trimmed) {
-    return "unknown";
-  }
-  try {
-    const { ast } = parseFormula(trimmed);
-    return inferTypeFromAST(ast, fieldTypes);
-  } catch {
-    return "unknown";
-  }
-}
-
-// src/ohm/core/serialize-ast.ts
-function escapeDoubleQuoted(value) {
-  let result = "";
-  for (const char of value) {
-    switch (char) {
-      case "\\":
-        result += String.raw`\\`;
-        break;
-      case '"':
-        result += String.raw`\"`;
-        break;
-      case "\n":
-        result += String.raw`\n`;
-        break;
-      case "\r":
-        result += String.raw`\r`;
-        break;
-      case "	":
-        result += String.raw`\t`;
-        break;
-      default:
-        result += char;
-    }
-  }
-  return result;
-}
-var PRECEDENCE = {
-  "||": 1,
-  "&&": 2,
-  "==": 3,
-  "!=": 3,
-  ">": 4,
-  "<": 4,
-  ">=": 4,
-  "<=": 4,
-  "+": 5,
-  "-": 5,
-  "*": 6,
-  "/": 6,
-  "%": 6
-};
-function serializeBinaryOp(node) {
-  const prec = PRECEDENCE[node.op] ?? 0;
-  const wrapLeft = (child) => {
-    const s = serializeNode(child);
-    if (child.type === "BinaryOp") {
-      const childPrec = PRECEDENCE[child.op] ?? 0;
-      if (childPrec < prec) {
-        return `(${s})`;
-      }
-    }
-    if (child.type === "TernaryOp") {
-      return `(${s})`;
-    }
-    return s;
-  };
-  const wrapRight = (child) => {
-    const s = serializeNode(child);
-    if (child.type === "BinaryOp") {
-      const childPrec = PRECEDENCE[child.op] ?? 0;
-      if (childPrec <= prec) {
-        return `(${s})`;
-      }
-    }
-    if (child.type === "TernaryOp") {
-      return `(${s})`;
-    }
-    return s;
-  };
-  return `${wrapLeft(node.left)} ${node.op} ${wrapRight(node.right)}`;
-}
-function serializeNode(node) {
-  switch (node.type) {
-    case "NumberLiteral":
-      return String(node.value);
-    case "StringLiteral":
-      return `"${escapeDoubleQuoted(node.value)}"`;
-    case "BooleanLiteral":
-      return String(node.value);
-    case "NullLiteral":
-      return "null";
-    case "Identifier":
-      return node.name;
-    case "BracketedIdentifier":
-      return `["${escapeDoubleQuoted(node.name)}"]`;
-    case "RootPath":
-      return node.path;
-    case "RelativePath":
-      return node.path;
-    case "ContextToken":
-      return node.name;
-    case "BinaryOp":
-      return serializeBinaryOp(node);
-    case "UnaryOp":
-      return `${node.op}${serializeUnaryArgument(node)}`;
-    case "TernaryOp":
-      return `${serializeTernaryCondition(node.condition)} ? ${serializeNode(node.consequent)} : ${serializeNode(node.alternate)}`;
-    case "CallExpression":
-      return `${serializeNode(node.callee)}(${node.arguments.map(serializeNode).join(", ")})`;
-    case "MemberExpression":
-      return `${serializePostfixObject(node.object)}.${node.property}`;
-    case "BracketedMemberExpression":
-      return `${serializePostfixObject(node.object)}["${escapeDoubleQuoted(node.property)}"]`;
-    case "IndexExpression":
-      return `${serializePostfixObject(node.object)}[${serializeNode(node.index)}]`;
-    case "WildcardExpression":
-      return `${serializePostfixObject(node.object)}[*]`;
-  }
-}
-function serializeUnaryArgument(node) {
-  const s = serializeNode(node.argument);
-  if (node.argument.type === "BinaryOp" || node.argument.type === "TernaryOp") {
-    return `(${s})`;
-  }
-  return s;
-}
-function serializeTernaryCondition(node) {
-  const s = serializeNode(node);
-  if (node.type === "TernaryOp") {
-    return `(${s})`;
-  }
-  return s;
-}
-function serializePostfixObject(node) {
-  const s = serializeNode(node);
-  if (node.type === "BinaryOp" || node.type === "TernaryOp" || node.type === "UnaryOp") {
-    return `(${s})`;
-  }
-  return s;
-}
-function serializeAst(ast) {
-  return serializeNode(ast);
-}
-
-// src/ohm/core/replace-dependencies.ts
-function collectDependencyPath(node) {
-  switch (node.type) {
-    case "Identifier":
-      return node.name;
-    case "BracketedIdentifier":
-      return `["${node.name}"]`;
-    case "RootPath":
-      return node.path;
-    case "RelativePath":
-      return node.path;
-    case "MemberExpression": {
-      const objPath = collectDependencyPath(node.object);
-      if (objPath === null) {
-        return null;
-      }
-      return `${objPath}.${node.property}`;
-    }
-    case "BracketedMemberExpression": {
-      const objPath = collectDependencyPath(node.object);
-      if (objPath === null) {
-        return null;
-      }
-      const quote = '"';
-      return `${objPath}[${quote}${node.property}${quote}]`;
-    }
-    case "IndexExpression": {
-      const objPath = collectDependencyPath(node.object);
-      if (objPath === null) {
-        return null;
-      }
-      const numericIndex = getNumericIndex(node.index);
-      if (numericIndex !== null) {
-        return `${objPath}[${numericIndex}]`;
-      }
-      return null;
-    }
-    case "WildcardExpression": {
-      const objPath = collectDependencyPath(node.object);
-      if (objPath === null) {
-        return null;
-      }
-      return `${objPath}[*]`;
-    }
-    default:
-      return null;
-  }
-}
-function getNumericIndex(node) {
-  if (node.type === "NumberLiteral") {
-    return node.value;
-  }
-  if (node.type === "UnaryOp" && node.op === "-" && node.argument.type === "NumberLiteral") {
-    return -node.argument.value;
-  }
-  return null;
-}
-function findMatch(node, replacements) {
-  const fullPath = collectDependencyPath(node);
-  if (fullPath !== null) {
-    const value = replacements[fullPath];
-    if (value !== void 0) {
-      return value;
-    }
-  }
-  return null;
-}
-function pathToAst(path) {
-  const { ast } = parseFormula(path);
-  return ast;
-}
-function replaceNode(node, replacements) {
-  const replacement = findMatch(node, replacements);
-  if (replacement !== null) {
-    return pathToAst(replacement);
-  }
-  switch (node.type) {
-    case "NumberLiteral":
-    case "StringLiteral":
-    case "BooleanLiteral":
-    case "NullLiteral":
-    case "Identifier":
-    case "BracketedIdentifier":
-    case "RootPath":
-    case "RelativePath":
-    case "ContextToken":
-      return node;
-    case "BinaryOp":
-      return {
-        ...node,
-        left: replaceNode(node.left, replacements),
-        right: replaceNode(node.right, replacements)
-      };
-    case "UnaryOp":
-      return {
-        ...node,
-        argument: replaceNode(node.argument, replacements)
-      };
-    case "TernaryOp":
-      return {
-        ...node,
-        condition: replaceNode(node.condition, replacements),
-        consequent: replaceNode(node.consequent, replacements),
-        alternate: replaceNode(node.alternate, replacements)
-      };
-    case "CallExpression": {
-      const isSimpleFunctionCall = node.callee.type === "Identifier";
-      return {
-        ...node,
-        callee: isSimpleFunctionCall ? node.callee : replaceNode(node.callee, replacements),
-        arguments: node.arguments.map((arg) => replaceNode(arg, replacements))
-      };
-    }
-    case "MemberExpression":
-    case "BracketedMemberExpression":
-    case "WildcardExpression":
-      return {
-        ...node,
-        object: replaceNode(node.object, replacements)
-      };
-    case "IndexExpression":
-      return {
-        ...node,
-        object: replaceNode(node.object, replacements),
-        index: replaceNode(node.index, replacements)
-      };
-  }
-}
-function replaceDependencies(ast, replacements) {
-  return replaceNode(ast, replacements);
-}
-
-// src/parse-formula.ts
-function parseExpression(expression) {
-  const result = parseFormula(expression);
-  return {
-    expression,
-    dependencies: result.dependencies,
-    minVersion: result.minVersion,
-    features: result.features
-  };
-}
-
-// src/validate-syntax.ts
-function validateFormulaSyntax(expression) {
-  const result = validateSyntax(expression);
-  if (result.isValid) {
-    return { isValid: true };
-  }
-  return {
-    isValid: false,
-    error: result.error,
-    position: result.position
-  };
-}
-
-exports.evaluate = evaluate;
-exports.evaluateWithContext = evaluateWithContext;
-exports.inferFormulaType = inferFormulaType;
-exports.parseExpression = parseExpression;
-exports.parseFormula = parseFormula;
-exports.replaceDependencies = replaceDependencies;
-exports.serializeAst = serializeAst;
-exports.validateFormulaSyntax = validateFormulaSyntax;
-exports.validateSyntax = validateSyntax;
-//# sourceMappingURL=chunk-4FIOGFOL.cjs.map
-//# sourceMappingURL=chunk-4FIOGFOL.cjs.map