potatejs 0.13.0 → 0.14.0

package/dist/index-vite.js

@@ -12993,65 +12993,103 @@ function generate(node, options) {
 
 // src/plugin/babel-compat.js
 var t = {
-  // Type Checkers
-  isJSXElement: (node) => (node == null ? void 0 : node.type) === "JSXElement",
-  isJSXText: (node) => (node == null ? void 0 : node.type) === "JSXText",
-  isJSXExpressionContainer: (node) => (node == null ? void 0 : node.type) === "JSXExpressionContainer",
-  isJSXFragment: (node) => (node == null ? void 0 : node.type) === "JSXFragment",
-  isJSXEmptyExpression: (node) => (node == null ? void 0 : node.type) === "JSXEmptyExpression",
-  isJSXSpreadAttribute: (node) => (node == null ? void 0 : node.type) === "JSXSpreadAttribute",
-  isJSXAttribute: (node) => (node == null ? void 0 : node.type) === "JSXAttribute",
-  isObjectExpression: (node) => (node == null ? void 0 : node.type) === "ObjectExpression",
-  isJSXIdentifier: (node) => (node == null ? void 0 : node.type) === "JSXIdentifier",
-  isJSXMemberExpression: (node) => (node == null ? void 0 : node.type) === "JSXMemberExpression",
-  // Node Creators
-  identifier: (name) => ({ type: "Identifier", name }),
-  stringLiteral: (value) => ({ type: "Literal", value, raw: `'${value}'` }),
-  nullLiteral: () => ({ type: "Literal", value: null, raw: "null" }),
-  booleanLiteral: (value) => ({ type: "Literal", value, raw: String(value) }),
-  objectExpression: (properties) => ({ type: "ObjectExpression", properties }),
-  objectProperty: (key, value, computed = false, shorthand = false) => ({
-    type: "Property",
-    key,
-    value,
-    computed,
-    shorthand,
-    kind: "init"
-  }),
-  spreadElement: (argument) => ({ type: "SpreadElement", argument }),
-  callExpression: (callee, args) => ({ type: "CallExpression", callee, arguments: args }),
-  memberExpression: (object, property) => ({ type: "MemberExpression", object, property }),
-  taggedTemplateExpression: (tag, quasi) => ({ type: "TaggedTemplateExpression", tag, quasi }),
-  templateLiteral: (quasis, expressions) => ({ type: "TemplateLiteral", quasis, expressions }),
-  templateElement: (value, tail) => ({ type: "TemplateElement", value, tail })
-};
-var pathCache = /* @__PURE__ */ new WeakMap();
-var createPath = (node, parentPath = null) => {
-  if (!node || typeof node !== "object") return null;
-  if (pathCache.has(node)) {
-    const cachedPath = pathCache.get(node);
-    if (parentPath && cachedPath.parentPath !== parentPath) {
-      cachedPath.parentPath = parentPath;
-    }
-    return cachedPath;
-  }
-  const path = {
+  // Matches physical TemplateLiteral structure
+  templateLiteral(strings, expressions) {
+    return {
+      type: "TemplateLiteral",
+      strings,
+      expressions
+    };
+  },
+  // Matches physical TemplateElement structure
+  templateElement(value, tail) {
+    return {
+      type: "TemplateElement",
+      value: {
+        raw: value.raw,
+        cooked: value.cooked
+      },
+      tail
+    };
+  },
+  // Matches physical TaggedTemplateExpression structure
+  taggedTemplateExpression(tag, template) {
+    return {
+      type: "TaggedTemplateExpression",
+      tag,
+      template
+    };
+  },
+  identifier(name) {
+    return { type: "Identifier", name };
+  },
+  // In Potate engine, these are just "Literal"
+  stringLiteral(value) {
+    return { type: "Literal", value };
+  },
+  booleanLiteral(value) {
+    return { type: "Literal", value };
+  },
+  importSpecifier(local, imported) {
+    return { type: "ImportSpecifier", local, imported };
+  },
+  importDeclaration(specifiers, source) {
+    return { type: "ImportDeclaration", specifiers, source };
+  },
+  callExpression(callee, args) {
+    return { type: "CallExpression", callee, arguments: args };
+  },
+  memberExpression(object, property) {
+    return { type: "MemberExpression", object, property, computed: false };
+  },
+  objectExpression(properties) {
+    return { type: "ObjectExpression", properties };
+  },
+  objectProperty(key, value, computed = false, shorthand = false) {
+    return { type: "Property", key, value, kind: "init", computed, shorthand };
+  },
+  spreadElement(argument) {
+    return { type: "SpreadElement", argument };
+  },
+  arrayExpression(elements) {
+    return { type: "ArrayExpression", elements };
+  },
+  // Type checkers (Physical check)
+  isJSXElement(node) {
+    return node && node.type === "JSXElement";
+  },
+  isJSXFragment(node) {
+    return node && node.type === "JSXFragment";
+  },
+  isJSXText(node) {
+    return node && node.type === "JSXText";
+  },
+  isJSXExpressionContainer(node) {
+    return node && node.type === "JSXExpressionContainer";
+  },
+  isJSXEmptyExpression(node) {
+    return node && node.type === "JSXEmptyExpression";
+  },
+  isJSXAttribute(node) {
+    return node && node.type === "JSXAttribute";
+  },
+  isJSXSpreadAttribute(node) {
+    return node && node.type === "JSXSpreadAttribute";
+  }
+};
+function createPath(node, parentPath = null) {
+  return {
     node,
     parentPath,
-    get parent() {
-      return this.parentPath ? this.parentPath.node : null;
-    },
     get(key) {
-      const val = this.node[key];
-      if (Array.isArray(val)) {
-        return val.map((child) => createPath(child, this));
+      const value = this.node[key];
+      if (Array.isArray(value)) {
+        return value.map((v) => createPath(v, this));
       }
-      return createPath(val, this);
+      return value ? createPath(value, this) : null;
     }
   };
-  pathCache.set(node, path);
-  return path;
-};
+}
 
 // src/plugin/svgAttributeMap.js
 var svgAttributeMap_default = {
@@ -13143,6 +13181,7 @@ var svgAttributeMap_default = {
 };
 
 // src/plugin/constants.js
+var BRAHMOS_PLACEHOLDER = "{{brahmos}}";
 var RESERVED_ATTRIBUTES = {
   key: 1,
   ref: 1
@@ -13176,9 +13215,7 @@ function cleanStringForHtml(rawStr) {
   const lines = rawStr.split(/\r\n|\n|\r/);
   let lastNonEmptyLine = 0;
   for (let i = 0; i < lines.length; i++) {
-    if (lines[i].match(/[^ \t]/)) {
-      lastNonEmptyLine = i;
-    }
+    if (lines[i].match(/[^ \t]/)) lastNonEmptyLine = i;
   }
   let str = "";
   for (let i = 0; i < lines.length; i++) {
@@ -13187,16 +13224,10 @@ function cleanStringForHtml(rawStr) {
     const isLastLine = i === lines.length - 1;
     const isLastNonEmptyLine = i === lastNonEmptyLine;
     let trimmedLine = line.replace(/\t/g, " ");
-    if (!isFirstLine) {
-      trimmedLine = trimmedLine.replace(/^[ ]+/, "");
-    }
-    if (!isLastLine) {
-      trimmedLine = trimmedLine.replace(/[ ]+$/, "");
-    }
+    if (!isFirstLine) trimmedLine = trimmedLine.replace(/^[ ]+/, "");
+    if (!isLastLine) trimmedLine = trimmedLine.replace(/[ ]+$/, "");
     if (trimmedLine) {
-      if (!isLastNonEmptyLine) {
-        trimmedLine += " ";
-      }
+      if (!isLastNonEmptyLine) trimmedLine += " ";
       str += trimmedLine;
     }
   }
@@ -13217,23 +13248,73 @@ function isEmptyLiteralWrap(strings) {
 function getPropValue(value) {
   return t.isJSXExpressionContainer(value) ? value.expression : value;
 }
+function getAttributeName(nameNode) {
+  if (nameNode.type === "JSXNamespacedName") {
+    return `${nameNode.namespace.name}:${nameNode.name.name}`;
+  }
+  return nameNode.name;
+}
 function createAttributeProperty(name, value) {
   value = value || t.booleanLiteral(true);
-  const attrNameStr = name.name;
+  const attrNameStr = getAttributeName(name);
   const propName = attrNameStr.match("-|:") ? t.stringLiteral(attrNameStr) : t.identifier(attrNameStr);
   const propValue = getPropValue(value);
-  return t.objectProperty(propName, propValue, false, propName.name === propValue.name);
+  const isShorthand = propName.type === "Identifier" && propValue.type === "Identifier" && propName.name === propValue.name;
+  return t.objectProperty(propName, propValue, false, isShorthand);
 }
 function createAttributeExpression(name, value) {
   return t.objectExpression([createAttributeProperty(name, value)]);
 }
+function addBrahmosRuntime(programPath) {
+  if (programPath.node.hasBrahmosRuntime) return;
+  const jsxImport = t.importSpecifier(t.identifier("_brahmosJSX"), t.identifier("jsx"));
+  const htmlImport = t.importSpecifier(t.identifier("_brahmosHtml"), t.identifier("html"));
+  const importStatement = t.importDeclaration([jsxImport, htmlImport], t.stringLiteral("potatejs"));
+  programPath.node.body.unshift(importStatement);
+  programPath.node.hasBrahmosRuntime = true;
+}
+function transformToAstNode(res) {
+  if (typeof res === "string") {
+    return { type: "Literal", value: res, raw: `'${res}'` };
+  }
+  if (res.type === "TaggedTemplateExpression") {
+    return {
+      type: "CallExpression",
+      callee: {
+        type: "TaggedTemplateExpression",
+        tag: { type: "Identifier", name: res.tag },
+        quasi: {
+          type: "TemplateLiteral",
+          quasis: res.template.strings.map((s) => ({
+            type: "TemplateElement",
+            value: {
+              raw: s.value.raw || "",
+              cooked: s.value.cooked || ""
+            },
+            tail: s.tail
+          })),
+          expressions: res.template.expressions
+        }
+      },
+      arguments: [res.meta]
+    };
+  }
+  return res;
+}
 
 // src/plugin/partUtils.js
 function getSlimIndex(index) {
   return index === void 0 || index === -1 ? "" : index;
 }
 function isValidTemplateElement(node) {
-  return t.isJSXText(node) || node.elementCounter !== void 0;
+  return t.isJSXText(node) || node && node.elementCounter !== void 0;
+}
+function getEffectiveNodePath(path) {
+  let currentPath = path;
+  while (currentPath.parentPath && t.isJSXFragment(currentPath.parentPath.node)) {
+    currentPath = currentPath.parentPath;
+  }
+  return currentPath;
 }
 function flattenFragmentChildren(parent) {
   if (!parent || !parent.children) return [];
@@ -13260,41 +13341,35 @@ function getPartMetaStringLiteral(partsMeta) {
     const secondaryIndex = getSlimIndex(isAttribute ? part.attributeIndex : part.prevChildIndex);
     return `${combinedBooleanCode}|${primaryIndex}|${secondaryIndex}`;
   });
-  return partsMetaWithShortKeys.join(",");
+  return t.stringLiteral(partsMetaWithShortKeys.join(","));
 }
 function getNonFragmentParent(path) {
-  let currentPath = path;
-  while (currentPath && currentPath.parentPath) {
-    const parentNode = currentPath.parentPath.node;
-    if (!t.isJSXFragment(parentNode)) {
-      return parentNode;
-    }
-    currentPath = currentPath.parentPath;
-  }
-  return null;
+  const effectivePath = getEffectiveNodePath(path);
+  const parentNode = effectivePath.parentPath ? effectivePath.parentPath.node : null;
+  if (parentNode && !isValidTemplateElement(parentNode)) return parentNode;
+  return parentNode;
 }
 function getPreviousSiblingIndex(path) {
   const { node } = path;
   const parent = getNonFragmentParent(path);
-  if (!parent) return { prevChildIndex: -1, hasExpressionSibling: false };
+  if (!parent) return {};
   const children = flattenFragmentChildren(parent);
-  const nodeIndex = children.indexOf(node);
-  if (nodeIndex === -1) return { prevChildIndex: -1, hasExpressionSibling: false };
+  if (!children.length) return {};
   const validChildren = children.filter((child) => {
     if (t.isJSXText(child)) {
       return !!cleanStringForHtml(child.value);
-    } else if (child.type === "JSXExpressionContainer" && t.isJSXEmptyExpression(child.expression)) {
+    } else if (t.isJSXExpressionContainer(child) && t.isJSXEmptyExpression(child.expression)) {
       return false;
     }
     return true;
   });
-  const validNodeIndex = validChildren.indexOf(node);
-  const prevSibling = validChildren[validNodeIndex - 1];
+  const nodeIndex = validChildren.indexOf(node);
+  if (nodeIndex === -1) return {};
+  const prevSibling = validChildren[nodeIndex - 1];
   const hasExpressionSibling = !!prevSibling && !isValidTemplateElement(prevSibling);
   let prevChildIndex = -1;
-  for (let i = 0; i <= validNodeIndex; i++) {
-    const child = validChildren[i];
-    if (isValidTemplateElement(child) || i > 0 && !isValidTemplateElement(validChildren[i - 1])) {
+  for (let i = 0; i <= nodeIndex; i++) {
+    if (isValidTemplateElement(validChildren[i]) || i > 0 && !isValidTemplateElement(validChildren[i - 1])) {
       prevChildIndex += 1;
     }
   }
@@ -13303,19 +13378,106 @@ function getPreviousSiblingIndex(path) {
     hasExpressionSibling
   };
 }
+function isHTMLNode(node) {
+  if (!t.isJSXElement(node)) return false;
+  const nameNode = node.openingElement.name;
+  const tagName = nameNode.name;
+  return isHTMLElement(tagName) && tagName !== "svg";
+}
+function isRenderableText(node) {
+  return t.isJSXText(node) && !!cleanStringForHtml(node.value);
+}
 function isWrappedWithString(path) {
+  const effectivePath = getEffectiveNodePath(path);
   const parent = getNonFragmentParent(path);
   if (!parent) return false;
   const children = flattenFragmentChildren(parent);
-  const nodeIndex = children.indexOf(path.node);
-  if (nodeIndex <= 0 || nodeIndex >= children.length - 1) return false;
+  let nodeIndex = children.indexOf(effectivePath.node);
   const prevNode = children[nodeIndex - 1];
-  const nextNode = children[nodeIndex + 1];
-  const isRenderableText = (n) => t.isJSXText(n) && !!cleanStringForHtml(n.value);
-  return isRenderableText(prevNode) && isRenderableText(nextNode);
+  if (!(prevNode && isRenderableText(prevNode))) return false;
+  let nextNode;
+  while (nextNode = children[nodeIndex + 1]) {
+    if (isRenderableText(nextNode)) {
+      return true;
+    } else if (t.isJSXExpressionContainer(nextNode) || !isHTMLNode(nextNode)) {
+      nodeIndex += 1;
+    } else {
+      return false;
+    }
+  }
+  return false;
+}
+
+// src/plugin/svg.js
+function isSvgHasDynamicPart(part) {
+  let hasDynamicPart = false;
+  function walk(node) {
+    if (hasDynamicPart) return;
+    if (!node || typeof node !== "object") return;
+    if (node.type === "JSXSpreadAttribute") {
+      hasDynamicPart = true;
+      return;
+    }
+    if (node.type === "JSXExpressionContainer") {
+      hasDynamicPart = true;
+      return;
+    }
+    if (node.type === "JSXElement") {
+      const nameNode = node.openingElement.name;
+      if (nameNode.type === "JSXMemberExpression") {
+        hasDynamicPart = true;
+        return;
+      }
+      const tagName = nameNode.name;
+      if (!isHTMLElement(tagName)) {
+        hasDynamicPart = true;
+        return;
+      }
+    }
+    for (const key in node) {
+      if (key === "parent" || key === "parentPath" || key === "loc") continue;
+      const val = node[key];
+      if (Array.isArray(val)) {
+        val.forEach(walk);
+      } else if (val && typeof val === "object") {
+        walk(val);
+      }
+    }
+  }
+  walk(part.node);
+  return hasDynamicPart;
 }
 
 // src/plugin/taggedTemplate.js
+function jsxNameToExpression(node) {
+  if (node.type === "JSXIdentifier") {
+    return { type: "Identifier", name: node.name };
+  } else if (node.type === "JSXMemberExpression") {
+    return {
+      type: "MemberExpression",
+      object: jsxNameToExpression(node.object),
+      property: jsxNameToExpression(node.property),
+      computed: false
+    };
+  }
+  throw new Error(`Unsupported JSX name type: ${node.type}`);
+}
+function needsToBeJSXCall(path) {
+  const { node } = path;
+  if (node.type === "JSXFragment") return false;
+  const nameNode = node.openingElement.name;
+  if (nameNode.type === "JSXMemberExpression") return true;
+  const tagName = nameNode.name;
+  if (!isHTMLElement(tagName)) return true;
+  if (tagName === "svg" && isSvgHasDynamicPart(path)) return true;
+  return node.openingElement.attributes.some(
+    (attr) => attr.type === "JSXAttribute" && attr.name.name === "key"
+  );
+}
+function getAttrValue(value) {
+  if (!value) return { type: "Literal", value: true };
+  return value.type === "JSXExpressionContainer" ? value.expression : { type: "Literal", value: value.value };
+}
 function getLiteralParts(rootPath) {
   const strings = [];
   const expressions = [];
@@ -13337,120 +13499,111 @@ function getLiteralParts(rootPath) {
     const refNodeIndex = isAttribute ? elementCounter - 1 : parent ? parent.elementCounter : 0;
     let partMeta = { refNodeIndex, isAttribute };
     if (isAttribute) {
-      partMeta.attributeIndex = path.node.staticAttributes ? path.node.staticAttributes.length : 0;
+      const elementNode = path.parentPath.node;
+      partMeta.attributeIndex = elementNode.staticAttributes ? elementNode.staticAttributes.length : 0;
     } else {
       partMeta = { ...partMeta, ...getPreviousSiblingIndex(path) };
     }
     partsMeta.push(partMeta);
     expressions.push(expression);
+    return expression;
+  }
+  function pushAttributeToExpressions(expression, lastExpression, path) {
+    if (lastExpression && lastExpression.type === "ObjectExpression") {
+      const props = expression.type === "ObjectExpression" ? expression.properties : [{ type: "SpreadElement", argument: expression }];
+      lastExpression.properties.push(...props);
+      return lastExpression;
+    }
+    pushToExpressions(expression, path, true);
+    stringPart.push(" ");
+    return expression;
   }
   function recursePath(path) {
-    if (!path || !path.node) return;
+    if (!path) return;
+    if (Array.isArray(path)) {
+      path.forEach(recursePath);
+      return;
+    }
+    if (!path.node) return;
     const { node } = path;
-    if (t.isJSXElement(node) || t.isJSXFragment(node)) {
-      if (t.isJSXElement(node)) {
-        const { openingElement } = node;
-        const tagName = openingElement.name.name;
-        if (isHTMLElement(tagName)) {
-          node.elementCounter = elementCounter;
-          node.staticAttributes = [];
-          elementCounter += 1;
-          stringPart.push(`<${tagName}`);
-          openingElement.attributes.forEach((attr) => {
-            if (t.isJSXSpreadAttribute(attr)) {
-              const attrPath = createPath(attr, path);
-              pushToExpressions(attr.argument, attrPath, true);
-              stringPart.push(" ");
+    if (node.type === "JSXElement") {
+      const { openingElement } = node;
+      const nameNode = openingElement.name;
+      if (!needsToBeJSXCall(path)) {
+        const tagName = nameNode.name;
+        node.elementCounter = elementCounter;
+        node.staticAttributes = [];
+        elementCounter += 1;
+        stringPart.push(`<${tagName} `);
+        let lastExpression = null;
+        openingElement.attributes.forEach((attr) => {
+          if (attr.type === "JSXSpreadAttribute") {
+            lastExpression = pushAttributeToExpressions(attr.argument, lastExpression, createPath(attr, path));
+          } else {
+            const { name, value } = attr;
+            const attrNameStr = getAttributeName(name);
+            if (needsToBeExpression(tagName, attrNameStr) || value && value.type === "JSXExpressionContainer") {
+              const expr = createAttributeExpression(name, value);
+              lastExpression = pushAttributeToExpressions(expr, lastExpression, createPath(attr, path));
             } else {
-              const { name, value } = attr;
-              let attrName = name.name;
-              if (needsToBeExpression(tagName, attrName) || value && t.isJSXExpressionContainer(value)) {
-                const expr = createAttributeExpression(name, value);
-                const attrPath = createPath(attr, path);
-                pushToExpressions(expr, attrPath, true);
-                stringPart.push(" ");
-              } else {
-                attrName = PROPERTY_ATTRIBUTE_MAP[attrName] || attrName;
-                let attrString = ` ${attrName}`;
-                if (value) {
-                  const attrValue = value.value;
-                  const quote = attrValue.includes('"') ? `'` : `"`;
-                  attrString = `${attrString}=${quote}${attrValue}${quote}`;
-                }
-                stringPart.push(attrString);
-                node.staticAttributes.push(attr);
+              const attrName = PROPERTY_ATTRIBUTE_MAP[attrNameStr] || attrNameStr;
+              let attrString = ` ${attrName}`;
+              if (value) {
+                const attrValue = value.value;
+                const quote = attrValue.includes('"') ? "'" : '"';
+                attrString = `${attrString}=${quote}${attrValue}${quote}`;
               }
+              stringPart.push(attrString);
+              node.staticAttributes.push(attr);
+              lastExpression = null;
             }
-          });
-          stringPart.push(">");
-          const children2 = path.get("children");
-          if (Array.isArray(children2)) {
-            children2.forEach((child) => recursePath(child));
-          }
-          if (!SELF_CLOSING_TAGS.includes(tagName)) {
-            stringPart.push(`</${tagName}>`);
           }
-          return;
-        } else {
-          const propsProperties = [];
-          openingElement.attributes.forEach((attr) => {
-            if (t.isJSXAttribute(attr)) {
-              let attrName = attr.name.name;
-              const value = attr.value;
-              let valNode;
-              attrName = PROPERTY_ATTRIBUTE_MAP[attrName] || attrName;
-              if (!value) {
-                valNode = { type: "Literal", value: true };
-              } else if (t.isJSXExpressionContainer(value)) {
-                valNode = value.expression;
-              } else {
-                valNode = { type: "Literal", value: value.value };
-              }
-              propsProperties.push({
-                type: "Property",
-                key: { type: "Identifier", name: attrName },
-                value: valNode,
-                kind: "init"
-              });
-            } else if (t.isJSXSpreadAttribute(attr)) {
-              propsProperties.push({
-                type: "SpreadElement",
-                argument: attr.argument
-              });
+        });
+        stringPart.push(">");
+        path.get("children").forEach(recursePath);
+        if (!SELF_CLOSING_TAGS.includes(tagName)) stringPart.push(`</${tagName}>`);
+      } else {
+        const propsProperties = [];
+        let keyValue = null;
+        openingElement.attributes.forEach((attr) => {
+          if (attr.type === "JSXAttribute") {
+            const attrName = attr.name.name;
+            const valNode = getAttrValue(attr.value);
+            if (attrName === "key") {
+              keyValue = valNode;
+            } else {
+              propsProperties.push({ type: "Property", key: { type: "Identifier", name: attrName }, value: valNode, kind: "init" });
             }
+          } else if (attr.type === "JSXSpreadAttribute") {
+            propsProperties.push({ type: "SpreadElement", argument: attr.argument });
+          }
+        });
+        const childrenPaths = path.get("children");
+        if (childrenPaths && childrenPaths.length) {
+          propsProperties.push({
+            type: "Property",
+            key: { type: "Identifier", name: "children" },
+            value: transformToAstNode(getTaggedTemplate(childrenPaths)),
+            kind: "init"
           });
-          let extractedText = "";
-          const children2 = path.get("children");
-          if (Array.isArray(children2)) {
-            children2.forEach((cp) => {
-              if (t.isJSXText(cp.node)) {
-                extractedText += cleanStringForHtml(cp.node.value);
-              }
-            });
-          }
-          const callExpr = {
-            type: "CallExpression",
-            callee: { type: "Identifier", name: "jsx" },
-            arguments: [
-              { type: "Identifier", name: tagName },
-              { type: "ObjectExpression", properties: propsProperties },
-              { type: "Literal", value: extractedText }
-            ]
-          };
-          pushToExpressions(callExpr, path, false);
-          return;
         }
-      }
-      const children = path.get("children");
-      if (Array.isArray(children)) {
-        children.forEach((child) => recursePath(child));
-      }
-    } else if (t.isJSXText(node)) {
+        pushToExpressions({
+          type: "CallExpression",
+          callee: {
+            type: "Identifier",
+            name: "_brahmosJSX"
+          },
+          arguments: keyValue ? [jsxNameToExpression(nameNode), { type: "ObjectExpression", properties: propsProperties }, keyValue] : [jsxNameToExpression(nameNode), { type: "ObjectExpression", properties: propsProperties }]
+        }, path, false);
+      }
+    } else if (node.type === "JSXFragment") {
+      path.get("children").forEach(recursePath);
+    } else if (node.type === "JSXText") {
       const cleanStr = cleanStringForHtml(node.value);
       if (cleanStr) stringPart.push(cleanStr);
-    } else if (t.isJSXExpressionContainer(node) && !t.isJSXEmptyExpression(node.expression)) {
+    } else if (node.type === "JSXExpressionContainer" && node.expression.type !== "JSXEmptyExpression") {
       if (isWrappedWithString(path)) {
-        stringPart.push("");
+        stringPart.push(`<!--${BRAHMOS_PLACEHOLDER}-->`);
       }
       pushToExpressions(node.expression, path, false);
     }
@@ -13459,33 +13612,51 @@ function getLiteralParts(rootPath) {
   pushToStrings(true);
   return { strings, expressions, partsMeta };
 }
-function getTaggedTemplate(node) {
-  const path = createPath(node);
-  const { strings, expressions, partsMeta } = getLiteralParts(path);
-  if (expressions.length === 1 && isEmptyLiteralWrap(strings)) {
-    return expressions[0];
+function getSingleTextChild(path) {
+  let jsxText;
+  if (Array.isArray(path) && path.length === 1 && path[0].node.type === "JSXText") {
+    jsxText = path[0].node;
+  } else if (path.node && path.node.type === "JSXFragment" && path.node.children.length === 1 && path.node.children[0].type === "JSXText") {
+    jsxText = path.node.children[0];
+  }
+  return jsxText && { type: "Literal", value: cleanStringForHtml(jsxText.value) };
+}
+function getTaggedTemplate(nodeOrPath) {
+  let path;
+  if (Array.isArray(nodeOrPath) || nodeOrPath.node && nodeOrPath.get) {
+    path = nodeOrPath;
+  } else {
+    path = createPath(nodeOrPath);
   }
-  const metaStr = getPartMetaStringLiteral(partsMeta);
+  const singleTextChild = getSingleTextChild(path);
+  if (singleTextChild) return singleTextChild;
+  const { strings, expressions, partsMeta } = getLiteralParts(path);
+  if (expressions.length === 1 && isEmptyLiteralWrap(strings)) return expressions[0];
   return {
     type: "TaggedTemplateExpression",
-    tag: "html",
+    tag: "_brahmosHtml",
     template: {
+      type: "TemplateLiteral",
       strings,
       expressions
     },
-    meta: metaStr
+    meta: getPartMetaStringLiteral(partsMeta)
   };
 }
 
 // src/plugin/walkAndTransform.js
 function walkAndTransform(node) {
   if (!node || typeof node !== "object") return node;
+  if (node.type === "Program") {
+    addBrahmosRuntime(createPath(node));
+  }
   if (Array.isArray(node)) {
     return node.map(walkAndTransform);
   }
   if (node.type === "JSXElement" || node.type === "JSXFragment") {
     const result = getTaggedTemplate(node);
-    return transformToAstNode(result);
+    const astNode = transformToAstNode(result);
+    return walkAndTransform(astNode);
   }
   const newNode = { ...node };
   for (const key in newNode) {
@@ -13495,36 +13666,6 @@ function walkAndTransform(node) {
   }
   return newNode;
 }
-function transformToAstNode(res) {
-  if (typeof res === "string") {
-    return { type: "Literal", value: res, raw: `'${res}'` };
-  }
-  if (res.type === "TaggedTemplateExpression") {
-    return {
-      type: "CallExpression",
-      callee: {
-        type: "TaggedTemplateExpression",
-        // tag name uses 'html' etc. passed from getTaggedTemplate
-        tag: { type: "Identifier", name: res.tag },
-        quasi: {
-          type: "TemplateLiteral",
-          quasis: res.template.strings.map((s) => ({
-            type: "TemplateElement",
-            // astring requires value: { raw, cooked } to output the content
-            value: {
-              raw: s.value.raw || "",
-              cooked: s.value.cooked || ""
-            },
-            tail: s.tail
-          })),
-          expressions: res.template.expressions
-        }
-      },
-      arguments: [{ type: "Literal", value: res.meta, raw: `'${res.meta}'` }]
-    };
-  }
-  return res;
-}
 
 // src/plugin/transformer.js
 var parser = Parser.extend((0, import_acorn_jsx.default)());
@@ -13533,36 +13674,7 @@ function transformCode(source) {
     ecmaVersion: "latest",
     sourceType: "module"
   });
-  const LIBRARY_NAME = "potatejs";
-  const IMPORT_NAME = "html";
-  let isHtmlImported = false;
-  for (const node of ast.body) {
-    if (node.type === "ImportDeclaration" && node.source.value === LIBRARY_NAME) {
-      if (node.specifiers.some((s) => s.imported && s.imported.name === IMPORT_NAME)) {
-        isHtmlImported = true;
-        break;
-      }
-    }
-  }
   const transformedAst = walkAndTransform(ast);
-  const needsHtml = JSON.stringify(transformedAst).includes(`"name":"${IMPORT_NAME}"`);
-  if (needsHtml && !isHtmlImported) {
-    transformedAst.body.unshift({
-      type: "ImportDeclaration",
-      specifiers: [
-        {
-          type: "ImportSpecifier",
-          imported: { type: "Identifier", name: IMPORT_NAME },
-          local: { type: "Identifier", name: IMPORT_NAME }
-        }
-      ],
-      source: {
-        type: "Literal",
-        value: LIBRARY_NAME,
-        raw: `'${LIBRARY_NAME}'`
-      }
-    });
-  }
   return generate(transformedAst);
 }