@revisium/formula 0.4.0 → 0.6.0

package/dist/chunk-AGBOCJGV.cjs

@@ -1,1266 +0,0 @@
-'use strict';
-
-var chunkQ7SFCCGT_cjs = require('./chunk-Q7SFCCGT.cjs');
-
-// node_modules/subscript/src/parse.js
-var parse_exports = {};
-chunkQ7SFCCGT_cjs.__export(parse_exports, {
-  access: () => access,
-  binary: () => binary,
-  cur: () => cur,
-  default: () => parse_default,
-  err: () => err2,
-  expr: () => expr,
-  group: () => group,
-  id: () => id,
-  idx: () => idx,
-  lookup: () => lookup,
-  nary: () => nary,
-  next: () => next,
-  parse: () => parse,
-  skip: () => skip,
-  space: () => space,
-  token: () => token,
-  unary: () => unary
-});
-
-// node_modules/subscript/src/const.js
-var PERIOD = 46;
-var SPACE = 32;
-var DQUOTE = 34;
-var QUOTE = 39;
-var _0 = 48;
-var _9 = 57;
-var _E = 69;
-var _e = 101;
-var BSLASH = 92;
-var PREC_STATEMENT = 5;
-var PREC_SEQ = 10;
-var PREC_ASSIGN = 20;
-var PREC_LOR = 30;
-var PREC_LAND = 40;
-var PREC_OR = 50;
-var PREC_XOR = 60;
-var PREC_AND = 70;
-var PREC_EQ = 80;
-var PREC_COMP = 90;
-var PREC_SHIFT = 100;
-var PREC_ADD = 110;
-var PREC_MULT = 120;
-var PREC_PREFIX = 140;
-var PREC_POSTFIX = 150;
-var PREC_ACCESS = 170;
-var unsafe = (k) => k?.[0] === "_" && k[1] === "_" || k === "constructor" || k === "prototype";
-
-// node_modules/subscript/src/parse.js
-var idx;
-var cur;
-var parse = (s) => (idx = 0, cur = s, s = expr(), cur[idx] ? err2() : s || "");
-var err2 = (msg = "Unexpected token", lines = cur.slice(0, idx).split("\n"), last2 = lines.pop(), before = cur.slice(Math.max(0, idx - 40), idx), after = cur.slice(idx, idx + 20)) => {
-  throw SyntaxError(`${msg} at ${lines.length + 1}:${last2.length + 1} \u2014 ${before}^${after}`);
-};
-var next = (is, from = idx, l) => {
-  while (l = is(cur.charCodeAt(idx))) idx += l;
-  return cur.slice(from, idx);
-};
-var skip = () => cur[idx++];
-var expr = (prec = 0, end) => {
-  let cc, token2, newNode, fn;
-  while ((cc = space()) && // till not end
-  // NOTE: when lookup bails on lower precedence, parent expr re-calls space() — acceptable overhead
-  (newNode = ((fn = lookup[cc]) && fn(token2, prec)) ?? // if operator with higher precedence isn't found
-  (!token2 && next(parse.id)))) token2 = newNode;
-  if (end) cc == end ? idx++ : err2("Unclosed " + String.fromCharCode(end - (end > 42 ? 2 : 1)));
-  return token2;
-};
-var space = (cc) => {
-  while ((cc = cur.charCodeAt(idx)) <= SPACE) idx++;
-  return cc;
-};
-var id = parse.id = (c) => c >= 48 && c <= 57 || // 0..9
-c >= 65 && c <= 90 || // A...Z
-c >= 97 && c <= 122 || // a...z
-c == 36 || c == 95 || // $, _,
-c >= 192 && c != 215 && c != 247;
-var lookup = [];
-var token = (op, prec = SPACE, map, c = op.charCodeAt(0), l = op.length, prev = lookup[c], word = op.toUpperCase() !== op) => lookup[c] = (a, curPrec, curOp, from = idx) => (curOp ? op == curOp : (l < 2 || cur.substr(idx, l) == op) && (curOp = op)) && curPrec < prec && // matches precedence AFTER operator matched
-!(word && parse.id(cur.charCodeAt(idx + l))) && // finished word, not part of bigger word
-(idx += l, map(a) || (idx = from, !prev && err2())) || prev?.(a, curPrec, curOp);
-var binary = (op, prec, right = false) => token(op, prec, (a, b) => a && (b = expr(prec - (right ? 0.5 : 0))) && [op, a, b]);
-var unary = (op, prec, post) => token(op, prec, (a) => post ? a && [op, a] : !a && (a = expr(prec - 0.5)) && [op, a]);
-var nary = (op, prec, right) => {
-  token(
-    op,
-    prec,
-    (a, b) => (b = expr(prec - (right ? 0.5 : 0)), a?.[0] !== op && (a = [op, a || null]), // if beginning of sequence - init node
-    b?.[0] === op ? a.push(...b.slice(1)) : a.push(b || null), // comments can return same-token expr
-    a)
-  );
-};
-var group = (op, prec) => token(op[0], prec, (a) => !a && [op, expr(0, op.charCodeAt(1))]);
-var access = (op, prec) => token(op[0], prec, (a) => a && [op, a, expr(0, op.charCodeAt(1)) || null]);
-var parse_default = parse;
-
-// node_modules/subscript/feature/number.js
-var _b = 98;
-var _B = 66;
-var _o = 111;
-var _O = 79;
-var _x = 120;
-var _X = 88;
-var _a = 97;
-var _f = 102;
-var _A = 65;
-var _F = 70;
-var num = (a, _) => [, (a = +next((c) => c === PERIOD || c >= _0 && c <= _9 || (c === _E || c === _e ? 2 : 0))) != a ? err2() : a];
-lookup[PERIOD] = (a) => !a && num();
-for (let i = _0 + 1; i <= _9; i++) lookup[i] = (a) => a ? err2() : num();
-lookup[_0] = (a) => {
-  if (a) return err2();
-  const nextChar = cur.charCodeAt(idx + 1);
-  if (nextChar === _b || nextChar === _B) {
-    skip();
-    skip();
-    const s = next((c) => c === 48 || c === 49);
-    return [, parseInt(s, 2)];
-  }
-  if (nextChar === _o || nextChar === _O) {
-    skip();
-    skip();
-    const s = next((c) => c >= 48 && c <= 55);
-    return [, parseInt(s, 8)];
-  }
-  if (nextChar === _x || nextChar === _X) {
-    skip();
-    skip();
-    const s = next((c) => c >= _0 && c <= _9 || c >= _a && c <= _f || c >= _A && c <= _F);
-    return [, parseInt(s, 16)];
-  }
-  return num();
-};
-
-// node_modules/subscript/feature/string.js
-var escape = { n: "\n", r: "\r", t: "	", b: "\b", f: "\f", v: "\v" };
-var string = (q) => (qc, prec, str = "") => {
-  qc && err2("Unexpected string");
-  skip();
-  next((c) => c - q && (c === BSLASH ? (str += escape[cur[idx + 1]] || cur[idx + 1], 2) : (str += cur[idx], 1)));
-  skip() || err2("Bad string");
-  return [, str];
-};
-lookup[DQUOTE] = string(DQUOTE);
-lookup[QUOTE] = string(QUOTE);
-
-// node_modules/subscript/src/compile.js
-var compile = (node) => !Array.isArray(node) ? compile.id(node) : !node[0] ? () => node[1] : operators[node[0]].call(...node);
-compile.id = (name) => (ctx) => ctx?.[name];
-var operators = {};
-var operator = (op, fn, prev = operators[op]) => operators[op] = (...args) => fn(...args) || prev?.(...args);
-var prop2 = (a, fn, generic, obj, path) => (
-  // (((x))) => x
-  a[0] === "()" && a.length == 2 ? prop2(a[1], fn, generic) : (
-    // (_, name, ctx) => ctx[path]
-    typeof a === "string" ? (ctx) => fn(ctx, a, ctx) : (
-      // (container, path, ctx) => container(ctx)[path]
-      a[0] === "." ? (obj = compile(a[1]), path = a[2], (ctx) => fn(obj(ctx), path, ctx)) : (
-        // (container, path, ctx) => container(ctx)[path(ctx)]
-        a[0] === "[]" && a.length === 3 ? (obj = compile(a[1]), path = compile(a[2]), (ctx) => fn(obj(ctx), path(ctx), ctx)) : (
-          // (src, _, ctx) => src(ctx)
-          generic ? (a = compile(a), (ctx) => fn([a(ctx)], 0, ctx)) : () => err2("Bad left value")
-        )
-      )
-    )
-  )
-);
-var compile_default = compile;
-
-// node_modules/subscript/feature/call.js
-access("()", PREC_ACCESS);
-operator(
-  "()",
-  (a, b, args) => b !== void 0 && (args = !b ? () => [] : (
-    // a()
-    b[0] === "," ? (b = b.slice(1).map((b2) => !b2 ? err() : compile(b2)), (ctx) => b.map((arg) => arg(ctx))) : (
-      // a(b,c)
-      (b = compile(b), (ctx) => [b(ctx)])
-    )
-  ), // a(b)
-  // a(...args), a.b(...args), a[b](...args)
-  prop2(a, (obj, path, ctx) => obj[path](...args(ctx)), true))
-);
-
-// node_modules/subscript/feature/access.js
-access("[]", PREC_ACCESS);
-operator("[]", (a, b) => !b ? err2() : (a = compile(a), b = compile(b), (ctx) => {
-  const k = b(ctx);
-  return unsafe(k) ? void 0 : a(ctx)[k];
-}));
-binary(".", PREC_ACCESS);
-operator(".", (a, b) => (a = compile(a), b = !b[0] ? b[1] : b, unsafe(b) ? () => void 0 : (ctx) => a(ctx)[b]));
-
-// node_modules/subscript/feature/group.js
-group("()", PREC_ACCESS);
-operator("()", (a, b) => b === void 0 && (!a && err2("Empty ()"), compile(a)));
-var last = (...args) => (args = args.map(compile), (ctx) => args.map((arg) => arg(ctx)).pop());
-nary(",", PREC_SEQ), operator(",", last);
-nary(";", PREC_STATEMENT, true), operator(";", last);
-
-// node_modules/subscript/feature/assign.js
-binary("=", PREC_ASSIGN, true);
-operator("=", (a, b) => (b = compile(b), // a = x, ((a)) = x, a.b = x, a['b'] = x
-prop2(a, (container, path, ctx) => container[path] = b(ctx))));
-
-// node_modules/subscript/feature/mult.js
-binary("*", PREC_MULT), operator("*", (a, b) => b && (a = compile(a), b = compile(b), (ctx) => a(ctx) * b(ctx)));
-binary("/", PREC_MULT), operator("/", (a, b) => b && (a = compile(a), b = compile(b), (ctx) => a(ctx) / b(ctx)));
-binary("%", PREC_MULT), operator("%", (a, b) => b && (a = compile(a), b = compile(b), (ctx) => a(ctx) % b(ctx)));
-binary("*=", PREC_ASSIGN, true);
-operator("*=", (a, b) => (b = compile(b), prop2(a, (container, path, ctx) => container[path] *= b(ctx))));
-binary("/=", PREC_ASSIGN, true);
-operator("/=", (a, b) => (b = compile(b), prop2(a, (container, path, ctx) => container[path] /= b(ctx))));
-binary("%=", PREC_ASSIGN, true);
-operator("%=", (a, b) => (b = compile(b), prop2(a, (container, path, ctx) => container[path] %= b(ctx))));
-
-// node_modules/subscript/feature/add.js
-binary("+", PREC_ADD), operator("+", (a, b) => b && (a = compile(a), b = compile(b), (ctx) => a(ctx) + b(ctx)));
-binary("-", PREC_ADD), operator("-", (a, b) => b && (a = compile(a), b = compile(b), (ctx) => a(ctx) - b(ctx)));
-unary("+", PREC_PREFIX), operator("+", (a, b) => !b && (a = compile(a), (ctx) => +a(ctx)));
-unary("-", PREC_PREFIX), operator("-", (a, b) => !b && (a = compile(a), (ctx) => -a(ctx)));
-binary("+=", PREC_ASSIGN, true);
-operator("+=", (a, b) => (b = compile(b), prop2(a, (container, path, ctx) => container[path] += b(ctx))));
-binary("-=", PREC_ASSIGN, true);
-operator("-=", (a, b) => (b = compile(b), prop2(a, (container, path, ctx) => container[path] -= b(ctx))));
-
-// node_modules/subscript/feature/increment.js
-token("++", PREC_POSTFIX, (a) => a ? ["++", a, null] : ["++", expr(PREC_POSTFIX - 1)]);
-operator("++", (a, b) => prop2(a, b === null ? (obj, path) => obj[path]++ : (obj, path) => ++obj[path]));
-token("--", PREC_POSTFIX, (a) => a ? ["--", a, null] : ["--", expr(PREC_POSTFIX - 1)]);
-operator("--", (a, b) => prop2(a, b === null ? (obj, path) => obj[path]-- : (obj, path) => --obj[path]));
-
-// node_modules/subscript/feature/bitwise.js
-unary("~", PREC_PREFIX), operator("~", (a, b) => !b && (a = compile(a), (ctx) => ~a(ctx)));
-binary("|", PREC_OR), operator("|", (a, b) => b && (a = compile(a), b = compile(b), (ctx) => a(ctx) | b(ctx)));
-binary("&", PREC_AND), operator("&", (a, b) => b && (a = compile(a), b = compile(b), (ctx) => a(ctx) & b(ctx)));
-binary("^", PREC_XOR), operator("^", (a, b) => b && (a = compile(a), b = compile(b), (ctx) => a(ctx) ^ b(ctx)));
-
-// node_modules/subscript/feature/logic.js
-unary("!", PREC_PREFIX), operator("!", (a, b) => !b && (a = compile(a), (ctx) => !a(ctx)));
-binary("||", PREC_LOR);
-operator("||", (a, b) => (a = compile(a), b = compile(b), (ctx) => a(ctx) || b(ctx)));
-binary("&&", PREC_LAND);
-operator("&&", (a, b) => (a = compile(a), b = compile(b), (ctx) => a(ctx) && b(ctx)));
-
-// node_modules/subscript/feature/compare.js
-binary("==", PREC_EQ), operator("==", (a, b) => b && (a = compile(a), b = compile(b), (ctx) => a(ctx) == b(ctx)));
-binary("!=", PREC_EQ), operator("!=", (a, b) => b && (a = compile(a), b = compile(b), (ctx) => a(ctx) != b(ctx)));
-binary(">", PREC_COMP), operator(">", (a, b) => b && (a = compile(a), b = compile(b), (ctx) => a(ctx) > b(ctx)));
-binary("<", PREC_COMP), operator("<", (a, b) => b && (a = compile(a), b = compile(b), (ctx) => a(ctx) < b(ctx)));
-binary(">=", PREC_COMP), operator(">=", (a, b) => b && (a = compile(a), b = compile(b), (ctx) => a(ctx) >= b(ctx)));
-binary("<=", PREC_COMP), operator("<=", (a, b) => b && (a = compile(a), b = compile(b), (ctx) => a(ctx) <= b(ctx)));
-
-// node_modules/subscript/feature/shift.js
-binary(">>", PREC_SHIFT), operator(">>", (a, b) => b && (a = compile(a), b = compile(b), (ctx) => a(ctx) >> b(ctx)));
-binary("<<", PREC_SHIFT), operator("<<", (a, b) => b && (a = compile(a), b = compile(b), (ctx) => a(ctx) << b(ctx)));
-binary(">>=", PREC_ASSIGN, true);
-operator(">>=", (a, b) => (b = compile(b), prop(a, (obj, path, ctx) => obj[path] >>= b(ctx))));
-binary("<<=", PREC_ASSIGN, true);
-operator("<<=", (a, b) => (b = compile(b), prop(a, (obj, path, ctx) => obj[path] <<= b(ctx))));
-
-// node_modules/subscript/subscript.js
-var subscript_default = (s) => compile_default(parse_default(s));
-
-// src/parser.ts
-var { next: next2 } = parse_exports;
-var isIdChar = (c) => c >= 97 && c <= 122 || // a-z
-c >= 65 && c <= 90 || // A-Z
-c >= 48 && c <= 57 || // 0-9
-c === 95 ? 1 : 0;
-token("@", 200, (a) => {
-  if (a) return;
-  const name = next2(isIdChar);
-  if (!name) return;
-  return "@" + name;
-});
-token("#", 200, (a) => {
-  if (a) return;
-  const name = next2(isIdChar);
-  if (!name) return;
-  return "#" + name;
-});
-var createWildcardLiteral = () => {
-  const arr = [];
-  arr[1] = "*";
-  return arr;
-};
-token("*", 200, (a) => {
-  if (!a) return createWildcardLiteral();
-  return void 0;
-});
-token("/", 200, (a) => {
-  if (a) return;
-  const name = next2(isIdChar);
-  if (!name) return;
-  return "/" + name;
-});
-var isRelativePathChar = (c) => isIdChar(c) || c === 47 || c === 46 ? 1 : 0;
-token(".", 200, (a) => {
-  if (a) return;
-  const second = next2((c) => c === 46 ? 1 : 0);
-  if (!second) return;
-  const rest = next2(isRelativePathChar);
-  if (!rest) return;
-  return ".." + rest;
-});
-var BUILTIN_FUNCTIONS = {
-  and: (a, b) => Boolean(a) && Boolean(b),
-  or: (a, b) => Boolean(a) || Boolean(b),
-  not: (a) => !a,
-  concat: (...args) => args.map(String).join(""),
-  upper: (s) => String(s).toUpperCase(),
-  lower: (s) => String(s).toLowerCase(),
-  trim: (s) => String(s).trim(),
-  left: (s, n) => {
-    const count = Math.max(0, Math.floor(Number(n)));
-    return String(s).slice(0, count);
-  },
-  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, replacement) => String(s).replace(String(search), String(replacement)),
-  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)),
-  tonumber: Number,
-  toboolean: Boolean,
-  isnull: (v) => v === null || v === void 0,
-  coalesce: (...args) => args.find((v) => v !== null && v !== void 0) ?? null,
-  round: (n, decimals) => {
-    const num2 = Number(n);
-    const dec = decimals === void 0 ? 0 : Number(decimals);
-    const factor = 10 ** dec;
-    return Math.round(num2 * 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)),
-  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,
-  join: (arr, separator) => {
-    if (!Array.isArray(arr)) return "";
-    if (separator === void 0) return arr.join(",");
-    if (typeof separator === "string") return arr.join(separator);
-    if (typeof separator === "number") return arr.join(String(separator));
-    return arr.join(",");
-  },
-  includes: (arr, value) => Array.isArray(arr) ? arr.includes(value) : false,
-  if: (condition, ifTrue, ifFalse) => condition ? ifTrue : ifFalse
-};
-function extractCallArgs(argsNode) {
-  if (!argsNode) return [];
-  if (!Array.isArray(argsNode)) return [argsNode];
-  if (argsNode[0] === ",") {
-    return argsNode.slice(1);
-  }
-  return [argsNode];
-}
-function compileNode(node) {
-  return compile(node);
-}
-function createGroupingEvaluator(fn) {
-  const compiledExpr = compileNode(fn);
-  return (ctx) => compiledExpr(ctx);
-}
-function createFunctionCallEvaluator(fn, argsNode) {
-  const args = extractCallArgs(argsNode);
-  const compiledArgs = args.map((arg) => compileNode(arg));
-  return (ctx) => {
-    const argValues = compiledArgs.map((a) => a(ctx));
-    if (typeof fn === "string") {
-      const builtinFn = BUILTIN_FUNCTIONS[fn.toLowerCase()];
-      if (builtinFn) {
-        return builtinFn(...argValues);
-      }
-    }
-    const fnValue = compileNode(fn)(ctx);
-    if (typeof fnValue === "function") {
-      return fnValue(...argValues);
-    }
-    const fnName = typeof fn === "string" ? fn : String(fn);
-    throw new Error(`'${fnName}' is not a function`);
-  };
-}
-operator("()", (fn, argsNode) => {
-  if (argsNode === void 0) {
-    return createGroupingEvaluator(fn);
-  }
-  return createFunctionCallEvaluator(fn, argsNode);
-});
-var KEYWORDS = /* @__PURE__ */ new Set([
-  "true",
-  "false",
-  "null",
-  "and",
-  "or",
-  "not",
-  "if",
-  "round",
-  "floor",
-  "ceil",
-  "abs",
-  "sqrt",
-  "pow",
-  "min",
-  "max",
-  "log",
-  "log10",
-  "exp",
-  "sign",
-  "concat",
-  "upper",
-  "lower",
-  "length",
-  "trim",
-  "left",
-  "right",
-  "replace",
-  "contains",
-  "startswith",
-  "endswith",
-  "tostring",
-  "tonumber",
-  "toboolean",
-  "isnull",
-  "coalesce",
-  "sum",
-  "avg",
-  "count",
-  "first",
-  "last",
-  "join",
-  "includes"
-]);
-var ARRAY_FUNCTIONS = /* @__PURE__ */ new Set([
-  "sum",
-  "avg",
-  "count",
-  "first",
-  "last",
-  "join",
-  "includes"
-]);
-function isKeyword(name) {
-  return KEYWORDS.has(name.toLowerCase());
-}
-function isArrayFunction(name) {
-  return ARRAY_FUNCTIONS.has(name.toLowerCase());
-}
-function isContextToken(name) {
-  return name.startsWith("@") || name.startsWith("#");
-}
-function isRootPath(name) {
-  return name.startsWith("/");
-}
-function isRelativePath(name) {
-  return name.startsWith("..");
-}
-function isValidIdentifierRoot(rootName) {
-  return !isKeyword(rootName) && !isContextToken(rootName);
-}
-function extractRootName(path) {
-  return path.split(".")[0]?.split("[")[0] ?? "";
-}
-function addPathIfValid(path, identifiers) {
-  if (path && isValidIdentifierRoot(extractRootName(path))) {
-    identifiers.add(path);
-  }
-}
-function collectStringIdentifier(node, identifiers) {
-  if (isRootPath(node) || isRelativePath(node)) {
-    identifiers.add(node);
-    return;
-  }
-  if (!isContextToken(node) && !isKeyword(node)) {
-    identifiers.add(node);
-  }
-}
-function collectFunctionCallIdentifiers(args, identifiers) {
-  for (let i = 1; i < args.length; i++) {
-    collectIdentifiers(args[i], identifiers);
-  }
-  const funcName = args[0];
-  if (typeof funcName !== "string") {
-    collectIdentifiers(funcName, identifiers);
-  }
-}
-function collectPathOrFallback(node, identifiers) {
-  const path = buildDotPath(node);
-  if (path) {
-    addPathIfValid(path, identifiers);
-  } else {
-    const [, ...args] = node;
-    for (const arg of args) {
-      collectIdentifiers(arg, identifiers);
-    }
-  }
-}
-function collectIdentifiers(node, identifiers) {
-  if (typeof node === "string") {
-    collectStringIdentifier(node, identifiers);
-    return;
-  }
-  if (!Array.isArray(node)) {
-    return;
-  }
-  if (isLiteralArray(node)) {
-    return;
-  }
-  const [op, ...args] = node;
-  if (op === "." || op === "[]") {
-    collectPathOrFallback(node, identifiers);
-    return;
-  }
-  if (op === "()") {
-    collectFunctionCallIdentifiers(args, identifiers);
-    return;
-  }
-  for (const arg of args) {
-    collectIdentifiers(arg, identifiers);
-  }
-}
-function isLiteralArray(arr) {
-  return !(0 in arr);
-}
-function buildPropertyAccessPath(left, right) {
-  const leftPath = buildDotPath(left);
-  const rightPath = typeof right === "string" ? right : null;
-  if (leftPath && rightPath) {
-    return `${leftPath}.${rightPath}`;
-  }
-  return null;
-}
-function getNegativeIndexValue(index) {
-  if (!Array.isArray(index) || index[0] !== "-" || index.length !== 2) {
-    return null;
-  }
-  const inner = index[1];
-  if (Array.isArray(inner) && isLiteralArray(inner) && typeof inner[1] === "number") {
-    return -inner[1];
-  }
-  return null;
-}
-function buildArrayAccessPath(left, right) {
-  const leftPath = buildDotPath(left);
-  if (!leftPath) {
-    return null;
-  }
-  if (Array.isArray(right) && isLiteralArray(right)) {
-    if (right[1] === "*") {
-      return `${leftPath}[*]`;
-    }
-    if (typeof right[1] === "number") {
-      return `${leftPath}[${right[1]}]`;
-    }
-  }
-  const negativeIndex = getNegativeIndexValue(right);
-  if (negativeIndex !== null) {
-    return `${leftPath}[${negativeIndex}]`;
-  }
-  const rightPath = buildDotPath(right);
-  if (rightPath) {
-    return `${leftPath}[${rightPath}]`;
-  }
-  return null;
-}
-function buildDotPath(node) {
-  if (typeof node === "string") {
-    return node;
-  }
-  if (!Array.isArray(node) || isLiteralArray(node)) {
-    return null;
-  }
-  const [op, left, right] = node;
-  if (op === ".") {
-    return buildPropertyAccessPath(left, right);
-  }
-  if (op === "[]") {
-    return buildArrayAccessPath(left, right);
-  }
-  return null;
-}
-function isNegativeIndexLiteral(index) {
-  if (!Array.isArray(index) || index[0] !== "-" || index.length !== 2) {
-    return false;
-  }
-  const inner = index[1];
-  return Array.isArray(inner) && isLiteralArray(inner) && typeof inner[1] === "number";
-}
-function detectArrayAccessFeatures(index, features) {
-  if (Array.isArray(index) && isLiteralArray(index)) {
-    if (index[1] === "*") {
-      features.add("array_wildcard");
-    } else if (typeof index[1] === "number") {
-      features.add("array_index");
-    }
-  }
-  if (isNegativeIndexLiteral(index)) {
-    features.add("array_index");
-  }
-}
-function detectFunctionCallFeatures(funcName, features) {
-  if (typeof funcName === "string" && isArrayFunction(funcName)) {
-    features.add("array_function");
-  }
-}
-function detectStringFeatures(node, features) {
-  if (isContextToken(node)) {
-    features.add("context_token");
-  }
-  if (isRootPath(node)) {
-    features.add("root_path");
-    if (node.includes(".")) {
-      features.add("nested_path");
-    }
-  }
-  if (isRelativePath(node)) {
-    features.add("relative_path");
-    const withoutPrefix = node.replace(/^(\.\.\/)+/, "");
-    if (withoutPrefix.includes(".")) {
-      features.add("nested_path");
-    }
-  }
-}
-function detectOperatorFeatures(node, features) {
-  const op = node[0];
-  if (op === ".") {
-    features.add("nested_path");
-  }
-  if (op === "[]") {
-    detectArrayAccessFeatures(node[2], features);
-  }
-  if (op === "()") {
-    detectFunctionCallFeatures(node[1], features);
-  }
-}
-function detectFeatures(node, features) {
-  if (typeof node === "string") {
-    detectStringFeatures(node, features);
-    return;
-  }
-  if (!Array.isArray(node) || isLiteralArray(node)) {
-    return;
-  }
-  detectOperatorFeatures(node, features);
-  for (let i = 1; i < node.length; i++) {
-    detectFeatures(node[i], features);
-  }
-}
-function parseFormula(expression) {
-  const trimmed = expression.trim();
-  if (!trimmed) {
-    throw new Error("Empty expression");
-  }
-  const ast = parse(trimmed);
-  const identifiers = /* @__PURE__ */ new Set();
-  collectIdentifiers(ast, identifiers);
-  const featuresSet = /* @__PURE__ */ new Set();
-  detectFeatures(ast, featuresSet);
-  const features = Array.from(featuresSet);
-  const minVersion = features.length > 0 ? "1.1" : "1.0";
-  return {
-    ast,
-    dependencies: Array.from(identifiers),
-    features,
-    minVersion
-  };
-}
-function validateSyntax(expression) {
-  const trimmed = expression.trim();
-  if (!trimmed) {
-    return { isValid: false, error: "Empty expression" };
-  }
-  try {
-    parse(trimmed);
-    return { isValid: true };
-  } catch (e) {
-    const error = e;
-    const match = /at (\d+):(\d+)/.exec(error.message);
-    const position = match ? Number.parseInt(match[2] ?? "0", 10) - 1 : void 0;
-    return {
-      isValid: false,
-      error: error.message,
-      position
-    };
-  }
-}
-function evaluate(expression, context) {
-  const trimmed = expression.trim();
-  if (!trimmed) {
-    throw new Error("Empty expression");
-  }
-  const fn = subscript_default(trimmed);
-  const safeContext = {};
-  for (const [key, value] of Object.entries(context)) {
-    if (typeof value !== "function") {
-      safeContext[key] = value;
-    }
-  }
-  return fn(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 buildPathReferences(rootData, dependencies) {
-  const refs = {};
-  for (const dep of dependencies) {
-    if (dep.startsWith("/")) {
-      const fieldPath = dep.slice(1);
-      const rootField = fieldPath.split(".")[0] ?? 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 inferPrimitiveType(node, fieldTypes) {
-  if (typeof node === "number") return "number";
-  if (typeof node === "boolean") return "boolean";
-  if (typeof node === "string") return getFieldType(node, fieldTypes);
-  if (node === null) return "unknown";
-  return null;
-}
-function inferLiteralArrayType(node) {
-  const val = node[1];
-  if (typeof val === "number") return "number";
-  if (typeof val === "string") return "string";
-  if (typeof val === "boolean") return "boolean";
-  return "unknown";
-}
-function inferOperatorType(op, argsLength, argTypes) {
-  if (op === "+" && argTypes) {
-    if (argTypes.includes("string")) return "string";
-    if (argTypes.includes("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";
-  if (op === "-" && argsLength === 1) return "number";
-  return null;
-}
-function inferPropertyAccessType(node, fieldTypes) {
-  const path = buildDotPath(node);
-  return path ? getFieldType(path, fieldTypes) : "unknown";
-}
-function inferFunctionCallType(funcName) {
-  if (typeof funcName !== "string") return "unknown";
-  const lowerName = funcName.toLowerCase();
-  if (NUMERIC_FUNCTIONS.has(lowerName)) return "number";
-  if (STRING_FUNCTIONS.has(lowerName)) return "string";
-  if (BOOLEAN_FUNCTIONS.has(lowerName)) return "boolean";
-  return "unknown";
-}
-function inferTypeFromNode(node, fieldTypes) {
-  const primitiveType = inferPrimitiveType(node, fieldTypes);
-  if (primitiveType !== null) return primitiveType;
-  if (!Array.isArray(node)) return "unknown";
-  if (isLiteralArray(node)) return inferLiteralArrayType(node);
-  const [op, ...args] = node;
-  const argTypes = op === "+" ? args.map((arg) => inferTypeFromNode(arg, fieldTypes)) : void 0;
-  const operatorType = inferOperatorType(op, args.length, argTypes);
-  if (operatorType !== null) return operatorType;
-  if (op === "." || op === "[]") {
-    return inferPropertyAccessType(node, fieldTypes);
-  }
-  if (op === "()") {
-    return inferFunctionCallType(args[0]);
-  }
-  return "unknown";
-}
-function inferFormulaType(expression, fieldTypes = {}) {
-  const trimmed = expression.trim();
-  if (!trimmed) {
-    return "unknown";
-  }
-  try {
-    const ast = parse(trimmed);
-    return inferTypeFromNode(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: [] };
-}
-
-exports.buildDependencyGraph = buildDependencyGraph;
-exports.detectCircularDependencies = detectCircularDependencies;
-exports.evaluate = evaluate;
-exports.evaluateWithContext = evaluateWithContext;
-exports.extractSchemaFormulas = extractSchemaFormulas;
-exports.getTopologicalOrder = getTopologicalOrder;
-exports.inferFormulaType = inferFormulaType;
-exports.parseExpression = parseExpression;
-exports.parseFormula = parseFormula;
-exports.validateFormulaAgainstSchema = validateFormulaAgainstSchema;
-exports.validateFormulaSyntax = validateFormulaSyntax;
-exports.validateSchemaFormulas = validateSchemaFormulas;
-exports.validateSyntax = validateSyntax;
-//# sourceMappingURL=chunk-AGBOCJGV.cjs.map
-//# sourceMappingURL=chunk-AGBOCJGV.cjs.map