@eslint-react/core 1.46.1-next.0 → 1.47.0-beta.2

package/dist/index.js

@@ -1,12 +1,11 @@
 'use strict';
 
-var AST6 = require('@eslint-react/ast');
+var AST8 = require('@eslint-react/ast');
 var eff = require('@eslint-react/eff');
-var JSX3 = require('@eslint-react/jsx');
 var kit = require('@eslint-react/kit');
 var shared = require('@eslint-react/shared');
 var types = require('@typescript-eslint/types');
-var VAR = require('@eslint-react/var');
+var VAR3 = require('@eslint-react/var');
 var tsPattern = require('ts-pattern');
 var birecord = require('birecord');
 
@@ -30,9 +29,8 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var AST6__namespace = /*#__PURE__*/_interopNamespace(AST6);
-var JSX3__namespace = /*#__PURE__*/_interopNamespace(JSX3);
-var VAR__namespace = /*#__PURE__*/_interopNamespace(VAR);
+var AST8__namespace = /*#__PURE__*/_interopNamespace(AST8);
+var VAR3__namespace = /*#__PURE__*/_interopNamespace(VAR3);
 var birecord__default = /*#__PURE__*/_interopDefault(birecord);
 
 var __defProp = Object.defineProperty;
@@ -1429,7 +1427,7 @@ function getRequireExpressionArguments(node) {
 }
 function isInitializedFromReact(name, importSource, initialScope) {
   if (name.toLowerCase() === "react") return true;
-  const latestDef = VAR__namespace.findVariable(name, initialScope)?.defs.at(-1);
+  const latestDef = VAR3__namespace.findVariable(name, initialScope)?.defs.at(-1);
   if (latestDef == null) return false;
   const { node, parent } = latestDef;
   if (node.type === types.AST_NODE_TYPES.VariableDeclarator && node.init != null) {
@@ -1442,7 +1440,7 @@ function isInitializedFromReact(name, importSource, initialScope) {
     }
     const args = getRequireExpressionArguments(init);
     const arg0 = args?.[0];
-    if (arg0 == null || !AST6__namespace.isLiteral(arg0, "string")) {
+    if (arg0 == null || !AST8__namespace.isLiteral(arg0, "string")) {
       return false;
     }
     return arg0.value === importSource || arg0.value.startsWith(`${importSource}/`);
@@ -1507,7 +1505,7 @@ function isCallFromReactObject(objectName, propertyName) {
   });
 }
 function isInstanceIdEqual(context, a, b) {
-  return AST6__namespace.isNodeEqual(a, b) || VAR__namespace.isNodeValueEqual(a, b, [
+  return AST8__namespace.isNodeEqual(a, b) || VAR3__namespace.isNodeValueEqual(a, b, [
     context.sourceCode.getScope(a),
     context.sourceCode.getScope(b)
   ]);
@@ -1552,10 +1550,10 @@ function isReactHookName(name) {
   return name === "use" || /^use[A-Z0-9]/.test(name);
 }
 
-// src/hook/is.ts
+// src/hook/hook-is.ts
 function isReactHook(node) {
   if (node == null) return false;
-  const id = AST6__namespace.getFunctionIdentifier(node);
+  const id = AST8__namespace.getFunctionIdentifier(node);
   return id?.name != null && isReactHookName(id.name);
 }
 function isReactHookCall(node) {
@@ -1653,23 +1651,12 @@ var isUseStateCall = eff.flip(isReactHookCallWithName)("useState");
 var isUseSyncExternalStoreCall = eff.flip(isReactHookCallWithName)("useSyncExternalStore");
 var isUseTransitionCall = eff.flip(isReactHookCallWithName)("useTransition");
 
-// src/hook/hierarchy.ts
-function isFunctionOfUseEffectSetup(node) {
-  if (node == null) return false;
-  return node.parent?.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee !== node && node.parent.callee.type === types.AST_NODE_TYPES.Identifier && node.parent.arguments.at(0) === node && isUseEffectCallLoose(node.parent);
-}
-function isFunctionOfUseEffectCleanup(node) {
-  if (node == null) return false;
-  const returnStatement = AST6__namespace.findParentNode(node, AST6__namespace.is(types.AST_NODE_TYPES.ReturnStatement));
-  const enclosingFunction = AST6__namespace.findParentNode(node, AST6__namespace.isFunction);
-  const functionOfReturnStatement = AST6__namespace.findParentNode(returnStatement, AST6__namespace.isFunction);
-  return enclosingFunction === functionOfReturnStatement && isFunctionOfUseEffectSetup(enclosingFunction);
-}
+// src/hook/hook-collector.ts
 function useHookCollector() {
   const hooks = /* @__PURE__ */ new Map();
   const functionEntries = [];
   const onFunctionEnter = (node) => {
-    const id = AST6__namespace.getFunctionIdentifier(node);
+    const id = AST8__namespace.getFunctionIdentifier(node);
     const key = shared.getId();
     const name = id?.name;
     if (name != null && isReactHookName(name)) {
@@ -1717,11 +1704,256 @@ function useHookCollector() {
   };
   return { ctx, listeners };
 }
+function isFunctionOfUseEffectSetup(node) {
+  if (node == null) return false;
+  return node.parent?.type === types.AST_NODE_TYPES.CallExpression && node.parent.callee !== node && node.parent.callee.type === types.AST_NODE_TYPES.Identifier && node.parent.arguments.at(0) === node && isUseEffectCallLoose(node.parent);
+}
+function isFunctionOfUseEffectCleanup(node) {
+  if (node == null) return false;
+  const returnStatement = AST8__namespace.findParentNode(node, AST8__namespace.is(types.AST_NODE_TYPES.ReturnStatement));
+  const enclosingFunction = AST8__namespace.findParentNode(node, AST8__namespace.isFunction);
+  const functionOfReturnStatement = AST8__namespace.findParentNode(returnStatement, AST8__namespace.isFunction);
+  return enclosingFunction === functionOfReturnStatement && isFunctionOfUseEffectSetup(enclosingFunction);
+}
+function stringifyJsx(node) {
+  switch (node.type) {
+    case types.AST_NODE_TYPES.JSXIdentifier:
+      return node.name;
+    case types.AST_NODE_TYPES.JSXNamespacedName:
+      return `${node.namespace.name}:${node.name.name}`;
+    case types.AST_NODE_TYPES.JSXMemberExpression:
+      return `${stringifyJsx(node.object)}.${stringifyJsx(node.property)}`;
+    case types.AST_NODE_TYPES.JSXText:
+      return node.value;
+    case types.AST_NODE_TYPES.JSXOpeningElement:
+      return `<${stringifyJsx(node.name)}>`;
+    case types.AST_NODE_TYPES.JSXClosingElement:
+      return `</${stringifyJsx(node.name)}>`;
+    case types.AST_NODE_TYPES.JSXOpeningFragment:
+      return "<>";
+    case types.AST_NODE_TYPES.JSXClosingFragment:
+      return "</>";
+  }
+}
+
+// src/jsx/jsx-attribute-name.ts
+function getAttributeName(context, node) {
+  return stringifyJsx(node.name);
+}
+
+// src/jsx/jsx-attribute.ts
+function getAttribute(context, name, attributes, initialScope) {
+  return attributes.findLast((attr) => {
+    if (attr.type === types.AST_NODE_TYPES.JSXAttribute) {
+      return getAttributeName(context, attr) === name;
+    }
+    if (initialScope == null) return false;
+    switch (attr.argument.type) {
+      case types.AST_NODE_TYPES.Identifier: {
+        const variable = VAR3__namespace.findVariable(attr.argument.name, initialScope);
+        const variableNode = VAR3__namespace.getVariableInitNode(variable, 0);
+        if (variableNode?.type === types.AST_NODE_TYPES.ObjectExpression) {
+          return VAR3__namespace.findPropertyInProperties(name, variableNode.properties, initialScope) != null;
+        }
+        return false;
+      }
+      case types.AST_NODE_TYPES.ObjectExpression:
+        return VAR3__namespace.findPropertyInProperties(name, attr.argument.properties, initialScope) != null;
+    }
+    return false;
+  });
+}
+function getAttributeValue(context, node, name) {
+  const initialScope = context.sourceCode.getScope(node);
+  switch (node.type) {
+    case types.AST_NODE_TYPES.JSXAttribute:
+      if (node.value?.type === types.AST_NODE_TYPES.Literal) {
+        return {
+          kind: "some",
+          node: node.value,
+          initialScope,
+          value: node.value.value
+        };
+      }
+      if (node.value?.type === types.AST_NODE_TYPES.JSXExpressionContainer) {
+        return VAR3__namespace.toStaticValue({
+          kind: "lazy",
+          node: node.value.expression,
+          initialScope
+        });
+      }
+      return { kind: "none", node, initialScope };
+    case types.AST_NODE_TYPES.JSXSpreadAttribute: {
+      const staticValue = VAR3__namespace.toStaticValue({
+        kind: "lazy",
+        node: node.argument,
+        initialScope
+      });
+      if (staticValue.kind === "none") {
+        return staticValue;
+      }
+      return tsPattern.match(staticValue.value).with({ [name]: tsPattern.P.select(tsPattern.P.any) }, (value) => ({
+        kind: "some",
+        node: node.argument,
+        initialScope,
+        value
+      })).otherwise(() => ({ kind: "none", node, initialScope }));
+    }
+    default:
+      return { kind: "none", node, initialScope };
+  }
+}
+
+// src/jsx/jsx-detection-hint.ts
+var JSXDetectionHint = {
+  None: 0n,
+  SkipUndefined: 1n << 0n,
+  SkipNullLiteral: 1n << 1n,
+  SkipBooleanLiteral: 1n << 2n,
+  SkipStringLiteral: 1n << 3n,
+  SkipNumberLiteral: 1n << 4n,
+  SkipBigIntLiteral: 1n << 5n,
+  SkipEmptyArray: 1n << 6n,
+  SkipCreateElement: 1n << 7n,
+  StrictArray: 1n << 8n,
+  StrictLogical: 1n << 9n,
+  StrictConditional: 1n << 10n
+};
+var DEFAULT_JSX_DETECTION_HINT = 0n | JSXDetectionHint.SkipUndefined | JSXDetectionHint.SkipBooleanLiteral;
+
+// src/jsx/jsx-detection.ts
+function isJsxText(node) {
+  if (node == null) return false;
+  return node.type === types.AST_NODE_TYPES.JSXText || node.type === types.AST_NODE_TYPES.Literal;
+}
+function isJsxLike(code, node, hint = DEFAULT_JSX_DETECTION_HINT) {
+  if (node == null) return false;
+  if (AST8__namespace.isJSX(node)) return true;
+  switch (node.type) {
+    case types.AST_NODE_TYPES.Literal: {
+      switch (typeof node.value) {
+        case "boolean":
+          return !(hint & JSXDetectionHint.SkipBooleanLiteral);
+        case "string":
+          return !(hint & JSXDetectionHint.SkipStringLiteral);
+        case "number":
+          return !(hint & JSXDetectionHint.SkipNumberLiteral);
+        case "bigint":
+          return !(hint & JSXDetectionHint.SkipBigIntLiteral);
+      }
+      if (node.value == null) {
+        return !(hint & JSXDetectionHint.SkipNullLiteral);
+      }
+      return false;
+    }
+    case types.AST_NODE_TYPES.TemplateLiteral: {
+      return !(hint & JSXDetectionHint.SkipStringLiteral);
+    }
+    case types.AST_NODE_TYPES.ArrayExpression: {
+      if (hint & JSXDetectionHint.StrictArray) {
+        return node.elements.every((n) => isJsxLike(code, n, hint));
+      }
+      return node.elements.some((n) => isJsxLike(code, n, hint));
+    }
+    case types.AST_NODE_TYPES.LogicalExpression: {
+      if (hint & JSXDetectionHint.StrictLogical) {
+        return isJsxLike(code, node.left, hint) && isJsxLike(code, node.right, hint);
+      }
+      return isJsxLike(code, node.left, hint) || isJsxLike(code, node.right, hint);
+    }
+    case types.AST_NODE_TYPES.ConditionalExpression: {
+      let leftHasJSX2 = function(node2) {
+        if (Array.isArray(node2.consequent)) {
+          if (node2.consequent.length === 0) {
+            return !(hint & JSXDetectionHint.SkipEmptyArray);
+          }
+          if (hint & JSXDetectionHint.StrictArray) {
+            return node2.consequent.every((n) => isJsxLike(code, n, hint));
+          }
+          return node2.consequent.some((n) => isJsxLike(code, n, hint));
+        }
+        return isJsxLike(code, node2.consequent, hint);
+      }, rightHasJSX2 = function(node2) {
+        return isJsxLike(code, node2.alternate, hint);
+      };
+      if (hint & JSXDetectionHint.StrictConditional) {
+        return leftHasJSX2(node) && rightHasJSX2(node);
+      }
+      return leftHasJSX2(node) || rightHasJSX2(node);
+    }
+    case types.AST_NODE_TYPES.SequenceExpression: {
+      const exp = node.expressions.at(-1);
+      return isJsxLike(code, exp, hint);
+    }
+    case types.AST_NODE_TYPES.CallExpression: {
+      if (hint & JSXDetectionHint.SkipCreateElement) {
+        return false;
+      }
+      switch (node.callee.type) {
+        case types.AST_NODE_TYPES.Identifier:
+          return node.callee.name === "createElement";
+        case types.AST_NODE_TYPES.MemberExpression:
+          return node.callee.property.type === types.AST_NODE_TYPES.Identifier && node.callee.property.name === "createElement";
+      }
+      return false;
+    }
+    case types.AST_NODE_TYPES.Identifier: {
+      const { name } = node;
+      if (name === "undefined") {
+        return !(hint & JSXDetectionHint.SkipUndefined);
+      }
+      if (AST8__namespace.isJSXTagNameExpression(node)) {
+        return true;
+      }
+      const variable = VAR3__namespace.findVariable(name, code.getScope(node));
+      const variableNode = variable && VAR3__namespace.getVariableInitNode(variable, 0);
+      return !!variableNode && isJsxLike(code, variableNode, hint);
+    }
+  }
+  return false;
+}
+function getElementType(context, node) {
+  if (node.type === types.AST_NODE_TYPES.JSXFragment) {
+    return "";
+  }
+  return stringifyJsx(node.openingElement.name);
+}
+
+// src/jsx/jsx-has.ts
+function hasAttribute(context, name, attributes, initialScope) {
+  return getAttribute(context, name, attributes, initialScope) != null;
+}
+function hasAnyAttribute(context, names, attributes, initialScope) {
+  return names.some((n) => hasAttribute(context, n, attributes, initialScope));
+}
+function hasEveryAttribute(context, names, attributes, initialScope) {
+  return names.every((n) => hasAttribute(context, n, attributes, initialScope));
+}
+function findParentAttribute(node, test = eff.constTrue) {
+  const guard = (node2) => {
+    return node2.type === types.AST_NODE_TYPES.JSXAttribute && test(node2);
+  };
+  return AST8__namespace.findParentNode(node, guard);
+}
+function isHostElement(context, node) {
+  return node.type === types.AST_NODE_TYPES.JSXElement && node.openingElement.name.type === types.AST_NODE_TYPES.JSXIdentifier && /^[a-z]/u.test(node.openingElement.name.name);
+}
+function isKeyedElement(context, node, initialScope) {
+  return node.type === types.AST_NODE_TYPES.JSXElement && hasAttribute(context, "key", node.openingElement.attributes, initialScope);
+}
+function isFragmentElement(context, node, allowJSXFragment = false) {
+  if (node == null) return false;
+  if (node.type !== types.AST_NODE_TYPES.JSXElement && node.type !== types.AST_NODE_TYPES.JSXFragment) return false;
+  if (node.type === types.AST_NODE_TYPES.JSXFragment) return allowJSXFragment;
+  return getElementType(context, node).split(".").at(-1) === "Fragment";
+}
+
+// src/component/component-detection-hint.ts
 var ComponentDetectionHint = {
   /**
    * 1n << 0n - 1n << 63n are reserved for JSXDetectionHint
    */
-  ...JSX3__namespace.JSXDetectionHint,
+  ...JSXDetectionHint,
   /**
    * Skip function component created by React.memo
    */
@@ -1748,85 +1980,83 @@ var ComponentDetectionHint = {
   SkipClassProperty: 1n << 69n
 };
 var DEFAULT_COMPONENT_DETECTION_HINT = 0n | ComponentDetectionHint.SkipBooleanLiteral | ComponentDetectionHint.SkipEmptyArray | ComponentDetectionHint.SkipArrayMapArgument | ComponentDetectionHint.SkipNumberLiteral | ComponentDetectionHint.SkipStringLiteral | ComponentDetectionHint.SkipUndefined | ComponentDetectionHint.StrictArray | ComponentDetectionHint.StrictConditional | ComponentDetectionHint.StrictLogical;
+function isClassComponent(node) {
+  if ("superClass" in node && node.superClass != null) {
+    const re = /^(?:Pure)?Component$/u;
+    switch (true) {
+      case node.superClass.type === types.AST_NODE_TYPES.Identifier:
+        return re.test(node.superClass.name);
+      case (node.superClass.type === types.AST_NODE_TYPES.MemberExpression && node.superClass.property.type === types.AST_NODE_TYPES.Identifier):
+        return re.test(node.superClass.property.name);
+    }
+  }
+  return false;
+}
+function isPureComponent(node) {
+  if ("superClass" in node && node.superClass != null) {
+    const re = /^PureComponent$/u;
+    switch (true) {
+      case node.superClass.type === types.AST_NODE_TYPES.Identifier:
+        return re.test(node.superClass.name);
+      case (node.superClass.type === types.AST_NODE_TYPES.MemberExpression && node.superClass.property.type === types.AST_NODE_TYPES.Identifier):
+        return re.test(node.superClass.property.name);
+    }
+  }
+  return false;
+}
 function isComponentDidCatch(node) {
-  return AST6__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidCatch";
+  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidCatch";
 }
 function isComponentDidMount(node) {
-  return AST6__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
+  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
 }
 function isComponentDidUpdate(node) {
-  return AST6__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidUpdate";
+  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidUpdate";
 }
 function isComponentWillMount(node) {
-  return AST6__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillMount";
+  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillMount";
 }
 function isComponentWillReceiveProps(node) {
-  return AST6__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillReceiveProps";
+  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillReceiveProps";
 }
 function isComponentWillUnmount(node) {
-  return AST6__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillUnmount";
+  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillUnmount";
 }
 function isComponentWillUpdate(node) {
-  return AST6__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillUpdate";
+  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillUpdate";
 }
 function isGetChildContext(node) {
-  return AST6__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getChildContext";
+  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getChildContext";
 }
 function isGetDefaultProps(node) {
-  return AST6__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDefaultProps";
+  return AST8__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDefaultProps";
 }
 function isGetInitialState(node) {
-  return AST6__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getInitialState";
+  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getInitialState";
 }
 function isGetSnapshotBeforeUpdate(node) {
-  return AST6__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getSnapshotBeforeUpdate";
+  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getSnapshotBeforeUpdate";
 }
 function isShouldComponentUpdate(node) {
-  return AST6__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
+  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
 }
 function isUnsafeComponentWillMount(node) {
-  return AST6__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillMount";
+  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillMount";
 }
 function isUnsafeComponentWillReceiveProps(node) {
-  return AST6__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillReceiveProps";
+  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillReceiveProps";
 }
 function isUnsafeComponentWillUpdate(node) {
-  return AST6__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillUpdate";
+  return AST8__namespace.isMethodOrProperty(node) && !node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillUpdate";
 }
 function isGetDerivedStateFromProps(node) {
-  return AST6__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromProps";
+  return AST8__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromProps";
 }
 function isGetDerivedStateFromError(node) {
-  return AST6__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromError";
+  return AST8__namespace.isMethodOrProperty(node) && node.static && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "getDerivedStateFromError";
 }
-function isClassComponent(node) {
-  if ("superClass" in node && node.superClass != null) {
-    const re = /^(?:Pure)?Component$/u;
-    switch (true) {
-      case node.superClass.type === types.AST_NODE_TYPES.Identifier:
-        return re.test(node.superClass.name);
-      case (node.superClass.type === types.AST_NODE_TYPES.MemberExpression && node.superClass.property.type === types.AST_NODE_TYPES.Identifier):
-        return re.test(node.superClass.property.name);
-    }
-  }
-  return false;
-}
-function isPureComponent(node) {
-  if ("superClass" in node && node.superClass != null) {
-    const re = /^PureComponent$/u;
-    switch (true) {
-      case node.superClass.type === types.AST_NODE_TYPES.Identifier:
-        return re.test(node.superClass.name);
-      case (node.superClass.type === types.AST_NODE_TYPES.MemberExpression && node.superClass.property.type === types.AST_NODE_TYPES.Identifier):
-        return re.test(node.superClass.property.name);
-    }
-  }
-  return false;
-}
-
-// src/component/component-render.ts
 function isRenderLike(node) {
-  return AST6__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "render" && node.parent.parent.type === types.AST_NODE_TYPES.ClassDeclaration;
+  return AST8__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "render" && node.parent.parent.type === types.AST_NODE_TYPES.ClassDeclaration;
 }
 function isFunctionOfRender(node) {
   if (!isRenderLike(node.parent)) {
@@ -1835,10 +2065,10 @@ function isFunctionOfRender(node) {
   return isClassComponent(node.parent.parent.parent);
 }
 function isRenderMethodLike(node) {
-  return AST6__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name.startsWith("render") && node.parent.parent.type === types.AST_NODE_TYPES.ClassDeclaration;
+  return AST8__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name.startsWith("render") && node.parent.parent.type === types.AST_NODE_TYPES.ClassDeclaration;
 }
 
-// src/component/hierarchy.ts
+// src/component/component-hierarchy.ts
 function isChildrenOfCreateElement(context, node) {
   const parent = node.parent;
   if (parent == null || parent.type !== types.AST_NODE_TYPES.CallExpression) return false;
@@ -1846,13 +2076,13 @@ function isChildrenOfCreateElement(context, node) {
   return parent.arguments.slice(2).some((arg) => arg === node);
 }
 function isInsideRenderMethod(node) {
-  return AST6__namespace.findParentNode(node, (n) => isRenderLike(n) && isClassComponent(n.parent.parent)) != null;
+  return AST8__namespace.findParentNode(node, (n) => isRenderLike(n) && isClassComponent(n.parent.parent)) != null;
 }
 function isFunctionOfComponentDidMount(node) {
-  return AST6__namespace.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
+  return AST8__namespace.isFunction(node) && isComponentDidMount(node.parent) && node.parent.value === node;
 }
 function isFunctionOfComponentWillUnmount(node) {
-  return AST6__namespace.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
+  return AST8__namespace.isFunction(node) && isComponentWillUnmount(node.parent) && node.parent.value === node;
 }
 function isFunctionOfRenderMethod(node) {
   if (!isRenderMethodLike(node.parent)) {
@@ -1892,12 +2122,12 @@ function isValidComponentDefinition(context, node, hint) {
   if (hint & ComponentDetectionHint.SkipClassProperty && isFunctionOfClassProperty(node.parent)) {
     return false;
   }
-  if (hint & ComponentDetectionHint.SkipArrayMapArgument && AST6__namespace.isArrayMapCall(node.parent)) {
+  if (hint & ComponentDetectionHint.SkipArrayMapArgument && AST8__namespace.isArrayMapCall(node.parent)) {
     return false;
   }
-  const significantParent = AST6__namespace.findParentNode(
+  const significantParent = AST8__namespace.findParentNode(
     node,
-    AST6__namespace.isOneOf([
+    AST8__namespace.isOneOf([
       types.AST_NODE_TYPES.JSXExpressionContainer,
       types.AST_NODE_TYPES.ArrowFunctionExpression,
       types.AST_NODE_TYPES.FunctionExpression,
@@ -1918,7 +2148,7 @@ function isComponentWrapperCallLoose(context, node) {
 
 // src/component/component-id.ts
 function getFunctionComponentId(context, node) {
-  const functionId = AST6__namespace.getFunctionIdentifier(node);
+  const functionId = AST8__namespace.getFunctionIdentifier(node);
   if (functionId != null) {
     return functionId;
   }
@@ -1945,10 +2175,10 @@ var ComponentFlag = {
 // src/component/component-init-path.ts
 function getComponentFlagFromInitPath(initPath) {
   let flag = ComponentFlag.None;
-  if (initPath != null && AST6__namespace.hasCallInFunctionInitPath("memo", initPath)) {
+  if (initPath != null && AST8__namespace.hasCallInFunctionInitPath("memo", initPath)) {
     flag |= ComponentFlag.Memo;
   }
-  if (initPath != null && AST6__namespace.hasCallInFunctionInitPath("forwardRef", initPath)) {
+  if (initPath != null && AST8__namespace.hasCallInFunctionInitPath("forwardRef", initPath)) {
     flag |= ComponentFlag.ForwardRef;
   }
   return flag;
@@ -1988,8 +2218,8 @@ function useComponentCollector(context, options = {}) {
     const entry = functionEntries.at(-1);
     if (entry == null) return;
     if (!entry.isComponent) return functionEntries.pop();
-    const shouldDrop = AST6__namespace.getNestedReturnStatements(entry.node.body).slice().reverse().some((r) => {
-      return context.sourceCode.getScope(r).block === entry.node && r.argument != null && !JSX3__namespace.isJsxLike(context.sourceCode, r.argument, hint);
+    const shouldDrop = AST8__namespace.getNestedReturnStatements(entry.node.body).slice().reverse().some((r) => {
+      return context.sourceCode.getScope(r).block === entry.node && r.argument != null && !isJsxLike(context.sourceCode, r.argument, hint);
     });
     if (shouldDrop) {
       components.delete(entry.key);
@@ -2013,9 +2243,9 @@ function useComponentCollector(context, options = {}) {
       const entry = getCurrentEntry();
       if (entry == null) return;
       const { body } = entry.node;
-      const isComponent = hasNoneOrLooseComponentName(context, entry.node) && JSX3__namespace.isJsxLike(context.sourceCode, body, hint) && isValidComponentDefinition(context, entry.node, hint);
+      const isComponent = hasNoneOrLooseComponentName(context, entry.node) && isJsxLike(context.sourceCode, body, hint) && isValidComponentDefinition(context, entry.node, hint);
       if (!isComponent) return;
-      const initPath = AST6__namespace.getFunctionInitPath(entry.node);
+      const initPath = AST8__namespace.getFunctionInitPath(entry.node);
       const id = getFunctionComponentId(context, entry.node);
       const name = getComponentNameFromId(id);
       const key = shared.getId();
@@ -2053,10 +2283,10 @@ function useComponentCollector(context, options = {}) {
     "ReturnStatement[type]"(node) {
       const entry = getCurrentEntry();
       if (entry == null) return;
-      const isComponent = hasNoneOrLooseComponentName(context, entry.node) && JSX3__namespace.isJsxLike(context.sourceCode, node.argument, hint) && isValidComponentDefinition(context, entry.node, hint);
+      const isComponent = hasNoneOrLooseComponentName(context, entry.node) && isJsxLike(context.sourceCode, node.argument, hint) && isValidComponentDefinition(context, entry.node, hint);
       if (!isComponent) return;
       entry.isComponent = true;
-      const initPath = AST6__namespace.getFunctionInitPath(entry.node);
+      const initPath = AST8__namespace.getFunctionInitPath(entry.node);
       const id = getFunctionComponentId(context, entry.node);
       const name = getComponentNameFromId(id);
       components.set(entry.key, {
@@ -2087,7 +2317,7 @@ function useComponentCollectorLegacy() {
     if (!isClassComponent(node)) {
       return;
     }
-    const id = AST6__namespace.getClassIdentifier(node);
+    const id = AST8__namespace.getClassIdentifier(node);
     const key = shared.getId();
     const flag = isPureComponent(node) ? ComponentFlag.PureComponent : ComponentFlag.None;
     components.set(
@@ -2120,20 +2350,20 @@ var ComponentPhaseRelevance = birecord__default.default({
 var isInversePhase = eff.dual(2, (a, b) => ComponentPhaseRelevance.get(a) === b);
 function isRenderFunctionLoose(context, node) {
   const { body, parent } = node;
-  if (AST6__namespace.getFunctionIdentifier(node)?.name.startsWith("render")) {
+  if (AST8__namespace.getFunctionIdentifier(node)?.name.startsWith("render")) {
     return parent.type === types.AST_NODE_TYPES.JSXExpressionContainer && parent.parent.type === types.AST_NODE_TYPES.JSXAttribute && parent.parent.name.type === types.AST_NODE_TYPES.JSXIdentifier && parent.parent.name.name.startsWith("render");
   }
-  return JSX3__namespace.isJsxLike(
+  return isJsxLike(
     context.sourceCode,
     body,
-    JSX3__namespace.JSXDetectionHint.SkipNullLiteral | JSX3__namespace.JSXDetectionHint.SkipUndefined | JSX3__namespace.JSXDetectionHint.StrictLogical | JSX3__namespace.JSXDetectionHint.StrictConditional
+    JSXDetectionHint.SkipNullLiteral | JSXDetectionHint.SkipUndefined | JSXDetectionHint.StrictLogical | JSXDetectionHint.StrictConditional
   );
 }
 function isRenderPropLoose(context, node) {
   if (node.name.type !== types.AST_NODE_TYPES.JSXIdentifier) {
     return false;
   }
-  return node.name.name.startsWith("render") && node.value?.type === types.AST_NODE_TYPES.JSXExpressionContainer && AST6__namespace.isFunction(node.value.expression) && isRenderFunctionLoose(context, node.value.expression);
+  return node.name.name.startsWith("render") && node.value?.type === types.AST_NODE_TYPES.JSXExpressionContainer && AST8__namespace.isFunction(node.value.expression) && isRenderFunctionLoose(context, node.value.expression);
 }
 function isDirectValueOfRenderPropertyLoose(node) {
   const matching = (node2) => {
@@ -2145,7 +2375,7 @@ function isDeclaredInRenderPropLoose(node) {
   if (isDirectValueOfRenderPropertyLoose(node)) {
     return true;
   }
-  const parent = AST6__namespace.findParentNode(node, AST6__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer))?.parent;
+  const parent = AST8__namespace.findParentNode(node, AST8__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer))?.parent;
   if (parent?.type !== types.AST_NODE_TYPES.JSXAttribute) {
     return false;
   }
@@ -2153,21 +2383,31 @@ function isDeclaredInRenderPropLoose(node) {
 }
 function isThisSetState(node) {
   const { callee } = node;
-  return callee.type === types.AST_NODE_TYPES.MemberExpression && AST6__namespace.isThisExpression(callee.object) && callee.property.type === types.AST_NODE_TYPES.Identifier && callee.property.name === "setState";
+  return callee.type === types.AST_NODE_TYPES.MemberExpression && AST8__namespace.isThisExpression(callee.object) && callee.property.type === types.AST_NODE_TYPES.Identifier && callee.property.name === "setState";
 }
 function isAssignmentToThisState(node) {
   const { left } = node;
-  return left.type === types.AST_NODE_TYPES.MemberExpression && AST6__namespace.isThisExpression(left.object) && AST6__namespace.getPropertyName(left.property) === "state";
+  return left.type === types.AST_NODE_TYPES.MemberExpression && AST8__namespace.isThisExpression(left.object) && AST8__namespace.getPropertyName(left.property) === "state";
 }
 
 exports.ComponentDetectionHint = ComponentDetectionHint;
 exports.ComponentFlag = ComponentFlag;
 exports.ComponentPhaseRelevance = ComponentPhaseRelevance;
 exports.DEFAULT_COMPONENT_DETECTION_HINT = DEFAULT_COMPONENT_DETECTION_HINT;
+exports.DEFAULT_JSX_DETECTION_HINT = DEFAULT_JSX_DETECTION_HINT;
+exports.JSXDetectionHint = JSXDetectionHint;
+exports.findParentAttribute = findParentAttribute;
+exports.getAttribute = getAttribute;
+exports.getAttributeName = getAttributeName;
+exports.getAttributeValue = getAttributeValue;
 exports.getComponentFlagFromInitPath = getComponentFlagFromInitPath;
 exports.getComponentNameFromId = getComponentNameFromId;
+exports.getElementType = getElementType;
 exports.getFunctionComponentId = getFunctionComponentId;
 exports.getInstanceId = getInstanceId;
+exports.hasAnyAttribute = hasAnyAttribute;
+exports.hasAttribute = hasAttribute;
+exports.hasEveryAttribute = hasEveryAttribute;
 exports.hasNoneOrLooseComponentName = hasNoneOrLooseComponentName;
 exports.isAssignmentToThisState = isAssignmentToThisState;
 exports.isCallFromReact = isCallFromReact;
@@ -2209,6 +2449,7 @@ exports.isDeclaredInRenderPropLoose = isDeclaredInRenderPropLoose;
 exports.isDirectValueOfRenderPropertyLoose = isDirectValueOfRenderPropertyLoose;
 exports.isForwardRef = isForwardRef;
 exports.isForwardRefCall = isForwardRefCall;
+exports.isFragmentElement = isFragmentElement;
 exports.isFromReact = isFromReact;
 exports.isFromReactLoose = isFromReactLoose;
 exports.isFromReactObject = isFromReactObject;
@@ -2225,10 +2466,14 @@ exports.isGetDerivedStateFromError = isGetDerivedStateFromError;
 exports.isGetDerivedStateFromProps = isGetDerivedStateFromProps;
 exports.isGetInitialState = isGetInitialState;
 exports.isGetSnapshotBeforeUpdate = isGetSnapshotBeforeUpdate;
+exports.isHostElement = isHostElement;
 exports.isInitializedFromReact = isInitializedFromReact;
 exports.isInsideRenderMethod = isInsideRenderMethod;
 exports.isInstanceIdEqual = isInstanceIdEqual;
 exports.isInversePhase = isInversePhase;
+exports.isJsxLike = isJsxLike;
+exports.isJsxText = isJsxText;
+exports.isKeyedElement = isKeyedElement;
 exports.isLazy = isLazy;
 exports.isLazyCall = isLazyCall;
 exports.isMemo = isMemo;
@@ -2272,6 +2517,7 @@ exports.isUseStateCall = isUseStateCall;
 exports.isUseSyncExternalStoreCall = isUseSyncExternalStoreCall;
 exports.isUseTransitionCall = isUseTransitionCall;
 exports.isValidComponentDefinition = isValidComponentDefinition;
+exports.stringifyJsx = stringifyJsx;
 exports.useComponentCollector = useComponentCollector;
 exports.useComponentCollectorLegacy = useComponentCollectorLegacy;
 exports.useHookCollector = useHookCollector;