eslint-plugin-react-x 2.0.0-beta.18 → 2.0.0-beta.2

package/dist/index.js

@@ -1,12 +1,12 @@
 import { getDocsUrl, getSettingsFromContext, coerceSettings, DEFAULT_ESLINT_REACT_SETTINGS } from '@eslint-react/shared';
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
 import { ESLintUtils } from '@typescript-eslint/utils';
-import * as AST7 from '@eslint-react/ast';
-import * as VAR3 from '@eslint-react/var';
+import * as AST13 from '@eslint-react/ast';
+import * as VAR5 from '@eslint-react/var';
 import { match, isMatching, P } from 'ts-pattern';
-import * as ER27 from '@eslint-react/core';
-import { JsxConfig, Reporter, Selector } from '@eslint-react/kit';
-import { getOrElseUpdate, constVoid, flow, identity, constTrue, constFalse, _ } from '@eslint-react/eff';
+import * as ER26 from '@eslint-react/core';
+import { JsxConfig, Reporter, Selector, LanguagePreference } from '@eslint-react/kit';
+import { flow, identity, getOrElseUpdate, constTrue, constFalse, unit } from '@eslint-react/eff';
 import { compare } from 'compare-versions';
 import { getConstrainedTypeAtLocation, isTypeReadonly } from '@typescript-eslint/type-utils';
 import { unionTypeParts, isTypeFlagSet, isTrueLiteralType, isFalseLiteralType } from 'ts-api-utils';
@@ -28,8 +28,8 @@ __export(recommended_exports, {
 });
 var name = "react-x/recommended";
 var rules = {
-  "react-x/jsx-no-comment-textnodes": "warn",
   "react-x/jsx-key-before-spread": "warn",
+  "react-x/jsx-no-comment-textnodes": "warn",
   "react-x/jsx-no-duplicate-props": "warn",
   // "react-x/jsx-no-undef": "error",
   "react-x/jsx-uses-react": "warn",
@@ -54,7 +54,6 @@ var rules = {
   // "react-x/prefer-destructuring-assignment": "warn",
   // "react-x/prefer-namespace-import": "warn",
   // "react-x/prefer-read-only-props": "error",
-  "react-x/no-direct-set-state-in-use-effect": "warn",
   "react-x/no-duplicate-key": "warn",
   "react-x/no-forward-ref": "warn",
   "react-x/no-implicit-key": "warn",
@@ -126,7 +125,7 @@ var settings3 = {
 
 // package.json
 var name4 = "eslint-plugin-react-x";
-var version = "2.0.0-beta.18";
+var version = "2.0.0-beta.2";
 var createRule = ESLintUtils.RuleCreator(getDocsUrl("x"));
 
 // src/rules/jsx-key-before-spread.ts
@@ -192,14 +191,14 @@ var jsx_no_comment_textnodes_default = createRule({
 });
 function create2(context) {
   function hasCommentLike(node) {
-    if (AST7.isOneOf([AST_NODE_TYPES.JSXAttribute, AST_NODE_TYPES.JSXExpressionContainer])(node.parent)) {
+    if (AST13.isOneOf([AST_NODE_TYPES.JSXAttribute, AST_NODE_TYPES.JSXExpressionContainer])(node.parent)) {
       return false;
     }
     const rawValue = context.sourceCode.getText(node);
     return /^\s*\/(?:\/|\*)/mu.test(rawValue);
   }
   const visitorFunction = (node) => {
-    if (!AST7.isOneOf([AST_NODE_TYPES.JSXElement, AST_NODE_TYPES.JSXFragment])(node.parent)) {
+    if (!AST13.isOneOf([AST_NODE_TYPES.JSXElement, AST_NODE_TYPES.JSXFragment])(node.parent)) {
       return;
     }
     if (!hasCommentLike(node)) {
@@ -260,17 +259,19 @@ function create3(context) {
     }
   };
 }
-var RULE_NAME4 = "jsx-no-undef";
-var RULE_FEATURES4 = [];
-var jsx_no_undef_default = createRule({
+var RULE_NAME4 = "jsx-no-iife";
+var RULE_FEATURES4 = [
+  "EXP"
+];
+var jsx_no_iife_default = createRule({
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow undefined variables in JSX.",
+      description: "Disallows 'IIFE' in JSX elements.",
       [Symbol.for("rule_features")]: RULE_FEATURES4
     },
     messages: {
-      jsxNoUndef: "JSX variable '{{name}}' is not defined."
+      jsxNoIife: "Avoid using IIFE in JSX elements."
     },
     schema: []
   },
@@ -279,13 +280,51 @@ var jsx_no_undef_default = createRule({
   defaultOptions: []
 });
 function create4(context) {
+  return {
+    "JSXElement :function"(node) {
+      if (node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node) {
+        context.report({
+          messageId: "jsxNoIife",
+          node: node.parent
+        });
+      }
+    },
+    "JSXFragment :function"(node) {
+      if (node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node) {
+        context.report({
+          messageId: "jsxNoIife",
+          node: node.parent
+        });
+      }
+    }
+  };
+}
+var RULE_NAME5 = "jsx-no-undef";
+var RULE_FEATURES5 = [];
+var jsx_no_undef_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow undefined variables in JSX.",
+      [Symbol.for("rule_features")]: RULE_FEATURES5
+    },
+    messages: {
+      jsxNoUndef: "JSX variable '{{name}}' is not defined."
+    },
+    schema: []
+  },
+  name: RULE_NAME5,
+  create: create5,
+  defaultOptions: []
+});
+function create5(context) {
   return {
     JSXOpeningElement(node) {
       const name5 = match(node.name).with({ type: AST_NODE_TYPES.JSXIdentifier }, (n) => n.name).with({ type: AST_NODE_TYPES.JSXMemberExpression, object: { type: AST_NODE_TYPES.JSXIdentifier } }, (n) => n.object.name).otherwise(() => null);
       if (name5 == null) return;
       if (name5 === "this") return;
       if (/^[a-z]/u.test(name5)) return;
-      if (VAR3.findVariable(name5, context.sourceCode.getScope(node)) == null) {
+      if (VAR5.findVariable(name5, context.sourceCode.getScope(node)) == null) {
         context.report({
           messageId: "jsxNoUndef",
           node,
@@ -297,8 +336,8 @@ function create4(context) {
     }
   };
 }
-var RULE_NAME5 = "jsx-shorthand-boolean";
-var RULE_FEATURES5 = [
+var RULE_NAME6 = "jsx-shorthand-boolean";
+var RULE_FEATURES6 = [
   "CFG",
   "FIX"
 ];
@@ -314,7 +353,7 @@ var jsx_shorthand_boolean_default = createRule({
     type: "problem",
     docs: {
       description: "Enforces shorthand syntax for boolean attributes.",
-      [Symbol.for("rule_features")]: RULE_FEATURES5
+      [Symbol.for("rule_features")]: RULE_FEATURES6
     },
     fixable: "code",
     messages: {
@@ -322,16 +361,16 @@ var jsx_shorthand_boolean_default = createRule({
     },
     schema
   },
-  name: RULE_NAME5,
-  create: create5,
+  name: RULE_NAME6,
+  create: create6,
   defaultOptions
 });
-function create5(context) {
+function create6(context) {
   const policy = context.options[0] ?? defaultOptions[0];
   return {
     JSXAttribute(node) {
       const { value } = node;
-      const propName = ER27.getAttributeName(context, node);
+      const propName = ER26.getAttributeName(context, node);
       switch (true) {
         case (policy === 1 && value?.type === AST_NODE_TYPES.JSXExpressionContainer && value.expression.type === AST_NODE_TYPES.Literal && value.expression.value === true): {
           context.report({
@@ -359,8 +398,8 @@ function create5(context) {
     }
   };
 }
-var RULE_NAME6 = "jsx-shorthand-fragment";
-var RULE_FEATURES6 = [
+var RULE_NAME7 = "jsx-shorthand-fragment";
+var RULE_FEATURES7 = [
   "CFG",
   "FIX"
 ];
@@ -376,7 +415,7 @@ var jsx_shorthand_fragment_default = createRule({
     type: "problem",
     docs: {
       description: "Enforces shorthand syntax for fragments.",
-      [Symbol.for("rule_features")]: RULE_FEATURES6
+      [Symbol.for("rule_features")]: RULE_FEATURES7
     },
     fixable: "code",
     messages: {
@@ -384,11 +423,11 @@ var jsx_shorthand_fragment_default = createRule({
     },
     schema: schema2
   },
-  name: RULE_NAME6,
-  create: create6,
+  name: RULE_NAME7,
+  create: create7,
   defaultOptions: defaultOptions2
 });
-function create6(context) {
+function create7(context) {
   const policy = context.options[0] ?? defaultOptions2[0];
   const jsxConfig = {
     ...JsxConfig.getFromContext(context),
@@ -397,7 +436,7 @@ function create6(context) {
   const { jsxFragmentFactory } = jsxConfig;
   return match(policy).with(1, () => ({
     JSXElement(node) {
-      if (!ER27.isFragmentElement(context, node)) return;
+      if (!ER26.isFragmentElement(context, node)) return;
       const hasAttributes = node.openingElement.attributes.length > 0;
       if (hasAttributes) return;
       context.report({
@@ -440,25 +479,25 @@ function create6(context) {
   })).otherwise(() => ({}));
 }
 var { JsxEmit } = JsxConfig;
-var RULE_NAME7 = "jsx-uses-react";
-var RULE_FEATURES7 = [];
+var RULE_NAME8 = "jsx-uses-react";
+var RULE_FEATURES8 = [];
 var jsx_uses_react_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Marks React variables as used when JSX is used.",
-      [Symbol.for("rule_features")]: RULE_FEATURES7
+      [Symbol.for("rule_features")]: RULE_FEATURES8
     },
     messages: {
       jsxUsesReact: "Marked {{name}} as used."
     },
     schema: []
   },
-  name: RULE_NAME7,
-  create: create7,
+  name: RULE_NAME8,
+  create: create8,
   defaultOptions: []
 });
-function create7(context) {
+function create8(context) {
   const jsxConfig = {
     ...JsxConfig.getFromContext(context),
     ...JsxConfig.getFromAnnotation(context)
@@ -487,25 +526,25 @@ function debugReport(context, node, name5) {
     data: { name: name5 }
   });
 }
-var RULE_NAME8 = "jsx-uses-vars";
-var RULE_FEATURES8 = [];
+var RULE_NAME9 = "jsx-uses-vars";
+var RULE_FEATURES9 = [];
 var jsx_uses_vars_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Marks variables used in JSX elements as used.",
-      [Symbol.for("rule_features")]: RULE_FEATURES8
+      [Symbol.for("rule_features")]: RULE_FEATURES9
     },
     messages: {
-      jsxUsesVars: ""
+      jsxUsesVars: "An identifier in JSX is marked as used."
     },
     schema: []
   },
-  name: RULE_NAME8,
-  create: create8,
+  name: RULE_NAME9,
+  create: create9,
   defaultOptions: []
 });
-function create8(context) {
+function create9(context) {
   return {
     JSXOpeningElement(node) {
       switch (node.name.type) {
@@ -527,8 +566,8 @@ function create8(context) {
     }
   };
 }
-var RULE_NAME9 = "no-access-state-in-setstate";
-var RULE_FEATURES9 = [];
+var RULE_NAME10 = "no-access-state-in-setstate";
+var RULE_FEATURES10 = [];
 function isKeyLiteral(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);
 }
@@ -537,18 +576,18 @@ var no_access_state_in_setstate_default = createRule({
     type: "problem",
     docs: {
       description: "Disallow accessing `this.state` inside `setState` calls.",
-      [Symbol.for("rule_features")]: RULE_FEATURES9
+      [Symbol.for("rule_features")]: RULE_FEATURES10
     },
     messages: {
       noAccessStateInSetstate: "Do not access 'this.state' within 'setState'. Use the update function instead."
     },
     schema: []
   },
-  name: RULE_NAME9,
-  create: create9,
+  name: RULE_NAME10,
+  create: create10,
   defaultOptions: []
 });
-function create9(context) {
+function create10(context) {
   if (!context.sourceCode.text.includes("setState")) {
     return {};
   }
@@ -557,31 +596,31 @@ function create9(context) {
   const setStateEntries = [];
   return {
     CallExpression(node) {
-      if (!ER27.isThisSetState(node)) {
+      if (!ER26.isThisSetState(node)) {
         return;
       }
       setStateEntries.push([node, false]);
     },
     "CallExpression:exit"(node) {
-      if (!ER27.isThisSetState(node)) {
+      if (!ER26.isThisSetState(node)) {
         return;
       }
       setStateEntries.pop();
     },
     ClassDeclaration(node) {
-      classEntries.push([node, ER27.isClassComponent(node)]);
+      classEntries.push([node, ER26.isClassComponent(node)]);
     },
     "ClassDeclaration:exit"() {
       classEntries.pop();
     },
     ClassExpression(node) {
-      classEntries.push([node, ER27.isClassComponent(node)]);
+      classEntries.push([node, ER26.isClassComponent(node)]);
     },
     "ClassExpression:exit"() {
       classEntries.pop();
     },
     MemberExpression(node) {
-      if (!AST7.isThisExpression(node.object)) {
+      if (!AST13.isThisExpression(node.object)) {
         return;
       }
       const [currClass, isComponent = false] = classEntries.at(-1) ?? [];
@@ -596,7 +635,7 @@ function create9(context) {
       if (setState == null || hasThisState) {
         return;
       }
-      if (AST7.getPropertyName(node.property) !== "state") {
+      if (AST13.getPropertyName(node.property) !== "state") {
         return;
       }
       context.report({ messageId: "noAccessStateInSetstate", node });
@@ -626,11 +665,11 @@ function create9(context) {
       if (setState == null || hasThisState) {
         return;
       }
-      if (node.init == null || !AST7.isThisExpression(node.init) || node.id.type !== AST_NODE_TYPES.ObjectPattern) {
+      if (node.init == null || !AST13.isThisExpression(node.init) || node.id.type !== AST_NODE_TYPES.ObjectPattern) {
         return;
       }
       const hasState = node.id.properties.some(
-        (prop) => prop.type === AST_NODE_TYPES.Property && isKeyLiteral(prop, prop.key) && AST7.getPropertyName(prop.key) === "state"
+        (prop) => prop.type === AST_NODE_TYPES.Property && isKeyLiteral(prop, prop.key) && AST13.getPropertyName(prop.key) === "state"
       );
       if (!hasState) {
         return;
@@ -639,8 +678,8 @@ function create9(context) {
     }
   };
 }
-var RULE_NAME10 = "no-array-index-key";
-var RULE_FEATURES10 = [];
+var RULE_NAME11 = "no-array-index-key";
+var RULE_FEATURES11 = [];
 var reactChildrenMethod = ["forEach", "map"];
 function isReactChildrenMethod(name5) {
   return reactChildrenMethod.some((method) => method === name5);
@@ -659,36 +698,36 @@ function isUsingReactChildren(context, node) {
     return true;
   }
   if (callee.object.type === AST_NODE_TYPES.MemberExpression && "name" in callee.object.object) {
-    return ER27.isInitializedFromReact(callee.object.object.name, importSource, initialScope);
+    return ER26.isInitializedFromReact(callee.object.object.name, importSource, initialScope);
   }
   return false;
 }
 function getMapIndexParamName(context, node) {
   const { callee } = node;
   if (callee.type !== AST_NODE_TYPES.MemberExpression) {
-    return _;
+    return unit;
   }
   if (callee.property.type !== AST_NODE_TYPES.Identifier) {
-    return _;
+    return unit;
   }
   const { name: name5 } = callee.property;
-  const indexPosition = AST7.getArrayMethodCallbackIndexParamPosition(name5);
+  const indexPosition = AST13.getArrayMethodCallbackIndexParamPosition(name5);
   if (indexPosition === -1) {
-    return _;
+    return unit;
   }
   const callbackArg = node.arguments[isUsingReactChildren(context, node) ? 1 : 0];
   if (callbackArg == null) {
-    return _;
+    return unit;
   }
-  if (!AST7.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(callbackArg)) {
-    return _;
+  if (!AST13.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(callbackArg)) {
+    return unit;
   }
   const { params } = callbackArg;
   if (params.length < indexPosition + 1) {
-    return _;
+    return unit;
   }
   const param = params.at(indexPosition);
-  return param != null && "name" in param ? param.name : _;
+  return param != null && "name" in param ? param.name : unit;
 }
 function getIdentifiersFromBinaryExpression(side) {
   if (side.type === AST_NODE_TYPES.Identifier) {
@@ -707,25 +746,25 @@ var no_array_index_key_default = createRule({
     type: "problem",
     docs: {
       description: "Disallow an item's index in the array as its key.",
-      [Symbol.for("rule_features")]: RULE_FEATURES10
+      [Symbol.for("rule_features")]: RULE_FEATURES11
     },
     messages: {
       noArrayIndexKey: "Do not use item index in the array as its key."
     },
     schema: []
   },
-  name: RULE_NAME10,
-  create: create10,
+  name: RULE_NAME11,
+  create: create11,
   defaultOptions: []
 });
-function create10(context) {
+function create11(context) {
   const report = Reporter.make(context);
   const indexParamNames = [];
   function isArrayIndex(node) {
     return node.type === AST_NODE_TYPES.Identifier && indexParamNames.some((name5) => name5 != null && name5 === node.name);
   }
   function isCreateOrCloneElementCall(node) {
-    return ER27.isCreateElementCall(context, node) || ER27.isCloneElementCall(context, node);
+    return ER26.isCreateElementCall(context, node) || ER26.isCloneElementCall(context, node);
   }
   function getReportDescriptors(node) {
     switch (node.type) {
@@ -820,28 +859,28 @@ function create10(context) {
     }
   };
 }
-var RULE_NAME11 = "no-children-count";
-var RULE_FEATURES11 = [];
+var RULE_NAME12 = "no-children-count";
+var RULE_FEATURES12 = [];
 var no_children_count_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow `Children.count`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES11
+      [Symbol.for("rule_features")]: RULE_FEATURES12
     },
     messages: {
       noChildrenCount: "Using 'Children.count' is uncommon and can lead to fragile code. Use alternatives instead."
     },
     schema: []
   },
-  name: RULE_NAME11,
-  create: create11,
+  name: RULE_NAME12,
+  create: create12,
   defaultOptions: []
 });
-function create11(context) {
+function create12(context) {
   return {
     MemberExpression(node) {
-      if (ER27.isChildrenCount(context, node)) {
+      if (ER26.isChildrenCount(context, node)) {
         context.report({
           messageId: "noChildrenCount",
           node: node.property
@@ -850,28 +889,28 @@ function create11(context) {
     }
   };
 }
-var RULE_NAME12 = "no-children-for-each";
-var RULE_FEATURES12 = [];
+var RULE_NAME13 = "no-children-for-each";
+var RULE_FEATURES13 = [];
 var no_children_for_each_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow 'Children.forEach'.",
-      [Symbol.for("rule_features")]: RULE_FEATURES12
+      [Symbol.for("rule_features")]: RULE_FEATURES13
     },
     messages: {
       noChildrenForEach: "Using 'Children.forEach' is uncommon and can lead to fragile code. Use alternatives instead."
     },
     schema: []
   },
-  name: RULE_NAME12,
-  create: create12,
+  name: RULE_NAME13,
+  create: create13,
   defaultOptions: []
 });
-function create12(context) {
+function create13(context) {
   return {
     MemberExpression(node) {
-      if (ER27.isChildrenForEach(context, node)) {
+      if (ER26.isChildrenForEach(context, node)) {
         context.report({
           messageId: "noChildrenForEach",
           node: node.property
@@ -880,28 +919,28 @@ function create12(context) {
     }
   };
 }
-var RULE_NAME13 = "no-children-map";
-var RULE_FEATURES13 = [];
+var RULE_NAME14 = "no-children-map";
+var RULE_FEATURES14 = [];
 var no_children_map_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow `Children.map`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES13
+      [Symbol.for("rule_features")]: RULE_FEATURES14
     },
     messages: {
       noChildrenMap: "Using 'Children.map' is uncommon and can lead to fragile code. Use alternatives instead."
     },
     schema: []
   },
-  name: RULE_NAME13,
-  create: create13,
+  name: RULE_NAME14,
+  create: create14,
   defaultOptions: []
 });
-function create13(context) {
+function create14(context) {
   return {
     MemberExpression(node) {
-      if (ER27.isChildrenMap(context, node)) {
+      if (ER26.isChildrenMap(context, node)) {
         context.report({
           messageId: "noChildrenMap",
           node: node.property
@@ -910,28 +949,28 @@ function create13(context) {
     }
   };
 }
-var RULE_NAME14 = "no-children-only";
-var RULE_FEATURES14 = [];
+var RULE_NAME15 = "no-children-only";
+var RULE_FEATURES15 = [];
 var no_children_only_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow `Children.only`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES14
+      [Symbol.for("rule_features")]: RULE_FEATURES15
     },
     messages: {
       noChildrenOnly: "Using 'Children.only' is uncommon and can lead to fragile code. Use alternatives instead."
     },
     schema: []
   },
-  name: RULE_NAME14,
-  create: create14,
+  name: RULE_NAME15,
+  create: create15,
   defaultOptions: []
 });
-function create14(context) {
+function create15(context) {
   return {
     MemberExpression(node) {
-      if (ER27.isChildrenOnly(context, node)) {
+      if (ER26.isChildrenOnly(context, node)) {
         context.report({
           messageId: "noChildrenOnly",
           node: node.property
@@ -940,29 +979,29 @@ function create14(context) {
     }
   };
 }
-var RULE_NAME15 = "no-children-prop";
-var RULE_FEATURES15 = [];
+var RULE_NAME16 = "no-children-prop";
+var RULE_FEATURES16 = [];
 var no_children_prop_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow passing `children` as a prop.",
-      [Symbol.for("rule_features")]: RULE_FEATURES15
+      [Symbol.for("rule_features")]: RULE_FEATURES16
     },
     messages: {
       noChildrenProp: "Do not pass 'children' as props."
     },
     schema: []
   },
-  name: RULE_NAME15,
-  create: create15,
+  name: RULE_NAME16,
+  create: create16,
   defaultOptions: []
 });
-function create15(context) {
+function create16(context) {
   return {
     JSXElement(node) {
       const attributes = node.openingElement.attributes;
-      const childrenProp = ER27.getAttribute(context, "children", attributes, context.sourceCode.getScope(node));
+      const childrenProp = ER26.getAttribute(context, "children", attributes, context.sourceCode.getScope(node));
       if (childrenProp != null) {
         context.report({
           messageId: "noChildrenProp",
@@ -972,28 +1011,28 @@ function create15(context) {
     }
   };
 }
-var RULE_NAME16 = "no-children-to-array";
-var RULE_FEATURES16 = [];
+var RULE_NAME17 = "no-children-to-array";
+var RULE_FEATURES17 = [];
 var no_children_to_array_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow `Children.toArray`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES16
+      [Symbol.for("rule_features")]: RULE_FEATURES17
     },
     messages: {
       noChildrenToArray: "Using 'Children.toArray' is uncommon and can lead to fragile code. Use alternatives instead."
     },
     schema: []
   },
-  name: RULE_NAME16,
-  create: create16,
+  name: RULE_NAME17,
+  create: create17,
   defaultOptions: []
 });
-function create16(context) {
+function create17(context) {
   return {
     MemberExpression(node) {
-      if (ER27.isChildrenToArray(context, node)) {
+      if (ER26.isChildrenToArray(context, node)) {
         context.report({
           messageId: "noChildrenToArray",
           node: node.property
@@ -1002,33 +1041,33 @@ function create16(context) {
     }
   };
 }
-var RULE_NAME17 = "no-class-component";
-var RULE_FEATURES17 = [];
+var RULE_NAME18 = "no-class-component";
+var RULE_FEATURES18 = [];
 var no_class_component_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow class components except for error boundaries.",
-      [Symbol.for("rule_features")]: RULE_FEATURES17
+      [Symbol.for("rule_features")]: RULE_FEATURES18
     },
     messages: {
       noClassComponent: "Avoid using class components. Use function components instead."
     },
     schema: []
   },
-  name: RULE_NAME17,
-  create: create17,
+  name: RULE_NAME18,
+  create: create18,
   defaultOptions: []
 });
-function create17(context) {
+function create18(context) {
   if (!context.sourceCode.text.includes("Component")) return {};
-  const { ctx, listeners } = ER27.useComponentCollectorLegacy();
+  const { ctx, listeners } = ER26.useComponentCollectorLegacy();
   return {
     ...listeners,
     "Program:exit"(program) {
       const components = ctx.getAllComponents(program);
       for (const { name: name5 = "anonymous", node: component } of components.values()) {
-        if (component.body.body.some((m) => ER27.isComponentDidCatch(m) || ER27.isGetDerivedStateFromError(m))) {
+        if (component.body.body.some((m) => ER26.isComponentDidCatch(m) || ER26.isGetDerivedStateFromError(m))) {
           continue;
         }
         context.report({
@@ -1042,28 +1081,28 @@ function create17(context) {
     }
   };
 }
-var RULE_NAME18 = "no-clone-element";
-var RULE_FEATURES18 = [];
+var RULE_NAME19 = "no-clone-element";
+var RULE_FEATURES19 = [];
 var no_clone_element_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow `cloneElement`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES18
+      [Symbol.for("rule_features")]: RULE_FEATURES19
     },
     messages: {
       noCloneElement: "Using 'cloneElement' is uncommon and can lead to fragile code. Use alternatives instead."
     },
     schema: []
   },
-  name: RULE_NAME18,
-  create: create18,
+  name: RULE_NAME19,
+  create: create19,
   defaultOptions: []
 });
-function create18(context) {
+function create19(context) {
   return {
     CallExpression(node) {
-      if (ER27.isCloneElementCall(context, node)) {
+      if (ER26.isCloneElementCall(context, node)) {
         context.report({
           messageId: "noCloneElement",
           node
@@ -1072,8 +1111,8 @@ function create18(context) {
     }
   };
 }
-var RULE_NAME19 = "no-component-will-mount";
-var RULE_FEATURES19 = [
+var RULE_NAME20 = "no-component-will-mount";
+var RULE_FEATURES20 = [
   "MOD"
 ];
 var no_component_will_mount_default = createRule({
@@ -1081,7 +1120,7 @@ var no_component_will_mount_default = createRule({
     type: "problem",
     docs: {
       description: "Replace usages of `componentWillMount` with `UNSAFE_componentWillMount`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES19
+      [Symbol.for("rule_features")]: RULE_FEATURES20
     },
     fixable: "code",
     messages: {
@@ -1089,13 +1128,13 @@ var no_component_will_mount_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME19,
-  create: create19,
+  name: RULE_NAME20,
+  create: create20,
   defaultOptions: []
 });
-function create19(context) {
+function create20(context) {
   if (!context.sourceCode.text.includes("componentWillMount")) return {};
-  const { ctx, listeners } = ER27.useComponentCollectorLegacy();
+  const { ctx, listeners } = ER26.useComponentCollectorLegacy();
   return {
     ...listeners,
     "Program:exit"(program) {
@@ -1103,7 +1142,7 @@ function create19(context) {
       for (const { node: component } of components.values()) {
         const { body } = component.body;
         for (const member of body) {
-          if (ER27.isComponentWillMount(member)) {
+          if (ER26.isComponentWillMount(member)) {
             context.report({
               messageId: "noComponentWillMount",
               node: member,
@@ -1120,8 +1159,8 @@ function create19(context) {
     }
   };
 }
-var RULE_NAME20 = "no-component-will-receive-props";
-var RULE_FEATURES20 = [
+var RULE_NAME21 = "no-component-will-receive-props";
+var RULE_FEATURES21 = [
   "MOD"
 ];
 var no_component_will_receive_props_default = createRule({
@@ -1129,7 +1168,7 @@ var no_component_will_receive_props_default = createRule({
     type: "problem",
     docs: {
       description: "Replace usages of `componentWillReceiveProps` with `UNSAFE_componentWillReceiveProps`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES20
+      [Symbol.for("rule_features")]: RULE_FEATURES21
     },
     fixable: "code",
     messages: {
@@ -1137,13 +1176,13 @@ var no_component_will_receive_props_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME20,
-  create: create20,
+  name: RULE_NAME21,
+  create: create21,
   defaultOptions: []
 });
-function create20(context) {
+function create21(context) {
   if (!context.sourceCode.text.includes("componentWillReceiveProps")) return {};
-  const { ctx, listeners } = ER27.useComponentCollectorLegacy();
+  const { ctx, listeners } = ER26.useComponentCollectorLegacy();
   return {
     ...listeners,
     "Program:exit"(program) {
@@ -1151,7 +1190,7 @@ function create20(context) {
       for (const { node: component } of components.values()) {
         const { body } = component.body;
         for (const member of body) {
-          if (ER27.isComponentWillReceiveProps(member)) {
+          if (ER26.isComponentWillReceiveProps(member)) {
             context.report({
               messageId: "noComponentWillReceiveProps",
               node: member,
@@ -1168,8 +1207,8 @@ function create20(context) {
     }
   };
 }
-var RULE_NAME21 = "no-component-will-update";
-var RULE_FEATURES21 = [
+var RULE_NAME22 = "no-component-will-update";
+var RULE_FEATURES22 = [
   "MOD"
 ];
 var no_component_will_update_default = createRule({
@@ -1177,7 +1216,7 @@ var no_component_will_update_default = createRule({
     type: "problem",
     docs: {
       description: "Replace usages of `componentWillUpdate` with `UNSAFE_componentWillUpdate`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES21
+      [Symbol.for("rule_features")]: RULE_FEATURES22
     },
     fixable: "code",
     messages: {
@@ -1185,13 +1224,13 @@ var no_component_will_update_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME21,
-  create: create21,
+  name: RULE_NAME22,
+  create: create22,
   defaultOptions: []
 });
-function create21(context) {
+function create22(context) {
   if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
-  const { ctx, listeners } = ER27.useComponentCollectorLegacy();
+  const { ctx, listeners } = ER26.useComponentCollectorLegacy();
   return {
     ...listeners,
     "Program:exit"(program) {
@@ -1199,7 +1238,7 @@ function create21(context) {
       for (const { node: component } of components.values()) {
         const { body } = component.body;
         for (const member of body) {
-          if (ER27.isComponentWillUpdate(member)) {
+          if (ER26.isComponentWillUpdate(member)) {
             context.report({
               messageId: "noComponentWillUpdate",
               node: member,
@@ -1216,8 +1255,8 @@ function create21(context) {
     }
   };
 }
-var RULE_NAME22 = "no-context-provider";
-var RULE_FEATURES22 = [
+var RULE_NAME23 = "no-context-provider";
+var RULE_FEATURES23 = [
   "MOD"
 ];
 var no_context_provider_default = createRule({
@@ -1225,7 +1264,7 @@ var no_context_provider_default = createRule({
     type: "problem",
     docs: {
       description: "Replace usages of `<Context.Provider>` with `<Context>`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES22
+      [Symbol.for("rule_features")]: RULE_FEATURES23
     },
     fixable: "code",
     messages: {
@@ -1233,17 +1272,17 @@ var no_context_provider_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME22,
-  create: create22,
+  name: RULE_NAME23,
+  create: create23,
   defaultOptions: []
 });
-function create22(context) {
+function create23(context) {
   if (!context.sourceCode.text.includes("Provider")) return {};
   const { version: version2 } = getSettingsFromContext(context);
   if (compare(version2, "19.0.0", "<")) return {};
   return {
     JSXElement(node) {
-      const fullName = ER27.getElementType(context, node);
+      const fullName = ER26.getElementType(context, node);
       const parts = fullName.split(".");
       const selfName = parts.pop();
       const contextFullName = parts.join(".");
@@ -1254,7 +1293,7 @@ function create22(context) {
         messageId: "noContextProvider",
         node,
         fix(fixer) {
-          if (!ER27.isComponentNameLoose(contextSelfName)) return null;
+          if (!ER26.isComponentNameLoose(contextSelfName)) return null;
           const openingElement = node.openingElement;
           const closingElement = node.closingElement;
           if (closingElement == null) {
@@ -1269,52 +1308,52 @@ function create22(context) {
     }
   };
 }
-var RULE_NAME23 = "no-create-ref";
-var RULE_FEATURES23 = [];
+var RULE_NAME24 = "no-create-ref";
+var RULE_FEATURES24 = [];
 var no_create_ref_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow `createRef` in function components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES23
+      [Symbol.for("rule_features")]: RULE_FEATURES24
     },
     messages: {
       noCreateRef: "[Deprecated] Use 'useRef' instead."
     },
     schema: []
   },
-  name: RULE_NAME23,
-  create: create23,
+  name: RULE_NAME24,
+  create: create24,
   defaultOptions: []
 });
-function create23(context) {
+function create24(context) {
   return {
     CallExpression(node) {
-      if (ER27.isCreateRefCall(context, node) && AST7.findParentNode(node, ER27.isClassComponent) == null) {
+      if (ER26.isCreateRefCall(context, node) && AST13.findParentNode(node, ER26.isClassComponent) == null) {
         context.report({ messageId: "noCreateRef", node });
       }
     }
   };
 }
-var RULE_NAME24 = "no-default-props";
-var RULE_FEATURES24 = [];
+var RULE_NAME25 = "no-default-props";
+var RULE_FEATURES25 = [];
 var no_default_props_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow `defaultProps` property in favor of ES6 default parameters.",
-      [Symbol.for("rule_features")]: RULE_FEATURES24
+      [Symbol.for("rule_features")]: RULE_FEATURES25
     },
     messages: {
       noDefaultProps: "[Deprecated] Use ES6 default parameters instead."
     },
     schema: []
   },
-  name: RULE_NAME24,
-  create: create24,
+  name: RULE_NAME25,
+  create: create25,
   defaultOptions: []
 });
-function create24(context) {
+function create25(context) {
   if (!context.sourceCode.text.includes("defaultProps")) return {};
   return {
     AssignmentExpression(node) {
@@ -1328,60 +1367,51 @@ function create24(context) {
       if (property.type !== AST_NODE_TYPES.Identifier || property.name !== "defaultProps") {
         return;
       }
-      if (!ER27.isComponentNameLoose(object.name)) {
+      if (!ER26.isComponentNameLoose(object.name)) {
         return;
       }
-      const variable = VAR3.findVariable(object.name, context.sourceCode.getScope(node));
-      const variableNode = VAR3.getVariableInitNode(variable, 0);
+      const variable = VAR5.findVariable(object.name, context.sourceCode.getScope(node));
+      const variableNode = VAR5.getVariableInitNode(variable, 0);
       if (variableNode == null) return;
-      if (!AST7.isFunction(variableNode) && !ER27.isClassComponent(variableNode)) return;
+      if (!AST13.isFunction(variableNode)) return;
       context.report({ messageId: "noDefaultProps", node: property });
-    },
-    PropertyDefinition(node) {
-      if (!ER27.isClassComponent(node.parent.parent)) {
-        return;
-      }
-      if (!node.static || node.key.type !== AST_NODE_TYPES.Identifier || node.key.name !== "defaultProps") {
-        return;
-      }
-      context.report({ messageId: "noDefaultProps", node });
     }
   };
 }
-var RULE_NAME25 = "no-direct-mutation-state";
-var RULE_FEATURES25 = [];
+var RULE_NAME26 = "no-direct-mutation-state";
+var RULE_FEATURES26 = [];
 function isConstructorFunction(node) {
-  return AST7.isOneOf([AST_NODE_TYPES.FunctionDeclaration, AST_NODE_TYPES.FunctionExpression])(node) && AST7.isMethodOrProperty(node.parent) && node.parent.key.type === AST_NODE_TYPES.Identifier && node.parent.key.name === "constructor";
+  return AST13.isOneOf([AST_NODE_TYPES.FunctionDeclaration, AST_NODE_TYPES.FunctionExpression])(node) && AST13.isMethodOrProperty(node.parent) && node.parent.key.type === AST_NODE_TYPES.Identifier && node.parent.key.name === "constructor";
 }
 var no_direct_mutation_state_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow direct mutation of `this.state`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES25
+      [Symbol.for("rule_features")]: RULE_FEATURES26
     },
     messages: {
       noDirectMutationState: "Do not mutate state directly. Use 'setState()' instead."
     },
     schema: []
   },
-  name: RULE_NAME25,
-  create: create25,
+  name: RULE_NAME26,
+  create: create26,
   defaultOptions: []
 });
-function create25(context) {
+function create26(context) {
   return {
     AssignmentExpression(node) {
-      if (!ER27.isAssignmentToThisState(node)) return;
-      const parentClass = AST7.findParentNode(
+      if (!ER26.isAssignmentToThisState(node)) return;
+      const parentClass = AST13.findParentNode(
         node,
-        AST7.isOneOf([
+        AST13.isOneOf([
           AST_NODE_TYPES.ClassDeclaration,
           AST_NODE_TYPES.ClassExpression
         ])
       );
       if (parentClass == null) return;
-      if (ER27.isClassComponent(parentClass) && context.sourceCode.getScope(node).block !== AST7.findParentNode(node, isConstructorFunction)) {
+      if (ER26.isClassComponent(parentClass) && context.sourceCode.getScope(node).block !== AST13.findParentNode(node, isConstructorFunction)) {
         context.report({
           messageId: "noDirectMutationState",
           node
@@ -1390,327 +1420,25 @@ function create25(context) {
     }
   };
 }
-var RULE_NAME26 = "no-direct-set-state-in-use-effect";
-var RULE_FEATURES26 = [
-  "EXP"
-];
-var no_direct_set_state_in_use_effect_default = createRule({
+var RULE_NAME27 = "no-duplicate-key";
+var RULE_FEATURES27 = [];
+var no_duplicate_key_default = createRule({
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow direct calls to the `set` function of `useState` in `useEffect`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES26
+      description: "Disallow duplicate `key` on elements in the same array or a list of `children`.",
+      [Symbol.for("rule_features")]: RULE_FEATURES27
     },
     messages: {
-      noDirectSetStateInUseEffect: "Do not call the 'set' function '{{name}}' of 'useState' directly in 'useEffect'."
+      noDuplicateKey: "A key must be unique. '{{value}}' is duplicated."
     },
     schema: []
   },
-  name: RULE_NAME26,
-  create: create26,
-  defaultOptions: []
-});
-function create26(context) {
-  if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
-  return useNoDirectSetStateInUseEffect(context, {
-    onViolation(ctx, node, data) {
-      ctx.report({ messageId: "noDirectSetStateInUseEffect", node, data });
-    },
-    useEffectKind: "useEffect"
-  });
-}
-function useNoDirectSetStateInUseEffect(context, options) {
-  const { onViolation, useEffectKind } = options;
-  const settings4 = getSettingsFromContext(context);
-  const hooks = settings4.additionalHooks;
-  const getText = (n) => context.sourceCode.getText(n);
-  const isUseEffectLikeCall = ER27.isReactHookCallWithNameAlias(context, useEffectKind, hooks[useEffectKind]);
-  const isUseStateCall = ER27.isReactHookCallWithNameAlias(context, "useState", hooks.useState);
-  const isUseMemoCall = ER27.isReactHookCallWithNameAlias(context, "useMemo", hooks.useMemo);
-  const isUseCallbackCall = ER27.isReactHookCallWithNameAlias(context, "useCallback", hooks.useCallback);
-  const functionEntries = [];
-  const setupFunctionRef = { current: null };
-  const setupFunctionIdentifiers = [];
-  const indFunctionCalls = [];
-  const indSetStateCalls = /* @__PURE__ */ new WeakMap();
-  const indSetStateCallsInUseEffectArg0 = /* @__PURE__ */ new WeakMap();
-  const indSetStateCallsInUseEffectSetup = /* @__PURE__ */ new Map();
-  const indSetStateCallsInUseMemoOrCallback = /* @__PURE__ */ new WeakMap();
-  const onSetupFunctionEnter = (node) => {
-    setupFunctionRef.current = node;
-  };
-  const onSetupFunctionExit = (node) => {
-    if (setupFunctionRef.current === node) {
-      setupFunctionRef.current = null;
-    }
-  };
-  function isFunctionOfUseEffectSetup(node) {
-    return node.parent?.type === AST_NODE_TYPES.CallExpression && node.parent.callee !== node && isUseEffectLikeCall(node.parent);
-  }
-  function getCallName(node) {
-    if (node.type === AST_NODE_TYPES.CallExpression) {
-      return AST7.toStringFormat(node.callee, getText);
-    }
-    return AST7.toStringFormat(node, getText);
-  }
-  function getCallKind(node) {
-    return match(node).when(isUseStateCall, () => "useState").when(isUseEffectLikeCall, () => useEffectKind).when(isSetStateCall, () => "setState").when(AST7.isThenCall, () => "then").otherwise(() => "other");
-  }
-  function getFunctionKind(node) {
-    return match(node).when(isFunctionOfUseEffectSetup, () => "setup").when(AST7.isImmediatelyInvokedFunction, () => "immediate").otherwise(() => "other");
-  }
-  function isIdFromUseStateCall(topLevelId, at) {
-    const variable = VAR3.findVariable(topLevelId, context.sourceCode.getScope(topLevelId));
-    const variableNode = VAR3.getVariableInitNode(variable, 0);
-    if (variableNode == null) return false;
-    if (variableNode.type !== AST_NODE_TYPES.CallExpression) return false;
-    if (!ER27.isReactHookCallWithNameAlias(context, "useState", hooks.useState)(variableNode)) return false;
-    const variableNodeParent = variableNode.parent;
-    if (!("id" in variableNodeParent) || variableNodeParent.id?.type !== AST_NODE_TYPES.ArrayPattern) {
-      return true;
-    }
-    return variableNodeParent.id.elements.findIndex((e) => e?.type === AST_NODE_TYPES.Identifier && e.name === topLevelId.name) === at;
-  }
-  function isSetStateCall(node) {
-    switch (node.callee.type) {
-      // const data = useState();
-      // data.at(1)();
-      case AST_NODE_TYPES.CallExpression: {
-        const { callee } = node.callee;
-        if (callee.type !== AST_NODE_TYPES.MemberExpression) {
-          return false;
-        }
-        if (!("name" in callee.object)) {
-          return false;
-        }
-        const isAt = callee.property.type === AST_NODE_TYPES.Identifier && callee.property.name === "at";
-        const [index] = node.callee.arguments;
-        if (!isAt || index == null) {
-          return false;
-        }
-        const indexScope = context.sourceCode.getScope(node);
-        const indexValue = VAR3.toStaticValue({
-          kind: "lazy",
-          node: index,
-          initialScope: indexScope
-        }).value;
-        return indexValue === 1 && isIdFromUseStateCall(callee.object);
-      }
-      // const [data, setData] = useState();
-      // setData();
-      case AST_NODE_TYPES.Identifier: {
-        return isIdFromUseStateCall(node.callee, 1);
-      }
-      // const data = useState();
-      // data[1]();
-      case AST_NODE_TYPES.MemberExpression: {
-        if (!("name" in node.callee.object)) {
-          return false;
-        }
-        const property = node.callee.property;
-        const propertyScope = context.sourceCode.getScope(node);
-        const propertyValue = VAR3.toStaticValue({
-          kind: "lazy",
-          node: property,
-          initialScope: propertyScope
-        }).value;
-        return propertyValue === 1 && isIdFromUseStateCall(node.callee.object, 1);
-      }
-      default: {
-        return false;
-      }
-    }
-  }
-  return {
-    ":function"(node) {
-      const kind = getFunctionKind(node);
-      functionEntries.push({ kind, node });
-      if (kind === "setup") {
-        onSetupFunctionEnter(node);
-      }
-    },
-    ":function:exit"(node) {
-      const { kind } = functionEntries.at(-1) ?? {};
-      if (kind === "setup") {
-        onSetupFunctionExit(node);
-      }
-      functionEntries.pop();
-    },
-    CallExpression(node) {
-      const setupFunction = setupFunctionRef.current;
-      const pEntry = functionEntries.at(-1);
-      if (pEntry == null || pEntry.node.async) {
-        return;
-      }
-      match(getCallKind(node)).with("setState", () => {
-        switch (true) {
-          case pEntry.node === setupFunction:
-          case (pEntry.kind === "immediate" && AST7.findParentNode(pEntry.node, AST7.isFunction) === setupFunction): {
-            onViolation(context, node, {
-              name: context.sourceCode.getText(node.callee)
-            });
-            return;
-          }
-          default: {
-            const vd = AST7.findParentNode(node, isVariableDeclaratorFromHookCall);
-            if (vd == null) getOrElseUpdate(indSetStateCalls, pEntry.node, () => []).push(node);
-            else getOrElseUpdate(indSetStateCallsInUseMemoOrCallback, vd.init, () => []).push(node);
-          }
-        }
-      }).with(useEffectKind, () => {
-        if (AST7.isFunction(node.arguments.at(0))) return;
-        setupFunctionIdentifiers.push(...AST7.getNestedIdentifiers(node));
-      }).with("other", () => {
-        if (pEntry.node !== setupFunction) return;
-        indFunctionCalls.push(node);
-      }).otherwise(constVoid);
-    },
-    Identifier(node) {
-      if (node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node) {
-        return;
-      }
-      if (!isIdFromUseStateCall(node, 1)) {
-        return;
-      }
-      switch (node.parent.type) {
-        case AST_NODE_TYPES.ArrowFunctionExpression: {
-          const parent = node.parent.parent;
-          if (parent.type !== AST_NODE_TYPES.CallExpression) {
-            break;
-          }
-          if (!isUseMemoCall(parent)) {
-            break;
-          }
-          const vd = AST7.findParentNode(parent, isVariableDeclaratorFromHookCall);
-          if (vd != null) {
-            getOrElseUpdate(indSetStateCallsInUseEffectArg0, vd.init, () => []).push(node);
-          }
-          break;
-        }
-        case AST_NODE_TYPES.CallExpression: {
-          if (node !== node.parent.arguments.at(0)) {
-            break;
-          }
-          if (isUseCallbackCall(node.parent)) {
-            const vd = AST7.findParentNode(node.parent, isVariableDeclaratorFromHookCall);
-            if (vd != null) {
-              getOrElseUpdate(indSetStateCallsInUseEffectArg0, vd.init, () => []).push(node);
-            }
-            break;
-          }
-          if (isUseEffectLikeCall(node.parent)) {
-            getOrElseUpdate(indSetStateCallsInUseEffectSetup, node.parent, () => []).push(node);
-          }
-        }
-      }
-    },
-    "Program:exit"() {
-      const getSetStateCalls = (id, initialScope) => {
-        const node = VAR3.getVariableInitNode(VAR3.findVariable(id, initialScope), 0);
-        switch (node?.type) {
-          case AST_NODE_TYPES.ArrowFunctionExpression:
-          case AST_NODE_TYPES.FunctionDeclaration:
-          case AST_NODE_TYPES.FunctionExpression:
-            return indSetStateCalls.get(node) ?? [];
-          case AST_NODE_TYPES.CallExpression:
-            return indSetStateCallsInUseMemoOrCallback.get(node) ?? indSetStateCallsInUseEffectArg0.get(node) ?? [];
-        }
-        return [];
-      };
-      for (const [, calls] of indSetStateCallsInUseEffectSetup) {
-        for (const call of calls) {
-          onViolation(context, call, { name: call.name });
-        }
-      }
-      for (const { callee } of indFunctionCalls) {
-        if (!("name" in callee)) {
-          continue;
-        }
-        const { name: name5 } = callee;
-        const setStateCalls = getSetStateCalls(name5, context.sourceCode.getScope(callee));
-        for (const setStateCall of setStateCalls) {
-          onViolation(context, setStateCall, {
-            name: getCallName(setStateCall)
-          });
-        }
-      }
-      for (const id of setupFunctionIdentifiers) {
-        const setStateCalls = getSetStateCalls(id.name, context.sourceCode.getScope(id));
-        for (const setStateCall of setStateCalls) {
-          onViolation(context, setStateCall, {
-            name: getCallName(setStateCall)
-          });
-        }
-      }
-    }
-  };
-}
-function isInitFromHookCall(init) {
-  if (init?.type !== AST_NODE_TYPES.CallExpression) return false;
-  switch (init.callee.type) {
-    case AST_NODE_TYPES.Identifier:
-      return ER27.isReactHookName(init.callee.name);
-    case AST_NODE_TYPES.MemberExpression:
-      return init.callee.property.type === AST_NODE_TYPES.Identifier && ER27.isReactHookName(init.callee.property.name);
-    default:
-      return false;
-  }
-}
-function isVariableDeclaratorFromHookCall(node) {
-  if (node.type !== AST_NODE_TYPES.VariableDeclarator) return false;
-  if (node.id.type !== AST_NODE_TYPES.Identifier) return false;
-  return isInitFromHookCall(node.init);
-}
-
-// src/rules/no-direct-set-state-in-use-layout-effect.ts
-var RULE_NAME27 = "no-direct-set-state-in-use-layout-effect";
-var RULE_FEATURES27 = [
-  "EXP"
-];
-var no_direct_set_state_in_use_layout_effect_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow direct calls to the `set` function of `useState` in `useLayoutEffect`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES27
-    },
-    messages: {
-      noDirectSetStateInUseLayoutEffect: "Do not call the 'set' function '{{name}}' of 'useState' directly in 'useLayoutEffect'."
-    },
-    schema: []
-  },
-  name: RULE_NAME27,
-  create: create27,
+  name: RULE_NAME27,
+  create: create27,
   defaultOptions: []
 });
 function create27(context) {
-  if (!/use\w*Effect/u.test(context.sourceCode.text)) return {};
-  return useNoDirectSetStateInUseEffect(context, {
-    onViolation(ctx, node, data) {
-      ctx.report({ messageId: "noDirectSetStateInUseLayoutEffect", node, data });
-    },
-    useEffectKind: "useLayoutEffect"
-  });
-}
-var RULE_NAME28 = "no-duplicate-key";
-var RULE_FEATURES28 = [];
-var no_duplicate_key_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow duplicate `key` on elements in the same array or a list of `children`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES28
-    },
-    messages: {
-      noDuplicateKey: "A key must be unique. '{{value}}' is duplicated."
-    },
-    schema: []
-  },
-  name: RULE_NAME28,
-  create: create28,
-  defaultOptions: []
-});
-function create28(context) {
   if (!context.sourceCode.getText().includes("key=")) {
     return {};
   }
@@ -1721,7 +1449,7 @@ function create28(context) {
     if (aValue == null || bValue == null) {
       return false;
     }
-    return AST7.isNodeEqual(aValue, bValue);
+    return AST13.isNodeEqual(aValue, bValue);
   }
   return {
     "JSXAttribute[name.name='key']"(node) {
@@ -1740,12 +1468,12 @@ function create28(context) {
           break;
         }
         default: {
-          const call = AST7.findParentNode(jsxElement, AST7.isArrayMapCall);
-          const iter = AST7.findParentNode(jsxElement, (n) => n === call || AST7.isFunction(n));
-          if (!AST7.isFunction(iter)) return;
+          const call = AST13.findParentNode(jsxElement, AST13.isArrayMapCall);
+          const iter = AST13.findParentNode(jsxElement, (n) => n === call || AST13.isFunction(n));
+          if (!AST13.isFunction(iter)) return;
           const arg0 = call?.arguments[0];
           if (call == null || arg0 == null) return;
-          if (AST7.getJSExpression(arg0) !== iter) {
+          if (AST13.getJSExpression(arg0) !== iter) {
             return;
           }
           keyedEntries.set(call, {
@@ -1774,8 +1502,8 @@ function create28(context) {
     }
   };
 }
-var RULE_NAME29 = "no-forward-ref";
-var RULE_FEATURES29 = [
+var RULE_NAME28 = "no-forward-ref";
+var RULE_FEATURES28 = [
   "MOD"
 ];
 var no_forward_ref_default = createRule({
@@ -1783,7 +1511,7 @@ var no_forward_ref_default = createRule({
     type: "problem",
     docs: {
       description: "Replaces usages of `forwardRef` with passing `ref` as a prop.",
-      [Symbol.for("rule_features")]: RULE_FEATURES29
+      [Symbol.for("rule_features")]: RULE_FEATURES28
     },
     fixable: "code",
     messages: {
@@ -1791,11 +1519,11 @@ var no_forward_ref_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME29,
-  create: create29,
+  name: RULE_NAME28,
+  create: create28,
   defaultOptions: []
 });
-function create29(context) {
+function create28(context) {
   if (!context.sourceCode.text.includes("forwardRef")) {
     return {};
   }
@@ -1805,10 +1533,10 @@ function create29(context) {
   }
   return {
     CallExpression(node) {
-      if (!ER27.isForwardRefCall(context, node)) {
+      if (!ER26.isForwardRefCall(context, node)) {
         return;
       }
-      const id = AST7.getFunctionId(node);
+      const id = AST13.getFunctionId(node);
       context.report({
         messageId: "noForwardRef",
         node: id ?? node,
@@ -1820,7 +1548,7 @@ function create29(context) {
 function getFix(context, node) {
   return (fixer) => {
     const [componentNode] = node.arguments;
-    if (componentNode == null || !AST7.isFunction(componentNode)) {
+    if (componentNode == null || !AST13.isFunction(componentNode)) {
       return [];
     }
     return [
@@ -1884,8 +1612,8 @@ function getComponentPropsFixes(context, fixer, node, typeArguments) {
     ...arg1 == null ? [] : [fixer.remove(arg1), fixer.removeRange([arg0.range[1], arg1.range[0]])]
   ];
 }
-var RULE_NAME30 = "no-implicit-key";
-var RULE_FEATURES30 = [
+var RULE_NAME29 = "no-implicit-key";
+var RULE_FEATURES29 = [
   "EXP"
 ];
 var no_implicit_key_default = createRule({
@@ -1893,22 +1621,22 @@ var no_implicit_key_default = createRule({
     type: "problem",
     docs: {
       description: "Prevents `key` from not being explicitly specified (e.g. spreading `key` from objects).",
-      [Symbol.for("rule_features")]: RULE_FEATURES30
+      [Symbol.for("rule_features")]: RULE_FEATURES29
     },
     messages: {
       noImplicitKey: "Do not use implicit 'key' props."
     },
     schema: []
   },
-  name: RULE_NAME30,
-  create: create30,
+  name: RULE_NAME29,
+  create: create29,
   defaultOptions: []
 });
-function create30(context) {
+function create29(context) {
   return {
     JSXOpeningElement(node) {
       const initialScope = context.sourceCode.getScope(node);
-      const keyProp = ER27.getAttribute(context, "key", node.attributes, initialScope);
+      const keyProp = ER26.getAttribute(context, "key", node.attributes, initialScope);
       const isKeyPropOnElement = node.attributes.some(
         (n) => n.type === AST_NODE_TYPES.JSXAttribute && n.name.type === AST_NODE_TYPES.JSXIdentifier && n.name.name === "key"
       );
@@ -1918,8 +1646,8 @@ function create30(context) {
     }
   };
 }
-var RULE_NAME31 = "no-leaked-conditional-rendering";
-var RULE_FEATURES31 = [
+var RULE_NAME30 = "no-leaked-conditional-rendering";
+var RULE_FEATURES30 = [
   "TSC"
 ];
 var tsHelpers = {
@@ -2005,18 +1733,18 @@ var no_leaked_conditional_rendering_default = createRule({
     type: "problem",
     docs: {
       description: "Prevents problematic leaked values from being rendered.",
-      [Symbol.for("rule_features")]: RULE_FEATURES31
+      [Symbol.for("rule_features")]: RULE_FEATURES30
     },
     messages: {
       noLeakedConditionalRendering: "Potential leaked value {{value}} that might cause unintentionally rendered values or rendering crashes."
     },
     schema: []
   },
-  name: RULE_NAME31,
-  create: create31,
+  name: RULE_NAME30,
+  create: create30,
   defaultOptions: []
 });
-function create31(context) {
+function create30(context) {
   if (!context.sourceCode.text.includes("&&")) return {};
   const { version: version2 } = getSettingsFromContext(context);
   const allowedVariants = [
@@ -2033,17 +1761,17 @@ function create31(context) {
   ];
   const services = ESLintUtils.getParserServices(context, false);
   function getReportDescriptor(node) {
-    if (node == null) return _;
-    if (AST7.is(AST_NODE_TYPES.JSXExpressionContainer)(node)) return getReportDescriptor(node.expression);
-    if (AST7.isJSX(node)) return _;
-    if (AST7.isTypeExpression(node)) return getReportDescriptor(node.expression);
+    if (node == null) return unit;
+    if (AST13.is(AST_NODE_TYPES.JSXExpressionContainer)(node)) return getReportDescriptor(node.expression);
+    if (AST13.isJSX(node)) return unit;
+    if (AST13.isTypeExpression(node)) return getReportDescriptor(node.expression);
     return match(node).with({ type: AST_NODE_TYPES.LogicalExpression, operator: "&&" }, ({ left, right }) => {
       const isLeftUnaryNot = left.type === AST_NODE_TYPES.UnaryExpression && left.operator === "!";
       if (isLeftUnaryNot) {
         return getReportDescriptor(right);
       }
       const initialScope = context.sourceCode.getScope(left);
-      const isLeftNan = left.type === AST_NODE_TYPES.Identifier && left.name === "NaN" || VAR3.toStaticValue({ kind: "lazy", node: left, initialScope }).value === "NaN";
+      const isLeftNan = left.type === AST_NODE_TYPES.Identifier && left.name === "NaN" || VAR5.toStaticValue({ kind: "lazy", node: left, initialScope }).value === "NaN";
       if (isLeftNan) {
         return {
           messageId: "noLeakedConditionalRendering",
@@ -2065,44 +1793,44 @@ function create31(context) {
     }).with({ type: AST_NODE_TYPES.ConditionalExpression }, ({ alternate, consequent }) => {
       return getReportDescriptor(consequent) ?? getReportDescriptor(alternate);
     }).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-      const variable = VAR3.findVariable(n.name, context.sourceCode.getScope(n));
+      const variable = VAR5.findVariable(n.name, context.sourceCode.getScope(n));
       const variableDefNode = variable?.defs.at(0)?.node;
-      return match(variableDefNode).with({ init: P.select({ type: P.not(AST_NODE_TYPES.VariableDeclaration) }) }, getReportDescriptor).otherwise(() => _);
-    }).otherwise(() => _);
+      return match(variableDefNode).with({ init: P.select({ type: P.not(AST_NODE_TYPES.VariableDeclaration) }) }, getReportDescriptor).otherwise(() => unit);
+    }).otherwise(() => unit);
   }
   return {
     JSXExpressionContainer: flow(getReportDescriptor, Reporter.make(context).send)
   };
 }
-var RULE_NAME32 = "no-missing-component-display-name";
-var RULE_FEATURES32 = [];
+var RULE_NAME31 = "no-missing-component-display-name";
+var RULE_FEATURES31 = [];
 var no_missing_component_display_name_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Enforces that all components have a `displayName` which can be used in devtools.",
-      [Symbol.for("rule_features")]: RULE_FEATURES32
+      [Symbol.for("rule_features")]: RULE_FEATURES31
     },
     messages: {
       noMissingComponentDisplayName: "Add missing 'displayName' for component."
     },
     schema: []
   },
-  name: RULE_NAME32,
-  create: create32,
+  name: RULE_NAME31,
+  create: create31,
   defaultOptions: []
 });
-function create32(context) {
+function create31(context) {
   if (!context.sourceCode.text.includes("memo") && !context.sourceCode.text.includes("forwardRef")) return {};
   const {
     ctx,
     listeners
-  } = ER27.useComponentCollector(
+  } = ER26.useComponentCollector(
     context,
     {
       collectDisplayName: true,
       collectHookCalls: false,
-      hint: ER27.DEFAULT_COMPONENT_DETECTION_HINT
+      hint: ER26.DEFAULT_COMPONENT_DETECTION_HINT
     }
   );
   return {
@@ -2110,15 +1838,15 @@ function create32(context) {
     "Program:exit"(program) {
       const components = ctx.getAllComponents(program);
       for (const { node, displayName, flag } of components.values()) {
-        const isMemoOrForwardRef = (flag & (ER27.ComponentFlag.ForwardRef | ER27.ComponentFlag.Memo)) > 0n;
-        if (AST7.getFunctionId(node) != null) {
+        const isMemoOrForwardRef = (flag & (ER26.ComponentFlag.ForwardRef | ER26.ComponentFlag.Memo)) > 0n;
+        if (AST13.getFunctionId(node) != null) {
           continue;
         }
         if (!isMemoOrForwardRef) {
           continue;
         }
         if (displayName == null) {
-          const id = AST7.getFunctionId(node);
+          const id = AST13.getFunctionId(node);
           context.report({
             messageId: "noMissingComponentDisplayName",
             node: id ?? node
@@ -2128,36 +1856,39 @@ function create32(context) {
     }
   };
 }
-var RULE_NAME33 = "no-missing-context-display-name";
-var RULE_FEATURES33 = [];
+var RULE_NAME32 = "no-missing-context-display-name";
+var RULE_FEATURES32 = [
+  "FIX"
+];
 var no_missing_context_display_name_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Enforces that all contexts have a `displayName` which can be used in devtools.",
-      [Symbol.for("rule_features")]: RULE_FEATURES33
+      [Symbol.for("rule_features")]: RULE_FEATURES32
     },
+    fixable: "code",
     messages: {
       noMissingContextDisplayName: "Add missing 'displayName' for context."
     },
     schema: []
   },
-  name: RULE_NAME33,
-  create: create33,
+  name: RULE_NAME32,
+  create: create32,
   defaultOptions: []
 });
-function create33(context) {
+function create32(context) {
   if (!context.sourceCode.text.includes("createContext")) return {};
   const createCalls = [];
   const displayNameAssignments = [];
   return {
     CallExpression(node) {
-      if (!ER27.isCreateContextCall(context, node)) return;
+      if (!ER26.isCreateContextCall(context, node)) return;
       createCalls.push(node);
     },
     "Program:exit"() {
       for (const call of createCalls) {
-        const id = ER27.getInstanceId(call);
+        const id = ER26.getInstanceId(call);
         if (id == null) {
           context.report({
             messageId: "noMissingContextDisplayName",
@@ -2169,12 +1900,30 @@ function create33(context) {
           const left = node.left;
           if (left.type !== AST_NODE_TYPES.MemberExpression) return false;
           const object = left.object;
-          return ER27.isInstanceIdEqual(context, id, object);
+          return ER26.isInstanceIdEqual(context, id, object);
         });
         if (!hasDisplayNameAssignment) {
+          const semi = LanguagePreference.defaultLanguagePreference.semicolons === "always" ? ";" : "";
           context.report({
             messageId: "noMissingContextDisplayName",
-            node: id
+            node: id,
+            fix(fixer) {
+              if (id.type !== AST_NODE_TYPES.Identifier || id.parent !== call.parent) return [];
+              return fixer.insertTextAfter(
+                context.sourceCode.getTokenAfter(call) ?? call,
+                [
+                  "\n",
+                  id.name,
+                  ".",
+                  "displayName",
+                  " ",
+                  "=",
+                  " ",
+                  JSON.stringify(id.name),
+                  semi
+                ].join("")
+              );
+            }
           });
         }
       }
@@ -2184,14 +1933,14 @@ function create33(context) {
     }
   };
 }
-var RULE_NAME34 = "no-missing-key";
-var RULE_FEATURES34 = [];
+var RULE_NAME33 = "no-missing-key";
+var RULE_FEATURES33 = [];
 var no_missing_key_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow missing `key` on items in list rendering.",
-      [Symbol.for("rule_features")]: RULE_FEATURES34
+      [Symbol.for("rule_features")]: RULE_FEATURES33
     },
     messages: {
       missingKey: "Missing 'key' for element when rendering list.",
@@ -2199,18 +1948,18 @@ var no_missing_key_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME34,
-  create: create34,
+  name: RULE_NAME33,
+  create: create33,
   defaultOptions: []
 });
-function create34(context) {
+function create33(context) {
   const report = Reporter.make(context);
   const state = { isWithinChildrenToArray: false };
   function checkIteratorElement(node) {
     switch (node.type) {
       case AST_NODE_TYPES.JSXElement: {
         const initialScope = context.sourceCode.getScope(node);
-        if (!ER27.hasAttribute(context, "key", node.openingElement.attributes, initialScope)) {
+        if (!ER26.hasAttribute(context, "key", node.openingElement.attributes, initialScope)) {
           return {
             messageId: "missingKey",
             node
@@ -2249,7 +1998,7 @@ function create34(context) {
   }
   function checkBlockStatement(node) {
     const descriptors = [];
-    for (const statement of AST7.getNestedReturnStatements(node)) {
+    for (const statement of AST13.getNestedReturnStatements(node)) {
       if (statement.argument == null) continue;
       const descriptor = checkIteratorElement(statement.argument);
       if (descriptor != null) descriptors.push(descriptor);
@@ -2261,13 +2010,13 @@ function create34(context) {
       if (state.isWithinChildrenToArray) {
         return;
       }
-      const elements = node.elements.filter(AST7.is(AST_NODE_TYPES.JSXElement));
+      const elements = node.elements.filter(AST13.is(AST_NODE_TYPES.JSXElement));
       if (elements.length === 0) {
         return;
       }
       const initialScope = context.sourceCode.getScope(node);
       for (const element of elements) {
-        if (!ER27.hasAttribute(context, "key", element.openingElement.attributes, initialScope)) {
+        if (!ER26.hasAttribute(context, "key", element.openingElement.attributes, initialScope)) {
           report.send({
             messageId: "missingKey",
             node: element
@@ -2276,10 +2025,10 @@ function create34(context) {
       }
     },
     CallExpression(node) {
-      state.isWithinChildrenToArray ||= ER27.isChildrenToArrayCall(context, node);
+      state.isWithinChildrenToArray ||= ER26.isChildrenToArrayCall(context, node);
       if (state.isWithinChildrenToArray) return;
-      const callback = match(node).when(AST7.isArrayMapCall, (n) => n.arguments[0]).when(AST7.isArrayFromCall, (n) => n.arguments[1]).otherwise(() => null);
-      if (!AST7.isFunction(callback)) return;
+      const callback = match(node).when(AST13.isArrayMapCall, (n) => n.arguments[0]).when(AST13.isArrayFromCall, (n) => n.arguments[1]).otherwise(() => null);
+      if (!AST13.isFunction(callback)) return;
       const body = callback.body;
       if (body.type === AST_NODE_TYPES.BlockStatement) {
         checkBlockStatement(body).forEach(report.send);
@@ -2288,7 +2037,7 @@ function create34(context) {
       report.send(checkExpression(body));
     },
     "CallExpression:exit"(node) {
-      if (!ER27.isChildrenToArrayCall(context, node)) {
+      if (!ER26.isChildrenToArrayCall(context, node)) {
         return;
       }
       state.isWithinChildrenToArray = false;
@@ -2306,8 +2055,8 @@ function create34(context) {
     }
   };
 }
-var RULE_NAME35 = "no-misused-capture-owner-stack";
-var RULE_FEATURES35 = [
+var RULE_NAME34 = "no-misused-capture-owner-stack";
+var RULE_FEATURES34 = [
   "EXP"
 ];
 var no_misused_capture_owner_stack_default = createRule({
@@ -2315,7 +2064,7 @@ var no_misused_capture_owner_stack_default = createRule({
     type: "problem",
     docs: {
       description: "Prevents incorrect usage of `captureOwnerStack`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES35
+      [Symbol.for("rule_features")]: RULE_FEATURES34
     },
     fixable: "code",
     messages: {
@@ -2325,17 +2074,17 @@ var no_misused_capture_owner_stack_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME35,
-  create: create35,
+  name: RULE_NAME34,
+  create: create34,
   defaultOptions: []
 });
-function create35(context) {
+function create34(context) {
   if (!context.sourceCode.text.includes("captureOwnerStack")) return {};
   const { importSource } = getSettingsFromContext(context);
   return {
     CallExpression(node) {
-      if (!ER27.isCaptureOwnerStackCall(context, node)) return;
-      if (AST7.findParentNode(node, isDevelopmentOnlyCheck) == null) {
+      if (!ER26.isCaptureOwnerStackCall(context, node)) return;
+      if (AST13.findParentNode(node, isDevelopmentOnlyCheck) == null) {
         context.report({
           messageId: "missingDevelopmentOnlyCheck",
           node
@@ -2359,31 +2108,31 @@ function create35(context) {
 }
 function isDevelopmentOnlyCheck(node) {
   if (node.type !== AST_NODE_TYPES.IfStatement) return false;
-  if (AST7.isProcessEnvNodeEnvCompare(node.test, "!==", "production")) return true;
+  if (AST13.isProcessEnvNodeEnvCompare(node.test, "!==", "production")) return true;
   return false;
 }
-var RULE_NAME36 = "no-nested-component-definitions";
-var RULE_FEATURES36 = [];
+var RULE_NAME35 = "no-nested-component-definitions";
+var RULE_FEATURES35 = [];
 var no_nested_component_definitions_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow nesting component definitions inside other components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES36
+      [Symbol.for("rule_features")]: RULE_FEATURES35
     },
     messages: {
       noNestedComponentDefinitions: "Do not nest component definitions inside other components or props. {{suggestion}}"
     },
     schema: []
   },
-  name: RULE_NAME36,
-  create: create36,
+  name: RULE_NAME35,
+  create: create35,
   defaultOptions: []
 });
-function create36(context) {
-  const hint = ER27.ComponentDetectionHint.SkipArrayMapArgument | ER27.ComponentDetectionHint.SkipNullLiteral | ER27.ComponentDetectionHint.SkipUndefined | ER27.ComponentDetectionHint.SkipBooleanLiteral | ER27.ComponentDetectionHint.SkipStringLiteral | ER27.ComponentDetectionHint.SkipNumberLiteral | ER27.ComponentDetectionHint.StrictLogical | ER27.ComponentDetectionHint.StrictConditional;
-  const collector = ER27.useComponentCollector(context, { hint });
-  const collectorLegacy = ER27.useComponentCollectorLegacy();
+function create35(context) {
+  const hint = ER26.ComponentDetectionHint.SkipArrayMapArgument | ER26.ComponentDetectionHint.SkipNullLiteral | ER26.ComponentDetectionHint.SkipUndefined | ER26.ComponentDetectionHint.SkipBooleanLiteral | ER26.ComponentDetectionHint.SkipStringLiteral | ER26.ComponentDetectionHint.SkipNumberLiteral | ER26.ComponentDetectionHint.StrictLogical | ER26.ComponentDetectionHint.StrictConditional;
+  const collector = ER26.useComponentCollector(context, { hint });
+  const collectorLegacy = ER26.useComponentCollectorLegacy();
   return {
     ...collector.listeners,
     ...collectorLegacy.listeners,
@@ -2395,16 +2144,16 @@ function create36(context) {
         ...collectorLegacy.ctx.getAllComponents(program).values()
       ];
       const isFunctionComponent = (node) => {
-        return AST7.isFunction(node) && functionComponents.some((component) => component.node === node);
+        return AST13.isFunction(node) && functionComponents.some((component) => component.node === node);
       };
-      const isClassComponent13 = (node) => {
-        return AST7.isClass(node) && classComponents.some((component) => component.node === node);
+      const isClassComponent12 = (node) => {
+        return AST13.isClass(node) && classComponents.some((component) => component.node === node);
       };
       for (const { name: name5, node: component } of functionComponents) {
         if (name5 == null) continue;
-        if (ER27.isDirectValueOfRenderPropertyLoose(component)) continue;
+        if (ER26.isDirectValueOfRenderPropertyLoose(component)) continue;
         if (isInsideJSXAttributeValue(component)) {
-          if (!ER27.isDeclaredInRenderPropLoose(component)) {
+          if (!ER26.isDeclaredInRenderPropLoose(component)) {
             context.report({
               messageId: "noNestedComponentDefinitions",
               node: component,
@@ -2427,8 +2176,8 @@ function create36(context) {
           });
           continue;
         }
-        const parentComponent = AST7.findParentNode(component, isFunctionComponent);
-        if (parentComponent != null && !ER27.isDirectValueOfRenderPropertyLoose(parentComponent)) {
+        const parentComponent = AST13.findParentNode(component, isFunctionComponent);
+        if (parentComponent != null && !ER26.isDirectValueOfRenderPropertyLoose(parentComponent)) {
           context.report({
             messageId: "noNestedComponentDefinitions",
             node: component,
@@ -2451,7 +2200,7 @@ function create36(context) {
         }
       }
       for (const { name: name5 = "unknown", node: component } of classComponents) {
-        if (AST7.findParentNode(component, (n) => isClassComponent13(n) || isFunctionComponent(n)) == null) {
+        if (AST13.findParentNode(component, (n) => isClassComponent12(n) || isFunctionComponent(n)) == null) {
           continue;
         }
         context.report({
@@ -2467,46 +2216,46 @@ function create36(context) {
   };
 }
 function isInsideJSXAttributeValue(node) {
-  return node.parent.type === AST_NODE_TYPES.JSXAttribute || ER27.findParentAttribute(node, (n) => n.value?.type === AST_NODE_TYPES.JSXExpressionContainer) != null;
+  return node.parent.type === AST_NODE_TYPES.JSXAttribute || ER26.findParentAttribute(node, (n) => n.value?.type === AST_NODE_TYPES.JSXExpressionContainer) != null;
 }
 function isInsideRenderMethod(node) {
-  return AST7.findParentNode(node, (n) => ER27.isRenderLike(n) && ER27.isClassComponent(n.parent.parent)) != null;
+  return AST13.findParentNode(node, (n) => ER26.isRenderLike(n) && ER26.isClassComponent(n.parent.parent)) != null;
 }
 function isInsideCreateElementProps(context, node) {
-  const call = AST7.findParentNode(node, ER27.isCreateElementCall(context));
+  const call = AST13.findParentNode(node, ER26.isCreateElementCall(context));
   if (call == null) return false;
-  const prop = AST7.findParentNode(node, AST7.is(AST_NODE_TYPES.ObjectExpression));
+  const prop = AST13.findParentNode(node, AST13.is(AST_NODE_TYPES.ObjectExpression));
   if (prop == null) return false;
   return prop === call.arguments[1];
 }
-var RULE_NAME37 = "no-nested-component-definitions";
-var RULE_FEATURES37 = [];
+var RULE_NAME36 = "no-nested-component-definitions";
+var RULE_FEATURES36 = [];
 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_FEATURES37
+      [Symbol.for("rule_features")]: RULE_FEATURES36
     },
     messages: {
       noNestedComponentDefinitions: "Do not declare lazy components inside other components. Instead, always declare them at the top level of your module."
     },
     schema: []
   },
-  name: RULE_NAME37,
-  create: create37,
+  name: RULE_NAME36,
+  create: create36,
   defaultOptions: []
 });
-function create37(context) {
-  const hint = ER27.ComponentDetectionHint.None;
-  const collector = ER27.useComponentCollector(context, { hint });
-  const collectorLegacy = ER27.useComponentCollectorLegacy();
+function create36(context) {
+  const hint = ER26.ComponentDetectionHint.None;
+  const collector = ER26.useComponentCollector(context, { hint });
+  const collectorLegacy = ER26.useComponentCollectorLegacy();
   const lazyComponentDeclarations = /* @__PURE__ */ new Set();
   return {
     ...collector.listeners,
     ...collectorLegacy.listeners,
     ImportExpression(node) {
-      const lazyCall = AST7.findParentNode(node, (n) => ER27.isLazyCall(context, n));
+      const lazyCall = AST13.findParentNode(node, (n) => ER26.isLazyCall(context, n));
       if (lazyCall != null) {
         lazyComponentDeclarations.add(lazyCall);
       }
@@ -2519,15 +2268,15 @@ function create37(context) {
         ...collectorLegacy.ctx.getAllComponents(program).values()
       ];
       for (const lazy of lazyComponentDeclarations) {
-        const significantParent = AST7.findParentNode(lazy, (n) => {
-          if (AST7.isJSX(n)) return true;
+        const significantParent = AST13.findParentNode(lazy, (n) => {
+          if (AST13.isJSX(n)) return true;
           if (n.type === AST_NODE_TYPES.CallExpression) {
-            return ER27.isReactHookCall(n) || ER27.isCreateElementCall(context, n) || ER27.isCreateContextCall(context, n);
+            return ER26.isReactHookCall(n) || ER26.isCreateElementCall(context, n) || ER26.isCreateContextCall(context, n);
           }
-          if (AST7.isFunction(n)) {
+          if (AST13.isFunction(n)) {
             return functionComponents.some((c) => c.node === n);
           }
-          if (AST7.isClass(n)) {
+          if (AST13.isClass(n)) {
             return classComponents.some((c) => c.node === n);
           }
           return false;
@@ -2542,25 +2291,25 @@ function create37(context) {
     }
   };
 }
-var RULE_NAME38 = "no-prop-types";
-var RULE_FEATURES38 = [];
+var RULE_NAME37 = "no-prop-types";
+var RULE_FEATURES37 = [];
 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_FEATURES38
+      [Symbol.for("rule_features")]: RULE_FEATURES37
     },
     messages: {
       noPropTypes: "[Deprecated] Use TypeScript or another type-checking solution instead."
     },
     schema: []
   },
-  name: RULE_NAME38,
-  create: create38,
+  name: RULE_NAME37,
+  create: create37,
   defaultOptions: []
 });
-function create38(context) {
+function create37(context) {
   if (!context.sourceCode.text.includes("propTypes")) {
     return {};
   }
@@ -2576,17 +2325,17 @@ function create38(context) {
       if (property.type !== AST_NODE_TYPES.Identifier || property.name !== "propTypes") {
         return;
       }
-      if (!ER27.isComponentNameLoose(object.name)) {
+      if (!ER26.isComponentNameLoose(object.name)) {
         return;
       }
-      const variable = VAR3.findVariable(object.name, context.sourceCode.getScope(node));
-      const variableNode = VAR3.getVariableInitNode(variable, 0);
-      if (variableNode != null && (AST7.isFunction(variableNode) || ER27.isClassComponent(variableNode))) {
+      const variable = VAR5.findVariable(object.name, context.sourceCode.getScope(node));
+      const variableNode = VAR5.getVariableInitNode(variable, 0);
+      if (variableNode != null && (AST13.isFunction(variableNode) || ER26.isClassComponent(variableNode))) {
         context.report({ messageId: "noPropTypes", node: property });
       }
     },
     PropertyDefinition(node) {
-      if (!ER27.isClassComponent(node.parent.parent)) {
+      if (!ER26.isClassComponent(node.parent.parent)) {
         return;
       }
       if (!node.static || node.key.type !== AST_NODE_TYPES.Identifier || node.key.name !== "propTypes") {
@@ -2596,36 +2345,36 @@ function create38(context) {
     }
   };
 }
-var RULE_NAME39 = "no-redundant-should-component-update";
-var RULE_FEATURES39 = [];
+var RULE_NAME38 = "no-redundant-should-component-update";
+var RULE_FEATURES38 = [];
 function isShouldComponentUpdate(node) {
-  return AST7.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
+  return AST13.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
 }
 var no_redundant_should_component_update_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow `shouldComponentUpdate` when extending `React.PureComponent`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES39
+      [Symbol.for("rule_features")]: RULE_FEATURES38
     },
     messages: {
       noRedundantShouldComponentUpdate: "'{{componentName}}' does not need 'shouldComponentUpdate' when extending 'React.PureComponent'."
     },
     schema: []
   },
-  name: RULE_NAME39,
-  create: create39,
+  name: RULE_NAME38,
+  create: create38,
   defaultOptions: []
 });
-function create39(context) {
+function create38(context) {
   if (!context.sourceCode.text.includes("shouldComponentUpdate")) return {};
-  const { ctx, listeners } = ER27.useComponentCollectorLegacy();
+  const { ctx, listeners } = ER26.useComponentCollectorLegacy();
   return {
     ...listeners,
     "Program:exit"(program) {
       const components = ctx.getAllComponents(program);
       for (const { name: name5 = "PureComponent", node: component, flag } of components.values()) {
-        if ((flag & ER27.ComponentFlag.PureComponent) === 0n) {
+        if ((flag & ER26.ComponentFlag.PureComponent) === 0n) {
           continue;
         }
         const { body } = component.body;
@@ -2644,33 +2393,33 @@ function create39(context) {
     }
   };
 }
-var RULE_NAME40 = "no-set-state-in-component-did-mount";
-var RULE_FEATURES40 = [];
+var RULE_NAME39 = "no-set-state-in-component-did-mount";
+var RULE_FEATURES39 = [];
 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_FEATURES40
+      [Symbol.for("rule_features")]: RULE_FEATURES39
     },
     messages: {
       noSetStateInComponentDidMount: "Do not call `this.setState` in `componentDidMount` outside of functions, such as callbacks."
     },
     schema: []
   },
-  name: RULE_NAME40,
-  create: create40,
+  name: RULE_NAME39,
+  create: create39,
   defaultOptions: []
 });
-function create40(context) {
+function create39(context) {
   if (!context.sourceCode.text.includes("componentDidMount")) return {};
   return {
     CallExpression(node) {
-      if (!ER27.isThisSetState(node)) {
+      if (!ER26.isThisSetState(node)) {
         return;
       }
-      const clazz = AST7.findParentNode(node, ER27.isClassComponent);
-      const method = AST7.findParentNode(node, (n) => n === clazz || ER27.isComponentDidMount(n));
+      const clazz = AST13.findParentNode(node, ER26.isClassComponent);
+      const method = AST13.findParentNode(node, (n) => n === clazz || ER26.isComponentDidMount(n));
       if (clazz == null || method == null || method === clazz) return;
       const methodScope = context.sourceCode.getScope(method);
       const upperScope = context.sourceCode.getScope(node).upper;
@@ -2683,33 +2432,33 @@ function create40(context) {
     }
   };
 }
-var RULE_NAME41 = "no-set-state-in-component-did-update";
-var RULE_FEATURES41 = [];
+var RULE_NAME40 = "no-set-state-in-component-did-update";
+var RULE_FEATURES40 = [];
 var no_set_state_in_component_did_update_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow calling `this.setState` in `componentDidUpdate` outside of functions, such as callbacks.",
-      [Symbol.for("rule_features")]: RULE_FEATURES41
+      [Symbol.for("rule_features")]: RULE_FEATURES40
     },
     messages: {
       noSetStateInComponentDidUpdate: "Do not call `this.setState` in `componentDidUpdate` outside of functions, such as callbacks."
     },
     schema: []
   },
-  name: RULE_NAME41,
-  create: create41,
+  name: RULE_NAME40,
+  create: create40,
   defaultOptions: []
 });
-function create41(context) {
+function create40(context) {
   if (!context.sourceCode.text.includes("componentDidUpdate")) return {};
   return {
     CallExpression(node) {
-      if (!ER27.isThisSetState(node)) {
+      if (!ER26.isThisSetState(node)) {
         return;
       }
-      const clazz = AST7.findParentNode(node, ER27.isClassComponent);
-      const method = AST7.findParentNode(node, (n) => n === clazz || ER27.isComponentDidUpdate(n));
+      const clazz = AST13.findParentNode(node, ER26.isClassComponent);
+      const method = AST13.findParentNode(node, (n) => n === clazz || ER26.isComponentDidUpdate(n));
       if (clazz == null || method == null || method === clazz) return;
       const methodScope = context.sourceCode.getScope(method);
       const upperScope = context.sourceCode.getScope(node).upper;
@@ -2722,33 +2471,33 @@ function create41(context) {
     }
   };
 }
-var RULE_NAME42 = "no-set-state-in-component-will-update";
-var RULE_FEATURES42 = [];
+var RULE_NAME41 = "no-set-state-in-component-will-update";
+var RULE_FEATURES41 = [];
 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_FEATURES42
+      [Symbol.for("rule_features")]: RULE_FEATURES41
     },
     messages: {
       noSetStateInComponentWillUpdate: "Do not call `this.setState` in `componentWillUpdate` outside of functions, such as callbacks."
     },
     schema: []
   },
-  name: RULE_NAME42,
-  create: create42,
+  name: RULE_NAME41,
+  create: create41,
   defaultOptions: []
 });
-function create42(context) {
+function create41(context) {
   if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
   return {
     CallExpression(node) {
-      if (!ER27.isThisSetState(node)) {
+      if (!ER26.isThisSetState(node)) {
         return;
       }
-      const clazz = AST7.findParentNode(node, ER27.isClassComponent);
-      const method = AST7.findParentNode(node, (n) => n === clazz || ER27.isComponentWillUpdate(n));
+      const clazz = AST13.findParentNode(node, ER26.isClassComponent);
+      const method = AST13.findParentNode(node, (n) => n === clazz || ER26.isComponentWillUpdate(n));
       if (clazz == null || method == null || method === clazz) return;
       const methodScope = context.sourceCode.getScope(method);
       const upperScope = context.sourceCode.getScope(node).upper;
@@ -2761,8 +2510,8 @@ function create42(context) {
     }
   };
 }
-var RULE_NAME43 = "no-string-refs";
-var RULE_FEATURES43 = [
+var RULE_NAME42 = "no-string-refs";
+var RULE_FEATURES42 = [
   "MOD"
 ];
 var no_string_refs_default = createRule({
@@ -2770,7 +2519,7 @@ var no_string_refs_default = createRule({
     type: "problem",
     docs: {
       description: "Replaces string refs with callback refs.",
-      [Symbol.for("rule_features")]: RULE_FEATURES43
+      [Symbol.for("rule_features")]: RULE_FEATURES42
     },
     fixable: "code",
     messages: {
@@ -2778,16 +2527,16 @@ var no_string_refs_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME43,
-  create: create43,
+  name: RULE_NAME42,
+  create: create42,
   defaultOptions: []
 });
-function create43(context) {
+function create42(context) {
   const state = {
     isWithinClassComponent: false
   };
   function onClassBodyEnter(node) {
-    if (ER27.isClassComponent(node.parent)) {
+    if (ER26.isClassComponent(node.parent)) {
       state.isWithinClassComponent = true;
     }
   }
@@ -2826,8 +2575,8 @@ function getAttributeValueText(context, node) {
       return null;
   }
 }
-var RULE_NAME44 = "no-unnecessary-use-callback";
-var RULE_FEATURES44 = [
+var RULE_NAME43 = "no-unnecessary-use-callback";
+var RULE_FEATURES43 = [
   "EXP"
 ];
 var no_unnecessary_use_callback_default = createRule({
@@ -2835,24 +2584,24 @@ var no_unnecessary_use_callback_default = createRule({
     type: "problem",
     docs: {
       description: "Disallow unnecessary usage of `useCallback`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES44
+      [Symbol.for("rule_features")]: RULE_FEATURES43
     },
     messages: {
       noUnnecessaryUseCallback: "An 'useCallback' with empty deps and no references to the component scope may be unnecessary."
     },
     schema: []
   },
-  name: RULE_NAME44,
-  create: create44,
+  name: RULE_NAME43,
+  create: create43,
   defaultOptions: []
 });
-function create44(context) {
+function create43(context) {
   if (!context.sourceCode.text.includes("use")) return {};
   const alias = getSettingsFromContext(context).additionalHooks.useCallback ?? [];
-  const isUseCallbackCall = ER27.isReactHookCallWithNameAlias(context, "useCallback", alias);
+  const isUseCallbackCall = ER26.isReactHookCallWithNameAlias(context, "useCallback", alias);
   return {
     CallExpression(node) {
-      if (!ER27.isReactHookCall(node)) {
+      if (!ER26.isReactHookCall(node)) {
         return;
       }
       const initialScope = context.sourceCode.getScope(node);
@@ -2861,7 +2610,7 @@ function create44(context) {
       }
       const scope = context.sourceCode.getScope(node);
       const component = scope.block;
-      if (!AST7.isFunction(component)) {
+      if (!AST13.isFunction(component)) {
         return;
       }
       const [arg0, arg1] = node.arguments;
@@ -2869,8 +2618,8 @@ function create44(context) {
         return;
       }
       const hasEmptyDeps = match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-        const variable = VAR3.findVariable(n.name, initialScope);
-        const variableNode = VAR3.getVariableInitNode(variable, 0);
+        const variable = VAR5.findVariable(n.name, initialScope);
+        const variableNode = VAR5.getVariableInitNode(variable, 0);
         if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) {
           return false;
         }
@@ -2885,8 +2634,8 @@ function create44(context) {
         }
         return n;
       }).with({ type: AST_NODE_TYPES.FunctionExpression }, identity).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-        const variable = VAR3.findVariable(n.name, initialScope);
-        const variableNode = VAR3.getVariableInitNode(variable, 0);
+        const variable = VAR5.findVariable(n.name, initialScope);
+        const variableNode = VAR5.getVariableInitNode(variable, 0);
         if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) {
           return null;
         }
@@ -2894,7 +2643,7 @@ function create44(context) {
       }).otherwise(() => null);
       if (arg0Node == null) return;
       const arg0NodeScope = context.sourceCode.getScope(arg0Node);
-      const arg0NodeReferences = VAR3.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
+      const arg0NodeReferences = VAR5.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
       const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
       if (!isReferencedToComponentScope) {
         context.report({
@@ -2905,8 +2654,8 @@ function create44(context) {
     }
   };
 }
-var RULE_NAME45 = "no-unnecessary-use-memo";
-var RULE_FEATURES45 = [
+var RULE_NAME44 = "no-unnecessary-use-memo";
+var RULE_FEATURES44 = [
   "EXP"
 ];
 var no_unnecessary_use_memo_default = createRule({
@@ -2914,24 +2663,24 @@ var no_unnecessary_use_memo_default = createRule({
     type: "problem",
     docs: {
       description: "Disallow unnecessary usage of `useMemo`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES45
+      [Symbol.for("rule_features")]: RULE_FEATURES44
     },
     messages: {
       noUnnecessaryUseMemo: "An 'useMemo' with empty deps and no references to the component scope may be unnecessary."
     },
     schema: []
   },
-  name: RULE_NAME45,
-  create: create45,
+  name: RULE_NAME44,
+  create: create44,
   defaultOptions: []
 });
-function create45(context) {
+function create44(context) {
   if (!context.sourceCode.text.includes("use")) return {};
   const alias = getSettingsFromContext(context).additionalHooks.useMemo ?? [];
-  const isUseMemoCall = ER27.isReactHookCallWithNameAlias(context, "useMemo", alias);
+  const isUseMemoCall = ER26.isReactHookCallWithNameAlias(context, "useMemo", alias);
   return {
     CallExpression(node) {
-      if (!ER27.isReactHookCall(node)) {
+      if (!ER26.isReactHookCall(node)) {
         return;
       }
       const initialScope = context.sourceCode.getScope(node);
@@ -2940,20 +2689,20 @@ function create45(context) {
       }
       const scope = context.sourceCode.getScope(node);
       const component = scope.block;
-      if (!AST7.isFunction(component)) {
+      if (!AST13.isFunction(component)) {
         return;
       }
       const [arg0, arg1] = node.arguments;
       if (arg0 == null || arg1 == null) {
         return;
       }
-      const hasCallInArg0 = AST7.isFunction(arg0) && [...AST7.getNestedCallExpressions(arg0.body), ...AST7.getNestedNewExpressions(arg0.body)].length > 0;
+      const hasCallInArg0 = AST13.isFunction(arg0) && [...AST13.getNestedCallExpressions(arg0.body), ...AST13.getNestedNewExpressions(arg0.body)].length > 0;
       if (hasCallInArg0) {
         return;
       }
       const hasEmptyDeps = match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-        const variable = VAR3.findVariable(n.name, initialScope);
-        const variableNode = VAR3.getVariableInitNode(variable, 0);
+        const variable = VAR5.findVariable(n.name, initialScope);
+        const variableNode = VAR5.getVariableInitNode(variable, 0);
         if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) {
           return false;
         }
@@ -2968,8 +2717,8 @@ function create45(context) {
         }
         return n;
       }).with({ type: AST_NODE_TYPES.FunctionExpression }, identity).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-        const variable = VAR3.findVariable(n.name, initialScope);
-        const variableNode = VAR3.getVariableInitNode(variable, 0);
+        const variable = VAR5.findVariable(n.name, initialScope);
+        const variableNode = VAR5.getVariableInitNode(variable, 0);
         if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) {
           return null;
         }
@@ -2977,7 +2726,7 @@ function create45(context) {
       }).otherwise(() => null);
       if (arg0Node == null) return;
       const arg0NodeScope = context.sourceCode.getScope(arg0Node);
-      const arg0NodeReferences = VAR3.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
+      const arg0NodeReferences = VAR5.getChidScopes(arg0NodeScope).flatMap((x) => x.references);
       const isReferencedToComponentScope = arg0NodeReferences.some((x) => x.resolved?.scope.block === component);
       if (!isReferencedToComponentScope) {
         context.report({
@@ -2988,8 +2737,8 @@ function create45(context) {
     }
   };
 }
-var RULE_NAME46 = "no-unnecessary-use-prefix";
-var RULE_FEATURES46 = [];
+var RULE_NAME45 = "no-unnecessary-use-prefix";
+var RULE_FEATURES45 = [];
 var WELL_KNOWN_HOOKS = [
   "useMDXComponents"
 ];
@@ -3001,19 +2750,19 @@ var no_unnecessary_use_prefix_default = createRule({
     type: "problem",
     docs: {
       description: "Enforces that a function with the `use` prefix should use at least one Hook inside of it.",
-      [Symbol.for("rule_features")]: RULE_FEATURES46
+      [Symbol.for("rule_features")]: RULE_FEATURES45
     },
     messages: {
       noUnnecessaryUsePrefix: "If your function doesn't call any Hooks, avoid the 'use' prefix. Instead, write it as a regular function without the 'use' prefix."
     },
     schema: []
   },
-  name: RULE_NAME46,
-  create: create46,
+  name: RULE_NAME45,
+  create: create45,
   defaultOptions: []
 });
-function create46(context) {
-  const { ctx, listeners } = ER27.useHookCollector();
+function create45(context) {
+  const { ctx, listeners } = ER26.useHookCollector();
   return {
     ...listeners,
     "Program:exit"(program) {
@@ -3022,7 +2771,7 @@ function create46(context) {
         if (WELL_KNOWN_HOOKS.includes(name5)) {
           continue;
         }
-        if (AST7.isEmptyFunction(node)) {
+        if (AST13.isEmptyFunction(node)) {
           continue;
         }
         if (hookCalls.length > 0) {
@@ -3053,7 +2802,7 @@ function create46(context) {
   };
 }
 function getPreferredLoc(context, id) {
-  if (AST7.isMultiLine(id)) return id.loc;
+  if (AST13.isMultiLine(id)) return id.loc;
   if (!context.sourceCode.getText(id).startsWith("use")) return id.loc;
   return {
     end: {
@@ -3066,27 +2815,27 @@ function getPreferredLoc(context, id) {
     }
   };
 }
-var RULE_NAME47 = "no-unsafe-component-will-mount";
-var RULE_FEATURES47 = [];
+var RULE_NAME46 = "no-unsafe-component-will-mount";
+var RULE_FEATURES46 = [];
 var no_unsafe_component_will_mount_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Warns the usage of `UNSAFE_componentWillMount` in class components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES47
+      [Symbol.for("rule_features")]: RULE_FEATURES46
     },
     messages: {
       noUnsafeComponentWillMount: "Do not use 'UNSAFE_componentWillMount'."
     },
     schema: []
   },
-  name: RULE_NAME47,
-  create: create47,
+  name: RULE_NAME46,
+  create: create46,
   defaultOptions: []
 });
-function create47(context) {
+function create46(context) {
   if (!context.sourceCode.text.includes("UNSAFE_componentWillMount")) return {};
-  const { ctx, listeners } = ER27.useComponentCollectorLegacy();
+  const { ctx, listeners } = ER26.useComponentCollectorLegacy();
   return {
     ...listeners,
     "Program:exit"(program) {
@@ -3094,7 +2843,7 @@ function create47(context) {
       for (const { node: component } of components.values()) {
         const { body } = component.body;
         for (const member of body) {
-          if (ER27.isUnsafeComponentWillMount(member)) {
+          if (ER26.isUnsafeComponentWillMount(member)) {
             context.report({
               messageId: "noUnsafeComponentWillMount",
               node: member
@@ -3105,29 +2854,29 @@ function create47(context) {
     }
   };
 }
-var RULE_NAME48 = "no-unsafe-component-will-receive-props";
-var RULE_FEATURES48 = [];
+var RULE_NAME47 = "no-unsafe-component-will-receive-props";
+var RULE_FEATURES47 = [];
 var no_unsafe_component_will_receive_props_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Warns the usage of `UNSAFE_componentWillReceiveProps` in class components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES48
+      [Symbol.for("rule_features")]: RULE_FEATURES47
     },
     messages: {
       noUnsafeComponentWillReceiveProps: "Do not use 'UNSAFE_componentWillReceiveProps'."
     },
     schema: []
   },
-  name: RULE_NAME48,
-  create: create48,
+  name: RULE_NAME47,
+  create: create47,
   defaultOptions: []
 });
-function create48(context) {
+function create47(context) {
   if (!context.sourceCode.text.includes("UNSAFE_componentWillReceiveProps")) {
     return {};
   }
-  const { ctx, listeners } = ER27.useComponentCollectorLegacy();
+  const { ctx, listeners } = ER26.useComponentCollectorLegacy();
   return {
     ...listeners,
     "Program:exit"(program) {
@@ -3135,7 +2884,7 @@ function create48(context) {
       for (const { node: component } of components.values()) {
         const { body } = component.body;
         for (const member of body) {
-          if (ER27.isUnsafeComponentWillReceiveProps(member)) {
+          if (ER26.isUnsafeComponentWillReceiveProps(member)) {
             context.report({
               messageId: "noUnsafeComponentWillReceiveProps",
               node: member
@@ -3146,27 +2895,27 @@ function create48(context) {
     }
   };
 }
-var RULE_NAME49 = "no-unsafe-component-will-update";
-var RULE_FEATURES49 = [];
+var RULE_NAME48 = "no-unsafe-component-will-update";
+var RULE_FEATURES48 = [];
 var no_unsafe_component_will_update_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Warns the usage of `UNSAFE_componentWillUpdate` in class components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES49
+      [Symbol.for("rule_features")]: RULE_FEATURES48
     },
     messages: {
       noUnsafeComponentWillUpdate: "Do not use 'UNSAFE_componentWillUpdate'."
     },
     schema: []
   },
-  name: RULE_NAME49,
-  create: create49,
+  name: RULE_NAME48,
+  create: create48,
   defaultOptions: []
 });
-function create49(context) {
+function create48(context) {
   if (!context.sourceCode.text.includes("UNSAFE_componentWillUpdate")) return {};
-  const { ctx, listeners } = ER27.useComponentCollectorLegacy();
+  const { ctx, listeners } = ER26.useComponentCollectorLegacy();
   return {
     ...listeners,
     "Program:exit"(program) {
@@ -3174,7 +2923,7 @@ function create49(context) {
       for (const { node: component } of components.values()) {
         const { body } = component.body;
         for (const member of body) {
-          if (ER27.isUnsafeComponentWillUpdate(member)) {
+          if (ER26.isUnsafeComponentWillUpdate(member)) {
             context.report({
               messageId: "noUnsafeComponentWillUpdate",
               node: member
@@ -3185,33 +2934,33 @@ function create49(context) {
     }
   };
 }
-var RULE_NAME50 = "no-unstable-context-value";
-var RULE_FEATURES50 = [];
+var RULE_NAME49 = "no-unstable-context-value";
+var RULE_FEATURES49 = [];
 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_FEATURES50
+      [Symbol.for("rule_features")]: RULE_FEATURES49
     },
     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_NAME50,
-  create: create50,
+  name: RULE_NAME49,
+  create: create49,
   defaultOptions: []
 });
-function create50(context) {
+function create49(context) {
   const { version: version2 } = getSettingsFromContext(context);
   const isReact18OrBelow = compare(version2, "19.0.0", "<");
-  const { ctx, listeners } = ER27.useComponentCollector(context);
+  const { ctx, listeners } = ER26.useComponentCollector(context);
   const constructions = /* @__PURE__ */ new WeakMap();
   return {
     ...listeners,
     JSXOpeningElement(node) {
-      const fullName = ER27.getElementType(context, node.parent);
+      const fullName = ER26.getElementType(context, node.parent);
       const selfName = fullName.split(".").at(-1);
       if (selfName == null) return;
       if (!isContextName(selfName, isReact18OrBelow)) return;
@@ -3225,9 +2974,9 @@ function create50(context) {
       if (value?.type !== AST_NODE_TYPES.JSXExpressionContainer) return;
       const valueExpression = value.expression;
       const initialScope = context.sourceCode.getScope(valueExpression);
-      const construction = VAR3.getConstruction(valueExpression, initialScope);
+      const construction = VAR5.getConstruction(valueExpression, initialScope);
       if (construction == null) return;
-      if (ER27.isReactHookCall(construction.node)) {
+      if (ER26.isReactHookCall(construction.node)) {
         return;
       }
       getOrElseUpdate(constructions, functionEntry.node, () => []).push(construction);
@@ -3242,7 +2991,7 @@ function create50(context) {
             messageId: "unstableContextValue",
             node: constructionNode,
             data: {
-              type: AST7.toDelimiterFormat(constructionNode),
+              type: AST13.toDelimiterFormat(constructionNode),
               suggestion
             }
           });
@@ -3258,26 +3007,26 @@ function isContextName(name5, isReact18OrBelow) {
   }
   return false;
 }
-var RULE_NAME51 = "no-unstable-default-props";
-var RULE_FEATURES51 = [];
+var RULE_NAME50 = "no-unstable-default-props";
+var RULE_FEATURES50 = [];
 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_FEATURES51
+      [Symbol.for("rule_features")]: RULE_FEATURES50
     },
     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_NAME51,
-  create: create51,
+  name: RULE_NAME50,
+  create: create50,
   defaultOptions: []
 });
-function create51(context) {
-  const { ctx, listeners } = ER27.useComponentCollector(context);
+function create50(context) {
+  const { ctx, listeners } = ER26.useComponentCollector(context);
   const declarators = /* @__PURE__ */ new WeakMap();
   return {
     ...listeners,
@@ -3299,18 +3048,18 @@ function create51(context) {
           const { value } = prop;
           const { right } = value;
           const initialScope = context.sourceCode.getScope(value);
-          const construction = VAR3.getConstruction(
+          const construction = VAR5.getConstruction(
             value,
             initialScope,
-            VAR3.ConstructionDetectionHint.StrictCallExpression
+            VAR5.ConstructionDetectionHint.StrictCallExpression
           );
           if (construction == null) {
             continue;
           }
-          if (ER27.isReactHookCall(construction.node)) {
+          if (ER26.isReactHookCall(construction.node)) {
             continue;
           }
-          const forbiddenType = AST7.toDelimiterFormat(right);
+          const forbiddenType = AST13.toDelimiterFormat(right);
           context.report({
             messageId: "noUnstableDefaultProps",
             node: right,
@@ -3332,8 +3081,8 @@ function create51(context) {
     }
   };
 }
-var RULE_NAME52 = "no-unused-class-component-members";
-var RULE_FEATURES52 = [];
+var RULE_NAME51 = "no-unused-class-component-members";
+var RULE_FEATURES51 = [];
 var LIFECYCLE_METHODS = /* @__PURE__ */ new Set([
   "componentDidCatch",
   "componentDidMount",
@@ -3359,25 +3108,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_FEATURES52
+      [Symbol.for("rule_features")]: RULE_FEATURES51
     },
     messages: {
       noUnusedClassComponentMembers: "Unused method or property '{{methodName}}'' of class '{{className}}'."
     },
     schema: []
   },
-  name: RULE_NAME52,
-  create: create52,
+  name: RULE_NAME51,
+  create: create51,
   defaultOptions: []
 });
-function create52(context) {
+function create51(context) {
   const classEntries = [];
   const methodEntries = [];
   const propertyDefs = /* @__PURE__ */ new WeakMap();
   const propertyUsages = /* @__PURE__ */ new WeakMap();
   function classEnter(node) {
     classEntries.push(node);
-    if (!ER27.isClassComponent(node)) {
+    if (!ER26.isClassComponent(node)) {
       return;
     }
     propertyDefs.set(node, /* @__PURE__ */ new Set());
@@ -3385,17 +3134,17 @@ function create52(context) {
   }
   function classExit() {
     const currentClass = classEntries.pop();
-    if (currentClass == null || !ER27.isClassComponent(currentClass)) {
+    if (currentClass == null || !ER26.isClassComponent(currentClass)) {
       return;
     }
-    const className = AST7.getClassId(currentClass)?.name;
+    const className = AST13.getClassId(currentClass)?.name;
     const defs = propertyDefs.get(currentClass);
     const usages = propertyUsages.get(currentClass);
     if (defs == null) {
       return;
     }
     for (const def of defs) {
-      const methodName = AST7.getPropertyName(def);
+      const methodName = AST13.getPropertyName(def);
       if (methodName == null) {
         continue;
       }
@@ -3415,7 +3164,7 @@ function create52(context) {
   function methodEnter(node) {
     methodEntries.push(node);
     const currentClass = classEntries.at(-1);
-    if (currentClass == null || !ER27.isClassComponent(currentClass)) {
+    if (currentClass == null || !ER26.isClassComponent(currentClass)) {
       return;
     }
     if (node.static) {
@@ -3439,17 +3188,17 @@ function create52(context) {
       if (currentClass == null || currentMethod == null) {
         return;
       }
-      if (!ER27.isClassComponent(currentClass) || currentMethod.static) {
+      if (!ER26.isClassComponent(currentClass) || currentMethod.static) {
         return;
       }
-      if (!AST7.isThisExpression(node.object) || !isKeyLiteral2(node, node.property)) {
+      if (!AST13.isThisExpression(node.object) || !isKeyLiteral2(node, node.property)) {
         return;
       }
       if (node.parent.type === AST_NODE_TYPES.AssignmentExpression && node.parent.left === node) {
         propertyDefs.get(currentClass)?.add(node.property);
         return;
       }
-      const propertyName = AST7.getPropertyName(node.property);
+      const propertyName = AST13.getPropertyName(node.property);
       if (propertyName != null) {
         propertyUsages.get(currentClass)?.add(propertyName);
       }
@@ -3464,13 +3213,13 @@ function create52(context) {
       if (currentClass == null || currentMethod == null) {
         return;
       }
-      if (!ER27.isClassComponent(currentClass) || currentMethod.static) {
+      if (!ER26.isClassComponent(currentClass) || currentMethod.static) {
         return;
       }
-      if (node.init != null && AST7.isThisExpression(node.init) && node.id.type === AST_NODE_TYPES.ObjectPattern) {
+      if (node.init != null && AST13.isThisExpression(node.init) && node.id.type === AST_NODE_TYPES.ObjectPattern) {
         for (const prop of node.id.properties) {
           if (prop.type === AST_NODE_TYPES.Property && isKeyLiteral2(prop, prop.key)) {
-            const keyName = AST7.getPropertyName(prop.key);
+            const keyName = AST13.getPropertyName(prop.key);
             if (keyName != null) {
               propertyUsages.get(currentClass)?.add(keyName);
             }
@@ -3480,8 +3229,8 @@ function create52(context) {
     }
   };
 }
-var RULE_NAME53 = "no-unused-state";
-var RULE_FEATURES53 = [];
+var RULE_NAME52 = "no-unused-state";
+var RULE_FEATURES52 = [];
 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);
 }
@@ -3490,18 +3239,18 @@ var no_unused_state_default = createRule({
     type: "problem",
     docs: {
       description: "Warns unused class component state.",
-      [Symbol.for("rule_features")]: RULE_FEATURES53
+      [Symbol.for("rule_features")]: RULE_FEATURES52
     },
     messages: {
       noUnusedState: "Unused class component state in '{{className}}'"
     },
     schema: []
   },
-  name: RULE_NAME53,
-  create: create53,
+  name: RULE_NAME52,
+  create: create52,
   defaultOptions: []
 });
-function create53(context) {
+function create52(context) {
   const classEntries = [];
   const methodEntries = [];
   const constructorEntries = [];
@@ -3511,10 +3260,10 @@ function create53(context) {
   }
   function classExit() {
     const currentClass = classEntries.pop();
-    if (currentClass == null || !ER27.isClassComponent(currentClass)) {
+    if (currentClass == null || !ER26.isClassComponent(currentClass)) {
       return;
     }
-    const className = AST7.getClassId(currentClass)?.name;
+    const className = AST13.getClassId(currentClass)?.name;
     const { node: defNode, isUsed = false } = stateDefs.get(currentClass) ?? {};
     if (defNode == null || isUsed) {
       return;
@@ -3530,17 +3279,17 @@ function create53(context) {
   function methodEnter(node) {
     methodEntries.push(node);
     const currentClass = classEntries.at(-1);
-    if (currentClass == null || !ER27.isClassComponent(currentClass)) {
+    if (currentClass == null || !ER26.isClassComponent(currentClass)) {
       return;
     }
     if (node.static) {
-      if (ER27.isGetDerivedStateFromProps(node) && isMatching({ params: [P.nonNullable, ...P.array()] })(node.value)) {
+      if (ER26.isGetDerivedStateFromProps(node) && isMatching({ params: [P.nonNullable, ...P.array()] })(node.value)) {
         const defNode = stateDefs.get(currentClass)?.node;
         stateDefs.set(currentClass, { node: defNode, isUsed: true });
       }
       return;
     }
-    if (AST7.getPropertyName(node.key) === "state") {
+    if (AST13.getPropertyName(node.key) === "state") {
       stateDefs.set(currentClass, { node: node.key, isUsed: false });
     }
   }
@@ -3555,11 +3304,11 @@ function create53(context) {
   }
   return {
     AssignmentExpression(node) {
-      if (!ER27.isAssignmentToThisState(node)) {
+      if (!ER26.isAssignmentToThisState(node)) {
         return;
       }
       const currentClass = classEntries.at(-1);
-      if (currentClass == null || !ER27.isClassComponent(currentClass)) {
+      if (currentClass == null || !ER26.isClassComponent(currentClass)) {
         return;
       }
       const currentConstructor = constructorEntries.at(-1);
@@ -3574,14 +3323,14 @@ function create53(context) {
     ClassExpression: classEnter,
     "ClassExpression:exit": classExit,
     MemberExpression(node) {
-      if (!AST7.isThisExpression(node.object)) {
+      if (!AST13.isThisExpression(node.object)) {
         return;
       }
-      if (AST7.getPropertyName(node.property) !== "state") {
+      if (AST13.getPropertyName(node.property) !== "state") {
         return;
       }
       const currentClass = classEntries.at(-1);
-      if (currentClass == null || !ER27.isClassComponent(currentClass)) {
+      if (currentClass == null || !ER26.isClassComponent(currentClass)) {
         return;
       }
       const currentMethod = methodEntries.at(-1);
@@ -3605,7 +3354,7 @@ function create53(context) {
     "PropertyDefinition:exit": methodExit,
     VariableDeclarator(node) {
       const currentClass = classEntries.at(-1);
-      if (currentClass == null || !ER27.isClassComponent(currentClass)) {
+      if (currentClass == null || !ER26.isClassComponent(currentClass)) {
         return;
       }
       const currentMethod = methodEntries.at(-1);
@@ -3618,12 +3367,12 @@ function create53(context) {
       if (!currentClass.body.body.includes(currentMethod)) {
         return;
       }
-      if (node.init == null || !AST7.isThisExpression(node.init) || node.id.type !== AST_NODE_TYPES.ObjectPattern) {
+      if (node.init == null || !AST13.isThisExpression(node.init) || node.id.type !== AST_NODE_TYPES.ObjectPattern) {
         return;
       }
       const hasState = node.id.properties.some((prop) => {
         if (prop.type === AST_NODE_TYPES.Property && isKeyLiteral3(prop, prop.key)) {
-          return AST7.getPropertyName(prop.key) === "state";
+          return AST13.getPropertyName(prop.key) === "state";
         }
         return false;
       });
@@ -3635,8 +3384,8 @@ function create53(context) {
     }
   };
 }
-var RULE_NAME54 = "no-use-context";
-var RULE_FEATURES54 = [
+var RULE_NAME53 = "no-use-context";
+var RULE_FEATURES53 = [
   "MOD"
 ];
 var no_use_context_default = createRule({
@@ -3644,7 +3393,7 @@ var no_use_context_default = createRule({
     type: "problem",
     docs: {
       description: "Replaces usages of `useContext` with `use`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES54
+      [Symbol.for("rule_features")]: RULE_FEATURES53
     },
     fixable: "code",
     messages: {
@@ -3652,11 +3401,11 @@ var no_use_context_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME54,
-  create: create54,
+  name: RULE_NAME53,
+  create: create53,
   defaultOptions: []
 });
-function create54(context) {
+function create53(context) {
   if (!context.sourceCode.text.includes("useContext")) return {};
   const settings4 = getSettingsFromContext(context);
   if (compare(settings4.version, "19.0.0", "<")) {
@@ -3666,7 +3415,7 @@ function create54(context) {
   const hookCalls = /* @__PURE__ */ new Set();
   return {
     CallExpression(node) {
-      if (!ER27.isReactHookCall(node)) {
+      if (!ER26.isReactHookCall(node)) {
         return;
       }
       hookCalls.add(node);
@@ -3705,7 +3454,7 @@ function create54(context) {
       }
     },
     "Program:exit"() {
-      const isUseContextCall = ER27.isReactHookCallWithNameAlias(context, "useContext", [...useContextNames]);
+      const isUseContextCall = ER26.isReactHookCallWithNameAlias(context, "useContext", [...useContextNames]);
       for (const node of hookCalls) {
         if (!isUseContextCall(node)) {
           continue;
@@ -3739,32 +3488,32 @@ function getCorrelativeTokens(context, node) {
   }
   return tokens;
 }
-var RULE_NAME55 = "no-useless-forward-ref";
-var RULE_FEATURES55 = [];
+var RULE_NAME54 = "no-useless-forward-ref";
+var RULE_FEATURES54 = [];
 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_FEATURES55
+      [Symbol.for("rule_features")]: RULE_FEATURES54
     },
     messages: {
       noUselessForwardRef: "A 'forwardRef' is used with this component but no 'ref' parameter is set."
     },
     schema: []
   },
-  name: RULE_NAME55,
-  create: create55,
+  name: RULE_NAME54,
+  create: create54,
   defaultOptions: []
 });
-function create55(context) {
+function create54(context) {
   return {
     CallExpression(node) {
-      if (!ER27.isForwardRefCall(context, node)) {
+      if (!ER26.isForwardRefCall(context, node)) {
         return;
       }
       const [component] = node.arguments;
-      if (component == null || !AST7.isFunction(component)) {
+      if (component == null || !AST13.isFunction(component)) {
         return;
       }
       const ref = component.params[1];
@@ -3778,8 +3527,158 @@ function create55(context) {
     }
   };
 }
+var RULE_NAME55 = "no-useless-fragment";
+var defaultOptions3 = [{
+  allowExpressions: true
+}];
+var no_useless_fragment_default = createRule({
+  meta: {
+    type: "problem",
+    defaultOptions: [...defaultOptions3],
+    docs: {
+      description: "Disallow useless fragment elements."
+    },
+    fixable: "code",
+    messages: {
+      uselessFragment: "A fragment {{reason}} is useless."
+    },
+    schema: [{
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        allowExpressions: {
+          type: "boolean",
+          description: "Allow fragments with a single expression child"
+        }
+      }
+    }]
+  },
+  name: RULE_NAME55,
+  create: create55,
+  defaultOptions: defaultOptions3
+});
+function create55(context, [option]) {
+  const { allowExpressions = true } = option;
+  return {
+    JSXElement(node) {
+      if (!ER26.isFragmentElement(context, node)) return;
+      checkNode(context, node, allowExpressions);
+    },
+    JSXFragment(node) {
+      checkNode(context, node, allowExpressions);
+    }
+  };
+}
+function isWhiteSpace(node) {
+  return typeof node.value === "string" && node.raw.trim() === "";
+}
+function isPaddingSpaces(node) {
+  return ER26.isJsxText(node) && isWhiteSpace(node) && node.raw.includes("\n");
+}
+function trimLikeReact(text) {
+  const leadingSpaces = /^\s*/.exec(text)?.[0] ?? "";
+  const trailingSpaces = /\s*$/.exec(text)?.[0] ?? "";
+  const start = leadingSpaces.includes("\n") ? leadingSpaces.length : 0;
+  const end = trailingSpaces.includes("\n") ? text.length - trailingSpaces.length : text.length;
+  return text.slice(start, end);
+}
+function checkNode(context, node, allowExpressions) {
+  const initialScope = context.sourceCode.getScope(node);
+  if (ER26.isKeyedElement(context, node, initialScope)) {
+    return;
+  }
+  if (ER26.isHostElement(context, node.parent)) {
+    context.report({
+      messageId: "uselessFragment",
+      node,
+      data: {
+        reason: "placed inside a host component"
+      },
+      fix: getFix2(context, node)
+    });
+  }
+  if (node.children.length === 0) {
+    context.report({
+      messageId: "uselessFragment",
+      node,
+      data: {
+        reason: "contains less than two children"
+      },
+      fix: getFix2(context, node)
+    });
+    return;
+  }
+  const isChildElement = AST13.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 && ER26.isJsxText(node.children.at(0))): {
+      return;
+    }
+    // <Foo><>hello, world</></Foo>
+    case (!allowExpressions && isChildElement): {
+      context.report({
+        messageId: "uselessFragment",
+        node,
+        data: {
+          reason: "contains less than two children"
+        },
+        fix: getFix2(context, node)
+      });
+      return;
+    }
+    case (!allowExpressions && !isChildElement && node.children.length === 1): {
+      context.report({
+        messageId: "uselessFragment",
+        node,
+        data: {
+          reason: "contains less than two children"
+        },
+        fix: getFix2(context, node)
+      });
+      return;
+    }
+  }
+  const nonPaddingChildren = node.children.filter((child) => !isPaddingSpaces(child));
+  const firstNonPaddingChild = nonPaddingChildren.at(0);
+  switch (true) {
+    case nonPaddingChildren.length === 0:
+    case (nonPaddingChildren.length === 1 && firstNonPaddingChild?.type !== AST_NODE_TYPES.JSXExpressionContainer): {
+      context.report({
+        messageId: "uselessFragment",
+        node,
+        data: {
+          reason: "contains less than two children"
+        },
+        fix: getFix2(context, node)
+      });
+      return;
+    }
+  }
+  return;
+}
+function getFix2(context, node) {
+  if (!canFix(context, node)) return null;
+  return (fixer) => {
+    const opener = node.type === AST_NODE_TYPES.JSXFragment ? node.openingFragment : node.openingElement;
+    const closer = node.type === AST_NODE_TYPES.JSXFragment ? node.closingFragment : node.closingElement;
+    const childrenText = opener.type === AST_NODE_TYPES.JSXOpeningElement && opener.selfClosing ? "" : context.sourceCode.getText().slice(opener.range[1], closer?.range[0]);
+    return fixer.replaceText(node, trimLikeReact(childrenText));
+  };
+}
+function canFix(context, node) {
+  if (node.parent.type === AST_NODE_TYPES.JSXElement || node.parent.type === AST_NODE_TYPES.JSXFragment) {
+    return ER26.isHostElement(context, node.parent);
+  }
+  if (node.children.length === 0) {
+    return false;
+  }
+  if (node.children.some((child) => ER26.isJsxText(child) && !isWhiteSpace(child) || AST13.is(AST_NODE_TYPES.JSXExpressionContainer)(child))) {
+    return false;
+  }
+  return true;
+}
 var RULE_NAME56 = "prefer-destructuring-assignment";
-var RULE_FEATURES56 = [];
+var RULE_FEATURES55 = [];
 function isMemberExpressionWithObjectName(node) {
   return node.object.type === AST_NODE_TYPES.Identifier && "name" in node.object;
 }
@@ -3788,7 +3687,7 @@ var prefer_destructuring_assignment_default = createRule({
     type: "problem",
     docs: {
       description: "Enforces destructuring assignment for component props and context.",
-      [Symbol.for("rule_features")]: RULE_FEATURES56
+      [Symbol.for("rule_features")]: RULE_FEATURES55
     },
     messages: {
       preferDestructuringAssignment: "Use destructuring assignment for {{name}}."
@@ -3800,7 +3699,7 @@ var prefer_destructuring_assignment_default = createRule({
   defaultOptions: []
 });
 function create56(context) {
-  const { ctx, listeners } = ER27.useComponentCollector(context);
+  const { ctx, listeners } = ER26.useComponentCollector(context);
   const memberExpressionWithNames = [];
   return {
     ...listeners,
@@ -3815,11 +3714,11 @@ function create56(context) {
         ...ctx.getAllComponents(program).values()
       ];
       function isFunctionComponent(block) {
-        if (!AST7.isFunction(block)) {
+        if (!AST13.isFunction(block)) {
           return false;
         }
-        const id = AST7.getFunctionId(block);
-        return id != null && ER27.isComponentNameLoose(id.name) && components.some((component) => component.node === block);
+        const id = AST13.getFunctionId(block);
+        return id != null && ER26.isComponentNameLoose(id.name) && components.some((component) => component.node === block);
       }
       for (const [initialScope, memberExpression] of memberExpressionWithNames) {
         let scope = initialScope;
@@ -3860,7 +3759,7 @@ function create56(context) {
   };
 }
 var RULE_NAME57 = "prefer-namespace-import";
-var RULE_FEATURES57 = [
+var RULE_FEATURES56 = [
   "FIX"
 ];
 var prefer_namespace_import_default = createRule({
@@ -3868,7 +3767,7 @@ var prefer_namespace_import_default = createRule({
     type: "problem",
     docs: {
       description: "Enforces React is imported via a namespace import.",
-      [Symbol.for("rule_features")]: RULE_FEATURES57
+      [Symbol.for("rule_features")]: RULE_FEATURES56
     },
     fixable: "code",
     messages: {
@@ -3916,7 +3815,7 @@ function create57(context) {
   };
 }
 var RULE_NAME58 = "prefer-read-only-props";
-var RULE_FEATURES58 = [
+var RULE_FEATURES57 = [
   "TSC",
   "EXP"
 ];
@@ -3925,7 +3824,7 @@ var prefer_read_only_props_default = createRule({
     type: "problem",
     docs: {
       description: "Enforces read-only props in components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES58
+      [Symbol.for("rule_features")]: RULE_FEATURES57
     },
     messages: {
       preferReadOnlyProps: "A function component's props should be read-only."
@@ -3938,12 +3837,14 @@ var prefer_read_only_props_default = createRule({
 });
 function create58(context) {
   const services = ESLintUtils.getParserServices(context, false);
-  const { ctx, listeners } = ER27.useComponentCollector(context);
+  const { ctx, listeners } = ER26.useComponentCollector(context);
   return {
     ...listeners,
     "Program:exit"(program) {
       const components = ctx.getAllComponents(program);
       for (const [, component] of components) {
+        if (component.id == null) continue;
+        if (component.name == null) continue;
         const [props] = component.node.params;
         if (props == null) {
           continue;
@@ -3967,7 +3868,7 @@ function isTypeReadonlyLoose(services, type) {
   }
 }
 var RULE_NAME59 = "prefer-use-state-lazy-initialization";
-var RULE_FEATURES59 = [
+var RULE_FEATURES58 = [
   "EXP"
 ];
 var ALLOW_LIST = [
@@ -3980,7 +3881,7 @@ var prefer_use_state_lazy_initialization_default = createRule({
     type: "problem",
     docs: {
       description: "Enforces function calls made inside `useState` to be wrapped in an `initializer function`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES59
+      [Symbol.for("rule_features")]: RULE_FEATURES58
     },
     messages: {
       preferUseStateLazyInitialization: "To prevent re-computation, consider using lazy initial state for useState calls that involve function calls. Ex: 'useState(() => getValue())'."
@@ -3993,10 +3894,10 @@ var prefer_use_state_lazy_initialization_default = createRule({
 });
 function create59(context) {
   const alias = getSettingsFromContext(context).additionalHooks.useState ?? [];
-  const isUseStateCall = ER27.isReactHookCallWithNameAlias(context, "useState", alias);
+  const isUseStateCall = ER26.isReactHookCallWithNameAlias(context, "useState", alias);
   return {
     CallExpression(node) {
-      if (!ER27.isReactHookCall(node)) {
+      if (!ER26.isReactHookCall(node)) {
         return;
       }
       if (!isUseStateCall(node)) {
@@ -4006,20 +3907,20 @@ function create59(context) {
       if (useStateInput == null) {
         return;
       }
-      for (const expr of AST7.getNestedNewExpressions(useStateInput)) {
+      for (const expr of AST13.getNestedNewExpressions(useStateInput)) {
         if (!("name" in expr.callee)) continue;
         if (ALLOW_LIST.includes(expr.callee.name)) continue;
-        if (AST7.findParentNode(expr, (n) => ER27.isUseCall(context, n)) != null) continue;
+        if (AST13.findParentNode(expr, (n) => ER26.isUseCall(context, n)) != null) continue;
         context.report({
           messageId: "preferUseStateLazyInitialization",
           node: expr
         });
       }
-      for (const expr of AST7.getNestedCallExpressions(useStateInput)) {
+      for (const expr of AST13.getNestedCallExpressions(useStateInput)) {
         if (!("name" in expr.callee)) continue;
-        if (ER27.isReactHookName(expr.callee.name)) continue;
+        if (ER26.isReactHookName(expr.callee.name)) continue;
         if (ALLOW_LIST.includes(expr.callee.name)) continue;
-        if (AST7.findParentNode(expr, (n) => ER27.isUseCall(context, n)) != null) continue;
+        if (AST13.findParentNode(expr, (n) => ER26.isUseCall(context, n)) != null) continue;
         context.report({
           messageId: "preferUseStateLazyInitialization",
           node: expr
@@ -4028,6 +3929,337 @@ function create59(context) {
     }
   };
 }
+var RULE_NAME60 = "avoid-shorthand-boolean";
+var RULE_FEATURES59 = [];
+var avoid_shorthand_boolean_default = createRule({
+  meta: {
+    type: "problem",
+    deprecated: true,
+    docs: {
+      description: "Enforces explicit boolean values for boolean attributes.",
+      [Symbol.for("rule_features")]: RULE_FEATURES59
+    },
+    fixable: "code",
+    messages: {
+      avoidShorthandBoolean: "Avoid using shorthand boolean attribute '{{propName}}'. Use '{{propName}}={true}' instead."
+    },
+    replacedBy: [
+      "react-x/jsx-shorthand-boolean"
+    ],
+    schema: []
+  },
+  name: RULE_NAME60,
+  create: create60,
+  defaultOptions: []
+});
+function create60(context) {
+  return {
+    JSXAttribute(node) {
+      if (node.value == null) {
+        context.report({
+          messageId: "avoidShorthandBoolean",
+          node,
+          data: {
+            propName: ER26.getAttributeName(context, node)
+          },
+          fix: (fixer) => fixer.insertTextAfter(node.name, `={true}`)
+        });
+      }
+    }
+  };
+}
+var RULE_NAME61 = "avoid-shorthand-fragment";
+var RULE_FEATURES60 = [];
+var avoid_shorthand_fragment_default = createRule({
+  meta: {
+    type: "problem",
+    deprecated: true,
+    docs: {
+      description: "Enforces explicit `<Fragment>` components instead of the shorthand `<>` or `</>` syntax.",
+      [Symbol.for("rule_features")]: RULE_FEATURES60
+    },
+    messages: {
+      avoidShorthandFragment: "Avoid using shorthand fragment syntax. Use '{{jsxFragmentFactory}}' component instead."
+    },
+    replacedBy: [
+      "react-x/jsx-shorthand-fragment"
+    ],
+    schema: []
+  },
+  name: RULE_NAME61,
+  create: create61,
+  defaultOptions: []
+});
+function create61(context) {
+  const jsxConfigFromContext = JsxConfig.getFromContext(context);
+  const jsxConfigFromAnnotation = JsxConfig.getFromAnnotation(context);
+  const jsxConfig = {
+    ...jsxConfigFromContext,
+    ...jsxConfigFromAnnotation
+  };
+  return {
+    JSXFragment(node) {
+      context.report({
+        messageId: "avoidShorthandFragment",
+        node,
+        data: {
+          jsxFragmentFactory: jsxConfig.jsxFragmentFactory
+        }
+      });
+    }
+  };
+}
+var RULE_NAME62 = "prefer-shorthand-boolean";
+var RULE_FEATURES61 = [
+  "FIX"
+];
+var prefer_shorthand_boolean_default = createRule({
+  meta: {
+    type: "problem",
+    deprecated: true,
+    docs: {
+      description: "Enforces shorthand syntax for boolean attributes.",
+      [Symbol.for("rule_features")]: RULE_FEATURES61
+    },
+    fixable: "code",
+    messages: {
+      preferShorthandBoolean: "Use shorthand boolean attribute '{{propName}}'."
+    },
+    replacedBy: [
+      "react-x/jsx-shorthand-boolean"
+    ],
+    schema: []
+  },
+  name: RULE_NAME62,
+  create: create62,
+  defaultOptions: []
+});
+function create62(context) {
+  return {
+    JSXAttribute(node) {
+      const { value } = node;
+      const propName = ER26.getAttributeName(context, node);
+      const hasValueTrue = value?.type === AST_NODE_TYPES.JSXExpressionContainer && value.expression.type === AST_NODE_TYPES.Literal && value.expression.value === true;
+      if (!hasValueTrue) {
+        return;
+      }
+      context.report({
+        messageId: "preferShorthandBoolean",
+        node: node.value ?? node,
+        data: {
+          propName
+        },
+        fix: (fixer) => fixer.removeRange([node.name.range[1], value.range[1]])
+      });
+    }
+  };
+}
+var RULE_NAME63 = "prefer-shorthand-fragment";
+var RULE_FEATURES62 = [
+  "FIX"
+];
+var prefer_shorthand_fragment_default = createRule({
+  meta: {
+    type: "problem",
+    deprecated: true,
+    docs: {
+      description: "Enforces shorthand syntax for fragments.",
+      [Symbol.for("rule_features")]: RULE_FEATURES62
+    },
+    fixable: "code",
+    messages: {
+      preferShorthandFragment: "Use fragment shorthand syntax instead of 'Fragment' component."
+    },
+    replacedBy: [
+      "react-x/jsx-shorthand-fragment"
+    ],
+    schema: []
+  },
+  name: RULE_NAME63,
+  create: create63,
+  defaultOptions: []
+});
+function create63(context) {
+  return {
+    JSXElement(node) {
+      if (!ER26.isFragmentElement(context, node)) return;
+      const hasAttributes = node.openingElement.attributes.length > 0;
+      if (hasAttributes) {
+        return;
+      }
+      context.report({
+        messageId: "preferShorthandFragment",
+        node,
+        fix: (fixer) => {
+          const { closingElement, openingElement } = node;
+          if (closingElement == null) {
+            return [];
+          }
+          return [
+            fixer.replaceTextRange([openingElement.range[0], openingElement.range[1]], "<>"),
+            fixer.replaceTextRange([closingElement.range[0], closingElement.range[1]], "</>")
+          ];
+        }
+      });
+    }
+  };
+}
+var RULE_NAME64 = "prefer-react-namespace-import";
+var RULE_FEATURES63 = [
+  "FIX"
+];
+var prefer_react_namespace_import_default = createRule({
+  meta: {
+    type: "problem",
+    deprecated: true,
+    docs: {
+      description: "Enforces React is imported via a namespace import.",
+      [Symbol.for("rule_features")]: RULE_FEATURES63
+    },
+    fixable: "code",
+    messages: {
+      preferReactNamespaceImport: `Prefer importing React as 'import * as React from "{{importSource}}"';`
+    },
+    replacedBy: [
+      "react-x/prefer-namespace-import"
+    ],
+    schema: []
+  },
+  name: RULE_NAME64,
+  create: create64,
+  defaultOptions: []
+});
+function create64(context) {
+  const { importSource } = getSettingsFromContext(context);
+  return {
+    [`ImportDeclaration[source.value="${importSource}"] ImportDefaultSpecifier`](node) {
+      const hasOtherSpecifiers = node.parent.specifiers.length > 1;
+      context.report({
+        messageId: "preferReactNamespaceImport",
+        node: hasOtherSpecifiers ? node : node.parent,
+        data: { importSource },
+        fix(fixer) {
+          const importDeclarationText = context.sourceCode.getText(node.parent);
+          const semi = importDeclarationText.endsWith(";") ? ";" : "";
+          const quote = node.parent.source.raw.at(0) ?? "'";
+          const isTypeImport = node.parent.importKind === "type";
+          const importStringPrefix = `import${isTypeImport ? " type" : ""}`;
+          const importSourceQuoted = `${quote}${importSource}${quote}`;
+          if (!hasOtherSpecifiers) {
+            return fixer.replaceText(
+              node.parent,
+              `${importStringPrefix} * as ${node.local.name} from ${importSourceQuoted}${semi}`
+            );
+          }
+          const specifiers = importDeclarationText.slice(importDeclarationText.indexOf("{"), importDeclarationText.indexOf("}") + 1);
+          return fixer.replaceText(
+            node.parent,
+            [
+              `${importStringPrefix} * as ${node.local.name} from ${importSourceQuoted}${semi}`,
+              `${importStringPrefix} ${specifiers} from ${importSourceQuoted}${semi}`
+            ].join("\n")
+          );
+        }
+      });
+    }
+  };
+}
+var RULE_NAME65 = "no-comment-textnodes";
+var RULE_FEATURES64 = [];
+var no_comment_textnodes_default = createRule({
+  meta: {
+    type: "problem",
+    deprecated: true,
+    docs: {
+      description: "Prevents comments from being inserted as text nodes.",
+      [Symbol.for("rule_features")]: RULE_FEATURES64
+    },
+    messages: {
+      noCommentTextnodes: "Possible misused comment in text node. Comments inside children section of tag should be placed inside braces."
+    },
+    replacedBy: [
+      "react-x/jsx-no-comment-textnodes"
+    ],
+    schema: []
+  },
+  name: RULE_NAME65,
+  create: create65,
+  defaultOptions: []
+});
+function create65(context) {
+  function hasCommentLike(node) {
+    if (AST13.isOneOf([AST_NODE_TYPES.JSXAttribute, AST_NODE_TYPES.JSXExpressionContainer])(node.parent)) {
+      return false;
+    }
+    const rawValue = context.sourceCode.getText(node);
+    return /^\s*\/(?:\/|\*)/mu.test(rawValue);
+  }
+  const visitorFunction = (node) => {
+    if (!AST13.isOneOf([AST_NODE_TYPES.JSXElement, AST_NODE_TYPES.JSXFragment])(node.parent)) {
+      return;
+    }
+    if (!hasCommentLike(node)) {
+      return;
+    }
+    if (!node.parent.type.includes("JSX")) {
+      return;
+    }
+    context.report({
+      messageId: "noCommentTextnodes",
+      node
+    });
+  };
+  return {
+    JSXText: visitorFunction,
+    Literal: visitorFunction
+  };
+}
+var RULE_NAME66 = "no-complex-conditional-rendering";
+var RULE_FEATURES65 = [
+  "EXP"
+];
+var no_complex_conditional_rendering_default = createRule({
+  meta: {
+    type: "problem",
+    deprecated: true,
+    docs: {
+      description: "Disallow complex conditional rendering in JSX expressions.",
+      [Symbol.for("rule_features")]: RULE_FEATURES65
+    },
+    messages: {
+      noComplexConditionalRendering: "Avoid complex conditional rendering. Extract the logic into separate elements or components."
+    },
+    schema: []
+  },
+  name: RULE_NAME66,
+  create: create66,
+  defaultOptions: []
+});
+function create66(context) {
+  const visitorFunction = (node) => {
+    const jsxExpContainer = node.parent?.parent;
+    if (!AST13.is(AST_NODE_TYPES.JSXExpressionContainer)(jsxExpContainer)) {
+      return;
+    }
+    if (!AST13.isOneOf([AST_NODE_TYPES.JSXElement, AST_NODE_TYPES.JSXFragment])(jsxExpContainer.parent)) {
+      return;
+    }
+    if (!jsxExpContainer.parent.children.includes(jsxExpContainer)) {
+      return;
+    }
+    context.report({
+      messageId: "noComplexConditionalRendering",
+      node: jsxExpContainer
+    });
+  };
+  return {
+    "JSXExpressionContainer > ConditionalExpression > ConditionalExpression": visitorFunction,
+    "JSXExpressionContainer > ConditionalExpression > LogicalExpression": visitorFunction,
+    "JSXExpressionContainer > LogicalExpression > ConditionalExpression": visitorFunction,
+    "JSXExpressionContainer > LogicalExpression[operator='&&'] > LogicalExpression[operator='||']": visitorFunction,
+    "JSXExpressionContainer > LogicalExpression[operator='||'] > LogicalExpression[operator='&&']": visitorFunction
+  };
+}
 
 // src/plugin.ts
 var plugin = {
@@ -4039,6 +4271,7 @@ var plugin = {
     "jsx-key-before-spread": jsx_key_before_spread_default,
     "jsx-no-comment-textnodes": jsx_no_comment_textnodes_default,
     "jsx-no-duplicate-props": jsx_no_duplicate_props_default,
+    "jsx-no-iife": jsx_no_iife_default,
     "jsx-no-undef": jsx_no_undef_default,
     "jsx-shorthand-boolean": jsx_shorthand_boolean_default,
     "jsx-shorthand-fragment": jsx_shorthand_fragment_default,
@@ -4061,8 +4294,6 @@ var plugin = {
     "no-create-ref": no_create_ref_default,
     "no-default-props": no_default_props_default,
     "no-direct-mutation-state": no_direct_mutation_state_default,
-    "no-direct-set-state-in-use-effect": no_direct_set_state_in_use_effect_default,
-    "no-direct-set-state-in-use-layout-effect": no_direct_set_state_in_use_layout_effect_default,
     "no-duplicate-key": no_duplicate_key_default,
     "no-forward-ref": no_forward_ref_default,
     "no-implicit-key": no_implicit_key_default,
@@ -4091,10 +4322,19 @@ var plugin = {
     "no-unused-state": no_unused_state_default,
     "no-use-context": no_use_context_default,
     "no-useless-forward-ref": no_useless_forward_ref_default,
+    "no-useless-fragment": no_useless_fragment_default,
     "prefer-destructuring-assignment": prefer_destructuring_assignment_default,
     "prefer-namespace-import": prefer_namespace_import_default,
     "prefer-read-only-props": prefer_read_only_props_default,
-    "prefer-use-state-lazy-initialization": prefer_use_state_lazy_initialization_default
+    "prefer-use-state-lazy-initialization": prefer_use_state_lazy_initialization_default,
+    // Removed rules
+    "avoid-shorthand-boolean": avoid_shorthand_boolean_default,
+    "avoid-shorthand-fragment": avoid_shorthand_fragment_default,
+    "no-comment-textnodes": no_comment_textnodes_default,
+    "no-complex-conditional-rendering": no_complex_conditional_rendering_default,
+    "prefer-react-namespace-import": prefer_react_namespace_import_default,
+    "prefer-shorthand-boolean": prefer_shorthand_boolean_default,
+    "prefer-shorthand-fragment": prefer_shorthand_fragment_default
   }
 };