@vue-jsx-vapor/compiler 2.3.0 → 2.3.2

package/dist/index.js

@@ -1,1727 +1,1402 @@
-// src/compile.ts
-import { parse } from "@babel/parser";
-import {
-  generate
-} from "@vue/compiler-vapor";
-import { extend as extend5, isString as isString3 } from "@vue/shared";
+import { parse, parseExpression } from "@babel/parser";
+import { NEWLINE, genCall, genExpression, generate } from "@vue/compiler-vapor";
+import { EMPTY_OBJ, NOOP, camelize, extend, isArray, isBuiltInDirective, isGloballyAllowed, isHTMLTag, isSVGTag, isString, isVoidTag, makeMap } from "@vue/shared";
+import { DOMErrorCodes, ErrorCodes, NodeTypes, createCompilerError, createDOMCompilerError, createSimpleExpression, defaultOnError, defaultOnWarn, isConstantNode, isLiteralWhitelisted, isMemberExpression, isStaticNode, isValidHTMLNesting, resolveModifiers, walkIdentifiers } from "@vue/compiler-dom";
+import { isLiteral, jsxClosingFragment, jsxExpressionContainer, jsxFragment, jsxOpeningFragment } from "@babel/types";
 
-// src/generate.ts
-import {
-  genCall,
-  genExpression,
-  NEWLINE
-} from "@vue/compiler-vapor";
+//#region src/ir/component.ts
+let IRDynamicPropsKind = /* @__PURE__ */ function(IRDynamicPropsKind$1) {
+	IRDynamicPropsKind$1[IRDynamicPropsKind$1["EXPRESSION"] = 0] = "EXPRESSION";
+	IRDynamicPropsKind$1[IRDynamicPropsKind$1["ATTRIBUTE"] = 1] = "ATTRIBUTE";
+	return IRDynamicPropsKind$1;
+}({});
+let IRSlotType = /* @__PURE__ */ function(IRSlotType$1) {
+	IRSlotType$1[IRSlotType$1["STATIC"] = 0] = "STATIC";
+	IRSlotType$1[IRSlotType$1["DYNAMIC"] = 1] = "DYNAMIC";
+	IRSlotType$1[IRSlotType$1["LOOP"] = 2] = "LOOP";
+	IRSlotType$1[IRSlotType$1["CONDITIONAL"] = 3] = "CONDITIONAL";
+	IRSlotType$1[IRSlotType$1["EXPRESSION"] = 4] = "EXPRESSION";
+	return IRSlotType$1;
+}({});
 
-// src/ir/component.ts
-var IRDynamicPropsKind = /* @__PURE__ */ ((IRDynamicPropsKind2) => {
-  IRDynamicPropsKind2[IRDynamicPropsKind2["EXPRESSION"] = 0] = "EXPRESSION";
-  IRDynamicPropsKind2[IRDynamicPropsKind2["ATTRIBUTE"] = 1] = "ATTRIBUTE";
-  return IRDynamicPropsKind2;
-})(IRDynamicPropsKind || {});
-var IRSlotType = /* @__PURE__ */ ((IRSlotType2) => {
-  IRSlotType2[IRSlotType2["STATIC"] = 0] = "STATIC";
-  IRSlotType2[IRSlotType2["DYNAMIC"] = 1] = "DYNAMIC";
-  IRSlotType2[IRSlotType2["LOOP"] = 2] = "LOOP";
-  IRSlotType2[IRSlotType2["CONDITIONAL"] = 3] = "CONDITIONAL";
-  IRSlotType2[IRSlotType2["EXPRESSION"] = 4] = "EXPRESSION";
-  return IRSlotType2;
-})(IRSlotType || {});
-
-// src/ir/index.ts
-var IRNodeTypes = /* @__PURE__ */ ((IRNodeTypes2) => {
-  IRNodeTypes2[IRNodeTypes2["ROOT"] = 0] = "ROOT";
-  IRNodeTypes2[IRNodeTypes2["BLOCK"] = 1] = "BLOCK";
-  IRNodeTypes2[IRNodeTypes2["SET_PROP"] = 2] = "SET_PROP";
-  IRNodeTypes2[IRNodeTypes2["SET_DYNAMIC_PROPS"] = 3] = "SET_DYNAMIC_PROPS";
-  IRNodeTypes2[IRNodeTypes2["SET_TEXT"] = 4] = "SET_TEXT";
-  IRNodeTypes2[IRNodeTypes2["SET_EVENT"] = 5] = "SET_EVENT";
-  IRNodeTypes2[IRNodeTypes2["SET_DYNAMIC_EVENTS"] = 6] = "SET_DYNAMIC_EVENTS";
-  IRNodeTypes2[IRNodeTypes2["SET_HTML"] = 7] = "SET_HTML";
-  IRNodeTypes2[IRNodeTypes2["SET_TEMPLATE_REF"] = 8] = "SET_TEMPLATE_REF";
-  IRNodeTypes2[IRNodeTypes2["INSERT_NODE"] = 9] = "INSERT_NODE";
-  IRNodeTypes2[IRNodeTypes2["PREPEND_NODE"] = 10] = "PREPEND_NODE";
-  IRNodeTypes2[IRNodeTypes2["CREATE_COMPONENT_NODE"] = 11] = "CREATE_COMPONENT_NODE";
-  IRNodeTypes2[IRNodeTypes2["SLOT_OUTLET_NODE"] = 12] = "SLOT_OUTLET_NODE";
-  IRNodeTypes2[IRNodeTypes2["DIRECTIVE"] = 13] = "DIRECTIVE";
-  IRNodeTypes2[IRNodeTypes2["DECLARE_OLD_REF"] = 14] = "DECLARE_OLD_REF";
-  IRNodeTypes2[IRNodeTypes2["IF"] = 15] = "IF";
-  IRNodeTypes2[IRNodeTypes2["FOR"] = 16] = "FOR";
-  IRNodeTypes2[IRNodeTypes2["GET_TEXT_CHILD"] = 17] = "GET_TEXT_CHILD";
-  IRNodeTypes2[IRNodeTypes2["CREATE_NODES"] = 18] = "CREATE_NODES";
-  IRNodeTypes2[IRNodeTypes2["SET_NODES"] = 19] = "SET_NODES";
-  return IRNodeTypes2;
-})(IRNodeTypes || {});
-var DynamicFlag = /* @__PURE__ */ ((DynamicFlag2) => {
-  DynamicFlag2[DynamicFlag2["NONE"] = 0] = "NONE";
-  DynamicFlag2[DynamicFlag2["REFERENCED"] = 1] = "REFERENCED";
-  DynamicFlag2[DynamicFlag2["NON_TEMPLATE"] = 2] = "NON_TEMPLATE";
-  DynamicFlag2[DynamicFlag2["INSERT"] = 4] = "INSERT";
-  return DynamicFlag2;
-})(DynamicFlag || {});
+//#endregion
+//#region src/ir/index.ts
+let IRNodeTypes = /* @__PURE__ */ function(IRNodeTypes$1) {
+	IRNodeTypes$1[IRNodeTypes$1["ROOT"] = 0] = "ROOT";
+	IRNodeTypes$1[IRNodeTypes$1["BLOCK"] = 1] = "BLOCK";
+	IRNodeTypes$1[IRNodeTypes$1["SET_PROP"] = 2] = "SET_PROP";
+	IRNodeTypes$1[IRNodeTypes$1["SET_DYNAMIC_PROPS"] = 3] = "SET_DYNAMIC_PROPS";
+	IRNodeTypes$1[IRNodeTypes$1["SET_TEXT"] = 4] = "SET_TEXT";
+	IRNodeTypes$1[IRNodeTypes$1["SET_EVENT"] = 5] = "SET_EVENT";
+	IRNodeTypes$1[IRNodeTypes$1["SET_DYNAMIC_EVENTS"] = 6] = "SET_DYNAMIC_EVENTS";
+	IRNodeTypes$1[IRNodeTypes$1["SET_HTML"] = 7] = "SET_HTML";
+	IRNodeTypes$1[IRNodeTypes$1["SET_TEMPLATE_REF"] = 8] = "SET_TEMPLATE_REF";
+	IRNodeTypes$1[IRNodeTypes$1["INSERT_NODE"] = 9] = "INSERT_NODE";
+	IRNodeTypes$1[IRNodeTypes$1["PREPEND_NODE"] = 10] = "PREPEND_NODE";
+	IRNodeTypes$1[IRNodeTypes$1["CREATE_COMPONENT_NODE"] = 11] = "CREATE_COMPONENT_NODE";
+	IRNodeTypes$1[IRNodeTypes$1["SLOT_OUTLET_NODE"] = 12] = "SLOT_OUTLET_NODE";
+	IRNodeTypes$1[IRNodeTypes$1["DIRECTIVE"] = 13] = "DIRECTIVE";
+	IRNodeTypes$1[IRNodeTypes$1["DECLARE_OLD_REF"] = 14] = "DECLARE_OLD_REF";
+	IRNodeTypes$1[IRNodeTypes$1["IF"] = 15] = "IF";
+	IRNodeTypes$1[IRNodeTypes$1["FOR"] = 16] = "FOR";
+	IRNodeTypes$1[IRNodeTypes$1["GET_TEXT_CHILD"] = 17] = "GET_TEXT_CHILD";
+	IRNodeTypes$1[IRNodeTypes$1["CREATE_NODES"] = 18] = "CREATE_NODES";
+	IRNodeTypes$1[IRNodeTypes$1["SET_NODES"] = 19] = "SET_NODES";
+	return IRNodeTypes$1;
+}({});
+let DynamicFlag = /* @__PURE__ */ function(DynamicFlag$1) {
+	DynamicFlag$1[DynamicFlag$1["NONE"] = 0] = "NONE";
+	/**
+	* This node is referenced and needs to be saved as a variable.
+	*/
+	DynamicFlag$1[DynamicFlag$1["REFERENCED"] = 1] = "REFERENCED";
+	/**
+	* This node is not generated from template, but is generated dynamically.
+	*/
+	DynamicFlag$1[DynamicFlag$1["NON_TEMPLATE"] = 2] = "NON_TEMPLATE";
+	/**
+	* This node needs to be inserted back into the template.
+	*/
+	DynamicFlag$1[DynamicFlag$1["INSERT"] = 4] = "INSERT";
+	return DynamicFlag$1;
+}({});
 function isBlockOperation(op) {
-  const type = op.type;
-  return type === 11 /* CREATE_COMPONENT_NODE */ || type === 12 /* SLOT_OUTLET_NODE */ || type === 15 /* IF */ || type === 16 /* FOR */;
+	const type = op.type;
+	return type === IRNodeTypes.CREATE_COMPONENT_NODE || type === IRNodeTypes.SLOT_OUTLET_NODE || type === IRNodeTypes.IF || type === IRNodeTypes.FOR;
 }
 
-// src/generate.ts
-var customGenOperation = (oper, context) => {
-  if (oper.type === 18 /* CREATE_NODES */) {
-    return genCreateNodes(oper, context);
-  } else if (oper.type === 19 /* SET_NODES */) {
-    return genSetNodes(oper, context);
-  }
+//#endregion
+//#region src/generate.ts
+const customGenOperation = (oper, context) => {
+	if (oper.type === IRNodeTypes.CREATE_NODES) return genCreateNodes(oper, context);
+	else if (oper.type === IRNodeTypes.SET_NODES) return genSetNodes(oper, context);
 };
 function genSetNodes(oper, context) {
-  const { helper } = context;
-  const { element, values, generated } = oper;
-  return [
-    NEWLINE,
-    ...genCall(
-      helper("setNodes"),
-      `${generated ? "x" : "n"}${element}`,
-      combineValues(values, context)
-    )
-  ];
+	const { helper } = context;
+	const { element, values, generated } = oper;
+	return [NEWLINE, ...genCall(helper("setNodes"), `${generated ? "x" : "n"}${element}`, combineValues(values, context))];
 }
 function genCreateNodes(oper, context) {
-  const { helper } = context;
-  const { id, values } = oper;
-  return [
-    NEWLINE,
-    `const n${id} = `,
-    ...genCall(helper("createNodes"), values && combineValues(values, context))
-  ];
+	const { helper } = context;
+	const { id, values } = oper;
+	return [
+		NEWLINE,
+		`const n${id} = `,
+		...genCall(helper("createNodes"), values && combineValues(values, context))
+	];
 }
 function combineValues(values, context) {
-  return values.flatMap((value, i) => {
-    const exp = genExpression(value, context);
-    if (i > 0) {
-      exp.unshift(", ");
-    }
-    return exp;
-  });
+	return values.flatMap((value, i) => {
+		const exp = genExpression(value, context);
+		if (i > 0) exp.unshift(", ");
+		return exp;
+	});
 }
 
-// src/transform.ts
-import {
-  defaultOnError,
-  defaultOnWarn
-} from "@vue/compiler-dom";
-import { EMPTY_OBJ, extend, isArray, isString as isString2, NOOP } from "@vue/shared";
-
-// src/transforms/utils.ts
-import {
-  jsxClosingFragment,
-  jsxExpressionContainer,
-  jsxFragment,
-  jsxOpeningFragment
-} from "@babel/types";
-import { createSimpleExpression as createSimpleExpression2 } from "@vue/compiler-dom";
-
-// src/utils.ts
-import { parseExpression } from "@babel/parser";
-import {
-  isLiteral
-} from "@babel/types";
-import {
-  createSimpleExpression,
-  ElementTypes,
-  isLiteralWhitelisted,
-  Namespaces,
-  NodeTypes,
-  walkIdentifiers
-} from "@vue/compiler-dom";
-import { isGloballyAllowed, isHTMLTag, isString, isSVGTag } from "@vue/shared";
+//#endregion
+//#region src/utils.ts
 function propToExpression(prop, context) {
-  return prop.type === "JSXAttribute" && prop.value?.type === "JSXExpressionContainer" ? resolveExpression(prop.value.expression, context) : EMPTY_EXPRESSION;
+	return prop.type === "JSXAttribute" && prop.value?.type === "JSXExpressionContainer" ? resolveExpression(prop.value.expression, context) : EMPTY_EXPRESSION;
 }
 function isConstantExpression(exp) {
-  return isLiteralWhitelisted(exp.content) || isGloballyAllowed(exp.content) || getLiteralExpressionValue(exp) !== null;
+	return isLiteralWhitelisted(exp.content) || isGloballyAllowed(exp.content) || getLiteralExpressionValue(exp) !== null;
 }
 function getLiteralExpressionValue(exp) {
-  if (exp.ast) {
-    if (["StringLiteral", "NumericLiteral", "BigIntLiteral"].includes(
-      exp.ast.type
-    )) {
-      return exp.ast.value;
-    } else if (exp.ast.type === "TemplateLiteral" && exp.ast.expressions.length === 0) {
-      return exp.ast.quasis[0].value.cooked;
-    }
-  }
-  return exp.isStatic ? exp.content : null;
+	if (exp.ast) {
+		if ([
+			"StringLiteral",
+			"NumericLiteral",
+			"BigIntLiteral"
+		].includes(exp.ast.type)) return exp.ast.value;
+		else if (exp.ast.type === "TemplateLiteral" && exp.ast.expressions.length === 0) return exp.ast.quasis[0].value.cooked;
+	}
+	return exp.isStatic ? exp.content : null;
 }
-var isConstant = (node) => {
-  if (!node) return false;
-  if (node.type === "Identifier") {
-    return node.name === "undefined";
-  }
-  if (node.type === "ArrayExpression") {
-    const { elements } = node;
-    return elements.every((element) => element && isConstant(element));
-  }
-  if (node.type === "ObjectExpression") {
-    return node.properties.every(
-      (property) => isConstant(property.value)
-    );
-  }
-  if (node.type === "TemplateLiteral" ? !node.expressions.length : isLiteral(node)) {
-    return true;
-  }
-  return false;
+const isConstant = (node) => {
+	if (!node) return false;
+	if (node.type === "Identifier") return node.name === "undefined";
+	if (node.type === "ArrayExpression") {
+		const { elements } = node;
+		return elements.every((element) => element && isConstant(element));
+	}
+	if (node.type === "ObjectExpression") return node.properties.every((property) => isConstant(property.value));
+	if (node.type === "TemplateLiteral" ? !node.expressions.length : isLiteral(node)) return true;
+	return false;
 };
-var EMPTY_TEXT_REGEX = /^[\t\v\f \u00A0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]*[\n\r]\s*$/;
-var START_EMPTY_TEXT_REGEX = /^\s*[\n\r]/;
-var END_EMPTY_TEXT_REGEX = /[\n\r]\s*$/;
+const EMPTY_TEXT_REGEX = /^[\t\v\f \u00A0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]*[\n\r]\s*$/;
+const START_EMPTY_TEXT_REGEX = /^\s*[\n\r]/;
+const END_EMPTY_TEXT_REGEX = /[\n\r]\s*$/;
 function resolveJSXText(node) {
-  if (EMPTY_TEXT_REGEX.test(String(node.extra?.raw))) {
-    return "";
-  }
-  let value = node.value;
-  if (START_EMPTY_TEXT_REGEX.test(value)) {
-    value = value.trimStart();
-  }
-  if (END_EMPTY_TEXT_REGEX.test(value)) {
-    value = value.trimEnd();
-  }
-  return value;
+	if (EMPTY_TEXT_REGEX.test(String(node.extra?.raw))) return "";
+	let value = node.value;
+	if (START_EMPTY_TEXT_REGEX.test(value)) value = value.trimStart();
+	if (END_EMPTY_TEXT_REGEX.test(value)) value = value.trimEnd();
+	return value;
 }
 function isEmptyText(node) {
-  return node.type === "JSXText" && EMPTY_TEXT_REGEX.test(String(node.extra?.raw)) || node.type === "JSXExpressionContainer" && node.expression.type === "JSXEmptyExpression";
+	return node.type === "JSXText" && EMPTY_TEXT_REGEX.test(String(node.extra?.raw)) || node.type === "JSXExpressionContainer" && node.expression.type === "JSXEmptyExpression";
 }
 function resolveSimpleExpressionNode(exp) {
-  if (!exp.isStatic) {
-    const value = getLiteralExpressionValue(exp);
-    if (value !== null) {
-      return createSimpleExpression(String(value), true, exp.loc);
-    }
-  }
-  return exp;
+	if (!exp.isStatic) {
+		const value = getLiteralExpressionValue(exp);
+		if (value !== null) return createSimpleExpression(String(value), true, exp.loc);
+	}
+	return exp;
 }
+const resolvedExpressions = new WeakSet();
 function resolveExpression(node, context, effect = false) {
-  node = node?.type === "JSXExpressionContainer" ? node.expression : node;
-  const isStatic = !!node && (node.type === "StringLiteral" || node.type === "JSXText" || node.type === "JSXIdentifier");
-  let source = !node || node.type === "JSXEmptyExpression" ? "" : node.type === "JSXIdentifier" ? node.name : node.type === "StringLiteral" ? node.value : node.type === "JSXText" ? resolveJSXText(node) : node.type === "Identifier" ? node.name : context.ir.source.slice(node.start, node.end);
-  const location = node ? node.loc : null;
-  if (source && !isStatic && effect && !isConstant(node)) {
-    source = `() => (${source})`;
-    if (location && node) {
-      location.start.column -= 7;
-      node.start -= 7;
-    }
-  }
-  if (node) {
-    const offset = node.start - 1;
-    walkIdentifiers(
-      node,
-      (id) => {
-        if (!id.loc) return;
-        id.start = id.loc.start.index - offset;
-        id.end = id.loc.end.index - offset;
-      },
-      true
-    );
-  }
-  return resolveSimpleExpression(source, isStatic, location, node);
+	node = node?.type === "JSXExpressionContainer" ? node.expression : node;
+	const isStatic = !!node && (node.type === "StringLiteral" || node.type === "JSXText" || node.type === "JSXIdentifier");
+	let source = !node || node.type === "JSXEmptyExpression" ? "" : node.type === "JSXIdentifier" ? node.name : node.type === "StringLiteral" ? node.value : node.type === "JSXText" ? resolveJSXText(node) : node.type === "Identifier" ? node.name : context.ir.source.slice(node.start, node.end);
+	const location = node ? node.loc : null;
+	const isResolved = node && resolvedExpressions.has(node);
+	if (source && !isStatic && effect && !isConstant(node)) {
+		source = `() => (${source})`;
+		if (location && node && !isResolved) {
+			location.start.column -= 7;
+			node.start -= 7;
+		}
+	}
+	if (node && !isResolved) {
+		const offset = node.start - 1;
+		walkIdentifiers(node, (id) => {
+			if (!id.loc) return;
+			id.start = id.loc.start.index - offset;
+			id.end = id.loc.end.index - offset;
+		}, true);
+		resolvedExpressions.add(node);
+	}
+	return resolveSimpleExpression(source, isStatic, location, node);
 }
 function resolveSimpleExpression(source, isStatic, location, ast) {
-  const result = createSimpleExpression(
-    source,
-    isStatic,
-    resolveLocation(location, source)
-  );
-  result.ast = ast ?? null;
-  return result;
+	const result = createSimpleExpression(source, isStatic, resolveLocation(location, source));
+	result.ast = ast ?? null;
+	return result;
 }
 function resolveLocation(location, context) {
-  return location ? {
-    start: {
-      line: location.start.line,
-      column: location.start.column + 1,
-      offset: location.start.index
-    },
-    end: {
-      line: location.end.line,
-      column: location.end.column + 1,
-      offset: location.end.index
-    },
-    source: isString(context) ? context : context.ir.source.slice(location.start.index, location.end.index)
-  } : {
-    start: { line: 1, column: 1, offset: 0 },
-    end: { line: 1, column: 1, offset: 0 },
-    source: ""
-  };
+	return location ? {
+		start: {
+			line: location.start.line,
+			column: location.start.column + 1,
+			offset: location.start.index
+		},
+		end: {
+			line: location.end.line,
+			column: location.end.column + 1,
+			offset: location.end.index
+		},
+		source: isString(context) ? context : context.ir.source.slice(location.start.index, location.end.index)
+	} : {
+		start: {
+			line: 1,
+			column: 1,
+			offset: 0
+		},
+		end: {
+			line: 1,
+			column: 1,
+			offset: 0
+		},
+		source: ""
+	};
 }
-function resolveValue(value, context) {
-  return value ? {
-    type: NodeTypes.TEXT,
-    content: value.type === "StringLiteral" ? value.value : value.type === "JSXExpressionContainer" ? context.ir.source.slice(
-      value.expression.start,
-      value.expression.end
-    ) : "",
-    loc: resolveLocation(value.loc, context)
-  } : void 0;
-}
-function resolveNode(node, context) {
-  const tag = node.openingElement.name.type === "JSXIdentifier" ? node.openingElement.name.name : "";
-  const loc = resolveLocation(node.loc, context);
-  const tagType = isJSXComponent(node) ? ElementTypes.COMPONENT : ElementTypes.ELEMENT;
-  const props = node.openingElement.attributes.reduce(
-    (result, attr) => {
-      if (attr.type === "JSXAttribute") {
-        result.push(
-          attr.value?.type === "StringLiteral" ? {
-            type: NodeTypes.ATTRIBUTE,
-            name: String(attr.name.name),
-            nameLoc: resolveLocation(attr.name.loc, context),
-            value: resolveValue(attr.value, context),
-            loc: resolveLocation(attr.loc, context)
-          } : resolveDirectiveNode(attr, context)
-        );
-      } else if (attr.type === "JSXSpreadAttribute") {
-        result.push({
-          type: NodeTypes.DIRECTIVE,
-          name: "bind",
-          rawName: getText(attr, context),
-          exp: resolveExpression(attr.argument, context),
-          arg: void 0,
-          loc: resolveLocation(node.loc, context),
-          modifiers: []
-        });
-      }
-      return result;
-    },
-    []
-  );
-  return {
-    type: NodeTypes.ELEMENT,
-    props,
-    children: node.children,
-    tag,
-    loc,
-    ns: Namespaces.HTML,
-    tagType,
-    isSelfClosing: !!node.selfClosing,
-    codegenNode: void 0
-  };
-}
-var namespaceRE = /^(?:\$([\w-]+)\$)?([\w-]+)?/;
-function resolveDirectiveNode(node, context, withFn = false) {
-  const { value, name } = node;
-  let nameString = name.type === "JSXNamespacedName" ? name.namespace.name : name.type === "JSXIdentifier" ? name.name : "";
-  const isDirective = nameString.startsWith("v-");
-  let modifiers = [];
-  let isStatic = true;
-  let argString = name.type === "JSXNamespacedName" ? name.name.name : "";
-  if (name.type !== "JSXNamespacedName" && !argString) {
-    ;
-    [nameString, ...modifiers] = nameString.split("_");
-  } else {
-    const result = argString.match(namespaceRE);
-    if (result) {
-      let modifierString = "";
-      [, argString, modifierString] = result;
-      if (argString) {
-        argString = argString.replaceAll("_", ".");
-        isStatic = false;
-        if (modifierString && modifierString.startsWith("_"))
-          modifiers = modifierString.slice(1).split("_");
-      } else if (modifierString) {
-        ;
-        [argString, ...modifiers] = modifierString.split("_");
-      }
-    }
-  }
-  const arg = isDirective ? argString && name.type === "JSXNamespacedName" ? resolveSimpleExpression(argString, isStatic, name.name.loc) : void 0 : resolveSimpleExpression(nameString, true, name.loc);
-  const exp = value ? withFn && value.type === "JSXExpressionContainer" ? resolveExpressionWithFn(value.expression, context) : resolveExpression(value, context) : void 0;
-  return {
-    type: NodeTypes.DIRECTIVE,
-    name: isDirective ? nameString.slice(2) : "bind",
-    rawName: getText(name, context),
-    exp,
-    arg,
-    loc: resolveLocation(node.loc, context),
-    modifiers: modifiers.map((modifier) => createSimpleExpression(modifier))
-  };
+const namespaceRE = /^(?:\$([\w-]+)\$)?([\w-]+)?/;
+function resolveDirective(node, context, withFn = false) {
+	const { value, name } = node;
+	let nameString = name.type === "JSXNamespacedName" ? name.namespace.name : name.type === "JSXIdentifier" ? name.name : "";
+	const isDirective = nameString.startsWith("v-");
+	let modifiers = [];
+	let isStatic = true;
+	let argString = name.type === "JSXNamespacedName" ? name.name.name : "";
+	if (name.type !== "JSXNamespacedName" && !argString) [nameString, ...modifiers] = nameString.split("_");
+	else {
+		const result = argString.match(namespaceRE);
+		if (result) {
+			let modifierString = "";
+			[, argString, modifierString] = result;
+			if (argString) {
+				argString = argString.replaceAll("_", ".");
+				isStatic = false;
+				if (modifierString && modifierString.startsWith("_")) modifiers = modifierString.slice(1).split("_");
+			} else if (modifierString) [argString, ...modifiers] = modifierString.split("_");
+		}
+	}
+	const arg = isDirective ? argString && name.type === "JSXNamespacedName" ? resolveSimpleExpression(argString, isStatic, name.name.loc) : void 0 : resolveSimpleExpression(nameString, true, name.loc);
+	const exp = value ? withFn && value.type === "JSXExpressionContainer" ? resolveExpressionWithFn(value.expression, context) : resolveExpression(value, context) : void 0;
+	return {
+		type: NodeTypes.DIRECTIVE,
+		name: isDirective ? nameString.slice(2) : "bind",
+		rawName: getText(name, context),
+		exp,
+		arg,
+		loc: resolveLocation(node.loc, context),
+		modifiers: modifiers.map((modifier) => createSimpleExpression(modifier))
+	};
 }
 function resolveExpressionWithFn(node, context) {
-  const text = getText(node, context);
-  return node.type === "Identifier" ? resolveSimpleExpression(text, false, node.loc) : resolveSimpleExpression(
-    text,
-    false,
-    node.loc,
-    parseExpression(`(${text})=>{}`, {
-      plugins: ["typescript"]
-    })
-  );
+	const text = getText(node, context);
+	return node.type === "Identifier" ? resolveSimpleExpression(text, false, node.loc) : resolveSimpleExpression(text, false, node.loc, parseExpression(`(${text})=>{}`, { plugins: ["typescript"] }));
 }
 function isJSXComponent(node) {
-  if (node.type !== "JSXElement") return false;
-  const { openingElement } = node;
-  if (openingElement.name.type === "JSXIdentifier") {
-    const name = openingElement.name.name;
-    return !isHTMLTag(name) && !isSVGTag(name);
-  } else {
-    return openingElement.name.type === "JSXMemberExpression";
-  }
+	if (node.type !== "JSXElement") return false;
+	const { openingElement } = node;
+	if (openingElement.name.type === "JSXIdentifier") {
+		const name = openingElement.name.name;
+		return !isHTMLTag(name) && !isSVGTag(name);
+	} else return openingElement.name.type === "JSXMemberExpression";
 }
 function findProp(expression, key) {
-  if (expression?.type === "JSXElement") {
-    for (const attr of expression.openingElement.attributes) {
-      const name = attr.type === "JSXAttribute" && (attr.name.type === "JSXIdentifier" ? attr.name.name : attr.name.type === "JSXNamespacedName" ? attr.name.namespace.name : "").split("_")[0];
-      if (name && (isString(key) ? name === key : key.test(name))) {
-        return attr;
-      }
-    }
-  }
+	if (expression?.type === "JSXElement") for (const attr of expression.openingElement.attributes) {
+		const name = attr.type === "JSXAttribute" && (attr.name.type === "JSXIdentifier" ? attr.name.name : attr.name.type === "JSXNamespacedName" ? attr.name.namespace.name : "").split("_")[0];
+		if (name && (isString(key) ? name === key : key.test(name))) return attr;
+	}
 }
 function getText(node, content) {
-  return content.ir.source.slice(node.start, node.end);
+	return content.ir.source.slice(node.start, node.end);
 }
 function isTemplate(node) {
-  if (node.type === "JSXElement" && node.openingElement.name.type === "JSXIdentifier") {
-    return node.openingElement.name.name === "template";
-  }
+	if (node.type === "JSXElement" && node.openingElement.name.type === "JSXIdentifier") return node.openingElement.name.name === "template";
 }
 
-// src/transforms/utils.ts
+//#endregion
+//#region src/transforms/utils.ts
 function newDynamic() {
-  return {
-    flags: 1 /* REFERENCED */,
-    children: []
-  };
+	return {
+		flags: DynamicFlag.REFERENCED,
+		children: []
+	};
 }
 function newBlock(node) {
-  return {
-    type: 1,
-    node,
-    dynamic: newDynamic(),
-    effect: [],
-    operation: [],
-    returns: [],
-    expressions: [],
-    tempId: 0
-  };
+	return {
+		type: 1,
+		node,
+		dynamic: newDynamic(),
+		effect: [],
+		operation: [],
+		returns: [],
+		expressions: [],
+		tempId: 0
+	};
 }
 function createBranch(node, context, isVFor) {
-  context.node = node = wrapFragment(node);
-  const branch = newBlock(node);
-  const exitBlock = context.enterBlock(branch, isVFor);
-  context.reference();
-  return [branch, exitBlock];
+	context.node = node = wrapFragment(node);
+	const branch = newBlock(node);
+	const exitBlock = context.enterBlock(branch, isVFor);
+	context.reference();
+	return [branch, exitBlock];
 }
 function wrapFragment(node) {
-  if (node.type === "JSXFragment" || isTemplate(node)) {
-    return node;
-  }
-  return jsxFragment(jsxOpeningFragment(), jsxClosingFragment(), [
-    node.type === "JSXElement" ? node : jsxExpressionContainer(node)
-  ]);
+	if (node.type === "JSXFragment" || isTemplate(node)) return node;
+	return jsxFragment(jsxOpeningFragment(), jsxClosingFragment(), [node.type === "JSXElement" ? node : jsxExpressionContainer(node)]);
 }
-var EMPTY_EXPRESSION = createSimpleExpression2("", true);
-var isFragmentNode = (node) => node.type === 0 /* ROOT */ || node.type === "JSXFragment" || node.type === "JSXElement" && !!isTemplate(node);
+const EMPTY_EXPRESSION = createSimpleExpression("", true);
+const isFragmentNode = (node) => node.type === IRNodeTypes.ROOT || node.type === "JSXFragment" || node.type === "JSXElement" && !!isTemplate(node);
 
-// src/transform.ts
-var defaultOptions = {
-  filename: "",
-  prefixIdentifiers: false,
-  hoistStatic: false,
-  hmr: false,
-  cacheHandlers: false,
-  nodeTransforms: [],
-  directiveTransforms: {},
-  transformHoist: null,
-  isBuiltInComponent: NOOP,
-  isCustomElement: NOOP,
-  expressionPlugins: [],
-  scopeId: null,
-  slotted: true,
-  ssr: false,
-  inSSR: false,
-  ssrCssVars: ``,
-  bindingMetadata: EMPTY_OBJ,
-  inline: false,
-  isTS: false,
-  onError: defaultOnError,
-  onWarn: defaultOnWarn
+//#endregion
+//#region src/transform.ts
+const defaultOptions = {
+	filename: "",
+	prefixIdentifiers: false,
+	hoistStatic: false,
+	hmr: false,
+	cacheHandlers: false,
+	nodeTransforms: [],
+	directiveTransforms: {},
+	transformHoist: null,
+	isBuiltInComponent: NOOP,
+	isCustomElement: NOOP,
+	expressionPlugins: [],
+	scopeId: null,
+	slotted: true,
+	ssr: false,
+	inSSR: false,
+	ssrCssVars: ``,
+	bindingMetadata: EMPTY_OBJ,
+	inline: false,
+	isTS: false,
+	onError: defaultOnError,
+	onWarn: defaultOnWarn
 };
-var TransformContext = class _TransformContext {
-  constructor(ir, node, options = {}) {
-    this.ir = ir;
-    this.node = node;
-    this.parent = null;
-    this.index = 0;
-    this.block = this.ir.block;
-    this.template = "";
-    this.childrenTemplate = [];
-    this.dynamic = this.ir.block.dynamic;
-    this.inVOnce = false;
-    this.inVFor = 0;
-    this.comment = [];
-    this.component = this.ir.component;
-    this.directive = this.ir.directive;
-    this.slots = [];
-    this.globalId = 0;
-    this.increaseId = () => this.globalId++;
-    this.options = extend({}, defaultOptions, options);
-    this.root = this;
-  }
-  enterBlock(ir, isVFor = false) {
-    const { block, template, dynamic, childrenTemplate, slots } = this;
-    this.block = ir;
-    this.dynamic = ir.dynamic;
-    this.template = "";
-    this.childrenTemplate = [];
-    this.slots = [];
-    isVFor && this.inVFor++;
-    return () => {
-      this.registerTemplate();
-      this.block = block;
-      this.template = template;
-      this.dynamic = dynamic;
-      this.childrenTemplate = childrenTemplate;
-      this.slots = slots;
-      isVFor && this.inVFor--;
-    };
-  }
-  reference() {
-    if (this.dynamic.id !== void 0) return this.dynamic.id;
-    this.dynamic.flags |= 1 /* REFERENCED */;
-    return this.dynamic.id = this.increaseId();
-  }
-  pushTemplate(content) {
-    const existing = this.ir.template.indexOf(content);
-    if (existing !== -1) return existing;
-    this.ir.template.push(content);
-    return this.ir.template.length - 1;
-  }
-  registerTemplate() {
-    if (!this.template) return -1;
-    const id = this.pushTemplate(this.template);
-    return this.dynamic.template = id;
-  }
-  registerEffect(expressions, ...operations) {
-    expressions = expressions.filter((exp) => !isConstantExpression(exp));
-    if (this.inVOnce || expressions.length === 0) {
-      return this.registerOperation(...operations);
-    }
-    const existing = this.block.effect.find(
-      (e) => isSameExpression(e.expressions, expressions)
-    );
-    if (existing) {
-      existing.operations.push(...operations);
-    } else {
-      this.block.effect.push({
-        expressions,
-        operations
-      });
-    }
-    function isSameExpression(a, b) {
-      if (a.length !== b.length) return false;
-      return a.every((exp, i) => exp.content === b[i].content);
-    }
-  }
-  registerOperation(...node) {
-    this.block.operation.push(...node);
-  }
-  create(node, index) {
-    return Object.assign(Object.create(_TransformContext.prototype), this, {
-      node,
-      parent: this,
-      index,
-      template: "",
-      childrenTemplate: [],
-      dynamic: newDynamic()
-    });
-  }
+var TransformContext = class TransformContext {
+	parent = null;
+	root;
+	index = 0;
+	block;
+	options;
+	template = "";
+	childrenTemplate = [];
+	dynamic;
+	inVOnce = false;
+	inVFor = 0;
+	comment = [];
+	component;
+	directive;
+	slots = [];
+	globalId = 0;
+	constructor(ir, node, options = {}) {
+		this.ir = ir;
+		this.node = node;
+		this.options = extend({}, defaultOptions, options);
+		this.block = this.ir.block;
+		this.dynamic = this.ir.block.dynamic;
+		this.component = this.ir.component;
+		this.directive = this.ir.directive;
+		this.root = this;
+	}
+	enterBlock(ir, isVFor = false) {
+		const { block, template, dynamic, childrenTemplate, slots } = this;
+		this.block = ir;
+		this.dynamic = ir.dynamic;
+		this.template = "";
+		this.childrenTemplate = [];
+		this.slots = [];
+		isVFor && this.inVFor++;
+		return () => {
+			this.registerTemplate();
+			this.block = block;
+			this.template = template;
+			this.dynamic = dynamic;
+			this.childrenTemplate = childrenTemplate;
+			this.slots = slots;
+			isVFor && this.inVFor--;
+		};
+	}
+	increaseId = () => this.globalId++;
+	reference() {
+		if (this.dynamic.id !== void 0) return this.dynamic.id;
+		this.dynamic.flags |= DynamicFlag.REFERENCED;
+		return this.dynamic.id = this.increaseId();
+	}
+	pushTemplate(content) {
+		const existing = this.ir.template.indexOf(content);
+		if (existing !== -1) return existing;
+		this.ir.template.push(content);
+		return this.ir.template.length - 1;
+	}
+	registerTemplate() {
+		if (!this.template) return -1;
+		const id = this.pushTemplate(this.template);
+		return this.dynamic.template = id;
+	}
+	registerEffect(expressions, ...operations) {
+		expressions = expressions.filter((exp) => !isConstantExpression(exp));
+		if (this.inVOnce || expressions.length === 0 || expressions.every((e) => e.ast && isConstantNode(e.ast, {}))) return this.registerOperation(...operations);
+		this.block.expressions.push(...expressions);
+		const existing = this.block.effect.find((e) => isSameExpression(e.expressions, expressions));
+		if (existing) existing.operations.push(...operations);
+		else this.block.effect.push({
+			expressions,
+			operations
+		});
+		function isSameExpression(a, b) {
+			if (a.length !== b.length) return false;
+			return a.every((exp, i) => exp.content === b[i].content);
+		}
+	}
+	registerOperation(...node) {
+		this.block.operation.push(...node);
+	}
+	create(node, index) {
+		return Object.assign(Object.create(TransformContext.prototype), this, {
+			node,
+			parent: this,
+			index,
+			template: "",
+			childrenTemplate: [],
+			dynamic: newDynamic()
+		});
+	}
 };
 function transform(node, options = {}) {
-  const ir = {
-    type: 0 /* ROOT */,
-    node,
-    source: node.source,
-    template: [],
-    component: /* @__PURE__ */ new Set(),
-    directive: /* @__PURE__ */ new Set(),
-    block: newBlock(node),
-    hasTemplateRef: false
-  };
-  const context = new TransformContext(ir, node, options);
-  transformNode(context);
-  return ir;
+	const ir = {
+		type: IRNodeTypes.ROOT,
+		node,
+		source: node.source,
+		template: [],
+		component: new Set(),
+		directive: new Set(),
+		block: newBlock(node),
+		hasTemplateRef: false
+	};
+	const context = new TransformContext(ir, node, options);
+	transformNode(context);
+	return ir;
 }
 function transformNode(context) {
-  let { node } = context;
-  const { nodeTransforms } = context.options;
-  const exitFns = [];
-  for (const nodeTransform of nodeTransforms) {
-    const onExit = nodeTransform(node, context);
-    if (onExit) {
-      if (isArray(onExit)) {
-        exitFns.push(...onExit);
-      } else {
-        exitFns.push(onExit);
-      }
-    }
-    if (!context.node) {
-      return;
-    } else {
-      node = context.node;
-    }
-  }
-  context.node = node;
-  let i = exitFns.length;
-  while (i--) {
-    exitFns[i]();
-  }
-  if (context.node.type === 0 /* ROOT */) {
-    context.registerTemplate();
-  }
+	let { node } = context;
+	const { nodeTransforms } = context.options;
+	const exitFns = [];
+	for (const nodeTransform of nodeTransforms) {
+		const onExit = nodeTransform(node, context);
+		if (onExit) if (isArray(onExit)) exitFns.push(...onExit);
+		else exitFns.push(onExit);
+		if (!context.node) return;
+		else node = context.node;
+	}
+	context.node = node;
+	let i = exitFns.length;
+	while (i--) exitFns[i]();
+	if (context.node.type === IRNodeTypes.ROOT) context.registerTemplate();
 }
 function createStructuralDirectiveTransform(name, fn) {
-  const matches = (n) => isString2(name) ? n === name : name.includes(n);
-  return (node, context) => {
-    if (node.type === "JSXElement") {
-      const {
-        openingElement: { attributes }
-      } = node;
-      if (isTemplate(node) && findProp(node, "v-slot")) {
-        return;
-      }
-      const exitFns = [];
-      for (const prop of attributes) {
-        if (prop.type !== "JSXAttribute") continue;
-        const propName = getText(prop.name, context);
-        if (propName.startsWith("v-") && matches(propName.slice(2))) {
-          attributes.splice(attributes.indexOf(prop), 1);
-          const onExit = fn(node, prop, context);
-          if (onExit) exitFns.push(onExit);
-          break;
-        }
-      }
-      return exitFns;
-    }
-  };
+	const matches = (n) => isString(name) ? n === name : name.includes(n);
+	return (node, context) => {
+		if (node.type === "JSXElement") {
+			const { openingElement: { attributes } } = node;
+			if (isTemplate(node) && findProp(node, "v-slot")) return;
+			const exitFns = [];
+			for (const prop of attributes) {
+				if (prop.type !== "JSXAttribute") continue;
+				const propName = getText(prop.name, context);
+				if (propName.startsWith("v-") && matches(propName.slice(2))) {
+					attributes.splice(attributes.indexOf(prop), 1);
+					const onExit = fn(node, prop, context);
+					if (onExit) exitFns.push(onExit);
+					break;
+				}
+			}
+			return exitFns;
+		}
+	};
 }
 
-// src/transforms/transformChildren.ts
-var transformChildren = (node, context) => {
-  const isFragment = node.type === 0 /* ROOT */ || node.type === "JSXFragment" || node.type === "JSXElement" && (isTemplate(node) || isJSXComponent(node));
-  if (node.type !== "JSXElement" && !isFragment) return;
-  for (const [i, child] of node.children.entries()) {
-    const childContext = context.create(child, i);
-    transformNode(childContext);
-    const childDynamic = childContext.dynamic;
-    if (isFragment) {
-      childContext.reference();
-      childContext.registerTemplate();
-      if (!(childDynamic.flags & 2 /* NON_TEMPLATE */) || childDynamic.flags & 4 /* INSERT */) {
-        context.block.returns.push(childDynamic.id);
-      }
-    } else {
-      context.childrenTemplate.push(childContext.template);
-    }
-    if (childDynamic.hasDynamicChild || childDynamic.id !== void 0 || childDynamic.flags & 2 /* NON_TEMPLATE */ || childDynamic.flags & 4 /* INSERT */) {
-      context.dynamic.hasDynamicChild = true;
-    }
-    context.dynamic.children[i] = childContext.dynamic;
-  }
-  if (!isFragment) {
-    processDynamicChildren(context);
-  }
+//#endregion
+//#region src/transforms/transformChildren.ts
+const transformChildren = (node, context) => {
+	const isFragment = node.type === IRNodeTypes.ROOT || node.type === "JSXFragment" || node.type === "JSXElement" && (isTemplate(node) || isJSXComponent(node));
+	if (node.type !== "JSXElement" && !isFragment) return;
+	for (const [i, child] of node.children.entries()) {
+		const childContext = context.create(child, i);
+		transformNode(childContext);
+		const childDynamic = childContext.dynamic;
+		if (isFragment) {
+			childContext.reference();
+			childContext.registerTemplate();
+			if (!(childDynamic.flags & DynamicFlag.NON_TEMPLATE) || childDynamic.flags & DynamicFlag.INSERT) context.block.returns.push(childDynamic.id);
+		} else context.childrenTemplate.push(childContext.template);
+		if (childDynamic.hasDynamicChild || childDynamic.id !== void 0 || childDynamic.flags & DynamicFlag.NON_TEMPLATE || childDynamic.flags & DynamicFlag.INSERT) context.dynamic.hasDynamicChild = true;
+		context.dynamic.children[i] = childContext.dynamic;
+	}
+	if (!isFragment) processDynamicChildren(context);
 };
 function processDynamicChildren(context) {
-  let prevDynamics = [];
-  let hasStaticTemplate = false;
-  const children = context.dynamic.children;
-  for (const [index, child] of children.entries()) {
-    if (child.flags & 4 /* INSERT */) {
-      prevDynamics.push(child);
-    }
-    if (!(child.flags & 2 /* NON_TEMPLATE */)) {
-      if (prevDynamics.length) {
-        if (hasStaticTemplate) {
-          context.childrenTemplate[index - prevDynamics.length] = `<!>`;
-          prevDynamics[0].flags -= 2 /* NON_TEMPLATE */;
-          const anchor = prevDynamics[0].anchor = context.increaseId();
-          registerInsertion(prevDynamics, context, anchor);
-        } else {
-          registerInsertion(
-            prevDynamics,
-            context,
-            -1
-            /* prepend */
-          );
-        }
-        prevDynamics = [];
-      }
-      hasStaticTemplate = true;
-    }
-  }
-  if (prevDynamics.length) {
-    registerInsertion(prevDynamics, context);
-  }
+	let prevDynamics = [];
+	let hasStaticTemplate = false;
+	const children = context.dynamic.children;
+	for (const [index, child] of children.entries()) {
+		if (child.flags & DynamicFlag.INSERT) prevDynamics.push(child);
+		if (!(child.flags & DynamicFlag.NON_TEMPLATE)) {
+			if (prevDynamics.length) {
+				if (hasStaticTemplate) {
+					context.childrenTemplate[index - prevDynamics.length] = `<!>`;
+					prevDynamics[0].flags -= DynamicFlag.NON_TEMPLATE;
+					const anchor = prevDynamics[0].anchor = context.increaseId();
+					registerInsertion(prevDynamics, context, anchor);
+				} else registerInsertion(
+					prevDynamics,
+					context,
+					-1
+					/* prepend */
+);
+				prevDynamics = [];
+			}
+			hasStaticTemplate = true;
+		}
+	}
+	if (prevDynamics.length) registerInsertion(prevDynamics, context);
 }
 function registerInsertion(dynamics, context, anchor) {
-  for (const child of dynamics) {
-    if (child.template != null) {
-      context.registerOperation({
-        type: 9 /* INSERT_NODE */,
-        elements: dynamics.map((child2) => child2.id),
-        parent: context.reference(),
-        anchor
-      });
-    } else if (child.operation && isBlockOperation(child.operation)) {
-      child.operation.parent = context.reference();
-      child.operation.anchor = anchor;
-    }
-  }
+	for (const child of dynamics) if (child.template != null) context.registerOperation({
+		type: IRNodeTypes.INSERT_NODE,
+		elements: dynamics.map((child$1) => child$1.id),
+		parent: context.reference(),
+		anchor
+	});
+	else if (child.operation && isBlockOperation(child.operation)) {
+		child.operation.parent = context.reference();
+		child.operation.anchor = anchor;
+	}
 }
 
-// src/transforms/transformElement.ts
-import {
-  isValidHTMLNesting
-} from "@vue/compiler-dom";
-import { extend as extend2, isBuiltInDirective, isVoidTag, makeMap } from "@vue/shared";
-var isReservedProp = /* @__PURE__ */ makeMap(
-  // the leading comma is intentional so empty string "" is also included
-  ",key,ref,ref_for,ref_key,"
+//#endregion
+//#region src/transforms/transformElement.ts
+const isReservedProp = /* @__PURE__ */ makeMap(
+	// the leading comma is intentional so empty string "" is also included
+	",key,ref,ref_for,ref_key,"
 );
-var isEventRegex = /^on[A-Z]/;
-var isDirectiveRegex = /^v-[a-z]/;
-var transformElement = (node, context) => {
-  return function postTransformElement() {
-    ;
-    ({ node } = context);
-    if (node.type !== "JSXElement" || isTemplate(node)) return;
-    const {
-      openingElement: { name }
-    } = node;
-    const tag = name.type === "JSXIdentifier" ? name.name : name.type === "JSXMemberExpression" ? context.ir.source.slice(name.start, name.end) : "";
-    const isComponent = isJSXComponent(node);
-    const propsResult = buildProps(
-      node,
-      context,
-      isComponent
-    );
-    let { parent } = context;
-    while (parent && parent.parent && parent.node.type === "JSXElement" && isTemplate(parent.node)) {
-      parent = parent.parent;
-    }
-    const singleRoot = context.root === parent && parent.node.children.filter((child) => !isJSXComponent(child)).length === 1;
-    (isComponent ? transformComponentElement : transformNativeElement)(
-      tag,
-      propsResult,
-      singleRoot,
-      context
-    );
-  };
+const isEventRegex = /^on[A-Z]/;
+const isDirectiveRegex = /^v-[a-z]/;
+const transformElement = (node, context) => {
+	return function postTransformElement() {
+		({node} = context);
+		if (node.type !== "JSXElement" || isTemplate(node)) return;
+		const { openingElement: { name } } = node;
+		const tag = name.type === "JSXIdentifier" ? name.name : name.type === "JSXMemberExpression" ? context.ir.source.slice(name.start, name.end) : "";
+		const isComponent = isJSXComponent(node);
+		const propsResult = buildProps(node, context, isComponent);
+		let { parent } = context;
+		while (parent && parent.parent && parent.node.type === "JSXElement" && isTemplate(parent.node)) parent = parent.parent;
+		const singleRoot = context.root === parent && parent.node.children.filter((child) => !isJSXComponent(child)).length === 1;
+		(isComponent ? transformComponentElement : transformNativeElement)(tag, propsResult, singleRoot, context);
+	};
 };
 function transformComponentElement(tag, propsResult, singleRoot, context) {
-  let asset = true;
-  const fromSetup = tag;
-  if (fromSetup) {
-    tag = fromSetup;
-    asset = false;
-  }
-  const dotIndex = tag.indexOf(".");
-  if (dotIndex > 0) {
-    const ns = tag.slice(0, dotIndex);
-    if (ns) {
-      tag = ns + tag.slice(dotIndex);
-      asset = false;
-    }
-  }
-  if (asset) {
-    context.component.add(tag);
-  }
-  context.dynamic.flags |= 2 /* NON_TEMPLATE */ | 4 /* INSERT */;
-  context.dynamic.operation = {
-    type: 11 /* CREATE_COMPONENT_NODE */,
-    id: context.reference(),
-    tag,
-    props: propsResult[0] ? propsResult[1] : [propsResult[1]],
-    asset,
-    root: singleRoot,
-    slots: [...context.slots],
-    once: context.inVOnce
-  };
-  context.slots = [];
+	let asset = true;
+	const fromSetup = tag;
+	if (fromSetup) {
+		tag = fromSetup;
+		asset = false;
+	}
+	const dotIndex = tag.indexOf(".");
+	if (dotIndex > 0) {
+		const ns = tag.slice(0, dotIndex);
+		if (ns) {
+			tag = ns + tag.slice(dotIndex);
+			asset = false;
+		}
+	}
+	if (asset) context.component.add(tag);
+	context.dynamic.flags |= DynamicFlag.NON_TEMPLATE | DynamicFlag.INSERT;
+	context.dynamic.operation = {
+		type: IRNodeTypes.CREATE_COMPONENT_NODE,
+		id: context.reference(),
+		tag,
+		props: propsResult[0] ? propsResult[1] : [propsResult[1]],
+		asset,
+		root: singleRoot,
+		slots: [...context.slots],
+		once: context.inVOnce
+	};
+	context.slots = [];
 }
 function transformNativeElement(tag, propsResult, singleRoot, context) {
-  const { scopeId } = context.options;
-  let template = "";
-  template += `<${tag}`;
-  if (scopeId) template += ` ${scopeId}`;
-  const dynamicProps = [];
-  if (propsResult[0]) {
-    const [, dynamicArgs, expressions] = propsResult;
-    context.registerEffect(expressions, {
-      type: 3 /* SET_DYNAMIC_PROPS */,
-      element: context.reference(),
-      props: dynamicArgs,
-      root: singleRoot
-    });
-  } else {
-    for (const prop of propsResult[1]) {
-      const { key, values } = prop;
-      if (key.isStatic && values.length === 1 && values[0].isStatic) {
-        template += ` ${key.content}`;
-        if (values[0].content) template += `="${values[0].content}"`;
-      } else {
-        dynamicProps.push(key.content);
-        context.registerEffect(values, {
-          type: 2 /* SET_PROP */,
-          element: context.reference(),
-          prop,
-          tag,
-          root: singleRoot
-        });
-      }
-    }
-  }
-  template += `>${context.childrenTemplate.join("")}`;
-  if (!isVoidTag(tag)) {
-    template += `</${tag}>`;
-  }
-  if (singleRoot) {
-    context.ir.rootTemplateIndex = context.ir.template.length;
-  }
-  if (context.parent && context.parent.node.type === "JSXElement" && context.parent.node.openingElement.name.type === "JSXIdentifier" && !isValidHTMLNesting(context.parent.node.openingElement.name.name, tag)) {
-    context.reference();
-    context.dynamic.template = context.pushTemplate(template);
-    context.dynamic.flags |= 4 /* INSERT */ | 2 /* NON_TEMPLATE */;
-  } else {
-    context.template += template;
-  }
+	const { scopeId } = context.options;
+	let template = "";
+	template += `<${tag}`;
+	if (scopeId) template += ` ${scopeId}`;
+	const dynamicProps = [];
+	if (propsResult[0]) {
+		const [, dynamicArgs, expressions] = propsResult;
+		context.registerEffect(expressions, {
+			type: IRNodeTypes.SET_DYNAMIC_PROPS,
+			element: context.reference(),
+			props: dynamicArgs,
+			root: singleRoot
+		});
+	} else for (const prop of propsResult[1]) {
+		const { key, values } = prop;
+		if (key.isStatic && values.length === 1 && values[0].isStatic) {
+			template += ` ${key.content}`;
+			if (values[0].content) template += `="${values[0].content}"`;
+		} else {
+			dynamicProps.push(key.content);
+			context.registerEffect(values, {
+				type: IRNodeTypes.SET_PROP,
+				element: context.reference(),
+				prop,
+				tag,
+				root: singleRoot
+			});
+		}
+	}
+	template += `>${context.childrenTemplate.join("")}`;
+	if (!isVoidTag(tag)) template += `</${tag}>`;
+	if (singleRoot) context.ir.rootTemplateIndex = context.ir.template.length;
+	if (context.parent && context.parent.node.type === "JSXElement" && context.parent.node.openingElement.name.type === "JSXIdentifier" && !isValidHTMLNesting(context.parent.node.openingElement.name.name, tag)) {
+		context.reference();
+		context.dynamic.template = context.pushTemplate(template);
+		context.dynamic.flags |= DynamicFlag.INSERT | DynamicFlag.NON_TEMPLATE;
+	} else context.template += template;
 }
 function buildProps(node, context, isComponent) {
-  const props = node.openingElement.attributes;
-  if (props.length === 0) return [false, []];
-  const dynamicArgs = [];
-  const dynamicExpr = [];
-  let results = [];
-  function pushMergeArg() {
-    if (results.length) {
-      dynamicArgs.push(dedupeProperties(results));
-      results = [];
-    }
-  }
-  for (const prop of props) {
-    if (prop.type === "JSXSpreadAttribute" && prop.argument) {
-      const value = resolveExpression(prop.argument, context);
-      dynamicExpr.push(value);
-      pushMergeArg();
-      dynamicArgs.push({
-        kind: 0 /* EXPRESSION */,
-        value
-      });
-      continue;
-    }
-    const result = transformProp(prop, node, context);
-    if (result) {
-      dynamicExpr.push(result.key, result.value);
-      if (isComponent && !result.key.isStatic) {
-        pushMergeArg();
-        dynamicArgs.push(
-          extend2(resolveDirectiveResult(result), {
-            kind: 1 /* ATTRIBUTE */
-          })
-        );
-      } else {
-        results.push(result);
-      }
-    }
-  }
-  if (dynamicArgs.length || results.some(({ key }) => !key.isStatic)) {
-    pushMergeArg();
-    return [true, dynamicArgs, dynamicExpr];
-  }
-  const irProps = dedupeProperties(results);
-  return [false, irProps];
+	const props = node.openingElement.attributes;
+	if (props.length === 0) return [false, []];
+	const dynamicArgs = [];
+	const dynamicExpr = [];
+	let results = [];
+	function pushMergeArg() {
+		if (results.length) {
+			dynamicArgs.push(dedupeProperties(results));
+			results = [];
+		}
+	}
+	for (const prop of props) {
+		if (prop.type === "JSXSpreadAttribute" && prop.argument) {
+			const value = resolveExpression(prop.argument, context);
+			dynamicExpr.push(value);
+			pushMergeArg();
+			dynamicArgs.push({
+				kind: IRDynamicPropsKind.EXPRESSION,
+				value
+			});
+			continue;
+		}
+		const result = transformProp(prop, node, context);
+		if (result) {
+			dynamicExpr.push(result.key, result.value);
+			if (isComponent && !result.key.isStatic) {
+				pushMergeArg();
+				dynamicArgs.push(extend(resolveDirectiveResult(result), { kind: IRDynamicPropsKind.ATTRIBUTE }));
+			} else results.push(result);
+		}
+	}
+	if (dynamicArgs.length || results.some(({ key }) => !key.isStatic)) {
+		pushMergeArg();
+		return [
+			true,
+			dynamicArgs,
+			dynamicExpr
+		];
+	}
+	const irProps = dedupeProperties(results);
+	return [false, irProps];
 }
 function transformProp(prop, node, context) {
-  if (prop.type === "JSXSpreadAttribute") return;
-  let name = prop.name.type === "JSXIdentifier" ? prop.name.name : prop.name.type === "JSXNamespacedName" ? prop.name.namespace.name : "";
-  name = name.split("_")[0];
-  if (!isDirectiveRegex.test(name) && !isEventRegex.test(name) && (!prop.value || prop.value.type === "StringLiteral")) {
-    if (isReservedProp(name)) return;
-    return {
-      key: resolveSimpleExpression(name, true, prop.name.loc),
-      value: prop.value && prop.value.type === "StringLiteral" ? resolveSimpleExpression(prop.value.value, true, prop.value.loc) : EMPTY_EXPRESSION
-    };
-  }
-  name = isEventRegex.test(name) ? "on" : isDirectiveRegex.test(name) ? name.slice(2) : "bind";
-  const directiveTransform = context.options.directiveTransforms[name];
-  if (directiveTransform) {
-    return directiveTransform(prop, node, context);
-  }
-  if (!isBuiltInDirective(name)) {
-    const fromSetup = `v-${name}`;
-    if (fromSetup) {
-      name = fromSetup;
-    } else {
-      context.directive.add(name);
-    }
-  }
+	if (prop.type === "JSXSpreadAttribute") return;
+	let name = prop.name.type === "JSXIdentifier" ? prop.name.name : prop.name.type === "JSXNamespacedName" ? prop.name.namespace.name : "";
+	name = name.split("_")[0];
+	if (!isDirectiveRegex.test(name) && !isEventRegex.test(name) && (!prop.value || prop.value.type === "StringLiteral")) {
+		if (isReservedProp(name)) return;
+		return {
+			key: resolveSimpleExpression(name, true, prop.name.loc),
+			value: prop.value && prop.value.type === "StringLiteral" ? resolveSimpleExpression(prop.value.value, true, prop.value.loc) : EMPTY_EXPRESSION
+		};
+	}
+	name = isEventRegex.test(name) ? "on" : isDirectiveRegex.test(name) ? name.slice(2) : "bind";
+	const directiveTransform = context.options.directiveTransforms[name];
+	if (directiveTransform) return directiveTransform(prop, node, context);
+	if (!isBuiltInDirective(name)) {
+		const fromSetup = `v-${name}`;
+		if (fromSetup) name = fromSetup;
+		else context.directive.add(name);
+	}
 }
 function dedupeProperties(results) {
-  const knownProps = /* @__PURE__ */ new Map();
-  const deduped = [];
-  for (const result of results) {
-    const prop = resolveDirectiveResult(result);
-    if (!prop.key.isStatic) {
-      deduped.push(prop);
-      continue;
-    }
-    const name = prop.key.content;
-    const existing = knownProps.get(name);
-    if (existing) {
-      if (name === "style" || name === "class") {
-        mergePropValues(existing, prop);
-      }
-    } else {
-      knownProps.set(name, prop);
-      deduped.push(prop);
-    }
-  }
-  return deduped;
+	const knownProps = new Map();
+	const deduped = [];
+	for (const result of results) {
+		const prop = resolveDirectiveResult(result);
+		if (!prop.key.isStatic) {
+			deduped.push(prop);
+			continue;
+		}
+		const name = prop.key.content;
+		const existing = knownProps.get(name);
+		if (existing) {
+			if (name === "style" || name === "class") mergePropValues(existing, prop);
+		} else {
+			knownProps.set(name, prop);
+			deduped.push(prop);
+		}
+	}
+	return deduped;
 }
 function resolveDirectiveResult(prop) {
-  return extend2({}, prop, {
-    value: void 0,
-    values: [prop.value]
-  });
+	return extend({}, prop, {
+		value: void 0,
+		values: [prop.value]
+	});
 }
 function mergePropValues(existing, incoming) {
-  const newValues = incoming.values;
-  existing.values.push(...newValues);
+	const newValues = incoming.values;
+	existing.values.push(...newValues);
 }
 
-// src/transforms/transformTemplateRef.ts
-var transformTemplateRef = (node, context) => {
-  if (node.type !== "JSXElement") return;
-  const dir = findProp(node, "ref");
-  if (!dir?.value) return;
-  context.ir.hasTemplateRef = true;
-  const value = resolveExpression(dir.value, context);
-  return () => {
-    const id = context.reference();
-    const effect = !isConstantExpression(value);
-    effect && context.registerOperation({
-      type: 14 /* DECLARE_OLD_REF */,
-      id
-    });
-    context.registerEffect([value], {
-      type: 8 /* SET_TEMPLATE_REF */,
-      element: id,
-      value,
-      refFor: !!context.inVFor,
-      effect
-    });
-  };
+//#endregion
+//#region src/transforms/transformTemplateRef.ts
+const transformTemplateRef = (node, context) => {
+	if (node.type !== "JSXElement") return;
+	const dir = findProp(node, "ref");
+	if (!dir?.value) return;
+	context.ir.hasTemplateRef = true;
+	const value = resolveExpression(dir.value, context);
+	return () => {
+		const id = context.reference();
+		const effect = !isConstantExpression(value);
+		effect && context.registerOperation({
+			type: IRNodeTypes.DECLARE_OLD_REF,
+			id
+		});
+		context.registerEffect([value], {
+			type: IRNodeTypes.SET_TEMPLATE_REF,
+			element: id,
+			value,
+			refFor: !!context.inVFor,
+			effect
+		});
+	};
 };
 
-// src/transforms/expression.ts
-import { isStaticNode } from "@vue/compiler-dom";
+//#endregion
+//#region src/transforms/expression.ts
 function processConditionalExpression(node, context) {
-  const { test, consequent, alternate } = node;
-  context.dynamic.flags |= 2 /* NON_TEMPLATE */ | 4 /* INSERT */;
-  const id = context.reference();
-  const condition = resolveExpression(test, context);
-  const [branch, onExit] = createBranch(consequent, context);
-  const operation = {
-    type: 15 /* IF */,
-    id,
-    condition,
-    positive: branch,
-    once: context.inVOnce || isStaticNode(test)
-  };
-  return [
-    () => {
-      onExit();
-      context.dynamic.operation = operation;
-    },
-    () => {
-      const [branch2, onExit2] = createBranch(alternate, context);
-      operation.negative = branch2;
-      transformNode(context);
-      onExit2();
-    }
-  ];
+	const { test, consequent, alternate } = node;
+	context.dynamic.flags |= DynamicFlag.NON_TEMPLATE | DynamicFlag.INSERT;
+	const id = context.reference();
+	const condition = resolveExpression(test, context);
+	const [branch, onExit] = createBranch(consequent, context);
+	const operation = {
+		type: IRNodeTypes.IF,
+		id,
+		condition,
+		positive: branch,
+		once: context.inVOnce || isStaticNode(test)
+	};
+	return [() => {
+		onExit();
+		context.dynamic.operation = operation;
+	}, () => {
+		const [branch$1, onExit$1] = createBranch(alternate, context);
+		operation.negative = branch$1;
+		transformNode(context);
+		onExit$1();
+	}];
 }
 function processLogicalExpression(node, context) {
-  const { left, right, operator } = node;
-  context.dynamic.flags |= 2 /* NON_TEMPLATE */;
-  context.dynamic.flags |= 4 /* INSERT */;
-  const id = context.reference();
-  const condition = resolveExpression(left, context);
-  const [branch, onExit] = createBranch(
-    operator === "&&" ? right : left,
-    context
-  );
-  const operation = {
-    type: 15 /* IF */,
-    id,
-    condition,
-    positive: branch,
-    once: context.inVOnce
-  };
-  return [
-    () => {
-      onExit();
-      context.dynamic.operation = operation;
-    },
-    () => {
-      const [branch2, onExit2] = createBranch(
-        operator === "&&" ? left : right,
-        context
-      );
-      operation.negative = branch2;
-      transformNode(context);
-      onExit2();
-    }
-  ];
+	const { left, right, operator } = node;
+	context.dynamic.flags |= DynamicFlag.NON_TEMPLATE;
+	context.dynamic.flags |= DynamicFlag.INSERT;
+	const id = context.reference();
+	const condition = resolveExpression(left, context);
+	const [branch, onExit] = createBranch(operator === "&&" ? right : left, context);
+	const operation = {
+		type: IRNodeTypes.IF,
+		id,
+		condition,
+		positive: branch,
+		once: context.inVOnce
+	};
+	return [() => {
+		onExit();
+		context.dynamic.operation = operation;
+	}, () => {
+		const [branch$1, onExit$1] = createBranch(operator === "&&" ? left : right, context);
+		operation.negative = branch$1;
+		transformNode(context);
+		onExit$1();
+	}];
 }
 
-// src/transforms/transformText.ts
-var seen = /* @__PURE__ */ new WeakMap();
-var transformText = (node, context) => {
-  if (!seen.has(context.root)) seen.set(context.root, /* @__PURE__ */ new WeakSet());
-  if (seen.get(context.root).has(node)) {
-    context.dynamic.flags |= 2 /* NON_TEMPLATE */;
-    return;
-  }
-  const isFragment = isFragmentNode(node);
-  if ((node.type === "JSXElement" && !isTemplate(node) && !isJSXComponent(node) || isFragment) && node.children.length) {
-    let hasInterp = false;
-    let isAllTextLike = true;
-    for (const c of node.children) {
-      if (c.type === "JSXExpressionContainer" && c.expression.type !== "ConditionalExpression" && c.expression.type !== "LogicalExpression") {
-        hasInterp = true;
-      } else if (c.type !== "JSXText") {
-        isAllTextLike = false;
-      }
-    }
-    if (!isFragment && isAllTextLike && hasInterp) {
-      processTextContainer(node.children, context);
-    } else if (hasInterp) {
-      for (let i = 0; i < node.children.length; i++) {
-        const c = node.children[i];
-        const prev = node.children[i - 1];
-        if (c.type === "JSXExpressionContainer" && prev && prev.type === "JSXText") {
-          seen.get(context.root).add(prev);
-        }
-      }
-    }
-  } else if (node.type === "JSXExpressionContainer") {
-    if (node.expression.type === "ConditionalExpression") {
-      return processConditionalExpression(node.expression, context);
-    } else if (node.expression.type === "LogicalExpression") {
-      return processLogicalExpression(node.expression, context);
-    } else {
-      processInterpolation(context);
-    }
-  } else if (node.type === "JSXText") {
-    const value = resolveJSXText(node);
-    if (value) {
-      context.template += value;
-    } else {
-      context.dynamic.flags |= 2 /* NON_TEMPLATE */;
-    }
-  }
+//#endregion
+//#region src/transforms/transformText.ts
+const seen = new WeakMap();
+const transformText = (node, context) => {
+	if (!seen.has(context.root)) seen.set(context.root, new WeakSet());
+	if (seen.get(context.root).has(node)) {
+		context.dynamic.flags |= DynamicFlag.NON_TEMPLATE;
+		return;
+	}
+	const isFragment = isFragmentNode(node);
+	if ((node.type === "JSXElement" && !isTemplate(node) && !isJSXComponent(node) || isFragment) && node.children.length) {
+		let hasInterp = false;
+		let isAllTextLike = true;
+		for (const c of node.children) if (c.type === "JSXExpressionContainer" && c.expression.type !== "ConditionalExpression" && c.expression.type !== "LogicalExpression") hasInterp = true;
+		else if (c.type !== "JSXText") isAllTextLike = false;
+		if (!isFragment && isAllTextLike && hasInterp) processTextContainer(node.children, context);
+		else if (hasInterp) for (let i = 0; i < node.children.length; i++) {
+			const c = node.children[i];
+			const prev = node.children[i - 1];
+			if (c.type === "JSXExpressionContainer" && prev && prev.type === "JSXText") seen.get(context.root).add(prev);
+		}
+	} else if (node.type === "JSXExpressionContainer") if (node.expression.type === "ConditionalExpression") return processConditionalExpression(node.expression, context);
+	else if (node.expression.type === "LogicalExpression") return processLogicalExpression(node.expression, context);
+	else processInterpolation(context);
+	else if (node.type === "JSXText") {
+		const value = resolveJSXText(node);
+		if (value) context.template += value;
+		else context.dynamic.flags |= DynamicFlag.NON_TEMPLATE;
+	}
 };
 function processInterpolation(context) {
-  const parent = context.parent.node;
-  const children = parent.children;
-  const nexts = children.slice(context.index);
-  const idx = nexts.findIndex((n) => !isTextLike(n));
-  const nodes = idx !== -1 ? nexts.slice(0, idx) : nexts;
-  const prev = children[context.index - 1];
-  if (prev && prev.type === "JSXText") {
-    nodes.unshift(prev);
-  }
-  const values = createTextLikeExpressions(nodes, context);
-  if (!values.length) {
-    context.dynamic.flags |= 2 /* NON_TEMPLATE */;
-    return;
-  }
-  const id = context.reference();
-  if (isFragmentNode(parent)) {
-    context.registerOperation({
-      type: 18 /* CREATE_NODES */,
-      id,
-      values
-    });
-  } else {
-    context.template += " ";
-    context.registerOperation({
-      type: 19 /* SET_NODES */,
-      element: id,
-      values
-    });
-  }
+	const parent = context.parent.node;
+	const children = parent.children;
+	const nexts = children.slice(context.index);
+	const idx = nexts.findIndex((n) => !isTextLike(n));
+	const nodes = idx !== -1 ? nexts.slice(0, idx) : nexts;
+	const prev = children[context.index - 1];
+	if (prev && prev.type === "JSXText") nodes.unshift(prev);
+	const values = createTextLikeExpressions(nodes, context);
+	if (!values.length) {
+		context.dynamic.flags |= DynamicFlag.NON_TEMPLATE;
+		return;
+	}
+	const id = context.reference();
+	if (isFragmentNode(parent)) context.registerOperation({
+		type: IRNodeTypes.CREATE_NODES,
+		id,
+		values
+	});
+	else {
+		context.template += " ";
+		context.registerOperation({
+			type: IRNodeTypes.SET_NODES,
+			element: id,
+			values
+		});
+	}
 }
 function processTextContainer(children, context) {
-  const values = createTextLikeExpressions(children, context);
-  const literals = values.map(getLiteralExpressionValue);
-  if (literals.every((l) => l != null)) {
-    context.childrenTemplate = literals.map((l) => String(l));
-  } else {
-    context.childrenTemplate = [" "];
-    context.registerOperation({
-      type: 17 /* GET_TEXT_CHILD */,
-      parent: context.reference()
-    });
-    context.registerOperation({
-      type: 19 /* SET_NODES */,
-      element: context.reference(),
-      values,
-      // indicates this node is generated, so prefix should be "x" instead of "n"
-      generated: true
-    });
-  }
+	const values = createTextLikeExpressions(children, context);
+	const literals = values.map(getLiteralExpressionValue);
+	if (literals.every((l) => l != null)) context.childrenTemplate = literals.map((l) => String(l));
+	else {
+		context.childrenTemplate = [" "];
+		context.registerOperation({
+			type: IRNodeTypes.GET_TEXT_CHILD,
+			parent: context.reference()
+		});
+		context.registerOperation({
+			type: IRNodeTypes.SET_NODES,
+			element: context.reference(),
+			values,
+			generated: true
+		});
+	}
 }
 function createTextLikeExpressions(nodes, context) {
-  const values = [];
-  for (const node of nodes) {
-    seen.get(context.root).add(node);
-    if (isEmptyText(node)) continue;
-    values.push(resolveExpression(node, context, !context.inVOnce));
-  }
-  return values;
+	const values = [];
+	for (const node of nodes) {
+		seen.get(context.root).add(node);
+		if (isEmptyText(node)) continue;
+		values.push(resolveExpression(node, context, !context.inVOnce));
+	}
+	return values;
 }
 function isTextLike(node) {
-  return node.type === "JSXExpressionContainer" && node.expression.type !== "ConditionalExpression" && node.expression.type !== "LogicalExpression" || node.type === "JSXText";
+	return node.type === "JSXExpressionContainer" && node.expression.type !== "ConditionalExpression" && node.expression.type !== "LogicalExpression" || node.type === "JSXText";
 }
 
-// src/transforms/vBind.ts
-import { camelize, extend as extend3 } from "@vue/shared";
-var transformVBind = (dir, node, context) => {
-  const { name, value, loc } = dir;
-  if (!loc || name.type === "JSXNamespacedName") return;
-  const [nameString, ...modifiers] = name.name.split("_");
-  const exp = resolveExpression(value, context);
-  let arg = resolveSimpleExpression(nameString, true, dir.name.loc);
-  if (arg.isStatic && isReservedProp(arg.content)) return;
-  let camel = false;
-  if (modifiers.includes("camel")) {
-    if (arg.isStatic) {
-      arg = extend3({}, arg, { content: camelize(arg.content) });
-    } else {
-      camel = true;
-    }
-  }
-  return {
-    key: arg,
-    value: exp,
-    loc,
-    runtimeCamelize: camel,
-    modifier: modifiers.includes("prop") ? "." : modifiers.includes("attr") ? "^" : void 0
-  };
+//#endregion
+//#region src/transforms/vBind.ts
+const transformVBind = (dir, node, context) => {
+	const { name, value, loc } = dir;
+	if (!loc || name.type === "JSXNamespacedName") return;
+	const [nameString, ...modifiers] = name.name.split("_");
+	const exp = resolveExpression(value, context);
+	let arg = resolveSimpleExpression(nameString, true, dir.name.loc);
+	if (arg.isStatic && isReservedProp(arg.content)) return;
+	let camel = false;
+	if (modifiers.includes("camel")) if (arg.isStatic) arg = extend({}, arg, { content: camelize(arg.content) });
+	else camel = true;
+	return {
+		key: arg,
+		value: exp,
+		loc,
+		runtimeCamelize: camel,
+		modifier: modifiers.includes("prop") ? "." : modifiers.includes("attr") ? "^" : void 0
+	};
 };
 
-// src/transforms/vFor.ts
-import {
-  createCompilerError,
-  ErrorCodes,
-  isConstantNode
-} from "@vue/compiler-dom";
-var transformVFor = createStructuralDirectiveTransform(
-  "for",
-  processFor
-);
+//#endregion
+//#region src/transforms/vFor.ts
+const transformVFor = createStructuralDirectiveTransform("for", processFor);
 function processFor(node, dir, context) {
-  const { value, index, key, source } = getForParseResult(dir, context);
-  if (!source) {
-    context.options.onError(
-      createCompilerError(
-        ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION,
-        resolveLocation(dir.loc, context)
-      )
-    );
-    return;
-  }
-  const keyProp = findProp(node, "key");
-  const keyProperty = keyProp && propToExpression(keyProp, context);
-  const isComponent = isJSXComponent(node);
-  const id = context.reference();
-  context.dynamic.flags |= 2 /* NON_TEMPLATE */ | 4 /* INSERT */;
-  const [render, exitBlock] = createBranch(node, context, true);
-  return () => {
-    exitBlock();
-    const { parent } = context;
-    const isOnlyChild = parent && parent.block.node !== parent.node && parent.node.children.length === 1;
-    context.dynamic.operation = {
-      type: 16 /* FOR */,
-      id,
-      source,
-      value,
-      key,
-      index,
-      keyProp: keyProperty,
-      render,
-      once: context.inVOnce || !!(source.ast && isConstantNode(source.ast, {})),
-      component: isComponent,
-      onlyChild: !!isOnlyChild
-    };
-  };
+	const { value, index, key, source } = getForParseResult(dir, context);
+	if (!source) {
+		context.options.onError(createCompilerError(ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION, resolveLocation(dir.loc, context)));
+		return;
+	}
+	const keyProp = findProp(node, "key");
+	const keyProperty = keyProp && propToExpression(keyProp, context);
+	const isComponent = isJSXComponent(node);
+	const id = context.reference();
+	context.dynamic.flags |= DynamicFlag.NON_TEMPLATE | DynamicFlag.INSERT;
+	const [render, exitBlock] = createBranch(node, context, true);
+	return () => {
+		exitBlock();
+		const { parent } = context;
+		const isOnlyChild = parent && parent.block.node !== parent.node && parent.node.children.length === 1;
+		context.dynamic.operation = {
+			type: IRNodeTypes.FOR,
+			id,
+			source,
+			value,
+			key,
+			index,
+			keyProp: keyProperty,
+			render,
+			once: context.inVOnce || !!(source.ast && isConstantNode(source.ast, {})),
+			component: isComponent,
+			onlyChild: !!isOnlyChild
+		};
+	};
 }
 function getForParseResult(dir, context) {
-  let value, index, key, source;
-  if (dir.value) {
-    if (dir.value.type === "JSXExpressionContainer" && dir.value.expression.type === "BinaryExpression") {
-      if (dir.value.expression.left.type === "SequenceExpression") {
-        const expressions = dir.value.expression.left.expressions;
-        value = expressions[0] && resolveExpressionWithFn(expressions[0], context);
-        key = expressions[1] && resolveExpression(expressions[1], context);
-        index = expressions[2] && resolveExpression(expressions[2], context);
-      } else {
-        value = resolveExpressionWithFn(dir.value.expression.left, context);
-      }
-      source = resolveExpression(dir.value.expression.right, context);
-    }
-  } else {
-    context.options.onError(
-      createCompilerError(
-        ErrorCodes.X_V_FOR_NO_EXPRESSION,
-        resolveLocation(dir.loc, context)
-      )
-    );
-  }
-  return {
-    value,
-    index,
-    key,
-    source
-  };
+	let value, index, key, source;
+	if (dir.value) {
+		if (dir.value.type === "JSXExpressionContainer" && dir.value.expression.type === "BinaryExpression") {
+			if (dir.value.expression.left.type === "SequenceExpression") {
+				const expressions = dir.value.expression.left.expressions;
+				value = expressions[0] && resolveExpressionWithFn(expressions[0], context);
+				key = expressions[1] && resolveExpression(expressions[1], context);
+				index = expressions[2] && resolveExpression(expressions[2], context);
+			} else value = resolveExpressionWithFn(dir.value.expression.left, context);
+			source = resolveExpression(dir.value.expression.right, context);
+		}
+	} else context.options.onError(createCompilerError(ErrorCodes.X_V_FOR_NO_EXPRESSION, resolveLocation(dir.loc, context)));
+	return {
+		value,
+		index,
+		key,
+		source
+	};
 }
 
-// src/transforms/vHtml.ts
-import { transformVHtml as _transformVHtml } from "@vue/compiler-vapor";
-var transformVHtml = (dir, node, context) => {
-  return _transformVHtml(
-    resolveDirectiveNode(dir, context),
-    resolveNode(node, context),
-    context
-  );
+//#endregion
+//#region src/transforms/vHtml.ts
+const transformVHtml = (dir, node, context) => {
+	let exp;
+	const loc = resolveLocation(dir.loc, context);
+	if (!dir.value) {
+		context.options.onError(createDOMCompilerError(DOMErrorCodes.X_V_HTML_NO_EXPRESSION, loc));
+		exp = EMPTY_EXPRESSION;
+	} else exp = resolveExpression(dir.value, context);
+	if (node.children.length) {
+		context.options.onError(createDOMCompilerError(DOMErrorCodes.X_V_HTML_WITH_CHILDREN, loc));
+		context.childrenTemplate.length = 0;
+	}
+	context.registerEffect([exp], {
+		type: IRNodeTypes.SET_HTML,
+		element: context.reference(),
+		value: exp
+	});
 };
 
-// src/transforms/vIf.ts
-import {
-  createCompilerError as createCompilerError2,
-  createSimpleExpression as createSimpleExpression3,
-  ErrorCodes as ErrorCodes2,
-  isConstantNode as isConstantNode2
-} from "@vue/compiler-dom";
-var transformVIf = createStructuralDirectiveTransform(
-  ["if", "else", "else-if"],
-  processIf
-);
-var transformedIfNode = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region src/transforms/vIf.ts
+const transformVIf = createStructuralDirectiveTransform([
+	"if",
+	"else",
+	"else-if"
+], processIf);
+const transformedIfNode = new WeakMap();
 function processIf(node, attribute, context) {
-  const dir = resolveDirectiveNode(attribute, context);
-  if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) {
-    const loc = dir.exp ? dir.exp.loc : resolveLocation(node.loc, context);
-    context.options.onError(
-      createCompilerError2(ErrorCodes2.X_V_IF_NO_EXPRESSION, dir.loc)
-    );
-    dir.exp = createSimpleExpression3(`true`, false, loc);
-  }
-  context.dynamic.flags |= 2 /* NON_TEMPLATE */;
-  transformedIfNode.set(node, dir);
-  if (dir.name === "if") {
-    const id = context.reference();
-    context.dynamic.flags |= 4 /* INSERT */;
-    const [branch, onExit] = createBranch(node, context);
-    return () => {
-      onExit();
-      context.dynamic.operation = {
-        type: 15 /* IF */,
-        id,
-        condition: dir.exp,
-        positive: branch,
-        once: context.inVOnce || isConstantNode2(attribute.value, context.options.bindingMetadata)
-      };
-    };
-  } else {
-    const siblingIf = getSiblingIf(context);
-    const siblings = context.parent && context.parent.dynamic.children;
-    let lastIfNode;
-    if (siblings) {
-      let i = siblings.length;
-      while (i--) {
-        if (siblings[i].operation) lastIfNode = siblings[i].operation;
-      }
-    }
-    if (
-      // check if v-if is the sibling node
-      !siblingIf || // check if IfNode is the last operation and get the root IfNode
-      !lastIfNode || lastIfNode.type !== 15 /* IF */
-    ) {
-      context.options.onError(
-        createCompilerError2(
-          ErrorCodes2.X_V_ELSE_NO_ADJACENT_IF,
-          resolveLocation(node.loc, context)
-        )
-      );
-      return;
-    }
-    while (lastIfNode.negative && lastIfNode.negative.type === 15 /* IF */) {
-      lastIfNode = lastIfNode.negative;
-    }
-    if (dir.name === "else-if" && lastIfNode.negative) {
-      context.options.onError(
-        createCompilerError2(
-          ErrorCodes2.X_V_ELSE_NO_ADJACENT_IF,
-          resolveLocation(node.loc, context)
-        )
-      );
-    }
-    context.root.comment = [];
-    const [branch, onExit] = createBranch(node, context);
-    if (dir.name === "else") {
-      lastIfNode.negative = branch;
-    } else {
-      lastIfNode.negative = {
-        type: 15 /* IF */,
-        id: -1,
-        condition: dir.exp,
-        positive: branch,
-        once: context.inVOnce
-      };
-    }
-    return () => onExit();
-  }
+	const dir = resolveDirective(attribute, context);
+	if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) {
+		const loc = dir.exp ? dir.exp.loc : resolveLocation(node.loc, context);
+		context.options.onError(createCompilerError(ErrorCodes.X_V_IF_NO_EXPRESSION, dir.loc));
+		dir.exp = createSimpleExpression(`true`, false, loc);
+	}
+	context.dynamic.flags |= DynamicFlag.NON_TEMPLATE;
+	transformedIfNode.set(node, dir);
+	if (dir.name === "if") {
+		const id = context.reference();
+		context.dynamic.flags |= DynamicFlag.INSERT;
+		const [branch, onExit] = createBranch(node, context);
+		return () => {
+			onExit();
+			context.dynamic.operation = {
+				type: IRNodeTypes.IF,
+				id,
+				condition: dir.exp,
+				positive: branch,
+				once: context.inVOnce || isConstantNode(attribute.value, context.options.bindingMetadata)
+			};
+		};
+	} else {
+		const siblingIf = getSiblingIf(context);
+		const siblings = context.parent && context.parent.dynamic.children;
+		let lastIfNode;
+		if (siblings) {
+			let i = siblings.length;
+			while (i--) if (siblings[i].operation) lastIfNode = siblings[i].operation;
+		}
+		if (!siblingIf || !lastIfNode || lastIfNode.type !== IRNodeTypes.IF) {
+			context.options.onError(createCompilerError(ErrorCodes.X_V_ELSE_NO_ADJACENT_IF, resolveLocation(node.loc, context)));
+			return;
+		}
+		while (lastIfNode.negative && lastIfNode.negative.type === IRNodeTypes.IF) lastIfNode = lastIfNode.negative;
+		if (dir.name === "else-if" && lastIfNode.negative) context.options.onError(createCompilerError(ErrorCodes.X_V_ELSE_NO_ADJACENT_IF, resolveLocation(node.loc, context)));
+		context.root.comment = [];
+		const [branch, onExit] = createBranch(node, context);
+		if (dir.name === "else") lastIfNode.negative = branch;
+		else lastIfNode.negative = {
+			type: IRNodeTypes.IF,
+			id: -1,
+			condition: dir.exp,
+			positive: branch,
+			once: context.inVOnce
+		};
+		return () => onExit();
+	}
 }
 function getSiblingIf(context) {
-  const parent = context.parent;
-  if (!parent) return;
-  const siblings = parent.node.children;
-  let sibling;
-  let i = siblings.indexOf(context.node);
-  while (--i >= 0) {
-    if (!isEmptyText(siblings[i])) {
-      sibling = siblings[i];
-      break;
-    }
-  }
-  if (sibling && sibling.type === "JSXElement" && transformedIfNode.has(sibling)) {
-    return sibling;
-  }
+	const parent = context.parent;
+	if (!parent) return;
+	const siblings = parent.node.children;
+	let sibling;
+	let i = siblings.indexOf(context.node);
+	while (--i >= 0) if (!isEmptyText(siblings[i])) {
+		sibling = siblings[i];
+		break;
+	}
+	if (sibling && sibling.type === "JSXElement" && transformedIfNode.has(sibling)) return sibling;
 }
 
-// src/transforms/vModel.ts
-import { transformVModel as _transformVModel } from "@vue/compiler-vapor";
-var transformVModel = (dir, node, context) => {
-  return _transformVModel(
-    resolveDirectiveNode(dir, context),
-    resolveNode(node, context),
-    context
-  );
+//#endregion
+//#region src/transforms/vModel.ts
+const transformVModel = (_dir, node, context) => {
+	const dir = resolveDirective(_dir, context);
+	const { exp, arg } = dir;
+	if (!exp) {
+		context.options.onError(createCompilerError(ErrorCodes.X_V_MODEL_NO_EXPRESSION, dir.loc));
+		return;
+	}
+	const expString = exp.content;
+	if (!expString.trim() || !isMemberExpression(exp, context.options)) {
+		context.options.onError(createCompilerError(ErrorCodes.X_V_MODEL_MALFORMED_EXPRESSION, exp.loc));
+		return;
+	}
+	const isComponent = isJSXComponent(node);
+	if (isComponent) return {
+		key: arg ? arg : createSimpleExpression("modelValue", true),
+		value: exp,
+		model: true,
+		modelModifiers: dir.modifiers.map((m) => m.content)
+	};
+	if (dir.arg) context.options.onError(createDOMCompilerError(DOMErrorCodes.X_V_MODEL_ARG_ON_ELEMENT, dir.arg.loc));
+	const tag = getText(node.openingElement.name, context);
+	const isCustomElement = context.options.isCustomElement(tag);
+	let modelType = "text";
+	if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) if (tag === "input" || isCustomElement) {
+		const type = findProp(node, "type");
+		if (type?.value) {
+			if (type.value.type === "JSXExpressionContainer") modelType = "dynamic";
+			else if (type.value.type === "StringLiteral") switch (type.value.value) {
+				case "radio":
+					modelType = "radio";
+					break;
+				case "checkbox":
+					modelType = "checkbox";
+					break;
+				case "file":
+					modelType = void 0;
+					context.options.onError(createDOMCompilerError(DOMErrorCodes.X_V_MODEL_ON_FILE_INPUT_ELEMENT, dir.loc));
+					break;
+				default:
+					checkDuplicatedValue();
+					break;
+			}
+		} else if (hasDynamicKeyVBind(node)) modelType = "dynamic";
+		else checkDuplicatedValue();
+	} else if (tag === "select") modelType = "select";
+	else checkDuplicatedValue();
+	else context.options.onError(createDOMCompilerError(DOMErrorCodes.X_V_MODEL_ON_INVALID_ELEMENT, dir.loc));
+	if (modelType) context.registerOperation({
+		type: IRNodeTypes.DIRECTIVE,
+		element: context.reference(),
+		dir,
+		name: "model",
+		modelType,
+		builtin: true
+	});
+	function checkDuplicatedValue() {
+		const value = findProp(node, "value");
+		if (value && value.value?.type !== "StringLiteral") context.options.onError(createDOMCompilerError(DOMErrorCodes.X_V_MODEL_UNNECESSARY_VALUE, resolveLocation(value.loc, context)));
+	}
 };
+function hasDynamicKeyVBind(node) {
+	return node.openingElement.attributes.some((p) => p.type === "JSXSpreadAttribute" || p.type === "JSXAttribute" && p.name.type === "JSXNamespacedName" && !p.name.namespace.name.startsWith("v-"));
+}
 
-// src/transforms/vOn.ts
-import {
-  createCompilerError as createCompilerError3,
-  createSimpleExpression as createSimpleExpression4,
-  ErrorCodes as ErrorCodes3,
-  resolveModifiers
-} from "@vue/compiler-dom";
-import { extend as extend4, makeMap as makeMap2 } from "@vue/shared";
-var delegatedEvents = /* @__PURE__ */ makeMap2(
-  "beforeinput,click,dblclick,contextmenu,focusin,focusout,input,keydown,keyup,mousedown,mousemove,mouseout,mouseover,mouseup,pointerdown,pointermove,pointerout,pointerover,pointerup,touchend,touchmove,touchstart"
-);
-var transformVOn = (dir, node, context) => {
-  const { name, loc, value } = dir;
-  if (name.type === "JSXNamespacedName") return;
-  const isComponent = isJSXComponent(node);
-  const [nameString, ...modifiers] = name.name.replace(/^on([A-Z])/, (_, $1) => $1.toLowerCase()).split("_");
-  if (!value && !modifiers.length) {
-    context.options.onError(
-      createCompilerError3(
-        ErrorCodes3.X_V_ON_NO_EXPRESSION,
-        resolveLocation(loc, context)
-      )
-    );
-  }
-  let arg = resolveSimpleExpression(nameString, true, dir.name.loc);
-  const exp = resolveExpression(dir.value, context);
-  const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(
-    arg.isStatic ? `on${nameString}` : arg,
-    modifiers.map((modifier) => createSimpleExpression4(modifier)),
-    null,
-    resolveLocation(loc, context)
-  );
-  let keyOverride;
-  const isStaticClick = arg.isStatic && arg.content.toLowerCase() === "click";
-  if (nonKeyModifiers.includes("middle")) {
-    if (keyOverride) {
-    }
-    if (isStaticClick) {
-      arg = extend4({}, arg, { content: "mouseup" });
-    } else if (!arg.isStatic) {
-      keyOverride = ["click", "mouseup"];
-    }
-  }
-  if (nonKeyModifiers.includes("right")) {
-    if (isStaticClick) {
-      arg = extend4({}, arg, { content: "contextmenu" });
-    } else if (!arg.isStatic) {
-      keyOverride = ["click", "contextmenu"];
-    }
-  }
-  if (isComponent) {
-    const handler = exp || EMPTY_EXPRESSION;
-    return {
-      key: arg,
-      value: handler,
-      handler: true,
-      handlerModifiers: {
-        keys: keyModifiers,
-        nonKeys: nonKeyModifiers,
-        options: eventOptionModifiers
-      }
-    };
-  }
-  const delegate = arg.isStatic && !eventOptionModifiers.length && delegatedEvents(arg.content);
-  const operation = {
-    type: 5 /* SET_EVENT */,
-    element: context.reference(),
-    key: arg,
-    value: exp,
-    modifiers: {
-      keys: keyModifiers,
-      nonKeys: nonKeyModifiers,
-      options: eventOptionModifiers
-    },
-    keyOverride,
-    delegate,
-    effect: !arg.isStatic
-  };
-  context.registerEffect([arg], operation);
+//#endregion
+//#region src/transforms/vOn.ts
+const delegatedEvents = /* @__PURE__ */ makeMap("beforeinput,click,dblclick,contextmenu,focusin,focusout,input,keydown,keyup,mousedown,mousemove,mouseout,mouseover,mouseup,pointerdown,pointermove,pointerout,pointerover,pointerup,touchend,touchmove,touchstart");
+const transformVOn = (dir, node, context) => {
+	const { name, loc, value } = dir;
+	if (name.type === "JSXNamespacedName") return;
+	const isComponent = isJSXComponent(node);
+	const [nameString, ...modifiers] = name.name.replace(/^on([A-Z])/, (_, $1) => $1.toLowerCase()).split("_");
+	if (!value && !modifiers.length) context.options.onError(createCompilerError(ErrorCodes.X_V_ON_NO_EXPRESSION, resolveLocation(loc, context)));
+	let arg = resolveSimpleExpression(nameString, true, dir.name.loc);
+	const exp = resolveExpression(dir.value, context);
+	const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(arg.isStatic ? `on${nameString}` : arg, modifiers.map((modifier) => createSimpleExpression(modifier)), null, resolveLocation(loc, context));
+	let keyOverride;
+	const isStaticClick = arg.isStatic && arg.content.toLowerCase() === "click";
+	if (nonKeyModifiers.includes("middle")) {
+		if (keyOverride) {}
+		if (isStaticClick) arg = extend({}, arg, { content: "mouseup" });
+		else if (!arg.isStatic) keyOverride = ["click", "mouseup"];
+	}
+	if (nonKeyModifiers.includes("right")) {
+		if (isStaticClick) arg = extend({}, arg, { content: "contextmenu" });
+		else if (!arg.isStatic) keyOverride = ["click", "contextmenu"];
+	}
+	if (isComponent) {
+		const handler = exp || EMPTY_EXPRESSION;
+		return {
+			key: arg,
+			value: handler,
+			handler: true,
+			handlerModifiers: {
+				keys: keyModifiers,
+				nonKeys: nonKeyModifiers,
+				options: eventOptionModifiers
+			}
+		};
+	}
+	const delegate = arg.isStatic && !eventOptionModifiers.length && delegatedEvents(arg.content);
+	const operation = {
+		type: IRNodeTypes.SET_EVENT,
+		element: context.reference(),
+		key: arg,
+		value: exp,
+		modifiers: {
+			keys: keyModifiers,
+			nonKeys: nonKeyModifiers,
+			options: eventOptionModifiers
+		},
+		keyOverride,
+		delegate,
+		effect: !arg.isStatic
+	};
+	context.registerEffect([arg], operation);
 };
 
-// src/transforms/vOnce.ts
-var transformVOnce = (node, context) => {
-  if (
-    // !context.inSSR &&
-    node.type === "JSXElement" && findProp(node, "v-once")
-  ) {
-    context.inVOnce = true;
-  }
+//#endregion
+//#region src/transforms/vOnce.ts
+const transformVOnce = (node, context) => {
+	if (node.type === "JSXElement" && findProp(node, "v-once")) context.inVOnce = true;
 };
 
-// src/transforms/vShow.ts
-import { transformVShow as _transformVShow } from "@vue/compiler-vapor";
-var transformVShow = (dir, node, context) => {
-  return _transformVShow(
-    resolveDirectiveNode(dir, context),
-    resolveNode(node, context),
-    context
-  );
+//#endregion
+//#region src/transforms/vShow.ts
+const transformVShow = (_dir, node, context) => {
+	const dir = resolveDirective(_dir, context);
+	const { exp, loc } = dir;
+	if (!exp) {
+		context.options.onError(createDOMCompilerError(DOMErrorCodes.X_V_SHOW_NO_EXPRESSION, loc));
+		return;
+	}
+	context.registerOperation({
+		type: IRNodeTypes.DIRECTIVE,
+		element: context.reference(),
+		dir,
+		name: "show",
+		builtin: true
+	});
 };
 
-// src/transforms/vSlot.ts
-import {
-  createCompilerError as createCompilerError4,
-  ErrorCodes as ErrorCodes4
-} from "@vue/compiler-dom";
-var transformVSlot = (node, context) => {
-  if (node.type !== "JSXElement") return;
-  const { children } = node;
-  const dir = findProp(node, "v-slot");
-  const resolvedDirective = dir ? resolveDirectiveNode(dir, context, true) : void 0;
-  const { parent } = context;
-  const isComponent = isJSXComponent(node);
-  const isSlotTemplate = isTemplate(node) && parent && parent.node.type === "JSXElement" && isJSXComponent(parent.node);
-  if (isComponent && children.length) {
-    return transformComponentSlot(node, resolvedDirective, context);
-  } else if (isSlotTemplate && resolvedDirective) {
-    return transformTemplateSlot(node, resolvedDirective, context);
-  } else if (!isComponent && dir) {
-    context.options.onError(
-      createCompilerError4(
-        ErrorCodes4.X_V_SLOT_MISPLACED,
-        resolveLocation(dir.loc, context)
-      )
-    );
-  }
+//#endregion
+//#region src/transforms/vSlot.ts
+const transformVSlot = (node, context) => {
+	if (node.type !== "JSXElement") return;
+	const { children } = node;
+	const dir = findProp(node, "v-slot");
+	const resolvedDirective = dir ? resolveDirective(dir, context, true) : void 0;
+	const { parent } = context;
+	const isComponent = isJSXComponent(node);
+	const isSlotTemplate = isTemplate(node) && parent && parent.node.type === "JSXElement" && isJSXComponent(parent.node);
+	if (isComponent && children.length) return transformComponentSlot(node, resolvedDirective, context);
+	else if (isSlotTemplate && resolvedDirective) return transformTemplateSlot(node, resolvedDirective, context);
+	else if (!isComponent && dir) context.options.onError(createCompilerError(ErrorCodes.X_V_SLOT_MISPLACED, resolveLocation(dir.loc, context)));
 };
 function transformComponentSlot(node, dir, context) {
-  const { children } = node;
-  const arg = dir && dir.arg;
-  const nonSlotTemplateChildren = children.filter(
-    (n) => !isEmptyText(n) && (n.type !== "JSXElement" || !findProp(n, "v-slot"))
-  );
-  const [block, onExit] = createSlotBlock(node, dir, context);
-  const { slots } = context;
-  return () => {
-    onExit();
-    const hasOtherSlots = !!slots.length;
-    if (dir && hasOtherSlots) {
-      context.options.onError(
-        createCompilerError4(ErrorCodes4.X_V_SLOT_MIXED_SLOT_USAGE, dir.loc)
-      );
-      return;
-    }
-    if (nonSlotTemplateChildren.length) {
-      if (hasStaticSlot(slots, "default")) {
-        context.options.onError(
-          createCompilerError4(
-            ErrorCodes4.X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN,
-            resolveLocation(nonSlotTemplateChildren[0].loc, context)
-          )
-        );
-      } else {
-        registerSlot(slots, arg, block);
-        context.slots = slots;
-      }
-    } else if (hasOtherSlots) {
-      context.slots = slots;
-    }
-  };
+	const { children } = node;
+	const arg = dir && dir.arg;
+	const nonSlotTemplateChildren = children.filter((n) => !isEmptyText(n) && (n.type !== "JSXElement" || !findProp(n, "v-slot")));
+	const [block, onExit] = createSlotBlock(node, dir, context);
+	const { slots } = context;
+	return () => {
+		onExit();
+		const hasOtherSlots = !!slots.length;
+		if (dir && hasOtherSlots) {
+			context.options.onError(createCompilerError(ErrorCodes.X_V_SLOT_MIXED_SLOT_USAGE, dir.loc));
+			return;
+		}
+		if (nonSlotTemplateChildren.length) if (hasStaticSlot(slots, "default")) context.options.onError(createCompilerError(ErrorCodes.X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN, resolveLocation(nonSlotTemplateChildren[0].loc, context)));
+		else {
+			registerSlot(slots, arg, block);
+			context.slots = slots;
+		}
+		else if (hasOtherSlots) context.slots = slots;
+	};
 }
-var elseIfRE = /^v-else(-if)?$/;
+const elseIfRE = /^v-else(-if)?$/;
 function transformTemplateSlot(node, dir, context) {
-  context.dynamic.flags |= 2 /* NON_TEMPLATE */;
-  const arg = dir.arg && resolveSimpleExpressionNode(dir.arg);
-  const vFor = findProp(node, "v-for");
-  const vIf = findProp(node, "v-if");
-  const vElse = findProp(node, elseIfRE);
-  const { slots } = context;
-  const [block, onExit] = createSlotBlock(node, dir, context);
-  if (!vFor && !vIf && !vElse) {
-    const slotName = arg ? arg.isStatic && arg.content : "default";
-    if (slotName && hasStaticSlot(slots, slotName)) {
-      context.options.onError(
-        createCompilerError4(ErrorCodes4.X_V_SLOT_DUPLICATE_SLOT_NAMES, dir.loc)
-      );
-    } else {
-      registerSlot(slots, arg, block);
-    }
-  } else if (vIf) {
-    const vIfDir = resolveDirectiveNode(vIf, context);
-    registerDynamicSlot(slots, {
-      slotType: 3 /* CONDITIONAL */,
-      condition: vIfDir.exp,
-      positive: {
-        slotType: 1 /* DYNAMIC */,
-        name: arg,
-        fn: block
-      }
-    });
-  } else if (vElse) {
-    const vElseDir = resolveDirectiveNode(vElse, context);
-    const vIfSlot = slots.at(-1);
-    if (vIfSlot.slotType === 3 /* CONDITIONAL */) {
-      let ifNode = vIfSlot;
-      while (ifNode.negative && ifNode.negative.slotType === 3 /* CONDITIONAL */)
-        ifNode = ifNode.negative;
-      const negative = vElseDir.exp ? {
-        slotType: 3 /* CONDITIONAL */,
-        condition: vElseDir.exp,
-        positive: {
-          slotType: 1 /* DYNAMIC */,
-          name: arg,
-          fn: block
-        }
-      } : {
-        slotType: 1 /* DYNAMIC */,
-        name: arg,
-        fn: block
-      };
-      ifNode.negative = negative;
-    } else {
-      context.options.onError(
-        createCompilerError4(ErrorCodes4.X_V_ELSE_NO_ADJACENT_IF, vElseDir.loc)
-      );
-    }
-  } else if (vFor) {
-    const forParseResult = getForParseResult(vFor, context);
-    if (forParseResult.source) {
-      registerDynamicSlot(slots, {
-        slotType: 2 /* LOOP */,
-        name: arg,
-        fn: block,
-        loop: forParseResult
-      });
-    }
-  }
-  return onExit;
+	context.dynamic.flags |= DynamicFlag.NON_TEMPLATE;
+	const arg = dir.arg && resolveSimpleExpressionNode(dir.arg);
+	const vFor = findProp(node, "v-for");
+	const vIf = findProp(node, "v-if");
+	const vElse = findProp(node, elseIfRE);
+	const { slots } = context;
+	const [block, onExit] = createSlotBlock(node, dir, context);
+	if (!vFor && !vIf && !vElse) {
+		const slotName = arg ? arg.isStatic && arg.content : "default";
+		if (slotName && hasStaticSlot(slots, slotName)) context.options.onError(createCompilerError(ErrorCodes.X_V_SLOT_DUPLICATE_SLOT_NAMES, dir.loc));
+		else registerSlot(slots, arg, block);
+	} else if (vIf) {
+		const vIfDir = resolveDirective(vIf, context);
+		registerDynamicSlot(slots, {
+			slotType: IRSlotType.CONDITIONAL,
+			condition: vIfDir.exp,
+			positive: {
+				slotType: IRSlotType.DYNAMIC,
+				name: arg,
+				fn: block
+			}
+		});
+	} else if (vElse) {
+		const vElseDir = resolveDirective(vElse, context);
+		const vIfSlot = slots.at(-1);
+		if (vIfSlot.slotType === IRSlotType.CONDITIONAL) {
+			let ifNode = vIfSlot;
+			while (ifNode.negative && ifNode.negative.slotType === IRSlotType.CONDITIONAL) ifNode = ifNode.negative;
+			const negative = vElseDir.exp ? {
+				slotType: IRSlotType.CONDITIONAL,
+				condition: vElseDir.exp,
+				positive: {
+					slotType: IRSlotType.DYNAMIC,
+					name: arg,
+					fn: block
+				}
+			} : {
+				slotType: IRSlotType.DYNAMIC,
+				name: arg,
+				fn: block
+			};
+			ifNode.negative = negative;
+		} else context.options.onError(createCompilerError(ErrorCodes.X_V_ELSE_NO_ADJACENT_IF, vElseDir.loc));
+	} else if (vFor) {
+		const forParseResult = getForParseResult(vFor, context);
+		if (forParseResult.source) registerDynamicSlot(slots, {
+			slotType: IRSlotType.LOOP,
+			name: arg,
+			fn: block,
+			loop: forParseResult
+		});
+	}
+	return onExit;
 }
 function ensureStaticSlots(slots) {
-  let lastSlots = slots.at(-1);
-  if (!slots.length || lastSlots.slotType !== 0 /* STATIC */) {
-    slots.push(
-      lastSlots = {
-        slotType: 0 /* STATIC */,
-        slots: {}
-      }
-    );
-  }
-  return lastSlots.slots;
+	let lastSlots = slots.at(-1);
+	if (!slots.length || lastSlots.slotType !== IRSlotType.STATIC) slots.push(lastSlots = {
+		slotType: IRSlotType.STATIC,
+		slots: {}
+	});
+	return lastSlots.slots;
 }
 function registerSlot(slots, name, block) {
-  const isStatic = !name || name.isStatic;
-  if (isStatic) {
-    const staticSlots = ensureStaticSlots(slots);
-    staticSlots[name ? name.content : "default"] = block;
-  } else {
-    slots.push({
-      slotType: 1 /* DYNAMIC */,
-      name,
-      fn: block
-    });
-  }
+	const isStatic = !name || name.isStatic;
+	if (isStatic) {
+		const staticSlots = ensureStaticSlots(slots);
+		staticSlots[name ? name.content : "default"] = block;
+	} else slots.push({
+		slotType: IRSlotType.DYNAMIC,
+		name,
+		fn: block
+	});
 }
 function registerDynamicSlot(allSlots, dynamic) {
-  allSlots.push(dynamic);
+	allSlots.push(dynamic);
 }
 function hasStaticSlot(slots, name) {
-  return slots.some(
-    (slot) => slot.slotType === 0 /* STATIC */ ? !!slot.slots[name] : false
-  );
+	return slots.some((slot) => slot.slotType === IRSlotType.STATIC ? !!slot.slots[name] : false);
 }
 function createSlotBlock(slotNode, dir, context) {
-  const block = newBlock(slotNode);
-  block.props = dir && dir.exp;
-  const exitBlock = context.enterBlock(block);
-  return [block, exitBlock];
+	const block = newBlock(slotNode);
+	block.props = dir && dir.exp;
+	const exitBlock = context.enterBlock(block);
+	return [block, exitBlock];
 }
 
-// src/transforms/vSlots.ts
-import { createCompilerError as createCompilerError5, ErrorCodes as ErrorCodes5 } from "@vue/compiler-dom";
-var transformVSlots = (dir, node, context) => {
-  if (!isJSXComponent(node)) return;
-  if (dir.value?.type === "JSXExpressionContainer") {
-    context.slots = [
-      {
-        slotType: 4 /* EXPRESSION */,
-        slots: resolveExpression(dir.value.expression, context)
-      }
-    ];
-    if (node.children.length) {
-      context.options.onError(
-        createCompilerError5(
-          ErrorCodes5.X_V_SLOT_MIXED_SLOT_USAGE,
-          resolveLocation(node.children[0].loc, context)
-        )
-      );
-    }
-  }
+//#endregion
+//#region src/transforms/vSlots.ts
+const transformVSlots = (dir, node, context) => {
+	if (!isJSXComponent(node)) return;
+	if (dir.value?.type === "JSXExpressionContainer") {
+		context.slots = [{
+			slotType: IRSlotType.EXPRESSION,
+			slots: resolveExpression(dir.value.expression, context)
+		}];
+		if (node.children.length) context.options.onError(createCompilerError(ErrorCodes.X_V_SLOT_MIXED_SLOT_USAGE, resolveLocation(node.children[0].loc, context)));
+	}
 };
 
-// src/transforms/vText.ts
-import { transformVText as _transformVText } from "@vue/compiler-vapor";
-var transformVText = (dir, node, context) => {
-  return _transformVText(
-    resolveDirectiveNode(dir, context),
-    resolveNode(node, context),
-    context
-  );
+//#endregion
+//#region src/transforms/vText.ts
+const transformVText = (dir, node, context) => {
+	let exp;
+	const loc = resolveLocation(dir.loc, context);
+	if (!dir.value) {
+		context.options.onError(createDOMCompilerError(DOMErrorCodes.X_V_TEXT_NO_EXPRESSION, loc));
+		exp = EMPTY_EXPRESSION;
+	} else exp = resolveExpression(dir.value, context);
+	if (node.children.length) {
+		context.options.onError(createDOMCompilerError(DOMErrorCodes.X_V_TEXT_WITH_CHILDREN, loc));
+		context.childrenTemplate.length = 0;
+	}
+	if (isVoidTag(getText(node.openingElement.name, context))) return;
+	const literal = getLiteralExpressionValue(exp);
+	if (literal != null) context.childrenTemplate = [String(literal)];
+	else {
+		context.childrenTemplate = [" "];
+		context.registerOperation({
+			type: IRNodeTypes.GET_TEXT_CHILD,
+			parent: context.reference()
+		});
+		context.registerEffect([exp], {
+			type: IRNodeTypes.SET_TEXT,
+			element: context.reference(),
+			values: [exp],
+			generated: true
+		});
+	}
 };
 
-// src/compile.ts
+//#endregion
+//#region src/compile.ts
 function compile(source, options = {}) {
-  const resolvedOptions = extend5({}, options, {
-    inline: true,
-    prefixIdentifiers: false,
-    expressionPlugins: options.expressionPlugins || ["jsx"]
-  });
-  if (!resolvedOptions.source && isString3(source)) {
-    resolvedOptions.source = source;
-  }
-  if (resolvedOptions.isTS) {
-    const { expressionPlugins } = resolvedOptions;
-    if (!expressionPlugins.includes("typescript")) {
-      resolvedOptions.expressionPlugins = [
-        ...expressionPlugins || [],
-        "typescript"
-      ];
-    }
-  }
-  const root = isString3(source) ? parse(source, {
-    sourceType: "module",
-    plugins: resolvedOptions.expressionPlugins
-  }).program.body[0].expression : source;
-  const children = root.type === "JSXFragment" ? root.children : root.type === "JSXElement" ? [root] : [];
-  const ast = {
-    type: 0 /* ROOT */,
-    children,
-    source: resolvedOptions.source || ""
-  };
-  const [nodeTransforms, directiveTransforms] = getBaseTransformPreset();
-  const ir = transform(
-    ast,
-    extend5({}, resolvedOptions, {
-      nodeTransforms: [
-        ...nodeTransforms,
-        ...resolvedOptions.nodeTransforms || []
-        // user transforms
-      ],
-      directiveTransforms: extend5(
-        {},
-        directiveTransforms,
-        resolvedOptions.directiveTransforms || {}
-        // user transforms
-      )
-    })
-  );
-  return generate(ir, {
-    ...resolvedOptions,
-    customGenOperation
-  });
+	const resolvedOptions = extend({}, options, {
+		inline: true,
+		prefixIdentifiers: false,
+		expressionPlugins: options.expressionPlugins || ["jsx"]
+	});
+	if (!resolvedOptions.source && isString(source)) resolvedOptions.source = source;
+	if (resolvedOptions.isTS) {
+		const { expressionPlugins } = resolvedOptions;
+		if (!expressionPlugins.includes("typescript")) resolvedOptions.expressionPlugins = [...expressionPlugins || [], "typescript"];
+	}
+	const root = isString(source) ? parse(source, {
+		sourceType: "module",
+		plugins: resolvedOptions.expressionPlugins
+	}).program.body[0].expression : source;
+	const children = root.type === "JSXFragment" ? root.children : root.type === "JSXElement" ? [root] : [];
+	const ast = {
+		type: IRNodeTypes.ROOT,
+		children,
+		source: resolvedOptions.source || ""
+	};
+	const [nodeTransforms, directiveTransforms] = getBaseTransformPreset();
+	const ir = transform(ast, extend({}, resolvedOptions, {
+		nodeTransforms: [...nodeTransforms, ...resolvedOptions.nodeTransforms || []],
+		directiveTransforms: extend({}, directiveTransforms, resolvedOptions.directiveTransforms || {})
+	}));
+	return generate(ir, {
+		...resolvedOptions,
+		customGenOperation
+	});
 }
 function getBaseTransformPreset() {
-  return [
-    [
-      transformVOnce,
-      transformVIf,
-      transformVFor,
-      transformTemplateRef,
-      transformText,
-      transformElement,
-      transformVSlot,
-      transformChildren
-    ],
-    {
-      bind: transformVBind,
-      on: transformVOn,
-      model: transformVModel,
-      show: transformVShow,
-      html: transformVHtml,
-      text: transformVText,
-      slots: transformVSlots
-    }
-  ];
+	return [[
+		transformVOnce,
+		transformVIf,
+		transformVFor,
+		transformTemplateRef,
+		transformText,
+		transformElement,
+		transformVSlot,
+		transformChildren
+	], {
+		bind: transformVBind,
+		on: transformVOn,
+		model: transformVModel,
+		show: transformVShow,
+		html: transformVHtml,
+		text: transformVText,
+		slots: transformVSlots
+	}];
 }
-export {
-  DynamicFlag,
-  IRDynamicPropsKind,
-  IRNodeTypes,
-  IRSlotType,
-  TransformContext,
-  compile,
-  createStructuralDirectiveTransform,
-  generate,
-  isBlockOperation,
-  resolveDirectiveNode,
-  resolveNode,
-  transform,
-  transformChildren,
-  transformElement,
-  transformNode,
-  transformTemplateRef,
-  transformText,
-  transformVBind,
-  transformVFor,
-  transformVHtml,
-  transformVIf,
-  transformVModel,
-  transformVOn,
-  transformVOnce,
-  transformVShow,
-  transformVSlot,
-  transformVSlots,
-  transformVText
-};
+
+//#endregion
+export { DynamicFlag, IRDynamicPropsKind, IRNodeTypes, IRSlotType, TransformContext, compile, createStructuralDirectiveTransform, generate, isBlockOperation, transform, transformChildren, transformElement, transformNode, transformTemplateRef, transformText, transformVBind, transformVFor, transformVHtml, transformVIf, transformVModel, transformVOn, transformVOnce, transformVShow, transformVSlot, transformVSlots, transformVText };