@zeus-js/compiler 0.1.1-beta.0 → 0.1.1-beta.2

package/dist/compiler.esm-bundler.js

@@ -1,2004 +1,9 @@
 /**
-* compiler v0.1.1-beta.0
+* compiler v0.1.1-beta.2
 * (c) 2026 baicie
 * Released under the MIT License.
 **/
-import { declare } from "@babel/helper-plugin-utils";
-import { extend } from "@zeus-js/shared";
-import * as t from "@babel/types";
-import { parseExpression } from "@babel/parser";
-import { attrBindingIR, componentIR, dynamicTextIR, elementIR, eventBindingIR, expressionIR, forIR, fragmentIR, hostIR, id, identifierIR, propBindingIR, ref, refBindingIR, showIR, slotIR, staticAttrIR, textIR } from "@zeus-js/compiler-shared";
-export * from "@zeus-js/compiler-shared";
-//#region packages/core/compiler/src/codegen/support/imports.ts
-/**
-* Runtime helpers registration and program injection.
-*
-* Manages the collection of runtime helper imports (template, insert, setAttr,
-* createComponent, delegateEvents, etc.) and generates the necessary import
-* declarations at the top of the program.
-*/
-const DEFAULT_RENDERER_MODULE = "@zeus-js/runtime-dom";
-function getImportKey(moduleName, imported) {
-	return `${moduleName}:${imported}`;
-}
-function getRendererConfig(path, renderer = "dom") {
-	var _hub$file;
-	const hub = path.hub;
-	return {
-		renderer,
-		moduleName: (hub === null || hub === void 0 || (_hub$file = hub.file) === null || _hub$file === void 0 || (_hub$file = _hub$file.metadata) === null || _hub$file === void 0 || (_hub$file = _hub$file.zeus) === null || _hub$file === void 0 || (_hub$file = _hub$file.config) === null || _hub$file === void 0 ? void 0 : _hub$file.moduleName) || "@zeus-js/runtime-dom"
-	};
-}
-function registerImportMethod(path, imported, moduleName = getRendererConfig(path, "dom").moduleName) {
-	const data = getProgramScopeData(path);
-	const importMethods = data.importMethods || (data.importMethods = /* @__PURE__ */ new Map());
-	const key = getImportKey(moduleName, imported);
-	const cached = importMethods.get(key);
-	if (cached) return t.cloneNode(cached.local);
-	const local = getProgramPath(path).scope.generateUidIdentifier(imported);
-	importMethods.set(key, {
-		imported,
-		local,
-		moduleName
-	});
-	return t.cloneNode(local);
-}
-/**
-* Generates import declarations for all collected runtime helpers and
-* prepends them to the program body.
-*/
-function appendImportMethods(path) {
-	const importMethods = path.scope.data.importMethods;
-	if (!(importMethods === null || importMethods === void 0 ? void 0 : importMethods.size)) return;
-	const grouped = /* @__PURE__ */ new Map();
-	for (const record of importMethods.values()) {
-		const records = grouped.get(record.moduleName);
-		if (records) records.push(record);
-		else grouped.set(record.moduleName, [record]);
-	}
-	const declarations = [];
-	for (const [moduleName, records] of grouped) declarations.push(t.importDeclaration(records.map((record) => t.importSpecifier(t.cloneNode(record.local), t.identifier(record.imported))), t.stringLiteral(moduleName)));
-	path.unshiftContainer("body", declarations);
-}
-function getProgramScopeData(path) {
-	return path.scope.getProgramParent().path.scope.data;
-}
-function getProgramPath(path) {
-	return path.scope.getProgramParent().path;
-}
-//#endregion
-//#region packages/core/compiler/src/codegen/support/templates.ts
-/**
-* Template registration, scope data management, and program injection.
-*
-* Tracks all compiled templates across the program scope, registers template
-* variable declarations (tmpl$0, tmpl$1, ...), and generates the template
-* registration calls at the top of the program.
-*/
-/**
-* Retrieves all registered templates for a given renderer.
-*/
-function getTemplates(path, renderer = "dom") {
-	var _scopeData$templates$, _scopeData$templates;
-	return (_scopeData$templates$ = (_scopeData$templates = path.scope.data.templates) === null || _scopeData$templates === void 0 ? void 0 : _scopeData$templates.filter((t) => t.renderer === renderer)) !== null && _scopeData$templates$ !== void 0 ? _scopeData$templates$ : [];
-}
-function escapeStringForTemplate(value) {
-	return value.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
-}
-function isMathMLTemplate(template) {
-	return /^<(math|annotation|annotation-xml|maction|merror|mfrac|mi|mmultiscripts|mn|mo|mover|mpadded|mphantom|mprescripts|mroot|mrow|ms|mspace|msqrt|mstyle|msub|msubsup|msup|mtable|mtd|mtext|mtr|munder|munderover|semantics|menclose|mfenced)(\s|>)/.test(template);
-}
-/**
-* Generates `var tmpl$0 = template(...), tmpl$1 = template(...)` declarations
-* and unshifts them to the top of the program.
-*/
-function appendTemplates(path) {
-	const templates = getTemplates(path, "dom");
-	if (!templates.length) return;
-	const templateMethod = registerImportMethod(path, "template", getRendererConfig(path, "dom").moduleName);
-	const declarators = templates.map((template) => {
-		const html = template.templateWithClosingTags || template.template;
-		const tmpl = {
-			cooked: html,
-			raw: escapeStringForTemplate(html)
-		};
-		const shouldUseImportNode = Boolean(template.isCE || template.isImportNode);
-		const isMathML = isMathMLTemplate(html);
-		const args = [t.templateLiteral([t.templateElement(tmpl, true)], [])];
-		if (template.isSVG || shouldUseImportNode || isMathML) args.push(t.booleanLiteral(shouldUseImportNode), t.booleanLiteral(Boolean(template.isSVG)), t.booleanLiteral(isMathML));
-		return t.variableDeclarator(t.cloneNode(template.id), t.addComment(t.callExpression(t.cloneNode(templateMethod), args), "leading", "#__PURE__"));
-	});
-	path.node.body.unshift(t.variableDeclaration("var", declarators));
-}
-//#endregion
-//#region packages/core/compiler/src/codegen/support/events.ts
-/**
-* Event registration and delegation.
-*
-* Tracks all event handlers encountered during JSX transform and generates
-* a single delegateEvents call at the end of the program (if any events
-* were found).
-*/
-/**
-* Registers an event name in the program scope.
-* Events are deduplicated — registering the same event name multiple times
-* only keeps it once.
-*/
-function registerEvent(path, eventName) {
-	const scopeData = path.scope.getProgramParent().path.scope.data;
-	(scopeData.events || (scopeData.events = /* @__PURE__ */ new Set())).add(eventName);
-}
-/**
-* Generates a delegateEvents(...) call at the end of the program body.
-*
-* This implements the event delegation pattern: instead of attaching individual
-* addEventListener calls, we register event names with the runtime so it can
-* attach a single delegated listener at the root.
-*/
-function appendEvents(path) {
-	const events = path.scope.data.events;
-	if (!(events === null || events === void 0 ? void 0 : events.size)) return;
-	path.node.body.push(t.expressionStatement(t.callExpression(registerImportMethod(path, "delegateEvents", getRendererConfig(path, "dom").moduleName), [t.arrayExpression(Array.from(events).map((eventName) => t.stringLiteral(eventName)))])));
-}
-//#endregion
-//#region packages/core/compiler/src/config/index.ts
-const DEFAULT_SSR_RENDERER_MODULE = "@zeus-js/runtime-ssr";
-const DEFAULT_OPTIONS = {
-	moduleName: DEFAULT_RENDERER_MODULE,
-	generate: "dom",
-	hydratable: false,
-	delegateEvents: true,
-	delegatedEvents: [],
-	builtIns: [],
-	wrapConditionals: true,
-	omitNestedClosingTags: false,
-	omitLastClosingTag: true,
-	omitQuotes: true,
-	contextToCustomElements: false,
-	staticMarker: "@once",
-	effectWrapper: "effect",
-	memoWrapper: "memo",
-	validate: true,
-	inlineStyles: true
-};
-/**
-* Resolve the compiler options by merging the default options with the provided options.
-* @param options - The compiler options to resolve.
-* @returns The resolved compiler options.
-*/
-function resolveConfig(options) {
-	const config = extend({}, DEFAULT_OPTIONS, options);
-	if (config.generate === "ssr" && (options === null || options === void 0 ? void 0 : options.moduleName) === void 0) config.moduleName = DEFAULT_SSR_RENDERER_MODULE;
-	return config;
-}
-//#endregion
-//#region packages/core/compiler/src/context/CompilerContext.ts
-var CompilerContext = class {
-	constructor(options, programPath) {
-		this.options = options;
-		this.programPath = programPath;
-	}
-	runtimeModule() {
-		return this.options.moduleName || "@zeus-js/runtime-dom";
-	}
-	uid(name) {
-		return this.programPath.scope.generateUidIdentifier(name);
-	}
-	importRuntime(imported) {
-		const moduleName = this.runtimeModule();
-		const scopeData = this.programPath.scope.data;
-		const importMethods = scopeData.importMethods || (scopeData.importMethods = /* @__PURE__ */ new Map());
-		const key = `${moduleName}:${imported}`;
-		const cached = importMethods.get(key);
-		if (cached) return t.cloneNode(cached.local);
-		const local = this.uid(imported);
-		importMethods.set(key, {
-			moduleName,
-			imported,
-			local
-		});
-		return t.cloneNode(local);
-	}
-	registerTemplate(html, isSVG = false) {
-		const scopeData = this.programPath.scope.data;
-		const templateMap = scopeData.templateMap || (scopeData.templateMap = /* @__PURE__ */ new Map());
-		const templates = scopeData.templates || (scopeData.templates = []);
-		const cached = templateMap.get(html);
-		if (cached) return {
-			id: t.cloneNode(cached.id),
-			html,
-			isSVG: Boolean(cached.isSVG)
-		};
-		const id = this.uid("tmpl$");
-		templateMap.set(html, {
-			id,
-			template: html,
-			templateWithClosingTags: html,
-			renderer: "dom",
-			isSVG,
-			isCE: html.includes("-"),
-			isImportNode: /^<(img|iframe)(\s|>)/.test(html)
-		});
-		templates.push(templateMap.get(html));
-		return {
-			id: t.cloneNode(id),
-			html,
-			isSVG
-		};
-	}
-};
-function getCompilerContext(path, options) {
-	return new CompilerContext(options, path.scope.getProgramParent().path);
-}
-//#endregion
-//#region packages/core/compiler/src/context/defineElementSetups.ts
-const ZEUS_PUBLIC_MODULE = "@zeus-js/zeus";
-function collectDefineElementSetups(path, runtimeModule) {
-	const setups = /* @__PURE__ */ new WeakSet();
-	const trustedModules = /* @__PURE__ */ new Set([
-		DEFAULT_RENDERER_MODULE,
-		ZEUS_PUBLIC_MODULE,
-		runtimeModule
-	]);
-	for (const statement of path.node.body) {
-		if (!t.isImportDeclaration(statement) || !trustedModules.has(statement.source.value)) continue;
-		for (const specifier of statement.specifiers) {
-			if (!isDefineElementImport(specifier)) continue;
-			const binding = path.scope.getBinding(specifier.local.name);
-			if (!binding || binding.path.node !== specifier) continue;
-			for (const reference of binding.referencePaths) collectSetupFromReference(reference, setups);
-		}
-	}
-	getProgramScopeData(path).defineElementSetups = setups;
-}
-function isDefineElementRenderRoot(path) {
-	var _returnPath$getFuncti;
-	const setups = getProgramScopeData(path).defineElementSetups;
-	const functionPath = path.getFunctionParent();
-	if (!setups || !functionPath || !t.isFunction(functionPath.node) || !setups.has(functionPath.node)) return false;
-	const root = skipTransparentExpressionWrappers(path);
-	if (functionPath.isArrowFunctionExpression() && functionPath.node.body === root.node) return true;
-	const returnPath = root.parentPath;
-	return Boolean((returnPath === null || returnPath === void 0 ? void 0 : returnPath.isReturnStatement()) && returnPath.node.argument === root.node && ((_returnPath$getFuncti = returnPath.getFunctionParent()) === null || _returnPath$getFuncti === void 0 ? void 0 : _returnPath$getFuncti.node) === functionPath.node);
-}
-function isDefineElementImport(specifier) {
-	if (!t.isImportSpecifier(specifier)) return false;
-	const imported = specifier.imported;
-	return t.isIdentifier(imported) && imported.name === "defineElement" || t.isStringLiteral(imported) && imported.value === "defineElement";
-}
-function collectSetupFromReference(reference, setups) {
-	const call = reference.parentPath;
-	if (reference.key !== "callee" || !(call === null || call === void 0 ? void 0 : call.isCallExpression()) || call.node.callee !== reference.node) return;
-	const setup = call.get("arguments")[2];
-	if (!setup) return;
-	const setupFunction = resolveSetupFunction(setup, /* @__PURE__ */ new Set());
-	if (setupFunction) setups.add(setupFunction);
-}
-function resolveSetupFunction(path, visitedBindings) {
-	const setupPath = unwrapTransparentExpressionWrappers(path);
-	if (setupPath.isArrowFunctionExpression() || setupPath.isFunctionExpression()) return setupPath.node;
-	if (!setupPath.isIdentifier()) return void 0;
-	const binding = setupPath.scope.getBinding(setupPath.node.name);
-	if (!(binding === null || binding === void 0 ? void 0 : binding.constant) || visitedBindings.has(binding)) return void 0;
-	visitedBindings.add(binding);
-	if (binding.path.isFunctionDeclaration()) return binding.path.node;
-	if (!binding.path.isVariableDeclarator()) return void 0;
-	const init = binding.path.get("init");
-	if (Array.isArray(init) || !init.node) return void 0;
-	return resolveSetupFunction(init, visitedBindings);
-}
-function unwrapTransparentExpressionWrappers(path) {
-	let current = path;
-	while (isTransparentExpressionWrapper(current.node)) current = current.get("expression");
-	return current;
-}
-function skipTransparentExpressionWrappers(path) {
-	let current = path;
-	while (current.parentPath && wrapsExpression(current.parentPath, current)) current = current.parentPath;
-	return current;
-}
-function wrapsExpression(parent, child) {
-	const node = parent.node;
-	return isTransparentExpressionWrapper(node) && node.expression === child.node;
-}
-function isTransparentExpressionWrapper(node) {
-	return t.isParenthesizedExpression(node) || t.isTSAsExpression(node) || t.isTSSatisfiesExpression(node) || t.isTSTypeAssertion(node) || t.isTypeCastExpression(node) || t.isTSNonNullExpression(node);
-}
-//#endregion
-//#region packages/core/compiler/src/utils/constant.ts
-const VoidElements = [
-	"area",
-	"base",
-	"br",
-	"col",
-	"embed",
-	"hr",
-	"img",
-	"input",
-	"keygen",
-	"link",
-	"menuitem",
-	"meta",
-	"param",
-	"source",
-	"track",
-	"wbr"
-];
-//#endregion
-//#region packages/core/compiler/src/utils/html.ts
-function escapeHTML(value, attr = false) {
-	let result = value.replace(/&/g, "&amp;");
-	if (attr) return result.replace(/"/g, "&quot;").replace(/>/g, "&gt;");
-	return result.replace(/</g, "&lt;");
-}
-function trimJSXText(value) {
-	return value.replace(/\r\n?/g, "\n").split("\n").map((line) => line.trim()).filter(Boolean).join(" ");
-}
-const rawTextElements = /* @__PURE__ */ new Set([
-	"script",
-	"style",
-	"textarea",
-	"title"
-]);
-function isRawTextElement(tagName) {
-	return rawTextElements.has(tagName);
-}
-//#endregion
-//#region packages/core/compiler/src/utils/metadata.ts
-function setZeusMetadata(state, config) {
-	const metadata = state.file.metadata;
-	metadata.zeus = extend({}, metadata.zeus, { config });
-	return metadata.zeus;
-}
-//#endregion
-//#region packages/core/compiler/src/program.ts
-/**
-* Program visitor — entry and exit point for the entire transform pass.
-*
-* - Program.enter: initializes file metadata
-* - Program.exit: injects all collected codegen artifacts (templates, events, imports)
-*/
-function enterProgram(config, path, state) {
-	setZeusMetadata(state, config);
-	collectDefineElementSetups(path, config.moduleName);
-}
-function exitProgram(config, path, state) {
-	if (state.get("skip")) return;
-	if (config.generate === "dom") {
-		appendTemplates(path);
-		if (config.delegateEvents) appendEvents(path);
-	}
-	appendImportMethods(path);
-}
-function createProgramVisitor(config) {
-	return {
-		enter(path, state) {
-			enterProgram(config, path, state);
-		},
-		exit(path, state) {
-			exitProgram(config, path, state);
-		}
-	};
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.137.0/helpers/esm/typeof.js
-function _typeof(o) {
-	"@babel/helpers - typeof";
-	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
-		return typeof o;
-	} : function(o) {
-		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-	}, _typeof(o);
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.137.0/helpers/esm/toPrimitive.js
-function toPrimitive(t, r) {
-	if ("object" != _typeof(t) || !t) return t;
-	var e = t[Symbol.toPrimitive];
-	if (void 0 !== e) {
-		var i = e.call(t, r || "default");
-		if ("object" != _typeof(i)) return i;
-		throw new TypeError("@@toPrimitive must return a primitive value.");
-	}
-	return ("string" === r ? String : Number)(t);
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.137.0/helpers/esm/toPropertyKey.js
-function toPropertyKey(t) {
-	var i = toPrimitive(t, "string");
-	return "symbol" == _typeof(i) ? i : i + "";
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.137.0/helpers/esm/defineProperty.js
-function _defineProperty(e, r, t) {
-	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
-		value: t,
-		enumerable: !0,
-		configurable: !0,
-		writable: !0
-	}) : e[r] = t, e;
-}
-//#endregion
-//#region \0@oxc-project+runtime@0.137.0/helpers/esm/objectSpread2.js
-function ownKeys(e, r) {
-	var t = Object.keys(e);
-	if (Object.getOwnPropertySymbols) {
-		var o = Object.getOwnPropertySymbols(e);
-		r && (o = o.filter(function(r) {
-			return Object.getOwnPropertyDescriptor(e, r).enumerable;
-		})), t.push.apply(t, o);
-	}
-	return t;
-}
-function _objectSpread2(e) {
-	for (var r = 1; r < arguments.length; r++) {
-		var t = null != arguments[r] ? arguments[r] : {};
-		r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
-			_defineProperty(e, r, t[r]);
-		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
-			Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
-		});
-	}
-	return e;
-}
-//#endregion
-//#region packages/core/compiler/src/adapters/babel/expression.ts
-function lowerExpressionIR(path) {
-	return expressionIR(path.getSource() || path.toString(), sourceSpanFromBabelNode(path.node));
-}
-function expressionIRFromCode(code, node) {
-	return expressionIR(code, sourceSpanFromBabelNode(node));
-}
-function parseExpressionIR(expression) {
-	var _expression$span;
-	const start = (_expression$span = expression.span) === null || _expression$span === void 0 ? void 0 : _expression$span.start;
-	const sourceStart = typeof (start === null || start === void 0 ? void 0 : start.offset) === "number" ? {
-		startLine: start.line,
-		startColumn: start.column,
-		startIndex: start.offset
-	} : {};
-	return parseExpression(expression.code, _objectSpread2({
-		sourceType: "module",
-		plugins: ["typescript", "jsx"]
-	}, sourceStart));
-}
-function sourceSpanFromBabelNode(node) {
-	if (!(node === null || node === void 0 ? void 0 : node.loc)) return void 0;
-	return {
-		start: sourcePosition(node.loc.start.line, node.loc.start.column, node.start),
-		end: sourcePosition(node.loc.end.line, node.loc.end.column, node.end)
-	};
-}
-function sourcePosition(line, column, offset) {
-	return typeof offset === "number" ? {
-		line,
-		column,
-		offset
-	} : {
-		line,
-		column
-	};
-}
-//#endregion
-//#region packages/core/compiler/src/codegen/dom/emitBinding.ts
-function emitBindings(node, context) {
-	const statements = [];
-	for (const attr of node.attrs) {
-		if (attr.kind === "AttrBinding") statements.push(emitAttrBinding(node, attr, context));
-		if (attr.kind === "EventBinding") statements.push(emitEventBinding(node, attr, context));
-		if (attr.kind === "PropBinding") statements.push(emitPropBinding(node, attr, context));
-		if (attr.kind === "RefBinding") statements.push(emitRefBinding(node, attr, context));
-	}
-	if (isRawTextElement(node.tagName) && hasRuntimeRawText$1(node.children)) {
-		statements.push(emitRawTextBinding(node, context));
-		return statements;
-	}
-	for (const child of node.children) statements.push(...emitChildBinding(child, context));
-	return statements;
-}
-function emitRawTextBinding(node, context) {
-	return t.expressionStatement(t.callExpression(context.importRuntime("bindTextContent"), [t.identifier(node.ref.name), t.arrowFunctionExpression([], emitRawTextValue(node.children))]));
-}
-function hasRuntimeRawText$1(children) {
-	return children.some((child) => {
-		if (child.kind === "Text") return false;
-		if (child.kind === "Fragment") return hasRuntimeRawText$1(child.children);
-		return true;
-	});
-}
-function emitRawTextValue(children) {
-	const values = children.flatMap((child) => {
-		switch (child.kind) {
-			case "Text": return [t.stringLiteral(child.value)];
-			case "DynamicText": return [parseExpressionIR(child.expr)];
-			case "Fragment": return [emitRawTextValue(child.children)];
-			default: return [];
-		}
-	});
-	if (values.length === 0) return t.stringLiteral("");
-	if (values.length === 1) return values[0];
-	return t.arrayExpression(values);
-}
-function emitChildBinding(node, context) {
-	switch (node.kind) {
-		case "DynamicText": return emitDynamicText(node, context);
-		case "Component": return emitComponentInsert(node, context);
-		case "Show": return emitMarkerMount(node, context, emitMountShow(node, context));
-		case "For": return emitMarkerMount(node, context, emitMountFor(node, context));
-		case "Slot": return emitMarkerInsert(node, context, emitSlot(node, context));
-		case "Element": return emitBindings(node, context);
-		case "Fragment": return node.children.flatMap((child) => emitChildBinding(child, context));
-		default: return [];
-	}
-}
-function emitAttrBinding(target, binding, context) {
-	const name = normalizeAttrName(binding.name);
-	if (name === "class") return t.expressionStatement(t.callExpression(context.importRuntime("bindClass"), [t.identifier(target.ref.name), emitGetter(parseExpressionIR(binding.expr))]));
-	if (name === "style") return t.expressionStatement(t.callExpression(context.importRuntime("bindStyle"), [t.identifier(target.ref.name), emitGetter(parseExpressionIR(binding.expr))]));
-	return t.expressionStatement(t.callExpression(context.importRuntime("bindAttr"), [
-		t.identifier(target.ref.name),
-		t.stringLiteral(name),
-		emitGetter(parseExpressionIR(binding.expr))
-	]));
-}
-function normalizeAttrName(name) {
-	return name === "className" ? "class" : name;
-}
-function emitEventBinding(target, binding, context) {
-	registerEvent(context.programPath, binding.eventName);
-	return t.expressionStatement(t.callExpression(context.importRuntime("bindEvent"), [
-		t.identifier(target.ref.name),
-		t.stringLiteral(binding.eventName),
-		normalizeEventHandler(parseExpressionIR(binding.handler), context)
-	]));
-}
-function normalizeEventHandler(handler, context) {
-	if (t.isMemberExpression(handler) || t.isOptionalMemberExpression(handler)) {
-		const event = context.uid("event$");
-		return t.arrowFunctionExpression([t.identifier(event.name)], t.optionalCallExpression(t.cloneNode(handler), [t.identifier(event.name)], true));
-	}
-	return handler;
-}
-function emitPropBinding(target, binding, context) {
-	return t.expressionStatement(t.callExpression(context.importRuntime("bindProp"), [
-		t.identifier(target.ref.name),
-		t.stringLiteral(binding.name),
-		emitGetter(parseExpressionIR(binding.expr))
-	]));
-}
-function emitGetter(expr) {
-	if (t.isArrowFunctionExpression(expr) || t.isFunctionExpression(expr)) return expr;
-	return t.arrowFunctionExpression([], expr);
-}
-function emitRefBinding(target, binding, context) {
-	return t.expressionStatement(t.callExpression(context.importRuntime("bindRef"), [t.identifier(target.ref.name), parseExpressionIR(binding.expr)]));
-}
-function emitDynamicText(node, context) {
-	if (!node.domPath || node.domPath.kind !== "Marker") return [];
-	const textRef = context.uid("text$");
-	const expression = parseExpressionIR(node.expr);
-	if (node.once) return [t.variableDeclaration("const", [t.variableDeclarator(textRef, t.callExpression(t.memberExpression(t.identifier("document"), t.identifier("createTextNode")), [t.callExpression(t.identifier("String"), [expression])]))]), t.expressionStatement(t.callExpression(context.importRuntime("insert"), [
-		t.identifier(node.domPath.parent.name),
-		textRef,
-		t.identifier(node.ref.name)
-	]))];
-	return [
-		t.variableDeclaration("const", [t.variableDeclarator(textRef, t.callExpression(t.memberExpression(t.identifier("document"), t.identifier("createTextNode")), [t.stringLiteral("")]))]),
-		t.expressionStatement(t.callExpression(context.importRuntime("insert"), [
-			t.identifier(node.domPath.parent.name),
-			textRef,
-			t.identifier(node.ref.name)
-		])),
-		t.expressionStatement(t.callExpression(context.importRuntime("bindText"), [textRef, t.arrowFunctionExpression([], expression)]))
-	];
-}
-function emitComponentInsert(node, context) {
-	return emitMarkerInsert(node, context, emitComponent$1(node, context));
-}
-function emitMarkerInsert(node, context, value) {
-	if (!node.domPath || node.domPath.kind !== "Marker") return [];
-	return [t.expressionStatement(t.callExpression(context.importRuntime("insert"), [
-		t.identifier(node.domPath.parent.name),
-		value,
-		t.identifier(node.ref.name)
-	]))];
-}
-function emitMarkerMount(node, context, mountCall) {
-	if (!node.domPath || node.domPath.kind !== "Marker") return [];
-	return [t.expressionStatement(mountCall)];
-}
-//#endregion
-//#region packages/core/compiler/src/codegen/dom/emitDomPath.ts
-function emitPhysicalDomPath(path) {
-	switch (path.kind) {
-		case "Root": throw new Error("Root path is emitted from template clone directly");
-		case "FirstChild": return t.memberExpression(t.identifier(path.parent.name), t.identifier("firstChild"));
-		case "NextSibling": return t.memberExpression(t.identifier(path.previous.name), t.identifier("nextSibling"));
-		case "ChildNode": return t.memberExpression(t.memberExpression(t.identifier(path.parent.name), t.identifier("childNodes")), t.numericLiteral(path.index), true);
-	}
-}
-//#endregion
-//#region packages/core/compiler/src/passes/collectTemplates.ts
-function collectTemplates(node, context) {
-	if (node.kind === "Element") {
-		context.registerTemplate(renderTemplateHTML(node), node.flags.isSVG);
-		return;
-	}
-	if (node.kind === "Fragment") for (const child of node.children) {
-		if (child.kind !== "Element") continue;
-		context.registerTemplate(renderTemplateHTML(child), child.flags.isSVG);
-	}
-}
-function normalizeStaticAttrName(name) {
-	return name === "className" ? "class" : name;
-}
-function renderTemplateHTML(node) {
-	const attrs = node.attrs.filter((attr) => attr.kind === "StaticAttribute").map((attr) => {
-		if (attr.kind !== "StaticAttribute") return "";
-		const name = normalizeStaticAttrName(attr.name);
-		if (attr.value === true) return ` ${name}`;
-		return ` ${name}="${escapeAttr(attr.value)}"`;
-	}).join("");
-	if (node.flags.isVoid) return `<${node.tagName}${attrs}>`;
-	if (isRawTextElement(node.tagName) && hasRuntimeRawText(node.children)) return `<${node.tagName}${attrs}></${node.tagName}>`;
-	return `<${node.tagName}${attrs}>${node.children.map(renderChildTemplate).join("")}</${node.tagName}>`;
-}
-function hasRuntimeRawText(children) {
-	return children.some((child) => {
-		if (child.kind === "Text") return false;
-		if (child.kind === "Fragment") return hasRuntimeRawText(child.children);
-		return true;
-	});
-}
-function renderChildTemplate(node) {
-	switch (node.kind) {
-		case "Element": return renderTemplateHTML(node);
-		case "Text": return node.value;
-		case "DynamicText":
-		case "Component":
-		case "Show":
-		case "For":
-		case "Slot": return "<!>";
-		case "Host": return node.child ? renderChildTemplate(node.child) : "";
-		case "Fragment": return node.children.map(renderChildTemplate).join("");
-	}
-}
-function escapeAttr(value) {
-	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
-}
-//#endregion
-//#region packages/core/compiler/src/codegen/dom/emitTemplate.ts
-function emitTemplateClone(node, context) {
-	const html = renderTemplateHTML(node);
-	const template = context.registerTemplate(html, node.flags.isSVG);
-	const templateCall = t.callExpression(t.cloneNode(template.id), []);
-	return t.memberExpression(templateCall, t.identifier("firstChild"));
-}
-//#endregion
-//#region packages/core/compiler/src/codegen/dom/emitElement.ts
-function emitElement$1(node, context) {
-	if (!hasRuntimeWork(node)) return emitTemplateClone(node, context);
-	const statements = [
-		t.variableDeclaration("const", [t.variableDeclarator(t.identifier(node.ref.name), emitTemplateClone(node, context))]),
-		...emitDomRefDeclarations(node.children, context),
-		...emitBindings(node, context),
-		t.returnStatement(t.identifier(node.ref.name))
-	];
-	return t.callExpression(t.arrowFunctionExpression([], t.blockStatement(statements)), []);
-}
-function emitDomRefDeclarations(children, context) {
-	const statements = [];
-	const declared = /* @__PURE__ */ new Set();
-	const refNodeMap = collectRefNodeMap(children);
-	for (const child of children) collectRequiredDomRefDeclaration(child, statements, context, refNodeMap, declared);
-	return statements;
-}
-function collectRefNodeMap(children) {
-	const map = /* @__PURE__ */ new Map();
-	for (const child of children) collectRefNode(child, map);
-	return map;
-}
-function collectRefNode(node, map) {
-	switch (node.kind) {
-		case "Element":
-			map.set(node.ref.name, node);
-			for (const child of node.children) collectRefNode(child, map);
-			return;
-		case "DynamicText":
-		case "Component":
-		case "Show":
-		case "For":
-		case "Slot":
-			map.set(node.ref.name, node);
-			return;
-		case "Fragment":
-			for (const child of node.children) collectRefNode(child, map);
-			return;
-		case "Host":
-			if (node.child) collectRefNode(node.child, map);
-			return;
-		default: return;
-	}
-}
-function collectRequiredDomRefDeclaration(node, statements, context, refNodeMap, declared) {
-	switch (node.kind) {
-		case "Element":
-			if (needsDomRefDeclaration(node)) emitDomRefDeclarationWithDeps(node, statements, context, refNodeMap, declared);
-			for (const child of node.children) collectRequiredDomRefDeclaration(child, statements, context, refNodeMap, declared);
-			return;
-		case "DynamicText":
-		case "Component":
-		case "Show":
-		case "For":
-		case "Slot":
-			emitDomRefDeclarationWithDeps(node, statements, context, refNodeMap, declared);
-			return;
-		case "Fragment":
-			for (const child of node.children) collectRequiredDomRefDeclaration(child, statements, context, refNodeMap, declared);
-			return;
-		case "Host":
-			if (node.child) collectRequiredDomRefDeclaration(node.child, statements, context, refNodeMap, declared);
-			return;
-		default: return;
-	}
-}
-function emitDomRefDeclarationWithDeps(node, statements, context, refNodeMap, declared) {
-	if (declared.has(node.ref.name)) return;
-	if (!node.physicalDomPath) throw new Error(`${node.kind} physical DOM path is not assigned`);
-	emitPhysicalDomPathDependencies(node.physicalDomPath, statements, context, refNodeMap, declared);
-	statements.push(createDomRefDeclaration(node, context));
-	declared.add(node.ref.name);
-}
-function emitPhysicalDomPathDependencies(path, statements, context, refNodeMap, declared) {
-	switch (path.kind) {
-		case "Root": return;
-		case "FirstChild":
-			emitRefDependency(path.parent, statements, context, refNodeMap, declared);
-			return;
-		case "ChildNode":
-			emitRefDependency(path.parent, statements, context, refNodeMap, declared);
-			return;
-		case "NextSibling":
-			emitRefDependency(path.previous, statements, context, refNodeMap, declared);
-			return;
-	}
-}
-function emitRefDependency(ref, statements, context, refNodeMap, declared) {
-	const dep = refNodeMap.get(ref.name);
-	if (!dep) return;
-	emitDomRefDeclarationWithDeps(dep, statements, context, refNodeMap, declared);
-}
-function createDomRefDeclaration(node, _context) {
-	if (!node.physicalDomPath) throw new Error(`${node.kind} physical DOM path is not assigned`);
-	return t.variableDeclaration("const", [t.variableDeclarator(t.identifier(node.ref.name), emitPhysicalDomPath(node.physicalDomPath))]);
-}
-function needsDomRefDeclaration(node) {
-	if (!node.physicalDomPath) return false;
-	if (node.attrs.some((attr) => attr.kind === "AttrBinding" || attr.kind === "PropBinding" || attr.kind === "EventBinding" || attr.kind === "RefBinding")) return true;
-	return node.children.some((child) => {
-		switch (child.kind) {
-			case "DynamicText":
-			case "Component":
-			case "Show":
-			case "For":
-			case "Slot": return true;
-			case "Element": return needsDomRefDeclaration(child);
-			case "Fragment": return child.children.some((inner) => inner.kind === "Element" ? needsDomRefDeclaration(inner) : inner.kind !== "Text");
-			case "Host": return child.child ? innerKind(child.child) : false;
-			default: return false;
-		}
-	});
-}
-function innerKind(node) {
-	switch (node.kind) {
-		case "Element": return needsDomRefDeclaration(node);
-		case "Text": return false;
-		default: return true;
-	}
-}
-function hasRuntimeWork(node) {
-	return node.attrs.some((attr) => attr.kind === "AttrBinding" || attr.kind === "PropBinding" || attr.kind === "EventBinding" || attr.kind === "RefBinding") || node.children.some(hasChildRuntimeWork);
-}
-function hasChildRuntimeWork(node) {
-	switch (node.kind) {
-		case "DynamicText":
-		case "Component":
-		case "Show":
-		case "For":
-		case "Slot": return true;
-		case "Element": return hasRuntimeWork(node);
-		case "Fragment": return node.children.some(hasChildRuntimeWork);
-		case "Host": return node.child ? hasChildRuntimeWork(node.child) : false;
-		default: return false;
-	}
-}
-//#endregion
-//#region packages/core/compiler/src/codegen/dom/emitFragment.ts
-function emitFragment(node, context) {
-	return t.arrayExpression(node.children.map((child) => emitDOM(child, context)));
-}
-//#endregion
-//#region packages/core/compiler/src/codegen/dom/emitNodeExpression.ts
-function emitNodeExpression(node, context) {
-	switch (node.kind) {
-		case "Text": return t.stringLiteral(node.value);
-		case "DynamicText": return parseExpressionIR(node.expr);
-		case "Element": return emitElement$1(node, context);
-		case "Component": return emitComponent$1(node, context);
-		case "Fragment": return emitFragment(node, context);
-		case "Show": return emitShow$1(node, context);
-		case "For": return emitFor$1(node, context);
-		case "Host": return emitHost(node, context);
-		case "Slot": return emitSlot(node, context);
-		default: return t.nullLiteral();
-	}
-}
-//#endregion
-//#region packages/core/compiler/src/codegen/dom/emitComponent.ts
-function emitComponent$1(node, context) {
-	const props = t.objectExpression(node.props.map((prop) => emitComponentProp$1(prop, context)));
-	return t.callExpression(context.importRuntime("createComponent"), [parseExpressionIR(node.callee), props]);
-}
-function emitComponentProp$1(prop, context) {
-	const key = createObjectKey$2(prop.name);
-	if (Array.isArray(prop.value)) return t.objectMethod("get", key, [], t.blockStatement([t.returnStatement(emitChildrenProp(prop.value, context))]));
-	const value = parseExpressionIR(prop.value);
-	if (isStaticPropValue$1(value)) return t.objectProperty(key, value);
-	return t.objectMethod("get", key, [], t.blockStatement([t.returnStatement(value)]));
-}
-function emitChildrenProp(children, context) {
-	const nodes = children.map((child) => emitNodeExpression(child, context));
-	if (nodes.length === 1) return nodes[0];
-	return t.arrayExpression(nodes);
-}
-function isStaticPropValue$1(value) {
-	return t.isStringLiteral(value) || t.isNumericLiteral(value) || t.isBooleanLiteral(value) || t.isNullLiteral(value);
-}
-function createObjectKey$2(key) {
-	return t.isValidIdentifier(key) ? t.identifier(key) : t.stringLiteral(key);
-}
-//#endregion
-//#region packages/core/compiler/src/codegen/dom/emitBuiltin.ts
-function emitShow$1(node, context) {
-	const props = [t.objectProperty(t.identifier("when"), parseExpressionIR(node.when)), t.objectProperty(t.identifier("children"), t.arrowFunctionExpression([], emitChildrenProp(node.children, context)))];
-	if (node.fallback) props.push(t.objectProperty(t.identifier("fallback"), Array.isArray(node.fallback) ? t.arrowFunctionExpression([], emitChildrenProp(node.fallback, context)) : parseExpressionIR(node.fallback)));
-	return t.callExpression(context.importRuntime("createComponent"), [context.importRuntime("Show"), t.objectExpression(props)]);
-}
-function emitMountShow(node, context) {
-	const path = node.domPath;
-	if (!path || path.kind !== "Marker") throw new Error("Show DOM path is not assigned");
-	return t.callExpression(context.importRuntime("mountShow"), [
-		t.identifier(path.parent.name),
-		emitMarkerIdentifier(node),
-		t.arrowFunctionExpression([], parseExpressionIR(node.when)),
-		t.arrowFunctionExpression([], emitChildrenProp(node.children, context)),
-		node.fallback ? Array.isArray(node.fallback) ? t.arrowFunctionExpression([], emitChildrenProp(node.fallback, context)) : t.arrowFunctionExpression([], parseExpressionIR(node.fallback)) : t.identifier("undefined")
-	]);
-}
-function emitFor$1(node, context) {
-	const params = [t.identifier(node.item.name)];
-	if (node.index) params.push(t.identifier(node.index.name));
-	const props = [t.objectProperty(t.identifier("each"), parseExpressionIR(node.each)), t.objectProperty(t.identifier("children"), t.arrowFunctionExpression(params, emitChildrenProp(node.body, context)))];
-	if (node.by) props.push(t.objectProperty(t.identifier("by"), parseExpressionIR(node.by)));
-	return t.callExpression(context.importRuntime("createComponent"), [context.importRuntime("For"), t.objectExpression(props)]);
-}
-function emitMountFor(node, context) {
-	const params = [t.identifier(node.item.name)];
-	if (node.index) params.push(t.identifier(node.index.name));
-	const path = node.domPath;
-	if (!path || path.kind !== "Marker") throw new Error("For DOM path is not assigned");
-	return t.callExpression(context.importRuntime("mountFor"), [
-		t.identifier(path.parent.name),
-		emitMarkerIdentifier(node),
-		t.arrowFunctionExpression([], parseExpressionIR(node.each)),
-		node.by ? parseExpressionIR(node.by) : t.identifier("undefined"),
-		t.arrowFunctionExpression(params, emitChildrenProp(node.body, context))
-	]);
-}
-function emitHost(node, context) {
-	const props = buildHostProps(node, context);
-	const hostIdent = context.importRuntime("Host");
-	if (!node.child) return t.callExpression(hostIdent, [t.objectExpression(props)]);
-	const childExpr = emitNodeExpression(node.child, context);
-	const hostCall = t.callExpression(hostIdent, [t.objectExpression(props)]);
-	return t.callExpression(t.arrowFunctionExpression([], t.blockStatement([t.expressionStatement(hostCall), t.returnStatement(childExpr)])), []);
-}
-function buildHostProps(node, context) {
-	const props = [];
-	for (const attr of node.attrs) {
-		const key = createObjectKey$1(attr.name);
-		const expression = parseExpressionIR(attr.expr);
-		if (isStaticValue(expression) || isGetterExpression(expression)) props.push(t.objectProperty(key, expression));
-		else props.push(t.objectProperty(key, t.arrowFunctionExpression([], expression)));
-	}
-	return props;
-}
-function isStaticValue(expr) {
-	return t.isStringLiteral(expr) || t.isNumericLiteral(expr) || t.isBooleanLiteral(expr) || t.isNullLiteral(expr);
-}
-function isGetterExpression(expr) {
-	return t.isArrowFunctionExpression(expr) || t.isFunctionExpression(expr);
-}
-function createObjectKey$1(name) {
-	return t.isValidIdentifier(name) ? t.identifier(name) : t.stringLiteral(name);
-}
-function emitSlot(node, context) {
-	return t.callExpression(context.importRuntime("createSlot"), [node.name ? t.stringLiteral(node.name) : t.identifier("undefined"), node.fallback.length > 0 ? t.arrowFunctionExpression([], emitChildrenProp(node.fallback, context)) : t.identifier("undefined")]);
-}
-function emitMarkerIdentifier(node) {
-	return t.identifier(node.ref.name);
-}
-//#endregion
-//#region packages/core/compiler/src/codegen/dom/index.ts
-function emitDOM(node, context) {
-	switch (node.kind) {
-		case "Element": return emitElement$1(node, context);
-		case "Fragment": return emitFragment(node, context);
-		case "Component": return emitComponent$1(node, context);
-		case "Show": return emitShow$1(node, context);
-		case "For": return emitFor$1(node, context);
-		case "Host": return emitHost(node, context);
-		case "Slot": return emitSlot(node, context);
-		case "DynamicText": return t.arrowFunctionExpression([], parseExpressionIR(node.expr));
-		default: throw new Error(`Unsupported root IR node: ${node.kind}`);
-	}
-}
-//#endregion
-//#region packages/core/compiler/src/codegen/ssr/rawText.ts
-function getSSRRawTextTag(tagName) {
-	const normalized = tagName.toLowerCase();
-	return normalized === "script" || normalized === "style" ? normalized : void 0;
-}
-//#endregion
-//#region packages/core/compiler/src/codegen/ssr/property.ts
-const BOOLEAN_PROPERTY_ELEMENTS = {
-	checked: /* @__PURE__ */ new Set(["input"]),
-	disabled: /* @__PURE__ */ new Set([
-		"button",
-		"fieldset",
-		"input",
-		"optgroup",
-		"option",
-		"select",
-		"textarea"
-	]),
-	multiple: /* @__PURE__ */ new Set(["input", "select"]),
-	readOnly: /* @__PURE__ */ new Set(["input", "textarea"]),
-	selected: /* @__PURE__ */ new Set(["option"])
-};
-const VALUE_PROPERTY_ELEMENTS = /* @__PURE__ */ new Set([
-	"button",
-	"input",
-	"option",
-	"textarea"
-]);
-function isSSRPropertySupported(tag, name) {
-	var _BOOLEAN_PROPERTY_ELE;
-	const normalizedTag = tag.toLowerCase();
-	if (name === "tabIndex") return true;
-	if (name === "htmlFor") return normalizedTag === "label";
-	if (name === "value") return VALUE_PROPERTY_ELEMENTS.has(normalizedTag);
-	return Boolean((_BOOLEAN_PROPERTY_ELE = BOOLEAN_PROPERTY_ELEMENTS[name]) === null || _BOOLEAN_PROPERTY_ELE === void 0 ? void 0 : _BOOLEAN_PROPERTY_ELE.has(normalizedTag));
-}
-//#endregion
-//#region packages/core/compiler/src/diagnostics/codes.ts
-const CompilerErrorCode = {
-	UNSUPPORTED_SPREAD_ATTRIBUTE: "ZEUS_UNSUPPORTED_SPREAD_ATTRIBUTE",
-	UNSUPPORTED_SPREAD_CHILD: "ZEUS_UNSUPPORTED_SPREAD_CHILD",
-	UNSUPPORTED_FRAGMENT: "ZEUS_UNSUPPORTED_FRAGMENT",
-	UNSUPPORTED_FRAGMENT_CHILD: "ZEUS_UNSUPPORTED_FRAGMENT_CHILD",
-	UNSUPPORTED_COMPONENT_PROP: "ZEUS_UNSUPPORTED_COMPONENT_PROP",
-	EMPTY_EXPRESSION: "ZEUS_EMPTY_EXPRESSION",
-	INVALID_TRANSFORM_RESULT: "ZEUS_INVALID_TRANSFORM_RESULT",
-	UNSUPPORTED_NODE: "ZEUS_UNSUPPORTED_NODE",
-	INVALID_BUILTIN_USAGE: "ZEUS_INVALID_BUILTIN_USAGE",
-	UNSUPPORTED_SSR_BUILTIN: "ZEUS_UNSUPPORTED_SSR_BUILTIN",
-	UNSUPPORTED_SSR_PROPERTY: "ZEUS_UNSUPPORTED_SSR_PROPERTY",
-	UNSUPPORTED_SSR_RAW_TEXT_CHILD: "ZEUS_UNSUPPORTED_SSR_RAW_TEXT_CHILD",
-	INVALID_REF_USAGE: "ZEUS_INVALID_REF_USAGE"
-};
-//#endregion
-//#region packages/core/compiler/src/diagnostics/CompilerDiagnostic.ts
-function createCompilerDiagnostic(input) {
-	var _input$severity;
-	return _objectSpread2(_objectSpread2(_objectSpread2({
-		code: input.code,
-		severity: (_input$severity = input.severity) !== null && _input$severity !== void 0 ? _input$severity : "error",
-		message: input.message
-	}, input.hint === void 0 ? {} : { hint: input.hint }), input.filename === void 0 ? {} : { filename: input.filename }), input.span === void 0 ? {} : { span: input.span });
-}
-function formatCompilerDiagnostic(diagnostic) {
-	const hint = diagnostic.hint ? `\nHint: ${diagnostic.hint}` : "";
-	return `[${diagnostic.code}] ${diagnostic.message}${hint}`;
-}
-//#endregion
-//#region packages/core/compiler/src/diagnostics/CompilerError.ts
-var CompilerError = class extends Error {
-	constructor(options) {
-		const diagnostic = createCompilerDiagnostic(_objectSpread2(_objectSpread2({}, options), {}, { severity: "error" }));
-		super(formatCompilerDiagnostic(diagnostic));
-		this.name = "ZeusCompilerError";
-		this.diagnostic = diagnostic;
-		this.code = diagnostic.code;
-		this.severity = "error";
-		this.hint = diagnostic.hint;
-		this.filename = diagnostic.filename;
-		this.span = diagnostic.span;
-		this.loc = diagnostic.span ? {
-			line: diagnostic.span.start.line,
-			column: diagnostic.span.start.column
-		} : void 0;
-	}
-};
-//#endregion
-//#region packages/core/compiler/src/codegen/ssr/validate.ts
-function assertSSRSupported(node, filename, rawTextTag) {
-	if (rawTextTag && (node.kind === "Element" || node.kind === "Component")) throwUnsupportedSSRRawTextChild(node, rawTextTag, filename);
-	switch (node.kind) {
-		case "Host":
-		case "Slot": throwUnsupportedSSRBuiltin(node, filename);
-		case "Element":
-			for (const attribute of node.attrs) if (attribute.kind === "PropBinding" && !isSSRPropertySupported(node.tagName, attribute.name)) throwUnsupportedSSRProperty(node, attribute, filename);
-			const childRawTextTag = getSSRRawTextTag(node.tagName);
-			for (const child of node.children) assertSSRSupported(child, filename, childRawTextTag);
-			return;
-		case "Fragment":
-			for (const child of node.children) assertSSRSupported(child, filename, rawTextTag);
-			return;
-		case "Component":
-			for (const prop of node.props) {
-				if (!Array.isArray(prop.value)) continue;
-				for (const child of prop.value) assertSSRSupported(child, filename);
-			}
-			return;
-		case "Show":
-			for (const child of node.children) assertSSRSupported(child, filename, rawTextTag);
-			if (Array.isArray(node.fallback)) for (const child of node.fallback) assertSSRSupported(child, filename, rawTextTag);
-			return;
-		case "For":
-			for (const child of node.body) assertSSRSupported(child, filename, rawTextTag);
-			return;
-		case "Text":
-		case "DynamicText": return;
-	}
-}
-function throwUnsupportedSSRRawTextChild(node, tag, filename) {
-	throw new CompilerError({
-		code: CompilerErrorCode.UNSUPPORTED_SSR_RAW_TEXT_CHILD,
-		message: `${node.kind} children are not supported inside <${tag}> SSR raw text.`,
-		hint: "Use text expressions, Fragment, Show, or For directly inside the raw-text element.",
-		filename,
-		span: node.span
-	});
-}
-function throwUnsupportedSSRProperty(element, property, filename) {
-	var _ref, _property$span;
-	throw new CompilerError({
-		code: CompilerErrorCode.UNSUPPORTED_SSR_PROPERTY,
-		message: `Property "${property.name}" on <${element.tagName}> cannot be serialized by SSR codegen.`,
-		hint: "Use an equivalent HTML attribute binding or move this DOM-only property update to client code.",
-		filename,
-		span: (_ref = (_property$span = property.span) !== null && _property$span !== void 0 ? _property$span : property.expr.span) !== null && _ref !== void 0 ? _ref : element.span
-	});
-}
-function throwUnsupportedSSRBuiltin(node, filename) {
-	throw new CompilerError({
-		code: CompilerErrorCode.UNSUPPORTED_SSR_BUILTIN,
-		message: `<${node.kind}> is not supported by SSR codegen.`,
-		hint: "Render Web Components on the client; the SSR baseline supports DOM components only.",
-		filename,
-		span: node.span
-	});
-}
-//#endregion
-//#region packages/core/compiler/src/codegen/ssr/index.ts
-function emitSSR(node, context, rawTextTag) {
-	switch (node.kind) {
-		case "Element": return emitElement(node, context);
-		case "Fragment": return emitChildren(node.children, context, rawTextTag);
-		case "Text":
-			if (rawTextTag) return t.stringLiteral(decodeCompilerEscapedText(node.value));
-			return t.callExpression(context.importRuntime("ssrStatic"), [t.stringLiteral(node.value)]);
-		case "DynamicText":
-			if (rawTextTag) return parseExpressionIR(node.expr);
-			return t.callExpression(context.importRuntime("ssrText"), [parseExpressionIR(node.expr)]);
-		case "Component": return emitComponent(node, context);
-		case "Show": return emitShow(node, context, rawTextTag);
-		case "For": return emitFor(node, context, rawTextTag);
-		case "Host":
-		case "Slot": return throwUnsupportedSSRBuiltin(node);
-		default: return throwUnsupportedSSRNode(node);
-	}
-}
-function emitShow(node, context, rawTextTag) {
-	const args = [t.arrowFunctionExpression([], parseExpressionIR(node.when)), t.arrowFunctionExpression([], emitChildrenValue(node.children, context, rawTextTag))];
-	if (node.fallback) {
-		const fallback = Array.isArray(node.fallback) ? emitChildrenValue(node.fallback, context, rawTextTag) : parseExpressionIR(node.fallback);
-		args.push(t.arrowFunctionExpression([], fallback));
-	}
-	return t.callExpression(context.importRuntime("ssrShow"), args);
-}
-function emitFor(node, context, rawTextTag) {
-	const params = [t.identifier(node.item.name)];
-	if (node.index) params.push(t.identifier(node.index.name));
-	return t.callExpression(context.importRuntime("ssrFor"), [t.arrowFunctionExpression([], parseExpressionIR(node.each)), t.arrowFunctionExpression(params, emitChildrenValue(node.body, context, rawTextTag))]);
-}
-function emitComponent(node, context) {
-	return t.callExpression(context.importRuntime("ssrComponent"), [parseExpressionIR(node.callee), t.objectExpression(node.props.map((prop) => emitComponentProp(prop, context)))]);
-}
-function emitComponentProp(prop, context) {
-	const key = createObjectKey(prop.name);
-	if (Array.isArray(prop.value)) return t.objectMethod("get", key, [], t.blockStatement([t.returnStatement(emitChildrenValue(prop.value, context))]));
-	const value = parseExpressionIR(prop.value);
-	if (isStaticPropValue(value)) return t.objectProperty(key, value);
-	return t.objectMethod("get", key, [], t.blockStatement([t.returnStatement(value)]));
-}
-function emitElement(node, context) {
-	const rawTextTag = getSSRRawTextTag(node.tagName);
-	const args = [t.stringLiteral(node.tagName), t.arrayExpression(node.attrs.flatMap((attr) => {
-		switch (attr.kind) {
-			case "StaticAttribute":
-				if (isEventAttributeName$1(attr.name)) return [];
-				return [emitStaticAttribute(attr, context)];
-			case "AttrBinding": return [emitAttributeBinding(attr, context)];
-			case "PropBinding": return [emitPropertyBinding(attr, context)];
-			default: return [];
-		}
-	}))];
-	if (node.children.length > 0) args.push(emitChildren(node.children, context, rawTextTag));
-	if (node.flags.isVoid) {
-		if (node.children.length === 0) args.push(t.identifier("undefined"));
-		args.push(t.booleanLiteral(true));
-	}
-	return t.callExpression(context.importRuntime("ssrElement"), args);
-}
-function emitAttributeBinding(attr, context) {
-	const name = normalizeAttributeName(attr.name);
-	return t.callExpression(context.importRuntime("ssrAttr"), [t.stringLiteral(name), emitBindingValue(attr.expr)]);
-}
-function emitPropertyBinding(attr, context) {
-	return t.callExpression(context.importRuntime("ssrProp"), [t.stringLiteral(attr.name), emitBindingValue(attr.expr)]);
-}
-function emitBindingValue(expression) {
-	const value = parseExpressionIR(expression);
-	if (t.isArrowFunctionExpression(value) || t.isFunctionExpression(value)) return t.callExpression(value, []);
-	return value;
-}
-function emitStaticAttribute(attr, context) {
-	return t.callExpression(context.importRuntime("ssrAttr"), [t.stringLiteral(normalizeAttributeName(attr.name)), attr.value === true ? t.booleanLiteral(true) : t.stringLiteral(attr.value)]);
-}
-function emitChildren(children, context, rawTextTag) {
-	return t.arrayExpression(children.map((child) => emitSSR(child, context, rawTextTag)));
-}
-function emitChildrenValue(children, context, rawTextTag) {
-	if (children.length === 1) return emitSSR(children[0], context, rawTextTag);
-	return emitChildren(children, context, rawTextTag);
-}
-function decodeCompilerEscapedText(value) {
-	return value.replace(/&lt;/g, "<").replace(/&amp;/g, "&");
-}
-function isStaticPropValue(value) {
-	return t.isStringLiteral(value) || t.isNumericLiteral(value) || t.isBooleanLiteral(value) || t.isNullLiteral(value);
-}
-function createObjectKey(name) {
-	return t.isValidIdentifier(name) ? t.identifier(name) : t.stringLiteral(name);
-}
-function normalizeAttributeName(name) {
-	return name === "className" ? "class" : name;
-}
-function isEventAttributeName$1(name) {
-	return name.length > 2 && name.slice(0, 2).toLowerCase() === "on";
-}
-function throwUnsupportedSSRNode(node) {
-	const kind = node.kind;
-	throw new Error(`Unsupported SSR IR node: ${kind}`);
-}
-//#endregion
-//#region packages/core/compiler/src/adapters/babel/diagnostic.ts
-function createBabelCompilerError(path, options) {
-	var _hub$file;
-	const hub = path.hub;
-	return new CompilerError(_objectSpread2(_objectSpread2({}, options), {}, {
-		filename: hub === null || hub === void 0 || (_hub$file = hub.file) === null || _hub$file === void 0 || (_hub$file = _hub$file.opts) === null || _hub$file === void 0 ? void 0 : _hub$file.filename,
-		span: sourceSpanFromBabelNode(path.node)
-	}));
-}
-//#endregion
-//#region packages/core/compiler/src/parse/jsx.ts
-/**
-* JSX AST parsing utilities.
-*
-* Low-level helpers for extracting and interpreting information from Babel's
-* JSX AST nodes — tag names, attribute names, and path type guards.
-* These do NOT produce IR or Babel AST; they only read the JSX tree.
-*/
-function jsxElementNameToString(node) {
-	if (t.isJSXMemberExpression(node)) return `${jsxElementNameToString(node.object)}.${node.property.name}`;
-	if (t.isJSXIdentifier(node) || t.isIdentifier(node)) return node.name;
-	return `${node.namespace.name}:${node.name.name}`;
-}
-function getTagName(node) {
-	return jsxElementNameToString(node.openingElement.name);
-}
-function getJSXAttrName(name) {
-	if (t.isJSXNamespacedName(name)) return `${name.namespace.name}:${name.name.name}`;
-	return name.name;
-}
-function isComponentTag(tagName) {
-	return /^[A-Z]/.test(tagName) || tagName.includes(".");
-}
-function toEventName(name) {
-	return name.slice(2).toLowerCase();
-}
-//#endregion
-//#region packages/core/compiler/src/lower/lowerAttribute.ts
-function lowerAttribute(path, _context) {
-	if (path.isJSXSpreadAttribute() || t.isJSXSpreadAttribute(path.node)) throw createBabelCompilerError(path, {
-		code: CompilerErrorCode.UNSUPPORTED_SPREAD_ATTRIBUTE,
-		message: "Spread attributes are not supported in Zeus MVP.",
-		hint: "Use explicit attributes instead, for example <div id={id} />."
-	});
-	const node = path.node;
-	const name = getJSXAttrName(node.name);
-	const value = path.get("value");
-	if (!value.node) {
-		if (name === "ref") throw createBabelCompilerError(path, {
-			code: CompilerErrorCode.EMPTY_EXPRESSION,
-			message: "ref attribute requires an expression.",
-			hint: "Use <div ref={target} /> instead."
-		});
-		return staticAttrIR(name, true);
-	}
-	if (value.isStringLiteral()) {
-		if (name === "ref") throw createBabelCompilerError(path, {
-			code: CompilerErrorCode.INVALID_REF_USAGE,
-			message: "String refs are not supported in Zeus.",
-			hint: "Use a state holder or callback ref: <div ref={el} />."
-		});
-		return staticAttrIR(name, value.node.value);
-	}
-	if (value.isJSXExpressionContainer()) {
-		const expression = value.get("expression");
-		if (expression.isJSXEmptyExpression()) throw createBabelCompilerError(path, {
-			code: CompilerErrorCode.EMPTY_EXPRESSION,
-			message: `Attribute "${name}" expression cannot be empty.`
-		});
-		if (!expression.isExpression()) return null;
-		const expr = lowerExpressionIR(expression);
-		if (name === "ref") return refBindingIR(expr);
-		if (isEventAttributeName(name)) return eventBindingIR(toEventName(name), expr);
-		if (name.startsWith("prop:")) return propBindingIR(name.slice(5), expr);
-		return attrBindingIR(name, expr);
-	}
-	return null;
-}
-function isEventAttributeName(name) {
-	return name.length > 2 && name.slice(0, 2).toLowerCase() === "on";
-}
-//#endregion
-//#region packages/core/compiler/src/lower/lowerChildren.ts
-function lowerChildren(children, context) {
-	const result = [];
-	for (const child of children) {
-		if (child.isJSXText()) {
-			const text = trimJSXText(child.node.value);
-			if (text) result.push(textIR(escapeHTML(text)));
-			continue;
-		}
-		if (child.isJSXExpressionContainer()) {
-			const expression = child.get("expression");
-			if (expression.isJSXEmptyExpression()) continue;
-			if (expression.isExpression()) result.push(dynamicTextIR(lowerExpressionIR(expression), ref(context.uid("anchor$").name)));
-			continue;
-		}
-		if (child.isJSXElement() || child.isJSXFragment()) {
-			result.push(lowerJSX(child, context));
-			continue;
-		}
-	}
-	return result;
-}
-//#endregion
-//#region packages/core/compiler/src/lower/lowerBuiltin.ts
-const HOST_SKIP_PROPS = /* @__PURE__ */ new Set([
-	"key",
-	"__slot",
-	"__anchor"
-]);
-function isBuiltinTag(tagName) {
-	return tagName === "Show" || tagName === "For" || tagName === "Host" || tagName === "Slot";
-}
-function lowerBuiltin(path, context) {
-	const tagName = path.node.openingElement.name;
-	if (!t.isJSXIdentifier(tagName)) throw createBabelCompilerError(path, {
-		code: CompilerErrorCode.INVALID_BUILTIN_USAGE,
-		message: "Built-in JSX nodes do not support member expressions."
-	});
-	switch (tagName.name) {
-		case "Show": return lowerShow(path, context);
-		case "For": return lowerFor(path, context);
-		case "Host": return lowerHost(path, context);
-		case "Slot": return lowerSlot(path, context);
-		default: throw createBabelCompilerError(path, {
-			code: CompilerErrorCode.INVALID_BUILTIN_USAGE,
-			message: `Unsupported built-in <${tagName.name}>.`
-		});
-	}
-}
-function lowerShow(path, context) {
-	const when = requiredExpressionAttr(path, "when");
-	const fallback = optionalShowFallbackAttr(path, context);
-	return showIR({
-		ref: ref(context.uid("show$").name),
-		when,
-		fallback,
-		children: lowerChildren(path.get("children"), context)
-	});
-}
-function optionalShowFallbackAttr(path, context) {
-	const attr = path.get("openingElement").get("attributes").find((attrPath) => {
-		if (!attrPath.isJSXAttribute()) return false;
-		return getJSXAttrName(attrPath.node.name) === "fallback";
-	});
-	if (!(attr === null || attr === void 0 ? void 0 : attr.isJSXAttribute())) return void 0;
-	const value = attr.get("value");
-	if (!value.node) return expressionIRFromCode("true", attr.node);
-	if (value.isStringLiteral()) return expressionIRFromCode(JSON.stringify(value.node.value), value.node);
-	if (!value.isJSXExpressionContainer()) return void 0;
-	const expression = value.get("expression");
-	if (expression.isJSXEmptyExpression()) return void 0;
-	if (expression.isJSXElement() || expression.isJSXFragment()) return [lowerJSX(expression, context)];
-	if (expression.isExpression()) return lowerExpressionIR(expression);
-}
-function lowerFor(path, context) {
-	const each = requiredExpressionAttr(path, "each");
-	const by = optionalExpressionAttr(path, "by");
-	const render = getOnlyRenderFunction(path);
-	const item = getParamIdentifier(render, 0, "item");
-	const index = getParamIdentifier(render, 1);
-	const bodyPath = render.get("body");
-	const body = [];
-	if (bodyPath.isJSXElement() || bodyPath.isJSXFragment()) body.push(lowerJSX(bodyPath, context));
-	else if (bodyPath.isExpression()) body.push(dynamicTextIR(lowerExpressionIR(bodyPath), ref(context.uid("anchor$").name)));
-	return forIR({
-		ref: ref(context.uid("for$").name),
-		each,
-		by,
-		item,
-		index,
-		body
-	});
-}
-function lowerSlot(path, context) {
-	const name = optionalStringAttr(path, "name");
-	return slotIR({
-		ref: ref(context.uid("slot$").name),
-		name,
-		fallback: lowerChildren(path.get("children"), context),
-		span: sourceSpanFromBabelNode(path.node)
-	});
-}
-function requiredExpressionAttr(path, name) {
-	const value = optionalExpressionAttr(path, name);
-	if (!value) throw createBabelCompilerError(path, {
-		code: CompilerErrorCode.INVALID_BUILTIN_USAGE,
-		message: `<${getBuiltinName(path)}> requires "${name}".`
-	});
-	return value;
-}
-function optionalExpressionAttr(path, name) {
-	const attr = path.get("openingElement").get("attributes").find((attrPath) => {
-		if (!attrPath.isJSXAttribute()) return false;
-		return getJSXAttrName(attrPath.node.name) === name;
-	});
-	if (!(attr === null || attr === void 0 ? void 0 : attr.isJSXAttribute())) return void 0;
-	const value = attr.get("value");
-	if (!value.node) return expressionIRFromCode("true", attr.node);
-	if (value.isStringLiteral()) return expressionIRFromCode(JSON.stringify(value.node.value), value.node);
-	if (!value.isJSXExpressionContainer()) return void 0;
-	const expression = value.get("expression");
-	if (expression.isExpression()) return lowerExpressionIR(expression);
-}
-function optionalStringAttr(path, name) {
-	const attr = path.get("openingElement").get("attributes").find((attrPath) => {
-		if (!attrPath.isJSXAttribute()) return false;
-		return getJSXAttrName(attrPath.node.name) === name;
-	});
-	if (!(attr === null || attr === void 0 ? void 0 : attr.isJSXAttribute())) return void 0;
-	const value = attr.node.value;
-	if (!value) return "";
-	if (t.isStringLiteral(value)) return value.value;
-}
-function getOnlyRenderFunction(path) {
-	const expressions = path.get("children").filter((child) => child.isJSXExpressionContainer()).map((child) => child.get("expression")).filter((expression) => expression.isArrowFunctionExpression() || expression.isFunctionExpression());
-	if (expressions.length !== 1) throw createBabelCompilerError(path, {
-		code: CompilerErrorCode.INVALID_BUILTIN_USAGE,
-		message: "<For> requires exactly one render function child."
-	});
-	return expressions[0];
-}
-function getParamIdentifier(path, index, fallback) {
-	const param = path.node.params[index];
-	if (t.isIdentifier(param)) return identifierIR(param.name, sourceSpanFromBabelNode(param));
-	if (fallback) return identifierIR(fallback);
-}
-function getBuiltinName(path) {
-	const name = path.node.openingElement.name;
-	return t.isJSXIdentifier(name) ? name.name : "Builtin";
-}
-function isEventLikeProp(key) {
-	return /^on[A-Z]/.test(key) || key.startsWith("on:");
-}
-function normalizeHostAttrName(name) {
-	switch (name) {
-		case "className": return "class";
-		case "htmlFor": return "for";
-		case "tabIndex": return "tabindex";
-		case "readOnly": return "readonly";
-		default: return name;
-	}
-}
-function lowerHost(path, context) {
-	const attrs = [];
-	const rawChildren = lowerChildren(path.get("children"), context);
-	for (const attrPath of path.get("openingElement").get("attributes")) {
-		const node = attrPath.node;
-		if (t.isJSXSpreadAttribute(node)) throw createBabelCompilerError(attrPath, {
-			code: CompilerErrorCode.UNSUPPORTED_COMPONENT_PROP,
-			message: "Spread props are not supported on Host in Phase 1."
-		});
-		if (!attrPath.isJSXAttribute()) continue;
-		const name = getJSXAttrName(node.name);
-		if (HOST_SKIP_PROPS.has(name)) continue;
-		if (name === "children") continue;
-		if (name === "ref") {
-			const value = attrPath.get("value");
-			if (value.isJSXExpressionContainer()) {
-				const expr = value.get("expression");
-				if (expr.isExpression()) attrs.push({
-					id: id(),
-					kind: "HostAttr",
-					name: "ref",
-					expr: lowerExpressionIR(expr)
-				});
-			}
-			continue;
-		}
-		if (isEventLikeProp(name)) continue;
-		const value = attrPath.get("value");
-		if (!value.node) attrs.push({
-			id: id(),
-			kind: "HostAttr",
-			name: normalizeHostAttrName(name),
-			expr: expressionIRFromCode("true", node)
-		});
-		else if (value.isStringLiteral()) attrs.push({
-			id: id(),
-			kind: "HostAttr",
-			name: normalizeHostAttrName(name),
-			expr: expressionIRFromCode(JSON.stringify(value.node.value), value.node)
-		});
-		else if (value.isJSXExpressionContainer()) {
-			const expression = value.get("expression");
-			if (expression.isExpression()) attrs.push({
-				id: id(),
-				kind: "HostAttr",
-				name: normalizeHostAttrName(name),
-				expr: lowerExpressionIR(expression)
-			});
-		}
-	}
-	return hostIR({
-		attrs,
-		child: rawChildren.length === 0 ? void 0 : rawChildren.length === 1 ? rawChildren[0] : fragmentIR(rawChildren),
-		span: sourceSpanFromBabelNode(path.node)
-	});
-}
-//#endregion
-//#region packages/core/compiler/src/lower/lowerComponent.ts
-function lowerComponent(path, context) {
-	const tag = convertComponentIdentifier(path.node.openingElement.name);
-	const props = [];
-	for (const attr of path.get("openingElement").get("attributes")) {
-		const node = attr.node;
-		if (t.isJSXSpreadAttribute(node)) throw createBabelCompilerError(attr, {
-			code: CompilerErrorCode.UNSUPPORTED_COMPONENT_PROP,
-			message: "Spread props are not supported in Zeus MVP."
-		});
-		const name = getJSXAttrName(node.name);
-		const value = attr.get("value");
-		if (!value.node) {
-			props.push({
-				name,
-				value: expressionIRFromCode("true", node)
-			});
-			continue;
-		}
-		if (value.isStringLiteral()) {
-			props.push({
-				name,
-				value: expressionIRFromCode(JSON.stringify(value.node.value), value.node)
-			});
-			continue;
-		}
-		if (value.isJSXExpressionContainer()) {
-			const expression = value.get("expression");
-			if (expression.isJSXEmptyExpression()) throw createBabelCompilerError(attr, {
-				code: CompilerErrorCode.EMPTY_EXPRESSION,
-				message: `Component prop "${name}" expression cannot be empty.`
-			});
-			if (expression.isExpression()) props.push({
-				name,
-				value: lowerExpressionIR(expression)
-			});
-		}
-	}
-	const children = lowerChildren(path.get("children"), context);
-	if (children.length > 0) props.push({
-		name: "children",
-		value: children
-	});
-	return componentIR({
-		ref: ref(context.uid("cmp$").name),
-		callee: tag,
-		props,
-		span: sourceSpanFromBabelNode(path.node)
-	});
-}
-function convertComponentIdentifier(node) {
-	return expressionIRFromCode(componentIdentifierCode(node), node);
-}
-function componentIdentifierCode(node) {
-	if (t.isJSXIdentifier(node)) {
-		if (node.name === "this") return "this";
-		return t.isValidIdentifier(node.name) ? node.name : JSON.stringify(node.name);
-	}
-	if (t.isJSXMemberExpression(node)) {
-		const object = componentIdentifierCode(node.object);
-		const property = node.property.name;
-		return t.isValidIdentifier(property) ? `${object}.${property}` : `${object}[${JSON.stringify(property)}]`;
-	}
-	if (t.isJSXNamespacedName(node)) return JSON.stringify(`${node.namespace.name}:${node.name.name}`);
-	return JSON.stringify("");
-}
-//#endregion
-//#region packages/core/compiler/src/lower/lowerElement.ts
-function lowerElement(path, context) {
-	const tagName = getTagName(path.node);
-	if (isBuiltinTag(tagName)) return lowerBuiltin(path, context);
-	if (isComponentTag(tagName)) return lowerComponent(path, context);
-	const attrs = path.get("openingElement").get("attributes").map((attr) => lowerAttribute(attr, context)).filter(Boolean);
-	return elementIR({
-		ref: ref(context.uid("el$").name),
-		tagName,
-		attrs,
-		children: VoidElements.includes(tagName) ? [] : lowerChildren(path.get("children"), context),
-		span: sourceSpanFromBabelNode(path.node),
-		flags: {
-			isVoid: VoidElements.includes(tagName),
-			isCustomElement: tagName.includes("-")
-		}
-	});
-}
-//#endregion
-//#region packages/core/compiler/src/lower/lowerFragment.ts
-function lowerFragment(path, context) {
-	return fragmentIR(lowerChildren(path.get("children"), context));
-}
-//#endregion
-//#region packages/core/compiler/src/lower/lowerJSX.ts
-function lowerJSX(path, context) {
-	if (path.isJSXElement()) return lowerElement(path, context);
-	if (path.isJSXFragment()) return lowerFragment(path, context);
-	throw new Error("Unsupported JSX node");
-}
-//#endregion
-//#region packages/core/compiler/src/passes/normalizeChildren.ts
-function normalizeChildren(node) {
-	visit$2(node);
-	return node;
-}
-function visit$2(node) {
-	switch (node.kind) {
-		case "Element":
-		case "Fragment":
-			node.children = node.children.filter((child) => {
-				if (child.kind === "Text") return child.value.length > 0;
-				return true;
-			});
-			for (const child of node.children) visit$2(child);
-			return;
-		case "Host":
-			if (node.child) visit$2(node.child);
-			return;
-		case "Component":
-			for (const prop of node.props) {
-				if (!Array.isArray(prop.value)) continue;
-				prop.value = prop.value.filter((child) => {
-					if (child.kind === "Text") return child.value.length > 0;
-					return true;
-				});
-				for (const child of prop.value) visit$2(child);
-			}
-			return;
-		case "Slot":
-			node.fallback = node.fallback.filter((child) => {
-				if (child.kind === "Text") return child.value.length > 0;
-				return true;
-			});
-			for (const child of node.fallback) visit$2(child);
-			return;
-		case "Show":
-			for (const child of node.children) visit$2(child);
-			if (Array.isArray(node.fallback)) {
-				node.fallback = node.fallback.filter((child) => {
-					if (child.kind === "Text") return child.value.length > 0;
-					return true;
-				});
-				for (const child of node.fallback) visit$2(child);
-			}
-			return;
-		case "For":
-			for (const child of node.body) visit$2(child);
-			return;
-		case "Text":
-		case "DynamicText": return;
-	}
-}
-//#endregion
-//#region packages/core/compiler/src/passes/assignDomPaths.ts
-function assignDomPaths(node) {
-	visitNode$1(node);
-	return node;
-}
-function visitNode$1(node, parent) {
-	switch (node.kind) {
-		case "Element":
-			assignElementPath(node, parent);
-			assignChildPaths(node);
-			return;
-		case "Fragment":
-			for (const child of node.children) visitNode$1(child, parent);
-			return;
-		case "Component":
-			for (const prop of node.props) {
-				if (!Array.isArray(prop.value)) continue;
-				for (const child of prop.value) visitNode$1(child);
-			}
-			return;
-		case "Show":
-			for (const child of node.children) visitNode$1(child);
-			if (Array.isArray(node.fallback)) for (const child of node.fallback) visitNode$1(child);
-			return;
-		case "For":
-			for (const child of node.body) visitNode$1(child);
-			return;
-		case "Host":
-			if (node.child) visitNode$1(node.child, parent);
-			return;
-		case "Slot":
-			for (const child of node.fallback) visitNode$1(child);
-			return;
-		case "Text":
-		case "DynamicText": return;
-	}
-}
-function assignElementPath(node, parent) {
-	if (!parent) {
-		node.domPath = { kind: "Root" };
-		return;
-	}
-	const templateChildren = parent.children.filter(isTemplateChild);
-	const index = templateChildren.indexOf(node);
-	if (index === -1) return;
-	if (index === 0) {
-		node.domPath = {
-			kind: "FirstChild",
-			parent: parent.ref
-		};
-		return;
-	}
-	const previous = templateChildren[index - 1];
-	if (previous.kind === "Element") {
-		node.domPath = {
-			kind: "NextSibling",
-			previous: previous.ref
-		};
-		return;
-	}
-	node.domPath = {
-		kind: "Child",
-		parent: parent.ref,
-		index
-	};
-}
-function assignChildPaths(parent) {
-	let markerIndex = 0;
-	for (const child of parent.children) {
-		if (isMarkerTemplateNode(child)) {
-			assignMarkerPath(child, parent.ref, markerIndex++);
-			visitNode$1(child);
-			continue;
-		}
-		visitNode$1(child, parent);
-	}
-}
-function assignMarkerPath(node, parent, index) {
-	node.domPath = {
-		kind: "Marker",
-		parent,
-		index
-	};
-}
-function isTemplateChild(node) {
-	return node.kind === "Element" || node.kind === "DynamicText" || node.kind === "Component" || node.kind === "Show" || node.kind === "For" || node.kind === "Slot";
-}
-function isMarkerTemplateNode(node) {
-	return node.kind === "DynamicText" || node.kind === "Component" || node.kind === "Show" || node.kind === "For" || node.kind === "Slot";
-}
-//#endregion
-//#region packages/core/compiler/src/passes/assignPhysicalDomPaths.ts
-function assignPhysicalDomPaths(node) {
-	visitNode(node);
-	return node;
-}
-function visitNode(node, parent) {
-	switch (node.kind) {
-		case "Element":
-			assignElementPhysicalPath(node, parent);
-			assignChildrenPhysicalPaths(node);
-			return;
-		case "Fragment":
-			for (const child of node.children) visitNode(child, parent);
-			return;
-		case "Host":
-			if (node.child) visitNode(node.child, parent);
-			return;
-		case "Show":
-			for (const child of node.children) visitNode(child);
-			if (Array.isArray(node.fallback)) for (const child of node.fallback) visitNode(child);
-			return;
-		case "For":
-			for (const child of node.body) visitNode(child);
-			return;
-		case "Slot":
-			for (const child of node.fallback) visitNode(child);
-			return;
-		case "Component":
-			for (const prop of node.props) {
-				if (!Array.isArray(prop.value)) continue;
-				for (const child of prop.value) visitNode(child);
-			}
-			return;
-		case "Text":
-		case "DynamicText": return;
-	}
-}
-function assignElementPhysicalPath(node, parent) {
-	if (!parent) {
-		node.physicalDomPath = { kind: "Root" };
-		return;
-	}
-	const physicalChildren = flattenPhysicalChildren(parent.children);
-	const index = physicalChildren.indexOf(node);
-	if (index < 0) return;
-	node.physicalDomPath = createPhysicalPath(parent.ref, physicalChildren, index);
-}
-function assignChildrenPhysicalPaths(parent) {
-	const physicalChildren = flattenPhysicalChildren(parent.children);
-	for (let index = 0; index < physicalChildren.length; index++) {
-		const child = physicalChildren[index];
-		if (child.kind === "TextPlaceholder") continue;
-		child.physicalDomPath = createPhysicalPath(parent.ref, physicalChildren, index);
-	}
-	for (const child of parent.children) visitNode(child, parent);
-}
-function createPhysicalPath(parent, children, index) {
-	if (index === 0) return {
-		kind: "FirstChild",
-		parent
-	};
-	const previous = findPreviousRefNode(children, index);
-	if (previous) return {
-		kind: "NextSibling",
-		previous: previous.ref
-	};
-	return {
-		kind: "ChildNode",
-		parent,
-		index
-	};
-}
-function findPreviousRefNode(children, index) {
-	for (let i = index - 1; i >= 0; i--) {
-		const node = children[i];
-		if (node.kind === "TextPlaceholder") continue;
-		return node;
-	}
-}
-function flattenPhysicalChildren(children) {
-	const result = [];
-	for (const child of children) appendPhysicalChild(result, child);
-	return result;
-}
-function appendPhysicalChild(result, node) {
-	switch (node.kind) {
-		case "Text":
-			if (node.value.length > 0) result.push({ kind: "TextPlaceholder" });
-			return;
-		case "Element":
-		case "DynamicText":
-		case "Component":
-		case "Show":
-		case "For":
-		case "Slot":
-			result.push(node);
-			return;
-		case "Fragment":
-			for (const child of node.children) appendPhysicalChild(result, child);
-			return;
-		case "Host":
-			if (node.child) appendPhysicalChild(result, node.child);
-			return;
-	}
-}
-//#endregion
-//#region packages/core/compiler/src/passes/validateBuiltins.ts
-function validateBuiltins(node, options) {
-	visit$1(node, {
-		isDefineElementRenderRoot: options.isDefineElementRenderRoot,
-		filename: options.filename,
-		insideHost: false,
-		root: true
-	});
-}
-function visit$1(node, state) {
-	switch (node.kind) {
-		case "Host":
-			if (!state.isDefineElementRenderRoot || !state.root) throw new CompilerError({
-				code: CompilerErrorCode.INVALID_BUILTIN_USAGE,
-				message: "<Host> can only be used as a defineElement root boundary.",
-				filename: state.filename,
-				span: node.span,
-				hint: "Return <Host> directly from the defineElement setup function."
-			});
-			if (node.child) visit$1(node.child, _objectSpread2(_objectSpread2({}, state), {}, {
-				insideHost: true,
-				root: false
-			}));
-			return;
-		case "Slot":
-			if (!state.insideHost) throw new CompilerError({
-				code: CompilerErrorCode.INVALID_BUILTIN_USAGE,
-				message: "<Slot> can only be used inside the defineElement Host boundary.",
-				filename: state.filename,
-				span: node.span,
-				hint: "Place <Slot> inside the root <Host> returned by defineElement setup."
-			});
-			for (const child of node.fallback) visit$1(child, _objectSpread2(_objectSpread2({}, state), {}, { root: false }));
-			return;
-		case "Element":
-		case "Fragment":
-			for (const child of node.children) visit$1(child, _objectSpread2(_objectSpread2({}, state), {}, { root: false }));
-			return;
-		case "Component":
-			for (const prop of node.props) {
-				if (!Array.isArray(prop.value)) continue;
-				for (const child of prop.value) visit$1(child, _objectSpread2(_objectSpread2({}, state), {}, { root: false }));
-			}
-			return;
-		case "Show":
-			for (const child of node.children) visit$1(child, _objectSpread2(_objectSpread2({}, state), {}, { root: false }));
-			if (Array.isArray(node.fallback)) for (const child of node.fallback) visit$1(child, _objectSpread2(_objectSpread2({}, state), {}, { root: false }));
-			return;
-		case "For":
-			for (const child of node.body) visit$1(child, _objectSpread2(_objectSpread2({}, state), {}, { root: false }));
-			return;
-		default: return;
-	}
-}
-//#endregion
-//#region packages/core/compiler/src/passes/analyzeBindings.ts
-function analyzeBindings(node) {
-	const analysis = {
-		dynamicText: 0,
-		dynamicAttrs: 0,
-		events: 0,
-		components: 0
-	};
-	visit(node, analysis);
-	return analysis;
-}
-function visit(node, analysis) {
-	switch (node.kind) {
-		case "Element":
-			for (const attr of node.attrs) {
-				if (attr.kind === "AttrBinding" || attr.kind === "PropBinding") analysis.dynamicAttrs++;
-				if (attr.kind === "EventBinding") analysis.events++;
-			}
-			for (const child of node.children) visit(child, analysis);
-			return;
-		case "DynamicText":
-			analysis.dynamicText++;
-			return;
-		case "Component":
-			analysis.components++;
-			for (const prop of node.props) {
-				if (!Array.isArray(prop.value)) continue;
-				for (const child of prop.value) visit(child, analysis);
-			}
-			return;
-		case "Fragment":
-			for (const child of node.children) visit(child, analysis);
-			return;
-		case "Host":
-			if (node.child) visit(node.child, analysis);
-			return;
-		case "Slot":
-			for (const child of node.fallback) visit(child, analysis);
-			return;
-		case "Show":
-			for (const child of node.children) visit(child, analysis);
-			if (Array.isArray(node.fallback)) for (const child of node.fallback) visit(child, analysis);
-			return;
-		case "For":
-			for (const child of node.body) visit(child, analysis);
-			return;
-		case "Text": return;
-	}
-}
-//#endregion
-//#region packages/core/compiler/src/transform/index.ts
-function transformJSX(path, state, config) {
-	if (state.get("skip")) return;
-	if (!path.isJSXElement() && !path.isJSXFragment()) return;
-	const context = getCompilerContext(path, config);
-	const ir = lowerJSX(path, context);
-	normalizeChildren(ir);
-	if (config.generate === "ssr") assertSSRSupported(ir, state.filename);
-	validateBuiltins(ir, {
-		isDefineElementRenderRoot: isDefineElementRenderRoot(path),
-		filename: state.filename
-	});
-	analyzeBindings(ir);
-	if (config.generate === "ssr") {
-		path.replaceWith(emitSSR(ir, context));
-		return;
-	}
-	assignDomPaths(ir);
-	assignPhysicalDomPaths(ir);
-	collectTemplates(ir, context);
-	path.replaceWith(emitDOM(ir, context));
-}
-//#endregion
-//#region packages/core/compiler/src/visitor.ts
-function createVisitor(config) {
-	return {
-		JSXElement(path, state) {
-			transformJSX(path, state, config);
-		},
-		JSXFragment(path, state) {
-			transformJSX(path, state, config);
-		},
-		Program: createProgramVisitor(config)
-	};
-}
-//#endregion
-//#region packages/core/compiler/src/index.ts
-function hasParserPlugin(plugins, name) {
-	return plugins.some((plugin) => (Array.isArray(plugin) ? plugin[0] : plugin) === name);
-}
-var src_default = declare((api, options) => {
-	api.assertVersion(8);
-	return {
-		name: "babel-plugin-zeus-compiler",
-		manipulateOptions(_opts, parserOpts) {
-			var _parserOpts$plugins;
-			(_parserOpts$plugins = parserOpts.plugins) !== null && _parserOpts$plugins !== void 0 || (parserOpts.plugins = []);
-			if (!hasParserPlugin(parserOpts.plugins, "jsx")) parserOpts.plugins.push("jsx");
-		},
-		visitor: createVisitor(resolveConfig(options))
-	};
-});
+import { createRequire } from "node:module";
+const transformModule = createRequire(import.meta.url)("@zeus-js/compiler-native").transformModule;
 //#endregion
-export { CompilerError, CompilerErrorCode, src_default as default, formatCompilerDiagnostic };
+export { transformModule as default, transformModule };