typebars 1.0.3 → 1.0.5

package/dist/esm/utils.d.ts

@@ -0,0 +1,113 @@
+import type { JSONSchema7 } from "json-schema";
+import type { AnalysisResult } from "./types.js";
+/**
+ * Recursively compares two JSON-compatible values.
+ *
+ * @param a - First value
+ * @param b - Second value
+ * @returns `true` if the two values are structurally identical
+ *
+ * @example
+ * ```
+ * deepEqual({ a: 1, b: 2 }, { b: 2, a: 1 }) // → true
+ * deepEqual([1, 2], [1, 2])                   // → true
+ * deepEqual({ a: 1 }, { a: 2 })               // → false
+ * ```
+ */
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+/**
+ * Simple fixed-capacity LRU cache.
+ *
+ * @example
+ * ```
+ * const cache = new LRUCache<string, number>(2);
+ * cache.set("a", 1);
+ * cache.set("b", 2);
+ * cache.get("a");      // → 1 (marks "a" as recently used)
+ * cache.set("c", 3);   // evicts "b" (least recently used)
+ * cache.get("b");      // → undefined
+ * ```
+ */
+export declare class LRUCache<K, V> {
+    private readonly capacity;
+    private readonly cache;
+    constructor(capacity: number);
+    /**
+     * Retrieves a value from the cache. Returns `undefined` if absent.
+     * Marks the entry as recently used.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Inserts or updates a value in the cache.
+     * If the cache is full, evicts the least recently used entry.
+     */
+    set(key: K, value: V): void;
+    /**
+     * Checks whether a key exists in the cache (without affecting LRU order).
+     */
+    has(key: K): boolean;
+    /**
+     * Removes an entry from the cache.
+     * @returns `true` if the entry existed and was removed
+     */
+    delete(key: K): boolean;
+    /** Clears the entire cache. */
+    clear(): void;
+    /** Number of entries currently in the cache. */
+    get size(): number;
+}
+/**
+ * Extracts a template fragment around a given position.
+ *
+ * @param template - The full template source
+ * @param loc      - The position (line/column, 1-based) of the error
+ * @returns The corresponding code fragment (trimmed)
+ */
+export declare function extractSourceSnippet(template: string, loc: {
+    start: {
+        line: number;
+        column: number;
+    };
+    end: {
+        line: number;
+        column: number;
+    };
+}): string;
+/**
+ * Lists the declared property names in a JSON Schema.
+ * Returns an empty array if the schema has no `properties`.
+ */
+export declare function getSchemaPropertyNames(schema: JSONSchema7): string[];
+/**
+ * Aggregates analysis results from a set of named entries into a single
+ * `AnalysisResult` with an object-typed `outputSchema`.
+ *
+ * @param keys         - The keys of the object to analyze
+ * @param analyzeEntry - Callback that analyzes an entry by its key
+ * @returns An aggregated `AnalysisResult`
+ *
+ * @example
+ * ```
+ * aggregateObjectAnalysis(
+ *   Object.keys(template),
+ *   (key) => analyze(template[key], inputSchema),
+ * );
+ * ```
+ */
+export declare function aggregateObjectAnalysis(keys: string[], analyzeEntry: (key: string) => AnalysisResult): AnalysisResult;
+/**
+ * Aggregates both analysis **and** execution results from a set of named
+ * entries. Returns the aggregated `AnalysisResult` and the object of
+ * executed values (or `undefined` if at least one entry is invalid).
+ *
+ * @param keys         - The keys of the object
+ * @param processEntry - Callback that analyzes and executes an entry by its key
+ * @returns Aggregated `{ analysis, value }`
+ */
+export declare function aggregateObjectAnalysisAndExecution(keys: string[], processEntry: (key: string) => {
+    analysis: AnalysisResult;
+    value: unknown;
+}): {
+    analysis: AnalysisResult;
+    value: unknown;
+};

package/dist/esm/utils.js

@@ -0,0 +1,2 @@
+function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}export function deepEqual(a,b){if(a===b)return true;if(a===null||b===null)return false;if(typeof a!==typeof b)return false;if(Array.isArray(a)){if(!Array.isArray(b))return false;if(a.length!==b.length)return false;for(let i=0;i<a.length;i++){if(!deepEqual(a[i],b[i]))return false}return true}if(typeof a==="object"){const objA=a;const objB=b;const keysA=Object.keys(objA);const keysB=Object.keys(objB);if(keysA.length!==keysB.length)return false;for(const key of keysA){if(!(key in objB)||!deepEqual(objA[key],objB[key]))return false}return true}return false}export class LRUCache{get(key){if(!this.cache.has(key))return undefined;const value=this.cache.get(key);this.cache.delete(key);this.cache.set(key,value);return value}set(key,value){if(this.cache.has(key)){this.cache.delete(key)}else if(this.cache.size>=this.capacity){const oldestKey=this.cache.keys().next().value;if(oldestKey!==undefined){this.cache.delete(oldestKey)}}this.cache.set(key,value)}has(key){return this.cache.has(key)}delete(key){return this.cache.delete(key)}clear(){this.cache.clear()}get size(){return this.cache.size}constructor(capacity){_define_property(this,"capacity",void 0);_define_property(this,"cache",void 0);this.capacity=capacity;this.cache=new Map;if(capacity<1){throw new Error("LRUCache capacity must be at least 1")}}}export function extractSourceSnippet(template,loc){const lines=template.split("\n");const startLine=loc.start.line-1;const endLine=loc.end.line-1;if(startLine<0||startLine>=lines.length)return"";if(startLine===endLine){const line=lines[startLine]??"";return line.trim()}const clampedEnd=Math.min(endLine,lines.length-1);return lines.slice(startLine,clampedEnd+1).map(l=>l.trimEnd()).join("\n").trim()}export function getSchemaPropertyNames(schema){const names=new Set;if(schema.properties){for(const key of Object.keys(schema.properties)){names.add(key)}}for(const combinator of["allOf","anyOf","oneOf"]){const branches=schema[combinator];if(branches){for(const branch of branches){if(typeof branch==="boolean")continue;if(branch.properties){for(const key of Object.keys(branch.properties)){names.add(key)}}}}}return Array.from(names).sort()}export function aggregateObjectAnalysis(keys,analyzeEntry){const allDiagnostics=[];const properties={};let allValid=true;for(const key of keys){const child=analyzeEntry(key);if(!child.valid)allValid=false;allDiagnostics.push(...child.diagnostics);properties[key]=child.outputSchema}return{valid:allValid,diagnostics:allDiagnostics,outputSchema:{type:"object",properties,required:keys}}}export function aggregateObjectAnalysisAndExecution(keys,processEntry){const allDiagnostics=[];const properties={};const resultValues={};let allValid=true;for(const key of keys){const child=processEntry(key);if(!child.analysis.valid)allValid=false;allDiagnostics.push(...child.analysis.diagnostics);properties[key]=child.analysis.outputSchema;resultValues[key]=child.value}const analysis={valid:allValid,diagnostics:allDiagnostics,outputSchema:{type:"object",properties,required:keys}};return{analysis,value:allValid?resultValues:undefined}}
+//# sourceMappingURL=utils.js.map

package/dist/esm/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils.ts"],"sourcesContent":["import type { JSONSchema7 } from \"json-schema\";\nimport type { AnalysisResult, TemplateDiagnostic } from \"./types.ts\";\n\n// ─── Utilities ───────────────────────────────────────────────────────────────\n// Shared utility functions and classes used across the different modules\n// of the template engine.\n\n// ─── Deep Equality ───────────────────────────────────────────────────────────\n// Deep structural comparison for JSON-compatible values.\n// More robust than `JSON.stringify` because it is independent of key order\n// and does not allocate intermediate strings.\n\n/**\n * Recursively compares two JSON-compatible values.\n *\n * @param a - First value\n * @param b - Second value\n * @returns `true` if the two values are structurally identical\n *\n * @example\n * ```\n * deepEqual({ a: 1, b: 2 }, { b: 2, a: 1 }) // → true\n * deepEqual([1, 2], [1, 2])                   // → true\n * deepEqual({ a: 1 }, { a: 2 })               // → false\n * ```\n */\nexport function deepEqual(a: unknown, b: unknown): boolean {\n\t// Strict identity (covers primitives, same ref; NaN !== NaN is intentional)\n\tif (a === b) return true;\n\n\t// null is typeof \"object\" in JS — handle it separately\n\tif (a === null || b === null) return false;\n\tif (typeof a !== typeof b) return false;\n\n\t// ── Arrays ───────────────────────────────────────────────────────────────\n\tif (Array.isArray(a)) {\n\t\tif (!Array.isArray(b)) return false;\n\t\tif (a.length !== b.length) return false;\n\t\tfor (let i = 0; i < a.length; i++) {\n\t\t\tif (!deepEqual(a[i], b[i])) return false;\n\t\t}\n\t\treturn true;\n\t}\n\n\t// ── Objects ──────────────────────────────────────────────────────────────\n\tif (typeof a === \"object\") {\n\t\tconst objA = a as Record<string, unknown>;\n\t\tconst objB = b as Record<string, unknown>;\n\t\tconst keysA = Object.keys(objA);\n\t\tconst keysB = Object.keys(objB);\n\n\t\tif (keysA.length !== keysB.length) return false;\n\n\t\tfor (const key of keysA) {\n\t\t\tif (!(key in objB) || !deepEqual(objA[key], objB[key])) return false;\n\t\t}\n\t\treturn true;\n\t}\n\n\t// Different primitives (already covered by a === b at the top)\n\treturn false;\n}\n\n// ─── LRU Cache ───────────────────────────────────────────────────────────────\n// Fixed-capacity cache with Least Recently Used (LRU) eviction.\n// Leverages `Map` insertion order to track access: the oldest entry\n// is always in the first position.\n\n/**\n * Simple fixed-capacity LRU cache.\n *\n * @example\n * ```\n * const cache = new LRUCache<string, number>(2);\n * cache.set(\"a\", 1);\n * cache.set(\"b\", 2);\n * cache.get(\"a\");      // → 1 (marks \"a\" as recently used)\n * cache.set(\"c\", 3);   // evicts \"b\" (least recently used)\n * cache.get(\"b\");      // → undefined\n * ```\n */\nexport class LRUCache<K, V> {\n\tprivate readonly cache = new Map<K, V>();\n\n\tconstructor(private readonly capacity: number) {\n\t\tif (capacity < 1) {\n\t\t\tthrow new Error(\"LRUCache capacity must be at least 1\");\n\t\t}\n\t}\n\n\t/**\n\t * Retrieves a value from the cache. Returns `undefined` if absent.\n\t * Marks the entry as recently used.\n\t */\n\tget(key: K): V | undefined {\n\t\tif (!this.cache.has(key)) return undefined;\n\n\t\t// Move to the end of the Map (= most recently used)\n\t\tconst value = this.cache.get(key) as V;\n\t\tthis.cache.delete(key);\n\t\tthis.cache.set(key, value);\n\t\treturn value;\n\t}\n\n\t/**\n\t * Inserts or updates a value in the cache.\n\t * If the cache is full, evicts the least recently used entry.\n\t */\n\tset(key: K, value: V): void {\n\t\tif (this.cache.has(key)) {\n\t\t\tthis.cache.delete(key);\n\t\t} else if (this.cache.size >= this.capacity) {\n\t\t\t// Evict the first entry (the oldest one)\n\t\t\tconst oldestKey = this.cache.keys().next().value;\n\t\t\tif (oldestKey !== undefined) {\n\t\t\t\tthis.cache.delete(oldestKey);\n\t\t\t}\n\t\t}\n\t\tthis.cache.set(key, value);\n\t}\n\n\t/**\n\t * Checks whether a key exists in the cache (without affecting LRU order).\n\t */\n\thas(key: K): boolean {\n\t\treturn this.cache.has(key);\n\t}\n\n\t/**\n\t * Removes an entry from the cache.\n\t * @returns `true` if the entry existed and was removed\n\t */\n\tdelete(key: K): boolean {\n\t\treturn this.cache.delete(key);\n\t}\n\n\t/** Clears the entire cache. */\n\tclear(): void {\n\t\tthis.cache.clear();\n\t}\n\n\t/** Number of entries currently in the cache. */\n\tget size(): number {\n\t\treturn this.cache.size;\n\t}\n}\n\n// ─── Source Snippet Extraction ────────────────────────────────────────────────\n// Used to enrich diagnostics with the template fragment that caused the error.\n\n/**\n * Extracts a template fragment around a given position.\n *\n * @param template - The full template source\n * @param loc      - The position (line/column, 1-based) of the error\n * @returns The corresponding code fragment (trimmed)\n */\nexport function extractSourceSnippet(\n\ttemplate: string,\n\tloc: {\n\t\tstart: { line: number; column: number };\n\t\tend: { line: number; column: number };\n\t},\n): string {\n\tconst lines = template.split(\"\\n\");\n\tconst startLine = loc.start.line - 1; // 0-based\n\tconst endLine = loc.end.line - 1;\n\n\tif (startLine < 0 || startLine >= lines.length) return \"\";\n\n\tif (startLine === endLine) {\n\t\t// Same line — extract the portion between start.column and end.column\n\t\tconst line = lines[startLine] ?? \"\";\n\t\treturn line.trim();\n\t}\n\n\t// Multi-line — return the affected lines\n\tconst clampedEnd = Math.min(endLine, lines.length - 1);\n\treturn lines\n\t\t.slice(startLine, clampedEnd + 1)\n\t\t.map((l) => l.trimEnd())\n\t\t.join(\"\\n\")\n\t\t.trim();\n}\n\n// ─── Schema Properties ──────────────────────────────────────────────────────\n// Utility for listing available properties in a schema, used to enrich\n// error messages with suggestions.\n\n/**\n * Lists the declared property names in a JSON Schema.\n * Returns an empty array if the schema has no `properties`.\n */\nexport function getSchemaPropertyNames(schema: JSONSchema7): string[] {\n\tconst names = new Set<string>();\n\n\t// Direct properties\n\tif (schema.properties) {\n\t\tfor (const key of Object.keys(schema.properties)) {\n\t\t\tnames.add(key);\n\t\t}\n\t}\n\n\t// Properties within combinators\n\tfor (const combinator of [\"allOf\", \"anyOf\", \"oneOf\"] as const) {\n\t\tconst branches = schema[combinator];\n\t\tif (branches) {\n\t\t\tfor (const branch of branches) {\n\t\t\t\tif (typeof branch === \"boolean\") continue;\n\t\t\t\tif (branch.properties) {\n\t\t\t\t\tfor (const key of Object.keys(branch.properties)) {\n\t\t\t\t\t\tnames.add(key);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn Array.from(names).sort();\n}\n\n// ─── Object Analysis Aggregation ─────────────────────────────────────────────\n// Factorizes the common recursion pattern over template objects:\n// iterate the keys, analyze each entry via a callback, accumulate\n// diagnostics, and build the output object schema.\n//\n// Used by:\n// - `analyzer.ts` (analyzeObjectTemplate)\n// - `Typebars.analyzeObject()` (typebars.ts)\n// - `CompiledTemplate.analyze()` in object mode (compiled-template.ts)\n\n/**\n * Aggregates analysis results from a set of named entries into a single\n * `AnalysisResult` with an object-typed `outputSchema`.\n *\n * @param keys         - The keys of the object to analyze\n * @param analyzeEntry - Callback that analyzes an entry by its key\n * @returns An aggregated `AnalysisResult`\n *\n * @example\n * ```\n * aggregateObjectAnalysis(\n *   Object.keys(template),\n *   (key) => analyze(template[key], inputSchema),\n * );\n * ```\n */\nexport function aggregateObjectAnalysis(\n\tkeys: string[],\n\tanalyzeEntry: (key: string) => AnalysisResult,\n): AnalysisResult {\n\tconst allDiagnostics: TemplateDiagnostic[] = [];\n\tconst properties: Record<string, JSONSchema7> = {};\n\tlet allValid = true;\n\n\tfor (const key of keys) {\n\t\tconst child = analyzeEntry(key);\n\t\tif (!child.valid) allValid = false;\n\t\tallDiagnostics.push(...child.diagnostics);\n\t\tproperties[key] = child.outputSchema;\n\t}\n\n\treturn {\n\t\tvalid: allValid,\n\t\tdiagnostics: allDiagnostics,\n\t\toutputSchema: {\n\t\t\ttype: \"object\",\n\t\t\tproperties,\n\t\t\trequired: keys,\n\t\t},\n\t};\n}\n\n/**\n * Aggregates both analysis **and** execution results from a set of named\n * entries. Returns the aggregated `AnalysisResult` and the object of\n * executed values (or `undefined` if at least one entry is invalid).\n *\n * @param keys         - The keys of the object\n * @param processEntry - Callback that analyzes and executes an entry by its key\n * @returns Aggregated `{ analysis, value }`\n */\nexport function aggregateObjectAnalysisAndExecution(\n\tkeys: string[],\n\tprocessEntry: (key: string) => { analysis: AnalysisResult; value: unknown },\n): { analysis: AnalysisResult; value: unknown } {\n\tconst allDiagnostics: TemplateDiagnostic[] = [];\n\tconst properties: Record<string, JSONSchema7> = {};\n\tconst resultValues: Record<string, unknown> = {};\n\tlet allValid = true;\n\n\tfor (const key of keys) {\n\t\tconst child = processEntry(key);\n\t\tif (!child.analysis.valid) allValid = false;\n\t\tallDiagnostics.push(...child.analysis.diagnostics);\n\t\tproperties[key] = child.analysis.outputSchema;\n\t\tresultValues[key] = child.value;\n\t}\n\n\tconst analysis: AnalysisResult = {\n\t\tvalid: allValid,\n\t\tdiagnostics: allDiagnostics,\n\t\toutputSchema: {\n\t\t\ttype: \"object\",\n\t\t\tproperties,\n\t\t\trequired: keys,\n\t\t},\n\t};\n\n\treturn {\n\t\tanalysis,\n\t\tvalue: allValid ? resultValues : undefined,\n\t};\n}\n"],"names":["deepEqual","a","b","Array","isArray","length","i","objA","objB","keysA","Object","keys","keysB","key","LRUCache","get","cache","has","undefined","value","delete","set","size","capacity","oldestKey","next","clear","Map","Error","extractSourceSnippet","template","loc","lines","split","startLine","start","line","endLine","end","trim","clampedEnd","Math","min","slice","map","l","trimEnd","join","getSchemaPropertyNames","schema","names","Set","properties","add","combinator","branches","branch","from","sort","aggregateObjectAnalysis","analyzeEntry","allDiagnostics","allValid","child","valid","push","diagnostics","outputSchema","type","required","aggregateObjectAnalysisAndExecution","processEntry","resultValues","analysis"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "typebars",
-	"version": "1.0.3",
+	"version": "1.0.5",
 	"license": "MIT",
 	"description": "Typebars is a type-safe handlebars based template engine for generating object or content with static type checking",
 	"author": {
@@ -8,9 +8,22 @@
 		"url": "https://github.com/atinseau/typebars",
 		"name": "atinseau"
 	},
-	"main": "dist/index.js",
-	"types": "dist/index.d.ts",
 	"type": "module",
+	"main": "./dist/cjs/index.js",
+	"module": "./dist/esm/index.js",
+	"types": "./dist/esm/index.d.ts",
+	"exports": {
+		".": {
+			"import": {
+				"types": "./dist/esm/index.d.ts",
+				"default": "./dist/esm/index.js"
+			},
+			"require": {
+				"types": "./dist/cjs/index.d.ts",
+				"default": "./dist/cjs/index.js"
+			}
+		}
+	},
 	"sideEffects": false,
 	"files": [
 		"dist",
@@ -18,9 +31,16 @@
 	],
 	"scripts": {
 		"prepare": "lefthook install",
-		"build:bun": "bun build src/*.ts --outdir ./dist --production --minify --root src --sourcemap --splitting --target node --format esm --packages external --chunk-naming='chunk-[hash].js'",
-		"build:tsc": "tsc --project tsconfig.build.json",
-		"build": "bun --parallel build:bun build:tsc",
+		"clean": "rm -rf dist",
+		"build:esm": "swc src -d dist/esm --strip-leading-paths --config-file .swcrc.esm.json",
+		"build:cjs": "swc src -d dist/cjs --strip-leading-paths --config-file .swcrc.cjs.json",
+		"build:types:esm": "tsc --project tsconfig.build.json",
+		"build:types:cjs": "tsc --project tsconfig.build.cjs.json",
+		"build:swc": "bun --parallel build:esm build:cjs",
+		"build:types": "bun --parallel build:types:esm build:types:cjs",
+		"build": "bun run clean && bun --parallel build:swc build:types && bun run postbuild",
+		"postbuild": "bun scripts/postbuild.ts",
+		"test:integration": "bun test tests/integration/",
 		"prepublishOnly": "bun run build",
 		"check-types": "tsc --noEmit",
 		"check": "biome check --write --unsafe",
@@ -28,8 +48,11 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.4.3",
+		"@swc/cli": "0.8.0",
+		"@swc/core": "1.15.17",
 		"@types/bun": "latest",
 		"@types/json-schema": "7.0.15",
+		"es-module-lexer": "^2.0.0",
 		"lefthook": "2.1.1"
 	},
 	"peerDependencies": {

package/dist/analyzer.js

@@ -1,4 +0,0 @@
-import{b as a,c as b,d as c}from"./chunk-dpffacsy.js";import"./chunk-8xza8tca.js";import"./chunk-s96k41p3.js";import"./chunk-5znsrn10.js";import"./chunk-9jxzj2h4.js";import"./chunk-gayk9ew1.js";export{c as inferBlockType,b as analyzeFromAst,a as analyze};
-
-//# debugId=417A4C32D75B517C64756E2164756E21
-//# sourceMappingURL=analyzer.js.map

package/dist/analyzer.js.map

@@ -1,9 +0,0 @@
-{
-  "version": 3,
-  "sources": [],
-  "sourcesContent": [
-  ],
-  "mappings": "",
-  "debugId": "417A4C32D75B517C64756E2164756E21",
-  "names": []
-}

package/dist/chunk-5znsrn10.js

@@ -1,5 +0,0 @@
-import{D as Q}from"./chunk-9jxzj2h4.js";import{N as M}from"./chunk-gayk9ew1.js";function L(z,B="",A=new Set){if(A.has(z))return;if(A.add(z),z.if!==void 0)throw new M("if/then/else",B||"/");if(z.then!==void 0)throw new M("if/then/else",B||"/");if(z.else!==void 0)throw new M("if/then/else",B||"/");if(z.properties){for(let[j,D]of Object.entries(z.properties))if(D&&typeof D!=="boolean")L(D,`${B}/properties/${j}`,A)}if(z.additionalProperties&&typeof z.additionalProperties==="object")L(z.additionalProperties,`${B}/additionalProperties`,A);if(z.items){if(Array.isArray(z.items))for(let j=0;j<z.items.length;j++){let D=z.items[j];if(D&&typeof D!=="boolean")L(D,`${B}/items/${j}`,A)}else if(typeof z.items!=="boolean")L(z.items,`${B}/items`,A)}for(let j of["allOf","anyOf","oneOf"]){let D=z[j];if(D)for(let F=0;F<D.length;F++){let G=D[F];if(G&&typeof G!=="boolean")L(G,`${B}/${j}/${F}`,A)}}if(z.not&&typeof z.not!=="boolean")L(z.not,`${B}/not`,A);for(let j of["definitions","$defs"]){let D=z[j];if(D){for(let[F,G]of Object.entries(D))if(G&&typeof G!=="boolean")L(G,`${B}/${j}/${F}`,A)}}}function H(z,B){if(!z.$ref)return z;let A=z.$ref,j=A.match(/^#\/(definitions|\$defs)\/(.+)$/);if(!j)throw Error(`Unsupported $ref format: "${A}". Only internal #/definitions/ references are supported.`);let D=j[1],F=j[2]??"",G=D==="definitions"?B.definitions:B.$defs;if(!G||!(F in G))throw Error(`Cannot resolve $ref "${A}": definition "${F}" not found.`);let J=G[F];if(!J||typeof J==="boolean")throw Error(`Cannot resolve $ref "${A}": definition "${F}" not found.`);return H(J,B)}function P(z,B,A){let j=H(z,A);if(j.properties&&B in j.properties){let J=j.properties[B];if(J&&typeof J!=="boolean")return H(J,A);if(J===!0)return{}}if(j.additionalProperties!==void 0&&j.additionalProperties!==!1){if(j.additionalProperties===!0)return{};return H(j.additionalProperties,A)}let D=j.type;if((D==="array"||Array.isArray(D)&&D.includes("array"))&&B==="length")return{type:"integer"};let G=V(j,B,A);if(G)return G;return}function V(z,B,A){if(z.allOf){let j=z.allOf.filter((D)=>typeof D!=="boolean").map((D)=>P(D,B,A)).filter((D)=>D!==void 0);if(j.length===1)return j[0];if(j.length>1)return{allOf:j}}for(let j of["anyOf","oneOf"]){if(!z[j])continue;let D=z[j].filter((F)=>typeof F!=="boolean").map((F)=>P(F,B,A)).filter((F)=>F!==void 0);if(D.length===1)return D[0];if(D.length>1)return{[j]:D}}return}function Y(z,B){if(B.length===0)return H(z,z);let A=H(z,z),j=z;for(let D of B){let F=P(A,D,j);if(F===void 0)return;A=F}return A}function Z(z,B){let A=H(z,B),j=A.type;if(!(j==="array"||Array.isArray(j)&&j.includes("array"))&&A.items===void 0)return;if(A.items===void 0)return{};if(typeof A.items==="boolean")return{};if(Array.isArray(A.items)){let F=A.items.filter((G)=>typeof G!=="boolean").map((G)=>H(G,B));if(F.length===0)return{};return{oneOf:F}}return H(A.items,B)}function O(z){for(let B of["oneOf","anyOf"]){let A=z[B];if(A&&A.length===1){let j=A[0];if(j!==void 0&&typeof j!=="boolean")return O(j)}}if(z.allOf&&z.allOf.length===1){let B=z.allOf[0];if(B!==void 0&&typeof B!=="boolean")return O(B)}for(let B of["oneOf","anyOf"]){let A=z[B];if(A&&A.length>1){let j=[];for(let D of A){if(typeof D==="boolean")continue;if(!j.some((G)=>Q(G,D)))j.push(O(D))}if(j.length===1)return j[0];return{...z,[B]:j}}}return z}
-export{L as y,H as z,Y as A,Z as B,O as C};
-
-//# debugId=F89A6CEA5796209264756E2164756E21
-//# sourceMappingURL=chunk-5znsrn10.js.map

package/dist/chunk-5znsrn10.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/schema-resolver.ts"],
-  "sourcesContent": [
-    "import type { JSONSchema7 } from \"json-schema\";\nimport { UnsupportedSchemaError } from \"./errors.ts\";\nimport { deepEqual } from \"./utils.ts\";\n\n// ─── JSON Schema Resolver ────────────────────────────────────────────────────\n// Utility for navigating a JSON Schema Draft v7 by following a property path\n// (e.g. [\"user\", \"address\", \"city\"]).\n//\n// Handles:\n// - `$ref` resolution (internal references #/definitions/...)\n// - Navigation through `properties`\n// - Navigation through `items` (array elements)\n// - Combinators `allOf`, `anyOf`, `oneOf` (searches each branch)\n// - `additionalProperties` when the property is not explicitly declared\n//\n// Rejects:\n// - Conditional schemas (`if/then/else`) — non-resolvable without runtime data\n\n// ─── Conditional Schema Detection ────────────────────────────────────────────\n// JSON Schema Draft v7 introduced `if/then/else` conditional schemas.\n// These are fundamentally non-resolvable during static analysis because\n// they depend on runtime data values. Rather than silently ignoring them\n// (which would produce incorrect results — missing properties, wrong types),\n// we fail fast with a clear error pointing to the exact location in the schema.\n\n/**\n * Recursively validates that a JSON Schema does not contain `if/then/else`\n * conditional keywords. Throws an `UnsupportedSchemaError` if any are found.\n *\n * This check traverses the entire schema tree, including:\n * - `properties` values\n * - `additionalProperties` (when it's a schema)\n * - `items` (single schema or tuple)\n * - `allOf`, `anyOf`, `oneOf` branches\n * - `not`\n * - `definitions` / `$defs` values\n *\n * A `Set<object>` is used to track visited schemas and prevent infinite loops\n * from circular structures.\n *\n * @param schema - The JSON Schema to validate\n * @param path   - The current JSON pointer path (for error reporting)\n * @param visited - Set of already-visited schema objects (cycle protection)\n *\n * @throws {UnsupportedSchemaError} if `if`, `then`, or `else` is found\n *\n * @example\n * ```\n * // Throws UnsupportedSchemaError:\n * assertNoConditionalSchema({\n *   type: \"object\",\n *   if: { properties: { kind: { const: \"a\" } } },\n *   then: { properties: { a: { type: \"string\" } } },\n * });\n *\n * // OK — no conditional keywords:\n * assertNoConditionalSchema({\n *   type: \"object\",\n *   properties: { name: { type: \"string\" } },\n * });\n * ```\n */\nexport function assertNoConditionalSchema(\n\tschema: JSONSchema7,\n\tpath = \"\",\n\tvisited: Set<object> = new Set(),\n): void {\n\t// Cycle protection — avoid infinite loops on circular schema structures\n\tif (visited.has(schema)) return;\n\tvisited.add(schema);\n\n\t// ── Detect if/then/else at the current level ─────────────────────────\n\tif (schema.if !== undefined) {\n\t\tthrow new UnsupportedSchemaError(\"if/then/else\", path || \"/\");\n\t}\n\t// `then` or `else` without `if` is unusual but still unsupported\n\tif (schema.then !== undefined) {\n\t\tthrow new UnsupportedSchemaError(\"if/then/else\", path || \"/\");\n\t}\n\tif (schema.else !== undefined) {\n\t\tthrow new UnsupportedSchemaError(\"if/then/else\", path || \"/\");\n\t}\n\n\t// ── Recurse into properties ──────────────────────────────────────────\n\tif (schema.properties) {\n\t\tfor (const [key, prop] of Object.entries(schema.properties)) {\n\t\t\tif (prop && typeof prop !== \"boolean\") {\n\t\t\t\tassertNoConditionalSchema(prop, `${path}/properties/${key}`, visited);\n\t\t\t}\n\t\t}\n\t}\n\n\t// ── Recurse into additionalProperties ────────────────────────────────\n\tif (\n\t\tschema.additionalProperties &&\n\t\ttypeof schema.additionalProperties === \"object\"\n\t) {\n\t\tassertNoConditionalSchema(\n\t\t\tschema.additionalProperties,\n\t\t\t`${path}/additionalProperties`,\n\t\t\tvisited,\n\t\t);\n\t}\n\n\t// ── Recurse into items ───────────────────────────────────────────────\n\tif (schema.items) {\n\t\tif (Array.isArray(schema.items)) {\n\t\t\tfor (let i = 0; i < schema.items.length; i++) {\n\t\t\t\tconst item = schema.items[i];\n\t\t\t\tif (item && typeof item !== \"boolean\") {\n\t\t\t\t\tassertNoConditionalSchema(item, `${path}/items/${i}`, visited);\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (typeof schema.items !== \"boolean\") {\n\t\t\tassertNoConditionalSchema(schema.items, `${path}/items`, visited);\n\t\t}\n\t}\n\n\t// ── Recurse into combinators ─────────────────────────────────────────\n\tfor (const keyword of [\"allOf\", \"anyOf\", \"oneOf\"] as const) {\n\t\tconst branches = schema[keyword];\n\t\tif (branches) {\n\t\t\tfor (let i = 0; i < branches.length; i++) {\n\t\t\t\tconst branch = branches[i];\n\t\t\t\tif (branch && typeof branch !== \"boolean\") {\n\t\t\t\t\tassertNoConditionalSchema(branch, `${path}/${keyword}/${i}`, visited);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// ── Recurse into not ─────────────────────────────────────────────────\n\tif (schema.not && typeof schema.not !== \"boolean\") {\n\t\tassertNoConditionalSchema(schema.not, `${path}/not`, visited);\n\t}\n\n\t// ── Recurse into definitions / $defs ─────────────────────────────────\n\tfor (const defsKey of [\"definitions\", \"$defs\"] as const) {\n\t\tconst defs = schema[defsKey];\n\t\tif (defs) {\n\t\t\tfor (const [name, def] of Object.entries(defs)) {\n\t\t\t\tif (def && typeof def !== \"boolean\") {\n\t\t\t\t\tassertNoConditionalSchema(def, `${path}/${defsKey}/${name}`, visited);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\n// ─── $ref Resolution ─────────────────────────────────────────────────────────\n// Only supports internal references in the format `#/definitions/Foo`\n// or `#/$defs/Foo` (JSON Schema Draft 2019+). Remote $refs (URLs) are\n// not supported — that is outside the scope of a template engine.\n\n/**\n * Recursively resolves `$ref` in a schema using the root schema as the\n * source of definitions.\n */\nexport function resolveRef(\n\tschema: JSONSchema7,\n\troot: JSONSchema7,\n): JSONSchema7 {\n\tif (!schema.$ref) return schema;\n\n\tconst ref = schema.$ref;\n\n\t// Expected format: #/definitions/Name or #/$defs/Name\n\tconst match = ref.match(/^#\\/(definitions|\\$defs)\\/(.+)$/);\n\tif (!match) {\n\t\tthrow new Error(\n\t\t\t`Unsupported $ref format: \"${ref}\". Only internal #/definitions/ references are supported.`,\n\t\t);\n\t}\n\n\tconst defsKey = match[1] as \"definitions\" | \"$defs\";\n\tconst name = match[2] ?? \"\";\n\n\tconst defs = defsKey === \"definitions\" ? root.definitions : root.$defs;\n\n\tif (!defs || !(name in defs)) {\n\t\tthrow new Error(\n\t\t\t`Cannot resolve $ref \"${ref}\": definition \"${name}\" not found.`,\n\t\t);\n\t}\n\n\t// Recursive resolution in case the definition itself contains a $ref\n\tconst def = defs[name];\n\tif (!def || typeof def === \"boolean\") {\n\t\tthrow new Error(\n\t\t\t`Cannot resolve $ref \"${ref}\": definition \"${name}\" not found.`,\n\t\t);\n\t}\n\treturn resolveRef(def, root);\n}\n\n// ─── Single-Segment Path Navigation ─────────────────────────────────────────\n\n/**\n * Resolves a single path segment (a property name) within a schema.\n * Returns the corresponding sub-schema, or `undefined` if the path is invalid.\n *\n * @param schema  - The current schema (already resolved, no $ref)\n * @param segment - The property name to resolve\n * @param root    - The root schema (for resolving any internal $refs)\n */\nfunction resolveSegment(\n\tschema: JSONSchema7,\n\tsegment: string,\n\troot: JSONSchema7,\n): JSONSchema7 | undefined {\n\tconst resolved = resolveRef(schema, root);\n\n\t// 1. Explicit properties\n\tif (resolved.properties && segment in resolved.properties) {\n\t\tconst prop = resolved.properties[segment];\n\t\tif (prop && typeof prop !== \"boolean\") return resolveRef(prop, root);\n\t\tif (prop === true) return {};\n\t}\n\n\t// 2. additionalProperties (when the property is not declared)\n\tif (\n\t\tresolved.additionalProperties !== undefined &&\n\t\tresolved.additionalProperties !== false\n\t) {\n\t\tif (resolved.additionalProperties === true) {\n\t\t\t// additionalProperties: true → type is unknown\n\t\t\treturn {};\n\t\t}\n\t\treturn resolveRef(resolved.additionalProperties, root);\n\t}\n\n\t// 3. Intrinsic array properties (e.g. `.length`)\n\tconst schemaType = resolved.type;\n\tconst isArray =\n\t\tschemaType === \"array\" ||\n\t\t(Array.isArray(schemaType) && schemaType.includes(\"array\"));\n\n\tif (isArray && segment === \"length\") {\n\t\treturn { type: \"integer\" };\n\t}\n\n\t// 4. Combinators — search within each branch\n\tconst combinatorResult = resolveInCombinators(resolved, segment, root);\n\tif (combinatorResult) return combinatorResult;\n\n\treturn undefined;\n}\n\n/**\n * Searches for a segment within `allOf`, `anyOf`, `oneOf` branches.\n * Returns the first matching sub-schema, or `undefined`.\n * For `allOf`, found results are merged into a single `allOf`.\n */\nfunction resolveInCombinators(\n\tschema: JSONSchema7,\n\tsegment: string,\n\troot: JSONSchema7,\n): JSONSchema7 | undefined {\n\t// allOf: the property can be defined in any branch, and all constraints\n\t// apply simultaneously.\n\tif (schema.allOf) {\n\t\tconst matches = schema.allOf\n\t\t\t.filter((b): b is JSONSchema7 => typeof b !== \"boolean\")\n\t\t\t.map((branch) => resolveSegment(branch, segment, root))\n\t\t\t.filter((s): s is JSONSchema7 => s !== undefined);\n\n\t\tif (matches.length === 1) return matches[0] as JSONSchema7;\n\t\tif (matches.length > 1) return { allOf: matches };\n\t}\n\n\t// anyOf / oneOf: the property can come from any branch.\n\tfor (const key of [\"anyOf\", \"oneOf\"] as const) {\n\t\tif (!schema[key]) continue;\n\t\tconst matches = schema[key]\n\t\t\t.filter((b): b is JSONSchema7 => typeof b !== \"boolean\")\n\t\t\t.map((branch) => resolveSegment(branch, segment, root))\n\t\t\t.filter((s): s is JSONSchema7 => s !== undefined);\n\n\t\tif (matches.length === 1) return matches[0] as JSONSchema7;\n\t\tif (matches.length > 1) return { [key]: matches };\n\t}\n\n\treturn undefined;\n}\n\n// ─── Public API ──────────────────────────────────────────────────────────────\n\n/**\n * Resolves a full path (e.g. [\"user\", \"address\", \"city\"]) within a JSON\n * Schema and returns the corresponding sub-schema.\n *\n * @param schema - The root schema describing the template context\n * @param path   - Array of segments (property names)\n * @returns The sub-schema at the end of the path, or `undefined` if the path\n *          cannot be resolved.\n *\n * @example\n * ```\n * const schema = {\n *   type: \"object\",\n *   properties: {\n *     user: {\n *       type: \"object\",\n *       properties: {\n *         name: { type: \"string\" }\n *       }\n *     }\n *   }\n * };\n * resolveSchemaPath(schema, [\"user\", \"name\"]);\n * // → { type: \"string\" }\n * ```\n */\nexport function resolveSchemaPath(\n\tschema: JSONSchema7,\n\tpath: string[],\n): JSONSchema7 | undefined {\n\tif (path.length === 0) return resolveRef(schema, schema);\n\n\tlet current: JSONSchema7 = resolveRef(schema, schema);\n\tconst root = schema;\n\n\tfor (const segment of path) {\n\t\tconst next = resolveSegment(current, segment, root);\n\t\tif (next === undefined) return undefined;\n\t\tcurrent = next;\n\t}\n\n\treturn current;\n}\n\n/**\n * Resolves the item schema of an array.\n * If the schema is not of type `array` or has no `items`, returns `undefined`.\n *\n * @param schema - The array schema\n * @param root   - The root schema (for resolving $refs)\n */\nexport function resolveArrayItems(\n\tschema: JSONSchema7,\n\troot: JSONSchema7,\n): JSONSchema7 | undefined {\n\tconst resolved = resolveRef(schema, root);\n\n\t// Verify that it's actually an array\n\tconst schemaType = resolved.type;\n\tconst isArray =\n\t\tschemaType === \"array\" ||\n\t\t(Array.isArray(schemaType) && schemaType.includes(\"array\"));\n\n\tif (!isArray && resolved.items === undefined) {\n\t\treturn undefined;\n\t}\n\n\tif (resolved.items === undefined) {\n\t\t// array without items → element type is unknown\n\t\treturn {};\n\t}\n\n\t// items can be a boolean (true = anything, false = nothing)\n\tif (typeof resolved.items === \"boolean\") {\n\t\treturn {};\n\t}\n\n\t// items can be a single schema or a tuple (array of schemas).\n\t// For template loops, we handle the single-schema case.\n\tif (Array.isArray(resolved.items)) {\n\t\t// Tuple: create a oneOf of all possible types\n\t\tconst schemas = resolved.items\n\t\t\t.filter((item): item is JSONSchema7 => typeof item !== \"boolean\")\n\t\t\t.map((item) => resolveRef(item, root));\n\t\tif (schemas.length === 0) return {};\n\t\treturn { oneOf: schemas };\n\t}\n\n\treturn resolveRef(resolved.items, root);\n}\n\n/**\n * Simplifies an output schema to avoid unnecessarily complex constructs\n * (e.g. `oneOf` with a single element, duplicates, etc.).\n *\n * Uses `deepEqual` for deduplication — more robust and performant than\n * `JSON.stringify` (independent of key order, no intermediate string\n * allocations).\n */\nexport function simplifySchema(schema: JSONSchema7): JSONSchema7 {\n\t// oneOf / anyOf with a single element → unwrap\n\tfor (const key of [\"oneOf\", \"anyOf\"] as const) {\n\t\tconst arr = schema[key];\n\t\tif (arr && arr.length === 1) {\n\t\t\tconst first = arr[0];\n\t\t\tif (first !== undefined && typeof first !== \"boolean\")\n\t\t\t\treturn simplifySchema(first);\n\t\t}\n\t}\n\n\t// allOf with a single element → unwrap\n\tif (schema.allOf && schema.allOf.length === 1) {\n\t\tconst first = schema.allOf[0];\n\t\tif (first !== undefined && typeof first !== \"boolean\")\n\t\t\treturn simplifySchema(first);\n\t}\n\n\t// Deduplicate identical entries in oneOf/anyOf\n\tfor (const key of [\"oneOf\", \"anyOf\"] as const) {\n\t\tconst arr = schema[key];\n\t\tif (arr && arr.length > 1) {\n\t\t\tconst unique: JSONSchema7[] = [];\n\t\t\tfor (const entry of arr) {\n\t\t\t\tif (typeof entry === \"boolean\") continue;\n\t\t\t\t// Use deepEqual instead of JSON.stringify for structural\n\t\t\t\t// comparison — more robust (key order independent) and\n\t\t\t\t// more performant (no string allocations).\n\t\t\t\tconst isDuplicate = unique.some((existing) =>\n\t\t\t\t\tdeepEqual(existing, entry),\n\t\t\t\t);\n\t\t\t\tif (!isDuplicate) {\n\t\t\t\t\tunique.push(simplifySchema(entry));\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (unique.length === 1) return unique[0] as JSONSchema7;\n\t\t\treturn { ...schema, [key]: unique };\n\t\t}\n\t}\n\n\treturn schema;\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "F89A6CEA5796209264756E2164756E21",
-  "names": []
-}

package/dist/chunk-867xywnk.js

@@ -1,5 +0,0 @@
-import{c as N}from"./chunk-dpffacsy.js";import{f as J}from"./chunk-wvnn9g55.js";import{k as I}from"./chunk-8xza8tca.js";import{H as L,I as M}from"./chunk-9jxzj2h4.js";import{L as K}from"./chunk-gayk9ew1.js";class H{state;options;hbsCompiled=null;get ast(){return this.state.kind==="template"?this.state.ast:null}get template(){return this.state.kind==="template"?this.state.source:""}constructor(w,q){this.state=w,this.options=q}static fromTemplate(w,q,B){return new H({kind:"template",ast:w,source:q},B)}static fromLiteral(w,q){return new H({kind:"literal",value:w},q)}static fromObject(w,q){return new H({kind:"object",children:w},q)}analyze(w,q){switch(this.state.kind){case"object":{let{children:B}=this.state;return L(Object.keys(B),(D)=>{let G=B[D];if(!G)throw Error(`unreachable: missing child "${D}"`);return G.analyze(w,q)})}case"literal":return{valid:!0,diagnostics:[],outputSchema:I(this.state.value)};case"template":return N(this.state.ast,this.state.source,w,{identifierSchemas:q,helpers:this.options.helpers})}}validate(w,q){let B=this.analyze(w,q);return{valid:B.valid,diagnostics:B.diagnostics}}execute(w,q){switch(this.state.kind){case"object":{let{children:B}=this.state,D={};for(let[G,Q]of Object.entries(B))D[G]=Q.execute(w,q);return D}case"literal":return this.state.value;case"template":{if(q?.schema){let B=this.analyze(q.schema,q.identifierSchemas);if(!B.valid)throw new K(B.diagnostics)}return J(this.state.ast,this.state.source,w,this.buildExecutorContext(q))}}}analyzeAndExecute(w,q,B){switch(this.state.kind){case"object":{let{children:D}=this.state;return M(Object.keys(D),(G)=>D[G].analyzeAndExecute(w,q,B))}case"literal":return{analysis:{valid:!0,diagnostics:[],outputSchema:I(this.state.value)},value:this.state.value};case"template":{let D=this.analyze(w,B?.identifierSchemas);if(!D.valid)return{analysis:D,value:void 0};let G=J(this.state.ast,this.state.source,q,this.buildExecutorContext({identifierData:B?.identifierData}));return{analysis:D,value:G}}}}buildExecutorContext(w){return{identifierData:w?.identifierData,compiledTemplate:this.getOrCompileHbs(),hbs:this.options.hbs,compilationCache:this.options.compilationCache}}getOrCompileHbs(){if(!this.hbsCompiled)this.hbsCompiled=this.options.hbs.compile(this.template,{noEscape:!0,strict:!1});return this.hbsCompiled}}
-export{H as a};
-
-//# debugId=C5C16B277901BD3E64756E2164756E21
-//# sourceMappingURL=chunk-867xywnk.js.map

package/dist/chunk-867xywnk.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/compiled-template.ts"],
-  "sourcesContent": [
-    "import type Handlebars from \"handlebars\";\nimport type { JSONSchema7 } from \"json-schema\";\nimport { analyzeFromAst } from \"./analyzer.ts\";\nimport { TemplateAnalysisError } from \"./errors.ts\";\nimport { type ExecutorContext, executeFromAst } from \"./executor.ts\";\nimport type {\n\tAnalysisResult,\n\tExecuteOptions,\n\tHelperDefinition,\n\tValidationResult,\n} from \"./types.ts\";\nimport { inferPrimitiveSchema } from \"./types.ts\";\nimport {\n\taggregateObjectAnalysis,\n\taggregateObjectAnalysisAndExecution,\n\ttype LRUCache,\n} from \"./utils.ts\";\n\n// ─── CompiledTemplate ────────────────────────────────────────────────────────\n// Pre-parsed template ready to be executed or analyzed without re-parsing.\n//\n// The compile-once / execute-many pattern avoids the cost of Handlebars\n// parsing on every call. The AST is parsed once at compile time, and the\n// Handlebars template is lazily compiled on the first `execute()`.\n//\n// Usage:\n//   const tpl = engine.compile(\"Hello {{name}}\");\n//   tpl.execute({ name: \"Alice\" });   // no re-parsing\n//   tpl.execute({ name: \"Bob\" });     // no re-parsing or recompilation\n//   tpl.analyze(schema);              // no re-parsing\n//\n// ─── Internal State (TemplateState) ──────────────────────────────────────────\n// CompiledTemplate operates in 3 exclusive modes, modeled by a discriminated\n// union `TemplateState`:\n//\n// - `\"template\"` — parsed Handlebars template (AST + source string)\n// - `\"literal\"`  — primitive passthrough value (number, boolean, null)\n// - `\"object\"`   — object where each property is a child CompiledTemplate\n//\n// This design eliminates optional fields and `!` assertions in favor of\n// natural TypeScript narrowing via `switch (this.state.kind)`.\n//\n// ─── Advantages Over the Direct API ──────────────────────────────────────────\n// - **Performance**: parsing and compilation happen only once\n// - **Simplified API**: no need to re-pass the template string on each call\n// - **Consistency**: the same AST is used for both analysis and execution\n\n// ─── Internal Types ──────────────────────────────────────────────────────────\n\n/** Internal options passed by Typebars during compilation */\nexport interface CompiledTemplateOptions {\n\t/** Custom helpers registered on the engine */\n\thelpers: Map<string, HelperDefinition>;\n\t/** Isolated Handlebars environment (with registered helpers) */\n\thbs: typeof Handlebars;\n\t/** Compilation cache shared by the engine */\n\tcompilationCache: LRUCache<string, HandlebarsTemplateDelegate>;\n}\n\n/** Discriminated internal state of the CompiledTemplate */\ntype TemplateState =\n\t| {\n\t\t\treadonly kind: \"template\";\n\t\t\treadonly ast: hbs.AST.Program;\n\t\t\treadonly source: string;\n\t  }\n\t| { readonly kind: \"literal\"; readonly value: number | boolean | null }\n\t| {\n\t\t\treadonly kind: \"object\";\n\t\t\treadonly children: Record<string, CompiledTemplate>;\n\t  };\n\n// ─── Public Class ────────────────────────────────────────────────────────────\n\nexport class CompiledTemplate {\n\t/** Discriminated internal state */\n\tprivate readonly state: TemplateState;\n\n\t/** Options inherited from the parent Typebars instance */\n\tprivate readonly options: CompiledTemplateOptions;\n\n\t/** Compiled Handlebars template (lazy — created on the first `execute()` that needs it) */\n\tprivate hbsCompiled: HandlebarsTemplateDelegate | null = null;\n\n\t// ─── Public Accessors (backward-compatible) ──────────────────────────\n\n\t/** The pre-parsed Handlebars AST — `null` in literal or object mode */\n\tget ast(): hbs.AST.Program | null {\n\t\treturn this.state.kind === \"template\" ? this.state.ast : null;\n\t}\n\n\t/** The original template source — empty string in literal or object mode */\n\tget template(): string {\n\t\treturn this.state.kind === \"template\" ? this.state.source : \"\";\n\t}\n\n\t// ─── Construction ────────────────────────────────────────────────────\n\n\tprivate constructor(state: TemplateState, options: CompiledTemplateOptions) {\n\t\tthis.state = state;\n\t\tthis.options = options;\n\t}\n\n\t/**\n\t * Creates a CompiledTemplate for a parsed Handlebars template.\n\t *\n\t * @param ast     - The pre-parsed Handlebars AST\n\t * @param source  - The original template source\n\t * @param options - Options inherited from Typebars\n\t */\n\tstatic fromTemplate(\n\t\tast: hbs.AST.Program,\n\t\tsource: string,\n\t\toptions: CompiledTemplateOptions,\n\t): CompiledTemplate {\n\t\treturn new CompiledTemplate({ kind: \"template\", ast, source }, options);\n\t}\n\n\t/**\n\t * Creates a CompiledTemplate in passthrough mode for a literal value\n\t * (number, boolean, null). No parsing or compilation is performed.\n\t *\n\t * @param value   - The primitive value\n\t * @param options - Options inherited from Typebars\n\t * @returns A CompiledTemplate that always returns `value`\n\t */\n\tstatic fromLiteral(\n\t\tvalue: number | boolean | null,\n\t\toptions: CompiledTemplateOptions,\n\t): CompiledTemplate {\n\t\treturn new CompiledTemplate({ kind: \"literal\", value }, options);\n\t}\n\n\t/**\n\t * Creates a CompiledTemplate in object mode, where each property is a\n\t * child CompiledTemplate. All operations are recursively delegated\n\t * to the children.\n\t *\n\t * @param children - The compiled child templates `{ [key]: CompiledTemplate }`\n\t * @param options  - Options inherited from Typebars\n\t * @returns A CompiledTemplate that delegates to children\n\t */\n\tstatic fromObject(\n\t\tchildren: Record<string, CompiledTemplate>,\n\t\toptions: CompiledTemplateOptions,\n\t): CompiledTemplate {\n\t\treturn new CompiledTemplate({ kind: \"object\", children }, options);\n\t}\n\n\t// ─── Static Analysis ─────────────────────────────────────────────────\n\n\t/**\n\t * Statically analyzes this template against a JSON Schema v7.\n\t *\n\t * Returns an `AnalysisResult` containing:\n\t * - `valid`        — `true` if no errors\n\t * - `diagnostics`  — list of diagnostics (errors + warnings)\n\t * - `outputSchema` — JSON Schema describing the return type\n\t *\n\t * Since the AST is pre-parsed, this method never re-parses the template.\n\t *\n\t * @param inputSchema        - JSON Schema describing the available variables\n\t * @param identifierSchemas  - (optional) Schemas by identifier `{ [id]: JSONSchema7 }`\n\t */\n\tanalyze(\n\t\tinputSchema: JSONSchema7,\n\t\tidentifierSchemas?: Record<number, JSONSchema7>,\n\t): AnalysisResult {\n\t\tswitch (this.state.kind) {\n\t\t\tcase \"object\": {\n\t\t\t\tconst { children } = this.state;\n\t\t\t\treturn aggregateObjectAnalysis(Object.keys(children), (key) => {\n\t\t\t\t\tconst child = children[key];\n\t\t\t\t\tif (!child) throw new Error(`unreachable: missing child \"${key}\"`);\n\t\t\t\t\treturn child.analyze(inputSchema, identifierSchemas);\n\t\t\t\t});\n\t\t\t}\n\n\t\t\tcase \"literal\":\n\t\t\t\treturn {\n\t\t\t\t\tvalid: true,\n\t\t\t\t\tdiagnostics: [],\n\t\t\t\t\toutputSchema: inferPrimitiveSchema(this.state.value),\n\t\t\t\t};\n\n\t\t\tcase \"template\":\n\t\t\t\treturn analyzeFromAst(this.state.ast, this.state.source, inputSchema, {\n\t\t\t\t\tidentifierSchemas,\n\t\t\t\t\thelpers: this.options.helpers,\n\t\t\t\t});\n\t\t}\n\t}\n\n\t// ─── Validation ──────────────────────────────────────────────────────\n\n\t/**\n\t * Validates the template against a schema without returning the output type.\n\t *\n\t * This is an API shortcut for `analyze()` that only returns `valid` and\n\t * `diagnostics`, without `outputSchema`. The full analysis (including type\n\t * inference) is executed internally — this method provides no performance\n\t * gain, only a simplified API.\n\t *\n\t * @param inputSchema        - JSON Schema describing the available variables\n\t * @param identifierSchemas  - (optional) Schemas by identifier\n\t */\n\tvalidate(\n\t\tinputSchema: JSONSchema7,\n\t\tidentifierSchemas?: Record<number, JSONSchema7>,\n\t): ValidationResult {\n\t\tconst analysis = this.analyze(inputSchema, identifierSchemas);\n\t\treturn {\n\t\t\tvalid: analysis.valid,\n\t\t\tdiagnostics: analysis.diagnostics,\n\t\t};\n\t}\n\n\t// ─── Execution ───────────────────────────────────────────────────────\n\n\t/**\n\t * Executes this template with the provided data.\n\t *\n\t * The return type depends on the template structure:\n\t * - Single expression `{{expr}}` → raw value (number, boolean, object…)\n\t * - Mixed template or with blocks → `string`\n\t * - Primitive literal → the value as-is\n\t * - Object template → object with resolved values\n\t *\n\t * If a `schema` is provided in options, static analysis is performed\n\t * before execution. A `TemplateAnalysisError` is thrown on errors.\n\t *\n\t * @param data    - The context data for rendering\n\t * @param options - Execution options (schema, identifierData, etc.)\n\t * @returns The execution result\n\t */\n\texecute(data: Record<string, unknown>, options?: ExecuteOptions): unknown {\n\t\tswitch (this.state.kind) {\n\t\t\tcase \"object\": {\n\t\t\t\tconst { children } = this.state;\n\t\t\t\tconst result: Record<string, unknown> = {};\n\t\t\t\tfor (const [key, child] of Object.entries(children)) {\n\t\t\t\t\tresult[key] = child.execute(data, options);\n\t\t\t\t}\n\t\t\t\treturn result;\n\t\t\t}\n\n\t\t\tcase \"literal\":\n\t\t\t\treturn this.state.value;\n\n\t\t\tcase \"template\": {\n\t\t\t\t// Pre-execution static validation if a schema is provided\n\t\t\t\tif (options?.schema) {\n\t\t\t\t\tconst analysis = this.analyze(\n\t\t\t\t\t\toptions.schema,\n\t\t\t\t\t\toptions.identifierSchemas,\n\t\t\t\t\t);\n\t\t\t\t\tif (!analysis.valid) {\n\t\t\t\t\t\tthrow new TemplateAnalysisError(analysis.diagnostics);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn executeFromAst(\n\t\t\t\t\tthis.state.ast,\n\t\t\t\t\tthis.state.source,\n\t\t\t\t\tdata,\n\t\t\t\t\tthis.buildExecutorContext(options),\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\t// ─── Combined Shortcuts ──────────────────────────────────────────────\n\n\t/**\n\t * Analyzes and executes the template in a single call.\n\t *\n\t * Returns both the analysis result and the executed value.\n\t * If analysis fails, `value` is `undefined`.\n\t *\n\t * @param inputSchema        - JSON Schema describing the available variables\n\t * @param data               - The context data for rendering\n\t * @param options            - Additional options\n\t * @returns `{ analysis, value }`\n\t */\n\tanalyzeAndExecute(\n\t\tinputSchema: JSONSchema7,\n\t\tdata: Record<string, unknown>,\n\t\toptions?: {\n\t\t\tidentifierSchemas?: Record<number, JSONSchema7>;\n\t\t\tidentifierData?: Record<number, Record<string, unknown>>;\n\t\t},\n\t): { analysis: AnalysisResult; value: unknown } {\n\t\tswitch (this.state.kind) {\n\t\t\tcase \"object\": {\n\t\t\t\tconst { children } = this.state;\n\t\t\t\treturn aggregateObjectAnalysisAndExecution(\n\t\t\t\t\tObject.keys(children),\n\t\t\t\t\t// biome-ignore lint/style/noNonNullAssertion: key comes from Object.keys(children), access is guaranteed\n\t\t\t\t\t(key) => children[key]!.analyzeAndExecute(inputSchema, data, options),\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tcase \"literal\":\n\t\t\t\treturn {\n\t\t\t\t\tanalysis: {\n\t\t\t\t\t\tvalid: true,\n\t\t\t\t\t\tdiagnostics: [],\n\t\t\t\t\t\toutputSchema: inferPrimitiveSchema(this.state.value),\n\t\t\t\t\t},\n\t\t\t\t\tvalue: this.state.value,\n\t\t\t\t};\n\n\t\t\tcase \"template\": {\n\t\t\t\tconst analysis = this.analyze(inputSchema, options?.identifierSchemas);\n\n\t\t\t\tif (!analysis.valid) {\n\t\t\t\t\treturn { analysis, value: undefined };\n\t\t\t\t}\n\n\t\t\t\tconst value = executeFromAst(\n\t\t\t\t\tthis.state.ast,\n\t\t\t\t\tthis.state.source,\n\t\t\t\t\tdata,\n\t\t\t\t\tthis.buildExecutorContext({\n\t\t\t\t\t\tidentifierData: options?.identifierData,\n\t\t\t\t\t}),\n\t\t\t\t);\n\n\t\t\t\treturn { analysis, value };\n\t\t\t}\n\t\t}\n\t}\n\n\t// ─── Internals ───────────────────────────────────────────────────────\n\n\t/**\n\t * Builds the execution context for `executeFromAst`.\n\t *\n\t * Uses lazy Handlebars compilation: the template is only compiled\n\t * on the first call that needs it (not for single expressions).\n\t */\n\tprivate buildExecutorContext(options?: ExecuteOptions): ExecutorContext {\n\t\treturn {\n\t\t\tidentifierData: options?.identifierData,\n\t\t\tcompiledTemplate: this.getOrCompileHbs(),\n\t\t\thbs: this.options.hbs,\n\t\t\tcompilationCache: this.options.compilationCache,\n\t\t};\n\t}\n\n\t/**\n\t * Lazily compiles the Handlebars template and caches it.\n\t *\n\t * Compilation happens only once — subsequent calls return the\n\t * in-memory compiled template.\n\t *\n\t * Precondition: this method is only called from \"template\" mode.\n\t */\n\tprivate getOrCompileHbs(): HandlebarsTemplateDelegate {\n\t\tif (!this.hbsCompiled) {\n\t\t\t// In \"template\" mode, `this.template` returns the source string\n\t\t\tthis.hbsCompiled = this.options.hbs.compile(this.template, {\n\t\t\t\tnoEscape: true,\n\t\t\t\tstrict: false,\n\t\t\t});\n\t\t}\n\t\treturn this.hbsCompiled;\n\t}\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "C5C16B277901BD3E64756E2164756E21",
-  "names": []
-}

package/dist/chunk-8xza8tca.js

@@ -1,5 +0,0 @@
-function k(j){return j===null||typeof j!=="string"&&typeof j!=="object"}function z(j){return j!==null&&typeof j==="object"}function A(j){if(j===null)return{type:"null"};if(typeof j==="boolean")return{type:"boolean"};if(typeof j==="number")return Number.isInteger(j)?{type:"integer"}:{type:"number"};return{type:"null"}}function B(j){return j}
-export{k as i,z as j,A as k,B as l};
-
-//# debugId=6623216F1317FB4964756E2164756E21
-//# sourceMappingURL=chunk-8xza8tca.js.map

package/dist/chunk-8xza8tca.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/types.ts"],
-  "sourcesContent": [
-    "import type { JSONSchema7 } from \"json-schema\";\nimport type { FromSchema, JSONSchema } from \"json-schema-to-ts\";\n\n// ─── Template Input ──────────────────────────────────────────────────────────\n// The engine accepts primitive values in addition to template strings.\n// When a non-string value is passed, it is treated as a literal passthrough:\n// analysis returns the inferred type, and execution returns the value as-is.\n\n/**\n * Object where each property is a `TemplateInput` (recursive).\n *\n * Allows passing an entire structure as a template:\n * ```\n * engine.analyze({\n *   userName: \"{{name}}\",\n *   userAge: \"{{age}}\",\n *   nested: { x: \"{{foo}}\" },\n * }, inputSchema);\n * ```\n */\nexport interface TemplateInputObject {\n\t[key: string]: TemplateInput;\n}\n\n/**\n * Input type accepted by the template engine.\n *\n * - `string`              → standard Handlebars template (parsed and executed)\n * - `number`              → numeric literal (passthrough)\n * - `boolean`             → boolean literal (passthrough)\n * - `null`                → null literal (passthrough)\n * - `TemplateInputObject` → object where each property is a `TemplateInput`\n */\nexport type TemplateInput =\n\t| string\n\t| number\n\t| boolean\n\t| null\n\t| TemplateInputObject;\n\n/**\n * Checks whether a value is a non-string primitive literal (number, boolean, null).\n * These values are treated as passthrough by the engine.\n *\n * Note: objects (`TemplateInputObject`) are NOT literals.\n */\nexport function isLiteralInput(\n\tinput: TemplateInput,\n): input is number | boolean | null {\n\treturn (\n\t\tinput === null || (typeof input !== \"string\" && typeof input !== \"object\")\n\t);\n}\n\n/**\n * Checks whether a value is a template object (`TemplateInputObject`).\n * Template objects are processed recursively by the engine:\n * each property is analyzed/executed individually.\n */\nexport function isObjectInput(\n\tinput: TemplateInput,\n): input is TemplateInputObject {\n\treturn input !== null && typeof input === \"object\";\n}\n\n/**\n * Infers the JSON Schema of a non-string primitive value.\n *\n * @param value - The primitive value (number, boolean, null)\n * @returns The corresponding JSON Schema\n *\n * @example\n * ```\n * inferPrimitiveSchema(42)    // → { type: \"number\" }\n * inferPrimitiveSchema(true)  // → { type: \"boolean\" }\n * inferPrimitiveSchema(null)  // → { type: \"null\" }\n * ```\n */\nexport function inferPrimitiveSchema(\n\tvalue: number | boolean | null,\n): JSONSchema7 {\n\tif (value === null) return { type: \"null\" };\n\tif (typeof value === \"boolean\") return { type: \"boolean\" };\n\tif (typeof value === \"number\") {\n\t\treturn Number.isInteger(value) ? { type: \"integer\" } : { type: \"number\" };\n\t}\n\t// Exhaustiveness check — all branches are covered above.\n\t// If the type of `value` changes, TypeScript will raise an error here.\n\tvalue satisfies never;\n\treturn { type: \"null\" };\n}\n\n// ─── Diagnostic Codes ────────────────────────────────────────────────────────\n// Machine-readable codes for each error/warning type, enabling the frontend\n// to react programmatically without parsing the human-readable message.\n\nexport type DiagnosticCode =\n\t/** The referenced property does not exist in the context schema */\n\t| \"UNKNOWN_PROPERTY\"\n\t/** Type mismatch (e.g. #each on a non-array) */\n\t| \"TYPE_MISMATCH\"\n\t/** A block helper is used without a required argument */\n\t| \"MISSING_ARGUMENT\"\n\t/** Unknown block helper (neither built-in nor registered) */\n\t| \"UNKNOWN_HELPER\"\n\t/** The expression cannot be statically analyzed */\n\t| \"UNANALYZABLE\"\n\t/** The {{key:N}} syntax is used but no identifierSchemas were provided */\n\t| \"MISSING_IDENTIFIER_SCHEMAS\"\n\t/** The identifier N does not exist in the provided identifierSchemas */\n\t| \"UNKNOWN_IDENTIFIER\"\n\t/** The property does not exist in the identifier's schema */\n\t| \"IDENTIFIER_PROPERTY_NOT_FOUND\"\n\t/** Syntax error in the template */\n\t| \"PARSE_ERROR\";\n\n// ─── Diagnostic Details ──────────────────────────────────────────────────────\n// Supplementary information to understand the exact cause of the error.\n// Designed to be easily JSON-serializable and consumable by a frontend.\n\nexport interface DiagnosticDetails {\n\t/** Path of the expression that caused the error (e.g. `\"user.name.foo\"`) */\n\tpath?: string;\n\t/** Name of the helper involved (for helper-related errors) */\n\thelperName?: string;\n\t/** What was expected (e.g. `\"array\"`, `\"property to exist\"`) */\n\texpected?: string;\n\t/** What was found (e.g. `\"string\"`, `\"undefined\"`) */\n\tactual?: string;\n\t/** Available properties in the current schema (for suggestions) */\n\tavailableProperties?: string[];\n\t/** Template identifier number (for `{{key:N}}` errors) */\n\tidentifier?: number;\n}\n\n// ─── Static Analysis Result ──────────────────────────────────────────────────\n\n/** Diagnostic produced by the static analyzer */\nexport interface TemplateDiagnostic {\n\t/** \"error\" blocks execution, \"warning\" is informational */\n\tseverity: \"error\" | \"warning\";\n\n\t/** Machine-readable code identifying the error type */\n\tcode: DiagnosticCode;\n\n\t/** Human-readable message describing the problem */\n\tmessage: string;\n\n\t/** Position in the template source (if available from the AST) */\n\tloc?: {\n\t\tstart: { line: number; column: number };\n\t\tend: { line: number; column: number };\n\t};\n\n\t/** Fragment of the template source around the error */\n\tsource?: string;\n\n\t/** Structured information for debugging and frontend display */\n\tdetails?: DiagnosticDetails;\n}\n\n/** Complete result of the static analysis */\nexport interface AnalysisResult {\n\t/** true if no errors (warnings are tolerated) */\n\tvalid: boolean;\n\t/** List of diagnostics (errors + warnings) */\n\tdiagnostics: TemplateDiagnostic[];\n\t/** JSON Schema describing the template's return type */\n\toutputSchema: JSONSchema7;\n}\n\n/** Lightweight validation result (without output type inference) */\nexport interface ValidationResult {\n\t/** true if no errors (warnings are tolerated) */\n\tvalid: boolean;\n\t/** List of diagnostics (errors + warnings) */\n\tdiagnostics: TemplateDiagnostic[];\n}\n\n// ─── Public Engine Options ───────────────────────────────────────────────────\n\nexport interface TemplateEngineOptions {\n\t/**\n\t * Capacity of the parsed AST cache. Each parsed template is cached\n\t * to avoid costly re-parsing on repeated calls.\n\t * @default 256\n\t */\n\tastCacheSize?: number;\n\n\t/**\n\t * Capacity of the compiled Handlebars template cache.\n\t * @default 256\n\t */\n\tcompilationCacheSize?: number;\n\n\t/**\n\t * Custom helpers to register during engine construction.\n\t *\n\t * Each entry describes a helper with its name, implementation,\n\t * expected parameters, and return type.\n\t *\n\t * @example\n\t * ```\n\t * const engine = new Typebars({\n\t *   helpers: [\n\t *     {\n\t *       name: \"uppercase\",\n\t *       description: \"Converts a string to uppercase\",\n\t *       fn: (value: string) => String(value).toUpperCase(),\n\t *       params: [\n\t *         { name: \"value\", type: { type: \"string\" }, description: \"The string to convert\" },\n\t *       ],\n\t *       returnType: { type: \"string\" },\n\t *     },\n\t *   ],\n\t * });\n\t * ```\n\t */\n\thelpers?: HelperConfig[];\n}\n\n// ─── Execution Options ───────────────────────────────────────────────────────\n// Optional options object for `execute()`, replacing multiple positional\n// parameters for better ergonomics.\n\nexport interface ExecuteOptions {\n\t/** JSON Schema for pre-execution static validation */\n\tschema?: JSONSchema7;\n\t/** Data by identifier `{ [id]: { key: value } }` */\n\tidentifierData?: Record<number, Record<string, unknown>>;\n\t/** Schemas by identifier (for static validation with identifiers) */\n\tidentifierSchemas?: Record<number, JSONSchema7>;\n}\n\n// ─── Combined Analyze-and-Execute Options ────────────────────────────────────\n// Optional options object for `analyzeAndExecute()`, grouping parameters\n// related to template identifiers.\n\nexport interface AnalyzeAndExecuteOptions {\n\t/** Schemas by identifier `{ [id]: JSONSchema7 }` for static analysis */\n\tidentifierSchemas?: Record<number, JSONSchema7>;\n\t/** Data by identifier `{ [id]: { key: value } }` for execution */\n\tidentifierData?: Record<number, Record<string, unknown>>;\n}\n\n// ─── Custom Helpers ──────────────────────────────────────────────────────────\n// Allows registering custom helpers with their type signature for static\n// analysis support.\n\n/** Describes a parameter expected by a helper */\nexport interface HelperParam {\n\t/** Parameter name (for documentation / introspection) */\n\tname: string;\n\n\t/**\n\t * JSON Schema describing the expected type for this parameter.\n\t * Used for documentation and static validation.\n\t */\n\ttype?: JSONSchema7;\n\n\t/** Human-readable description of the parameter */\n\tdescription?: string;\n\n\t/**\n\t * Whether the parameter is optional.\n\t * @default false\n\t */\n\toptional?: boolean;\n}\n\n/**\n * Definition of a helper registerable via `registerHelper()`.\n *\n * Contains the runtime implementation and typing metadata\n * for static analysis.\n */\nexport interface HelperDefinition {\n\t/**\n\t * Runtime implementation of the helper — will be registered with Handlebars.\n\t *\n\t * For an inline helper `{{uppercase name}}`:\n\t *   `(value: string) => string`\n\t *\n\t * For a block helper `{{#repeat count}}...{{/repeat}}`:\n\t *   `function(this: any, count: number, options: Handlebars.HelperOptions) { ... }`\n\t */\n\t// biome-ignore lint/suspicious/noExplicitAny: Handlebars helper signatures are inherently dynamic\n\tfn: (...args: any[]) => unknown;\n\n\t/**\n\t * Parameters expected by the helper (for documentation and analysis).\n\t *\n\t * @example\n\t * ```\n\t * params: [\n\t *   { name: \"value\", type: { type: \"number\" }, description: \"The value to round\" },\n\t *   { name: \"precision\", type: { type: \"number\" }, description: \"Decimal places\", optional: true },\n\t * ]\n\t * ```\n\t */\n\tparams?: HelperParam[];\n\n\t/**\n\t * JSON Schema describing the helper's return type for static analysis.\n\t * @default { type: \"string\" }\n\t */\n\treturnType?: JSONSchema7;\n\n\t/** Human-readable description of the helper */\n\tdescription?: string;\n}\n\n/**\n * Full helper configuration for registration via the `Typebars({ helpers: [...] })`\n * constructor options.\n *\n * Extends `HelperDefinition` with a required `name`.\n *\n * @example\n * ```\n * const config: HelperConfig = {\n *   name: \"round\",\n *   description: \"Rounds a number to a given precision\",\n *   fn: (value: number, precision?: number) => { ... },\n *   params: [\n *     { name: \"value\", type: { type: \"number\" } },\n *     { name: \"precision\", type: { type: \"number\" }, optional: true },\n *   ],\n *   returnType: { type: \"number\" },\n * };\n * ```\n */\nexport interface HelperConfig extends HelperDefinition {\n\t/** Name of the helper as used in templates (e.g. `\"uppercase\"`) */\n\tname: string;\n}\n\n// ─── Automatic Type Inference via json-schema-to-ts ──────────────────────────\n// Allows `defineHelper()` to infer TypeScript types for `fn` arguments\n// from the JSON Schemas declared in `params`.\n\n/**\n * Param definition used for type inference.\n * Accepts `JSONSchema` from `json-schema-to-ts` to allow `FromSchema`\n * to resolve literal types.\n */\ntype TypedHelperParam = {\n\treadonly name: string;\n\treadonly type?: JSONSchema;\n\treadonly description?: string;\n\treadonly optional?: boolean;\n};\n\n/**\n * Infers the TypeScript type of a single parameter from its JSON Schema.\n * - If `optional: true`, the resolved type is unioned with `undefined`.\n * - If `type` is not provided, the type is `unknown`.\n */\ntype InferParamType<P> = P extends {\n\treadonly type: infer S extends JSONSchema;\n\treadonly optional: true;\n}\n\t? FromSchema<S> | undefined\n\t: P extends { readonly type: infer S extends JSONSchema }\n\t\t? FromSchema<S>\n\t\t: unknown;\n\n/**\n * Maps a tuple of `TypedHelperParam` to a tuple of inferred TypeScript types,\n * usable as the `fn` signature.\n *\n * @example\n * ```\n * type Args = InferArgs<readonly [\n *   { name: \"a\"; type: { type: \"string\" } },\n *   { name: \"b\"; type: { type: \"number\" }; optional: true },\n * ]>;\n * // => [string, number | undefined]\n * ```\n */\ntype InferArgs<P extends readonly TypedHelperParam[]> = {\n\t[K in keyof P]: InferParamType<P[K]>;\n};\n\n/**\n * Helper configuration with generic parameter inference.\n * Used exclusively by `defineHelper()`.\n */\ninterface TypedHelperConfig<P extends readonly TypedHelperParam[]> {\n\tname: string;\n\tdescription?: string;\n\tparams: P;\n\tfn: (...args: InferArgs<P>) => unknown;\n\treturnType?: JSONSchema;\n}\n\n/**\n * Creates a `HelperConfig` with automatic type inference for `fn` arguments\n * based on the JSON Schemas declared in `params`.\n *\n * The generic parameter `const P` preserves schema literal types\n * (equivalent of `as const`), enabling `FromSchema` to resolve the\n * corresponding TypeScript types.\n *\n * @example\n * ```\n * const helper = defineHelper({\n *   name: \"concat\",\n *   description: \"Concatenates two strings\",\n *   params: [\n *     { name: \"a\", type: { type: \"string\" }, description: \"First string\" },\n *     { name: \"b\", type: { type: \"string\" }, description: \"Second string\" },\n *     { name: \"sep\", type: { type: \"string\" }, description: \"Separator\", optional: true },\n *   ],\n *   fn: (a, b, sep) => {\n *     // a: string, b: string, sep: string | undefined\n *     const separator = sep ?? \"\";\n *     return `${a}${separator}${b}`;\n *   },\n *   returnType: { type: \"string\" },\n * });\n * ```\n */\nexport function defineHelper<const P extends readonly TypedHelperParam[]>(\n\tconfig: TypedHelperConfig<P>,\n): HelperConfig {\n\treturn config as unknown as HelperConfig;\n}\n"
-  ],
-  "mappings": "AA8CO,SAAS,CAAc,CAC7B,EACmC,CACnC,OACC,IAAU,MAAS,OAAO,IAAU,UAAY,OAAO,IAAU,SAS5D,SAAS,CAAa,CAC5B,EAC+B,CAC/B,OAAO,IAAU,MAAQ,OAAO,IAAU,SAgBpC,SAAS,CAAoB,CACnC,EACc,CACd,GAAI,IAAU,KAAM,MAAO,CAAE,KAAM,MAAO,EAC1C,GAAI,OAAO,IAAU,UAAW,MAAO,CAAE,KAAM,SAAU,EACzD,GAAI,OAAO,IAAU,SACpB,OAAO,OAAO,UAAU,CAAK,EAAI,CAAE,KAAM,SAAU,EAAI,CAAE,KAAM,QAAS,EAKzE,MAAO,CAAE,KAAM,MAAO,EA8UhB,SAAS,CAAyD,CACxE,EACe,CACf,OAAO",
-  "debugId": "6623216F1317FB4964756E2164756E21",
-  "names": []
-}

package/dist/chunk-9jxzj2h4.js

@@ -1,7 +0,0 @@
-function P(w,G){if(w===G)return!0;if(w===null||G===null)return!1;if(typeof w!==typeof G)return!1;if(Array.isArray(w)){if(!Array.isArray(G))return!1;if(w.length!==G.length)return!1;for(let F=0;F<w.length;F++)if(!P(w[F],G[F]))return!1;return!0}if(typeof w==="object"){let F=w,H=G,I=Object.keys(F),J=Object.keys(H);if(I.length!==J.length)return!1;for(let M of I)if(!(M in H)||!P(F[M],H[M]))return!1;return!0}return!1}class Q{capacity;cache=new Map;constructor(w){this.capacity=w;if(w<1)throw Error("LRUCache capacity must be at least 1")}get(w){if(!this.cache.has(w))return;let G=this.cache.get(w);return this.cache.delete(w),this.cache.set(w,G),G}set(w,G){if(this.cache.has(w))this.cache.delete(w);else if(this.cache.size>=this.capacity){let F=this.cache.keys().next().value;if(F!==void 0)this.cache.delete(F)}this.cache.set(w,G)}has(w){return this.cache.has(w)}delete(w){return this.cache.delete(w)}clear(){this.cache.clear()}get size(){return this.cache.size}}function S(w,G){let F=w.split(`
-`),H=G.start.line-1,I=G.end.line-1;if(H<0||H>=F.length)return"";if(H===I)return(F[H]??"").trim();let J=Math.min(I,F.length-1);return F.slice(H,J+1).map((M)=>M.trimEnd()).join(`
-`).trim()}function U(w){let G=new Set;if(w.properties)for(let F of Object.keys(w.properties))G.add(F);for(let F of["allOf","anyOf","oneOf"]){let H=w[F];if(H)for(let I of H){if(typeof I==="boolean")continue;if(I.properties)for(let J of Object.keys(I.properties))G.add(J)}}return Array.from(G).sort()}function W(w,G){let F=[],H={},I=!0;for(let J of w){let M=G(J);if(!M.valid)I=!1;F.push(...M.diagnostics),H[J]=M.outputSchema}return{valid:I,diagnostics:F,outputSchema:{type:"object",properties:H,required:w}}}function X(w,G){let F=[],H={},I={},J=!0;for(let O of w){let N=G(O);if(!N.analysis.valid)J=!1;F.push(...N.analysis.diagnostics),H[O]=N.analysis.outputSchema,I[O]=N.value}return{analysis:{valid:J,diagnostics:F,outputSchema:{type:"object",properties:H,required:w}},value:J?I:void 0}}
-export{P as D,Q as E,S as F,U as G,W as H,X as I};
-
-//# debugId=DA20CEFC32FCC07E64756E2164756E21
-//# sourceMappingURL=chunk-9jxzj2h4.js.map

package/dist/chunk-9jxzj2h4.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/utils.ts"],
-  "sourcesContent": [
-    "import type { JSONSchema7 } from \"json-schema\";\nimport type { AnalysisResult, TemplateDiagnostic } from \"./types.ts\";\n\n// ─── Utilities ───────────────────────────────────────────────────────────────\n// Shared utility functions and classes used across the different modules\n// of the template engine.\n\n// ─── Deep Equality ───────────────────────────────────────────────────────────\n// Deep structural comparison for JSON-compatible values.\n// More robust than `JSON.stringify` because it is independent of key order\n// and does not allocate intermediate strings.\n\n/**\n * Recursively compares two JSON-compatible values.\n *\n * @param a - First value\n * @param b - Second value\n * @returns `true` if the two values are structurally identical\n *\n * @example\n * ```\n * deepEqual({ a: 1, b: 2 }, { b: 2, a: 1 }) // → true\n * deepEqual([1, 2], [1, 2])                   // → true\n * deepEqual({ a: 1 }, { a: 2 })               // → false\n * ```\n */\nexport function deepEqual(a: unknown, b: unknown): boolean {\n\t// Strict identity (covers primitives, same ref; NaN !== NaN is intentional)\n\tif (a === b) return true;\n\n\t// null is typeof \"object\" in JS — handle it separately\n\tif (a === null || b === null) return false;\n\tif (typeof a !== typeof b) return false;\n\n\t// ── Arrays ───────────────────────────────────────────────────────────────\n\tif (Array.isArray(a)) {\n\t\tif (!Array.isArray(b)) return false;\n\t\tif (a.length !== b.length) return false;\n\t\tfor (let i = 0; i < a.length; i++) {\n\t\t\tif (!deepEqual(a[i], b[i])) return false;\n\t\t}\n\t\treturn true;\n\t}\n\n\t// ── Objects ──────────────────────────────────────────────────────────────\n\tif (typeof a === \"object\") {\n\t\tconst objA = a as Record<string, unknown>;\n\t\tconst objB = b as Record<string, unknown>;\n\t\tconst keysA = Object.keys(objA);\n\t\tconst keysB = Object.keys(objB);\n\n\t\tif (keysA.length !== keysB.length) return false;\n\n\t\tfor (const key of keysA) {\n\t\t\tif (!(key in objB) || !deepEqual(objA[key], objB[key])) return false;\n\t\t}\n\t\treturn true;\n\t}\n\n\t// Different primitives (already covered by a === b at the top)\n\treturn false;\n}\n\n// ─── LRU Cache ───────────────────────────────────────────────────────────────\n// Fixed-capacity cache with Least Recently Used (LRU) eviction.\n// Leverages `Map` insertion order to track access: the oldest entry\n// is always in the first position.\n\n/**\n * Simple fixed-capacity LRU cache.\n *\n * @example\n * ```\n * const cache = new LRUCache<string, number>(2);\n * cache.set(\"a\", 1);\n * cache.set(\"b\", 2);\n * cache.get(\"a\");      // → 1 (marks \"a\" as recently used)\n * cache.set(\"c\", 3);   // evicts \"b\" (least recently used)\n * cache.get(\"b\");      // → undefined\n * ```\n */\nexport class LRUCache<K, V> {\n\tprivate readonly cache = new Map<K, V>();\n\n\tconstructor(private readonly capacity: number) {\n\t\tif (capacity < 1) {\n\t\t\tthrow new Error(\"LRUCache capacity must be at least 1\");\n\t\t}\n\t}\n\n\t/**\n\t * Retrieves a value from the cache. Returns `undefined` if absent.\n\t * Marks the entry as recently used.\n\t */\n\tget(key: K): V | undefined {\n\t\tif (!this.cache.has(key)) return undefined;\n\n\t\t// Move to the end of the Map (= most recently used)\n\t\tconst value = this.cache.get(key) as V;\n\t\tthis.cache.delete(key);\n\t\tthis.cache.set(key, value);\n\t\treturn value;\n\t}\n\n\t/**\n\t * Inserts or updates a value in the cache.\n\t * If the cache is full, evicts the least recently used entry.\n\t */\n\tset(key: K, value: V): void {\n\t\tif (this.cache.has(key)) {\n\t\t\tthis.cache.delete(key);\n\t\t} else if (this.cache.size >= this.capacity) {\n\t\t\t// Evict the first entry (the oldest one)\n\t\t\tconst oldestKey = this.cache.keys().next().value;\n\t\t\tif (oldestKey !== undefined) {\n\t\t\t\tthis.cache.delete(oldestKey);\n\t\t\t}\n\t\t}\n\t\tthis.cache.set(key, value);\n\t}\n\n\t/**\n\t * Checks whether a key exists in the cache (without affecting LRU order).\n\t */\n\thas(key: K): boolean {\n\t\treturn this.cache.has(key);\n\t}\n\n\t/**\n\t * Removes an entry from the cache.\n\t * @returns `true` if the entry existed and was removed\n\t */\n\tdelete(key: K): boolean {\n\t\treturn this.cache.delete(key);\n\t}\n\n\t/** Clears the entire cache. */\n\tclear(): void {\n\t\tthis.cache.clear();\n\t}\n\n\t/** Number of entries currently in the cache. */\n\tget size(): number {\n\t\treturn this.cache.size;\n\t}\n}\n\n// ─── Source Snippet Extraction ────────────────────────────────────────────────\n// Used to enrich diagnostics with the template fragment that caused the error.\n\n/**\n * Extracts a template fragment around a given position.\n *\n * @param template - The full template source\n * @param loc      - The position (line/column, 1-based) of the error\n * @returns The corresponding code fragment (trimmed)\n */\nexport function extractSourceSnippet(\n\ttemplate: string,\n\tloc: {\n\t\tstart: { line: number; column: number };\n\t\tend: { line: number; column: number };\n\t},\n): string {\n\tconst lines = template.split(\"\\n\");\n\tconst startLine = loc.start.line - 1; // 0-based\n\tconst endLine = loc.end.line - 1;\n\n\tif (startLine < 0 || startLine >= lines.length) return \"\";\n\n\tif (startLine === endLine) {\n\t\t// Same line — extract the portion between start.column and end.column\n\t\tconst line = lines[startLine] ?? \"\";\n\t\treturn line.trim();\n\t}\n\n\t// Multi-line — return the affected lines\n\tconst clampedEnd = Math.min(endLine, lines.length - 1);\n\treturn lines\n\t\t.slice(startLine, clampedEnd + 1)\n\t\t.map((l) => l.trimEnd())\n\t\t.join(\"\\n\")\n\t\t.trim();\n}\n\n// ─── Schema Properties ──────────────────────────────────────────────────────\n// Utility for listing available properties in a schema, used to enrich\n// error messages with suggestions.\n\n/**\n * Lists the declared property names in a JSON Schema.\n * Returns an empty array if the schema has no `properties`.\n */\nexport function getSchemaPropertyNames(schema: JSONSchema7): string[] {\n\tconst names = new Set<string>();\n\n\t// Direct properties\n\tif (schema.properties) {\n\t\tfor (const key of Object.keys(schema.properties)) {\n\t\t\tnames.add(key);\n\t\t}\n\t}\n\n\t// Properties within combinators\n\tfor (const combinator of [\"allOf\", \"anyOf\", \"oneOf\"] as const) {\n\t\tconst branches = schema[combinator];\n\t\tif (branches) {\n\t\t\tfor (const branch of branches) {\n\t\t\t\tif (typeof branch === \"boolean\") continue;\n\t\t\t\tif (branch.properties) {\n\t\t\t\t\tfor (const key of Object.keys(branch.properties)) {\n\t\t\t\t\t\tnames.add(key);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn Array.from(names).sort();\n}\n\n// ─── Object Analysis Aggregation ─────────────────────────────────────────────\n// Factorizes the common recursion pattern over template objects:\n// iterate the keys, analyze each entry via a callback, accumulate\n// diagnostics, and build the output object schema.\n//\n// Used by:\n// - `analyzer.ts` (analyzeObjectTemplate)\n// - `Typebars.analyzeObject()` (typebars.ts)\n// - `CompiledTemplate.analyze()` in object mode (compiled-template.ts)\n\n/**\n * Aggregates analysis results from a set of named entries into a single\n * `AnalysisResult` with an object-typed `outputSchema`.\n *\n * @param keys         - The keys of the object to analyze\n * @param analyzeEntry - Callback that analyzes an entry by its key\n * @returns An aggregated `AnalysisResult`\n *\n * @example\n * ```\n * aggregateObjectAnalysis(\n *   Object.keys(template),\n *   (key) => analyze(template[key], inputSchema),\n * );\n * ```\n */\nexport function aggregateObjectAnalysis(\n\tkeys: string[],\n\tanalyzeEntry: (key: string) => AnalysisResult,\n): AnalysisResult {\n\tconst allDiagnostics: TemplateDiagnostic[] = [];\n\tconst properties: Record<string, JSONSchema7> = {};\n\tlet allValid = true;\n\n\tfor (const key of keys) {\n\t\tconst child = analyzeEntry(key);\n\t\tif (!child.valid) allValid = false;\n\t\tallDiagnostics.push(...child.diagnostics);\n\t\tproperties[key] = child.outputSchema;\n\t}\n\n\treturn {\n\t\tvalid: allValid,\n\t\tdiagnostics: allDiagnostics,\n\t\toutputSchema: {\n\t\t\ttype: \"object\",\n\t\t\tproperties,\n\t\t\trequired: keys,\n\t\t},\n\t};\n}\n\n/**\n * Aggregates both analysis **and** execution results from a set of named\n * entries. Returns the aggregated `AnalysisResult` and the object of\n * executed values (or `undefined` if at least one entry is invalid).\n *\n * @param keys         - The keys of the object\n * @param processEntry - Callback that analyzes and executes an entry by its key\n * @returns Aggregated `{ analysis, value }`\n */\nexport function aggregateObjectAnalysisAndExecution(\n\tkeys: string[],\n\tprocessEntry: (key: string) => { analysis: AnalysisResult; value: unknown },\n): { analysis: AnalysisResult; value: unknown } {\n\tconst allDiagnostics: TemplateDiagnostic[] = [];\n\tconst properties: Record<string, JSONSchema7> = {};\n\tconst resultValues: Record<string, unknown> = {};\n\tlet allValid = true;\n\n\tfor (const key of keys) {\n\t\tconst child = processEntry(key);\n\t\tif (!child.analysis.valid) allValid = false;\n\t\tallDiagnostics.push(...child.analysis.diagnostics);\n\t\tproperties[key] = child.analysis.outputSchema;\n\t\tresultValues[key] = child.value;\n\t}\n\n\tconst analysis: AnalysisResult = {\n\t\tvalid: allValid,\n\t\tdiagnostics: allDiagnostics,\n\t\toutputSchema: {\n\t\t\ttype: \"object\",\n\t\t\tproperties,\n\t\t\trequired: keys,\n\t\t},\n\t};\n\n\treturn {\n\t\tanalysis,\n\t\tvalue: allValid ? resultValues : undefined,\n\t};\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "DA20CEFC32FCC07E64756E2164756E21",
-  "names": []
-}

package/dist/chunk-dpffacsy.js

@@ -1,4 +0,0 @@
-import{i as S,j as f,k as h}from"./chunk-8xza8tca.js";import{m as q,o as C,p as D,q as W,r as E,s as T,u as P,x as y}from"./chunk-s96k41p3.js";import{A as $,B as v,C as V,y as Y}from"./chunk-5znsrn10.js";import{D as u,F as N,G as _,H as g}from"./chunk-9jxzj2h4.js";import{O as B,P as M,Q as U,R as b,S as k}from"./chunk-gayk9ew1.js";function i(j,w,A){if(f(j))return p(j,w,A);if(S(j))return{valid:!0,diagnostics:[],outputSchema:h(j)};let F=q(j);return a(F,j,w,{identifierSchemas:A})}function p(j,w,A){return g(Object.keys(j),(F)=>i(j[F],w,A))}function a(j,w,A,F){if(Y(A),F?.identifierSchemas)for(let[G,J]of Object.entries(F.identifierSchemas))Y(J,`/identifierSchemas/${G}`);let z={root:A,current:A,diagnostics:[],template:w,identifierSchemas:F?.identifierSchemas,helpers:F?.helpers},H=K(j,z);return{valid:!z.diagnostics.some((G)=>G.severity==="error"),diagnostics:z.diagnostics,outputSchema:V(H)}}function x(j,w){switch(j.type){case"ContentStatement":case"CommentStatement":return;case"MustacheStatement":return d(j,w);case"BlockStatement":return Z(j,w);default:L(w,"UNANALYZABLE","warning",`Unsupported AST node type: "${j.type}"`,j);return}}function d(j,w){if(j.path.type==="SubExpression")return L(w,"UNANALYZABLE","warning","Sub-expressions are not statically analyzable",j),{};if(j.params.length>0||j.hash){let A=n(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)L(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 J=G.type;if(!o(I,J)){let O=G.name;L(w,"TYPE_MISMATCH","error",`Helper "${A}" parameter "${O}" expects ${Q(J)}, but got ${Q(I)}`,j,{helperName:A,expected:Q(J),actual:Q(I)})}}}return F.returnType??{type:"string"}}return L(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 K(j,w){let A=W(j);if(A.length===0)return{type:"string"};let F=T(j);if(F)return d(F,w);let z=E(j);if(z)return Z(z,w);if(A.every((G)=>G.type==="ContentStatement")){let G=A.map((O)=>O.value).join("").trim();if(G==="")return{type:"string"};let J=P(G);if(J)return{type:J}}if(A.every((G)=>G.type==="BlockStatement")){let G=[];for(let J of A){let O=Z(J,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)x(G,w);return{type:"string"}}function Z(j,w){let A=c(j);switch(A){case"if":case"unless":{let F=X(j);if(F)R(F,w,j);else L(w,"MISSING_ARGUMENT","error",U(A),j,{helperName:A});let z=K(j.program,w);if(j.inverse){let H=K(j.inverse,w);if(u(z,H))return z;return V({oneOf:[z,H]})}return z}case"each":{let F=X(j);if(!F){L(w,"MISSING_ARGUMENT","error",U("each"),j,{helperName:"each"});let G=w.current;if(w.current={},K(j.program,w),w.current=G,j.inverse)K(j.inverse,w);return{type:"string"}}let z=R(F,w,j);if(!z){let G=w.current;if(w.current={},K(j.program,w),w.current=G,j.inverse)K(j.inverse,w);return{type:"string"}}let H=v(z,w.root);if(!H){L(w,"TYPE_MISMATCH","error",M("each","an array",Q(z)),j,{helperName:"each",expected:"array",actual:Q(z)});let G=w.current;if(w.current={},K(j.program,w),w.current=G,j.inverse)K(j.inverse,w);return{type:"string"}}let I=w.current;if(w.current=H,K(j.program,w),w.current=I,j.inverse)K(j.inverse,w);return{type:"string"}}case"with":{let F=X(j);if(!F){L(w,"MISSING_ARGUMENT","error",U("with"),j,{helperName:"with"});let G=w.current;w.current={};let J=K(j.program,w);if(w.current=G,j.inverse)K(j.inverse,w);return J}let z=R(F,w,j),H=w.current;w.current=z??{};let I=K(j.program,w);if(w.current=H,j.inverse)K(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(K(j.program,w),j.inverse)K(j.inverse,w);return F.returnType??{type:"string"}}if(L(w,"UNKNOWN_HELPER","warning",b(A),j,{helperName:A}),K(j.program,w),j.inverse)K(j.inverse,w);return{type:"string"}}}}function R(j,w,A){if(D(j))return w.current;if(j.type==="SubExpression")return m(j,w,A);let F=C(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{};L(w,"UNANALYZABLE","warning",k(j.type),A??j);return}let{cleanSegments:z,identifier:H}=y(F);if(H!==null)return r(z,H,w,A??j);let I=$(w.current,z);if(I===void 0){let G=z.join("."),J=_(w.current);L(w,"UNKNOWN_PROPERTY","error",B(G,J),A??j,{path:G,availableProperties:J});return}return I}function r(j,w,A,F){let z=j.join(".");if(!A.identifierSchemas){L(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){L(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=_(H);L(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 m(j,w,A){let F=n(j.path),z=w.helpers?.get(F);if(!z)return L(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)L(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),J=H?.[I];if(G&&J?.type){let O=J.type;if(!o(G,O)){let l=J.name;L(w,"TYPE_MISMATCH","error",`Helper "${F}" parameter "${l}" 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 c(j){if(j.path.type==="PathExpression")return j.path.original;return""}function n(j){if(j.type==="PathExpression")return j.original;return""}function L(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=N(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{i as b,a as c,Z as d};
-
-//# debugId=57C3498B4F6E645064756E2164756E21
-//# sourceMappingURL=chunk-dpffacsy.js.map