typebars 1.0.1 → 1.0.2

package/dist/{chunk-7j6q1e3z.js.map → chunk-xd2vmd03.js.map}

@@ -8,7 +8,7 @@
     "import type { HelperDefinition } from \"../types.ts\";\nimport { HelperFactory } from \"./helper-factory.ts\";\nimport { toNumber } from \"./utils.ts\";\n\n// ─── LogicalHelpers ──────────────────────────────────────────────────────────\n// Aggregates all logical / comparison helpers for the template engine.\n//\n// Provides two kinds of helpers:\n//\n// 1. **Named helpers** — one helper per operation (`eq`, `lt`, `not`, …)\n//    Usage: `{{#if (eq status \"active\")}}`, `{{#if (lt price 100)}}`\n//\n// 2. **Generic `compare` helper** — single helper with the operator as a param\n//    Usage: `{{#if (compare a \"<\" b)}}`, `{{#if (compare name \"==\" \"Alice\")}}`\n//\n// ─── Registration ────────────────────────────────────────────────────────────\n// LogicalHelpers are automatically pre-registered by the `Typebars` constructor.\n// They can also be registered manually on any object implementing\n// `HelperRegistry`:\n//\n//   const factory = new LogicalHelpers();\n//   factory.register(engine);   // registers all helpers\n//   factory.unregister(engine); // removes all helpers\n//\n// ─── Supported operators (generic `compare` helper) ──────────────────────────\n//   ==   Loose equality\n//   ===  Strict equality\n//   !=   Loose inequality\n//   !==  Strict inequality\n//   <    Less than\n//   <=   Less than or equal\n//   >    Greater than\n//   >=   Greater than or equal\n\n// ─── Types ───────────────────────────────────────────────────────────────────\n\n/** Operators supported by the generic `compare` helper */\ntype CompareOperator = \"==\" | \"===\" | \"!=\" | \"!==\" | \"<\" | \"<=\" | \">\" | \">=\";\n\nconst SUPPORTED_OPERATORS = new Set<string>([\n\t\"==\",\n\t\"===\",\n\t\"!=\",\n\t\"!==\",\n\t\"<\",\n\t\"<=\",\n\t\">\",\n\t\">=\",\n]);\n\n// ─── Internal utilities ─────────────────────────────────────────────────────\n\n/**\n * Applies a comparison operator to two operands.\n */\nfunction applyOperator(a: unknown, op: CompareOperator, b: unknown): boolean {\n\tswitch (op) {\n\t\tcase \"==\":\n\t\t\t// biome-ignore lint/suspicious/noDoubleEquals: intentional loose equality\n\t\t\treturn a == b;\n\t\tcase \"===\":\n\t\t\treturn a === b;\n\t\tcase \"!=\":\n\t\t\t// biome-ignore lint/suspicious/noDoubleEquals: intentional loose inequality\n\t\t\treturn a != b;\n\t\tcase \"!==\":\n\t\t\treturn a !== b;\n\t\tcase \"<\":\n\t\t\treturn toNumber(a) < toNumber(b);\n\t\tcase \"<=\":\n\t\t\treturn toNumber(a) <= toNumber(b);\n\t\tcase \">\":\n\t\t\treturn toNumber(a) > toNumber(b);\n\t\tcase \">=\":\n\t\t\treturn toNumber(a) >= toNumber(b);\n\t}\n}\n\n/**\n * Checks whether a value is a Handlebars options object.\n * Handlebars always passes an options object as the last argument to helpers.\n */\nfunction isHandlebarsOptions(value: unknown): boolean {\n\treturn (\n\t\tvalue !== null &&\n\t\ttypeof value === \"object\" &&\n\t\t\"hash\" in (value as Record<string, unknown>) &&\n\t\t\"name\" in (value as Record<string, unknown>)\n\t);\n}\n\n// ─── Main class ─────────────────────────────────────────────────────────────\n\nexport class LogicalHelpers extends HelperFactory {\n\t// ─── buildDefinitions (required by HelperFactory) ──────────────────\n\n\tprotected buildDefinitions(defs: Map<string, HelperDefinition>): void {\n\t\tthis.registerEquality(defs);\n\t\tthis.registerComparison(defs);\n\t\tthis.registerLogicalOperators(defs);\n\t\tthis.registerCollectionHelpers(defs);\n\t\tthis.registerGenericCompare(defs);\n\t}\n\n\t// ── Equality helpers ─────────────────────────────────────────────\n\n\t/** Registers eq, ne / neq */\n\tprivate registerEquality(defs: Map<string, HelperDefinition>): void {\n\t\t// eq — Strict equality: {{#if (eq a b)}}\n\t\tdefs.set(\"eq\", {\n\t\t\tfn: (a: unknown, b: unknown) => a === b,\n\t\t\tparams: [\n\t\t\t\t{ name: \"a\", description: \"Left value\" },\n\t\t\t\t{ name: \"b\", description: \"Right value\" },\n\t\t\t],\n\t\t\treturnType: { type: \"boolean\" },\n\t\t\tdescription: \"Returns true if a is strictly equal to b: {{#if (eq a b)}}\",\n\t\t});\n\n\t\t// ne / neq — Strict inequality: {{#if (ne a b)}}\n\t\tconst neDef: HelperDefinition = {\n\t\t\tfn: (a: unknown, b: unknown) => a !== b,\n\t\t\tparams: [\n\t\t\t\t{ name: \"a\", description: \"Left value\" },\n\t\t\t\t{ name: \"b\", description: \"Right value\" },\n\t\t\t],\n\t\t\treturnType: { type: \"boolean\" },\n\t\t\tdescription:\n\t\t\t\t\"Returns true if a is not strictly equal to b: {{#if (ne a b)}}\",\n\t\t};\n\t\tdefs.set(\"ne\", neDef);\n\t\tdefs.set(\"neq\", neDef);\n\t}\n\n\t// ── Comparison helpers ───────────────────────────────────────────\n\n\t/** Registers lt, lte / le, gt, gte / ge */\n\tprivate registerComparison(defs: Map<string, HelperDefinition>): void {\n\t\t// lt — Less than: {{#if (lt a b)}}\n\t\tdefs.set(\"lt\", {\n\t\t\tfn: (a: unknown, b: unknown) => toNumber(a) < toNumber(b),\n\t\t\tparams: [\n\t\t\t\t{ name: \"a\", type: { type: \"number\" }, description: \"Left operand\" },\n\t\t\t\t{ name: \"b\", type: { type: \"number\" }, description: \"Right operand\" },\n\t\t\t],\n\t\t\treturnType: { type: \"boolean\" },\n\t\t\tdescription: \"Returns true if a < b: {{#if (lt a b)}}\",\n\t\t});\n\n\t\t// lte / le — Less than or equal: {{#if (lte a b)}}\n\t\tconst lteDef: HelperDefinition = {\n\t\t\tfn: (a: unknown, b: unknown) => toNumber(a) <= toNumber(b),\n\t\t\tparams: [\n\t\t\t\t{ name: \"a\", type: { type: \"number\" }, description: \"Left operand\" },\n\t\t\t\t{ name: \"b\", type: { type: \"number\" }, description: \"Right operand\" },\n\t\t\t],\n\t\t\treturnType: { type: \"boolean\" },\n\t\t\tdescription: \"Returns true if a <= b: {{#if (lte a b)}}\",\n\t\t};\n\t\tdefs.set(\"lte\", lteDef);\n\t\tdefs.set(\"le\", lteDef);\n\n\t\t// gt — Greater than: {{#if (gt a b)}}\n\t\tdefs.set(\"gt\", {\n\t\t\tfn: (a: unknown, b: unknown) => toNumber(a) > toNumber(b),\n\t\t\tparams: [\n\t\t\t\t{ name: \"a\", type: { type: \"number\" }, description: \"Left operand\" },\n\t\t\t\t{ name: \"b\", type: { type: \"number\" }, description: \"Right operand\" },\n\t\t\t],\n\t\t\treturnType: { type: \"boolean\" },\n\t\t\tdescription: \"Returns true if a > b: {{#if (gt a b)}}\",\n\t\t});\n\n\t\t// gte / ge — Greater than or equal: {{#if (gte a b)}}\n\t\tconst gteDef: HelperDefinition = {\n\t\t\tfn: (a: unknown, b: unknown) => toNumber(a) >= toNumber(b),\n\t\t\tparams: [\n\t\t\t\t{ name: \"a\", type: { type: \"number\" }, description: \"Left operand\" },\n\t\t\t\t{ name: \"b\", type: { type: \"number\" }, description: \"Right operand\" },\n\t\t\t],\n\t\t\treturnType: { type: \"boolean\" },\n\t\t\tdescription: \"Returns true if a >= b: {{#if (gte a b)}}\",\n\t\t};\n\t\tdefs.set(\"gte\", gteDef);\n\t\tdefs.set(\"ge\", gteDef);\n\t}\n\n\t// ── Logical operators ────────────────────────────────────────────\n\n\t/** Registers not, and, or */\n\tprivate registerLogicalOperators(defs: Map<string, HelperDefinition>): void {\n\t\t// not — Logical negation: {{#if (not active)}}\n\t\tdefs.set(\"not\", {\n\t\t\tfn: (value: unknown) => !value,\n\t\t\tparams: [{ name: \"value\", description: \"Value to negate\" }],\n\t\t\treturnType: { type: \"boolean\" },\n\t\t\tdescription: \"Returns true if the value is falsy: {{#if (not active)}}\",\n\t\t});\n\n\t\t// and — Logical AND: {{#if (and a b)}}\n\t\tdefs.set(\"and\", {\n\t\t\tfn: (a: unknown, b: unknown) => !!a && !!b,\n\t\t\tparams: [\n\t\t\t\t{ name: \"a\", description: \"First condition\" },\n\t\t\t\t{ name: \"b\", description: \"Second condition\" },\n\t\t\t],\n\t\t\treturnType: { type: \"boolean\" },\n\t\t\tdescription: \"Returns true if both values are truthy: {{#if (and a b)}}\",\n\t\t});\n\n\t\t// or — Logical OR: {{#if (or a b)}}\n\t\tdefs.set(\"or\", {\n\t\t\tfn: (a: unknown, b: unknown) => !!a || !!b,\n\t\t\tparams: [\n\t\t\t\t{ name: \"a\", description: \"First condition\" },\n\t\t\t\t{ name: \"b\", description: \"Second condition\" },\n\t\t\t],\n\t\t\treturnType: { type: \"boolean\" },\n\t\t\tdescription:\n\t\t\t\t\"Returns true if at least one value is truthy: {{#if (or a b)}}\",\n\t\t});\n\t}\n\n\t// ── Collection / String helpers ──────────────────────────────────\n\n\t/** Registers contains, in */\n\tprivate registerCollectionHelpers(defs: Map<string, HelperDefinition>): void {\n\t\t// contains — Checks if a string contains a substring or an array contains an element\n\t\t// Usage: {{#if (contains name \"ali\")}} or {{#if (contains tags \"admin\")}}\n\t\tdefs.set(\"contains\", {\n\t\t\tfn: (haystack: unknown, needle: unknown) => {\n\t\t\t\tif (typeof haystack === \"string\") {\n\t\t\t\t\treturn haystack.includes(String(needle));\n\t\t\t\t}\n\t\t\t\tif (Array.isArray(haystack)) {\n\t\t\t\t\treturn haystack.includes(needle);\n\t\t\t\t}\n\t\t\t\treturn false;\n\t\t\t},\n\t\t\tparams: [\n\t\t\t\t{\n\t\t\t\t\tname: \"haystack\",\n\t\t\t\t\tdescription: \"String or array to search in\",\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\tname: \"needle\",\n\t\t\t\t\tdescription: \"Value to search for\",\n\t\t\t\t},\n\t\t\t],\n\t\t\treturnType: { type: \"boolean\" },\n\t\t\tdescription:\n\t\t\t\t'Checks if a string contains a substring or an array contains an element: {{#if (contains name \"ali\")}}',\n\t\t});\n\n\t\t// in — Checks if a value is one of the provided options (variadic)\n\t\t// Usage: {{#if (in status \"active\" \"pending\" \"draft\")}}\n\t\tdefs.set(\"in\", {\n\t\t\tfn: (...args: unknown[]) => {\n\t\t\t\t// Handlebars always passes an options object as the last argument.\n\t\t\t\t// We need to exclude it from the candidate list.\n\t\t\t\tif (args.length < 2) return false;\n\n\t\t\t\tconst value = args[0];\n\t\t\t\t// Filter out the trailing Handlebars options object\n\t\t\t\tconst candidates = args.slice(1).filter((a) => !isHandlebarsOptions(a));\n\n\t\t\t\treturn candidates.some((c) => c === value);\n\t\t\t},\n\t\t\tparams: [\n\t\t\t\t{\n\t\t\t\t\tname: \"value\",\n\t\t\t\t\tdescription: \"Value to look for\",\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\tname: \"candidates\",\n\t\t\t\t\tdescription:\n\t\t\t\t\t\t'One or more candidate values (variadic): {{#if (in status \"active\" \"pending\")}}',\n\t\t\t\t},\n\t\t\t],\n\t\t\treturnType: { type: \"boolean\" },\n\t\t\tdescription:\n\t\t\t\t'Checks if a value is one of the provided options: {{#if (in status \"active\" \"pending\" \"draft\")}}',\n\t\t});\n\t}\n\n\t// ── Generic helper ───────────────────────────────────────────────\n\n\t/** Registers the generic `compare` helper with operator as a parameter */\n\tprivate registerGenericCompare(defs: Map<string, HelperDefinition>): void {\n\t\t// Usage: {{#if (compare a \"<\" b)}}, {{#if (compare name \"===\" \"Alice\")}}\n\t\tdefs.set(\"compare\", {\n\t\t\tfn: (a: unknown, operator: unknown, b: unknown) => {\n\t\t\t\tconst op = String(operator);\n\t\t\t\tif (!SUPPORTED_OPERATORS.has(op)) {\n\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t`[compare helper] Unknown operator \"${op}\". ` +\n\t\t\t\t\t\t\t`Supported: ${[...SUPPORTED_OPERATORS].join(\", \")} `,\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\treturn applyOperator(a, op as CompareOperator, b);\n\t\t\t},\n\t\t\tparams: [\n\t\t\t\t{ name: \"a\", description: \"Left operand\" },\n\t\t\t\t{\n\t\t\t\t\tname: \"operator\",\n\t\t\t\t\ttype: {\n\t\t\t\t\t\ttype: \"string\",\n\t\t\t\t\t\tenum: [\"==\", \"===\", \"!=\", \"!==\", \"<\", \"<=\", \">\", \">=\"],\n\t\t\t\t\t},\n\t\t\t\t\tdescription:\n\t\t\t\t\t\t'Comparison operator: \"==\", \"===\", \"!=\", \"!==\", \"<\", \"<=\", \">\", \">=\"',\n\t\t\t\t},\n\t\t\t\t{ name: \"b\", description: \"Right operand\" },\n\t\t\t],\n\t\t\treturnType: { type: \"boolean\" },\n\t\t\tdescription:\n\t\t\t\t'Generic comparison helper with operator as parameter: {{#if (compare a \"<\" b)}}. ' +\n\t\t\t\t\"Supported operators: ==, ===, !=, !==, <, <=, >, >=\",\n\t\t});\n\t}\n}\n",
     "import type { HelperDefinition } from \"../types.ts\";\nimport { HelperFactory } from \"./helper-factory.ts\";\nimport { toNumber } from \"./utils.ts\";\n\n// ─── MathHelpers ─────────────────────────────────────────────────────────────\n// Aggregates all math-related helpers for the template engine.\n//\n// Provides two kinds of helpers:\n//\n// 1. **Named helpers** — one helper per operation (`add`, `subtract`, `divide`, …)\n//    Usage: `{{ add a b }}`, `{{ abs value }}`, `{{ round value 2 }}`\n//\n// 2. **Generic `math` helper** — single helper with the operator as a parameter\n//    Usage: `{{ math a \"+\" b }}`, `{{ math a \"/\" b }}`, `{{ math a \"**\" b }}`\n//\n// ─── Registration ────────────────────────────────────────────────────────────\n// MathHelpers are automatically pre-registered by the `Typebars` constructor.\n// They can also be registered manually on any object implementing\n// `HelperRegistry`:\n//\n//   const factory = new MathHelpers();\n//   factory.register(engine);   // registers all helpers\n//   factory.unregister(engine); // removes all helpers\n//\n// ─── Supported operators (generic `math` helper) ─────────────────────────────\n//   +   Addition\n//   -   Subtraction\n//   *   Multiplication\n//   /   Division\n//   %   Modulo\n//   **  Exponentiation\n\n// ─── Types ───────────────────────────────────────────────────────────────────\n\n/** Operators supported by the generic `math` helper */\ntype MathOperator = \"+\" | \"-\" | \"*\" | \"/\" | \"%\" | \"**\";\n\nconst SUPPORTED_OPERATORS = new Set<string>([\"+\", \"-\", \"*\", \"/\", \"%\", \"**\"]);\n\n// ─── Internal utilities ─────────────────────────────────────────────────────\n\n/** Converts a value to a number with a fallback of `0` for math operations. */\nconst num = (value: unknown): number => toNumber(value, 0);\n\n/**\n * Applies a binary operator to two operands.\n */\nfunction applyOperator(a: number, op: MathOperator, b: number): number {\n\tswitch (op) {\n\t\tcase \"+\":\n\t\t\treturn a + b;\n\t\tcase \"-\":\n\t\t\treturn a - b;\n\t\tcase \"*\":\n\t\t\treturn a * b;\n\t\tcase \"/\":\n\t\t\treturn b === 0 ? Infinity : a / b;\n\t\tcase \"%\":\n\t\t\treturn b === 0 ? NaN : a % b;\n\t\tcase \"**\":\n\t\t\treturn a ** b;\n\t}\n}\n\n// ─── Main class ─────────────────────────────────────────────────────────────\n\nexport class MathHelpers extends HelperFactory {\n\t// ─── buildDefinitions (required by HelperFactory) ──────────────────\n\n\tprotected buildDefinitions(defs: Map<string, HelperDefinition>): void {\n\t\tthis.registerBinaryOperators(defs);\n\t\tthis.registerUnaryFunctions(defs);\n\t\tthis.registerMinMax(defs);\n\t\tthis.registerGenericMath(defs);\n\t}\n\n\t// ── Binary operators ─────────────────────────────────────────────\n\n\t/** Registers add, subtract/sub, multiply/mul, divide/div, modulo/mod, pow */\n\tprivate registerBinaryOperators(defs: Map<string, HelperDefinition>): void {\n\t\t// add — Addition : {{ add a b }}\n\t\tconst addDef: HelperDefinition = {\n\t\t\tfn: (a: unknown, b: unknown) => num(a) + num(b),\n\t\t\tparams: [\n\t\t\t\t{ name: \"a\", type: { type: \"number\" }, description: \"First operand\" },\n\t\t\t\t{ name: \"b\", type: { type: \"number\" }, description: \"Second operand\" },\n\t\t\t],\n\t\t\treturnType: { type: \"number\" },\n\t\t\tdescription: \"Adds two numbers: {{ add a b }}\",\n\t\t};\n\t\tdefs.set(\"add\", addDef);\n\n\t\t// subtract / sub — Subtraction: {{ subtract a b }} or {{ sub a b }}\n\t\tconst subtractDef: HelperDefinition = {\n\t\t\tfn: (a: unknown, b: unknown) => num(a) - num(b),\n\t\t\tparams: [\n\t\t\t\t{\n\t\t\t\t\tname: \"a\",\n\t\t\t\t\ttype: { type: \"number\" },\n\t\t\t\t\tdescription: \"Value to subtract from\",\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\tname: \"b\",\n\t\t\t\t\ttype: { type: \"number\" },\n\t\t\t\t\tdescription: \"Value to subtract\",\n\t\t\t\t},\n\t\t\t],\n\t\t\treturnType: { type: \"number\" },\n\t\t\tdescription: \"Subtracts b from a: {{ subtract a b }}\",\n\t\t};\n\t\tdefs.set(\"subtract\", subtractDef);\n\t\tdefs.set(\"sub\", subtractDef);\n\n\t\t// multiply / mul — Multiplication: {{ multiply a b }} or {{ mul a b }}\n\t\tconst multiplyDef: HelperDefinition = {\n\t\t\tfn: (a: unknown, b: unknown) => num(a) * num(b),\n\t\t\tparams: [\n\t\t\t\t{ name: \"a\", type: { type: \"number\" }, description: \"First factor\" },\n\t\t\t\t{ name: \"b\", type: { type: \"number\" }, description: \"Second factor\" },\n\t\t\t],\n\t\t\treturnType: { type: \"number\" },\n\t\t\tdescription: \"Multiplies two numbers: {{ multiply a b }}\",\n\t\t};\n\t\tdefs.set(\"multiply\", multiplyDef);\n\t\tdefs.set(\"mul\", multiplyDef);\n\n\t\t// divide / div — Division: {{ divide a b }} or {{ div a b }}\n\t\tconst divideDef: HelperDefinition = {\n\t\t\tfn: (a: unknown, b: unknown) => {\n\t\t\t\tconst divisor = num(b);\n\t\t\t\treturn divisor === 0 ? Infinity : num(a) / divisor;\n\t\t\t},\n\t\t\tparams: [\n\t\t\t\t{ name: \"a\", type: { type: \"number\" }, description: \"Dividend\" },\n\t\t\t\t{ name: \"b\", type: { type: \"number\" }, description: \"Divisor\" },\n\t\t\t],\n\t\t\treturnType: { type: \"number\" },\n\t\t\tdescription:\n\t\t\t\t\"Divides a by b: {{ divide a b }}. Returns Infinity if b is 0.\",\n\t\t};\n\t\tdefs.set(\"divide\", divideDef);\n\t\tdefs.set(\"div\", divideDef);\n\n\t\t// modulo / mod — Modulo: {{ modulo a b }} or {{ mod a b }}\n\t\tconst moduloDef: HelperDefinition = {\n\t\t\tfn: (a: unknown, b: unknown) => {\n\t\t\t\tconst divisor = num(b);\n\t\t\t\treturn divisor === 0 ? NaN : num(a) % divisor;\n\t\t\t},\n\t\t\tparams: [\n\t\t\t\t{ name: \"a\", type: { type: \"number\" }, description: \"Dividend\" },\n\t\t\t\t{ name: \"b\", type: { type: \"number\" }, description: \"Divisor\" },\n\t\t\t],\n\t\t\treturnType: { type: \"number\" },\n\t\t\tdescription: \"Returns the remainder of a divided by b: {{ modulo a b }}\",\n\t\t};\n\t\tdefs.set(\"modulo\", moduloDef);\n\t\tdefs.set(\"mod\", moduloDef);\n\n\t\t// pow — Exponentiation : {{ pow base exponent }}\n\t\tdefs.set(\"pow\", {\n\t\t\tfn: (base: unknown, exponent: unknown) => num(base) ** num(exponent),\n\t\t\tparams: [\n\t\t\t\t{ name: \"base\", type: { type: \"number\" }, description: \"The base\" },\n\t\t\t\t{\n\t\t\t\t\tname: \"exponent\",\n\t\t\t\t\ttype: { type: \"number\" },\n\t\t\t\t\tdescription: \"The exponent\",\n\t\t\t\t},\n\t\t\t],\n\t\t\treturnType: { type: \"number\" },\n\t\t\tdescription:\n\t\t\t\t\"Raises base to the power of exponent: {{ pow base exponent }}\",\n\t\t});\n\t}\n\n\t// ── Unary functions ──────────────────────────────────────────────\n\n\t/** Registers abs, ceil, floor, round, sqrt */\n\tprivate registerUnaryFunctions(defs: Map<string, HelperDefinition>): void {\n\t\t// abs — Absolute value: {{ abs value }}\n\t\tdefs.set(\"abs\", {\n\t\t\tfn: (value: unknown) => Math.abs(num(value)),\n\t\t\tparams: [\n\t\t\t\t{ name: \"value\", type: { type: \"number\" }, description: \"The number\" },\n\t\t\t],\n\t\t\treturnType: { type: \"number\" },\n\t\t\tdescription: \"Returns the absolute value: {{ abs value }}\",\n\t\t});\n\n\t\t// ceil — Round up: {{ ceil value }}\n\t\tdefs.set(\"ceil\", {\n\t\t\tfn: (value: unknown) => Math.ceil(num(value)),\n\t\t\tparams: [\n\t\t\t\t{\n\t\t\t\t\tname: \"value\",\n\t\t\t\t\ttype: { type: \"number\" },\n\t\t\t\t\tdescription: \"The number to round up\",\n\t\t\t\t},\n\t\t\t],\n\t\t\treturnType: { type: \"number\" },\n\t\t\tdescription: \"Rounds up to the nearest integer: {{ ceil value }}\",\n\t\t});\n\n\t\t// floor — Round down: {{ floor value }}\n\t\tdefs.set(\"floor\", {\n\t\t\tfn: (value: unknown) => Math.floor(num(value)),\n\t\t\tparams: [\n\t\t\t\t{\n\t\t\t\t\tname: \"value\",\n\t\t\t\t\ttype: { type: \"number\" },\n\t\t\t\t\tdescription: \"The number to round down\",\n\t\t\t\t},\n\t\t\t],\n\t\t\treturnType: { type: \"number\" },\n\t\t\tdescription: \"Rounds down to the nearest integer: {{ floor value }}\",\n\t\t});\n\n\t\t// round — Rounding: {{ round value }} or {{ round value precision }}\n\t\t// With precision: {{ round 3.14159 2 }} → 3.14\n\t\tdefs.set(\"round\", {\n\t\t\tfn: (value: unknown, precision: unknown) => {\n\t\t\t\tconst n = num(value);\n\t\t\t\t// If precision is a Handlebars options object (not a number),\n\t\t\t\t// it means the second parameter was not provided.\n\t\t\t\tif (\n\t\t\t\t\tprecision === undefined ||\n\t\t\t\t\tprecision === null ||\n\t\t\t\t\ttypeof precision === \"object\"\n\t\t\t\t) {\n\t\t\t\t\treturn Math.round(n);\n\t\t\t\t}\n\t\t\t\tconst p = num(precision);\n\t\t\t\tconst factor = 10 ** p;\n\t\t\t\treturn Math.round(n * factor) / factor;\n\t\t\t},\n\t\t\tparams: [\n\t\t\t\t{\n\t\t\t\t\tname: \"value\",\n\t\t\t\t\ttype: { type: \"number\" },\n\t\t\t\t\tdescription: \"The number to round\",\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\tname: \"precision\",\n\t\t\t\t\ttype: { type: \"number\" },\n\t\t\t\t\tdescription: \"Number of decimal places (default: 0)\",\n\t\t\t\t\toptional: true,\n\t\t\t\t},\n\t\t\t],\n\t\t\treturnType: { type: \"number\" },\n\t\t\tdescription:\n\t\t\t\t\"Rounds to the nearest integer or to a given precision: {{ round value }} or {{ round value 2 }}\",\n\t\t});\n\n\t\t// sqrt — Square root: {{ sqrt value }}\n\t\tdefs.set(\"sqrt\", {\n\t\t\tfn: (value: unknown) => Math.sqrt(num(value)),\n\t\t\tparams: [\n\t\t\t\t{ name: \"value\", type: { type: \"number\" }, description: \"The number\" },\n\t\t\t],\n\t\t\treturnType: { type: \"number\" },\n\t\t\tdescription: \"Returns the square root: {{ sqrt value }}\",\n\t\t});\n\t}\n\n\t// ── Min / Max ────────────────────────────────────────────────────\n\n\t/** Registers min and max */\n\tprivate registerMinMax(defs: Map<string, HelperDefinition>): void {\n\t\t// min — Minimum : {{ min a b }}\n\t\tdefs.set(\"min\", {\n\t\t\tfn: (a: unknown, b: unknown) => Math.min(num(a), num(b)),\n\t\t\tparams: [\n\t\t\t\t{ name: \"a\", type: { type: \"number\" }, description: \"First number\" },\n\t\t\t\t{ name: \"b\", type: { type: \"number\" }, description: \"Second number\" },\n\t\t\t],\n\t\t\treturnType: { type: \"number\" },\n\t\t\tdescription: \"Returns the smaller of two numbers: {{ min a b }}\",\n\t\t});\n\n\t\t// max — Maximum : {{ max a b }}\n\t\tdefs.set(\"max\", {\n\t\t\tfn: (a: unknown, b: unknown) => Math.max(num(a), num(b)),\n\t\t\tparams: [\n\t\t\t\t{ name: \"a\", type: { type: \"number\" }, description: \"First number\" },\n\t\t\t\t{ name: \"b\", type: { type: \"number\" }, description: \"Second number\" },\n\t\t\t],\n\t\t\treturnType: { type: \"number\" },\n\t\t\tdescription: \"Returns the larger of two numbers: {{ max a b }}\",\n\t\t});\n\t}\n\n\t// ── Generic helper ───────────────────────────────────────────────\n\n\t/** Registers the generic `math` helper with operator as a parameter */\n\tprivate registerGenericMath(defs: Map<string, HelperDefinition>): void {\n\t\t// Usage : {{ math a \"+\" b }}, {{ math a \"/\" b }}, {{ math a \"**\" b }}\n\t\tdefs.set(\"math\", {\n\t\t\tfn: (a: unknown, operator: unknown, b: unknown) => {\n\t\t\t\tconst op = String(operator);\n\t\t\t\tif (!SUPPORTED_OPERATORS.has(op)) {\n\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t`[math helper] Unknown operator \"${op}\". ` +\n\t\t\t\t\t\t\t`Supported: ${[...SUPPORTED_OPERATORS].join(\", \")} `,\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\treturn applyOperator(num(a), op as MathOperator, num(b));\n\t\t\t},\n\t\t\tparams: [\n\t\t\t\t{ name: \"a\", type: { type: \"number\" }, description: \"Left operand\" },\n\t\t\t\t{\n\t\t\t\t\tname: \"operator\",\n\t\t\t\t\ttype: { type: \"string\", enum: [\"+\", \"-\", \"*\", \"/\", \"%\", \"**\"] },\n\t\t\t\t\tdescription: 'Arithmetic operator: \"+\", \"-\", \"*\", \"/\", \"%\", \"**\"',\n\t\t\t\t},\n\t\t\t\t{ name: \"b\", type: { type: \"number\" }, description: \"Right operand\" },\n\t\t\t],\n\t\t\treturnType: { type: \"number\" },\n\t\t\tdescription:\n\t\t\t\t'Generic math helper with operator as parameter: {{ math a \"+\" b }}, {{ math a \"/\" b }}. ' +\n\t\t\t\t\"Supported operators: +, -, *, /, %, **\",\n\t\t});\n\t}\n}\n"
   ],
-  "mappings": "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",
-  "debugId": "D5BDDDBE699F089564756E2164756E21",
+  "mappings": "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",
+  "debugId": "2517AB2E996B3F7E64756E2164756E21",
   "names": []
 }

package/dist/chunk-zh1e0yhd.js

@@ -0,0 +1,7 @@
+class F extends Error{constructor(j){super(j);this.name="TemplateError"}toJSON(){return{name:this.name,message:this.message}}}class H extends F{loc;source;constructor(j,q,A){super(`Parse error: ${j}`);this.loc=q;this.source=A;this.name="TemplateParseError"}toJSON(){return{name:this.name,message:this.message,loc:this.loc,source:this.source}}}class I extends F{diagnostics;errors;warnings;errorCount;warningCount;constructor(j){let q=j.filter((B)=>B.severity==="error"),A=j.filter((B)=>B.severity==="warning"),G=q.map((B)=>M(B)).join(`
+`);super(`Static analysis failed with ${q.length} error(s):
+${G}`);this.name="TemplateAnalysisError",this.diagnostics=j,this.errors=q,this.warnings=A,this.errorCount=q.length,this.warningCount=A.length}toJSON(){return{name:this.name,message:this.message,errorCount:this.errorCount,warningCount:this.warningCount,diagnostics:this.diagnostics}}}class J extends F{constructor(j){super(`Runtime error: ${j}`);this.name="TemplateRuntimeError"}}class K extends F{keyword;schemaPath;constructor(j,q){super(`Unsupported JSON Schema feature: "${j}" at "${q}". Conditional schemas (if/then/else) cannot be resolved during static analysis because they depend on runtime data. Consider using oneOf/anyOf combinators instead.`);this.keyword=j;this.schemaPath=q;this.name="UnsupportedSchemaError"}toJSON(){return{name:this.name,message:this.message,keyword:this.keyword,schemaPath:this.schemaPath}}}function M(j){let q=[`  • [${j.code}] ${j.message}`];if(j.loc)q.push(`(at ${j.loc.start.line}:${j.loc.start.column})`);return q.join(" ")}function O(j,q){let A=`Property "${j}" does not exist in the context schema`;if(q.length===0)return A;return`${A}. Available properties: ${q.join(", ")}`}function Q(j,q,A){return`"{{#${j}}}" expects ${q}, but resolved schema has type "${A}"`}function R(j){return`"{{#${j}}}" requires an argument`}function S(j){return`Unknown block helper "{{#${j}}}" — cannot analyze statically`}function U(j){return`Expression of type "${j}" cannot be statically analyzed`}
+export{F as K,H as L,I as M,J as N,K as O,O as P,Q,R,S,U as T};
+
+//# debugId=B837B229D55D66E864756E2164756E21
+//# sourceMappingURL=chunk-zh1e0yhd.js.map

package/dist/chunk-zh1e0yhd.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/errors.ts"],
+  "sourcesContent": [
+    "import type { TemplateDiagnostic } from \"./types.ts\";\n\n// ─── Base Class ──────────────────────────────────────────────────────────────\n// All template engine errors extend this class, enabling targeted catch blocks:\n// `catch (e) { if (e instanceof TemplateError) … }`\n// Subclasses:\n// - `TemplateParseError`        — invalid template syntax\n// - `TemplateAnalysisError`     — static analysis failures (diagnostics)\n// - `TemplateRuntimeError`      — execution failures\n// - `UnsupportedSchemaError`    — schema uses unsupported JSON Schema features\n\nexport class TemplateError extends Error {\n\tconstructor(message: string) {\n\t\tsuper(message);\n\t\tthis.name = \"TemplateError\";\n\t}\n\n\t/**\n\t * Serializes the error into a JSON-compatible object, suitable for sending\n\t * to a frontend or a structured logging system.\n\t */\n\ttoJSON(): Record<string, unknown> {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tmessage: this.message,\n\t\t};\n\t}\n}\n\n// ─── Parse Error ─────────────────────────────────────────────────────────────\n// Thrown when Handlebars fails to parse the template (invalid syntax).\n\nexport class TemplateParseError extends TemplateError {\n\tconstructor(\n\t\tmessage: string,\n\t\t/** Approximate position of the error in the source */\n\t\tpublic readonly loc?: { line: number; column: number },\n\t\t/** Fragment of the template source around the error */\n\t\tpublic readonly source?: string,\n\t) {\n\t\tsuper(`Parse error: ${message}`);\n\t\tthis.name = \"TemplateParseError\";\n\t}\n\n\toverride toJSON(): Record<string, unknown> {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tmessage: this.message,\n\t\t\tloc: this.loc,\n\t\t\tsource: this.source,\n\t\t};\n\t}\n}\n\n// ─── Static Analysis Error ───────────────────────────────────────────────────\n// Thrown in strict mode when the analysis produces at least one error.\n// Contains the full list of diagnostics for detailed inspection.\n\nexport class TemplateAnalysisError extends TemplateError {\n\t/** Full list of diagnostics (errors + warnings) */\n\tpublic readonly diagnostics: TemplateDiagnostic[];\n\n\t/** Only diagnostics with \"error\" severity */\n\tpublic readonly errors: TemplateDiagnostic[];\n\n\t/** Only diagnostics with \"warning\" severity */\n\tpublic readonly warnings: TemplateDiagnostic[];\n\n\t/** Total number of errors */\n\tpublic readonly errorCount: number;\n\n\t/** Total number of warnings */\n\tpublic readonly warningCount: number;\n\n\tconstructor(diagnostics: TemplateDiagnostic[]) {\n\t\tconst errors = diagnostics.filter((d) => d.severity === \"error\");\n\t\tconst warnings = diagnostics.filter((d) => d.severity === \"warning\");\n\n\t\tconst summary = errors.map((d) => formatDiagnosticLine(d)).join(\"\\n\");\n\t\tsuper(`Static analysis failed with ${errors.length} error(s):\\n${summary}`);\n\n\t\tthis.name = \"TemplateAnalysisError\";\n\t\tthis.diagnostics = diagnostics;\n\t\tthis.errors = errors;\n\t\tthis.warnings = warnings;\n\t\tthis.errorCount = errors.length;\n\t\tthis.warningCount = warnings.length;\n\t}\n\n\t/**\n\t * Serializes the analysis error into a JSON-compatible object.\n\t *\n\t * Designed for direct use in API responses:\n\t * ```\n\t * res.status(400).json(error.toJSON());\n\t * ```\n\t *\n\t * Returned structure:\n\t * ```\n\t * {\n\t *   name: \"TemplateAnalysisError\",\n\t *   message: \"Static analysis failed with 2 error(s): ...\",\n\t *   errorCount: 2,\n\t *   warningCount: 0,\n\t *   diagnostics: [\n\t *     {\n\t *       severity: \"error\",\n\t *       code: \"UNKNOWN_PROPERTY\",\n\t *       message: \"Property \\\"foo\\\" does not exist...\",\n\t *       loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 7 } },\n\t *       source: \"{{foo}}\",\n\t *       details: { path: \"foo\", availableProperties: [\"name\", \"age\"] }\n\t *     }\n\t *   ]\n\t * }\n\t * ```\n\t */\n\toverride toJSON(): Record<string, unknown> {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tmessage: this.message,\n\t\t\terrorCount: this.errorCount,\n\t\t\twarningCount: this.warningCount,\n\t\t\tdiagnostics: this.diagnostics,\n\t\t};\n\t}\n}\n\n// ─── Runtime Error ───────────────────────────────────────────────────────────\n// Thrown when template execution fails (accessing a non-existent property\n// in strict mode, unexpected type, etc.).\n\nexport class TemplateRuntimeError extends TemplateError {\n\tconstructor(message: string) {\n\t\tsuper(`Runtime error: ${message}`);\n\t\tthis.name = \"TemplateRuntimeError\";\n\t}\n}\n\n// ─── Unsupported Schema Error ────────────────────────────────────────────────\n// Thrown when the provided JSON Schema uses features that cannot be handled\n// by static analysis (e.g. `if/then/else` conditional schemas).\n//\n// These features are data-dependent and fundamentally non-resolvable without\n// runtime values. Rather than silently ignoring them (which would produce\n// incorrect analysis results), we fail fast with a clear error message.\n\nexport class UnsupportedSchemaError extends TemplateError {\n\tconstructor(\n\t\t/** The unsupported keyword(s) detected (e.g. `\"if/then/else\"`) */\n\t\tpublic readonly keyword: string,\n\t\t/** JSON pointer path to the location in the schema (e.g. `\"/properties/user\"`) */\n\t\tpublic readonly schemaPath: string,\n\t) {\n\t\tsuper(\n\t\t\t`Unsupported JSON Schema feature: \"${keyword}\" at \"${schemaPath}\". ` +\n\t\t\t\t\"Conditional schemas (if/then/else) cannot be resolved during static analysis \" +\n\t\t\t\t\"because they depend on runtime data. Consider using oneOf/anyOf combinators instead.\",\n\t\t);\n\t\tthis.name = \"UnsupportedSchemaError\";\n\t}\n\n\toverride toJSON(): Record<string, unknown> {\n\t\treturn {\n\t\t\tname: this.name,\n\t\t\tmessage: this.message,\n\t\t\tkeyword: this.keyword,\n\t\t\tschemaPath: this.schemaPath,\n\t\t};\n\t}\n}\n\n// ─── Internal Utilities ──────────────────────────────────────────────────────\n\n/**\n * Formats a single diagnostic line for the summary message\n * of a `TemplateAnalysisError`.\n *\n * Produces a human-readable format:\n *   `  • [UNKNOWN_PROPERTY] Property \"foo\" does not exist (at 1:0)`\n */\nfunction formatDiagnosticLine(diag: TemplateDiagnostic): string {\n\tconst parts: string[] = [`  • [${diag.code}] ${diag.message}`];\n\n\tif (diag.loc) {\n\t\tparts.push(`(at ${diag.loc.start.line}:${diag.loc.start.column})`);\n\t}\n\n\treturn parts.join(\" \");\n}\n\n// ─── Common Error Factories ──────────────────────────────────────────────────\n// These functions simplify the creation of typed errors across the codebase.\n\n/**\n * Creates a structured diagnostic message for a missing property.\n * Used by the analyzer to produce enriched error messages with suggestions.\n */\nexport function createPropertyNotFoundMessage(\n\tpath: string,\n\tavailableProperties: string[],\n): string {\n\tconst base = `Property \"${path}\" does not exist in the context schema`;\n\tif (availableProperties.length === 0) return base;\n\treturn `${base}. Available properties: ${availableProperties.join(\", \")}`;\n}\n\n/**\n * Creates a message for a type mismatch on a block helper.\n */\nexport function createTypeMismatchMessage(\n\thelperName: string,\n\texpected: string,\n\tactual: string,\n): string {\n\treturn `\"{{#${helperName}}}\" expects ${expected}, but resolved schema has type \"${actual}\"`;\n}\n\n/**\n * Creates a message for a missing argument on a block helper.\n */\nexport function createMissingArgumentMessage(helperName: string): string {\n\treturn `\"{{#${helperName}}}\" requires an argument`;\n}\n\n/**\n * Creates a message for an unknown block helper.\n */\nexport function createUnknownHelperMessage(helperName: string): string {\n\treturn `Unknown block helper \"{{#${helperName}}}\" — cannot analyze statically`;\n}\n\n/**\n * Creates a message for an expression that cannot be statically analyzed.\n */\nexport function createUnanalyzableMessage(nodeType: string): string {\n\treturn `Expression of type \"${nodeType}\" cannot be statically analyzed`;\n}\n"
+  ],
+  "mappings": "AAWO,MAAM,UAAsB,KAAM,CACxC,WAAW,CAAC,EAAiB,CAC5B,MAAM,CAAO,EACb,KAAK,KAAO,gBAOb,MAAM,EAA4B,CACjC,MAAO,CACN,KAAM,KAAK,KACX,QAAS,KAAK,OACf,EAEF,CAKO,MAAM,UAA2B,CAAc,CAIpC,IAEA,OALjB,WAAW,CACV,EAEgB,EAEA,EACf,CACD,MAAM,gBAAgB,GAAS,EAJf,WAEA,cAGhB,KAAK,KAAO,qBAGJ,MAAM,EAA4B,CAC1C,MAAO,CACN,KAAM,KAAK,KACX,QAAS,KAAK,QACd,IAAK,KAAK,IACV,OAAQ,KAAK,MACd,EAEF,CAMO,MAAM,UAA8B,CAAc,CAExC,YAGA,OAGA,SAGA,WAGA,aAEhB,WAAW,CAAC,EAAmC,CAC9C,IAAM,EAAS,EAAY,OAAO,CAAC,IAAM,EAAE,WAAa,OAAO,EACzD,EAAW,EAAY,OAAO,CAAC,IAAM,EAAE,WAAa,SAAS,EAE7D,EAAU,EAAO,IAAI,CAAC,IAAM,EAAqB,CAAC,CAAC,EAAE,KAAK;AAAA,CAAI,EACpE,MAAM,+BAA+B,EAAO;AAAA,EAAqB,GAAS,EAE1E,KAAK,KAAO,wBACZ,KAAK,YAAc,EACnB,KAAK,OAAS,EACd,KAAK,SAAW,EAChB,KAAK,WAAa,EAAO,OACzB,KAAK,aAAe,EAAS,OA+BrB,MAAM,EAA4B,CAC1C,MAAO,CACN,KAAM,KAAK,KACX,QAAS,KAAK,QACd,WAAY,KAAK,WACjB,aAAc,KAAK,aACnB,YAAa,KAAK,WACnB,EAEF,CAMO,MAAM,UAA6B,CAAc,CACvD,WAAW,CAAC,EAAiB,CAC5B,MAAM,kBAAkB,GAAS,EACjC,KAAK,KAAO,uBAEd,CAUO,MAAM,UAA+B,CAAc,CAGxC,QAEA,WAJjB,WAAW,CAEM,EAEA,EACf,CACD,MACC,qCAAqC,UAAgB,uKAGtD,EARgB,eAEA,kBAOhB,KAAK,KAAO,yBAGJ,MAAM,EAA4B,CAC1C,MAAO,CACN,KAAM,KAAK,KACX,QAAS,KAAK,QACd,QAAS,KAAK,QACd,WAAY,KAAK,UAClB,EAEF,CAWA,SAAS,CAAoB,CAAC,EAAkC,CAC/D,IAAM,EAAkB,CAAC,QAAO,EAAK,SAAS,EAAK,SAAS,EAE5D,GAAI,EAAK,IACR,EAAM,KAAK,OAAO,EAAK,IAAI,MAAM,QAAQ,EAAK,IAAI,MAAM,SAAS,EAGlE,OAAO,EAAM,KAAK,GAAG,EAUf,SAAS,CAA6B,CAC5C,EACA,EACS,CACT,IAAM,EAAO,aAAa,0CAC1B,GAAI,EAAoB,SAAW,EAAG,OAAO,EAC7C,MAAO,GAAG,4BAA+B,EAAoB,KAAK,IAAI,IAMhE,SAAS,CAAyB,CACxC,EACA,EACA,EACS,CACT,MAAO,OAAO,gBAAyB,oCAA2C,KAM5E,SAAS,CAA4B,CAAC,EAA4B,CACxE,MAAO,OAAO,4BAMR,SAAS,CAA0B,CAAC,EAA4B,CACtE,MAAO,4BAA4B,mCAM7B,SAAS,CAAyB,CAAC,EAA0B,CACnE,MAAO,uBAAuB",
+  "debugId": "B837B229D55D66E864756E2164756E21",
+  "names": []
+}

package/dist/compiled-template.js

@@ -1,4 +1,4 @@
-import{b as a}from"./chunk-kznb0bev.js";import"./chunk-1qwj7pjc.js";import"./chunk-qpzzr2rd.js";import"./chunk-6955jpr7.js";import"./chunk-1gm6cf0e.js";import"./chunk-ybh51hbe.js";import"./chunk-8g0d6h85.js";import"./chunk-4zv02svp.js";export{a as CompiledTemplate};
+import{b as a}from"./chunk-ecs3yth2.js";import"./chunk-t6n956qz.js";import"./chunk-efqd0598.js";import"./chunk-6955jpr7.js";import"./chunk-rkrp4ysw.js";import"./chunk-jms1ndxn.js";import"./chunk-p5efqsxw.js";import"./chunk-zh1e0yhd.js";export{a as CompiledTemplate};
 
 //# debugId=771271DE7F3CA9FE64756E2164756E21
 //# sourceMappingURL=compiled-template.js.map

package/dist/errors.d.ts

@@ -70,6 +70,18 @@ export declare class TemplateAnalysisError extends TemplateError {
 export declare class TemplateRuntimeError extends TemplateError {
     constructor(message: string);
 }
+export declare class UnsupportedSchemaError extends TemplateError {
+    /** The unsupported keyword(s) detected (e.g. `"if/then/else"`) */
+    readonly keyword: string;
+    /** JSON pointer path to the location in the schema (e.g. `"/properties/user"`) */
+    readonly schemaPath: string;
+    constructor(
+    /** The unsupported keyword(s) detected (e.g. `"if/then/else"`) */
+    keyword: string, 
+    /** JSON pointer path to the location in the schema (e.g. `"/properties/user"`) */
+    schemaPath: string);
+    toJSON(): Record<string, unknown>;
+}
 /**
  * Creates a structured diagnostic message for a missing property.
  * Used by the analyzer to produce enriched error messages with suggestions.

package/dist/errors.js

@@ -1,4 +1,4 @@
-import{A as b,B as c,C as d,D as e,E as f,F as g,G as h,H as i,z as a}from"./chunk-ybh51hbe.js";export{h as createUnknownHelperMessage,i as createUnanalyzableMessage,f as createTypeMismatchMessage,e as createPropertyNotFoundMessage,g as createMissingArgumentMessage,d as TemplateRuntimeError,b as TemplateParseError,a as TemplateError,c as TemplateAnalysisError};
+import{K as a,L as b,M as c,N as d,O as e,P as f,Q as g,R as h,S as i,T as j}from"./chunk-zh1e0yhd.js";export{i as createUnknownHelperMessage,j as createUnanalyzableMessage,g as createTypeMismatchMessage,f as createPropertyNotFoundMessage,h as createMissingArgumentMessage,e as UnsupportedSchemaError,d as TemplateRuntimeError,b as TemplateParseError,a as TemplateError,c as TemplateAnalysisError};
 
-//# debugId=043280437018AA4064756E2164756E21
+//# debugId=5F99984E8843AC9E64756E2164756E21
 //# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -4,6 +4,6 @@
   "sourcesContent": [
   ],
   "mappings": "",
-  "debugId": "043280437018AA4064756E2164756E21",
+  "debugId": "5F99984E8843AC9E64756E2164756E21",
   "names": []
 }

package/dist/executor.js

@@ -1,4 +1,4 @@
-import{f as a,g as b,h as c,i as d}from"./chunk-qpzzr2rd.js";import"./chunk-6955jpr7.js";import"./chunk-1gm6cf0e.js";import"./chunk-ybh51hbe.js";import"./chunk-4zv02svp.js";export{c as resolveDataPath,b as executeFromAst,a as execute,d as clearCompilationCache};
+import{f as a,g as b,h as c,i as d}from"./chunk-efqd0598.js";import"./chunk-6955jpr7.js";import"./chunk-rkrp4ysw.js";import"./chunk-p5efqsxw.js";import"./chunk-zh1e0yhd.js";export{c as resolveDataPath,b as executeFromAst,a as execute,d as clearCompilationCache};
 
 //# debugId=E439EBF232D2886264756E2164756E21
 //# sourceMappingURL=executor.js.map

package/dist/index.d.ts

@@ -1,2 +1,3 @@
+export * from "./errors.ts";
 export { Typebars } from "./typebars.ts";
 export { defineHelper } from "./types.ts";

package/dist/index.js

@@ -1,4 +1,4 @@
-import{a as r}from"./chunk-7j6q1e3z.js";import"./chunk-kznb0bev.js";import"./chunk-1qwj7pjc.js";import"./chunk-qpzzr2rd.js";import{m as e}from"./chunk-6955jpr7.js";import"./chunk-1gm6cf0e.js";import"./chunk-ybh51hbe.js";import"./chunk-8g0d6h85.js";import"./chunk-4zv02svp.js";export{e as defineHelper,r as Typebars};
+import{a as r}from"./chunk-xd2vmd03.js";import"./chunk-ecs3yth2.js";import"./chunk-t6n956qz.js";import"./chunk-efqd0598.js";import{m as e}from"./chunk-6955jpr7.js";import"./chunk-rkrp4ysw.js";import"./chunk-jms1ndxn.js";import"./chunk-p5efqsxw.js";import{K as t,L as x,M as a,N as b,O as d,P as i,Q as l,R as n,S as s,T as y}from"./chunk-zh1e0yhd.js";export{e as defineHelper,s as createUnknownHelperMessage,y as createUnanalyzableMessage,l as createTypeMismatchMessage,i as createPropertyNotFoundMessage,n as createMissingArgumentMessage,d as UnsupportedSchemaError,r as Typebars,b as TemplateRuntimeError,x as TemplateParseError,t as TemplateError,a as TemplateAnalysisError};
 
-//# debugId=55D58DC910FCA0B664756E2164756E21
+//# debugId=907E45F8A123358764756E2164756E21
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -4,6 +4,6 @@
   "sourcesContent": [
   ],
   "mappings": "",
-  "debugId": "55D58DC910FCA0B664756E2164756E21",
+  "debugId": "907E45F8A123358764756E2164756E21",
   "names": []
 }

package/dist/parser.js

@@ -1,4 +1,4 @@
-import{n as a,o as b,p as c,q as d,r as e,s as f,t as g,u as h,v as i,w as j,x as k,y as l}from"./chunk-1gm6cf0e.js";import"./chunk-ybh51hbe.js";export{k as parseIdentifier,a as parse,d as isThisExpression,b as isSingleExpression,g as getEffectivelySingleExpression,f as getEffectivelySingleBlock,e as getEffectiveBody,c as extractPathSegments,l as extractExpressionIdentifier,i as detectLiteralType,j as coerceLiteral,h as canUseFastPath};
+import{n as a,o as b,p as c,q as d,r as e,s as f,t as g,u as h,v as i,w as j,x as k,y as l}from"./chunk-rkrp4ysw.js";import"./chunk-zh1e0yhd.js";export{k as parseIdentifier,a as parse,d as isThisExpression,b as isSingleExpression,g as getEffectivelySingleExpression,f as getEffectivelySingleBlock,e as getEffectiveBody,c as extractPathSegments,l as extractExpressionIdentifier,i as detectLiteralType,j as coerceLiteral,h as canUseFastPath};
 
 //# debugId=238977E59328291964756E2164756E21
 //# sourceMappingURL=parser.js.map

package/dist/schema-resolver.d.ts

@@ -1,4 +1,42 @@
 import type { JSONSchema7 } from "json-schema";
+/**
+ * Recursively validates that a JSON Schema does not contain `if/then/else`
+ * conditional keywords. Throws an `UnsupportedSchemaError` if any are found.
+ *
+ * This check traverses the entire schema tree, including:
+ * - `properties` values
+ * - `additionalProperties` (when it's a schema)
+ * - `items` (single schema or tuple)
+ * - `allOf`, `anyOf`, `oneOf` branches
+ * - `not`
+ * - `definitions` / `$defs` values
+ *
+ * A `Set<object>` is used to track visited schemas and prevent infinite loops
+ * from circular structures.
+ *
+ * @param schema - The JSON Schema to validate
+ * @param path   - The current JSON pointer path (for error reporting)
+ * @param visited - Set of already-visited schema objects (cycle protection)
+ *
+ * @throws {UnsupportedSchemaError} if `if`, `then`, or `else` is found
+ *
+ * @example
+ * ```
+ * // Throws UnsupportedSchemaError:
+ * assertNoConditionalSchema({
+ *   type: "object",
+ *   if: { properties: { kind: { const: "a" } } },
+ *   then: { properties: { a: { type: "string" } } },
+ * });
+ *
+ * // OK — no conditional keywords:
+ * assertNoConditionalSchema({
+ *   type: "object",
+ *   properties: { name: { type: "string" } },
+ * });
+ * ```
+ */
+export declare function assertNoConditionalSchema(schema: JSONSchema7, path?: string, visited?: Set<object>): void;
 /**
  * Recursively resolves `$ref` in a schema using the root schema as the
  * source of definitions.

package/dist/schema-resolver.js

@@ -1,4 +1,4 @@
-import{I as a,J as b,K as c,L as d}from"./chunk-8g0d6h85.js";import"./chunk-4zv02svp.js";export{d as simplifySchema,b as resolveSchemaPath,a as resolveRef,c as resolveArrayItems};
+import{A as b,B as c,C as d,D as e,z as a}from"./chunk-jms1ndxn.js";import"./chunk-p5efqsxw.js";import"./chunk-zh1e0yhd.js";export{e as simplifySchema,c as resolveSchemaPath,b as resolveRef,d as resolveArrayItems,a as assertNoConditionalSchema};
 
-//# debugId=0ED578ADCD4302EE64756E2164756E21
+//# debugId=EA8E60A23E3E11CC64756E2164756E21
 //# sourceMappingURL=schema-resolver.js.map

package/dist/schema-resolver.js.map

@@ -4,6 +4,6 @@
   "sourcesContent": [
   ],
   "mappings": "",
-  "debugId": "0ED578ADCD4302EE64756E2164756E21",
+  "debugId": "EA8E60A23E3E11CC64756E2164756E21",
   "names": []
 }

package/dist/typebars.js

@@ -1,4 +1,4 @@
-import{a}from"./chunk-7j6q1e3z.js";import"./chunk-kznb0bev.js";import"./chunk-1qwj7pjc.js";import"./chunk-qpzzr2rd.js";import"./chunk-6955jpr7.js";import"./chunk-1gm6cf0e.js";import"./chunk-ybh51hbe.js";import"./chunk-8g0d6h85.js";import"./chunk-4zv02svp.js";export{a as Typebars};
+import{a}from"./chunk-xd2vmd03.js";import"./chunk-ecs3yth2.js";import"./chunk-t6n956qz.js";import"./chunk-efqd0598.js";import"./chunk-6955jpr7.js";import"./chunk-rkrp4ysw.js";import"./chunk-jms1ndxn.js";import"./chunk-p5efqsxw.js";import"./chunk-zh1e0yhd.js";export{a as Typebars};
 
 //# debugId=AADE9F1482151B2C64756E2164756E21
 //# sourceMappingURL=typebars.js.map

package/dist/utils.js

@@ -1,4 +1,4 @@
-import{M as a,N as b,O as c,P as d,Q as e,R as f}from"./chunk-4zv02svp.js";export{d as getSchemaPropertyNames,c as extractSourceSnippet,a as deepEqual,f as aggregateObjectAnalysisAndExecution,e as aggregateObjectAnalysis,b as LRUCache};
+import{E as a,F as b,G as c,H as d,I as e,J as f}from"./chunk-p5efqsxw.js";export{d as getSchemaPropertyNames,c as extractSourceSnippet,a as deepEqual,f as aggregateObjectAnalysisAndExecution,e as aggregateObjectAnalysis,b as LRUCache};
 
-//# debugId=F71EB52AAB98830164756E2164756E21
+//# debugId=6C8BFE07B8FFC81B64756E2164756E21
 //# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -4,6 +4,6 @@
   "sourcesContent": [
   ],
   "mappings": "",
-  "debugId": "F71EB52AAB98830164756E2164756E21",
+  "debugId": "6C8BFE07B8FFC81B64756E2164756E21",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "typebars",
-	"version": "1.0.1",
+	"version": "1.0.2",
 	"license": "MIT",
 	"description": "Typebars is a type-safe handlebars based template engine for generating object or content with static type checking",
 	"author": {

package/dist/chunk-1qwj7pjc.js

@@ -1,4 +0,0 @@
-import{j as g,k as v,l as f}from"./chunk-6955jpr7.js";import{n as k,p as q,q as C,r as D,s as W,t as E,v as T,y as P}from"./chunk-1gm6cf0e.js";import{D as $,E as B,F as U,G as M,H as b}from"./chunk-ybh51hbe.js";import{J as _,K as S,L as V}from"./chunk-8g0d6h85.js";import{M as y,O as u,P as Z,Q as N}from"./chunk-4zv02svp.js";function l(j,w,A){if(v(j))return i(j,w,A);if(g(j))return{valid:!0,diagnostics:[],outputSchema:f(j)};let F=k(j);return p(F,j,w,{identifierSchemas:A})}function i(j,w,A){return N(Object.keys(j),(F)=>l(j[F],w,A))}function p(j,w,A,F){let z={root:A,current:A,diagnostics:[],template:w,identifierSchemas:F?.identifierSchemas,helpers:F?.helpers},H=J(j,z);return{valid:!z.diagnostics.some((G)=>G.severity==="error"),diagnostics:z.diagnostics,outputSchema:V(H)}}function a(j,w){switch(j.type){case"ContentStatement":case"CommentStatement":return;case"MustacheStatement":return h(j,w);case"BlockStatement":return Y(j,w);default:K(w,"UNANALYZABLE","warning",`Unsupported AST node type: "${j.type}"`,j);return}}function h(j,w){if(j.path.type==="SubExpression")return K(w,"UNANALYZABLE","warning","Sub-expressions are not statically analyzable",j),{};if(j.params.length>0||j.hash){let A=d(j.path),F=w.helpers?.get(A);if(F){let z=F.params;if(z){let H=z.filter((I)=>!I.optional).length;if(j.params.length<H)K(w,"MISSING_ARGUMENT","error",`Helper "${A}" expects at least ${H} argument(s), but got ${j.params.length}`,j,{helperName:A,expected:`${H} argument(s)`,actual:`${j.params.length} argument(s)`})}for(let H=0;H<j.params.length;H++){let I=R(j.params[H],w,j),G=z?.[H];if(I&&G?.type){let L=G.type;if(!o(I,L)){let O=G.name;K(w,"TYPE_MISMATCH","error",`Helper "${A}" parameter "${O}" expects ${Q(L)}, but got ${Q(I)}`,j,{helperName:A,expected:Q(L),actual:Q(I)})}}}return F.returnType??{type:"string"}}return K(w,"UNKNOWN_HELPER","warning",`Unknown inline helper "${A}" — cannot analyze statically`,j,{helperName:A}),{type:"string"}}return R(j.path,w,j)??{}}function o(j,w){if(!w.type||!j.type)return!0;let A=Array.isArray(w.type)?w.type:[w.type];return(Array.isArray(j.type)?j.type:[j.type]).some((z)=>A.some((H)=>z===H||H==="number"&&z==="integer"||H==="integer"&&z==="number"))}function J(j,w){let A=D(j);if(A.length===0)return{type:"string"};let F=E(j);if(F)return h(F,w);let z=W(j);if(z)return Y(z,w);if(A.every((G)=>G.type==="ContentStatement")){let G=A.map((O)=>O.value).join("").trim();if(G==="")return{type:"string"};let L=T(G);if(L)return{type:L}}if(A.every((G)=>G.type==="BlockStatement")){let G=[];for(let L of A){let O=Y(L,w);if(O)G.push(O)}if(G.length===1)return G[0];if(G.length>1)return V({oneOf:G});return{type:"string"}}for(let G of j.body)a(G,w);return{type:"string"}}function Y(j,w){let A=m(j);switch(A){case"if":case"unless":{let F=X(j);if(F)R(F,w,j);else K(w,"MISSING_ARGUMENT","error",U(A),j,{helperName:A});let z=J(j.program,w);if(j.inverse){let H=J(j.inverse,w);if(y(z,H))return z;return V({oneOf:[z,H]})}return z}case"each":{let F=X(j);if(!F){K(w,"MISSING_ARGUMENT","error",U("each"),j,{helperName:"each"});let G=w.current;if(w.current={},J(j.program,w),w.current=G,j.inverse)J(j.inverse,w);return{type:"string"}}let z=R(F,w,j);if(!z){let G=w.current;if(w.current={},J(j.program,w),w.current=G,j.inverse)J(j.inverse,w);return{type:"string"}}let H=S(z,w.root);if(!H){K(w,"TYPE_MISMATCH","error",B("each","an array",Q(z)),j,{helperName:"each",expected:"array",actual:Q(z)});let G=w.current;if(w.current={},J(j.program,w),w.current=G,j.inverse)J(j.inverse,w);return{type:"string"}}let I=w.current;if(w.current=H,J(j.program,w),w.current=I,j.inverse)J(j.inverse,w);return{type:"string"}}case"with":{let F=X(j);if(!F){K(w,"MISSING_ARGUMENT","error",U("with"),j,{helperName:"with"});let G=w.current;w.current={};let L=J(j.program,w);if(w.current=G,j.inverse)J(j.inverse,w);return L}let z=R(F,w,j),H=w.current;w.current=z??{};let I=J(j.program,w);if(w.current=H,j.inverse)J(j.inverse,w);return I}default:{let F=w.helpers?.get(A);if(F){for(let z of j.params)R(z,w,j);if(J(j.program,w),j.inverse)J(j.inverse,w);return F.returnType??{type:"string"}}if(K(w,"UNKNOWN_HELPER","warning",M(A),j,{helperName:A}),J(j.program,w),j.inverse)J(j.inverse,w);return{type:"string"}}}}function R(j,w,A){if(C(j))return w.current;if(j.type==="SubExpression")return r(j,w,A);let F=q(j);if(F.length===0){if(j.type==="StringLiteral")return{type:"string"};if(j.type==="NumberLiteral")return{type:"number"};if(j.type==="BooleanLiteral")return{type:"boolean"};if(j.type==="NullLiteral")return{type:"null"};if(j.type==="UndefinedLiteral")return{};K(w,"UNANALYZABLE","warning",b(j.type),A??j);return}let{cleanSegments:z,identifier:H}=P(F);if(H!==null)return x(z,H,w,A??j);let I=_(w.current,z);if(I===void 0){let G=z.join("."),L=Z(w.current);K(w,"UNKNOWN_PROPERTY","error",$(G,L),A??j,{path:G,availableProperties:L});return}return I}function x(j,w,A,F){let z=j.join(".");if(!A.identifierSchemas){K(A,"MISSING_IDENTIFIER_SCHEMAS","error",`Property "${z}:${w}" uses an identifier but no identifier schemas were provided`,F,{path:`${z}:${w}`,identifier:w});return}let H=A.identifierSchemas[w];if(!H){K(A,"UNKNOWN_IDENTIFIER","error",`Property "${z}:${w}" references identifier ${w} but no schema exists for this identifier`,F,{path:`${z}:${w}`,identifier:w});return}let I=_(H,j);if(I===void 0){let G=Z(H);K(A,"IDENTIFIER_PROPERTY_NOT_FOUND","error",`Property "${z}" does not exist in the schema for identifier ${w}`,F,{path:z,identifier:w,availableProperties:G});return}return I}function r(j,w,A){let F=d(j.path),z=w.helpers?.get(F);if(!z)return K(w,"UNKNOWN_HELPER","warning",`Unknown sub-expression helper "${F}" — cannot analyze statically`,A??j,{helperName:F}),{type:"string"};let H=z.params;if(H){let I=H.filter((G)=>!G.optional).length;if(j.params.length<I)K(w,"MISSING_ARGUMENT","error",`Helper "${F}" expects at least ${I} argument(s), but got ${j.params.length}`,A??j,{helperName:F,expected:`${I} argument(s)`,actual:`${j.params.length} argument(s)`})}for(let I=0;I<j.params.length;I++){let G=R(j.params[I],w,A??j),L=H?.[I];if(G&&L?.type){let O=L.type;if(!o(G,O)){let n=L.name;K(w,"TYPE_MISMATCH","error",`Helper "${F}" parameter "${n}" expects ${Q(O)}, but got ${Q(G)}`,A??j,{helperName:F,expected:Q(O),actual:Q(G)})}}}return z.returnType??{type:"string"}}function X(j){return j.params[0]}function m(j){if(j.path.type==="PathExpression")return j.path.original;return""}function d(j){if(j.type==="PathExpression")return j.original;return""}function K(j,w,A,F,z,H){let I={severity:A,code:w,message:F};if(z&&"loc"in z&&z.loc)I.loc={start:{line:z.loc.start.line,column:z.loc.start.column},end:{line:z.loc.end.line,column:z.loc.end.column}},I.source=u(j.template,I.loc);if(H)I.details=H;j.diagnostics.push(I)}function Q(j){if(j.type)return Array.isArray(j.type)?j.type.join(" | "):j.type;if(j.oneOf)return"oneOf(...)";if(j.anyOf)return"anyOf(...)";if(j.allOf)return"allOf(...)";if(j.enum)return"enum";return"unknown"}export{l as c,p as d,Y as e};
-
-//# debugId=812E930FBACC0FA364756E2164756E21
-//# sourceMappingURL=chunk-1qwj7pjc.js.map

package/dist/chunk-1qwj7pjc.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/analyzer.ts"],
-  "sourcesContent": [
-    "import type { JSONSchema7 } from \"json-schema\";\nimport {\n\tcreateMissingArgumentMessage,\n\tcreatePropertyNotFoundMessage,\n\tcreateTypeMismatchMessage,\n\tcreateUnanalyzableMessage,\n\tcreateUnknownHelperMessage,\n} from \"./errors.ts\";\nimport {\n\tdetectLiteralType,\n\textractExpressionIdentifier,\n\textractPathSegments,\n\tgetEffectiveBody,\n\tgetEffectivelySingleBlock,\n\tgetEffectivelySingleExpression,\n\tisThisExpression,\n\tparse,\n} from \"./parser.ts\";\nimport {\n\tresolveArrayItems,\n\tresolveSchemaPath,\n\tsimplifySchema,\n} from \"./schema-resolver.ts\";\nimport type {\n\tAnalysisResult,\n\tDiagnosticCode,\n\tDiagnosticDetails,\n\tHelperDefinition,\n\tTemplateDiagnostic,\n\tTemplateInput,\n\tTemplateInputObject,\n} from \"./types.ts\";\nimport {\n\tinferPrimitiveSchema,\n\tisLiteralInput,\n\tisObjectInput,\n} from \"./types.ts\";\nimport {\n\taggregateObjectAnalysis,\n\tdeepEqual,\n\textractSourceSnippet,\n\tgetSchemaPropertyNames,\n} from \"./utils.ts\";\n\n// ─── Static Analyzer ─────────────────────────────────────────────────────────\n// Static analysis of a Handlebars template against a JSON Schema v7\n// describing the available context.\n//\n// Merged architecture (v2):\n// A single AST traversal performs both **validation** and **return type\n// inference** simultaneously. This eliminates duplication between the former\n// `validate*` and `infer*` functions and improves performance by avoiding\n// a double traversal.\n//\n// Context:\n// The analysis context uses a **save/restore** pattern instead of creating\n// new objects on each recursion (`{ ...ctx, current: X }`). This reduces\n// GC pressure for deeply nested templates.\n//\n// ─── Template Identifiers ────────────────────────────────────────────────────\n// The `{{key:N}}` syntax allows referencing a variable from a specific\n// schema, identified by an integer N. The optional `identifierSchemas`\n// parameter provides a mapping `{ [id]: JSONSchema7 }`.\n//\n// Resolution rules:\n// - `{{meetingId}}`   → validated against `inputSchema` (standard behavior)\n// - `{{meetingId:1}}` → validated against `identifierSchemas[1]`\n// - `{{meetingId:1}}` without `identifierSchemas[1]` → error\n\n// ─── Internal Types ──────────────────────────────────────────────────────────\n\n/** Context passed recursively during AST traversal */\ninterface AnalysisContext {\n\t/** Root schema (for resolving $refs) */\n\troot: JSONSchema7;\n\t/** Current context schema (changes with #each, #with) — mutated via save/restore */\n\tcurrent: JSONSchema7;\n\t/** Diagnostics accumulator */\n\tdiagnostics: TemplateDiagnostic[];\n\t/** Full template source (for extracting error snippets) */\n\ttemplate: string;\n\t/** Schemas by template identifier (for the {{key:N}} syntax) */\n\tidentifierSchemas?: Record<number, JSONSchema7>;\n\t/** Registered custom helpers (for static analysis) */\n\thelpers?: Map<string, HelperDefinition>;\n}\n\n// ─── Public API ──────────────────────────────────────────────────────────────\n\n/**\n * Statically analyzes a template against a JSON Schema v7 describing the\n * available context.\n *\n * Backward-compatible version — parses the template internally.\n *\n * @param template           - The template string (e.g. `\"Hello {{user.name}}\"`)\n * @param inputSchema        - JSON Schema v7 describing the available variables\n * @param identifierSchemas  - (optional) Schemas by identifier `{ [id]: JSONSchema7 }`\n * @returns An `AnalysisResult` containing validity, diagnostics, and the\n *          inferred output schema.\n */\nexport function analyze(\n\ttemplate: TemplateInput,\n\tinputSchema: JSONSchema7,\n\tidentifierSchemas?: Record<number, JSONSchema7>,\n): AnalysisResult {\n\tif (isObjectInput(template)) {\n\t\treturn analyzeObjectTemplate(template, inputSchema, identifierSchemas);\n\t}\n\tif (isLiteralInput(template)) {\n\t\treturn {\n\t\t\tvalid: true,\n\t\t\tdiagnostics: [],\n\t\t\toutputSchema: inferPrimitiveSchema(template),\n\t\t};\n\t}\n\tconst ast = parse(template);\n\treturn analyzeFromAst(ast, template, inputSchema, { identifierSchemas });\n}\n\n/**\n * Analyzes an object template recursively (standalone version).\n * Each property is analyzed individually, diagnostics are merged,\n * and the `outputSchema` reflects the object structure.\n */\nfunction analyzeObjectTemplate(\n\ttemplate: TemplateInputObject,\n\tinputSchema: JSONSchema7,\n\tidentifierSchemas?: Record<number, JSONSchema7>,\n): AnalysisResult {\n\treturn aggregateObjectAnalysis(Object.keys(template), (key) =>\n\t\tanalyze(template[key] as TemplateInput, inputSchema, identifierSchemas),\n\t);\n}\n\n/**\n * Statically analyzes a template from an already-parsed AST.\n *\n * This is the internal function used by `Typebars.compile()` and\n * `CompiledTemplate.analyze()` to avoid costly re-parsing.\n *\n * @param ast               - The already-parsed Handlebars AST\n * @param template          - The template source (for error snippets)\n * @param inputSchema       - JSON Schema v7 describing the available variables\n * @param options           - Additional options\n * @returns An `AnalysisResult`\n */\nexport function analyzeFromAst(\n\tast: hbs.AST.Program,\n\ttemplate: string,\n\tinputSchema: JSONSchema7,\n\toptions?: {\n\t\tidentifierSchemas?: Record<number, JSONSchema7>;\n\t\thelpers?: Map<string, HelperDefinition>;\n\t},\n): AnalysisResult {\n\tconst ctx: AnalysisContext = {\n\t\troot: inputSchema,\n\t\tcurrent: inputSchema,\n\t\tdiagnostics: [],\n\t\ttemplate,\n\t\tidentifierSchemas: options?.identifierSchemas,\n\t\thelpers: options?.helpers,\n\t};\n\n\t// Single pass: type inference + validation in one traversal.\n\tconst outputSchema = inferProgramType(ast, ctx);\n\n\tconst hasErrors = ctx.diagnostics.some((d) => d.severity === \"error\");\n\n\treturn {\n\t\tvalid: !hasErrors,\n\t\tdiagnostics: ctx.diagnostics,\n\t\toutputSchema: simplifySchema(outputSchema),\n\t};\n}\n\n// ─── Unified AST Traversal ───────────────────────────────────────────────────\n// A single set of functions handles both validation (emitting diagnostics)\n// and type inference (returning a JSONSchema7).\n//\n// Main functions:\n// - `inferProgramType`   — entry point for a Program (template body or block)\n// - `processStatement`   — dispatches a statement (validation side-effects)\n// - `processMustache`    — handles a MustacheStatement (expression or inline helper)\n// - `inferBlockType`     — handles a BlockStatement (if, each, with, custom…)\n\n/**\n * Dispatches the processing of an individual statement.\n *\n * Called by `inferProgramType` in the \"mixed template\" case to validate\n * each statement while ignoring the returned type (the result is always\n * `string` for a mixed template).\n *\n * @returns The inferred schema for this statement, or `undefined` for\n *          statements with no semantics (ContentStatement, CommentStatement).\n */\nfunction processStatement(\n\tstmt: hbs.AST.Statement,\n\tctx: AnalysisContext,\n): JSONSchema7 | undefined {\n\tswitch (stmt.type) {\n\t\tcase \"ContentStatement\":\n\t\tcase \"CommentStatement\":\n\t\t\t// Static text or comment — nothing to validate, no type to infer\n\t\t\treturn undefined;\n\n\t\tcase \"MustacheStatement\":\n\t\t\treturn processMustache(stmt as hbs.AST.MustacheStatement, ctx);\n\n\t\tcase \"BlockStatement\":\n\t\t\treturn inferBlockType(stmt as hbs.AST.BlockStatement, ctx);\n\n\t\tdefault:\n\t\t\t// Unrecognized AST node — emit a warning rather than an error\n\t\t\t// to avoid blocking on future Handlebars extensions.\n\t\t\taddDiagnostic(\n\t\t\t\tctx,\n\t\t\t\t\"UNANALYZABLE\",\n\t\t\t\t\"warning\",\n\t\t\t\t`Unsupported AST node type: \"${stmt.type}\"`,\n\t\t\t\tstmt,\n\t\t\t);\n\t\t\treturn undefined;\n\t}\n}\n\n/**\n * Processes a MustacheStatement `{{expression}}` or `{{helper arg}}`.\n *\n * Distinguishes two cases:\n * 1. **Simple expression** (`{{name}}`, `{{user.age}}`) — resolution in the schema\n * 2. **Inline helper** (`{{uppercase name}}`) — params > 0 or hash present\n *\n * @returns The inferred schema for this expression\n */\nfunction processMustache(\n\tstmt: hbs.AST.MustacheStatement,\n\tctx: AnalysisContext,\n): JSONSchema7 {\n\t// Sub-expressions (nested helpers) are not supported for static\n\t// analysis — emit a warning.\n\tif (stmt.path.type === \"SubExpression\") {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNANALYZABLE\",\n\t\t\t\"warning\",\n\t\t\t\"Sub-expressions are not statically analyzable\",\n\t\t\tstmt,\n\t\t);\n\t\treturn {};\n\t}\n\n\t// ── Inline helper detection ──────────────────────────────────────────────\n\t// If the MustacheStatement has parameters or a hash, it's a helper call\n\t// (e.g. `{{uppercase name}}`), not a simple expression.\n\tif (stmt.params.length > 0 || stmt.hash) {\n\t\tconst helperName = getExpressionName(stmt.path);\n\n\t\t// Check if the helper is registered\n\t\tconst helper = ctx.helpers?.get(helperName);\n\t\tif (helper) {\n\t\t\tconst helperParams = helper.params;\n\n\t\t\t// ── Check the number of required parameters ──────────────\n\t\t\tif (helperParams) {\n\t\t\t\tconst requiredCount = helperParams.filter((p) => !p.optional).length;\n\t\t\t\tif (stmt.params.length < requiredCount) {\n\t\t\t\t\taddDiagnostic(\n\t\t\t\t\t\tctx,\n\t\t\t\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\t\t\t\"error\",\n\t\t\t\t\t\t`Helper \"${helperName}\" expects at least ${requiredCount} argument(s), but got ${stmt.params.length}`,\n\t\t\t\t\t\tstmt,\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\thelperName,\n\t\t\t\t\t\t\texpected: `${requiredCount} argument(s)`,\n\t\t\t\t\t\t\tactual: `${stmt.params.length} argument(s)`,\n\t\t\t\t\t\t},\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// ── Validate each parameter (existence + type) ───────────────\n\t\t\tfor (let i = 0; i < stmt.params.length; i++) {\n\t\t\t\tconst resolvedSchema = resolveExpressionWithDiagnostics(\n\t\t\t\t\tstmt.params[i] as hbs.AST.Expression,\n\t\t\t\t\tctx,\n\t\t\t\t\tstmt,\n\t\t\t\t);\n\n\t\t\t\t// Check type compatibility if the helper declares the\n\t\t\t\t// expected type for this parameter\n\t\t\t\tconst helperParam = helperParams?.[i];\n\t\t\t\tif (resolvedSchema && helperParam?.type) {\n\t\t\t\t\tconst expectedType = helperParam.type;\n\t\t\t\t\tif (!isParamTypeCompatible(resolvedSchema, expectedType)) {\n\t\t\t\t\t\tconst paramName = helperParam.name;\n\t\t\t\t\t\taddDiagnostic(\n\t\t\t\t\t\t\tctx,\n\t\t\t\t\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\t\t\t\t\"error\",\n\t\t\t\t\t\t\t`Helper \"${helperName}\" parameter \"${paramName}\" expects ${schemaTypeLabel(expectedType)}, but got ${schemaTypeLabel(resolvedSchema)}`,\n\t\t\t\t\t\t\tstmt,\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\thelperName,\n\t\t\t\t\t\t\t\texpected: schemaTypeLabel(expectedType),\n\t\t\t\t\t\t\t\tactual: schemaTypeLabel(resolvedSchema),\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn helper.returnType ?? { type: \"string\" };\n\t\t}\n\n\t\t// Unknown inline helper — warning\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_HELPER\",\n\t\t\t\"warning\",\n\t\t\t`Unknown inline helper \"${helperName}\" — cannot analyze statically`,\n\t\t\tstmt,\n\t\t\t{ helperName },\n\t\t);\n\t\treturn { type: \"string\" };\n\t}\n\n\t// ── Simple expression ────────────────────────────────────────────────────\n\treturn resolveExpressionWithDiagnostics(stmt.path, ctx, stmt) ?? {};\n}\n\n/**\n * Checks whether a resolved type is compatible with the type expected\n * by a helper parameter.\n *\n * Compatibility rules:\n * - If either schema has no `type`, validation is not possible → compatible\n * - `integer` is compatible with `number` (integer ⊂ number)\n * - For multiple types (e.g. `[\"string\", \"number\"]`), at least one resolved\n *   type must match one expected type\n */\nfunction isParamTypeCompatible(\n\tresolved: JSONSchema7,\n\texpected: JSONSchema7,\n): boolean {\n\t// If either has no type info, we cannot validate\n\tif (!expected.type || !resolved.type) return true;\n\n\tconst expectedTypes = Array.isArray(expected.type)\n\t\t? expected.type\n\t\t: [expected.type];\n\tconst resolvedTypes = Array.isArray(resolved.type)\n\t\t? resolved.type\n\t\t: [resolved.type];\n\n\t// At least one resolved type must be compatible with one expected type\n\treturn resolvedTypes.some((rt) =>\n\t\texpectedTypes.some(\n\t\t\t(et) =>\n\t\t\t\trt === et ||\n\t\t\t\t// integer is a subtype of number\n\t\t\t\t(et === \"number\" && rt === \"integer\") ||\n\t\t\t\t(et === \"integer\" && rt === \"number\"),\n\t\t),\n\t);\n}\n\n/**\n * Infers the output type of a `Program` (template body or block body).\n *\n * Handles 4 cases, from most specific to most general:\n *\n * 1. **Single expression** `{{expr}}` → type of the expression\n * 2. **Single block** `{{#if}}…{{/if}}` → type of the block\n * 3. **Pure text content** → literal detection (number, boolean, null)\n * 4. **Mixed template** → always `string` (concatenation)\n *\n * Validation is performed alongside inference: each expression and block\n * is validated during processing.\n */\nfunction inferProgramType(\n\tprogram: hbs.AST.Program,\n\tctx: AnalysisContext,\n): JSONSchema7 {\n\tconst effective = getEffectiveBody(program);\n\n\t// No significant statements → empty string\n\tif (effective.length === 0) {\n\t\treturn { type: \"string\" };\n\t}\n\n\t// ── Case 1: single expression {{expr}} ─────────────────────────────────\n\tconst singleExpr = getEffectivelySingleExpression(program);\n\tif (singleExpr) {\n\t\treturn processMustache(singleExpr, ctx);\n\t}\n\n\t// ── Case 2: single block {{#if}}, {{#each}}, {{#with}}, … ──────────────\n\tconst singleBlock = getEffectivelySingleBlock(program);\n\tif (singleBlock) {\n\t\treturn inferBlockType(singleBlock, ctx);\n\t}\n\n\t// ── Case 3: only ContentStatements (no expressions) ────────────────────\n\t// If the concatenated (trimmed) text is a typed literal (number, boolean,\n\t// null), we infer the corresponding type.\n\tconst allContent = effective.every((s) => s.type === \"ContentStatement\");\n\tif (allContent) {\n\t\tconst text = effective\n\t\t\t.map((s) => (s as hbs.AST.ContentStatement).value)\n\t\t\t.join(\"\")\n\t\t\t.trim();\n\n\t\tif (text === \"\") return { type: \"string\" };\n\n\t\tconst literalType = detectLiteralType(text);\n\t\tif (literalType) return { type: literalType };\n\t}\n\n\t// ── Case 4: multiple blocks only (no significant text between them) ────\n\t// When the effective body consists entirely of BlockStatements, collect\n\t// each block's inferred type and combine them via oneOf. This handles\n\t// templates like:\n\t//   {{#if showName}}{{name}}{{/if}}\n\t//   {{#if showAge}}{{age}}{{/if}}\n\t// where the output could be string OR number depending on which branch\n\t// is active.\n\tconst allBlocks = effective.every((s) => s.type === \"BlockStatement\");\n\tif (allBlocks) {\n\t\tconst types: JSONSchema7[] = [];\n\t\tfor (const stmt of effective) {\n\t\t\tconst t = inferBlockType(stmt as hbs.AST.BlockStatement, ctx);\n\t\t\tif (t) types.push(t);\n\t\t}\n\t\tif (types.length === 1) return types[0] as JSONSchema7;\n\t\tif (types.length > 1) return simplifySchema({ oneOf: types });\n\t\treturn { type: \"string\" };\n\t}\n\n\t// ── Case 5: mixed template (text + expressions, blocks…) ───────────────\n\t// Traverse all statements for validation (side-effects: diagnostics).\n\t// The result is always string (concatenation).\n\tfor (const stmt of program.body) {\n\t\tprocessStatement(stmt, ctx);\n\t}\n\treturn { type: \"string\" };\n}\n\n/**\n * Infers the output type of a BlockStatement and validates its content.\n *\n * Supports built-in helpers (`if`, `unless`, `each`, `with`) and custom\n * helpers registered via `Typebars.registerHelper()`.\n *\n * Uses the **save/restore** pattern for context: instead of creating a new\n * object `{ ...ctx, current: X }` on each recursion, we save `ctx.current`,\n * mutate it, process the body, then restore. This reduces GC pressure for\n * deeply nested templates.\n */\nfunction inferBlockType(\n\tstmt: hbs.AST.BlockStatement,\n\tctx: AnalysisContext,\n): JSONSchema7 {\n\tconst helperName = getBlockHelperName(stmt);\n\n\tswitch (helperName) {\n\t\t// ── if / unless ──────────────────────────────────────────────────────\n\t\t// Validate the condition argument, then infer types from both branches.\n\t\tcase \"if\":\n\t\tcase \"unless\": {\n\t\t\tconst arg = getBlockArgument(stmt);\n\t\t\tif (arg) {\n\t\t\t\tresolveExpressionWithDiagnostics(arg, ctx, stmt);\n\t\t\t} else {\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\tcreateMissingArgumentMessage(helperName),\n\t\t\t\t\tstmt,\n\t\t\t\t\t{ helperName },\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// Infer the type of the \"then\" branch\n\t\t\tconst thenType = inferProgramType(stmt.program, ctx);\n\n\t\t\tif (stmt.inverse) {\n\t\t\t\tconst elseType = inferProgramType(stmt.inverse, ctx);\n\t\t\t\t// If both branches have the same type → single type\n\t\t\t\tif (deepEqual(thenType, elseType)) return thenType;\n\t\t\t\t// Otherwise → union of both types\n\t\t\t\treturn simplifySchema({ oneOf: [thenType, elseType] });\n\t\t\t}\n\n\t\t\t// No else branch → the result is the type of the then branch\n\t\t\t// (conceptually optional, but Handlebars returns \"\" for falsy)\n\t\t\treturn thenType;\n\t\t}\n\n\t\t// ── each ─────────────────────────────────────────────────────────────\n\t\t// Resolve the collection schema, then validate the body with the item\n\t\t// schema as the new context.\n\t\tcase \"each\": {\n\t\t\tconst arg = getBlockArgument(stmt);\n\t\t\tif (!arg) {\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\tcreateMissingArgumentMessage(\"each\"),\n\t\t\t\t\tstmt,\n\t\t\t\t\t{ helperName: \"each\" },\n\t\t\t\t);\n\t\t\t\t// Validate the body with an empty context (best-effort)\n\t\t\t\tconst saved = ctx.current;\n\t\t\t\tctx.current = {};\n\t\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\t\tctx.current = saved;\n\t\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\t\treturn { type: \"string\" };\n\t\t\t}\n\n\t\t\tconst collectionSchema = resolveExpressionWithDiagnostics(arg, ctx, stmt);\n\t\t\tif (!collectionSchema) {\n\t\t\t\t// The path could not be resolved — diagnostic already emitted.\n\t\t\t\tconst saved = ctx.current;\n\t\t\t\tctx.current = {};\n\t\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\t\tctx.current = saved;\n\t\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\t\treturn { type: \"string\" };\n\t\t\t}\n\n\t\t\t// Resolve the schema of the array elements\n\t\t\tconst itemSchema = resolveArrayItems(collectionSchema, ctx.root);\n\t\t\tif (!itemSchema) {\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\tcreateTypeMismatchMessage(\n\t\t\t\t\t\t\"each\",\n\t\t\t\t\t\t\"an array\",\n\t\t\t\t\t\tschemaTypeLabel(collectionSchema),\n\t\t\t\t\t),\n\t\t\t\t\tstmt,\n\t\t\t\t\t{\n\t\t\t\t\t\thelperName: \"each\",\n\t\t\t\t\t\texpected: \"array\",\n\t\t\t\t\t\tactual: schemaTypeLabel(collectionSchema),\n\t\t\t\t\t},\n\t\t\t\t);\n\t\t\t\t// Validate the body with an empty context (best-effort)\n\t\t\t\tconst saved = ctx.current;\n\t\t\t\tctx.current = {};\n\t\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\t\tctx.current = saved;\n\t\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\t\treturn { type: \"string\" };\n\t\t\t}\n\n\t\t\t// Validate the body with the item schema as the new context\n\t\t\tconst saved = ctx.current;\n\t\t\tctx.current = itemSchema;\n\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\tctx.current = saved;\n\n\t\t\t// The inverse branch ({{else}}) keeps the parent context\n\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\n\t\t\t// An each concatenates renders → always string\n\t\t\treturn { type: \"string\" };\n\t\t}\n\n\t\t// ── with ─────────────────────────────────────────────────────────────\n\t\t// Resolve the inner schema, then validate the body with it as the\n\t\t// new context.\n\t\tcase \"with\": {\n\t\t\tconst arg = getBlockArgument(stmt);\n\t\t\tif (!arg) {\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\tcreateMissingArgumentMessage(\"with\"),\n\t\t\t\t\tstmt,\n\t\t\t\t\t{ helperName: \"with\" },\n\t\t\t\t);\n\t\t\t\t// Validate the body with an empty context\n\t\t\t\tconst saved = ctx.current;\n\t\t\t\tctx.current = {};\n\t\t\t\tconst result = inferProgramType(stmt.program, ctx);\n\t\t\t\tctx.current = saved;\n\t\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\t\treturn result;\n\t\t\t}\n\n\t\t\tconst innerSchema = resolveExpressionWithDiagnostics(arg, ctx, stmt);\n\n\t\t\tconst saved = ctx.current;\n\t\t\tctx.current = innerSchema ?? {};\n\t\t\tconst result = inferProgramType(stmt.program, ctx);\n\t\t\tctx.current = saved;\n\n\t\t\t// The inverse branch keeps the parent context\n\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\n\t\t\treturn result;\n\t\t}\n\n\t\t// ── Custom or unknown helper ─────────────────────────────────────────\n\t\tdefault: {\n\t\t\tconst helper = ctx.helpers?.get(helperName);\n\t\t\tif (helper) {\n\t\t\t\t// Registered custom helper — validate parameters\n\t\t\t\tfor (const param of stmt.params) {\n\t\t\t\t\tresolveExpressionWithDiagnostics(\n\t\t\t\t\t\tparam as hbs.AST.Expression,\n\t\t\t\t\t\tctx,\n\t\t\t\t\t\tstmt,\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\t// Validate the body with the current context\n\t\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\t\treturn helper.returnType ?? { type: \"string\" };\n\t\t\t}\n\n\t\t\t// Unknown helper — warning\n\t\t\taddDiagnostic(\n\t\t\t\tctx,\n\t\t\t\t\"UNKNOWN_HELPER\",\n\t\t\t\t\"warning\",\n\t\t\t\tcreateUnknownHelperMessage(helperName),\n\t\t\t\tstmt,\n\t\t\t\t{ helperName },\n\t\t\t);\n\t\t\t// Still validate the body with the current context (best-effort)\n\t\t\tinferProgramType(stmt.program, ctx);\n\t\t\tif (stmt.inverse) inferProgramType(stmt.inverse, ctx);\n\t\t\treturn { type: \"string\" };\n\t\t}\n\t}\n}\n\n// ─── Expression Resolution ───────────────────────────────────────────────────\n\n/**\n * Resolves an AST expression to a sub-schema, emitting a diagnostic\n * if the path cannot be resolved.\n *\n * Handles the `{{key:N}}` syntax:\n * - If the expression has an identifier N → resolution in `identifierSchemas[N]`\n * - If identifier N has no associated schema → error\n * - If no identifier → resolution in `ctx.current` (standard behavior)\n *\n * @returns The resolved sub-schema, or `undefined` if the path is invalid.\n */\nfunction resolveExpressionWithDiagnostics(\n\texpr: hbs.AST.Expression,\n\tctx: AnalysisContext,\n\t/** Parent AST node (for diagnostic location) */\n\tparentNode?: hbs.AST.Node,\n): JSONSchema7 | undefined {\n\t// Handle `this` / `.` → return the current context\n\tif (isThisExpression(expr)) {\n\t\treturn ctx.current;\n\t}\n\n\t// ── SubExpression (nested helper call, e.g. `(lt account.balance 500)`) ──\n\tif (expr.type === \"SubExpression\") {\n\t\treturn resolveSubExpression(expr as hbs.AST.SubExpression, ctx, parentNode);\n\t}\n\n\tconst segments = extractPathSegments(expr);\n\tif (segments.length === 0) {\n\t\t// Expression that is not a PathExpression (e.g. literal)\n\t\tif (expr.type === \"StringLiteral\") return { type: \"string\" };\n\t\tif (expr.type === \"NumberLiteral\") return { type: \"number\" };\n\t\tif (expr.type === \"BooleanLiteral\") return { type: \"boolean\" };\n\t\tif (expr.type === \"NullLiteral\") return { type: \"null\" };\n\t\tif (expr.type === \"UndefinedLiteral\") return {};\n\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNANALYZABLE\",\n\t\t\t\"warning\",\n\t\t\tcreateUnanalyzableMessage(expr.type),\n\t\t\tparentNode ?? expr,\n\t\t);\n\t\treturn undefined;\n\t}\n\n\t// ── Identifier extraction ──────────────────────────────────────────────\n\tconst { cleanSegments, identifier } = extractExpressionIdentifier(segments);\n\n\tif (identifier !== null) {\n\t\t// The expression uses the {{key:N}} syntax — resolve from\n\t\t// the schema of identifier N.\n\t\treturn resolveWithIdentifier(\n\t\t\tcleanSegments,\n\t\t\tidentifier,\n\t\t\tctx,\n\t\t\tparentNode ?? expr,\n\t\t);\n\t}\n\n\t// ── Standard resolution (no identifier) ────────────────────────────────\n\tconst resolved = resolveSchemaPath(ctx.current, cleanSegments);\n\tif (resolved === undefined) {\n\t\tconst fullPath = cleanSegments.join(\".\");\n\t\tconst availableProperties = getSchemaPropertyNames(ctx.current);\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_PROPERTY\",\n\t\t\t\"error\",\n\t\t\tcreatePropertyNotFoundMessage(fullPath, availableProperties),\n\t\t\tparentNode ?? expr,\n\t\t\t{ path: fullPath, availableProperties },\n\t\t);\n\t\treturn undefined;\n\t}\n\n\treturn resolved;\n}\n\n/**\n * Resolves an expression with identifier `{{key:N}}` by looking up the\n * schema associated with identifier N.\n *\n * Emits an error diagnostic if:\n * - No `identifierSchemas` were provided\n * - Identifier N has no associated schema\n * - The property does not exist in the identifier's schema\n */\nfunction resolveWithIdentifier(\n\tcleanSegments: string[],\n\tidentifier: number,\n\tctx: AnalysisContext,\n\tnode: hbs.AST.Node,\n): JSONSchema7 | undefined {\n\tconst fullPath = cleanSegments.join(\".\");\n\n\t// No identifierSchemas provided at all\n\tif (!ctx.identifierSchemas) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"MISSING_IDENTIFIER_SCHEMAS\",\n\t\t\t\"error\",\n\t\t\t`Property \"${fullPath}:${identifier}\" uses an identifier but no identifier schemas were provided`,\n\t\t\tnode,\n\t\t\t{ path: `${fullPath}:${identifier}`, identifier },\n\t\t);\n\t\treturn undefined;\n\t}\n\n\t// The identifier does not exist in the provided schemas\n\tconst idSchema = ctx.identifierSchemas[identifier];\n\tif (!idSchema) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_IDENTIFIER\",\n\t\t\t\"error\",\n\t\t\t`Property \"${fullPath}:${identifier}\" references identifier ${identifier} but no schema exists for this identifier`,\n\t\t\tnode,\n\t\t\t{ path: `${fullPath}:${identifier}`, identifier },\n\t\t);\n\t\treturn undefined;\n\t}\n\n\t// Resolve the path within the identifier's schema\n\tconst resolved = resolveSchemaPath(idSchema, cleanSegments);\n\tif (resolved === undefined) {\n\t\tconst availableProperties = getSchemaPropertyNames(idSchema);\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"IDENTIFIER_PROPERTY_NOT_FOUND\",\n\t\t\t\"error\",\n\t\t\t`Property \"${fullPath}\" does not exist in the schema for identifier ${identifier}`,\n\t\t\tnode,\n\t\t\t{\n\t\t\t\tpath: fullPath,\n\t\t\t\tidentifier,\n\t\t\t\tavailableProperties,\n\t\t\t},\n\t\t);\n\t\treturn undefined;\n\t}\n\n\treturn resolved;\n}\n\n// ─── Utilities ───────────────────────────────────────────────────────────────\n\n/**\n * Extracts the first argument of a BlockStatement.\n *\n * In the Handlebars AST, for `{{#if active}}`:\n * - `stmt.path` → PathExpression(\"if\")    ← the helper name\n * - `stmt.params[0]` → PathExpression(\"active\") ← the actual argument\n *\n * @returns The argument expression, or `undefined` if the block has no argument.\n */\n// ─── SubExpression Resolution ────────────────────────────────────────────────\n\n/**\n * Resolves a SubExpression (nested helper call) such as `(lt account.balance 500)`.\n *\n * This mirrors the helper-call logic in `processMustache` but applies to\n * expressions used as arguments (e.g. inside `{{#if (lt a b)}}`).\n *\n * Steps:\n * 1. Extract the helper name from the SubExpression's path.\n * 2. Look up the helper in `ctx.helpers`.\n * 3. Validate argument count and types.\n * 4. Return the helper's declared `returnType` (defaults to `{ type: \"string\" }`).\n */\nfunction resolveSubExpression(\n\texpr: hbs.AST.SubExpression,\n\tctx: AnalysisContext,\n\tparentNode?: hbs.AST.Node,\n): JSONSchema7 | undefined {\n\tconst helperName = getExpressionName(expr.path);\n\n\tconst helper = ctx.helpers?.get(helperName);\n\tif (!helper) {\n\t\taddDiagnostic(\n\t\t\tctx,\n\t\t\t\"UNKNOWN_HELPER\",\n\t\t\t\"warning\",\n\t\t\t`Unknown sub-expression helper \"${helperName}\" — cannot analyze statically`,\n\t\t\tparentNode ?? expr,\n\t\t\t{ helperName },\n\t\t);\n\t\treturn { type: \"string\" };\n\t}\n\n\tconst helperParams = helper.params;\n\n\t// ── Check the number of required parameters ──────────────────────\n\tif (helperParams) {\n\t\tconst requiredCount = helperParams.filter((p) => !p.optional).length;\n\t\tif (expr.params.length < requiredCount) {\n\t\t\taddDiagnostic(\n\t\t\t\tctx,\n\t\t\t\t\"MISSING_ARGUMENT\",\n\t\t\t\t\"error\",\n\t\t\t\t`Helper \"${helperName}\" expects at least ${requiredCount} argument(s), but got ${expr.params.length}`,\n\t\t\t\tparentNode ?? expr,\n\t\t\t\t{\n\t\t\t\t\thelperName,\n\t\t\t\t\texpected: `${requiredCount} argument(s)`,\n\t\t\t\t\tactual: `${expr.params.length} argument(s)`,\n\t\t\t\t},\n\t\t\t);\n\t\t}\n\t}\n\n\t// ── Validate each parameter (existence + type) ───────────────────\n\tfor (let i = 0; i < expr.params.length; i++) {\n\t\tconst resolvedSchema = resolveExpressionWithDiagnostics(\n\t\t\texpr.params[i] as hbs.AST.Expression,\n\t\t\tctx,\n\t\t\tparentNode ?? expr,\n\t\t);\n\n\t\tconst helperParam = helperParams?.[i];\n\t\tif (resolvedSchema && helperParam?.type) {\n\t\t\tconst expectedType = helperParam.type;\n\t\t\tif (!isParamTypeCompatible(resolvedSchema, expectedType)) {\n\t\t\t\tconst paramName = helperParam.name;\n\t\t\t\taddDiagnostic(\n\t\t\t\t\tctx,\n\t\t\t\t\t\"TYPE_MISMATCH\",\n\t\t\t\t\t\"error\",\n\t\t\t\t\t`Helper \"${helperName}\" parameter \"${paramName}\" expects ${schemaTypeLabel(expectedType)}, but got ${schemaTypeLabel(resolvedSchema)}`,\n\t\t\t\t\tparentNode ?? expr,\n\t\t\t\t\t{\n\t\t\t\t\t\thelperName,\n\t\t\t\t\t\texpected: schemaTypeLabel(expectedType),\n\t\t\t\t\t\tactual: schemaTypeLabel(resolvedSchema),\n\t\t\t\t\t},\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn helper.returnType ?? { type: \"string\" };\n}\n\nfunction getBlockArgument(\n\tstmt: hbs.AST.BlockStatement,\n): hbs.AST.Expression | undefined {\n\treturn stmt.params[0] as hbs.AST.Expression | undefined;\n}\n\n/**\n * Retrieves the helper name from a BlockStatement (e.g. \"if\", \"each\", \"with\").\n */\nfunction getBlockHelperName(stmt: hbs.AST.BlockStatement): string {\n\tif (stmt.path.type === \"PathExpression\") {\n\t\treturn (stmt.path as hbs.AST.PathExpression).original;\n\t}\n\treturn \"\";\n}\n\n/**\n * Retrieves the name of an expression (first segment of the PathExpression).\n * Used to identify inline helpers.\n */\nfunction getExpressionName(expr: hbs.AST.Expression): string {\n\tif (expr.type === \"PathExpression\") {\n\t\treturn (expr as hbs.AST.PathExpression).original;\n\t}\n\treturn \"\";\n}\n\n/**\n * Adds an enriched diagnostic to the analysis context.\n *\n * Each diagnostic includes:\n * - A machine-readable `code` for the frontend\n * - A human-readable `message` describing the problem\n * - A `source` snippet from the template (if the position is available)\n * - Structured `details` for debugging\n */\nfunction addDiagnostic(\n\tctx: AnalysisContext,\n\tcode: DiagnosticCode,\n\tseverity: \"error\" | \"warning\",\n\tmessage: string,\n\tnode?: hbs.AST.Node,\n\tdetails?: DiagnosticDetails,\n): void {\n\tconst diagnostic: TemplateDiagnostic = { severity, code, message };\n\n\t// Extract the position and source snippet if available\n\tif (node && \"loc\" in node && node.loc) {\n\t\tdiagnostic.loc = {\n\t\t\tstart: { line: node.loc.start.line, column: node.loc.start.column },\n\t\t\tend: { line: node.loc.end.line, column: node.loc.end.column },\n\t\t};\n\t\t// Extract the template fragment around the error\n\t\tdiagnostic.source = extractSourceSnippet(ctx.template, diagnostic.loc);\n\t}\n\n\tif (details) {\n\t\tdiagnostic.details = details;\n\t}\n\n\tctx.diagnostics.push(diagnostic);\n}\n\n/**\n * Returns a human-readable label for a schema's type (for error messages).\n */\nfunction schemaTypeLabel(schema: JSONSchema7): string {\n\tif (schema.type) {\n\t\treturn Array.isArray(schema.type) ? schema.type.join(\" | \") : schema.type;\n\t}\n\tif (schema.oneOf) return \"oneOf(...)\";\n\tif (schema.anyOf) return \"anyOf(...)\";\n\tif (schema.allOf) return \"allOf(...)\";\n\tif (schema.enum) return \"enum\";\n\treturn \"unknown\";\n}\n\n// ─── Export for Internal Use ─────────────────────────────────────────────────\n// `inferBlockType` is exported to allow targeted unit tests\n// on block type inference.\nexport { inferBlockType };\n"
-  ],
-  "mappings": "8VAqGO,GAAS,LAAO,LACtB,JACA,EACA,EACiB,CACjB,GAAI,EAAc,CAAQ,EACzB,OAAO,EAAsB,EAAU,EAAa,CAAiB,EAEtE,GAAI,EAAe,CAAQ,EAC1B,MAAO,CACN,MAAO,GACP,YAAa,CAAC,EACd,aAAc,EAAqB,CAAQ,CAC5C,EAED,IAAM,EAAM,EAAM,CAAQ,EAC1B,OAAO,EAAe,EAAK,EAAU,EAAa,CAAE,mBAAkB,CAAC,EAQxE,SAAS,CAAqB,CAC7B,EACA,EACA,EACiB,CACjB,OAAO,EAAwB,OAAO,KAAK,CAAQ,EAAG,CAAC,IACtD,EAAQ,EAAS,GAAuB,EAAa,CAAiB,CACvE,EAeM,SAAS,CAAc,CAC7B,EACA,EACA,EACA,EAIiB,CACjB,IAAM,EAAuB,CAC5B,KAAM,EACN,QAAS,EACT,YAAa,CAAC,EACd,WACA,kBAAmB,GAAS,kBAC5B,QAAS,GAAS,OACnB,EAGM,EAAe,EAAiB,EAAK,CAAG,EAI9C,MAAO,CACN,MAAO,CAHU,EAAI,YAAY,KAAK,CAAC,IAAM,EAAE,WAAa,OAAO,EAInE,YAAa,EAAI,YACjB,aAAc,EAAe,CAAY,CAC1C,EAuBD,SAAS,CAAgB,CACxB,EACA,EAC0B,CAC1B,OAAQ,EAAK,UACP,uBACA,mBAEJ,WAEI,oBACJ,OAAO,EAAgB,EAAmC,CAAG,MAEzD,iBACJ,OAAO,EAAe,EAAgC,CAAG,UAKzD,EACC,EACA,eACA,UACA,+BAA+B,EAAK,QACpC,CACD,EACA,QAaH,SAAS,CAAe,CACvB,EACA,EACc,CAGd,GAAI,EAAK,KAAK,OAAS,gBAQtB,OAPA,EACC,EACA,eACA,UACA,gDACA,CACD,EACO,CAAC,EAMT,GAAI,EAAK,OAAO,OAAS,GAAK,EAAK,KAAM,CACxC,IAAM,EAAa,EAAkB,EAAK,IAAI,EAGxC,EAAS,EAAI,SAAS,IAAI,CAAU,EAC1C,GAAI,EAAQ,CACX,IAAM,EAAe,EAAO,OAG5B,GAAI,EAAc,CACjB,IAAM,EAAgB,EAAa,OAAO,CAAC,IAAM,CAAC,EAAE,QAAQ,EAAE,OAC9D,GAAI,EAAK,OAAO,OAAS,EACxB,EACC,EACA,mBACA,QACA,WAAW,uBAAgC,0BAAsC,EAAK,OAAO,SAC7F,EACA,CACC,aACA,SAAU,GAAG,gBACb,OAAQ,GAAG,EAAK,OAAO,oBACxB,CACD,EAKF,QAAS,EAAI,EAAG,EAAI,EAAK,OAAO,OAAQ,IAAK,CAC5C,IAAM,EAAiB,EACtB,EAAK,OAAO,GACZ,EACA,CACD,EAIM,EAAc,IAAe,GACnC,GAAI,GAAkB,GAAa,KAAM,CACxC,IAAM,EAAe,EAAY,KACjC,GAAI,CAAC,EAAsB,EAAgB,CAAY,EAAG,CACzD,IAAM,EAAY,EAAY,KAC9B,EACC,EACA,gBACA,QACA,WAAW,iBAA0B,cAAsB,EAAgB,CAAY,cAAc,EAAgB,CAAc,IACnI,EACA,CACC,aACA,SAAU,EAAgB,CAAY,EACtC,OAAQ,EAAgB,CAAc,CACvC,CACD,IAKH,OAAO,EAAO,YAAc,CAAE,KAAM,QAAS,EAY9C,OARA,EACC,EACA,iBACA,UACA,0BAA0B,iCAC1B,EACA,CAAE,YAAW,CACd,EACO,CAAE,KAAM,QAAS,EAIzB,OAAO,EAAiC,EAAK,KAAM,EAAK,CAAI,GAAK,CAAC,EAanE,SAAS,CAAqB,CAC7B,EACA,EACU,CAEV,GAAI,CAAC,EAAS,MAAQ,CAAC,EAAS,KAAM,MAAO,GAE7C,IAAM,EAAgB,MAAM,QAAQ,EAAS,IAAI,EAC9C,EAAS,KACT,CAAC,EAAS,IAAI,EAMjB,OALsB,MAAM,QAAQ,EAAS,IAAI,EAC9C,EAAS,KACT,CAAC,EAAS,IAAI,GAGI,KAAK,CAAC,IAC1B,EAAc,KACb,CAAC,IACA,IAAO,GAEN,IAAO,UAAY,IAAO,WAC1B,IAAO,WAAa,IAAO,QAC9B,CACD,EAgBD,SAAS,CAAgB,CACxB,EACA,EACc,CACd,IAAM,EAAY,EAAiB,CAAO,EAG1C,GAAI,EAAU,SAAW,EACxB,MAAO,CAAE,KAAM,QAAS,EAIzB,IAAM,EAAa,EAA+B,CAAO,EACzD,GAAI,EACH,OAAO,EAAgB,EAAY,CAAG,EAIvC,IAAM,EAAc,EAA0B,CAAO,EACrD,GAAI,EACH,OAAO,EAAe,EAAa,CAAG,EAOvC,GADmB,EAAU,MAAM,CAAC,IAAM,EAAE,OAAS,kBAAkB,EACvD,CACf,IAAM,EAAO,EACX,IAAI,CAAC,IAAO,EAA+B,KAAK,EAChD,KAAK,EAAE,EACP,KAAK,EAEP,GAAI,IAAS,GAAI,MAAO,CAAE,KAAM,QAAS,EAEzC,IAAM,EAAc,EAAkB,CAAI,EAC1C,GAAI,EAAa,MAAO,CAAE,KAAM,CAAY,EAY7C,GADkB,EAAU,MAAM,CAAC,IAAM,EAAE,OAAS,gBAAgB,EACrD,CACd,IAAM,EAAuB,CAAC,EAC9B,QAAW,KAAQ,EAAW,CAC7B,IAAM,EAAI,EAAe,EAAgC,CAAG,EAC5D,GAAI,EAAG,EAAM,KAAK,CAAC,EAEpB,GAAI,EAAM,SAAW,EAAG,OAAO,EAAM,GACrC,GAAI,EAAM,OAAS,EAAG,OAAO,EAAe,CAAE,MAAO,CAAM,CAAC,EAC5D,MAAO,CAAE,KAAM,QAAS,EAMzB,QAAW,KAAQ,EAAQ,KAC1B,EAAiB,EAAM,CAAG,EAE3B,MAAO,CAAE,KAAM,QAAS,EAczB,SAAS,CAAc,CACtB,EACA,EACc,CACd,IAAM,EAAa,EAAmB,CAAI,EAE1C,OAAQ,OAGF,SACA,SAAU,CACd,IAAM,EAAM,EAAiB,CAAI,EACjC,GAAI,EACH,EAAiC,EAAK,EAAK,CAAI,EAE/C,OACC,EACA,mBACA,QACA,EAA6B,CAAU,EACvC,EACA,CAAE,YAAW,CACd,EAID,IAAM,EAAW,EAAiB,EAAK,QAAS,CAAG,EAEnD,GAAI,EAAK,QAAS,CACjB,IAAM,EAAW,EAAiB,EAAK,QAAS,CAAG,EAEnD,GAAI,EAAU,EAAU,CAAQ,EAAG,OAAO,EAE1C,OAAO,EAAe,CAAE,MAAO,CAAC,EAAU,CAAQ,CAAE,CAAC,EAKtD,OAAO,CACR,KAKK,OAAQ,CACZ,IAAM,EAAM,EAAiB,CAAI,EACjC,GAAI,CAAC,EAAK,CACT,EACC,EACA,mBACA,QACA,EAA6B,MAAM,EACnC,EACA,CAAE,WAAY,MAAO,CACtB,EAEA,IAAM,EAAQ,EAAI,QAIlB,GAHA,EAAI,QAAU,CAAC,EACf,EAAiB,EAAK,QAAS,CAAG,EAClC,EAAI,QAAU,EACV,EAAK,QAAS,EAAiB,EAAK,QAAS,CAAG,EACpD,MAAO,CAAE,KAAM,QAAS,EAGzB,IAAM,EAAmB,EAAiC,EAAK,EAAK,CAAI,EACxE,GAAI,CAAC,EAAkB,CAEtB,IAAM,EAAQ,EAAI,QAIlB,GAHA,EAAI,QAAU,CAAC,EACf,EAAiB,EAAK,QAAS,CAAG,EAClC,EAAI,QAAU,EACV,EAAK,QAAS,EAAiB,EAAK,QAAS,CAAG,EACpD,MAAO,CAAE,KAAM,QAAS,EAIzB,IAAM,EAAa,EAAkB,EAAkB,EAAI,IAAI,EAC/D,GAAI,CAAC,EAAY,CAChB,EACC,EACA,gBACA,QACA,EACC,OACA,WACA,EAAgB,CAAgB,CACjC,EACA,EACA,CACC,WAAY,OACZ,SAAU,QACV,OAAQ,EAAgB,CAAgB,CACzC,CACD,EAEA,IAAM,EAAQ,EAAI,QAIlB,GAHA,EAAI,QAAU,CAAC,EACf,EAAiB,EAAK,QAAS,CAAG,EAClC,EAAI,QAAU,EACV,EAAK,QAAS,EAAiB,EAAK,QAAS,CAAG,EACpD,MAAO,CAAE,KAAM,QAAS,EAIzB,IAAM,EAAQ,EAAI,QAMlB,GALA,EAAI,QAAU,EACd,EAAiB,EAAK,QAAS,CAAG,EAClC,EAAI,QAAU,EAGV,EAAK,QAAS,EAAiB,EAAK,QAAS,CAAG,EAGpD,MAAO,CAAE,KAAM,QAAS,CACzB,KAKK,OAAQ,CACZ,IAAM,EAAM,EAAiB,CAAI,EACjC,GAAI,CAAC,EAAK,CACT,EACC,EACA,mBACA,QACA,EAA6B,MAAM,EACnC,EACA,CAAE,WAAY,MAAO,CACtB,EAEA,IAAM,EAAQ,EAAI,QAClB,EAAI,QAAU,CAAC,EACf,IAAM,EAAS,EAAiB,EAAK,QAAS,CAAG,EAEjD,GADA,EAAI,QAAU,EACV,EAAK,QAAS,EAAiB,EAAK,QAAS,CAAG,EACpD,OAAO,EAGR,IAAM,EAAc,EAAiC,EAAK,EAAK,CAAI,EAE7D,EAAQ,EAAI,QAClB,EAAI,QAAU,GAAe,CAAC,EAC9B,IAAM,EAAS,EAAiB,EAAK,QAAS,CAAG,EAIjD,GAHA,EAAI,QAAU,EAGV,EAAK,QAAS,EAAiB,EAAK,QAAS,CAAG,EAEpD,OAAO,CACR,SAGS,CACR,IAAM,EAAS,EAAI,SAAS,IAAI,CAAU,EAC1C,GAAI,EAAQ,CAEX,QAAW,KAAS,EAAK,OACxB,EACC,EACA,EACA,CACD,EAID,GADA,EAAiB,EAAK,QAAS,CAAG,EAC9B,EAAK,QAAS,EAAiB,EAAK,QAAS,CAAG,EACpD,OAAO,EAAO,YAAc,CAAE,KAAM,QAAS,EAc9C,GAVA,EACC,EACA,iBACA,UACA,EAA2B,CAAU,EACrC,EACA,CAAE,YAAW,CACd,EAEA,EAAiB,EAAK,QAAS,CAAG,EAC9B,EAAK,QAAS,EAAiB,EAAK,QAAS,CAAG,EACpD,MAAO,CAAE,KAAM,QAAS,CACzB,GAiBF,SAAS,CAAgC,CACxC,EACA,EAEA,EAC0B,CAE1B,GAAI,EAAiB,CAAI,EACxB,OAAO,EAAI,QAIZ,GAAI,EAAK,OAAS,gBACjB,OAAO,EAAqB,EAA+B,EAAK,CAAU,EAG3E,IAAM,EAAW,EAAoB,CAAI,EACzC,GAAI,EAAS,SAAW,EAAG,CAE1B,GAAI,EAAK,OAAS,gBAAiB,MAAO,CAAE,KAAM,QAAS,EAC3D,GAAI,EAAK,OAAS,gBAAiB,MAAO,CAAE,KAAM,QAAS,EAC3D,GAAI,EAAK,OAAS,iBAAkB,MAAO,CAAE,KAAM,SAAU,EAC7D,GAAI,EAAK,OAAS,cAAe,MAAO,CAAE,KAAM,MAAO,EACvD,GAAI,EAAK,OAAS,mBAAoB,MAAO,CAAC,EAE9C,EACC,EACA,eACA,UACA,EAA0B,EAAK,IAAI,EACnC,GAAc,CACf,EACA,OAID,IAAQ,gBAAe,cAAe,EAA4B,CAAQ,EAE1E,GAAI,IAAe,KAGlB,OAAO,EACN,EACA,EACA,EACA,GAAc,CACf,EAID,IAAM,EAAW,EAAkB,EAAI,QAAS,CAAa,EAC7D,GAAI,IAAa,OAAW,CAC3B,IAAM,EAAW,EAAc,KAAK,GAAG,EACjC,EAAsB,EAAuB,EAAI,OAAO,EAC9D,EACC,EACA,mBACA,QACA,EAA8B,EAAU,CAAmB,EAC3D,GAAc,EACd,CAAE,KAAM,EAAU,qBAAoB,CACvC,EACA,OAGD,OAAO,EAYR,SAAS,CAAqB,CAC7B,EACA,EACA,EACA,EAC0B,CAC1B,IAAM,EAAW,EAAc,KAAK,GAAG,EAGvC,GAAI,CAAC,EAAI,kBAAmB,CAC3B,EACC,EACA,6BACA,QACA,aAAa,KAAY,gEACzB,EACA,CAAE,KAAM,GAAG,KAAY,IAAc,YAAW,CACjD,EACA,OAID,IAAM,EAAW,EAAI,kBAAkB,GACvC,GAAI,CAAC,EAAU,CACd,EACC,EACA,qBACA,QACA,aAAa,KAAY,4BAAqC,6CAC9D,EACA,CAAE,KAAM,GAAG,KAAY,IAAc,YAAW,CACjD,EACA,OAID,IAAM,EAAW,EAAkB,EAAU,CAAa,EAC1D,GAAI,IAAa,OAAW,CAC3B,IAAM,EAAsB,EAAuB,CAAQ,EAC3D,EACC,EACA,gCACA,QACA,aAAa,kDAAyD,IACtE,EACA,CACC,KAAM,EACN,aACA,qBACD,CACD,EACA,OAGD,OAAO,EA4BR,SAAS,CAAoB,CAC5B,EACA,EACA,EAC0B,CAC1B,IAAM,EAAa,EAAkB,EAAK,IAAI,EAExC,EAAS,EAAI,SAAS,IAAI,CAAU,EAC1C,GAAI,CAAC,EASJ,OARA,EACC,EACA,iBACA,UACA,kCAAkC,iCAClC,GAAc,EACd,CAAE,YAAW,CACd,EACO,CAAE,KAAM,QAAS,EAGzB,IAAM,EAAe,EAAO,OAG5B,GAAI,EAAc,CACjB,IAAM,EAAgB,EAAa,OAAO,CAAC,IAAM,CAAC,EAAE,QAAQ,EAAE,OAC9D,GAAI,EAAK,OAAO,OAAS,EACxB,EACC,EACA,mBACA,QACA,WAAW,uBAAgC,0BAAsC,EAAK,OAAO,SAC7F,GAAc,EACd,CACC,aACA,SAAU,GAAG,gBACb,OAAQ,GAAG,EAAK,OAAO,oBACxB,CACD,EAKF,QAAS,EAAI,EAAG,EAAI,EAAK,OAAO,OAAQ,IAAK,CAC5C,IAAM,EAAiB,EACtB,EAAK,OAAO,GACZ,EACA,GAAc,CACf,EAEM,EAAc,IAAe,GACnC,GAAI,GAAkB,GAAa,KAAM,CACxC,IAAM,EAAe,EAAY,KACjC,GAAI,CAAC,EAAsB,EAAgB,CAAY,EAAG,CACzD,IAAM,EAAY,EAAY,KAC9B,EACC,EACA,gBACA,QACA,WAAW,iBAA0B,cAAsB,EAAgB,CAAY,cAAc,EAAgB,CAAc,IACnI,GAAc,EACd,CACC,aACA,SAAU,EAAgB,CAAY,EACtC,OAAQ,EAAgB,CAAc,CACvC,CACD,IAKH,OAAO,EAAO,YAAc,CAAE,KAAM,QAAS,EAG9C,SAAS,CAAgB,CACxB,EACiC,CACjC,OAAO,EAAK,OAAO,GAMpB,SAAS,CAAkB,CAAC,EAAsC,CACjE,GAAI,EAAK,KAAK,OAAS,iBACtB,OAAQ,EAAK,KAAgC,SAE9C,MAAO,GAOR,SAAS,CAAiB,CAAC,EAAkC,CAC5D,GAAI,EAAK,OAAS,iBACjB,OAAQ,EAAgC,SAEzC,MAAO,GAYR,SAAS,CAAa,CACrB,EACA,EACA,EACA,EACA,EACA,EACO,CACP,IAAM,EAAiC,CAAE,WAAU,OAAM,SAAQ,EAGjE,GAAI,GAAQ,QAAS,GAAQ,EAAK,IACjC,EAAW,IAAM,CAChB,MAAO,CAAE,KAAM,EAAK,IAAI,MAAM,KAAM,OAAQ,EAAK,IAAI,MAAM,MAAO,EAClE,IAAK,CAAE,KAAM,EAAK,IAAI,IAAI,KAAM,OAAQ,EAAK,IAAI,IAAI,MAAO,CAC7D,EAEA,EAAW,OAAS,EAAqB,EAAI,SAAU,EAAW,GAAG,EAGtE,GAAI,EACH,EAAW,QAAU,EAGtB,EAAI,YAAY,KAAK,CAAU,EAMhC,SAAS,CAAe,CAAC,EAA6B,CACrD,GAAI,EAAO,KACV,OAAO,MAAM,QAAQ,EAAO,IAAI,EAAI,EAAO,KAAK,KAAK,KAAK,EAAI,EAAO,KAEtE,GAAI,EAAO,MAAO,MAAO,aACzB,GAAI,EAAO,MAAO,MAAO,aACzB,GAAI,EAAO,MAAO,MAAO,aACzB,GAAI,EAAO,KAAM,MAAO,OACxB,MAAO",
-  "debugId": "812E930FBACC0FA364756E2164756E21",
-  "names": []
-}

package/dist/chunk-7j6q1e3z.js

@@ -1,5 +0,0 @@
-import{b as C}from"./chunk-kznb0bev.js";import{d as z}from"./chunk-1qwj7pjc.js";import{g as L}from"./chunk-qpzzr2rd.js";import{j as Q,k as W,l as _}from"./chunk-6955jpr7.js";import{n as k}from"./chunk-1gm6cf0e.js";import{B as U}from"./chunk-ybh51hbe.js";import{N,Q as E,R as I}from"./chunk-4zv02svp.js";import P from"handlebars";class Y{_definitions=null;_helperNames=null;_helperNamesSet=null;getDefinitions(){if(!this._definitions)this._definitions=new Map,this.buildDefinitions(this._definitions);return this._definitions}getHelperNames(){if(!this._helperNames)this._helperNames=[...this.getDefinitions().keys()];return this._helperNames}isHelper(w){if(!this._helperNamesSet)this._helperNamesSet=new Set(this.getHelperNames());return this._helperNamesSet.has(w)}register(w){for(let[M,H]of this.getDefinitions())w.registerHelper(M,H)}unregister(w){for(let M of this.getHelperNames())w.unregisterHelper(M)}}function B(w,M=NaN){if(typeof w==="number")return w;if(typeof w==="string"){let H=Number(w);return Number.isNaN(H)?M:H}if(typeof w==="boolean")return w?1:0;return M}var j=new Set(["==","===","!=","!==","<","<=",">",">="]);function T(w,M,H){switch(M){case"==":return w==H;case"===":return w===H;case"!=":return w!=H;case"!==":return w!==H;case"<":return B(w)<B(H);case"<=":return B(w)<=B(H);case">":return B(w)>B(H);case">=":return B(w)>=B(H)}}function A(w){return w!==null&&typeof w==="object"&&"hash"in w&&"name"in w}class Z extends Y{buildDefinitions(w){this.registerEquality(w),this.registerComparison(w),this.registerLogicalOperators(w),this.registerCollectionHelpers(w),this.registerGenericCompare(w)}registerEquality(w){w.set("eq",{fn:(H,V)=>H===V,params:[{name:"a",description:"Left value"},{name:"b",description:"Right value"}],returnType:{type:"boolean"},description:"Returns true if a is strictly equal to b: {{#if (eq a b)}}"});let M={fn:(H,V)=>H!==V,params:[{name:"a",description:"Left value"},{name:"b",description:"Right value"}],returnType:{type:"boolean"},description:"Returns true if a is not strictly equal to b: {{#if (ne a b)}}"};w.set("ne",M),w.set("neq",M)}registerComparison(w){w.set("lt",{fn:(V,q)=>B(V)<B(q),params:[{name:"a",type:{type:"number"},description:"Left operand"},{name:"b",type:{type:"number"},description:"Right operand"}],returnType:{type:"boolean"},description:"Returns true if a < b: {{#if (lt a b)}}"});let M={fn:(V,q)=>B(V)<=B(q),params:[{name:"a",type:{type:"number"},description:"Left operand"},{name:"b",type:{type:"number"},description:"Right operand"}],returnType:{type:"boolean"},description:"Returns true if a <= b: {{#if (lte a b)}}"};w.set("lte",M),w.set("le",M),w.set("gt",{fn:(V,q)=>B(V)>B(q),params:[{name:"a",type:{type:"number"},description:"Left operand"},{name:"b",type:{type:"number"},description:"Right operand"}],returnType:{type:"boolean"},description:"Returns true if a > b: {{#if (gt a b)}}"});let H={fn:(V,q)=>B(V)>=B(q),params:[{name:"a",type:{type:"number"},description:"Left operand"},{name:"b",type:{type:"number"},description:"Right operand"}],returnType:{type:"boolean"},description:"Returns true if a >= b: {{#if (gte a b)}}"};w.set("gte",H),w.set("ge",H)}registerLogicalOperators(w){w.set("not",{fn:(M)=>!M,params:[{name:"value",description:"Value to negate"}],returnType:{type:"boolean"},description:"Returns true if the value is falsy: {{#if (not active)}}"}),w.set("and",{fn:(M,H)=>!!M&&!!H,params:[{name:"a",description:"First condition"},{name:"b",description:"Second condition"}],returnType:{type:"boolean"},description:"Returns true if both values are truthy: {{#if (and a b)}}"}),w.set("or",{fn:(M,H)=>!!M||!!H,params:[{name:"a",description:"First condition"},{name:"b",description:"Second condition"}],returnType:{type:"boolean"},description:"Returns true if at least one value is truthy: {{#if (or a b)}}"})}registerCollectionHelpers(w){w.set("contains",{fn:(M,H)=>{if(typeof M==="string")return M.includes(String(H));if(Array.isArray(M))return M.includes(H);return!1},params:[{name:"haystack",description:"String or array to search in"},{name:"needle",description:"Value to search for"}],returnType:{type:"boolean"},description:'Checks if a string contains a substring or an array contains an element: {{#if (contains name "ali")}}'}),w.set("in",{fn:(...M)=>{if(M.length<2)return!1;let H=M[0];return M.slice(1).filter((q)=>!A(q)).some((q)=>q===H)},params:[{name:"value",description:"Value to look for"},{name:"candidates",description:'One or more candidate values (variadic): {{#if (in status "active" "pending")}}'}],returnType:{type:"boolean"},description:'Checks if a value is one of the provided options: {{#if (in status "active" "pending" "draft")}}'})}registerGenericCompare(w){w.set("compare",{fn:(M,H,V)=>{let q=String(H);if(!j.has(q))throw Error(`[compare helper] Unknown operator "${q}". Supported: ${[...j].join(", ")} `);return T(M,q,V)},params:[{name:"a",description:"Left operand"},{name:"operator",type:{type:"string",enum:["==","===","!=","!==","<","<=",">",">="]},description:'Comparison operator: "==", "===", "!=", "!==", "<", "<=", ">", ">="'},{name:"b",description:"Right operand"}],returnType:{type:"boolean"},description:'Generic comparison helper with operator as parameter: {{#if (compare a "<" b)}}. Supported operators: ==, ===, !=, !==, <, <=, >, >='})}}var F=new Set(["+","-","*","/","%","**"]),x=(w)=>B(w,0);function g(w,M,H){switch(M){case"+":return w+H;case"-":return w-H;case"*":return w*H;case"/":return H===0?1/0:w/H;case"%":return H===0?NaN:w%H;case"**":return w**H}}class $ extends Y{buildDefinitions(w){this.registerBinaryOperators(w),this.registerUnaryFunctions(w),this.registerMinMax(w),this.registerGenericMath(w)}registerBinaryOperators(w){let M={fn:(G,K)=>x(G)+x(K),params:[{name:"a",type:{type:"number"},description:"First operand"},{name:"b",type:{type:"number"},description:"Second operand"}],returnType:{type:"number"},description:"Adds two numbers: {{ add a b }}"};w.set("add",M);let H={fn:(G,K)=>x(G)-x(K),params:[{name:"a",type:{type:"number"},description:"Value to subtract from"},{name:"b",type:{type:"number"},description:"Value to subtract"}],returnType:{type:"number"},description:"Subtracts b from a: {{ subtract a b }}"};w.set("subtract",H),w.set("sub",H);let V={fn:(G,K)=>x(G)*x(K),params:[{name:"a",type:{type:"number"},description:"First factor"},{name:"b",type:{type:"number"},description:"Second factor"}],returnType:{type:"number"},description:"Multiplies two numbers: {{ multiply a b }}"};w.set("multiply",V),w.set("mul",V);let q={fn:(G,K)=>{let X=x(K);return X===0?1/0:x(G)/X},params:[{name:"a",type:{type:"number"},description:"Dividend"},{name:"b",type:{type:"number"},description:"Divisor"}],returnType:{type:"number"},description:"Divides a by b: {{ divide a b }}. Returns Infinity if b is 0."};w.set("divide",q),w.set("div",q);let J={fn:(G,K)=>{let X=x(K);return X===0?NaN:x(G)%X},params:[{name:"a",type:{type:"number"},description:"Dividend"},{name:"b",type:{type:"number"},description:"Divisor"}],returnType:{type:"number"},description:"Returns the remainder of a divided by b: {{ modulo a b }}"};w.set("modulo",J),w.set("mod",J),w.set("pow",{fn:(G,K)=>x(G)**x(K),params:[{name:"base",type:{type:"number"},description:"The base"},{name:"exponent",type:{type:"number"},description:"The exponent"}],returnType:{type:"number"},description:"Raises base to the power of exponent: {{ pow base exponent }}"})}registerUnaryFunctions(w){w.set("abs",{fn:(M)=>Math.abs(x(M)),params:[{name:"value",type:{type:"number"},description:"The number"}],returnType:{type:"number"},description:"Returns the absolute value: {{ abs value }}"}),w.set("ceil",{fn:(M)=>Math.ceil(x(M)),params:[{name:"value",type:{type:"number"},description:"The number to round up"}],returnType:{type:"number"},description:"Rounds up to the nearest integer: {{ ceil value }}"}),w.set("floor",{fn:(M)=>Math.floor(x(M)),params:[{name:"value",type:{type:"number"},description:"The number to round down"}],returnType:{type:"number"},description:"Rounds down to the nearest integer: {{ floor value }}"}),w.set("round",{fn:(M,H)=>{let V=x(M);if(H===void 0||H===null||typeof H==="object")return Math.round(V);let J=10**x(H);return Math.round(V*J)/J},params:[{name:"value",type:{type:"number"},description:"The number to round"},{name:"precision",type:{type:"number"},description:"Number of decimal places (default: 0)",optional:!0}],returnType:{type:"number"},description:"Rounds to the nearest integer or to a given precision: {{ round value }} or {{ round value 2 }}"}),w.set("sqrt",{fn:(M)=>Math.sqrt(x(M)),params:[{name:"value",type:{type:"number"},description:"The number"}],returnType:{type:"number"},description:"Returns the square root: {{ sqrt value }}"})}registerMinMax(w){w.set("min",{fn:(M,H)=>Math.min(x(M),x(H)),params:[{name:"a",type:{type:"number"},description:"First number"},{name:"b",type:{type:"number"},description:"Second number"}],returnType:{type:"number"},description:"Returns the smaller of two numbers: {{ min a b }}"}),w.set("max",{fn:(M,H)=>Math.max(x(M),x(H)),params:[{name:"a",type:{type:"number"},description:"First number"},{name:"b",type:{type:"number"},description:"Second number"}],returnType:{type:"number"},description:"Returns the larger of two numbers: {{ max a b }}"})}registerGenericMath(w){w.set("math",{fn:(M,H,V)=>{let q=String(H);if(!F.has(q))throw Error(`[math helper] Unknown operator "${q}". Supported: ${[...F].join(", ")} `);return g(x(M),q,x(V))},params:[{name:"a",type:{type:"number"},description:"Left operand"},{name:"operator",type:{type:"string",enum:["+","-","*","/","%","**"]},description:'Arithmetic operator: "+", "-", "*", "/", "%", "**"'},{name:"b",type:{type:"number"},description:"Right operand"}],returnType:{type:"number"},description:'Generic math helper with operator as parameter: {{ math a "+" b }}, {{ math a "/" b }}. Supported operators: +, -, *, /, %, **'})}}class R{hbs;astCache;compilationCache;helpers=new Map;constructor(w={}){if(this.hbs=P.create(),this.astCache=new N(w.astCacheSize??256),this.compilationCache=new N(w.compilationCacheSize??256),new $().register(this),new Z().register(this),w.helpers)for(let M of w.helpers){let{name:H,...V}=M;this.registerHelper(H,V)}}compile(w){if(W(w)){let V={};for(let[q,J]of Object.entries(w))V[q]=this.compile(J);return C.fromObject(V,{helpers:this.helpers,hbs:this.hbs,compilationCache:this.compilationCache})}if(Q(w))return C.fromLiteral(w,{helpers:this.helpers,hbs:this.hbs,compilationCache:this.compilationCache});let M=this.getCachedAst(w),H={helpers:this.helpers,hbs:this.hbs,compilationCache:this.compilationCache};return C.fromTemplate(M,w,H)}analyze(w,M,H){if(W(w))return E(Object.keys(w),(q)=>this.analyze(w[q],M,H));if(Q(w))return{valid:!0,diagnostics:[],outputSchema:_(w)};let V=this.getCachedAst(w);return z(V,w,M,{identifierSchemas:H,helpers:this.helpers})}validate(w,M,H){let V=this.analyze(w,M,H);return{valid:V.valid,diagnostics:V.diagnostics}}isValidSyntax(w){if(W(w))return Object.values(w).every((M)=>this.isValidSyntax(M));if(Q(w))return!0;try{return this.getCachedAst(w),!0}catch{return!1}}execute(w,M,H){if(W(w)){let q={};for(let[J,G]of Object.entries(w))q[J]=this.execute(G,M,H);return q}if(Q(w))return w;let V=this.getCachedAst(w);if(H?.schema){let q=z(V,w,H.schema,{identifierSchemas:H.identifierSchemas,helpers:this.helpers});if(!q.valid)throw new U(q.diagnostics)}return L(V,w,M,{identifierData:H?.identifierData,hbs:this.hbs,compilationCache:this.compilationCache})}analyzeAndExecute(w,M,H,V){if(W(w))return I(Object.keys(w),(K)=>this.analyzeAndExecute(w[K],M,H,V));if(Q(w))return{analysis:{valid:!0,diagnostics:[],outputSchema:_(w)},value:w};let q=this.getCachedAst(w),J=z(q,w,M,{identifierSchemas:V?.identifierSchemas,helpers:this.helpers});if(!J.valid)return{analysis:J,value:void 0};let G=L(q,w,H,{identifierData:V?.identifierData,hbs:this.hbs,compilationCache:this.compilationCache});return{analysis:J,value:G}}registerHelper(w,M){return this.helpers.set(w,M),this.hbs.registerHelper(w,M.fn),this.compilationCache.clear(),this}unregisterHelper(w){return this.helpers.delete(w),this.hbs.unregisterHelper(w),this.compilationCache.clear(),this}hasHelper(w){return this.helpers.has(w)}clearCaches(){this.astCache.clear(),this.compilationCache.clear()}getCachedAst(w){let M=this.astCache.get(w);if(!M)M=k(w),this.astCache.set(w,M);return M}}
-export{R as a};
-
-//# debugId=D5BDDDBE699F089564756E2164756E21
-//# sourceMappingURL=chunk-7j6q1e3z.js.map

package/dist/chunk-8g0d6h85.js

@@ -1,5 +0,0 @@
-import{M}from"./chunk-4zv02svp.js";function G(A,z){if(!A.$ref)return A;let w=A.$ref,j=w.match(/^#\/(definitions|\$defs)\/(.+)$/);if(!j)throw Error(`Unsupported $ref format: "${w}". Only internal #/definitions/ references are supported.`);let B=j[1],D=j[2]??"",F=B==="definitions"?z.definitions:z.$defs;if(!F||!(D in F))throw Error(`Cannot resolve $ref "${w}": definition "${D}" not found.`);let H=F[D];if(!H||typeof H==="boolean")throw Error(`Cannot resolve $ref "${w}": definition "${D}" not found.`);return G(H,z)}function L(A,z,w){let j=G(A,w);if(j.properties&&z in j.properties){let H=j.properties[z];if(H&&typeof H!=="boolean")return G(H,w);if(H===!0)return{}}if(j.additionalProperties!==void 0&&j.additionalProperties!==!1){if(j.additionalProperties===!0)return{};return G(j.additionalProperties,w)}let B=j.type;if((B==="array"||Array.isArray(B)&&B.includes("array"))&&z==="length")return{type:"integer"};let F=N(j,z,w);if(F)return F;return}function N(A,z,w){if(A.allOf){let j=A.allOf.filter((B)=>typeof B!=="boolean").map((B)=>L(B,z,w)).filter((B)=>B!==void 0);if(j.length===1)return j[0];if(j.length>1)return{allOf:j}}for(let j of["anyOf","oneOf"]){if(!A[j])continue;let B=A[j].filter((D)=>typeof D!=="boolean").map((D)=>L(D,z,w)).filter((D)=>D!==void 0);if(B.length===1)return B[0];if(B.length>1)return{[j]:B}}return}function P(A,z){if(z.length===0)return G(A,A);let w=G(A,A),j=A;for(let B of z){let D=L(w,B,j);if(D===void 0)return;w=D}return w}function Q(A,z){let w=G(A,z),j=w.type;if(!(j==="array"||Array.isArray(j)&&j.includes("array"))&&w.items===void 0)return;if(w.items===void 0)return{};if(typeof w.items==="boolean")return{};if(Array.isArray(w.items)){let D=w.items.filter((F)=>typeof F!=="boolean").map((F)=>G(F,z));if(D.length===0)return{};return{oneOf:D}}return G(w.items,z)}function J(A){for(let z of["oneOf","anyOf"]){let w=A[z];if(w&&w.length===1){let j=w[0];if(j!==void 0&&typeof j!=="boolean")return J(j)}}if(A.allOf&&A.allOf.length===1){let z=A.allOf[0];if(z!==void 0&&typeof z!=="boolean")return J(z)}for(let z of["oneOf","anyOf"]){let w=A[z];if(w&&w.length>1){let j=[];for(let B of w){if(typeof B==="boolean")continue;if(!j.some((F)=>M(F,B)))j.push(J(B))}if(j.length===1)return j[0];return{...A,[z]:j}}}return A}
-export{G as I,P as J,Q as K,J as L};
-
-//# debugId=3010A16AF72C22DE64756E2164756E21
-//# sourceMappingURL=chunk-8g0d6h85.js.map