@rockn/vue-formula-editor 1.0.0

package/dist/engine/index.js

@@ -0,0 +1,1383 @@
+var H = Object.defineProperty;
+var P = (e, t, r) => t in e ? H(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var x = (e, t, r) => P(e, typeof t != "symbol" ? t + "" : t, r);
+const V = ["===", "!=="], _ = ["==", "!=", "<=", ">=", "&&", "||", "**"], Y = "+-*/%<>!?=,():[]";
+function G(e) {
+  return e.replace(
+    /\\u([0-9a-fA-F]{4})/g,
+    (t, r) => String.fromCharCode(parseInt(r, 16))
+  ).replace(/\\(.)/g, (t, r) => r === "n" ? `
+` : r === "t" ? "	" : r === "r" ? "\r" : r);
+}
+function W(e) {
+  const t = [], r = e.length;
+  let n = 0;
+  const s = (i, l, u, m, p = !0) => t.push({ type: i, value: l, start: u, end: m, raw: e.slice(u, m), closed: p });
+  for (; n < r; ) {
+    const i = e[n];
+    if (/\s/.test(i)) {
+      n++;
+      continue;
+    }
+    if (i === "{") {
+      const m = n;
+      let p = n + 1, f = !1;
+      for (; p < r && e[p] !== "}"; ) p++;
+      p < r && (f = !0);
+      const o = e.slice(n + 1, p), N = f ? p + 1 : p;
+      s("variable", o, m, N, f), n = N;
+      continue;
+    }
+    if (/[0-9]/.test(i) || i === "." && /[0-9]/.test(e[n + 1] ?? "")) {
+      const m = /^(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/.exec(e.slice(n));
+      if (m) {
+        s("number", m[0], n, n + m[0].length), n += m[0].length;
+        continue;
+      }
+    }
+    if (i === ".") {
+      s("dot", i, n, n + 1), n++;
+      continue;
+    }
+    if (i === '"' || i === "'") {
+      const m = n, p = i;
+      let f = n + 1, o = !1, N = !1;
+      for (; f < r; ) {
+        const a = e[f];
+        if (N) N = !1;
+        else if (a === "\\") N = !0;
+        else if (a === p) {
+          o = !0, f++;
+          break;
+        } else if (a === `
+`) break;
+        f++;
+      }
+      const g = e.slice(m + 1, o ? f - 1 : f);
+      s("string", o ? G(g) : g, m, f, o), n = f;
+      continue;
+    }
+    if (/[A-Za-z_\u4e00-\u9fa5]/.test(i)) {
+      const m = /^[A-Za-z_\u4e00-\u9fa5][A-Za-z0-9_\u4e00-\u9fa5]*/.exec(e.slice(n));
+      if (m) {
+        s("identifier", m[0], n, n + m[0].length), n += m[0].length;
+        continue;
+      }
+    }
+    const l = e.slice(n, n + 3);
+    if (V.includes(l)) {
+      s("operator", l, n, n + 3), n += 3;
+      continue;
+    }
+    const u = e.slice(n, n + 2);
+    if (_.includes(u)) {
+      s("operator", u, n, n + 2), n += 2;
+      continue;
+    }
+    if (Y.includes(i)) {
+      s(i === "(" ? "lparen" : i === ")" ? "rparen" : i === "[" ? "lbracket" : i === "]" ? "rbracket" : i === "," ? "comma" : i === "?" ? "question" : i === ":" ? "colon" : "operator", i, n, n + 1), n++;
+      continue;
+    }
+    s("error", i, n, n + 1), n++;
+  }
+  return t.push({ type: "eof", value: "", start: r, end: r, raw: "" }), t;
+}
+class E extends Error {
+  constructor(r, n, s) {
+    super(r);
+    x(this, "start");
+    x(this, "end");
+    this.name = "ParseError", this.start = n, this.end = s;
+  }
+}
+const C = {
+  OR: 1,
+  "||": 1,
+  AND: 2,
+  "&&": 2,
+  "==": 3,
+  "!=": 3,
+  "===": 3,
+  "!==": 3,
+  "<": 4,
+  "<=": 4,
+  ">": 4,
+  ">=": 4,
+  "+": 5,
+  "-": 5,
+  "*": 6,
+  "/": 6,
+  "%": 6,
+  "**": 7
+};
+function O(e, ...t) {
+  if (!e || e.type !== "identifier") return !1;
+  for (const r of t)
+    if (e.value === r || /^[A-Za-z]+$/.test(e.value) && /^[A-Za-z]+$/.test(r) && e.value.toUpperCase() === r.toUpperCase())
+      return !0;
+  return !1;
+}
+function K(e) {
+  return O(e, "IF", "如果") && e !== void 0;
+}
+function U(e) {
+  const t = W(e);
+  let r = 0;
+  const n = (a = 0) => t[r + a] ?? t[t.length - 1], s = () => t[r++];
+  function i(a, c) {
+    const b = n();
+    if (b.type !== a) throw new E(c, b.start, b.end);
+    return s();
+  }
+  function l(a = 0) {
+    let c = f();
+    for (; ; ) {
+      const b = n(), h = b.type === "operator" ? b.value : b.type === "identifier" ? b.value.toUpperCase() : void 0;
+      if (h !== void 0 && C[h] !== void 0) {
+        const I = C[h];
+        if (I < a) break;
+        s();
+        const $ = l(h === "**" ? I : I + 1);
+        c = { type: "binary", op: h, left: c, right: $, start: c.start, end: $.end };
+      } else if (b.type === "question" && a === 0) {
+        s();
+        const I = l(0);
+        i("colon", '三元表达式缺少 ":" 分隔符');
+        const $ = l(0);
+        c = {
+          type: "conditional",
+          test: c,
+          consequent: I,
+          alternate: $,
+          start: c.start,
+          end: $.end
+        };
+      } else
+        break;
+    }
+    return c;
+  }
+  function u(a) {
+    const c = [];
+    let b = null;
+    if (n().type === "eof" || O(n(), "THEN", "那么", "ELSE", "否则", "ELSEIF", "否则如果"))
+      throw new E(`IF/如果 后缺少条件表达式（遇到 "${n().raw}"）`, n().start, n().end);
+    let h = l(0);
+    m();
+    let I = l(0);
+    c.push({ condition: h, body: I });
+    let $ = I.end;
+    for (; ; ) {
+      const d = n();
+      if (O(d, "ELSE", "否则", "ELSEIF", "否则如果")) {
+        if (s(), O(d, "ELSEIF", "否则如果") || O(n(), "IF", "如果") && n(1).type !== "lparen") {
+          if (O(d, "ELSEIF", "否则如果") || s(), n().type === "eof" || O(n(), "THEN", "那么", "ELSE", "否则", "ELSEIF", "否则如果"))
+            throw new E(`ELSE IF/否则如果 后缺少条件表达式（遇到 "${n().raw}"）`, n().start, n().end);
+          h = l(0), m(), I = l(0), c.push({ condition: h, body: I }), $ = I.end;
+          continue;
+        }
+        if (n().type === "eof")
+          throw new E("ELSE/否则 后缺少表达式", d.start, d.end);
+        b = l(0), $ = b.end;
+        break;
+      }
+      break;
+    }
+    return { type: "if", branches: c, elseBody: b, start: a.start, end: $ };
+  }
+  function m() {
+    const a = n();
+    if (!O(a, "THEN", "那么"))
+      throw new E(
+        `IF 条件后缺少 "THEN/那么"（遇到 "${a.raw}"，块状 IF 写法：IF 条件 THEN 真值 ELSE 假值）`,
+        a.start,
+        a.end
+      );
+    s();
+  }
+  function p(a) {
+    let c = a;
+    for (; ; ) {
+      const b = n();
+      if (b.type === "dot") {
+        s();
+        const h = n();
+        if (h.type !== "identifier")
+          throw new E(`"." 后应为成员名，遇到 "${h.raw}"`, h.start, h.end);
+        s(), c = { type: "member", object: c, prop: h.value, index: null, start: c.start, end: h.end };
+        continue;
+      }
+      if (b.type === "lbracket") {
+        s();
+        const h = l(0), I = i("rbracket", '缺少右括号 "]"');
+        h.type === "string" ? c = { type: "member", object: c, prop: h.value, index: null, start: c.start, end: I.end } : c = { type: "member", object: c, prop: "", index: h, start: c.start, end: I.end };
+        continue;
+      }
+      break;
+    }
+    return c;
+  }
+  function f() {
+    const a = n();
+    if (a.type === "operator" && (a.value === "-" || a.value === "+" || a.value === "!")) {
+      s();
+      const c = f();
+      return { type: "unary", op: a.value, operand: c, start: a.start, end: c.end };
+    }
+    return p(o());
+  }
+  function o() {
+    const a = n();
+    if (a.type === "number")
+      return s(), { type: "number", value: parseFloat(a.value), start: a.start, end: a.end };
+    if (a.type === "string") {
+      if (s(), !a.closed) throw new E(`字符串未闭合（缺少 ${a.raw[0] ?? "引号"}）`, a.start, a.end);
+      return { type: "string", value: a.value, start: a.start, end: a.end };
+    }
+    if (a.type === "variable") {
+      if (s(), !a.closed) throw new E('变量缺少结束符 "}"', a.start, a.end);
+      if (!a.value.trim()) throw new E("变量名不能为空，例如 {订单金额}", a.start, a.end);
+      return { type: "variable", name: a.value.trim(), start: a.start, end: a.end };
+    }
+    if (a.type === "identifier") {
+      s();
+      const c = a.value.toLowerCase();
+      if (c === "true" || c === "false")
+        return { type: "boolean", value: c === "true", start: a.start, end: a.end };
+      if (c === "null" || c === "undefined") return { type: "null", start: a.start, end: a.end };
+      if (K(a) && n().type !== "lparen")
+        return u(a);
+      if (O(a, "THEN", "那么"))
+        throw new E('意外的 "THEN/那么"（缺少与之配对的 IF？）', a.start, a.end);
+      if (O(a, "ELSE", "否则", "ELSEIF", "否则如果"))
+        throw new E('意外的 "ELSE/否则"（缺少与之配对的 IF？）', a.start, a.end);
+      if (n().type === "lparen") {
+        s();
+        const b = [];
+        if (n().type !== "rparen")
+          for (b.push(l(0)); n().type === "comma"; )
+            s(), b.push(l(0));
+        const h = i("rparen", `函数 ${a.value}() 缺少右括号 ")"`);
+        return { type: "call", name: a.value, args: b, start: a.start, end: h.end };
+      }
+      throw new E(
+        `无法识别的标识符 "${a.value}"（变量请用 {名称} 引用；函数需要括号调用）`,
+        a.start,
+        a.end
+      );
+    }
+    if (a.type === "lparen") {
+      s();
+      const c = l(0);
+      return i("rparen", '缺少右括号 ")"'), c;
+    }
+    throw a.type === "eof" ? new E("表达式不完整，结尾缺少操作数", a.start, a.end) : a.type === "operator" && a.value === "=" ? new E('单个 "=" 不能用于比较，请使用 "==" 或 "==="', a.start, a.end) : a.type === "operator" && (a.value === ")" || a.value === "]") ? new E(`多余的 "${a.value}"`, a.start, a.end) : a.type === "rbracket" ? new E('多余的 "]"', a.start, a.end) : a.type === "dot" ? new E('"." 前缺少被访问的表达式', a.start, a.end) : a.type === "comma" ? new E('多余的逗号 ","', a.start, a.end) : new E(`意外的符号 "${a.raw}"`, a.start, a.end);
+  }
+  const N = l(0), g = n();
+  if (g.type !== "eof")
+    throw g.type === "operator" && g.value === "=" ? new E('单个 "=" 不能用于比较，请使用 "==" 或 "==="', g.start, g.end) : new E(`意外的符号 "${g.raw}"（表达式已结束）`, g.start, g.end);
+  return N;
+}
+class y extends Error {
+  constructor(r, n, s) {
+    super(r);
+    x(this, "start");
+    x(this, "end");
+    this.name = "RuntimeError", this.start = n, this.end = s;
+  }
+}
+function q(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const r of e ?? []) {
+    if (r.type !== "enum" || !r.options) continue;
+    const n = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Map();
+    for (const l of r.options) {
+      const u = typeof l == "string" ? { label: l, value: l } : l;
+      n.add(u.label), s.add(u.value), i.set(u.label, u.value);
+    }
+    t.set(r.name, { labels: n, values: s, labelToValue: i });
+  }
+  return { byName: t };
+}
+function w(e) {
+  return e == null ? "空值 NULL" : typeof e == "number" ? `数字 ${e}` : typeof e == "string" ? `字符串 "${e.length > 12 ? e.slice(0, 12) + "…" : e}"` : typeof e == "boolean" ? `布尔值 ${e}` : Array.isArray(e) ? `数组(${e.length} 项)` : typeof e == "object" ? `对象(${Object.keys(e).length} 个键)` : "其他";
+}
+function M(e, t) {
+  if (typeof e == "number" && !Number.isNaN(e)) return e;
+  throw new y(`${t} 需要数字，实际为 ${w(e)}`, 0, 0);
+}
+function S(e, t, r) {
+  if (typeof e == "number" && !Number.isNaN(e)) return e;
+  if (typeof e == "string" && e.trim() !== "" && !Number.isNaN(Number(e))) return Number(e);
+  throw new y(
+    `函数 ${t}() 的第 ${r + 1} 个参数需要数字，实际为 ${w(e)}`,
+    0,
+    0
+  );
+}
+function k(e) {
+  return typeof e == "number" && !Number.isNaN(e) ? e : typeof e == "string" && e.trim() !== "" && !Number.isNaN(Number(e)) ? Number(e) : 0;
+}
+function R(e, t) {
+  if (e === t) return !0;
+  if (e == null || t === null || t === void 0) return !1;
+  if (typeof e == "boolean" && (e = e ? 1 : 0), typeof t == "boolean" && (t = t ? 1 : 0), typeof e == "number" && typeof t == "string") {
+    const r = Number(t);
+    return !Number.isNaN(r) && e === r;
+  }
+  if (typeof t == "number" && typeof e == "string") {
+    const r = Number(e);
+    return !Number.isNaN(r) && r === t;
+  }
+  return !1;
+}
+function X(e, t, r, n, s, i) {
+  const l = (u, m) => s ? Object.is(u, m) : R(u, m);
+  if (e.type === "variable") {
+    const u = i.byName.get(e.name);
+    if (u) {
+      const m = u.labelToValue.has(String(r)) ? u.labelToValue.get(String(r)) : r;
+      let p = n;
+      return typeof n == "string" && u.labelToValue.has(n) && (p = u.labelToValue.get(n)), l(m, p);
+    }
+  }
+  if (t.type === "variable") {
+    const u = i.byName.get(t.name);
+    if (u) {
+      const m = u.labelToValue.has(String(n)) ? u.labelToValue.get(String(n)) : n;
+      let p = r;
+      return typeof r == "string" && u.labelToValue.has(r) && (p = u.labelToValue.get(r)), l(p, m);
+    }
+  }
+  return null;
+}
+function z(e, t, r) {
+  let n, s;
+  if (typeof t == "number" && typeof r == "number")
+    n = t, s = r;
+  else if (typeof t == "string" && typeof r == "string")
+    n = t, s = r;
+  else {
+    const i = typeof t == "boolean" ? t ? 1 : 0 : typeof t == "string" ? Number(t) : t, l = typeof r == "boolean" ? r ? 1 : 0 : typeof r == "string" ? Number(r) : r;
+    if (typeof i == "number" && !Number.isNaN(i) || typeof l == "number" && !Number.isNaN(l))
+      if (typeof i == "number" && typeof l == "number" && !Number.isNaN(i) && !Number.isNaN(l))
+        n = i, s = l;
+      else
+        throw new y(`无法比较 ${w(t)} 与 ${w(r)}`, 0, 0);
+    else
+      throw new y(`无法比较 ${w(t)} 与 ${w(r)}`, 0, 0);
+  }
+  switch (e) {
+    case "<":
+      return n < s;
+    case "<=":
+      return n <= s;
+    case ">":
+      return n > s;
+    case ">=":
+      return n >= s;
+    default:
+      return !1;
+  }
+}
+function Z(e, t) {
+  return e === t ? `${e}` : t === 1 / 0 ? `至少 ${e}` : `${e}~${t}`;
+}
+function J(e, t, r, n) {
+  const s = A(e.object, t, r, n);
+  let i;
+  if (e.index !== null ? i = A(e.index, t, r, n) : i = e.prop, s == null)
+    throw new y(`无法访问 ${String(i)}：左侧是 ${w(s)}`, e.start, e.end);
+  if (Array.isArray(s)) {
+    const l = typeof i == "number" ? i : Number(i);
+    if (!Number.isInteger(l) || l < 0 || l >= s.length)
+      throw new y(`数组下标 ${String(i)} 越界（长度 ${s.length}）`, e.start, e.end);
+    return s[l];
+  }
+  if (typeof s == "object") {
+    const l = String(i);
+    if (!(l in s))
+      throw new y(`对象中不存在字段 "${l}"`, e.start, e.end);
+    return s[l];
+  }
+  throw new y(`无法访问 ${String(i)}：${w(s)} 不是对象或数组`, e.start, e.end);
+}
+function Q(e, t, r = {}, n) {
+  return A(e, t, r, q(n));
+}
+function A(e, t, r, n) {
+  switch (e.type) {
+    case "number":
+      return e.value;
+    case "string":
+      return e.value;
+    case "boolean":
+      return e.value;
+    case "null":
+      return null;
+    case "variable": {
+      if (!(e.name in t))
+        throw new y(
+          `变量 {${e.name}} 未定义，请先在测试值中填写`,
+          e.start,
+          e.end
+        );
+      return t[e.name];
+    }
+    case "member":
+      return J(e, t, r, n);
+    case "unary": {
+      const s = A(e.operand, t, r, n);
+      if (e.op === "!") return !s;
+      if (e.op === "-") return -M(s, '一元 "-"');
+      if (e.op === "+") return +M(s, '一元 "+"');
+      throw new y(`未知一元运算符 "${e.op}"`, e.start, e.end);
+    }
+    case "binary": {
+      if (e.op === "&&" || e.op === "AND")
+        return A(e.left, t, r, n) ? !!A(e.right, t, r, n) : !1;
+      if (e.op === "||" || e.op === "OR")
+        return A(e.left, t, r, n) ? !0 : !!A(e.right, t, r, n);
+      if (e.op === "==" || e.op === "!=" || e.op === "===" || e.op === "!==") {
+        const l = A(e.left, t, r, n), u = A(e.right, t, r, n), m = e.op === "===" || e.op === "!==", p = e.op === "!=" || e.op === "!==", f = X(e.left, e.right, l, u, m, n), o = f !== null ? f : m ? Object.is(l, u) : R(l, u);
+        return p ? !o : o;
+      }
+      const s = A(e.left, t, r, n), i = A(e.right, t, r, n);
+      switch (e.op) {
+        case "<":
+        case "<=":
+        case ">":
+        case ">=":
+          return z(e.op, s, i);
+        case "+": {
+          if (typeof s == "string" || typeof i == "string") return String(s) + String(i);
+          if (typeof s == "number" && typeof i == "number") return s + i;
+          throw new y(
+            `"+" 需要数字或字符串操作数，得到 ${w(s)} 与 ${w(i)}`,
+            e.start,
+            e.end
+          );
+        }
+        case "-":
+        case "*":
+        case "/":
+        case "%":
+        case "**": {
+          if (typeof s != "number" || typeof i != "number")
+            throw new y(
+              `"${e.op}" 需要数字操作数，得到 ${w(s)} 与 ${w(i)}`,
+              e.start,
+              e.end
+            );
+          if (e.op === "/" && i === 0)
+            throw new y("除法运算中除数不能为 0", e.start, e.end);
+          if (e.op === "%" && i === 0)
+            throw new y("取余运算中除数不能为 0", e.start, e.end);
+          switch (e.op) {
+            case "-":
+              return s - i;
+            case "*":
+              return s * i;
+            case "/":
+              return s / i;
+            case "%":
+              return s % i;
+            case "**":
+              return Math.pow(s, i);
+            default:
+              throw new y(`未知运算符 "${e.op}"`, e.start, e.end);
+          }
+        }
+        default:
+          throw new y(`未知运算符 "${e.op}"`, e.start, e.end);
+      }
+    }
+    case "conditional": {
+      const s = A(e.test, t, r, n);
+      return A(s ? e.consequent : e.alternate, t, r, n);
+    }
+    case "if": {
+      for (const s of e.branches)
+        if (A(s.condition, t, r, n)) return A(s.body, t, r, n);
+      return e.elseBody ? A(e.elseBody, t, r, n) : null;
+    }
+    case "call": {
+      const s = e.name, i = r[s], l = F[s];
+      if (!i && !l)
+        throw new y(
+          `未知函数 ${s}()（内置函数：${Object.keys(F).join("、")}）`,
+          e.start,
+          e.end
+        );
+      if (s === "IF") {
+        if (e.args.length !== 3)
+          throw new y(
+            `函数 IF() 需要 3 个参数：IF(条件, 真值, 假值)，实际 ${e.args.length} 个`,
+            e.start,
+            e.end
+          );
+        const m = A(e.args[0], t, r, n);
+        return A(m ? e.args[1] : e.args[2], t, r, n);
+      }
+      if (s === "IFS") {
+        if (e.args.length < 3)
+          throw new y(
+            "函数 IFS() 至少需要 3 个参数：IFS(条件1, 值1, 条件2, 值2, …, 默认值)",
+            e.start,
+            e.end
+          );
+        const m = e.args.length, p = (m - 1) / 2;
+        if (!Number.isInteger(p))
+          throw new y(
+            "函数 IFS() 参数应为“成对的条件/值”，最后可跟一个默认值",
+            e.start,
+            e.end
+          );
+        for (let f = 0; f < p; f++)
+          if (A(e.args[f * 2], t, r, n)) return A(e.args[f * 2 + 1], t, r, n);
+        return A(e.args[m - 1], t, r, n);
+      }
+      const u = e.args.map((m) => A(m, t, r, n));
+      if (l) {
+        if (u.length < l.minArgs || u.length > l.maxArgs)
+          throw new y(
+            `函数 ${s}() 需要 ${Z(l.minArgs, l.maxArgs)} 个参数，实际 ${u.length} 个`,
+            e.start,
+            e.end
+          );
+        return l.fn(u);
+      }
+      return i(u);
+    }
+    default: {
+      const s = e;
+      throw new y("无法求值的表达式", s.start, s.end);
+    }
+  }
+}
+function ee(e) {
+  return e == null ? "" : String(e);
+}
+function B(e, t, r) {
+  if (Array.isArray(e)) return e;
+  throw new y(`函数 ${t}() 的第 ${r + 1} 个参数需要数组，实际为 ${w(e)}`, 0, 0);
+}
+function j(e, t, r) {
+  if (e !== null && typeof e == "object" && !Array.isArray(e)) return e;
+  throw new y(`函数 ${t}() 的第 ${r + 1} 个参数需要对象，实际为 ${w(e)}`, 0, 0);
+}
+const F = {
+  /* ---------- 逻辑 ---------- */
+  IF: {
+    name: "IF",
+    signature: "IF(条件, 真值, 假值)",
+    description: "条件判断：条件成立返回真值，否则返回假值（短路求值）。",
+    minArgs: 3,
+    maxArgs: 3,
+    params: ["条件：布尔表达式", "真值：条件成立时返回", "假值：条件不成立时返回"],
+    example: "IF({年龄} >= 18, '成年', '未成年')",
+    fn: () => null
+    // 在 evaluate 中特判
+  },
+  IFS: {
+    name: "IFS",
+    signature: "IFS(条件1, 值1, 条件2, 值2, …, 默认值)",
+    description: "多级条件判断：依次判断，命中即返回对应值；都不命中返回默认值。",
+    minArgs: 3,
+    maxArgs: 1 / 0,
+    params: ["条件/值成对出现", "…", "默认值（可选）"],
+    example: "IFS({等级} == '黑金', 0.8, {等级} == '金卡', 0.85, 1)",
+    fn: () => null
+  },
+  AND: {
+    name: "AND",
+    signature: "AND(条件1, 条件2, …)",
+    description: "逻辑与：全部为真才返回 true。",
+    minArgs: 1,
+    maxArgs: 1 / 0,
+    params: ["条件：布尔表达式，至少 1 个"],
+    example: "AND({金额} > 100, {包邮})",
+    fn: (e) => e.every(Boolean)
+  },
+  OR: {
+    name: "OR",
+    signature: "OR(条件1, 条件2, …)",
+    description: "逻辑或：任一为真即返回 true。",
+    minArgs: 1,
+    maxArgs: 1 / 0,
+    params: ["条件：布尔表达式，至少 1 个"],
+    example: "OR({等级} == '金卡', {等级} == '黑金')",
+    fn: (e) => e.some(Boolean)
+  },
+  NOT: {
+    name: "NOT",
+    signature: "NOT(条件)",
+    description: "逻辑非：取反。",
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["条件：布尔表达式"],
+    example: "NOT({包邮})",
+    fn: (e) => !e[0]
+  },
+  IFNULL: {
+    name: "IFNULL",
+    signature: "IFNULL(值, 兜底值)",
+    description: "值为 NULL / 未定义时返回兜底值，否则返回值本身。",
+    minArgs: 2,
+    maxArgs: 2,
+    params: ["值：待判断的值", "兜底值：为空时返回"],
+    example: "IFNULL({优惠券码}, '无优惠')",
+    fn: (e) => e[0] === null || e[0] === void 0 ? e[1] : e[0]
+  },
+  COALESCE: {
+    name: "COALESCE",
+    signature: "COALESCE(值1, 值2, …)",
+    description: "返回第一个非 NULL 的值；全部为空返回 NULL。",
+    minArgs: 1,
+    maxArgs: 1 / 0,
+    params: ["值列表：从前往后取第一个非空"],
+    example: "COALESCE({备注}, {优惠券码}, '无')",
+    fn: (e) => {
+      for (const t of e) if (t != null) return t;
+      return null;
+    }
+  },
+  SWITCH: {
+    name: "SWITCH",
+    signature: "SWITCH(值, 情况1, 结果1, …, 默认值)",
+    description: "按值匹配：与某个情况相等则返回对应结果；都不匹配返回默认值（可选）。",
+    minArgs: 2,
+    maxArgs: 1 / 0,
+    params: ["值：待匹配值", "情况/结果成对出现", "…", "默认值（可选）"],
+    example: "SWITCH({会员等级}, '金卡', 0.85, '黑金', 0.8, 1)",
+    fn: (e) => {
+      const t = e[0], r = e.slice(1), n = Math.floor(r.length / 2);
+      for (let s = 0; s < n; s++)
+        if (R(t, r[s * 2])) return r[s * 2 + 1];
+      return r.length % 2 === 1 ? r[r.length - 1] : null;
+    }
+  },
+  /* ---------- 数字 ---------- */
+  ABS: {
+    name: "ABS",
+    signature: "ABS(数字)",
+    description: "取绝对值。",
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["数字"],
+    example: "ABS(-9)",
+    fn: (e) => Math.abs(S(e[0], "ABS", 0))
+  },
+  ROUND: {
+    name: "ROUND",
+    signature: "ROUND(数字[, 小数位])",
+    description: "四舍五入到指定小数位（默认 0 位）。",
+    minArgs: 1,
+    maxArgs: 2,
+    params: ["数字", "小数位（可选，默认 0）"],
+    example: "ROUND(3.14159, 2)",
+    fn: (e) => {
+      const t = S(e[0], "ROUND", 0), r = e.length > 1 ? S(e[1], "ROUND", 1) : 0, n = Math.pow(10, r);
+      return Math.round(t * n) / n;
+    }
+  },
+  FLOOR: {
+    name: "FLOOR",
+    signature: "FLOOR(数字)",
+    description: "向下取整。",
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["数字"],
+    example: "FLOOR(3.7)",
+    fn: (e) => Math.floor(S(e[0], "FLOOR", 0))
+  },
+  CEIL: {
+    name: "CEIL",
+    signature: "CEIL(数字)",
+    description: "向上取整。",
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["数字"],
+    example: "CEIL(3.2)",
+    fn: (e) => Math.ceil(S(e[0], "CEIL", 0))
+  },
+  MIN: {
+    name: "MIN",
+    signature: "MIN(数字1, 数字2, …)",
+    description: "取最小值。",
+    minArgs: 1,
+    maxArgs: 1 / 0,
+    params: ["数字列表"],
+    example: "MIN({金额}, 100)",
+    fn: (e) => Math.min(...e.map((t, r) => S(t, "MIN", r)))
+  },
+  MAX: {
+    name: "MAX",
+    signature: "MAX(数字1, 数字2, …)",
+    description: "取最大值。",
+    minArgs: 1,
+    maxArgs: 1 / 0,
+    params: ["数字列表"],
+    example: "MAX({金额}, 0)",
+    fn: (e) => Math.max(...e.map((t, r) => S(t, "MAX", r)))
+  },
+  SUM: {
+    name: "SUM",
+    signature: "SUM(数字1, 数字2, …)",
+    description: "求数值总和（忽略非数字参数）。",
+    minArgs: 1,
+    maxArgs: 1 / 0,
+    params: ["数字列表（可引用数组变量）"],
+    example: "SUM(1, 2, 3)",
+    fn: (e) => e.reduce((t, r) => t + k(r), 0)
+  },
+  AVERAGE: {
+    name: "AVERAGE",
+    signature: "AVERAGE(数字1, 数字2, …)",
+    description: "求数值平均值（忽略非数字参数）。",
+    minArgs: 1,
+    maxArgs: 1 / 0,
+    params: ["数字列表"],
+    example: "AVERAGE(2, 4, 6)",
+    fn: (e) => {
+      const t = [];
+      for (const r of e)
+        typeof r == "number" ? t.push(r) : typeof r == "string" && r.trim() !== "" && !Number.isNaN(Number(r)) && t.push(Number(r));
+      return t.length ? t.reduce((r, n) => r + n, 0) / t.length : 0;
+    }
+  },
+  /* ---------- 文本 ---------- */
+  CONCAT: {
+    name: "CONCAT",
+    signature: "CONCAT(文本1, 文本2, …)",
+    description: "拼接多个值为一个字符串。",
+    minArgs: 1,
+    maxArgs: 1 / 0,
+    params: ["值列表（非文本会转成字符串）"],
+    example: "CONCAT('订单#', {订单编号})",
+    fn: (e) => e.map((t) => String(t ?? "")).join("")
+  },
+  LEN: {
+    name: "LEN",
+    signature: "LEN(文本)",
+    description: "返回文本长度（按字符数）。",
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["文本"],
+    example: "LEN('你好abc')",
+    fn: (e) => String(e[0] ?? "").length
+  },
+  UPPER: {
+    name: "UPPER",
+    signature: "UPPER(文本)",
+    description: "转大写。",
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["文本"],
+    example: "UPPER('ab')",
+    fn: (e) => String(e[0] ?? "").toUpperCase()
+  },
+  LOWER: {
+    name: "LOWER",
+    signature: "LOWER(文本)",
+    description: "转小写。",
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["文本"],
+    example: "LOWER('AB')",
+    fn: (e) => String(e[0] ?? "").toLowerCase()
+  },
+  TRIM: {
+    name: "TRIM",
+    signature: "TRIM(文本)",
+    description: "去除首尾空白。",
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["文本"],
+    example: "TRIM('  hi  ')",
+    fn: (e) => String(e[0] ?? "").trim()
+  },
+  SUBSTR: {
+    name: "SUBSTR",
+    signature: "SUBSTR(文本, 起始下标[, 长度])",
+    description: '截取子串（0 起始，如 SUBSTR("hello", 1, 3) = "ell"）。',
+    minArgs: 2,
+    maxArgs: 3,
+    params: ["文本", "起始下标（0 起始）", "长度（可选）"],
+    example: "SUBSTR('hello', 1, 3)",
+    fn: (e) => {
+      const t = String(e[0] ?? ""), r = S(e[1], "SUBSTR", 1), n = e.length > 2 ? S(e[2], "SUBSTR", 2) : void 0;
+      return n === void 0 ? t.slice(r) : t.slice(r, r + n);
+    }
+  },
+  MID: {
+    name: "MID",
+    signature: "MID(文本, 起始位, 长度)",
+    description: 'Excel 风格截取（1 起始，如 MID("hello", 2, 3) = "ell"）。',
+    minArgs: 3,
+    maxArgs: 3,
+    params: ["文本", "起始位（1 起始）", "长度"],
+    example: "MID('hello', 2, 3)",
+    fn: (e) => {
+      const t = String(e[0] ?? ""), r = S(e[1], "MID", 1), n = S(e[2], "MID", 2);
+      return t.slice(r - 1, r - 1 + n);
+    }
+  },
+  LEFT: {
+    name: "LEFT",
+    signature: "LEFT(文本, 长度)",
+    description: "取左侧 N 个字符。",
+    minArgs: 2,
+    maxArgs: 2,
+    params: ["文本", "长度"],
+    example: "LEFT('hello', 2)",
+    fn: (e) => String(e[0] ?? "").slice(0, S(e[1], "LEFT", 1))
+  },
+  RIGHT: {
+    name: "RIGHT",
+    signature: "RIGHT(文本, 长度)",
+    description: "取右侧 N 个字符。",
+    minArgs: 2,
+    maxArgs: 2,
+    params: ["文本", "长度"],
+    example: "RIGHT('hello', 2)",
+    fn: (e) => String(e[0] ?? "").slice(-S(e[1], "RIGHT", 1))
+  },
+  CONTAINS: {
+    name: "CONTAINS",
+    signature: "CONTAINS(文本, 子串)",
+    description: "文本是否包含子串（大小写敏感）。",
+    minArgs: 2,
+    maxArgs: 2,
+    params: ["文本", "子串"],
+    example: "CONTAINS({优惠券码}, 'FM')",
+    fn: (e) => String(e[0] ?? "").includes(String(e[1] ?? ""))
+  },
+  STARTSWITH: {
+    name: "STARTSWITH",
+    signature: "STARTSWITH(文本, 前缀)",
+    description: "文本是否以指定前缀开头。",
+    minArgs: 2,
+    maxArgs: 2,
+    params: ["文本", "前缀"],
+    example: "STARTSWITH({订单编号}, 'A')",
+    fn: (e) => String(e[0] ?? "").startsWith(String(e[1] ?? ""))
+  },
+  ENDSWITH: {
+    name: "ENDSWITH",
+    signature: "ENDSWITH(文本, 后缀)",
+    description: "文本是否以指定后缀结尾。",
+    minArgs: 2,
+    maxArgs: 2,
+    params: ["文本", "后缀"],
+    example: "ENDSWITH({订单编号}, '8')",
+    fn: (e) => String(e[0] ?? "").endsWith(String(e[1] ?? ""))
+  },
+  INDEXOF: {
+    name: "INDEXOF",
+    signature: "INDEXOF(文本, 子串[, 起始下标])",
+    description: "返回子串首次出现的位置（0 起始），未找到返回 -1。",
+    minArgs: 2,
+    maxArgs: 3,
+    params: ["文本", "子串", "起始下标（可选，默认 0）"],
+    example: "INDEXOF('hello', 'l')",
+    fn: (e) => {
+      const t = String(e[0] ?? ""), r = String(e[1] ?? ""), n = e.length > 2 ? S(e[2], "INDEXOF", 2) : 0;
+      return t.indexOf(r, n);
+    }
+  },
+  REPLACE: {
+    name: "REPLACE",
+    signature: "REPLACE(文本, 被替换, 替换为)",
+    description: "把文本中所有匹配的子串替换为新内容。",
+    minArgs: 3,
+    maxArgs: 3,
+    params: ["文本", "被替换的子串", "替换为"],
+    example: "REPLACE('a-b-c', '-', '/')",
+    fn: (e) => String(e[0] ?? "").split(String(e[1] ?? "")).join(String(e[2] ?? ""))
+  },
+  SPLIT: {
+    name: "SPLIT",
+    signature: "SPLIT(文本, 分隔符)",
+    description: "按分隔符拆分为数组。",
+    minArgs: 2,
+    maxArgs: 2,
+    params: ["文本", "分隔符"],
+    example: "SPLIT('a,b,c', ',')",
+    fn: (e) => String(e[0] ?? "").split(String(e[1] ?? ""))
+  },
+  /* ---------- 类型转换 ---------- */
+  TOSTRING: {
+    name: "TOSTRING",
+    signature: "TOSTRING(值)",
+    description: "转字符串（NULL 转空串）。",
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["值"],
+    example: "TOSTRING({金额})",
+    fn: (e) => ee(e[0])
+  },
+  TONUMBER: {
+    name: "TONUMBER",
+    signature: "TONUMBER(值)",
+    description: "转数字；无法转换时报错。",
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["值（数字或数字字符串）"],
+    example: "TONUMBER('42')",
+    fn: (e) => S(e[0], "TONUMBER", 0)
+  },
+  TOBOOLEAN: {
+    name: "TOBOOLEAN",
+    signature: "TOBOOLEAN(值)",
+    description: '转布尔：布尔原样；数字非 0 为 true；字符串 "true"/"false"（大小写不敏感）转换，其他为 true（非空）。',
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["值"],
+    example: "TOBOOLEAN('true')",
+    fn: (e) => {
+      const t = e[0];
+      if (typeof t == "boolean") return t;
+      if (typeof t == "number") return t !== 0;
+      if (typeof t == "string") {
+        const r = t.trim().toLowerCase();
+        return r === "true" ? !0 : r === "false" ? !1 : t.trim() !== "";
+      }
+      return t != null;
+    }
+  },
+  /* ---------- 日期 ---------- */
+  NOW: {
+    name: "NOW",
+    signature: "NOW()",
+    description: "返回当前时间戳（毫秒）。",
+    minArgs: 0,
+    maxArgs: 0,
+    params: [],
+    example: "NOW()",
+    fn: () => Date.now()
+  },
+  TODAY: {
+    name: "TODAY",
+    signature: "TODAY()",
+    description: "返回今天零点的时间戳（毫秒）。",
+    minArgs: 0,
+    maxArgs: 0,
+    params: [],
+    example: "TODAY()",
+    fn: () => {
+      const e = /* @__PURE__ */ new Date();
+      return e.setHours(0, 0, 0, 0), e.getTime();
+    }
+  },
+  DATEADD: {
+    name: "DATEADD",
+    signature: "DATEADD(时间戳, 天数)",
+    description: "时间戳加 N 天，返回新时间戳。",
+    minArgs: 2,
+    maxArgs: 2,
+    params: ["时间戳（毫秒）", "天数（可为负）"],
+    example: "DATEADD(TODAY(), 7)",
+    fn: (e) => {
+      const t = S(e[0], "DATEADD", 0), r = S(e[1], "DATEADD", 1);
+      return t + r * 864e5;
+    }
+  },
+  DATEDIF: {
+    name: "DATEDIF",
+    signature: "DATEDIF(起始时间戳, 结束时间戳)",
+    description: "两个时间戳相隔的整天数。",
+    minArgs: 2,
+    maxArgs: 2,
+    params: ["起始时间戳", "结束时间戳"],
+    example: "DATEDIF(TODAY(), DATEADD(TODAY(), 3))",
+    fn: (e) => {
+      const t = S(e[0], "DATEDIF", 0), r = S(e[1], "DATEDIF", 1);
+      return Math.round((r - t) / 864e5);
+    }
+  },
+  /* ---------- 判断 ---------- */
+  ISNULL: {
+    name: "ISNULL",
+    signature: "ISNULL(值)",
+    description: "是否为空值（NULL / 未定义）。",
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["值"],
+    example: "ISNULL({备注})",
+    fn: (e) => e[0] === null || e[0] === void 0
+  },
+  ISEMPTY: {
+    name: "ISEMPTY",
+    signature: "ISEMPTY(值)",
+    description: "是否为空（NULL、空字符串、空数组/对象均视为空）。",
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["值"],
+    example: "ISEMPTY({优惠券码})",
+    fn: (e) => {
+      const t = e[0];
+      return t == null ? !0 : typeof t == "string" ? t.trim() === "" : Array.isArray(t) ? t.length === 0 : typeof t == "object" ? Object.keys(t).length === 0 : !1;
+    }
+  },
+  ISNUMERIC: {
+    name: "ISNUMERIC",
+    signature: "ISNUMERIC(值)",
+    description: "是否为数字（含可转换的数字字符串）。",
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["值"],
+    example: "ISNUMERIC('42')",
+    fn: (e) => {
+      const t = e[0];
+      return typeof t == "number" ? !Number.isNaN(t) : typeof t == "string" ? t.trim() !== "" && !Number.isNaN(Number(t)) : !1;
+    }
+  },
+  BETWEEN: {
+    name: "BETWEEN",
+    signature: "BETWEEN(值, 下限, 上限)",
+    description: "值是否在 [下限, 上限] 区间内（含边界）。",
+    minArgs: 3,
+    maxArgs: 3,
+    params: ["值", "下限", "上限"],
+    example: "BETWEEN({重量}, 1, 5)",
+    fn: (e) => {
+      const t = S(e[0], "BETWEEN", 0), r = S(e[1], "BETWEEN", 1), n = S(e[2], "BETWEEN", 2);
+      return t >= r && t <= n;
+    }
+  },
+  /* ---------- 数组 / 对象 ---------- */
+  COUNT: {
+    name: "COUNT",
+    signature: "COUNT(数组)",
+    description: "返回数组长度；空值返回 0。",
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["数组"],
+    example: "COUNT({商品列表})",
+    fn: (e) => Array.isArray(e[0]) ? e[0].length : 0
+  },
+  COUNTIF: {
+    name: "COUNTIF",
+    signature: "COUNTIF(数组, 目标值)",
+    description: "统计数组中与目标值相等的元素个数（宽松比较）。",
+    minArgs: 2,
+    maxArgs: 2,
+    params: ["数组", "目标值"],
+    example: "COUNTIF({地区列表}, '华东')",
+    fn: (e) => B(e[0], "COUNTIF", 0).filter((r) => R(r, e[1])).length
+  },
+  SUMIF: {
+    name: "SUMIF",
+    signature: "SUMIF(数组, 目标值)",
+    description: "对数组中与目标值相等的数字元素求和（宽松比较，忽略非数字）。",
+    minArgs: 2,
+    maxArgs: 2,
+    params: ["数组", "目标值"],
+    example: "SUMIF({价格列表}, 10)",
+    fn: (e) => B(e[0], "SUMIF", 0).reduce((r, n) => R(n, e[1]) ? r + k(n) : r, 0)
+  },
+  KEYS: {
+    name: "KEYS",
+    signature: "KEYS(对象)",
+    description: "返回对象的键名数组。",
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["对象（键值对变量）"],
+    example: "KEYS({订单})",
+    fn: (e) => Object.keys(j(e[0], "KEYS", 0))
+  },
+  VALUES: {
+    name: "VALUES",
+    signature: "VALUES(对象)",
+    description: "返回对象的键值数组。",
+    minArgs: 1,
+    maxArgs: 1,
+    params: ["对象（键值对变量）"],
+    example: "VALUES({订单})",
+    fn: (e) => Object.values(j(e[0], "VALUES", 0))
+  }
+}, D = 2;
+function L(e, t, r) {
+  return r.slice(e.end, t.start).trim();
+}
+function T(e, t, r) {
+  switch (e.type) {
+    case "if":
+      return te(e, t, r);
+    case "number":
+    case "string":
+    case "boolean":
+    case "null":
+    case "variable":
+      return t.slice(e.start, e.end).trim();
+    case "member": {
+      const n = T(e.object, t, r);
+      return e.index !== null ? `${n}[${T(e.index, t, r)}]` : `${n}.${e.prop}`;
+    }
+    case "call": {
+      const n = e.args.map((i) => T(i, t, r)).join(", ");
+      return `${t.slice(e.start, e.start + e.name.length).trim()}(${n})`;
+    }
+    case "unary":
+      return `${e.op}${T(e.operand, t, r)}`;
+    case "binary": {
+      const n = t.slice(e.left.end, e.right.start).trim(), s = T(e.left, t, r), i = T(e.right, t, r), l = e.op === "**" && e.right.type === "binary" && e.right.op === "**" ? `(${i})` : i;
+      return `${s} ${n} ${l}`;
+    }
+    case "conditional": {
+      const n = T(e.test, t, r), s = T(e.consequent, t, r), i = T(e.alternate, t, r);
+      return `${n} ? ${s} : ${i}`;
+    }
+    default: {
+      const n = e;
+      return t.slice(n.start, n.end).trim();
+    }
+  }
+}
+function te(e, t, r) {
+  const n = " ".repeat(r * D), s = " ".repeat((r + 1) * D), i = [], l = (f) => {
+    f.type === "if" ? i.push(T(f, t, r + 1)) : i.push(`${s}${T(f, t, r + 1)}`);
+  }, u = e.branches[0], m = L({ end: e.start }, u.condition, t), p = L(u.condition, u.body, t);
+  i.push(`${n}${m} ${T(u.condition, t, r)} ${p}`), l(u.body);
+  for (let f = 1; f < e.branches.length; f++) {
+    const o = e.branches[f], N = e.branches[f - 1], g = L(N.body, o.condition, t), a = L(o.condition, o.body, t);
+    i.push(`${n}${g} ${T(o.condition, t, r)} ${a}`), l(o.body);
+  }
+  if (e.elseBody) {
+    const f = e.branches[e.branches.length - 1], o = L(f.body, e.elseBody, t);
+    i.push(`${n}${o}`), l(e.elseBody);
+  }
+  return i.join(`
+`);
+}
+const re = /^(IF|如果)(?=\s|$)/i, ne = /^(ELSE\s+IF|否则如果)(?=\s|$)/i, se = /^(ELSE|否则)(?=\s|$)/i, ae = /(ELSE|否则)$/i;
+function v(e) {
+  const t = e.split(`
+`);
+  if (t.length <= 1) return e.trim();
+  const r = [], n = [];
+  let s = 0;
+  const i = (l) => {
+    let u = s;
+    if (ne.test(l))
+      u = n.length ? n[n.length - 1] : 0;
+    else if (se.test(l)) {
+      const m = n.length ? n[n.length - 1] : 0;
+      u = m, n.length && n.pop(), s = m + 1;
+    } else re.test(l) && (u = s, n.push(s), s += 1);
+    r.push(" ".repeat(u * D) + l);
+  };
+  for (const l of t) {
+    const u = l.trim();
+    if (!u) {
+      r.push("");
+      continue;
+    }
+    const m = ae.exec(u);
+    if (m && m.index > 0) {
+      i(u.slice(0, m.index).trim()), i(u.slice(m.index));
+      continue;
+    }
+    i(u);
+  }
+  return r.join(`
+`);
+}
+function le(e) {
+  const t = e.replace(/\r\n/g, `
+`);
+  if (!t.trim()) return "";
+  try {
+    const r = U(t);
+    return T(r, t, 0) || v(t);
+  } catch {
+    return v(t);
+  }
+}
+function ue(e) {
+  return U(e);
+}
+function me(e, t = {}, r = {}, n = []) {
+  try {
+    const s = U(e);
+    return { ok: !0, value: Q(s, t, r, n) };
+  } catch (s) {
+    if (s instanceof E)
+      return {
+        ok: !1,
+        error: {
+          message: s.message,
+          start: s.start,
+          end: s.end,
+          severity: "error",
+          kind: "parse"
+        }
+      };
+    if (s instanceof y)
+      return {
+        ok: !1,
+        error: {
+          message: s.message,
+          start: s.start,
+          end: s.end,
+          severity: "error",
+          kind: "runtime"
+        }
+      };
+    throw s;
+  }
+}
+function fe(e, t = [], r = {}, n = []) {
+  const s = [];
+  let i = null;
+  if (!e.trim())
+    return { ok: !1, errors: [], ast: null };
+  try {
+    i = U(e);
+  } catch (o) {
+    if (o instanceof E)
+      return {
+        ok: !1,
+        errors: [
+          {
+            message: o.message,
+            start: o.start,
+            end: o.end,
+            severity: "error",
+            kind: "parse"
+          }
+        ],
+        ast: null
+      };
+    throw o;
+  }
+  const l = /* @__PURE__ */ new Set([
+    ...t.map((o) => o.name),
+    ...n
+  ]), u = new Set(t.map((o) => o.name)), m = /* @__PURE__ */ new Map();
+  for (const o of t)
+    o.type === "object" && o.fields && o.fields.length > 0 && m.set(o.name, new Set(o.fields.map((N) => N.key)));
+  const p = /* @__PURE__ */ new Set([
+    ...Object.keys(F),
+    ...Object.keys(r)
+  ]), f = (o) => {
+    switch (o.type) {
+      case "variable": {
+        if (!l.has(o.name)) {
+          const N = u.size > 0 ? `（已定义：${Array.from(u).join("、")}）` : "（尚未定义任何变量）";
+          s.push({
+            message: `未定义的变量 {${o.name}}${N}`,
+            start: o.start,
+            end: o.end,
+            severity: "error",
+            kind: "semantic"
+          });
+        }
+        return;
+      }
+      case "member": {
+        if (f(o.object), o.index === null && o.object.type === "variable") {
+          const N = o.object.name, g = m.get(N);
+          g && !g.has(o.prop) && s.push({
+            message: `变量 {${N}} 中不存在字段 "${o.prop}"（已定义：${Array.from(g).join("、")}）`,
+            start: o.start,
+            end: o.end,
+            severity: "error",
+            kind: "semantic"
+          });
+        } else o.index && f(o.index);
+        return;
+      }
+      case "call": {
+        const N = r[o.name];
+        if (!p.has(o.name))
+          s.push({
+            message: `未知函数 ${o.name}()（内置：${Object.keys(F).join("、")}）`,
+            start: o.start,
+            end: o.end,
+            severity: "error",
+            kind: "semantic"
+          });
+        else if (!N) {
+          const g = F[o.name];
+          if (g && (o.args.length < g.minArgs || o.args.length > g.maxArgs)) {
+            const a = g.minArgs === g.maxArgs ? `${g.minArgs}` : g.maxArgs === 1 / 0 ? `至少 ${g.minArgs}` : `${g.minArgs}~${g.maxArgs}`;
+            s.push({
+              message: `函数 ${o.name}() 需要 ${a} 个参数，实际 ${o.args.length} 个`,
+              start: o.start,
+              end: o.end,
+              severity: "error",
+              kind: "semantic"
+            });
+          }
+        }
+        o.args.forEach(f);
+        return;
+      }
+      case "binary":
+        f(o.left), f(o.right);
+        return;
+      case "unary":
+        f(o.operand);
+        return;
+      case "conditional":
+        f(o.test), f(o.consequent), f(o.alternate);
+        return;
+      case "if":
+        for (const N of o.branches)
+          f(N.condition), f(N.body);
+        o.elseBody && f(o.elseBody);
+        return;
+      default:
+        return;
+    }
+  };
+  return f(i), { ok: s.length === 0, errors: s, ast: i };
+}
+function ce(e, t = 80) {
+  let r;
+  if (e == null) r = "NULL";
+  else if (typeof e == "string") r = `"${e}"`;
+  else if (typeof e == "number")
+    r = Number.isInteger(e) ? String(e) : String(Math.round(e * 1e6) / 1e6);
+  else if (typeof e == "boolean") r = String(e);
+  else if (Array.isArray(e) || typeof e == "object")
+    try {
+      r = JSON.stringify(e);
+    } catch {
+      r = String(e);
+    }
+  else r = String(e);
+  return r.length > t ? r.slice(0, t) + "…" : r;
+}
+function pe(e) {
+  return e == null ? "空" : typeof e == "number" ? "数字" : typeof e == "string" ? "文本" : typeof e == "boolean" ? "布尔" : Array.isArray(e) ? "数组" : typeof e == "object" ? "对象" : "其他";
+}
+function ge(e) {
+  const t = [];
+  for (const r of W(e))
+    r.type === "error" && t.push({
+      message: `无法识别的字符 "${r.raw}"`,
+      start: r.start,
+      end: r.end,
+      severity: "error",
+      kind: "lex"
+    });
+  return t;
+}
+export {
+  F as BUILTIN_FUNCTIONS,
+  E as ParseError,
+  y as RuntimeError,
+  Q as evaluate,
+  me as evaluateFormula,
+  le as formatFormula,
+  ce as formatValue,
+  ge as lexErrors,
+  U as parse,
+  ue as parseFormula,
+  W as tokenize,
+  fe as validateFormula,
+  pe as valueTypeName
+};