@xaendar/compiler 0.6.14 → 0.6.15

package/dist/xaendar-compiler.es.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Compiles a template string into a TypeScript 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 TypeScript 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 TypeScript render method body.
+ */
 export declare function compile(input: string, cssVariableName?: string): string;
 
 /**

package/dist/xaendar-compiler.es.js

@@ -70,10 +70,6 @@ var LexerState = /* @__PURE__ */ function(LexerState) {
 	* Consuming a template-literal string inside `` {`...`} ``.
 	*/
 	LexerState["INTERPOLATION_LITERAL"] = "interpolation-literal";
-	/**
-	* Consuming a `@const name = expression;` declaration.
-	*/
-	LexerState["CONST_DECLARATION"] = "const-declaration";
 	return LexerState;
 }({});
 //#endregion
@@ -123,57 +119,62 @@ var TokenType = /* @__PURE__ */ function(TokenType) {
 	*/
 	TokenType[TokenType["INTERPOLATION_EXPRESSION"] = 9] = "INTERPOLATION_EXPRESSION";
 	/**
-	* A `@const name = expression;` template-level constant declaration.
-	*/
-	TokenType[TokenType["CONST_DECLARATION"] = 10] = "CONST_DECLARATION";
-	/**
 	* Opening keyword of an `@if` directive.
 	*/
-	TokenType[TokenType["IF"] = 11] = "IF";
+	TokenType[TokenType["IF"] = 10] = "IF";
 	/**
 	* Opening keyword of a `@for` directive.
 	*/
-	TokenType[TokenType["FOR"] = 12] = "FOR";
+	TokenType[TokenType["FOR"] = 11] = "FOR";
 	/**
 	* Opening keyword of an `@else` branch.
 	*/
-	TokenType[TokenType["ELSE"] = 13] = "ELSE";
+	TokenType[TokenType["ELSE"] = 12] = "ELSE";
 	/**
 	* Opening keyword of an `@else if` branch.
 	*/
-	TokenType[TokenType["ELSE_IF"] = 14] = "ELSE_IF";
+	TokenType[TokenType["ELSE_IF"] = 13] = "ELSE_IF";
 	/**
 	* Opening keyword of a `@switch` directive.
 	*/
-	TokenType[TokenType["SWITCH"] = 15] = "SWITCH";
+	TokenType[TokenType["SWITCH"] = 14] = "SWITCH";
 	/**
 	* Opening keyword of a `@case` branch.
 	*/
-	TokenType[TokenType["CASE"] = 16] = "CASE";
+	TokenType[TokenType["CASE"] = 15] = "CASE";
 	/**
 	* Opening keyword of a `@default` branch.
 	*/
-	TokenType[TokenType["DEFAULT"] = 17] = "DEFAULT";
+	TokenType[TokenType["DEFAULT"] = 16] = "DEFAULT";
 	/**
 	* The condition expression `(...)` associated with a flow-control directive.
 	*/
-	TokenType[TokenType["CONDITION"] = 18] = "CONDITION";
+	TokenType[TokenType["CONDITION"] = 17] = "CONDITION";
 	/**
 	* The opening `{` of a flow-control block body.
 	*/
-	TokenType[TokenType["BLOCK_OPEN"] = 19] = "BLOCK_OPEN";
+	TokenType[TokenType["BLOCK_OPEN"] = 18] = "BLOCK_OPEN";
 	/**
 	* The closing `}` of a flow-control block body.
 	*/
-	TokenType[TokenType["BLOCK_CLOSE"] = 20] = "BLOCK_CLOSE";
+	TokenType[TokenType["BLOCK_CLOSE"] = 19] = "BLOCK_CLOSE";
 	/**
 	* Sentinel token emitted when the end of the input is reached.
 	*/
-	TokenType[TokenType["EOF"] = 21] = "EOF";
+	TokenType[TokenType["EOF"] = 20] = "EOF";
 	return TokenType;
 }({});
 //#endregion
 //#region ../packages/compiler/src/lexer/states/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 consumeAttributeValue(cursor, _context) {
 	let read = true;
 	let value = "";
@@ -203,8 +204,8 @@ function consumeAttributeValue(cursor, _context) {
 * 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.
+* @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 consumeAttribute(cursor, _context) {
@@ -248,6 +249,18 @@ function consumeAttribute(cursor, _context) {
 }
 //#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}`);
@@ -274,9 +287,9 @@ function consumeFlowControlCondition(cursor, _context) {
 /**
 * 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 string.
-* @returns The updated string with the new character appended.
+* @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$2(cursor, expression) {
 	cursor.advance();
@@ -289,8 +302,8 @@ function addCharacter$2(cursor, expression) {
 * 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.
+* @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 consumeCaseFlowControlCondition(cursor, _context) {
@@ -306,64 +319,14 @@ function consumeCaseFlowControlCondition(cursor, _context) {
 	};
 }
 //#endregion
-//#region ../packages/compiler/src/lexer/states/const-declaration.ts
-/**
-* Consumes a `@const name = expression;` declaration from the current position.
-* Expects the cursor to be positioned after the `@const ` keyword.
-* Emits a CONST_DECLARATION token containing the variable name and initializer expression.
-*
-* @param cursor The lexer cursor positioned at the start of the variable name.
-* @param _context Unused lexer context.
-* @returns Transition result with the CONST_DECLARATION token and the TEXT state.
-*/
-function consumeConstDeclaration(cursor, _context) {
-	let read = true;
-	let varName = "";
-	let expression = "";
-	let retVal;
-	cursor.skipSpaces();
-	while (read) switch (cursor.peek()) {
-		case 32:
-			read = false;
-			break;
-		default:
-			cursor.advance();
-			varName = `${varName}${cursor.currentChar.value}`;
-	}
-	cursor.skipSpaces();
-	const nextChar = cursor.peek();
-	if (nextChar !== 61) throw new Error(`Unexpected character ${String.fromCharCode(nextChar)}.\nExpected '=' `);
-	cursor.advance();
-	cursor.skipSpaces();
-	read = true;
-	while (read) switch (cursor.peek()) {
-		case 59:
-			retVal = {
-				state: LexerState.TEXT,
-				tokens: [{
-					type: TokenType.CONST_DECLARATION,
-					parts: [varName, expression]
-				}]
-			};
-			read = false;
-			break;
-		default:
-			cursor.advance();
-			expression = `${expression}${cursor.currentChar.value}`;
-	}
-	cursor.advance();
-	expression = `${expression};`;
-	return retVal;
-}
-//#endregion
 //#region ../packages/compiler/src/lexer/states/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.
+* @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 consumeDefaultFlowControlCondition(cursor, _context) {
@@ -382,8 +345,8 @@ function consumeDefaultFlowControlCondition(cursor, _context) {
 * 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.
+* @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 consumeEvent(cursor, _context) {
@@ -428,8 +391,8 @@ function consumeEvent(cursor, _context) {
 * 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.
+* @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 consumeFlowControl(cursor, _context) {
@@ -482,24 +445,24 @@ function consumeFlowControl(cursor, _context) {
 			state: LexerState.FLOW_CONTROL_BLOCK,
 			tokens: [{ type: TokenType.DEFAULT }]
 		};
-	} else if (cursor.peekMatch("const ")) {
-		cursor.advance(6);
-		retVal = { state: LexerState.CONST_DECLARATION };
 	}
 	return retVal;
 }
 //#endregion
 //#region ../packages/compiler/src/lexer/states/flow-control-block.state.ts
 /**
-* Consumes the opening `{` of a flow control block body,
+* 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.
-* This allows consumeText to later recognise the matching `}` as a BLOCK_CLOSE
-* rather than as an interpolation boundary.
+* 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
+* 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 consumeFlowControlBlock(cursor, _context) {
 	cursor.skipSpaces();
@@ -518,8 +481,8 @@ function consumeFlowControlBlock(cursor, _context) {
 * 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 Lexer context used to retrieve the previous state for restoration.
+* @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 consumeInterpolationExpression(cursor, context) {
@@ -568,9 +531,9 @@ function consumeInterpolationExpression(cursor, context) {
 /**
 * 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 string.
-* @returns The updated string with the new character appended.
+* @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);
@@ -583,8 +546,8 @@ function addCharacter$1(cursor, interpolation) {
 * 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 Lexer context used to retrieve the previous state for restoration.
+* @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 consumeInterpolationliteral(cursor, context) {
@@ -623,9 +586,9 @@ function consumeInterpolationliteral(cursor, context) {
 /**
 * 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 string.
-* @returns The updated string with the new character appended.
+* @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();
@@ -634,24 +597,22 @@ function addCharacter(cursor, interpolation) {
 //#endregion
 //#region ../packages/compiler/src/utils/chars.utils.ts
 /**
-* Check if the string contains at least one character different from
-* ' '
-* \n
-* \r
-* \t
-* \f
-* \v
-* @param str String to check
-* @returns True if string is not blank, false otherwise
+* 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);
 }
 /**
-* Check if given ascii code is a valid First Character
-* for Javasript Identifiers
-* @param code The ascii code to valuate
-* @returns True if is valid, false otherwise
+* Checks whether the given ASCII code is a valid first character for a
+* JavaScript identifier (`A`–`Z`, `a`–`z`, `$`, `_`).
+*
+* @param code - The ASCII code to evaluate.
+* @returns `true` if the code can start a JS identifier, `false` otherwise.
 */
 function isJSIdentifierStart(code) {
 	return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 36 || code === 95;
@@ -663,8 +624,8 @@ function isJSIdentifierStart(code) {
 * 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.
+* @param cursor - The lexer cursor positioned on the `{` character.
+* @param _context - Unused lexer context.
 * @returns Transition result with the appropriate interpolation sub-state.
 */
 function consumeInterpolation(cursor, _context) {
@@ -684,8 +645,8 @@ function consumeInterpolation(cursor, _context) {
 * 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.
+* @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 consumeTagBody(cursor, _context) {
@@ -716,8 +677,8 @@ function consumeTagBody(cursor, _context) {
 * 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.
+* @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 consumeTagClose(cursor, _context) {
@@ -751,8 +712,8 @@ function consumeTagClose(cursor, _context) {
 * 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.
+* @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 consumeTagOpenEnd(cursor, _context) {
@@ -788,8 +749,8 @@ function consumeTagOpenEnd(cursor, _context) {
 * 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.
+* @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 consumeTagOpenName(cursor, _context) {
@@ -824,8 +785,8 @@ function consumeTagOpenName(cursor, _context) {
 * 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 Lexer context used to detect flow-control block boundaries.
+* @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 consumeText(cursor, context) {
@@ -941,7 +902,7 @@ var LexerCursor = class {
 	/**
 	* Creates a new cursor for the given input source.
 	*
-	* @param input Full source string to be tokenized.
+	* @param input - Full source string to be tokenised.
 	*/
 	constructor(input) {
 		this.input = input;
@@ -955,9 +916,8 @@ var LexerCursor = class {
 	* - 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 Error with cause `EOF` when advancing past input length
+	* @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`);
@@ -1072,13 +1032,12 @@ var Lexer = class {
 		[LexerState.EVENT]: consumeEvent,
 		[LexerState.INTERPOLATION]: consumeInterpolation,
 		[LexerState.INTERPOLATION_EXPRESSION]: consumeInterpolationExpression,
-		[LexerState.INTERPOLATION_LITERAL]: consumeInterpolationliteral,
-		[LexerState.CONST_DECLARATION]: consumeConstDeclaration
+		[LexerState.INTERPOLATION_LITERAL]: consumeInterpolationliteral
 	};
 	/**
-	* Creates a new Cursor instance for the given template content.
+	* Creates a new Lexer instance for the given template content.
 	*
-	* @param input The full template text that the cursor will navigate.
+	* @param input - The full template text to tokenise.
 	*/
 	constructor(input) {
 		this.input = input;
@@ -1147,7 +1106,7 @@ var ParserCursor = class {
 	/**
 	* Creates a new ParserCursor for the given token array.
 	*
-	* @param _tokens Array of tokens to navigate.
+	* @param _tokens - The array of tokens to navigate.
 	*/
 	constructor(_tokens) {
 		this._tokens = _tokens;
@@ -1155,11 +1114,10 @@ var ParserCursor = class {
 	/**
 	* Advances the cursor by the specified number of tokens.
 	*
-	* Updates the current token and index.
+	* Updates the current token and its index.
 	*
-	* @param chars Number of tokens to advance (must be >= 1)
-	*
-	* @throws Error with cause `EOF` when advancing past the end
+	* @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`);
@@ -1235,10 +1193,6 @@ var ASTNodeType = /* @__PURE__ */ function(ASTNodeType) {
 	* A `@case` or `@default` branch inside a `@switch`.
 	*/
 	ASTNodeType[ASTNodeType["Case"] = 8] = "Case";
-	/**
-	* A `@const` declaration node.
-	*/
-	ASTNodeType[ASTNodeType["ConstDeclaration"] = 9] = "ConstDeclaration";
 	return ASTNodeType;
 }({});
 //#endregion
@@ -1419,31 +1373,13 @@ function isAssignmentOperator(kind) {
 	return kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
 }
 //#endregion
-//#region ../packages/compiler/src/parser/states/parse-const-declaration.state.ts
-/**
-* Parses a CONST_DECLARATION token into a `ConstDeclarationNode`.
-*
-* @param cursor Parser cursor; advanced past the CONST_DECLARATION token.
-* @param _parseNode Unused parser function.
-* @param token The CONST_DECLARATION token containing variable name and expression.
-* @returns The parsed `ConstDeclarationNode`.
-*/
-function parseConstDeclaration(cursor, _parseNode, token) {
-	cursor.advance();
-	return {
-		type: ASTNodeType.ConstDeclaration,
-		varName: token.parts[0],
-		expression: validateExpression(token.parts[1]).node
-	};
-}
-//#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.
-* @param token The INTERPOLATION_EXPRESSION or INTERPOLATION_LITERAL token.
+* @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) {
@@ -1459,9 +1395,9 @@ function parseInterpolation(cursor, _parseNode, token) {
 * 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 node function for recursive parsing.
-* @param token The ATTRIBUTE token to parse.
+* @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) {
@@ -1489,9 +1425,9 @@ function parseAttribute(cursor, parseNode, token) {
 * 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.
-* @param token The EVENT token to parse.
+* @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) {
@@ -1510,9 +1446,9 @@ function parseEvent(cursor, _parseNode, token) {
 * 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 context Parser context for recursive child parsing.
-* @param token The TAG_OPEN_NAME token containing the tag name.
+* @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) {
@@ -1561,8 +1497,8 @@ function parseElement(cursor, parseNode, token) {
 /**
 * 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.
+* @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) {
@@ -1575,8 +1511,8 @@ function isTagClose(cursor, tagName) {
 * 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.
+* @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) {
@@ -1594,9 +1530,9 @@ function parseBlockChildren(cursor, parseNode) {
 * 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 context Parser context for recursive child parsing.
-* @param _token The FOR token (unused; consumed for position advancement).
+* @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) {
@@ -1656,12 +1592,10 @@ function parseForExpression(source, baseOffset) {
 * aliases for implicit loop variables (e.g. `$index = i, $last = l, $even = isEven`).
 *
 * Valid entries are comma-separated pairs in the form `$implicit = alias`.
-* Diagnostics are pushed to `diagnostics` for any malformed or duplicate entry.
 *
-* @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.
-* @param diagnostics - Array to collect any parse errors.
+* @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(",");
@@ -1761,9 +1695,9 @@ function isValidIdentifier(name) {
 * 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 context for recursive child parsing.
-* @param token The IF token (unused; consumed for position advancement).
+* @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) {
@@ -1803,9 +1737,9 @@ function parseIfOrElseIf(cursor, parseNode, token) {
 * 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 (unused; consumed for position advancement).
+* @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) {
@@ -1853,9 +1787,9 @@ function parseSwitchControlFlow(cursor, parseNode, _token) {
 /**
 * Parses a TEXT token into a `TextNode`.
 *
-* @param cursor Parser cursor; advanced past the TEXT token.
-* @param _parseNode Function to parse the next AST node.
-* @param token The TEXT token containing the raw text content.
+* @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) {
@@ -1896,13 +1830,12 @@ var Parser = class {
 		[TokenType.TAG_OPEN_NAME]: parseElement,
 		[TokenType.IF]: parseIfControlFlow,
 		[TokenType.FOR]: parseForControlFlow,
-		[TokenType.SWITCH]: parseSwitchControlFlow,
-		[TokenType.CONST_DECLARATION]: parseConstDeclaration
+		[TokenType.SWITCH]: parseSwitchControlFlow
 	};
 	/**
 	* Creates a new Parser instance.
 	*
-	* @param tokens Array of tokens produced by the Lexer
+	* @param tokens - Array of tokens produced by the Lexer.
 	*/
 	constructor(tokens) {
 		this.tokens = tokens;
@@ -1911,7 +1844,7 @@ var Parser = class {
 	/**
 	* Entry point for parsing the token stream into AST nodes.
 	*
-	* @returns Array of top-level AST nodes
+	* @returns Array of top-level AST nodes.
 	*/
 	parse() {
 		const nodes = new Array();
@@ -1924,8 +1857,8 @@ var Parser = class {
 	/**
 	* Parses the next AST node based on the current token.
 	*
-	* @returns Parsed AST node
-	* @throws Error if an unexpected token is encountered
+	* @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();
@@ -1936,6 +1869,47 @@ var Parser = class {
 	}
 };
 //#endregion
+//#region ../packages/compiler/src/render-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 {
+	_identifiers;
+	_parent;
+	/**
+	* Creates a new scope context.
+	*
+	* @param _identifiers - Named identifier bindings declared in this scope.
+	* @param _parent - Optional parent context representing the enclosing scope.
+	*/
+	constructor(_identifiers = new Array(), _parent) {
+		this._identifiers = _identifiers;
+		this._parent = _parent;
+	}
+	/**
+	* Registers a new identifier name in this scope.
+	*
+	* @param name - The identifier name to register.
+	* @throws When an identifier with the same name is already declared in this scope.
+	*/
+	addIdentifier(name) {
+		if (this.hasIdentifier(name)) throw new Error(`Identifier "${name}" is already declared in this scope.`);
+		this._identifiers.push(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.includes(name) || (this._parent?.hasIdentifier(name) ?? false);
+	}
+};
+//#endregion
 //#region ../packages/compiler/src/render-generator/utils/render-generator.utils.ts
 /**
 * Complete set of JavaScript global identifiers up to ES2026.
@@ -2193,37 +2167,44 @@ function needsResolution(node, parent) {
 	return !(ts.isPropertyAccessExpression(parent) && parent.name === node || GLOBAL_IDENTIFIERS.has(node.text));
 }
 /**
-* Generates a unique variable name for an element based on its tag name and parent node.
-* If the parent node is 'this._root', the identifier will be based solely on the element's type.
-* Otherwise, it will be prefixed with the parent node's name to ensure uniqueness.
-* @param node The ElementNode for which to generate the identifier.
-* @param parentNode  The name of the parent node to ensure uniqueness in the context of nested elements.
-* @returns A string representing the unique variable name for the element.
+* 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 (parentNode !== "root" ? `${parentNode}_${node.tagName}${index}` : `${node.tagName}${index}`).replace(/-/g, "_");
 }
+/**
+* Generates a unique variable name for a text or interpolation node.
+*
+* @param parentNode - The variable name of the parent node.
+* @param index - A numeric suffix to disambiguate sibling text nodes.
+* @param prefix - Optional prefix to use instead of the default `'text'`.
+* @returns A unique variable name string for the text node.
+*/
 function getTextIdentifier(parentNode, index, prefix = "text") {
 	return (parentNode !== "root" ? `${parentNode}_${prefix}${index}` : `${prefix}${index}`).replace(/-/g, "_");
 }
-function getBlockIdentifier(parentNode, index, prefix) {
-	return (parentNode !== "root" ? `${parentNode}_${prefix}${index}` : `${prefix}${index}`).replace(/-/g, "_");
-}
-//#endregion
-//#region ../packages/compiler/src/render-generator/states/process-const-declaration.state.ts
 /**
-* Generates code for a `@const` declaration node.
-* Emits a `const name = expression;` JavaScript statement.
+* Generates a unique variable name for a control-flow block (if, else-if, else,
+* for, switch, case, or default).
 *
-* @param node The `ConstDeclarationNode` to process.
-* @param _nodeName Unused node name.
-* @param _parentNode Unused parent node name.
-* @param _context Unused render context.
-* @returns Array containing the generated const statement string.
+* @param parentNode - The variable name of the parent node.
+* @param index - A suffix to disambiguate sibling blocks.
+* @param prefix - The block type prefix (`'if'`, `'elseIf'`, `'else'`, etc.).
+* @returns A unique variable name string for the block.
 */
-function processConstDeclaration(node, _nodeName, _parentNode, compilerContext) {
-	compilerContext.addIdentifier(node.varName);
-	return [`declareConst(context, ${node.varName}, () => ${resolveExpression(node.expression, compilerContext)});`];
+function getBlockIdentifier(parentNode, index, prefix) {
+	return (parentNode !== "root" ? `${parentNode}_${prefix}${index}` : `${prefix}${index}`).replace(/-/g, "_");
 }
 //#endregion
 //#region ../packages/compiler/src/render-generator/states/process-element.state.ts
@@ -2231,10 +2212,10 @@ function processConstDeclaration(node, _nodeName, _parentNode, compilerContext)
 * 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 nodeName 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.
+* @param node - The `ElementNode` to process.
+* @param nodeName - 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 processElement(node, nodeName, parentNode, compilerContext) {
@@ -2255,15 +2236,11 @@ function processElement(node, nodeName, parentNode, compilerContext) {
 	return code;
 }
 /**
-* Generates code that assigns attributes to a DOM element.
-*
-* Static (string) attribute values are set once via a direct `setAttribute` call,
-* while dynamic attribute values are wrapped in an `effect` so the attribute is
-* re-evaluated and updated whenever its underlying signal dependencies change.
-* The disposer returned by the `effect` is registered in `unwatchFns` for cleanup.
+* Maps attribute nodes to their corresponding generated code lines.
 *
-* @param attributes The attribute nodes to map onto the element.
-* @returns Array of generated code lines, one per attribute.
+* @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 }) => {
@@ -2277,47 +2254,13 @@ function mapAttributes(attributes, compilerContext) {
 * 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 events - The event nodes to bind to the element.
 * @returns Array of generated code lines, one per event listener.
 */
 function mapEvents(events) {
 	return events?.map((event) => `{ name: '${event.name}', handler: '${event.handler}' }`);
 }
 //#endregion
-//#region ../packages/compiler/src/render-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 {
-	_identifiers;
-	_parent;
-	/**
-	* Creates a new scope context.
-	*
-	* @param _identifiers List of loop variable names declared in this scope.
-	* @param _parent Optional parent context representing the enclosing scope.
-	*/
-	constructor(_identifiers = new Array(), _parent) {
-		this._identifiers = _identifiers;
-		this._parent = _parent;
-	}
-	addIdentifier(name) {
-		if (this.hasIdentifier(name)) throw new Error(`Identifier "${name}" is already declared in this scope.`);
-		this._identifiers.push(name);
-	}
-	/**
-	* Returns the innermost identifier in the current scope chain, or
-	* delegates to the parent context if none is found in this scope.
-	*
-	* @returns The most recently declared identifier name, or `undefined` if none exists.
-	*/
-	hasIdentifier(name) {
-		return this._identifiers.includes(name) || (this._parent?.hasIdentifier(name) ?? false);
-	}
-};
-//#endregion
 //#region ../packages/compiler/src/render-generator/states/process-for.state.ts
 /**
 * Generates code for a `@for` iteration node.
@@ -2405,12 +2348,13 @@ function resolveImplicit(node, implicit) {
 //#region ../packages/compiler/src/render-generator/states/process-if.state.ts
 /**
 * Generates code for an `@if` conditional node.
-* Emits an `if (...) { ... }` block, appending an `else { ... }` block if an alternate exists.
+* Emits an `_if(...)` call wrapping the resolved condition blocks.
 *
-* @param node The `IfNode` to process.
-* @param nodeName Base variable name prefix for child nodes.
-* @param parentNode Variable name of the parent DOM node.
-* @returns Array of generated code lines.
+* @param node - The `IfNode` to process.
+* @param nodeName - 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 processIf(node, nodeName, parentNode, compilerContext) {
 	const ifContext = new CompilerContext([], compilerContext);
@@ -2472,14 +2416,13 @@ function processConsequent(node, nodeName, parentNode, compilerContext) {
 //#region ../packages/compiler/src/render-generator/states/process-switch.state.ts
 /**
 * Generates code for a `@switch` node.
-* Emits a `_switch(unwatchFns, () => expression, [...])` call that delegates
-* to the reactive `_switch` runtime utility.
+* Emits a `_switch(...)` call that delegates to the reactive `_switch` runtime utility.
 *
-* @param node The `SwitchNode` to process.
-* @param nodeName Base variable name prefix for child nodes.
-* @param parentNode Variable name of the parent DOM node.
+* @param node - The `SwitchNode` to process.
+* @param nodeName - Base variable name prefix for child nodes.
+* @param parentNode - Variable name of the parent DOM node.
 * @param compilerContext - Current render scope context.
-* @returns Array of generated code lines.
+* @returns An object with the main block code lines and a map of helper functions to register.
 */
 function processSwitch(node, nodeName, parentNode, compilerContext) {
 	const functionsToProcess = /* @__PURE__ */ new Map();
@@ -2515,15 +2458,17 @@ function processSwitch(node, nodeName, parentNode, compilerContext) {
 //#region ../packages/compiler/src/render-generator/states/process-text-and-interpolation.state.ts
 /**
 * Generates code for a text or interpolation node.
-* Creates a DOM text node with either a JSON-stringified literal or a resolved expression,
-* then appends it to the parent DOM node.
 *
-* @param node A `TextNode` or `InterpolationNode` to process.
-* @param parentNode Variable name of the parent DOM node.
-* @returns Array of two generated code lines: the text node creation and the appendChild call.
+* 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 processTextAndInterpolation(node, parentNode) {
-	return [`${node.type === ASTNodeType.Text ? `_renderLiteralText(${parentNode}, context, '${node.value}')` : `_renderText(${parentNode}, context, '${node.expression.text}')`}`];
+function processTextAndInterpolation(node, parentNode, compilerContext) {
+	return [`${node.type === ASTNodeType.Text ? `_renderLiteralText(${parentNode}, context, '${node.value}')` : `_renderText(${parentNode}, context, () => ${resolveExpression(node.expression, compilerContext)})`}`];
 }
 //#endregion
 //#region ../packages/compiler/src/render-generator/render-generator.ts
@@ -2531,8 +2476,10 @@ var nodeToProcess = /* @__PURE__ */ new Map();
 /**
 * Generates the TypeScript body of a render function from an AST.
 *
-* @param ast Top-level AST nodes produced by the Parser
-* @returns String containing the render function body
+* @param ast - Top-level AST nodes produced by the Parser.
+* @param cssVariableName - Optional name of the CSS variable to inject into
+*   the generated `adoptedStyleSheets` assignment.
+* @returns A string containing the render function body.
 */
 function generateRenderFunction(ast, cssVariableName) {
 	nodeToProcess.clear();
@@ -2559,7 +2506,7 @@ function generateRenderFunction(ast, cssVariableName) {
 function processNode(node, nodeName, parentNode, compilerContext) {
 	switch (node.type) {
 		case ASTNodeType.Text:
-		case ASTNodeType.Interpolation: return processTextAndInterpolation(node, parentNode);
+		case ASTNodeType.Interpolation: return processTextAndInterpolation(node, parentNode, compilerContext);
 		case ASTNodeType.Element: return processElement(node, getElementIdentifier(node, parentNode, nodeName), parentNode, compilerContext);
 		case ASTNodeType.If:
 			const conditionalBlockData = processIf(node, nodeName, parentNode, compilerContext);
@@ -2582,12 +2529,24 @@ function processNode(node, nodeName, parentNode, compilerContext) {
 				args: fnBody.args
 			}));
 			return switchBlockData.mainBlock;
-		case ASTNodeType.ConstDeclaration: return processConstDeclaration(node, nodeName, parentNode, compilerContext);
 		default: return [];
 	}
 }
 //#endregion
 //#region ../packages/compiler/src/compile.ts
+/**
+* Compiles a template string into a TypeScript 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 TypeScript 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 TypeScript render method body.
+*/
 function compile(input, cssVariableName) {
 	return generateRenderFunction(new Parser(new Lexer(input).tokenize()).parse(), cssVariableName);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xaendar/compiler",
-  "version": "0.6.14",
+  "version": "0.6.15",
   "description": "A library for transpiling Xaendar Templates into JavaScript code",
   "sideEffects": false,
   "type": "module",
@@ -16,8 +16,8 @@
     }
   },
   "dependencies": {
-    "@xaendar/common": "0.6.14",
-    "@xaendar/types": "0.6.14",
+    "@xaendar/common": "0.6.15",
+    "@xaendar/types": "0.6.15",
     "typescript": "^6.0.3"
   }
 }