@vue-jsx-vapor/compiler 1.6.0 → 2.0.0

package/dist/index.js

@@ -1,16 +1,9 @@
 // src/compile.ts
-import { extend as extend5, isString as isString3 } from "@vue/shared";
+import { parse } from "@babel/parser";
 import {
   generate
 } from "@vue/compiler-vapor";
-import { parse } from "@babel/parser";
-
-// src/transform.ts
-import {
-  defaultOnError,
-  defaultOnWarn
-} from "@vue/compiler-dom";
-import { EMPTY_OBJ, NOOP, extend, isArray, isString as isString2 } from "@vue/shared";
+import { extend as extend5, isString as isString3 } from "@vue/shared";
 
 // src/ir/component.ts
 var IRDynamicPropsKind = /* @__PURE__ */ ((IRDynamicPropsKind2) => {
@@ -58,29 +51,36 @@ var DynamicFlag = /* @__PURE__ */ ((DynamicFlag2) => {
   return DynamicFlag2;
 })(DynamicFlag || {});
 
+// 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 { createSimpleExpression as createSimpleExpression2 } from "@vue/compiler-dom";
 import {
   jsxClosingFragment,
   jsxExpressionContainer,
   jsxFragment,
   jsxOpeningFragment
 } from "@babel/types";
+import { createSimpleExpression as createSimpleExpression2 } from "@vue/compiler-dom";
 
 // src/utils.ts
-import { isGloballyAllowed, isHTMLTag, isSVGTag, isString } from "@vue/shared";
+import { parseExpression } from "@babel/parser";
+import {
+  isLiteral
+} from "@babel/types";
 import {
+  createSimpleExpression,
   ElementTypes,
+  isLiteralWhitelisted,
   Namespaces,
   NodeTypes,
-  createSimpleExpression,
-  isLiteralWhitelisted,
   walkIdentifiers
 } from "@vue/compiler-dom";
-import {
-  isLiteral
-} from "@babel/types";
-import { parseExpression } from "@babel/parser";
+import { isGloballyAllowed, isHTMLTag, isString, isSVGTag } from "@vue/shared";
 function propToExpression(prop, context) {
   return prop.type === "JSXAttribute" && prop.value?.type === "JSXExpressionContainer" ? resolveExpression(prop.value.expression, context) : EMPTY_EXPRESSION;
 }
@@ -118,11 +118,11 @@ var isConstant = (node) => {
   }
   return false;
 };
-var EMPTY_TEXT_REGEX = /^\s*[\n\r]\s*$/;
+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*$/;
 function resolveJSXText(node) {
-  if (EMPTY_TEXT_REGEX.test(`${node.extra?.raw}`)) {
+  if (EMPTY_TEXT_REGEX.test(String(node.extra?.raw))) {
     return "";
   }
   let value = node.value;
@@ -135,13 +135,13 @@ function resolveJSXText(node) {
   return value;
 }
 function isEmptyText(node) {
-  return node.type === "JSXText" && EMPTY_TEXT_REGEX.test(`${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(`${value}`, true, exp.loc);
+      return createSimpleExpression(String(value), true, exp.loc);
     }
   }
   return exp;
@@ -222,7 +222,7 @@ function resolveNode(node, context) {
         } else {
           result.push({
             type: NodeTypes.ATTRIBUTE,
-            name: `${attr.name.name}`,
+            name: String(attr.name.name),
             nameLoc: resolveLocation(attr.name.loc, context),
             value: resolveValue(attr.value, context),
             loc: resolveLocation(attr.loc, context)
@@ -542,11 +542,78 @@ function createStructuralDirectiveTransform(name, fn) {
   };
 }
 
+// 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);
+  }
+};
+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();
+          context.registerOperation({
+            type: 9 /* INSERT_NODE */,
+            elements: prevDynamics.map((child2) => child2.id),
+            parent: context.reference(),
+            anchor
+          });
+        } else {
+          context.registerOperation({
+            type: 10 /* PREPEND_NODE */,
+            elements: prevDynamics.map((child2) => child2.id),
+            parent: context.reference()
+          });
+        }
+        prevDynamics = [];
+      }
+      hasStaticTemplate = true;
+    }
+  }
+  if (prevDynamics.length) {
+    context.registerOperation({
+      type: 9 /* INSERT_NODE */,
+      elements: prevDynamics.map((child) => child.id),
+      parent: context.reference()
+    });
+  }
+}
+
 // src/transforms/transformElement.ts
-import { extend as extend2, isBuiltInDirective, isVoidTag, makeMap } from "@vue/shared";
 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,"
@@ -762,73 +829,6 @@ function mergePropValues(existing, incoming) {
   existing.values.push(...newValues);
 }
 
-// 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);
-  }
-};
-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();
-          context.registerOperation({
-            type: 9 /* INSERT_NODE */,
-            elements: prevDynamics.map((child2) => child2.id),
-            parent: context.reference(),
-            anchor
-          });
-        } else {
-          context.registerOperation({
-            type: 10 /* PREPEND_NODE */,
-            elements: prevDynamics.map((child2) => child2.id),
-            parent: context.reference()
-          });
-        }
-        prevDynamics = [];
-      }
-      hasStaticTemplate = true;
-    }
-  }
-  if (prevDynamics.length) {
-    context.registerOperation({
-      type: 9 /* INSERT_NODE */,
-      elements: prevDynamics.map((child) => child.id),
-      parent: context.reference()
-    });
-  }
-}
-
 // src/transforms/transformTemplateRef.ts
 var transformTemplateRef = (node, context) => {
   if (node.type !== "JSXElement") return;
@@ -948,7 +948,7 @@ var transformText = (node, context) => {
 function processTextLike(context) {
   const nexts = context.parent.node.children?.slice(context.index);
   const idx = nexts.findIndex((n) => !isTextLike(n));
-  const nodes = idx > -1 ? nexts.slice(0, idx) : nexts;
+  const nodes = idx !== -1 ? nexts.slice(0, idx) : nexts;
   const values = createTextLikeExpressions(nodes, context);
   if (!values.length) {
     context.dynamic.flags |= 2 /* NON_TEMPLATE */;
@@ -991,7 +991,7 @@ function isAllTextLike(children) {
   children.some((n) => n.type === "JSXExpressionContainer");
 }
 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
@@ -1020,93 +1020,10 @@ var transformVBind = (dir, node, context) => {
   };
 };
 
-// src/transforms/vOn.ts
-import {
-  ErrorCodes,
-  createCompilerError,
-  createSimpleExpression as createSimpleExpression3,
-  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(
-      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) => createSimpleExpression3(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: 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);
-};
-
-// src/transforms/vSlot.ts
-import {
-  ErrorCodes as ErrorCodes3,
-  createCompilerError as createCompilerError3
-} from "@vue/compiler-dom";
-
 // src/transforms/vFor.ts
 import {
-  ErrorCodes as ErrorCodes2,
-  createCompilerError as createCompilerError2,
+  createCompilerError,
+  ErrorCodes,
   isConstantNode
 } from "@vue/compiler-dom";
 var transformVFor = createStructuralDirectiveTransform(
@@ -1117,8 +1034,8 @@ function processFor(node, dir, context) {
   const { value, index, key, source } = getForParseResult(dir, context);
   if (!source) {
     context.options.onError(
-      createCompilerError2(
-        ErrorCodes2.X_V_FOR_MALFORMED_EXPRESSION,
+      createCompilerError(
+        ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION,
         resolveLocation(dir.loc, context)
       )
     );
@@ -1165,8 +1082,8 @@ function getForParseResult(dir, context) {
     }
   } else {
     context.options.onError(
-      createCompilerError2(
-        ErrorCodes2.X_V_FOR_NO_EXPRESSION,
+      createCompilerError(
+        ErrorCodes.X_V_FOR_NO_EXPRESSION,
         resolveLocation(dir.loc, context)
       )
     );
@@ -1179,10 +1096,229 @@ function getForParseResult(dir, context) {
   };
 }
 
-// src/transforms/vSlot.ts
-var transformVSlot = (node, context) => {
-  if (node.type !== "JSXElement") return;
-  const { children } = node;
+// 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
+  );
+};
+
+// 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();
+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.registerOperation({
+        type: 16 /* IF */,
+        id,
+        condition: dir.exp,
+        positive: branch,
+        once: context.inVOnce || isConstantNode2(attribute.value, context.options.bindingMetadata)
+      });
+    };
+  } else {
+    const siblingIf = getSiblingIf(context);
+    const { operation } = context.block;
+    let lastIfNode = operation.at(-1);
+    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 !== 16 /* IF */
+    ) {
+      context.options.onError(
+        createCompilerError2(
+          ErrorCodes2.X_V_ELSE_NO_ADJACENT_IF,
+          resolveLocation(node.loc, context)
+        )
+      );
+      return;
+    }
+    while (lastIfNode.negative && lastIfNode.negative.type === 16 /* 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: 16 /* 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;
+  }
+}
+
+// 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
+  );
+};
+
+// 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: 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);
+};
+
+// src/transforms/vOnce.ts
+var transformVOnce = (node, context) => {
+  if (
+    // !context.inSSR &&
+    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
+  );
+};
+
+// 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;
@@ -1194,8 +1330,8 @@ var transformVSlot = (node, context) => {
     return transformTemplateSlot(node, resolvedDirective, context);
   } else if (!isComponent && dir) {
     context.options.onError(
-      createCompilerError3(
-        ErrorCodes3.X_V_SLOT_MISPLACED,
+      createCompilerError4(
+        ErrorCodes4.X_V_SLOT_MISPLACED,
         resolveLocation(dir.loc, context)
       )
     );
@@ -1205,7 +1341,7 @@ 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"))
+    (n) => !isEmptyText(n) && (n.type !== "JSXElement" || !findProp(n, "v-slot"))
   );
   const [block, onExit] = createSlotBlock(node, dir, context);
   const { slots } = context;
@@ -1214,15 +1350,15 @@ function transformComponentSlot(node, dir, context) {
     const hasOtherSlots = !!slots.length;
     if (dir && hasOtherSlots) {
       context.options.onError(
-        createCompilerError3(ErrorCodes3.X_V_SLOT_MIXED_SLOT_USAGE, dir.loc)
+        createCompilerError4(ErrorCodes4.X_V_SLOT_MIXED_SLOT_USAGE, dir.loc)
       );
       return;
     }
     if (nonSlotTemplateChildren.length) {
       if (hasStaticSlot(slots, "default")) {
         context.options.onError(
-          createCompilerError3(
-            ErrorCodes3.X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN,
+          createCompilerError4(
+            ErrorCodes4.X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN,
             resolveLocation(nonSlotTemplateChildren[0].loc, context)
           )
         );
@@ -1248,7 +1384,7 @@ function transformTemplateSlot(node, dir, context) {
     const slotName = arg ? arg.isStatic && arg.content : "default";
     if (slotName && hasStaticSlot(slots, slotName)) {
       context.options.onError(
-        createCompilerError3(ErrorCodes3.X_V_SLOT_DUPLICATE_SLOT_NAMES, dir.loc)
+        createCompilerError4(ErrorCodes4.X_V_SLOT_DUPLICATE_SLOT_NAMES, dir.loc)
       );
     } else {
       registerSlot(slots, arg, block);
@@ -1287,7 +1423,7 @@ function transformTemplateSlot(node, dir, context) {
       ifNode.negative = negative;
     } else {
       context.options.onError(
-        createCompilerError3(ErrorCodes3.X_V_ELSE_NO_ADJACENT_IF, vElseDir.loc)
+        createCompilerError4(ErrorCodes4.X_V_ELSE_NO_ADJACENT_IF, vElseDir.loc)
       );
     }
   } else if (vFor) {
@@ -1344,7 +1480,7 @@ function createSlotBlock(slotNode, dir, context) {
 }
 
 // src/transforms/vSlots.ts
-import { ErrorCodes as ErrorCodes4, createCompilerError as createCompilerError4 } from "@vue/compiler-dom";
+import { createCompilerError as createCompilerError5, ErrorCodes as ErrorCodes5 } from "@vue/compiler-dom";
 var transformVSlots = (node, context) => {
   if (node.type !== "JSXElement" || !isJSXComponent(node)) return;
   const {
@@ -1365,8 +1501,8 @@ var transformVSlots = (node, context) => {
     ];
     if (children.length) {
       context.options.onError(
-        createCompilerError4(
-          ErrorCodes4.X_V_SLOT_MIXED_SLOT_USAGE,
+        createCompilerError5(
+          ErrorCodes5.X_V_SLOT_MIXED_SLOT_USAGE,
           resolveLocation(children[0].loc, context)
         )
       );
@@ -1374,144 +1510,6 @@ var transformVSlots = (node, context) => {
   }
 };
 
-// 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
-  );
-};
-
-// 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
-  );
-};
-
-// 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
-  );
-};
-
-// src/transforms/vOnce.ts
-var transformVOnce = (node, context) => {
-  if (
-    // !context.inSSR &&
-    node.type === "JSXElement" && findProp(node, "v-once")
-  ) {
-    context.inVOnce = true;
-  }
-};
-
-// src/transforms/vIf.ts
-import {
-  ErrorCodes as ErrorCodes5,
-  createCompilerError as createCompilerError5,
-  createSimpleExpression as createSimpleExpression4,
-  isConstantNode as isConstantNode2
-} from "@vue/compiler-dom";
-var transformVIf = createStructuralDirectiveTransform(
-  ["if", "else", "else-if"],
-  processIf
-);
-var transformedIfNode = /* @__PURE__ */ 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(
-      createCompilerError5(ErrorCodes5.X_V_IF_NO_EXPRESSION, dir.loc)
-    );
-    dir.exp = createSimpleExpression4(`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.registerOperation({
-        type: 16 /* IF */,
-        id,
-        condition: dir.exp,
-        positive: branch,
-        once: context.inVOnce || isConstantNode2(attribute.value, context.options.bindingMetadata)
-      });
-    };
-  } else {
-    const siblingIf = getSiblingIf(context);
-    const { operation } = context.block;
-    let lastIfNode = operation.at(-1);
-    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 !== 16 /* IF */
-    ) {
-      context.options.onError(
-        createCompilerError5(
-          ErrorCodes5.X_V_ELSE_NO_ADJACENT_IF,
-          resolveLocation(node.loc, context)
-        )
-      );
-      return;
-    }
-    while (lastIfNode.negative && lastIfNode.negative.type === 16 /* IF */) {
-      lastIfNode = lastIfNode.negative;
-    }
-    if (dir.name === "else-if" && lastIfNode.negative) {
-      context.options.onError(
-        createCompilerError5(
-          ErrorCodes5.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: 16 /* 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;
-  }
-}
-
 // src/compile.ts
 function compile(source, options = {}) {
   const resolvedOptions = extend5({}, options, {