babel-plugin-essor 0.0.6-beta.13 → 0.0.6-beta.14

package/dist/index.cjs

@@ -116,17 +116,78 @@ var svgTags = [
   "use"
 ];
 
-// src/jsx/client.ts
+// src/jsx/shared.ts
 var import_core2 = require("@babel/core");
-function transformJSXClient(path) {
+function hasSiblingElement(path) {
+  function isSelfClosing(element) {
+    return element.openingElement.selfClosing;
+  }
+  const siblings = path.getAllPrevSiblings().concat(path.getAllNextSiblings());
+  const hasNonSelfClosingSibling = siblings.some(
+    (siblingPath) => siblingPath.isJSXElement() && !isSelfClosing(siblingPath.node)
+  );
+  return hasNonSelfClosingSibling;
+}
+function getAttrName(attribute) {
+  if (import_core2.types.isJSXIdentifier(attribute.name)) {
+    return attribute.name.name;
+  }
+  if (import_core2.types.isJSXNamespacedName(attribute.name)) {
+    return `${attribute.name.namespace.name}:${attribute.name.name.name}`;
+  }
+  throw new Error("Unsupported attribute type");
+}
+function getTagName(node) {
+  const tag = node.openingElement.name;
+  return jsxElementNameToString(tag);
+}
+function jsxElementNameToString(node) {
+  if (import_core2.types.isJSXMemberExpression(node)) {
+    return `${jsxElementNameToString(node.object)}.${jsxElementNameToString(node.property)}`;
+  }
+  if (import_core2.types.isJSXIdentifier(node) || import_core2.types.isIdentifier(node)) {
+    return node.name;
+  }
+  return `${node.namespace.name}:${node.name.name}`;
+}
+function isComponent(tagName) {
+  return tagName[0] && tagName[0].toLowerCase() !== tagName[0] || tagName.includes(".") || /[^A-Za-z]/.test(tagName[0]);
+}
+function isTextChild(path) {
+  if (path.isJSXExpressionContainer()) {
+    const expression = path.get("expression");
+    if (expression.isJSXText() || expression.isStringLiteral() || expression.isNumericLiteral()) {
+      return true;
+    }
+  }
+  if (path.isJSXText() || path.isStringLiteral() || path.isNullLiteral()) {
+    return true;
+  }
+  return false;
+}
+function setNodeText(path, text) {
+  if (path.isJSXText()) {
+    path.node.value = text;
+  }
+  if (path.isJSXExpressionContainer()) {
+    const expression = path.get("expression");
+    if (expression.isStringLiteral() || expression.isNumericLiteral()) {
+      expression.replaceWith(import_core2.types.stringLiteral(text));
+    }
+  }
+}
+
+// src/jsx/server.ts
+function transformJSXService(path) {
   const result = {
-    index: 1,
+    index: 0,
     isLastChild: false,
     parentIndex: 0,
     props: {},
-    template: ""
+    template: []
+    // 修改为数组
   };
-  transformJSXElement(path, result, true);
+  transformJSXServiceElement(path, result, true);
   path.replaceWith(createEssorNode(path, result));
 }
 function createEssorNode(path, result) {
@@ -134,82 +195,94 @@ function createEssorNode(path, result) {
   const state = path.state;
   let tmpl;
   if (path.isJSXElement() && isComponent(getTagName(path.node))) {
-    tmpl = import_core2.types.identifier(getTagName(path.node));
+    tmpl = import_core3.types.identifier(getTagName(path.node));
   } else {
     tmpl = path.scope.generateUidIdentifier("_tmpl$");
-    const template = import_core2.types.callExpression(state.template, [import_core2.types.stringLiteral(result.template)]);
-    const declarator = import_core2.types.variableDeclarator(tmpl, template);
+    const template = import_core3.types.callExpression(state.ssrtmpl, [
+      import_core3.types.arrayExpression(result.template.map(import_core3.types.stringLiteral))
+    ]);
+    const declarator = import_core3.types.variableDeclarator(tmpl, template);
     state.tmplDeclaration.declarations.push(declarator);
-    imports.add("template");
+    imports.add("ssrtmpl");
   }
   const args = [tmpl, createProps(result.props)];
   const key = result.props.key || ((_a = result.props[0]) == null ? void 0 : _a.key);
   if (key) {
     args.push(key);
   }
-  imports.add("h");
-  return import_core2.types.callExpression(state.h, args);
+  imports.add("ssr");
+  return import_core3.types.callExpression(state.ssr, args);
 }
 function createProps(props) {
-  const toAstNode = (value) => {
+  const result = [];
+  for (const prop in props) {
+    let value = props[prop];
+    if (prop === "key") {
+      continue;
+    }
     if (Array.isArray(value)) {
-      return import_core2.types.arrayExpression(value.map(toAstNode));
+      value = import_core3.types.arrayExpression(value);
     }
-    if (value && typeof value === "object" && !import_core2.types.isNode(value)) {
-      return createProps(value);
+    if (typeof value === "object" && value !== null && !import_core3.types.isNode(value)) {
+      value = createProps(value);
     }
-    switch (typeof value) {
-      case "string":
-        return import_core2.types.stringLiteral(value);
-      case "number":
-        return import_core2.types.numericLiteral(value);
-      case "boolean":
-        return import_core2.types.booleanLiteral(value);
-      case "undefined":
-        return import_core2.types.tsUndefinedKeyword();
-      case void 0:
-        return import_core2.types.tsUndefinedKeyword();
-      case null:
-        return import_core2.types.nullLiteral();
-      default:
-        return value;
+    if (typeof value === "string") {
+      value = import_core3.types.stringLiteral(value);
     }
-  };
-  const result = Object.keys(props).filter((prop) => prop !== "key").map((prop) => {
-    const value = toAstNode(props[prop]);
-    return prop === "_$spread$" ? import_core2.types.spreadElement(value) : import_core2.types.objectProperty(import_core2.types.stringLiteral(prop), value);
-  });
-  return import_core2.types.objectExpression(result);
+    if (typeof value === "number") {
+      value = import_core3.types.numericLiteral(value);
+    }
+    if (typeof value === "boolean") {
+      value = import_core3.types.booleanLiteral(value);
+    }
+    if (value === void 0) {
+      value = import_core3.types.tsUndefinedKeyword();
+    }
+    if (value === null) {
+      value = import_core3.types.nullLiteral();
+    }
+    if (prop === "_$spread$") {
+      result.push(import_core3.types.spreadElement(value));
+    } else {
+      result.push(import_core3.types.objectProperty(import_core3.types.stringLiteral(prop), value));
+    }
+  }
+  return import_core3.types.objectExpression(result);
 }
-function transformJSXElement(path, result, isRoot = false) {
+function transformJSXServiceElement(path, result, isRoot = false) {
   if (path.isJSXElement()) {
     const tagName = getTagName(path.node);
     const tagIsComponent = isComponent(tagName);
     const isSelfClose = !tagIsComponent && selfClosingTags.includes(tagName);
     const isSvg = svgTags.includes(tagName) && result.index === 1;
-    const props = getAttrProps(path);
+    const { props, hasExpression } = getAttrProps(path);
     if (tagIsComponent) {
       if (isRoot) {
         result.props = props;
         const children = getChildren(path);
         if (children.length > 0) {
-          const childrenGenerator = children.length === 1 ? children[0] : import_core2.types.arrayExpression(children);
+          const childrenGenerator = children.length === 1 ? children[0] : import_core3.types.arrayExpression(children);
           result.props.children = childrenGenerator;
         }
       } else {
-        transformJSXClient(path);
+        transformJSXService(path);
         replaceChild(path.node, result);
       }
     } else {
       if (isSvg) {
-        result.template = "<svg _svg_>";
+        result.template.push("<svg _svg_>");
       }
-      result.template += `<${tagName}`;
+      result.template.push(`<${tagName}`);
       handleAttributes(props, result);
-      result.template += isSelfClose ? "/>" : ">";
+      if (hasExpression) {
+        result.template.push(isSelfClose ? "/>" : ">");
+        result.props || (result.props = {});
+      } else {
+        result.template[result.template.length - 1] += isSelfClose ? "/>" : ">";
+      }
+      transformChildren(path, result);
       if (!isSelfClose) {
-        transformChildren(path, result);
-        result.template += `</${tagName}>`;
+        result.template.push(`</${tagName}>`);
       }
     }
   } else {
@@ -218,7 +291,7 @@ function transformJSXElement(path, result, isRoot = false) {
   }
 }
 function transformChildren(path, result) {
-  const parentIndex = result.index;
+  const parentIndex = result.template.length;
   path.get("children").reduce((pre, cur) => {
     if (isValidChild(cur)) {
       const lastChild = pre.at(-1);
@@ -236,21 +309,20 @@ function transformChildren(path, result) {
   });
 }
 function transformChild(child, result) {
-  result.index++;
   if (child.isJSXElement() || child.isJSXFragment()) {
-    transformJSXElement(child, result, false);
+    transformJSXServiceElement(child, result, false);
   } else if (child.isJSXExpressionContainer()) {
     const expression = child.get("expression");
     if (expression.isStringLiteral() || expression.isNumericLiteral()) {
-      result.template += String(expression.node.value);
+      result.template[result.template.length - 1] += String(expression.node.value);
     } else if (expression.isExpression()) {
       replaceChild(expression.node, result);
-    } else if (import_core2.types.isJSXEmptyExpression(expression.node)) {
+    } else if (import_core3.types.isJSXEmptyExpression(expression.node)) {
     } else {
       throw new Error("Unsupported child type");
     }
   } else if (child.isJSXText()) {
-    result.template += String(child.node.value);
+    result.template.push(String(child.node.value));
   } else {
     throw new Error("Unsupported child type");
   }
@@ -267,29 +339,6 @@ function getNodeText(path) {
   }
   return "";
 }
-function setNodeText(path, text) {
-  if (path.isJSXText()) {
-    path.node.value = text;
-  }
-  if (path.isJSXExpressionContainer()) {
-    const expression = path.get("expression");
-    if (expression.isStringLiteral() || expression.isNumericLiteral()) {
-      expression.replaceWith(import_core2.types.stringLiteral(text));
-    }
-  }
-}
-function isTextChild(path) {
-  if (path.isJSXExpressionContainer()) {
-    const expression = path.get("expression");
-    if (expression.isJSXText() || expression.isStringLiteral() || expression.isNumericLiteral()) {
-      return true;
-    }
-  }
-  if (path.isJSXText() || path.isStringLiteral() || path.isNullLiteral()) {
-    return true;
-  }
-  return false;
-}
 function handleAttributes(props, result) {
   let klass = "";
   let style = "";
@@ -324,14 +373,14 @@ function handleAttributes(props, result) {
       continue;
     }
     if (value === true) {
-      result.template += ` ${prop}`;
+      result.template[result.template.length - 1] += ` ${prop}`;
       delete props[prop];
     }
     if (value === false) {
       delete props[prop];
     }
     if (typeof value === "string" || typeof value === "number") {
-      result.template += ` ${prop}="${value}"`;
+      result.template[result.template.length - 1] += ` ${prop}="${value}"`;
       delete props[prop];
     }
   }
@@ -341,36 +390,34 @@ function handleAttributes(props, result) {
   klass = klass.trim();
   style = style.trim();
   if (klass) {
-    result.template += ` class="${klass}"`;
+    result.template[result.template.length - 1] += ` class="${klass}"`;
   }
   if (style) {
-    result.template += ` style="${style}"`;
+    result.template[result.template.length - 1] += ` style="${style}"`;
   }
 }
 function replaceChild(node, result) {
   var _a, _b, _c, _d, _e;
   if (result.isLastChild) {
     result.index--;
-  } else {
-    result.template += "<!-->";
   }
   (_c = (_a = result.props)[_b = result.parentIndex]) != null ? _c : _a[_b] = {};
   (_e = (_d = result.props[result.parentIndex]).children) != null ? _e : _d.children = [];
   result.props[result.parentIndex].children.push(
-    import_core2.types.arrayExpression([
-      import_core2.types.arrowFunctionExpression([], node),
-      result.isLastChild ? import_core2.types.nullLiteral() : import_core2.types.identifier(String(result.index))
+    import_core3.types.arrayExpression([
+      import_core3.types.arrowFunctionExpression([], node),
+      import_core3.types.identifier(String(result.template.length))
     ])
   );
 }
 function getChildren(path) {
   return path.get("children").filter((child) => isValidChild(child)).map((child) => {
     if (child.isJSXElement() || child.isJSXFragment()) {
-      transformJSXClient(child);
+      transformJSXService(child);
     } else if (child.isJSXExpressionContainer()) {
       child.replaceWith(child.get("expression"));
     } else if (child.isJSXText()) {
-      child.replaceWith(import_core2.types.stringLiteral(child.node.value));
+      child.replaceWith(import_core3.types.stringLiteral(child.node.value));
     } else {
       throw new Error("Unsupported child type");
     }
@@ -386,6 +433,7 @@ function isValidChild(path) {
 }
 function getAttrProps(path) {
   const props = {};
+  let hasExpression = false;
   path.get("openingElement").get("attributes").forEach((attribute) => {
     if (attribute.isJSXAttribute()) {
       const name = getAttrName(attribute.node);
@@ -402,77 +450,57 @@ function getAttrProps(path) {
           } else if (expression.isNumericLiteral()) {
             props[name] = expression.node.value;
           } else if (expression.isJSXElement() || expression.isJSXFragment()) {
-            transformJSXClient(expression);
+            transformJSXService(expression);
             props[name] = expression.node;
           } else if (expression.isExpression()) {
+            hasExpression = true;
             if (/^key|ref|on.+$/.test(name)) {
               props[name] = expression.node;
             } else if (/^bind:.+/.test(name)) {
               const value2 = path.scope.generateUidIdentifier("value");
               const bindName = name.slice(5).toLocaleLowerCase();
               props[bindName] = expression.node;
-              props[`update${capitalizeFirstLetter(bindName)}`] = import_core2.types.arrowFunctionExpression(
+              props[`update${capitalizeFirstLetter(bindName)}`] = import_core3.types.arrowFunctionExpression(
                 [value2],
-                import_core2.types.assignmentExpression("=", expression.node, value2)
+                import_core3.types.assignmentExpression("=", expression.node, value2)
               );
             } else {
               if (expression.isConditionalExpression()) {
-                props[name] = import_core2.types.arrowFunctionExpression([], expression.node);
+                props[name] = import_core3.types.arrowFunctionExpression([], expression.node);
               } else {
                 props[name] = expression.node;
               }
             }
           }
         } else if (value.isJSXElement() || value.isJSXFragment()) {
-          transformJSXClient(value);
+          transformJSXService(value);
           props[name] = value.node;
         }
       }
     } else if (attribute.isJSXSpreadAttribute()) {
       props._$spread$ = attribute.get("argument").node;
+      hasExpression = true;
     } else {
       throw new Error("Unsupported attribute type");
     }
   });
-  return props;
-}
-function getAttrName(attribute) {
-  if (import_core2.types.isJSXIdentifier(attribute.name)) {
-    return attribute.name.name;
-  }
-  if (import_core2.types.isJSXNamespacedName(attribute.name)) {
-    return `${attribute.name.namespace.name}:${attribute.name.name.name}`;
-  }
-  throw new Error("Unsupported attribute type");
-}
-function isComponent(tagName) {
-  return tagName[0] && tagName[0].toLowerCase() !== tagName[0] || tagName.includes(".") || /[^A-Za-z]/.test(tagName[0]);
-}
-function getTagName(node) {
-  const tag = node.openingElement.name;
-  return jsxElementNameToString(tag);
-}
-function jsxElementNameToString(node) {
-  if (import_core2.types.isJSXMemberExpression(node)) {
-    return `${jsxElementNameToString(node.object)}.${jsxElementNameToString(node.property)}`;
-  }
-  if (import_core2.types.isJSXIdentifier(node) || import_core2.types.isIdentifier(node)) {
-    return node.name;
-  }
-  return `${node.namespace.name}:${node.name.name}`;
+  return {
+    props,
+    hasExpression
+  };
 }
 
-// src/jsx/server.ts
-function transformJSXService(path) {
+// src/jsx/client.ts
+var import_core4 = require("@babel/core");
+function transformJSXClient(path) {
   const result = {
-    index: 0,
+    index: 1,
     isLastChild: false,
     parentIndex: 0,
     props: {},
-    template: []
-    // 修改为数组
+    template: ""
   };
-  transformJSXServiceElement(path, result, true);
+  transformJSXElement(path, result, true);
   path.replaceWith(createEssorNode2(path, result));
 }
 function createEssorNode2(path, result) {
@@ -480,94 +508,84 @@ function createEssorNode2(path, result) {
   const state = path.state;
   let tmpl;
   if (path.isJSXElement() && isComponent(getTagName(path.node))) {
-    tmpl = import_core3.types.identifier(getTagName(path.node));
+    tmpl = import_core4.types.identifier(getTagName(path.node));
   } else {
     tmpl = path.scope.generateUidIdentifier("_tmpl$");
-    const template = import_core3.types.callExpression(state.ssrtmpl, [
-      import_core3.types.arrayExpression(result.template.map(import_core3.types.stringLiteral))
-    ]);
-    const declarator = import_core3.types.variableDeclarator(tmpl, template);
+    const template = import_core4.types.callExpression(state.template, [import_core4.types.stringLiteral(result.template)]);
+    const declarator = import_core4.types.variableDeclarator(tmpl, template);
     state.tmplDeclaration.declarations.push(declarator);
-    imports.add("ssrtmpl");
+    imports.add("template");
   }
   const args = [tmpl, createProps2(result.props)];
   const key = result.props.key || ((_a = result.props[0]) == null ? void 0 : _a.key);
   if (key) {
     args.push(key);
   }
-  imports.add("ssr");
-  return import_core3.types.callExpression(state.ssr, args);
+  imports.add("h");
+  return import_core4.types.callExpression(state.h, args);
 }
 function createProps2(props) {
-  const result = [];
-  for (const prop in props) {
-    let value = props[prop];
-    if (prop === "key") {
-      continue;
-    }
+  const toAstNode = (value) => {
     if (Array.isArray(value)) {
-      value = import_core3.types.arrayExpression(value);
-    }
-    if (typeof value === "object" && value !== null && !import_core3.types.isNode(value)) {
-      value = createProps2(value);
-    }
-    if (typeof value === "string") {
-      value = import_core3.types.stringLiteral(value);
-    }
-    if (typeof value === "number") {
-      value = import_core3.types.numericLiteral(value);
-    }
-    if (typeof value === "boolean") {
-      value = import_core3.types.booleanLiteral(value);
+      return import_core4.types.arrayExpression(value.map(toAstNode));
     }
-    if (value === void 0) {
-      value = import_core3.types.tsUndefinedKeyword();
+    if (value && typeof value === "object" && !import_core4.types.isNode(value)) {
+      return createProps2(value);
     }
-    if (value === null) {
-      value = import_core3.types.nullLiteral();
-    }
-    if (prop === "_$spread$") {
-      result.push(import_core3.types.spreadElement(value));
-    } else {
-      result.push(import_core3.types.objectProperty(import_core3.types.stringLiteral(prop), value));
+    switch (typeof value) {
+      case "string":
+        return import_core4.types.stringLiteral(value);
+      case "number":
+        return import_core4.types.numericLiteral(value);
+      case "boolean":
+        return import_core4.types.booleanLiteral(value);
+      case "undefined":
+        return import_core4.types.tsUndefinedKeyword();
+      case void 0:
+        return import_core4.types.tsUndefinedKeyword();
+      case null:
+        return import_core4.types.nullLiteral();
+      default:
+        return value;
     }
-  }
-  return import_core3.types.objectExpression(result);
+  };
+  const result = Object.keys(props).filter((prop) => prop !== "key").map((prop) => {
+    const value = toAstNode(props[prop]);
+    return prop === "_$spread$" ? import_core4.types.spreadElement(value) : import_core4.types.objectProperty(import_core4.types.stringLiteral(prop), value);
+  });
+  return import_core4.types.objectExpression(result);
 }
-function transformJSXServiceElement(path, result, isRoot = false) {
+function transformJSXElement(path, result, isRoot = false) {
   if (path.isJSXElement()) {
     const tagName = getTagName(path.node);
     const tagIsComponent = isComponent(tagName);
     const isSelfClose = !tagIsComponent && selfClosingTags.includes(tagName);
     const isSvg = svgTags.includes(tagName) && result.index === 1;
-    const { props, hasExpression } = getAttrProps2(path);
+    const props = getAttrProps2(path);
     if (tagIsComponent) {
       if (isRoot) {
         result.props = props;
         const children = getChildren2(path);
         if (children.length > 0) {
-          const childrenGenerator = children.length === 1 ? children[0] : import_core3.types.arrayExpression(children);
+          const childrenGenerator = children.length === 1 ? children[0] : import_core4.types.arrayExpression(children);
           result.props.children = childrenGenerator;
         }
       } else {
-        transformJSXService(path);
+        transformJSXClient(path);
         replaceChild2(path.node, result);
       }
     } else {
       if (isSvg) {
-        result.template.push("<svg _svg_>");
+        result.template = "<svg _svg_>";
       }
-      result.template.push(`<${tagName}`);
+      result.template += `<${tagName}`;
       handleAttributes2(props, result);
-      if (hasExpression) {
-        result.template.push(isSelfClose ? "/>" : ">");
-        result.props || (result.props = {});
-      } else {
-        result.template[result.template.length - 1] += isSelfClose ? "/>" : ">";
-      }
-      transformChildren2(path, result);
+      result.template += isSelfClose ? "/>" : ">";
       if (!isSelfClose) {
-        result.template.push(`</${tagName}>`);
+        transformChildren2(path, result);
+        if (hasSiblingElement(path)) {
+          result.template += `</${tagName}>`;
+        }
       }
     }
   } else {
@@ -576,12 +594,12 @@ function transformJSXServiceElement(path, result, isRoot = false) {
   }
 }
 function transformChildren2(path, result) {
-  const parentIndex = result.template.length;
+  const parentIndex = result.index;
   path.get("children").reduce((pre, cur) => {
     if (isValidChild2(cur)) {
       const lastChild = pre.at(-1);
       if (lastChild && isTextChild(cur) && isTextChild(lastChild)) {
-        setNodeText2(lastChild, getNodeText2(lastChild) + getNodeText2(cur));
+        setNodeText(lastChild, getNodeText2(lastChild) + getNodeText2(cur));
       } else {
         pre.push(cur);
       }
@@ -594,20 +612,21 @@ function transformChildren2(path, result) {
   });
 }
 function transformChild2(child, result) {
+  result.index++;
   if (child.isJSXElement() || child.isJSXFragment()) {
-    transformJSXServiceElement(child, result, false);
+    transformJSXElement(child, result, false);
   } else if (child.isJSXExpressionContainer()) {
     const expression = child.get("expression");
     if (expression.isStringLiteral() || expression.isNumericLiteral()) {
-      result.template[result.template.length - 1] += String(expression.node.value);
+      result.template += String(expression.node.value);
     } else if (expression.isExpression()) {
       replaceChild2(expression.node, result);
-    } else if (import_core3.types.isJSXEmptyExpression(expression.node)) {
+    } else if (import_core4.types.isJSXEmptyExpression(expression.node)) {
     } else {
       throw new Error("Unsupported child type");
     }
   } else if (child.isJSXText()) {
-    result.template.push(String(child.node.value));
+    result.template += String(child.node.value);
   } else {
     throw new Error("Unsupported child type");
   }
@@ -624,17 +643,6 @@ function getNodeText2(path) {
   }
   return "";
 }
-function setNodeText2(path, text) {
-  if (path.isJSXText()) {
-    path.node.value = text;
-  }
-  if (path.isJSXExpressionContainer()) {
-    const expression = path.get("expression");
-    if (expression.isStringLiteral() || expression.isNumericLiteral()) {
-      expression.replaceWith(import_core3.types.stringLiteral(text));
-    }
-  }
-}
 function handleAttributes2(props, result) {
   let klass = "";
   let style = "";
@@ -669,14 +677,14 @@ function handleAttributes2(props, result) {
       continue;
     }
     if (value === true) {
-      result.template[result.template.length - 1] += ` ${prop}`;
+      result.template += ` ${prop}`;
       delete props[prop];
     }
     if (value === false) {
       delete props[prop];
     }
     if (typeof value === "string" || typeof value === "number") {
-      result.template[result.template.length - 1] += ` ${prop}="${value}"`;
+      result.template += ` ${prop}="${value}"`;
       delete props[prop];
     }
   }
@@ -686,34 +694,36 @@ function handleAttributes2(props, result) {
   klass = klass.trim();
   style = style.trim();
   if (klass) {
-    result.template[result.template.length - 1] += ` class="${klass}"`;
+    result.template += ` class="${klass}"`;
   }
   if (style) {
-    result.template[result.template.length - 1] += ` style="${style}"`;
+    result.template += ` style="${style}"`;
   }
 }
 function replaceChild2(node, result) {
   var _a, _b, _c, _d, _e;
   if (result.isLastChild) {
     result.index--;
+  } else {
+    result.template += "<!>";
   }
   (_c = (_a = result.props)[_b = result.parentIndex]) != null ? _c : _a[_b] = {};
   (_e = (_d = result.props[result.parentIndex]).children) != null ? _e : _d.children = [];
   result.props[result.parentIndex].children.push(
-    import_core3.types.arrayExpression([
-      import_core3.types.arrowFunctionExpression([], node),
-      import_core3.types.identifier(String(result.template.length))
+    import_core4.types.arrayExpression([
+      import_core4.types.arrowFunctionExpression([], node),
+      result.isLastChild ? import_core4.types.nullLiteral() : import_core4.types.identifier(String(result.index))
     ])
   );
 }
 function getChildren2(path) {
   return path.get("children").filter((child) => isValidChild2(child)).map((child) => {
     if (child.isJSXElement() || child.isJSXFragment()) {
-      transformJSXService(child);
+      transformJSXClient(child);
     } else if (child.isJSXExpressionContainer()) {
       child.replaceWith(child.get("expression"));
     } else if (child.isJSXText()) {
-      child.replaceWith(import_core3.types.stringLiteral(child.node.value));
+      child.replaceWith(import_core4.types.stringLiteral(child.node.value));
     } else {
       throw new Error("Unsupported child type");
     }
@@ -729,7 +739,6 @@ function isValidChild2(path) {
 }
 function getAttrProps2(path) {
   const props = {};
-  let hasExpression = false;
   path.get("openingElement").get("attributes").forEach((attribute) => {
     if (attribute.isJSXAttribute()) {
       const name = getAttrName(attribute.node);
@@ -746,44 +755,39 @@ function getAttrProps2(path) {
           } else if (expression.isNumericLiteral()) {
             props[name] = expression.node.value;
           } else if (expression.isJSXElement() || expression.isJSXFragment()) {
-            transformJSXService(expression);
+            transformJSXClient(expression);
             props[name] = expression.node;
           } else if (expression.isExpression()) {
-            hasExpression = true;
             if (/^key|ref|on.+$/.test(name)) {
               props[name] = expression.node;
             } else if (/^bind:.+/.test(name)) {
               const value2 = path.scope.generateUidIdentifier("value");
               const bindName = name.slice(5).toLocaleLowerCase();
               props[bindName] = expression.node;
-              props[`update${capitalizeFirstLetter(bindName)}`] = import_core3.types.arrowFunctionExpression(
+              props[`update${capitalizeFirstLetter(bindName)}`] = import_core4.types.arrowFunctionExpression(
                 [value2],
-                import_core3.types.assignmentExpression("=", expression.node, value2)
+                import_core4.types.assignmentExpression("=", expression.node, value2)
               );
             } else {
               if (expression.isConditionalExpression()) {
-                props[name] = import_core3.types.arrowFunctionExpression([], expression.node);
+                props[name] = import_core4.types.arrowFunctionExpression([], expression.node);
               } else {
                 props[name] = expression.node;
               }
             }
           }
         } else if (value.isJSXElement() || value.isJSXFragment()) {
-          transformJSXService(value);
+          transformJSXClient(value);
           props[name] = value.node;
         }
       }
     } else if (attribute.isJSXSpreadAttribute()) {
       props._$spread$ = attribute.get("argument").node;
-      hasExpression = true;
     } else {
       throw new Error("Unsupported attribute type");
     }
   });
-  return {
-    props,
-    hasExpression
-  };
+  return props;
 }
 
 // src/jsx/index.ts
@@ -794,24 +798,24 @@ function transformJSX(path) {
 }
 
 // src/signal/symbol.ts
-var import_core4 = require("@babel/core");
+var import_core5 = require("@babel/core");
 var import_types = require("@babel/types");
 function replaceSymbol(path) {
   const init = path.node.init;
   const variableName = path.node.id.name;
-  if (import_core4.types.isObjectPattern(path.node.id) || import_core4.types.isArrayPattern(path.node.id)) {
+  if (import_core5.types.isObjectPattern(path.node.id) || import_core5.types.isArrayPattern(path.node.id)) {
     return;
   }
   if (!startsWith(variableName, "$")) {
     return;
   }
-  if (init && (import_core4.types.isFunctionExpression(init) || import_core4.types.isArrowFunctionExpression(init)) && path.parent.kind === "const") {
-    const newInit = import_core4.types.callExpression(import_core4.types.identifier(path.state.useComputed.name), init ? [init] : []);
+  if (init && (import_core5.types.isFunctionExpression(init) || import_core5.types.isArrowFunctionExpression(init)) && path.parent.kind === "const") {
+    const newInit = import_core5.types.callExpression(import_core5.types.identifier(path.state.useComputed.name), init ? [init] : []);
     imports.add("useComputed");
     path.node.init = newInit;
   } else {
     const originalImportDeclarationNodes = (0, import_types.cloneNode)(path.get("id").node, true);
-    const newInit = import_core4.types.callExpression(import_core4.types.identifier(path.state.useSignal.name), init ? [init] : []);
+    const newInit = import_core5.types.callExpression(import_core5.types.identifier(path.state.useSignal.name), init ? [init] : []);
     imports.add("useSignal");
     path.node.init = newInit;
     path.scope.rename(variableName, `${variableName}.value`);
@@ -820,7 +824,7 @@ function replaceSymbol(path) {
 }
 
 // src/signal/import.ts
-var import_core5 = require("@babel/core");
+var import_core6 = require("@babel/core");
 function isVariableUsedAsObject(path, variableName) {
   const binding = path.scope.getBinding(variableName);
   let isUsedObject = false;
@@ -828,7 +832,7 @@ function isVariableUsedAsObject(path, variableName) {
     return isUsedObject;
   }
   for (const referencePath of binding.referencePaths) {
-    if (import_core5.types.isMemberExpression(referencePath.parent)) {
+    if (import_core6.types.isMemberExpression(referencePath.parent)) {
       isUsedObject = true;
     }
   }
@@ -846,11 +850,11 @@ function replaceImportDeclaration(path) {
 }
 
 // src/signal/props.ts
-var import_core6 = require("@babel/core");
+var import_core7 = require("@babel/core");
 function replaceProps(path) {
   var _a;
   const firstParam = path.node.params[0];
-  if (!firstParam || !import_core6.types.isObjectPattern(firstParam)) {
+  if (!firstParam || !import_core7.types.isObjectPattern(firstParam)) {
     return;
   }
   const returnStatement = path.get("body").get("body").find((statement) => statement.isReturnStatement());
@@ -858,18 +862,18 @@ function replaceProps(path) {
     return;
   }
   const returnValue = (_a = returnStatement.node) == null ? void 0 : _a.argument;
-  if (!import_core6.types.isJSXElement(returnValue)) {
+  if (!import_core7.types.isJSXElement(returnValue)) {
     return;
   }
   function replaceProperties(properties2, parentPath) {
     properties2.forEach((property) => {
-      if (import_core6.types.isObjectProperty(property)) {
+      if (import_core7.types.isObjectProperty(property)) {
         const keyName = property.key.name;
-        if (import_core6.types.isIdentifier(property.value)) {
+        if (import_core7.types.isIdentifier(property.value)) {
           const propertyName = property.value.name;
           const newName = `${parentPath}${keyName}`;
           path.scope.rename(propertyName, newName);
-        } else if (import_core6.types.isObjectPattern(property.value)) {
+        } else if (import_core7.types.isObjectPattern(property.value)) {
           replaceProperties(property.value.properties, `${parentPath}${keyName}.`);
         }
       }
@@ -877,18 +881,18 @@ function replaceProps(path) {
   }
   const properties = firstParam.properties;
   replaceProperties(
-    properties.filter((property) => !import_core6.types.isRestElement(property)),
+    properties.filter((property) => !import_core7.types.isRestElement(property)),
     "__props."
   );
-  const restElement = properties.find((property) => import_core6.types.isRestElement(property));
+  const restElement = properties.find((property) => import_core7.types.isRestElement(property));
   if (restElement) {
     const restName = restElement.argument.name;
-    const restVariableDeclaration = import_core6.types.variableDeclaration("const", [
-      import_core6.types.variableDeclarator(import_core6.types.identifier(restName), import_core6.types.identifier("__props"))
+    const restVariableDeclaration = import_core7.types.variableDeclaration("const", [
+      import_core7.types.variableDeclarator(import_core7.types.identifier(restName), import_core7.types.identifier("__props"))
     ]);
     path.node.body.body.unshift(restVariableDeclaration);
   }
-  path.node.params[0] = import_core6.types.identifier("__props");
+  path.node.params[0] = import_core7.types.identifier("__props");
 }
 
 // src/index.ts