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

package/dist/compiler.global.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.
 **/
@@ -32,7 +32,7 @@ var ZeusCompiler = (function(exports) {
 	}) : 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;
@@ -85,22 +85,6 @@ var ZeusCompiler = (function(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;
@@ -14163,9 +14147,8 @@ var ZeusCompiler = (function(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}`;
@@ -14183,14 +14166,14 @@ var ZeusCompiler = (function(exports) {
 		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
@@ -14206,7 +14189,7 @@ var ZeusCompiler = (function(exports) {
 			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) {
@@ -14253,11 +14236,11 @@ var ZeusCompiler = (function(exports) {
 			};
 			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
@@ -14287,7 +14270,7 @@ var ZeusCompiler = (function(exports) {
 	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
@@ -14408,7 +14391,7 @@ var ZeusCompiler = (function(exports) {
 		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) => {
@@ -14420,15 +14403,15 @@ var ZeusCompiler = (function(exports) {
 	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) {
@@ -14444,12 +14427,12 @@ var ZeusCompiler = (function(exports) {
 	}
 	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) {
@@ -14457,45 +14440,45 @@ var ZeusCompiler = (function(exports) {
 	}
 	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) {
@@ -14503,24 +14486,24 @@ var ZeusCompiler = (function(exports) {
 	}
 	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
@@ -14577,20 +14560,20 @@ var ZeusCompiler = (function(exports) {
 	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 = [];
@@ -14676,7 +14659,7 @@ var ZeusCompiler = (function(exports) {
 	}
 	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;
@@ -14721,13 +14704,13 @@ var ZeusCompiler = (function(exports) {
 	//#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);
@@ -14736,101 +14719,102 @@ var ZeusCompiler = (function(exports) {
 			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
@@ -14843,7 +14827,7 @@ var ZeusCompiler = (function(exports) {
 			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}`);
 		}
 	}
@@ -14867,14 +14851,14 @@ var ZeusCompiler = (function(exports) {
 			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;
@@ -14882,7 +14866,7 @@ var ZeusCompiler = (function(exports) {
 			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)
 			};
@@ -14898,7 +14882,7 @@ var ZeusCompiler = (function(exports) {
 			});
 			templates.push(templateMap.get(html));
 			return {
-				id: import_lib$2.cloneNode(id),
+				id: import_lib$1.cloneNode(id),
 				html,
 				isSVG
 			};
@@ -15145,15 +15129,15 @@ var ZeusCompiler = (function(exports) {
 	* 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) {
@@ -15165,7 +15149,7 @@ var ZeusCompiler = (function(exports) {
 	//#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,
@@ -15183,7 +15167,7 @@ var ZeusCompiler = (function(exports) {
 			});
 			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.",
@@ -15192,9 +15176,9 @@ var ZeusCompiler = (function(exports) {
 			});
 			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
@@ -15218,8 +15202,8 @@ var ZeusCompiler = (function(exports) {
 			}
 			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()) {
@@ -15241,7 +15225,7 @@ var ZeusCompiler = (function(exports) {
 	}
 	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
@@ -15275,7 +15259,7 @@ var ZeusCompiler = (function(exports) {
 		});
 		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");
@@ -15288,7 +15272,7 @@ var ZeusCompiler = (function(exports) {
 		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 = [];
@@ -15327,9 +15311,9 @@ var ZeusCompiler = (function(exports) {
 		});
 		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) => {
@@ -15339,7 +15323,7 @@ var ZeusCompiler = (function(exports) {
 		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());
@@ -15352,12 +15336,12 @@ var ZeusCompiler = (function(exports) {
 	}
 	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:");
@@ -15376,7 +15360,7 @@ var ZeusCompiler = (function(exports) {
 		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
@@ -15404,15 +15388,15 @@ var ZeusCompiler = (function(exports) {
 				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),
@@ -15431,7 +15415,7 @@ var ZeusCompiler = (function(exports) {
 		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
@@ -15440,19 +15424,19 @@ var ZeusCompiler = (function(exports) {
 			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
@@ -15475,17 +15459,17 @@ var ZeusCompiler = (function(exports) {
 		});
 	}
 	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
@@ -15893,11 +15877,20 @@ var ZeusCompiler = (function(exports) {
 		};
 	}
 	//#endregion
+	//#region packages/core/compiler/src/index.ts
+	function hasParserPlugin(plugins, name) {
+		return plugins.some((plugin) => (Array.isArray(plugin) ? plugin[0] : plugin) === name);
+	}
+	//#endregion
 	exports.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))
 		};
 	});