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

package/dist/compiler.esm-browser.js

@@ -1,5 +1,5 @@
 /**
-* compiler v0.1.0-beta.0
+* compiler v0.1.0-beta.2
 * (c) 2026 baicie
 * Released under the MIT License.
 **/
@@ -27,7 +27,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 //#region node_modules/.pnpm/@babel+helper-plugin-utils@7.29.7/node_modules/@babel/helper-plugin-utils/lib/index.js
-var require_lib$4 = /* @__PURE__ */ __commonJSMin(((exports) => {
+var require_lib$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.declare = declare;
 	exports.declarePreset = void 0;
@@ -80,22 +80,6 @@ var require_lib$4 = /* @__PURE__ */ __commonJSMin(((exports) => {
 		});
 	}
 }));
-//#endregion
-//#region node_modules/.pnpm/@babel+plugin-syntax-jsx@7.28.6_@babel+core@7.29.0/node_modules/@babel/plugin-syntax-jsx/lib/index.js
-var require_lib$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.default = void 0;
-	exports.default = (0, require_lib$4().declare)((api) => {
-		api.assertVersion("^7.0.0-0 || ^8.0.0-0");
-		return {
-			name: "syntax-jsx",
-			manipulateOptions(opts, parserOpts) {
-				if (parserOpts.plugins.some((p) => (Array.isArray(p) ? p[0] : p) === "typescript")) return;
-				parserOpts.plugins.push("jsx");
-			}
-		};
-	});
-}));
 Object.freeze({});
 Object.freeze([]);
 const extend = Object.assign;
@@ -14158,9 +14142,8 @@ var require_lib = /* @__PURE__ */ __commonJSMin(((exports) => {
 }));
 //#endregion
 //#region packages/core/compiler/src/codegen/support/imports.ts
-var import_lib = require_lib$4();
-var import_lib$1 = /* @__PURE__ */ __toESM(require_lib$3());
-var import_lib$2 = /* @__PURE__ */ __toESM(require_lib());
+var import_lib = require_lib$3();
+var import_lib$1 = /* @__PURE__ */ __toESM(require_lib());
 const DEFAULT_RENDERER_MODULE = "@zeus-js/runtime-dom";
 function getImportKey(moduleName, imported) {
 	return `${moduleName}:${imported}`;
@@ -14178,14 +14161,14 @@ function registerImportMethod(path, imported, moduleName = getRendererConfig(pat
 	const importMethods = data.importMethods || (data.importMethods = /* @__PURE__ */ new Map());
 	const key = getImportKey(moduleName, imported);
 	const cached = importMethods.get(key);
-	if (cached) return import_lib$2.cloneNode(cached.local);
+	if (cached) return import_lib$1.cloneNode(cached.local);
 	const local = getProgramPath(path).scope.generateUidIdentifier(imported);
 	importMethods.set(key, {
 		imported,
 		local,
 		moduleName
 	});
-	return import_lib$2.cloneNode(local);
+	return import_lib$1.cloneNode(local);
 }
 /**
 * Generates import declarations for all collected runtime helpers and
@@ -14201,7 +14184,7 @@ function appendImportMethods(path) {
 		else grouped.set(record.moduleName, [record]);
 	}
 	const declarations = [];
-	for (const [moduleName, records] of grouped) declarations.push(import_lib$2.importDeclaration(records.map((record) => import_lib$2.importSpecifier(import_lib$2.cloneNode(record.local), import_lib$2.identifier(record.imported))), import_lib$2.stringLiteral(moduleName)));
+	for (const [moduleName, records] of grouped) declarations.push(import_lib$1.importDeclaration(records.map((record) => import_lib$1.importSpecifier(import_lib$1.cloneNode(record.local), import_lib$1.identifier(record.imported))), import_lib$1.stringLiteral(moduleName)));
 	path.unshiftContainer("body", declarations);
 }
 function getProgramScopeData(path) {
@@ -14248,11 +14231,11 @@ function appendTemplates(path) {
 		};
 		const shouldUseImportNode = Boolean(template.isCE || template.isImportNode);
 		const isMathML = isMathMLTemplate(html);
-		const args = [import_lib$2.templateLiteral([import_lib$2.templateElement(tmpl, true)], [])];
-		if (template.isSVG || shouldUseImportNode || isMathML) args.push(import_lib$2.booleanLiteral(shouldUseImportNode), import_lib$2.booleanLiteral(Boolean(template.isSVG)), import_lib$2.booleanLiteral(isMathML));
-		return import_lib$2.variableDeclarator(import_lib$2.cloneNode(template.id), import_lib$2.addComment(import_lib$2.callExpression(import_lib$2.cloneNode(templateMethod), args), "leading", "#__PURE__"));
+		const args = [import_lib$1.templateLiteral([import_lib$1.templateElement(tmpl, true)], [])];
+		if (template.isSVG || shouldUseImportNode || isMathML) args.push(import_lib$1.booleanLiteral(shouldUseImportNode), import_lib$1.booleanLiteral(Boolean(template.isSVG)), import_lib$1.booleanLiteral(isMathML));
+		return import_lib$1.variableDeclarator(import_lib$1.cloneNode(template.id), import_lib$1.addComment(import_lib$1.callExpression(import_lib$1.cloneNode(templateMethod), args), "leading", "#__PURE__"));
 	});
-	path.node.body.unshift(import_lib$2.variableDeclaration("var", declarators));
+	path.node.body.unshift(import_lib$1.variableDeclaration("var", declarators));
 }
 //#endregion
 //#region packages/core/compiler/src/codegen/support/events.ts
@@ -14282,7 +14265,7 @@ function registerEvent(path, eventName) {
 function appendEvents(path) {
 	const events = path.scope.data.events;
 	if (!(events === null || events === void 0 ? void 0 : events.size)) return;
-	path.node.body.push(import_lib$2.expressionStatement(import_lib$2.callExpression(registerImportMethod(path, "delegateEvents", getRendererConfig(path, "dom").moduleName), [import_lib$2.arrayExpression(Array.from(events).map((eventName) => import_lib$2.stringLiteral(eventName)))])));
+	path.node.body.push(import_lib$1.expressionStatement(import_lib$1.callExpression(registerImportMethod(path, "delegateEvents", getRendererConfig(path, "dom").moduleName), [import_lib$1.arrayExpression(Array.from(events).map((eventName) => import_lib$1.stringLiteral(eventName)))])));
 }
 //#endregion
 //#region packages/core/compiler/src/config/index.ts
@@ -14403,7 +14386,7 @@ function emitBindings(node, context) {
 	return statements;
 }
 function emitRawTextBinding(node, context) {
-	return import_lib$2.expressionStatement(import_lib$2.callExpression(context.importRuntime("bindTextContent"), [import_lib$2.identifier(node.ref.name), import_lib$2.arrowFunctionExpression([], emitRawTextValue(node.children))]));
+	return import_lib$1.expressionStatement(import_lib$1.callExpression(context.importRuntime("bindTextContent"), [import_lib$1.identifier(node.ref.name), import_lib$1.arrowFunctionExpression([], emitRawTextValue(node.children))]));
 }
 function hasRuntimeRawText$1(children) {
 	return children.some((child) => {
@@ -14415,15 +14398,15 @@ function hasRuntimeRawText$1(children) {
 function emitRawTextValue(children) {
 	const values = children.flatMap((child) => {
 		switch (child.kind) {
-			case "Text": return [import_lib$2.stringLiteral(child.value)];
+			case "Text": return [import_lib$1.stringLiteral(child.value)];
 			case "DynamicText": return [child.expr];
 			case "Fragment": return [emitRawTextValue(child.children)];
 			default: return [];
 		}
 	});
-	if (values.length === 0) return import_lib$2.stringLiteral("");
+	if (values.length === 0) return import_lib$1.stringLiteral("");
 	if (values.length === 1) return values[0];
-	return import_lib$2.arrayExpression(values);
+	return import_lib$1.arrayExpression(values);
 }
 function emitChildBinding(node, context) {
 	switch (node.kind) {
@@ -14439,12 +14422,12 @@ function emitChildBinding(node, context) {
 }
 function emitAttrBinding(target, binding, context) {
 	const name = normalizeAttrName(binding.name);
-	if (name === "class") return import_lib$2.expressionStatement(import_lib$2.callExpression(context.importRuntime("bindClass"), [import_lib$2.identifier(target.ref.name), import_lib$2.arrowFunctionExpression([], binding.expr)]));
-	if (name === "style") return import_lib$2.expressionStatement(import_lib$2.callExpression(context.importRuntime("bindStyle"), [import_lib$2.identifier(target.ref.name), import_lib$2.arrowFunctionExpression([], binding.expr)]));
-	return import_lib$2.expressionStatement(import_lib$2.callExpression(context.importRuntime("bindAttr"), [
-		import_lib$2.identifier(target.ref.name),
-		import_lib$2.stringLiteral(name),
-		import_lib$2.arrowFunctionExpression([], binding.expr)
+	if (name === "class") return import_lib$1.expressionStatement(import_lib$1.callExpression(context.importRuntime("bindClass"), [import_lib$1.identifier(target.ref.name), import_lib$1.arrowFunctionExpression([], binding.expr)]));
+	if (name === "style") return import_lib$1.expressionStatement(import_lib$1.callExpression(context.importRuntime("bindStyle"), [import_lib$1.identifier(target.ref.name), import_lib$1.arrowFunctionExpression([], binding.expr)]));
+	return import_lib$1.expressionStatement(import_lib$1.callExpression(context.importRuntime("bindAttr"), [
+		import_lib$1.identifier(target.ref.name),
+		import_lib$1.stringLiteral(name),
+		import_lib$1.arrowFunctionExpression([], binding.expr)
 	]));
 }
 function normalizeAttrName(name) {
@@ -14452,45 +14435,45 @@ function normalizeAttrName(name) {
 }
 function emitEventBinding(target, binding, context) {
 	registerEvent(context.programPath, binding.eventName);
-	return import_lib$2.expressionStatement(import_lib$2.callExpression(context.importRuntime("bindEvent"), [
-		import_lib$2.identifier(target.ref.name),
-		import_lib$2.stringLiteral(binding.eventName),
+	return import_lib$1.expressionStatement(import_lib$1.callExpression(context.importRuntime("bindEvent"), [
+		import_lib$1.identifier(target.ref.name),
+		import_lib$1.stringLiteral(binding.eventName),
 		normalizeEventHandler(binding.handler, context)
 	]));
 }
 function normalizeEventHandler(handler, context) {
-	if (import_lib$2.isMemberExpression(handler) || import_lib$2.isOptionalMemberExpression(handler)) {
+	if (import_lib$1.isMemberExpression(handler) || import_lib$1.isOptionalMemberExpression(handler)) {
 		const event = context.uid("event$");
-		return import_lib$2.arrowFunctionExpression([import_lib$2.identifier(event.name)], import_lib$2.optionalCallExpression(import_lib$2.cloneNode(handler), [import_lib$2.identifier(event.name)], true));
+		return import_lib$1.arrowFunctionExpression([import_lib$1.identifier(event.name)], import_lib$1.optionalCallExpression(import_lib$1.cloneNode(handler), [import_lib$1.identifier(event.name)], true));
 	}
 	return handler;
 }
 function emitPropBinding(target, binding, context) {
-	return import_lib$2.expressionStatement(import_lib$2.callExpression(context.importRuntime("bindProp"), [
-		import_lib$2.identifier(target.ref.name),
-		import_lib$2.stringLiteral(binding.name),
-		import_lib$2.arrowFunctionExpression([], binding.expr)
+	return import_lib$1.expressionStatement(import_lib$1.callExpression(context.importRuntime("bindProp"), [
+		import_lib$1.identifier(target.ref.name),
+		import_lib$1.stringLiteral(binding.name),
+		import_lib$1.arrowFunctionExpression([], binding.expr)
 	]));
 }
 function emitRefBinding(target, binding, context) {
-	return import_lib$2.expressionStatement(import_lib$2.callExpression(context.importRuntime("bindRef"), [import_lib$2.identifier(target.ref.name), binding.expr]));
+	return import_lib$1.expressionStatement(import_lib$1.callExpression(context.importRuntime("bindRef"), [import_lib$1.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 [import_lib$2.variableDeclaration("const", [import_lib$2.variableDeclarator(textRef, import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("document"), import_lib$2.identifier("createTextNode")), [import_lib$2.callExpression(import_lib$2.identifier("String"), [node.expr])]))]), import_lib$2.expressionStatement(import_lib$2.callExpression(context.importRuntime("insert"), [
-		import_lib$2.identifier(node.domPath.parent.name),
+	if (node.once) return [import_lib$1.variableDeclaration("const", [import_lib$1.variableDeclarator(textRef, import_lib$1.callExpression(import_lib$1.memberExpression(import_lib$1.identifier("document"), import_lib$1.identifier("createTextNode")), [import_lib$1.callExpression(import_lib$1.identifier("String"), [node.expr])]))]), import_lib$1.expressionStatement(import_lib$1.callExpression(context.importRuntime("insert"), [
+		import_lib$1.identifier(node.domPath.parent.name),
 		textRef,
-		import_lib$2.identifier(node.ref.name)
+		import_lib$1.identifier(node.ref.name)
 	]))];
 	return [
-		import_lib$2.variableDeclaration("const", [import_lib$2.variableDeclarator(textRef, import_lib$2.callExpression(import_lib$2.memberExpression(import_lib$2.identifier("document"), import_lib$2.identifier("createTextNode")), [import_lib$2.stringLiteral("")]))]),
-		import_lib$2.expressionStatement(import_lib$2.callExpression(context.importRuntime("insert"), [
-			import_lib$2.identifier(node.domPath.parent.name),
+		import_lib$1.variableDeclaration("const", [import_lib$1.variableDeclarator(textRef, import_lib$1.callExpression(import_lib$1.memberExpression(import_lib$1.identifier("document"), import_lib$1.identifier("createTextNode")), [import_lib$1.stringLiteral("")]))]),
+		import_lib$1.expressionStatement(import_lib$1.callExpression(context.importRuntime("insert"), [
+			import_lib$1.identifier(node.domPath.parent.name),
 			textRef,
-			import_lib$2.identifier(node.ref.name)
+			import_lib$1.identifier(node.ref.name)
 		])),
-		import_lib$2.expressionStatement(import_lib$2.callExpression(context.importRuntime("bindText"), [textRef, import_lib$2.arrowFunctionExpression([], node.expr)]))
+		import_lib$1.expressionStatement(import_lib$1.callExpression(context.importRuntime("bindText"), [textRef, import_lib$1.arrowFunctionExpression([], node.expr)]))
 	];
 }
 function emitComponentInsert(node, context) {
@@ -14498,24 +14481,24 @@ function emitComponentInsert(node, context) {
 }
 function emitMarkerInsert(node, context, value) {
 	if (!node.domPath || node.domPath.kind !== "Marker") return [];
-	return [import_lib$2.expressionStatement(import_lib$2.callExpression(context.importRuntime("insert"), [
-		import_lib$2.identifier(node.domPath.parent.name),
+	return [import_lib$1.expressionStatement(import_lib$1.callExpression(context.importRuntime("insert"), [
+		import_lib$1.identifier(node.domPath.parent.name),
 		value,
-		import_lib$2.identifier(node.ref.name)
+		import_lib$1.identifier(node.ref.name)
 	]))];
 }
 function emitMarkerMount(node, context, mountCall) {
 	if (!node.domPath || node.domPath.kind !== "Marker") return [];
-	return [import_lib$2.expressionStatement(mountCall)];
+	return [import_lib$1.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 import_lib$2.memberExpression(import_lib$2.identifier(path.parent.name), import_lib$2.identifier("firstChild"));
-		case "NextSibling": return import_lib$2.memberExpression(import_lib$2.identifier(path.previous.name), import_lib$2.identifier("nextSibling"));
-		case "ChildNode": return import_lib$2.memberExpression(import_lib$2.memberExpression(import_lib$2.identifier(path.parent.name), import_lib$2.identifier("childNodes")), import_lib$2.numericLiteral(path.index), true);
+		case "FirstChild": return import_lib$1.memberExpression(import_lib$1.identifier(path.parent.name), import_lib$1.identifier("firstChild"));
+		case "NextSibling": return import_lib$1.memberExpression(import_lib$1.identifier(path.previous.name), import_lib$1.identifier("nextSibling"));
+		case "ChildNode": return import_lib$1.memberExpression(import_lib$1.memberExpression(import_lib$1.identifier(path.parent.name), import_lib$1.identifier("childNodes")), import_lib$1.numericLiteral(path.index), true);
 	}
 }
 //#endregion
@@ -14572,20 +14555,20 @@ function escapeAttr(value) {
 function emitTemplateClone(node, context) {
 	const html = renderTemplateHTML(node);
 	const template = context.registerTemplate(html, node.flags.isSVG);
-	const templateCall = import_lib$2.callExpression(import_lib$2.cloneNode(template.id), []);
-	return import_lib$2.memberExpression(templateCall, import_lib$2.identifier("firstChild"));
+	const templateCall = import_lib$1.callExpression(import_lib$1.cloneNode(template.id), []);
+	return import_lib$1.memberExpression(templateCall, import_lib$1.identifier("firstChild"));
 }
 //#endregion
 //#region packages/core/compiler/src/codegen/dom/emitElement.ts
 function emitElement(node, context) {
 	if (!hasRuntimeWork(node)) return emitTemplateClone(node, context);
 	const statements = [
-		import_lib$2.variableDeclaration("const", [import_lib$2.variableDeclarator(import_lib$2.identifier(node.ref.name), emitTemplateClone(node, context))]),
+		import_lib$1.variableDeclaration("const", [import_lib$1.variableDeclarator(import_lib$1.identifier(node.ref.name), emitTemplateClone(node, context))]),
 		...emitDomRefDeclarations(node.children, context),
 		...emitBindings(node, context),
-		import_lib$2.returnStatement(import_lib$2.identifier(node.ref.name))
+		import_lib$1.returnStatement(import_lib$1.identifier(node.ref.name))
 	];
-	return import_lib$2.callExpression(import_lib$2.arrowFunctionExpression([], import_lib$2.blockStatement(statements)), []);
+	return import_lib$1.callExpression(import_lib$1.arrowFunctionExpression([], import_lib$1.blockStatement(statements)), []);
 }
 function emitDomRefDeclarations(children, context) {
 	const statements = [];
@@ -14671,7 +14654,7 @@ function emitRefDependency(ref, statements, context, refNodeMap, declared) {
 }
 function createDomRefDeclaration(node, _context) {
 	if (!node.physicalDomPath) throw new Error(`${node.kind} physical DOM path is not assigned`);
-	return import_lib$2.variableDeclaration("const", [import_lib$2.variableDeclarator(import_lib$2.identifier(node.ref.name), emitPhysicalDomPath(node.physicalDomPath))]);
+	return import_lib$1.variableDeclaration("const", [import_lib$1.variableDeclarator(import_lib$1.identifier(node.ref.name), emitPhysicalDomPath(node.physicalDomPath))]);
 }
 function needsDomRefDeclaration(node) {
 	if (!node.physicalDomPath) return false;
@@ -14716,13 +14699,13 @@ function hasChildRuntimeWork(node) {
 //#endregion
 //#region packages/core/compiler/src/codegen/dom/emitFragment.ts
 function emitFragment(node, context) {
-	return import_lib$2.arrayExpression(node.children.map((child) => emitDOM(child, context)));
+	return import_lib$1.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 import_lib$2.stringLiteral(node.value);
+		case "Text": return import_lib$1.stringLiteral(node.value);
 		case "DynamicText": return node.expr;
 		case "Element": return emitElement(node, context);
 		case "Component": return emitComponent(node, context);
@@ -14731,101 +14714,102 @@ function emitNodeExpression(node, context) {
 		case "For": return emitFor(node, context);
 		case "Host": return emitHost(node, context);
 		case "Slot": return emitSlot(node, context);
-		default: return import_lib$2.nullLiteral();
+		default: return import_lib$1.nullLiteral();
 	}
 }
 //#endregion
 //#region packages/core/compiler/src/codegen/dom/emitComponent.ts
 function emitComponent(node, context) {
-	const props = import_lib$2.objectExpression(node.props.map((prop) => emitComponentProp(prop, context)));
-	return import_lib$2.callExpression(context.importRuntime("createComponent"), [node.callee, props]);
+	const props = import_lib$1.objectExpression(node.props.map((prop) => emitComponentProp(prop, context)));
+	return import_lib$1.callExpression(context.importRuntime("createComponent"), [node.callee, props]);
 }
 function emitComponentProp(prop, context) {
 	const key = createObjectKey$1(prop.name);
-	if (Array.isArray(prop.value)) return import_lib$2.objectMethod("get", key, [], import_lib$2.blockStatement([import_lib$2.returnStatement(emitChildrenProp(prop.value, context))]));
-	if (isStaticPropValue(prop.value)) return import_lib$2.objectProperty(key, prop.value);
-	return import_lib$2.objectMethod("get", key, [], import_lib$2.blockStatement([import_lib$2.returnStatement(prop.value)]));
+	if (Array.isArray(prop.value)) return import_lib$1.objectMethod("get", key, [], import_lib$1.blockStatement([import_lib$1.returnStatement(emitChildrenProp(prop.value, context))]));
+	if (isStaticPropValue(prop.value)) return import_lib$1.objectProperty(key, prop.value);
+	return import_lib$1.objectMethod("get", key, [], import_lib$1.blockStatement([import_lib$1.returnStatement(prop.value)]));
 }
 function emitChildrenProp(children, context) {
 	const nodes = children.map((child) => emitNodeExpression(child, context));
 	if (nodes.length === 1) return nodes[0];
-	return import_lib$2.arrayExpression(nodes);
+	return import_lib$1.arrayExpression(nodes);
 }
 function isStaticPropValue(value) {
-	return import_lib$2.isStringLiteral(value) || import_lib$2.isNumericLiteral(value) || import_lib$2.isBooleanLiteral(value) || import_lib$2.isNullLiteral(value);
+	return import_lib$1.isStringLiteral(value) || import_lib$1.isNumericLiteral(value) || import_lib$1.isBooleanLiteral(value) || import_lib$1.isNullLiteral(value);
 }
 function createObjectKey$1(key) {
-	return import_lib$2.isValidIdentifier(key) ? import_lib$2.identifier(key) : import_lib$2.stringLiteral(key);
+	return import_lib$1.isValidIdentifier(key) ? import_lib$1.identifier(key) : import_lib$1.stringLiteral(key);
 }
 //#endregion
 //#region packages/core/compiler/src/codegen/dom/emitBuiltin.ts
 function emitShow(node, context) {
-	const props = [import_lib$2.objectProperty(import_lib$2.identifier("when"), node.when), import_lib$2.objectProperty(import_lib$2.identifier("children"), import_lib$2.arrowFunctionExpression([], emitChildrenProp(node.children, context)))];
-	if (node.fallback) props.push(import_lib$2.objectProperty(import_lib$2.identifier("fallback"), Array.isArray(node.fallback) ? import_lib$2.arrowFunctionExpression([], emitChildrenProp(node.fallback, context)) : node.fallback));
-	return import_lib$2.callExpression(context.importRuntime("createComponent"), [context.importRuntime("Show"), import_lib$2.objectExpression(props)]);
+	const props = [import_lib$1.objectProperty(import_lib$1.identifier("when"), node.when), import_lib$1.objectProperty(import_lib$1.identifier("children"), import_lib$1.arrowFunctionExpression([], emitChildrenProp(node.children, context)))];
+	if (node.fallback) props.push(import_lib$1.objectProperty(import_lib$1.identifier("fallback"), Array.isArray(node.fallback) ? import_lib$1.arrowFunctionExpression([], emitChildrenProp(node.fallback, context)) : node.fallback));
+	return import_lib$1.callExpression(context.importRuntime("createComponent"), [context.importRuntime("Show"), import_lib$1.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 import_lib$2.callExpression(context.importRuntime("mountShow"), [
-		import_lib$2.identifier(path.parent.name),
+	return import_lib$1.callExpression(context.importRuntime("mountShow"), [
+		import_lib$1.identifier(path.parent.name),
 		emitMarkerIdentifier(node),
-		import_lib$2.arrowFunctionExpression([], node.when),
-		import_lib$2.arrowFunctionExpression([], emitChildrenProp(node.children, context)),
-		node.fallback ? Array.isArray(node.fallback) ? import_lib$2.arrowFunctionExpression([], emitChildrenProp(node.fallback, context)) : import_lib$2.arrowFunctionExpression([], node.fallback) : import_lib$2.identifier("undefined")
+		import_lib$1.arrowFunctionExpression([], node.when),
+		import_lib$1.arrowFunctionExpression([], emitChildrenProp(node.children, context)),
+		node.fallback ? Array.isArray(node.fallback) ? import_lib$1.arrowFunctionExpression([], emitChildrenProp(node.fallback, context)) : import_lib$1.arrowFunctionExpression([], node.fallback) : import_lib$1.identifier("undefined")
 	]);
 }
 function emitFor(node, context) {
 	const params = [node.item];
 	if (node.index) params.push(node.index);
-	const props = [import_lib$2.objectProperty(import_lib$2.identifier("each"), node.each), import_lib$2.objectProperty(import_lib$2.identifier("children"), import_lib$2.arrowFunctionExpression(params, emitChildrenProp(node.body, context)))];
-	if (node.by) props.push(import_lib$2.objectProperty(import_lib$2.identifier("by"), node.by));
-	return import_lib$2.callExpression(context.importRuntime("createComponent"), [context.importRuntime("For"), import_lib$2.objectExpression(props)]);
+	const props = [import_lib$1.objectProperty(import_lib$1.identifier("each"), node.each), import_lib$1.objectProperty(import_lib$1.identifier("children"), import_lib$1.arrowFunctionExpression(params, emitChildrenProp(node.body, context)))];
+	if (node.by) props.push(import_lib$1.objectProperty(import_lib$1.identifier("by"), node.by));
+	return import_lib$1.callExpression(context.importRuntime("createComponent"), [context.importRuntime("For"), import_lib$1.objectExpression(props)]);
 }
 function emitMountFor(node, context) {
 	var _node$by;
 	const params = [node.item];
-	const path = node.domPath;
 	if (node.index) params.push(node.index);
+	const path = node.domPath;
 	if (!path || path.kind !== "Marker") throw new Error("For DOM path is not assigned");
-	return import_lib$2.callExpression(context.importRuntime("mountFor"), [
-		import_lib$2.identifier(path.parent.name),
+	return import_lib$1.callExpression(context.importRuntime("mountFor"), [
+		import_lib$1.identifier(path.parent.name),
 		emitMarkerIdentifier(node),
-		import_lib$2.arrowFunctionExpression([], node.each),
-		(_node$by = node.by) !== null && _node$by !== void 0 ? _node$by : import_lib$2.identifier("undefined"),
-		import_lib$2.arrowFunctionExpression(params, emitChildrenProp(node.body, context))
+		import_lib$1.arrowFunctionExpression([], node.each),
+		(_node$by = node.by) !== null && _node$by !== void 0 ? _node$by : import_lib$1.identifier("undefined"),
+		import_lib$1.arrowFunctionExpression(params, emitChildrenProp(node.body, context))
 	]);
 }
 function emitHost(node, context) {
 	const props = buildHostProps(node, context);
-	const hostCall = import_lib$2.callExpression(context.importRuntime("Host"), [import_lib$2.objectExpression(props)]);
-	if (!node.child) return hostCall;
+	const hostIdent = context.importRuntime("Host");
+	if (!node.child) return import_lib$1.callExpression(hostIdent, [import_lib$1.objectExpression(props)]);
 	const childExpr = emitNodeExpression(node.child, context);
-	return import_lib$2.callExpression(import_lib$2.arrowFunctionExpression([], import_lib$2.blockStatement([import_lib$2.expressionStatement(hostCall), import_lib$2.returnStatement(childExpr)])), []);
+	const hostCall = import_lib$1.callExpression(hostIdent, [import_lib$1.objectExpression(props)]);
+	return import_lib$1.callExpression(import_lib$1.arrowFunctionExpression([], import_lib$1.blockStatement([import_lib$1.expressionStatement(hostCall), import_lib$1.returnStatement(childExpr)])), []);
 }
 function buildHostProps(node, context) {
 	const props = [];
 	for (const attr of node.attrs) {
 		const key = createObjectKey(attr.name);
-		if (isStaticValue(attr.expr) || isGetterExpression(attr.expr)) props.push(import_lib$2.objectProperty(key, attr.expr));
-		else props.push(import_lib$2.objectProperty(key, import_lib$2.arrowFunctionExpression([], attr.expr)));
+		if (isStaticValue(attr.expr) || isGetterExpression(attr.expr)) props.push(import_lib$1.objectProperty(key, attr.expr));
+		else props.push(import_lib$1.objectProperty(key, import_lib$1.arrowFunctionExpression([], attr.expr)));
 	}
 	return props;
 }
 function isStaticValue(expr) {
-	return import_lib$2.isStringLiteral(expr) || import_lib$2.isNumericLiteral(expr) || import_lib$2.isBooleanLiteral(expr) || import_lib$2.isNullLiteral(expr);
+	return import_lib$1.isStringLiteral(expr) || import_lib$1.isNumericLiteral(expr) || import_lib$1.isBooleanLiteral(expr) || import_lib$1.isNullLiteral(expr);
 }
 function isGetterExpression(expr) {
-	return import_lib$2.isArrowFunctionExpression(expr) || import_lib$2.isFunctionExpression(expr);
+	return import_lib$1.isArrowFunctionExpression(expr) || import_lib$1.isFunctionExpression(expr);
 }
 function createObjectKey(name) {
-	return import_lib$2.isValidIdentifier(name) ? import_lib$2.identifier(name) : import_lib$2.stringLiteral(name);
+	return import_lib$1.isValidIdentifier(name) ? import_lib$1.identifier(name) : import_lib$1.stringLiteral(name);
 }
 function emitSlot(node, context) {
-	return import_lib$2.callExpression(context.importRuntime("createSlot"), [node.name ? import_lib$2.stringLiteral(node.name) : import_lib$2.identifier("undefined"), node.fallback.length > 0 ? import_lib$2.arrowFunctionExpression([], emitChildrenProp(node.fallback, context)) : import_lib$2.identifier("undefined")]);
+	return import_lib$1.callExpression(context.importRuntime("createSlot"), [node.name ? import_lib$1.stringLiteral(node.name) : import_lib$1.identifier("undefined"), node.fallback.length > 0 ? import_lib$1.arrowFunctionExpression([], emitChildrenProp(node.fallback, context)) : import_lib$1.identifier("undefined")]);
 }
 function emitMarkerIdentifier(node) {
-	return import_lib$2.identifier(node.ref.name);
+	return import_lib$1.identifier(node.ref.name);
 }
 //#endregion
 //#region packages/core/compiler/src/codegen/dom/index.ts
@@ -14838,7 +14822,7 @@ function emitDOM(node, context) {
 		case "For": return emitFor(node, context);
 		case "Host": return emitHost(node, context);
 		case "Slot": return emitSlot(node, context);
-		case "DynamicText": return import_lib$2.arrowFunctionExpression([], node.expr);
+		case "DynamicText": return import_lib$1.arrowFunctionExpression([], node.expr);
 		default: throw new Error(`Unsupported root IR node: ${node.kind}`);
 	}
 }
@@ -14862,14 +14846,14 @@ var CompilerContext = class {
 		const importMethods = scopeData.importMethods || (scopeData.importMethods = /* @__PURE__ */ new Map());
 		const key = `${moduleName}:${imported}`;
 		const cached = importMethods.get(key);
-		if (cached) return import_lib$2.cloneNode(cached.local);
+		if (cached) return import_lib$1.cloneNode(cached.local);
 		const local = this.uid(imported);
 		importMethods.set(key, {
 			moduleName,
 			imported,
 			local
 		});
-		return import_lib$2.cloneNode(local);
+		return import_lib$1.cloneNode(local);
 	}
 	registerTemplate(html, isSVG = false) {
 		const scopeData = this.programPath.scope.data;
@@ -14877,7 +14861,7 @@ var CompilerContext = class {
 		const templates = scopeData.templates || (scopeData.templates = []);
 		const cached = templateMap.get(html);
 		if (cached) return {
-			id: import_lib$2.cloneNode(cached.id),
+			id: import_lib$1.cloneNode(cached.id),
 			html,
 			isSVG: Boolean(cached.isSVG)
 		};
@@ -14893,7 +14877,7 @@ var CompilerContext = class {
 		});
 		templates.push(templateMap.get(html));
 		return {
-			id: import_lib$2.cloneNode(id),
+			id: import_lib$1.cloneNode(id),
 			html,
 			isSVG
 		};
@@ -15140,15 +15124,15 @@ function slotIR(input) {
 * These do NOT produce IR or Babel AST; they only read the JSX tree.
 */
 function jsxElementNameToString(node) {
-	if (import_lib$2.isJSXMemberExpression(node)) return `${jsxElementNameToString(node.object)}.${node.property.name}`;
-	if (import_lib$2.isJSXIdentifier(node) || import_lib$2.isIdentifier(node)) return node.name;
+	if (import_lib$1.isJSXMemberExpression(node)) return `${jsxElementNameToString(node.object)}.${node.property.name}`;
+	if (import_lib$1.isJSXIdentifier(node) || import_lib$1.isIdentifier(node)) return node.name;
 	return `${node.namespace.name}:${node.name.name}`;
 }
 function getTagName(node) {
 	return jsxElementNameToString(node.openingElement.name);
 }
 function getJSXAttrName(name) {
-	if (import_lib$2.isJSXNamespacedName(name)) return `${name.namespace.name}:${name.name.name}`;
+	if (import_lib$1.isJSXNamespacedName(name)) return `${name.namespace.name}:${name.name.name}`;
 	return name.name;
 }
 function isComponentTag(tagName) {
@@ -15160,7 +15144,7 @@ function toEventName(name) {
 //#endregion
 //#region packages/core/compiler/src/lower/lowerAttribute.ts
 function lowerAttribute(path, _context) {
-	if (path.isJSXSpreadAttribute() || import_lib$2.isJSXSpreadAttribute(path.node)) throw new CompilerError({
+	if (path.isJSXSpreadAttribute() || import_lib$1.isJSXSpreadAttribute(path.node)) throw new CompilerError({
 		code: CompilerErrorCode.UNSUPPORTED_SPREAD_ATTRIBUTE,
 		message: "Spread attributes are not supported in Zeus MVP.",
 		path,
@@ -15178,7 +15162,7 @@ function lowerAttribute(path, _context) {
 		});
 		return staticAttrIR(name, true);
 	}
-	if (import_lib$2.isStringLiteral(value)) {
+	if (import_lib$1.isStringLiteral(value)) {
 		if (name === "ref") throw new CompilerError({
 			code: CompilerErrorCode.INVALID_REF_USAGE,
 			message: "String refs are not supported in Zeus.",
@@ -15187,9 +15171,9 @@ function lowerAttribute(path, _context) {
 		});
 		return staticAttrIR(name, value.value);
 	}
-	if (import_lib$2.isJSXExpressionContainer(value)) {
+	if (import_lib$1.isJSXExpressionContainer(value)) {
 		const expr = value.expression;
-		if (import_lib$2.isJSXEmptyExpression(expr)) throw new CompilerError({
+		if (import_lib$1.isJSXEmptyExpression(expr)) throw new CompilerError({
 			code: CompilerErrorCode.EMPTY_EXPRESSION,
 			message: `Attribute "${name}" expression cannot be empty.`,
 			path
@@ -15213,8 +15197,8 @@ function lowerChildren(children, context) {
 		}
 		if (child.isJSXExpressionContainer()) {
 			const expr = child.node.expression;
-			if (import_lib$2.isJSXEmptyExpression(expr)) continue;
-			if (import_lib$2.isExpression(expr)) result.push(dynamicTextIR(expr, ref(context.uid("anchor$").name)));
+			if (import_lib$1.isJSXEmptyExpression(expr)) continue;
+			if (import_lib$1.isExpression(expr)) result.push(dynamicTextIR(expr, ref(context.uid("anchor$").name)));
 			continue;
 		}
 		if (child.isJSXElement() || child.isJSXFragment()) {
@@ -15236,7 +15220,7 @@ function isBuiltinTag(tagName) {
 }
 function lowerBuiltin(path, context) {
 	const tagName = path.node.openingElement.name;
-	if (!import_lib$2.isJSXIdentifier(tagName)) throw new CompilerError({
+	if (!import_lib$1.isJSXIdentifier(tagName)) throw new CompilerError({
 		code: CompilerErrorCode.INVALID_BUILTIN_USAGE,
 		message: "Built-in JSX nodes do not support member expressions.",
 		path
@@ -15270,7 +15254,7 @@ function optionalShowFallbackAttr(path, context) {
 	});
 	if (!(attr === null || attr === void 0 ? void 0 : attr.isJSXAttribute())) return void 0;
 	const value = attr.get("value");
-	if (!value.node) return import_lib$2.booleanLiteral(true);
+	if (!value.node) return import_lib$1.booleanLiteral(true);
 	if (value.isStringLiteral()) return value.node;
 	if (!value.isJSXExpressionContainer()) return void 0;
 	const expression = value.get("expression");
@@ -15283,7 +15267,7 @@ function lowerFor(path, context) {
 	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 : import_lib$2.identifier("item");
+	const item = (_getParamIdentifier = getParamIdentifier(render, 0)) !== null && _getParamIdentifier !== void 0 ? _getParamIdentifier : import_lib$1.identifier("item");
 	const index = getParamIdentifier(render, 1);
 	const bodyPath = render.get("body");
 	const body = [];
@@ -15322,9 +15306,9 @@ function optionalExpressionAttr(path, name) {
 	});
 	if (!(attr === null || attr === void 0 ? void 0 : attr.isJSXAttribute())) return void 0;
 	const value = attr.node.value;
-	if (!value) return import_lib$2.booleanLiteral(true);
-	if (import_lib$2.isStringLiteral(value)) return value;
-	if (import_lib$2.isJSXExpressionContainer(value) && !import_lib$2.isJSXEmptyExpression(value.expression)) return value.expression;
+	if (!value) return import_lib$1.booleanLiteral(true);
+	if (import_lib$1.isStringLiteral(value)) return value;
+	if (import_lib$1.isJSXExpressionContainer(value) && !import_lib$1.isJSXEmptyExpression(value.expression)) return value.expression;
 }
 function optionalStringAttr(path, name) {
 	const attr = path.get("openingElement").get("attributes").find((attrPath) => {
@@ -15334,7 +15318,7 @@ function optionalStringAttr(path, name) {
 	if (!(attr === null || attr === void 0 ? void 0 : attr.isJSXAttribute())) return void 0;
 	const value = attr.node.value;
 	if (!value) return "";
-	if (import_lib$2.isStringLiteral(value)) return value.value;
+	if (import_lib$1.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());
@@ -15347,12 +15331,12 @@ function getOnlyRenderFunction(path) {
 }
 function getParamIdentifier(path, index, fallback) {
 	const param = path.node.params[index];
-	if (import_lib$2.isIdentifier(param)) return param;
-	if (fallback) return import_lib$2.identifier(fallback);
+	if (import_lib$1.isIdentifier(param)) return param;
+	if (fallback) return import_lib$1.identifier(fallback);
 }
 function getBuiltinName(path) {
 	const name = path.node.openingElement.name;
-	return import_lib$2.isJSXIdentifier(name) ? name.name : "Builtin";
+	return import_lib$1.isJSXIdentifier(name) ? name.name : "Builtin";
 }
 function isEventLikeProp(key) {
 	return /^on[A-Z]/.test(key) || key.startsWith("on:");
@@ -15371,7 +15355,7 @@ function lowerHost(path, context) {
 	const rawChildren = lowerChildren(path.get("children"), context);
 	for (const attrPath of path.get("openingElement").get("attributes")) {
 		const node = attrPath.node;
-		if (import_lib$2.isJSXSpreadAttribute(node)) throw new CompilerError({
+		if (import_lib$1.isJSXSpreadAttribute(node)) throw new CompilerError({
 			code: CompilerErrorCode.UNSUPPORTED_COMPONENT_PROP,
 			message: "Spread props are not supported on Host in Phase 1.",
 			path: attrPath
@@ -15399,15 +15383,15 @@ function lowerHost(path, context) {
 			id: id(),
 			kind: "HostAttr",
 			name: normalizeHostAttrName(name),
-			expr: import_lib$2.booleanLiteral(true)
+			expr: import_lib$1.booleanLiteral(true)
 		});
-		else if (import_lib$2.isStringLiteral(value)) attrs.push({
+		else if (import_lib$1.isStringLiteral(value)) attrs.push({
 			id: id(),
 			kind: "HostAttr",
 			name: normalizeHostAttrName(name),
-			expr: import_lib$2.stringLiteral(value.value)
+			expr: import_lib$1.stringLiteral(value.value)
 		});
-		else if (import_lib$2.isJSXExpressionContainer(value) && !import_lib$2.isJSXEmptyExpression(value.expression)) attrs.push({
+		else if (import_lib$1.isJSXExpressionContainer(value) && !import_lib$1.isJSXEmptyExpression(value.expression)) attrs.push({
 			id: id(),
 			kind: "HostAttr",
 			name: normalizeHostAttrName(name),
@@ -15426,7 +15410,7 @@ function lowerComponent(path, context) {
 	const props = [];
 	for (const attr of path.get("openingElement").get("attributes")) {
 		const node = attr.node;
-		if (import_lib$2.isJSXSpreadAttribute(node)) throw new CompilerError({
+		if (import_lib$1.isJSXSpreadAttribute(node)) throw new CompilerError({
 			code: CompilerErrorCode.UNSUPPORTED_COMPONENT_PROP,
 			message: "Spread props are not supported in Zeus MVP.",
 			path: attr
@@ -15435,19 +15419,19 @@ function lowerComponent(path, context) {
 		if (!node.value) {
 			props.push({
 				name,
-				value: import_lib$2.booleanLiteral(true)
+				value: import_lib$1.booleanLiteral(true)
 			});
 			continue;
 		}
-		if (import_lib$2.isStringLiteral(node.value)) {
+		if (import_lib$1.isStringLiteral(node.value)) {
 			props.push({
 				name,
 				value: node.value
 			});
 			continue;
 		}
-		if (import_lib$2.isJSXExpressionContainer(node.value)) {
-			if (import_lib$2.isJSXEmptyExpression(node.value.expression)) throw new CompilerError({
+		if (import_lib$1.isJSXExpressionContainer(node.value)) {
+			if (import_lib$1.isJSXEmptyExpression(node.value.expression)) throw new CompilerError({
 				code: CompilerErrorCode.EMPTY_EXPRESSION,
 				message: `Component prop "${name}" expression cannot be empty.`,
 				path: attr
@@ -15470,17 +15454,17 @@ function lowerComponent(path, context) {
 	});
 }
 function convertComponentIdentifier(node) {
-	if (import_lib$2.isJSXIdentifier(node)) {
-		if (node.name === "this") return import_lib$2.thisExpression();
-		if (import_lib$2.isValidIdentifier(node.name)) return import_lib$2.identifier(node.name);
-		return import_lib$2.stringLiteral(node.name);
+	if (import_lib$1.isJSXIdentifier(node)) {
+		if (node.name === "this") return import_lib$1.thisExpression();
+		if (import_lib$1.isValidIdentifier(node.name)) return import_lib$1.identifier(node.name);
+		return import_lib$1.stringLiteral(node.name);
 	}
-	if (import_lib$2.isJSXMemberExpression(node)) {
+	if (import_lib$1.isJSXMemberExpression(node)) {
 		const object = convertComponentIdentifier(node.object);
 		const property = convertComponentIdentifier(node.property);
-		return import_lib$2.memberExpression(object, property, import_lib$2.isStringLiteral(property));
+		return import_lib$1.memberExpression(object, property, import_lib$1.isStringLiteral(property));
 	}
-	if (import_lib$2.isJSXNamespacedName(node)) return import_lib$2.stringLiteral(`${node.namespace.name}:${node.name.name}`);
+	if (import_lib$1.isJSXNamespacedName(node)) return import_lib$1.stringLiteral(`${node.namespace.name}:${node.name.name}`);
 	return node;
 }
 //#endregion
@@ -15889,11 +15873,18 @@ function createVisitor(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 = (0, import_lib.declare)((api, options) => {
 	api.assertVersion(7);
 	return {
 		name: "babel-plugin-zeus-compiler",
-		inherits: import_lib$1.default,
+		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))
 	};
 });