@pebble-software/bonsai 0.1.0 → 0.1.1

package/dist/chunks/index-DzpRdatr.js

@@ -0,0 +1,359 @@
+import w from "jsep";
+import x from "@jsep-plugin/arrow";
+class A {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(e) {
+    this.maxSize = e;
+  }
+  get(e) {
+    const t = this.cache.get(e);
+    return t !== void 0 && (this.cache.delete(e), this.cache.set(e, t)), t;
+  }
+  set(e, t) {
+    if (this.cache.delete(e), this.cache.set(e, t), this.cache.size > this.maxSize) {
+      const { value: n, done: s } = this.cache.keys().next();
+      s || this.cache.delete(n);
+    }
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+w.plugins.register(x);
+const C = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function m(r, e) {
+  if (r != null && !(typeof e == "string" && C.has(e)) && Object.prototype.hasOwnProperty.call(r, e))
+    return r[e];
+}
+function g(r) {
+  if (r.type === "Identifier") return r.name;
+  if (r.type === "MemberExpression") {
+    const e = g(r.object);
+    if (e == null) return null;
+    const t = r.property;
+    return r.computed ? t.type !== "Literal" ? null : `${e}[${JSON.stringify(t.value)}]` : t.type !== "Identifier" ? null : `${e}.${t.name}`;
+  }
+  return null;
+}
+function M(r) {
+  const e = r.match(/^[^.[]+/);
+  return e ? e[0] : r;
+}
+function E(r) {
+  const e = /* @__PURE__ */ new Set();
+  function t(n, s) {
+    if (n)
+      switch (n.type) {
+        case "Identifier": {
+          const i = n.name;
+          s.has(i) || e.add(i);
+          return;
+        }
+        case "MemberExpression": {
+          const i = g(n);
+          if (i != null) {
+            s.has(M(i)) || e.add(i);
+            return;
+          }
+          t(n.object, s), t(n.property, s);
+          return;
+        }
+        case "UnaryExpression":
+          t(n.argument, s);
+          return;
+        case "BinaryExpression":
+          t(n.left, s), t(n.right, s);
+          return;
+        case "ConditionalExpression":
+          t(n.test, s), t(n.consequent, s), t(n.alternate, s);
+          return;
+        case "ArrayExpression":
+          n.elements.forEach((i) => t(i, s));
+          return;
+        case "CallExpression": {
+          const i = n.callee;
+          i.type === "MemberExpression" && t(i.object, s), n.arguments.forEach((c) => {
+            if (c.type === "ArrowFunctionExpression") {
+              const a = new Set(s);
+              c.params?.forEach((l) => {
+                l.type === "Identifier" && a.add(l.name);
+              }), t(c.body, a);
+            } else
+              t(c, s);
+          });
+          return;
+        }
+        case "Compound":
+          n.body.forEach((i) => t(i, s));
+          return;
+        default:
+          return;
+      }
+  }
+  return t(r, /* @__PURE__ */ new Set()), Array.from(e);
+}
+const u = (r, e = 2) => String(r).padStart(e, "0");
+function U(r) {
+  const e = r instanceof Date ? r : new Date(r);
+  return Number.isNaN(e.getTime()) ? null : e;
+}
+function f(r) {
+  const e = typeof r == "number" ? r : parseFloat(r);
+  return Number.isNaN(e) ? 0 : e;
+}
+function y(r) {
+  return r.flat(1 / 0).map(f);
+}
+const D = {
+  // Uses UTC getters so SSR and client render the same calendar date regardless of local timezone.
+  formatDate(r, e = "YYYY-MM-DD") {
+    const t = U(r);
+    if (!t) return "";
+    if (e === "short" || e === "medium" || e === "long" || e === "full")
+      return new Intl.DateTimeFormat("en-US", { dateStyle: e, timeZone: "UTC" }).format(t);
+    const n = {
+      YYYY: String(t.getUTCFullYear()),
+      MM: u(t.getUTCMonth() + 1),
+      DD: u(t.getUTCDate()),
+      HH: u(t.getUTCHours()),
+      mm: u(t.getUTCMinutes()),
+      ss: u(t.getUTCSeconds())
+    };
+    return e.replace(/YYYY|MM|DD|HH|mm|ss/g, (s) => n[s]);
+  },
+  formatCurrency(r, e = "USD", t = "en-US") {
+    const n = f(r);
+    return new Intl.NumberFormat(t, { style: "currency", currency: e }).format(n);
+  },
+  upper(r) {
+    return String(r ?? "").toUpperCase();
+  },
+  lower(r) {
+    return String(r ?? "").toLowerCase();
+  },
+  trim(r) {
+    return String(r ?? "").trim();
+  },
+  concat(...r) {
+    return r.map((e) => e ?? "").join("");
+  },
+  join(r, e = ", ") {
+    return Array.isArray(r) ? r.join(e) : "";
+  },
+  default(r, e) {
+    return r == null || r === "" ? e : r;
+  },
+  length(r) {
+    return typeof r == "string" || Array.isArray(r) ? r.length : 0;
+  },
+  count(r) {
+    return Array.isArray(r) ? r.length : 0;
+  },
+  sum(r) {
+    return Array.isArray(r) ? r.reduce((e, t) => e + f(t), 0) : 0;
+  },
+  min(...r) {
+    const e = y(r);
+    return e.length ? Math.min(...e) : void 0;
+  },
+  max(...r) {
+    const e = y(r);
+    return e.length ? Math.max(...e) : void 0;
+  },
+  round(r, e = 0) {
+    const t = 10 ** e;
+    return Math.round(f(r) * t) / t;
+  }
+}, Y = /* @__PURE__ */ new Set(["map", "filter", "some", "every", "find"]);
+function b(r, e, t) {
+  const n = { ...t };
+  return (r.params ?? []).forEach((s, i) => {
+    s.type === "Identifier" && (n[s.name] = e[i]);
+  }), o(r.body, n);
+}
+function o(r, e) {
+  switch (r.type) {
+    case "Literal":
+      return r.value;
+    case "Identifier":
+      return m(e, r.name);
+    case "MemberExpression": {
+      const t = o(r.object, e), n = r.property, s = r.computed ? o(n, e) : n.name;
+      return m(t, s);
+    }
+    case "UnaryExpression": {
+      const t = o(r.argument, e);
+      switch (r.operator) {
+        case "!":
+          return !t;
+        case "-":
+          return -t;
+        case "+":
+          return +t;
+        case "~":
+          return ~t;
+        default:
+          throw new Error(`Unknown unary operator: ${r.operator}`);
+      }
+    }
+    case "BinaryExpression": {
+      const t = r.operator;
+      if (t === "&&" || t === "||" || t === "??") {
+        const i = o(r.left, e);
+        return (t === "&&" ? !i : t === "||" ? !!i : i != null) ? i : o(r.right, e);
+      }
+      const n = o(r.left, e), s = o(r.right, e);
+      switch (t) {
+        case "===":
+          return n === s;
+        case "!==":
+          return n !== s;
+        case "==":
+          return n == s;
+        case "!=":
+          return n != s;
+        case "<":
+          return n < s;
+        case ">":
+          return n > s;
+        case "<=":
+          return n <= s;
+        case ">=":
+          return n >= s;
+        case "+":
+          return n + s;
+        case "-":
+          return n - s;
+        case "*":
+          return n * s;
+        case "/":
+          return n / s;
+        case "%":
+          return n % s;
+        case "**":
+          return n ** s;
+        case "&":
+          return n & s;
+        case "|":
+          return n | s;
+        case "^":
+          return n ^ s;
+        case "<<":
+          return n << s;
+        case ">>":
+          return n >> s;
+        case ">>>":
+          return n >>> s;
+        default:
+          throw new Error(`Unknown binary operator: ${t}`);
+      }
+    }
+    case "ConditionalExpression": {
+      const t = o(r.test, e);
+      return o(t ? r.consequent : r.alternate, e);
+    }
+    case "ArrayExpression":
+      return r.elements.map(
+        (t) => t ? o(t, e) : void 0
+      );
+    case "CallExpression": {
+      const t = r.callee, n = r.arguments;
+      if (t.type === "MemberExpression") {
+        if (t.computed || t.property.type !== "Identifier")
+          throw new Error(
+            "Method calls must use a fixed dot-notation method name"
+          );
+        const i = t.property.name;
+        if (!Y.has(i))
+          throw new Error(`Unknown array method: ${i}`);
+        const c = o(t.object, e);
+        if (!Array.isArray(c))
+          throw new Error(`.${i}() can only be called on an array`);
+        const [a] = n;
+        if (n.length !== 1 || a.type !== "ArrowFunctionExpression")
+          throw new Error(
+            `.${i}() requires a single arrow-function argument`
+          );
+        return c[i](
+          (l, S) => b(a, [l, S], e)
+        );
+      }
+      if (t.type !== "Identifier")
+        throw new Error(
+          "Function calls are only allowed via a bare helper name"
+        );
+      const s = D[t.name];
+      if (typeof s != "function")
+        throw new Error(`Unknown helper: ${t.name}`);
+      return s(...n.map((i) => o(i, e)));
+    }
+    default:
+      throw new Error(`Unsupported expression type: ${r.type}`);
+  }
+}
+const p = new A(250);
+function h(r) {
+  let e = p.get(r);
+  return e || (e = w(r), p.set(r, e), e);
+}
+function $(r) {
+  if (!r || typeof r != "string")
+    return [];
+  if (!r.startsWith("{{") || !r.endsWith("}}"))
+    return [];
+  const e = r.slice(2, -2).trim();
+  if (!e)
+    return [];
+  try {
+    return E(h(e));
+  } catch (t) {
+    return console.error(`Error extracting variables from "${r}":`, t), [];
+  }
+}
+function T(r, e) {
+  if (!r || typeof r != "string" || !r.startsWith("{{") || !r.endsWith("}}"))
+    return r;
+  const t = r.slice(2, -2).trim();
+  if (t)
+    try {
+      return o(h(t), e);
+    } catch (n) {
+      console.error(`Error parsing expression "${r}":`, n);
+      return;
+    }
+}
+function j() {
+  p.clear();
+}
+function d(r) {
+  return typeof r == "string" && r.startsWith("{{") && r.endsWith("}}");
+}
+function F(r) {
+  if (!d(r)) return null;
+  const e = r.slice(2, -2).trim();
+  if (!e)
+    return { source: r, content: e, ast: null, error: null, variables: [] };
+  try {
+    const t = h(e);
+    return {
+      source: r,
+      content: e,
+      ast: t,
+      error: null,
+      variables: E(t)
+    };
+  } catch (t) {
+    return { source: r, content: e, ast: null, error: t, variables: [] };
+  }
+}
+export {
+  A as L,
+  j as a,
+  F as c,
+  $ as e,
+  d as i,
+  T as p,
+  g as s
+};
+//# sourceMappingURL=index-DzpRdatr.js.map

package/dist/chunks/index-DzpRdatr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DzpRdatr.js","sources":["../../src/lib/ast/cache.ts","../../src/lib/ast/setup.ts","../../src/lib/ast/utils.ts","../../src/lib/ast/helpers.ts","../../src/lib/ast/evaluator.ts","../../src/lib/ast/index.ts"],"sourcesContent":["export class LRUCache<K, V> {\n  private cache = new Map<K, V>();\n  private maxSize: number;\n\n  constructor(maxSize: number) {\n    this.maxSize = maxSize;\n  }\n\n  get(key: K): V | undefined {\n    const value = this.cache.get(key);\n    if (value !== undefined) {\n      this.cache.delete(key);\n      this.cache.set(key, value);\n    }\n    return value;\n  }\n\n  set(key: K, value: V): void {\n    this.cache.delete(key);\n    this.cache.set(key, value);\n\n    if (this.cache.size > this.maxSize) {\n      const { value: firstKey, done } = this.cache.keys().next();\n      if (!done) this.cache.delete(firstKey);\n    }\n  }\n\n  clear(): void {\n    this.cache.clear();\n  }\n}\n","import jsep from \"jsep\";\nimport arrow from \"@jsep-plugin/arrow\";\n\n// Teaches jsep arrow syntax (`a => a.age >= 18`) — the body is still walked by our own evaluate(), never eval'd.\njsep.plugins.register(arrow);\n\nexport default jsep;\n","import type { ASTNode } from \"./types\";\n\n// Blocked even as a literal own-key, since a JSON.parse'd payload can carry one.\nconst FORBIDDEN_KEYS = new Set([\"__proto__\", \"constructor\", \"prototype\"]);\n\n// Null-safe, own-property-only read — blocks prototype-chain escapes from template expressions.\nexport function getOwn(obj: any, key: string | number): any {\n  if (obj == null) return undefined;\n  if (typeof key === \"string\" && FORBIDDEN_KEYS.has(key)) return undefined;\n  if (!Object.prototype.hasOwnProperty.call(obj, key)) return undefined;\n  return (obj as any)[key];\n}\n\n// Rebuilds a static dot/bracket path string; returns null for a non-literal computed key (e.g. `items[i].label`).\nexport function staticPath(node: ASTNode): string | null {\n  if (node.type === \"Identifier\") return (node as any).name;\n\n  if (node.type === \"MemberExpression\") {\n    const objectPath = staticPath((node as any).object);\n    if (objectPath == null) return null;\n\n    const property = (node as any).property;\n    if ((node as any).computed) {\n      if (property.type !== \"Literal\") return null;\n      return `${objectPath}[${JSON.stringify(property.value)}]`;\n    }\n    if (property.type !== \"Identifier\") return null;\n    return `${objectPath}.${property.name}`;\n  }\n\n  return null;\n}\n\n// Extracts the leading identifier from a static path (\"a.age\" -> \"a\").\nfunction rootOf(path: string): string {\n  const match = path.match(/^[^.[]+/);\n  return match ? match[0] : path;\n}\n\n// Collects the data paths an expression reads (root identifiers + static member paths); arrow params are\n// tracked in `bound` so they're excluded as locally-scoped, while free variables inside the body still surface.\nexport function extractIdentifiers(node: ASTNode): string[] {\n  const identifiers = new Set<string>();\n\n  function traverse(n: ASTNode | null | undefined, bound: ReadonlySet<string>) {\n    if (!n) return;\n\n    switch (n.type) {\n      case \"Identifier\": {\n        const name = (n as any).name;\n        if (!bound.has(name)) identifiers.add(name);\n        return;\n      }\n\n      case \"MemberExpression\": {\n        const path = staticPath(n);\n        if (path != null) {\n          if (!bound.has(rootOf(path))) identifiers.add(path);\n          return;\n        }\n        traverse((n as any).object, bound);\n        traverse((n as any).property, bound);\n        return;\n      }\n\n      case \"UnaryExpression\":\n        traverse((n as any).argument, bound);\n        return;\n\n      case \"BinaryExpression\":\n        traverse((n as any).left, bound);\n        traverse((n as any).right, bound);\n        return;\n\n      case \"ConditionalExpression\":\n        traverse((n as any).test, bound);\n        traverse((n as any).consequent, bound);\n        traverse((n as any).alternate, bound);\n        return;\n\n      case \"ArrayExpression\":\n        ((n as any).elements as ASTNode[]).forEach((el) => traverse(el, bound));\n        return;\n\n      case \"CallExpression\": {\n        // The callee itself is never a data read; only a MemberExpression callee's object is.\n        const callee = (n as any).callee;\n        if (callee.type === \"MemberExpression\") {\n          traverse(callee.object, bound);\n        }\n        ((n as any).arguments as ASTNode[]).forEach((arg) => {\n          if (arg.type === \"ArrowFunctionExpression\") {\n            const withParams = new Set(bound);\n            ((arg as any).params as ASTNode[] | null)?.forEach((p) => {\n              if (p.type === \"Identifier\") withParams.add((p as any).name);\n            });\n            traverse((arg as any).body, withParams);\n          } else {\n            traverse(arg, bound);\n          }\n        });\n        return;\n      }\n\n      case \"Compound\":\n        ((n as any).body as ASTNode[]).forEach((stmt) => traverse(stmt, bound));\n        return;\n\n      default:\n        return;\n    }\n  }\n\n  traverse(node, new Set());\n  return Array.from(identifiers);\n}\n","// Formula-language helper registry. Helpers run in SSR/PDF too, so they must be pure and synchronous — no\n// fetch, no clock reads, no randomness — or SSR output stops being a pure function of (template, data).\n\nexport type Helper = (...args: any[]) => any;\n\nconst pad = (n: number, len = 2): string => String(n).padStart(len, \"0\");\n\nfunction toDate(value: any): Date | null {\n  const date = value instanceof Date ? value : new Date(value);\n  return Number.isNaN(date.getTime()) ? null : date;\n}\n\nfunction toNumber(value: any): number {\n  const n = typeof value === \"number\" ? value : parseFloat(value);\n  return Number.isNaN(n) ? 0 : n;\n}\n\nfunction flattenNumbers(args: any[]): number[] {\n  return args.flat(Infinity).map(toNumber);\n}\n\nexport const helpers: Record<string, Helper> = {\n  // Uses UTC getters so SSR and client render the same calendar date regardless of local timezone.\n  formatDate(value: any, format: string = \"YYYY-MM-DD\"): string {\n    const date = toDate(value);\n    if (!date) return \"\";\n\n    if (format === \"short\" || format === \"medium\" || format === \"long\" || format === \"full\") {\n      return new Intl.DateTimeFormat(\"en-US\", { dateStyle: format, timeZone: \"UTC\" }).format(date);\n    }\n\n    const tokens: Record<string, string> = {\n      YYYY: String(date.getUTCFullYear()),\n      MM: pad(date.getUTCMonth() + 1),\n      DD: pad(date.getUTCDate()),\n      HH: pad(date.getUTCHours()),\n      mm: pad(date.getUTCMinutes()),\n      ss: pad(date.getUTCSeconds()),\n    };\n    return format.replace(/YYYY|MM|DD|HH|mm|ss/g, (token) => tokens[token]);\n  },\n\n  formatCurrency(value: any, currency: string = \"USD\", locale: string = \"en-US\"): string {\n    const amount = toNumber(value);\n    return new Intl.NumberFormat(locale, { style: \"currency\", currency }).format(amount);\n  },\n\n  upper(value: any): string {\n    return String(value ?? \"\").toUpperCase();\n  },\n\n  lower(value: any): string {\n    return String(value ?? \"\").toLowerCase();\n  },\n\n  trim(value: any): string {\n    return String(value ?? \"\").trim();\n  },\n\n  concat(...args: any[]): string {\n    return args.map((a) => (a ?? \"\")).join(\"\");\n  },\n\n  join(value: any, separator: string = \", \"): string {\n    return Array.isArray(value) ? value.join(separator) : \"\";\n  },\n\n  default(value: any, fallback: any): any {\n    return value == null || value === \"\" ? fallback : value;\n  },\n\n  length(value: any): number {\n    if (typeof value === \"string\" || Array.isArray(value)) return value.length;\n    return 0;\n  },\n\n  count(value: any): number {\n    return Array.isArray(value) ? value.length : 0;\n  },\n\n  sum(value: any): number {\n    return Array.isArray(value) ? value.reduce((acc: number, v: any) => acc + toNumber(v), 0) : 0;\n  },\n\n  min(...args: any[]): number | undefined {\n    const nums = flattenNumbers(args);\n    return nums.length ? Math.min(...nums) : undefined;\n  },\n\n  max(...args: any[]): number | undefined {\n    const nums = flattenNumbers(args);\n    return nums.length ? Math.max(...nums) : undefined;\n  },\n\n  round(value: any, digits: number = 0): number {\n    const factor = 10 ** digits;\n    return Math.round(toNumber(value) * factor) / factor;\n  },\n};\n","import type { ASTNode } from \"./types\";\nimport { getOwn } from \"./utils\";\nimport { helpers } from \"./helpers\";\n\n// Only these array methods are callable via `.method(lambda)`; anything else is always an error.\nconst ALLOWED_ARRAY_METHODS = new Set([\"map\", \"filter\", \"some\", \"every\", \"find\"]);\n\n// Walks the arrow body with `evaluate()` itself — no real JS function is ever compiled from the lambda.\nfunction callArrow(\n  arrow: any,\n  args: any[],\n  outerData: Record<string, any>,\n): any {\n  const scope: Record<string, any> = { ...outerData };\n  ((arrow.params as ASTNode[] | null) ?? []).forEach((param, i) => {\n    if (param.type === \"Identifier\") scope[(param as any).name] = args[i];\n  });\n  return evaluate(arrow.body, scope);\n}\n\nexport function evaluate(node: ASTNode, data: Record<string, any>): any {\n  switch (node.type) {\n    case \"Literal\":\n      return (node as any).value;\n\n    case \"Identifier\":\n      return getOwn(data, (node as any).name);\n\n    case \"MemberExpression\": {\n      const objectValue = evaluate((node as any).object, data);\n      const property = (node as any).property;\n      const key = (node as any).computed\n        ? evaluate(property, data)\n        : (property as any).name;\n      return getOwn(objectValue, key);\n    }\n\n    case \"UnaryExpression\": {\n      const argument = evaluate((node as any).argument, data);\n      switch ((node as any).operator) {\n        case \"!\":\n          return !argument;\n        case \"-\":\n          return -argument;\n        case \"+\":\n          return +argument;\n        case \"~\":\n          return ~argument;\n        default:\n          throw new Error(`Unknown unary operator: ${(node as any).operator}`);\n      }\n    }\n\n    case \"BinaryExpression\": {\n      const operator = (node as any).operator as string;\n\n      // Short-circuit: right side only evaluated when needed; returns the operand, not a boolean (JS semantics).\n      if (operator === \"&&\" || operator === \"||\" || operator === \"??\") {\n        const left = evaluate((node as any).left, data);\n        const shortCircuits =\n          operator === \"&&\"\n            ? !left\n            : operator === \"||\"\n              ? !!left\n              : left != null;\n        return shortCircuits ? left : evaluate((node as any).right, data);\n      }\n\n      const left = evaluate((node as any).left, data);\n      const right = evaluate((node as any).right, data);\n\n      switch (operator) {\n        case \"===\":\n          return left === right;\n        case \"!==\":\n          return left !== right;\n        case \"==\":\n          return left == right;\n        case \"!=\":\n          return left != right;\n        case \"<\":\n          return left < right;\n        case \">\":\n          return left > right;\n        case \"<=\":\n          return left <= right;\n        case \">=\":\n          return left >= right;\n        case \"+\":\n          return left + right;\n        case \"-\":\n          return left - right;\n        case \"*\":\n          return left * right;\n        case \"/\":\n          return left / right;\n        case \"%\":\n          return left % right;\n        case \"**\":\n          return left ** right;\n        case \"&\":\n          return left & right;\n        case \"|\":\n          return left | right;\n        case \"^\":\n          return left ^ right;\n        case \"<<\":\n          return left << right;\n        case \">>\":\n          return left >> right;\n        case \">>>\":\n          return left >>> right;\n        default:\n          throw new Error(`Unknown binary operator: ${operator}`);\n      }\n    }\n\n    case \"ConditionalExpression\": {\n      const test = evaluate((node as any).test, data);\n      return test\n        ? evaluate((node as any).consequent, data)\n        : evaluate((node as any).alternate, data);\n    }\n\n    case \"ArrayExpression\":\n      return ((node as any).elements as (ASTNode | null)[]).map((el) =>\n        el ? evaluate(el, data) : undefined,\n      );\n\n    case \"CallExpression\": {\n      const callee = (node as any).callee;\n      const argNodes = (node as any).arguments as ASTNode[];\n\n      // Allowlisted array method + lambda; any other member-access call is rejected before the receiver is touched.\n      if (callee.type === \"MemberExpression\") {\n        if (callee.computed || callee.property.type !== \"Identifier\") {\n          throw new Error(\n            \"Method calls must use a fixed dot-notation method name\",\n          );\n        }\n        const methodName = callee.property.name as string;\n        if (!ALLOWED_ARRAY_METHODS.has(methodName)) {\n          throw new Error(`Unknown array method: ${methodName}`);\n        }\n\n        const receiver = evaluate(callee.object, data);\n        if (!Array.isArray(receiver)) {\n          throw new Error(`.${methodName}() can only be called on an array`);\n        }\n\n        const [arg] = argNodes;\n        if (argNodes.length !== 1 || arg.type !== \"ArrowFunctionExpression\") {\n          throw new Error(\n            `.${methodName}() requires a single arrow-function argument`,\n          );\n        }\n\n        return (receiver as any[])[methodName]((item: any, index: number) =>\n          callArrow(arg, [item, index], data),\n        );\n      }\n\n      if (callee.type !== \"Identifier\") {\n        throw new Error(\n          \"Function calls are only allowed via a bare helper name\",\n        );\n      }\n\n      const helper = helpers[(callee as any).name];\n      if (typeof helper !== \"function\") {\n        throw new Error(`Unknown helper: ${(callee as any).name}`);\n      }\n\n      return helper(...argNodes.map((a) => evaluate(a, data)));\n    }\n\n    default:\n      throw new Error(`Unsupported expression type: ${node.type}`);\n  }\n}\n","import jsep from \"./setup\";\nimport type { ASTNode } from \"./types\";\nimport { LRUCache } from \"./cache\";\nimport { evaluate } from \"./evaluator\";\nimport { extractIdentifiers } from \"./utils\";\n\nexport type { ASTNode } from \"./types\";\n\nconst astCache = new LRUCache<string, ASTNode>(250);\n\nfunction parseToAST(content: string): ASTNode {\n  let ast = astCache.get(content);\n  if (ast) {\n    return ast;\n  }\n\n  ast = jsep(content) as ASTNode;\n  astCache.set(content, ast);\n  return ast;\n}\n\nexport function extractVariables(expr: string): string[] {\n  if (!expr || typeof expr !== \"string\") {\n    return [];\n  }\n\n  if (!expr.startsWith(\"{{\") || !expr.endsWith(\"}}\")) {\n    return [];\n  }\n\n  const content = expr.slice(2, -2).trim();\n  if (!content) {\n    return [];\n  }\n\n  try {\n    return extractIdentifiers(parseToAST(content));\n  } catch (error) {\n    console.error(`Error extracting variables from \"${expr}\":`, error);\n    return [];\n  }\n}\n\nexport function parseExpression(expr: string, data: Record<string, any>): any {\n  if (!expr || typeof expr !== \"string\") {\n    return expr;\n  }\n\n  if (!expr.startsWith(\"{{\") || !expr.endsWith(\"}}\")) {\n    return expr;\n  }\n\n  const content = expr.slice(2, -2).trim();\n  if (!content) {\n    return undefined;\n  }\n\n  try {\n    return evaluate(parseToAST(content), data);\n  } catch (error) {\n    console.error(`Error parsing expression \"${expr}\":`, error);\n    return undefined;\n  }\n}\n\nexport function clearExpressionCache(): void {\n  astCache.clear();\n}\n\n/**\n * The single predicate that decides whether a value is a template expression.\n * `parseExpression` / `extractVariables` / the template compiler must all agree\n * on it — a divergence would silently stop evaluating a prop.\n */\nexport function isExpression(value: unknown): value is string {\n  return (\n    typeof value === \"string\" && value.startsWith(\"{{\") && value.endsWith(\"}}\")\n  );\n}\n\nexport interface CompiledExpression {\n  /** The original `{{...}}` source, i.e. what gets handed to `parseExpression`. */\n  source: string;\n  /** The trimmed inner content, i.e. the raw binding path for a plain path binding. */\n  content: string;\n  /** Parsed AST, or null for an empty expression or a parse failure. */\n  ast: ASTNode | null;\n  /** Parse failure, if any. Deferred to evaluation time so logging stays per-render. */\n  error: unknown;\n  /** Data paths the expression reads. Empty for literal-only expressions. */\n  variables: string[];\n}\n\n/**\n * Parses an expression ahead of render. Returns null for anything that isn't a\n * `{{...}}` expression. Never throws: a malformed expression is captured in\n * `error` so the caller can keep `parseExpression`'s per-render error reporting.\n */\nexport function compileExpression(value: unknown): CompiledExpression | null {\n  if (!isExpression(value)) return null;\n\n  const content = value.slice(2, -2).trim();\n  if (!content) {\n    return { source: value, content, ast: null, error: null, variables: [] };\n  }\n\n  try {\n    const ast = parseToAST(content);\n    return {\n      source: value,\n      content,\n      ast,\n      error: null,\n      variables: extractIdentifiers(ast),\n    };\n  } catch (error) {\n    return { source: value, content, ast: null, error, variables: [] };\n  }\n}\n"],"names":["LRUCache","maxSize","key","value","firstKey","done","jsep","arrow","FORBIDDEN_KEYS","getOwn","obj","staticPath","node","objectPath","property","rootOf","path","match","extractIdentifiers","identifiers","traverse","bound","name","el","callee","arg","withParams","p","stmt","pad","n","len","toDate","date","toNumber","flattenNumbers","args","helpers","format","tokens","token","currency","locale","amount","a","separator","fallback","acc","v","nums","digits","factor","ALLOWED_ARRAY_METHODS","callArrow","outerData","scope","param","evaluate","data","objectValue","argument","operator","left","right","test","argNodes","methodName","receiver","item","index","helper","astCache","parseToAST","content","ast","extractVariables","expr","error","parseExpression","clearExpressionCache","isExpression","compileExpression"],"mappings":"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"}