@revisium/formula 0.3.0 → 0.5.0

package/dist/chunk-INF4CK6N.js

@@ -0,0 +1,1419 @@
+import * as ohm from 'ohm-js';
+
+// 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
+    | 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.grammar(grammarText);
+
+// src/ohm/semantics/index.ts
+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) {
+    return {
+      type: "IndexExpression",
+      object: obj.toAST(),
+      index: index.toAST()
+    };
+  },
+  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(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];
+  },
+  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();
+    const 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;
+    };
+    const numericIndex = getNumericIndex(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", {
+  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();
+    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 (idx < 0) {
+      return objVal?.[objVal.length + idx];
+    }
+    return objVal?.[idx];
+  },
+  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(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 getValueByPath(data, path) {
+  const segments = path.split(".");
+  let current = data;
+  for (const segment of segments) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    if (typeof current !== "object") {
+      return void 0;
+    }
+    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 buildPathReferences(rootData, dependencies) {
+  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 fieldPath = dep.slice(3);
+      refs[dep] = getValueByPath(rootData, fieldPath);
+    }
+  }
+  return refs;
+}
+function evaluateWithContext(expression, options) {
+  const { rootData, itemData } = options;
+  const trimmed = expression.trim();
+  if (!trimmed) {
+    throw new Error("Empty expression");
+  }
+  const parsed = parseFormula(trimmed);
+  const pathRefs = buildPathReferences(rootData, parsed.dependencies);
+  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/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
+  };
+}
+
+// src/dependency-graph.ts
+function buildDependencyGraph(dependencies) {
+  const nodes = /* @__PURE__ */ new Set();
+  const edges = /* @__PURE__ */ new Map();
+  for (const [node, deps] of Object.entries(dependencies)) {
+    nodes.add(node);
+    edges.set(node, new Set(deps));
+    for (const dep of deps) {
+      nodes.add(dep);
+    }
+  }
+  return { nodes, edges };
+}
+function detectCircularDependencies(graph) {
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  const path = [];
+  for (const node of graph.nodes) {
+    if (!visited.has(node)) {
+      const cycle = dfsVisit(node, graph, visited, recursionStack, path);
+      if (cycle) {
+        return { hasCircular: true, cycle };
+      }
+    }
+  }
+  return { hasCircular: false, cycle: null };
+}
+function dfsVisit(node, graph, visited, recursionStack, path) {
+  visited.add(node);
+  recursionStack.add(node);
+  path.push(node);
+  const deps = graph.edges.get(node);
+  if (deps) {
+    for (const dep of deps) {
+      if (!visited.has(dep)) {
+        const cycle = dfsVisit(dep, graph, visited, recursionStack, path);
+        if (cycle) {
+          return cycle;
+        }
+      } else if (recursionStack.has(dep)) {
+        const cycleStart = path.indexOf(dep);
+        return [...path.slice(cycleStart), dep];
+      }
+    }
+  }
+  path.pop();
+  recursionStack.delete(node);
+  return null;
+}
+function getTopologicalOrder(graph) {
+  const circularCheck = detectCircularDependencies(graph);
+  if (circularCheck.hasCircular && circularCheck.cycle) {
+    return {
+      success: false,
+      order: [],
+      error: `Circular dependency detected: ${circularCheck.cycle.join(" -> ")}`
+    };
+  }
+  const inDegree = initializeInDegree(graph);
+  const queue = findZeroInDegreeNodes(inDegree);
+  const order = processQueue(queue, graph, inDegree);
+  order.reverse();
+  return { success: true, order };
+}
+function initializeInDegree(graph) {
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    inDegree.set(node, 0);
+  }
+  for (const deps of graph.edges.values()) {
+    for (const dep of deps) {
+      inDegree.set(dep, (inDegree.get(dep) ?? 0) + 1);
+    }
+  }
+  return inDegree;
+}
+function findZeroInDegreeNodes(inDegree) {
+  const result = [];
+  for (const [node, degree] of inDegree) {
+    if (degree === 0) {
+      result.push(node);
+    }
+  }
+  return result;
+}
+function processQueue(queue, graph, inDegree) {
+  const order = [];
+  let head = 0;
+  while (head < queue.length) {
+    const node = queue[head];
+    head++;
+    order.push(node);
+    const deps = graph.edges.get(node);
+    if (deps) {
+      for (const dep of deps) {
+        const newDegree = (inDegree.get(dep) ?? 0) - 1;
+        inDegree.set(dep, newDegree);
+        if (newDegree === 0) {
+          queue.push(dep);
+        }
+      }
+    }
+  }
+  return order;
+}
+
+// src/extract-schema.ts
+function extractSchemaFormulas(schema) {
+  const formulas = [];
+  extractFormulasRecursive(schema, "", formulas);
+  return formulas;
+}
+function extractFormulasRecursive(schema, pathPrefix, formulas) {
+  if (schema.type === "array" && schema.items) {
+    extractFormulasRecursive(schema.items, `${pathPrefix}[]`, formulas);
+    return;
+  }
+  const properties = schema.properties ?? {};
+  for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+    const fullPath = pathPrefix ? `${pathPrefix}.${fieldName}` : fieldName;
+    const xFormula = fieldSchema["x-formula"];
+    if (xFormula) {
+      formulas.push({
+        fieldName: fullPath,
+        expression: xFormula.expression,
+        fieldType: fieldSchema.type ?? "string"
+      });
+    }
+    if (fieldSchema.type === "object" && fieldSchema.properties) {
+      extractFormulasRecursive(fieldSchema, fullPath, formulas);
+    }
+    if (fieldSchema.type === "array" && fieldSchema.items) {
+      extractFormulasRecursive(fieldSchema.items, `${fullPath}[]`, formulas);
+    }
+  }
+}
+
+// src/validate-schema.ts
+function resolveSubSchema(schema, fieldPath) {
+  if (!fieldPath) {
+    return schema;
+  }
+  const segments = parsePathSegments(fieldPath);
+  let current = schema;
+  for (const segment of segments) {
+    if (segment === "[]") {
+      if (current.type === "array" && current.items) {
+        current = current.items;
+      } else {
+        return null;
+      }
+    } else {
+      if (current.properties?.[segment]) {
+        current = current.properties[segment];
+      } else {
+        return null;
+      }
+    }
+  }
+  return current;
+}
+function parsePathSegments(path) {
+  const segments = [];
+  let current = "";
+  let inBracket = false;
+  for (const char of path) {
+    if (char === "[") {
+      if (current) {
+        segments.push(current);
+        current = "";
+      }
+      inBracket = true;
+    } else if (char === "]") {
+      inBracket = false;
+      segments.push("[]");
+    } else if (char === "." && !inBracket) {
+      if (current) {
+        segments.push(current);
+        current = "";
+      }
+    } else if (!inBracket) {
+      current += char;
+    }
+  }
+  if (current) {
+    segments.push(current);
+  }
+  return segments;
+}
+function getParentPath(fieldPath) {
+  const lastDotIndex = fieldPath.lastIndexOf(".");
+  const lastBracketIndex = fieldPath.lastIndexOf("[");
+  const splitIndex = Math.max(lastDotIndex, lastBracketIndex);
+  if (splitIndex <= 0) {
+    return "";
+  }
+  return fieldPath.substring(0, splitIndex);
+}
+function getFieldName(fieldPath) {
+  const lastDotIndex = fieldPath.lastIndexOf(".");
+  const lastBracketIndex = fieldPath.lastIndexOf("]");
+  const splitIndex = Math.max(lastDotIndex, lastBracketIndex);
+  if (splitIndex === -1) {
+    return fieldPath;
+  }
+  return fieldPath.substring(splitIndex + 1);
+}
+function getSchemaFields(schema) {
+  const fields = /* @__PURE__ */ new Set();
+  const properties = schema.properties ?? {};
+  for (const fieldName of Object.keys(properties)) {
+    fields.add(fieldName);
+  }
+  return fields;
+}
+function getSchemaFieldTypes(schema) {
+  const fieldTypes = {};
+  const properties = schema.properties ?? {};
+  for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+    const schemaType = fieldSchema.type;
+    if (schemaType === "number" || schemaType === "string" || schemaType === "boolean" || schemaType === "object" || schemaType === "array") {
+      fieldTypes[fieldName] = schemaType;
+    }
+  }
+  return fieldTypes;
+}
+function schemaTypeToInferred(schemaType) {
+  if (schemaType === "number") return "number";
+  if (schemaType === "string") return "string";
+  if (schemaType === "boolean") return "boolean";
+  return null;
+}
+function isTypeCompatible(inferredType, expectedType) {
+  if (expectedType === null) return true;
+  if (inferredType === "unknown") return true;
+  return inferredType === expectedType;
+}
+function extractFieldRoot(dependency) {
+  const root = dependency.split(".")[0]?.split("[")[0];
+  return root || dependency;
+}
+function validateFormulaInContext(expression, fieldPath, rootSchema) {
+  const syntaxResult = validateFormulaSyntax(expression);
+  if (!syntaxResult.isValid) {
+    return {
+      field: fieldPath,
+      error: syntaxResult.error,
+      position: syntaxResult.position
+    };
+  }
+  const parentPath = getParentPath(fieldPath);
+  const localFieldName = getFieldName(fieldPath);
+  const contextSchema = resolveSubSchema(rootSchema, parentPath);
+  if (!contextSchema) {
+    return {
+      field: fieldPath,
+      error: `Cannot resolve schema context for path '${parentPath}'`
+    };
+  }
+  const parseResult = parseExpression(expression);
+  const schemaFields = getSchemaFields(contextSchema);
+  for (const dep of parseResult.dependencies) {
+    const rootField = extractFieldRoot(dep);
+    if (!schemaFields.has(rootField)) {
+      return {
+        field: fieldPath,
+        error: `Unknown field '${rootField}' in formula`
+      };
+    }
+  }
+  if (parseResult.dependencies.some((d) => extractFieldRoot(d) === localFieldName)) {
+    return {
+      field: fieldPath,
+      error: `Formula cannot reference itself`
+    };
+  }
+  const fieldSchema = contextSchema.properties?.[localFieldName];
+  const expectedType = schemaTypeToInferred(fieldSchema?.type);
+  const fieldTypes = getSchemaFieldTypes(contextSchema);
+  const inferredType = inferFormulaType(expression, fieldTypes);
+  if (!isTypeCompatible(inferredType, expectedType)) {
+    return {
+      field: fieldPath,
+      error: `Type mismatch: formula returns '${inferredType}' but field expects '${expectedType}'`
+    };
+  }
+  return null;
+}
+function validateFormulaAgainstSchema(expression, fieldName, schema) {
+  return validateFormulaInContext(expression, fieldName, schema);
+}
+function validateSchemaFormulas(schema) {
+  const errors = [];
+  const formulas = extractSchemaFormulas(schema);
+  for (const formula of formulas) {
+    const error = validateFormulaAgainstSchema(
+      formula.expression,
+      formula.fieldName,
+      schema
+    );
+    if (error) {
+      errors.push(error);
+    }
+  }
+  if (errors.length > 0) {
+    return { isValid: false, errors };
+  }
+  const dependencies = {};
+  for (const formula of formulas) {
+    const parseResult = parseExpression(formula.expression);
+    const parentPath = getParentPath(formula.fieldName);
+    const prefix = parentPath ? `${parentPath}.` : "";
+    dependencies[formula.fieldName] = parseResult.dependencies.map((dep) => {
+      const rootField = extractFieldRoot(dep);
+      return `${prefix}${rootField}`;
+    });
+  }
+  const graph = buildDependencyGraph(dependencies);
+  const circularCheck = detectCircularDependencies(graph);
+  const cycle = circularCheck.cycle;
+  if (circularCheck.hasCircular && cycle && cycle.length > 0) {
+    const firstField = cycle[0];
+    if (firstField) {
+      errors.push({
+        field: firstField,
+        error: `Circular dependency: ${cycle.join(" \u2192 ")}`
+      });
+      return { isValid: false, errors };
+    }
+  }
+  return { isValid: true, errors: [] };
+}
+
+export { buildDependencyGraph, detectCircularDependencies, evaluate, evaluateWithContext, extractSchemaFormulas, getTopologicalOrder, inferFormulaType, parseExpression, parseFormula, validateFormulaAgainstSchema, validateFormulaSyntax, validateSchemaFormulas, validateSyntax };
+//# sourceMappingURL=chunk-INF4CK6N.js.map
+//# sourceMappingURL=chunk-INF4CK6N.js.map