@xaendar/compiler 0.7.31 → 0.7.32

package/dist/xaendar-compiler.es.js

@@ -1,3531 +0,0 @@
-import { Stack, indent } from "@xaendar/common";
-import { ScriptTarget, SyntaxKind, createSourceFile, forEachChild, getNameOfDeclaration, isAccessor, isArrayLiteralExpression, isCallExpression, isClassDeclaration, isExpressionStatement, isIdentifier, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isStringLiteral } from "typescript";
-//#region \0rolldown/runtime.js
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-//#endregion
-//#region ../packages/compiler/src/parser/types/node.enum.ts
-/**
-* Discriminant values that identify the type of each AST node produced by the parser.
-*/
-var ASTNodeType = /* @__PURE__ */ function(ASTNodeType) {
-	/**
-	* An HTML element node with a tag name, attributes, events, and children.
-	*/
-	ASTNodeType[ASTNodeType["Element"] = 0] = "Element";
-	/**
-	* A plain text node.
-	*/
-	ASTNodeType[ASTNodeType["Text"] = 1] = "Text";
-	/**
-	* An inline interpolation expression or literal.
-	*/
-	ASTNodeType[ASTNodeType["Interpolation"] = 2] = "Interpolation";
-	/**
-	* An `@if` conditional node.
-	*/
-	ASTNodeType[ASTNodeType["If"] = 3] = "If";
-	/**
-	* An `@else` branch node attached to an `@if`.
-	*/
-	ASTNodeType[ASTNodeType["Else"] = 4] = "Else";
-	/**
-	* An `@else if` branch node attached to an `@if`.
-	*/
-	ASTNodeType[ASTNodeType["ElseIf"] = 5] = "ElseIf";
-	/**
-	* An `@for` iteration node.
-	*/
-	ASTNodeType[ASTNodeType["For"] = 6] = "For";
-	/**
-	* An `@switch` node containing one or more case nodes.
-	*/
-	ASTNodeType[ASTNodeType["Switch"] = 7] = "Switch";
-	/**
-	* A `@case` or `@default` branch inside a `@switch`.
-	*/
-	ASTNodeType[ASTNodeType["Case"] = 8] = "Case";
-	/**
-	*
-	*/
-	ASTNodeType[ASTNodeType["Import"] = 9] = "Import";
-	return ASTNodeType;
-}({});
-//#endregion
-//#region ../packages/compiler/src/generator/models/compiler-context.model.ts
-/**
-* Tracks identifier scope during render code generation.
-* Each `Context` instance represents one lexical scope (e.g. a `@for` loop body)
-* and can be chained to a parent context for outer-scope resolution.
-*/
-var CompilerContext = class {
-	_parent;
-	/**
-	* Identifiers declared directly in this scope, mapped to whether they
-	* hold a plain value or a signal (e.g. `@for` implicit variables like
-	* `$index` are signals; the loop item itself is a plain value).
-	*/
-	_identifiers = /* @__PURE__ */ new Map();
-	/**
-	* List of identifiers that should not be resolved
-	* and touched in anyway
-	* (e.g. $event)
-	*/
-	_unresolvableIdentifiers = new Array();
-	/**
-	* Creates a new scope context.
-	*
-	* @param identifiers - Named identifier bindings declared in this scope.
-	*   Plain strings default to kind `'value'`; pass a `[name, kind]` tuple
-	*   to declare a signal-backed identifier.
-	* @param _parent - Optional parent context representing the enclosing scope.
-	*/
-	constructor(identifiers = [], _parent) {
-		this._parent = _parent;
-		for (const identifier of identifiers) typeof identifier === "string" ? this._identifiers.set(identifier, "value") : this._identifiers.set(identifier[0], identifier[1]);
-	}
-	/**
-	* Registers a new identifier name in this scope.
-	*
-	* @param name - The identifier name to register.
-	* @param kind - Whether the identifier holds a plain value or a signal.
-	*   Defaults to `'value'`.
-	* @throws When an identifier with the same name is already declared in this scope.
-	*/
-	addIdentifier(name, kind = "value") {
-		if (this.hasIdentifier(name)) throw new Error(`Identifier "${name}" is already declared in this scope.`);
-		this._identifiers.set(name, kind);
-	}
-	/**
-	* Registers a new unresolvable identifier name in this scope.
-	* Unresolvable identifiers (e.g. `$event`) are tracked so lookups via
-	* {@link hasIdentifier} recognize them, but they are never meant to be
-	* resolved or otherwise manipulated by the compiler.
-	*
-	* @param name - The identifier name to register.
-	* @throws When an identifier with the same name is already declared in this scope.
-	*/
-	addUnresolvableIdentifier(name) {
-		if (this.hasIdentifier(name)) throw new Error(`Identifier "${name}" is already declared in this scope.`);
-		this._unresolvableIdentifiers.push(name);
-	}
-	/**
-	* Removes a previously registered identifier from this scope, if present.
-	* Does nothing if no identifier with the given name is declared in this scope.
-	* Note: this only affects the current scope, not any ancestor scopes.
-	*
-	* @param name - The identifier name to remove.
-	*/
-	removeIdentifier(name) {
-		this._identifiers.delete(name);
-	}
-	/**
-	* Removes a previously registered unresolvable identifier from this scope, if present.
-	* Does nothing if no unresolvable identifier with the given name is declared in this scope.
-	* Note: this only affects the current scope, not any ancestor scopes.
-	*
-	* @param name - The identifier name to remove. 
-	*/
-	removeUnresolvabledIdentifier(name) {
-		this._unresolvableIdentifiers = this._unresolvableIdentifiers.filter((identifier) => identifier !== name);
-	}
-	/**
-	* Returns `true` if an identifier with the given name is declared in this
-	* scope or any of its ancestor scopes.
-	*
-	* @param name - The identifier name to look up.
-	* @returns `true` if the identifier exists in the scope chain, `false` otherwise.
-	*/
-	hasIdentifier(name) {
-		return this._identifiers.has(name) || (this._parent?.hasIdentifier(name) ?? false);
-	}
-	/**
-	* Resolves the kind (`'value'` or `'signal'`) of a declared identifier,
-	* walking up the scope chain if not found in this scope.
-	*
-	* @param name - The identifier name to look up.
-	* @returns The identifier's kind, or `undefined` if it isn't declared
-	*   anywhere in the scope chain.
-	*/
-	getIdentifierKind(name) {
-		return this._identifiers.get(name) ?? this._parent?.getIdentifierKind(name);
-	}
-	/**
-	* Returns `true` if an identifier with the given name is declared in this
-	* scope or any of its ancestor scopes.
-	*
-	* @param name - The identifier name to look up.
-	* @returns `true` if the identifier exists in the scope chain, `false` otherwise.
-	*/
-	hasUnresolvableIdentifier(name) {
-		return this._unresolvableIdentifiers.includes(name) || (this._parent?.hasUnresolvableIdentifier(name) ?? false);
-	}
-};
-//#endregion
-//#region ../packages/compiler/src/generator/utils/generator.utils.ts
-/**
-* Complete set of JavaScript global identifiers up to ES2026.
-*
-* These are identifiers that TypeScript's parser classifies as
-* `SyntaxKind.Identifier` (unlike true keywords such as `typeof`,
-* `instanceof`, `true`, `false`, `null` which have their own SyntaxKind)
-* but that must never be prefixed with `this.` inside a template expression
-* because they refer to well-known globals, not to component properties.
-*
-* Organised by ECMAScript category, mirroring the MDN "Standard built-in
-* objects" reference, plus the ES2026 additions (Temporal, DisposableStack,
-* AsyncDisposableStack, SuppressedError, Math.sumPrecise surface).
-*
-* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
-*/
-var GLOBAL_IDENTIFIERS = /* @__PURE__ */ new Set([
-	"undefined",
-	"NaN",
-	"Infinity",
-	"globalThis",
-	"eval",
-	"isFinite",
-	"isNaN",
-	"parseFloat",
-	"parseInt",
-	"decodeURI",
-	"decodeURIComponent",
-	"encodeURI",
-	"encodeURIComponent",
-	"escape",
-	"unescape",
-	"Object",
-	"Function",
-	"Boolean",
-	"Symbol",
-	"Error",
-	"AggregateError",
-	"EvalError",
-	"RangeError",
-	"ReferenceError",
-	"SyntaxError",
-	"TypeError",
-	"URIError",
-	"SuppressedError",
-	"InternalError",
-	"Number",
-	"BigInt",
-	"Math",
-	"Date",
-	"Temporal",
-	"String",
-	"RegExp",
-	"Array",
-	"TypedArray",
-	"Int8Array",
-	"Uint8Array",
-	"Uint8ClampedArray",
-	"Int16Array",
-	"Uint16Array",
-	"Int32Array",
-	"Uint32Array",
-	"BigInt64Array",
-	"BigUint64Array",
-	"Float16Array",
-	"Float32Array",
-	"Float64Array",
-	"Map",
-	"Set",
-	"WeakMap",
-	"WeakSet",
-	"ArrayBuffer",
-	"SharedArrayBuffer",
-	"DataView",
-	"Atomics",
-	"JSON",
-	"WeakRef",
-	"FinalizationRegistry",
-	"Iterator",
-	"AsyncIterator",
-	"Promise",
-	"GeneratorFunction",
-	"AsyncGeneratorFunction",
-	"Generator",
-	"AsyncGenerator",
-	"AsyncFunction",
-	"DisposableStack",
-	"AsyncDisposableStack",
-	"Reflect",
-	"Proxy",
-	"Intl",
-	"WebAssembly",
-	"window",
-	"document",
-	"navigator",
-	"location",
-	"history",
-	"screen",
-	"console",
-	"performance",
-	"crypto",
-	"fetch",
-	"alert",
-	"confirm",
-	"prompt",
-	"setTimeout",
-	"setInterval",
-	"clearTimeout",
-	"clearInterval",
-	"requestAnimationFrame",
-	"cancelAnimationFrame",
-	"queueMicrotask",
-	"structuredClone",
-	"URL",
-	"URLSearchParams",
-	"FormData",
-	"Headers",
-	"Request",
-	"Response",
-	"AbortController",
-	"AbortSignal",
-	"CustomEvent",
-	"Event",
-	"EventTarget",
-	"MutationObserver",
-	"IntersectionObserver",
-	"ResizeObserver",
-	"PerformanceObserver",
-	"Worker",
-	"SharedWorker",
-	"ServiceWorker",
-	"Blob",
-	"File",
-	"FileReader",
-	"ReadableStream",
-	"WritableStream",
-	"TransformStream",
-	"TextEncoder",
-	"TextDecoder",
-	"ImageData",
-	"Canvas",
-	"Storage",
-	"localStorage",
-	"sessionStorage",
-	"indexedDB",
-	"WebSocket",
-	"XMLHttpRequest",
-	"HTMLElement",
-	"HTMLInputElement",
-	"HTMLButtonElement",
-	"HTMLFormElement",
-	"HTMLAnchorElement",
-	"HTMLImageElement",
-	"HTMLVideoElement",
-	"HTMLAudioElement",
-	"HTMLCanvasElement",
-	"HTMLSelectElement",
-	"HTMLTextAreaElement",
-	"HTMLDivElement",
-	"HTMLSpanElement",
-	"HTMLParagraphElement",
-	"HTMLHeadingElement",
-	"HTMLTableElement",
-	"HTMLTableRowElement",
-	"HTMLTableCellElement",
-	"HTMLUListElement",
-	"HTMLOListElement",
-	"HTMLLIElement",
-	"HTMLLabelElement",
-	"HTMLDialogElement",
-	"HTMLDetailsElement",
-	"HTMLSlotElement",
-	"HTMLTemplateElement",
-	"SVGElement",
-	"SVGSVGElement",
-	"Element",
-	"Node",
-	"NodeList",
-	"DocumentFragment",
-	"ShadowRoot",
-	"Document",
-	"Window"
-]);
-var ROOT_NODE = "root";
-/**
-* Resolves references to component properties inside a template expression.
-*
-* Identifiers that are not found in the active scope chain and are not
-* well-known globals are prefixed with `this.` so they resolve against
-* the component instance at runtime. Identifiers found in the scope chain
-* are resolved either as a bare local reference (if declared directly in
-* the current generated function's own scope) or via a runtime
-* `parentContext.get(...)` traversal (if inherited from an enclosing
-* scope) — and a trailing `()` is appended in either case if the
-* identifier was declared as a signal, so the generated code always
-* correctly unwraps it.
-*
-* The original formatting of the expression — parentheses, spacing,
-* operator tokens, member access dots — is preserved verbatim by delegating
-* to `node.getText()` for any subtree that contains no resolvable identifiers.
-*
-* @param expression - Either a raw identifier string or a validated
-*   `Expression` node produced by `validateExpression`.
-* @param compilerContext - The active template scope context.
-* @returns The resolved expression as a JavaScript string ready for codegen.
-*
-* @example
-* // Simple identifier
-* resolveExpression('items', context) // → 'this.items'
-*
-* @example
-* // Signal identifier inherited from an ancestor scope (e.g. `$index` in a
-* // nested @for body)
-* resolveExpression('$index', context) // → "parentContext.get('$index')()"
-*
-* @example
-* // Complex expression — formatting preserved
-* resolveExpression(node, context)
-* // typeof id !== 'boolean' || pippo instanceof HTMLElement
-* // → typeof this.id !== 'boolean' || this.pippo instanceof HTMLElement
-*/
-function resolveExpression(expression, compilerContext, options) {
-	return emitNode(expression, expression, compilerContext, mapDefaultOptions(options));
-}
-/**
-* Emits the resolved text for a node.
-*
-* - If the node has no resolvable identifiers in its subtree, emits
-*   `node.getText()` verbatim — preserving all original spacing,
-*   parentheses, dots, and punctuation.
-* - If the node is a resolvable Identifier, emits the resolved access
-*   expression (see {@link resolveIdentifierAccess}).
-* - Otherwise recurses into children and concatenates their output.
-*/
-function emitNode(node, parent, compilerContext, options) {
-	if (isIdentifier(node) && needsResolution(node, parent)) {
-		const text = node.text;
-		if (compilerContext?.hasUnresolvableIdentifier(text) || options.skipResolution) return text;
-		if (options.resolver) return `${options.resolver}.${text}`;
-		if (compilerContext) return resolveIdentifierAccess(text, compilerContext);
-		return text;
-	}
-	if (!containsResolvableIdentifier(node, parent)) return node.getText();
-	const sourceText = node.getSourceFile().text;
-	let result = "";
-	let lastEnd = node.getStart();
-	forEachChild(node, (child) => {
-		result = `${result}${sourceText.slice(lastEnd, child.getStart())}${emitNode(child, node, compilerContext, options)}`;
-		lastEnd = child.getEnd();
-	});
-	return `${result}${sourceText.slice(lastEnd, node.getEnd())}`;
-}
-/**
-* Decides how to access a resolvable identifier's value in generated code,
-* based purely on compile-time scope information — no runtime type
-* detection is ever needed:
-*
-* - Declared directly in the CURRENT generated function's own scope (e.g.
-*   destructured from `vars` in a `@for` body) → bare reference: `name`,
-*   or `name()` if it's a signal.
-* - Declared in an ANCESTOR scope (an enclosing `@for`/`@if`/element-children
-*   function) → must cross the closure boundary through the runtime
-*   `Context` chain: `parentContext.get('name')`, or with a trailing `()`
-*   if it's a signal.
-* - Not declared anywhere in the template scope chain → assumed to be a
-*   component member: `this.name`.
-*
-* @param text - The identifier name to resolve.
-* @param compilerContext - The active template scope context.
-* @returns The generated code expression that yields the identifier's value.
-*/
-function resolveIdentifierAccess(text, compilerContext) {
-	if (compilerContext.hasIdentifier(text)) {
-		const kind = compilerContext.getIdentifierKind(text);
-		const access = `context.get('${text}')`;
-		return kind === "signal" ? `${access}()` : access;
-	}
-	return text;
-}
-/**
-* Returns true if the subtree rooted at `node` contains at least one
-* Identifier that needs context resolution.
-*
-* Short-circuits as soon as one is found to avoid visiting the whole tree.
-*/
-function containsResolvableIdentifier(node, parent) {
-	if (isIdentifier(node) && needsResolution(node, parent)) return true;
-	let found = false;
-	forEachChild(node, (child) => {
-		if (!found) found = containsResolvableIdentifier(child, node);
-	});
-	return found;
-}
-/**
-* Returns true if the identifier needs to be resolved against the context
-* or prefixed with `this.` — i.e. it is not a global/builtin identifier
-* and not the property-name side of a member access expression.
-*/
-function needsResolution(node, parent) {
-	return !(isPropertyAccessExpression(parent) && parent.name === node || isPropertyAssignment(parent) && parent.name === node || GLOBAL_IDENTIFIERS.has(node.text) || !node.text);
-}
-/**
-* Generates a unique variable name for a DOM element based on its tag name
-* and parent node context.
-*
-* When the parent is the root node (`this._root`), the identifier is based
-* solely on the tag name; otherwise the parent name is prepended to ensure
-* uniqueness within nested structures. Hyphens in tag names are replaced
-* with underscores to produce a valid JavaScript identifier.
-*
-* @param node - The `ElementNode` for which to generate the identifier.
-* @param parentNode - The variable name of the parent node.
-* @param index - A numeric suffix to disambiguate sibling elements of the same type.
-* @returns A unique variable name string for the element.
-*/
-function getElementIdentifier(node, parentNode, index) {
-	return getIdentifier(node.tagName, parentNode, index);
-}
-/**
-* Generates a unique variable name for a text or interpolation node.
-*
-* @param prefix - Optional prefix to use instead of the default `'text'`.
-* @param parentNode - The variable name of the parent node.
-* @param index - A numeric suffix to disambiguate sibling text nodes.
-* @returns A unique variable name string for the text node.
-*/
-function getTextIdentifier(prefix = "text", parentNode, index) {
-	return getIdentifier(prefix, parentNode, index);
-}
-/**
-* Generates a unique variable name for a control-flow block (if, else-if, else,
-* for, switch, case, or default).
-*
-* @param prefix - The block type prefix (`'if'`, `'elseIf'`, `'else'`, etc.).
-* @param parentNode - The variable name of the parent node.
-* @param index - A suffix to disambiguate sibling blocks.
-* @returns A unique variable name string for the block.
-*/
-function getBlockIdentifier(prefix, parentNode, index) {
-	return getIdentifier(prefix, parentNode, index);
-}
-function getIdentifier(prefix, parentNode, index) {
-	return (parentNode !== "root" ? `${parentNode}__${prefix}${index}` : `${prefix}${index}`).replace(/-/g, "_");
-}
-function mapDefaultOptions(options) {
-	return {
-		skipResolution: options?.skipResolution ?? false,
-		resolver: options?.resolver ?? "this"
-	};
-}
-//#endregion
-//#region ../packages/compiler/src/generator/states/generate-element.state.ts
-/**
-* Generates code for an HTML element node: creates the DOM element, sets attributes,
-* attaches event listeners, appends it to the parent, and recursively processes children.
-*
-* @param node - The `ElementNode` to process.
-* @param index - Variable name to use for the created DOM element.
-* @param parentNode - Variable name of the parent DOM node to append to.
-* @param compilerContext - Current render scope context.
-* @returns Array of generated code lines.
-*/
-function generateElement(node, parentNode, index, compilerContext, anchor) {
-	const attributes = mapAttributes(node.attributes, compilerContext);
-	const events = mapEvents(node.events, compilerContext);
-	const nodeName = getElementIdentifier(node, parentNode, index);
-	const tagName = node.tagName;
-	const retVal = {
-		code: [],
-		functionsToProcess: /* @__PURE__ */ new Map()
-	};
-	switch (tagName) {
-		case "svg":
-			retVal.code.push("context.createElement = createSVGElement");
-			break;
-		case "math": retVal.code.push("context.createElement = createMATHMLElement");
-	}
-	retVal.code.push(`const ${nodeName} = _renderElement(${parentNode}, context, ${anchor}, '${tagName}',`);
-	attributes.length ? retVal.code.push(...indent([
-		"[",
-		...indent(attributes),
-		"],"
-	])) : retVal.code[retVal.code.length - 1] = `${retVal.code[retVal.code.length - 1]} [],`;
-	events.length ? retVal.code.push(...indent([
-		"[",
-		...indent(events),
-		"]"
-	]), ");") : retVal.code[retVal.code.length - 1] = `${retVal.code[retVal.code.length - 1]} []);`;
-	switch (tagName) {
-		case "svg":
-		case "math": retVal.code.push("context.createElement = createElement");
-	}
-	if (node.children.length) {
-		retVal.functionsToProcess.set(`${nodeName}Children`, {
-			fn: {
-				node,
-				parentNode: nodeName,
-				context: compilerContext,
-				precode: getPrecode(tagName)
-			},
-			args: [nodeName, "parentContext"]
-		});
-		retVal.code.push(`this.${nodeName}Children(${nodeName}, context);`);
-	}
-	return retVal;
-}
-/**
-* Maps attribute nodes to their corresponding generated code lines.
-*
-* @param attributes - The attribute nodes to map onto the element.
-* @param compilerContext - Current render scope context, used to resolve identifier references.
-* @returns Array of generated code strings, one per attribute.
-*/
-function mapAttributes(attributes, compilerContext) {
-	return attributes?.map(({ name, value }) => {
-		const isLiteral = typeof value === "string";
-		return `{ name: '${name}', value: () => ${isLiteral ? `'${value}'` : resolveExpression(value.expression, compilerContext)}, literal: ${isLiteral} },`;
-	});
-}
-/**
-* Generates code that attaches event listeners to a DOM element.
-*
-* For each event node an `addEventListener` call is emitted, binding the event
-* to the component instance handler and exposing the native event as `$event`.
-*
-* @param events - The event nodes to bind to the element.
-* @param compilerContext - Current render scope context, used to resolve identifier references.
-* @returns Array of generated code lines, one per event listener.
-*/
-function mapEvents(events, compilerContext) {
-	compilerContext.addUnresolvableIdentifier("$event");
-	const mappedEvents = events.map((event) => {
-		let parsedEventParameter = false;
-		const parameters = event.parameters.map((parameter) => {
-			const resolvedParameter = resolveExpression(parameter, compilerContext);
-			if (!parsedEventParameter && resolvedParameter === "$event") {
-				parsedEventParameter = true;
-				return `($event) => ${resolvedParameter},`;
-			} else return `() => ${resolvedParameter},`;
-		});
-		const eventCode = ["{", ...indent([
-			`name: '${event.name}',`,
-			`handler: '${event.handler}',`,
-			"parameters: ["
-		])];
-		if (parameters.length) eventCode.push(...indent([...indent(parameters), "]"]), "},");
-		else {
-			eventCode[eventCode.length - 1] = `${eventCode[eventCode.length - 1]}]`;
-			eventCode.push("},");
-		}
-		return eventCode;
-	}).flat();
-	compilerContext.removeIdentifier("$event");
-	return mappedEvents;
-}
-function getPrecode(tagName) {
-	switch (tagName) {
-		case "svg": return "context.createElement = createSVGElement;";
-		case "math": return "context.createElement = createMATHMLElement;";
-		default: return "";
-	}
-}
-//#endregion
-//#region ../packages/compiler/src/generator/states/generate-for.state.ts
-/**
-* Generates code for a `@for` iteration node.
-*
-* Emits a classic index-based `for` loop with all implicit variables
-* declared at the top of the loop body:
-*
-* ```javascript
-* for (let $i = 0; $i < ctx_items.length; $i++) {
-*   const item = items[$i];
-*   const $index = $i;
-*   const $first = $i === 0;
-*   const $last  = $i === items.length - 1;
-*   const $even  = $i % 2 === 0;
-*   const $odd   = $i % 2 !== 0;
-*   // ... child nodes
-* }
-* ```
-*
-* The iterable identifier is resolved through the active {@link Context}:
-* if found in scope it is used as-is, otherwise `this.` is prepended.
-*
-* The internal loop counter is always named `$i_<nodeName>` to avoid
-* collisions when `@for` blocks are nested.
-*
-* @param node - The `ForNode` to process.
-* @param index - Base variable name prefix used for child nodes and
-*   to produce a unique loop counter identifier.
-* @param parentNode - Variable name of the parent DOM node.
-* @param compilerContext - The enclosing scope context.
-* @returns Array of generated code lines.
-*/
-function generateFor(node, parentNode, index, compilerContext) {
-	const retVal = {
-		code: [],
-		functionsToProcess: /* @__PURE__ */ new Map()
-	};
-	const iterableSource = node.iterableSource;
-	const iterableExpr = compilerContext.hasIdentifier(iterableSource) ? iterableSource : `this.${iterableSource}`;
-	const itemsName = getTextIdentifier("items", parentNode, index);
-	const counterName = getTextIdentifier("i", parentNode, index);
-	const indexName = resolveImplicit$1(node, "$index");
-	const firstName = resolveImplicit$1(node, "$first");
-	const lastName = resolveImplicit$1(node, "$last");
-	const evenName = resolveImplicit$1(node, "$even");
-	const oddName = resolveImplicit$1(node, "$odd");
-	const forContext = new CompilerContext([
-		node.itemAlias,
-		[indexName, "signal"],
-		[firstName, "signal"],
-		[lastName, "signal"],
-		[evenName, "signal"],
-		[oddName, "signal"]
-	], compilerContext);
-	const forKey = getBlockIdentifier("for", parentNode, index);
-	retVal.functionsToProcess.set(forKey, {
-		fn: {
-			precode: `const { vars, update } = _iterationVariables(context, ${itemsName}, ${counterName}, '${node.itemAlias}', { 
-    $index: '${indexName}', 
-    $first: '${firstName}', 
-    $last: '${lastName}', 
-    $even: '${evenName}', 
-    $odd: '${oddName}' 
-  });
-  const { ${node.itemAlias}, ${indexName}, ${firstName}, ${lastName}, ${evenName}, ${oddName} } = vars;`,
-			node,
-			parentNode: forKey,
-			context: forContext,
-			anchor: "anchor",
-			isForBody: true
-		},
-		args: [
-			forKey,
-			"parentContext",
-			itemsName,
-			counterName,
-			"anchor"
-		]
-	});
-	retVal.code.push(`_for(${parentNode}, context, () => ${iterableExpr}, ${node.itemAlias} => ${resolveExpression(node.trackExpression, forContext, { skipResolution: true })}, this.${forKey}.bind(this));`);
-	return retVal;
-}
-/**
-* Resolves the name that should be used in generated code for a given
-* implicit variable.
-*
-* If the template declared an explicit alias for the variable
-* (e.g. `; $index = i`) that alias is returned. Otherwise the default
-* implicit variable name (e.g. `$index`) is used.
-*
-* @param node - The `ForNode` whose implicit alias map is consulted.
-* @param implicit - The implicit variable to look up (e.g. `'$index'`).
-* @returns The alias string if one was declared, otherwise `implicit` itself.
-*/
-function resolveImplicit$1(node, implicit) {
-	return node.implicitAliases.get(implicit) ?? implicit;
-}
-//#endregion
-//#region ../packages/compiler/src/generator/states/generate-if.state.ts
-function generateIf(node, parentNode, index, compilerContext) {
-	const ifContext = new CompilerContext([], compilerContext);
-	const retVal = {
-		code: [],
-		functionsToProcess: /* @__PURE__ */ new Map()
-	};
-	retVal.code.push(`_if(${parentNode}, context, [`);
-	const ifKey = getBlockIdentifier("if", parentNode, index);
-	retVal.code.push(...indent([
-		"{",
-		...indent([`condition: () => ${resolveExpression(node.conditionNode, compilerContext)},`, `block: this.${ifKey}.bind(this)`]),
-		"},"
-	]));
-	retVal.functionsToProcess.set(ifKey, {
-		fn: {
-			node,
-			parentNode: ifKey,
-			context: ifContext,
-			anchor: "anchor"
-		},
-		args: [
-			ifKey,
-			"parentContext",
-			"anchor"
-		]
-	});
-	let alt = node.alternate;
-	let i = 0;
-	while (alt?.type === ASTNodeType.ElseIf) {
-		const elseIfContext = new CompilerContext([], compilerContext);
-		const keyElseIf = getBlockIdentifier("elseIf", parentNode, `${index}_${i}`);
-		const conditionNode = alt.conditionNode;
-		retVal.code.push(...indent([
-			"{",
-			...indent([`condition: () => ${resolveExpression(conditionNode, compilerContext)},`, `block: this.${keyElseIf}.bind(this)`]),
-			"},"
-		]));
-		retVal.functionsToProcess.set(keyElseIf, {
-			fn: {
-				node: alt,
-				parentNode,
-				context: elseIfContext,
-				anchor: "anchor"
-			},
-			args: [
-				parentNode,
-				"parentContext",
-				"anchor"
-			]
-		});
-		alt = alt.alternate;
-		i++;
-	}
-	if (alt) {
-		const elseContext = new CompilerContext([], compilerContext);
-		const keyElse = getBlockIdentifier("else", parentNode, index);
-		retVal.code.push(...indent([
-			"{",
-			...indent([`block: this.${keyElse}.bind(this)`]),
-			"},"
-		]));
-		retVal.functionsToProcess.set(keyElse, {
-			fn: {
-				node: alt,
-				parentNode,
-				context: elseContext,
-				anchor: "anchor"
-			},
-			args: [
-				parentNode,
-				"parentContext",
-				"anchor"
-			]
-		});
-	}
-	retVal.code.push("]);");
-	return retVal;
-}
-//#endregion
-//#region ../packages/compiler/src/generator/states/generate-switch.state.ts
-/**
-* Generates code for a `@switch` node.
-* Emits a `_switch(...)` call that delegates to the reactive `_switch` runtime utility.
-*
-* @param node - The `SwitchNode` to process.
-* @param index - Base variable name prefix for child nodes.
-* @param parentNode - Variable name of the parent DOM node.
-* @param compilerContext - Current render scope context.
-* @returns An object with the main block code lines and a map of helper functions to register.
-*/
-function generateSwitch(node, parentNode, index, compilerContext) {
-	const retVal = {
-		code: [],
-		functionsToProcess: /* @__PURE__ */ new Map()
-	};
-	retVal.code.push(`_switch(${parentNode}, context, () => ${resolveExpression(node.expression, compilerContext)}, [`);
-	node.children.forEach((caseNode, i) => {
-		const caseContext = new CompilerContext([], compilerContext);
-		const caseKey = caseNode.condition ? getBlockIdentifier("case", parentNode, `${index}_${i}`) : getBlockIdentifier("default", parentNode, index);
-		retVal.functionsToProcess.set(caseKey, {
-			fn: {
-				node: caseNode,
-				parentNode: caseKey,
-				context: caseContext
-			},
-			args: [
-				caseKey,
-				"parentContext",
-				"anchor"
-			]
-		});
-		const fnName = `this.${caseKey}.bind(this)`;
-		retVal.code.push(...indent([
-			"{",
-			...indent([`condition: ${caseNode.condition ? `[${caseNode.condition.join(", ")}]` : `null`},`, `block: ${fnName}`]),
-			"},"
-		]));
-	});
-	retVal.code.push("])");
-	return retVal;
-}
-//#endregion
-//#region ../packages/compiler/src/generator/states/generate-text-and-interpolation.state.ts
-/**
-* Generates code for a text or interpolation node.
-*
-* Emits a `_renderLiteralText` call for plain text nodes and a
-* `_renderText` call for interpolation nodes, both appending a DOM text
-* node to the parent.
-*
-* @param node - A `TextNode` or `InterpolationNode` to process.
-* @param parentNode - Variable name of the parent DOM node to append to.
-* @returns Array of generated code lines.
-*/
-function generateTextAndInterpolation(node, parentNode, _index, compilerContext) {
-	return { code: [`${node.type === ASTNodeType.Text ? `_renderLiteralText(${parentNode}, context, '${node.value}');` : `_renderText(${parentNode}, context, () => ${resolveExpression(node.expression, compilerContext)});`}`] };
-}
-//#endregion
-//#region ../packages/compiler/src/generator/states/skip-generation.state.ts
-function skipGeneration(_node, _parentNode, _index, _compilerContext) {}
-//#endregion
-//#region ../packages/compiler/src/generator/generator.ts
-var Generator = class {
-	_ast;
-	_nodeToProcess = /* @__PURE__ */ new Map();
-	_states = {
-		[ASTNodeType.Text]: generateTextAndInterpolation,
-		[ASTNodeType.Interpolation]: generateTextAndInterpolation,
-		[ASTNodeType.Element]: generateElement,
-		[ASTNodeType.If]: generateIf,
-		[ASTNodeType.For]: generateFor,
-		[ASTNodeType.Switch]: generateSwitch,
-		[ASTNodeType.Import]: skipGeneration
-	};
-	constructor(_ast) {
-		this._ast = _ast;
-	}
-	generate(cssVariableName) {
-		this._nodeToProcess.clear();
-		const compilerContext = new CompilerContext();
-		const generatedCode = ["_render() {", ...indent([`const ${ROOT_NODE} = this._root;`, "const context = new Context(this, { createElement: document.createElement.bind(document), get: () => undefined });"])];
-		if (cssVariableName) generatedCode.push(indent(`${ROOT_NODE}.adoptedStyleSheets = [${cssVariableName}];`));
-		for (let i = 0; i < this._ast.length; i++) {
-			const result = this._processNode(this._ast[i], ROOT_NODE, i.toString(), compilerContext, null);
-			if (result) {
-				const { code, functionsToProcess } = result;
-				functionsToProcess?.forEach((value, key) => this._nodeToProcess.set(key, value));
-				generatedCode.push(...indent(code));
-			}
-		}
-		generatedCode.push(...indent(["return context;"]), "}");
-		for (const [key, fnData] of this._nodeToProcess.entries()) {
-			const { node, parentNode, context, precode, anchor } = fnData.fn;
-			generatedCode.push(`\n${key}(${fnData.args?.join(", ")}) {`, ...indent(["const context = new Context(this, parentContext);"]));
-			if (precode) generatedCode.push(indent(precode));
-			generatedCode.push(...indent([...node.children.map((child, i) => {
-				const result = this._processNode(child, parentNode, i.toString(), context, anchor ?? null);
-				if (result) {
-					const { code, functionsToProcess } = result;
-					functionsToProcess?.forEach((value, key) => this._nodeToProcess.set(key, value));
-					return code;
-				}
-				return "";
-			}).flat(), fnData.fn.isForBody ? "return { context, update };" : "return context;"]), "}");
-		}
-		return generatedCode.join("\n");
-	}
-	_processNode(node, parentNode, index, compilerContext, anchor) {
-		const state = this._states[node.type];
-		if (!state) throw new Error(`[Generator] No transition function for token type ${ASTNodeType[node.type]}`);
-		return state(node, parentNode, index, compilerContext, anchor);
-	}
-};
-//#endregion
-//#region ../packages/compiler/src/lexer/types/lexer-state.enum.ts
-/**
-* Represents the set of states the lexer can be in while processing template input.
-*/
-var LexerState = /* @__PURE__ */ function(LexerState) {
-	/**
-	* Consuming plain text content between tags or at the top level.
-	*/
-	LexerState["TEXT"] = "text";
-	/**
-	* Consuming the opening tag name after `<`.
-	*/
-	LexerState["TAG_OPEN_NAME"] = "tag-open-name";
-	/**
-	* Inside an open tag body, scanning for attributes, events, or the closing `>`.
-	*/
-	LexerState["TAG_BODY"] = "tag-body";
-	/**
-	* Processing the end of an open tag: `>` or `/>`.
-	*/
-	LexerState["TAG_OPEN_END"] = "tag-open-end";
-	/**
-	* Consuming a closing tag `</tagName>`.
-	*/
-	LexerState["TAG_CLOSE"] = "tag-close";
-	/**
-	* Consuming an HTML attribute name and its optional value.
-	*/
-	LexerState["ATTRIBUTE"] = "attribute";
-	/**
-	* Consuming a DOM event binding starting with `@`.
-	*/
-	LexerState["EVENT"] = "event";
-	/**
-	* Consuming a DOM event parameter
-	*/
-	LexerState["EVENT_PARAMETER"] = "parameter";
-	/**
-	* Dispatching a flow-control keyword (@if, @for, @switch, etc.).
-	*/
-	LexerState["FLOW_CONTROL"] = "flow-control";
-	/**
-	* Consuming the condition expression `(...)` of a flow-control directive.
-	*/
-	LexerState["FLOW_CONTROL_CONDITION"] = "flow-control-condition";
-	/**
-	* Consuming the condition expression `(...)` of a @case directive.
-	* This is needed to correctly handle special consecutives @case 
-	*/
-	LexerState["CASE_FLOW_CONTROL_CONDITION"] = "case-flow-control-condition";
-	/**
-	* Consuming the opening `{` of a flow-control block body.
-	*/
-	LexerState["FLOW_CONTROL_BLOCK"] = "flow-control-block";
-	/**
-	* Consuming an attribute literal value
-	*/
-	LexerState["ATTRIBUTE_VALUE"] = "attribute-value";
-	/**
-	* Dispatching between an expression or literal interpolation after `{`.
-	*/
-	LexerState["INTERPOLATION"] = "interpolation";
-	/**
-	* Consuming a JavaScript expression inside `{ }`.
-	*/
-	LexerState["INTERPOLATION_EXPRESSION"] = "interpolation-expression";
-	/**
-	* Consuming a template-literal string inside `` {`...`} ``.
-	*/
-	LexerState["INTERPOLATION_LITERAL"] = "interpolation-literal";
-	/**
-	* Consuming an import statement `@import { X, Y, ... }
-	*/
-	LexerState["IMPORT"] = "import";
-	LexerState["IMPORT_PATH"] = "import-path";
-	return LexerState;
-}({});
-//#endregion
-//#region ../packages/compiler/src/lexer/types/token-type.enum.ts
-/**
-* Discriminant values that identify the type of each token emitted by the lexer.
-*/
-var TokenType = /* @__PURE__ */ function(TokenType) {
-	/**
-	* A plain text node between tags or at the top level.
-	*/
-	TokenType[TokenType["TEXT"] = 0] = "TEXT";
-	/**
-	* The name portion of an opening tag, e.g. `div` in `<div`.
-	*/
-	TokenType[TokenType["TAG_OPEN_NAME"] = 1] = "TAG_OPEN_NAME";
-	/**
-	* A self-closing tag marker `/>`.
-	*/
-	TokenType[TokenType["TAG_SELF_CLOSE"] = 2] = "TAG_SELF_CLOSE";
-	/**
-	* The closing `>` of an opening tag.
-	*/
-	TokenType[TokenType["TAG_OPEN_END"] = 3] = "TAG_OPEN_END";
-	/**
-	* The name portion of a closing tag, e.g. `div` in `</div>`.
-	*/
-	TokenType[TokenType["TAG_CLOSE_NAME"] = 4] = "TAG_CLOSE_NAME";
-	/**
-	* An HTML attribute
-	*/
-	TokenType[TokenType["ATTRIBUTE"] = 5] = "ATTRIBUTE";
-	/**
-	* An HTML attribute literal value
-	*/
-	TokenType[TokenType["ATTRIBUTE_VALUE"] = 6] = "ATTRIBUTE_VALUE";
-	/**
-	* A DOM event binding declared with `@eventName=handler`.
-	*/
-	TokenType[TokenType["EVENT"] = 7] = "EVENT";
-	/**
-	* An event paremeter included in a event call '()'
-	*/
-	TokenType[TokenType["EVENT_PAREMETER"] = 8] = "EVENT_PAREMETER";
-	/**
-	* A template-literal interpolation string enclosed in `` {`...`} ``.
-	*/
-	TokenType[TokenType["INTERPOLATION_LITERAL"] = 9] = "INTERPOLATION_LITERAL";
-	/**
-	* A JavaScript expression interpolation enclosed in `{ }`.
-	*/
-	TokenType[TokenType["INTERPOLATION_EXPRESSION"] = 10] = "INTERPOLATION_EXPRESSION";
-	/**
-	* Opening keyword of an `@if` directive.
-	*/
-	TokenType[TokenType["IF"] = 11] = "IF";
-	/**
-	* Opening keyword of a `@for` directive.
-	*/
-	TokenType[TokenType["FOR"] = 12] = "FOR";
-	/**
-	* Opening keyword of an `@else` branch.
-	*/
-	TokenType[TokenType["ELSE"] = 13] = "ELSE";
-	/**
-	* Opening keyword of an `@else if` branch.
-	*/
-	TokenType[TokenType["ELSE_IF"] = 14] = "ELSE_IF";
-	/**
-	* Opening keyword of a `@switch` directive.
-	*/
-	TokenType[TokenType["SWITCH"] = 15] = "SWITCH";
-	/**
-	* Opening keyword of a `@case` branch.
-	*/
-	TokenType[TokenType["CASE"] = 16] = "CASE";
-	/**
-	* Opening keyword of a `@default` branch.
-	*/
-	TokenType[TokenType["DEFAULT"] = 17] = "DEFAULT";
-	/**
-	* The condition expression `(...)` associated with a flow-control directive.
-	*/
-	TokenType[TokenType["CONDITION"] = 18] = "CONDITION";
-	/**
-	* The opening `{` of a flow-control block body.
-	*/
-	TokenType[TokenType["BLOCK_OPEN"] = 19] = "BLOCK_OPEN";
-	/**
-	* The closing `}` of a flow-control block body.
-	*/
-	TokenType[TokenType["BLOCK_CLOSE"] = 20] = "BLOCK_CLOSE";
-	TokenType[TokenType["IMPORT"] = 21] = "IMPORT";
-	TokenType[TokenType["IMPORT_PATH"] = 22] = "IMPORT_PATH";
-	/**
-	* Sentinel token emitted when the end of the input is reached.
-	*/
-	TokenType[TokenType["EOF"] = 23] = "EOF";
-	return TokenType;
-}({});
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-attribute-value.state.ts
-/**
-* Consumes a quoted attribute value `"..."`, collecting characters until
-* the closing `"` is found. Emits an ATTRIBUTE_VALUE token and transitions
-* back to TAG_BODY.
-*
-* @param cursor - The lexer cursor positioned at the first character of the value (after the opening `"`).
-* @param _context - Unused lexer context.
-* @returns Transition result with the ATTRIBUTE_VALUE token and the TAG_BODY state.
-*/
-function lexAttributeValue(cursor, _context) {
-	let read = true;
-	let value = "";
-	let retVal;
-	while (read) switch (cursor.peek()) {
-		case 34:
-			cursor.advance();
-			read = false;
-			retVal = {
-				state: LexerState.TAG_BODY,
-				tokens: [{
-					type: TokenType.ATTRIBUTE_VALUE,
-					parts: [value]
-				}],
-				popState: true
-			};
-			break;
-		default:
-			cursor.advance();
-			value = `${value}${cursor.currentChar.value}`;
-	}
-	return retVal;
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-attribute.state.ts
-/**
-* Consumes an attribute name and optional value from the current position,
-* transitioning back to TAG_BODY when a space, `/`, or `>` is encountered.
-* If the attribute value is an interpolation, pushes the INTERPOLATION state.
-*
-* @param cursor - The lexer cursor positioned at the start of the attribute.
-* @param _context - Unused lexer context.
-* @returns Transition result with the ATTRIBUTE token and next state.
-*/
-function lexAttribute(cursor, _context) {
-	let read = true;
-	let attribute = "";
-	let retVal;
-	while (read) switch (cursor.peek()) {
-		case 32:
-			cursor.advance();
-			read = false;
-			retVal = {
-				state: LexerState.TAG_BODY,
-				tokens: [{
-					type: TokenType.ATTRIBUTE,
-					parts: [attribute]
-				}]
-			};
-			break;
-		case 61:
-			cursor.advance();
-			if (cursor.peek() !== 34) {
-				const { row, column } = cursor.position;
-				throw new Error(`Attribute value must start with double quotes '"'.Row ${row} Col ${column}`);
-			}
-			cursor.advance();
-			read = false;
-			retVal = {
-				state: cursor.peek() === 123 ? LexerState.INTERPOLATION : LexerState.ATTRIBUTE_VALUE,
-				pushState: true,
-				tokens: [{
-					type: TokenType.ATTRIBUTE,
-					parts: [attribute]
-				}]
-			};
-			break;
-		default:
-			cursor.advance();
-			attribute = `${attribute}${cursor.currentChar.value}`;
-	}
-	return retVal;
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/utils/consume-flow-control-condition.utils.ts
-/**
-* Consumes a parenthesised flow-control condition expression from the cursor.
-*
-* Skips leading whitespace, then expects `(` followed by a balanced
-* parenthesised expression. Handles nested parentheses and returns the
-* raw expression string (excluding the outer `(` and `)`).
-*
-* @param cursor - The lexer cursor positioned before the opening `(`.
-* @param _context - Unused lexer context (kept for signature consistency).
-* @returns The raw expression string extracted from inside the parentheses.
-* @throws When the next non-space character is not `(`.
-*/
-function consumeFlowControlCondition(cursor, _context) {
-	cursor.skipSpaces();
-	if (cursor.peek() !== 40) throw new Error(`Expected '(' but got '${String.fromCharCode(cursor.peek())}' at row ${cursor.position.row}, col ${cursor.position.column}`);
-	cursor.advance();
-	let expression = "";
-	let depth = 1;
-	while (depth > 0) switch (cursor.peek()) {
-		case 40:
-			depth++;
-			expression = addCharacter$3(cursor, expression);
-			break;
-		case 41:
-			depth--;
-			if (!depth) {
-				cursor.advance();
-				break;
-			}
-			expression = addCharacter$3(cursor, expression);
-			break;
-		default: expression = addCharacter$3(cursor, expression);
-	}
-	return expression;
-}
-/**
-* Advances the cursor by one character and appends it to the accumulator string.
-*
-* @param cursor - The lexer cursor to advance.
-* @param expression - The current accumulated expression string.
-* @returns The updated string with the newly consumed character appended.
-*/
-function addCharacter$3(cursor, expression) {
-	cursor.advance();
-	return `${expression}${cursor.currentChar.value}`;
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-case-flow-control-condition.state.ts
-/**
-* Consumes the condition expression `(...)` of a flow-control directive,
-* handling nested parentheses correctly. Emits a CONDITION token with the
-* raw expression string and transitions to FLOW_CONTROL_BLOCK.
-*
-* @param cursor - The lexer cursor positioned at the opening `(`.
-* @param _context - Unused lexer context.
-* @returns Transition result with the CONDITION token and the FLOW_CONTROL_BLOCK state.
-*/
-function lexCaseFlowControlCondition(cursor, _context) {
-	const condition = consumeFlowControlCondition(cursor, _context);
-	cursor.skipSpaces();
-	return {
-		state: cursor.peekMatch("@case") ? LexerState.FLOW_CONTROL : LexerState.FLOW_CONTROL_BLOCK,
-		tokens: [{
-			type: TokenType.CONDITION,
-			parts: [condition]
-		}],
-		popState: true
-	};
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-default-flow-control-condition.state.ts
-/**
-* Consumes the condition expression `(...)` of a flow-control directive,
-* handling nested parentheses correctly. Emits a CONDITION token with the
-* raw expression string and transitions to FLOW_CONTROL_BLOCK.
-*
-* @param cursor - The lexer cursor positioned at the opening `(`.
-* @param _context - Unused lexer context.
-* @returns Transition result with the CONDITION token and the FLOW_CONTROL_BLOCK state.
-*/
-function lexDefaultFlowControlCondition(cursor, _context) {
-	return {
-		state: LexerState.FLOW_CONTROL_BLOCK,
-		tokens: [{
-			type: TokenType.CONDITION,
-			parts: [consumeFlowControlCondition(cursor, _context)]
-		}],
-		popState: true
-	};
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-event-parameter.state.ts
-/**
-* Consumes an event parameter and reads until a ',' or ')'.
-* Emits an EVENT_ATTRIBUTE token containing the raw paremeter string.
-*
-* @param cursor - The lexer cursor positioned on the `@` character.
-* @param _context - Unused lexer context.
-* @returns Transition result with the EVENT_PAREMETER token and the EVENT state.
-*/
-function lexEventParameter(cursor, _context) {
-	let read = true;
-	let eventParameter = "";
-	let charDelimiter = "";
-	const retVal = {
-		state: LexerState.TAG_BODY,
-		tokens: []
-	};
-	while (read) switch (cursor.peek()) {
-		case 91:
-		case 93:
-		case 123:
-		case 125:
-		case 34:
-		case 39:
-		case 40:
-			eventParameter = addCharacter$2(cursor, eventParameter);
-			if (!charDelimiter) charDelimiter = cursor.currentChar.value;
-			else if (charDelimiter === cursor.currentChar.value || charDelimiter === "[" && cursor.currentChar.value === "]" || charDelimiter === "{" && cursor.currentChar.value === "}") charDelimiter = "";
-			break;
-		case 44:
-			if (!charDelimiter) {
-				retVal.tokens.push({
-					type: TokenType.EVENT_PAREMETER,
-					parts: [eventParameter]
-				});
-				cursor.advance();
-				cursor.skipSpaces();
-				eventParameter = "";
-			} else eventParameter = addCharacter$2(cursor, eventParameter);
-			break;
-		case 41:
-			cursor.advance();
-			if (!charDelimiter) {
-				retVal.tokens.push({
-					type: TokenType.EVENT_PAREMETER,
-					parts: [eventParameter]
-				});
-				read = false;
-			}
-		default: eventParameter = addCharacter$2(cursor, eventParameter);
-	}
-	return retVal;
-}
-function addCharacter$2(cursor, eventParameter) {
-	cursor.advance();
-	return `${eventParameter}${cursor.currentChar.value}`;
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-event.state.ts
-/**
-* Consumes a DOM event binding starting with `@` and reads until a delimiter
-* (space, `/`, or `>`) is found. Emits an EVENT token containing the raw binding string.
-*
-* @param cursor - The lexer cursor positioned on the `@` character.
-* @param _context - Unused lexer context.
-* @returns Transition result with the EVENT token and the TAG_BODY state.
-*/
-function lexEvent(cursor, _context) {
-	let read = true;
-	let event = "";
-	let retVal;
-	cursor.advance();
-	while (read) switch (cursor.peek()) {
-		case 32:
-		case 47:
-		case 62:
-			retVal = { state: LexerState.TAG_BODY };
-			read = false;
-			break;
-		case 40:
-			let state = LexerState.EVENT_PARAMETER;
-			cursor.advance();
-			cursor.skipSpaces();
-			if (cursor.peek() === 41) {
-				state = LexerState.TAG_BODY;
-				cursor.advance(2);
-			}
-			retVal = {
-				state,
-				tokens: [{
-					type: TokenType.EVENT,
-					parts: [event]
-				}]
-			};
-			read = false;
-			break;
-		default:
-			cursor.advance();
-			event = `${event}${cursor.currentChar.value}`;
-	}
-	return retVal;
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-flow-control.ts
-/**
-* Dispatches on a `@keyword` to determine which flow-control directive begins here.
-* Recognises `@if`, `@for`, `@else`, `@switch`, `@case`, `@default`, and `@const`.
-* Advances the cursor past the keyword and transitions to the appropriate next state.
-*
-* @param cursor - The lexer cursor positioned on the `@` character.
-* @param _context - Unused lexer context.
-* @returns Transition result with the matching flow-control token and next state.
-*/
-function lexFlowControl(cursor, _context) {
-	let retVal;
-	cursor.advance();
-	if (cursor.peekMatch("for ")) {
-		cursor.advance(4);
-		retVal = {
-			state: LexerState.FLOW_CONTROL_CONDITION,
-			tokens: [{ type: TokenType.FOR }],
-			pushState: true
-		};
-	} else if (cursor.peekMatch("if ")) {
-		cursor.advance(2);
-		retVal = {
-			state: LexerState.FLOW_CONTROL_CONDITION,
-			tokens: [{ type: TokenType.IF }],
-			pushState: true
-		};
-	} else if (cursor.peekMatch("else if ")) {
-		cursor.advance(8);
-		retVal = {
-			state: LexerState.FLOW_CONTROL_CONDITION,
-			tokens: [{ type: TokenType.ELSE_IF }],
-			pushState: true
-		};
-	} else if (cursor.peekMatch("else ")) {
-		cursor.advance(5);
-		retVal = {
-			state: LexerState.FLOW_CONTROL_BLOCK,
-			tokens: [{ type: TokenType.ELSE }]
-		};
-	} else if (cursor.peekMatch("switch ")) {
-		cursor.advance(7);
-		retVal = {
-			state: LexerState.FLOW_CONTROL_CONDITION,
-			tokens: [{ type: TokenType.SWITCH }],
-			pushState: true
-		};
-	} else if (cursor.peekMatch("case ")) {
-		cursor.advance(5);
-		retVal = {
-			state: LexerState.CASE_FLOW_CONTROL_CONDITION,
-			tokens: [{ type: TokenType.CASE }],
-			pushState: true
-		};
-	} else if (cursor.peekMatch("default ")) {
-		cursor.advance(8);
-		retVal = {
-			state: LexerState.FLOW_CONTROL_BLOCK,
-			tokens: [{ type: TokenType.DEFAULT }]
-		};
-	} else if (cursor.peekMatch("import ")) {
-		cursor.advance(7);
-		retVal = { state: LexerState.IMPORT };
-	}
-	return retVal;
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-flow-control-block.state.ts
-/**
-* Consumes the opening `{` of a flow-control block body,
-* skipping any leading whitespace before it.
-*
-* Emits a BLOCK_OPEN token and transitions to TEXT, pushing FLOW_CONTROL_BLOCK
-* onto the state stack so that `consumeText` later recognises the matching `}`
-* as a BLOCK_CLOSE rather than an interpolation boundary.
-*
-* Used by: `@if`, `@for`, `@switch`, `@case`, `@else`, `@default`.
-*
-* @param cursor - The lexer cursor positioned before the opening `{`.
-* @param _context - Unused lexer context.
-* @returns Transition result with the BLOCK_OPEN token and the TEXT state.
-*/
-function lexFlowControlBlock(cursor, _context) {
-	cursor.skipSpaces();
-	if (cursor.peek() !== 123) throw new Error(`Expected '{' but got '${String.fromCharCode(cursor.peek())}' at row ${cursor.position.row}, col ${cursor.position.column}`);
-	cursor.advance();
-	return {
-		state: LexerState.TEXT,
-		tokens: [{ type: TokenType.BLOCK_OPEN }],
-		pushState: true
-	};
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-import-path.state.ts
-function lexImportPath(cursor, _context) {
-	let read = true;
-	let path = "";
-	let retVal;
-	let singleQuote = false;
-	cursor.skipSpaces();
-	if (!cursor.peekMatch("from")) throw new Error(`Expected from keywork after list of imports at ${cursor.currentChar}`);
-	cursor.advance(4);
-	cursor.skipSpaces();
-	cursor.advance();
-	switch (cursor.currentChar.code) {
-		case 39:
-			singleQuote = true;
-			break;
-		case 34: break;
-		default: throw new Error(`Import statement must start with ' or ".\nFound character ${cursor.currentChar.value} at ${cursor.formattedPosition}`);
-	}
-	const delimiter = singleQuote ? 39 : 34;
-	while (read) switch (cursor.peek()) {
-		case delimiter:
-			cursor.advance();
-			read = false;
-			retVal = {
-				state: LexerState.TEXT,
-				tokens: [{
-					type: TokenType.IMPORT_PATH,
-					parts: [path]
-				}]
-			};
-			break;
-		default:
-			cursor.advance();
-			path = `${path}${cursor.currentChar.value}`;
-	}
-	return retVal;
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-import.state.ts
-function lexImport(cursor, _context) {
-	let read = true;
-	let importValue = "";
-	let retVal = {
-		state: LexerState.IMPORT_PATH,
-		tokens: []
-	};
-	cursor.skipSpaces();
-	cursor.advance();
-	if (cursor.currentChar.code !== 123) throw new Error(`Expected { after @import at ${cursor.formattedPosition}`);
-	while (read) switch (cursor.peek()) {
-		case 32:
-			cursor.skipSpaces();
-			if (importValue && cursor.peek() !== 44 && cursor.peek() !== 125) importValue = `${importValue} `;
-			break;
-		case 44:
-			addImport(retVal, cursor, importValue);
-			importValue = "";
-			break;
-		case 125:
-			addImport(retVal, cursor, importValue);
-			read = false;
-			break;
-		default:
-			cursor.advance();
-			importValue = `${importValue}${cursor.currentChar.value}`;
-	}
-	return retVal;
-}
-function addImport(retVal, cursor, value) {
-	cursor.advance();
-	retVal.tokens.push({
-		type: TokenType.IMPORT,
-		parts: [value]
-	});
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-interpolation-expression.state.ts
-/**
-* Consumes a JavaScript expression interpolation `{ expression }`, tracking nested
-* brace depth. Emits an INTERPOLATION_EXPRESSION token and pops the state stack to
-* return to the previous state (ATTRIBUTE or TEXT).
-*
-* @param cursor - The lexer cursor positioned at the first character of the expression.
-* @param context - The lexer context used to retrieve the previous state for restoration.
-* @returns Transition result with the INTERPOLATION_EXPRESSION token and restored state.
-*/
-function lexInterpolationExpression(cursor, context) {
-	let read = true;
-	let interpolation = "";
-	let deep = 1;
-	let retVal;
-	while (read) switch (cursor.peek()) {
-		case 123:
-			deep++;
-			interpolation = addCharacter$1(cursor, interpolation);
-			break;
-		case 125:
-			deep--;
-			if (deep === 0) {
-				cursor.advance();
-				interpolation = interpolation.trimEnd();
-				const previousState = context.history.pop();
-				let state;
-				switch (previousState) {
-					case LexerState.ATTRIBUTE:
-						if (cursor.peek() !== 34) throw new Error(`Interpolation must end with double quotes '"' Found ${String.fromCharCode(cursor.peek())} at ${cursor.formattedPosition}`);
-						cursor.advance();
-						state = LexerState.TAG_BODY;
-						break;
-					case LexerState.TEXT: state = LexerState.TEXT;
-				}
-				retVal = {
-					state,
-					tokens: [{
-						type: TokenType.INTERPOLATION_EXPRESSION,
-						parts: [interpolation]
-					}],
-					popState: true
-				};
-				read = false;
-			} else interpolation = addCharacter$1(cursor, interpolation);
-			break;
-		default: interpolation = addCharacter$1(cursor, interpolation);
-	}
-	return retVal;
-}
-/**
-* Advances the cursor by one character and appends it to the accumulator string.
-*
-* @param cursor - The lexer cursor to advance.
-* @param interpolation - The current accumulated expression string.
-* @returns The updated string with the newly consumed character appended.
-*/
-function addCharacter$1(cursor, interpolation) {
-	cursor.advance(1);
-	return `${interpolation}${cursor.currentChar.value}`;
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-interpolation-literal.state.ts
-/**
-* Consumes a template-literal interpolation `` {`...`} ``, collecting characters
-* until the closing backtick followed by `}`. Emits an INTERPOLATION_LITERAL token
-* and pops the state stack to return to the previous state.
-*
-* @param cursor - The lexer cursor positioned at the opening backtick.
-* @param context - The lexer context used to retrieve the previous state for restoration.
-* @returns Transition result with the INTERPOLATION_LITERAL token and restored state.
-*/
-function lexInterpolationliteral(cursor, context) {
-	let read = true;
-	let interpolation = "`";
-	let retVal;
-	cursor.advance();
-	while (read) switch (cursor.peek()) {
-		case 96:
-			interpolation = addCharacter(cursor, interpolation);
-			if (cursor.peek() === 125) {
-				cursor.advance();
-				const previousState = context.history.pop();
-				let state;
-				switch (previousState) {
-					case LexerState.ATTRIBUTE:
-						if (cursor.peek() !== 34) throw new Error(`Attribute interpolation expression must end with double quotes at ${cursor.formattedPosition}`);
-						cursor.advance();
-						state = LexerState.TAG_BODY;
-						break;
-					case LexerState.TEXT: state = LexerState.TEXT;
-				}
-				retVal = {
-					state,
-					tokens: [{
-						type: TokenType.INTERPOLATION_LITERAL,
-						parts: [interpolation]
-					}],
-					popState: true
-				};
-				read = false;
-			} else interpolation = `${interpolation}${cursor.currentChar.value}`;
-			break;
-		default: interpolation = addCharacter(cursor, interpolation);
-	}
-	return retVal;
-}
-/**
-* Advances the cursor by one character and appends it to the accumulator string.
-*
-* @param cursor - The lexer cursor to advance.
-* @param interpolation - The current accumulated expression string.
-* @returns The updated string with the newly consumed character appended.
-*/
-function addCharacter(cursor, interpolation) {
-	cursor.advance();
-	return `${interpolation}${cursor.currentChar.value}`;
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-interpolation.state.ts
-/**
-* Dispatches between an expression and a literal interpolation after the opening `{`.
-* Advances past `{` and any leading spaces, then inspects the next character:
-* a backtick routes to INTERPOLATION_LITERAL, a JS identifier start routes to INTERPOLATION_EXPRESSION.
-*
-* @param cursor - The lexer cursor positioned on the `{` character.
-* @param _context - Unused lexer context.
-* @returns Transition result with the appropriate interpolation sub-state.
-*/
-function lexInterpolation(cursor, _context) {
-	cursor.advance();
-	cursor.skipSpaces();
-	return cursor.peek() === 96 ? { state: LexerState.INTERPOLATION_LITERAL } : { state: LexerState.INTERPOLATION_EXPRESSION };
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-tag-body.state.ts
-/**
-* Scans the body of an open tag to determine what comes next:
-* an event binding (`@`), an attribute, the end of the tag (`>` or `/`), or whitespace.
-* Transitions to the appropriate state without emitting any tokens.
-*
-* @param cursor - The lexer cursor positioned inside a tag body.
-* @param _context - Unused lexer context.
-* @returns Transition result with the next state and no tokens.
-*/
-function lexTagBody(cursor, _context) {
-	let read = true;
-	let retVal;
-	while (read) switch (cursor.peek()) {
-		case 64:
-			retVal = { state: LexerState.EVENT };
-			read = false;
-			break;
-		case 32:
-			cursor.skipSpaces();
-			break;
-		case 62:
-		case 47:
-			retVal = { state: LexerState.TAG_OPEN_END };
-			read = false;
-			break;
-		default:
-			retVal = { state: LexerState.ATTRIBUTE };
-			read = false;
-	}
-	return retVal;
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-tag-close.state.ts
-/**
-* Consumes a closing tag `</tagName>`, skipping the `</` prefix and any surrounding
-* whitespace. Emits a TAG_CLOSE_NAME token with the tag name and transitions to TEXT.
-*
-* @param cursor - The lexer cursor positioned at the `<` of a closing tag.
-* @param _context - Unused lexer context.
-* @returns Transition result with the TAG_CLOSE_NAME token and the TEXT state.
-*/
-function lexTagClose(cursor, _context) {
-	let read = true;
-	let tagName = "";
-	let retVal;
-	cursor.advance(2);
-	cursor.skipSpaces();
-	while (read) switch (cursor.peek()) {
-		case 62:
-			cursor.advance();
-			retVal = {
-				state: LexerState.TEXT,
-				tokens: [{
-					type: TokenType.TAG_CLOSE_NAME,
-					parts: [tagName]
-				}]
-			};
-			read = false;
-			break;
-		case 32: throw new Error("Tag Close Name cannot contains spaces");
-		default:
-			cursor.advance();
-			tagName = `${tagName}${cursor.currentChar.value}`;
-	}
-	return retVal;
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-tag-open-end.state.ts
-/**
-* Consumes the closing characters of an open tag: `>` emits TAG_OPEN_END and
-* transitions to TEXT, while `/>` emits TAG_SELF_CLOSE and also transitions to TEXT.
-*
-* @param cursor - The lexer cursor positioned at `>` or `/`.
-* @param _context - Unused lexer context.
-* @returns Transition result with TAG_OPEN_END or TAG_SELF_CLOSE and the TEXT state.
-*/
-function lexTagOpenEnd(cursor, _context) {
-	let retVal;
-	if (cursor.peek() === 62) {
-		cursor.advance();
-		retVal = {
-			state: LexerState.TEXT,
-			tokens: [{
-				type: TokenType.TAG_OPEN_END,
-				parts: []
-			}]
-		};
-	} else {
-		cursor.advance();
-		const nextChar = cursor.peek();
-		if (nextChar === 62) {
-			cursor.advance();
-			retVal = {
-				state: LexerState.TEXT,
-				tokens: [{
-					type: TokenType.TAG_SELF_CLOSE,
-					parts: []
-				}]
-			};
-		} else throw new Error(`Unexpected character ${nextChar} for closing tag.\nExpected />\nRead of /${String.fromCharCode(nextChar)} at ${cursor.formattedPosition}`);
-	}
-	return retVal;
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-tag-open-name.state.ts
-/**
-* Consumes an opening tag name after `<`, reading until a space, `/`, or `>` is found.
-* Emits a TAG_OPEN_NAME token with the tag name and transitions to TAG_BODY.
-*
-* @param cursor - The lexer cursor positioned at the `<` character.
-* @param _context - Unused lexer context.
-* @returns Transition result with the TAG_OPEN_NAME token and the TAG_BODY state.
-*/
-function lexTagOpenName(cursor, _context) {
-	let read = true;
-	let tagName = "";
-	let retVal;
-	cursor.advance();
-	cursor.skipSpaces();
-	while (read) switch (cursor.peek()) {
-		case 32:
-		case 47:
-		case 62:
-			retVal = {
-				state: LexerState.TAG_BODY,
-				tokens: [{
-					type: TokenType.TAG_OPEN_NAME,
-					parts: [tagName]
-				}]
-			};
-			read = false;
-			break;
-		default:
-			cursor.advance();
-			tagName = `${tagName}${cursor.currentChar.value}`;
-	}
-	return retVal;
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/utils/chars.utils.ts
-/**
-* Checks whether a string contains at least one non-whitespace character.
-*
-* Whitespace characters include space, `\n`, `\r`, `\t`, `\f`, and `\v`.
-*
-* @param str - The string to check.
-* @returns `true` if the string is not blank, `false` if it consists entirely of whitespace.
-*/
-function isNotBlank(str) {
-	return /\S/.test(str);
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/states/lex-text.state.ts
-/**
-* Consumes plain text content, accumulating characters until a structural boundary
-* is reached: `<` (tag open/close), `{` (interpolation), `@` (flow-control or event),
-* or `}` (block close). Emits a TEXT token if non-blank text was accumulated.
-*
-* @param cursor - The lexer cursor positioned at the start of text content.
-* @param context - The lexer context used to detect flow-control block boundaries.
-* @returns Transition result with an optional TEXT token and the next state.
-*/
-function lexText(cursor, context) {
-	let read = true;
-	let text = "";
-	let retVal;
-	while (read) switch (cursor.peek()) {
-		case 60:
-			retVal = { state: cursor.peek(1, { offset: 1 }) === 47 ? LexerState.TAG_CLOSE : LexerState.TAG_OPEN_NAME };
-			read = false;
-			break;
-		case 123:
-			retVal = {
-				state: LexerState.INTERPOLATION,
-				pushState: true
-			};
-			read = false;
-			break;
-		case 64:
-			retVal = { state: LexerState.FLOW_CONTROL };
-			read = false;
-			break;
-		case 125:
-			if (context.history[context.history.length - 1] === LexerState.FLOW_CONTROL_BLOCK) {
-				cursor.advance();
-				retVal = {
-					state: LexerState.TEXT,
-					tokens: [{ type: TokenType.BLOCK_CLOSE }],
-					popState: true
-				};
-				read = false;
-			} else {
-				cursor.advance();
-				text = `${text}${cursor.currentChar.value}`;
-			}
-			break;
-		case 10:
-		case 13:
-			cursor.advance();
-			break;
-		default:
-			cursor.advance();
-			text = `${text}${cursor.currentChar.value}`;
-	}
-	retVal.tokens ??= isNotBlank(text) ? [{
-		type: TokenType.TEXT,
-		parts: [text]
-	}] : void 0;
-	return retVal;
-}
-//#endregion
-//#region ../packages/compiler/src/lexer/types/lexer-cursor.model.ts
-/**
-* Cursor abstraction used by the Lexer to navigate the input source.
-*
-* The LexerCursor is responsible for:
-* - Sequential character consumption
-* - Lookahead (peek) operations without state mutation
-* - Tracking logical position (row, column)
-* - Handling end-of-file conditions
-*
-* This class deliberately contains **no lexer logic**:
-* it does not know about tokens, states, or grammar rules.
-* Its sole responsibility is controlled navigation of the input stream.
-*/
-var LexerCursor = class {
-	input;
-	/**
-	* Representation of the current character.
-	*
-	* - `index`: absolute index within the input string
-	* - `code`: Unicode code point of the character
-	* - `value`: actual character value
-	*
-	* An index of `-1` indicates that the cursor has not yet consumed
-	* any character or has reached EOF.
-	*/
-	_currentChar = {
-		code: 0,
-		index: -1,
-		value: ""
-	};
-	/**
-	* Returns a read-only snapshot of the current character.
-	*/
-	get currentChar() {
-		return this._currentChar;
-	}
-	/**
-	* Cache used by peek operations to avoid re-reading
-	* the same character positions multiple times.
-	*
-	* Key: absolute character index
-	* Value: Unicode code point
-	*/
-	_peekCache = /* @__PURE__ */ new Map();
-	/**
-	* Logical position of the cursor in the input.
-	*
-	* - `row`: zero-based line number
-	* - `column`: zero-based column number
-	*/
-	_position = {
-		row: 0,
-		column: 0
-	};
-	/**
-	* Returns a read-only snapshot of the current cursor position.
-	*/
-	get position() {
-		return this._position;
-	}
-	get formattedPosition() {
-		return `[Ln ${this._position.row}, Col ${this._position.column}]`;
-	}
-	/**
-	* Creates a new cursor for the given input source.
-	*
-	* @param input - Full source string to be tokenised.
-	*/
-	constructor(input) {
-		this.input = input;
-	}
-	/**
-	* Advances the cursor by the specified number of characters.
-	*
-	* This method:
-	* - Updates the current character
-	* - Updates row/column position
-	* - Detects line breaks (LF / CR)
-	* - Throws an EOF error when the end of the input is reached
-	*
-	* @param chars - Number of characters to consume. Must be >= 1.
-	* @throws When `chars` is less than 1 or when advancing past the end of the input.
-	*/
-	advance(chars = 1) {
-		if (chars < 1) throw new Error(`${chars} is not a valid value. Please enter a number equal or greater than 1`);
-		const newIndex = this._currentChar.index + chars;
-		if (newIndex >= this.input.length) {
-			this._currentChar.code = 0;
-			this._currentChar.index = -1;
-			this._currentChar.value = "";
-			this.throwEOFError();
-		} else {
-			if ([10, 13].includes(this._currentChar.code)) {
-				this._position.row++;
-				this._position.column = 0;
-			} else this._position.column++;
-			this._currentChar.index = newIndex;
-			this._currentChar.value = this.input[newIndex];
-			this._currentChar.code = this.input.charCodeAt(newIndex);
-		}
-	}
-	peekMatch(pattern, length) {
-		if (typeof pattern === "string") {
-			const peekedChars = this.peek(pattern.length);
-			for (let i = 0; i < pattern.length; i++) if (peekedChars[i] !== pattern.charCodeAt(i)) return false;
-			return true;
-		}
-		const start = this._currentChar.index + 1;
-		const slice = this.input.slice(start, start + length);
-		return pattern.test(slice);
-	}
-	peek(charsOrOptions, options) {
-		const cache = this._peekCache;
-		const chars = typeof charsOrOptions === "number" ? charsOrOptions : 1;
-		const offset = (typeof charsOrOptions === "object" ? charsOrOptions : options)?.offset ?? 0;
-		return chars === 1 ? this.peekOneChar(this._currentChar.index + offset + 1, cache) : this.peekMany(chars + offset, cache);
-	}
-	/**
-	* Skips all consecutive space characters from the current position.
-	*/
-	skipSpaces() {
-		while (this.peek() === 32 || this.peek() === 10 || this.peek() === 13) this.advance();
-	}
-	/**
-	* Peeks multiple characters ahead.
-	*/
-	peekMany(chars, cache) {
-		const peekedChars = new Array();
-		const nextCharIndex = this._currentChar.index + 1;
-		for (let i = nextCharIndex; i < nextCharIndex + chars; i++) peekedChars.push(this.peekOneChar(i, cache));
-		return peekedChars;
-	}
-	/**
-	* Peeks a single character at the given absolute index.
-	*/
-	peekOneChar(index, cache) {
-		if (cache.has(index)) return cache.get(index);
-		if (index >= this.input.length) this.throwEOFError();
-		const charCode = this.input.charCodeAt(index);
-		cache.set(index, charCode);
-		return charCode;
-	}
-	/**
-	* Throws a standardized EOF error used by the lexer engine
-	* to terminate tokenization.
-	*/
-	throwEOFError() {
-		throw new Error("", { cause: 0 });
-	}
-};
-//#endregion
-//#region ../packages/compiler/src/lexer/lexer.ts
-/**
-* Utility class that emulates a cursor navigating through a template string.
-*
-* The cursor keeps track of the current character, its absolute position
-* within the text, and its logical position expressed as row and column.
-* This is useful when parsing or analyzing template content character by character.
-*/
-var Lexer = class {
-	input;
-	/**
-	* Cursor for navigating the input character stream.
-	*/
-	_cursor;
-	/**
-	* Current lexer state.
-	*/
-	_state = LexerState.TEXT;
-	/**
-	* State stack used to support nested states (e.g. interpolations).
-	*/
-	_stack = new Stack();
-	/**
-	* Accumulated list of tokens emitted during tokenization.
-	*/
-	_tokens = new Array();
-	/**
-	* Maps each lexer state to its corresponding transition function.
-	*/
-	_states = {
-		[LexerState.TEXT]: lexText,
-		[LexerState.TAG_OPEN_NAME]: lexTagOpenName,
-		[LexerState.TAG_BODY]: lexTagBody,
-		[LexerState.TAG_OPEN_END]: lexTagOpenEnd,
-		[LexerState.TAG_CLOSE]: lexTagClose,
-		[LexerState.ATTRIBUTE]: lexAttribute,
-		[LexerState.ATTRIBUTE_VALUE]: lexAttributeValue,
-		[LexerState.EVENT]: lexEvent,
-		[LexerState.EVENT_PARAMETER]: lexEventParameter,
-		[LexerState.FLOW_CONTROL]: lexFlowControl,
-		[LexerState.FLOW_CONTROL_CONDITION]: lexDefaultFlowControlCondition,
-		[LexerState.CASE_FLOW_CONTROL_CONDITION]: lexCaseFlowControlCondition,
-		[LexerState.FLOW_CONTROL_BLOCK]: lexFlowControlBlock,
-		[LexerState.INTERPOLATION]: lexInterpolation,
-		[LexerState.INTERPOLATION_EXPRESSION]: lexInterpolationExpression,
-		[LexerState.INTERPOLATION_LITERAL]: lexInterpolationliteral,
-		[LexerState.IMPORT]: lexImport,
-		[LexerState.IMPORT_PATH]: lexImportPath
-	};
-	/**
-	* Creates a new Lexer instance for the given template content.
-	*
-	* @param input - The full template text to tokenise.
-	*/
-	constructor(input) {
-		this.input = input;
-		this._cursor = new LexerCursor(this.input);
-	}
-	/**
-	* Runs the lexer over the input string and returns the full token array.
-	* Drives the state machine until EOF is reached.
-	*
-	* @returns Array of all tokens produced from the input.
-	*/
-	tokenize() {
-		let eof = false;
-		while (!eof) try {
-			const transitionFunction = this._states[this._state];
-			const { state, tokens, popState, pushState } = transitionFunction(this._cursor, {
-				history: this._stack.values,
-				tokens: [...this._tokens]
-			});
-			if (tokens?.length) this._tokens.push(...tokens);
-			if (pushState) this._stack.push(this._state);
-			if (popState) this._stack.pop();
-			this._state = state;
-		} catch (err) {
-			if (err.cause === 0) eof = true;
-			else {
-				console.log(`Something went wrong while computing state ${this._state} at ${this._cursor.formattedPosition}`);
-				throw err;
-			}
-		}
-		return this._tokens;
-	}
-};
-//#endregion
-//#region ../packages/compiler/src/parser/models/parser-cursor.model.ts
-/**
-* Cursor abstraction used by the Parser to navigate
-* through a sequence of tokens produced by the Lexer.
-*
-* Responsibilities:
-* - Sequential token consumption
-* - Lookahead (peek) operations without mutating state
-* - Handling end-of-file conditions
-*
-* This class does not perform parsing itself: it only
-* manages position and access to the token stream.
-*/
-var ParserCursor = class {
-	_tokens;
-	/**
-	* Representation of the current token.
-	*
-	* - `index`: absolute index within the token array
-	* - `value`: current token object (or EOF token)
-	*
-	* An index of `-1` indicates that the cursor has not
-	* yet consumed any token or has reached EOF.
-	*/
-	_currentToken = {
-		value: { type: TokenType.EOF },
-		index: -1
-	};
-	/**
-	* Returns a read-only snapshot of the current token.
-	*/
-	getCurrentToken() {
-		return this._currentToken;
-	}
-	/**
-	* Creates a new ParserCursor for the given token array.
-	*
-	* @param _tokens - The array of tokens to navigate.
-	*/
-	constructor(_tokens) {
-		this._tokens = _tokens;
-	}
-	/**
-	* Advances the cursor by the specified number of tokens.
-	*
-	* Updates the current token and its index.
-	*
-	* @param chars - Number of tokens to advance. Must be >= 1.
-	* @throws When `chars` is less than 1.
-	*/
-	advance(chars = 1) {
-		if (chars < 1) throw new Error(`${chars} is not a valid value. Please enter a number equal or greater than 1`);
-		const newIndex = this._currentToken.index + chars;
-		if (newIndex >= this._tokens.length) {
-			this._currentToken.value = { type: TokenType.EOF };
-			this._currentToken.index = -1;
-		} else {
-			this._currentToken.index = newIndex;
-			this._currentToken.value = this._tokens[newIndex];
-		}
-	}
-	peek(charsOrOptions, options) {
-		const tokens = typeof charsOrOptions === "number" ? charsOrOptions : 1;
-		const offset = (typeof charsOrOptions === "object" ? charsOrOptions : options)?.offset ?? 0;
-		return tokens === 1 ? this.peekOneToken(this._currentToken.index + offset + 1) : this.peekMany(tokens + offset);
-	}
-	/**
-	* Peeks multiple tokens ahead.
-	*/
-	peekMany(chars) {
-		const peekedTokens = new Array();
-		const nextTokenIndex = this._currentToken.index + 1;
-		for (let i = nextTokenIndex; i < nextTokenIndex + chars; i++) peekedTokens.push(this.peekOneToken(i));
-		return peekedTokens;
-	}
-	/**
-	* Peeks a single token at the given absolute index.
-	*/
-	peekOneToken(index) {
-		return index < this._tokens.length ? this._tokens[index] : { type: TokenType.EOF };
-	}
-};
-//#endregion
-//#region ../packages/compiler/src/parser/utils/expression-validator.ts
-/**
-* Validates that a string contains a single expression belonging to the
-* permitted subset of JavaScript supported inside Xaendar template expressions.
-*
-* ## Permitted constructs
-*
-* - **Literals** — strings, numbers, bigints, booleans, `null`, `undefined`
-* - **Identifiers** — resolved at runtime against the active scope chain
-* - **Member access** — `user.name`, `user.address.city`, `items[0]`
-* - **Call expressions** — `user.getFullName()`, `user.hasRole('admin')`
-* - **Binary expressions** — arithmetic (`+`, `-`, `*`, `/`, `%`, `**`),
-*   comparison (`===`, `!==`, `<`, `>`, `<=`, `>=`),
-*   logical (`&&`, `||`, `??`),
-*   bitwise (`&`, `|`, `^`, `<<`, `>>`, `>>>`)
-* - **Unary expressions** — `!`, `~`, `+`, `-`, `typeof`, `void`
-* - **Conditional (ternary)** — `isAdmin ? 'yes' : 'no'`
-* - **Parenthesised expressions** — `(user.age > 18)`
-* - **Template literals** — `` `Hello ${user.name}` ``
-* - **Array literals** — `[1, 2, 3]`, `[...items]`
-* - **Object literals** — `{ key: value }`, `{ ...defaults, name }`
-* - **Spread** — `foo(...args)`, `[...items]`, `{ ...obj }`
-* - **`typeof` / `instanceof`** — `typeof user.role`, `user instanceof AdminUser`
-*
-* ## Prohibited constructs
-*
-* - Assignments (`=`, `+=`, `&&=`, etc.) — use `@const` for local bindings
-* - `await` and `yield`
-* - `new` expressions
-* - Function and arrow function expressions
-* - Tagged template expressions
-*
-* ## Scope resolution
-*
-* This function performs **syntactic** validation only. Identifier resolution
-* (scope chain walk → `ctx.` prefix injection) is the responsibility of the
-* caller and must be performed on the returned `node` after this function
-* reports no diagnostics.
-*
-* @param source - The raw expression string extracted from the template.
-* @returns A {@link ExpressionValidationResult} containing the parsed AST node
-*   (when valid) and any diagnostics produced during validation.
-*
-* @example
-* const result = validateExpression('user.hasRole("admin") && isVerified');
-* if (result.diagnostics.length === 0) {
-*   // result.node is safe to use
-* }
-*
-* @example
-* const result = validateExpression('await user.load()');
-* // result.diagnostics[0].message →
-* //   "'await' is not allowed inside template expressions."
-*/
-function validateExpression(source) {
-	const expression = createSourceFile("expression.ts", `const x = ${source}`, ScriptTarget.ESNext, true).statements[0].declarationList.declarations[0].initializer;
-	const diagnostics = new Array();
-	visitNode(expression, 10, diagnostics);
-	if (diagnostics.length) throw new Error(diagnostics.reduce((acc, d) => `${acc}${d.message}\n`, ""));
-	return { node: expression };
-}
-/**
-* Recursively visits an AST node and appends a diagnostic for every node
-* kind that is not part of the permitted expression subset.
-*
-* Recursion stops at the first disallowed node to avoid producing a cascade
-* of redundant diagnostics for its children.
-*
-* @param node - The AST node to inspect.
-* @param offset - Number of characters to subtract from raw node positions
-*   to obtain offsets relative to the original expression string.
-* @param diagnostics - Accumulator for diagnostics found during the walk.
-*/
-function visitNode(node, offset, diagnostics) {
-	if (!isAllowedNode(node)) throw new Error(buildDisallowedMessage(node));
-	forEachChild(node, (child) => visitNode(child, offset, diagnostics));
-	if (diagnostics.length) throw new Error(diagnostics[0].message);
-}
-/**
-* Returns `true` if the given AST node kind is permitted inside a
-* Xaendar template expression.
-*
-* Assignment operators nested inside a `BinaryExpression` are handled
-* separately in {@link buildDisallowedMessage} since TypeScript does not
-* distinguish them at the node-kind level.
-*/
-function isAllowedNode(node) {
-	switch (node.kind) {
-		case SyntaxKind.StringLiteral:
-		case SyntaxKind.NumericLiteral:
-		case SyntaxKind.BigIntLiteral:
-		case SyntaxKind.TrueKeyword:
-		case SyntaxKind.FalseKeyword:
-		case SyntaxKind.NullKeyword:
-		case SyntaxKind.UndefinedKeyword:
-		case SyntaxKind.Identifier:
-		case SyntaxKind.PropertyAccessExpression:
-		case SyntaxKind.ElementAccessExpression:
-		case SyntaxKind.CallExpression:
-		case SyntaxKind.BinaryExpression:
-		case SyntaxKind.EqualsEqualsToken:
-		case SyntaxKind.EqualsEqualsEqualsToken:
-		case SyntaxKind.ExclamationEqualsToken:
-		case SyntaxKind.ExclamationEqualsEqualsToken:
-		case SyntaxKind.LessThanToken:
-		case SyntaxKind.LessThanEqualsToken:
-		case SyntaxKind.GreaterThanToken:
-		case SyntaxKind.GreaterThanEqualsToken:
-		case SyntaxKind.PlusToken:
-		case SyntaxKind.MinusToken:
-		case SyntaxKind.AsteriskToken:
-		case SyntaxKind.SlashToken:
-		case SyntaxKind.PercentToken:
-		case SyntaxKind.AsteriskAsteriskToken:
-		case SyntaxKind.AmpersandAmpersandToken:
-		case SyntaxKind.BarBarToken:
-		case SyntaxKind.QuestionQuestionToken:
-		case SyntaxKind.QuestionDotToken:
-		case SyntaxKind.QuestionToken:
-		case SyntaxKind.ColonToken:
-		case SyntaxKind.AmpersandToken:
-		case SyntaxKind.BarToken:
-		case SyntaxKind.CaretToken:
-		case SyntaxKind.LessThanLessThanToken:
-		case SyntaxKind.GreaterThanGreaterThanToken:
-		case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
-		case SyntaxKind.InstanceOfKeyword:
-		case SyntaxKind.InKeyword:
-		case SyntaxKind.PrefixUnaryExpression:
-		case SyntaxKind.PostfixUnaryExpression:
-		case SyntaxKind.TypeOfExpression:
-		case SyntaxKind.VoidExpression:
-		case SyntaxKind.ConditionalExpression:
-		case SyntaxKind.ParenthesizedExpression:
-		case SyntaxKind.TemplateExpression:
-		case SyntaxKind.NoSubstitutionTemplateLiteral:
-		case SyntaxKind.TemplateHead:
-		case SyntaxKind.TemplateMiddle:
-		case SyntaxKind.TemplateTail:
-		case SyntaxKind.TemplateSpan:
-		case SyntaxKind.ArrayLiteralExpression:
-		case SyntaxKind.ObjectLiteralExpression:
-		case SyntaxKind.PropertyAssignment:
-		case SyntaxKind.ShorthandPropertyAssignment:
-		case SyntaxKind.SpreadAssignment:
-		case SyntaxKind.SpreadElement:
-		case SyntaxKind.TaggedTemplateExpression:
-		case SyntaxKind.SyntaxList: return true;
-		default: return false;
-	}
-}
-/**
-* Builds a human-readable diagnostic message for a node that is not permitted
-* inside a Xaendar template expression.
-*
-* Provides specific messages for the most common mistakes (assignments, `await`,
-* `new`, functions) and falls back to a generic message for anything else.
-*/
-function buildDisallowedMessage(node) {
-	switch (node.kind) {
-		case SyntaxKind.AwaitExpression: return "'await' is not allowed inside template expressions.";
-		case SyntaxKind.YieldExpression: return "'yield' is not allowed inside template expressions.";
-		case SyntaxKind.NewExpression: return "'new' is not allowed inside template expressions.";
-		case SyntaxKind.ArrowFunction:
-		case SyntaxKind.FunctionExpression: return "Function expressions are not allowed inside template expressions.";
-		case SyntaxKind.BinaryExpression: return isAssignmentOperator(node.operatorToken.kind) ? "Assignments are not allowed inside template expressions. Use @const to declare local template variables instead." : `'${SyntaxKind[node.kind]}' is not allowed inside template expressions.`;
-		default: return `'${SyntaxKind[node.kind]}' is not allowed inside template expressions.`;
-	}
-}
-/**
-* Returns `true` if the given {@link SyntaxKind} is an assignment operator.
-*
-* Covers simple assignment (`=`) as well as all compound assignment operators
-* (`+=`, `-=`, `&&=`, `||=`, `??=`, etc.) as defined by the TypeScript
-* `FirstAssignment`–`LastAssignment` range.
-*/
-function isAssignmentOperator(kind) {
-	return kind >= SyntaxKind.FirstAssignment && kind <= SyntaxKind.LastAssignment;
-}
-//#endregion
-//#region ../packages/compiler/src/parser/states/parse-interpolation.state.ts
-/**
-* Parses an interpolation expression or literal token into an `InterpolationNode`.
-*
-* @param cursor - Parser cursor; advanced past the interpolation token.
-* @param _parseNode - Unused parser function (kept for signature consistency).
-* @param token - The INTERPOLATION_EXPRESSION or INTERPOLATION_LITERAL token.
-* @returns The parsed `InterpolationNode`.
-*/
-function parseInterpolation(cursor, _parseNode, token) {
-	cursor.advance();
-	return {
-		type: ASTNodeType.Interpolation,
-		expression: validateExpression(token.parts[0]).node
-	};
-}
-//#endregion
-//#region ../packages/compiler/src/parser/states/parse-attribute.state.ts
-/**
-* Parses an ATTRIBUTE token into an `AttributeNode`.
-* Handles boolean attributes (no `=`), string values, and interpolation values.
-*
-* @param cursor - Parser cursor; advanced past the ATTRIBUTE token.
-* @param parseNode - Parser function for recursive child parsing.
-* @param token - The ATTRIBUTE token to parse.
-* @returns The parsed `AttributeNode`.
-*/
-function parseAttribute(cursor, parseNode, token) {
-	cursor.advance();
-	const name = token.parts[0];
-	const nextToken = cursor.peek();
-	if (nextToken.type === TokenType.ATTRIBUTE || nextToken.type === TokenType.TAG_CLOSE_NAME || nextToken.type === TokenType.EVENT) return {
-		name,
-		value: "true"
-	};
-	if (nextToken.type === TokenType.INTERPOLATION_EXPRESSION || nextToken.type === TokenType.INTERPOLATION_LITERAL) return {
-		name,
-		value: parseInterpolation(cursor, parseNode, nextToken)
-	};
-	if (nextToken.type !== TokenType.ATTRIBUTE_VALUE) throw new Error(`[Parser] Attribute value missing for ${name} in: ${name}`);
-	cursor.advance();
-	return {
-		name,
-		value: nextToken.parts[0]
-	};
-}
-//#endregion
-//#region ../packages/compiler/src/parser/states/parse-event.state.ts
-/**
-* Parses an EVENT token into an `EventNode` by splitting the raw
-* `eventName=handler` string.
-*
-* @param cursor - Parser cursor; advanced past the EVENT token.
-* @param _parseNode - Unused parser function (kept for signature consistency).
-* @param token - The EVENT token to parse.
-* @returns The parsed `EventNode`.
-*/
-function parseEvent(cursor, _parseNode, token) {
-	cursor.advance();
-	const raw = token.parts[0];
-	const [name, value] = raw.split("=");
-	if (!name || !value) throw new Error(`[Parser] Invalid event format: ${raw}`);
-	const parameters = new Array();
-	while (cursor.peek().type === TokenType.EVENT_PAREMETER) {
-		cursor.advance();
-		parameters.push(validateExpression(cursor.getCurrentToken().value.parts[0]).node);
-	}
-	return {
-		name,
-		handler: value.replace(/^[""]|[""]$/g, ""),
-		parameters
-	};
-}
-//#endregion
-//#region ../packages/compiler/src/parser/states/parse-element.state.ts
-/**
-* Parses a TAG_OPEN_NAME token and the subsequent attributes, events, and children
-* into an `ElementNode`. Handles both regular and self-closing tags.
-*
-* @param cursor - Parser cursor positioned at the TAG_OPEN_NAME token.
-* @param parseNode - Parser function for recursive child parsing.
-* @param token - The TAG_OPEN_NAME token containing the tag name.
-* @returns The parsed `ElementNode`.
-*/
-function parseElement(cursor, parseNode, token) {
-	cursor.advance();
-	const tagName = token.parts[0];
-	const attributes = new Array();
-	const events = new Array();
-	let read = true;
-	while (read) {
-		const token = cursor.peek();
-		switch (token.type) {
-			case TokenType.ATTRIBUTE:
-				attributes.push(parseAttribute(cursor, parseNode, token));
-				break;
-			case TokenType.EVENT:
-				events.push(parseEvent(cursor, parseNode, token));
-				break;
-			default: read = false;
-		}
-	}
-	if (cursor.peek().type === TokenType.TAG_OPEN_END) cursor.advance();
-	if (cursor.peek().type === TokenType.TAG_SELF_CLOSE) {
-		cursor.advance();
-		return {
-			type: ASTNodeType.Element,
-			tagName,
-			attributes,
-			events,
-			children: []
-		};
-	}
-	const children = new Array();
-	while (!isTagClose(cursor, tagName)) {
-		const child = parseNode();
-		if (child) children.push(child);
-	}
-	cursor.advance();
-	return {
-		type: ASTNodeType.Element,
-		tagName,
-		attributes,
-		events,
-		children
-	};
-}
-/**
-* Returns `true` if the next token in the stream is a closing tag for the given tag name.
-*
-* @param cursor - Parser cursor to peek from.
-* @param tagName - The expected tag name to match.
-* @returns `true` if the next token is TAG_CLOSE_NAME matching `tagName`.
-*/
-function isTagClose(cursor, tagName) {
-	const nextToken = cursor.peek();
-	return nextToken.type === TokenType.TAG_CLOSE_NAME && nextToken.parts[0] === tagName;
-}
-//#endregion
-//#region ../packages/compiler/src/parser/states/parse-block-children.state.ts
-/**
-* Parses child AST nodes inside a flow-control block until a BLOCK_CLOSE token is reached.
-* Consumes the BLOCK_CLOSE token before returning.
-*
-* @param cursor - Parser cursor positioned at the first token inside the block.
-* @param parseNode - Parser function for recursive child parsing.
-* @returns Array of parsed child `ASTNode`s.
-*/
-function parseBlockChildren(cursor, parseNode) {
-	const children = new Array();
-	while (cursor.peek().type !== TokenType.BLOCK_CLOSE) {
-		const child = parseNode();
-		if (child) children.push(child);
-	}
-	cursor.advance();
-	return children;
-}
-//#endregion
-//#region ../packages/compiler/src/parser/states/parse-for.state.ts
-/**
-* Parses a `@for` directive, consuming the FOR token, the CONDITION token,
-* the BLOCK_OPEN token, and all child nodes until BLOCK_CLOSE.
-*
-* @param cursor - Parser cursor positioned at the FOR token.
-* @param parseNode - Parser function for recursive child parsing.
-* @param _token - The FOR token (consumed for position advancement).
-* @returns The parsed `ForNode`.
-*/
-function parseForControlFlow(cursor, parseNode, _token) {
-	cursor.advance();
-	const conditionToken = cursor.peek();
-	if (conditionToken.type !== TokenType.CONDITION) throw new Error(`[Parser] Expected CONDITION after FOR, got ${TokenType[conditionToken.type]}`);
-	const expression = parseForExpression(conditionToken.parts[0], 0);
-	cursor.advance(2);
-	const children = parseBlockChildren(cursor, parseNode);
-	return {
-		type: ASTNodeType.For,
-		...expression,
-		children
-	};
-}
-/**
-* Parses the body of an `@for` block into a structured {@link ForExpression}.
-*
-* The expected format is:
-* ```
-* item of iterable; track expr[; $implicit = alias, ...]
-* ```
-*
-* @param source     - The raw string content of the `@for(...)` expression.
-* @param baseOffset - Character offset of `source` within the original template,
-*                     used to produce accurate diagnostic positions.
-* @returns A {@link ForExpression} object. When unrecoverable syntax errors are
-*          found the returned object contains only `diagnostics`.
-*/
-function parseForExpression(source, baseOffset) {
-	const sections = splitForSections(source);
-	if (sections.length < 2) throw new Error(`[Parser] @for requires at least "item of iterable; track expr".`);
-	const iterSection = sections[0].trim();
-	const ofIndex = iterSection.indexOf(" of ");
-	if (ofIndex === -1) throw new Error(`[Parser] @for expression must be in the form "item of iterable".`);
-	const itemAlias = iterSection.slice(0, ofIndex).trim();
-	const iterableSource = iterSection.slice(ofIndex + 4).trim();
-	if (!isValidIdentifier(itemAlias)) throw new Error(`[Parser] '${itemAlias}' is not a valid item alias.`);
-	const iterValidation = validateExpression(iterableSource);
-	const trackSection = sections[1].trim();
-	if (!trackSection.startsWith("track ")) throw new Error(`[Parser] Second section of @for must start with "track".`);
-	const trackSource = trackSection.slice(6).trim();
-	const trackValidation = validateExpression(trackSource);
-	const implicitAliases = /* @__PURE__ */ new Map();
-	if (sections.length >= 3 && sections[2] !== void 0) parseImplicitAliases(sections[2].trim(), baseOffset + source.indexOf(sections[2]), implicitAliases);
-	return {
-		itemAlias,
-		iterableExpression: iterValidation.node,
-		iterableSource,
-		trackExpression: trackValidation.node,
-		trackSource,
-		implicitAliases
-	};
-}
-/**
-* Parses the optional third section of an `@for` expression, which declares
-* aliases for implicit loop variables (e.g. `$index = i, $last = l, $even = isEven`).
-*
-* Valid entries are comma-separated pairs in the form `$implicit = alias`.
-*
-* @param source - The raw alias-declarations string (everything after the second `;`).
-* @param baseOffset - Character offset of `source` within the original template.
-* @param out - Map to populate with `alias → implicit-variable` entries.
-*/
-function parseImplicitAliases(source, baseOffset, out) {
-	const entries = source.split(",");
-	let cursor = 0;
-	const IMPLICIT_VARIABLES = /* @__PURE__ */ new Set([
-		"$index",
-		"$last",
-		"$first",
-		"$even",
-		"$odd"
-	]);
-	for (const entry of entries) {
-		const trimmed = entry.trim();
-		const eqIndex = trimmed.indexOf("=");
-		if (eqIndex === -1) throw new Error(`[Parser] Invalid alias declaration '${trimmed}'. Expected '$implicit = alias'.`);
-		cursor += entry.length + 1;
-		const alias = trimmed.slice(0, eqIndex).trim();
-		const implicit = trimmed.slice(eqIndex + 1).trim();
-		const isImplicitVariable = (value) => IMPLICIT_VARIABLES.has(value);
-		if (!isImplicitVariable(implicit)) throw new Error(`[Parser] '${implicit}' is not a known implicit variable. Known variables: ${[...IMPLICIT_VARIABLES].join(", ")}.`);
-		cursor += entry.length + 1;
-		if (!isValidIdentifier(alias)) throw new Error(`[Parser] '${alias}' is not a valid alias identifier.`);
-		cursor += entry.length + 1;
-		if (out.has(implicit)) throw new Error(`[Parser] '${implicit}' is already aliased in this @for expression.`);
-		else out.set(implicit, alias);
-		cursor += entry.length + 1;
-	}
-}
-/**
-* Splits the raw `@for(...)` body into its semicolon-delimited sections,
-* respecting nested brackets and string literals so that semicolons inside
-* them are never treated as section separators.
-*
-* Example input:  `"item of items; track item.id; $index = i"`
-* Example output: `["item of items", " track item.id", " $index = i"]`
-*
-* @param source - The raw content of the `@for(...)` expression.
-* @returns An array of section strings (without the `;` separators).
-*/
-function splitForSections(source) {
-	const sections = new Array();
-	let current = "";
-	let depth = 0;
-	let inString;
-	for (let i = 0; i < source.length; i++) {
-		const char = source[i];
-		if (!current && char === " ") continue;
-		if (inString) {
-			current += char;
-			if (char === inString && source[i - 1] !== "\\") inString = null;
-			continue;
-		}
-		if (char === "\"" || char === "'" || char === "`") {
-			inString = char;
-			current += char;
-			continue;
-		}
-		if (char === "(" || char === "[" || char === "{") {
-			depth++;
-			current += char;
-			continue;
-		}
-		if (char === ")" || char === "]" || char === "}") {
-			depth--;
-			current += char;
-			continue;
-		}
-		if (char === ";" && depth === 0) {
-			sections.push(current);
-			current = "";
-			continue;
-		}
-		current += char;
-	}
-	if (current.trim().length) sections.push(current);
-	return sections;
-}
-/**
-* Checks whether `name` is a valid JavaScript identifier by delegating to
-* the TypeScript parser.
-*
-* A string is considered valid when the TS parser produces a single
-* `ExpressionStatement` whose expression is an `Identifier` with the
-* same text.
-*
-* @param name - The string to validate.
-* @returns `true` if `name` is a valid JS identifier, `false` otherwise.
-*/
-function isValidIdentifier(name) {
-	if (!name.length) return false;
-	const statement = createSourceFile("__id.ts", name, ScriptTarget.ESNext, false).statements[0];
-	return !!statement && isExpressionStatement(statement) && isIdentifier(statement.expression) && statement.expression.text === name;
-}
-//#endregion
-//#region ../packages/compiler/src/parser/states/parse-if.state.ts
-/**
-* Parses an `@if` directive, consuming the IF token, the CONDITION token,
-* the BLOCK_OPEN token, all consequent children, and an optional `@else` branch.
-*
-* @param cursor - Parser cursor positioned at the IF token.
-* @param context - Parser function for recursive child parsing.
-* @param token - The IF token (consumed for position advancement).
-* @returns The parsed `IfNode`.
-*/
-function parseIfControlFlow(cursor, parseNode, token) {
-	return parseIfOrElseIf(cursor, parseNode, token);
-}
-function parseElseIfRecursively(cursor, parseNode, token) {
-	switch (token.type) {
-		case TokenType.ELSE_IF: return parseIfOrElseIf(cursor, parseNode, token);
-		case TokenType.ELSE:
-			cursor.advance(2);
-			const elseChildren = parseBlockChildren(cursor, parseNode);
-			return {
-				type: ASTNodeType.Else,
-				children: elseChildren
-			};
-	}
-}
-function parseIfOrElseIf(cursor, parseNode, token) {
-	cursor.advance();
-	const conditionToken = cursor.peek();
-	if (conditionToken.type !== TokenType.CONDITION) throw new Error(`[Parser] Expected CONDITION after ${TokenType[token.type]}, got ${TokenType[conditionToken.type]}`);
-	cursor.advance(2);
-	const condition = conditionToken.parts[0];
-	const validationResult = validateExpression(condition);
-	const consequent = parseBlockChildren(cursor, parseNode);
-	return {
-		type: token.type === TokenType.IF ? ASTNodeType.If : ASTNodeType.ElseIf,
-		condition,
-		conditionNode: validationResult.node,
-		children: consequent,
-		alternate: parseElseIfRecursively(cursor, parseNode, cursor.peek())
-	};
-}
-//#endregion
-//#region ../packages/compiler/src/parser/states/parse-import.state.ts
-/**
-* Parses an `@import` statement.
-*
-* Extracts specifiers with optional aliases and maps them to structured
-* `ImportSpecifier` objects. Supports:
-* - `foo` → imported: 'foo', local: 'foo'
-* - `foo as bar` → imported: 'foo', local: 'bar'
-* - `default as D` → imported: 'default', local: 'D'
-* - `* as ns` → imported: '*', local: 'ns'
-*/
-function parseImport(cursor, _parseNode, _token) {
-	const specifiers = new Array();
-	while (cursor.peek().type === TokenType.IMPORT) {
-		cursor.advance();
-		const rawSpecifier = cursor.getCurrentToken().value.parts[0];
-		const specifier = parseSpecifier(rawSpecifier);
-		specifiers.push(specifier);
-	}
-	cursor.advance();
-	return {
-		type: ASTNodeType.Import,
-		specifiers,
-		path: cursor.getCurrentToken().value.parts[0]
-	};
-}
-/**
-* Parses a single import specifier string.
-*
-* @param raw - The raw specifier string (may include 'as' alias).
-* @returns An `ImportSpecifier` with `imported` and `local` fields.
-* @throws If the specifier format is invalid.
-*/
-function parseSpecifier(raw) {
-	const trimmed = raw.trim();
-	const namespaceMatch = trimmed.match(/^\*\s+as\s+([A-Za-z_$][\w$]*)$/);
-	if (namespaceMatch) return {
-		imported: "*",
-		local: namespaceMatch[1]
-	};
-	const defaultMatch = trimmed.match(/^default\s+as\s+([A-Za-z_$][\w$]*)$/);
-	if (defaultMatch) return {
-		imported: "default",
-		local: defaultMatch[1]
-	};
-	const namedMatch = trimmed.match(/^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
-	if (namedMatch) return {
-		imported: namedMatch[1],
-		local: namedMatch[2] ?? namedMatch[1]
-	};
-	throw new Error(`[Parser] Invalid import specifier "${raw}".`);
-}
-//#endregion
-//#region ../packages/compiler/src/parser/states/parse-switch.state.ts
-/**
-* Parses a `@switch` directive, consuming the SWITCH token, the CONDITION token,
-* the outer BLOCK_OPEN, all `@case` and `@default` branches, and the outer BLOCK_CLOSE.
-*
-* @param cursor - Parser cursor positioned at the SWITCH token.
-* @param parseNode - Parser function for recursive child parsing.
-* @param _token - The SWITCH token (consumed for position advancement).
-* @returns The parsed `SwitchNode`.
-*/
-function parseSwitchControlFlow(cursor, parseNode, _token) {
-	cursor.advance();
-	const conditionToken = cursor.peek();
-	if (conditionToken.type !== TokenType.CONDITION) throw new Error(`[Parser] Expected CONDITION after SWITCH, got ${TokenType[conditionToken.type]}`);
-	const expression = validateExpression(conditionToken.parts[0]).node;
-	cursor.advance(2);
-	const cases = new Array();
-	while (cursor.peek().type !== TokenType.BLOCK_CLOSE) switch (cursor.peek().type) {
-		case TokenType.CASE:
-			const condition = new Array();
-			do {
-				cursor.advance();
-				const caseCondition = cursor.peek();
-				if (caseCondition.type !== TokenType.CONDITION) throw new Error(`[Parser] Expected CONDITION after CASE`);
-				condition.push(caseCondition.parts[0]);
-				cursor.advance();
-			} while (cursor.peek().type !== TokenType.BLOCK_OPEN);
-			cursor.advance();
-			cases.push({
-				type: ASTNodeType.Case,
-				condition,
-				children: parseBlockChildren(cursor, parseNode)
-			});
-			break;
-		case TokenType.DEFAULT:
-			cursor.advance(2);
-			cases.push({
-				type: ASTNodeType.Case,
-				condition: null,
-				children: parseBlockChildren(cursor, parseNode)
-			});
-			break;
-	}
-	cursor.advance();
-	return {
-		type: ASTNodeType.Switch,
-		expression,
-		children: cases
-	};
-}
-//#endregion
-//#region ../packages/compiler/src/parser/states/parse-text.state.ts
-/**
-* Parses a TEXT token into a `TextNode`.
-*
-* @param cursor - Parser cursor; advanced past the TEXT token.
-* @param _parseNode - Unused parser function (kept for signature consistency).
-* @param token - The TEXT token containing the raw text content.
-* @returns The parsed `TextNode`.
-*/
-function parseText(cursor, _parseNode, token) {
-	cursor.advance();
-	return {
-		type: ASTNodeType.Text,
-		value: token.parts[0]
-	};
-}
-//#endregion
-//#region ../packages/compiler/src/parser/parser.ts
-/**
-* Parser class that transforms a stream of tokens (from the Lexer)
-* into an Abstract Syntax Tree (AST) representing the template structure.
-*
-* Responsibilities:
-* - Parse text nodes, elements, attributes, events, and interpolations
-* - Maintain cursor state for sequential token consumption
-* - Detect tag boundaries and nested structures
-*
-* The parser assumes that the token stream is syntactically valid according
-* to the Lexer rules. Parsing errors are thrown as exceptions.
-*/
-var Parser = class {
-	/**
-	* Internal cursor for navigating tokens
-	*/
-	_cursor;
-	/**
-	* Mapping of token types to their corresponding parser transition functions, 
-	* which handle the logic for parsing each token type into AST nodes.
-	*/
-	_states = {
-		[TokenType.TEXT]: parseText,
-		[TokenType.INTERPOLATION_EXPRESSION]: parseInterpolation,
-		[TokenType.INTERPOLATION_LITERAL]: parseInterpolation,
-		[TokenType.TAG_OPEN_NAME]: parseElement,
-		[TokenType.IF]: parseIfControlFlow,
-		[TokenType.FOR]: parseForControlFlow,
-		[TokenType.SWITCH]: parseSwitchControlFlow,
-		[TokenType.IMPORT]: parseImport
-	};
-	/**
-	* Creates a new Parser instance.
-	*
-	* @param tokens - Array of tokens produced by the Lexer.
-	*/
-	constructor(tokens) {
-		this._cursor = new ParserCursor(tokens);
-	}
-	/**
-	* Entry point for parsing the token stream into AST nodes.
-	*
-	* @returns Array of top-level AST nodes.
-	*/
-	parse() {
-		const nodes = new Array();
-		while (this._cursor.peek().type !== TokenType.EOF) {
-			const parseNode = this.parseNode();
-			if (parseNode) nodes.push(parseNode);
-		}
-		return nodes;
-	}
-	/**
-	* Parses the next AST node based on the current token.
-	*
-	* @returns The parsed AST node, or `undefined` for EOF.
-	* @throws When no transition function is registered for the current token type.
-	*/
-	parseNode() {
-		const token = this._cursor.peek();
-		if (token.type === TokenType.EOF) return;
-		const state = this._states[token.type];
-		if (!state) throw new Error(`[Parser] No transition function for token type ${TokenType[token.type]}`);
-		return state(this._cursor, this.parseNode.bind(this), token);
-	}
-};
-//#endregion
-//#region ../packages/compiler/src/type-checker/models/type-checker-context.ts
-/**
-* Type checker context that manages imported component and directive metadata
-* for the compilation process. Extends the base CompilerContext to provide
-* import-specific functionality.
-*/
-var TypeCheckContext = class extends CompilerContext {
-	/**
-	* Array of component and directive imports to be tracked during type checking.
-	* Stores metadata extracted from @WebComponent and @Directive decorators.
-	*/
-	_imports = new Array();
-	/**
-	* Adds a new component or directive import to the type checker context.
-	*
-	* @param value - The component or directive import metadata to be added
-	*/
-	addImport(value) {
-		this._imports.push(value);
-	}
-	/**
-	* Retrieves all registered component and directive imports.
-	*
-	* @returns Array of all tracked imports
-	*/
-	getImportBySelector(tagName) {
-		return this._imports.find((importValue) => importValue.type === "component" && importValue.selectors.includes(tagName));
-	}
-};
-//#endregion
-//#region ../packages/compiler/src/type-checker/states/type-check-element.state.ts
-/**
-* Type-checks an element node: its attribute/property bindings, its event
-* handlers, and recursively its children.
-*
-* Two completely different validation paths, depending on the tag:
-*
-* - **Native tags** (`div`, `button`, ...): bindings are just resolved
-*   expressions/handler calls, exactly as before — there's no component
-*   contract to check them against.
-* - **Custom elements** (tag contains a hyphen): every binding is checked
-*   by NAME against the `@Property`/`@Event` metadata extracted from the
-*   imported component class. An unknown name is a hard error (the
-*   template is binding to something the component doesn't expose) — not
-*   a warning, consistent with the "no matching @import" check already in
-*   place for the tag itself.
-*
-* No variable is declared for the element itself (see the module doc on
-* `TypeChecker` for why) — attribute expressions and event calls are
-* emitted as bare statements, validated in place.
-*/
-function typeCheckElement(node, processNode, context) {
-	const lines = new Array();
-	if (isCustomElementTag(node.tagName)) {
-		const metadata = context.getImportBySelector(node.tagName);
-		if (!metadata) throw new Error(`[Type Checker] ${node.tagName} selector is not associated to any WebComponent imported in the template`);
-		lines.push(...typeCheckComponentBindings(node, metadata, context));
-	} else {
-		node.attributes.forEach(({ value }) => {
-			if (typeof value !== "string") lines.push(`${resolveExpression(value.expression, context, { resolver: "root" })};`);
-		});
-		node.events.forEach(({ handler, parameters }) => {
-			const eventContext = new CompilerContext([], context);
-			eventContext.addUnresolvableIdentifier("$event");
-			const args = parameters.map((parameter) => resolveExpression(parameter, eventContext, { resolver: "root" })).join(", ");
-			lines.push(`root.${handler}(${args});`);
-		});
-	}
-	node.children.forEach((child) => lines.push(...processNode(child, context)));
-	return lines;
-}
-/**
-* Validates every attribute/property and event binding on a custom-element
-* node against the `@Property`/`@Event` metadata of the resolved component.
-*
-* Property values are checked with `satisfies` against `property.type` —
-* chosen over a typed `const` so an unused local never shows up if the
-* consuming project has `noUnusedLocals` enabled. Event handlers get a
-* block-scoped `$event` typed from `event.detailType`, wrapped in its own
-* `{ }` block so multiple event bindings on sibling elements never clash
-* on the `$event` name.
-*
-* ⚠️ Assumptions I couldn't verify against your actual types — please
-* confirm/adjust:
-* - `node.events` entries carry a `name` field (the template-facing event
-*   name used to look up `@Event` metadata), the same way attributes carry
-*   `name`. The snippets I've seen only destructured `handler`/`parameters`
-*   for events, never `name` — if the field is called something else,
-*   swap it in `findEvent`'s call site below.
-* - Literal string attribute values (`value` is a plain `string`, no
-*   `{ expression }`) are only checked for NAME existence, not type — I
-*   don't validate e.g. `collapsed="true"` against a `boolean` property,
-*   since I don't know whether your DSL treats un-bound string attributes
-*   as always-string or allows some literal coercion syntax. Flagging
-*   rather than guessing.
-* - `property.type`/`event.detailType` are text that must resolve as a
-*   standalone type expression in the shim's scope (e.g. `'NavItem[]'`
-*   requires `NavItem` to be importable there too, not just the component
-*   class). If your shim only imports the component class today, custom
-*   exported types referenced by `type`/`detailType` will fail to resolve
-*   as "cannot find name" — unrelated to the actual binding being right or
-*   wrong. Worth double-checking against a component that has a non-
-*   primitive `@Property` type, like `NavItem[]` in your own example.
-*/
-function typeCheckComponentBindings(node, metadata, context) {
-	const lines = new Array();
-	node.attributes.forEach(({ name, value }) => {
-		const property = findProperty(metadata, name);
-		if (!property) throw new Error(`[Type Checker] Unknown property "${name}" on <${node.tagName}> (${metadata.className} has no @Property with this name or alias).`);
-		if (typeof value === "string") return;
-		const expression = resolveExpression(value.expression, context, { resolver: "root" });
-		lines.push(property.type ? `(${expression}) satisfies ${property.type};` : `${expression};`);
-	});
-	node.events.forEach(({ name, handler, parameters }) => {
-		const event = findEvent(metadata, name);
-		if (!event) throw new Error(`[Type Checker] Unknown event "${name}" on <${node.tagName}> (${metadata.className} has no @Event with this name).`);
-		const eventContext = new CompilerContext([], context);
-		eventContext.addUnresolvableIdentifier("$event");
-		const args = parameters.map((parameter) => resolveExpression(parameter, eventContext, { resolver: "root" })).join(", ");
-		lines.push("{");
-		lines.push(`  let $event!: ${event.detailType ?? "unknown"};`);
-		lines.push(`  root.${handler}(${args});`);
-		lines.push("}");
-	});
-	return lines;
-}
-function findProperty(metadata, externalName) {
-	return metadata.properties.find((property) => (property.alias ?? property.name) === externalName);
-}
-function findEvent(metadata, externalName) {
-	return metadata.events.find((event) => event.name === externalName);
-}
-/**
-* Returns true if `tagName` has the shape of a custom element (per the
-* Custom Elements spec: contains a hyphen). This is a pure classification
-* check — it does NOT validate whether the name is actually usable as a
-* new custom element (reserved names, etc.); use `isValidCustomElementName`
-* for that, at declaration time.
-*/
-function isCustomElementTag(tagName) {
-	return /^[a-z][a-z0-9._\-]*-[a-z0-9._\-]*$/.test(tagName);
-}
-//#endregion
-//#region ../packages/compiler/src/type-checker/states/type-check-for.state.ts
-/**
-* Type-checks an `@for` block using a real `for...of` loop.
-*
-* This replaces the previous "synthetic function with a `typeof array`
-* parameter" trick, which mistyped the loop variable as the *whole array*
-* rather than a single element. A real `for (const item of array)` lets
-* TypeScript infer `item`'s type correctly as the array's element type —
-* exactly like it would for a loop written by hand — with no synthetic
-* function boundary needed.
-*/
-function typeCheckFor(node, processNode, context) {
-	const forContext = new TypeCheckContext([], context);
-	const indexName = resolveImplicit(node, "$index");
-	const firstName = resolveImplicit(node, "$first");
-	const lastName = resolveImplicit(node, "$last");
-	const evenName = resolveImplicit(node, "$even");
-	const oddName = resolveImplicit(node, "$odd");
-	[
-		indexName,
-		firstName,
-		lastName,
-		evenName,
-		oddName,
-		node.itemAlias
-	].forEach((identifier) => forContext.addUnresolvableIdentifier(identifier));
-	const lines = new Array();
-	lines.push(`for (const ${node.itemAlias} of root.${node.iterableSource}) {`);
-	lines.push(...indent([
-		`let ${indexName}!: number;`,
-		`let ${firstName}!: boolean;`,
-		`let ${lastName}!: boolean;`,
-		`let ${evenName}!: boolean;`,
-		`let ${oddName}!: boolean;`,
-		`${resolveExpression(node.trackExpression, context, { skipResolution: true })};`,
-		...node.children.flatMap((child) => processNode(child, forContext))
-	]));
-	lines.push("}");
-	return lines;
-}
-/**
-* Resolves the name that should be used in generated code for a given
-* implicit variable.
-*
-* If the template declared an explicit alias for the variable
-* (e.g. `; $index = i`) that alias is returned. Otherwise the default
-* implicit variable name (e.g. `$index`) is used.
-*
-* @param node - The `ForNode` whose implicit alias map is consulted.
-* @param implicit - The implicit variable to look up (e.g. `'$index'`).
-* @returns The alias string if one was declared, otherwise `implicit` itself.
-*/
-function resolveImplicit(node, implicit) {
-	return node.implicitAliases.get(implicit) ?? implicit;
-}
-//#endregion
-//#region ../packages/compiler/src/type-checker/states/type-check-if.state.ts
-/**
-* Type-checks an `@if`/`@else if`/`@else` chain using real TypeScript
-* `if` / `else if` / `else` blocks.
-*
-* This is a genuine correctness improvement over the previous
-* sibling-functions approach, not just a simplification: a real
-* `if`/`else if` chain gives the TS compiler's control-flow analysis the
-* negated narrowing of every preceding condition for free (e.g. inside an
-* `else if`, TS already knows the first condition was false) — something
-* flat sibling functions could never express.
-*/
-function typeCheckIf(node, processNode, context) {
-	const lines = new Array();
-	const condition = resolveExpression(node.conditionNode, context, { resolver: "root" });
-	lines.push(`if (${condition}) {`);
-	lines.push(...indent(node.children.flatMap((child) => processNode(child, context))));
-	lines.push("}");
-	let alt = node.alternate;
-	while (alt?.type === ASTNodeType.ElseIf) {
-		const elseIfCondition = resolveExpression(alt.conditionNode, context, { resolver: "root" });
-		lines.push(`else if (${elseIfCondition}) {`);
-		lines.push(...indent(alt.children.flatMap((child) => processNode(child, context))));
-		lines.push("}");
-		alt = alt.alternate;
-	}
-	if (alt) {
-		lines.push("else {");
-		lines.push(...indent(alt.children.flatMap((child) => processNode(child, context))));
-		lines.push("}");
-	}
-	return lines;
-}
-//#endregion
-//#region ../packages/compiler/src/type-checker/states/type-check-import.state.ts
-/**
-* Type-checks an `@import` node.
-*
-* Emits a typed variable declaration for each specifier so symbols are
-* available in template expressions. Metadata extraction (component/directive
-* decorator analysis) happens in a separate async phase via
-* `TypeChecker.populateImportMetadata()`.
-*/
-function typeCheckImport(node, _processNode, _context) {
-	const source = node.path;
-	const escapedSource = escapeTypeString(source);
-	const lines = new Array();
-	for (const specifier of node.specifiers) {
-		const { imported, local } = specifier;
-		switch (imported) {
-			case "*":
-				lines.push(`let ${local}!: typeof import('${escapedSource}');`);
-				break;
-			case "default":
-				lines.push(`let ${local}!: typeof import('${escapedSource}')['default'];`);
-				break;
-			default:
-				const escapedImported = escapeTypeString(imported);
-				lines.push(`let ${local}!: typeof import('${escapedSource}')['${escapedImported}'];`);
-				break;
-		}
-	}
-	return lines;
-}
-/**
-* Escapes path/specifier text for safe use in TS single-quoted type strings.
-*/
-function escapeTypeString(value) {
-	return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-}
-//#endregion
-//#region ../packages/compiler/src/type-checker/states/type-check-switch.state.ts
-/**
-* Type-checks a `@switch` block using a real TypeScript `switch` statement.
-*
-* This drops the previous `const case_0: typeof switchExpr = 'literal';`
-* trick entirely: a real `switch (expr) { case 'literal': ... }` already
-* makes TS validate that each case value is assignable to the switch
-* expression's type as part of ordinary switch-statement semantics — and,
-* as a bonus, narrows the switch expression's type inside each case block
-* (e.g. from a `'loading' | 'error' | 'idle'` union down to just
-* `'loading'`), which the previous approach never provided.
-*
-* Multiple case labels that shared one body in the AST (fallthrough) are
-* emitted as stacked `case` labels sharing that same body, matching real
-* JS/TS fallthrough syntax directly.
-*/
-function typeCheckSwitch(node, processNode, context) {
-	const lines = [`switch (${resolveExpression(node.expression, context, { resolver: "root" })}) {`];
-	node.children.forEach((caseNode) => {
-		caseNode.condition?.length ? caseNode.condition.forEach((conditionValue) => lines.push(`  case ${conditionValue}:`)) : lines.push("  default:");
-		lines.push(...indent(indent([...caseNode.children.flatMap((child) => processNode(child, context)), "break;"])));
-	});
-	lines.push("}");
-	return lines;
-}
-//#endregion
-//#region ../packages/compiler/src/type-checker/states/type-check-text-and-interpolation.state.ts
-/**
-* Type-checks a text or interpolation node.
-*
-* Plain text nodes carry no expression, so they produce no lines. An
-* interpolation's expression is emitted as a bare statement — enough for
-* TS to validate it, with no name needing to be bound to the result.
-*/
-function typeCheckTextAndInterpolation(node, _processNode, context) {
-	return node.type === ASTNodeType.Interpolation ? [`${resolveExpression(node.expression, context, { resolver: "root" })};`] : [];
-}
-//#endregion
-//#region ../packages/compiler/src/type-checker/utils/component-metadata-extractor.ts
-var import___vite_browser_external = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = {};
-})))();
-/**
-* Extracts component metadata from a source file by parsing decorators.
-* 
-* @param modulePath - The import module path (e.g., './button.component')
-* @param symbolName - The exported symbol name to look for
-* @param baseDir - The directory context for resolving relative paths
-* @returns Component metadata if found, undefined otherwise
-*/
-async function extractComponentMetadata(modulePath, symbolName, baseDir = process.cwd()) {
-	try {
-		const filePath = resolveModulePath(modulePath, baseDir);
-		if (!filePath) return;
-		const sourceFile = createSourceFile(filePath, await (0, import___vite_browser_external.readFile)(filePath, "utf8"), ScriptTarget.Latest, true);
-		let componentMetadata;
-		forEachChild(sourceFile, (node) => {
-			if (componentMetadata) return;
-			if (isClassDeclaration(node)) {
-				const className = node.name?.text;
-				if (className !== symbolName) return;
-				const modifiers = node.modifiers ?? [];
-				const webComponentDecorator = Array.from(modifiers).find((member) => isWebComponentDecorator(member));
-				if (!webComponentDecorator) return;
-				const selectors = extractSelectorsFromDecorator(webComponentDecorator);
-				if (!selectors?.length) return;
-				const properties = new Array();
-				const events = new Array();
-				node.members.forEach((member) => {
-					if (!isAccessor(member)) return;
-					const memberModifiers = member.modifiers ?? [];
-					const propDecorator = Array.from(memberModifiers).find((member) => isPropertyDecorator(member));
-					if (propDecorator) {
-						const nameNode = getNameOfDeclaration(member);
-						const propName = nameNode && isIdentifier(nameNode) ? nameNode.text : void 0;
-						if (propName) {
-							const metadata = extractPropertyMetadata(propName, propDecorator);
-							if (metadata) properties.push(metadata);
-						}
-						return;
-					}
-					const eventDecorator = Array.from(memberModifiers).find((member) => isEventDecorator(member));
-					if (eventDecorator) {
-						const nameNode = getNameOfDeclaration(member);
-						const eventName = nameNode && isIdentifier(nameNode) ? nameNode.text : void 0;
-						if (eventName) {
-							const metadata = extractEventMetadata(eventName, eventDecorator);
-							if (metadata) events.push(metadata);
-						}
-					}
-				});
-				componentMetadata = {
-					type: "component",
-					className,
-					selectors,
-					properties,
-					events
-				};
-			}
-		});
-		return componentMetadata;
-	} catch (error) {
-		console.error(`Failed to extract component metadata from ${modulePath}:`, error);
-		return;
-	}
-}
-/**
-* Resolves a module import path to an actual file system path.
-* Handles both relative paths (./button.component) and package paths (@scope/pkg).
-* 
-* @param modulePath - The import module path
-* @param baseDir - The directory to resolve relative imports from
-* @returns The resolved file path, or undefined if not found
-*/
-function resolveModulePath(modulePath, baseDir) {
-	if (modulePath.startsWith(".")) {
-		const resolvedPath = (0, import___vite_browser_external.resolve)(baseDir, modulePath);
-		if ((0, import___vite_browser_external.existsSync)(`${resolvedPath}.ts`)) return resolvedPath + ".ts";
-		if ((0, import___vite_browser_external.existsSync)(`${resolvedPath}/index.ts`)) return `${resolvedPath}/index.ts`;
-		if ((0, import___vite_browser_external.existsSync)(resolvedPath)) return resolvedPath;
-	}
-}
-/**
-* Checks if a modifier is a @WebComponent decorator.
-*/
-function isWebComponentDecorator(modifier) {
-	if (modifier.kind !== SyntaxKind.Decorator) return false;
-	const expr = isCallExpression(modifier.expression) ? modifier.expression.expression : modifier.expression;
-	return isIdentifier(expr) && expr.text === "WebComponent";
-}
-/**
-* Checks if a modifier is a @Property decorator.
-*/
-function isPropertyDecorator(modifier) {
-	if (modifier.kind !== SyntaxKind.Decorator) return false;
-	const expr = modifier.expression;
-	if (isCallExpression(expr)) return isIdentifier(expr.expression) && expr.expression.text === "Property";
-	if (isPropertyAccessExpression(expr)) return isIdentifier(expr.expression) && expr.expression.text === "Property" && isIdentifier(expr.name) && expr.name.text === "required";
-	return isIdentifier(expr) && expr.text === "Property";
-}
-/**
-* Checks if a modifier is an @Event decorator.
-*/
-function isEventDecorator(modifier) {
-	if (modifier.kind !== SyntaxKind.Decorator) return false;
-	const expr = isCallExpression(modifier.expression) ? modifier.expression.expression : modifier.expression;
-	return isIdentifier(expr) && expr.text === "Event";
-}
-/**
-* Extracts selector(s) from @WebComponent decorator arguments.
-* 
-* @example
-* @WebComponent({ selector: 'my-button' })
-* @WebComponent({ selector: ['my-btn', 'button-el'] })
-*/
-function extractSelectorsFromDecorator(modifier) {
-	try {
-		const expr = modifier.expression;
-		if (!isCallExpression(expr)) return [];
-		const args = expr.arguments;
-		if (args.length === 0) return [];
-		const arg = args[0];
-		if (!arg || !isObjectLiteralExpression(arg)) return [];
-		return extractStringOrStringArray(Array.from(arg.properties).find((prop) => isPropertyAssignment(prop) && isIdentifier(prop.name) && prop.name.text === "selector").initializer);
-	} catch {
-		return [];
-	}
-}
-/**
-* Extracts a string or string array value from a TypeScript node.
-*/
-function extractStringOrStringArray(node) {
-	if (isStringLiteral(node)) return [node.text];
-	return isArrayLiteralExpression(node) ? node.elements?.filter((node) => isStringLiteral(node)).map((node) => node.text) : [];
-}
-/**
-* Extracts property metadata from @Property or @Property.required decorator.
-*/
-function extractPropertyMetadata(propName, modifier) {
-	const metadata = {
-		name: propName,
-		required: false
-	};
-	const expr = modifier.expression;
-	if (isPropertyAccessExpression(expr)) {
-		if (isIdentifier(expr.name) && expr.name.text === "required") metadata.required = true;
-	}
-	if (isCallExpression(expr)) {
-		const args = expr.arguments;
-		if (args.length) {
-			const arg = args[0];
-			if (isObjectLiteralExpression(arg)) {
-				const aliasNode = arg.properties?.find((prop) => isPropertyAssignment(prop) && isIdentifier(prop.name) && prop.name.text === "alias");
-				if (aliasNode && isStringLiteral(aliasNode.initializer)) metadata.alias = aliasNode.initializer.text;
-			}
-		}
-	}
-	return metadata;
-}
-/**
-* Extracts event metadata from @Event decorator.
-*/
-function extractEventMetadata(eventName, modifier) {
-	return { name: eventName };
-}
-//#endregion
-//#region ../packages/compiler/src/type-checker/type-checker.ts
-/**
-* Generates a single, flat TypeScript function body ("shim") from a
-* template AST, meant only to be fed to the TS compiler / LanguageService
-* for diagnostics — it is never executed and never emitted as real output.
-*
-* This deliberately does NOT mirror the JS code generator's structure:
-*
-* - No variable is declared per HTML element. Element identifiers exist in
-*   the JS output purely so runtime code can create/reference the actual
-*   DOM node; a type-check expression never references "the element
-*   itself" (the DSL has no template-ref syntax), so an `HTMLElement`
-*   local would add zero type-checking value.
-* - No control-flow block gets its own function. In the JS output, each
-*   `@if`/`@for`/`@switch` becomes a separate function because it needs
-*   its own runtime closure over the `Context` chain. The type checker has
-*   no runtime at all, so real, nested TypeScript blocks — `if`, `for`,
-*   `switch` — give correct scoping and (as a bonus) real control-flow
-*   narrowing, for free, with no synthetic machinery.
-*
-* Every AST node turns directly into TypeScript lines, recursively, inside
-* one single `typeCheck()` function.
-*/
-var TypeChecker = class {
-	_ast;
-	_context = new TypeCheckContext();
-	_states = {
-		[ASTNodeType.Text]: typeCheckTextAndInterpolation,
-		[ASTNodeType.Interpolation]: typeCheckTextAndInterpolation,
-		[ASTNodeType.Element]: typeCheckElement,
-		[ASTNodeType.If]: typeCheckIf,
-		[ASTNodeType.For]: typeCheckFor,
-		[ASTNodeType.Switch]: typeCheckSwitch,
-		[ASTNodeType.Import]: typeCheckImport
-	};
-	constructor(_ast) {
-		this._ast = _ast;
-	}
-	/**
-	* Pre-populates the shared context with component and directive metadata
-	* by parsing source files for all `@import` nodes in the AST.
-	*
-	* Must be awaited before calling `generate()` if metadata-driven
-	* validation (e.g. unknown component inputs) is desired.
-	*
-	* @param baseDir - Absolute path used to resolve relative import paths.
-	*/
-	async populateImportMetadata(baseDir) {
-		const importNodes = this._ast.filter((node) => node.type === ASTNodeType.Import);
-		await Promise.all(importNodes.flatMap((node) => node.specifiers.filter(({ imported }) => imported !== "*").map(async ({ imported, local }) => {
-			const symbolName = imported === "default" ? local : imported;
-			const metadata = await extractComponentMetadata(node.path, symbolName, baseDir);
-			if (metadata) this._context.addImport(metadata);
-		})));
-	}
-	/**
-	* Generates the full `function typeCheck() { ... }` shim body for the
-	* component's template.
-	*
-	* A `let $event!: Event;` declaration is prepended only if the generated
-	* body actually references `$event` (event handler bindings), so shims
-	* for templates with no event bindings don't carry an unused local —
-	* relevant if the consuming project has `noUnusedLocals` enabled.
-	* 
-	* @param baseDir - Absolute path used to resolve relative import paths
-	*/
-	generate(baseDir) {
-		this.populateImportMetadata(baseDir);
-		return [
-			"function typeCheck() {",
-			...indent(this._ast.flatMap((node) => this._processNode(node, this._context))),
-			"}"
-		].join("\n");
-	}
-	/**
-	* Dispatches a single AST node to its state function, passing itself
-	* back down as `processNode` so state functions can recurse into their
-	* own children inline.
-	*/
-	_processNode = (node, context) => {
-		const state = this._states[node.type];
-		if (!state) throw new Error(`[Type Checker] No transition function for token type ${ASTNodeType[node.type]}`);
-		return state(node, this._processNode, context);
-	};
-};
-//#endregion
-//#region ../packages/compiler/src/compile.ts
-/**
-* Compiles a template string into a Javascript render function body.
-*
-* Runs the three-stage pipeline:
-* 1. **Lexer** — tokenises the raw template text.
-* 2. **Parser** — transforms the token stream into an AST.
-* 3. **Render generator** — emits Javascript source lines from the AST.
-*
-* @param input - The raw HTML-like template source to compile.
-* @param cssVariableName - Optional name of the CSS variable to inject
-*   into the generated `adoptedStyleSheets` assignment.
-* @returns A string containing the compiled Javascript render method body.
-*/
-function compile(input, cssVariableName) {
-	const nodes = new Parser(new Lexer(input).tokenize()).parse();
-	return {
-		javascript: new Generator(nodes).generate(cssVariableName),
-		typescript: new TypeChecker(nodes).generate()
-	};
-}
-//#endregion
-export { compile };