@litsx/babel-preset-litsx 0.3.0 → 0.5.0

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

@@ -4,39 +4,52 @@ 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) {
-    throw new Error("^lightDom() does not accept arguments.");
+
+  const args = statement.expression.arguments;
+  if (args.length === 0) {
+    return true;
   }
-  return true;
+
+  if (args.length === 1 && t$9.isBooleanLiteral(args[0], { value: true })) {
+    return true;
+  }
+
+  throw new Error("static lightDom = true only accepts the literal value true.");
 }
 
 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 +60,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 +89,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 +112,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))) {
-    throw new Error("^properties(...) only accepts an object literal with static Lit property options.");
+  if (isHoistedProperties && (t$9.isFunctionExpression(argument) || t$9.isArrowFunctionExpression(argument))) {
+    throw new Error("static properties = ... only accepts an object literal with static Lit property options.");
   }
 
-  if (!t$7.isObjectExpression(argument)) {
-    throw new Error("^properties(...) only accepts an object literal with static Lit property options.");
+  if (!t$9.isObjectExpression(argument)) {
+    throw new Error("static 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
     );
 
@@ -149,37 +162,37 @@ function normalizeStaticPropOverrideValue(value) {
   }
 
   throw new Error(
-    "^properties(...) values must be Lit property option objects or constructor references."
+    "static properties = ... values must be Lit property option objects or constructor references."
   );
 }
 
 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)) {
-      throw new Error("^properties(...) only accepts plain object members.");
+    if (!t$9.isObjectProperty(property) && !t$9.isObjectMethod(property)) {
+      throw new Error("static properties = ... only accepts plain object members.");
     }
 
     const keyName = getStaticPropertyName(property.key);
     if (!keyName) {
-      throw new Error("^properties(...) property option names must be static identifiers or strings.");
+      throw new Error("static properties = ... property option names must be static identifiers or strings.");
     }
 
     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 +201,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,24 +209,24 @@ function mergeStaticPropsIntoProperties(propertiesStatic, staticProps) {
 
   staticProps.forEach((optionsObject) => {
     optionsObject.properties.forEach((property) => {
-      if (!t$7.isObjectProperty(property)) {
-        throw new Error("^properties(...) only accepts plain object properties.");
+      if (!t$9.isObjectProperty(property)) {
+        throw new Error("static properties = ... only accepts plain object properties.");
       }
 
       const keyName = getStaticPropertyName(property.key);
       if (!keyName) {
-        throw new Error("^properties(...) property names must be static identifiers or strings.");
+        throw new Error("static properties = ... property names must be static identifiers or strings.");
       }
 
       const existing = propertyMap.get(keyName);
       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 +240,7 @@ function mergeStaticPropsIntoProperties(propertiesStatic, staticProps) {
         false
       );
 
-      if (t$7.isObjectExpression(property.value)) {
+      if (t$9.isObjectExpression(property.value)) {
         mergeStaticPropertyObject(existing, property.value);
       }
     });
@@ -235,7 +248,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 +256,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 +264,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 +286,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,8 +317,8 @@ function getStaticStylesExpression(statement, functionPath) {
 
   const [argument] = statement.expression.arguments;
 
-  if (isHoistedStyles && (t$7.isFunctionExpression(argument) || t$7.isArrowFunctionExpression(argument))) {
-    throw new Error("^styles(...) only accepts static values. Move dynamic values to useStyle(...) or CSS custom properties.");
+  if (isHoistedStyles && (t$9.isFunctionExpression(argument) || t$9.isArrowFunctionExpression(argument))) {
+    throw new Error("static styles = ... only accepts static values. Move dynamic values to useStyle(...) or CSS custom properties.");
   }
 
   const template = normalizeStylesTemplate(
@@ -313,19 +326,19 @@ function getStaticStylesExpression(statement, functionPath) {
     functionPath
   );
   if (!template) {
-    throw new Error("^styles(...) only accepts static values. Move dynamic values to useStyle(...) or CSS custom properties.");
+    throw new Error("static 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_")) {
@@ -338,32 +351,32 @@ function getStaticHoistExpression(statement, functionPath) {
   }
 
   if (statement.expression.arguments.length !== 1) {
-    throw new Error(`^${name}(...) expects exactly one argument.`);
+    throw new Error(`static ${name} = ... expects exactly one argument.`);
   }
 
   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.");
+    throw new Error("static expose = ... only accepts an object literal.");
   }
 
-  if (t$7.isFunctionExpression(argument) || t$7.isArrowFunctionExpression(argument)) {
-    throw new Error(`^${name}(...) only accepts a direct static value.`);
+  if (t$9.isFunctionExpression(argument) || t$9.isArrowFunctionExpression(argument)) {
+    throw new Error(`static ${name} = ... only accepts a direct static value.`);
   }
 
   if (!isStaticStylesExpression(argument, functionPath)) {
-    throw new Error(`^${name}(...) only accepts a direct static value.`);
+    throw new Error(`static ${name} = ... only accepts a direct static value.`);
   }
 
   return {
     name,
-    expression: t$7.cloneNode(argument),
+    expression: t$9.cloneNode(argument),
   };
 }
 
@@ -376,13 +389,13 @@ 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),
     };
   }
 
-  throw new Error("^expose(...) only accepts an object literal.");
+  throw new Error("static expose = ... only accepts an object literal.");
 }
 
 function createExposeClassMethod(property) {
@@ -392,41 +405,41 @@ function createExposeClassMethod(property) {
 }
 
 function normalizeExposePropertyToClassMethod(property) {
-  if (t$7.isSpreadElement(property)) {
-    throw new Error("^expose(...) does not accept spread elements.");
+  if (t$9.isSpreadElement(property)) {
+    throw new Error("static 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.");
+      throw new Error("static 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)) {
-    throw new Error("^expose(...) only accepts plain methods.");
+  if (!t$9.isObjectProperty(property)) {
+    throw new Error("static expose = ... only accepts plain methods.");
   }
 
   const value = property.value;
-  if (!t$7.isFunctionExpression(value) && !t$7.isArrowFunctionExpression(value)) {
-    throw new Error("^expose(...) values must be functions.");
+  if (!t$9.isFunctionExpression(value) && !t$9.isArrowFunctionExpression(value)) {
+    throw new Error("static 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 +451,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;
@@ -454,7 +467,7 @@ function assertStaticHoistsStayTopLevel(functionPath) {
 
       const macroName = callPath.node.callee.name.slice("__litsx_static_".length);
       throw callPath.buildCodeFrameError(
-        `^${macroName}(...) must appear as a top-level statement in the component body.`
+        `static ${macroName} = ... must appear as a top-level statement in the component body.`
       );
     },
   });
@@ -463,8 +476,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 +492,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 +530,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 +549,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 +557,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 +634,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) {
@@ -665,8 +678,12 @@ function processStaticHoists({
     }
   }
 
-  if (lightDomRequested && staticHoists.some((entry) => entry.name === "shadowRootOptions")) {
-    throw new Error("^lightDom() cannot be combined with ^shadowRootOptions(...).");
+  if (lightDomRequested) {
+    for (let index = staticHoists.length - 1; index >= 0; index -= 1) {
+      if (staticHoists[index]?.name === "shadowRootOptions") {
+        staticHoists.splice(index, 1);
+      }
+    }
   }
 
   if (staticProps.length > 0) {
@@ -675,9 +692,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 +706,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 +773,10 @@ function processStaticHoists({
   };
 }
 
-let t$6;
+let t$8;
 
 function setHandlersBabelTypes(types) {
-  t$6 = types;
+  t$8 = types;
 }
 
 function isHoistableHandler(exprPath, componentPath) {
@@ -806,11 +823,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 +842,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 +866,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 +902,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 +924,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 +942,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 +959,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 +981,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,7 +994,7 @@ 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) {
@@ -989,7 +1006,7 @@ function isCapitalizedComponentName$1(name) {
 }
 
 function setWrapperUtilsBabelTypes(nextTypes) {
-  t$5 = nextTypes;
+  t$7 = nextTypes;
 }
 
 function emitWrapperWarnings(meta, warn) {
@@ -1044,7 +1061,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;
 
@@ -1067,7 +1084,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);
   }
 
@@ -1099,21 +1116,21 @@ 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;
     }
@@ -1144,8 +1161,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);
@@ -1154,12 +1171,12 @@ 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());
@@ -1197,8 +1214,8 @@ function handlePotentialComponentExport({
 
       exportPath.replaceWith(
         isDefault
-          ? t$5.exportDefaultDeclaration(classNode)
-          : t$5.exportNamedDeclaration(classNode, [])
+          ? t$7.exportDefaultDeclaration(classNode)
+          : t$7.exportNamedDeclaration(classNode, [])
       );
       exportPath.requeue();
       pruneWrapperImports(wrapperMeta);
@@ -1207,7 +1224,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;
@@ -1240,7 +1257,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);
@@ -1250,23 +1267,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
     ),
@@ -1274,55 +1291,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")
                   )
                 ),
               ])
@@ -1330,13 +1347,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;
   }
 
@@ -1345,46 +1362,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")
                   )
                 ),
               ])
@@ -1392,7 +1409,7 @@ function createComponentInstanceRefSyncStatement() {
           ),
         ])
       ),
-      t$4.arrayExpression([createThisMemberExpression$3("ref")]),
+      t$6.arrayExpression([createThisMemberExpression$4("ref")]),
     ])
   );
 }
@@ -1403,27 +1420,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) => {
@@ -1432,7 +1449,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
       );
     });
@@ -1451,14 +1468,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;
@@ -1470,7 +1487,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;
@@ -1482,14 +1499,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({
@@ -1501,26 +1518,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);
@@ -1535,11 +1552,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);
@@ -1557,10 +1574,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) {
@@ -1569,8 +1586,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;
@@ -1578,8 +1595,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;
@@ -1592,68 +1609,14 @@ function createComponentClass({
   return classNode;
 }
 
-let t$2;
+let t$4;
 
 function setParamRewriteBabelTypes(nextTypes) {
-  t$2 = nextTypes;
-}
-
-function createThisMemberExpression$1(propName) {
-  return t$2.memberExpression(t$2.thisExpression(), t$2.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$2.isIdentifier(node)) {
-    return localNames.includes(node.name);
-  }
-
-  if (
-    t$2.isMemberExpression(node) &&
-    !node.computed &&
-    t$2.isIdentifier(node.object)
-  ) {
-    return localNames.includes(node.object.name) && node.object.name === "props";
-  }
-
-  return false;
+  t$4 = nextTypes;
 }
 
-function getPropBackedCalleeReplacement(node, bindings) {
-  if (t$2.isIdentifier(node)) {
-    const propName = getBoundPropName(bindings.get(node.name));
-    return propName ? createThisMemberExpression$1(propName) : node;
-  }
-
-  if (
-    t$2.isMemberExpression(node) &&
-    !node.computed &&
-    t$2.isIdentifier(node.object)
-  ) {
-    const propName = getBoundPropName(bindings.get(node.object.name));
-    if (!propName) {
-      return node;
-    }
-
-    return t$2.memberExpression(
-      createThisMemberExpression$1(propName),
-      t$2.cloneNode(node.property),
-      false
-    );
-  }
-
-  return node;
+function createThisMemberExpression$2(propName) {
+  return t$4.memberExpression(t$4.thisExpression(), t$4.identifier(propName));
 }
 
 function transformJSXExpressions(jsxPath, bindings, state = null) {
@@ -1661,30 +1624,13 @@ function transformJSXExpressions(jsxPath, bindings, state = null) {
 
   jsxPath.traverse({
     JSXExpressionContainer(expressionPath) {
-      if (t$2.isCallExpression(expressionPath.node.expression)) {
-        const { callee, arguments: args } = expressionPath.node.expression;
-        if (isPropBackedCallee(callee, localNames)) {
-          if (state) {
-            state.__litsxNeedsRendererCallImport = true;
-          }
-          expressionPath.node.expression = t$2.callExpression(
-            t$2.identifier("renderRendererCall"),
-            [
-              getPropBackedCalleeReplacement(callee, bindings),
-              ...args,
-            ]
-          );
-          return;
-        }
-      }
-
-      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)
           );
         }
       }
@@ -1703,16 +1649,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") {
@@ -1720,17 +1666,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;
@@ -1739,8 +1685,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);
@@ -1773,10 +1719,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) => {
@@ -1805,7 +1751,7 @@ function replaceParamReferences(functionPath, bindings, propertyMap = new Map())
           return;
         }
 
-        refPath.replaceWith(t$2.thisExpression());
+        refPath.replaceWith(t$4.thisExpression());
         return;
       }
 
@@ -1816,7 +1762,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;
@@ -1838,7 +1784,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;
@@ -1864,7 +1810,7 @@ function replaceParamReferences(functionPath, bindings, propertyMap = new Map())
         refPath.parentKey === "value"
       ) {
         refPath.replaceWith(
-          t$2.jsxExpressionContainer(
+          t$4.jsxExpressionContainer(
             getReplacementForProp(targetProp || localName, refPath)
           )
         );
@@ -1885,12 +1831,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) {
@@ -2175,6 +2317,9 @@ function createTransformFunctionToClassPlugin(defaultPluginOptions = {}) {
     setRefsBabelTypes(t);
     setClassGenerationBabelTypes(t);
     setParamRewriteBabelTypes(t);
+    setRendererCallsBabelTypes(t);
+    transformLitsxElementCandidates.setElementCandidatesBabelTypes(t);
+    setRenderBodyBabelTypes(t);
     setProgramBabelTypes(t);
     const resolvedPluginOptions = {
       ...defaultPluginOptions,
@@ -2475,8 +2620,8 @@ function getTypeResolverForFunction(functionPath, state) {
 
 function transformFunction(functionPath, programPath, className, options = {}) {
   const { node } = functionPath;
-  const elementCandidates = collectElementCandidates(functionPath, programPath, options);
-  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;
@@ -2502,19 +2647,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, options.state ?? null);
-      }
-    },
-  });
+  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 || {}),
@@ -2524,41 +2671,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 = [];
@@ -2607,185 +2725,21 @@ function transformFunction(functionPath, programPath, className, options = {}) {
     elementCandidates.forEach((candidate) => elementSet.add(candidate));
   }
 
-  return classNode;
-}
-
-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, options = {}) {
-  const candidates = new Set();
-  if (!programPath) return candidates;
-  programPath.scope.crawl();
-  const compatPascalNames =
-    programPath.getData("__litsxCompatPascalNames") || new Set();
-
-  const availableNames = new Set();
-  const helperPaths = new Map();
-  programPath.get("body").forEach((nodePath) => {
-    if (nodePath.isImportDeclaration()) {
-      nodePath.node.specifiers.forEach((specifier) => {
-        if (specifier.local?.name) {
-          availableNames.add(specifier.local.name);
-        }
-      });
-      return;
-    }
-
-    if (nodePath.isClassDeclaration() && nodePath.node.id?.name) {
-      availableNames.add(nodePath.node.id.name);
-      return;
-    }
-
-    if (
-      (nodePath.isExportNamedDeclaration() || nodePath.isExportDefaultDeclaration()) &&
-      nodePath.get("declaration")?.isClassDeclaration?.() &&
-      nodePath.node.declaration?.id?.name
-    ) {
-      availableNames.add(nodePath.node.declaration.id.name);
-      return;
-    }
-
-    if (nodePath.isFunctionDeclaration() && nodePath.node.id?.name) {
-      availableNames.add(nodePath.node.id.name);
-      helperPaths.set(nodePath.node.id.name, nodePath);
-      return;
-    }
-
-    if (!nodePath.isVariableDeclaration()) return;
-    nodePath.get("declarations").forEach((declaratorPath) => {
-      const declarator = declaratorPath.node;
-      if (!t.isIdentifier(declarator.id)) {
-        return;
-      }
-
-      availableNames.add(declarator.id.name);
-
-      const initPath = declaratorPath.get("init");
-      if (
-        initPath?.isArrowFunctionExpression?.() ||
-        initPath?.isFunctionExpression?.()
-      ) {
-        helperPaths.set(declarator.id.name, initPath);
-      }
-    });
-  });
-
-  const helperCandidateCache = new Map();
-
-  function isCapitalizedName(name) {
-    if (typeof name !== "string" || name.length === 0) {
-      return false;
-    }
-
-    const first = name[0];
-    return first === first.toUpperCase() && first !== first.toLowerCase();
-  }
-
-  function isProgramLevelBinding(binding) {
-    return binding?.scope?.path?.isProgram?.() === true;
-  }
-
-  function maybeRewriteComponentName(nameNode, pathForErrors = null) {
-    if (!nameNode || nameNode.type !== "JSXIdentifier") return null;
-    const originalName = nameNode.__scopedOriginal || nameNode.name;
-    if (!isCapitalizedName(originalName)) return null;
-    const binding = pathForErrors?.scope?.getBinding?.(originalName) || null;
-    if (!binding) {
-      if (availableNames.has(originalName)) {
-        return originalName;
-      }
-      if (compatPascalNames.has(originalName)) {
-        return null;
-      }
-      if (options?.allowUnknownPascalCase === true) {
-        return null;
+  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);
       }
-      throw (pathForErrors?.buildCodeFrameError?.(
-        `Unknown LitSX component "${originalName}". Add an import or declare it in this module before using it in JSX.`
-      ) || new Error(
-        `Unknown LitSX component "${originalName}". Add an import or declare it in this module before using it in JSX.`
-      ));
-    }
-
-    if (!isProgramLevelBinding(binding)) {
-      return null;
-    }
-
-    return originalName;
-  }
-
-  function scanFunction(path, seen = new Set()) {
-    if (!path?.node) {
-      return new Set();
-    }
-
-    if (helperCandidateCache.has(path.node)) {
-      return new Set(helperCandidateCache.get(path.node));
-    }
-
-    if (seen.has(path.node)) {
-      return new Set();
-    }
-
-    const nextSeen = new Set(seen);
-    nextSeen.add(path.node);
-    const localCandidates = new Set();
-    const referencedHelpers = new Set();
-
-    path.traverse({
-      JSXOpeningElement(jsxPath) {
-        const candidate = maybeRewriteComponentName(jsxPath.node.name, jsxPath);
-        if (candidate) {
-          localCandidates.add(candidate);
-        }
-      },
-      JSXClosingElement(jsxPath) {
-        maybeRewriteComponentName(jsxPath.node.name, jsxPath);
-      },
-      Identifier(identifierPath) {
-        if (!identifierPath.isReferencedIdentifier()) {
-          return;
-        }
-
-        if (!helperPaths.has(identifierPath.node.name)) {
-          return;
-        }
-
-        referencedHelpers.add(identifierPath.node.name);
-      },
     });
-
-    referencedHelpers.forEach((helperName) => {
-      const helperCandidates = scanFunction(helperPaths.get(helperName), nextSeen);
-      helperCandidates.forEach((candidate) => localCandidates.add(candidate));
-    });
-
-    helperCandidateCache.set(path.node, new Set(localCandidates));
-    return localCandidates;
   }
 
-  scanFunction(functionPath).forEach((candidate) => candidates.add(candidate));
-
-  return candidates;
+  return classNode;
 }
 
 exports.createTransformFunctionToClassPlugin = createTransformFunctionToClassPlugin;