@zeus-js/compiler 0.0.2

package/dist/compiler.esm-bundler.js

@@ -0,0 +1,1651 @@
+/**
+* compiler v0.0.2
+* (c) 2026 baicie
+* Released under the MIT License.
+**/
+import { declare } from "@babel/helper-plugin-utils";
+import syntaxJsx from "@babel/plugin-syntax-jsx";
+import { extend } from "@zeus-js/shared";
+import * as t from "@babel/types";
+//#region packages/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/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/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/compiler/src/config/index.ts
+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) {
+	return extend(DEFAULT_OPTIONS, options);
+}
+//#endregion
+//#region packages/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/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 = new Set([
+	"script",
+	"style",
+	"textarea",
+	"title"
+]);
+function isRawTextElement(tagName) {
+	return rawTextElements.has(tagName);
+}
+//#endregion
+//#region packages/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/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);
+}
+function exitProgram(config, path, state) {
+	if (state.get("skip")) return;
+	appendTemplates(path);
+	appendEvents(path);
+	appendImportMethods(path);
+}
+function createProgramVisitor(config) {
+	return {
+		enter(path, state) {
+			enterProgram(config, path, state);
+		},
+		exit(path, state) {
+			exitProgram(config, path, state);
+		}
+	};
+}
+//#endregion
+//#region packages/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 [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), t.arrowFunctionExpression([], binding.expr)]));
+	if (name === "style") return t.expressionStatement(t.callExpression(context.importRuntime("bindStyle"), [t.identifier(target.ref.name), t.arrowFunctionExpression([], binding.expr)]));
+	return t.expressionStatement(t.callExpression(context.importRuntime("bindAttr"), [
+		t.identifier(target.ref.name),
+		t.stringLiteral(name),
+		t.arrowFunctionExpression([], 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(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),
+		t.arrowFunctionExpression([], binding.expr)
+	]));
+}
+function emitRefBinding(target, binding, context) {
+	return t.expressionStatement(t.callExpression(context.importRuntime("bindRef"), [t.identifier(target.ref.name), binding.expr]));
+}
+function emitDynamicText(node, context) {
+	if (!node.domPath || node.domPath.kind !== "Marker") return [];
+	const textRef = context.uid("text$");
+	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"), [node.expr])]))]), 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([], node.expr)]))
+	];
+}
+function emitComponentInsert(node, context) {
+	return emitMarkerInsert(node, context, emitComponent(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/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/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.children.map(renderChildTemplate).join("");
+		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/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/compiler/src/codegen/dom/emitElement.ts
+function emitElement(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":
+			for (const child of node.children) collectRefNode(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":
+			for (const child of node.children) collectRequiredDomRefDeclaration(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.children.some((inner) => inner.kind === "Element" ? needsDomRefDeclaration(inner) : inner.kind !== "Text");
+			default: return false;
+		}
+	});
+}
+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":
+		case "Host": return node.children.some(hasChildRuntimeWork);
+		default: return false;
+	}
+}
+//#endregion
+//#region packages/compiler/src/codegen/dom/emitFragment.ts
+function emitFragment(node, context) {
+	return t.arrayExpression(node.children.map((child) => emitDOM(child, context)));
+}
+//#endregion
+//#region packages/compiler/src/codegen/dom/emitNodeExpression.ts
+function emitNodeExpression(node, context) {
+	switch (node.kind) {
+		case "Text": return t.stringLiteral(node.value);
+		case "DynamicText": return node.expr;
+		case "Element": return emitElement(node, context);
+		case "Component": return emitComponent(node, context);
+		case "Fragment": return emitFragment(node, context);
+		case "Show": return emitShow(node, context);
+		case "For": return emitFor(node, context);
+		case "Host": return emitHost(node, context);
+		case "Slot": return emitSlot(node, context);
+		default: return t.nullLiteral();
+	}
+}
+//#endregion
+//#region packages/compiler/src/codegen/dom/emitComponent.ts
+function emitComponent(node, context) {
+	const props = t.objectExpression(node.props.map((prop) => emitComponentProp(prop, context)));
+	return t.callExpression(context.importRuntime("createComponent"), [node.callee, props]);
+}
+function emitComponentProp(prop, context) {
+	const key = createObjectKey(prop.name);
+	if (Array.isArray(prop.value)) return t.objectMethod("get", key, [], t.blockStatement([t.returnStatement(emitChildrenProp(prop.value, context))]));
+	if (isStaticPropValue(prop.value)) return t.objectProperty(key, prop.value);
+	return t.objectMethod("get", key, [], t.blockStatement([t.returnStatement(prop.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(value) {
+	return t.isStringLiteral(value) || t.isNumericLiteral(value) || t.isBooleanLiteral(value) || t.isNullLiteral(value);
+}
+function createObjectKey(key) {
+	return t.isValidIdentifier(key) ? t.identifier(key) : t.stringLiteral(key);
+}
+//#endregion
+//#region packages/compiler/src/codegen/dom/emitBuiltin.ts
+function emitShow(node, context) {
+	const props = [t.objectProperty(t.identifier("when"), 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)) : 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([], node.when),
+		t.arrowFunctionExpression([], emitChildrenProp(node.children, context)),
+		node.fallback ? Array.isArray(node.fallback) ? t.arrowFunctionExpression([], emitChildrenProp(node.fallback, context)) : t.arrowFunctionExpression([], node.fallback) : t.identifier("undefined")
+	]);
+}
+function emitFor(node, context) {
+	const params = [node.item];
+	if (node.index) params.push(node.index);
+	const props = [t.objectProperty(t.identifier("each"), node.each), t.objectProperty(t.identifier("children"), t.arrowFunctionExpression(params, emitChildrenProp(node.body, context)))];
+	if (node.by) props.push(t.objectProperty(t.identifier("by"), node.by));
+	return t.callExpression(context.importRuntime("createComponent"), [context.importRuntime("For"), t.objectExpression(props)]);
+}
+function emitMountFor(node, context) {
+	var _node$by;
+	const params = [node.item];
+	const path = node.domPath;
+	if (node.index) params.push(node.index);
+	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([], node.each),
+		(_node$by = node.by) !== null && _node$by !== void 0 ? _node$by : t.identifier("undefined"),
+		t.arrowFunctionExpression(params, emitChildrenProp(node.body, context))
+	]);
+}
+function emitHost(node, context) {
+	return emitChildrenProp(node.children, context);
+}
+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/compiler/src/codegen/dom/index.ts
+function emitDOM(node, context) {
+	switch (node.kind) {
+		case "Element": return emitElement(node, context);
+		case "Fragment": return emitFragment(node, context);
+		case "Component": return emitComponent(node, context);
+		case "Show": return emitShow(node, context);
+		case "For": return emitFor(node, context);
+		case "Host": return emitHost(node, context);
+		case "Slot": return emitSlot(node, context);
+		case "DynamicText": return t.arrowFunctionExpression([], node.expr);
+		default: throw new Error(`Unsupported root IR node: ${node.kind}`);
+	}
+}
+//#endregion
+//#region packages/compiler/src/context/CompilerContext.ts
+var CompilerContext = class {
+	constructor(options, programPath) {
+		this.options = options;
+		this.programPath = programPath;
+		this.diagnostics = [];
+	}
+	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
+		};
+	}
+	report(diagnostic) {
+		this.diagnostics.push(diagnostic);
+	}
+};
+function getCompilerContext(path, options) {
+	return new CompilerContext(options, path.scope.getProgramParent().path);
+}
+//#endregion
+//#region packages/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",
+	INVALID_REF_USAGE: "ZEUS_INVALID_REF_USAGE"
+};
+//#endregion
+//#region packages/compiler/src/diagnostics/CompilerError.ts
+var CompilerError = class extends Error {
+	constructor(options) {
+		var _options$path;
+		const loc = (_options$path = options.path) === null || _options$path === void 0 || (_options$path = _options$path.node.loc) === null || _options$path === void 0 ? void 0 : _options$path.start;
+		const location = loc ? ` (${loc.line}:${loc.column})` : "";
+		const hint = options.hint ? `\nHint: ${options.hint}` : "";
+		super(`[${options.code}] ${options.message}${location}${hint}`);
+		this.name = "ZeusCompilerError";
+		this.code = options.code;
+		this.hint = options.hint;
+	}
+};
+//#endregion
+//#region \0@oxc-project+runtime@0.133.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.133.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.133.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.133.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.133.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/compiler/src/ir/semanticBuilders.ts
+let nextId = 0;
+function id() {
+	return nextId++;
+}
+function ref(name) {
+	return { name };
+}
+function elementIR(input) {
+	var _input$attrs, _input$children;
+	return {
+		id: id(),
+		kind: "Element",
+		ref: input.ref,
+		tagName: input.tagName,
+		attrs: (_input$attrs = input.attrs) !== null && _input$attrs !== void 0 ? _input$attrs : [],
+		children: (_input$children = input.children) !== null && _input$children !== void 0 ? _input$children : [],
+		flags: _objectSpread2({
+			isSVG: false,
+			isVoid: false,
+			isCustomElement: input.tagName.includes("-")
+		}, input.flags)
+	};
+}
+function textIR(value) {
+	return {
+		id: id(),
+		kind: "Text",
+		value
+	};
+}
+function dynamicTextIR(expr, nodeRef, once = false) {
+	return {
+		id: id(),
+		kind: "DynamicText",
+		expr,
+		ref: nodeRef,
+		once
+	};
+}
+function fragmentIR(children) {
+	return {
+		id: id(),
+		kind: "Fragment",
+		children
+	};
+}
+function staticAttrIR(name, value) {
+	return {
+		id: id(),
+		kind: "StaticAttribute",
+		name,
+		value
+	};
+}
+function attrBindingIR(name, expr) {
+	return {
+		id: id(),
+		kind: "AttrBinding",
+		name,
+		expr
+	};
+}
+function propBindingIR(name, expr) {
+	return {
+		id: id(),
+		kind: "PropBinding",
+		name,
+		expr
+	};
+}
+function eventBindingIR(eventName, handler) {
+	return {
+		id: id(),
+		kind: "EventBinding",
+		eventName,
+		handler
+	};
+}
+function refBindingIR(expr) {
+	return {
+		id: id(),
+		kind: "RefBinding",
+		expr
+	};
+}
+function componentIR(input) {
+	return {
+		id: id(),
+		kind: "Component",
+		ref: input.ref,
+		callee: input.callee,
+		props: input.props
+	};
+}
+function showIR(input) {
+	return {
+		id: id(),
+		kind: "Show",
+		ref: input.ref,
+		when: input.when,
+		children: input.children,
+		fallback: input.fallback
+	};
+}
+function forIR(input) {
+	return {
+		id: id(),
+		kind: "For",
+		ref: input.ref,
+		each: input.each,
+		by: input.by,
+		item: input.item,
+		index: input.index,
+		body: input.body
+	};
+}
+function hostIR(children) {
+	return {
+		id: id(),
+		kind: "Host",
+		children
+	};
+}
+function slotIR(input) {
+	var _input$fallback;
+	return {
+		id: id(),
+		kind: "Slot",
+		ref: input.ref,
+		name: input.name,
+		fallback: (_input$fallback = input.fallback) !== null && _input$fallback !== void 0 ? _input$fallback : []
+	};
+}
+//#endregion
+//#region packages/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/compiler/src/lower/lowerAttribute.ts
+function lowerAttribute(path, _context) {
+	if (path.isJSXSpreadAttribute() || t.isJSXSpreadAttribute(path.node)) throw new CompilerError({
+		code: CompilerErrorCode.UNSUPPORTED_SPREAD_ATTRIBUTE,
+		message: "Spread attributes are not supported in Zeus MVP.",
+		path,
+		hint: "Use explicit attributes instead, for example <div id={id} />."
+	});
+	const node = path.node;
+	const name = getJSXAttrName(node.name);
+	const value = node.value;
+	if (!value) {
+		if (name === "ref") throw new CompilerError({
+			code: CompilerErrorCode.EMPTY_EXPRESSION,
+			message: "ref attribute requires an expression.",
+			path,
+			hint: "Use <div ref={target} /> instead."
+		});
+		return staticAttrIR(name, true);
+	}
+	if (t.isStringLiteral(value)) {
+		if (name === "ref") throw new CompilerError({
+			code: CompilerErrorCode.INVALID_REF_USAGE,
+			message: "String refs are not supported in Zeus.",
+			path,
+			hint: "Use a state holder or callback ref: <div ref={el} />."
+		});
+		return staticAttrIR(name, value.value);
+	}
+	if (t.isJSXExpressionContainer(value)) {
+		const expr = value.expression;
+		if (t.isJSXEmptyExpression(expr)) throw new CompilerError({
+			code: CompilerErrorCode.EMPTY_EXPRESSION,
+			message: `Attribute "${name}" expression cannot be empty.`,
+			path
+		});
+		if (name === "ref") return refBindingIR(expr);
+		if (name.startsWith("on") && name.length > 2) return eventBindingIR(toEventName(name), expr);
+		if (name.startsWith("prop:")) return propBindingIR(name.slice(5), expr);
+		return attrBindingIR(name, expr);
+	}
+	return null;
+}
+//#endregion
+//#region packages/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 expr = child.node.expression;
+			if (t.isJSXEmptyExpression(expr)) continue;
+			if (t.isExpression(expr)) result.push(dynamicTextIR(expr, ref(context.uid("anchor$").name)));
+			continue;
+		}
+		if (child.isJSXElement() || child.isJSXFragment()) {
+			result.push(lowerJSX(child, context));
+			continue;
+		}
+	}
+	return result;
+}
+//#endregion
+//#region packages/compiler/src/lower/lowerBuiltin.ts
+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 new CompilerError({
+		code: CompilerErrorCode.INVALID_BUILTIN_USAGE,
+		message: "Built-in JSX nodes do not support member expressions.",
+		path
+	});
+	switch (tagName.name) {
+		case "Show": return lowerShow(path, context);
+		case "For": return lowerFor(path, context);
+		case "Host": return hostIR(lowerChildren(path.get("children"), context));
+		case "Slot": return lowerSlot(path, context);
+		default: throw new CompilerError({
+			code: CompilerErrorCode.INVALID_BUILTIN_USAGE,
+			message: `Unsupported built-in <${tagName.name}>.`,
+			path
+		});
+	}
+}
+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 t.booleanLiteral(true);
+	if (value.isStringLiteral()) return 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 expression.node;
+}
+function lowerFor(path, context) {
+	var _getParamIdentifier;
+	const each = requiredExpressionAttr(path, "each");
+	const by = optionalExpressionAttr(path, "by");
+	const render = getOnlyRenderFunction(path);
+	const item = (_getParamIdentifier = getParamIdentifier(render, 0)) !== null && _getParamIdentifier !== void 0 ? _getParamIdentifier : t.identifier("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(bodyPath.node, 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)
+	});
+}
+function requiredExpressionAttr(path, name) {
+	const value = optionalExpressionAttr(path, name);
+	if (!value || Array.isArray(value)) throw new CompilerError({
+		code: CompilerErrorCode.INVALID_BUILTIN_USAGE,
+		message: `<${getBuiltinName(path)}> requires "${name}".`,
+		path
+	});
+	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.node.value;
+	if (!value) return t.booleanLiteral(true);
+	if (t.isStringLiteral(value)) return value;
+	if (t.isJSXExpressionContainer(value) && !t.isJSXEmptyExpression(value.expression)) return value.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 new CompilerError({
+		code: CompilerErrorCode.INVALID_BUILTIN_USAGE,
+		message: "<For> requires exactly one render function child.",
+		path
+	});
+	return expressions[0];
+}
+function getParamIdentifier(path, index, fallback) {
+	const param = path.node.params[index];
+	if (t.isIdentifier(param)) return param;
+	if (fallback) return t.identifier(fallback);
+}
+function getBuiltinName(path) {
+	const name = path.node.openingElement.name;
+	return t.isJSXIdentifier(name) ? name.name : "Builtin";
+}
+//#endregion
+//#region packages/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 new CompilerError({
+			code: CompilerErrorCode.UNSUPPORTED_COMPONENT_PROP,
+			message: "Spread props are not supported in Zeus MVP.",
+			path: attr
+		});
+		const name = getJSXAttrName(node.name);
+		if (!node.value) {
+			props.push({
+				name,
+				value: t.booleanLiteral(true)
+			});
+			continue;
+		}
+		if (t.isStringLiteral(node.value)) {
+			props.push({
+				name,
+				value: node.value
+			});
+			continue;
+		}
+		if (t.isJSXExpressionContainer(node.value)) {
+			if (t.isJSXEmptyExpression(node.value.expression)) throw new CompilerError({
+				code: CompilerErrorCode.EMPTY_EXPRESSION,
+				message: `Component prop "${name}" expression cannot be empty.`,
+				path: attr
+			});
+			props.push({
+				name,
+				value: node.value.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
+	});
+}
+function convertComponentIdentifier(node) {
+	if (t.isJSXIdentifier(node)) {
+		if (node.name === "this") return t.thisExpression();
+		if (t.isValidIdentifier(node.name)) return t.identifier(node.name);
+		return t.stringLiteral(node.name);
+	}
+	if (t.isJSXMemberExpression(node)) {
+		const object = convertComponentIdentifier(node.object);
+		const property = convertComponentIdentifier(node.property);
+		return t.memberExpression(object, property, t.isStringLiteral(property));
+	}
+	if (t.isJSXNamespacedName(node)) return t.stringLiteral(`${node.namespace.name}:${node.name.name}`);
+	return node;
+}
+//#endregion
+//#region packages/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),
+		flags: {
+			isVoid: VoidElements.includes(tagName),
+			isCustomElement: tagName.includes("-")
+		}
+	});
+}
+//#endregion
+//#region packages/compiler/src/lower/lowerFragment.ts
+function lowerFragment(path, context) {
+	return fragmentIR(lowerChildren(path.get("children"), context));
+}
+//#endregion
+//#region packages/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/compiler/src/passes/normalizeChildren.ts
+function normalizeChildren(node) {
+	visit$2(node);
+	return node;
+}
+function visit$2(node) {
+	switch (node.kind) {
+		case "Element":
+		case "Fragment":
+		case "Host":
+			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 "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/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":
+			for (const child of node.children) visitNode$1(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/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":
+			for (const child of node.children) visitNode(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":
+			for (const child of node.children) appendPhysicalChild(result, child);
+			return;
+	}
+}
+//#endregion
+//#region packages/compiler/src/passes/validateBuiltins.ts
+function validateBuiltins(node) {
+	visit$1(node, {
+		insideHost: false,
+		root: true
+	});
+}
+function visit$1(node, state) {
+	switch (node.kind) {
+		case "Host":
+			if (!state.root) throw new CompilerError({
+				code: CompilerErrorCode.INVALID_BUILTIN_USAGE,
+				message: "<Host> can only be used as a root host boundary."
+			});
+			for (const child of node.children) visit$1(child, {
+				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 <Host>."
+			});
+			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/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":
+		case "Host":
+			for (const child of node.children) visit(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/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);
+	validateBuiltins(ir);
+	assignDomPaths(ir);
+	assignPhysicalDomPaths(ir);
+	analyzeBindings(ir);
+	collectTemplates(ir, context);
+	path.replaceWith(emitDOM(ir, context));
+}
+//#endregion
+//#region packages/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/compiler/src/index.ts
+var src_default = declare((api, options) => {
+	api.assertVersion(7);
+	return {
+		name: "babel-plugin-zeus-compiler",
+		inherits: syntaxJsx,
+		visitor: createVisitor(resolveConfig(options))
+	};
+});
+//#endregion
+export { src_default as default };