@litsx/babel-preset-litsx 0.1.0

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

@@ -0,0 +1,2518 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxSyntaxPlugin = require('@babel/plugin-syntax-jsx');
+var internal_transformLitsxProperties = require('./transform-litsx-properties.cjs');
+require('module');
+require('@litsx/typescript-session');
+
+let t$7;
+
+function setStaticHoistsBabelTypes(types) {
+  t$7 = 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" })) {
+    return false;
+  }
+  if (statement.expression.arguments.length !== 0) {
+    throw new Error("^lightDom() does not accept arguments.");
+  }
+  return true;
+}
+
+function createStaticHoistGetter(name, symbolId, expression) {
+  const getter = t$7.classMethod(
+    "get",
+    t$7.identifier(name),
+    [],
+    t$7.blockStatement([
+      t$7.returnStatement(
+        t$7.callExpression(
+          t$7.memberExpression(t$7.thisExpression(), t$7.identifier("__litsxStatic")),
+          [
+            t$7.cloneNode(symbolId),
+            t$7.arrowFunctionExpression([], expression),
+          ]
+        )
+      ),
+    ])
+  );
+  getter.static = true;
+  return getter;
+}
+
+function resolveStaticHoistExpression(expression) {
+  return t$7.callExpression(
+    t$7.memberExpression(t$7.thisExpression(), t$7.identifier("__litsxResolveStaticValue")),
+    [t$7.cloneNode(expression)]
+  );
+}
+
+function createPropertiesHoistResolver(propertiesStatic, staticProps, expression) {
+  const mergedProperties = propertiesStatic.map((property) => t$7.cloneNode(property));
+  if (staticProps.length > 0) {
+    mergeStaticPropsIntoProperties(mergedProperties, staticProps);
+  }
+
+  return t$7.callExpression(
+    t$7.memberExpression(t$7.thisExpression(), t$7.identifier("__litsxMergeProperties")),
+    [
+      t$7.objectExpression(mergedProperties),
+      resolveStaticHoistExpression(expression),
+    ]
+  );
+}
+
+function createStylesHoistResolver(staticStyles, expression) {
+  const resolvedExpression = resolveStaticHoistExpression(expression);
+  if (staticStyles.length === 0) {
+    return resolvedExpression;
+  }
+
+  const baseStyles =
+    staticStyles.length === 1
+      ? t$7.cloneNode(staticStyles[0])
+      : t$7.arrayExpression(staticStyles.map((style) => t$7.cloneNode(style)));
+
+  return t$7.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(
+    statement.expression.callee,
+    { name: "__litsx_static_properties" }
+  );
+  if (
+    !isLegacyStaticProps &&
+    !isHoistedProperties
+  ) {
+    return null;
+  }
+  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 (!t$7.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);
+}
+
+function getStaticPropertyName(node) {
+  if (t$7.isIdentifier(node)) return node.name;
+  if (t$7.isStringLiteral(node)) return node.value;
+  return null;
+}
+
+function normalizeStaticPropOverrideValue(value) {
+  if (
+    t$7.isIdentifier(value) &&
+    ["String", "Number", "Boolean", "Object", "Array", "Date"].includes(value.name)
+  ) {
+    return internal_transformLitsxProperties.createPropertyConfig(t$7.identifier(value.name));
+  }
+
+  if (t$7.isObjectExpression(value)) {
+    const typeProperty = value.properties.find(
+      (prop) =>
+        t$7.isObjectProperty(prop) &&
+        t$7.isIdentifier(prop.key, { name: "type" }) &&
+        t$7.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) &&
+        prop.value.value === false
+    );
+
+    return internal_transformLitsxProperties.createPropertyConfig(typeProperty ? typeProperty.value : null, {
+      attribute: attributeProperty ? false : undefined,
+    });
+  }
+
+  throw new Error(
+    "^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)) {
+    return;
+  }
+
+  overrideObject.properties.forEach((property) => {
+    if (!t$7.isObjectProperty(property) && !t$7.isObjectMethod(property)) {
+      throw new Error("^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.");
+    }
+
+    const existing = targetNode.value.properties.find(
+      (candidate) =>
+        (t$7.isObjectProperty(candidate) || t$7.isObjectMethod(candidate)) &&
+        getStaticPropertyName(candidate.key) === keyName
+    );
+
+    if (existing) {
+      const nextNode = t$7.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));
+    }
+  });
+}
+
+function mergeStaticPropsIntoProperties(propertiesStatic, staticProps) {
+  const propertyMap = new Map();
+
+  propertiesStatic.forEach((propertyNode) => {
+    if (!t$7.isObjectProperty(propertyNode)) return;
+    const keyName = getStaticPropertyName(propertyNode.key);
+    if (!keyName) return;
+    propertyMap.set(keyName, propertyNode);
+  });
+
+  staticProps.forEach((optionsObject) => {
+    optionsObject.properties.forEach((property) => {
+      if (!t$7.isObjectProperty(property)) {
+        throw new Error("^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.");
+      }
+
+      const existing = propertyMap.get(keyName);
+      const normalized = normalizeStaticPropOverrideValue(property.value);
+
+      if (!existing) {
+        const node = t$7.objectProperty(
+          t$7.identifier(keyName),
+          internal_transformLitsxProperties.createPropertyValue(normalized, false)
+        );
+        if (t$7.isObjectExpression(property.value)) {
+          mergeStaticPropertyObject(node, property.value);
+        }
+        propertiesStatic.push(node);
+        propertyMap.set(keyName, node);
+        return;
+      }
+
+      internal_transformLitsxProperties.mergePropertyConfig(
+        { node: existing },
+        normalized,
+        false
+      );
+
+      if (t$7.isObjectExpression(property.value)) {
+        mergeStaticPropertyObject(existing, property.value);
+      }
+    });
+  });
+}
+
+function normalizeStylesTemplate(argument, functionPath) {
+  if (t$7.isTemplateLiteral(argument)) {
+    if (
+      !argument.expressions.every((expression) =>
+        isStaticStylesExpression(expression, functionPath)
+      )
+    ) {
+      return null;
+    }
+    return t$7.templateLiteral(
+      argument.quasis,
+      argument.expressions.map((expression) =>
+        wrapStaticStylesInterpolation(expression)
+      )
+    );
+  }
+
+  if (t$7.isStringLiteral(argument)) {
+    return t$7.templateLiteral(
+      [t$7.templateElement({ raw: argument.value, cooked: argument.value }, true)],
+      []
+    );
+  }
+
+  if (isStaticStylesExpression(argument, functionPath)) {
+    return t$7.templateLiteral(
+      [
+        t$7.templateElement({ raw: "", cooked: "" }, false),
+        t$7.templateElement({ raw: "", cooked: "" }, true),
+      ],
+      [wrapStaticStylesInterpolation(argument)]
+    );
+  }
+
+  return null;
+}
+
+function wrapStaticStylesInterpolation(expression) {
+  if (
+    t$7.isTaggedTemplateExpression(expression) &&
+    t$7.isIdentifier(expression.tag, { name: "css" })
+  ) {
+    return expression;
+  }
+
+  if (t$7.isNumericLiteral(expression)) {
+    return expression;
+  }
+
+  return t$7.callExpression(
+    t$7.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 (
+    !isLegacyStaticStyles &&
+    !isHoistedStyles
+  ) {
+    return null;
+  }
+  if (statement.expression.arguments.length !== 1) return null;
+
+  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.");
+  }
+
+  const template = normalizeStylesTemplate(
+    argument,
+    functionPath
+  );
+  if (!template) {
+    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);
+  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;
+
+  const calleeName = statement.expression.callee.name;
+  if (!calleeName.startsWith("__litsx_static_")) {
+    return null;
+  }
+
+  const name = calleeName.slice("__litsx_static_".length);
+  if (!name || name === "properties" || name === "styles") {
+    return null;
+  }
+
+  if (statement.expression.arguments.length !== 1) {
+    throw new Error(`^${name}(...) expects exactly one argument.`);
+  }
+
+  const [argument] = statement.expression.arguments;
+  if (name === "expose") {
+    if (t$7.isObjectExpression(argument)) {
+      return {
+        name,
+        expression: t$7.cloneNode(argument),
+      };
+    }
+
+    throw new Error("^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 (!isStaticStylesExpression(argument, functionPath)) {
+    throw new Error(`^${name}(...) only accepts a direct static value.`);
+  }
+
+  return {
+    name,
+    expression: t$7.cloneNode(argument),
+  };
+}
+
+function createExposeHoistMembers(expression) {
+  const { methodsExpression } = normalizeExposeHoistExpression(expression);
+
+  return methodsExpression.properties.map((property) =>
+    createExposeClassMethod(property)
+  );
+}
+
+function normalizeExposeHoistExpression(expression) {
+  if (t$7.isObjectExpression(expression)) {
+    return {
+      methodsExpression: t$7.cloneNode(expression),
+    };
+  }
+
+  throw new Error("^expose(...) only accepts an object literal.");
+}
+
+function createExposeClassMethod(property) {
+  const method = normalizeExposePropertyToClassMethod(property);
+  method.static = true;
+  return method;
+}
+
+function normalizeExposePropertyToClassMethod(property) {
+  if (t$7.isSpreadElement(property)) {
+    throw new Error("^expose(...) does not accept spread elements.");
+  }
+
+  if (t$7.isObjectMethod(property)) {
+    if (property.kind !== "method") {
+      throw new Error("^expose(...) only accepts plain methods.");
+    }
+
+    return t$7.classMethod(
+      "method",
+      t$7.cloneNode(property.key),
+      property.params.map((param) => t$7.cloneNode(param)),
+      t$7.cloneNode(property.body),
+      property.computed
+    );
+  }
+
+  if (!t$7.isObjectProperty(property)) {
+    throw new Error("^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.");
+  }
+
+  const body = t$7.isBlockStatement(value.body)
+    ? t$7.cloneNode(value.body)
+    : t$7.blockStatement([t$7.returnStatement(t$7.cloneNode(value.body))]);
+
+  const method = t$7.classMethod(
+    "method",
+    t$7.cloneNode(property.key),
+    value.params.map((param) => t$7.cloneNode(param)),
+    body,
+    property.computed
+  );
+  method.async = value.async;
+  method.generator = value.generator || false;
+  return method;
+}
+
+function assertStaticHoistsStayTopLevel(functionPath) {
+  functionPath.traverse({
+    CallExpression(callPath) {
+      if (!t$7.isIdentifier(callPath.node.callee)) return;
+      if (!callPath.node.callee.name.startsWith("__litsx_static_")) return;
+
+      const statementParent = callPath.parentPath;
+      const blockParent = statementParent?.parentPath;
+
+      if (
+        statementParent?.isExpressionStatement() &&
+        blockParent?.isBlockStatement() &&
+        blockParent.node === functionPath.node.body
+      ) {
+        return;
+      }
+
+      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.`
+      );
+    },
+  });
+}
+
+function containsUnsafeCssCall(node) {
+  if (!node || typeof node !== "object") return false;
+  if (
+    t$7.isCallExpression(node) &&
+    t$7.isIdentifier(node.callee, { name: "unsafeCSS" })
+  ) {
+    return true;
+  }
+
+  return Object.values(node).some((value) => {
+    if (Array.isArray(value)) {
+      return value.some((entry) => containsUnsafeCssCall(entry));
+    }
+    return containsUnsafeCssCall(value);
+  });
+}
+
+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)
+  ) {
+    return true;
+  }
+
+  if (t$7.isTemplateLiteral(node)) {
+    return node.expressions.every((expression) =>
+      isStaticStylesExpression(expression, functionPath, seenBindings)
+    );
+  }
+
+  if (t$7.isIdentifier(node)) {
+    return isStaticStylesIdentifier(node, functionPath, seenBindings);
+  }
+
+  if (t$7.isUnaryExpression(node)) {
+    return isStaticStylesExpression(node.argument, functionPath, seenBindings);
+  }
+
+  if (t$7.isBinaryExpression(node) || t$7.isLogicalExpression(node)) {
+    return (
+      isStaticStylesExpression(node.left, functionPath, seenBindings) &&
+      isStaticStylesExpression(node.right, functionPath, seenBindings)
+    );
+  }
+
+  if (t$7.isConditionalExpression(node)) {
+    return (
+      isStaticStylesExpression(node.test, functionPath, seenBindings) &&
+      isStaticStylesExpression(node.consequent, functionPath, seenBindings) &&
+      isStaticStylesExpression(node.alternate, functionPath, seenBindings)
+    );
+  }
+
+  if (t$7.isArrayExpression(node)) {
+    return node.elements.every((element) =>
+      element == null || isStaticStylesExpression(element, functionPath, seenBindings)
+    );
+  }
+
+  if (t$7.isObjectExpression(node)) {
+    return node.properties.every((property) => {
+      if (t$7.isObjectProperty(property)) {
+        return (
+          (!property.computed ||
+            isStaticStylesExpression(property.key, functionPath, seenBindings)) &&
+          isStaticStylesExpression(property.value, functionPath, seenBindings)
+        );
+      }
+      return false;
+    });
+  }
+
+  if (t$7.isMemberExpression(node)) {
+    return (
+      isStaticStylesExpression(node.object, functionPath, seenBindings) &&
+      (!node.computed ||
+        isStaticStylesExpression(node.property, functionPath, seenBindings))
+    );
+  }
+
+  if (t$7.isCallExpression(node)) {
+    return (
+      isStaticStylesExpression(node.callee, functionPath, seenBindings) &&
+      node.arguments.every((argument) =>
+        t$7.isSpreadElement(argument)
+          ? false
+          : isStaticStylesExpression(argument, functionPath, seenBindings)
+      )
+    );
+  }
+
+  if (t$7.isTaggedTemplateExpression(node)) {
+    return (
+      isStaticStylesExpression(node.tag, functionPath, seenBindings) &&
+      isStaticStylesExpression(node.quasi, functionPath, seenBindings)
+    );
+  }
+
+  return false;
+}
+
+function isStaticStylesIdentifier(node, functionPath, seenBindings) {
+  const binding = functionPath?.scope
+    ? functionPath.scope.getBinding(node.name)
+    : null;
+
+  if (!binding) {
+    return false;
+  }
+
+  if (binding.path.findParent((parent) => parent === functionPath)) {
+    return false;
+  }
+
+  if (
+    binding.path.isImportSpecifier() ||
+    binding.path.isImportDefaultSpecifier() ||
+    binding.path.isImportNamespaceSpecifier()
+  ) {
+    return true;
+  }
+
+  if (binding.path.isVariableDeclarator()) {
+    if (binding.kind !== "const" || !binding.path.node.init) {
+      return false;
+    }
+
+    if (seenBindings.has(binding)) {
+      return true;
+    }
+
+    seenBindings.add(binding);
+    return isStaticStylesExpression(binding.path.node.init, functionPath, seenBindings);
+  }
+
+  if (binding.path.isFunctionDeclaration() || binding.path.isClassDeclaration()) {
+    return true;
+  }
+
+  return false;
+}
+
+function processStaticHoists({
+  functionPath,
+  node,
+  renderStatements,
+  programPath,
+  propertiesStatic,
+  classMembers,
+  options = {},
+  getOrCreateModuleStaticHoistSymbol,
+}) {
+  const staticStyles = [];
+  const staticProps = [];
+  const staticHoists = [];
+  let lightDomRequested = options.defaultDomMode === "light";
+
+  if (t$7.isBlockStatement(node.body)) {
+    for (let index = renderStatements.length - 1; index >= 0; index -= 1) {
+      const propertyOptions = getStaticPropsExpression(renderStatements[index]);
+      if (propertyOptions) {
+        if (propertyOptions.__litsxHoistedProperties) {
+          staticHoists.unshift({
+            name: "properties",
+            expression: propertyOptions.expression,
+          });
+        } else {
+          staticProps.unshift(propertyOptions);
+        }
+        renderStatements.splice(index, 1);
+        continue;
+      }
+
+      const cssExpression = getStaticStylesExpression(renderStatements[index], functionPath);
+      if (!cssExpression) continue;
+      if (cssExpression.__litsxHoistedStyles) {
+        staticHoists.unshift({
+          name: "styles",
+          expression: cssExpression.expression,
+        });
+      } else {
+        staticStyles.unshift(cssExpression);
+      }
+      renderStatements.splice(index, 1);
+    }
+
+    for (let index = renderStatements.length - 1; index >= 0; index -= 1) {
+      if (isLightDomHoist(renderStatements[index])) {
+        lightDomRequested = true;
+        renderStatements.splice(index, 1);
+      }
+    }
+
+    for (let index = renderStatements.length - 1; index >= 0; index -= 1) {
+      const hoistExpression = getStaticHoistExpression(renderStatements[index], functionPath);
+      if (!hoistExpression) continue;
+      staticHoists.unshift(hoistExpression);
+      renderStatements.splice(index, 1);
+    }
+  }
+
+  if (lightDomRequested && staticHoists.some((entry) => entry.name === "shadowRootOptions")) {
+    throw new Error("^lightDom() cannot be combined with ^shadowRootOptions(...).");
+  }
+
+  if (staticProps.length > 0) {
+    mergeStaticPropsIntoProperties(propertiesStatic, staticProps);
+  }
+
+  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),
+      null,
+      [],
+      false
+    );
+
+    classProperties.static = true;
+    classMembers.push(classProperties);
+  }
+
+  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),
+      null,
+      [],
+      false
+    );
+    stylesProperty.static = true;
+    classMembers.push(stylesProperty);
+  }
+
+  const hoistSymbolDeclarations = [];
+  let needsStaticHoistsMixin = false;
+  const hoistMembers = staticHoists.flatMap((hoist) => {
+    if (hoist.name === "expose") {
+      return createExposeHoistMembers(hoist.expression);
+    }
+
+    needsStaticHoistsMixin = true;
+    const { symbolId, declaration } = getOrCreateModuleStaticHoistSymbol(programPath, hoist.name);
+    if (declaration) {
+      hoistSymbolDeclarations.push(declaration);
+      const symbolMap = programPath.getData("__litsxStaticHoistSymbols");
+      if (symbolMap?.has(hoist.name)) {
+        symbolMap.set(hoist.name, { symbolId, declaration: null });
+      }
+    }
+
+    if (hoist.name === "properties") {
+      return createStaticHoistGetter(
+        "properties",
+        symbolId,
+        createPropertiesHoistResolver(propertiesStatic, staticProps, hoist.expression)
+      );
+    }
+
+    if (hoist.name === "styles") {
+      return createStaticHoistGetter(
+        "styles",
+        symbolId,
+        createStylesHoistResolver(staticStyles, hoist.expression)
+      );
+    }
+
+    return createStaticHoistGetter(
+      hoist.name,
+      symbolId,
+      resolveStaticHoistExpression(hoist.expression)
+    );
+  });
+
+  return {
+    lightDomRequested,
+    hoistMembers,
+    hoistSymbolDeclarations,
+    needsStaticHoistsMixin,
+    needsCss:
+      staticStyles.length > 0 ||
+      staticHoists.some((entry) => entry.name === "styles"),
+    needsUnsafeCss:
+      staticStyles.some(containsUnsafeCssCall) ||
+      staticHoists.some(
+        (entry) => entry.name === "styles" && containsUnsafeCssCall(entry.expression)
+      ),
+  };
+}
+
+let t$6;
+
+function setHandlersBabelTypes(types) {
+  t$6 = types;
+}
+
+function isHoistableHandler(exprPath, componentPath) {
+  let hoistable = true;
+
+  exprPath.traverse({
+    Identifier(identifierPath) {
+      if (!identifierPath.isReferencedIdentifier()) return;
+
+      const name = identifierPath.node.name;
+      const ownBinding = exprPath.scope.getOwnBinding(name);
+      if (ownBinding) return;
+
+      const binding = identifierPath.scope.getBinding(name);
+      if (!binding) return;
+
+      if (binding.scope === componentPath.scope) {
+        hoistable = false;
+        identifierPath.stop();
+      }
+    },
+  });
+
+  return hoistable;
+}
+
+function ensureUniqueHandlerName(baseName, usedNames) {
+  let candidate = baseName;
+  let suffix = 2;
+
+  while (usedNames.has(candidate)) {
+    candidate = `${baseName}${suffix}`;
+    suffix += 1;
+  }
+
+  usedNames.add(candidate);
+  return candidate;
+}
+
+function generateHandlerName(attrName, usedNames) {
+  const eventSegment = attrName.slice(2) || "Event";
+  const base = `handle${eventSegment}`;
+  return ensureUniqueHandlerName(base, usedNames);
+}
+
+function normalizeHandlerBody(body) {
+  if (t$6.isBlockStatement(body)) {
+    return t$6.cloneNode(body, true);
+  }
+
+  return t$6.blockStatement([t$6.returnStatement(t$6.cloneNode(body, true))]);
+}
+
+function hoistDeclaredHandlers(functionPath, usedNames) {
+  const handlerInfos = [];
+  const bodyPath = functionPath.get("body");
+  if (!bodyPath.isBlockStatement()) {
+    return handlerInfos;
+  }
+
+  functionPath.traverse({
+    VariableDeclarator(path) {
+      if (path.getFunctionParent() !== functionPath) return;
+
+      const id = path.node.id;
+      if (!t$6.isIdentifier(id)) return;
+
+      const initPath = path.get("init");
+      if (!initPath.isArrowFunctionExpression() && !initPath.isFunctionExpression()) {
+        return;
+      }
+
+      const statementParent = path.getStatementParent();
+      if (!statementParent || statementParent.parentPath !== bodyPath) {
+        return;
+      }
+
+      if (!isHoistableHandler(initPath, functionPath)) return;
+
+      const originalName = id.name;
+      usedNames.delete(originalName);
+      const handlerName = ensureUniqueHandlerName(originalName, usedNames);
+      const binding = path.scope.getBinding(originalName);
+
+      if (!binding) return;
+
+      binding.referencePaths.slice().forEach((refPath) => {
+        if (!refPath.node || refPath.removed) return;
+        refPath.replaceWith(
+          t$6.memberExpression(t$6.thisExpression(), t$6.identifier(handlerName))
+        );
+      });
+
+      handlerInfos.push({
+        name: handlerName,
+        params: initPath.node.params.map((param) => t$6.cloneNode(param, true)),
+        body: normalizeHandlerBody(initPath.node.body),
+        async: initPath.node.async,
+        generator: initPath.node.generator,
+      });
+
+      path.remove();
+
+      if (
+        statementParent.isVariableDeclaration() &&
+        statementParent.node.declarations.length === 0
+      ) {
+        statementParent.remove();
+      }
+
+      binding.scope.removeBinding(originalName);
+    },
+  });
+
+  return handlerInfos;
+}
+
+function hoistEventHandlers(functionPath, usedNames) {
+  const handlerInfos = [];
+
+  functionPath.traverse({
+    JSXAttribute(attrPath) {
+      if (attrPath.getFunctionParent() !== functionPath) return;
+
+      const { node } = attrPath;
+      if (!t$6.isJSXIdentifier(node.name)) return;
+
+      const attrName = node.name.name;
+      if (!/^on[A-Z]/.test(attrName)) return;
+
+      const valuePath = attrPath.get("value");
+      if (!valuePath.isJSXExpressionContainer()) return;
+
+      const exprPath = valuePath.get("expression");
+      if (
+        !exprPath.isArrowFunctionExpression() &&
+        !exprPath.isFunctionExpression()
+      ) {
+        return;
+      }
+
+      if (!isHoistableHandler(exprPath, functionPath)) return;
+
+      const handlerName = generateHandlerName(attrName, usedNames);
+
+      handlerInfos.push({
+        name: handlerName,
+        params: exprPath.node.params.map((param) => t$6.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))
+        )
+      );
+    },
+  });
+
+  return handlerInfos;
+}
+
+function isNativeIntrinsicJsxElement(nameNode) {
+  return t$6.isJSXIdentifier(nameNode) && /^[a-z]/.test(nameNode.name);
+}
+
+function collectNativeClassNameWarnings(functionPath, warn, options = {}) {
+  if (typeof warn !== "function" || options.suppressNativeClassNameWarning === true) {
+    return;
+  }
+
+  functionPath.traverse({
+    JSXAttribute(attrPath) {
+      if (attrPath.getFunctionParent() !== functionPath) return;
+
+      const openingElement = attrPath.parentPath;
+      if (!openingElement?.isJSXOpeningElement()) return;
+      if (!isNativeIntrinsicJsxElement(openingElement.node.name)) return;
+
+      const { node } = attrPath;
+      if (!t$6.isJSXIdentifier(node.name, { name: "className" })) return;
+
+      warn({
+        code: "LITSX_NATIVE_CLASSNAME",
+        message:
+          '`className` is not native LitSX syntax. Use `class` in native LitSX, or add the React compatibility layer to rewrite `className`.',
+        attributeName: "className",
+        tagName: openingElement.node.name.name,
+        line: node.loc?.start?.line ?? null,
+        column: node.loc?.start?.column ?? null,
+      });
+    },
+  });
+}
+
+function processHandlers(functionPath, usedNames) {
+  const declaredHandlers = hoistDeclaredHandlers(functionPath, usedNames);
+  const inlineHandlers = hoistEventHandlers(functionPath, usedNames);
+  return [...declaredHandlers, ...inlineHandlers];
+}
+
+function createHandlerClassMember({ name, params, body, async, generator }) {
+  const method = t$6.classMethod(
+    "method",
+    t$6.identifier(name),
+    params.map((param) => t$6.cloneNode(param, true)),
+    t$6.cloneNode(body, true)
+  );
+
+  method.async = Boolean(async);
+  method.generator = Boolean(generator);
+
+  return method;
+}
+
+let t$5;
+
+function setWrapperUtilsBabelTypes(nextTypes) {
+  t$5 = nextTypes;
+}
+
+function emitWrapperWarnings(meta, warn) {
+  if (!meta || typeof warn !== "function" || !Array.isArray(meta.warnings)) {
+    return;
+  }
+
+  meta.warnings.forEach((warning) => warn(warning));
+}
+
+function pruneWrapperImports(meta) {
+  if (!meta || !Array.isArray(meta.cleanups)) {
+    return;
+  }
+
+  meta.cleanups.forEach((cleanup) => {
+    if (!cleanup || !cleanup.shouldRemoveImport || !cleanup.importSpecifierPath) {
+      return;
+    }
+    const importDecl = cleanup.importSpecifierPath.parentPath;
+    cleanup.importSpecifierPath.remove();
+    if (importDecl.node.specifiers.length === 0) {
+      importDecl.remove();
+    }
+  });
+}
+
+function maybeTransformWrappedVariableDeclarator({
+  varPath,
+  resolvedPluginOptions,
+  state,
+  transformFunction,
+  updateTransformState,
+  getWrapperMetadata,
+}) {
+  if (typeof getWrapperMetadata !== "function") {
+    return false;
+  }
+
+  const initPath = varPath.get("init");
+  if (!initPath || !initPath.isCallExpression()) {
+    return false;
+  }
+
+  const wrapperMeta = getWrapperMetadata(initPath);
+  if (!wrapperMeta) {
+    return false;
+  }
+
+  emitWrapperWarnings(wrapperMeta, (warning) => {
+    state?.__litsxWarnings?.push(warning);
+  });
+
+  const programPath = varPath.findParent((p) => p.isProgram());
+  const localName = t$5.isIdentifier(varPath.node.id)
+    ? varPath.node.id.name
+    : undefined;
+
+  const classNode = transformFunction(
+    wrapperMeta.functionPath,
+    programPath,
+    localName,
+    {
+      ...resolvedPluginOptions,
+      ...wrapperMeta.options,
+      typeResolver: state?.__litsxTypeResolver,
+      warn: (warning) => {
+        state?.__litsxWarnings?.push(warning);
+      },
+    }
+  );
+
+  if (!classNode) {
+    return true;
+  }
+
+  if (t$5.isIdentifier(varPath.node.id)) {
+    varPath.scope.removeBinding(varPath.node.id.name);
+  }
+
+  const declarationPath = varPath.parentPath;
+  if (!declarationPath.isVariableDeclaration()) {
+    return true;
+  }
+
+  declarationPath.replaceWith(classNode);
+  declarationPath.requeue();
+  pruneWrapperImports(wrapperMeta);
+  updateTransformState?.(state, classNode);
+  return true;
+}
+
+function handlePotentialComponentExport({
+  exportPath,
+  state,
+  isDefault = false,
+  transformFunction,
+  isInsideFunctionOrClass,
+  updateTransformState,
+  getWrapperMetadata,
+}) {
+  const declaration = exportPath.node.declaration;
+  const typeResolver = state?.__litsxTypeResolver || null;
+  if (!declaration || isInsideFunctionOrClass(exportPath)) {
+    return false;
+  }
+
+  if (
+    t$5.isFunctionDeclaration(declaration) ||
+    (t$5.isVariableDeclaration(declaration) &&
+      declaration.declarations.length === 1 &&
+      t$5.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) {
+      exportName = declaration.id.name;
+    } else if (
+      t$5.isVariableDeclaration(declaration) &&
+      t$5.isIdentifier(declaration.declarations[0].id)
+    ) {
+      exportName = declaration.declarations[0].id.name;
+    }
+
+    const classNode = transformFunction(
+      declarationPath,
+      exportPath.findParent((p) => p.isProgram()),
+      exportName,
+      {
+        ...state?.__litsxResolvedPluginOptions,
+        typeResolver,
+        warn: (warning) => {
+          state?.__litsxWarnings?.push(warning);
+        },
+      }
+    );
+
+    if (!classNode) return true;
+
+    if (exportName) {
+      exportPath.scope.removeBinding(exportName);
+    }
+
+    exportPath.insertBefore(
+      isDefault
+        ? t$5.exportDefaultDeclaration(classNode)
+        : t$5.exportNamedDeclaration(classNode, [])
+    );
+    exportPath.remove();
+    updateTransformState?.(state, classNode);
+    return true;
+  }
+
+  if (
+    typeof getWrapperMetadata === "function" &&
+    t$5.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)
+      ? declaratorPath.node.id.name
+      : undefined;
+    const programPath = exportPath.findParent((p) => p.isProgram());
+
+    if (initPath.isCallExpression()) {
+      const wrapperMeta = getWrapperMetadata(initPath);
+      if (!wrapperMeta) return false;
+      emitWrapperWarnings(wrapperMeta, (warning) => {
+        state?.__litsxWarnings?.push(warning);
+      });
+
+      const classNode = transformFunction(
+        wrapperMeta.functionPath,
+        programPath,
+        exportName,
+        {
+          ...state?.__litsxResolvedPluginOptions,
+          ...wrapperMeta.options,
+          typeResolver,
+          warn: (warning) => {
+            state?.__litsxWarnings?.push(warning);
+          },
+        }
+      );
+      if (!classNode) return true;
+
+      if (exportName) {
+        exportPath.scope.removeBinding(exportName);
+      }
+
+      exportPath.replaceWith(t$5.exportNamedDeclaration(classNode, []));
+      exportPath.requeue();
+      pruneWrapperImports(wrapperMeta);
+      updateTransformState?.(state, classNode);
+      return true;
+    }
+  }
+
+  if (typeof getWrapperMetadata === "function" && isDefault && t$5.isCallExpression(declaration)) {
+    const callPath = exportPath.get("declaration");
+    const wrapperMeta = getWrapperMetadata(callPath);
+    if (!wrapperMeta) return false;
+    emitWrapperWarnings(wrapperMeta, (warning) => {
+      state?.__litsxWarnings?.push(warning);
+    });
+
+    const programPath = exportPath.findParent((p) => p.isProgram());
+    const inferredName = wrapperMeta.functionPath.node.id
+      ? wrapperMeta.functionPath.node.id.name
+      : undefined;
+
+    const classNode = transformFunction(
+      wrapperMeta.functionPath,
+      programPath,
+      inferredName,
+      {
+        ...state?.__litsxResolvedPluginOptions,
+        ...wrapperMeta.options,
+        typeResolver,
+        warn: (warning) => {
+          state?.__litsxWarnings?.push(warning);
+        },
+      }
+    );
+    if (!classNode) return true;
+
+    exportPath.replaceWith(t$5.exportDefaultDeclaration(classNode));
+    exportPath.requeue();
+    pruneWrapperImports(wrapperMeta);
+    updateTransformState?.(state, classNode);
+    return true;
+  }
+
+  return false;
+}
+
+let t$4;
+
+function setRefsBabelTypes(nextTypes) {
+  t$4 = nextTypes;
+}
+
+function createThisMemberExpression$3(propName) {
+  return t$4.memberExpression(t$4.thisExpression(), t$4.identifier(propName));
+}
+
+function createManagedRefLookupExpression(refName) {
+  const selectorLiteral = t$4.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"),
+      false,
+      true
+    ),
+    [selectorLiteral],
+    false
+  );
+
+  const hostQuery = t$4.callExpression(
+    t$4.memberExpression(t$4.thisExpression(), t$4.identifier("querySelector")),
+    [t$4.cloneNode(selectorLiteral)]
+  );
+
+  return t$4.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)
+            ),
+          ]),
+          t$4.ifStatement(
+            t$4.binaryExpression(
+              "===",
+              t$4.unaryExpression("typeof", t$4.identifier("componentRef")),
+              t$4.stringLiteral("function")
+            ),
+            t$4.blockStatement([
+              t$4.expressionStatement(
+                t$4.callExpression(t$4.identifier("componentRef"), [t$4.identifier("node")])
+              ),
+            ]),
+            t$4.ifStatement(
+              t$4.logicalExpression(
+                "&&",
+                t$4.identifier("componentRef"),
+                t$4.binaryExpression(
+                  "===",
+                  t$4.unaryExpression("typeof", t$4.identifier("componentRef")),
+                  t$4.stringLiteral("object")
+                )
+              ),
+              t$4.blockStatement([
+                t$4.expressionStatement(
+                  t$4.assignmentExpression(
+                    "=",
+                    t$4.memberExpression(t$4.identifier("componentRef"), t$4.identifier("current")),
+                    t$4.identifier("node")
+                  )
+                ),
+              ])
+            )
+          ),
+        ])
+      ),
+      t$4.arrayExpression([createThisMemberExpression$3(propName)]),
+    ])
+  );
+}
+
+function isStandardElementJsxName(nameNode) {
+  if (!t$4.isJSXIdentifier(nameNode)) {
+    return false;
+  }
+
+  const name = nameNode.name || "";
+  return Boolean(name) && name[0] === name[0].toLowerCase() && !name.includes("-");
+}
+
+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")
+            ),
+          ]),
+          t$4.ifStatement(
+            t$4.binaryExpression(
+              "===",
+              t$4.unaryExpression("typeof", t$4.identifier("componentRef")),
+              t$4.stringLiteral("function")
+            ),
+            t$4.blockStatement([
+              t$4.expressionStatement(
+                t$4.callExpression(t$4.identifier("componentRef"), [t$4.identifier("node")])
+              ),
+            ]),
+            t$4.ifStatement(
+              t$4.logicalExpression(
+                "&&",
+                t$4.identifier("componentRef"),
+                t$4.binaryExpression(
+                  "===",
+                  t$4.unaryExpression("typeof", t$4.identifier("componentRef")),
+                  t$4.stringLiteral("object")
+                )
+              ),
+              t$4.blockStatement([
+                t$4.expressionStatement(
+                  t$4.assignmentExpression(
+                    "=",
+                    t$4.memberExpression(t$4.identifier("componentRef"), t$4.identifier("current")),
+                    t$4.identifier("node")
+                  )
+                ),
+              ])
+            )
+          ),
+        ])
+      ),
+      t$4.arrayExpression([createThisMemberExpression$3("ref")]),
+    ])
+  );
+}
+
+function hasRefProp(functionPath) {
+  const [firstParam] = functionPath.node.params || [];
+  if (!firstParam) {
+    return false;
+  }
+
+  if (t$4.isObjectPattern(firstParam)) {
+    return firstParam.properties.some((property) => {
+      if (!t$4.isObjectProperty(property)) return false;
+      return (
+        t$4.isIdentifier(property.key, { name: "ref" }) ||
+        t$4.isStringLiteral(property.key, { value: "ref" })
+      );
+    });
+  }
+
+  if (t$4.isAssignmentPattern(firstParam) && t$4.isObjectPattern(firstParam.left)) {
+    return firstParam.left.properties.some((property) => {
+      if (!t$4.isObjectProperty(property)) return false;
+      return (
+        t$4.isIdentifier(property.key, { name: "ref" }) ||
+        t$4.isStringLiteral(property.key, { value: "ref" })
+      );
+    });
+  }
+
+  if (t$4.isIdentifier(firstParam)) {
+    const binding = functionPath.scope.getBinding(firstParam.name);
+    if (!binding) return false;
+    return binding.referencePaths.some((refPath) => {
+      const parentPath = refPath.parentPath;
+      return Boolean(
+        parentPath &&
+        parentPath.isMemberExpression() &&
+        parentPath.node.object === refPath.node &&
+        t$4.isIdentifier(parentPath.node.property, { name: "ref" }) &&
+        !parentPath.node.computed
+      );
+    });
+  }
+
+  return false;
+}
+
+function lowerForwardedElementRefs(functionPath, propName) {
+  if (!propName) {
+    return [];
+  }
+
+  const callbackStatements = [];
+  const seenRefNames = new Set();
+
+  functionPath.traverse({
+    JSXAttribute(attrPath) {
+      if (!t$4.isJSXIdentifier(attrPath.node.name, { name: "ref" })) return;
+
+      const value = attrPath.node.value;
+      if (!t$4.isJSXExpressionContainer(value)) return;
+      if (
+        !t$4.isMemberExpression(value.expression) ||
+        !t$4.isThisExpression(value.expression.object) ||
+        !t$4.isIdentifier(value.expression.property, { name: propName }) ||
+        value.expression.computed
+      ) {
+        return;
+      }
+
+      const openingElement = attrPath.parentPath;
+      if (!openingElement?.isJSXOpeningElement()) return;
+      if (!isStandardElementJsxName(openingElement.node.name)) return;
+
+      const managedRefName = functionPath.scope.generateUidIdentifier(`${propName}Element`).name;
+      attrPath.replaceWith(
+        t$4.jsxAttribute(t$4.jsxIdentifier("data-ref"), t$4.stringLiteral(managedRefName))
+      );
+
+      if (seenRefNames.has(managedRefName)) return;
+      seenRefNames.add(managedRefName);
+      callbackStatements.push(createForwardedTargetRefSyncStatement(propName, managedRefName));
+    },
+  });
+
+  return callbackStatements;
+}
+
+let t$3;
+
+function setClassGenerationBabelTypes(nextTypes) {
+  t$3 = nextTypes;
+}
+
+function createThisMemberExpression$2(propName) {
+  return t$3.memberExpression(t$3.thisExpression(), t$3.identifier(propName));
+}
+
+function buildClassMembers({
+  classMembers = [],
+  defaults,
+  renderStatements,
+  handlerInfos,
+  createHandlerClassMember,
+}) {
+  if (defaults.size > 0) {
+    const constructorStatements = [
+      t$3.expressionStatement(t$3.callExpression(t$3.super(), [])),
+    ];
+
+    defaults.forEach((defaultExpression, propName) => {
+      constructorStatements.push(
+        t$3.expressionStatement(
+          t$3.assignmentExpression(
+            "??=",
+            createThisMemberExpression$2(propName),
+            t$3.cloneNode(defaultExpression)
+          )
+        )
+      );
+    });
+
+    const constructorMethod = t$3.classMethod(
+      "constructor",
+      t$3.identifier("constructor"),
+      [],
+      t$3.blockStatement(constructorStatements)
+    );
+
+    const insertionIndex = classMembers.findIndex((member) => !member.static);
+    if (insertionIndex === -1) {
+      classMembers.push(constructorMethod);
+    } else {
+      classMembers.splice(insertionIndex, 0, constructorMethod);
+    }
+  }
+
+  const handlerMembers = handlerInfos.map((handler) =>
+    createHandlerClassMember(handler)
+  );
+
+  const renderMethod = t$3.classMethod(
+    "method",
+    t$3.identifier("render"),
+    [],
+    t$3.blockStatement(renderStatements)
+  );
+
+  classMembers.push(...handlerMembers, renderMethod);
+  return classMembers;
+}
+
+function createComponentClass({
+  className,
+  classMembers,
+  hoistMembers,
+  hoistSymbolDeclarations,
+  needsStaticHoistsMixin,
+  lightDomRequested,
+  needsCss,
+  needsUnsafeCss,
+  needsCallbackRef = false,
+}) {
+  const classNode = t$3.classDeclaration(
+    t$3.identifier(className),
+    t$3.identifier("LitElement"),
+    t$3.classBody(classMembers)
+  );
+
+  if (hoistMembers.length > 0) {
+    classNode.body.body.unshift(...hoistMembers);
+    if (hoistSymbolDeclarations.length > 0) {
+      classNode._litsxStaticSymbolDeclarations = hoistSymbolDeclarations;
+    }
+    if (needsStaticHoistsMixin) {
+      classNode.superClass = t$3.callExpression(
+        t$3.identifier("LitsxStaticHoistsMixin"),
+        [classNode.superClass]
+      );
+      classNode._needsStaticHoistsMixin = true;
+    }
+  }
+
+  if (lightDomRequested) {
+    classNode.superClass = t$3.callExpression(
+      t$3.identifier("LightDomMixin"),
+      [classNode.superClass]
+    );
+    classNode._needsLightDomMixin = true;
+  }
+
+  classNode._needsCss = needsCss;
+  classNode._needsUnsafeCss = needsUnsafeCss;
+  classNode._litsxLightDom = lightDomRequested;
+  classNode._needsCallbackRef = needsCallbackRef;
+  return classNode;
+}
+
+let t$2;
+
+function setParamRewriteBabelTypes(nextTypes) {
+  t$2 = nextTypes;
+}
+
+function createThisMemberExpression$1(propName) {
+  return t$2.memberExpression(t$2.thisExpression(), t$2.identifier(propName));
+}
+
+function transformJSXExpressions(jsxPath, bindings) {
+  const localNames = Array.from(bindings.keys());
+
+  jsxPath.traverse({
+    JSXExpressionContainer(expressionPath) {
+      if (t$2.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)
+          );
+        }
+      }
+    },
+  });
+}
+
+function registerLocalPropAliases(functionPath, bindings) {
+  let changed = true;
+
+  while (changed) {
+    changed = false;
+
+    functionPath.traverse({
+      VariableDeclarator(path) {
+        if (path.getFunctionParent() !== functionPath) return;
+
+        const { id, init } = path.node;
+        if (!t$2.isIdentifier(init)) return;
+
+        if (t$2.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;
+
+        const bindingInfo = bindings.get(init.name);
+        if (!bindingInfo || typeof bindingInfo !== "object" || bindingInfo.kind !== "alias") {
+          return;
+        }
+
+        id.properties.forEach((property) => {
+          if (!t$2.isObjectProperty(property)) return;
+
+          const keyName = t$2.isIdentifier(property.key)
+            ? property.key.name
+            : t$2.isStringLiteral(property.key)
+              ? property.key.value
+              : null;
+
+          if (!keyName || !bindingInfo.properties.has(keyName)) return;
+
+          if (t$2.isIdentifier(property.value)) {
+            if (!bindings.has(property.value.name)) {
+              bindings.set(property.value.name, keyName);
+              changed = true;
+            }
+            return;
+          }
+
+          if (
+            t$2.isAssignmentPattern(property.value) &&
+            t$2.isIdentifier(property.value.left) &&
+            !bindings.has(property.value.left.name)
+          ) {
+            bindings.set(property.value.left.name, keyName);
+            changed = true;
+          }
+        });
+      },
+    });
+  }
+}
+
+function shouldCapturePropReference(refPath, functionPath) {
+  const functionParent = refPath.getFunctionParent();
+  if (!functionParent || functionParent === functionPath) {
+    return false;
+  }
+
+  return !functionParent.isArrowFunctionExpression();
+}
+
+function replaceParamReferences(functionPath, bindings, propertyMap = new Map()) {
+  registerLocalPropAliases(functionPath, bindings);
+
+  const capturedPropAliases = new Map();
+
+  function getReplacementForProp(propName, refPath) {
+    if (shouldCapturePropReference(refPath, functionPath)) {
+      let aliasId = capturedPropAliases.get(propName);
+      if (!aliasId) {
+        aliasId = functionPath.scope.generateUidIdentifier(propName);
+        capturedPropAliases.set(propName, aliasId);
+      }
+      return t$2.cloneNode(aliasId);
+    }
+
+    return t$2.memberExpression(t$2.thisExpression(), t$2.identifier(propName));
+  }
+
+  bindings.forEach((bindingInfo, localName) => {
+    if (!localName) return;
+    const binding = functionPath.scope.getBinding(localName);
+    if (!binding) return;
+
+    binding.referencePaths.slice().forEach((refPath) => {
+      if (!refPath.node) return;
+
+      if (
+        bindingInfo &&
+        typeof bindingInfo === "object" &&
+        bindingInfo.kind === "alias" &&
+        (!refPath.parentPath || !refPath.parentPath.isMemberExpression())
+      ) {
+        if (shouldCapturePropReference(refPath, functionPath)) {
+          return;
+        }
+
+        if (
+          refPath.parentPath &&
+          refPath.parentPath.isObjectProperty({ shorthand: true }) &&
+          refPath.parentKey === "value"
+        ) {
+          return;
+        }
+
+        refPath.replaceWith(t$2.thisExpression());
+        return;
+      }
+
+      if (
+        bindingInfo &&
+        typeof bindingInfo === "object" &&
+        bindingInfo.kind === "alias" &&
+        refPath.parentPath &&
+        refPath.parentPath.isMemberExpression() &&
+        refPath.parentKey === "object" &&
+        t$2.isIdentifier(refPath.parentPath.node.property) &&
+        !refPath.parentPath.node.computed
+      ) {
+        const propName = refPath.parentPath.node.property.name;
+        if (bindingInfo.properties.has(propName)) {
+          refPath.parentPath.replaceWith(getReplacementForProp(propName, refPath));
+          return;
+        }
+      }
+
+      let targetProp;
+      if (typeof bindingInfo === "string") {
+        targetProp = bindingInfo;
+      } else if (bindingInfo && typeof bindingInfo === "object") {
+        targetProp = bindingInfo.bindKey;
+      }
+
+      if (
+        typeof bindingInfo === "string" &&
+        refPath.parentPath &&
+        refPath.parentPath.isMemberExpression() &&
+        refPath.parentKey === "object" &&
+        t$2.isIdentifier(refPath.parentPath.node.property) &&
+        !refPath.parentPath.node.computed
+      ) {
+        const propName = refPath.parentPath.node.property.name;
+        if (localName === "props" || propertyMap.has(propName)) {
+          refPath.parentPath.replaceWith(getReplacementForProp(propName, refPath));
+          return;
+        }
+      }
+
+      if (
+        refPath.parentPath &&
+        refPath.parentPath.isObjectProperty({ shorthand: true }) &&
+        refPath.parentKey === "value"
+      ) {
+        refPath.parentPath.node.shorthand = false;
+        refPath.replaceWith(getReplacementForProp(targetProp || localName, refPath));
+        return;
+      }
+
+      if (
+        refPath.parentPath &&
+        refPath.parentPath.isJSXAttribute() &&
+        refPath.parentKey === "value"
+      ) {
+        refPath.replaceWith(
+          t$2.jsxExpressionContainer(
+            getReplacementForProp(targetProp || localName, refPath)
+          )
+        );
+        return;
+      }
+
+      if (refPath.parentPath && refPath.parentPath.isMemberExpression()) {
+        if (
+          refPath.parentKey === "property" &&
+          !refPath.parentPath.node.computed
+        ) {
+          return;
+        }
+      }
+
+      refPath.replaceWith(getReplacementForProp(targetProp || localName, refPath));
+    });
+  });
+
+  return Array.from(capturedPropAliases.entries()).map(([propName, aliasId]) =>
+    t$2.variableDeclaration("const", [
+      t$2.variableDeclarator(t$2.cloneNode(aliasId), createThisMemberExpression$1(propName)),
+    ])
+  );
+}
+
+let t$1;
+
+function setProgramBabelTypes(nextTypes) {
+  t$1 = nextTypes;
+}
+
+function createLitElementImport() {
+  return t$1.importDeclaration(
+    [
+      t$1.importSpecifier(t$1.identifier("LitElement"), t$1.identifier("LitElement")),
+    ],
+    t$1.stringLiteral("lit")
+  );
+}
+
+function createLitsxInfrastructureImport(importedName) {
+  return t$1.importDeclaration(
+    [
+      t$1.importSpecifier(t$1.identifier(importedName), t$1.identifier(importedName)),
+    ],
+    t$1.stringLiteral("litsx/runtime-infrastructure")
+  );
+}
+
+function createLitsxImport(importedName) {
+  return t$1.importDeclaration(
+    [
+      t$1.importSpecifier(t$1.identifier(importedName), t$1.identifier(importedName)),
+    ],
+    t$1.stringLiteral("litsx")
+  );
+}
+
+function ensureNamedImport(importPath, importedName) {
+  const specifiers = importPath.node.specifiers;
+
+  if (
+    specifiers.some(
+      (specifier) =>
+        t$1.isImportSpecifier(specifier) &&
+        t$1.isIdentifier(specifier.imported, { name: importedName })
+    )
+  ) {
+    return true;
+  }
+
+  if (specifiers.some((specifier) => t$1.isImportNamespaceSpecifier(specifier))) {
+    return false;
+  }
+
+  specifiers.push(
+    t$1.importSpecifier(t$1.identifier(importedName), t$1.identifier(importedName))
+  );
+  return true;
+}
+
+function pruneUnusedLitsxStaticImports(programPath) {
+  programPath.scope.crawl();
+
+  const bodyPaths = programPath.get("body");
+  const litsxImports = bodyPaths.filter(
+    (path) => path.isImportDeclaration() && path.node.source.value === "litsx"
+  );
+
+  litsxImports.forEach((importPath) => {
+    const removableSpecifiers = importPath.get("specifiers").filter((specifierPath) => {
+      if (!specifierPath.isImportSpecifier()) return false;
+      if (!t$1.isIdentifier(specifierPath.node.imported)) return false;
+
+      const importedName = specifierPath.node.imported.name;
+      if (importedName !== "staticStyles" && importedName !== "staticProps") {
+        return false;
+      }
+
+      const localName = t$1.isIdentifier(specifierPath.node.local)
+        ? specifierPath.node.local.name
+        : importedName;
+      const binding = specifierPath.scope.getBinding(localName);
+      return !binding || binding.referencePaths.length === 0;
+    });
+
+    removableSpecifiers.forEach((specifierPath) => {
+      specifierPath.remove();
+    });
+
+    if (importPath.node.specifiers.length === 0) {
+      importPath.remove();
+    }
+  });
+}
+
+function finalizeProgram(programPath, state) {
+  if (!state?.__litsxTransformCount) {
+    return;
+  }
+
+  const hoistDeclarations = [];
+  for (const bodyPath of programPath.get("body")) {
+    const node = bodyPath.isClassDeclaration()
+      ? bodyPath.node
+      : bodyPath.isVariableDeclaration()
+        ? bodyPath.node
+        : bodyPath.isExportNamedDeclaration() || bodyPath.isExportDefaultDeclaration()
+          ? bodyPath.node.declaration
+          : null;
+
+    if (!node) {
+      continue;
+    }
+
+    if (t$1.isClassDeclaration(node) && Array.isArray(node._litsxStaticSymbolDeclarations)) {
+      hoistDeclarations.push(...node._litsxStaticSymbolDeclarations);
+      continue;
+    }
+
+    if (t$1.isVariableDeclaration(node)) {
+      node.declarations.forEach((declarator) => {
+        if (Array.isArray(declarator.init?._litsxStaticSymbolDeclarations)) {
+          hoistDeclarations.push(...declarator.init._litsxStaticSymbolDeclarations);
+        }
+      });
+    }
+  }
+
+  if (hoistDeclarations.length > 0) {
+    programPath.unshiftContainer("body", hoistDeclarations);
+  }
+
+  const bodyPaths = programPath.get("body");
+  const litImports = bodyPaths.filter(
+    (n) => n.isImportDeclaration() && n.node.source.value === "lit"
+  );
+
+  let litElementImported = false;
+
+  litImports.some((importPath) => {
+    if (ensureNamedImport(importPath, "LitElement")) {
+      litElementImported = true;
+      return true;
+    }
+
+    return false;
+  });
+
+  if (!litElementImported) {
+    programPath.unshiftContainer("body", createLitElementImport());
+  }
+
+  if (state.__litsxNeedsCss) {
+    const nextBodyPaths = programPath.get("body");
+    const nextLitImports = nextBodyPaths.filter(
+      (n) => n.isImportDeclaration() && n.node.source.value === "lit"
+    );
+    nextLitImports.some((importPath) => ensureNamedImport(importPath, "css"));
+  }
+
+  if (state.__litsxNeedsUnsafeCss) {
+    const nextBodyPaths = programPath.get("body");
+    const nextLitImports = nextBodyPaths.filter(
+      (n) => n.isImportDeclaration() && n.node.source.value === "lit"
+    );
+    nextLitImports.some((importPath) => ensureNamedImport(importPath, "unsafeCSS"));
+  }
+
+  if (state.__litsxNeedsStaticHoistsMixin) {
+    const bodyPathsWithInternal = programPath.get("body");
+    const internalImports = bodyPathsWithInternal.filter(
+      (n) => n.isImportDeclaration() && n.node.source.value === "litsx/runtime-infrastructure"
+    );
+
+    let internalImported = false;
+    internalImports.some((importPath) => {
+      if (ensureNamedImport(importPath, "LitsxStaticHoistsMixin")) {
+        internalImported = true;
+        return true;
+      }
+
+      return false;
+    });
+
+    if (!internalImported) {
+      programPath.unshiftContainer("body", createLitsxInfrastructureImport("LitsxStaticHoistsMixin"));
+    }
+  }
+
+  if (state.__litsxNeedsLightDomMixin) {
+    const bodyPathsWithInternal = programPath.get("body");
+    const internalImports = bodyPathsWithInternal.filter(
+      (n) => n.isImportDeclaration() && n.node.source.value === "litsx/runtime-infrastructure"
+    );
+
+    let internalImported = false;
+    internalImports.some((importPath) => {
+      if (ensureNamedImport(importPath, "LightDomMixin")) {
+        internalImported = true;
+        return true;
+      }
+
+      return false;
+    });
+
+    if (!internalImported) {
+      programPath.unshiftContainer("body", createLitsxInfrastructureImport("LightDomMixin"));
+    }
+  }
+
+  if (state.__litsxNeedsCallbackRef) {
+    const bodyPathsWithLitsx = programPath.get("body");
+    const litsxImports = bodyPathsWithLitsx.filter(
+      (n) => n.isImportDeclaration() && n.node.source.value === "litsx"
+    );
+
+    let litsxImported = false;
+    litsxImports.some((importPath) => {
+      if (ensureNamedImport(importPath, "useCallbackRef")) {
+        litsxImported = true;
+        return true;
+      }
+
+      return false;
+    });
+
+    if (!litsxImported) {
+      programPath.unshiftContainer("body", createLitsxImport("useCallbackRef"));
+    }
+  }
+
+  pruneUnusedLitsxStaticImports(programPath);
+}
+
+let t;
+
+function createTransformFunctionToClassPlugin(defaultPluginOptions = {}) {
+  return function transformFunctionToClassPlugin(_api, pluginOptions = {}) {
+    internal_transformLitsxProperties.ensureTypescriptModule();
+    t = _api.types;
+    internal_transformLitsxProperties.setPropertyBabelTypes(t);
+    setStaticHoistsBabelTypes(t);
+    setHandlersBabelTypes(t);
+    setWrapperUtilsBabelTypes(t);
+    setRefsBabelTypes(t);
+    setClassGenerationBabelTypes(t);
+    setParamRewriteBabelTypes(t);
+    setProgramBabelTypes(t);
+    const resolvedPluginOptions = {
+      ...defaultPluginOptions,
+      ...pluginOptions,
+    };
+
+    const getWrapperMetadata =
+      typeof resolvedPluginOptions.getWrapperMetadata === "function"
+        ? resolvedPluginOptions.getWrapperMetadata
+        : null;
+
+    return {
+      name: "transform-function-to-class",
+      inherits: jsxSyntaxPlugin.default || jsxSyntaxPlugin,
+      pre() {
+        this.__litsxTransformCount = 0;
+        this.__litsxNeedsCss = false;
+        this.__litsxNeedsUnsafeCss = false;
+        this.__litsxNeedsStaticHoistsMixin = false;
+        this.__litsxNeedsLightDomMixin = false;
+        this.__litsxNeedsCallbackRef = false;
+        this.__litsxWarnings = [];
+        this.__litsxResolvedPluginOptions = resolvedPluginOptions;
+        this.__litsxTypeResolver = fileLikelyNeedsTypeResolver(this)
+          ? internal_transformLitsxProperties.createTypeResolver(
+              this.file?.opts?.filename,
+              this.file?.code,
+              resolvedPluginOptions
+            )
+          : undefined;
+      },
+      post() {
+        if (!this.file) return;
+        this.file.metadata ||= {};
+        this.file.metadata.litsxWarnings = this.__litsxWarnings || [];
+      },
+      visitor: {
+        Program: {
+          exit(programPath) {
+            finalizeProgram(programPath, this);
+          },
+        },
+        ExportNamedDeclaration(exportPath) {
+          handlePotentialComponentExport({
+            exportPath,
+            state: this,
+            transformFunction,
+            isInsideFunctionOrClass,
+            updateTransformState,
+            getWrapperMetadata,
+          });
+        },
+        ExportDefaultDeclaration(exportPath) {
+          handlePotentialComponentExport({
+            exportPath,
+            state: this,
+            isDefault: true,
+            transformFunction,
+            isInsideFunctionOrClass,
+            updateTransformState,
+            getWrapperMetadata,
+          });
+        },
+        VariableDeclarator(varPath) {
+          if (
+            varPath.findParent(
+              (p) => p.isExportNamedDeclaration?.() || p.isExportDefaultDeclaration?.()
+            )
+          ) {
+            return;
+          }
+
+          const initPath = varPath.get("init");
+
+          if (
+            maybeTransformWrappedVariableDeclarator({
+              varPath,
+              resolvedPluginOptions,
+              state: this,
+              transformFunction,
+              updateTransformState,
+              getWrapperMetadata,
+            })
+          ) {
+            return;
+          }
+
+          if (initPath && initPath.isArrowFunctionExpression() && !isInsideFunctionOrClass(varPath)) {
+            const programPath = varPath.findParent((p) => p.isProgram());
+            const elementCandidates = collectElementCandidates(initPath, programPath);
+            const classNode = transformFunction(
+              initPath,
+              programPath,
+              varPath.node.id.name,
+              {
+                ...resolvedPluginOptions,
+                typeResolver: getTypeResolverForFunction(initPath, this),
+                warn: (warning) => {
+                  this.__litsxWarnings.push(warning);
+                },
+              }
+            );
+
+            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;
+
+            varPath.scope.removeBinding(varPath.node.id.name);
+            declarationPath.replaceWith(classNode);
+            declarationPath.requeue();
+            updateTransformState(this, classNode);
+          }
+        },
+        FunctionDeclaration(funcPath) {
+          if (!isInsideFunctionOrClass(funcPath)) {
+            const programPath = funcPath.findParent((p) => p.isProgram());
+            const elementCandidates = collectElementCandidates(funcPath, programPath);
+            const classNode = transformFunction(
+              funcPath,
+              programPath,
+              undefined,
+              {
+                ...resolvedPluginOptions,
+                typeResolver: getTypeResolverForFunction(funcPath, this),
+                warn: (warning) => {
+                  this.__litsxWarnings.push(warning);
+                },
+              }
+            );
+
+            if (!classNode) return;
+
+            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);
+          }
+        },
+      },
+    };
+  };
+}
+
+var transformLitsxComponents = createTransformFunctionToClassPlugin();
+
+function getOrCreateModuleStaticHoistSymbol(programPath, hoistName) {
+  let symbolMap = programPath.getData("__litsxStaticHoistSymbols");
+  if (!symbolMap) {
+    symbolMap = new Map();
+    programPath.setData("__litsxStaticHoistSymbols", symbolMap);
+  }
+
+  if (symbolMap.has(hoistName)) {
+    return symbolMap.get(hoistName);
+  }
+
+  const symbolId = programPath.scope.generateUidIdentifier(`litsx_static_${hoistName}`);
+  const declaration = t.variableDeclaration("const", [
+    t.variableDeclarator(
+      symbolId,
+      t.callExpression(t.identifier("Symbol"), [t.stringLiteral(`litsx.static.${hoistName}`)])
+    ),
+  ]);
+
+  const entry = { symbolId, declaration };
+  symbolMap.set(hoistName, entry);
+  return entry;
+}
+
+
+function updateTransformState(state, classNode) {
+  if (!state || !classNode) {
+    return;
+  }
+
+  state.__litsxTransformCount = (state.__litsxTransformCount || 0) + 1;
+  state.__litsxNeedsCss ||= Boolean(classNode._needsCss);
+  state.__litsxNeedsUnsafeCss ||= Boolean(classNode._needsUnsafeCss);
+  state.__litsxNeedsStaticHoistsMixin ||= Boolean(
+    classNode._needsStaticHoistsMixin
+  );
+  state.__litsxNeedsLightDomMixin ||= Boolean(
+    classNode._needsLightDomMixin
+  );
+  state.__litsxNeedsCallbackRef ||= Boolean(
+    classNode._needsCallbackRef
+  );
+}
+
+// Verifica si el nodo está dentro de otra función o clase
+function isInsideFunctionOrClass(path) {
+  return path.findParent(
+    (p) => p.isFunctionDeclaration() || p.isFunctionExpression() || p.isArrowFunctionExpression() || p.isClassDeclaration()
+  );
+}
+
+function getOrCreateTypeResolver(state) {
+  if (state.__litsxTypeResolver !== undefined) {
+    return state.__litsxTypeResolver;
+  }
+
+  state.__litsxTypeResolver = internal_transformLitsxProperties.createTypeResolver(
+    state.file?.opts?.filename,
+    state.file?.code,
+    state.__litsxResolvedPluginOptions
+  );
+  return state.__litsxTypeResolver;
+}
+
+function fileLikelyNeedsTypeResolver(state) {
+  const filename = state?.file?.opts?.filename || "";
+  if (/\.(?:[cm]?ts|tsx)$/i.test(filename)) {
+    return true;
+  }
+
+  const source = state?.file?.code || "";
+  return /\b(?:type|interface|enum)\b/.test(source);
+}
+
+function functionNeedsTypeResolver(functionPath, state) {
+  const params = functionPath.get("params");
+  if (!Array.isArray(params) || params.length === 0) {
+    return false;
+  }
+
+  if (fileLikelyNeedsTypeResolver(state)) {
+    return true;
+  }
+
+  return params.some((paramPath) => containsTypeResolutionSyntax(paramPath));
+}
+
+function containsTypeResolutionSyntax(path) {
+  if (!path?.node) {
+    return false;
+  }
+
+  if (
+    path.isIdentifier?.() ||
+    path.isObjectPattern?.() ||
+    path.isArrayPattern?.() ||
+    path.isAssignmentPattern?.()
+  ) {
+    if (path.node.typeAnnotation) {
+      return true;
+    }
+  }
+
+  if (path.isAssignmentPattern?.()) {
+    return containsTypeResolutionSyntax(path.get("left"));
+  }
+
+  if (path.isObjectPattern?.()) {
+    return path.get("properties").some((propertyPath) => {
+      if (propertyPath.isRestElement()) {
+        return containsTypeResolutionSyntax(propertyPath.get("argument"));
+      }
+      if (propertyPath.isObjectProperty()) {
+        return containsTypeResolutionSyntax(propertyPath.get("value"));
+      }
+      return false;
+    });
+  }
+
+  if (path.isArrayPattern?.()) {
+    return path.get("elements").some((elementPath) => {
+      if (!elementPath?.node) return false;
+      return containsTypeResolutionSyntax(elementPath);
+    });
+  }
+
+  return false;
+}
+
+function getTypeResolverForFunction(functionPath, state) {
+  if (!functionNeedsTypeResolver(functionPath, state)) {
+    return null;
+  }
+
+  return getOrCreateTypeResolver(state);
+}
+
+function transformFunction(functionPath, programPath, className, options = {}) {
+  const { node } = functionPath;
+  const forwardRefOptions = options.forwardRef || null;
+  let resolvedName = className;
+  if (!resolvedName && node && node.id && t.isIdentifier(node.id)) {
+    resolvedName = node.id.name;
+  }
+  if (!resolvedName) {
+    resolvedName = "AnonymousComponent";
+  }
+
+  className = resolvedName;
+
+  const {
+    properties: propertiesStatic,
+    propertyNames,
+    bindings,
+    defaults,
+    nestedInitializers,
+  } = internal_transformLitsxProperties.extractProperties(
+    functionPath,
+    programPath,
+    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);
+      }
+    },
+  });
+
+  if (!returnStatement) return;
+
+  const capturedPropAliasStatements = replaceParamReferences(functionPath, bindings, propertyNames);
+
+  const usedNames = new Set([
+    ...Object.keys(functionPath.scope.bindings || {}),
+    "render",
+    "properties",
+    "constructor",
+  ]);
+
+  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);
+  }
+
+  const classMembers = [];
+
+  const {
+    lightDomRequested,
+    hoistMembers,
+    hoistSymbolDeclarations,
+    needsStaticHoistsMixin,
+    needsCss,
+    needsUnsafeCss,
+  } = processStaticHoists({
+    functionPath,
+    node,
+    renderStatements,
+    programPath,
+    propertiesStatic,
+    classMembers,
+    options,
+    getOrCreateModuleStaticHoistSymbol,
+  });
+
+  buildClassMembers({
+    classMembers,
+    defaults,
+    renderStatements,
+    handlerInfos,
+    createHandlerClassMember,
+  });
+
+  return createComponentClass({
+    className,
+    classMembers,
+    hoistMembers,
+    hoistSymbolDeclarations,
+    needsStaticHoistsMixin,
+    lightDomRequested,
+    needsCss,
+    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);
+      }
+    });
+  });
+
+  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;
+}
+
+exports.createTransformFunctionToClassPlugin = createTransformFunctionToClassPlugin;
+exports.default = transformLitsxComponents;
+//# sourceMappingURL=transform-litsx-components.cjs.map