xmlui 0.12.4 → 0.12.6

package/dist/bin/index.cjs

@@ -54,12 +54,19 @@ let path = require("path");
 path = __toESM(path);
 let __eslint_community_regexpp = require("@eslint-community/regexpp");
 __eslint_community_regexpp = __toESM(__eslint_community_regexpp);
+require("react");
+let lodash_es = require("lodash-es");
+lodash_es = __toESM(lodash_es);
 let node_fs = require("node:fs");
 node_fs = __toESM(node_fs);
 let node_url = require("node:url");
 node_url = __toESM(node_url);
 let node_path = require("node:path");
 node_path = __toESM(node_path);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises);
+let node_vm = require("node:vm");
+node_vm = __toESM(node_vm);
 let yargs_yargs = require("yargs/yargs");
 yargs_yargs = __toESM(yargs_yargs);
 let yargs_helpers = require("yargs/helpers");
@@ -71,7 +78,7 @@ vite_plugin_lib_inject_css = __toESM(vite_plugin_lib_inject_css);
 
 //#region ../node_modules/picomatch/lib/constants.js
 var require_constants = /* @__PURE__ */ __commonJS({ "../node_modules/picomatch/lib/constants.js": ((exports, module) => {
-	const path$5 = require("path");
+	const path$7 = require("path");
 	const WIN_SLASH = "\\\\/";
 	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 	/**
@@ -196,7 +203,7 @@ var require_constants = /* @__PURE__ */ __commonJS({ "../node_modules/picomatch/
 		CHAR_UNDERSCORE: 95,
 		CHAR_VERTICAL_LINE: 124,
 		CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
-		SEP: path$5.sep,
+		SEP: path$7.sep,
 		extglobChars(chars) {
 			return {
 				"!": {
@@ -235,7 +242,7 @@ var require_constants = /* @__PURE__ */ __commonJS({ "../node_modules/picomatch/
 //#endregion
 //#region ../node_modules/picomatch/lib/utils.js
 var require_utils = /* @__PURE__ */ __commonJS({ "../node_modules/picomatch/lib/utils.js": ((exports) => {
-	const path$4 = require("path");
+	const path$6 = require("path");
 	const win32$1 = process.platform === "win32";
 	const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = require_constants();
 	exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
@@ -255,7 +262,7 @@ var require_utils = /* @__PURE__ */ __commonJS({ "../node_modules/picomatch/lib/
 	};
 	exports.isWindows = (options) => {
 		if (options && typeof options.windows === "boolean") return options.windows;
-		return win32$1 === true || path$4.sep === "\\";
+		return win32$1 === true || path$6.sep === "\\";
 	};
 	exports.escapeLast = (input, char, lastIdx) => {
 		const idx = input.lastIndexOf(char, lastIdx);
@@ -1431,7 +1438,7 @@ var require_parse = /* @__PURE__ */ __commonJS({ "../node_modules/picomatch/lib/
 //#endregion
 //#region ../node_modules/picomatch/lib/picomatch.js
 var require_picomatch$1 = /* @__PURE__ */ __commonJS({ "../node_modules/picomatch/lib/picomatch.js": ((exports, module) => {
-	const path$3 = require("path");
+	const path$5 = require("path");
 	const scan = require_scan();
 	const parse = require_parse();
 	const utils = require_utils();
@@ -1570,7 +1577,7 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJS({ "../node_modules/picomatc
 	* @api public
 	*/
 	picomatch.matchBase = (input, glob$2, options, posix$1 = utils.isWindows(options)) => {
-		return (glob$2 instanceof RegExp ? glob$2 : picomatch.makeRe(glob$2, options)).test(path$3.basename(input));
+		return (glob$2 instanceof RegExp ? glob$2 : picomatch.makeRe(glob$2, options)).test(path$5.basename(input));
 	};
 	/**
 	* Returns true if **any** of the given glob `patterns` match the specified `string`.
@@ -5198,10 +5205,66 @@ var Parser = class {
 				endToken = this._lexer.peek();
 				this.expectToken(TokenType.RParent, "W006");
 			}
-			return this.createExpressionNode(T_NEW_EXPRESSION, {
+			let newExprResult = this.createExpressionNode(T_NEW_EXPRESSION, {
 				callee,
 				arguments: args
 			}, startToken, endToken);
+			let exitMemberLoop = false;
+			do {
+				const currentStart = this._lexer.peek();
+				switch (currentStart.type) {
+					case TokenType.LParent: {
+						this._lexer.get();
+						let invokeArgs = [];
+						if (this._lexer.peek().type !== TokenType.RParent) {
+							const expr = this.parseExpr();
+							if (!expr) {
+								this.reportError("W001");
+								return null;
+							}
+							invokeArgs = expr.type === T_SEQUENCE_EXPRESSION ? expr.exprs : [expr];
+						}
+						const invokeEndToken = this._lexer.peek();
+						this.expectToken(TokenType.RParent, "W006");
+						newExprResult = this.createExpressionNode(T_FUNCTION_INVOCATION_EXPRESSION, {
+							obj: newExprResult,
+							arguments: invokeArgs
+						}, startToken, invokeEndToken);
+						break;
+					}
+					case TokenType.Dot:
+					case TokenType.OptionalChaining: {
+						this._lexer.get();
+						const member = this._lexer.get();
+						if (!tokenTraits[member.type].keywordLike) {
+							this.reportError("W003");
+							return null;
+						}
+						newExprResult = this.createExpressionNode(T_MEMBER_ACCESS_EXPRESSION, {
+							obj: newExprResult,
+							member: member.text,
+							opt: currentStart.type === TokenType.OptionalChaining
+						}, startToken, member);
+						break;
+					}
+					case TokenType.LSquare: {
+						this._lexer.get();
+						const memberExpr = this.getExpression();
+						if (!memberExpr) return null;
+						const calcEndToken = this._lexer.peek();
+						this.expectToken(TokenType.RSquare, "W005");
+						newExprResult = this.createExpressionNode(T_CALCULATED_MEMBER_ACCESS_EXPRESSION, {
+							obj: newExprResult,
+							member: memberExpr
+						}, startToken, calcEndToken);
+						break;
+					}
+					default:
+						exitMemberLoop = true;
+						break;
+				}
+			} while (!exitMemberLoop);
+			return newExprResult;
 		}
 		if (startToken.type === TokenType.Identifier && startToken.text === "await") {
 			this._lexer.get();
@@ -6055,70 +6118,70 @@ var ModuleCache = class {
 	* @param path The module path
 	* @returns The resolved module or undefined if not cached
 	*/
-	static getResolved(path$6) {
-		return this.resolvedModules.get(path$6);
+	static getResolved(path$8) {
+		return this.resolvedModules.get(path$8);
 	}
 	/**
 	* Sets a resolved module in cache
 	* @param path The module path
 	* @param module The resolved module
 	*/
-	static setResolved(path$6, module$1) {
-		this.resolvedModules.set(path$6, module$1);
+	static setResolved(path$8, module$1) {
+		this.resolvedModules.set(path$8, module$1);
 	}
 	/**
 	* Checks if a resolved module is cached
 	* @param path The module path
 	* @returns True if the module is in cache
 	*/
-	static hasResolved(path$6) {
-		return this.resolvedModules.has(path$6);
+	static hasResolved(path$8) {
+		return this.resolvedModules.has(path$8);
 	}
 	/**
 	* Gets a parsed module from cache
 	* @param path The module path
 	* @returns The parsed module (or promise) or undefined if not cached
 	*/
-	static getParsed(path$6) {
-		return this.parsedModules.get(path$6);
+	static getParsed(path$8) {
+		return this.parsedModules.get(path$8);
 	}
 	/**
 	* Sets a parsed module in cache
 	* @param path The module path
 	* @param module The parsed module or promise
 	*/
-	static setParsed(path$6, module$1) {
-		this.parsedModules.set(path$6, module$1);
+	static setParsed(path$8, module$1) {
+		this.parsedModules.set(path$8, module$1);
 	}
 	/**
 	* Checks if a parsed module is cached
 	* @param path The module path
 	* @returns True if the module is in cache
 	*/
-	static hasParsed(path$6) {
-		return this.parsedModules.has(path$6);
+	static hasParsed(path$8) {
+		return this.parsedModules.has(path$8);
 	}
 	/**
 	* Checks if a module is currently being parsed (to detect circular dependencies at parse level)
 	* @param path The module path
 	* @returns True if the module is currently being parsed
 	*/
-	static isCurrentlyParsing(path$6) {
-		return this.currentlyParsing.has(path$6);
+	static isCurrentlyParsing(path$8) {
+		return this.currentlyParsing.has(path$8);
 	}
 	/**
 	* Mark a module as currently being parsed
 	* @param path The module path
 	*/
-	static markCurrentlyParsing(path$6) {
-		this.currentlyParsing.add(path$6);
+	static markCurrentlyParsing(path$8) {
+		this.currentlyParsing.add(path$8);
 	}
 	/**
 	* Mark a module as no longer being parsed
 	* @param path The module path
 	*/
-	static unmarkCurrentlyParsing(path$6) {
-		this.currentlyParsing.delete(path$6);
+	static unmarkCurrentlyParsing(path$8) {
+		this.currentlyParsing.delete(path$8);
 	}
 	/**
 	* Clears all caches (both resolved and parsed modules) and resets parsing state
@@ -6187,9 +6250,9 @@ var FilePathResolver = class {
 	* @returns The normalized path
 	* @throws Error if path tries to go above root
 	*/
-	normalizePath(path$6) {
-		const isAbsolute$1 = path$6.startsWith("/");
-		const segments = (isAbsolute$1 ? path$6.substring(1) : path$6).split("/").filter((seg) => seg !== "");
+	normalizePath(path$8) {
+		const isAbsolute$1 = path$8.startsWith("/");
+		const segments = (isAbsolute$1 ? path$8.substring(1) : path$8).split("/").filter((seg) => seg !== "");
 		const normalized = [];
 		for (const segment of segments) if (segment === ".") continue;
 		else if (segment === "..") {
@@ -6282,16 +6345,16 @@ var PathResolver = class {
 	* @param path The path to check
 	* @returns True if the path is a URL
 	*/
-	static isUrl(path$6) {
-		return path$6.startsWith("http://") || path$6.startsWith("https://");
+	static isUrl(path$8) {
+		return path$8.startsWith("http://") || path$8.startsWith("https://");
 	}
 	/**
 	* Checks if a given string is a file path
 	* @param path The path to check
 	* @returns True if the path is a file path
 	*/
-	static isFilePath(path$6) {
-		return !this.isUrl(path$6);
+	static isFilePath(path$8) {
+		return !this.isUrl(path$8);
 	}
 	/**
 	* Gets the file name from a path or URL
@@ -6331,9 +6394,9 @@ var PathResolver = class {
 	* @returns The normalized path
 	* @throws Error if path tries to go above root
 	*/
-	static normalizePath(path$6) {
-		if (this.isUrl(path$6)) return path$6;
-		return new FilePathResolver()["normalizePath"](path$6);
+	static normalizePath(path$8) {
+		if (this.isUrl(path$8)) return path$8;
+		return new FilePathResolver()["normalizePath"](path$8);
 	}
 };
 
@@ -6730,8 +6793,8 @@ async function doParseModule(moduleName, source, moduleFetcher) {
 		const resolvedModule = await ModuleResolver.resolveAndFetchModule(importDecl.source.value, moduleName);
 		const importedModuleResult = await parseScriptModuleAsync(resolvedModule.path, resolvedModule.content, moduleFetcher);
 		if (isModuleErrors(importedModuleResult)) {
-			Object.entries(importedModuleResult).forEach(([path$6, errs]) => {
-				moduleErrors[path$6] = errs;
+			Object.entries(importedModuleResult).forEach(([path$8, errs]) => {
+				moduleErrors[path$8] = errs;
 				if (errs.some((e) => e.code === ErrorCodes.reactiveVarInImportedModule || e.code === ErrorCodes.constLetInImportedModule)) hasValidationErrors = true;
 			});
 			continue;
@@ -6854,6 +6917,26 @@ const ARROW_EXPR_MARK = "_ARROW_EXPR_";
 * ```
 */
 const PARSED_EVENT_MARK = Symbol.for("__XMLUI_PARSED_EVENT__");
+/**
+* Type guard for arrow expression objects.
+*
+* Checks if a value is an executable arrow function expression.
+* These can be called with appropriate context and arguments.
+*
+* @param value - The value to check
+* @returns `true` if the value is an arrow expression object
+*
+* @example
+* ```typescript
+* const fn = evaluateArrowExpression(node);
+* if (isArrowExpressionObject(fn)) {
+*   const result = executeFunction(fn, args);
+* }
+* ```
+*/
+function isArrowExpressionObject(value) {
+	return typeof value === "object" && value !== null && ARROW_EXPR_MARK in value && value[ARROW_EXPR_MARK] === true;
+}
 
 //#endregion
 //#region src/parsers/scripting/types.ts
@@ -6944,11 +7027,11 @@ var ModuleLoader = class {
 	* }
 	* ```
 	*/
-	static async loadModule(path$6, options = {}) {
+	static async loadModule(path$8, options = {}) {
 		const { fetcher, allowImports = true, baseUrl, skipCache = false } = options;
 		try {
-			let resolvedPath = path$6;
-			if (baseUrl && !PathResolver.isUrl(path$6) && !PathResolver.isFilePath(path$6)) resolvedPath = PathResolver.resolve(path$6, baseUrl);
+			let resolvedPath = path$8;
+			if (baseUrl && !PathResolver.isUrl(path$8) && !PathResolver.isFilePath(path$8)) resolvedPath = PathResolver.resolve(path$8, baseUrl);
 			if (!skipCache && ModuleCache.hasParsed(resolvedPath)) {
 				const cached = ModuleCache.getParsed(resolvedPath);
 				if (cached && !(cached instanceof Promise)) return ok(cached);
@@ -6959,7 +7042,7 @@ var ModuleLoader = class {
 			return await this.parseWithImports(resolvedPath, content, fetcher);
 		} catch (error) {
 			const errorMessage = error instanceof Error ? error.message : String(error);
-			return err({ [path$6]: [{
+			return err({ [path$8]: [{
 				code: "MODULE_LOAD_ERROR",
 				text: errorMessage,
 				position: 0,
@@ -7012,8 +7095,8 @@ var ModuleLoader = class {
 	* @param path The module path to check
 	* @returns True if the module is cached
 	*/
-	static isCached(path$6) {
-		return ModuleCache.hasParsed(path$6);
+	static isCached(path$8) {
+		return ModuleCache.hasParsed(path$8);
 	}
 	/**
 	* Fetches module content from a resolved path
@@ -7036,8 +7119,8 @@ var ModuleLoader = class {
 	* Parses a module with full import support
 	*/
 	static async parseWithImports(moduleName, source, fetcher) {
-		const result = await parseScriptModuleAsync(moduleName, source, fetcher || (async (path$6) => {
-			return (await ModuleResolver.resolveModule(path$6)).content;
+		const result = await parseScriptModuleAsync(moduleName, source, fetcher || (async (path$8) => {
+			return (await ModuleResolver.resolveModule(path$8)).content;
 		}));
 		if (this.isModuleErrors(result)) return err(result);
 		return ok(result);
@@ -8193,6 +8276,17 @@ function isLineBreak(ch) {
 	return ch === CharacterCodes.lineFeed || ch === CharacterCodes.carriageReturn || ch === CharacterCodes.lineSeparator || ch === CharacterCodes.paragraphSeparator;
 }
 
+//#endregion
+//#region src/abstractions/AppContextDefs.ts
+const MediaBreakpointKeys = [
+	"xs",
+	"sm",
+	"md",
+	"lg",
+	"xl",
+	"xxl"
+];
+
 //#endregion
 //#region src/parsers/xmlui-parser/transform.ts
 const COMPOUND_COMP_ID = "Component";
@@ -8443,6 +8537,14 @@ function nodeToComponentDef(node, originalGetText, fileId, preResolvedImports) {
 				comp.uses = splitUsesValue(value);
 				return;
 			default:
+				if (name.startsWith("when-")) {
+					const bp = name.slice(5);
+					if (MediaBreakpointKeys.includes(bp)) {
+						comp.responsiveWhen ??= {};
+						comp.responsiveWhen[bp] = value;
+						return;
+					}
+				}
 				if (startSegment === "var") {
 					comp.vars ??= {};
 					comp.vars[name] = value;
@@ -9136,124 +9238,1894 @@ function splitUsesValue(value) {
 }
 
 //#endregion
-//#region src/language-server/base/text-document.ts
-var DocumentCursor = class {
-	constructor(text) {
-		this.text = text;
-		this.newlineOffsets = [0];
-		for (let i = 0; i < text.length; i++) {
-			const ch = text.charCodeAt(i);
-			if (isEOL(ch)) {
-				if (ch === 13 && i + 1 < text.length && text.charCodeAt(i + 1) === 10) i++;
-				this.newlineOffsets.push(i + 1);
-			}
+//#region src/components-core/script-runner/ParameterParser.ts
+/**
+* This function parses a parameter string and splits them into string literal and binding expression sections
+* @param source String to parse
+* @returns Parameter string sections
+*/
+function parseParameterString(source) {
+	const result = [];
+	if (source === void 0 || source === null) return result;
+	let phase = ParsePhase.StringLiteral;
+	let section = "";
+	let escape = "";
+	for (let i = 0; i < source.length; i++) {
+		const ch = source[i];
+		switch (phase) {
+			case ParsePhase.StringLiteral:
+				if (ch === "\\") {
+					phase = ParsePhase.Escape;
+					escape = "\\";
+				} else if (ch === "{") {
+					if (section !== "") result.push({
+						type: "literal",
+						value: section
+					});
+					section = "";
+					phase = ParsePhase.ExprStart;
+				} else section += ch;
+				break;
+			case ParsePhase.Escape:
+				if (ch === "\\") {
+					escape += ch;
+					break;
+				}
+				if (ch === "{") section += escape.substring(1) + ch;
+				else section += escape + ch;
+				phase = ParsePhase.StringLiteral;
+				break;
+			case ParsePhase.ExprStart:
+				const exprSource = source.substring(i);
+				const parser = new Parser(source.substring(i));
+				let expr = null;
+				try {
+					expr = parser.parseExpr();
+				} catch (err$1) {
+					throw new Error(`Cannot parse expression: '${exprSource}': ${err$1}`);
+				}
+				const tail = parser.getTail();
+				if (!tail || tail.trim().length < 1 || tail.trim()[0] !== "}") throw new Error(`Unclosed expression: '${source}'\n'${exprSource}'`);
+				else {
+					result.push({
+						type: "expression",
+						value: expr
+					});
+					i = source.length - tail.length;
+					section = "";
+				}
+				phase = ParsePhase.StringLiteral;
+				break;
 		}
 	}
-	get textLength() {
-		return this.text.length;
+	switch (phase) {
+		case ParsePhase.StringLiteral:
+			if (section !== "") result.push({
+				type: "literal",
+				value: section
+			});
+			break;
+		case ParsePhase.Escape:
+			result.push({
+				type: "literal",
+				value: section + escape
+			});
+			break;
+		case ParsePhase.ExprStart:
+			result.push({
+				type: "literal",
+				value: section + "{"
+			});
+			break;
 	}
-	get lineCount() {
-		return this.newlineOffsets.length;
+	return result;
+}
+var ParsePhase = /* @__PURE__ */ function(ParsePhase$1) {
+	ParsePhase$1[ParsePhase$1["StringLiteral"] = 0] = "StringLiteral";
+	ParsePhase$1[ParsePhase$1["Escape"] = 1] = "Escape";
+	ParsePhase$1[ParsePhase$1["ExprStart"] = 2] = "ExprStart";
+	return ParsePhase$1;
+}(ParsePhase || {});
+
+//#endregion
+//#region src/components-core/script-runner/bannedFunctions.ts
+/**
+* Checks if the specified function object is banned from running.
+* @param func Function to check
+* @return Information about the banned state, including a helper text
+*/
+function isBannedFunction(func) {
+	if (func === void 0) return { banned: false };
+	const bannedInfo = bannedFunctions.find((f) => f.func === func);
+	return bannedInfo ? {
+		banned: true,
+		func: bannedInfo.func,
+		help: bannedInfo.help
+	} : { banned: false };
+}
+/**
+* List of global functions we do not allow to call
+*/
+const bannedFunctions = [
+	{ func: globalThis.cancelAnimationFrame },
+	{ func: globalThis.cancelIdleCallback },
+	{ func: globalThis.clearInterval },
+	{ func: globalThis.clearImmediate },
+	{ func: globalThis.clearTimeout },
+	{ func: globalThis.eval },
+	{ func: globalThis.queueMicrotask },
+	{ func: globalThis.requestAnimationFrame },
+	{ func: globalThis.requestIdleCallback },
+	{ func: globalThis.setImmediate },
+	{ func: globalThis.setInterval },
+	{
+		func: globalThis.setTimeout,
+		help: "Use 'delay'"
 	}
-	/**
-	* Converts a zero-based offset to a position.
-	*
-	* @param offset A zero-based offset.
-	* @return A valid {@link Position position}.
-	* @example The text document "ab\ncd" produces:
-	* * position { line: 0, character: 0 } for `offset` 0.
-	* * position { line: 0, character: 1 } for `offset` 1.
-	* * position { line: 0, character: 2 } for `offset` 2.
-	* * position { line: 1, character: 0 } for `offset` 3.
-	* * position { line: 1, character: 1 } for `offset` 4.
-	*/
-	positionAt(offset) {
-		offset = Math.max(Math.min(offset, this.textLength), 0);
-		const lineOffsets = this.newlineOffsets;
-		let low = 0, high = lineOffsets.length;
-		if (high === 0) return {
-			line: 0,
-			character: offset
-		};
-		while (low < high) {
-			const mid = Math.floor((low + high) / 2);
-			if (lineOffsets[mid] > offset) high = mid;
-			else low = mid + 1;
+];
+
+//#endregion
+//#region src/components-core/script-runner/eval-tree-common.ts
+function getExprValue(expr, thread) {
+	return thread?.valueCache?.get(expr)?.value;
+}
+function setExprValue(expr, value, thread) {
+	thread.valueCache ??= /* @__PURE__ */ new Map();
+	thread.valueCache.set(expr, { value });
+}
+function isPromise(obj) {
+	return obj && typeof obj.then === "function";
+}
+function evalLiteral(thisStack, expr, thread) {
+	setExprValue(expr, { value: expr.value }, thread);
+	thisStack.push(expr.value);
+	return expr.value;
+}
+function getIdentifierScope(expr, evalContext, thread) {
+	let type;
+	let scope;
+	if (expr.isGlobal) {
+		scope = globalThis;
+		type = "global";
+	} else {
+		let currentThread = thread ?? evalContext.mainThread;
+		while (currentThread && !scope) {
+			if (currentThread.blocks) for (let idx = currentThread.blocks.length - 1; idx >= 0; idx--) {
+				const blockContext = currentThread.blocks[idx]?.vars;
+				if (blockContext && expr.name in blockContext) {
+					scope = blockContext;
+					type = "block";
+					break;
+				}
+			}
+			if (scope) break;
+			if (currentThread.closures) for (let idx = currentThread.closures.length - 1; idx >= 0; idx--) {
+				const blockContext = currentThread.closures[idx]?.vars;
+				if (blockContext && expr.name in blockContext) {
+					scope = blockContext;
+					type = "block";
+					break;
+				}
+			}
+			if (scope) break;
+			currentThread = currentThread.parent;
 		}
-		const line = low - 1;
-		return {
-			line,
-			character: offset - lineOffsets[line]
-		};
 	}
-	/**
-	* Converts the position to a zero-based offset.
-	* Invalid positions are adjusted as described in {@link Position.line}
-	* and {@link Position.character}.
-	*
-	* @param position A position.
-	* @return A valid zero-based offset.
-	*/
-	offsetAt(position) {
-		if (position.line >= this.newlineOffsets.length) return this.textLength;
-		else if (position.line < 0) return 0;
-		const lineOffset = this.newlineOffsets[position.line];
-		if (position.character <= 0) return lineOffset;
-		const nextLineOffset = position.line + 1 < this.newlineOffsets.length ? this.newlineOffsets[position.line + 1] : this.textLength;
-		return Math.min(lineOffset + position.character, nextLineOffset);
+	if (!scope) if (evalContext.localContext && expr.name in evalContext.localContext) {
+		scope = evalContext.localContext;
+		type = "localContext";
+	} else if (evalContext.appContext?.[expr.name] !== void 0) {
+		scope = evalContext.appContext;
+		type = "app";
+	} else {
+		scope = globalThis;
+		type = "global";
 	}
-	offsetToDisplayPos(offset) {
-		const pos = this.positionAt(offset);
-		return {
-			line: pos.line + 1,
-			character: pos.character + 1
+	return {
+		type,
+		scope
+	};
+}
+function evalIdentifier(thisStack, expr, evalContext, thread) {
+	let value;
+	const valueScope = getIdentifierScope(expr, evalContext, thread).scope;
+	let valueIndex = expr.name;
+	value = valueScope[valueIndex];
+	setExprValue(expr, {
+		valueScope,
+		valueIndex,
+		value
+	}, thread);
+	thisStack.push(value);
+	return value;
+}
+function getRootIdScope(expr, evalContext, thread) {
+	switch (expr.type) {
+		case T_IDENTIFIER: return {
+			type: getIdentifierScope(expr, evalContext, thread).type,
+			name: expr.name
 		};
+		case T_MEMBER_ACCESS_EXPRESSION: return getRootIdScope(expr.obj, evalContext, thread);
+		case T_CALCULATED_MEMBER_ACCESS_EXPRESSION: return getRootIdScope(expr.obj, evalContext, thread);
 	}
-	getSurroundingContext(pos, end, surroundingLines) {
-		const startLine = this.positionAt(pos).line;
-		const endLine = this.positionAt(end).line;
-		const contextStartLine = Math.max(0, startLine - surroundingLines);
-		const contextPos = this.newlineOffsets[contextStartLine];
-		const nextLineAfterContext = Math.min(this.lineCount - 1, endLine + surroundingLines) + 1;
-		let contextEnd;
-		if (nextLineAfterContext < this.lineCount) {
-			const nextLineStart = this.newlineOffsets[nextLineAfterContext];
-			let eolLength = 1;
-			if (nextLineStart > 0 && this.text.charCodeAt(nextLineStart - 1) === 10) {
-				if (nextLineStart > 1 && this.text.charCodeAt(nextLineStart - 2) === 13) eolLength = 2;
-			}
-			contextEnd = nextLineStart - eolLength;
-		} else contextEnd = this.textLength;
-		return {
-			contextPos,
-			contextEnd
-		};
+	return null;
+}
+function evalMemberAccessCore(thisStack, expr, evalContext, thread) {
+	const parentObj = getExprValue(expr.obj, thread)?.value;
+	const value = expr.opt || evalContext.options?.defaultToOptionalMemberAccess ? parentObj?.[expr.member] : parentObj[expr.member];
+	setExprValue(expr, {
+		valueScope: parentObj,
+		valueIndex: expr.member,
+		value
+	}, thread);
+	thisStack.push(value);
+	return value;
+}
+function evalCalculatedMemberAccessCore(thisStack, expr, evalContext, thread) {
+	const parentObj = getExprValue(expr.obj, thread)?.value;
+	const memberObj = getExprValue(expr.member, thread)?.value;
+	const value = evalContext.options?.defaultToOptionalMemberAccess ? parentObj?.[memberObj] : parentObj[memberObj];
+	setExprValue(expr, {
+		valueScope: parentObj,
+		valueIndex: memberObj,
+		value
+	}, thread);
+	thisStack.push(value);
+	return value;
+}
+function evalUnaryCore(expr, thisStack, evalContext, thread) {
+	let value;
+	const operand = getExprValue(expr.expr, thread);
+	const operValue = operand?.value;
+	switch (expr.op) {
+		case "typeof":
+			value = typeof operValue;
+			break;
+		case "delete":
+			if (operand.valueScope && operand.valueIndex) value = delete operand.valueScope[operand.valueIndex];
+			else value = false;
+			break;
+		case "+":
+			value = operValue;
+			break;
+		case "-":
+			value = -operValue;
+			break;
+		case "!":
+			value = !operValue;
+			break;
+		case "~":
+			value = ~operValue;
+			break;
+		default: throw new Error(`Unknown unary operator: ${expr.op}`);
 	}
-	rangeAt(range) {
-		return {
-			start: this.positionAt(range.pos),
-			end: this.positionAt(range.end)
-		};
+	setExprValue(expr, { value }, thread);
+	thisStack.push(value);
+	return value;
+}
+function evalBinaryCore(expr, thisStack, evalContext, thread) {
+	let value;
+	const l = getExprValue(expr.left, thread)?.value;
+	const r = getExprValue(expr.right, thread)?.value;
+	switch (expr.op) {
+		case "**":
+			value = l ** r;
+			break;
+		case "*":
+			value = l * r;
+			break;
+		case "/":
+			value = l / r;
+			break;
+		case "%":
+			value = l % r;
+			break;
+		case "+":
+			value = l + r;
+			break;
+		case "-":
+			value = l - r;
+			break;
+		case ">>":
+			value = l >> r;
+			break;
+		case ">>>":
+			value = l >>> r;
+			break;
+		case "<<":
+			value = l << r;
+			break;
+		case "<":
+			value = l < r;
+			break;
+		case "<=":
+			value = l <= r;
+			break;
+		case ">":
+			value = l > r;
+			break;
+		case ">=":
+			value = l >= r;
+			break;
+		case "in":
+			value = l in r;
+			break;
+		case "==":
+			value = l == r;
+			break;
+		case "!=":
+			value = l != r;
+			break;
+		case "===":
+			value = l === r;
+			break;
+		case "!==":
+			value = l !== r;
+			break;
+		case "&":
+			value = l & r;
+			break;
+		case "^":
+			value = l ^ r;
+			break;
+		case "|":
+			value = l | r;
+			break;
+		case "&&":
+			value = l && r;
+			break;
+		case "||":
+			value = l || r;
+			break;
+		case "??":
+			value = l ?? r;
+			break;
+		default: throw new Error(`Unknown binary operator: ${expr.op}`);
 	}
-	offsetRangeAt(range) {
-		return {
-			pos: this.offsetAt(range.start),
-			end: this.offsetAt(range.end)
-		};
+	setExprValue(expr, { value }, thread);
+	thisStack.push(value);
+	return value;
+}
+function evalAssignmentCore(thisStack, expr, evalContext, thread) {
+	const leftValue = getExprValue(expr.leftValue, thread);
+	const newValue = getExprValue(expr.expr, thread)?.value;
+	if (!leftValue.valueScope || leftValue.valueIndex === void 0 || leftValue.valueIndex === null) throw new Error(`Evaluation of ${expr.op} requires a left-hand value.`);
+	const leftScope = leftValue.valueScope;
+	const leftIndex = leftValue.valueIndex;
+	if (typeof leftScope !== "object" || leftScope === null) throw new Error(`Unknown left-hand value`);
+	if (expr.leftValue.type === T_IDENTIFIER) {
+		if (isConstVar(expr.leftValue.name, thread)) throw new Error("A const variable cannot be modified");
+	}
+	if (leftScope === globalThis && !(leftIndex in leftScope)) throw new Error(`Left value variable (${leftIndex}) not found in the scope.`);
+	thisStack.pop();
+	switch (expr.op) {
+		case "=":
+			leftScope[leftIndex] = newValue;
+			break;
+		case "+=":
+			leftScope[leftIndex] += newValue;
+			break;
+		case "-=":
+			leftScope[leftIndex] -= newValue;
+			break;
+		case "**=":
+			leftScope[leftIndex] **= newValue;
+			break;
+		case "*=":
+			leftScope[leftIndex] *= newValue;
+			break;
+		case "/=":
+			leftScope[leftIndex] /= newValue;
+			break;
+		case "%=":
+			leftScope[leftIndex] %= newValue;
+			break;
+		case "<<=":
+			leftScope[leftIndex] <<= newValue;
+			break;
+		case ">>=":
+			leftScope[leftIndex] >>= newValue;
+			break;
+		case ">>>=":
+			leftScope[leftIndex] >>>= newValue;
+			break;
+		case "&=":
+			leftScope[leftIndex] &= newValue;
+			break;
+		case "^=":
+			leftScope[leftIndex] ^= newValue;
+			break;
+		case "|=":
+			leftScope[leftIndex] |= newValue;
+			break;
+		case "&&=":
+			leftScope[leftIndex] &&= newValue;
+			break;
+		case "||=":
+			leftScope[leftIndex] ||= newValue;
+			break;
+		case "??=":
+			leftScope[leftIndex] += newValue;
+			break;
 	}
-};
-function isEOL(char) {
-	return char === 13 || char === 10;
+	const value = leftScope[leftIndex];
+	setExprValue(expr, { value }, thread);
+	thisStack.push(value);
+	return value;
+}
+function evalPreOrPostCore(thisStack, expr, evalContext, thread) {
+	const operand = getExprValue(expr.expr, thread);
+	if (!operand.valueScope || operand.valueIndex === void 0) throw new Error(`Evaluation of ${expr.op} requires a left-hand value.`);
+	if (expr.expr.type === T_IDENTIFIER) {
+		if (isConstVar(expr.expr.name, thread)) throw new Error("A const variable cannot be modified");
+	}
+	const value = expr.op === "++" ? expr.type === T_PREFIX_OP_EXPRESSION ? ++operand.valueScope[operand.valueIndex] : operand.valueScope[operand.valueIndex]++ : expr.type === T_PREFIX_OP_EXPRESSION ? --operand.valueScope[operand.valueIndex] : operand.valueScope[operand.valueIndex]--;
+	setExprValue(expr, { value }, thread);
+	thisStack.push(value);
+	return value;
+}
+function evalArrow(thisStack, expr, thread) {
+	if (expr.async) throw new Error("XMLUI does not support async arrow functions.");
+	const lazyArrow = {
+		...expr,
+		_ARROW_EXPR_: true,
+		closureContext: obtainClosures(thread)
+	};
+	setExprValue(expr, { value: lazyArrow }, thread);
+	thisStack.push(lazyArrow);
+	return lazyArrow;
+}
+function obtainClosures(thread) {
+	const closures = thread.blocks?.slice(0) ?? [];
+	return thread.parent ? [...obtainClosures(thread.parent), ...closures] : closures;
+}
+/**
+* Gets the context of the variable
+* @param id Identifier to test
+* @param thread Thread to use for evaluation
+*/
+function isConstVar(id, thread) {
+	if (thread.blocks) for (let idx = thread.blocks.length; idx >= 0; idx--) {
+		const constContext = thread.blocks[idx]?.constVars;
+		if (constContext && constContext.has(id)) return true;
+	}
+	return false;
+}
+function evalTemplateLiteralCore(segmentValues) {
+	return segmentValues.map((value) => typeof value === "string" ? value : `${value}`).join("");
 }
 
 //#endregion
-//#region src/parsers/xmlui-parser/parser.ts
-const RECOVER_FILE = [
-	SyntaxKind.CData,
-	SyntaxKind.Script,
-	SyntaxKind.OpenNodeStart
-];
-const RECOVER_OPEN_TAG = [
+//#region src/components-core/script-runner/statement-queue.ts
+var StatementQueue = class {
+	constructor() {
+		this.items = [];
+	}
+	get length() {
+		return this.items.length;
+	}
+	peek() {
+		return this.items[0];
+	}
+	dequeue() {
+		return this.items.shift();
+	}
+	push(statements) {
+		this.items.push(...statements);
+	}
+	unshift(statements) {
+		this.items.unshift(...statements);
+	}
+	clearToLabel(label) {
+		while (this.items.length > 0 && this.items[0].label !== label) this.items.shift();
+	}
+};
+let nextLabelValue = 1;
+function mapToItem(statement) {
+	return [{
+		label: nextLabelValue++,
+		statement: { ...statement }
+	}];
+}
+function mapStatementToQueueItem(stmt) {
+	return {
+		label: nextLabelValue++,
+		statement: stmt.statement,
+		execInfo: { ...stmt.execInfo }
+	};
+}
+function mapStatementsToQueueItems(statements) {
+	return statements.map(mapStatementToQueueItem);
+}
+
+//#endregion
+//#region src/components-core/script-runner/process-statement-common.ts
+function innermostLoopScope(thread) {
+	if (!thread.loops || thread.loops.length === 0) throw new Error("Missing loop scope");
+	return thread.loops[thread.loops.length - 1];
+}
+function innermostBlockScope(thread) {
+	if (!thread.blocks || thread.blocks.length === 0) return void 0;
+	return thread.blocks[thread.blocks.length - 1];
+}
+function innermostTryScope(thread) {
+	if (!thread.tryBlocks || thread.tryBlocks.length === 0) throw new Error("Missing try scope");
+	return thread.tryBlocks[thread.tryBlocks.length - 1];
+}
+function createLoopScope(thread, continueOffset = 0) {
+	thread.loops ??= [];
+	const breakDepth = thread.blocks?.length ?? 0;
+	const tryDepth = thread.tryBlocks?.length ?? 0;
+	const loopScope = {
+		breakLabel: -1,
+		continueLabel: -1,
+		breakBlockDepth: breakDepth,
+		continueBlockDepth: breakDepth + continueOffset,
+		tryBlockDepth: tryDepth
+	};
+	thread.loops.push(loopScope);
+	return loopScope;
+}
+function releaseLoopScope(thread, skipContinuation = true) {
+	const loopScope = innermostLoopScope(thread);
+	if (skipContinuation) thread.loops?.pop();
+	if (thread.blocks) thread.blocks.length = skipContinuation ? loopScope.breakBlockDepth : loopScope.continueBlockDepth;
+}
+function toStatementItems(statements) {
+	return statements.map((s) => ({ statement: s }));
+}
+function guard(statement) {
+	return {
+		statement,
+		execInfo: { guard: true }
+	};
+}
+function closing() {
+	return {
+		statement: {
+			type: T_EMPTY_STATEMENT,
+			nodeId: createXmlUiTreeNodeId()
+		},
+		execInfo: { removeBlockScope: true }
+	};
+}
+function provideLoopBody(loopScope, loopStatement, breakLabelValue) {
+	const guardStatement = guard(loopStatement);
+	const toUnshift = mapStatementsToQueueItems([{ statement: loopStatement.body }, guardStatement]);
+	loopScope.breakLabel = breakLabelValue ?? -1;
+	loopScope.continueLabel = toUnshift[1].label;
+	return toUnshift;
+}
+function createTryScope(thread, tryStatement) {
+	thread.tryBlocks ??= [];
+	const loopScope = {
+		statement: tryStatement,
+		processingPhase: "try",
+		tryLabel: -1
+	};
+	thread.tryBlocks.push(loopScope);
+	return loopScope;
+}
+function provideTryBody(thread, tryScope) {
+	const guardStatement = guard(tryScope.statement);
+	thread.blocks.push({ vars: {} });
+	const toUnshift = mapStatementsToQueueItems([
+		...toStatementItems(tryScope.statement.tryB.stmts),
+		closing(),
+		guardStatement
+	]);
+	tryScope.tryLabel = toUnshift[toUnshift.length - 1].label;
+	return toUnshift;
+}
+function provideCatchBody(thread, tryScope) {
+	const guardStatement = guard(tryScope.statement);
+	thread.blocks.push({ vars: {} });
+	const toUnshift = mapStatementsToQueueItems([
+		...toStatementItems(tryScope.statement.catchB.stmts),
+		closing(),
+		guardStatement
+	]);
+	tryScope.tryLabel = toUnshift[toUnshift.length - 1].label;
+	return toUnshift;
+}
+function provideFinallyBody(thread, tryScope) {
+	const guardStatement = guard(tryScope.statement);
+	thread.blocks.push({ vars: {} });
+	const finallyBlock = tryScope.statement.finallyB;
+	const toUnshift = mapStatementsToQueueItems([
+		...toStatementItems(finallyBlock ? finallyBlock.stmts : []),
+		closing(),
+		guardStatement
+	]);
+	tryScope.tryLabel = toUnshift[toUnshift.length - 1].label;
+	return toUnshift;
+}
+function provideFinallyErrorBody(tryScope) {
+	const toUnshift = mapStatementsToQueueItems([guard(tryScope.statement)]);
+	tryScope.tryLabel = toUnshift[0].label;
+	return toUnshift;
+}
+function ensureMainThread(evalContext) {
+	if (!evalContext.mainThread) evalContext.mainThread = {
+		childThreads: [],
+		blocks: [{ vars: {} }],
+		loops: [],
+		breakLabelValue: -1
+	};
+	return evalContext.mainThread;
+}
+function hoistFunctionDeclarations(thread, statements) {
+	const block = innermostBlockScope(thread);
+	if (!block) throw new Error("Missing block scope");
+	statements.filter((stmt) => stmt.type === T_FUNCTION_DECLARATION).forEach((stmt) => {
+		const funcDecl = stmt;
+		const arrowExpression = {
+			type: T_ARROW_EXPRESSION,
+			args: funcDecl.args,
+			statement: funcDecl.stmt,
+			closureContext: obtainClosures(thread),
+			_ARROW_EXPR_: true
+		};
+		const id = funcDecl.id.name;
+		if (block.vars[id]) throw new Error(`Variable ${id} is already declared in the current scope.`);
+		block.vars[id] = arrowExpression;
+		block.constVars ??= /* @__PURE__ */ new Set();
+		block.constVars.add(id);
+	});
+}
+
+//#endregion
+//#region src/components-core/EngineError.ts
+/**
+* The abstract base class of all UI engine errors
+*/
+var EngineError = class EngineError extends Error {
+	constructor(message) {
+		super(message);
+		Object.setPrototypeOf(this, EngineError.prototype);
+	}
+};
+/**
+* Custom exception indicating a parser error
+*/
+var ScriptParseError = class ScriptParseError extends EngineError {
+	constructor(message, source, position) {
+		message = `Parser Error: ${message}`;
+		super(message);
+		this.source = source;
+		this.position = position;
+		this.errorCategory = "ScriptParserError";
+		Object.setPrototypeOf(this, ScriptParseError.prototype);
+	}
+};
+/**
+* Custom exception signing parsing error
+*/
+var StatementExecutionError = class StatementExecutionError extends EngineError {
+	constructor(message, source) {
+		super(message);
+		this.source = source;
+		this.errorCategory = "StatementExecutionError";
+		Object.setPrototypeOf(this, StatementExecutionError.prototype);
+	}
+};
+/**
+* We throw this error when a throw statement is executed
+*/
+var ThrowStatementError = class ThrowStatementError extends EngineError {
+	constructor(errorObject) {
+		const message = typeof errorObject === "string" ? errorObject : errorObject?.message || "Error without message";
+		super(message);
+		this.errorObject = errorObject;
+		this.errorCategory = "ThrowStatementError";
+		this.message = message;
+		Object.setPrototypeOf(this, ThrowStatementError.prototype);
+	}
+};
+
+//#endregion
+//#region src/components-core/reportEngineError.ts
+const appErrors = [];
+/**
+* Use this function to report an error
+* @param error Error or string describing the error to report
+* @param errorToThrow The error to throw
+*/
+function reportEngineError(error, errorToThrow) {
+	if (typeof error === "string") error = new Error(error);
+	let helperMessage = "";
+	let colors = [];
+	if (error instanceof ScriptParseError) {
+		let pos = (error?.position ?? 0) - 1;
+		if (error.source) {
+			while (pos < error.source.length - 1 && error.source[pos] === " ") pos++;
+			helperMessage += `%c${error.message}%c\n\n`;
+			helperMessage += `${error.source.substring(0, pos)}%c${error.source[pos]}%c${error.source.substring(pos + 1) ?? ""}\n\n`;
+		}
+		helperMessage += `%cThe error handler associated with the parsed code did not run.%c`;
+		colors = [
+			"color: red",
+			"color: inherited",
+			"color: red",
+			"color: inherited",
+			"color: orange",
+			"color: inherited"
+		];
+	} else if (error instanceof StatementExecutionError) {
+		helperMessage += `%cError while executing code: ${error.message}%c`;
+		if (error.source) helperMessage += `\n\n${error.source}`;
+		colors = ["color: red", "color: inherited"];
+	} else if (error instanceof ThrowStatementError) {
+		helperMessage += `A 'throw' statement executed:\n\n%c${error.message}%c\n\n${error.errorObject}`;
+		colors = ["color: red", "color: inherited"];
+	}
+	if (helperMessage) console.error(helperMessage, ...colors);
+	appErrors.push({
+		error,
+		helperMessage,
+		colors
+	});
+	throw errorToThrow ?? error;
+}
+
+//#endregion
+//#region src/components-core/script-runner/process-statement-sync.ts
+const SYNC_EVAL_TIMEOUT = 1e3;
+function processStatementQueue(statements, evalContext, thread) {
+	if (!thread) thread = ensureMainThread(evalContext);
+	hoistFunctionDeclarations(thread, statements);
+	evalContext.startTick = (/* @__PURE__ */ new Date()).valueOf();
+	const queue = new StatementQueue();
+	queue.push(mapStatementsToQueueItems(toStatementItems(statements)));
+	const diagInfo = {
+		processedStatements: 0,
+		maxQueueLength: queue.length,
+		unshiftedItems: 0,
+		clearToLabels: 0,
+		maxBlocks: 0,
+		maxLoops: 0
+	};
+	while (queue.length > 0) {
+		if (evalContext.startTick !== void 0 && (/* @__PURE__ */ new Date()).valueOf() - evalContext.startTick > SYNC_EVAL_TIMEOUT) throw new Error(`Sync evaluation timeout exceeded ${SYNC_EVAL_TIMEOUT} milliseconds`);
+		const queueItem = queue.dequeue();
+		thread.breakLabelValue = queue.length > 0 ? queue.peek().label : -1;
+		let outcome;
+		try {
+			evalContext?.onStatementStarted?.(evalContext, queueItem.statement);
+			outcome = processStatement(queueItem.statement, queueItem.execInfo ?? {}, evalContext, thread);
+		} catch (err$1) {
+			if (thread.tryBlocks && thread.tryBlocks.length > 0) {
+				const tryScope = thread.tryBlocks[thread.tryBlocks.length - 1];
+				tryScope.errorToThrow = err$1;
+				tryScope.errorSource = tryScope.processingPhase;
+				tryScope.processingPhase = "error";
+				outcome = { clearToLabel: tryScope.tryLabel };
+			} else if (err$1 instanceof ThrowStatementError) reportEngineError(err$1);
+			else reportEngineError(new StatementExecutionError(err$1), err$1);
+		}
+		if (outcome) {
+			if (outcome.toUnshift) {
+				queue.unshift(outcome.toUnshift);
+				diagInfo.unshiftedItems += outcome.toUnshift.length;
+			}
+			if (outcome.clearToLabel !== void 0) {
+				queue.clearToLabel(outcome.clearToLabel);
+				diagInfo.clearToLabels++;
+			}
+		}
+		evalContext?.onStatementCompleted?.(evalContext, queueItem.statement);
+		if (queue.length > diagInfo.maxQueueLength) diagInfo.maxQueueLength = queue.length;
+		if (thread.blocks && thread.blocks.length > diagInfo.maxBlocks) diagInfo.maxBlocks = thread.blocks.length;
+		if (thread.loops && thread.loops.length > diagInfo.maxLoops) diagInfo.maxLoops = thread.loops.length;
+		diagInfo.processedStatements++;
+	}
+	return diagInfo;
+}
+/**
+* Process the specified statement synchronously
+* @param statement Statement to process
+* @param evalContext Evaluation context used for processing
+* @param thread Logical thread to use for statement processing
+* @returns Items to put back into the queue of statements
+*/
+function processStatement(statement, execInfo, evalContext, thread) {
+	let toUnshift = [];
+	let clearToLabel;
+	switch (statement.type) {
+		case T_ASYNC_FUNCTION_DECLARATION: throw new Error("XMLUI does not support async function declarations.");
+		case T_FUNCTION_DECLARATION: break;
+		case T_VAR_STATEMENT:
+			if (thread !== evalContext.mainThread) throw new Error("'var' declarations are not allowed within functions");
+			break;
+		case T_EMPTY_STATEMENT: break;
+		case T_BLOCK_STATEMENT:
+			if (statement.stmts.length === 0) break;
+			thread.blocks ??= [];
+			thread.blocks.push({ vars: {} });
+			hoistFunctionDeclarations(thread, statement.stmts);
+			toUnshift = mapStatementsToQueueItems([...toStatementItems(statement.stmts), closing()]);
+			break;
+		case T_EXPRESSION_STATEMENT:
+			const statementValue = evalBinding(statement.expr, evalContext, thread);
+			if (thread.blocks && thread.blocks.length !== 0) thread.blocks[thread.blocks.length - 1].returnValue = statementValue;
+			break;
+		case T_ARROW_EXPRESSION_STATEMENT:
+			const arrowFuncValue = executeArrowExpressionSync(statement.expr, evalContext, thread, ...evalContext.eventArgs ?? []);
+			if (thread.blocks && thread.blocks.length !== 0) thread.blocks[thread.blocks.length - 1].returnValue = arrowFuncValue;
+			break;
+		case T_LET_STATEMENT: {
+			const block = innermostBlockScope(thread);
+			if (!block) throw new Error("Missing block scope");
+			processDeclarations(block, evalContext, thread, statement.decls);
+			break;
+		}
+		case T_CONST_STATEMENT: {
+			const block = innermostBlockScope(thread);
+			if (!block) throw new Error("Missing block scope");
+			processDeclarations(block, evalContext, thread, statement.decls, true);
+			break;
+		}
+		case T_IF_STATEMENT:
+			if (!!evalBinding(statement.cond, evalContext, thread)) toUnshift = mapToItem(statement.thenB);
+			else if (statement.elseB) toUnshift = mapToItem(statement.elseB);
+			break;
+		case T_RETURN_STATEMENT:
+			if (innermostBlockScope(thread) === void 0) throw new Error("Return requires a block scope");
+			thread.returnValue = statement.expr ? evalBinding(statement.expr, evalContext, thread) : void 0;
+			if ((thread.tryBlocks ?? []).length > 0) {
+				for (let i = 0; i < thread.tryBlocks.length; i++) thread.tryBlocks[i].exitType = "return";
+				const tryScope = innermostTryScope(thread);
+				if (tryScope.processingPhase !== "postFinally") thread.blocks.pop();
+				clearToLabel = tryScope.tryLabel;
+			} else clearToLabel = -1;
+			break;
+		case T_WHILE_STATEMENT: {
+			let loopScope = execInfo.guard ? innermostLoopScope(thread) : createLoopScope(thread);
+			if (!!evalBinding(statement.cond, evalContext, thread)) toUnshift = provideLoopBody(loopScope, statement, thread.breakLabelValue);
+			else releaseLoopScope(thread);
+			break;
+		}
+		case T_DO_WHILE_STATEMENT:
+			if (!execInfo.guard) {
+				toUnshift = provideLoopBody(createLoopScope(thread), statement, thread.breakLabelValue);
+				break;
+			}
+			if (!!evalBinding(statement.cond, evalContext, thread)) toUnshift = provideLoopBody(innermostLoopScope(thread), statement, thread.breakLabelValue);
+			else releaseLoopScope(thread);
+			break;
+		case T_CONTINUE_STATEMENT: {
+			if (!thread.loops || thread.loops.length === 0) throw new Error("Missing loop scope");
+			let loopScope;
+			while (thread.loops.length > 0) {
+				loopScope = innermostLoopScope(thread);
+				if (!loopScope.isSwitch) break;
+				thread.loops.pop();
+			}
+			if (!loopScope) throw new Error("Missing loop scope");
+			if (loopScope.tryBlockDepth >= 0 && loopScope.tryBlockDepth < (thread.tryBlocks ?? []).length) {
+				for (let i = loopScope.tryBlockDepth; i < thread.tryBlocks.length; i++) thread.tryBlocks[loopScope.tryBlockDepth].exitType = "continue";
+				clearToLabel = innermostTryScope(thread).tryLabel;
+			} else {
+				clearToLabel = loopScope.continueLabel;
+				releaseLoopScope(thread, false);
+			}
+			break;
+		}
+		case T_BREAK_STATEMENT: {
+			const loopScope = innermostLoopScope(thread);
+			if (loopScope === void 0) throw new Error("Missing loop scope");
+			if (!!loopScope.isSwitch) {
+				clearToLabel = loopScope.breakLabel;
+				break;
+			}
+			if (loopScope.tryBlockDepth >= 0 && loopScope.tryBlockDepth < (thread.tryBlocks ?? []).length) {
+				for (let i = loopScope.tryBlockDepth; i < thread.tryBlocks.length; i++) thread.tryBlocks[loopScope.tryBlockDepth].exitType = "break";
+				clearToLabel = innermostTryScope(thread).tryLabel;
+			} else {
+				clearToLabel = loopScope.breakLabel;
+				releaseLoopScope(thread);
+			}
+			break;
+		}
+		case T_FOR_STATEMENT:
+			if (!execInfo.guard) {
+				createLoopScope(thread, 1);
+				thread.blocks ??= [];
+				thread.blocks.push({ vars: {} });
+				const guardStatement = guard(statement);
+				if (statement.init) toUnshift = mapStatementsToQueueItems([{ statement: statement.init }, guardStatement]);
+				else toUnshift = mapStatementsToQueueItems([guardStatement]);
+			} else if (!statement.cond || evalBinding(statement.cond, evalContext, thread)) {
+				const loopScope = innermostLoopScope(thread);
+				if (statement.upd) {
+					const updateStmt = { statement: {
+						type: T_EXPRESSION_STATEMENT,
+						nodeId: createXmlUiTreeNodeId(),
+						expr: statement.upd
+					} };
+					toUnshift = mapStatementsToQueueItems([
+						{ statement: statement.body },
+						updateStmt,
+						{
+							statement,
+							execInfo
+						}
+					]);
+				} else toUnshift = mapStatementsToQueueItems([{ statement: statement.body }, {
+					statement,
+					execInfo
+				}]);
+				loopScope.breakLabel = thread.breakLabelValue ?? -1;
+				loopScope.continueLabel = toUnshift[1].label;
+			} else releaseLoopScope(thread);
+			break;
+		case T_FOR_IN_STATEMENT:
+			if (!execInfo.guard) {
+				const keyedObject = evalBinding(statement.expr, evalContext, thread);
+				if (keyedObject == void 0) break;
+				createLoopScope(thread, 1);
+				thread.blocks ??= [];
+				thread.blocks.push({ vars: {} });
+				toUnshift = mapStatementsToQueueItems([{
+					statement,
+					execInfo: {
+						guard: true,
+						keys: Object.keys(keyedObject),
+						keyIndex: 0
+					}
+				}]);
+			} else {
+				if (execInfo.keyIndex === void 0 || execInfo.keys === void 0) throw new Error("Keys information expected in for..in loop");
+				if (execInfo.keyIndex < execInfo.keys.length) {
+					const propValue = execInfo.keys[execInfo.keyIndex++];
+					switch (statement.varB) {
+						case "none":
+							evalBinding({
+								type: T_ASSIGNMENT_EXPRESSION,
+								leftValue: {
+									type: T_IDENTIFIER,
+									name: statement.id.name
+								},
+								op: "=",
+								expr: {
+									type: T_LITERAL,
+									value: propValue
+								}
+							}, evalContext, thread);
+							break;
+						case "const":
+						case "let":
+							{
+								const block = innermostBlockScope(thread);
+								if (!block) throw new Error("Missing block scope");
+								block.vars[statement.id.name] = propValue;
+								if (statement.varB === "const") {
+									block.constVars ??= /* @__PURE__ */ new Set();
+									block.constVars.add(statement.id.name);
+								}
+							}
+							break;
+					}
+					const loopScope = innermostLoopScope(thread);
+					toUnshift = mapStatementsToQueueItems([{ statement: statement.body }, {
+						statement,
+						execInfo
+					}]);
+					loopScope.breakLabel = thread.breakLabelValue ?? -1;
+					loopScope.continueLabel = toUnshift[1].label;
+				} else releaseLoopScope(thread);
+			}
+			break;
+		case T_FOR_OF_STATEMENT:
+			if (!execInfo.guard) {
+				const iteratorObject = evalBinding(statement.expr, evalContext, thread);
+				if (iteratorObject == null || typeof iteratorObject[Symbol.iterator] !== "function") throw new Error("Object in for..of is not iterable");
+				createLoopScope(thread, 1);
+				thread.blocks ??= [];
+				thread.blocks.push({ vars: {} });
+				toUnshift = mapStatementsToQueueItems([{
+					statement,
+					execInfo: {
+						guard: true,
+						iterator: iteratorObject[Symbol.iterator]()
+					}
+				}]);
+			} else {
+				if (execInfo.iterator === void 0) throw new Error("Iterator expected in for..of loop");
+				const nextIteration = execInfo.iterator.next();
+				if (nextIteration.done) {
+					releaseLoopScope(thread);
+					break;
+				}
+				const propValue = nextIteration.value;
+				switch (statement.varB) {
+					case "none":
+						evalBinding({
+							type: T_ASSIGNMENT_EXPRESSION,
+							leftValue: {
+								type: T_IDENTIFIER,
+								name: statement.id.name
+							},
+							op: "=",
+							expr: {
+								type: T_LITERAL,
+								value: propValue
+							}
+						}, evalContext, thread);
+						break;
+					case "const":
+					case "let":
+						{
+							const block = innermostBlockScope(thread);
+							if (!block) throw new Error("Missing block scope");
+							block.vars[statement.id.name] = propValue;
+							if (statement.varB === "const") {
+								block.constVars ??= /* @__PURE__ */ new Set();
+								block.constVars.add(statement.id.name);
+							}
+						}
+						break;
+				}
+				const loopScope = innermostLoopScope(thread);
+				toUnshift = mapStatementsToQueueItems([{ statement: statement.body }, {
+					statement,
+					execInfo
+				}]);
+				loopScope.breakLabel = thread.breakLabelValue ?? -1;
+				loopScope.continueLabel = toUnshift[1].label;
+			}
+			break;
+		case T_THROW_STATEMENT: throw new ThrowStatementError(evalBinding(statement.expr, evalContext, thread));
+		case T_TRY_STATEMENT: {
+			if (!execInfo.guard) {
+				toUnshift = provideTryBody(thread, createTryScope(thread, statement));
+				break;
+			}
+			const tryScope = innermostTryScope(thread);
+			switch (tryScope.processingPhase) {
+				case "error":
+					switch (tryScope.errorSource) {
+						case "try":
+							thread.blocks.pop();
+							if (statement.catchB) {
+								if (tryScope.statement.catchV) {
+									const block = innermostBlockScope(thread);
+									block.vars[tryScope.statement.catchV.name] = tryScope.errorToThrow instanceof ThrowStatementError ? tryScope.errorToThrow.errorObject : tryScope.errorToThrow;
+								}
+								delete tryScope.errorToThrow;
+								tryScope.processingPhase = "catch";
+								toUnshift = provideCatchBody(thread, tryScope);
+							} else if (tryScope.statement.finallyB) {
+								tryScope.processingPhase = "finally";
+								toUnshift = provideFinallyBody(thread, tryScope);
+							}
+							break;
+						case "catch":
+							thread.blocks.pop();
+							tryScope.processingPhase = "finally";
+							toUnshift = provideFinallyBody(thread, tryScope);
+							break;
+						case "finally":
+							thread.blocks.pop();
+							tryScope.processingPhase = "postFinally";
+							toUnshift = provideFinallyErrorBody(tryScope);
+							break;
+					}
+					break;
+				case "try":
+					tryScope.processingPhase = "finally";
+					if (statement.finallyB) toUnshift = provideFinallyBody(thread, tryScope);
+					else toUnshift = provideFinallyErrorBody(tryScope);
+					break;
+				case "catch":
+					tryScope.processingPhase = "finally";
+					if (statement.finallyB) toUnshift = provideFinallyBody(thread, tryScope);
+					else toUnshift = provideFinallyErrorBody(tryScope);
+					break;
+				case "finally":
+					tryScope.processingPhase = "postFinally";
+					toUnshift = provideFinallyErrorBody(tryScope);
+					break;
+				case "postFinally":
+					const innermostTry = thread.tryBlocks.pop();
+					switch (innermostTry.exitType) {
+						case "break": {
+							const loopScope = innermostLoopScope(thread);
+							if (loopScope === void 0) throw new Error("Missing loop scope");
+							releaseLoopScope(thread);
+							clearToLabel = loopScope.breakLabel;
+							break;
+						}
+						case "continue": {
+							const loopScope = innermostLoopScope(thread);
+							if (loopScope === void 0) throw new Error("Missing loop scope");
+							clearToLabel = loopScope.continueLabel;
+							releaseLoopScope(thread, false);
+							break;
+						}
+						case "return":
+							if (thread.tryBlocks && thread.tryBlocks.length > 0) {
+								if (thread.blocks && thread.blocks.length > 1) thread.blocks.pop();
+								clearToLabel = thread.tryBlocks[thread.tryBlocks.length - 1].tryLabel;
+							} else clearToLabel = -1;
+							break;
+					}
+					if (innermostTry.errorToThrow) throw innermostTry.errorToThrow;
+					break;
+			}
+			break;
+		}
+		case T_SWITCH_STATEMENT:
+			if (execInfo.guard) releaseLoopScope(thread);
+			else {
+				let loopScope = createLoopScope(thread);
+				loopScope.isSwitch = true;
+				thread.blocks.push({ vars: {} });
+				const switchValue = evalBinding(statement.expr, evalContext, thread);
+				let matchingIndex = -1;
+				for (let i = 0; i < statement.cases.length; i++) {
+					const currentCase = statement.cases[i];
+					if (currentCase.caseE === void 0) {
+						matchingIndex = i;
+						break;
+					}
+					if (evalBinding(currentCase.caseE, evalContext, thread) === switchValue) {
+						matchingIndex = i;
+						break;
+					}
+				}
+				const statementFlow = [];
+				if (matchingIndex >= 0) for (let i = matchingIndex; i < statement.cases.length; i++) statementFlow.push(...statement.cases[i].stmts);
+				toUnshift = mapStatementsToQueueItems([...toStatementItems(statementFlow), guard(statement)]);
+				loopScope.breakLabel = toUnshift[toUnshift.length - 1].label;
+			}
+			break;
+	}
+	if (execInfo.removeBlockScope) {
+		if (thread.blocks && thread.blocks.length > 0) thread.blocks.pop();
+	}
+	return {
+		toUnshift,
+		clearToLabel
+	};
+}
+function processDeclarations(block, evalContext, thread, declarations, addConst = false, useValue = false, baseValue = void 0) {
+	for (let i = 0; i < declarations.length; i++) {
+		let value;
+		const decl = declarations[i];
+		if (useValue) value = baseValue;
+		else if (decl.expr) value = evalBinding(decl.expr, evalContext, thread);
+		visitDeclaration(block, decl, value, addConst);
+	}
+	function visitDeclaration(block$1, decl, baseValue$1, addConst$1) {
+		if (decl.id) visitIdDeclaration(block$1, decl.id, baseValue$1, addConst$1);
+		else if (decl.aDestr) visitArrayDestruct(block$1, decl.aDestr, baseValue$1, addConst$1);
+		else if (decl.oDestr) visitObjectDestruct(block$1, decl.oDestr, baseValue$1, addConst$1);
+		else throw new Error("Unknown declaration specifier");
+	}
+	function visitIdDeclaration(block$1, id, baseValue$1, addConst$1) {
+		if (block$1.vars[id]) throw new Error(`Variable ${id} is already declared in the current scope.`);
+		block$1.vars[id] = baseValue$1;
+		if (addConst$1) {
+			block$1.constVars ??= /* @__PURE__ */ new Set();
+			block$1.constVars.add(id);
+		}
+	}
+	function visitArrayDestruct(block$1, arrayD, baseValue$1, addConst$1) {
+		for (let i = 0; i < arrayD.length; i++) {
+			const arrDecl = arrayD[i];
+			const value = baseValue$1?.[i];
+			if (arrDecl.id) visitIdDeclaration(block$1, arrDecl.id, value, addConst$1);
+			else if (arrDecl.aDestr) visitArrayDestruct(block$1, arrDecl.aDestr, value, addConst$1);
+			else if (arrDecl.oDestr) visitObjectDestruct(block$1, arrDecl.oDestr, value, addConst$1);
+		}
+	}
+	function visitObjectDestruct(block$1, objectD, baseValue$1, addConst$1) {
+		for (let i = 0; i < objectD.length; i++) {
+			const objDecl = objectD[i];
+			const value = baseValue$1?.[objDecl.id];
+			if (objDecl.aDestr) visitArrayDestruct(block$1, objDecl.aDestr, value, addConst$1);
+			else if (objDecl.oDestr) visitObjectDestruct(block$1, objDecl.oDestr, value, addConst$1);
+			else visitIdDeclaration(block$1, objDecl.alias ?? objDecl.id, value, addConst$1);
+		}
+	}
+}
+
+//#endregion
+//#region src/components-core/script-runner/eval-tree-sync.ts
+/**
+* Evaluates a binding represented by the specified expression
+* @param expr Expression to evaluate
+* @param evalContext Evaluation context to use
+* @param thread The logical thread to use for evaluation
+*/
+function evalBinding(expr, evalContext, thread) {
+	const thisStack = [];
+	ensureMainThread(evalContext);
+	thread ??= evalContext.mainThread;
+	return evalBindingExpressionTree(thisStack, expr, evalContext, thread ?? evalContext.mainThread);
+}
+/**
+* Executes the specified arrow function
+* @param expr Arrow function expression to run
+* @param evalContext Evaluation context to use
+* @param thread The logical thread to use for evaluation
+* @param args Arguments of the arrow function to execute
+*/
+function executeArrowExpressionSync(expr, evalContext, thread, ...args) {
+	if (expr.type !== T_ARROW_EXPRESSION) throw new Error("executeArrowExpression expects an 'ArrowExpression' object.");
+	return createArrowFunction(evalBindingExpressionTree, expr)(expr.args, evalContext, thread ?? evalContext.mainThread, ...args);
+}
+/**
+* Evaluates the specified binding expression tree and retrieves the evaluated value
+* @param expr Binding tree expression
+* @param thisStack Stack of "this" object to use with function calls
+* @param evalContext Evaluation context
+* @param thread The logical thread to use for evaluation
+* This code uses the JavaScript semantics and errors when evaluating the code.
+* We use `thisStack` to keep track of the partial results of the evaluation tree so that we can set
+* the real `this` context when invoking a function.
+*/
+function evalBindingExpressionTree(thisStack, expr, evalContext, thread) {
+	if (!evalContext.options) evalContext.options = { defaultToOptionalMemberAccess: true };
+	const evaluator = evalBindingExpressionTree;
+	switch (expr.type) {
+		case T_TEMPLATE_LITERAL_EXPRESSION: return evalTemplateLiteral(evaluator, thisStack, expr, evalContext, thread);
+		case T_LITERAL: return evalLiteral(thisStack, expr, thread);
+		case T_IDENTIFIER: return evalIdentifier(thisStack, expr, evalContext, thread);
+		case T_MEMBER_ACCESS_EXPRESSION: return evalMemberAccess(evaluator, thisStack, expr, evalContext, thread);
+		case T_CALCULATED_MEMBER_ACCESS_EXPRESSION: return evalCalculatedMemberAccess(evaluator, thisStack, expr, evalContext, thread);
+		case T_SEQUENCE_EXPRESSION: return evalSequence(evaluator, thisStack, expr, evalContext, thread);
+		case T_ARRAY_LITERAL: return evalArrayLiteral(evaluator, thisStack, expr, evalContext, thread);
+		case T_OBJECT_LITERAL: return evalObjectLiteral(evaluator, thisStack, expr, evalContext, thread);
+		case T_UNARY_EXPRESSION: return evalUnary(evaluator, thisStack, expr, evalContext, thread);
+		case T_BINARY_EXPRESSION: return evalBinary(evaluator, thisStack, expr, evalContext, thread);
+		case T_CONDITIONAL_EXPRESSION: return evalConditional(evaluator, thisStack, expr, evalContext, thread);
+		case T_ASSIGNMENT_EXPRESSION: return evalAssignment(evaluator, thisStack, expr, evalContext, thread);
+		case T_PREFIX_OP_EXPRESSION:
+		case T_POSTFIX_OP_EXPRESSION: return evalPreOrPost(evaluator, thisStack, expr, evalContext, thread);
+		case T_FUNCTION_INVOCATION_EXPRESSION:
+			const funcResult = evalFunctionInvocation(evaluator, thisStack, expr, evalContext, thread);
+			if (isPromise(funcResult)) throw new Error("Promises (async function calls) are not allowed in binding expressions.");
+			return funcResult;
+		case T_ARROW_EXPRESSION: return evalArrow(thisStack, expr, thread);
+		case T_SPREAD_EXPRESSION: throw new Error("Cannot use spread expression (...) with the current intermediate value.");
+		case T_AWAIT_EXPRESSION: throw new Error("XMLUI does not support the await operator.");
+		case T_NEW_EXPRESSION: return evalNewExpression(evaluator, thisStack, expr, evalContext, thread);
+		default: throw new Error(`Unknown expression tree node: ${expr.type}`);
+	}
+}
+function evalTemplateLiteral(evaluator, thisStack, expr, evalContext, thread) {
+	const value = evalTemplateLiteralCore(expr.segments.map((s) => {
+		const evaledValue = evaluator(thisStack, s, evalContext, thread);
+		thisStack.pop();
+		return evaledValue;
+	}));
+	setExprValue(expr, { value }, thread);
+	thisStack.push(value);
+	return value;
+}
+function evalMemberAccess(evaluator, thisStack, expr, evalContext, thread) {
+	evaluator(thisStack, expr.obj, evalContext, thread);
+	return evalMemberAccessCore(thisStack, expr, evalContext, thread);
+}
+function evalCalculatedMemberAccess(evaluator, thisStack, expr, evalContext, thread) {
+	evaluator(thisStack, expr.obj, evalContext, thread);
+	evaluator(thisStack, expr.member, evalContext, thread);
+	thisStack.pop();
+	return evalCalculatedMemberAccessCore(thisStack, expr, evalContext, thread);
+}
+function evalSequence(evaluator, thisStack, expr, evalContext, thread) {
+	if (!expr.exprs || expr.exprs.length === 0) throw new Error(`Missing expression sequence`);
+	const result = expr.exprs.map((e) => {
+		const value = evaluator(thisStack, e, evalContext, thread);
+		setExprValue(e, { value }, thread);
+		thisStack.pop();
+		return value;
+	});
+	const lastObj = result[result.length - 1];
+	thisStack.push(lastObj);
+	return lastObj;
+}
+function evalArrayLiteral(evaluator, thisStack, expr, evalContext, thread) {
+	const value = [];
+	for (const item of expr.items) if (item.type === T_SPREAD_EXPRESSION) {
+		const spreadArray = evaluator(thisStack, item.expr, evalContext, thread);
+		thisStack.pop();
+		if (!Array.isArray(spreadArray)) throw new Error("Spread operator within an array literal expects an array operand.");
+		value.push(...spreadArray);
+	} else {
+		value.push(evaluator(thisStack, item, evalContext, thread));
+		thisStack.pop();
+		thisStack.push(value);
+	}
+	setExprValue(expr, { value }, thread);
+	thisStack.push(value);
+	return value;
+}
+function evalObjectLiteral(evaluator, thisStack, expr, evalContext, thread) {
+	const objectHash = {};
+	for (const prop of expr.props) {
+		if (!Array.isArray(prop)) {
+			const spreadItems = evaluator(thisStack, prop.expr, evalContext, thread);
+			thisStack.pop();
+			if (Array.isArray(spreadItems)) for (let i = 0; i < spreadItems.length; i++) objectHash[i] = spreadItems[i];
+			else if (typeof spreadItems === "object") for (const [key$1, value] of Object.entries(spreadItems)) objectHash[key$1] = value;
+			continue;
+		}
+		let key;
+		switch (prop[0].type) {
+			case T_LITERAL:
+				key = prop[0].value;
+				break;
+			case T_IDENTIFIER:
+				key = prop[0].name;
+				break;
+			default:
+				key = evaluator(thisStack, prop[0], evalContext, thread);
+				thisStack.pop();
+				break;
+		}
+		objectHash[key] = evaluator(thisStack, prop[1], evalContext, thread);
+		thisStack.pop();
+	}
+	setExprValue(expr, { value: objectHash }, thread);
+	thisStack.push(objectHash);
+	return objectHash;
+}
+function evalUnary(evaluator, thisStack, expr, evalContext, thread) {
+	evaluator(thisStack, expr.expr, evalContext, thread);
+	thisStack.pop();
+	return evalUnaryCore(expr, thisStack, evalContext, thread);
+}
+function evalBinary(evaluator, thisStack, expr, evalContext, thread) {
+	evaluator(thisStack, expr.left, evalContext, thread);
+	thisStack.pop();
+	const l = getExprValue(expr.left, thread)?.value;
+	if (expr.op === "&&" && !l) {
+		setExprValue(expr, { value: l }, thread);
+		thisStack.push(l);
+		return l;
+	}
+	if (expr.op === "||" && l) {
+		setExprValue(expr, { value: l }, thread);
+		thisStack.push(l);
+		return l;
+	}
+	if (expr.op === "??" && l !== null && l !== void 0) {
+		setExprValue(expr, { value: l }, thread);
+		thisStack.push(l);
+		return l;
+	}
+	evaluator(thisStack, expr.right, evalContext, thread);
+	thisStack.pop();
+	return evalBinaryCore(expr, thisStack, evalContext, thread);
+}
+function evalConditional(evaluator, thisStack, expr, evalContext, thread) {
+	const condition = evaluator(thisStack, expr.cond, evalContext, thread);
+	thisStack.pop();
+	const value = evaluator(thisStack, condition ? expr.thenE : expr.elseE, evalContext, thread);
+	setExprValue(expr, { value }, thread);
+	return value;
+}
+function evalAssignment(evaluator, thisStack, expr, evalContext, thread) {
+	const leftValue = expr.leftValue;
+	const rootScope = getRootIdScope(leftValue, evalContext, thread);
+	const updatesState = rootScope && rootScope.type !== "block";
+	if (updatesState && evalContext.onWillUpdate) evalContext.onWillUpdate(rootScope, rootScope.name, "assignment");
+	evaluator(thisStack, leftValue, evalContext, thread);
+	thisStack.pop();
+	evaluator(thisStack, expr.expr, evalContext, thread);
+	thisStack.pop();
+	const value = evalAssignmentCore(thisStack, expr, evalContext, thread);
+	if (updatesState && evalContext.onDidUpdate) evalContext.onDidUpdate(rootScope, rootScope.name, "assignment");
+	return value;
+}
+function evalPreOrPost(evaluator, thisStack, expr, evalContext, thread) {
+	const rootScope = getRootIdScope(expr.expr, evalContext, thread);
+	const updatesState = rootScope && rootScope.type !== "block";
+	if (updatesState && evalContext.onWillUpdate) evalContext.onWillUpdate(rootScope, rootScope.name, "pre-post");
+	evaluator(thisStack, expr.expr, evalContext, thread);
+	thisStack.pop();
+	const value = evalPreOrPostCore(thisStack, expr, evalContext, thread);
+	if (updatesState && evalContext.onDidUpdate) evalContext.onDidUpdate(rootScope, rootScope.name, "pre-post");
+	return value;
+}
+function evalFunctionInvocation(evaluator, thisStack, expr, evalContext, thread) {
+	let functionObj;
+	let implicitContextObject = null;
+	if (expr.obj.type === T_MEMBER_ACCESS_EXPRESSION) {
+		const hostObject = evaluator(thisStack, expr.obj.obj, evalContext, thread);
+		functionObj = evalMemberAccessCore(thisStack, expr.obj, evalContext, thread);
+		if (expr.obj.obj.type === T_IDENTIFIER && hostObject?._SUPPORT_IMPLICIT_CONTEXT) implicitContextObject = hostObject;
+	} else functionObj = evaluator(thisStack, expr.obj, evalContext, thread);
+	thisStack.pop();
+	const functionArgs = [];
+	if (isArrowExpressionObject(functionObj)) {
+		functionArgs.push(functionObj.args, evalContext, thread, ...expr.arguments.map((a) => ({
+			...a,
+			_EXPRESSION_: true
+		})));
+		functionObj = createArrowFunction(evaluator, functionObj);
+	} else if (expr.obj.type === T_ARROW_EXPRESSION) functionArgs.push(expr.obj.args, evalContext, thread, ...expr.arguments.map((a) => ({
+		...a,
+		_EXPRESSION_: true
+	})));
+	else {
+		for (let i = 0; i < expr.arguments.length; i++) {
+			const arg = expr.arguments[i];
+			if (arg.type === T_SPREAD_EXPRESSION) {
+				const funcArg = evaluator([], arg.expr, evalContext, thread);
+				if (!Array.isArray(funcArg)) throw new Error("Spread operator within a function invocation expects an array operand.");
+				functionArgs.push(...funcArg);
+			} else if (arg.type === T_ARROW_EXPRESSION) {
+				const funcArg = createArrowFunction(evaluator, arg);
+				const wrappedFunc = (...args) => funcArg(arg.args, evalContext, thread, ...args);
+				functionArgs.push(wrappedFunc);
+			} else {
+				const funcArg = evaluator([], arg, evalContext, thread);
+				if (isArrowExpressionObject(funcArg)) {
+					const wrappedFuncArg = createArrowFunction(evaluator, funcArg);
+					const wrappedFunc = (...args) => wrappedFuncArg(funcArg.args, evalContext, thread, ...args);
+					functionArgs.push(wrappedFunc);
+				} else functionArgs.push(funcArg);
+			}
+		}
+		if (implicitContextObject) if (evalContext.implicitContextGetter) {
+			const implicitContext = evalContext.implicitContextGetter(implicitContextObject);
+			functionArgs.unshift(implicitContext);
+		} else throw new Error("Cannot use implicitContextGetter, it is undefined");
+	}
+	const bannedInfo = isBannedFunction(functionObj);
+	if (bannedInfo.banned) throw new Error(`Function ${bannedInfo.func?.name ?? "unknown"} is not allowed to call. ${bannedInfo?.help ?? ""}`);
+	const currentContext = thisStack.length > 0 ? thisStack.pop() : evalContext.localContext;
+	const rootScope = getRootIdScope(expr.obj, evalContext, thread);
+	const updatesState = rootScope && rootScope.type !== "block";
+	if (updatesState && evalContext.onWillUpdate) evalContext.onWillUpdate(rootScope, rootScope.name, "function-call");
+	const value = evalContext.options?.defaultToOptionalMemberAccess ? functionObj?.call(currentContext, ...functionArgs) : functionObj.call(currentContext, ...functionArgs);
+	if (updatesState && evalContext.onDidUpdate) evalContext.onDidUpdate(rootScope, rootScope.name, "function-call");
+	setExprValue(expr, { value }, thread);
+	thisStack.push(value);
+	return value;
+}
+function evalNewExpression(evaluator, thisStack, expr, evalContext, thread) {
+	const allowedConstructors = new Map([
+		["String", String],
+		["Date", Date],
+		["Blob", Blob]
+	]);
+	const constructorObj = evaluator(thisStack, expr.callee, evalContext, thread);
+	thisStack.pop();
+	let allowedConstructor = null;
+	for (const [name, ctor] of allowedConstructors) if (constructorObj === ctor) {
+		allowedConstructor = ctor;
+		break;
+	}
+	if (!allowedConstructor) {
+		const constructorName = constructorObj?.name || "unknown";
+		throw new Error(`XMLUI does not support the new operator with constructor '${constructorName}'. Only String, Date, and Blob are allowed.`);
+	}
+	const constructorArgs = [];
+	for (let i = 0; i < expr.arguments.length; i++) {
+		const arg = expr.arguments[i];
+		if (arg.type === T_SPREAD_EXPRESSION) {
+			const funcArg = evaluator([], arg.expr, evalContext, thread);
+			if (!Array.isArray(funcArg)) throw new Error("Spread operator within a new expression expects an array operand.");
+			constructorArgs.push(...funcArg);
+		} else {
+			const funcArg = evaluator([], arg, evalContext, thread);
+			constructorArgs.push(funcArg);
+		}
+	}
+	const value = new allowedConstructor(...constructorArgs);
+	setExprValue(expr, { value }, thread);
+	thisStack.push(value);
+	return value;
+}
+function createArrowFunction(evaluator, expr) {
+	return (...args) => {
+		const runTimeEvalContext = args[1];
+		const runtimeThread = args[2];
+		const workingThread = {
+			parent: runtimeThread,
+			childThreads: [],
+			blocks: [{ vars: {} }],
+			loops: [],
+			breakLabelValue: -1,
+			closures: expr.closureContext
+		};
+		runtimeThread.childThreads.push(workingThread);
+		if (expr.name) {
+			const functionBlock = { vars: {} };
+			workingThread.blocks ??= [];
+			workingThread.blocks.push(functionBlock);
+			functionBlock.vars[expr.name] = expr;
+			functionBlock.constVars = new Set([expr.name]);
+		}
+		const arrowBlock = { vars: {} };
+		workingThread.blocks ??= [];
+		workingThread.blocks.push(arrowBlock);
+		const argSpecs = args[0];
+		let restFound = false;
+		for (let i = 0; i < argSpecs.length; i++) {
+			const argSpec = argSpecs[i];
+			let decl;
+			switch (argSpec.type) {
+				case T_IDENTIFIER:
+					decl = {
+						type: T_VAR_DECLARATION,
+						id: argSpec.name
+					};
+					break;
+				case T_DESTRUCTURE:
+					decl = {
+						type: T_VAR_DECLARATION,
+						id: argSpec.id,
+						aDestr: argSpec.aDestr,
+						oDestr: argSpec.oDestr
+					};
+					break;
+				case T_SPREAD_EXPRESSION:
+					restFound = true;
+					decl = {
+						type: T_VAR_DECLARATION,
+						id: argSpec.expr.name
+					};
+					break;
+				default: throw new Error("Unexpected arrow argument specification");
+			}
+			if (decl) if (restFound) {
+				const restArgs = args.slice(i + 3);
+				let argVals = [];
+				for (const arg of restArgs) if (arg?._EXPRESSION_) argVals.push(evaluator([], arg, runTimeEvalContext, runtimeThread));
+				else argVals.push(arg);
+				processDeclarations(arrowBlock, runTimeEvalContext, runtimeThread, [decl], false, true, argVals);
+			} else {
+				let argVal = args[i + 3];
+				if (argVal?._EXPRESSION_) argVal = evaluator([], argVal, runTimeEvalContext, runtimeThread);
+				processDeclarations(arrowBlock, runTimeEvalContext, runtimeThread, [decl], false, true, argVal);
+			}
+		}
+		let returnValue;
+		let statements;
+		switch (expr.statement.type) {
+			case T_EMPTY_STATEMENT:
+				statements = [];
+				break;
+			case T_EXPRESSION_STATEMENT:
+				statements = [{
+					type: T_RETURN_STATEMENT,
+					nodeId: createXmlUiTreeNodeId(),
+					expr: expr.statement.expr
+				}];
+				break;
+			case T_BLOCK_STATEMENT:
+				statements = expr.statement.stmts;
+				break;
+			default: throw new Error(`Arrow expression with a body of '${expr.statement.type}' is not supported yet.`);
+		}
+		processStatementQueue(statements, runTimeEvalContext, workingThread);
+		returnValue = workingThread.returnValue;
+		const workingIndex = runtimeThread.childThreads.indexOf(workingThread);
+		if (workingIndex < 0) throw new Error("Cannot find thread to remove.");
+		runtimeThread.childThreads.splice(workingIndex, 1);
+		workingThread.blocks.pop();
+		return returnValue;
+	};
+}
+
+//#endregion
+//#region src/components-core/utils/LruCache.ts
+/**
+* A single node of the LRU cache
+*/
+var DoublyLinkedNode = class {
+	constructor(value, key) {
+		this.value = value;
+		this.key = key;
+		this.next = void 0;
+		this.prev = void 0;
+	}
+};
+/**
+* We keep values in the LRU cache in a doubly linked list
+*/
+var DoublyLinkedList = class {
+	constructor() {
+		this.size = 0;
+		this.head = void 0;
+		this.tail = void 0;
+		this.size = 0;
+	}
+	/**
+	* Adds a new node to the head of the list
+	* @param node The node to add to head of list
+	*/
+	unshift(node) {
+		if (this.size === 0) {
+			this.head = node;
+			this.tail = node;
+			this.size++;
+		} else {
+			this.head.prev = node;
+			node.next = this.head;
+			node.prev = void 0;
+			this.head = node;
+			this.size++;
+		}
+	}
+	/**
+	* Remove least recently used node from tail
+	*/
+	pop() {
+		const node = this.tail;
+		if (!node) return;
+		else if (this.head === this.tail) {
+			this.head = void 0;
+			this.tail = void 0;
+		} else this.tail.prev.next = void 0;
+		this.tail = node.prev;
+		this.size--;
+		return node;
+	}
+	/**
+	* Moves the specified node to the head
+	*/
+	moveToHead(node) {
+		if (node === this.head) return;
+		if (node === this.head && node === this.tail) return;
+		if (node === this.tail) {
+			this.tail = this.tail.prev;
+			this.tail.next = void 0;
+			node.next = this.head;
+			this.head.prev = node;
+			this.head = node;
+			node.prev = void 0;
+		} else {
+			node.prev.next = node.next;
+			node.next.prev = node.prev;
+			node.next = this.head;
+			this.head.prev = node;
+			this.head = node;
+			node.prev = void 0;
+		}
+	}
+};
+/**
+* This class implements the LRU cache
+*/
+var LRUCache = class {
+	constructor(maxSize) {
+		this.maxSize = maxSize;
+		this.store = {};
+		this.list = new DoublyLinkedList();
+	}
+	/**
+	* Gets the number of items stored in the cache
+	*/
+	get length() {
+		return this.list.size;
+	}
+	/**
+	* Gets the value with the specified key
+	* @param key
+	*/
+	get(key) {
+		const existingNode = this.store[key];
+		if (existingNode) this.list.moveToHead(existingNode);
+		return existingNode?.value;
+	}
+	/**
+	* Sets the value for a particular key within the cache
+	* @param key Cache item key
+	* @param value Cache item value
+	*/
+	set(key, value) {
+		const existingNode = this.get(key);
+		if (existingNode) existingNode.value = value;
+		const newNode = new DoublyLinkedNode(value, key);
+		this.store[key] = newNode;
+		this.list.unshift(newNode);
+		if (this.hasReachedMaxSize()) this.evictLeastRecentlyUsed();
+	}
+	hasReachedMaxSize() {
+		return this.list.size === this.maxSize + 1;
+	}
+	evictLeastRecentlyUsed() {
+		const evictedNode = this.list.pop();
+		delete this.store[evictedNode.key];
+	}
+};
+
+//#endregion
+//#region src/components-core/utils/extractParam.ts
+/**
+* Extract the value of the specified parameter from the given view container state
+* @param state The state of the view container
+* @param param Parameter to extract
+* @param appContext Application context to use
+* @param strict Strict evaluation?
+* @param extractContext
+* @returns
+*/
+function extractParam(state, param, appContext = void 0, strict = false, extractContext = { didResolve: false }) {
+	if (typeof param === "string") {
+		const paramSegments = parseParameterString(param);
+		if (paramSegments.length === 0) return param;
+		if (paramSegments[0].type === "literal" && paramSegments[0].value.trim() === "") paramSegments.shift();
+		if (paramSegments.length === 0) return param;
+		const lastSegment = paramSegments[paramSegments.length - 1];
+		if (lastSegment.type === "literal" && lastSegment.value.trim() === "") paramSegments.pop();
+		if (paramSegments.length === 0) return param;
+		if (paramSegments.length === 1) if (paramSegments[0].type === "literal") return paramSegments[0].value;
+		else {
+			extractContext.didResolve = true;
+			return evalBinding(paramSegments[0].value, {
+				localContext: state,
+				appContext,
+				options: { defaultToOptionalMemberAccess: true }
+			});
+		}
+		let result = "";
+		paramSegments.forEach((ps) => {
+			if (ps.type === "literal") result += ps.value;
+			else {
+				extractContext.didResolve = true;
+				const exprValue = evalBinding(ps.value, {
+					localContext: state,
+					appContext,
+					options: { defaultToOptionalMemberAccess: true }
+				});
+				if (exprValue?.toString) result += exprValue.toString();
+			}
+		});
+		return result;
+	}
+	if (strict) return param;
+	if (Array.isArray(param)) {
+		const arrayExtractContext = { didResolve: false };
+		let resolvedChildren = param.map((childParam) => extractParam(state, childParam, appContext, false, arrayExtractContext));
+		if (arrayExtractContext.didResolve) {
+			extractContext.didResolve = true;
+			return resolvedChildren;
+		}
+		return param;
+	}
+	if ((0, lodash_es.isPlainObject)(param)) {
+		const objectExtractContext = { didResolve: false };
+		const substitutedObject = {};
+		Object.entries(param).forEach(([key, value]) => {
+			substitutedObject[key] = extractParam(state, value, appContext, false, objectExtractContext);
+		});
+		if (objectExtractContext.didResolve) {
+			extractContext.didResolve = true;
+			return substitutedObject;
+		}
+		return param;
+	}
+	return param;
+}
+const extractedObjectCache = new LRUCache(1024 * 10);
+
+//#endregion
+//#region src/language-server/base/text-document.ts
+var DocumentCursor = class {
+	constructor(text) {
+		this.text = text;
+		this.newlineOffsets = [0];
+		for (let i = 0; i < text.length; i++) {
+			const ch = text.charCodeAt(i);
+			if (isEOL(ch)) {
+				if (ch === 13 && i + 1 < text.length && text.charCodeAt(i + 1) === 10) i++;
+				this.newlineOffsets.push(i + 1);
+			}
+		}
+	}
+	get textLength() {
+		return this.text.length;
+	}
+	get lineCount() {
+		return this.newlineOffsets.length;
+	}
+	/**
+	* Converts a zero-based offset to a position.
+	*
+	* @param offset A zero-based offset.
+	* @return A valid {@link Position position}.
+	* @example The text document "ab\ncd" produces:
+	* * position { line: 0, character: 0 } for `offset` 0.
+	* * position { line: 0, character: 1 } for `offset` 1.
+	* * position { line: 0, character: 2 } for `offset` 2.
+	* * position { line: 1, character: 0 } for `offset` 3.
+	* * position { line: 1, character: 1 } for `offset` 4.
+	*/
+	positionAt(offset) {
+		offset = Math.max(Math.min(offset, this.textLength), 0);
+		const lineOffsets = this.newlineOffsets;
+		let low = 0, high = lineOffsets.length;
+		if (high === 0) return {
+			line: 0,
+			character: offset
+		};
+		while (low < high) {
+			const mid = Math.floor((low + high) / 2);
+			if (lineOffsets[mid] > offset) high = mid;
+			else low = mid + 1;
+		}
+		const line = low - 1;
+		return {
+			line,
+			character: offset - lineOffsets[line]
+		};
+	}
+	/**
+	* Converts the position to a zero-based offset.
+	* Invalid positions are adjusted as described in {@link Position.line}
+	* and {@link Position.character}.
+	*
+	* @param position A position.
+	* @return A valid zero-based offset.
+	*/
+	offsetAt(position) {
+		if (position.line >= this.newlineOffsets.length) return this.textLength;
+		else if (position.line < 0) return 0;
+		const lineOffset = this.newlineOffsets[position.line];
+		if (position.character <= 0) return lineOffset;
+		const nextLineOffset = position.line + 1 < this.newlineOffsets.length ? this.newlineOffsets[position.line + 1] : this.textLength;
+		return Math.min(lineOffset + position.character, nextLineOffset);
+	}
+	offsetToDisplayPos(offset) {
+		const pos = this.positionAt(offset);
+		return {
+			line: pos.line + 1,
+			character: pos.character + 1
+		};
+	}
+	getSurroundingContext(pos, end, surroundingLines) {
+		const startLine = this.positionAt(pos).line;
+		const endLine = this.positionAt(end).line;
+		const contextStartLine = Math.max(0, startLine - surroundingLines);
+		const contextPos = this.newlineOffsets[contextStartLine];
+		const nextLineAfterContext = Math.min(this.lineCount - 1, endLine + surroundingLines) + 1;
+		let contextEnd;
+		if (nextLineAfterContext < this.lineCount) {
+			const nextLineStart = this.newlineOffsets[nextLineAfterContext];
+			let eolLength = 1;
+			if (nextLineStart > 0 && this.text.charCodeAt(nextLineStart - 1) === 10) {
+				if (nextLineStart > 1 && this.text.charCodeAt(nextLineStart - 2) === 13) eolLength = 2;
+			}
+			contextEnd = nextLineStart - eolLength;
+		} else contextEnd = this.textLength;
+		return {
+			contextPos,
+			contextEnd
+		};
+	}
+	rangeAt(range) {
+		return {
+			start: this.positionAt(range.pos),
+			end: this.positionAt(range.end)
+		};
+	}
+	offsetRangeAt(range) {
+		return {
+			pos: this.offsetAt(range.start),
+			end: this.offsetAt(range.end)
+		};
+	}
+};
+function isEOL(char) {
+	return char === 13 || char === 10;
+}
+
+//#endregion
+//#region src/parsers/xmlui-parser/parser.ts
+const RECOVER_FILE = [
+	SyntaxKind.CData,
+	SyntaxKind.Script,
+	SyntaxKind.OpenNodeStart
+];
+const RECOVER_OPEN_TAG = [
 	SyntaxKind.OpenNodeStart,
 	SyntaxKind.NodeEnd,
 	SyntaxKind.NodeClose,
@@ -10220,9 +12092,9 @@ async function convertResourcesDir(distRoot, flatDist, filePrefix) {
 	}
 	return ret;
 }
-function removeLeadingSlashForPath(path$6) {
-	if (path$6.startsWith("/")) return path$6.substring(1);
-	return path$6;
+function removeLeadingSlashForPath(path$8) {
+	if (path$8.startsWith("/")) return path$8.substring(1);
+	return path$8;
 }
 const build = async ({ buildMode = "CONFIG_ONLY", flatDist = false, withMock = false, withHostingMetaFiles = false, withRelativeRoot = false }) => {
 	const flatDistUiPrefix = "ui_";
@@ -10411,6 +12283,420 @@ const preview = async ({ proxy }) => {
 	}
 };
 
+//#endregion
+//#region bin/ssg/discoverPaths.ts
+function getPagesComponent(comp) {
+	if (!comp) return null;
+	if (comp.type === "Pages") return comp;
+	if (Array.isArray(comp.children)) for (const child of comp.children) {
+		const result = getPagesComponent(child);
+		if (result) return result;
+	}
+	return null;
+}
+function substituteParams(url, params) {
+	let variants = [url];
+	for (const [key, value] of Object.entries(params)) {
+		if (!variants.some((variant) => variant.includes(`:${key}`))) continue;
+		const values = Array.isArray(value) ? value : [value];
+		const next = [];
+		for (const variant of variants) {
+			if (!variant.includes(`:${key}`)) {
+				next.push(variant);
+				continue;
+			}
+			for (const paramValue of values) {
+				if (paramValue === null || paramValue === void 0) continue;
+				next.push(variant.split(`:${key}`).join(String(paramValue)));
+			}
+		}
+		variants = next;
+	}
+	return variants.filter((variant) => !variant.includes(":"));
+}
+function normalizeRoute$1(pathname) {
+	let route = pathname.trim();
+	if (route.length === 0) return "/";
+	if (!route.startsWith("/")) route = `/${route}`;
+	if (route !== "/" && route.endsWith("/")) route = route.slice(0, -1);
+	return route;
+}
+async function readAllFilesRecursive(dir) {
+	const files = [];
+	let entries;
+	try {
+		entries = await (0, node_fs_promises.readdir)(dir, { withFileTypes: true });
+	} catch {
+		return files;
+	}
+	for (const entry of entries) {
+		const fullPath = node_path.default.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			files.push(...await readAllFilesRecursive(fullPath));
+			continue;
+		}
+		files.push(fullPath);
+	}
+	return files;
+}
+async function discoverPaths(cwd) {
+	const mainXmluiPath = node_path.default.resolve(cwd, "src", "Main.xmlui");
+	const discovered = /* @__PURE__ */ new Set();
+	let mainXmluiTextContent;
+	try {
+		mainXmluiTextContent = await (0, node_fs_promises.readFile)(mainXmluiPath, "utf-8");
+	} catch {
+		return ["/"];
+	}
+	const { parse: parse$2, getText } = createXmlUiParser(mainXmluiTextContent);
+	const pagesComp = getPagesComponent(nodeToComponentDef(parse$2().node, getText, 0));
+	if (pagesComp?.children) for (const page of pagesComp.children) {
+		const url = page.props?.url;
+		if (typeof url !== "string" || url.trim().length === 0) continue;
+		if (page.props?.staticPaths) try {
+			const staticPaths = extractParam({}, page.props.staticPaths, void 0, true);
+			if (Array.isArray(staticPaths)) for (const entry of staticPaths) {
+				if (!entry || typeof entry !== "object") continue;
+				const params = entry.params;
+				if (!params || typeof params !== "object") continue;
+				for (const resolved of substituteParams(url, params)) discovered.add(normalizeRoute$1(resolved));
+			}
+		} catch (error) {
+			console.warn(`Failed to evaluate staticPaths for '${url}'`, error);
+		}
+		if (!url.includes(":") && !url.includes("*")) discovered.add(normalizeRoute$1(url));
+	}
+	const contentDir = node_path.default.resolve(cwd, "content");
+	const contentFiles = await readAllFilesRecursive(contentDir);
+	for (const filePath of contentFiles) {
+		if (!filePath.endsWith(".md")) continue;
+		const relative = node_path.default.relative(contentDir, filePath).replace(/\\/g, "/");
+		if (relative.startsWith("pages/") || relative.includes("/pages/")) continue;
+		discovered.add(normalizeRoute$1(`/${relative.replace(/\.md$/, "")}`));
+	}
+	if (discovered.size === 0) return ["/"];
+	return [...discovered];
+}
+async function pathExists(targetPath) {
+	try {
+		await (0, node_fs_promises.stat)(targetPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region bin/ssg.ts
+const TEMP_ENTRY_FILE_NAME = ".xmlui-ssg-entry.tsx";
+const EXTENSION_FILE_CANDIDATES = [
+	"extensions.ts",
+	"extensions.tsx",
+	"extensions.mts",
+	"extensions.mjs",
+	"extensions.cjs",
+	"extensions.js"
+];
+function log(message) {
+	console.log(`[xmlui ssg] ${message}`);
+}
+function normalizeRoute(pathname) {
+	let normalized = new URL(pathname, "http://localhost").pathname;
+	if (!normalized.startsWith("/")) normalized = `/${normalized}`;
+	if (normalized !== "/" && normalized.endsWith("/")) normalized = normalized.slice(0, -1);
+	return normalized || "/";
+}
+function getOutputHtmlPath(outDir, routePath) {
+	if (routePath === "/") return node_path.default.join(outDir, "index.html");
+	return node_path.default.join(outDir, routePath.slice(1), "index.html");
+}
+function executeInlineScripts(html) {
+	const scriptRegex = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+	let match;
+	while ((match = scriptRegex.exec(html)) !== null) {
+		const attrs = match[1] || "";
+		const content = (match[2] || "").trim();
+		if (/\bsrc\s*=/.test(attrs) || !content) continue;
+		try {
+			node_vm.default.runInThisContext(content);
+		} catch (error) {
+			log(`inline script execution warning: ${content.slice(0, 500)}`);
+			console.error(error);
+		}
+	}
+}
+function mergeHtmlClasses(shellHtml, htmlClasses) {
+	if (!htmlClasses.trim()) return shellHtml;
+	return shellHtml.replace(/<html([^>]*?)>/i, (full, attributes) => {
+		const classMatch = /class=["']([^"']*)["']/.exec(attributes);
+		if (!classMatch) return `<html${attributes} class="${htmlClasses}">`;
+		const merged = `${classMatch[1].trim()} ${htmlClasses}`.trim();
+		return `<html${attributes.replace(classMatch[0], `class="${merged}"`)}>`;
+	});
+}
+function injectStylesIntoHead(shellHtml, ssrStyles, ssrHashes) {
+	if (!ssrStyles.trim()) return shellHtml;
+	const styleTag = `<style data-style-registry="true" data-ssr-hashes="${ssrHashes}">${ssrStyles}</style>`;
+	if (shellHtml.includes("</head>")) return shellHtml.replace("</head>", `${styleTag}</head>`);
+	return `${styleTag}${shellHtml}`;
+}
+function injectMarkup(shellHtml, markup) {
+	const rootRegex = /<div([^>]*\bid=["']root["'][^>]*)>[\s\S]*?<\/div>/i;
+	if (rootRegex.test(shellHtml)) return shellHtml.replace(rootRegex, `<div$1>${markup}</div>`);
+	if (shellHtml.includes("</body>")) return shellHtml.replace("</body>", `${markup}</body>`);
+	return `${shellHtml}${markup}`;
+}
+function applyRenderToShell(shellHtml, renderResult) {
+	let html = shellHtml;
+	html = mergeHtmlClasses(html, renderResult.htmlClasses);
+	html = injectStylesIntoHead(html, renderResult.ssrStyles, renderResult.ssrHashes);
+	html = injectMarkup(html, renderResult.markup);
+	if (!html.toLowerCase().startsWith("<!doctype")) return `<!DOCTYPE html>${html}`;
+	return html;
+}
+function getSsgEntrySource(extensionImportSpecifiers) {
+	return `
+import React from "react";
+import { renderToString } from "react-dom/server";
+import { StaticRouter } from "react-router-dom/server";
+import {
+  StandaloneApp,
+  StandaloneExtensionManager as ExtMgr,
+  StyleProvider,
+  StyleRegistry,
+} from "xmlui";
+
+const runtime = import.meta.glob("./src/**", { eager: true });
+
+const loadedExtensions: any[] = [];
+async function loadExtensions() {
+  const extensions: any[] = [];
+${extensionImportSpecifiers.map((spec, index) => {
+		return `  try {\n    const m${index} = await import(${JSON.stringify(spec)});\n    extensions.push(m${index}.default ?? m${index});\n  } catch (error) {\n    console.warn(\"[xmlui ssg] failed to load extension ${spec}\");\n    console.error(error);\n  }`;
+	}).join("\n")}
+  return extensions;
+}
+
+loadedExtensions.push(...(await loadExtensions()));
+
+function createExtensionManager() {
+  const extensionManager = new ExtMgr();
+  extensionManager.registerExtension(loadedExtensions || []);
+  return extensionManager;
+}
+
+export function renderPath(pathname: string) {
+  if (typeof globalThis !== "undefined") {
+    globalThis.location = new URL(pathname, "http://localhost") as unknown as Location;
+  }
+
+  const registry = new StyleRegistry();
+  const app = (
+    <StyleProvider styleRegistry={registry}>
+      <StaticRouter location={pathname}>
+        <StandaloneApp runtime={runtime} extensionManager={createExtensionManager()} />
+      </StaticRouter>
+    </StyleProvider>
+  );
+
+  const markup = renderToString(app);
+  return {
+    markup,
+    ssrStyles: registry.getSsrStyles(),
+    ssrHashes: Array.from(registry.cache.keys()).join(","),
+    htmlClasses: registry.getRootClasses(),
+  };
+}
+`;
+}
+async function findMonorepoRoot(startDir) {
+	let currentDir = startDir;
+	for (let depth$1 = 0; depth$1 < 12; depth$1++) {
+		const packageJsonPath = node_path.default.join(currentDir, "package.json");
+		if (await pathExists(packageJsonPath)) try {
+			if (JSON.parse(await (0, node_fs_promises.readFile)(packageJsonPath, "utf-8")).workspaces) return currentDir;
+		} catch {}
+		const parent = node_path.default.dirname(currentDir);
+		if (parent === currentDir) break;
+		currentDir = parent;
+	}
+	return null;
+}
+async function getWorkspacePatterns(monorepoRoot) {
+	const packageJsonPath = node_path.default.join(monorepoRoot, "package.json");
+	const pkg = JSON.parse(await (0, node_fs_promises.readFile)(packageJsonPath, "utf-8"));
+	if (Array.isArray(pkg.workspaces)) return pkg.workspaces;
+	if (Array.isArray(pkg.workspaces?.packages)) return pkg.workspaces.packages;
+	return [];
+}
+async function getExtensionImportSpecifiers(cwd) {
+	for (const fileName of EXTENSION_FILE_CANDIDATES) {
+		const filePath = node_path.default.join(cwd, fileName);
+		if (!await pathExists(filePath)) continue;
+		const matches = (await (0, node_fs_promises.readFile)(filePath, "utf-8")).matchAll(/from\s+["']([^"']+)["']/g);
+		const result = [];
+		for (const match of matches) {
+			const spec = match[1];
+			if (!result.includes(spec)) result.push(spec);
+		}
+		return result;
+	}
+	return [];
+}
+async function getWorkspaceExtensionAliases(cwd) {
+	const extensionSpecs = new Set((await getExtensionImportSpecifiers(cwd)).filter((spec) => !spec.startsWith(".") && !spec.startsWith("/")));
+	if (extensionSpecs.size === 0) return {};
+	const monorepoRoot = await findMonorepoRoot(cwd);
+	if (!monorepoRoot) return {};
+	const patterns = await getWorkspacePatterns(monorepoRoot);
+	const aliases = {};
+	for (const pattern of patterns) {
+		if (!pattern.endsWith("/*")) continue;
+		const patternBase = node_path.default.join(monorepoRoot, pattern.slice(0, -2));
+		if (!await pathExists(patternBase)) continue;
+		const entries = await (0, node_fs_promises.readdir)(patternBase, { withFileTypes: true });
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			const packageDir = node_path.default.join(patternBase, entry.name);
+			const packageJsonPath = node_path.default.join(packageDir, "package.json");
+			if (!await pathExists(packageJsonPath)) continue;
+			try {
+				const packageName = JSON.parse(await (0, node_fs_promises.readFile)(packageJsonPath, "utf-8")).name;
+				if (!packageName || !extensionSpecs.has(packageName)) continue;
+				const sourceEntryCandidates = [
+					node_path.default.join(packageDir, "src", "index.tsx"),
+					node_path.default.join(packageDir, "src", "index.ts"),
+					node_path.default.join(packageDir, "src", "index.js")
+				];
+				for (const candidate of sourceEntryCandidates) if (await pathExists(candidate)) {
+					aliases[packageName] = candidate;
+					break;
+				}
+			} catch {}
+		}
+	}
+	return aliases;
+}
+const ssg = async ({ outDir = "dist-ssg", fallbackFile = "200" } = {}) => {
+	const cwd = process.cwd();
+	const outPath = node_path.default.resolve(cwd, outDir);
+	const distPath = node_path.default.resolve(cwd, "dist");
+	const ssrBuildPath = node_path.default.resolve(cwd, ".xmlui-ssg-ssr");
+	const ssrBundlePath = node_path.default.join(ssrBuildPath, "render.mjs");
+	const builtIndexPath = node_path.default.join(outPath, "index.html");
+	const sourceIndexPath = node_path.default.resolve(cwd, "index.html");
+	const tempEntryPath = node_path.default.resolve(cwd, TEMP_ENTRY_FILE_NAME);
+	log(`starting in ${cwd}`);
+	log(`cleaning output directory ${outPath}`);
+	await (0, node_fs_promises.rm)(outPath, {
+		recursive: true,
+		force: true
+	});
+	await (0, node_fs_promises.mkdir)(outPath, { recursive: true });
+	log("building project assets");
+	await build({
+		buildMode: "INLINE_ALL",
+		withMock: false,
+		withHostingMetaFiles: false,
+		withRelativeRoot: false,
+		flatDist: false
+	});
+	if (!await pathExists(distPath)) throw new Error(`dist folder was not generated: ${distPath}`);
+	log(`copying dist to ${outPath}`);
+	await (0, node_fs_promises.cp)(distPath, outPath, { recursive: true });
+	executeInlineScripts(await (0, node_fs_promises.readFile)(sourceIndexPath, "utf-8"));
+	const shellHtml = await (0, node_fs_promises.readFile)(builtIndexPath, "utf-8");
+	const pathsToRender = (await discoverPaths(cwd)).map(normalizeRoute);
+	const fallbackBaseName = fallbackFile.replace(/\.html$/i, "");
+	const fallbackRoute = normalizeRoute(`/${fallbackBaseName}`);
+	if (pathsToRender.includes(fallbackRoute)) throw new Error(`A discovered page route "${fallbackRoute}" conflicts with the fallback file name "${fallbackBaseName}.html". Use --fallback to specify a different name.`);
+	log(`discovered ${pathsToRender.length} route(s)`);
+	for (const route of pathsToRender) log(`route: ${route}`);
+	const extensionImportSpecifiers = await getExtensionImportSpecifiers(cwd);
+	if (extensionImportSpecifiers.length > 0) log(`detected extensions: ${extensionImportSpecifiers.join(", ")}`);
+	log("creating SSR module");
+	await (0, node_fs_promises.writeFile)(tempEntryPath, getSsgEntrySource(extensionImportSpecifiers), "utf-8");
+	const viteConfig = await getViteConfig({});
+	const extensionAliases = await getWorkspaceExtensionAliases(cwd);
+	if (Object.keys(extensionAliases).length > 0) log(`using workspace extension aliases: ${Object.keys(extensionAliases).join(", ")}`);
+	const existingAlias = viteConfig.resolve?.alias;
+	const mergedAlias = Array.isArray(existingAlias) ? [...existingAlias, ...Object.entries(extensionAliases).map(([find, replacement]) => ({
+		find,
+		replacement
+	}))] : {
+		...existingAlias || {},
+		...extensionAliases
+	};
+	try {
+		log("building SSR module");
+		await (0, node_fs_promises.rm)(ssrBuildPath, {
+			recursive: true,
+			force: true
+		});
+		await (0, vite.build)({
+			...viteConfig,
+			resolve: {
+				...viteConfig.resolve || {},
+				alias: mergedAlias
+			},
+			define: {
+				...viteConfig.define || {},
+				"process.env.VITE_BUILD_MODE": JSON.stringify("INLINE_ALL"),
+				"process.env.VITE_DEV_MODE": false,
+				"process.env.VITE_MOCK_ENABLED": false,
+				"process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV || "production")
+			},
+			build: {
+				...viteConfig.build || {},
+				ssr: tempEntryPath,
+				outDir: ssrBuildPath,
+				emptyOutDir: true,
+				minify: false,
+				rollupOptions: {
+					...viteConfig.build?.rollupOptions || {},
+					input: void 0,
+					output: {
+						...viteConfig.build?.rollupOptions?.output || {},
+						entryFileNames: "render.mjs",
+						inlineDynamicImports: true
+					}
+				}
+			}
+		});
+		if (!await pathExists(ssrBundlePath)) throw new Error(`failed to build SSR bundle: ${ssrBundlePath}`);
+		const renderModule = await import(`${(0, node_url.pathToFileURL)(ssrBundlePath).href}?t=${Date.now()}`);
+		if (!renderModule?.renderPath) throw new Error("failed to load renderPath from temporary SSG entry module");
+		const writePromises = [];
+		for (const route of pathsToRender) {
+			log(`rendering ${route}`);
+			const finalHtml = applyRenderToShell(shellHtml, renderModule.renderPath(route));
+			const outputFile = getOutputHtmlPath(outPath, route);
+			const dir = node_path.default.dirname(outputFile);
+			const writePromise = (async () => {
+				await (0, node_fs_promises.mkdir)(dir, { recursive: true });
+				await (0, node_fs_promises.writeFile)(outputFile, finalHtml, "utf-8");
+				log(`wrote ${outputFile}`);
+			})();
+			writePromises.push(writePromise);
+		}
+		log("waiting for all writes to complete...");
+		await Promise.all(writePromises);
+		const fallbackRendered = renderModule.renderPath(fallbackFile);
+		log(`rendering fallback shell at synthetic route ${fallbackRoute}`);
+		const fallbackHtml = applyRenderToShell(shellHtml, fallbackRendered);
+		const fallbackOutputFile = node_path.default.join(outPath, `${fallbackBaseName}.html`);
+		await (0, node_fs_promises.writeFile)(fallbackOutputFile, fallbackHtml, "utf-8");
+		log(`wrote ${fallbackOutputFile}`);
+	} finally {
+		await (0, node_fs_promises.rm)(tempEntryPath, { force: true });
+		await (0, node_fs_promises.rm)(ssrBuildPath, {
+			recursive: true,
+			force: true
+		});
+	}
+	log(`completed. static files are in ${outPath}`);
+};
+
 //#endregion
 //#region bin/build-lib.ts
 const buildLib = async ({ watchMode, mode = "production" }) => {
@@ -10590,6 +12876,22 @@ function getStringArg(arg, defaultValue) {
 		target,
 		source
 	});
+}).command("ssg", "Generate static pages", (yargs$1) => {
+	return yargs$1.option("outDir", {
+		type: "string",
+		default: "dist-ssg",
+		description: "SSG output directory"
+	}).option("fallback", {
+		type: "string",
+		default: "200",
+		description: "Base name for the fallback HTML file served for unknown routes"
+	});
+}, (argv) => {
+	const { outDir, fallback } = argv;
+	ssg({
+		outDir: getStringArg(outDir, "dist-ssg"),
+		fallbackFile: getStringArg(fallback, "200")
+	});
 }).strict().demandCommand(1, "You need to provide a command").help().parse();
 
 //#endregion