@pebble-software/bonsai 0.1.2 → 0.2.1

package/dist/chunks/index-CD5pykpk.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-CD5pykpk.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, KnownNode } 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: unknown, key: PropertyKey): unknown {\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 Record<PropertyKey, unknown>)[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  const n = node as KnownNode;\n  if (n.type === \"Identifier\") return n.name;\n\n  if (n.type === \"MemberExpression\") {\n    const objectPath = staticPath(n.object);\n    if (objectPath == null) return null;\n\n    const property = n.property as KnownNode;\n    if (n.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(expr: ASTNode | null | undefined, bound: ReadonlySet<string>) {\n    if (!expr) return;\n    const n = expr as KnownNode;\n\n    switch (n.type) {\n      case \"Identifier\": {\n        if (!bound.has(n.name)) identifiers.add(n.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.object, bound);\n        traverse(n.property, bound);\n        return;\n      }\n\n      case \"UnaryExpression\":\n        traverse(n.argument, bound);\n        return;\n\n      case \"BinaryExpression\":\n        traverse(n.left, bound);\n        traverse(n.right, bound);\n        return;\n\n      case \"ConditionalExpression\":\n        traverse(n.test, bound);\n        traverse(n.consequent, bound);\n        traverse(n.alternate, bound);\n        return;\n\n      case \"ArrayExpression\":\n        n.elements.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.callee as KnownNode;\n        if (callee.type === \"MemberExpression\") {\n          traverse(callee.object, bound);\n        }\n        n.arguments.forEach((arg) => {\n          const a = arg as KnownNode;\n          if (a.type === \"ArrowFunctionExpression\") {\n            const withParams = new Set(bound);\n            a.params?.forEach((param) => {\n              const p = param as KnownNode;\n              if (p.type === \"Identifier\") withParams.add(p.name);\n            });\n            traverse(a.body, withParams);\n          } else {\n            traverse(arg, bound);\n          }\n        });\n        return;\n      }\n\n      case \"Compound\":\n        n.body.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\n// Method syntax on purpose: it keeps parameters bivariant, so each helper declares the argument\n// types it expects while the evaluator calls it with whatever values a template passes.\nexport type Helper = { helper(...args: unknown[]): unknown }[\"helper\"];\n\nconst pad = (n: number, len = 2): string => String(n).padStart(len, \"0\");\n\nfunction toDate(value: unknown): Date | null {\n  // Any other value is coerced by the Date constructor, same as an untyped call.\n  const date = value instanceof Date ? value : new Date(value as string | number);\n  return Number.isNaN(date.getTime()) ? null : date;\n}\n\nfunction toNumber(value: unknown): number {\n  // parseFloat stringifies non-strings itself.\n  const n = typeof value === \"number\" ? value : parseFloat(value as string);\n  return Number.isNaN(n) ? 0 : n;\n}\n\nfunction flattenNumbers(args: unknown[]): 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: unknown, 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: unknown, 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: unknown): string {\n    return String(value ?? \"\").toUpperCase();\n  },\n\n  lower(value: unknown): string {\n    return String(value ?? \"\").toLowerCase();\n  },\n\n  trim(value: unknown): string {\n    return String(value ?? \"\").trim();\n  },\n\n  concat(...args: unknown[]): string {\n    return args.map((a) => (a ?? \"\")).join(\"\");\n  },\n\n  join(value: unknown, separator: string = \", \"): string {\n    return Array.isArray(value) ? value.join(separator) : \"\";\n  },\n\n  default(value: unknown, fallback: unknown): unknown {\n    return value == null || value === \"\" ? fallback : value;\n  },\n\n  length(value: unknown): number {\n    if (typeof value === \"string\" || Array.isArray(value)) return value.length;\n    return 0;\n  },\n\n  count(value: unknown): number {\n    return Array.isArray(value) ? value.length : 0;\n  },\n\n  sum(value: unknown): number {\n    return Array.isArray(value) ? value.reduce((acc: number, v: unknown) => acc + toNumber(v), 0) : 0;\n  },\n\n  min(...args: unknown[]): number | undefined {\n    const nums = flattenNumbers(args);\n    return nums.length ? Math.min(...nums) : undefined;\n  },\n\n  max(...args: unknown[]): number | undefined {\n    const nums = flattenNumbers(args);\n    return nums.length ? Math.max(...nums) : undefined;\n  },\n\n  round(value: unknown, digits: number = 0): number {\n    const factor = 10 ** digits;\n    return Math.round(toNumber(value) * factor) / factor;\n  },\n};\n","import type { Identifier } from \"jsep\";\nimport type { ArrowExpression } from \"@jsep-plugin/arrow\";\nimport type { ASTNode, KnownNode } from \"./types\";\nimport { getOwn } from \"./utils\";\nimport { helpers } from \"./helpers\";\n\ntype Lambda = (item: unknown, index: number) => unknown;\n\n// Only these array methods are callable via `.method(lambda)`; anything else is always an error.\nconst ARRAY_METHODS: Record<string, (items: unknown[], fn: Lambda) => unknown> = {\n  map: (items, fn) => items.map(fn),\n  filter: (items, fn) => items.filter(fn),\n  some: (items, fn) => items.some(fn),\n  every: (items, fn) => items.every(fn),\n  find: (items, fn) => items.find(fn),\n};\n\n// Walks the arrow body with `evaluate()` itself — no real JS function is ever compiled from the lambda.\nfunction callArrow(\n  arrow: ArrowExpression,\n  args: unknown[],\n  outerData: Record<string, unknown>,\n): unknown {\n  const scope: Record<string, unknown> = { ...outerData };\n  (arrow.params ?? []).forEach((param, i) => {\n    const p = param as KnownNode;\n    if (p.type === \"Identifier\") scope[p.name] = args[i];\n  });\n  return evaluate(arrow.body, scope);\n}\n\nexport function evaluate(node: ASTNode, data: Record<string, unknown>): unknown {\n  const n = node as KnownNode;\n  switch (n.type) {\n    case \"Literal\":\n      return n.value;\n\n    case \"Identifier\":\n      return getOwn(data, n.name);\n\n    case \"MemberExpression\": {\n      const objectValue = evaluate(n.object, data);\n      // A computed key can evaluate to anything; the own-property lookup coerces it like `obj[key]` would.\n      const key = n.computed\n        ? (evaluate(n.property, data) as PropertyKey)\n        : (n.property as Identifier).name;\n      return getOwn(objectValue, key);\n    }\n\n    case \"UnaryExpression\": {\n      // Operands are whatever the template produced; JS coercion is the intended semantics,\n      // so they're typed as numbers only to satisfy the checker.\n      const argument = evaluate(n.argument, data) as number;\n      switch (n.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: ${n.operator}`);\n      }\n    }\n\n    case \"BinaryExpression\": {\n      const operator = n.operator;\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(n.left, data);\n        const shortCircuits =\n          operator === \"&&\"\n            ? !left\n            : operator === \"||\"\n              ? !!left\n              : left != null;\n        return shortCircuits ? left : evaluate(n.right, data);\n      }\n\n      // Same as the unary case: JS coercion semantics, number types only for the checker.\n      const left = evaluate(n.left, data) as number;\n      const right = evaluate(n.right, data) as number;\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(n.test, data);\n      return test\n        ? evaluate(n.consequent, data)\n        : evaluate(n.alternate, data);\n    }\n\n    case \"ArrayExpression\":\n      return n.elements.map((el) => (el ? evaluate(el, data) : undefined));\n\n    case \"CallExpression\": {\n      const callee = n.callee as KnownNode;\n      const argNodes = n.arguments;\n\n      // Allowlisted array method + lambda; any other member-access call is rejected before the receiver is touched.\n      if (callee.type === \"MemberExpression\") {\n        const property = callee.property as KnownNode;\n        if (callee.computed || property.type !== \"Identifier\") {\n          throw new Error(\n            \"Method calls must use a fixed dot-notation method name\",\n          );\n        }\n        const methodName = property.name;\n        const method = Object.hasOwn(ARRAY_METHODS, methodName)\n          ? ARRAY_METHODS[methodName]\n          : undefined;\n        if (!method) {\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[0] as KnownNode | undefined;\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 method(receiver, (item, index) => callArrow(arg, [item, index], data));\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      // Own keys only, so inherited names like `constructor` or `toString` never resolve to a helper.\n      const helper = Object.hasOwn(helpers, callee.name) ? helpers[callee.name] : undefined;\n      if (typeof helper !== \"function\") {\n        throw new Error(`Unknown helper: ${callee.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: unknown, data: Record<string, unknown>): unknown {\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","n","objectPath","property","rootOf","path","match","extractIdentifiers","identifiers","traverse","expr","bound","el","callee","arg","a","withParams","param","p","stmt","pad","len","toDate","date","toNumber","flattenNumbers","args","helpers","format","tokens","token","currency","locale","amount","separator","fallback","acc","v","nums","digits","factor","ARRAY_METHODS","items","fn","callArrow","outerData","scope","i","evaluate","data","objectValue","argument","operator","left","right","test","argNodes","methodName","method","receiver","item","index","helper","astCache","parseToAST","content","ast","extractVariables","error","parseExpression","clearExpressionCache","isExpression","compileExpression"],"mappings":"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"}