eslint-plugin-react-x 1.43.2-next.1 → 1.45.0-beta.3

package/dist/index.mjs

@@ -1,13 +1,13 @@
 import { getDocsUrl, getSettingsFromContext, unsafeDecodeSettings, DEFAULT_ESLINT_REACT_SETTINGS } from '@eslint-react/shared';
-import * as JSX8 from '@eslint-react/jsx';
+import * as JSX9 from '@eslint-react/jsx';
 import { ESLintUtils } from '@typescript-eslint/utils';
+import { JsxConfig, createReport, SEL } from '@eslint-react/kit';
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
 import * as VAR2 from '@eslint-react/var';
 import { match, isMatching, P } from 'ts-pattern';
-import { JsxConfig, createReport, SEL } from '@eslint-react/kit';
 import ts, { JsxEmit } from 'typescript';
 import * as AST8 from '@eslint-react/ast';
-import * as ER21 from '@eslint-react/core';
+import * as ER22 from '@eslint-react/core';
 import { flow, getOrUpdate, constTrue, constFalse, _ } from '@eslint-react/eff';
 import { compare } from 'compare-versions';
 import { getConstrainedTypeAtLocation, isTypeReadonly } from '@typescript-eslint/type-utils';
@@ -52,7 +52,9 @@ var rules = {
   "react-x/no-forward-ref": "warn",
   "react-x/no-implicit-key": "warn",
   "react-x/no-missing-key": "error",
+  "react-x/no-misused-capture-owner-stack": "error",
   "react-x/no-nested-component-definitions": "error",
+  "react-x/no-nested-lazy-component-declarations": "warn",
   "react-x/no-prop-types": "error",
   "react-x/no-redundant-should-component-update": "error",
   "react-x/no-set-state-in-component-did-mount": "warn",
@@ -113,7 +115,7 @@ var settings3 = {
 
 // package.json
 var name4 = "eslint-plugin-react-x";
-var version = "1.43.2-next.1";
+var version = "1.45.0-beta.3";
 var createRule = ESLintUtils.RuleCreator(getDocsUrl("x"));
 
 // src/rules/avoid-shorthand-boolean.ts
@@ -144,7 +146,7 @@ function create(context) {
           messageId: "avoidShorthandBoolean",
           node,
           data: {
-            propName: JSX8.getAttributeName(node)
+            propName: JSX9.getAttributeName(node)
           },
           fix: (fixer) => fixer.insertTextAfter(node.name, `={true}`)
         });
@@ -152,8 +154,6 @@ function create(context) {
     }
   };
 }
-
-// src/rules/avoid-shorthand-fragment.ts
 var RULE_NAME2 = "avoid-shorthand-fragment";
 var RULE_FEATURES2 = [];
 var avoid_shorthand_fragment_default = createRule({
@@ -164,7 +164,7 @@ var avoid_shorthand_fragment_default = createRule({
       [Symbol.for("rule_features")]: RULE_FEATURES2
     },
     messages: {
-      avoidShorthandFragment: "Avoid using shorthand fragment syntax. Use 'Fragment' component instead."
+      avoidShorthandFragment: "Avoid using shorthand fragment syntax. Use '{{jsxFragmentFactory}}' component instead."
     },
     schema: []
   },
@@ -173,11 +173,20 @@ var avoid_shorthand_fragment_default = createRule({
   defaultOptions: []
 });
 function create2(context) {
+  const jsxConfigFromContext = JsxConfig.getFromContext(context);
+  const jsxConfigFromAnnotation = JsxConfig.getFromAnnotation(context);
+  const jsxConfig = {
+    ...jsxConfigFromContext,
+    ...jsxConfigFromAnnotation
+  };
   return {
     JSXFragment(node) {
       context.report({
         messageId: "avoidShorthandFragment",
-        node
+        node,
+        data: {
+          jsxFragmentFactory: jsxConfig.jsxFragmentFactory
+        }
       });
     }
   };
@@ -378,25 +387,25 @@ function create7(context) {
   const setStateEntries = [];
   return {
     CallExpression(node) {
-      if (!ER21.isThisSetState(node)) {
+      if (!ER22.isThisSetState(node)) {
         return;
       }
       setStateEntries.push([node, false]);
     },
     "CallExpression:exit"(node) {
-      if (!ER21.isThisSetState(node)) {
+      if (!ER22.isThisSetState(node)) {
         return;
       }
       setStateEntries.pop();
     },
     ClassDeclaration(node) {
-      classEntries.push([node, ER21.isClassComponent(node)]);
+      classEntries.push([node, ER22.isClassComponent(node)]);
     },
     "ClassDeclaration:exit"() {
       classEntries.pop();
     },
     ClassExpression(node) {
-      classEntries.push([node, ER21.isClassComponent(node)]);
+      classEntries.push([node, ER22.isClassComponent(node)]);
     },
     "ClassExpression:exit"() {
       classEntries.pop();
@@ -480,7 +489,7 @@ function isUsingReactChildren(context, node) {
     return true;
   }
   if (callee.object.type === AST_NODE_TYPES.MemberExpression && "name" in callee.object.object) {
-    return ER21.isInitializedFromReact(callee.object.object.name, importSource, initialScope);
+    return ER22.isInitializedFromReact(callee.object.object.name, importSource, initialScope);
   }
   return false;
 }
@@ -546,7 +555,7 @@ function create8(context) {
     return node.type === AST_NODE_TYPES.Identifier && indexParamNames.some((name5) => name5 != null && name5 === node.name);
   }
   function isCreateOrCloneElementCall(node) {
-    return ER21.isCreateElementCall(context, node) || ER21.isCloneElementCall(context, node);
+    return ER22.isCreateElementCall(context, node) || ER22.isCloneElementCall(context, node);
   }
   function getReportDescriptors(node) {
     switch (node.type) {
@@ -662,7 +671,7 @@ var no_children_count_default = createRule({
 function create9(context) {
   return {
     MemberExpression(node) {
-      if (ER21.isChildrenCount(context, node)) {
+      if (ER22.isChildrenCount(context, node)) {
         context.report({
           messageId: "noChildrenCount",
           node: node.property
@@ -692,7 +701,7 @@ var no_children_for_each_default = createRule({
 function create10(context) {
   return {
     MemberExpression(node) {
-      if (ER21.isChildrenForEach(context, node)) {
+      if (ER22.isChildrenForEach(context, node)) {
         context.report({
           messageId: "noChildrenForEach",
           node: node.property
@@ -722,7 +731,7 @@ var no_children_map_default = createRule({
 function create11(context) {
   return {
     MemberExpression(node) {
-      if (ER21.isChildrenMap(context, node)) {
+      if (ER22.isChildrenMap(context, node)) {
         context.report({
           messageId: "noChildrenMap",
           node: node.property
@@ -752,7 +761,7 @@ var no_children_only_default = createRule({
 function create12(context) {
   return {
     MemberExpression(node) {
-      if (ER21.isChildrenOnly(context, node)) {
+      if (ER22.isChildrenOnly(context, node)) {
         context.report({
           messageId: "noChildrenOnly",
           node: node.property
@@ -783,7 +792,7 @@ function create13(context) {
   return {
     JSXElement(node) {
       const attributes = node.openingElement.attributes;
-      const childrenProp = JSX8.getAttribute("children", attributes, context.sourceCode.getScope(node));
+      const childrenProp = JSX9.getAttribute("children", attributes, context.sourceCode.getScope(node));
       if (childrenProp != null) {
         context.report({
           messageId: "noChildrenProp",
@@ -814,7 +823,7 @@ var no_children_to_array_default = createRule({
 function create14(context) {
   return {
     MemberExpression(node) {
-      if (ER21.isChildrenToArray(context, node)) {
+      if (ER22.isChildrenToArray(context, node)) {
         context.report({
           messageId: "noChildrenToArray",
           node: node.property
@@ -829,11 +838,11 @@ var no_class_component_default = createRule({
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow class components.",
+      description: "Disallow class components except for error boundaries.",
       [Symbol.for("rule_features")]: RULE_FEATURES15
     },
     messages: {
-      noClassComponent: "Do not use class components. Use function components instead."
+      noClassComponent: "Avoid using class components. Use function components instead."
     },
     schema: []
   },
@@ -843,13 +852,13 @@ var no_class_component_default = createRule({
 });
 function create15(context) {
   if (!context.sourceCode.text.includes("Component")) return {};
-  const { ctx, listeners } = ER21.useComponentCollectorLegacy();
+  const { ctx, listeners } = ER22.useComponentCollectorLegacy();
   return {
     ...listeners,
-    "Program:exit"(node) {
-      const components = ctx.getAllComponents(node);
+    "Program:exit"(program) {
+      const components = ctx.getAllComponents(program);
       for (const { name: name5 = "anonymous", node: component } of components.values()) {
-        if (component.body.body.some((m) => ER21.isComponentDidCatch(m) || ER21.isGetDerivedStateFromError(m))) {
+        if (component.body.body.some((m) => ER22.isComponentDidCatch(m) || ER22.isGetDerivedStateFromError(m))) {
           continue;
         }
         context.report({
@@ -884,7 +893,7 @@ var no_clone_element_default = createRule({
 function create16(context) {
   return {
     CallExpression(node) {
-      if (ER21.isCloneElementCall(context, node)) {
+      if (ER22.isCloneElementCall(context, node)) {
         context.report({
           messageId: "noCloneElement",
           node
@@ -1007,15 +1016,15 @@ var no_component_will_mount_default = createRule({
 });
 function create19(context) {
   if (!context.sourceCode.text.includes("componentWillMount")) return {};
-  const { ctx, listeners } = ER21.useComponentCollectorLegacy();
+  const { ctx, listeners } = ER22.useComponentCollectorLegacy();
   return {
     ...listeners,
-    "Program:exit"(node) {
-      const components = ctx.getAllComponents(node);
+    "Program:exit"(program) {
+      const components = ctx.getAllComponents(program);
       for (const { node: component } of components.values()) {
         const { body } = component.body;
         for (const member of body) {
-          if (ER21.isComponentWillMount(member)) {
+          if (ER22.isComponentWillMount(member)) {
             context.report({
               messageId: "noComponentWillMount",
               node: member,
@@ -1055,15 +1064,15 @@ var no_component_will_receive_props_default = createRule({
 });
 function create20(context) {
   if (!context.sourceCode.text.includes("componentWillReceiveProps")) return {};
-  const { ctx, listeners } = ER21.useComponentCollectorLegacy();
+  const { ctx, listeners } = ER22.useComponentCollectorLegacy();
   return {
     ...listeners,
-    "Program:exit"(node) {
-      const components = ctx.getAllComponents(node);
+    "Program:exit"(program) {
+      const components = ctx.getAllComponents(program);
       for (const { node: component } of components.values()) {
         const { body } = component.body;
         for (const member of body) {
-          if (ER21.isComponentWillReceiveProps(member)) {
+          if (ER22.isComponentWillReceiveProps(member)) {
             context.report({
               messageId: "noComponentWillReceiveProps",
               node: member,
@@ -1103,15 +1112,15 @@ var no_component_will_update_default = createRule({
 });
 function create21(context) {
   if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
-  const { ctx, listeners } = ER21.useComponentCollectorLegacy();
+  const { ctx, listeners } = ER22.useComponentCollectorLegacy();
   return {
     ...listeners,
-    "Program:exit"(node) {
-      const components = ctx.getAllComponents(node);
+    "Program:exit"(program) {
+      const components = ctx.getAllComponents(program);
       for (const { node: component } of components.values()) {
         const { body } = component.body;
         for (const member of body) {
-          if (ER21.isComponentWillUpdate(member)) {
+          if (ER22.isComponentWillUpdate(member)) {
             context.report({
               messageId: "noComponentWillUpdate",
               node: member,
@@ -1155,7 +1164,7 @@ function create22(context) {
   if (compare(version2, "19.0.0", "<")) return {};
   return {
     JSXElement(node) {
-      const fullName = JSX8.getElementType(node);
+      const fullName = JSX9.getElementType(node);
       const parts = fullName.split(".");
       const selfName = parts.pop();
       const contextFullName = parts.join(".");
@@ -1166,7 +1175,7 @@ function create22(context) {
         messageId: "noContextProvider",
         node,
         fix(fixer) {
-          if (!ER21.isComponentNameLoose(contextSelfName)) return null;
+          if (!ER22.isComponentNameLoose(contextSelfName)) return null;
           const openingElement = node.openingElement;
           const closingElement = node.closingElement;
           if (closingElement == null) {
@@ -1202,7 +1211,7 @@ var no_create_ref_default = createRule({
 function create23(context) {
   return {
     CallExpression(node) {
-      if (ER21.isCreateRefCall(context, node) && AST8.findParentNode(node, ER21.isClassComponent) == null) {
+      if (ER22.isCreateRefCall(context, node) && AST8.findParentNode(node, ER22.isClassComponent) == null) {
         context.report({ messageId: "noCreateRef", node });
       }
     }
@@ -1240,17 +1249,17 @@ function create24(context) {
       if (property.type !== AST_NODE_TYPES.Identifier || property.name !== "defaultProps") {
         return;
       }
-      if (!ER21.isComponentNameLoose(object.name)) {
+      if (!ER22.isComponentNameLoose(object.name)) {
         return;
       }
       const variable = VAR2.findVariable(object.name, context.sourceCode.getScope(node));
       const variableNode = VAR2.getVariableInitNode(variable, 0);
       if (variableNode == null) return;
-      if (!AST8.isFunction(variableNode) && !ER21.isClassComponent(variableNode)) return;
+      if (!AST8.isFunction(variableNode) && !ER22.isClassComponent(variableNode)) return;
       context.report({ messageId: "noDefaultProps", node: property });
     },
     PropertyDefinition(node) {
-      if (!ER21.isClassComponent(node.parent.parent)) {
+      if (!ER22.isClassComponent(node.parent.parent)) {
         return;
       }
       if (!node.static || node.key.type !== AST_NODE_TYPES.Identifier || node.key.name !== "defaultProps") {
@@ -1284,7 +1293,7 @@ var no_direct_mutation_state_default = createRule({
 function create25(context) {
   return {
     AssignmentExpression(node) {
-      if (!ER21.isAssignmentToThisState(node)) return;
+      if (!ER22.isAssignmentToThisState(node)) return;
       const parentClass = AST8.findParentNode(
         node,
         AST8.isOneOf([
@@ -1293,7 +1302,7 @@ function create25(context) {
         ])
       );
       if (parentClass == null) return;
-      if (ER21.isClassComponent(parentClass) && context.sourceCode.getScope(node).block !== AST8.findParentNode(node, isConstructorFunction)) {
+      if (ER22.isClassComponent(parentClass) && context.sourceCode.getScope(node).block !== AST8.findParentNode(node, isConstructorFunction)) {
         context.report({
           messageId: "noDirectMutationState",
           node
@@ -1415,7 +1424,7 @@ function create27(context) {
   }
   return {
     CallExpression(node) {
-      if (!ER21.isForwardRefCall(context, node)) {
+      if (!ER22.isForwardRefCall(context, node)) {
         return;
       }
       context.report({
@@ -1517,7 +1526,7 @@ function create28(context) {
   return {
     JSXOpeningElement(node) {
       const initialScope = context.sourceCode.getScope(node);
-      const keyPropFound = JSX8.getAttribute("key", node.attributes, initialScope);
+      const keyPropFound = JSX9.getAttribute("key", node.attributes, initialScope);
       const keyPropOnElement = node.attributes.some(
         (n) => n.type === AST_NODE_TYPES.JSXAttribute && n.name.type === AST_NODE_TYPES.JSXIdentifier && n.name.name === "key"
       );
@@ -1705,21 +1714,21 @@ function create30(context) {
   const {
     ctx,
     listeners
-  } = ER21.useComponentCollector(
+  } = ER22.useComponentCollector(
     context,
     {
       collectDisplayName: true,
       collectHookCalls: false,
-      hint: ER21.DEFAULT_COMPONENT_DETECTION_HINT
+      hint: ER22.DEFAULT_COMPONENT_DETECTION_HINT
     }
   );
   return {
     ...listeners,
-    "Program:exit"(node) {
-      const components = ctx.getAllComponents(node);
-      for (const { node: node2, displayName, flag } of components.values()) {
-        const isMemoOrForwardRef = (flag & (ER21.ComponentFlag.ForwardRef | ER21.ComponentFlag.Memo)) > 0n;
-        if (AST8.getFunctionIdentifier(node2) != null) {
+    "Program:exit"(program) {
+      const components = ctx.getAllComponents(program);
+      for (const { node, displayName, flag } of components.values()) {
+        const isMemoOrForwardRef = (flag & (ER22.ComponentFlag.ForwardRef | ER22.ComponentFlag.Memo)) > 0n;
+        if (AST8.getFunctionIdentifier(node) != null) {
           continue;
         }
         if (!isMemoOrForwardRef) {
@@ -1728,7 +1737,7 @@ function create30(context) {
         if (displayName == null) {
           context.report({
             messageId: "noMissingComponentDisplayName",
-            node: node2
+            node
           });
         }
       }
@@ -1759,12 +1768,12 @@ function create31(context) {
   const displayNameAssignments = [];
   return {
     CallExpression(node) {
-      if (!ER21.isCreateContextCall(context, node)) return;
+      if (!ER22.isCreateContextCall(context, node)) return;
       createCalls.push(node);
     },
     "Program:exit"() {
       for (const call of createCalls) {
-        const id = ER21.getInstanceId(call);
+        const id = ER22.getInstanceId(call);
         if (id == null) {
           context.report({
             messageId: "noMissingContextDisplayName",
@@ -1776,7 +1785,7 @@ function create31(context) {
           const left = node.left;
           if (left.type !== AST_NODE_TYPES.MemberExpression) return false;
           const object = left.object;
-          return ER21.isInstanceIdEqual(context, id, object);
+          return ER22.isInstanceIdEqual(context, id, object);
         });
         if (!hasDisplayNameAssignment) {
           context.report({
@@ -1817,7 +1826,7 @@ function create32(context) {
     switch (node.type) {
       case AST_NODE_TYPES.JSXElement: {
         const initialScope = context.sourceCode.getScope(node);
-        if (!JSX8.hasAttribute("key", node.openingElement.attributes, initialScope)) {
+        if (!JSX9.hasAttribute("key", node.openingElement.attributes, initialScope)) {
           return {
             messageId: "missingKey",
             node
@@ -1874,7 +1883,7 @@ function create32(context) {
       }
       const initialScope = context.sourceCode.getScope(node);
       for (const element of elements) {
-        if (!JSX8.hasAttribute("key", element.openingElement.attributes, initialScope)) {
+        if (!JSX9.hasAttribute("key", element.openingElement.attributes, initialScope)) {
           report({
             messageId: "missingKey",
             node: element
@@ -1883,7 +1892,7 @@ function create32(context) {
       }
     },
     CallExpression(node) {
-      state.isWithinChildrenToArray ||= ER21.isChildrenToArrayCall(context, node);
+      state.isWithinChildrenToArray ||= ER22.isChildrenToArrayCall(context, node);
       if (state.isWithinChildrenToArray) return;
       const callback = match(node).when(AST8.isArrayMapCall, (n) => n.arguments[0]).when(AST8.isArrayFromCall, (n) => n.arguments[1]).otherwise(() => null);
       if (!AST8.isFunction(callback)) return;
@@ -1895,7 +1904,7 @@ function create32(context) {
       report(checkExpression(body));
     },
     "CallExpression:exit"(node) {
-      if (!ER21.isChildrenToArrayCall(context, node)) {
+      if (!ER22.isChildrenToArrayCall(context, node)) {
         return;
       }
       state.isWithinChildrenToArray = false;
@@ -1913,17 +1922,22 @@ function create32(context) {
     }
   };
 }
-var RULE_NAME33 = "no-nested-component-definitions";
-var RULE_FEATURES33 = [];
-var no_nested_component_definitions_default = createRule({
+var RULE_NAME33 = "no-misused-capture-owner-stack";
+var RULE_FEATURES33 = [
+  "EXP"
+];
+var no_misused_capture_owner_stack_default = createRule({
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow nesting component definitions inside other components.",
+      description: "Prevents incorrect usage of `captureOwnerStack`.",
       [Symbol.for("rule_features")]: RULE_FEATURES33
     },
+    fixable: "code",
     messages: {
-      noNestedComponentDefinitions: "Do not nest component definitions inside other components or props. {{suggestion}}"
+      useNamespaceImport: "Don't use named imports of 'captureOwnerStack' in files that are bundled for development and production. Use a namespace import instead.",
+      // eslint-disable-next-line perfectionist/sort-objects
+      missingDevelopmentOnlyCheck: `Don't call 'captureOwnerStack' directly. Use 'if (process.env.NODE_ENV !== "production") {...}' to conditionally access it.`
     },
     schema: []
   },
@@ -1932,30 +1946,81 @@ var no_nested_component_definitions_default = createRule({
   defaultOptions: []
 });
 function create33(context) {
-  const hint = ER21.ComponentDetectionHint.SkipArrayMapArgument | ER21.ComponentDetectionHint.SkipNullLiteral | ER21.ComponentDetectionHint.SkipUndefined | ER21.ComponentDetectionHint.SkipBooleanLiteral | ER21.ComponentDetectionHint.SkipStringLiteral | ER21.ComponentDetectionHint.SkipNumberLiteral | ER21.ComponentDetectionHint.StrictLogical | ER21.ComponentDetectionHint.StrictConditional;
-  const collector = ER21.useComponentCollector(context, { hint });
-  const collectorLegacy = ER21.useComponentCollectorLegacy();
+  if (!context.sourceCode.text.includes("captureOwnerStack")) return {};
+  const { importSource } = getSettingsFromContext(context);
+  return {
+    CallExpression(node) {
+      if (!ER22.isCaptureOwnerStackCall(context, node)) return;
+      if (AST8.findParentNode(node, isDevelopmentOnlyCheck) == null) {
+        context.report({
+          messageId: "missingDevelopmentOnlyCheck",
+          node
+        });
+      }
+    },
+    ImportDeclaration(node) {
+      if (node.source.value !== importSource) return;
+      for (const specifier of node.specifiers) {
+        if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) continue;
+        if (specifier.imported.type !== AST_NODE_TYPES.Identifier) continue;
+        if (specifier.imported.name === "captureOwnerStack") {
+          context.report({
+            messageId: "useNamespaceImport",
+            node: specifier
+          });
+        }
+      }
+    }
+  };
+}
+function isDevelopmentOnlyCheck(node) {
+  if (node.type !== AST_NODE_TYPES.IfStatement) return false;
+  if (AST8.isProcessEnvNodeEnvCompare(node.test, "!==", "production")) return true;
+  return false;
+}
+var RULE_NAME34 = "no-nested-component-definitions";
+var RULE_FEATURES34 = [];
+var no_nested_component_definitions_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow nesting component definitions inside other components.",
+      [Symbol.for("rule_features")]: RULE_FEATURES34
+    },
+    messages: {
+      noNestedComponentDefinitions: "Do not nest component definitions inside other components or props. {{suggestion}}"
+    },
+    schema: []
+  },
+  name: RULE_NAME34,
+  create: create34,
+  defaultOptions: []
+});
+function create34(context) {
+  const hint = ER22.ComponentDetectionHint.SkipArrayMapArgument | ER22.ComponentDetectionHint.SkipNullLiteral | ER22.ComponentDetectionHint.SkipUndefined | ER22.ComponentDetectionHint.SkipBooleanLiteral | ER22.ComponentDetectionHint.SkipStringLiteral | ER22.ComponentDetectionHint.SkipNumberLiteral | ER22.ComponentDetectionHint.StrictLogical | ER22.ComponentDetectionHint.StrictConditional;
+  const collector = ER22.useComponentCollector(context, { hint });
+  const collectorLegacy = ER22.useComponentCollectorLegacy();
   return {
     ...collector.listeners,
     ...collectorLegacy.listeners,
-    "Program:exit"(node) {
+    "Program:exit"(program) {
       const functionComponents = [
-        ...collector.ctx.getAllComponents(node).values()
+        ...collector.ctx.getAllComponents(program).values()
       ];
       const classComponents = [
-        ...collectorLegacy.ctx.getAllComponents(node).values()
+        ...collectorLegacy.ctx.getAllComponents(program).values()
       ];
-      const isFunctionComponent = (node2) => {
-        return AST8.isFunction(node2) && functionComponents.some((component) => component.node === node2);
+      const isFunctionComponent = (node) => {
+        return AST8.isFunction(node) && functionComponents.some((component) => component.node === node);
       };
-      const isClassComponent12 = (node2) => {
-        return AST8.isClass(node2) && classComponents.some((component) => component.node === node2);
+      const isClassComponent12 = (node) => {
+        return AST8.isClass(node) && classComponents.some((component) => component.node === node);
       };
       for (const { name: name5, node: component } of functionComponents) {
         if (name5 == null) continue;
-        if (ER21.isDirectValueOfRenderPropertyLoose(component)) continue;
+        if (ER22.isDirectValueOfRenderPropertyLoose(component)) continue;
         if (isInsideJSXAttributeValue(component)) {
-          if (!ER21.isDeclaredInRenderPropLoose(component)) {
+          if (!ER22.isDeclaredInRenderPropLoose(component)) {
             context.report({
               messageId: "noNestedComponentDefinitions",
               node: component,
@@ -1979,7 +2044,7 @@ function create33(context) {
           continue;
         }
         const parentComponent = AST8.findParentNode(component, isFunctionComponent);
-        if (parentComponent != null && !ER21.isDirectValueOfRenderPropertyLoose(parentComponent)) {
+        if (parentComponent != null && !ER22.isDirectValueOfRenderPropertyLoose(parentComponent)) {
           context.report({
             messageId: "noNestedComponentDefinitions",
             node: component,
@@ -1990,7 +2055,7 @@ function create33(context) {
           });
           continue;
         }
-        if (ER21.isInsideRenderMethod(component)) {
+        if (ER22.isInsideRenderMethod(component)) {
           context.report({
             messageId: "noNestedComponentDefinitions",
             node: component,
@@ -2018,34 +2083,97 @@ function create33(context) {
   };
 }
 function isInsideJSXAttributeValue(node) {
-  return node.parent.type === AST_NODE_TYPES.JSXAttribute || JSX8.findParentAttribute(node, (n) => n.value?.type === AST_NODE_TYPES.JSXExpressionContainer) != null;
+  return node.parent.type === AST_NODE_TYPES.JSXAttribute || JSX9.findParentAttribute(node, (n) => n.value?.type === AST_NODE_TYPES.JSXExpressionContainer) != null;
 }
 function isInsideCreateElementProps(context, node) {
-  const call = AST8.findParentNode(node, ER21.isCreateElementCall(context));
+  const call = AST8.findParentNode(node, ER22.isCreateElementCall(context));
   if (call == null) return false;
   const prop = AST8.findParentNode(node, AST8.is(AST_NODE_TYPES.ObjectExpression));
   if (prop == null) return false;
   return prop === call.arguments[1];
 }
-var RULE_NAME34 = "no-prop-types";
-var RULE_FEATURES34 = [];
+var RULE_NAME35 = "no-nested-component-definitions";
+var RULE_FEATURES35 = [];
+var no_nested_lazy_component_declarations_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow nesting lazy component declarations inside other components.",
+      [Symbol.for("rule_features")]: RULE_FEATURES35
+    },
+    messages: {
+      noNestedComponentDefinitions: "Do not declare lazy components inside other components. Instead, always declare them at the top level of your module."
+    },
+    schema: []
+  },
+  name: RULE_NAME35,
+  create: create35,
+  defaultOptions: []
+});
+function create35(context) {
+  const hint = ER22.ComponentDetectionHint.None;
+  const collector = ER22.useComponentCollector(context, { hint });
+  const collectorLegacy = ER22.useComponentCollectorLegacy();
+  const lazyComponentDeclarations = /* @__PURE__ */ new Set();
+  return {
+    ...collector.listeners,
+    ...collectorLegacy.listeners,
+    ImportExpression(node) {
+      const lazyCall = AST8.findParentNode(node, (n) => ER22.isLazyCall(context, n));
+      if (lazyCall != null) {
+        lazyComponentDeclarations.add(lazyCall);
+      }
+    },
+    "Program:exit"(program) {
+      const functionComponents = [
+        ...collector.ctx.getAllComponents(program).values()
+      ];
+      const classComponents = [
+        ...collectorLegacy.ctx.getAllComponents(program).values()
+      ];
+      for (const lazy of lazyComponentDeclarations) {
+        const significantParent = AST8.findParentNode(lazy, (n) => {
+          if (JSX9.isJSX(n)) return true;
+          if (n.type === AST_NODE_TYPES.CallExpression) {
+            return ER22.isReactHookCall(n) || ER22.isCreateElementCall(context, n) || ER22.isCreateContextCall(context, n);
+          }
+          if (AST8.isFunction(n)) {
+            return functionComponents.some((c) => c.node === n);
+          }
+          if (AST8.isClass(n)) {
+            return classComponents.some((c) => c.node === n);
+          }
+          return false;
+        });
+        if (significantParent != null) {
+          context.report({
+            messageId: "noNestedComponentDefinitions",
+            node: lazy
+          });
+        }
+      }
+    }
+  };
+}
+var RULE_NAME36 = "no-prop-types";
+var RULE_FEATURES36 = [];
 var no_prop_types_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow `propTypes` in favor of TypeScript or another type-checking solution.",
-      [Symbol.for("rule_features")]: RULE_FEATURES34
+      [Symbol.for("rule_features")]: RULE_FEATURES36
     },
     messages: {
       noPropTypes: "[Deprecated] Use TypeScript or another type-checking solution instead."
     },
     schema: []
   },
-  name: RULE_NAME34,
-  create: create34,
+  name: RULE_NAME36,
+  create: create36,
   defaultOptions: []
 });
-function create34(context) {
+function create36(context) {
   if (!context.sourceCode.text.includes("propTypes")) {
     return {};
   }
@@ -2061,17 +2189,17 @@ function create34(context) {
       if (property.type !== AST_NODE_TYPES.Identifier || property.name !== "propTypes") {
         return;
       }
-      if (!ER21.isComponentNameLoose(object.name)) {
+      if (!ER22.isComponentNameLoose(object.name)) {
         return;
       }
       const variable = VAR2.findVariable(object.name, context.sourceCode.getScope(node));
       const variableNode = VAR2.getVariableInitNode(variable, 0);
-      if (variableNode != null && (AST8.isFunction(variableNode) || ER21.isClassComponent(variableNode))) {
+      if (variableNode != null && (AST8.isFunction(variableNode) || ER22.isClassComponent(variableNode))) {
         context.report({ messageId: "noPropTypes", node: property });
       }
     },
     PropertyDefinition(node) {
-      if (!ER21.isClassComponent(node.parent.parent)) {
+      if (!ER22.isClassComponent(node.parent.parent)) {
         return;
       }
       if (!node.static || node.key.type !== AST_NODE_TYPES.Identifier || node.key.name !== "propTypes") {
@@ -2081,8 +2209,8 @@ function create34(context) {
     }
   };
 }
-var RULE_NAME35 = "no-redundant-should-component-update";
-var RULE_FEATURES35 = [];
+var RULE_NAME37 = "no-redundant-should-component-update";
+var RULE_FEATURES37 = [];
 function isShouldComponentUpdate(node) {
   return AST8.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
 }
@@ -2091,26 +2219,26 @@ var no_redundant_should_component_update_default = createRule({
     type: "problem",
     docs: {
       description: "Disallow `shouldComponentUpdate` when extending `React.PureComponent`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES35
+      [Symbol.for("rule_features")]: RULE_FEATURES37
     },
     messages: {
       noRedundantShouldComponentUpdate: "'{{componentName}}' does not need 'shouldComponentUpdate' when extending 'React.PureComponent'."
     },
     schema: []
   },
-  name: RULE_NAME35,
-  create: create35,
+  name: RULE_NAME37,
+  create: create37,
   defaultOptions: []
 });
-function create35(context) {
+function create37(context) {
   if (!context.sourceCode.text.includes("shouldComponentUpdate")) return {};
-  const { ctx, listeners } = ER21.useComponentCollectorLegacy();
+  const { ctx, listeners } = ER22.useComponentCollectorLegacy();
   return {
     ...listeners,
-    "Program:exit"(node) {
-      const components = ctx.getAllComponents(node);
+    "Program:exit"(program) {
+      const components = ctx.getAllComponents(program);
       for (const { name: name5 = "PureComponent", node: component, flag } of components.values()) {
-        if ((flag & ER21.ComponentFlag.PureComponent) === 0n) {
+        if ((flag & ER22.ComponentFlag.PureComponent) === 0n) {
           continue;
         }
         const { body } = component.body;
@@ -2129,33 +2257,33 @@ function create35(context) {
     }
   };
 }
-var RULE_NAME36 = "no-set-state-in-component-did-mount";
-var RULE_FEATURES36 = [];
+var RULE_NAME38 = "no-set-state-in-component-did-mount";
+var RULE_FEATURES38 = [];
 var no_set_state_in_component_did_mount_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow calling `this.setState` in `componentDidMount` outside of functions, such as callbacks.",
-      [Symbol.for("rule_features")]: RULE_FEATURES36
+      [Symbol.for("rule_features")]: RULE_FEATURES38
     },
     messages: {
       noSetStateInComponentDidMount: "Do not call `this.setState` in `componentDidMount` outside of functions, such as callbacks."
     },
     schema: []
   },
-  name: RULE_NAME36,
-  create: create36,
+  name: RULE_NAME38,
+  create: create38,
   defaultOptions: []
 });
-function create36(context) {
+function create38(context) {
   if (!context.sourceCode.text.includes("componentDidMount")) return {};
   return {
     CallExpression(node) {
-      if (!ER21.isThisSetState(node)) {
+      if (!ER22.isThisSetState(node)) {
         return;
       }
-      const clazz = AST8.findParentNode(node, ER21.isClassComponent);
-      const method = AST8.findParentNode(node, (n) => n === clazz || ER21.isComponentDidMount(n));
+      const clazz = AST8.findParentNode(node, ER22.isClassComponent);
+      const method = AST8.findParentNode(node, (n) => n === clazz || ER22.isComponentDidMount(n));
       if (clazz == null || method == null || method === clazz) return;
       const methodScope = context.sourceCode.getScope(method);
       const upperScope = context.sourceCode.getScope(node).upper;
@@ -2168,33 +2296,33 @@ function create36(context) {
     }
   };
 }
-var RULE_NAME37 = "no-set-state-in-component-did-update";
-var RULE_FEATURES37 = [];
+var RULE_NAME39 = "no-set-state-in-component-did-update";
+var RULE_FEATURES39 = [];
 var no_set_state_in_component_did_update_default = createRule({
   meta: {
     type: "problem",
     docs: {
-      description: "Disallows calling `this.setState` in `componentDidUpdate` outside of functions, such as callbacks.",
-      [Symbol.for("rule_features")]: RULE_FEATURES37
+      description: "Disallow calling `this.setState` in `componentDidUpdate` outside of functions, such as callbacks.",
+      [Symbol.for("rule_features")]: RULE_FEATURES39
     },
     messages: {
       noSetStateInComponentDidUpdate: "Do not call `this.setState` in `componentDidUpdate` outside of functions, such as callbacks."
     },
     schema: []
   },
-  name: RULE_NAME37,
-  create: create37,
+  name: RULE_NAME39,
+  create: create39,
   defaultOptions: []
 });
-function create37(context) {
+function create39(context) {
   if (!context.sourceCode.text.includes("componentDidUpdate")) return {};
   return {
     CallExpression(node) {
-      if (!ER21.isThisSetState(node)) {
+      if (!ER22.isThisSetState(node)) {
         return;
       }
-      const clazz = AST8.findParentNode(node, ER21.isClassComponent);
-      const method = AST8.findParentNode(node, (n) => n === clazz || ER21.isComponentDidUpdate(n));
+      const clazz = AST8.findParentNode(node, ER22.isClassComponent);
+      const method = AST8.findParentNode(node, (n) => n === clazz || ER22.isComponentDidUpdate(n));
       if (clazz == null || method == null || method === clazz) return;
       const methodScope = context.sourceCode.getScope(method);
       const upperScope = context.sourceCode.getScope(node).upper;
@@ -2207,33 +2335,33 @@ function create37(context) {
     }
   };
 }
-var RULE_NAME38 = "no-set-state-in-component-will-update";
-var RULE_FEATURES38 = [];
+var RULE_NAME40 = "no-set-state-in-component-will-update";
+var RULE_FEATURES40 = [];
 var no_set_state_in_component_will_update_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallows calling `this.setState` in `componentWillUpdate` outside of functions, such as callbacks.",
-      [Symbol.for("rule_features")]: RULE_FEATURES38
+      [Symbol.for("rule_features")]: RULE_FEATURES40
     },
     messages: {
       noSetStateInComponentWillUpdate: "Do not call `this.setState` in `componentWillUpdate` outside of functions, such as callbacks."
     },
     schema: []
   },
-  name: RULE_NAME38,
-  create: create38,
+  name: RULE_NAME40,
+  create: create40,
   defaultOptions: []
 });
-function create38(context) {
+function create40(context) {
   if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
   return {
     CallExpression(node) {
-      if (!ER21.isThisSetState(node)) {
+      if (!ER22.isThisSetState(node)) {
         return;
       }
-      const clazz = AST8.findParentNode(node, ER21.isClassComponent);
-      const method = AST8.findParentNode(node, (n) => n === clazz || ER21.isComponentWillUpdate(n));
+      const clazz = AST8.findParentNode(node, ER22.isClassComponent);
+      const method = AST8.findParentNode(node, (n) => n === clazz || ER22.isComponentWillUpdate(n));
       if (clazz == null || method == null || method === clazz) return;
       const methodScope = context.sourceCode.getScope(method);
       const upperScope = context.sourceCode.getScope(node).upper;
@@ -2246,8 +2374,8 @@ function create38(context) {
     }
   };
 }
-var RULE_NAME39 = "no-string-refs";
-var RULE_FEATURES39 = [
+var RULE_NAME41 = "no-string-refs";
+var RULE_FEATURES41 = [
   "MOD"
 ];
 var no_string_refs_default = createRule({
@@ -2255,7 +2383,7 @@ var no_string_refs_default = createRule({
     type: "problem",
     docs: {
       description: "Replaces string refs with callback refs.",
-      [Symbol.for("rule_features")]: RULE_FEATURES39
+      [Symbol.for("rule_features")]: RULE_FEATURES41
     },
     fixable: "code",
     messages: {
@@ -2263,16 +2391,16 @@ var no_string_refs_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME39,
-  create: create39,
+  name: RULE_NAME41,
+  create: create41,
   defaultOptions: []
 });
-function create39(context) {
+function create41(context) {
   const state = {
     isWithinClassComponent: false
   };
   function onClassBodyEnter(node) {
-    if (ER21.isClassComponent(node.parent)) {
+    if (ER22.isClassComponent(node.parent)) {
       state.isWithinClassComponent = true;
     }
   }
@@ -2311,8 +2439,8 @@ function getAttributeValueText(context, node) {
       return null;
   }
 }
-var RULE_NAME40 = "no-unsafe-component-will-mount";
-var RULE_FEATURES40 = [];
+var RULE_NAME42 = "no-unsafe-component-will-mount";
+var RULE_FEATURES42 = [];
 function isUnsafeComponentWillMount(node) {
   return AST8.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillMount";
 }
@@ -2321,24 +2449,24 @@ var no_unsafe_component_will_mount_default = createRule({
     type: "problem",
     docs: {
       description: "Warns the usage of `UNSAFE_componentWillMount` in class components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES40
+      [Symbol.for("rule_features")]: RULE_FEATURES42
     },
     messages: {
       noUnsafeComponentWillMount: "Do not use 'UNSAFE_componentWillMount'."
     },
     schema: []
   },
-  name: RULE_NAME40,
-  create: create40,
+  name: RULE_NAME42,
+  create: create42,
   defaultOptions: []
 });
-function create40(context) {
+function create42(context) {
   if (!context.sourceCode.text.includes("UNSAFE_componentWillMount")) return {};
-  const { ctx, listeners } = ER21.useComponentCollectorLegacy();
+  const { ctx, listeners } = ER22.useComponentCollectorLegacy();
   return {
     ...listeners,
-    "Program:exit"(node) {
-      const components = ctx.getAllComponents(node);
+    "Program:exit"(program) {
+      const components = ctx.getAllComponents(program);
       for (const { node: component } of components.values()) {
         const { body } = component.body;
         for (const member of body) {
@@ -2353,8 +2481,8 @@ function create40(context) {
     }
   };
 }
-var RULE_NAME41 = "no-unsafe-component-will-receive-props";
-var RULE_FEATURES41 = [];
+var RULE_NAME43 = "no-unsafe-component-will-receive-props";
+var RULE_FEATURES43 = [];
 function isUnsafeComponentWillReceiveProps(node) {
   return AST8.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillReceiveProps";
 }
@@ -2363,26 +2491,26 @@ var no_unsafe_component_will_receive_props_default = createRule({
     type: "problem",
     docs: {
       description: "Warns the usage of `UNSAFE_componentWillReceiveProps` in class components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES41
+      [Symbol.for("rule_features")]: RULE_FEATURES43
     },
     messages: {
       noUnsafeComponentWillReceiveProps: "Do not use 'UNSAFE_componentWillReceiveProps'."
     },
     schema: []
   },
-  name: RULE_NAME41,
-  create: create41,
+  name: RULE_NAME43,
+  create: create43,
   defaultOptions: []
 });
-function create41(context) {
+function create43(context) {
   if (!context.sourceCode.text.includes("UNSAFE_componentWillReceiveProps")) {
     return {};
   }
-  const { ctx, listeners } = ER21.useComponentCollectorLegacy();
+  const { ctx, listeners } = ER22.useComponentCollectorLegacy();
   return {
     ...listeners,
-    "Program:exit"(node) {
-      const components = ctx.getAllComponents(node);
+    "Program:exit"(program) {
+      const components = ctx.getAllComponents(program);
       for (const { node: component } of components.values()) {
         const { body } = component.body;
         for (const member of body) {
@@ -2397,8 +2525,8 @@ function create41(context) {
     }
   };
 }
-var RULE_NAME42 = "no-unsafe-component-will-update";
-var RULE_FEATURES42 = [];
+var RULE_NAME44 = "no-unsafe-component-will-update";
+var RULE_FEATURES44 = [];
 function isUnsafeComponentWillUpdate(node) {
   return AST8.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillUpdate";
 }
@@ -2407,24 +2535,24 @@ var no_unsafe_component_will_update_default = createRule({
     type: "problem",
     docs: {
       description: "Warns the usage of `UNSAFE_componentWillUpdate` in class components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES42
+      [Symbol.for("rule_features")]: RULE_FEATURES44
     },
     messages: {
       noUnsafeComponentWillUpdate: "Do not use 'UNSAFE_componentWillUpdate'."
     },
     schema: []
   },
-  name: RULE_NAME42,
-  create: create42,
+  name: RULE_NAME44,
+  create: create44,
   defaultOptions: []
 });
-function create42(context) {
+function create44(context) {
   if (!context.sourceCode.text.includes("UNSAFE_componentWillUpdate")) return {};
-  const { ctx, listeners } = ER21.useComponentCollectorLegacy();
+  const { ctx, listeners } = ER22.useComponentCollectorLegacy();
   return {
     ...listeners,
-    "Program:exit"(node) {
-      const components = ctx.getAllComponents(node);
+    "Program:exit"(program) {
+      const components = ctx.getAllComponents(program);
       for (const { node: component } of components.values()) {
         const { body } = component.body;
         for (const member of body) {
@@ -2439,33 +2567,33 @@ function create42(context) {
     }
   };
 }
-var RULE_NAME43 = "no-unstable-context-value";
-var RULE_FEATURES43 = [];
+var RULE_NAME45 = "no-unstable-context-value";
+var RULE_FEATURES45 = [];
 var no_unstable_context_value_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Prevents non-stable values (i.e. object literals) from being used as a value for `Context.Provider`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES43
+      [Symbol.for("rule_features")]: RULE_FEATURES45
     },
     messages: {
       unstableContextValue: "A/an '{{type}}' passed as the value prop to the context provider should not be constructed. It will change on every render. {{suggestion}}"
     },
     schema: []
   },
-  name: RULE_NAME43,
-  create: create43,
+  name: RULE_NAME45,
+  create: create45,
   defaultOptions: []
 });
-function create43(context) {
+function create45(context) {
   const { version: version2 } = getSettingsFromContext(context);
   const isReact18OrBelow = compare(version2, "19.0.0", "<");
-  const { ctx, listeners } = ER21.useComponentCollector(context);
+  const { ctx, listeners } = ER22.useComponentCollector(context);
   const constructions = /* @__PURE__ */ new Map();
   return {
     ...listeners,
     JSXOpeningElement(node) {
-      const fullName = JSX8.getElementType(node.parent);
+      const fullName = JSX9.getElementType(node.parent);
       const selfName = fullName.split(".").at(-1);
       if (selfName == null) return;
       if (!isContextName(selfName, isReact18OrBelow)) return;
@@ -2481,13 +2609,13 @@ function create43(context) {
       const initialScope = context.sourceCode.getScope(valueExpression);
       const construction = VAR2.getConstructionDetectionResult(valueExpression, initialScope);
       if (construction == null) return;
-      if (ER21.isReactHookCall(construction.node)) {
+      if (ER22.isReactHookCall(construction.node)) {
         return;
       }
       getOrUpdate(constructions, functionEntry.node, () => []).push(construction);
     },
-    "Program:exit"(node) {
-      const components = ctx.getAllComponents(node).values();
+    "Program:exit"(program) {
+      const components = ctx.getAllComponents(program).values();
       for (const { node: component } of components) {
         for (const construction of constructions.get(component) ?? []) {
           const { kind, node: constructionNode } = construction;
@@ -2512,31 +2640,31 @@ function isContextName(name5, isReact18OrBelow) {
   }
   return false;
 }
-var RULE_NAME44 = "no-unstable-default-props";
-var RULE_FEATURES44 = [];
+var RULE_NAME46 = "no-unstable-default-props";
+var RULE_FEATURES46 = [];
 var no_unstable_default_props_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Prevents using referential-type values as default props in object destructuring.",
-      [Symbol.for("rule_features")]: RULE_FEATURES44
+      [Symbol.for("rule_features")]: RULE_FEATURES46
     },
     messages: {
       noUnstableDefaultProps: "A/an '{{forbiddenType}}' as default prop. This could lead to potential infinite render loop in React. Use a variable instead of '{{forbiddenType}}'."
     },
     schema: []
   },
-  name: RULE_NAME44,
-  create: create44,
+  name: RULE_NAME46,
+  create: create46,
   defaultOptions: []
 });
-function create44(context) {
-  const { ctx, listeners } = ER21.useComponentCollector(context);
+function create46(context) {
+  const { ctx, listeners } = ER22.useComponentCollector(context);
   const declarators = /* @__PURE__ */ new Map();
   return {
     ...listeners,
-    "Program:exit"(node) {
-      const components = ctx.getAllComponents(node);
+    "Program:exit"(program) {
+      const components = ctx.getAllComponents(program);
       for (const { node: component } of components.values()) {
         const { params } = component;
         const [props] = params;
@@ -2561,7 +2689,7 @@ function create44(context) {
           if (construction == null) {
             continue;
           }
-          if (ER21.isReactHookCall(construction.node)) {
+          if (ER22.isReactHookCall(construction.node)) {
             continue;
           }
           const forbiddenType = AST8.toReadableNodeType(right);
@@ -2586,8 +2714,8 @@ function create44(context) {
     }
   };
 }
-var RULE_NAME45 = "no-unused-class-component-members";
-var RULE_FEATURES45 = [];
+var RULE_NAME47 = "no-unused-class-component-members";
+var RULE_FEATURES47 = [];
 var LIFECYCLE_METHODS = /* @__PURE__ */ new Set([
   "componentDidCatch",
   "componentDidMount",
@@ -2613,25 +2741,25 @@ var no_unused_class_component_members_default = createRule({
     type: "problem",
     docs: {
       description: "Warns unused class component methods and properties.",
-      [Symbol.for("rule_features")]: RULE_FEATURES45
+      [Symbol.for("rule_features")]: RULE_FEATURES47
     },
     messages: {
       noUnusedClassComponentMembers: "Unused method or property '{{methodName}}'' of class '{{className}}'."
     },
     schema: []
   },
-  name: RULE_NAME45,
-  create: create45,
+  name: RULE_NAME47,
+  create: create47,
   defaultOptions: []
 });
-function create45(context) {
+function create47(context) {
   const classEntries = [];
   const methodEntries = [];
   const propertyDefs = /* @__PURE__ */ new WeakMap();
   const propertyUsages = /* @__PURE__ */ new WeakMap();
   function classEnter(node) {
     classEntries.push(node);
-    if (!ER21.isClassComponent(node)) {
+    if (!ER22.isClassComponent(node)) {
       return;
     }
     propertyDefs.set(node, /* @__PURE__ */ new Set());
@@ -2639,7 +2767,7 @@ function create45(context) {
   }
   function classExit() {
     const currentClass = classEntries.pop();
-    if (currentClass == null || !ER21.isClassComponent(currentClass)) {
+    if (currentClass == null || !ER22.isClassComponent(currentClass)) {
       return;
     }
     const className = AST8.getClassIdentifier(currentClass)?.name;
@@ -2669,7 +2797,7 @@ function create45(context) {
   function methodEnter(node) {
     methodEntries.push(node);
     const currentClass = classEntries.at(-1);
-    if (currentClass == null || !ER21.isClassComponent(currentClass)) {
+    if (currentClass == null || !ER22.isClassComponent(currentClass)) {
       return;
     }
     if (node.static) {
@@ -2693,7 +2821,7 @@ function create45(context) {
       if (currentClass == null || currentMethod == null) {
         return;
       }
-      if (!ER21.isClassComponent(currentClass) || currentMethod.static) {
+      if (!ER22.isClassComponent(currentClass) || currentMethod.static) {
         return;
       }
       if (!AST8.isThisExpression(node.object) || !isKeyLiteral2(node, node.property)) {
@@ -2718,7 +2846,7 @@ function create45(context) {
       if (currentClass == null || currentMethod == null) {
         return;
       }
-      if (!ER21.isClassComponent(currentClass) || currentMethod.static) {
+      if (!ER22.isClassComponent(currentClass) || currentMethod.static) {
         return;
       }
       if (node.init != null && AST8.isThisExpression(node.init) && node.id.type === AST_NODE_TYPES.ObjectPattern) {
@@ -2734,8 +2862,8 @@ function create45(context) {
     }
   };
 }
-var RULE_NAME46 = "no-unused-state";
-var RULE_FEATURES46 = [];
+var RULE_NAME48 = "no-unused-state";
+var RULE_FEATURES48 = [];
 function isKeyLiteral3(node, key) {
   return match(key).with({ type: AST_NODE_TYPES.Literal }, constTrue).with({ type: AST_NODE_TYPES.TemplateLiteral, expressions: [] }, constTrue).with({ type: AST_NODE_TYPES.Identifier }, () => !node.computed).otherwise(constFalse);
 }
@@ -2744,18 +2872,18 @@ var no_unused_state_default = createRule({
     type: "problem",
     docs: {
       description: "Warns unused class component state.",
-      [Symbol.for("rule_features")]: RULE_FEATURES46
+      [Symbol.for("rule_features")]: RULE_FEATURES48
     },
     messages: {
       noUnusedState: "Unused class component state in '{{className}}'"
     },
     schema: []
   },
-  name: RULE_NAME46,
-  create: create46,
+  name: RULE_NAME48,
+  create: create48,
   defaultOptions: []
 });
-function create46(context) {
+function create48(context) {
   const classEntries = [];
   const methodEntries = [];
   const constructorEntries = [];
@@ -2765,7 +2893,7 @@ function create46(context) {
   }
   function classExit() {
     const currentClass = classEntries.pop();
-    if (currentClass == null || !ER21.isClassComponent(currentClass)) {
+    if (currentClass == null || !ER22.isClassComponent(currentClass)) {
       return;
     }
     const className = AST8.getClassIdentifier(currentClass)?.name;
@@ -2784,11 +2912,11 @@ function create46(context) {
   function methodEnter(node) {
     methodEntries.push(node);
     const currentClass = classEntries.at(-1);
-    if (currentClass == null || !ER21.isClassComponent(currentClass)) {
+    if (currentClass == null || !ER22.isClassComponent(currentClass)) {
       return;
     }
     if (node.static) {
-      if (ER21.isGetDerivedStateFromProps(node) && isMatching({ params: [P.nonNullable, ...P.array()] })(node.value)) {
+      if (ER22.isGetDerivedStateFromProps(node) && isMatching({ params: [P.nonNullable, ...P.array()] })(node.value)) {
         const defNode = stateDefs.get(currentClass)?.node;
         stateDefs.set(currentClass, { node: defNode, isUsed: true });
       }
@@ -2809,11 +2937,11 @@ function create46(context) {
   }
   return {
     AssignmentExpression(node) {
-      if (!ER21.isAssignmentToThisState(node)) {
+      if (!ER22.isAssignmentToThisState(node)) {
         return;
       }
       const currentClass = classEntries.at(-1);
-      if (currentClass == null || !ER21.isClassComponent(currentClass)) {
+      if (currentClass == null || !ER22.isClassComponent(currentClass)) {
         return;
       }
       const currentConstructor = constructorEntries.at(-1);
@@ -2835,7 +2963,7 @@ function create46(context) {
         return;
       }
       const currentClass = classEntries.at(-1);
-      if (currentClass == null || !ER21.isClassComponent(currentClass)) {
+      if (currentClass == null || !ER22.isClassComponent(currentClass)) {
         return;
       }
       const currentMethod = methodEntries.at(-1);
@@ -2859,7 +2987,7 @@ function create46(context) {
     "PropertyDefinition:exit": methodExit,
     VariableDeclarator(node) {
       const currentClass = classEntries.at(-1);
-      if (currentClass == null || !ER21.isClassComponent(currentClass)) {
+      if (currentClass == null || !ER22.isClassComponent(currentClass)) {
         return;
       }
       const currentMethod = methodEntries.at(-1);
@@ -2889,8 +3017,8 @@ function create46(context) {
     }
   };
 }
-var RULE_NAME47 = "no-use-context";
-var RULE_FEATURES47 = [
+var RULE_NAME49 = "no-use-context";
+var RULE_FEATURES49 = [
   "MOD"
 ];
 var no_use_context_default = createRule({
@@ -2898,7 +3026,7 @@ var no_use_context_default = createRule({
     type: "problem",
     docs: {
       description: "Replaces usages of `useContext` with `use`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES47
+      [Symbol.for("rule_features")]: RULE_FEATURES49
     },
     fixable: "code",
     messages: {
@@ -2906,11 +3034,11 @@ var no_use_context_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME47,
-  create: create47,
+  name: RULE_NAME49,
+  create: create49,
   defaultOptions: []
 });
-function create47(context) {
+function create49(context) {
   if (!context.sourceCode.text.includes("useContext")) return {};
   const settings4 = getSettingsFromContext(context);
   const useContextAlias = /* @__PURE__ */ new Set();
@@ -2919,10 +3047,10 @@ function create47(context) {
   }
   return {
     CallExpression(node) {
-      if (!ER21.isReactHookCall(node)) {
+      if (!ER22.isReactHookCall(node)) {
         return;
       }
-      if (!ER21.isReactHookCallWithNameAlias(context, "useContext", [...useContextAlias])(node)) {
+      if (!ER22.isReactHookCallWithNameAlias(context, "useContext", [...useContextAlias])(node)) {
         return;
       }
       context.report({
@@ -2988,28 +3116,28 @@ function getAssociatedTokens(context, node) {
     return tokens;
   }
 }
-var RULE_NAME48 = "no-useless-forward-ref";
-var RULE_FEATURES48 = [];
+var RULE_NAME50 = "no-useless-forward-ref";
+var RULE_FEATURES50 = [];
 var no_useless_forward_ref_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow useless `forwardRef` calls on components that don't use `ref`s.",
-      [Symbol.for("rule_features")]: RULE_FEATURES48
+      [Symbol.for("rule_features")]: RULE_FEATURES50
     },
     messages: {
       noUselessForwardRef: "A 'forwardRef' is used with this component but no 'ref' parameter is set."
     },
     schema: []
   },
-  name: RULE_NAME48,
-  create: create48,
+  name: RULE_NAME50,
+  create: create50,
   defaultOptions: []
 });
-function create48(context) {
+function create50(context) {
   return {
     CallExpression(node) {
-      if (!ER21.isForwardRefCall(context, node)) {
+      if (!ER22.isForwardRefCall(context, node)) {
         return;
       }
       const [component] = node.arguments;
@@ -3027,7 +3155,7 @@ function create48(context) {
     }
   };
 }
-var RULE_NAME49 = "no-useless-fragment";
+var RULE_NAME51 = "no-useless-fragment";
 var defaultOptions = [{
   allowExpressions: true
 }];
@@ -3053,15 +3181,15 @@ var no_useless_fragment_default = createRule({
       }
     }]
   },
-  name: RULE_NAME49,
-  create: create49,
+  name: RULE_NAME51,
+  create: create51,
   defaultOptions
 });
-function create49(context, [option]) {
+function create51(context, [option]) {
   const { allowExpressions = true } = option;
   return {
     JSXElement(node) {
-      if (!JSX8.isFragmentElement(node)) return;
+      if (!JSX9.isFragmentElement(node)) return;
       checkNode(context, node, allowExpressions);
     },
     JSXFragment(node) {
@@ -3073,7 +3201,7 @@ function isWhiteSpace(node) {
   return typeof node.value === "string" && node.raw.trim() === "";
 }
 function isPaddingSpaces(node) {
-  return JSX8.isJsxText(node) && isWhiteSpace(node) && node.raw.includes("\n");
+  return JSX9.isJsxText(node) && isWhiteSpace(node) && node.raw.includes("\n");
 }
 function trimLikeReact(text) {
   const leadingSpaces = /^\s*/.exec(text)?.[0] ?? "";
@@ -3084,10 +3212,10 @@ function trimLikeReact(text) {
 }
 function checkNode(context, node, allowExpressions) {
   const initialScope = context.sourceCode.getScope(node);
-  if (JSX8.isKeyedElement(node, initialScope)) {
+  if (JSX9.isKeyedElement(node, initialScope)) {
     return;
   }
-  if (JSX8.isHostElement(node.parent)) {
+  if (JSX9.isHostElement(node.parent)) {
     context.report({
       messageId: "uselessFragment",
       node,
@@ -3111,7 +3239,7 @@ function checkNode(context, node, allowExpressions) {
   const isChildElement = AST8.isOneOf([AST_NODE_TYPES.JSXElement, AST_NODE_TYPES.JSXFragment])(node.parent);
   switch (true) {
     // <Foo content={<>ee eeee eeee ...</>} />
-    case (allowExpressions && !isChildElement && node.children.length === 1 && JSX8.isJsxText(node.children.at(0))): {
+    case (allowExpressions && !isChildElement && node.children.length === 1 && JSX9.isJsxText(node.children.at(0))): {
       return;
     }
     // <Foo><>hello, world</></Foo>
@@ -3167,18 +3295,18 @@ function getFix2(context, node) {
 }
 function canFix(node) {
   if (node.parent.type === AST_NODE_TYPES.JSXElement || node.parent.type === AST_NODE_TYPES.JSXFragment) {
-    return JSX8.isHostElement(node.parent);
+    return JSX9.isHostElement(node.parent);
   }
   if (node.children.length === 0) {
     return false;
   }
-  if (node.children.some((child) => JSX8.isJsxText(child) && !isWhiteSpace(child) || AST8.is(AST_NODE_TYPES.JSXExpressionContainer)(child))) {
+  if (node.children.some((child) => JSX9.isJsxText(child) && !isWhiteSpace(child) || AST8.is(AST_NODE_TYPES.JSXExpressionContainer)(child))) {
     return false;
   }
   return true;
 }
-var RULE_NAME50 = "prefer-destructuring-assignment";
-var RULE_FEATURES49 = [];
+var RULE_NAME52 = "prefer-destructuring-assignment";
+var RULE_FEATURES51 = [];
 function isMemberExpressionWithObjectName(node) {
   return node.object.type === AST_NODE_TYPES.Identifier && "name" in node.object;
 }
@@ -3187,19 +3315,19 @@ var prefer_destructuring_assignment_default = createRule({
     type: "problem",
     docs: {
       description: "Enforces destructuring assignment for component props and context.",
-      [Symbol.for("rule_features")]: RULE_FEATURES49
+      [Symbol.for("rule_features")]: RULE_FEATURES51
     },
     messages: {
       preferDestructuringAssignment: "Use destructuring assignment for {{name}}."
     },
     schema: []
   },
-  name: RULE_NAME50,
-  create: create50,
+  name: RULE_NAME52,
+  create: create52,
   defaultOptions: []
 });
-function create50(context) {
-  const { ctx, listeners } = ER21.useComponentCollector(context);
+function create52(context) {
+  const { ctx, listeners } = ER22.useComponentCollector(context);
   const memberExpressionWithNames = [];
   return {
     ...listeners,
@@ -3209,16 +3337,16 @@ function create50(context) {
         memberExpressionWithNames.push([scope, node]);
       }
     },
-    "Program:exit"(node) {
+    "Program:exit"(program) {
       const components = [
-        ...ctx.getAllComponents(node).values()
+        ...ctx.getAllComponents(program).values()
       ];
       function isFunctionComponent(block) {
         if (!AST8.isFunction(block)) {
           return false;
         }
         const id = AST8.getFunctionIdentifier(block);
-        return id != null && ER21.isComponentNameLoose(id.name) && components.some((component) => component.node === block);
+        return id != null && ER22.isComponentNameLoose(id.name) && components.some((component) => component.node === block);
       }
       for (const [initialScope, memberExpression] of memberExpressionWithNames) {
         let scope = initialScope;
@@ -3235,7 +3363,7 @@ function create50(context) {
           continue;
         }
         const [props, ctx2] = component.params;
-        const isMatch = (node2) => node2 != null && node2.type === AST_NODE_TYPES.Identifier && node2.name === memberExpression.object.name;
+        const isMatch = (node) => node != null && node.type === AST_NODE_TYPES.Identifier && node.name === memberExpression.object.name;
         if (isMatch(props)) {
           context.report({
             messageId: "preferDestructuringAssignment",
@@ -3258,8 +3386,8 @@ function create50(context) {
     }
   };
 }
-var RULE_NAME51 = "prefer-react-namespace-import";
-var RULE_FEATURES50 = [
+var RULE_NAME53 = "prefer-react-namespace-import";
+var RULE_FEATURES52 = [
   "FIX"
 ];
 var prefer_react_namespace_import_default = createRule({
@@ -3267,7 +3395,7 @@ var prefer_react_namespace_import_default = createRule({
     type: "problem",
     docs: {
       description: "Enforces React is imported via a namespace import.",
-      [Symbol.for("rule_features")]: RULE_FEATURES50
+      [Symbol.for("rule_features")]: RULE_FEATURES52
     },
     fixable: "code",
     messages: {
@@ -3275,11 +3403,11 @@ var prefer_react_namespace_import_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME51,
-  create: create51,
+  name: RULE_NAME53,
+  create: create53,
   defaultOptions: []
 });
-function create51(context) {
+function create53(context) {
   const { importSource } = getSettingsFromContext(context);
   return {
     [`ImportDeclaration[source.value="${importSource}"] ImportDefaultSpecifier`](node) {
@@ -3314,8 +3442,8 @@ function create51(context) {
     }
   };
 }
-var RULE_NAME52 = "prefer-read-only-props";
-var RULE_FEATURES51 = [
+var RULE_NAME54 = "prefer-read-only-props";
+var RULE_FEATURES53 = [
   "TSC",
   "EXP"
 ];
@@ -3324,24 +3452,24 @@ var prefer_read_only_props_default = createRule({
     type: "problem",
     docs: {
       description: "Enforces read-only props in components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES51
+      [Symbol.for("rule_features")]: RULE_FEATURES53
     },
     messages: {
       preferReadOnlyProps: "A function component's props should be read-only."
     },
     schema: []
   },
-  name: RULE_NAME52,
-  create: create52,
+  name: RULE_NAME54,
+  create: create54,
   defaultOptions: []
 });
-function create52(context) {
+function create54(context) {
   const services = ESLintUtils.getParserServices(context, false);
-  const { ctx, listeners } = ER21.useComponentCollector(context);
+  const { ctx, listeners } = ER22.useComponentCollector(context);
   return {
     ...listeners,
-    "Program:exit"(node) {
-      const components = ctx.getAllComponents(node);
+    "Program:exit"(program) {
+      const components = ctx.getAllComponents(program);
       for (const [, component] of components) {
         const [props] = component.node.params;
         if (props == null) {
@@ -3365,8 +3493,8 @@ function isTypeReadonlyLoose(services, type) {
     return true;
   }
 }
-var RULE_NAME53 = "prefer-shorthand-boolean";
-var RULE_FEATURES52 = [
+var RULE_NAME55 = "prefer-shorthand-boolean";
+var RULE_FEATURES54 = [
   "FIX"
 ];
 var prefer_shorthand_boolean_default = createRule({
@@ -3374,7 +3502,7 @@ var prefer_shorthand_boolean_default = createRule({
     type: "problem",
     docs: {
       description: "Enforces shorthand syntax for boolean attributes.",
-      [Symbol.for("rule_features")]: RULE_FEATURES52
+      [Symbol.for("rule_features")]: RULE_FEATURES54
     },
     fixable: "code",
     messages: {
@@ -3382,15 +3510,15 @@ var prefer_shorthand_boolean_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME53,
-  create: create53,
+  name: RULE_NAME55,
+  create: create55,
   defaultOptions: []
 });
-function create53(context) {
+function create55(context) {
   return {
     JSXAttribute(node) {
       const { value } = node;
-      const propName = JSX8.getAttributeName(node);
+      const propName = JSX9.getAttributeName(node);
       const hasValueTrue = value?.type === AST_NODE_TYPES.JSXExpressionContainer && value.expression.type === AST_NODE_TYPES.Literal && value.expression.value === true;
       if (!hasValueTrue) {
         return;
@@ -3406,8 +3534,8 @@ function create53(context) {
     }
   };
 }
-var RULE_NAME54 = "prefer-shorthand-fragment";
-var RULE_FEATURES53 = [
+var RULE_NAME56 = "prefer-shorthand-fragment";
+var RULE_FEATURES55 = [
   "FIX"
 ];
 var prefer_shorthand_fragment_default = createRule({
@@ -3415,7 +3543,7 @@ var prefer_shorthand_fragment_default = createRule({
     type: "problem",
     docs: {
       description: "Enforces shorthand syntax for fragments.",
-      [Symbol.for("rule_features")]: RULE_FEATURES53
+      [Symbol.for("rule_features")]: RULE_FEATURES55
     },
     fixable: "code",
     messages: {
@@ -3423,14 +3551,14 @@ var prefer_shorthand_fragment_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME54,
-  create: create54,
+  name: RULE_NAME56,
+  create: create56,
   defaultOptions: []
 });
-function create54(context) {
+function create56(context) {
   return {
     JSXElement(node) {
-      if (!JSX8.isFragmentElement(node)) return;
+      if (!JSX9.isFragmentElement(node)) return;
       const hasAttributes = node.openingElement.attributes.length > 0;
       if (hasAttributes) {
         return;
@@ -3488,7 +3616,9 @@ var plugin = {
     "no-missing-component-display-name": no_missing_component_display_name_default,
     "no-missing-context-display-name": no_missing_context_display_name_default,
     "no-missing-key": no_missing_key_default,
+    "no-misused-capture-owner-stack": no_misused_capture_owner_stack_default,
     "no-nested-component-definitions": no_nested_component_definitions_default,
+    "no-nested-lazy-component-declarations": no_nested_lazy_component_declarations_default,
     "no-prop-types": no_prop_types_default,
     "no-redundant-should-component-update": no_redundant_should_component_update_default,
     "no-set-state-in-component-did-mount": no_set_state_in_component_did_mount_default,