@vue-jsx-vapor/compiler 0.2.4 → 0.2.5

package/dist/index.cjs

@@ -66,40 +66,6 @@ var DynamicFlag = /* @__PURE__ */ ((DynamicFlag2) => {
 
 
 var _types = require('@babel/types');
-function newDynamic() {
-  return {
-    flags: 1 /* REFERENCED */,
-    children: []
-  };
-}
-function newBlock(node) {
-  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];
-}
-function wrapFragment(node) {
-  if (node.type === "JSXFragment") {
-    return node;
-  }
-  return _types.jsxFragment.call(void 0, _types.jsxOpeningFragment.call(void 0, ), _types.jsxClosingFragment.call(void 0, ), [
-    node.type === "JSXElement" ? node : _types.jsxExpressionContainer.call(void 0, node)
-  ]);
-}
-var EMPTY_EXPRESSION = _compilerdom.createSimpleExpression.call(void 0, "", true);
 
 // src/utils.ts
 
@@ -114,6 +80,7 @@ var EMPTY_EXPRESSION = _compilerdom.createSimpleExpression.call(void 0, "", true
 
 
 
+
 function propToExpression(prop, context) {
   return prop.type === "JSXAttribute" && _optionalChain([prop, 'access', _2 => _2.value, 'optionalAccess', _3 => _3.type]) === "JSXExpressionContainer" ? resolveExpression(prop.value.expression, context) : EMPTY_EXPRESSION;
 }
@@ -170,6 +137,15 @@ function resolveJSXText(node) {
 function isEmptyText(node) {
   return node.type === "JSXText" && EMPTY_TEXT_REGEX.test(`${_optionalChain([node, 'access', _6 => _6.extra, 'optionalAccess', _7 => _7.raw])}`) || node.type === "JSXExpressionContainer" && node.expression.type === "JSXEmptyExpression";
 }
+function resolveSimpleExpressionNode(exp) {
+  if (!exp.isStatic) {
+    const value = getLiteralExpressionValue(exp);
+    if (value !== null) {
+      return _compilerdom.createSimpleExpression.call(void 0, `${value}`, true, exp.loc);
+    }
+  }
+  return exp;
+}
 function resolveExpression(node, context, effect = false) {
   node = _optionalChain([node, 'optionalAccess', _8 => _8.type]) === "JSXExpressionContainer" ? node.expression : node;
   const isStatic = !!node && (node.type === "StringLiteral" || node.type === "JSXText" || node.type === "JSXIdentifier");
@@ -269,23 +245,54 @@ function resolveNode(node, context) {
     codegenNode: void 0
   };
 }
-function resolveDirectiveNode(node, context) {
+var namespaceRE = /^(?:\$([\w-]+)\$)?([\w-]+)?/;
+function resolveDirectiveNode(node, context, withFn = false) {
   const { value, name } = node;
-  const nameString = name.type === "JSXIdentifier" ? name.name : "";
-  const argString = name.type === "JSXNamespacedName" ? name.namespace.name : "";
-  const arg = name.type === "JSXNamespacedName" ? resolveSimpleExpression(argString, true, name.namespace.loc) : void 0;
-  const exp = value ? resolveExpression(value, context) : void 0;
-  const [tag, ...modifiers] = argString.split("_");
+  const nameString = name.type === "JSXNamespacedName" ? name.namespace.name : name.type === "JSXIdentifier" ? name.name : "";
+  let argString = name.type === "JSXNamespacedName" ? name.name.name : "";
+  if (name.type !== "JSXNamespacedName" && !argString) {
+    const [, modifiers2] = nameString.split("_");
+    argString = `_${modifiers2}`;
+  }
+  let modifiers = [];
+  let isStatic = true;
+  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 = argString && name.type === "JSXNamespacedName" ? resolveSimpleExpression(argString, isStatic, name.name.loc) : void 0;
+  const exp = value ? withFn && value.type === "JSXExpressionContainer" ? resolveExpressionWithFn(value.expression, context) : resolveExpression(value, context) : void 0;
   return {
     type: _compilerdom.NodeTypes.DIRECTIVE,
     name: nameString,
-    rawName: `${name}:${tag}`,
+    rawName: `${nameString}:${argString}`,
     exp,
     arg,
     loc: resolveLocation(node.loc, context),
     modifiers: modifiers.map((modifier) => _compilerdom.createSimpleExpression.call(void 0, modifier))
   };
 }
+function resolveExpressionWithFn(node, context) {
+  const text = getText(node, context);
+  return node.type === "Identifier" ? resolveSimpleExpression(text, false, node.loc) : resolveSimpleExpression(
+    text,
+    false,
+    node.loc,
+    _parser.parseExpression.call(void 0, `(${text})=>{}`, {
+      plugins: ["typescript"]
+    })
+  );
+}
 function isJSXComponent(node) {
   if (node.type !== "JSXElement") return false;
   const { openingElement } = node;
@@ -299,7 +306,8 @@ function isJSXComponent(node) {
 function findProp(expression, key) {
   if (_optionalChain([expression, 'optionalAccess', _9 => _9.type]) === "JSXElement") {
     for (const attr of expression.openingElement.attributes) {
-      if (attr.type === "JSXAttribute" && attr.name.name === key) {
+      const name = attr.type === "JSXAttribute" && (attr.name.type === "JSXIdentifier" ? attr.name.name : attr.name.type === "JSXNamespacedName" ? attr.name.namespace.name : "").split("_")[0];
+      if (name && (_shared.isString.call(void 0, key) ? name === key : key.test(name))) {
         return attr;
       }
     }
@@ -308,6 +316,47 @@ function findProp(expression, key) {
 function getText(node, content) {
   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";
+  }
+}
+
+// src/transforms/utils.ts
+function newDynamic() {
+  return {
+    flags: 1 /* REFERENCED */,
+    children: []
+  };
+}
+function newBlock(node) {
+  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];
+}
+function wrapFragment(node) {
+  if (node.type === "JSXFragment" || isTemplate(node)) {
+    return node;
+  }
+  return _types.jsxFragment.call(void 0, _types.jsxOpeningFragment.call(void 0, ), _types.jsxClosingFragment.call(void 0, ), [
+    node.type === "JSXElement" ? node : _types.jsxExpressionContainer.call(void 0, node)
+  ]);
+}
+var EMPTY_EXPRESSION = _compilerdom.createSimpleExpression.call(void 0, "", true);
 
 // src/transform.ts
 var defaultOptions = {
@@ -471,9 +520,9 @@ function createStructuralDirectiveTransform(name, fn) {
   return (node, context) => {
     if (node.type === "JSXElement") {
       const {
-        openingElement: { attributes, name: name2 }
+        openingElement: { attributes }
       } = node;
-      if (getText(name2, context) === "template" && findProp(node, "v-slot")) {
+      if (isTemplate(node) && findProp(node, "v-slot")) {
         return;
       }
       const exitFns = [];
@@ -507,7 +556,7 @@ var transformElement = (node, context) => {
   return function postTransformElement() {
     ;
     ({ node } = context);
-    if (node.type !== "JSXElement") return;
+    if (node.type !== "JSXElement" || isTemplate(node)) return;
     const {
       openingElement: { name }
     } = node;
@@ -518,7 +567,11 @@ var transformElement = (node, context) => {
       context,
       isComponent
     );
-    const singleRoot = context.root === context.parent && context.parent.node.children.filter((child) => !isJSXComponent(child)).length === 1;
+    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,
@@ -653,6 +706,7 @@ function buildProps(node, context, isComponent) {
 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) && (!prop.value || prop.value.type === "StringLiteral")) {
     if (isReservedProp(name)) return;
     return {
@@ -709,7 +763,7 @@ function mergePropValues(existing, incoming) {
 
 // src/transforms/transformChildren.ts
 var transformChildren = (node, context) => {
-  const isFragment = node.type === 0 /* ROOT */ || node.type === "JSXFragment" || isJSXComponent(node);
+  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);
@@ -868,7 +922,7 @@ var transformText = (node, context) => {
     context.dynamic.flags |= 2 /* NON_TEMPLATE */;
     return;
   }
-  if (node.type === "JSXElement" && !isJSXComponent(node) && isAllTextLike(node.children)) {
+  if (node.type === "JSXElement" && !isTemplate(node) && !isJSXComponent(node) && isAllTextLike(node.children)) {
     processTextLikeContainer(
       node.children,
       context
@@ -1037,42 +1091,211 @@ var transformVOn = (dir, node, context) => {
 };
 
 // src/transforms/vSlot.ts
-var transformVSlot = (node, context) => {
-  if (node.type !== "JSXElement") return;
-  if (!isJSXComponent(node)) return;
-  const { openingElement, children } = node;
-  const vSlotsIndex = openingElement.attributes.findIndex(
-    (attr) => attr.type === "JSXAttribute" && ["v-slots", "vSlots"].includes(attr.name.name.toString())
-  );
-  const vSlotsDir = openingElement.attributes[vSlotsIndex];
-  if (vSlotsDir && _optionalChain([vSlotsDir, 'access', _16 => _16.value, 'optionalAccess', _17 => _17.type]) === "JSXExpressionContainer") {
-    node.openingElement.attributes.splice(vSlotsIndex, 1);
-    context.slots = [
-      {
-        slotType: 4 /* EXPRESSION */,
-        slots: resolveExpression(vSlotsDir.value.expression, context)
+
+
+
+
+
+// src/transforms/vFor.ts
+
+
+
+
+
+var transformVFor = createStructuralDirectiveTransform(
+  "for",
+  processFor
+);
+function processFor(node, dir, context) {
+  const { value, index, key, source } = getForParseResult(dir, context);
+  if (!source) {
+    context.options.onError(
+      _compilerdom.createCompilerError.call(void 0, 
+        _compilerdom.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.registerOperation({
+      type: 17 /* FOR */,
+      id,
+      source,
+      value,
+      key,
+      index,
+      keyProp: keyProperty,
+      render,
+      once: context.inVOnce || !!(source.ast && _compilerdom.isConstantNode.call(void 0, 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(
+      _compilerdom.createCompilerError.call(void 0, 
+        _compilerdom.ErrorCodes.X_V_FOR_NO_EXPRESSION,
+        resolveLocation(dir.loc, context)
+      )
+    );
   }
-  if (children.length) {
-    return transformComponentSlot(node, context);
+  return {
+    value,
+    index,
+    key,
+    source
+  };
+}
+
+// src/transforms/vSlot.ts
+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(
+      _compilerdom.createCompilerError.call(void 0, 
+        _compilerdom.ErrorCodes.X_V_SLOT_MISPLACED,
+        resolveLocation(dir.loc, context)
+      )
+    );
   }
 };
-function transformComponentSlot(node, context) {
+function transformComponentSlot(node, dir, context) {
   const { children } = node;
-  const nonWhitespaceChildren = children.filter(
-    () => isNonWhitespaceContent(node)
+  const arg = dir && dir.arg;
+  const nonSlotTemplateChildren = children.filter(
+    (n) => isNonWhitespaceContent(n) && !(n.type === "JSXElement" && findProp(n, "v-slot"))
   );
-  const [block, onExit] = createSlotBlock(node, context);
+  const [block, onExit] = createSlotBlock(node, dir, context);
   const { slots } = context;
   return () => {
     onExit();
-    if (nonWhitespaceChildren.length) {
-      registerSlot(slots, block);
+    const hasOtherSlots = !!slots.length;
+    if (dir && hasOtherSlots) {
+      context.options.onError(
+        _compilerdom.createCompilerError.call(void 0, _compilerdom.ErrorCodes.X_V_SLOT_MIXED_SLOT_USAGE, dir.loc)
+      );
+      return;
+    }
+    if (nonSlotTemplateChildren.length) {
+      if (hasStaticSlot(slots, "default")) {
+        context.options.onError(
+          _compilerdom.createCompilerError.call(void 0, 
+            _compilerdom.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 = /^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(
+        _compilerdom.createCompilerError.call(void 0, _compilerdom.ErrorCodes.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(
+        _compilerdom.createCompilerError.call(void 0, _compilerdom.ErrorCodes.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;
+}
 function ensureStaticSlots(slots) {
   let lastSlots = slots.at(-1);
   if (!slots.length || lastSlots.slotType !== 0 /* STATIC */) {
@@ -1083,14 +1306,32 @@ function ensureStaticSlots(slots) {
       }
     );
   }
-  return lastSlots;
+  return lastSlots.slots;
 }
-function registerSlot(slots, block) {
-  const staticSlots = ensureStaticSlots(slots);
-  staticSlots.slots.default = block;
+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
+    });
+  }
 }
-function createSlotBlock(slotNode, context) {
+function registerDynamicSlot(allSlots, dynamic) {
+  allSlots.push(dynamic);
+}
+function hasStaticSlot(slots, name) {
+  return slots.some(
+    (slot) => slot.slotType === 0 /* 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];
 }
@@ -1099,6 +1340,37 @@ function isNonWhitespaceContent(node) {
   return !!node.value.trim();
 }
 
+// src/transforms/vSlots.ts
+
+var transformVSlots = (node, context) => {
+  if (node.type !== "JSXElement" || !isJSXComponent(node)) return;
+  const {
+    openingElement: { attributes },
+    children
+  } = node;
+  const vSlotsIndex = attributes.findIndex(
+    (attr) => attr.type === "JSXAttribute" && attr.name.name.toString() === "v-slots"
+  );
+  const vSlotsDir = attributes[vSlotsIndex];
+  if (vSlotsDir && _optionalChain([vSlotsDir, 'access', _16 => _16.value, 'optionalAccess', _17 => _17.type]) === "JSXExpressionContainer") {
+    attributes.splice(vSlotsIndex, 1);
+    context.slots = [
+      {
+        slotType: 4 /* EXPRESSION */,
+        slots: resolveExpression(vSlotsDir.value.expression, context)
+      }
+    ];
+    if (children.length) {
+      context.options.onError(
+        _compilerdom.createCompilerError.call(void 0, 
+          _compilerdom.ErrorCodes.X_V_SLOT_MIXED_SLOT_USAGE,
+          resolveLocation(children[0].loc, context)
+        )
+      );
+    }
+  }
+};
+
 // src/transforms/vModel.ts
 
 var transformVModel = (dir, node, context) => {
@@ -1129,86 +1401,6 @@ var transformVHtml = (dir, node, context) => {
   );
 };
 
-// src/transforms/vFor.ts
-
-
-
-
-
-
-
-var transformVFor = createStructuralDirectiveTransform(
-  "for",
-  processFor
-);
-function processFor(node, dir, context) {
-  if (!dir.value) {
-    context.options.onError(
-      _compilerdom.createCompilerError.call(void 0, 
-        _compilerdom.ErrorCodes.X_V_FOR_NO_EXPRESSION,
-        resolveLocation(dir.loc, context)
-      )
-    );
-    return;
-  }
-  if (!_compilerdom.forAliasRE) {
-    context.options.onError(
-      _compilerdom.createCompilerError.call(void 0, 
-        _compilerdom.ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION,
-        resolveLocation(dir.loc, context)
-      )
-    );
-    return;
-  }
-  let value, index, key, source;
-  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] && resolveValueExpression(expressions[0], context);
-      key = expressions[1] && resolveExpression(expressions[1], context);
-      index = expressions[2] && resolveExpression(expressions[2], context);
-    } else {
-      value = resolveValueExpression(dir.value.expression.left, context);
-    }
-    source = resolveExpression(dir.value.expression.right, context);
-  }
-  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.registerOperation({
-      type: 17 /* FOR */,
-      id,
-      source,
-      value,
-      key,
-      index,
-      keyProp: keyProperty,
-      render,
-      once: context.inVOnce || !!(source.ast && _compilerdom.isConstantNode.call(void 0, source.ast, {})),
-      component: isComponent,
-      onlyChild: !!isOnlyChild
-    });
-  };
-}
-function resolveValueExpression(node, context) {
-  const text = getText(node, context);
-  return node.type === "Identifier" ? resolveSimpleExpression(text, false, node.loc) : resolveSimpleExpression(
-    text,
-    false,
-    node.loc,
-    _parser.parseExpression.call(void 0, `(${text})=>{}`, {
-      plugins: ["typescript"]
-    })
-  );
-}
-
 // src/compile.ts
 function compile(source, options = {}) {
   const resolvedOptions = _shared.extend.call(void 0, {}, options, {
@@ -1264,6 +1456,7 @@ function getBaseTransformPreset() {
       transformTemplateRef,
       transformText,
       transformElement,
+      transformVSlots,
       transformVSlot,
       transformChildren
     ],
@@ -1300,4 +1493,5 @@ function getBaseTransformPreset() {
 
 
 
-exports.DynamicFlag = DynamicFlag; exports.IRDynamicPropsKind = IRDynamicPropsKind; exports.IRNodeTypes = IRNodeTypes; exports.IRSlotType = IRSlotType; exports.TransformContext = TransformContext; exports.compile = compile; exports.createStructuralDirectiveTransform = createStructuralDirectiveTransform; exports.generate = _compilervapor.generate; exports.resolveDirectiveNode = resolveDirectiveNode; exports.resolveNode = resolveNode; exports.transform = transform; exports.transformChildren = transformChildren; exports.transformElement = transformElement; exports.transformNode = transformNode; exports.transformTemplateRef = transformTemplateRef; exports.transformText = transformText; exports.transformVBind = transformVBind; exports.transformVFor = transformVFor; exports.transformVHtml = transformVHtml; exports.transformVModel = transformVModel; exports.transformVOn = transformVOn; exports.transformVShow = transformVShow; exports.transformVSlot = transformVSlot;
+
+exports.DynamicFlag = DynamicFlag; exports.IRDynamicPropsKind = IRDynamicPropsKind; exports.IRNodeTypes = IRNodeTypes; exports.IRSlotType = IRSlotType; exports.TransformContext = TransformContext; exports.compile = compile; exports.createStructuralDirectiveTransform = createStructuralDirectiveTransform; exports.generate = _compilervapor.generate; exports.resolveDirectiveNode = resolveDirectiveNode; exports.resolveNode = resolveNode; exports.transform = transform; exports.transformChildren = transformChildren; exports.transformElement = transformElement; exports.transformNode = transformNode; exports.transformTemplateRef = transformTemplateRef; exports.transformText = transformText; exports.transformVBind = transformVBind; exports.transformVFor = transformVFor; exports.transformVHtml = transformVHtml; exports.transformVModel = transformVModel; exports.transformVOn = transformVOn; exports.transformVShow = transformVShow; exports.transformVSlot = transformVSlot; exports.transformVSlots = transformVSlots;

package/dist/index.d.cts

@@ -334,7 +334,7 @@ type TransformPreset = [
 ];
 
 declare function resolveNode(node: JSXElement, context: TransformContext): ElementNode;
-declare function resolveDirectiveNode(node: JSXAttribute, context: TransformContext): VaporDirectiveNode;
+declare function resolveDirectiveNode(node: JSXAttribute, context: TransformContext, withFn?: boolean): VaporDirectiveNode;
 
 declare const transformText: NodeTransform;
 
@@ -350,6 +350,8 @@ declare const transformVOn: DirectiveTransform;
 
 declare const transformVSlot: NodeTransform;
 
+declare const transformVSlots: NodeTransform;
+
 declare const transformVModel: DirectiveTransform;
 
 declare const transformVShow: DirectiveTransform;
@@ -358,4 +360,4 @@ declare const transformVHtml: DirectiveTransform;
 
 declare const transformVFor: NodeTransform;
 
-export { type BaseIRNode, type BlockIRNode, type CompilerOptions, type CreateComponentIRNode, type CreateTextNodeIRNode, type DeclareOldRefIRNode, type DirectiveIRNode, type DirectiveTransform, type DirectiveTransformResult, DynamicFlag, type ForIRNode, type GetTextChildIRNode, type HackOptions, type IRDynamicInfo, IRDynamicPropsKind, type IREffect, type IRFor, type IRNode, IRNodeTypes, type IRProp, type IRProps, type IRPropsDynamicAttribute, type IRPropsDynamicExpression, type IRPropsStatic, type IRSlotDynamic, type IRSlotDynamicBasic, type IRSlotDynamicConditional, type IRSlotDynamicLoop, IRSlotType, type IRSlots, type IRSlotsExpression, type IRSlotsStatic, type IfIRNode, type InsertNodeIRNode, type KeyOverride, type NodeTransform, type OperationNode, type PrependNodeIRNode, type RootIRNode, type RootNode, type SetDynamicEventsIRNode, type SetDynamicPropsIRNode, type SetEventIRNode, type SetHtmlIRNode, type SetPropIRNode, type SetTemplateRefIRNode, type SetTextIRNode, type SlotBlockIRNode, type SlotOutletIRNode, type StructuralDirectiveTransform, TransformContext, type TransformOptions, type TransformPreset, type VaporDirectiveNode, compile, createStructuralDirectiveTransform, resolveDirectiveNode, resolveNode, transform, transformChildren, transformElement, transformNode, transformTemplateRef, transformText, transformVBind, transformVFor, transformVHtml, transformVModel, transformVOn, transformVShow, transformVSlot };
+export { type BaseIRNode, type BlockIRNode, type CompilerOptions, type CreateComponentIRNode, type CreateTextNodeIRNode, type DeclareOldRefIRNode, type DirectiveIRNode, type DirectiveTransform, type DirectiveTransformResult, DynamicFlag, type ForIRNode, type GetTextChildIRNode, type HackOptions, type IRDynamicInfo, IRDynamicPropsKind, type IREffect, type IRFor, type IRNode, IRNodeTypes, type IRProp, type IRProps, type IRPropsDynamicAttribute, type IRPropsDynamicExpression, type IRPropsStatic, type IRSlotDynamic, type IRSlotDynamicBasic, type IRSlotDynamicConditional, type IRSlotDynamicLoop, IRSlotType, type IRSlots, type IRSlotsExpression, type IRSlotsStatic, type IfIRNode, type InsertNodeIRNode, type KeyOverride, type NodeTransform, type OperationNode, type PrependNodeIRNode, type RootIRNode, type RootNode, type SetDynamicEventsIRNode, type SetDynamicPropsIRNode, type SetEventIRNode, type SetHtmlIRNode, type SetPropIRNode, type SetTemplateRefIRNode, type SetTextIRNode, type SlotBlockIRNode, type SlotOutletIRNode, type StructuralDirectiveTransform, TransformContext, type TransformOptions, type TransformPreset, type VaporDirectiveNode, compile, createStructuralDirectiveTransform, resolveDirectiveNode, resolveNode, transform, transformChildren, transformElement, transformNode, transformTemplateRef, transformText, transformVBind, transformVFor, transformVHtml, transformVModel, transformVOn, transformVShow, transformVSlot, transformVSlots };