@novility/react-converter-core 1.0.0

package/dist/index.js

@@ -0,0 +1,1338 @@
+// src/core/parser.js
+import { parse } from "@babel/parser";
+function parseFile(code) {
+  return parse(code, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript"]
+  });
+}
+
+// src/core/transformer/index.js
+import traverseModule from "@babel/traverse";
+import * as t4 from "@babel/types";
+
+// src/utils/ast.js
+import * as t from "@babel/types";
+function walkNode(node, visit) {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    node.forEach((child) => walkNode(child, visit));
+    return;
+  }
+  visit(node);
+  for (const key of Object.keys(node)) {
+    if (key === "loc" || key === "start" || key === "end") continue;
+    const value = node[key];
+    if (value && typeof value === "object") {
+      walkNode(value, visit);
+    }
+  }
+}
+function getJSXName(nameNode) {
+  if (t.isJSXIdentifier(nameNode)) return nameNode.name;
+  if (t.isJSXMemberExpression(nameNode)) {
+    return `${getJSXName(nameNode.object)}.${getJSXName(nameNode.property)}`;
+  }
+  return "div";
+}
+function isComponentTag(tagName) {
+  return Boolean(tagName && tagName[0] === tagName[0].toUpperCase());
+}
+function normalizeAttributeName(name) {
+  if (name === "className") return "class";
+  if (name === "htmlFor") return "for";
+  return name;
+}
+function normalizeText(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function indent(level) {
+  return "  ".repeat(level);
+}
+
+// src/core/transformer/printer.js
+import * as t2 from "@babel/types";
+function printExpression(expr, level = 0, printJSXAsExpression2, propNames, usePlaceholders) {
+  if (!expr) return "undefined";
+  if (t2.isArrowFunctionExpression(expr) || t2.isFunctionExpression(expr)) {
+    return printFunctionExpression(expr, level, printJSXAsExpression2, propNames, usePlaceholders);
+  }
+  if (t2.isIdentifier(expr)) {
+    if (usePlaceholders && propNames && propNames.has(expr.name)) {
+      return `$${expr.name}`;
+    }
+    return expr.name;
+  }
+  if (t2.isStringLiteral(expr)) return printLiteral(expr.value);
+  if (t2.isNumericLiteral(expr)) return String(expr.value);
+  if (t2.isBooleanLiteral(expr)) return String(expr.value);
+  if (t2.isNullLiteral(expr)) return "null";
+  if (t2.isJSXElement(expr) || t2.isJSXFragment(expr)) return printJSXAsExpression2(expr, level, propNames, usePlaceholders);
+  if (typeof t2.isTSAsExpression === "function" && t2.isTSAsExpression(expr) || typeof t2.isTSTypeAssertion === "function" && t2.isTSTypeAssertion(expr)) {
+    return printExpression(expr.expression, level, printJSXAsExpression2, propNames, usePlaceholders);
+  }
+  if (typeof t2.isTSNonNullExpression === "function" && t2.isTSNonNullExpression(expr)) {
+    return printExpression(expr.expression, level, printJSXAsExpression2, propNames, usePlaceholders);
+  }
+  if (typeof t2.isTypeCastExpression === "function" && t2.isTypeCastExpression(expr)) {
+    return printExpression(expr.expression, level, printJSXAsExpression2, propNames, usePlaceholders);
+  }
+  if (t2.isCallExpression(expr)) return printCallExpression(expr, level, printJSXAsExpression2, propNames, usePlaceholders);
+  if (t2.isMemberExpression(expr)) return printMemberExpression(expr, level, printJSXAsExpression2, propNames, usePlaceholders);
+  if (typeof t2.isOptionalMemberExpression === "function" && t2.isOptionalMemberExpression(expr)) {
+    return printOptionalMemberExpression(expr, level, printJSXAsExpression2, propNames, usePlaceholders);
+  }
+  if (typeof t2.isOptionalCallExpression === "function" && t2.isOptionalCallExpression(expr)) {
+    return printOptionalCallExpression(expr, level, printJSXAsExpression2, propNames, usePlaceholders);
+  }
+  if (t2.isTemplateLiteral(expr)) return printTemplateLiteral(expr, level, printJSXAsExpression2, propNames, usePlaceholders);
+  if (t2.isArrayExpression(expr)) return printArrayExpression(expr, level, printJSXAsExpression2, propNames, usePlaceholders);
+  if (t2.isObjectExpression(expr)) return printObjectExpression(expr, level, printJSXAsExpression2, propNames, usePlaceholders);
+  if (t2.isUnaryExpression(expr)) return `${expr.operator}${printExpression(expr.argument, level, printJSXAsExpression2, propNames, usePlaceholders)}`;
+  if (t2.isUpdateExpression(expr)) {
+    return expr.prefix ? `${expr.operator}${printExpression(expr.argument, level, printJSXAsExpression2, propNames, usePlaceholders)}` : `${printExpression(expr.argument, level, printJSXAsExpression2, propNames, usePlaceholders)}${expr.operator}`;
+  }
+  if (t2.isBinaryExpression(expr) || t2.isLogicalExpression(expr)) {
+    return `${printExpression(expr.left, level, printJSXAsExpression2, propNames, usePlaceholders)} ${expr.operator} ${printExpression(expr.right, level, printJSXAsExpression2, propNames, usePlaceholders)}`;
+  }
+  if (t2.isConditionalExpression(expr)) {
+    return `${printExpression(expr.test, level, printJSXAsExpression2, propNames, usePlaceholders)} ? ${printExpression(expr.consequent, level, printJSXAsExpression2, propNames, usePlaceholders)} : ${printExpression(expr.alternate, level, printJSXAsExpression2, propNames, usePlaceholders)}`;
+  }
+  return "undefined";
+}
+function printFunctionExpression(expr, level, printJSXAsExpression2, propNames, usePlaceholders) {
+  const params = expr.params.map((param) => printPattern(param, printJSXAsExpression2, propNames, usePlaceholders)).join(", ");
+  if (t2.isBlockStatement(expr.body)) {
+    const bodyLines = printStatementLines(expr.body.body, level + 1, printJSXAsExpression2, propNames, usePlaceholders);
+    return `function (${params}) {
+${bodyLines.join("\n")}
+${indent(level)}}`;
+  }
+  return `function (${params}) { return ${printExpression(expr.body, level, printJSXAsExpression2, propNames, usePlaceholders)}; }`;
+}
+function printPattern(param, printJSXAsExpression2, propNames, usePlaceholders) {
+  if (t2.isIdentifier(param)) {
+    if (usePlaceholders && propNames && propNames.has(param.name)) {
+      return `$${param.name}`;
+    }
+    return param.name;
+  }
+  if (t2.isAssignmentPattern(param)) {
+    return `${printPattern(param.left, printJSXAsExpression2, propNames, usePlaceholders)} = ${printExpression(param.right, 0, printJSXAsExpression2, propNames, usePlaceholders)}`;
+  }
+  if (t2.isArrayPattern(param)) {
+    const parts = param.elements.map((el) => el ? printPattern(el, printJSXAsExpression2, propNames, usePlaceholders) : "");
+    return `[${parts.join(", ")}]`;
+  }
+  if (t2.isObjectPattern(param)) {
+    const props = param.properties.map((prop) => {
+      if (t2.isObjectProperty(prop)) {
+        const key = t2.isIdentifier(prop.key) ? prop.key.name : printExpression(prop.key, 0, printJSXAsExpression2, propNames, usePlaceholders);
+        const value = printPattern(prop.value, printJSXAsExpression2, propNames, usePlaceholders);
+        if (prop.shorthand && t2.isIdentifier(prop.value) && prop.value.name === key) {
+          return key;
+        }
+        return `${key}: ${value}`;
+      }
+      if (t2.isRestElement(prop)) {
+        return `...${printPattern(prop.argument, printJSXAsExpression2, propNames, usePlaceholders)}`;
+      }
+      return "";
+    });
+    return `{ ${props.filter(Boolean).join(", ")} }`;
+  }
+  if (t2.isRestElement(param)) return `...${printPattern(param.argument, printJSXAsExpression2, propNames, usePlaceholders)}`;
+  return "param";
+}
+function printStatementLines(statements, level, printJSXAsExpression2, propNames, usePlaceholders) {
+  if (!statements || statements.length === 0) return [];
+  const lines = [];
+  for (const stmt of statements) {
+    if (t2.isExpressionStatement(stmt)) {
+      lines.push(`${indent(level)}${printExpression(stmt.expression, level, printJSXAsExpression2, propNames, usePlaceholders)};`);
+      continue;
+    }
+    if (t2.isReturnStatement(stmt)) {
+      lines.push(`${indent(level)}return ${printExpression(stmt.argument, level, printJSXAsExpression2, propNames, usePlaceholders)};`);
+      continue;
+    }
+    if (t2.isVariableDeclaration(stmt)) {
+      const decls = stmt.declarations.map((decl) => {
+        const name = printPattern(decl.id, printJSXAsExpression2, propNames, usePlaceholders);
+        const init = decl.init ? ` = ${printExpression(decl.init, level, printJSXAsExpression2, propNames, usePlaceholders)}` : "";
+        return `${name}${init}`;
+      });
+      lines.push(`${indent(level)}${stmt.kind} ${decls.join(", ")};`);
+      continue;
+    }
+    if (t2.isIfStatement(stmt)) {
+      lines.push(`${indent(level)}if (${printExpression(stmt.test, level, printJSXAsExpression2, propNames, usePlaceholders)}) {`);
+      lines.push(...printStatementLines(asStatementList(stmt.consequent), level + 1, printJSXAsExpression2, propNames, usePlaceholders));
+      lines.push(`${indent(level)}}`);
+      if (stmt.alternate) {
+        if (t2.isIfStatement(stmt.alternate)) {
+          lines.push(`${indent(level)}else ` + printInlineIf(stmt.alternate, printJSXAsExpression2, propNames, usePlaceholders));
+        } else {
+          lines.push(`${indent(level)}else {`);
+          lines.push(...printStatementLines(asStatementList(stmt.alternate), level + 1, printJSXAsExpression2, propNames, usePlaceholders));
+          lines.push(`${indent(level)}}`);
+        }
+      }
+      continue;
+    }
+    if (t2.isSwitchStatement(stmt)) {
+      lines.push(`${indent(level)}switch (${printExpression(stmt.discriminant, level, printJSXAsExpression2, propNames, usePlaceholders)}) {`);
+      for (const switchCase of stmt.cases) {
+        const label = switchCase.test ? `case ${printExpression(switchCase.test, level, printJSXAsExpression2, propNames, usePlaceholders)}:` : "default:";
+        lines.push(`${indent(level + 1)}${label}`);
+        lines.push(...printStatementLines(switchCase.consequent, level + 2, printJSXAsExpression2, propNames, usePlaceholders));
+      }
+      lines.push(`${indent(level)}}`);
+      continue;
+    }
+    if (t2.isBreakStatement(stmt)) {
+      lines.push(`${indent(level)}break;`);
+      continue;
+    }
+    if (t2.isFunctionDeclaration(stmt) && stmt.id) {
+      const name = stmt.id.name;
+      const params = stmt.params.map((param) => printPattern(param, printJSXAsExpression2, propNames, usePlaceholders)).join(", ");
+      const bodyLines = printStatementLines(stmt.body.body, level + 1, printJSXAsExpression2, propNames, usePlaceholders);
+      lines.push(`${indent(level)}function ${name}(${params}) {`);
+      lines.push(...bodyLines);
+      lines.push(`${indent(level)}}`);
+    }
+  }
+  return lines;
+}
+function asStatementList(stmt) {
+  if (t2.isBlockStatement(stmt)) return stmt.body;
+  return [stmt];
+}
+function printInlineIf(stmt, printJSXAsExpression2, propNames, usePlaceholders) {
+  const test = printExpression(stmt.test, 0, printJSXAsExpression2, propNames, usePlaceholders);
+  const consequentLines = printStatementLines(asStatementList(stmt.consequent), 0, printJSXAsExpression2, propNames, usePlaceholders);
+  const consequentBody = consequentLines.length ? `if (${test}) {
+${consequentLines.join("\n")}
+}` : `if (${test}) {}`;
+  if (!stmt.alternate) return consequentBody;
+  if (t2.isIfStatement(stmt.alternate)) {
+    return `${consequentBody} else ${printInlineIf(stmt.alternate, printJSXAsExpression2, propNames, usePlaceholders)}`;
+  }
+  const alternateLines = printStatementLines(asStatementList(stmt.alternate), 0, printJSXAsExpression2, propNames, usePlaceholders);
+  const alternateBody = alternateLines.length ? ` else {
+${alternateLines.join("\n")}
+}` : " else {}";
+  return `${consequentBody}${alternateBody}`;
+}
+function printCallExpression(expr, level, printJSXAsExpression2, propNames, usePlaceholders) {
+  const callee = printExpression(expr.callee, level, printJSXAsExpression2, propNames, usePlaceholders);
+  const args = expr.arguments.map((arg) => printExpression(arg, level, printJSXAsExpression2, propNames, usePlaceholders)).join(", ");
+  return `${callee}(${args})`;
+}
+function printMemberExpression(expr, level, printJSXAsExpression2, propNames, usePlaceholders) {
+  const object = printExpression(expr.object, level, printJSXAsExpression2, propNames, usePlaceholders);
+  const prop = expr.computed ? `[${printExpression(expr.property, level, printJSXAsExpression2, propNames, usePlaceholders)}]` : `.${expr.property.name}`;
+  return `${object}${prop}`;
+}
+function printOptionalMemberExpression(expr, level, printJSXAsExpression2, propNames, usePlaceholders) {
+  const object = printExpression(expr.object, level, printJSXAsExpression2, propNames, usePlaceholders);
+  const prop = expr.computed ? `[${printExpression(expr.property, level, printJSXAsExpression2, propNames, usePlaceholders)}]` : `.${expr.property.name}`;
+  return `${object}?.${prop.startsWith(".") ? prop.slice(1) : prop}`;
+}
+function printOptionalCallExpression(expr, level, printJSXAsExpression2, propNames, usePlaceholders) {
+  const callee = printExpression(expr.callee, level, printJSXAsExpression2, propNames, usePlaceholders);
+  const args = expr.arguments.map((arg) => printExpression(arg, level, printJSXAsExpression2, propNames, usePlaceholders)).join(", ");
+  return `${callee}?.(${args})`;
+}
+function printTemplateLiteral(expr, level, printJSXAsExpression2, propNames, usePlaceholders) {
+  const parts = expr.quasis.map((q) => q.value.cooked || "");
+  if (expr.expressions.length === 0) {
+    return printLiteral(parts.join(""));
+  }
+  const expressions = expr.expressions.map((e) => printExpression(e, level, printJSXAsExpression2, propNames, usePlaceholders));
+  let output = "`";
+  for (let i = 0; i < parts.length; i += 1) {
+    output += escapeTemplateChunk(parts[i]);
+    if (expressions[i]) output += "${" + expressions[i] + "}";
+  }
+  output += "`";
+  return output;
+}
+function escapeTemplateChunk(value) {
+  return String(value).replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+}
+function printArrayExpression(expr, level, printJSXAsExpression2, propNames, usePlaceholders) {
+  const parts = expr.elements.map((el) => {
+    if (!el) return "";
+    if (t2.isSpreadElement(el)) return `...${printExpression(el.argument, level, printJSXAsExpression2, propNames, usePlaceholders)}`;
+    return printExpression(el, level, printJSXAsExpression2, propNames, usePlaceholders);
+  });
+  return `[${parts.join(", ")}]`;
+}
+function printObjectExpression(expr, level, printJSXAsExpression2, propNames, usePlaceholders) {
+  const props = expr.properties.map((prop) => {
+    if (t2.isObjectProperty(prop)) {
+      const key = t2.isIdentifier(prop.key) ? prop.key.name : printExpression(prop.key, level, printJSXAsExpression2, propNames, usePlaceholders);
+      const value = printExpression(prop.value, level, printJSXAsExpression2, propNames, usePlaceholders);
+      if (prop.shorthand && t2.isIdentifier(prop.value) && prop.value.name === key) {
+        return key;
+      }
+      return `${key}: ${value}`;
+    }
+    if (t2.isSpreadElement(prop)) {
+      return `...${printExpression(prop.argument, level, printJSXAsExpression2, propNames, usePlaceholders)}`;
+    }
+    return "";
+  });
+  return `{ ${props.filter(Boolean).join(", ")} }`;
+}
+function printLiteral(value, isTemplate = false) {
+  const base = String(value).replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/\r/g, "").replace(/\t/g, "\\t");
+  if (isTemplate) {
+    const escaped2 = base.replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+    return `\`${escaped2}\``;
+  }
+  const escaped = base.replace(/"/g, '\\"');
+  return `"${escaped}"`;
+}
+
+// src/core/transformer/jsx-emitter.js
+import * as t3 from "@babel/types";
+function emitJSX(node, varName, level, lines, propNames, usePlaceholders) {
+  if (t3.isJSXFragment(node)) {
+    lines.push(`${indent(level)}const ${varName} = document.createDocumentFragment();`);
+    emitChildren(node.children, varName, level, lines, propNames, usePlaceholders);
+    return;
+  }
+  if (!t3.isJSXElement(node)) return;
+  const tagName = getJSXName(node.openingElement.name);
+  if (isComponentTag(tagName)) {
+    const propsExpr = buildPropsExpression(node.openingElement.attributes, node.children, level, propNames, usePlaceholders);
+    lines.push(`${indent(level)}const ${varName} = __renderComponent(${tagName}, ${propsExpr});`);
+    return;
+  }
+  lines.push(`${indent(level)}const ${varName} = document.createElement("${tagName}");`);
+  for (const attr of node.openingElement.attributes) {
+    if (t3.isJSXSpreadAttribute(attr)) continue;
+    if (!t3.isJSXIdentifier(attr.name)) continue;
+    const rawName = attr.name.name;
+    const attrName = normalizeAttributeName(rawName);
+    if (rawName.startsWith("on") && rawName.length > 2) {
+      const event = rawName.slice(2).toLowerCase();
+      const handler = attr.value ? printExpression(getExpressionValue(attr.value), level, printJSXAsExpression, propNames, usePlaceholders) : "function(){}";
+      lines.push(`${indent(level)}__addEventListener(${varName}, "${event}", ${handler});`);
+      continue;
+    }
+    if (!attr.value) {
+      lines.push(`${indent(level)}${varName}.setAttribute("${attrName}", "");`);
+      continue;
+    }
+    if (t3.isStringLiteral(attr.value)) {
+      if (attrName === "style") {
+        lines.push(
+          `${indent(level)}__setStyle(${varName}, ${printLiteral(attr.value.value)});`
+        );
+      } else {
+        lines.push(
+          `${indent(level)}__setAttribute(${varName}, "${attrName}", ${printLiteral(attr.value.value)});`
+        );
+      }
+      continue;
+    }
+    if (t3.isJSXExpressionContainer(attr.value)) {
+      const expr = attr.value.expression;
+      if (attrName === "style") {
+        lines.push(`${indent(level)}__setStyle(${varName}, ${printExpression(expr, level, printJSXAsExpression, propNames, usePlaceholders)});`);
+      } else {
+        lines.push(
+          `${indent(level)}__setAttribute(${varName}, "${attrName}", ${printExpression(expr, level, printJSXAsExpression, propNames, usePlaceholders)});`
+        );
+      }
+    }
+  }
+  emitChildren(node.children, varName, level, lines, propNames, usePlaceholders);
+}
+function emitChildren(children, varName, level, lines, propNames, usePlaceholders) {
+  let index = 0;
+  for (const child of children) {
+    const childVar = `${varName}_${index}`;
+    if (t3.isJSXText(child)) {
+      const text = normalizeText(child.value);
+      if (text) {
+        lines.push(`${indent(level)}__appendChild(${varName}, ${printLiteral(text)});`);
+      }
+      index += 1;
+      continue;
+    }
+    if (t3.isJSXElement(child) || t3.isJSXFragment(child)) {
+      emitJSX(child, childVar, level, lines, propNames, usePlaceholders);
+      lines.push(`${indent(level)}__appendChild(${varName}, ${childVar});`);
+      index += 1;
+      continue;
+    }
+    if (t3.isJSXExpressionContainer(child)) {
+      const expr = child.expression;
+      if (!t3.isJSXEmptyExpression(expr)) {
+        lines.push(`${indent(level)}__appendChild(${varName}, ${printExpression(expr, level, printJSXAsExpression, propNames, usePlaceholders)});`);
+      }
+      index += 1;
+    }
+  }
+}
+function buildPropsExpression(attributes, children, level, propNames, usePlaceholders) {
+  const props = [];
+  for (const attr of attributes) {
+    if (t3.isJSXSpreadAttribute(attr)) {
+      props.push(`...${printExpression(attr.argument, level, printJSXAsExpression, propNames, usePlaceholders)}`);
+      continue;
+    }
+    if (!t3.isJSXIdentifier(attr.name)) continue;
+    const name = attr.name.name;
+    if (!attr.value) {
+      props.push(`${name}: true`);
+      continue;
+    }
+    if (t3.isStringLiteral(attr.value)) {
+      props.push(`${name}: ${printLiteral(attr.value.value)}`);
+      continue;
+    }
+    if (t3.isJSXExpressionContainer(attr.value)) {
+      const expr = attr.value.expression;
+      if (!t3.isJSXEmptyExpression(expr)) {
+        props.push(`${name}: ${printExpression(expr, level, printJSXAsExpression, propNames, usePlaceholders)}`);
+      }
+    }
+  }
+  const childrenExpr = buildChildrenProp(children, level, propNames, usePlaceholders);
+  if (childrenExpr) {
+    props.push(`children: ${childrenExpr}`);
+  }
+  if (props.length === 0) return "{}";
+  return `{ ${props.join(", ")} }`;
+}
+function buildChildrenProp(children, level, propNames, usePlaceholders) {
+  const childExprs = [];
+  for (const child of children) {
+    const expr = printChildExpression(child, level, propNames, usePlaceholders);
+    if (expr) childExprs.push(expr);
+  }
+  if (childExprs.length === 0) return "";
+  if (childExprs.length === 1) return childExprs[0];
+  return `[${childExprs.join(", ")}]`;
+}
+function printChildExpression(child, level, propNames, usePlaceholders) {
+  if (t3.isJSXText(child)) {
+    const text = normalizeText(child.value);
+    return text ? printLiteral(text) : "";
+  }
+  if (t3.isJSXElement(child) || t3.isJSXFragment(child)) {
+    return printJSXAsExpression(child, level, propNames, usePlaceholders);
+  }
+  if (t3.isJSXExpressionContainer(child)) {
+    const expr = child.expression;
+    if (t3.isJSXEmptyExpression(expr)) return "";
+    return printExpression(expr, level, printJSXAsExpression, propNames, usePlaceholders);
+  }
+  return "";
+}
+function printJSXAsExpression(node, level, propNames, usePlaceholders) {
+  const lines = [];
+  emitJSX(node, "jsx_node", level + 1, lines, propNames, usePlaceholders);
+  lines.push(`${indent(level + 1)}return jsx_node;`);
+  return `(() => {
+${lines.join("\n")}
+${indent(level)}})()`;
+}
+function getExpressionValue(valueNode) {
+  if (t3.isJSXExpressionContainer(valueNode)) {
+    return valueNode.expression;
+  }
+  if (t3.isStringLiteral(valueNode)) {
+    return valueNode;
+  }
+  return null;
+}
+
+// src/core/transformer/index.js
+var traverse = traverseModule.default ?? traverseModule;
+var HOOK_NAMES = /* @__PURE__ */ new Set([
+  "useState",
+  "useEffect",
+  "useRef",
+  "useReducer",
+  "useMemo",
+  "useCallback",
+  "useContext"
+]);
+function transform(ast, options = {}) {
+  const output = [];
+  const usePlaceholders = Boolean(options.usePlaceholders);
+  function addComponent(name, jsxNode, preStatements = [], hooksUsed2 = [], params = "", propNames = /* @__PURE__ */ new Set()) {
+    if (!name || !jsxNode) return;
+    const bodyLines = buildComponentBody(jsxNode, preStatements, propNames, usePlaceholders);
+    if (bodyLines.length === 0) return;
+    output.push({ name, bodyLines, hooksUsed: hooksUsed2, params });
+  }
+  traverse(ast, {
+    FunctionDeclaration(path2) {
+      const name = path2.node.id?.name;
+      const result = findReturnedJSX(path2.node);
+      const hooksUsed2 = collectHookNames(path2.node);
+      const params = printFunctionParams(path2.node);
+      const propNames = collectPropNames(path2.node);
+      addComponent(name, result?.jsxNode, result?.preStatements, hooksUsed2, params, propNames);
+    },
+    VariableDeclarator(path2) {
+      if (!t4.isIdentifier(path2.node.id)) return;
+      const name = path2.node.id.name;
+      const init = unwrapComponentFunction(path2.node.init);
+      if (!init) return;
+      const result = findReturnedJSX(init);
+      const hooksUsed2 = collectHookNames(init);
+      const params = printFunctionParams(init);
+      const propNames = collectPropNames(init);
+      addComponent(name, result?.jsxNode, result?.preStatements, hooksUsed2, params, propNames);
+    }
+  });
+  const hooksUsed = /* @__PURE__ */ new Set();
+  for (const comp of output) {
+    if (!comp || !Array.isArray(comp.hooksUsed)) continue;
+    for (const hook of comp.hooksUsed) hooksUsed.add(hook);
+  }
+  return { components: output, hooksUsed: Array.from(hooksUsed) };
+}
+function unwrapComponentFunction(node) {
+  if (t4.isArrowFunctionExpression(node) || t4.isFunctionExpression(node)) {
+    return node;
+  }
+  if (t4.isCallExpression(node)) {
+    const callee = node.callee;
+    const isMemo = t4.isMemberExpression(callee) && t4.isIdentifier(callee.object, { name: "React" }) && t4.isIdentifier(callee.property, { name: "memo" }) || t4.isIdentifier(callee, { name: "memo" });
+    const firstArg = node.arguments[0];
+    if (isMemo && (t4.isArrowFunctionExpression(firstArg) || t4.isFunctionExpression(firstArg))) {
+      return firstArg;
+    }
+  }
+  return null;
+}
+function printFunctionParams(fnNode) {
+  if (!fnNode || !Array.isArray(fnNode.params)) return "";
+  return fnNode.params.map((param) => printPattern(param, printJSXAsExpression)).join(", ");
+}
+function findReturnedJSX(fnNode) {
+  const preStatements = [];
+  if (t4.isArrowFunctionExpression(fnNode)) {
+    if (t4.isJSXElement(fnNode.body) || t4.isJSXFragment(fnNode.body)) {
+      return { jsxNode: fnNode.body, preStatements };
+    }
+  }
+  if (t4.isFunctionDeclaration(fnNode) || t4.isFunctionExpression(fnNode) || t4.isArrowFunctionExpression(fnNode)) {
+    if (!t4.isBlockStatement(fnNode.body)) return null;
+    for (const stmt of fnNode.body.body) {
+      if (t4.isReturnStatement(stmt)) {
+        const arg = stmt.argument;
+        if (t4.isJSXElement(arg) || t4.isJSXFragment(arg)) {
+          return { jsxNode: arg, preStatements };
+        }
+      } else {
+        preStatements.push(stmt);
+      }
+    }
+  }
+  return null;
+}
+function buildComponentBody(jsxNode, preStatements, propNames, usePlaceholders) {
+  const lines = [];
+  lines.push(...printStatementLines(preStatements, 1, printJSXAsExpression, propNames, usePlaceholders));
+  emitJSX(jsxNode, "root", 1, lines, propNames, usePlaceholders);
+  lines.push(`${indent(1)}return root;`);
+  return lines;
+}
+function collectHookNames(fnNode) {
+  const hooks = /* @__PURE__ */ new Set();
+  walkNode(fnNode, (node) => {
+    if (t4.isCallExpression(node) && t4.isIdentifier(node.callee)) {
+      if (HOOK_NAMES.has(node.callee.name)) {
+        hooks.add(node.callee.name);
+      }
+    }
+    if (t4.isCallExpression(node) && t4.isMemberExpression(node.callee)) {
+      const prop = node.callee.property;
+      if (t4.isIdentifier(prop) && HOOK_NAMES.has(prop.name)) {
+        hooks.add(prop.name);
+      }
+    }
+  });
+  return Array.from(hooks);
+}
+function collectPropNames(fnNode) {
+  const names = /* @__PURE__ */ new Set();
+  if (!fnNode || !Array.isArray(fnNode.params)) return names;
+  for (const param of fnNode.params) {
+    if (t4.isIdentifier(param)) {
+      names.add(param.name);
+    } else if (t4.isObjectPattern(param)) {
+      for (const prop of param.properties) {
+        if (t4.isObjectProperty(prop)) {
+          if (t4.isIdentifier(prop.key)) {
+            names.add(prop.key.name);
+          }
+        } else if (t4.isRestElement(prop) && t4.isIdentifier(prop.argument)) {
+          names.add(prop.argument.name);
+        }
+      }
+    }
+  }
+  return names;
+}
+
+// src/utils/naming.js
+function toKebabCase(value) {
+  return String(value).replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+function toComponentClassName(tagName, fallbackName) {
+  const base = fallbackName || tagName || "";
+  const parts = String(base).replace(/[^a-zA-Z0-9]+/g, " ").trim().split(/\s+/).filter(Boolean);
+  let name = parts.map((part) => part[0].toUpperCase() + part.slice(1)).join("");
+  if (!name) name = "WebComponent";
+  if (!/^[A-Za-z_$]/.test(name)) name = `Component${name}`;
+  return `${name}Element`;
+}
+function resolveWebComponentTag(tag, fileName, componentName) {
+  if (tag && typeof tag === "string" && tag.includes("-")) {
+    return tag.toLowerCase();
+  }
+  const base = tag || componentName || String(fileName).split(/[\\/]/).pop().replace(/\.(tsx|jsx|ts|js)$/i, "");
+  const kebab = toKebabCase(base);
+  return kebab.includes("-") ? kebab : `x-${kebab}`;
+}
+function toTemplateLiteral(value) {
+  const escaped = String(value).replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+  return `\`${escaped}\``;
+}
+function createStyleId(relPath) {
+  return `tw-${relPath.replace(/[^a-zA-Z0-9-_]/g, "-")}`;
+}
+
+// src/runtime/dom.js
+var domRuntime = `
+function __appendChild(parent, child) {
+  if (child === null || child === undefined || child === false || child === true) return;
+  if (Array.isArray(child)) {
+    for (const item of child) __appendChild(parent, item);
+    return;
+  }
+  const isNode = child && (child.nodeType || (typeof Node !== "undefined" && child instanceof Node));
+  if (isNode) {
+    parent.appendChild(child);
+    return;
+  }
+  parent.appendChild(document.createTextNode(String(child)));
+}
+
+function __renderInstance(instance) {
+  const nextRoot = instance.component(instance.props || {});
+  if (instance.root && instance.root.parentNode) {
+    instance.root.parentNode.replaceChild(nextRoot, instance.root);
+  } else {
+    instance.mountTarget.appendChild(nextRoot);
+  }
+  instance.root = nextRoot;
+}
+
+function __mount(component, mountTarget, props) {
+  const instance = {
+    component,
+    props: props || {},
+    root: null,
+    mountTarget: mountTarget || document.body,
+  };
+  __renderInstance(instance);
+  return instance;
+}
+
+function __setAttribute(el, name, value) {
+  if (value === null || value === undefined || value === false) return;
+  el.setAttribute(name, String(value));
+}
+
+function __setStyle(el, value) {
+  if (!value) return;
+  if (typeof value === "string") {
+    el.setAttribute("style", value);
+    return;
+  }
+  if (typeof value !== "object") return;
+  for (const key of Object.keys(value)) {
+    const styleValue = value[key];
+    if (styleValue === null || styleValue === undefined) continue;
+    if (key.includes("-")) {
+      el.style.setProperty(key, String(styleValue));
+    } else {
+      el.style[key] = String(styleValue);
+    }
+  }
+}
+
+function __addEventListener(el, event, handler) {
+  if (typeof handler !== "function") return;
+  el.addEventListener(event, handler);
+}
+
+function __renderComponent(component, props) {
+  return component(props || {});
+}
+
+function __toCamelCase(name) {
+  return String(name).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+function __getElementProps(el, lightChildren) {
+  const props = {};
+  if (!el || !el.attributes) return props;
+  for (const attr of Array.from(el.attributes)) {
+    if (attr.name === 'data-props') continue;
+    const key = __toCamelCase(attr.name);
+    props[key] = attr.value;
+  }
+  const dataProps = el.getAttribute && el.getAttribute('data-props');
+  if (dataProps) {
+    try {
+      const parsed = JSON.parse(dataProps);
+      if (parsed && typeof parsed === 'object') {
+        Object.assign(props, parsed);
+      }
+    } catch (_) {}
+  }
+  if (lightChildren && lightChildren.length) {
+    props.children = lightChildren;
+  }
+  return props;
+}
+
+function __getRootProps() {
+  if (typeof window !== "undefined" && window.__COMPILER_PROPS__) {
+    return window.__COMPILER_PROPS__ || {};
+  }
+  return {};
+}
+
+function __applyShadowStyles(cssText, styleId, shadowRoot, host) {
+  if (!cssText || !shadowRoot) return;
+  if (host && host.__styleSheet) return;
+  if (typeof injectStyles === "function") {
+    injectStyles(cssText, styleId, shadowRoot);
+    if (host) host.__styleSheet = true;
+  }
+}
+`;
+
+// src/runtime/hooks.js
+function getHookRuntime(hooksUsed) {
+  const hooks = new Set(hooksUsed);
+  const needsDeps = hooks.has("useEffect") || hooks.has("useMemo") || hooks.has("useCallback");
+  const needsEffects = hooks.has("useEffect");
+  let code = "";
+  code += "let __currentInstance = null;\n";
+  code += "function __getCurrentInstance() {\n";
+  code += "  if (!__currentInstance) {\n";
+  code += '    throw new Error("Hooks can only be called inside a component render.");\n';
+  code += "  }\n";
+  code += "  return __currentInstance;\n";
+  code += "}\n\n";
+  if (needsDeps) {
+    code += "function __areHookDepsEqual(prevDeps, nextDeps) {\n";
+    code += "  if (!Array.isArray(prevDeps) || !Array.isArray(nextDeps)) return false;\n";
+    code += "  if (prevDeps.length !== nextDeps.length) return false;\n";
+    code += "  for (let i = 0; i < prevDeps.length; i += 1) {\n";
+    code += "    if (!Object.is(prevDeps[i], nextDeps[i])) return false;\n";
+    code += "  }\n";
+    code += "  return true;\n";
+    code += "}\n\n";
+  }
+  if (needsEffects) {
+    code += "function __flushEffects(instance) {\n";
+    code += "  if (!instance.pendingEffects.length) return;\n";
+    code += "  const effects = instance.pendingEffects.slice();\n";
+    code += "  instance.pendingEffects.length = 0;\n";
+    code += "  const run = () => {\n";
+    code += "    for (const item of effects) {\n";
+    code += "      const previous = instance.hooks[item.index];\n";
+    code += '      if (previous && typeof previous.cleanup === "function") {\n';
+    code += "        previous.cleanup();\n";
+    code += "      }\n";
+    code += "      const cleanup = item.effect();\n";
+    code += "      instance.hooks[item.index] = {\n";
+    code += "        deps: item.deps,\n";
+    code += '        cleanup: typeof cleanup === "function" ? cleanup : null,\n';
+    code += "      };\n";
+    code += "    }\n";
+    code += "  };\n";
+    code += '  if (typeof queueMicrotask === "function") {\n';
+    code += "    queueMicrotask(run);\n";
+    code += "  } else {\n";
+    code += "    setTimeout(run, 0);\n";
+    code += "  }\n";
+    code += "}\n\n";
+  }
+  code += "function __renderInstance(instance) {\n";
+  code += "  instance.hookIndex = 0;\n";
+  code += "  instance.pendingEffects = [];\n";
+  code += "  instance.childIndex = 0;\n";
+  code += "  __currentInstance = instance;\n";
+  code += "  const nextRoot = instance.component(instance.props || {});\n";
+  code += "  __currentInstance = null;\n";
+  code += "  if (instance.root && instance.root.parentNode) {\n";
+  code += "    instance.root.parentNode.replaceChild(nextRoot, instance.root);\n";
+  code += "  } else {\n";
+  code += "    instance.mountTarget.appendChild(nextRoot);\n";
+  code += "  }\n";
+  code += "  instance.root = nextRoot;\n";
+  if (needsEffects) {
+    code += "  __flushEffects(instance);\n";
+  }
+  code += "}\n\n";
+  code += "function __mount(component, mountTarget, props) {\n";
+  code += "  const instance = {\n";
+  code += "    component,\n";
+  code += "    props: props || {},\n";
+  code += "    hooks: [],\n";
+  code += "    hookIndex: 0,\n";
+  code += "    pendingEffects: [],\n";
+  code += "    children: [],\n";
+  code += "    childIndex: 0,\n";
+  code += "    root: null,\n";
+  code += "    mountTarget: mountTarget || document.body,\n";
+  code += "  };\n";
+  code += "  __renderInstance(instance);\n";
+  code += "  return instance;\n";
+  code += "}\n\n";
+  code += "function __renderComponent(component, props) {\n";
+  code += "  const parent = __getCurrentInstance();\n";
+  code += "  const index = parent.childIndex++;\n";
+  code += "  let instance = parent.children[index];\n";
+  code += "  if (!instance || instance.component !== component) {\n";
+  code += "    instance = {\n";
+  code += "      component,\n";
+  code += "      props: {},\n";
+  code += "      hooks: [],\n";
+  code += "      hookIndex: 0,\n";
+  code += "      pendingEffects: [],\n";
+  code += "      children: [],\n";
+  code += "      childIndex: 0,\n";
+  code += "      root: null,\n";
+  code += "      mountTarget: null,\n";
+  code += "    };\n";
+  code += "    parent.children[index] = instance;\n";
+  code += "  }\n";
+  code += "  instance.props = props || {};\n";
+  code += "  instance.hookIndex = 0;\n";
+  code += "  instance.pendingEffects = [];\n";
+  code += "  instance.childIndex = 0;\n";
+  code += "  const prev = __currentInstance;\n";
+  code += "  __currentInstance = instance;\n";
+  code += "  const nextRoot = component(instance.props);\n";
+  code += "  __currentInstance = prev;\n";
+  code += "  instance.root = nextRoot;\n";
+  if (needsEffects) {
+    code += "  __flushEffects(instance);\n";
+  }
+  code += "  return nextRoot;\n";
+  code += "}\n\n";
+  code += "function __teardownInstance(instance) {\n";
+  code += "  if (!instance) return;\n";
+  code += "  if (instance.children) {\n";
+  code += "    for (const child of instance.children) {\n";
+  code += "      __teardownInstance(child);\n";
+  code += "    }\n";
+  code += "  }\n";
+  code += "  if (instance.hooks) {\n";
+  code += "    for (const hook of instance.hooks) {\n";
+  code += '      if (hook && typeof hook.cleanup === "function") {\n';
+  code += "        hook.cleanup();\n";
+  code += "      }\n";
+  code += "    }\n";
+  code += "  }\n";
+  code += "}\n\n";
+  if (hooks.has("useState")) {
+    code += "function useState(initialValue) {\n";
+    code += "  const instance = __getCurrentInstance();\n";
+    code += "  const index = instance.hookIndex++;\n";
+    code += "  if (!Object.prototype.hasOwnProperty.call(instance.hooks, index)) {\n";
+    code += '    instance.hooks[index] = typeof initialValue === "function" ? initialValue() : initialValue;\n';
+    code += "  }\n";
+    code += "  const setState = (value) => {\n";
+    code += '    const nextValue = typeof value === "function" ? value(instance.hooks[index]) : value;\n';
+    code += "    if (!Object.is(nextValue, instance.hooks[index])) {\n";
+    code += "      instance.hooks[index] = nextValue;\n";
+    code += "      __renderInstance(instance);\n";
+    code += "    }\n";
+    code += "  };\n";
+    code += "  return [instance.hooks[index], setState];\n";
+    code += "}\n\n";
+  }
+  if (hooks.has("useReducer")) {
+    code += "function useReducer(reducer, initialArg, init) {\n";
+    code += "  const instance = __getCurrentInstance();\n";
+    code += "  const index = instance.hookIndex++;\n";
+    code += "  if (!Object.prototype.hasOwnProperty.call(instance.hooks, index)) {\n";
+    code += "    instance.hooks[index] = init ? init(initialArg) : initialArg;\n";
+    code += "  }\n";
+    code += "  const dispatch = (action) => {\n";
+    code += "    const nextValue = reducer(instance.hooks[index], action);\n";
+    code += "    if (!Object.is(nextValue, instance.hooks[index])) {\n";
+    code += "      instance.hooks[index] = nextValue;\n";
+    code += "      __renderInstance(instance);\n";
+    code += "    }\n";
+    code += "  };\n";
+    code += "  return [instance.hooks[index], dispatch];\n";
+    code += "}\n\n";
+  }
+  if (hooks.has("useRef")) {
+    code += "function useRef(initialValue) {\n";
+    code += "  const instance = __getCurrentInstance();\n";
+    code += "  const index = instance.hookIndex++;\n";
+    code += "  if (!Object.prototype.hasOwnProperty.call(instance.hooks, index)) {\n";
+    code += "    instance.hooks[index] = { current: initialValue };\n";
+    code += "  }\n";
+    code += "  return instance.hooks[index];\n";
+    code += "}\n\n";
+  }
+  if (hooks.has("useMemo")) {
+    code += "function useMemo(factory, deps) {\n";
+    code += "  const instance = __getCurrentInstance();\n";
+    code += "  const index = instance.hookIndex++;\n";
+    code += "  const prev = instance.hooks[index];\n";
+    code += "  if (prev && deps && __areHookDepsEqual(prev.deps, deps)) {\n";
+    code += "    return prev.value;\n";
+    code += "  }\n";
+    code += "  const value = factory();\n";
+    code += "  instance.hooks[index] = { value, deps };\n";
+    code += "  return value;\n";
+    code += "}\n\n";
+  }
+  if (hooks.has("useCallback")) {
+    code += "function useCallback(callback, deps) {\n";
+    code += "  const instance = __getCurrentInstance();\n";
+    code += "  const index = instance.hookIndex++;\n";
+    code += "  const prev = instance.hooks[index];\n";
+    code += "  if (prev && deps && __areHookDepsEqual(prev.deps, deps)) {\n";
+    code += "    return prev.callback;\n";
+    code += "  }\n";
+    code += "  instance.hooks[index] = { callback, deps };\n";
+    code += "  return callback;\n";
+    code += "}\n\n";
+  }
+  if (hooks.has("useEffect")) {
+    code += "function useEffect(effect, deps) {\n";
+    code += "  const instance = __getCurrentInstance();\n";
+    code += "  const index = instance.hookIndex++;\n";
+    code += "  const prev = instance.hooks[index];\n";
+    code += "  const hasChanged = !prev || !deps || !__areHookDepsEqual(prev.deps, deps);\n";
+    code += "  if (hasChanged) {\n";
+    code += "    instance.pendingEffects.push({ index, effect, deps });\n";
+    code += "  }\n";
+    code += "  if (!prev) {\n";
+    code += "    instance.hooks[index] = { deps, cleanup: null };\n";
+    code += "  }\n";
+    code += "}\n\n";
+  }
+  if (hooks.has("useContext")) {
+    code += "function useContext(context) {\n";
+    code += "  if (!context) return undefined;\n";
+    code += '  if (Object.prototype.hasOwnProperty.call(context, "value")) {\n';
+    code += "    return context.value;\n";
+    code += "  }\n";
+    code += "  return context.current;\n";
+    code += "}\n\n";
+  }
+  return code;
+}
+
+// src/core/generator/web-component.js
+function emitWebComponent({
+  className,
+  tagName,
+  rootComponent,
+  hooksUsed,
+  cssLiteral,
+  styleIdLiteral
+}) {
+  const hasCss = Boolean(cssLiteral);
+  let code = "";
+  code += `class ${className} extends HTMLElement {
+`;
+  code += "  constructor() {\n";
+  code += "    super();\n";
+  code += "    this.__instance = null;\n";
+  code += "    this.__observer = null;\n";
+  code += "    this.__lightChildren = [];\n";
+  code += "    this.__styleInjected = false;\n";
+  code += '    this.__shadow = this.attachShadow({ mode: "open" });\n';
+  code += "  }\n\n";
+  code += "  connectedCallback() {\n";
+  code += "    if (!this.__lightChildren.length) {\n";
+  code += "      this.__lightChildren = Array.from(this.childNodes);\n";
+  code += "    }\n";
+  code += "    this.__updateProps();\n";
+  code += '    if (!this.__observer && typeof MutationObserver !== "undefined") {\n';
+  code += "      this.__observer = new MutationObserver(() => this.__updateProps());\n";
+  code += "      this.__observer.observe(this, { attributes: true });\n";
+  code += "    }\n";
+  if (hasCss) {
+    code += "    if (!this.__styleInjected) {\n";
+    code += `      __applyShadowStyles(${cssLiteral}, ${styleIdLiteral}, this.__shadow, this);
+`;
+    code += "      this.__styleInjected = true;\n";
+    code += "    }\n";
+  }
+  code += "  }\n\n";
+  code += "  __updateProps() {\n";
+  code += "    const props = __getElementProps(this, this.__lightChildren);\n";
+  code += "    if (!this.__instance) {\n";
+  code += `      this.__instance = __mount(${rootComponent}, this.__shadow, props);
+`;
+  code += "    } else {\n";
+  code += "      this.__instance.props = props;\n";
+  code += "      __renderInstance(this.__instance);\n";
+  code += "    }\n";
+  code += "  }\n\n";
+  code += "  disconnectedCallback() {\n";
+  code += "    if (this.__observer) {\n";
+  code += "      this.__observer.disconnect();\n";
+  code += "      this.__observer = null;\n";
+  code += "    }\n";
+  if (hooksUsed.length > 0) {
+    code += '    if (typeof __teardownInstance === "function" && this.__instance) {\n';
+    code += "      __teardownInstance(this.__instance);\n";
+    code += "    }\n";
+  }
+  code += "  }\n";
+  code += "}\n\n";
+  code += `if (typeof customElements !== "undefined" && !customElements.get("${tagName}")) {
+`;
+  code += `  customElements.define("${tagName}", ${className});
+`;
+  code += "}\n\n";
+  return code;
+}
+
+// src/core/generator/index.js
+function generateCode(components, fileName, options = {}) {
+  const css = options.css ?? "";
+  const styleId = options.styleId ?? null;
+  const hooksUsed = Array.isArray(options.hooksUsed) ? options.hooksUsed : [];
+  const webComponent = Boolean(options.webComponent);
+  const webComponentTag = options.webComponentTag ?? null;
+  let code = `// Generated from ${fileName}
+`;
+  code += "// Vanilla JS output (no React, no imports)\n\n";
+  if (css) {
+    const cssLiteral = toTemplateLiteral(css);
+    const styleIdLiteral = styleId ? `"${styleId}"` : "null";
+    code += "function injectStyles(cssText, styleId) {\n";
+    code += "  if (!cssText) return;\n";
+    code += "  const target = arguments.length > 2 && arguments[2] ? arguments[2] : document.head;\n";
+    code += "  if (styleId && target.querySelector && target.querySelector('#' + styleId)) return;\n";
+    code += '  const style = document.createElement("style");\n';
+    code += "  if (styleId) style.id = styleId;\n";
+    code += "  style.textContent = cssText;\n";
+    code += "  target.appendChild(style);\n";
+    code += "}\n\n";
+    if (!webComponent) {
+      code += `injectStyles(${cssLiteral}, ${styleIdLiteral}, document.head);
+
+`;
+    }
+  }
+  code += domRuntime;
+  if (hooksUsed.length > 0) {
+    code += getHookRuntime(hooksUsed);
+  }
+  components.forEach((comp) => {
+    const params = comp.params ? comp.params : "";
+    code += `// Component: ${comp.name}
+`;
+    code += `function ${comp.name}(${params}) {
+`;
+    code += `${comp.bodyLines.join("\n")}
+`;
+    code += `}
+
+`;
+  });
+  const rootComponent = resolveRootComponent(components, fileName);
+  if (rootComponent) {
+    if (webComponent) {
+      const tagName = resolveWebComponentTag(webComponentTag, fileName, rootComponent.name);
+      const className = toComponentClassName(tagName, rootComponent.name);
+      code += emitWebComponent({
+        className,
+        tagName,
+        rootComponent: rootComponent.name,
+        hooksUsed,
+        cssLiteral: css ? toTemplateLiteral(css) : null,
+        styleIdLiteral: styleId ? `"${styleId}"` : "null"
+      });
+    } else if (hooksUsed.length > 0) {
+      code += `__mount(${rootComponent.name}, document.body, __getRootProps());
+`;
+    } else {
+      code += `document.body.appendChild(${rootComponent.name}(__getRootProps()));
+`;
+    }
+  }
+  return code;
+}
+function resolveRootComponent(components, fileName) {
+  if (!components || components.length === 0) return null;
+  const baseName = String(fileName).split(/[\\/]/).pop() || "";
+  const stem = baseName.replace(/\.(tsx|jsx|ts|js)$/i, "");
+  const match = components.find((comp) => comp.name === stem);
+  return match ?? components[0];
+}
+
+// src/core/tailwind.js
+import path from "path";
+import { createRequire } from "module";
+import fs from "fs-extra";
+var TAILWIND_INPUT_V3 = "@tailwind base;\n@tailwind components;\n@tailwind utilities;\n";
+var TAILWIND_INPUT_V4 = '@import "tailwindcss";\n';
+var TAILWIND_CONFIG_FILES = [
+  "tailwind.config.js",
+  "tailwind.config.cjs",
+  "tailwind.config.mjs",
+  "tailwind.config.ts"
+];
+async function buildTailwindCSS({ configPath, contentFiles, content }) {
+  if (!configPath) return "";
+  const resolvedConfigPath = path.resolve(configPath);
+  const exists = await fs.pathExists(resolvedConfigPath);
+  if (!exists) {
+    throw new Error(`Tailwind config not found: ${resolvedConfigPath}`);
+  }
+  const configDir = path.dirname(resolvedConfigPath);
+  const requireFromConfig = createRequire(path.join(configDir, "package.json"));
+  const tailwindcss = loadModule(requireFromConfig, "tailwindcss");
+  const tailwindPostcss = loadModule(requireFromConfig, "@tailwindcss/postcss");
+  const postcss = loadModule(requireFromConfig, "postcss");
+  if (!postcss || !tailwindcss && !tailwindPostcss) {
+    throw new Error(
+      "Tailwind build needs postcss and tailwindcss (or @tailwindcss/postcss) installed in the project."
+    );
+  }
+  const useTailwindPostcss = Boolean(tailwindPostcss);
+  const tailwindPlugin = useTailwindPostcss ? tailwindPostcss.default ?? tailwindPostcss : tailwindcss.default ?? tailwindcss;
+  const postcssRunner = postcss.default ?? postcss;
+  const rawContent = [];
+  if (Array.isArray(contentFiles) && contentFiles.length > 0) {
+    const fromFiles = await Promise.all(
+      contentFiles.map((file) => fs.readFile(file, "utf-8"))
+    );
+    rawContent.push(...fromFiles);
+  }
+  if (Array.isArray(content) && content.length > 0) {
+    rawContent.push(...content);
+  } else if (typeof content === "string" && content) {
+    rawContent.push(content);
+  }
+  if (rawContent.length === 0) return "";
+  const tempFile = path.join(
+    configDir,
+    `.tailwind-raw-${Date.now()}-${Math.random().toString(36).slice(2)}.tsx`
+  );
+  await fs.writeFile(tempFile, rawContent.join("\n"));
+  try {
+    const configRelative = toRelativeCssPath(configDir, resolvedConfigPath);
+    const sourceRelative = toRelativeCssPath(configDir, tempFile);
+    const configForCss = toCssPath(configRelative);
+    const sourceForCss = toCssPath(sourceRelative);
+    const tailwindInputBody = useTailwindPostcss ? TAILWIND_INPUT_V4 : TAILWIND_INPUT_V3;
+    const tailwindInput = `@config "${configForCss}";
+@source "${sourceForCss}";
+${tailwindInputBody}`;
+    const pluginOptions = useTailwindPostcss ? {} : { config: resolvedConfigPath };
+    const fromPath = path.join(configDir, ".tailwind-input.css");
+    const result = await postcssRunner([tailwindPlugin(pluginOptions)]).process(
+      tailwindInput,
+      { from: fromPath }
+    );
+    return result.css.trim();
+  } finally {
+    await fs.remove(tempFile);
+  }
+}
+function toCssPath(value) {
+  return String(value).replace(/\\/g, "/").replace(/"/g, '\\"');
+}
+function toRelativeCssPath(baseDir, filePath) {
+  let rel = path.relative(baseDir, filePath);
+  if (!rel || rel.startsWith("..")) {
+    rel = filePath;
+  }
+  if (!rel.startsWith(".") && !rel.startsWith("/")) {
+    rel = `./${rel}`;
+  }
+  return rel;
+}
+function loadModule(requireFromConfig, moduleName) {
+  try {
+    return requireFromConfig(moduleName);
+  } catch (err) {
+    return null;
+  }
+}
+async function findTailwindConfig(startDir) {
+  if (!startDir) return null;
+  let currentDir = path.resolve(startDir);
+  while (true) {
+    for (const filename of TAILWIND_CONFIG_FILES) {
+      const candidate = path.join(currentDir, filename);
+      if (await fs.pathExists(candidate)) return candidate;
+    }
+    const parent = path.dirname(currentDir);
+    if (parent === currentDir) break;
+    currentDir = parent;
+  }
+  return null;
+}
+
+// src/core/tailwind-extractor.js
+import { parse as parse2 } from "@babel/parser";
+import traverseModule2 from "@babel/traverse";
+import * as t5 from "@babel/types";
+var traverse2 = traverseModule2.default ?? traverseModule2;
+function collectTailwindClasses(components, fileLabel = "") {
+  const classNames = /* @__PURE__ */ new Set();
+  const warnings = [];
+  if (!Array.isArray(components) || components.length === 0) {
+    return { classNames: [], warnings };
+  }
+  for (const component of components) {
+    if (!component || !Array.isArray(component.bodyLines)) continue;
+    const componentName = component.name || "Component";
+    const context = fileLabel ? `${fileLabel}:${componentName}` : componentName;
+    const source = `function __tw_extract() {
+${component.bodyLines.join("\n")}
+}`;
+    let ast;
+    try {
+      ast = parse2(source, {
+        sourceType: "module",
+        plugins: ["jsx", "typescript"]
+      });
+    } catch (err) {
+      warnings.push(`${context}: unable to parse generated output for Tailwind extraction.`);
+      continue;
+    }
+    traverse2(ast, {
+      CallExpression(path2) {
+        const { callee, arguments: args } = path2.node;
+        if (!Array.isArray(args) || args.length < 2) return;
+        const setAttrArgs = getSetAttributeArgs(callee, args);
+        if (!setAttrArgs) return;
+        const [nameNode, valueNode] = setAttrArgs;
+        if (!t5.isStringLiteral(nameNode) || nameNode.value !== "class") return;
+        const { tokens, dynamic } = extractClassTokens(valueNode, warnings, context);
+        for (const token of tokens) classNames.add(token);
+        if (dynamic) {
+          warnings.push(`${context}: dynamic class expression detected; Tailwind output may be partial.`);
+        }
+      }
+    });
+  }
+  return { classNames: Array.from(classNames), warnings };
+}
+function buildTailwindContent(classNames) {
+  const classes = Array.isArray(classNames) ? classNames.filter(Boolean) : [];
+  if (classes.length === 0) return "";
+  return `<div class="${classes.join(" ")}"></div>`;
+}
+function getSetAttributeArgs(callee, args) {
+  if (t5.isIdentifier(callee, { name: "__setAttribute" })) {
+    if (args.length < 3) return null;
+    return [args[1], args[2]];
+  }
+  if (t5.isMemberExpression(callee) && t5.isIdentifier(callee.property, { name: "setAttribute" })) {
+    if (args.length < 2) return null;
+    return [args[0], args[1]];
+  }
+  return null;
+}
+function extractClassTokens(node, warnings, context) {
+  if (!node) return { tokens: [], dynamic: false };
+  if (t5.isStringLiteral(node)) {
+    return { tokens: splitClasses(node.value), dynamic: false };
+  }
+  if (t5.isTemplateLiteral(node)) {
+    const tokens = [];
+    for (const quasi of node.quasis) {
+      const raw = quasi.value.cooked || "";
+      tokens.push(...splitClasses(raw));
+    }
+    if (node.expressions.length > 0) {
+      return { tokens, dynamic: true };
+    }
+    return { tokens, dynamic: false };
+  }
+  if (t5.isBinaryExpression(node, { operator: "+" })) {
+    const left = extractClassTokens(node.left, warnings, context);
+    const right = extractClassTokens(node.right, warnings, context);
+    return {
+      tokens: [...left.tokens, ...right.tokens],
+      dynamic: left.dynamic || right.dynamic
+    };
+  }
+  return { tokens: [], dynamic: true };
+}
+function splitClasses(value) {
+  return String(value).split(/\s+/).map((entry) => entry.trim()).filter(Boolean);
+}
+
+// src/index.js
+async function convert(code, options = {}) {
+  const {
+    fileName = "component.jsx",
+    tailwindConfig = null,
+    webComponent = false,
+    webComponentTag = null,
+    usePlaceholders = false
+  } = options;
+  const ast = parseFile(code);
+  const transformed = transform(ast, { usePlaceholders });
+  const components = transformed.components ?? transformed;
+  const hooksUsed = transformed.hooksUsed ?? [];
+  const { classNames, warnings } = collectTailwindClasses(components, fileName);
+  const content = buildTailwindContent(classNames);
+  let css = "";
+  if (tailwindConfig && content) {
+    css = await buildTailwindCSS({
+      configPath: tailwindConfig,
+      content
+    });
+  }
+  const output = generateCode(components, fileName, {
+    css,
+    styleId: css ? createStyleId(fileName) : null,
+    hooksUsed,
+    webComponent,
+    webComponentTag
+  });
+  return {
+    code: output,
+    css,
+    warnings
+  };
+}
+export {
+  buildTailwindCSS,
+  buildTailwindContent,
+  collectTailwindClasses,
+  convert,
+  createStyleId,
+  findTailwindConfig,
+  generateCode,
+  parseFile,
+  transform
+};