@litsx/babel-preset-litsx 0.2.1 → 0.4.0

package/dist/internal/transform-litsx-components.cjs

@@ -4,19 +4,25 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var jsxSyntaxPlugin = require('@babel/plugin-syntax-jsx');
 var internal_transformLitsxProperties = require('./transform-litsx-properties.cjs');
+var transformLitsxElementCandidates = require('../shared/transform-litsx-element-candidates-JMFlPFXK.cjs');
 require('module');
 require('@litsx/typescript-session');
+require('@babel/helper-plugin-utils');
+require('@babel/traverse');
+require('@litsx/babel-parser');
+require('node:fs');
+require('node:path');
 
-let t$7;
+let t$9;
 
 function setStaticHoistsBabelTypes(types) {
-  t$7 = types;
+  t$9 = types;
 }
 
 function isLightDomHoist(statement) {
-  if (!t$7.isExpressionStatement(statement)) return false;
-  if (!t$7.isCallExpression(statement.expression)) return false;
-  if (!t$7.isIdentifier(statement.expression.callee, { name: "__litsx_static_lightDom" })) {
+  if (!t$9.isExpressionStatement(statement)) return false;
+  if (!t$9.isCallExpression(statement.expression)) return false;
+  if (!t$9.isIdentifier(statement.expression.callee, { name: "__litsx_static_lightDom" })) {
     return false;
   }
   if (statement.expression.arguments.length !== 0) {
@@ -26,17 +32,17 @@ function isLightDomHoist(statement) {
 }
 
 function createStaticHoistGetter(name, symbolId, expression) {
-  const getter = t$7.classMethod(
+  const getter = t$9.classMethod(
     "get",
-    t$7.identifier(name),
+    t$9.identifier(name),
     [],
-    t$7.blockStatement([
-      t$7.returnStatement(
-        t$7.callExpression(
-          t$7.memberExpression(t$7.thisExpression(), t$7.identifier("__litsxStatic")),
+    t$9.blockStatement([
+      t$9.returnStatement(
+        t$9.callExpression(
+          t$9.memberExpression(t$9.thisExpression(), t$9.identifier("__litsxStatic")),
           [
-            t$7.cloneNode(symbolId),
-            t$7.arrowFunctionExpression([], expression),
+            t$9.cloneNode(symbolId),
+            t$9.arrowFunctionExpression([], expression),
           ]
         )
       ),
@@ -47,22 +53,22 @@ function createStaticHoistGetter(name, symbolId, expression) {
 }
 
 function resolveStaticHoistExpression(expression) {
-  return t$7.callExpression(
-    t$7.memberExpression(t$7.thisExpression(), t$7.identifier("__litsxResolveStaticValue")),
-    [t$7.cloneNode(expression)]
+  return t$9.callExpression(
+    t$9.memberExpression(t$9.thisExpression(), t$9.identifier("__litsxResolveStaticValue")),
+    [t$9.cloneNode(expression)]
   );
 }
 
 function createPropertiesHoistResolver(propertiesStatic, staticProps, expression) {
-  const mergedProperties = propertiesStatic.map((property) => t$7.cloneNode(property));
+  const mergedProperties = propertiesStatic.map((property) => t$9.cloneNode(property));
   if (staticProps.length > 0) {
     mergeStaticPropsIntoProperties(mergedProperties, staticProps);
   }
 
-  return t$7.callExpression(
-    t$7.memberExpression(t$7.thisExpression(), t$7.identifier("__litsxMergeProperties")),
+  return t$9.callExpression(
+    t$9.memberExpression(t$9.thisExpression(), t$9.identifier("__litsxMergeProperties")),
     [
-      t$7.objectExpression(mergedProperties),
+      t$9.objectExpression(mergedProperties),
       resolveStaticHoistExpression(expression),
     ]
   );
@@ -76,17 +82,17 @@ function createStylesHoistResolver(staticStyles, expression) {
 
   const baseStyles =
     staticStyles.length === 1
-      ? t$7.cloneNode(staticStyles[0])
-      : t$7.arrayExpression(staticStyles.map((style) => t$7.cloneNode(style)));
+      ? t$9.cloneNode(staticStyles[0])
+      : t$9.arrayExpression(staticStyles.map((style) => t$9.cloneNode(style)));
 
-  return t$7.logicalExpression("||", resolvedExpression, baseStyles);
+  return t$9.logicalExpression("||", resolvedExpression, baseStyles);
 }
 
 function getStaticPropsExpression(statement) {
-  if (!t$7.isExpressionStatement(statement)) return null;
-  if (!t$7.isCallExpression(statement.expression)) return null;
-  const isLegacyStaticProps = t$7.isIdentifier(statement.expression.callee, { name: "staticProps" });
-  const isHoistedProperties = t$7.isIdentifier(
+  if (!t$9.isExpressionStatement(statement)) return null;
+  if (!t$9.isCallExpression(statement.expression)) return null;
+  const isLegacyStaticProps = t$9.isIdentifier(statement.expression.callee, { name: "staticProps" });
+  const isHoistedProperties = t$9.isIdentifier(
     statement.expression.callee,
     { name: "__litsx_static_properties" }
   );
@@ -99,47 +105,47 @@ function getStaticPropsExpression(statement) {
   if (statement.expression.arguments.length !== 1) return null;
 
   const [argument] = statement.expression.arguments;
-  if (isHoistedProperties && (t$7.isFunctionExpression(argument) || t$7.isArrowFunctionExpression(argument))) {
+  if (isHoistedProperties && (t$9.isFunctionExpression(argument) || t$9.isArrowFunctionExpression(argument))) {
     throw new Error("^properties(...) only accepts an object literal with static Lit property options.");
   }
 
-  if (!t$7.isObjectExpression(argument)) {
+  if (!t$9.isObjectExpression(argument)) {
     throw new Error("^properties(...) only accepts an object literal with static Lit property options.");
   }
 
   return isHoistedProperties ? {
     __litsxHoistedProperties: true,
-    expression: t$7.cloneNode(argument),
-  } : t$7.cloneNode(argument);
+    expression: t$9.cloneNode(argument),
+  } : t$9.cloneNode(argument);
 }
 
 function getStaticPropertyName(node) {
-  if (t$7.isIdentifier(node)) return node.name;
-  if (t$7.isStringLiteral(node)) return node.value;
+  if (t$9.isIdentifier(node)) return node.name;
+  if (t$9.isStringLiteral(node)) return node.value;
   return null;
 }
 
 function normalizeStaticPropOverrideValue(value) {
   if (
-    t$7.isIdentifier(value) &&
+    t$9.isIdentifier(value) &&
     ["String", "Number", "Boolean", "Object", "Array", "Date"].includes(value.name)
   ) {
-    return internal_transformLitsxProperties.createPropertyConfig(t$7.identifier(value.name));
+    return internal_transformLitsxProperties.createPropertyConfig(t$9.identifier(value.name));
   }
 
-  if (t$7.isObjectExpression(value)) {
+  if (t$9.isObjectExpression(value)) {
     const typeProperty = value.properties.find(
       (prop) =>
-        t$7.isObjectProperty(prop) &&
-        t$7.isIdentifier(prop.key, { name: "type" }) &&
-        t$7.isIdentifier(prop.value)
+        t$9.isObjectProperty(prop) &&
+        t$9.isIdentifier(prop.key, { name: "type" }) &&
+        t$9.isIdentifier(prop.value)
     );
 
     const attributeProperty = value.properties.find(
       (prop) =>
-        t$7.isObjectProperty(prop) &&
-        t$7.isIdentifier(prop.key, { name: "attribute" }) &&
-        t$7.isBooleanLiteral(prop.value) &&
+        t$9.isObjectProperty(prop) &&
+        t$9.isIdentifier(prop.key, { name: "attribute" }) &&
+        t$9.isBooleanLiteral(prop.value) &&
         prop.value.value === false
     );
 
@@ -154,12 +160,12 @@ function normalizeStaticPropOverrideValue(value) {
 }
 
 function mergeStaticPropertyObject(targetNode, overrideObject) {
-  if (!t$7.isObjectProperty(targetNode) || !t$7.isObjectExpression(targetNode.value)) {
+  if (!t$9.isObjectProperty(targetNode) || !t$9.isObjectExpression(targetNode.value)) {
     return;
   }
 
   overrideObject.properties.forEach((property) => {
-    if (!t$7.isObjectProperty(property) && !t$7.isObjectMethod(property)) {
+    if (!t$9.isObjectProperty(property) && !t$9.isObjectMethod(property)) {
       throw new Error("^properties(...) only accepts plain object members.");
     }
 
@@ -170,16 +176,16 @@ function mergeStaticPropertyObject(targetNode, overrideObject) {
 
     const existing = targetNode.value.properties.find(
       (candidate) =>
-        (t$7.isObjectProperty(candidate) || t$7.isObjectMethod(candidate)) &&
+        (t$9.isObjectProperty(candidate) || t$9.isObjectMethod(candidate)) &&
         getStaticPropertyName(candidate.key) === keyName
     );
 
     if (existing) {
-      const nextNode = t$7.cloneNode(property);
+      const nextNode = t$9.cloneNode(property);
       const index = targetNode.value.properties.indexOf(existing);
       targetNode.value.properties.splice(index, 1, nextNode);
     } else {
-      targetNode.value.properties.push(t$7.cloneNode(property));
+      targetNode.value.properties.push(t$9.cloneNode(property));
     }
   });
 }
@@ -188,7 +194,7 @@ function mergeStaticPropsIntoProperties(propertiesStatic, staticProps) {
   const propertyMap = new Map();
 
   propertiesStatic.forEach((propertyNode) => {
-    if (!t$7.isObjectProperty(propertyNode)) return;
+    if (!t$9.isObjectProperty(propertyNode)) return;
     const keyName = getStaticPropertyName(propertyNode.key);
     if (!keyName) return;
     propertyMap.set(keyName, propertyNode);
@@ -196,7 +202,7 @@ function mergeStaticPropsIntoProperties(propertiesStatic, staticProps) {
 
   staticProps.forEach((optionsObject) => {
     optionsObject.properties.forEach((property) => {
-      if (!t$7.isObjectProperty(property)) {
+      if (!t$9.isObjectProperty(property)) {
         throw new Error("^properties(...) only accepts plain object properties.");
       }
 
@@ -209,11 +215,11 @@ function mergeStaticPropsIntoProperties(propertiesStatic, staticProps) {
       const normalized = normalizeStaticPropOverrideValue(property.value);
 
       if (!existing) {
-        const node = t$7.objectProperty(
-          t$7.identifier(keyName),
+        const node = t$9.objectProperty(
+          t$9.identifier(keyName),
           internal_transformLitsxProperties.createPropertyValue(normalized, false)
         );
-        if (t$7.isObjectExpression(property.value)) {
+        if (t$9.isObjectExpression(property.value)) {
           mergeStaticPropertyObject(node, property.value);
         }
         propertiesStatic.push(node);
@@ -227,7 +233,7 @@ function mergeStaticPropsIntoProperties(propertiesStatic, staticProps) {
         false
       );
 
-      if (t$7.isObjectExpression(property.value)) {
+      if (t$9.isObjectExpression(property.value)) {
         mergeStaticPropertyObject(existing, property.value);
       }
     });
@@ -235,7 +241,7 @@ function mergeStaticPropsIntoProperties(propertiesStatic, staticProps) {
 }
 
 function normalizeStylesTemplate(argument, functionPath) {
-  if (t$7.isTemplateLiteral(argument)) {
+  if (t$9.isTemplateLiteral(argument)) {
     if (
       !argument.expressions.every((expression) =>
         isStaticStylesExpression(expression, functionPath)
@@ -243,7 +249,7 @@ function normalizeStylesTemplate(argument, functionPath) {
     ) {
       return null;
     }
-    return t$7.templateLiteral(
+    return t$9.templateLiteral(
       argument.quasis,
       argument.expressions.map((expression) =>
         wrapStaticStylesInterpolation(expression)
@@ -251,18 +257,18 @@ function normalizeStylesTemplate(argument, functionPath) {
     );
   }
 
-  if (t$7.isStringLiteral(argument)) {
-    return t$7.templateLiteral(
-      [t$7.templateElement({ raw: argument.value, cooked: argument.value }, true)],
+  if (t$9.isStringLiteral(argument)) {
+    return t$9.templateLiteral(
+      [t$9.templateElement({ raw: argument.value, cooked: argument.value }, true)],
       []
     );
   }
 
   if (isStaticStylesExpression(argument, functionPath)) {
-    return t$7.templateLiteral(
+    return t$9.templateLiteral(
       [
-        t$7.templateElement({ raw: "", cooked: "" }, false),
-        t$7.templateElement({ raw: "", cooked: "" }, true),
+        t$9.templateElement({ raw: "", cooked: "" }, false),
+        t$9.templateElement({ raw: "", cooked: "" }, true),
       ],
       [wrapStaticStylesInterpolation(argument)]
     );
@@ -273,27 +279,27 @@ function normalizeStylesTemplate(argument, functionPath) {
 
 function wrapStaticStylesInterpolation(expression) {
   if (
-    t$7.isTaggedTemplateExpression(expression) &&
-    t$7.isIdentifier(expression.tag, { name: "css" })
+    t$9.isTaggedTemplateExpression(expression) &&
+    t$9.isIdentifier(expression.tag, { name: "css" })
   ) {
     return expression;
   }
 
-  if (t$7.isNumericLiteral(expression)) {
+  if (t$9.isNumericLiteral(expression)) {
     return expression;
   }
 
-  return t$7.callExpression(
-    t$7.identifier("unsafeCSS"),
+  return t$9.callExpression(
+    t$9.identifier("unsafeCSS"),
     [expression]
   );
 }
 
 function getStaticStylesExpression(statement, functionPath) {
-  if (!t$7.isExpressionStatement(statement)) return null;
-  if (!t$7.isCallExpression(statement.expression)) return null;
-  const isLegacyStaticStyles = t$7.isIdentifier(statement.expression.callee, { name: "staticStyles" });
-  const isHoistedStyles = t$7.isIdentifier(statement.expression.callee, { name: "__litsx_static_styles" });
+  if (!t$9.isExpressionStatement(statement)) return null;
+  if (!t$9.isCallExpression(statement.expression)) return null;
+  const isLegacyStaticStyles = t$9.isIdentifier(statement.expression.callee, { name: "staticStyles" });
+  const isHoistedStyles = t$9.isIdentifier(statement.expression.callee, { name: "__litsx_static_styles" });
   if (
     !isLegacyStaticStyles &&
     !isHoistedStyles
@@ -304,7 +310,7 @@ function getStaticStylesExpression(statement, functionPath) {
 
   const [argument] = statement.expression.arguments;
 
-  if (isHoistedStyles && (t$7.isFunctionExpression(argument) || t$7.isArrowFunctionExpression(argument))) {
+  if (isHoistedStyles && (t$9.isFunctionExpression(argument) || t$9.isArrowFunctionExpression(argument))) {
     throw new Error("^styles(...) only accepts static values. Move dynamic values to useStyle(...) or CSS custom properties.");
   }
 
@@ -316,16 +322,16 @@ function getStaticStylesExpression(statement, functionPath) {
     throw new Error("^styles(...) only accepts static values. Move dynamic values to useStyle(...) or CSS custom properties.");
   }
 
-  const expression = t$7.taggedTemplateExpression(t$7.identifier("css"), template);
+  const expression = t$9.taggedTemplateExpression(t$9.identifier("css"), template);
   return isHoistedStyles
     ? { __litsxHoistedStyles: true, expression }
     : expression;
 }
 
 function getStaticHoistExpression(statement, functionPath) {
-  if (!t$7.isExpressionStatement(statement)) return null;
-  if (!t$7.isCallExpression(statement.expression)) return null;
-  if (!t$7.isIdentifier(statement.expression.callee)) return null;
+  if (!t$9.isExpressionStatement(statement)) return null;
+  if (!t$9.isCallExpression(statement.expression)) return null;
+  if (!t$9.isIdentifier(statement.expression.callee)) return null;
 
   const calleeName = statement.expression.callee.name;
   if (!calleeName.startsWith("__litsx_static_")) {
@@ -343,17 +349,17 @@ function getStaticHoistExpression(statement, functionPath) {
 
   const [argument] = statement.expression.arguments;
   if (name === "expose") {
-    if (t$7.isObjectExpression(argument)) {
+    if (t$9.isObjectExpression(argument)) {
       return {
         name,
-        expression: t$7.cloneNode(argument),
+        expression: t$9.cloneNode(argument),
       };
     }
 
     throw new Error("^expose(...) only accepts an object literal.");
   }
 
-  if (t$7.isFunctionExpression(argument) || t$7.isArrowFunctionExpression(argument)) {
+  if (t$9.isFunctionExpression(argument) || t$9.isArrowFunctionExpression(argument)) {
     throw new Error(`^${name}(...) only accepts a direct static value.`);
   }
 
@@ -363,7 +369,7 @@ function getStaticHoistExpression(statement, functionPath) {
 
   return {
     name,
-    expression: t$7.cloneNode(argument),
+    expression: t$9.cloneNode(argument),
   };
 }
 
@@ -376,9 +382,9 @@ function createExposeHoistMembers(expression) {
 }
 
 function normalizeExposeHoistExpression(expression) {
-  if (t$7.isObjectExpression(expression)) {
+  if (t$9.isObjectExpression(expression)) {
     return {
-      methodsExpression: t$7.cloneNode(expression),
+      methodsExpression: t$9.cloneNode(expression),
     };
   }
 
@@ -392,41 +398,41 @@ function createExposeClassMethod(property) {
 }
 
 function normalizeExposePropertyToClassMethod(property) {
-  if (t$7.isSpreadElement(property)) {
+  if (t$9.isSpreadElement(property)) {
     throw new Error("^expose(...) does not accept spread elements.");
   }
 
-  if (t$7.isObjectMethod(property)) {
+  if (t$9.isObjectMethod(property)) {
     if (property.kind !== "method") {
       throw new Error("^expose(...) only accepts plain methods.");
     }
 
-    return t$7.classMethod(
+    return t$9.classMethod(
       "method",
-      t$7.cloneNode(property.key),
-      property.params.map((param) => t$7.cloneNode(param)),
-      t$7.cloneNode(property.body),
+      t$9.cloneNode(property.key),
+      property.params.map((param) => t$9.cloneNode(param)),
+      t$9.cloneNode(property.body),
       property.computed
     );
   }
 
-  if (!t$7.isObjectProperty(property)) {
+  if (!t$9.isObjectProperty(property)) {
     throw new Error("^expose(...) only accepts plain methods.");
   }
 
   const value = property.value;
-  if (!t$7.isFunctionExpression(value) && !t$7.isArrowFunctionExpression(value)) {
+  if (!t$9.isFunctionExpression(value) && !t$9.isArrowFunctionExpression(value)) {
     throw new Error("^expose(...) values must be functions.");
   }
 
-  const body = t$7.isBlockStatement(value.body)
-    ? t$7.cloneNode(value.body)
-    : t$7.blockStatement([t$7.returnStatement(t$7.cloneNode(value.body))]);
+  const body = t$9.isBlockStatement(value.body)
+    ? t$9.cloneNode(value.body)
+    : t$9.blockStatement([t$9.returnStatement(t$9.cloneNode(value.body))]);
 
-  const method = t$7.classMethod(
+  const method = t$9.classMethod(
     "method",
-    t$7.cloneNode(property.key),
-    value.params.map((param) => t$7.cloneNode(param)),
+    t$9.cloneNode(property.key),
+    value.params.map((param) => t$9.cloneNode(param)),
     body,
     property.computed
   );
@@ -438,7 +444,7 @@ function normalizeExposePropertyToClassMethod(property) {
 function assertStaticHoistsStayTopLevel(functionPath) {
   functionPath.traverse({
     CallExpression(callPath) {
-      if (!t$7.isIdentifier(callPath.node.callee)) return;
+      if (!t$9.isIdentifier(callPath.node.callee)) return;
       if (!callPath.node.callee.name.startsWith("__litsx_static_")) return;
 
       const statementParent = callPath.parentPath;
@@ -463,8 +469,8 @@ function assertStaticHoistsStayTopLevel(functionPath) {
 function containsUnsafeCssCall(node) {
   if (!node || typeof node !== "object") return false;
   if (
-    t$7.isCallExpression(node) &&
-    t$7.isIdentifier(node.callee, { name: "unsafeCSS" })
+    t$9.isCallExpression(node) &&
+    t$9.isIdentifier(node.callee, { name: "unsafeCSS" })
   ) {
     return true;
   }
@@ -479,37 +485,37 @@ function containsUnsafeCssCall(node) {
 
 function isStaticStylesExpression(node, functionPath, seenBindings = new Set()) {
   if (
-    t$7.isStringLiteral(node) ||
-    t$7.isNumericLiteral(node) ||
-    t$7.isBooleanLiteral(node) ||
-    t$7.isNullLiteral(node) ||
-    t$7.isBigIntLiteral?.(node)
+    t$9.isStringLiteral(node) ||
+    t$9.isNumericLiteral(node) ||
+    t$9.isBooleanLiteral(node) ||
+    t$9.isNullLiteral(node) ||
+    t$9.isBigIntLiteral?.(node)
   ) {
     return true;
   }
 
-  if (t$7.isTemplateLiteral(node)) {
+  if (t$9.isTemplateLiteral(node)) {
     return node.expressions.every((expression) =>
       isStaticStylesExpression(expression, functionPath, seenBindings)
     );
   }
 
-  if (t$7.isIdentifier(node)) {
+  if (t$9.isIdentifier(node)) {
     return isStaticStylesIdentifier(node, functionPath, seenBindings);
   }
 
-  if (t$7.isUnaryExpression(node)) {
+  if (t$9.isUnaryExpression(node)) {
     return isStaticStylesExpression(node.argument, functionPath, seenBindings);
   }
 
-  if (t$7.isBinaryExpression(node) || t$7.isLogicalExpression(node)) {
+  if (t$9.isBinaryExpression(node) || t$9.isLogicalExpression(node)) {
     return (
       isStaticStylesExpression(node.left, functionPath, seenBindings) &&
       isStaticStylesExpression(node.right, functionPath, seenBindings)
     );
   }
 
-  if (t$7.isConditionalExpression(node)) {
+  if (t$9.isConditionalExpression(node)) {
     return (
       isStaticStylesExpression(node.test, functionPath, seenBindings) &&
       isStaticStylesExpression(node.consequent, functionPath, seenBindings) &&
@@ -517,15 +523,15 @@ function isStaticStylesExpression(node, functionPath, seenBindings = new Set())
     );
   }
 
-  if (t$7.isArrayExpression(node)) {
+  if (t$9.isArrayExpression(node)) {
     return node.elements.every((element) =>
       element == null || isStaticStylesExpression(element, functionPath, seenBindings)
     );
   }
 
-  if (t$7.isObjectExpression(node)) {
+  if (t$9.isObjectExpression(node)) {
     return node.properties.every((property) => {
-      if (t$7.isObjectProperty(property)) {
+      if (t$9.isObjectProperty(property)) {
         return (
           (!property.computed ||
             isStaticStylesExpression(property.key, functionPath, seenBindings)) &&
@@ -536,7 +542,7 @@ function isStaticStylesExpression(node, functionPath, seenBindings = new Set())
     });
   }
 
-  if (t$7.isMemberExpression(node)) {
+  if (t$9.isMemberExpression(node)) {
     return (
       isStaticStylesExpression(node.object, functionPath, seenBindings) &&
       (!node.computed ||
@@ -544,18 +550,18 @@ function isStaticStylesExpression(node, functionPath, seenBindings = new Set())
     );
   }
 
-  if (t$7.isCallExpression(node)) {
+  if (t$9.isCallExpression(node)) {
     return (
       isStaticStylesExpression(node.callee, functionPath, seenBindings) &&
       node.arguments.every((argument) =>
-        t$7.isSpreadElement(argument)
+        t$9.isSpreadElement(argument)
           ? false
           : isStaticStylesExpression(argument, functionPath, seenBindings)
       )
     );
   }
 
-  if (t$7.isTaggedTemplateExpression(node)) {
+  if (t$9.isTaggedTemplateExpression(node)) {
     return (
       isStaticStylesExpression(node.tag, functionPath, seenBindings) &&
       isStaticStylesExpression(node.quasi, functionPath, seenBindings)
@@ -621,7 +627,7 @@ function processStaticHoists({
   const staticHoists = [];
   let lightDomRequested = options.defaultDomMode === "light";
 
-  if (t$7.isBlockStatement(node.body)) {
+  if (t$9.isBlockStatement(node.body)) {
     for (let index = renderStatements.length - 1; index >= 0; index -= 1) {
       const propertyOptions = getStaticPropsExpression(renderStatements[index]);
       if (propertyOptions) {
@@ -675,9 +681,9 @@ function processStaticHoists({
 
   const hasHoistedProperties = staticHoists.some((entry) => entry.name === "properties");
   if (propertiesStatic.length > 0 && !hasHoistedProperties) {
-    const classProperties = t$7.classProperty(
-      t$7.identifier("properties"),
-      t$7.objectExpression(propertiesStatic),
+    const classProperties = t$9.classProperty(
+      t$9.identifier("properties"),
+      t$9.objectExpression(propertiesStatic),
       null,
       [],
       false
@@ -689,9 +695,9 @@ function processStaticHoists({
 
   const hasHoistedStyles = staticHoists.some((entry) => entry.name === "styles");
   if (staticStyles.length > 0 && !hasHoistedStyles) {
-    const stylesProperty = t$7.classProperty(
-      t$7.identifier("styles"),
-      staticStyles.length === 1 ? staticStyles[0] : t$7.arrayExpression(staticStyles),
+    const stylesProperty = t$9.classProperty(
+      t$9.identifier("styles"),
+      staticStyles.length === 1 ? staticStyles[0] : t$9.arrayExpression(staticStyles),
       null,
       [],
       false
@@ -756,10 +762,10 @@ function processStaticHoists({
   };
 }
 
-let t$6;
+let t$8;
 
 function setHandlersBabelTypes(types) {
-  t$6 = types;
+  t$8 = types;
 }
 
 function isHoistableHandler(exprPath, componentPath) {
@@ -806,11 +812,11 @@ function generateHandlerName(attrName, usedNames) {
 }
 
 function normalizeHandlerBody(body) {
-  if (t$6.isBlockStatement(body)) {
-    return t$6.cloneNode(body, true);
+  if (t$8.isBlockStatement(body)) {
+    return t$8.cloneNode(body, true);
   }
 
-  return t$6.blockStatement([t$6.returnStatement(t$6.cloneNode(body, true))]);
+  return t$8.blockStatement([t$8.returnStatement(t$8.cloneNode(body, true))]);
 }
 
 function hoistDeclaredHandlers(functionPath, usedNames) {
@@ -825,7 +831,7 @@ function hoistDeclaredHandlers(functionPath, usedNames) {
       if (path.getFunctionParent() !== functionPath) return;
 
       const id = path.node.id;
-      if (!t$6.isIdentifier(id)) return;
+      if (!t$8.isIdentifier(id)) return;
 
       const initPath = path.get("init");
       if (!initPath.isArrowFunctionExpression() && !initPath.isFunctionExpression()) {
@@ -849,13 +855,13 @@ function hoistDeclaredHandlers(functionPath, usedNames) {
       binding.referencePaths.slice().forEach((refPath) => {
         if (!refPath.node || refPath.removed) return;
         refPath.replaceWith(
-          t$6.memberExpression(t$6.thisExpression(), t$6.identifier(handlerName))
+          t$8.memberExpression(t$8.thisExpression(), t$8.identifier(handlerName))
         );
       });
 
       handlerInfos.push({
         name: handlerName,
-        params: initPath.node.params.map((param) => t$6.cloneNode(param, true)),
+        params: initPath.node.params.map((param) => t$8.cloneNode(param, true)),
         body: normalizeHandlerBody(initPath.node.body),
         async: initPath.node.async,
         generator: initPath.node.generator,
@@ -885,7 +891,7 @@ function hoistEventHandlers(functionPath, usedNames) {
       if (attrPath.getFunctionParent() !== functionPath) return;
 
       const { node } = attrPath;
-      if (!t$6.isJSXIdentifier(node.name)) return;
+      if (!t$8.isJSXIdentifier(node.name)) return;
 
       const attrName = node.name.name;
       if (!/^on[A-Z]/.test(attrName)) return;
@@ -907,15 +913,15 @@ function hoistEventHandlers(functionPath, usedNames) {
 
       handlerInfos.push({
         name: handlerName,
-        params: exprPath.node.params.map((param) => t$6.cloneNode(param, true)),
+        params: exprPath.node.params.map((param) => t$8.cloneNode(param, true)),
         body: normalizeHandlerBody(exprPath.node.body),
         async: exprPath.node.async,
         generator: exprPath.node.generator,
       });
 
       valuePath.replaceWith(
-        t$6.jsxExpressionContainer(
-          t$6.memberExpression(t$6.thisExpression(), t$6.identifier(handlerName))
+        t$8.jsxExpressionContainer(
+          t$8.memberExpression(t$8.thisExpression(), t$8.identifier(handlerName))
         )
       );
     },
@@ -925,7 +931,7 @@ function hoistEventHandlers(functionPath, usedNames) {
 }
 
 function isNativeIntrinsicJsxElement(nameNode) {
-  return t$6.isJSXIdentifier(nameNode) && /^[a-z]/.test(nameNode.name);
+  return t$8.isJSXIdentifier(nameNode) && /^[a-z]/.test(nameNode.name);
 }
 
 function collectNativeClassNameWarnings(functionPath, warn, options = {}) {
@@ -942,7 +948,7 @@ function collectNativeClassNameWarnings(functionPath, warn, options = {}) {
       if (!isNativeIntrinsicJsxElement(openingElement.node.name)) return;
 
       const { node } = attrPath;
-      if (!t$6.isJSXIdentifier(node.name, { name: "className" })) return;
+      if (!t$8.isJSXIdentifier(node.name, { name: "className" })) return;
 
       warn({
         code: "LITSX_NATIVE_CLASSNAME",
@@ -964,11 +970,11 @@ function processHandlers(functionPath, usedNames) {
 }
 
 function createHandlerClassMember({ name, params, body, async, generator }) {
-  const method = t$6.classMethod(
+  const method = t$8.classMethod(
     "method",
-    t$6.identifier(name),
-    params.map((param) => t$6.cloneNode(param, true)),
-    t$6.cloneNode(body, true)
+    t$8.identifier(name),
+    params.map((param) => t$8.cloneNode(param, true)),
+    t$8.cloneNode(body, true)
   );
 
   method.async = Boolean(async);
@@ -977,10 +983,19 @@ function createHandlerClassMember({ name, params, body, async, generator }) {
   return method;
 }
 
-let t$5;
+let t$7;
+
+function isCapitalizedComponentName$1(name) {
+  if (typeof name !== "string" || name.length === 0) {
+    return false;
+  }
+
+  const first = name[0];
+  return first === first.toUpperCase() && first !== first.toLowerCase();
+}
 
 function setWrapperUtilsBabelTypes(nextTypes) {
-  t$5 = nextTypes;
+  t$7 = nextTypes;
 }
 
 function emitWrapperWarnings(meta, warn) {
@@ -1035,7 +1050,7 @@ function maybeTransformWrappedVariableDeclarator({
   });
 
   const programPath = varPath.findParent((p) => p.isProgram());
-  const localName = t$5.isIdentifier(varPath.node.id)
+  const localName = t$7.isIdentifier(varPath.node.id)
     ? varPath.node.id.name
     : undefined;
 
@@ -1046,6 +1061,7 @@ function maybeTransformWrappedVariableDeclarator({
     {
       ...resolvedPluginOptions,
       ...wrapperMeta.options,
+      state,
       typeResolver: state?.__litsxTypeResolver,
       warn: (warning) => {
         state?.__litsxWarnings?.push(warning);
@@ -1057,7 +1073,7 @@ function maybeTransformWrappedVariableDeclarator({
     return true;
   }
 
-  if (t$5.isIdentifier(varPath.node.id)) {
+  if (t$7.isIdentifier(varPath.node.id)) {
     varPath.scope.removeBinding(varPath.node.id.name);
   }
 
@@ -1089,31 +1105,36 @@ function handlePotentialComponentExport({
   }
 
   if (
-    t$5.isFunctionDeclaration(declaration) ||
-    (t$5.isVariableDeclaration(declaration) &&
+    t$7.isFunctionDeclaration(declaration) ||
+    (t$7.isVariableDeclaration(declaration) &&
       declaration.declarations.length === 1 &&
-      t$5.isArrowFunctionExpression(declaration.declarations[0].init))
+      t$7.isArrowFunctionExpression(declaration.declarations[0].init))
   ) {
     const funcPath = exportPath.get("declaration");
     const declarationPath = funcPath.isVariableDeclaration()
       ? funcPath.get("declarations.0.init")
       : funcPath;
     let exportName;
-    if (t$5.isFunctionDeclaration(declaration) && declaration.id) {
+    if (t$7.isFunctionDeclaration(declaration) && declaration.id) {
       exportName = declaration.id.name;
     } else if (
-      t$5.isVariableDeclaration(declaration) &&
-      t$5.isIdentifier(declaration.declarations[0].id)
+      t$7.isVariableDeclaration(declaration) &&
+      t$7.isIdentifier(declaration.declarations[0].id)
     ) {
       exportName = declaration.declarations[0].id.name;
     }
 
+    if (exportName && !isCapitalizedComponentName$1(exportName)) {
+      return false;
+    }
+
     const classNode = transformFunction(
       declarationPath,
       exportPath.findParent((p) => p.isProgram()),
       exportName,
       {
         ...state?.__litsxResolvedPluginOptions,
+        state,
         typeResolver,
         warn: (warning) => {
           state?.__litsxWarnings?.push(warning);
@@ -1129,8 +1150,8 @@ function handlePotentialComponentExport({
 
     exportPath.insertBefore(
       isDefault
-        ? t$5.exportDefaultDeclaration(classNode)
-        : t$5.exportNamedDeclaration(classNode, [])
+        ? t$7.exportDefaultDeclaration(classNode)
+        : t$7.exportNamedDeclaration(classNode, [])
     );
     exportPath.remove();
     updateTransformState?.(state, classNode);
@@ -1139,16 +1160,20 @@ function handlePotentialComponentExport({
 
   if (
     typeof getWrapperMetadata === "function" &&
-    t$5.isVariableDeclaration(declaration) &&
+    t$7.isVariableDeclaration(declaration) &&
     declaration.declarations.length === 1
   ) {
     const declaratorPath = exportPath.get("declaration.declarations.0");
     const initPath = declaratorPath.get("init");
-    const exportName = t$5.isIdentifier(declaratorPath.node.id)
+    const exportName = t$7.isIdentifier(declaratorPath.node.id)
       ? declaratorPath.node.id.name
       : undefined;
     const programPath = exportPath.findParent((p) => p.isProgram());
 
+    if (exportName && !isCapitalizedComponentName$1(exportName)) {
+      return false;
+    }
+
     if (initPath.isCallExpression()) {
       const wrapperMeta = getWrapperMetadata(initPath);
       if (!wrapperMeta) return false;
@@ -1163,6 +1188,7 @@ function handlePotentialComponentExport({
         {
           ...state?.__litsxResolvedPluginOptions,
           ...wrapperMeta.options,
+          state,
           typeResolver,
           warn: (warning) => {
             state?.__litsxWarnings?.push(warning);
@@ -1175,7 +1201,11 @@ function handlePotentialComponentExport({
         exportPath.scope.removeBinding(exportName);
       }
 
-      exportPath.replaceWith(t$5.exportNamedDeclaration(classNode, []));
+      exportPath.replaceWith(
+        isDefault
+          ? t$7.exportDefaultDeclaration(classNode)
+          : t$7.exportNamedDeclaration(classNode, [])
+      );
       exportPath.requeue();
       pruneWrapperImports(wrapperMeta);
       updateTransformState?.(state, classNode);
@@ -1183,7 +1213,7 @@ function handlePotentialComponentExport({
     }
   }
 
-  if (typeof getWrapperMetadata === "function" && isDefault && t$5.isCallExpression(declaration)) {
+  if (typeof getWrapperMetadata === "function" && isDefault && t$7.isCallExpression(declaration)) {
     const callPath = exportPath.get("declaration");
     const wrapperMeta = getWrapperMetadata(callPath);
     if (!wrapperMeta) return false;
@@ -1196,6 +1226,10 @@ function handlePotentialComponentExport({
       ? wrapperMeta.functionPath.node.id.name
       : undefined;
 
+    if (!inferredName || !isCapitalizedComponentName$1(inferredName)) {
+      return false;
+    }
+
     const classNode = transformFunction(
       wrapperMeta.functionPath,
       programPath,
@@ -1203,6 +1237,7 @@ function handlePotentialComponentExport({
       {
         ...state?.__litsxResolvedPluginOptions,
         ...wrapperMeta.options,
+        state,
         typeResolver,
         warn: (warning) => {
           state?.__litsxWarnings?.push(warning);
@@ -1211,7 +1246,7 @@ function handlePotentialComponentExport({
     );
     if (!classNode) return true;
 
-    exportPath.replaceWith(t$5.exportDefaultDeclaration(classNode));
+    exportPath.replaceWith(t$7.exportDefaultDeclaration(classNode));
     exportPath.requeue();
     pruneWrapperImports(wrapperMeta);
     updateTransformState?.(state, classNode);
@@ -1221,23 +1256,23 @@ function handlePotentialComponentExport({
   return false;
 }
 
-let t$4;
+let t$6;
 
 function setRefsBabelTypes(nextTypes) {
-  t$4 = nextTypes;
+  t$6 = nextTypes;
 }
 
-function createThisMemberExpression$3(propName) {
-  return t$4.memberExpression(t$4.thisExpression(), t$4.identifier(propName));
+function createThisMemberExpression$4(propName) {
+  return t$6.memberExpression(t$6.thisExpression(), t$6.identifier(propName));
 }
 
 function createManagedRefLookupExpression(refName) {
-  const selectorLiteral = t$4.stringLiteral(`[data-ref="${refName}"]`);
+  const selectorLiteral = t$6.stringLiteral(`[data-ref="${refName}"]`);
 
-  const renderRootQuery = t$4.optionalCallExpression(
-    t$4.optionalMemberExpression(
-      t$4.memberExpression(t$4.thisExpression(), t$4.identifier("renderRoot")),
-      t$4.identifier("querySelector"),
+  const renderRootQuery = t$6.optionalCallExpression(
+    t$6.optionalMemberExpression(
+      t$6.memberExpression(t$6.thisExpression(), t$6.identifier("renderRoot")),
+      t$6.identifier("querySelector"),
       false,
       true
     ),
@@ -1245,55 +1280,55 @@ function createManagedRefLookupExpression(refName) {
     false
   );
 
-  const hostQuery = t$4.callExpression(
-    t$4.memberExpression(t$4.thisExpression(), t$4.identifier("querySelector")),
-    [t$4.cloneNode(selectorLiteral)]
+  const hostQuery = t$6.callExpression(
+    t$6.memberExpression(t$6.thisExpression(), t$6.identifier("querySelector")),
+    [t$6.cloneNode(selectorLiteral)]
   );
 
-  return t$4.logicalExpression("??", renderRootQuery, hostQuery);
+  return t$6.logicalExpression("??", renderRootQuery, hostQuery);
 }
 
 function createForwardedTargetRefSyncStatement(propName, refName) {
-  return t$4.expressionStatement(
-    t$4.callExpression(t$4.identifier("useCallbackRef"), [
-      t$4.thisExpression(),
-      t$4.arrowFunctionExpression([], createManagedRefLookupExpression(refName)),
-      t$4.arrowFunctionExpression(
-        [t$4.identifier("node")],
-        t$4.blockStatement([
-          t$4.variableDeclaration("const", [
-            t$4.variableDeclarator(
-              t$4.identifier("componentRef"),
-              createThisMemberExpression$3(propName)
+  return t$6.expressionStatement(
+    t$6.callExpression(t$6.identifier("useCallbackRef"), [
+      t$6.thisExpression(),
+      t$6.arrowFunctionExpression([], createManagedRefLookupExpression(refName)),
+      t$6.arrowFunctionExpression(
+        [t$6.identifier("node")],
+        t$6.blockStatement([
+          t$6.variableDeclaration("const", [
+            t$6.variableDeclarator(
+              t$6.identifier("componentRef"),
+              createThisMemberExpression$4(propName)
             ),
           ]),
-          t$4.ifStatement(
-            t$4.binaryExpression(
+          t$6.ifStatement(
+            t$6.binaryExpression(
               "===",
-              t$4.unaryExpression("typeof", t$4.identifier("componentRef")),
-              t$4.stringLiteral("function")
+              t$6.unaryExpression("typeof", t$6.identifier("componentRef")),
+              t$6.stringLiteral("function")
             ),
-            t$4.blockStatement([
-              t$4.expressionStatement(
-                t$4.callExpression(t$4.identifier("componentRef"), [t$4.identifier("node")])
+            t$6.blockStatement([
+              t$6.expressionStatement(
+                t$6.callExpression(t$6.identifier("componentRef"), [t$6.identifier("node")])
               ),
             ]),
-            t$4.ifStatement(
-              t$4.logicalExpression(
+            t$6.ifStatement(
+              t$6.logicalExpression(
                 "&&",
-                t$4.identifier("componentRef"),
-                t$4.binaryExpression(
+                t$6.identifier("componentRef"),
+                t$6.binaryExpression(
                   "===",
-                  t$4.unaryExpression("typeof", t$4.identifier("componentRef")),
-                  t$4.stringLiteral("object")
+                  t$6.unaryExpression("typeof", t$6.identifier("componentRef")),
+                  t$6.stringLiteral("object")
                 )
               ),
-              t$4.blockStatement([
-                t$4.expressionStatement(
-                  t$4.assignmentExpression(
+              t$6.blockStatement([
+                t$6.expressionStatement(
+                  t$6.assignmentExpression(
                     "=",
-                    t$4.memberExpression(t$4.identifier("componentRef"), t$4.identifier("current")),
-                    t$4.identifier("node")
+                    t$6.memberExpression(t$6.identifier("componentRef"), t$6.identifier("current")),
+                    t$6.identifier("node")
                   )
                 ),
               ])
@@ -1301,13 +1336,13 @@ function createForwardedTargetRefSyncStatement(propName, refName) {
           ),
         ])
       ),
-      t$4.arrayExpression([createThisMemberExpression$3(propName)]),
+      t$6.arrayExpression([createThisMemberExpression$4(propName)]),
     ])
   );
 }
 
 function isStandardElementJsxName(nameNode) {
-  if (!t$4.isJSXIdentifier(nameNode)) {
+  if (!t$6.isJSXIdentifier(nameNode)) {
     return false;
   }
 
@@ -1316,46 +1351,46 @@ function isStandardElementJsxName(nameNode) {
 }
 
 function createComponentInstanceRefSyncStatement() {
-  return t$4.expressionStatement(
-    t$4.callExpression(t$4.identifier("useCallbackRef"), [
-      t$4.thisExpression(),
-      t$4.arrowFunctionExpression([], t$4.thisExpression()),
-      t$4.arrowFunctionExpression(
-        [t$4.identifier("node")],
-        t$4.blockStatement([
-          t$4.variableDeclaration("const", [
-            t$4.variableDeclarator(
-              t$4.identifier("componentRef"),
-              createThisMemberExpression$3("ref")
+  return t$6.expressionStatement(
+    t$6.callExpression(t$6.identifier("useCallbackRef"), [
+      t$6.thisExpression(),
+      t$6.arrowFunctionExpression([], t$6.thisExpression()),
+      t$6.arrowFunctionExpression(
+        [t$6.identifier("node")],
+        t$6.blockStatement([
+          t$6.variableDeclaration("const", [
+            t$6.variableDeclarator(
+              t$6.identifier("componentRef"),
+              createThisMemberExpression$4("ref")
             ),
           ]),
-          t$4.ifStatement(
-            t$4.binaryExpression(
+          t$6.ifStatement(
+            t$6.binaryExpression(
               "===",
-              t$4.unaryExpression("typeof", t$4.identifier("componentRef")),
-              t$4.stringLiteral("function")
+              t$6.unaryExpression("typeof", t$6.identifier("componentRef")),
+              t$6.stringLiteral("function")
             ),
-            t$4.blockStatement([
-              t$4.expressionStatement(
-                t$4.callExpression(t$4.identifier("componentRef"), [t$4.identifier("node")])
+            t$6.blockStatement([
+              t$6.expressionStatement(
+                t$6.callExpression(t$6.identifier("componentRef"), [t$6.identifier("node")])
               ),
             ]),
-            t$4.ifStatement(
-              t$4.logicalExpression(
+            t$6.ifStatement(
+              t$6.logicalExpression(
                 "&&",
-                t$4.identifier("componentRef"),
-                t$4.binaryExpression(
+                t$6.identifier("componentRef"),
+                t$6.binaryExpression(
                   "===",
-                  t$4.unaryExpression("typeof", t$4.identifier("componentRef")),
-                  t$4.stringLiteral("object")
+                  t$6.unaryExpression("typeof", t$6.identifier("componentRef")),
+                  t$6.stringLiteral("object")
                 )
               ),
-              t$4.blockStatement([
-                t$4.expressionStatement(
-                  t$4.assignmentExpression(
+              t$6.blockStatement([
+                t$6.expressionStatement(
+                  t$6.assignmentExpression(
                     "=",
-                    t$4.memberExpression(t$4.identifier("componentRef"), t$4.identifier("current")),
-                    t$4.identifier("node")
+                    t$6.memberExpression(t$6.identifier("componentRef"), t$6.identifier("current")),
+                    t$6.identifier("node")
                   )
                 ),
               ])
@@ -1363,7 +1398,7 @@ function createComponentInstanceRefSyncStatement() {
           ),
         ])
       ),
-      t$4.arrayExpression([createThisMemberExpression$3("ref")]),
+      t$6.arrayExpression([createThisMemberExpression$4("ref")]),
     ])
   );
 }
@@ -1374,27 +1409,27 @@ function hasRefProp(functionPath) {
     return false;
   }
 
-  if (t$4.isObjectPattern(firstParam)) {
+  if (t$6.isObjectPattern(firstParam)) {
     return firstParam.properties.some((property) => {
-      if (!t$4.isObjectProperty(property)) return false;
+      if (!t$6.isObjectProperty(property)) return false;
       return (
-        t$4.isIdentifier(property.key, { name: "ref" }) ||
-        t$4.isStringLiteral(property.key, { value: "ref" })
+        t$6.isIdentifier(property.key, { name: "ref" }) ||
+        t$6.isStringLiteral(property.key, { value: "ref" })
       );
     });
   }
 
-  if (t$4.isAssignmentPattern(firstParam) && t$4.isObjectPattern(firstParam.left)) {
+  if (t$6.isAssignmentPattern(firstParam) && t$6.isObjectPattern(firstParam.left)) {
     return firstParam.left.properties.some((property) => {
-      if (!t$4.isObjectProperty(property)) return false;
+      if (!t$6.isObjectProperty(property)) return false;
       return (
-        t$4.isIdentifier(property.key, { name: "ref" }) ||
-        t$4.isStringLiteral(property.key, { value: "ref" })
+        t$6.isIdentifier(property.key, { name: "ref" }) ||
+        t$6.isStringLiteral(property.key, { value: "ref" })
       );
     });
   }
 
-  if (t$4.isIdentifier(firstParam)) {
+  if (t$6.isIdentifier(firstParam)) {
     const binding = functionPath.scope.getBinding(firstParam.name);
     if (!binding) return false;
     return binding.referencePaths.some((refPath) => {
@@ -1403,7 +1438,7 @@ function hasRefProp(functionPath) {
         parentPath &&
         parentPath.isMemberExpression() &&
         parentPath.node.object === refPath.node &&
-        t$4.isIdentifier(parentPath.node.property, { name: "ref" }) &&
+        t$6.isIdentifier(parentPath.node.property, { name: "ref" }) &&
         !parentPath.node.computed
       );
     });
@@ -1422,14 +1457,14 @@ function lowerForwardedElementRefs(functionPath, propName) {
 
   functionPath.traverse({
     JSXAttribute(attrPath) {
-      if (!t$4.isJSXIdentifier(attrPath.node.name, { name: "ref" })) return;
+      if (!t$6.isJSXIdentifier(attrPath.node.name, { name: "ref" })) return;
 
       const value = attrPath.node.value;
-      if (!t$4.isJSXExpressionContainer(value)) return;
+      if (!t$6.isJSXExpressionContainer(value)) return;
       if (
-        !t$4.isMemberExpression(value.expression) ||
-        !t$4.isThisExpression(value.expression.object) ||
-        !t$4.isIdentifier(value.expression.property, { name: propName }) ||
+        !t$6.isMemberExpression(value.expression) ||
+        !t$6.isThisExpression(value.expression.object) ||
+        !t$6.isIdentifier(value.expression.property, { name: propName }) ||
         value.expression.computed
       ) {
         return;
@@ -1441,7 +1476,7 @@ function lowerForwardedElementRefs(functionPath, propName) {
 
       const managedRefName = functionPath.scope.generateUidIdentifier(`${propName}Element`).name;
       attrPath.replaceWith(
-        t$4.jsxAttribute(t$4.jsxIdentifier("data-ref"), t$4.stringLiteral(managedRefName))
+        t$6.jsxAttribute(t$6.jsxIdentifier("data-ref"), t$6.stringLiteral(managedRefName))
       );
 
       if (seenRefNames.has(managedRefName)) return;
@@ -1453,14 +1488,14 @@ function lowerForwardedElementRefs(functionPath, propName) {
   return callbackStatements;
 }
 
-let t$3;
+let t$5;
 
 function setClassGenerationBabelTypes(nextTypes) {
-  t$3 = nextTypes;
+  t$5 = nextTypes;
 }
 
-function createThisMemberExpression$2(propName) {
-  return t$3.memberExpression(t$3.thisExpression(), t$3.identifier(propName));
+function createThisMemberExpression$3(propName) {
+  return t$5.memberExpression(t$5.thisExpression(), t$5.identifier(propName));
 }
 
 function buildClassMembers({
@@ -1472,26 +1507,26 @@ function buildClassMembers({
 }) {
   if (defaults.size > 0) {
     const constructorStatements = [
-      t$3.expressionStatement(t$3.callExpression(t$3.super(), [])),
+      t$5.expressionStatement(t$5.callExpression(t$5.super(), [])),
     ];
 
     defaults.forEach((defaultExpression, propName) => {
       constructorStatements.push(
-        t$3.expressionStatement(
-          t$3.assignmentExpression(
+        t$5.expressionStatement(
+          t$5.assignmentExpression(
             "??=",
-            createThisMemberExpression$2(propName),
-            t$3.cloneNode(defaultExpression)
+            createThisMemberExpression$3(propName),
+            t$5.cloneNode(defaultExpression)
           )
         )
       );
     });
 
-    const constructorMethod = t$3.classMethod(
+    const constructorMethod = t$5.classMethod(
       "constructor",
-      t$3.identifier("constructor"),
+      t$5.identifier("constructor"),
       [],
-      t$3.blockStatement(constructorStatements)
+      t$5.blockStatement(constructorStatements)
     );
 
     const insertionIndex = classMembers.findIndex((member) => !member.static);
@@ -1506,11 +1541,11 @@ function buildClassMembers({
     createHandlerClassMember(handler)
   );
 
-  const renderMethod = t$3.classMethod(
+  const renderMethod = t$5.classMethod(
     "method",
-    t$3.identifier("render"),
+    t$5.identifier("render"),
     [],
-    t$3.blockStatement(renderStatements)
+    t$5.blockStatement(renderStatements)
   );
 
   classMembers.push(...handlerMembers, renderMethod);
@@ -1528,10 +1563,10 @@ function createComponentClass({
   needsUnsafeCss,
   needsCallbackRef = false,
 }) {
-  const classNode = t$3.classDeclaration(
-    t$3.identifier(className),
-    t$3.identifier("LitElement"),
-    t$3.classBody(classMembers)
+  const classNode = t$5.classDeclaration(
+    t$5.identifier(className),
+    t$5.identifier("LitElement"),
+    t$5.classBody(classMembers)
   );
 
   if (hoistMembers.length > 0) {
@@ -1540,8 +1575,8 @@ function createComponentClass({
       classNode._litsxStaticSymbolDeclarations = hoistSymbolDeclarations;
     }
     if (needsStaticHoistsMixin) {
-      classNode.superClass = t$3.callExpression(
-        t$3.identifier("LitsxStaticHoistsMixin"),
+      classNode.superClass = t$5.callExpression(
+        t$5.identifier("LitsxStaticHoistsMixin"),
         [classNode.superClass]
       );
       classNode._needsStaticHoistsMixin = true;
@@ -1549,8 +1584,8 @@ function createComponentClass({
   }
 
   if (lightDomRequested) {
-    classNode.superClass = t$3.callExpression(
-      t$3.identifier("LightDomMixin"),
+    classNode.superClass = t$5.callExpression(
+      t$5.identifier("LightDomMixin"),
       [classNode.superClass]
     );
     classNode._needsLightDomMixin = true;
@@ -1563,28 +1598,28 @@ function createComponentClass({
   return classNode;
 }
 
-let t$2;
+let t$4;
 
 function setParamRewriteBabelTypes(nextTypes) {
-  t$2 = nextTypes;
+  t$4 = nextTypes;
 }
 
-function createThisMemberExpression$1(propName) {
-  return t$2.memberExpression(t$2.thisExpression(), t$2.identifier(propName));
+function createThisMemberExpression$2(propName) {
+  return t$4.memberExpression(t$4.thisExpression(), t$4.identifier(propName));
 }
 
-function transformJSXExpressions(jsxPath, bindings) {
+function transformJSXExpressions(jsxPath, bindings, state = null) {
   const localNames = Array.from(bindings.keys());
 
   jsxPath.traverse({
     JSXExpressionContainer(expressionPath) {
-      if (t$2.isIdentifier(expressionPath.node.expression)) {
+      if (t$4.isIdentifier(expressionPath.node.expression)) {
         const name = expressionPath.node.expression.name;
         if (localNames.includes(name)) {
           const propName = bindings.get(name) || name;
-          expressionPath.node.expression = t$2.memberExpression(
-            t$2.thisExpression(),
-            t$2.identifier(propName)
+          expressionPath.node.expression = t$4.memberExpression(
+            t$4.thisExpression(),
+            t$4.identifier(propName)
           );
         }
       }
@@ -1603,16 +1638,16 @@ function registerLocalPropAliases(functionPath, bindings) {
         if (path.getFunctionParent() !== functionPath) return;
 
         const { id, init } = path.node;
-        if (!t$2.isIdentifier(init)) return;
+        if (!t$4.isIdentifier(init)) return;
 
-        if (t$2.isIdentifier(id)) {
+        if (t$4.isIdentifier(id)) {
           if (bindings.has(id.name) || !bindings.has(init.name)) return;
           bindings.set(id.name, bindings.get(init.name));
           changed = true;
           return;
         }
 
-        if (!t$2.isObjectPattern(id)) return;
+        if (!t$4.isObjectPattern(id)) return;
 
         const bindingInfo = bindings.get(init.name);
         if (!bindingInfo || typeof bindingInfo !== "object" || bindingInfo.kind !== "alias") {
@@ -1620,17 +1655,17 @@ function registerLocalPropAliases(functionPath, bindings) {
         }
 
         id.properties.forEach((property) => {
-          if (!t$2.isObjectProperty(property)) return;
+          if (!t$4.isObjectProperty(property)) return;
 
-          const keyName = t$2.isIdentifier(property.key)
+          const keyName = t$4.isIdentifier(property.key)
             ? property.key.name
-            : t$2.isStringLiteral(property.key)
+            : t$4.isStringLiteral(property.key)
               ? property.key.value
               : null;
 
           if (!keyName || !bindingInfo.properties.has(keyName)) return;
 
-          if (t$2.isIdentifier(property.value)) {
+          if (t$4.isIdentifier(property.value)) {
             if (!bindings.has(property.value.name)) {
               bindings.set(property.value.name, keyName);
               changed = true;
@@ -1639,8 +1674,8 @@ function registerLocalPropAliases(functionPath, bindings) {
           }
 
           if (
-            t$2.isAssignmentPattern(property.value) &&
-            t$2.isIdentifier(property.value.left) &&
+            t$4.isAssignmentPattern(property.value) &&
+            t$4.isIdentifier(property.value.left) &&
             !bindings.has(property.value.left.name)
           ) {
             bindings.set(property.value.left.name, keyName);
@@ -1673,10 +1708,10 @@ function replaceParamReferences(functionPath, bindings, propertyMap = new Map())
         aliasId = functionPath.scope.generateUidIdentifier(propName);
         capturedPropAliases.set(propName, aliasId);
       }
-      return t$2.cloneNode(aliasId);
+      return t$4.cloneNode(aliasId);
     }
 
-    return t$2.memberExpression(t$2.thisExpression(), t$2.identifier(propName));
+    return t$4.memberExpression(t$4.thisExpression(), t$4.identifier(propName));
   }
 
   bindings.forEach((bindingInfo, localName) => {
@@ -1705,7 +1740,7 @@ function replaceParamReferences(functionPath, bindings, propertyMap = new Map())
           return;
         }
 
-        refPath.replaceWith(t$2.thisExpression());
+        refPath.replaceWith(t$4.thisExpression());
         return;
       }
 
@@ -1716,7 +1751,7 @@ function replaceParamReferences(functionPath, bindings, propertyMap = new Map())
         refPath.parentPath &&
         refPath.parentPath.isMemberExpression() &&
         refPath.parentKey === "object" &&
-        t$2.isIdentifier(refPath.parentPath.node.property) &&
+        t$4.isIdentifier(refPath.parentPath.node.property) &&
         !refPath.parentPath.node.computed
       ) {
         const propName = refPath.parentPath.node.property.name;
@@ -1738,7 +1773,7 @@ function replaceParamReferences(functionPath, bindings, propertyMap = new Map())
         refPath.parentPath &&
         refPath.parentPath.isMemberExpression() &&
         refPath.parentKey === "object" &&
-        t$2.isIdentifier(refPath.parentPath.node.property) &&
+        t$4.isIdentifier(refPath.parentPath.node.property) &&
         !refPath.parentPath.node.computed
       ) {
         const propName = refPath.parentPath.node.property.name;
@@ -1764,7 +1799,7 @@ function replaceParamReferences(functionPath, bindings, propertyMap = new Map())
         refPath.parentKey === "value"
       ) {
         refPath.replaceWith(
-          t$2.jsxExpressionContainer(
+          t$4.jsxExpressionContainer(
             getReplacementForProp(targetProp || localName, refPath)
           )
         );
@@ -1785,12 +1820,208 @@ function replaceParamReferences(functionPath, bindings, propertyMap = new Map())
   });
 
   return Array.from(capturedPropAliases.entries()).map(([propName, aliasId]) =>
-    t$2.variableDeclaration("const", [
-      t$2.variableDeclarator(t$2.cloneNode(aliasId), createThisMemberExpression$1(propName)),
+    t$4.variableDeclaration("const", [
+      t$4.variableDeclarator(t$4.cloneNode(aliasId), createThisMemberExpression$2(propName)),
     ])
   );
 }
 
+let t$3;
+
+function setRendererCallsBabelTypes(nextTypes) {
+  t$3 = nextTypes;
+}
+
+function createThisMemberExpression$1(propName) {
+  return t$3.memberExpression(t$3.thisExpression(), t$3.identifier(propName));
+}
+
+function getBoundPropName(bindingInfo) {
+  if (typeof bindingInfo === "string") {
+    return bindingInfo;
+  }
+
+  if (bindingInfo && typeof bindingInfo === "object") {
+    return bindingInfo.bindKey ?? null;
+  }
+
+  return null;
+}
+
+function isPropBackedCallee(node, localNames) {
+  if (t$3.isIdentifier(node)) {
+    return localNames.includes(node.name);
+  }
+
+  if (
+    t$3.isMemberExpression(node) &&
+    !node.computed &&
+    t$3.isIdentifier(node.object)
+  ) {
+    return localNames.includes(node.object.name) && node.object.name === "props";
+  }
+
+  return false;
+}
+
+function getPropBackedCalleeReplacement(node, bindings) {
+  if (t$3.isIdentifier(node)) {
+    const propName = getBoundPropName(bindings.get(node.name));
+    return propName ? createThisMemberExpression$1(propName) : node;
+  }
+
+  if (
+    t$3.isMemberExpression(node) &&
+    !node.computed &&
+    t$3.isIdentifier(node.object)
+  ) {
+    const propName = getBoundPropName(bindings.get(node.object.name));
+    if (!propName) {
+      return node;
+    }
+
+    return t$3.memberExpression(
+      createThisMemberExpression$1(propName),
+      t$3.cloneNode(node.property),
+      false
+    );
+  }
+
+  return node;
+}
+
+function transformJSXRendererCalls(jsxPath, bindings, state = null) {
+  const localNames = Array.from(bindings.keys());
+
+  jsxPath.traverse({
+    JSXExpressionContainer(expressionPath) {
+      if (!t$3.isCallExpression(expressionPath.node.expression)) {
+        return;
+      }
+
+      const { callee, arguments: args } = expressionPath.node.expression;
+      if (!isPropBackedCallee(callee, localNames)) {
+        return;
+      }
+
+      if (state) {
+        state.__litsxNeedsRendererCallImport = true;
+      }
+
+      expressionPath.node.expression = t$3.callExpression(
+        t$3.identifier("renderRendererCall"),
+        [
+          getPropBackedCalleeReplacement(callee, bindings),
+          ...args,
+        ]
+      );
+    },
+  });
+}
+
+let t$2;
+
+function setRenderBodyBabelTypes(nextTypes) {
+  t$2 = nextTypes;
+}
+
+function createThisMemberExpression(propName) {
+  return t$2.memberExpression(t$2.thisExpression(), t$2.identifier(propName));
+}
+
+function createNestedInitializerStatement(pattern, root, defaultValue) {
+  const rootAccess = createThisMemberExpression(root);
+  let sourceExpression = rootAccess;
+
+  if (defaultValue) {
+    sourceExpression = t$2.logicalExpression(
+      "??",
+      t$2.cloneNode(rootAccess),
+      t$2.cloneNode(defaultValue)
+    );
+  }
+
+  return t$2.variableDeclaration("const", [
+    t$2.variableDeclarator(t$2.cloneNode(pattern), sourceExpression),
+  ]);
+}
+
+function collectReturnStatement(functionPath, bindings, state) {
+  let returnStatement = null;
+
+  functionPath.traverse({
+    ReturnStatement(returnPath) {
+      if (t$2.isJSXElement(returnPath.node.argument)) {
+        returnStatement = returnPath.node;
+        transformJSXRendererCalls(returnPath, bindings, state);
+        transformJSXExpressions(returnPath, bindings, state);
+      }
+    },
+  });
+
+  return returnStatement;
+}
+
+function prepareComponentRender(functionPath, node, propertyNames, bindings, nestedInitializers, options = {}) {
+  const returnStatement = collectReturnStatement(
+    functionPath,
+    bindings,
+    options.state ?? null
+  );
+
+  if (!returnStatement) {
+    return null;
+  }
+
+  const capturedPropAliasStatements = replaceParamReferences(
+    functionPath,
+    bindings,
+    propertyNames
+  );
+  const prefixStatements = [];
+
+  const forwardRefOptions = options.forwardRef || null;
+  const resolvedRefPropName =
+    forwardRefOptions?.propName ||
+    (propertyNames.has("ref") || hasRefProp(functionPath) ? "ref" : null);
+  let needsCallbackRef = false;
+
+  if (resolvedRefPropName) {
+    prefixStatements.push(
+      ...lowerForwardedElementRefs(functionPath, resolvedRefPropName)
+    );
+    needsCallbackRef =
+      prefixStatements.some(
+        (statement) =>
+          t$2.isExpressionStatement(statement) &&
+          t$2.isCallExpression(statement.expression) &&
+          t$2.isIdentifier(statement.expression.callee, { name: "useCallbackRef" })
+      ) || needsCallbackRef;
+  }
+
+  if (resolvedRefPropName && !forwardRefOptions) {
+    prefixStatements.push(createComponentInstanceRefSyncStatement());
+    needsCallbackRef = true;
+  }
+
+  if (capturedPropAliasStatements.length > 0) {
+    prefixStatements.push(...capturedPropAliasStatements);
+  }
+
+  if (nestedInitializers.length > 0) {
+    const initializerStatements = nestedInitializers.map(({ pattern, root, defaultValue }) =>
+      createNestedInitializerStatement(pattern, root, defaultValue)
+    );
+    prefixStatements.push(...initializerStatements);
+  }
+
+  return {
+    needsCallbackRef,
+    prefixStatements,
+    returnStatement,
+  };
+}
+
 let t$1;
 
 function setProgramBabelTypes(nextTypes) {
@@ -1815,6 +2046,15 @@ function createLitsxInfrastructureImport(importedName) {
   );
 }
 
+function createLitsxInternalRuntimeImport(importedName) {
+  return t$1.importDeclaration(
+    [
+      t$1.importSpecifier(t$1.identifier(importedName), t$1.identifier(importedName)),
+    ],
+    t$1.stringLiteral("@litsx/litsx/internal/runtime-render-context")
+  );
+}
+
 function createLitsxImport(importedName) {
   return t$1.importDeclaration(
     [
@@ -2018,11 +2258,43 @@ function finalizeProgram(programPath, state) {
     }
   }
 
+  if (state.__litsxNeedsRendererCallImport) {
+    const bodyPathsWithInternalRuntime = programPath.get("body");
+    const internalRuntimeImports = bodyPathsWithInternalRuntime.filter(
+      (n) =>
+        n.isImportDeclaration() &&
+        n.node.source.value === "@litsx/litsx/internal/runtime-render-context"
+    );
+
+    let internalRuntimeImported = false;
+    internalRuntimeImports.some((importPath) => {
+      if (ensureNamedImport(importPath, "renderRendererCall")) {
+        internalRuntimeImported = true;
+        return true;
+      }
+
+      return false;
+    });
+
+    if (!internalRuntimeImported) {
+      programPath.unshiftContainer("body", createLitsxInternalRuntimeImport("renderRendererCall"));
+    }
+  }
+
   pruneUnusedLitsxStaticImports(programPath);
 }
 
 let t;
 
+function isCapitalizedComponentName(name) {
+  if (typeof name !== "string" || name.length === 0) {
+    return false;
+  }
+
+  const first = name[0];
+  return first === first.toUpperCase() && first !== first.toLowerCase();
+}
+
 function createTransformFunctionToClassPlugin(defaultPluginOptions = {}) {
   return function transformFunctionToClassPlugin(_api, pluginOptions = {}) {
     internal_transformLitsxProperties.ensureTypescriptModule();
@@ -2034,6 +2306,9 @@ function createTransformFunctionToClassPlugin(defaultPluginOptions = {}) {
     setRefsBabelTypes(t);
     setClassGenerationBabelTypes(t);
     setParamRewriteBabelTypes(t);
+    setRendererCallsBabelTypes(t);
+    transformLitsxElementCandidates.setElementCandidatesBabelTypes(t);
+    setRenderBodyBabelTypes(t);
     setProgramBabelTypes(t);
     const resolvedPluginOptions = {
       ...defaultPluginOptions,
@@ -2055,6 +2330,7 @@ function createTransformFunctionToClassPlugin(defaultPluginOptions = {}) {
         this.__litsxNeedsStaticHoistsMixin = false;
         this.__litsxNeedsLightDomMixin = false;
         this.__litsxNeedsCallbackRef = false;
+        this.__litsxNeedsRendererCallImport = false;
         this.__litsxWarnings = [];
         this.__litsxResolvedPluginOptions = resolvedPluginOptions;
         this.__litsxTypeResolver = fileLikelyNeedsTypeResolver(this)
@@ -2121,15 +2397,21 @@ function createTransformFunctionToClassPlugin(defaultPluginOptions = {}) {
             return;
           }
 
-          if (initPath && initPath.isArrowFunctionExpression() && !isInsideFunctionOrClass(varPath)) {
+          if (
+            initPath &&
+            initPath.isArrowFunctionExpression() &&
+            !isInsideFunctionOrClass(varPath) &&
+            t.isIdentifier(varPath.node.id) &&
+            isCapitalizedComponentName(varPath.node.id.name)
+          ) {
             const programPath = varPath.findParent((p) => p.isProgram());
-            const elementCandidates = collectElementCandidates(initPath, programPath);
             const classNode = transformFunction(
               initPath,
               programPath,
               varPath.node.id.name,
               {
                 ...resolvedPluginOptions,
+                state: this,
                 typeResolver: getTypeResolverForFunction(initPath, this),
                 warn: (warning) => {
                   this.__litsxWarnings.push(warning);
@@ -2139,12 +2421,6 @@ function createTransformFunctionToClassPlugin(defaultPluginOptions = {}) {
 
             if (!classNode) return;
 
-            if (elementCandidates.size) {
-              classNode._litsxElementCandidates &&= new Set(classNode._litsxElementCandidates);
-              const elementSet = classNode._litsxElementCandidates ||= new Set();
-              elementCandidates.forEach((candidate) => elementSet.add(candidate));
-            }
-
             const declarationPath = varPath.parentPath;
             if (!declarationPath.isVariableDeclaration()) return;
 
@@ -2155,15 +2431,21 @@ function createTransformFunctionToClassPlugin(defaultPluginOptions = {}) {
           }
         },
         FunctionDeclaration(funcPath) {
-          if (!isInsideFunctionOrClass(funcPath)) {
+          if (
+            !funcPath.parentPath?.isExportNamedDeclaration?.() &&
+            !funcPath.parentPath?.isExportDefaultDeclaration?.() &&
+            !isInsideFunctionOrClass(funcPath) &&
+            funcPath.node.id &&
+            isCapitalizedComponentName(funcPath.node.id.name)
+          ) {
             const programPath = funcPath.findParent((p) => p.isProgram());
-            const elementCandidates = collectElementCandidates(funcPath, programPath);
             const classNode = transformFunction(
               funcPath,
               programPath,
               undefined,
               {
                 ...resolvedPluginOptions,
+                state: this,
                 typeResolver: getTypeResolverForFunction(funcPath, this),
                 warn: (warning) => {
                   this.__litsxWarnings.push(warning);
@@ -2176,11 +2458,6 @@ function createTransformFunctionToClassPlugin(defaultPluginOptions = {}) {
             if (funcPath.node.id) {
               funcPath.scope.removeBinding(funcPath.node.id.name);
             }
-            if (elementCandidates.size) {
-              classNode._litsxElementCandidates &&= new Set(classNode._litsxElementCandidates);
-              const elementSet = classNode._litsxElementCandidates ||= new Set();
-              elementCandidates.forEach((candidate) => elementSet.add(candidate));
-            }
             funcPath.replaceWith(classNode);
             funcPath.requeue();
             updateTransformState(this, classNode);
@@ -2332,7 +2609,8 @@ function getTypeResolverForFunction(functionPath, state) {
 
 function transformFunction(functionPath, programPath, className, options = {}) {
   const { node } = functionPath;
-  const forwardRefOptions = options.forwardRef || null;
+  const elementCandidates = transformLitsxElementCandidates.getAnnotatedElementCandidates(functionPath, programPath, options);
+  const importedElementCandidates = transformLitsxElementCandidates.getAnnotatedImportedElementCandidates(functionPath, programPath, options);
   let resolvedName = className;
   if (!resolvedName && node && node.id && t.isIdentifier(node.id)) {
     resolvedName = node.id.name;
@@ -2358,19 +2636,21 @@ function transformFunction(functionPath, programPath, className, options = {}) {
   assertStaticHoistsStayTopLevel(functionPath);
   collectNativeClassNameWarnings(functionPath, options.warn, options);
 
-  let returnStatement;
-  functionPath.traverse({
-    ReturnStatement(returnPath) {
-      if (t.isJSXElement(returnPath.node.argument)) {
-        returnStatement = returnPath.node;
-        transformJSXExpressions(returnPath, bindings);
-      }
-    },
-  });
+  const renderPreparation = prepareComponentRender(
+    functionPath,
+    node,
+    propertyNames,
+    bindings,
+    nestedInitializers,
+    options
+  );
 
-  if (!returnStatement) return;
+  if (!renderPreparation?.returnStatement) return;
 
-  const capturedPropAliasStatements = replaceParamReferences(functionPath, bindings, propertyNames);
+  const {
+    needsCallbackRef,
+    prefixStatements,
+  } = renderPreparation;
 
   const usedNames = new Set([
     ...Object.keys(functionPath.scope.bindings || {}),
@@ -2380,41 +2660,12 @@ function transformFunction(functionPath, programPath, className, options = {}) {
   ]);
 
   const handlerInfos = processHandlers(functionPath, usedNames);
-
   const renderStatements = t.isBlockStatement(node.body)
     ? [...node.body.body]
     : [t.returnStatement(node.body)];
 
-  const resolvedRefPropName = forwardRefOptions?.propName ||
-    (propertyNames.has("ref") || hasRefProp(functionPath) ? "ref" : null);
-  let needsCallbackRef = false;
-
-  if (resolvedRefPropName) {
-    renderStatements.unshift(
-      ...lowerForwardedElementRefs(functionPath, resolvedRefPropName)
-    );
-    needsCallbackRef = renderStatements.some(
-      (statement) =>
-        t.isExpressionStatement(statement) &&
-        t.isCallExpression(statement.expression) &&
-        t.isIdentifier(statement.expression.callee, { name: "useCallbackRef" })
-    ) || needsCallbackRef;
-  }
-
-  if (resolvedRefPropName && !forwardRefOptions) {
-    renderStatements.unshift(createComponentInstanceRefSyncStatement());
-    needsCallbackRef = true;
-  }
-
-  if (capturedPropAliasStatements.length > 0) {
-    renderStatements.unshift(...capturedPropAliasStatements);
-  }
-
-  if (nestedInitializers.length > 0) {
-    const initializerStatements = nestedInitializers.map(({ pattern, root, defaultValue }) =>
-      createNestedInitializerStatement(pattern, root, defaultValue, t)
-    );
-    renderStatements.unshift(...initializerStatements);
+  if (prefixStatements.length > 0) {
+    renderStatements.unshift(...prefixStatements);
   }
 
   const classMembers = [];
@@ -2445,7 +2696,7 @@ function transformFunction(functionPath, programPath, className, options = {}) {
     createHandlerClassMember,
   });
 
-  return createComponentClass({
+  const classNode = createComponentClass({
     className,
     classMembers,
     hoistMembers,
@@ -2456,63 +2707,31 @@ function transformFunction(functionPath, programPath, className, options = {}) {
     needsUnsafeCss,
     needsCallbackRef,
   });
-}
-
-function createThisMemberExpression(propName) {
-  return t.memberExpression(t.thisExpression(), t.identifier(propName));
-}
-
-function createNestedInitializerStatement(pattern, root, defaultValue, t) {
-  const rootAccess = createThisMemberExpression(root);
-  let sourceExpression = rootAccess;
 
-  if (defaultValue) {
-    sourceExpression = t.logicalExpression(
-      "??",
-      t.cloneNode(rootAccess),
-      t.cloneNode(defaultValue)
-    );
-  }
-
-  return t.variableDeclaration("const", [
-    t.variableDeclarator(t.cloneNode(pattern), sourceExpression),
-  ]);
-}
-
-function collectElementCandidates(functionPath, programPath) {
-  const candidates = new Set();
-  if (!programPath) return candidates;
-
-  const importNames = new Set();
-  programPath.get("body").forEach((nodePath) => {
-    if (!nodePath.isImportDeclaration()) return;
-    nodePath.node.specifiers.forEach((specifier) => {
-      if (specifier.local) {
-        importNames.add(specifier.local.name);
+  if (classNode && elementCandidates.size) {
+    classNode._litsxElementCandidates &&= new Set(classNode._litsxElementCandidates);
+    const elementSet = classNode._litsxElementCandidates ||= new Set();
+    elementCandidates.forEach((candidate) => elementSet.add(candidate));
+  }
+
+  if (classNode && importedElementCandidates.length > 0) {
+    classNode._litsxImportedElementCandidates ||= [];
+    importedElementCandidates.forEach((candidate) => {
+      if (!classNode._litsxImportedElementCandidates.some(
+        (entry) =>
+          entry.sourceFile === candidate.sourceFile &&
+          entry.importedName === candidate.importedName &&
+          entry.tagName === candidate.tagName
+      )) {
+        classNode._litsxImportedElementCandidates.push(candidate);
       }
     });
-  });
-
-  functionPath.traverse({
-    JSXOpeningElement(path) {
-      if (!path.node.name || path.node.name.type !== "JSXIdentifier") return;
-      const originalName = path.node.name.name;
-      if (!importNames.has(originalName)) return;
-
-      path.node.__scopedOriginal = originalName;
-      candidates.add(originalName);
-    },
-    JSXClosingElement(path) {
-      if (!path.node.name || path.node.name.type !== "JSXIdentifier") return;
-      const originalName = path.node.name.name;
-      if (!importNames.has(originalName)) return;
-      path.node.__scopedOriginal = originalName;
-    },
-  });
+  }
 
-  return candidates;
+  return classNode;
 }
 
 exports.createTransformFunctionToClassPlugin = createTransformFunctionToClassPlugin;
 exports.default = transformLitsxComponents;
+exports.isCapitalizedComponentName = isCapitalizedComponentName;
 //# sourceMappingURL=transform-litsx-components.cjs.map