eslint-plugin-react-x 1.37.4-beta.0 → 1.38.0-beta.10

package/dist/index.js

@@ -1,16 +1,17 @@
 'use strict';
 
 var shared = require('@eslint-react/shared');
-var JSX8 = require('@eslint-react/jsx');
+var JSX9 = require('@eslint-react/jsx');
+var utils = require('@typescript-eslint/utils');
+var types = require('@typescript-eslint/types');
+var VAR2 = require('@eslint-react/var');
 var AST11 = require('@eslint-react/ast');
 var core = require('@eslint-react/core');
 var eff = require('@eslint-react/eff');
-var types = require('@typescript-eslint/types');
 var tsPattern = require('ts-pattern');
+var kit = require('@eslint-react/kit');
 var compareVersions = require('compare-versions');
-var VAR = require('@eslint-react/var');
 var typeUtils = require('@typescript-eslint/type-utils');
-var utils = require('@typescript-eslint/utils');
 var tsApiUtils = require('ts-api-utils');
 var ts = require('typescript');
 var isImmutableType = require('is-immutable-type');
@@ -35,9 +36,9 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var JSX8__namespace = /*#__PURE__*/_interopNamespace(JSX8);
+var JSX9__namespace = /*#__PURE__*/_interopNamespace(JSX9);
+var VAR2__namespace = /*#__PURE__*/_interopNamespace(VAR2);
 var AST11__namespace = /*#__PURE__*/_interopNamespace(AST11);
-var VAR__namespace = /*#__PURE__*/_interopNamespace(VAR);
 var ts__default = /*#__PURE__*/_interopDefault(ts);
 
 var __defProp = Object.defineProperty;
@@ -55,6 +56,9 @@ __export(recommended_exports, {
 });
 var name = "react-x/recommended";
 var rules = {
+  "react-x/jsx-no-duplicate-props": "warn",
+  "react-x/jsx-no-undef": "error",
+  "react-x/jsx-uses-vars": "warn",
   "react-x/no-access-state-in-setstate": "error",
   "react-x/no-array-index-key": "warn",
   "react-x/no-children-count": "warn",
@@ -71,7 +75,6 @@ var rules = {
   "react-x/no-create-ref": "error",
   "react-x/no-default-props": "error",
   "react-x/no-direct-mutation-state": "error",
-  "react-x/no-duplicate-jsx-props": "warn",
   "react-x/no-duplicate-key": "warn",
   "react-x/no-forward-ref": "warn",
   "react-x/no-implicit-key": "warn",
@@ -91,8 +94,7 @@ var rules = {
   "react-x/no-unused-class-component-members": "warn",
   "react-x/no-unused-state": "warn",
   "react-x/no-use-context": "warn",
-  "react-x/no-useless-forward-ref": "warn",
-  "react-x/use-jsx-vars": "warn"
+  "react-x/no-useless-forward-ref": "warn"
 };
 var settings = {
   "react-x": shared.DEFAULT_ESLINT_REACT_SETTINGS
@@ -116,8 +118,9 @@ __export(recommended_typescript_exports, {
 var name2 = "react-x/recommended-typescript";
 var rules2 = {
   ...rules,
-  "react-x/no-duplicate-jsx-props": "off",
-  "react-x/use-jsx-vars": "off"
+  "react-x/jsx-no-duplicate-props": "off",
+  "react-x/jsx-no-undef": "off",
+  "react-x/jsx-uses-vars": "off"
 };
 var settings2 = {
   ...settings
@@ -136,8 +139,8 @@ var settings3 = {
 
 // package.json
 var name4 = "eslint-plugin-react-x";
-var version = "1.37.4-beta.0";
-var createRule = shared.createRuleForPlugin("x");
+var version = "1.38.0-beta.10";
+var createRule = utils.ESLintUtils.RuleCreator(shared.getDocsUrl("x"));
 
 // src/rules/avoid-shorthand-boolean.ts
 var RULE_NAME = "avoid-shorthand-boolean";
@@ -167,7 +170,7 @@ function create(context) {
           messageId: "avoidShorthandBoolean",
           node,
           data: {
-            propName: JSX8__namespace.getAttributeName(node)
+            propName: JSX9__namespace.getAttributeName(node)
           },
           fix: (fixer) => fixer.insertTextAfter(node.name, `={true}`)
         });
@@ -205,8 +208,131 @@ function create2(context) {
     }
   };
 }
-var RULE_NAME3 = "no-access-state-in-setstate";
+var RULE_NAME3 = "jsx-no-duplicate-props";
 var RULE_FEATURES3 = [];
+var jsx_no_duplicate_props_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow duplicate props in JSX elements.",
+      [Symbol.for("rule_features")]: RULE_FEATURES3
+    },
+    messages: {
+      jsxNoDuplicateProps: "This JSX property is assigned multiple times."
+    },
+    schema: []
+  },
+  name: RULE_NAME3,
+  create: create3,
+  defaultOptions: []
+});
+function create3(context) {
+  return {
+    JSXOpeningElement(node) {
+      const props = [];
+      for (const attr of node.attributes) {
+        if (attr.type === types.AST_NODE_TYPES.JSXSpreadAttribute) {
+          continue;
+        }
+        const name5 = attr.name.name;
+        if (typeof name5 !== "string") {
+          continue;
+        }
+        if (!props.includes(name5)) {
+          props.push(name5);
+          continue;
+        }
+        context.report({
+          messageId: "jsxNoDuplicateProps",
+          node: attr
+        });
+      }
+    }
+  };
+}
+var RULE_NAME4 = "jsx-no-undef";
+var RULE_FEATURES4 = [];
+var jsx_no_undef_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow undefined variables in JSX.",
+      [Symbol.for("rule_features")]: RULE_FEATURES4
+    },
+    messages: {
+      jsxNoUndef: "JSX variable '{{name}}' is not defined."
+    },
+    schema: []
+  },
+  name: RULE_NAME4,
+  create: create4,
+  defaultOptions: []
+});
+function create4(context) {
+  return {
+    JSXIdentifier(node) {
+      if (node.name === "this") {
+        return;
+      }
+      if (/^[a-z]/u.test(node.name)) {
+        return;
+      }
+      if (node.parent.type === types.AST_NODE_TYPES.JSXMemberExpression && node.parent.property === node) {
+        return;
+      }
+      const initialScope = context.sourceCode.getScope(node);
+      if (VAR2__namespace.findVariable(node.name, initialScope) == null) {
+        context.report({
+          messageId: "jsxNoUndef",
+          node,
+          data: { name: node.name }
+        });
+      }
+    }
+  };
+}
+var RULE_NAME5 = "jsx-uses-vars";
+var RULE_FEATURES5 = [];
+var jsx_uses_vars_default = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Marks variables used in JSX elements as used.",
+      [Symbol.for("rule_features")]: RULE_FEATURES5
+    },
+    messages: {
+      jsxUsesVars: "JSX variables should be marked as used."
+    },
+    schema: []
+  },
+  name: RULE_NAME5,
+  create: create5,
+  defaultOptions: []
+});
+function create5(context) {
+  return {
+    JSXOpeningElement(node) {
+      switch (node.name.type) {
+        case types.AST_NODE_TYPES.JSXIdentifier: {
+          if (/^[a-z]/u.test(node.name.name)) {
+            return;
+          }
+          context.sourceCode.markVariableAsUsed(node.name.name, node);
+          break;
+        }
+        case types.AST_NODE_TYPES.JSXMemberExpression: {
+          const { object } = node.name;
+          if (object.type === types.AST_NODE_TYPES.JSXIdentifier) {
+            context.sourceCode.markVariableAsUsed(object.name, node);
+          }
+          break;
+        }
+      }
+    }
+  };
+}
+var RULE_NAME6 = "no-access-state-in-setstate";
+var RULE_FEATURES6 = [];
 function isKeyLiteral(node, key) {
   return tsPattern.match(key).with({ type: types.AST_NODE_TYPES.Literal }, eff.constTrue).with({ type: types.AST_NODE_TYPES.TemplateLiteral, expressions: [] }, eff.constTrue).with({ type: types.AST_NODE_TYPES.Identifier }, () => !node.computed).otherwise(eff.constFalse);
 }
@@ -215,18 +341,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_FEATURES3
+      [Symbol.for("rule_features")]: RULE_FEATURES6
     },
     messages: {
       noAccessStateInSetstate: "Do not access 'this.state' within 'setState'. Use the update function instead."
     },
     schema: []
   },
-  name: RULE_NAME3,
-  create: create3,
+  name: RULE_NAME6,
+  create: create6,
   defaultOptions: []
 });
-function create3(context) {
+function create6(context) {
   if (!context.sourceCode.text.includes("setState")) {
     return {};
   }
@@ -317,23 +443,9 @@ function create3(context) {
     }
   };
 }
-var RULE_NAME4 = "no-array-index-key";
-var RULE_FEATURES4 = [];
+var RULE_NAME7 = "no-array-index-key";
+var RULE_FEATURES7 = [];
 var reactChildrenMethod = ["forEach", "map"];
-var iteratorFunctionIndexParamPosition = /* @__PURE__ */ new Map([
-  ["every", 1],
-  ["filter", 1],
-  ["find", 1],
-  ["findIndex", 1],
-  ["findLast", 1],
-  ["findLastIndex", 1],
-  ["flatMap", 1],
-  ["forEach", 1],
-  ["map", 1],
-  ["reduce", 2],
-  ["reduceRight", 2],
-  ["some", 1]
-]);
 function isReactChildrenMethod(name5) {
   return reactChildrenMethod.some((method) => method === name5);
 }
@@ -364,7 +476,7 @@ function getMapIndexParamName(context, node) {
     return eff._;
   }
   const { name: name5 } = callee.property;
-  if (!iteratorFunctionIndexParamPosition.has(name5)) {
+  if (!AST11__namespace.ITERATOR_FUNCTION_INDEX_PARAM_POSITION.has(name5)) {
     return eff._;
   }
   const callbackArg = node.arguments[isUsingReactChildren(context, node) ? 1 : 0];
@@ -375,7 +487,7 @@ function getMapIndexParamName(context, node) {
     return eff._;
   }
   const { params } = callbackArg;
-  const indexParamPosition = iteratorFunctionIndexParamPosition.get(name5);
+  const indexParamPosition = AST11__namespace.ITERATOR_FUNCTION_INDEX_PARAM_POSITION.get(name5);
   if (indexParamPosition == null) {
     return eff._;
   }
@@ -402,19 +514,19 @@ 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_FEATURES4
+      [Symbol.for("rule_features")]: RULE_FEATURES7
     },
     messages: {
       noArrayIndexKey: "Do not use item index in the array as its key."
     },
     schema: []
   },
-  name: RULE_NAME4,
-  create: create4,
+  name: RULE_NAME7,
+  create: create7,
   defaultOptions: []
 });
-function create4(context) {
-  const report = shared.createReport(context);
+function create7(context) {
+  const report = kit.createReport(context);
   const indexParamNames = [];
   function isArrayIndex(node) {
     return node.type === types.AST_NODE_TYPES.Identifier && indexParamNames.some((name5) => name5 != null && name5 === node.name);
@@ -511,25 +623,25 @@ function create4(context) {
     }
   };
 }
-var RULE_NAME5 = "no-children-count";
-var RULE_FEATURES5 = [];
+var RULE_NAME8 = "no-children-count";
+var RULE_FEATURES8 = [];
 var no_children_count_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow `Children.count`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES5
+      [Symbol.for("rule_features")]: RULE_FEATURES8
     },
     messages: {
       noChildrenCount: "Using 'Children.count' is uncommon and can lead to fragile code. Use alternatives instead."
     },
     schema: []
   },
-  name: RULE_NAME5,
-  create: create5,
+  name: RULE_NAME8,
+  create: create8,
   defaultOptions: []
 });
-function create5(context) {
+function create8(context) {
   return {
     MemberExpression(node) {
       if (core.isChildrenCount(context, node)) {
@@ -541,25 +653,25 @@ function create5(context) {
     }
   };
 }
-var RULE_NAME6 = "no-children-for-each";
-var RULE_FEATURES6 = [];
+var RULE_NAME9 = "no-children-for-each";
+var RULE_FEATURES9 = [];
 var no_children_for_each_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow 'Children.forEach'.",
-      [Symbol.for("rule_features")]: RULE_FEATURES6
+      [Symbol.for("rule_features")]: RULE_FEATURES9
     },
     messages: {
       noChildrenForEach: "Using 'Children.forEach' is uncommon and can lead to fragile code. Use alternatives instead."
     },
     schema: []
   },
-  name: RULE_NAME6,
-  create: create6,
+  name: RULE_NAME9,
+  create: create9,
   defaultOptions: []
 });
-function create6(context) {
+function create9(context) {
   return {
     MemberExpression(node) {
       if (core.isChildrenForEach(context, node)) {
@@ -571,25 +683,25 @@ function create6(context) {
     }
   };
 }
-var RULE_NAME7 = "no-children-map";
-var RULE_FEATURES7 = [];
+var RULE_NAME10 = "no-children-map";
+var RULE_FEATURES10 = [];
 var no_children_map_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow `Children.map`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES7
+      [Symbol.for("rule_features")]: RULE_FEATURES10
     },
     messages: {
       noChildrenMap: "Using 'Children.map' is uncommon and can lead to fragile code. Use alternatives instead."
     },
     schema: []
   },
-  name: RULE_NAME7,
-  create: create7,
+  name: RULE_NAME10,
+  create: create10,
   defaultOptions: []
 });
-function create7(context) {
+function create10(context) {
   return {
     MemberExpression(node) {
       if (core.isChildrenMap(context, node)) {
@@ -601,25 +713,25 @@ function create7(context) {
     }
   };
 }
-var RULE_NAME8 = "no-children-only";
-var RULE_FEATURES8 = [];
+var RULE_NAME11 = "no-children-only";
+var RULE_FEATURES11 = [];
 var no_children_only_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow `Children.only`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES8
+      [Symbol.for("rule_features")]: RULE_FEATURES11
     },
     messages: {
       noChildrenOnly: "Using 'Children.only' is uncommon and can lead to fragile code. Use alternatives instead."
     },
     schema: []
   },
-  name: RULE_NAME8,
-  create: create8,
+  name: RULE_NAME11,
+  create: create11,
   defaultOptions: []
 });
-function create8(context) {
+function create11(context) {
   return {
     MemberExpression(node) {
       if (core.isChildrenOnly(context, node)) {
@@ -631,28 +743,28 @@ function create8(context) {
     }
   };
 }
-var RULE_NAME9 = "no-children-prop";
-var RULE_FEATURES9 = [];
+var RULE_NAME12 = "no-children-prop";
+var RULE_FEATURES12 = [];
 var no_children_prop_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow passing `children` as a prop.",
-      [Symbol.for("rule_features")]: RULE_FEATURES9
+      [Symbol.for("rule_features")]: RULE_FEATURES12
     },
     messages: {
       noChildrenProp: "Do not pass 'children' as props."
     },
     schema: []
   },
-  name: RULE_NAME9,
-  create: create9,
+  name: RULE_NAME12,
+  create: create12,
   defaultOptions: []
 });
-function create9(context) {
+function create12(context) {
   return {
     JSXElement(node) {
-      const attribute = JSX8__namespace.getAttribute(
+      const attribute = JSX9__namespace.getAttribute(
         "children",
         node.openingElement.attributes,
         context.sourceCode.getScope(node)
@@ -666,25 +778,25 @@ function create9(context) {
     }
   };
 }
-var RULE_NAME10 = "no-children-to-array";
-var RULE_FEATURES10 = [];
+var RULE_NAME13 = "no-children-to-array";
+var RULE_FEATURES13 = [];
 var no_children_to_array_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow `Children.toArray`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES10
+      [Symbol.for("rule_features")]: RULE_FEATURES13
     },
     messages: {
       noChildrenToArray: "Using 'Children.toArray' is uncommon and can lead to fragile code. Use alternatives instead."
     },
     schema: []
   },
-  name: RULE_NAME10,
-  create: create10,
+  name: RULE_NAME13,
+  create: create13,
   defaultOptions: []
 });
-function create10(context) {
+function create13(context) {
   return {
     MemberExpression(node) {
       if (core.isChildrenToArray(context, node)) {
@@ -696,25 +808,25 @@ function create10(context) {
     }
   };
 }
-var RULE_NAME11 = "no-class-component";
-var RULE_FEATURES11 = [];
+var RULE_NAME14 = "no-class-component";
+var RULE_FEATURES14 = [];
 var no_class_component_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow class components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES11
+      [Symbol.for("rule_features")]: RULE_FEATURES14
     },
     messages: {
       noClassComponent: "Do not use class components. Use function components instead."
     },
     schema: []
   },
-  name: RULE_NAME11,
-  create: create11,
+  name: RULE_NAME14,
+  create: create14,
   defaultOptions: []
 });
-function create11(context) {
+function create14(context) {
   if (!context.sourceCode.text.includes("Component")) return {};
   const { ctx, listeners } = core.useComponentCollectorLegacy();
   return {
@@ -736,25 +848,25 @@ function create11(context) {
     }
   };
 }
-var RULE_NAME12 = "no-clone-element";
-var RULE_FEATURES12 = [];
+var RULE_NAME15 = "no-clone-element";
+var RULE_FEATURES15 = [];
 var no_clone_element_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow `cloneElement`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES12
+      [Symbol.for("rule_features")]: RULE_FEATURES15
     },
     messages: {
       noCloneElement: "Using 'cloneElement' is uncommon and can lead to fragile code. Use alternatives instead."
     },
     schema: []
   },
-  name: RULE_NAME12,
-  create: create12,
+  name: RULE_NAME15,
+  create: create15,
   defaultOptions: []
 });
-function create12(context) {
+function create15(context) {
   return {
     CallExpression(node) {
       if (!core.isCloneElementCall(context, node)) {
@@ -767,25 +879,25 @@ function create12(context) {
     }
   };
 }
-var RULE_NAME13 = "no-comment-textnodes";
-var RULE_FEATURES13 = [];
+var RULE_NAME16 = "no-comment-textnodes";
+var RULE_FEATURES16 = [];
 var no_comment_textnodes_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Prevents comments from being inserted as text nodes.",
-      [Symbol.for("rule_features")]: RULE_FEATURES13
+      [Symbol.for("rule_features")]: RULE_FEATURES16
     },
     messages: {
       noCommentTextnodes: "Possible misused comment in text node. Comments inside children section of tag should be placed inside braces."
     },
     schema: []
   },
-  name: RULE_NAME13,
-  create: create13,
+  name: RULE_NAME16,
+  create: create16,
   defaultOptions: []
 });
-function create13(context) {
+function create16(context) {
   function hasCommentLike(node) {
     if (AST11__namespace.isOneOf([types.AST_NODE_TYPES.JSXAttribute, types.AST_NODE_TYPES.JSXExpressionContainer])(node.parent)) {
       return false;
@@ -813,25 +925,27 @@ function create13(context) {
     Literal: visitorFunction
   };
 }
-var RULE_NAME14 = "no-complex-conditional-rendering";
-var RULE_FEATURES14 = [];
+var RULE_NAME17 = "no-complex-conditional-rendering";
+var RULE_FEATURES17 = [
+  "EXP"
+];
 var no_complex_conditional_rendering_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow complex conditional rendering in JSX expressions.",
-      [Symbol.for("rule_features")]: RULE_FEATURES14
+      [Symbol.for("rule_features")]: RULE_FEATURES17
     },
     messages: {
       noComplexConditionalRendering: "Avoid complex conditional rendering. Extract the logic into separate elements or components."
     },
     schema: []
   },
-  name: RULE_NAME14,
-  create: create14,
+  name: RULE_NAME17,
+  create: create17,
   defaultOptions: []
 });
-function create14(context) {
+function create17(context) {
   const visitorFunction = (node) => {
     const jsxExpContainer = node.parent?.parent;
     if (!AST11__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer)(jsxExpContainer)) {
@@ -856,8 +970,8 @@ function create14(context) {
     "JSXExpressionContainer > LogicalExpression[operator='||'] > LogicalExpression[operator='&&']": visitorFunction
   };
 }
-var RULE_NAME15 = "no-component-will-mount";
-var RULE_FEATURES15 = [
+var RULE_NAME18 = "no-component-will-mount";
+var RULE_FEATURES18 = [
   "MOD"
 ];
 function isComponentWillMount(node) {
@@ -868,7 +982,7 @@ var no_component_will_mount_default = createRule({
     type: "problem",
     docs: {
       description: "Replace usages of `componentWillMount` with `UNSAFE_componentWillMount`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES15
+      [Symbol.for("rule_features")]: RULE_FEATURES18
     },
     fixable: "code",
     messages: {
@@ -876,11 +990,11 @@ var no_component_will_mount_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME15,
-  create: create15,
+  name: RULE_NAME18,
+  create: create18,
   defaultOptions: []
 });
-function create15(context) {
+function create18(context) {
   if (!context.sourceCode.text.includes("componentWillMount")) return {};
   const { ctx, listeners } = core.useComponentCollectorLegacy();
   return {
@@ -907,8 +1021,8 @@ function create15(context) {
     }
   };
 }
-var RULE_NAME16 = "no-component-will-receive-props";
-var RULE_FEATURES16 = [
+var RULE_NAME19 = "no-component-will-receive-props";
+var RULE_FEATURES19 = [
   "MOD"
 ];
 function isComponentWillUpdate(node) {
@@ -919,7 +1033,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_FEATURES16
+      [Symbol.for("rule_features")]: RULE_FEATURES19
     },
     fixable: "code",
     messages: {
@@ -927,11 +1041,11 @@ var no_component_will_receive_props_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME16,
-  create: create16,
+  name: RULE_NAME19,
+  create: create19,
   defaultOptions: []
 });
-function create16(context) {
+function create19(context) {
   if (!context.sourceCode.text.includes("componentWillReceiveProps")) return {};
   const { ctx, listeners } = core.useComponentCollectorLegacy();
   return {
@@ -958,8 +1072,8 @@ function create16(context) {
     }
   };
 }
-var RULE_NAME17 = "no-component-will-update";
-var RULE_FEATURES17 = [
+var RULE_NAME20 = "no-component-will-update";
+var RULE_FEATURES20 = [
   "MOD"
 ];
 function isComponentWillUpdate2(node) {
@@ -970,7 +1084,7 @@ var no_component_will_update_default = createRule({
     type: "problem",
     docs: {
       description: "Replace usages of `componentWillUpdate` with `UNSAFE_componentWillUpdate`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES17
+      [Symbol.for("rule_features")]: RULE_FEATURES20
     },
     fixable: "code",
     messages: {
@@ -978,11 +1092,11 @@ var no_component_will_update_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME17,
-  create: create17,
+  name: RULE_NAME20,
+  create: create20,
   defaultOptions: []
 });
-function create17(context) {
+function create20(context) {
   if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
   const { ctx, listeners } = core.useComponentCollectorLegacy();
   return {
@@ -1009,8 +1123,8 @@ function create17(context) {
     }
   };
 }
-var RULE_NAME18 = "no-context-provider";
-var RULE_FEATURES18 = [
+var RULE_NAME21 = "no-context-provider";
+var RULE_FEATURES21 = [
   "MOD"
 ];
 var no_context_provider_default = createRule({
@@ -1018,7 +1132,7 @@ var no_context_provider_default = createRule({
     type: "problem",
     docs: {
       description: "Replace usages of `<Context.Provider>` with `<Context>`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES18
+      [Symbol.for("rule_features")]: RULE_FEATURES21
     },
     fixable: "code",
     messages: {
@@ -1026,17 +1140,17 @@ var no_context_provider_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME18,
-  create: create18,
+  name: RULE_NAME21,
+  create: create21,
   defaultOptions: []
 });
-function create18(context) {
+function create21(context) {
   if (!context.sourceCode.text.includes("Provider")) return {};
   const { version: version2 } = shared.getSettingsFromContext(context);
   if (compareVersions.compare(version2, "19.0.0", "<")) return {};
   return {
     JSXElement(node) {
-      const fullName = JSX8__namespace.getElementType(node);
+      const fullName = JSX9__namespace.getElementType(node);
       const parts = fullName.split(".");
       const selfName = parts.pop();
       const contextFullName = parts.join(".");
@@ -1062,25 +1176,25 @@ function create18(context) {
     }
   };
 }
-var RULE_NAME19 = "no-create-ref";
-var RULE_FEATURES19 = [];
+var RULE_NAME22 = "no-create-ref";
+var RULE_FEATURES22 = [];
 var no_create_ref_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow `createRef` in function components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES19
+      [Symbol.for("rule_features")]: RULE_FEATURES22
     },
     messages: {
       noCreateRef: "[Deprecated] Use 'useRef' instead."
     },
     schema: []
   },
-  name: RULE_NAME19,
-  create: create19,
+  name: RULE_NAME22,
+  create: create22,
   defaultOptions: []
 });
-function create19(context) {
+function create22(context) {
   return {
     CallExpression(node) {
       if (core.isCreateRefCall(context, node) && AST11__namespace.findParentNode(node, core.isClassComponent) == null) {
@@ -1089,25 +1203,25 @@ function create19(context) {
     }
   };
 }
-var RULE_NAME20 = "no-default-props";
-var RULE_FEATURES20 = [];
+var RULE_NAME23 = "no-default-props";
+var RULE_FEATURES23 = [];
 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_FEATURES20
+      [Symbol.for("rule_features")]: RULE_FEATURES23
     },
     messages: {
       noDefaultProps: "[Deprecated] Use ES6 default parameters instead."
     },
     schema: []
   },
-  name: RULE_NAME20,
-  create: create20,
+  name: RULE_NAME23,
+  create: create23,
   defaultOptions: []
 });
-function create20(context) {
+function create23(context) {
   if (!context.sourceCode.text.includes("defaultProps")) return {};
   return {
     AssignmentExpression(node) {
@@ -1124,8 +1238,8 @@ function create20(context) {
       if (!core.isComponentNameLoose(object.name)) {
         return;
       }
-      const variable = VAR__namespace.findVariable(object.name, context.sourceCode.getScope(node));
-      const variableNode = VAR__namespace.getVariableInitNode(variable, 0);
+      const variable = VAR2__namespace.findVariable(object.name, context.sourceCode.getScope(node));
+      const variableNode = VAR2__namespace.getVariableInitNode(variable, 0);
       if (variableNode == null) return;
       if (!AST11__namespace.isFunction(variableNode) && !core.isClassComponent(variableNode)) return;
       context.report({ messageId: "noDefaultProps", node: property });
@@ -1141,8 +1255,8 @@ function create20(context) {
     }
   };
 }
-var RULE_NAME21 = "no-direct-mutation-state";
-var RULE_FEATURES21 = [];
+var RULE_NAME24 = "no-direct-mutation-state";
+var RULE_FEATURES24 = [];
 function isConstructorFunction(node) {
   return AST11__namespace.isOneOf([types.AST_NODE_TYPES.FunctionDeclaration, types.AST_NODE_TYPES.FunctionExpression])(node) && AST11__namespace.isMethodOrProperty(node.parent) && node.parent.key.type === types.AST_NODE_TYPES.Identifier && node.parent.key.name === "constructor";
 }
@@ -1151,18 +1265,18 @@ var no_direct_mutation_state_default = createRule({
     type: "problem",
     docs: {
       description: "Disallow direct mutation of `this.state`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES21
+      [Symbol.for("rule_features")]: RULE_FEATURES24
     },
     messages: {
       noDirectMutationState: "Do not mutate state directly. Use 'setState()' instead."
     },
     schema: []
   },
-  name: RULE_NAME21,
-  create: create21,
+  name: RULE_NAME24,
+  create: create24,
   defaultOptions: []
 });
-function create21(context) {
+function create24(context) {
   return {
     AssignmentExpression(node) {
       if (!core.isAssignmentToThisState(node)) return;
@@ -1183,67 +1297,25 @@ function create21(context) {
     }
   };
 }
-var RULE_NAME22 = "no-duplicate-jsx-props";
-var RULE_FEATURES22 = [];
-var no_duplicate_jsx_props_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow duplicate props in JSX elements.",
-      [Symbol.for("rule_features")]: RULE_FEATURES22
-    },
-    messages: {
-      noDuplicateJsxProps: "This JSX property is assigned multiple times."
-    },
-    schema: []
-  },
-  name: RULE_NAME22,
-  create: create22,
-  defaultOptions: []
-});
-function create22(context) {
-  return {
-    JSXOpeningElement(node) {
-      const props = [];
-      for (const attr of node.attributes) {
-        if (attr.type === types.AST_NODE_TYPES.JSXSpreadAttribute) {
-          continue;
-        }
-        const name5 = attr.name.name;
-        if (typeof name5 !== "string") {
-          continue;
-        }
-        if (!props.includes(name5)) {
-          props.push(name5);
-          continue;
-        }
-        context.report({
-          messageId: "noDuplicateJsxProps",
-          node: attr
-        });
-      }
-    }
-  };
-}
-var RULE_NAME23 = "no-duplicate-key";
-var RULE_FEATURES23 = [];
+var RULE_NAME25 = "no-duplicate-key";
+var RULE_FEATURES25 = [];
 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_FEATURES23
+      [Symbol.for("rule_features")]: RULE_FEATURES25
     },
     messages: {
       noDuplicateKey: "A key must be unique. '{{value}}' is duplicated."
     },
     schema: []
   },
-  name: RULE_NAME23,
-  create: create23,
+  name: RULE_NAME25,
+  create: create25,
   defaultOptions: []
 });
-function create23(context) {
+function create25(context) {
   if (!context.sourceCode.getText().includes("key=")) {
     return {};
   }
@@ -1273,7 +1345,7 @@ function create23(context) {
           break;
         }
         default: {
-          const call = AST11__namespace.findParentNode(jsxElement, AST11__namespace.isMapCallLoose);
+          const call = AST11__namespace.findParentNode(jsxElement, AST11__namespace.isArrayMapCallLoose);
           const iter = AST11__namespace.findParentNode(jsxElement, (n) => n === call || AST11__namespace.isFunction(n));
           if (!AST11__namespace.isFunction(iter)) return;
           const arg0 = call?.arguments[0];
@@ -1307,8 +1379,8 @@ function create23(context) {
     }
   };
 }
-var RULE_NAME24 = "no-forward-ref";
-var RULE_FEATURES24 = [
+var RULE_NAME26 = "no-forward-ref";
+var RULE_FEATURES26 = [
   "MOD"
 ];
 var no_forward_ref_default = createRule({
@@ -1316,7 +1388,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_FEATURES24
+      [Symbol.for("rule_features")]: RULE_FEATURES26
     },
     fixable: "code",
     messages: {
@@ -1324,11 +1396,11 @@ var no_forward_ref_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME24,
-  create: create24,
+  name: RULE_NAME26,
+  create: create26,
   defaultOptions: []
 });
-function create24(context) {
+function create26(context) {
   if (!context.sourceCode.text.includes("forwardRef")) {
     return {};
   }
@@ -1416,29 +1488,31 @@ function getComponentPropsFixes(context, fixer, node, typeArguments) {
     ...arg1 == null ? [] : [fixer.remove(arg1), fixer.removeRange([arg0.range[1], arg1.range[0]])]
   ];
 }
-var RULE_NAME25 = "no-implicit-key";
-var RULE_FEATURES25 = [];
+var RULE_NAME27 = "no-implicit-key";
+var RULE_FEATURES27 = [
+  "EXP"
+];
 var no_implicit_key_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Prevents `key` from not being explicitly specified (e.g. spreading `key` from objects).",
-      [Symbol.for("rule_features")]: RULE_FEATURES25
+      [Symbol.for("rule_features")]: RULE_FEATURES27
     },
     messages: {
       noImplicitKey: "Do not use implicit 'key' props."
     },
     schema: []
   },
-  name: RULE_NAME25,
-  create: create25,
+  name: RULE_NAME27,
+  create: create27,
   defaultOptions: []
 });
-function create25(context) {
+function create27(context) {
   return {
     JSXOpeningElement(node) {
       const initialScope = context.sourceCode.getScope(node);
-      const keyPropFound = JSX8__namespace.getAttribute("key", node.attributes, initialScope);
+      const keyPropFound = JSX9__namespace.getAttribute("key", node.attributes, initialScope);
       const keyPropOnElement = node.attributes.some(
         (n) => n.type === types.AST_NODE_TYPES.JSXAttribute && n.name.type === types.AST_NODE_TYPES.JSXIdentifier && n.name.name === "key"
       );
@@ -1448,8 +1522,8 @@ function create25(context) {
     }
   };
 }
-var RULE_NAME26 = "no-leaked-conditional-rendering";
-var RULE_FEATURES26 = [
+var RULE_NAME28 = "no-leaked-conditional-rendering";
+var RULE_FEATURES28 = [
   "TSC"
 ];
 var tsHelpers = {
@@ -1535,18 +1609,18 @@ var no_leaked_conditional_rendering_default = createRule({
     type: "problem",
     docs: {
       description: "Prevents problematic leaked values from being rendered.",
-      [Symbol.for("rule_features")]: RULE_FEATURES26
+      [Symbol.for("rule_features")]: RULE_FEATURES28
     },
     messages: {
       noLeakedConditionalRendering: "Potential leaked value {{value}} that might cause unintentionally rendered values or rendering crashes."
     },
     schema: []
   },
-  name: RULE_NAME26,
-  create: create26,
+  name: RULE_NAME28,
+  create: create28,
   defaultOptions: []
 });
-function create26(context) {
+function create28(context) {
   if (!context.sourceCode.text.includes("&&") && !context.sourceCode.text.includes("?")) return {};
   const { version: version2 } = shared.getSettingsFromContext(context);
   const allowedVariants = [
@@ -1570,7 +1644,7 @@ function create26(context) {
         return getReportDescriptor(right);
       }
       const initialScope = context.sourceCode.getScope(left);
-      const isLeftNan = left.type === types.AST_NODE_TYPES.Identifier && left.name === "NaN" || VAR__namespace.toStaticValue({ kind: "lazy", node: left, initialScope }).value === "NaN";
+      const isLeftNan = left.type === types.AST_NODE_TYPES.Identifier && left.name === "NaN" || VAR2__namespace.toStaticValue({ kind: "lazy", node: left, initialScope }).value === "NaN";
       if (isLeftNan) {
         return {
           messageId: "noLeakedConditionalRendering",
@@ -1592,36 +1666,36 @@ function create26(context) {
     }).with({ type: types.AST_NODE_TYPES.ConditionalExpression }, ({ alternate, consequent }) => {
       return getReportDescriptor(consequent) ?? getReportDescriptor(alternate);
     }).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
-      const variable = VAR__namespace.findVariable(n.name, context.sourceCode.getScope(n));
-      const initExpression = tsPattern.match(variable?.defs.at(0)?.node).with({ init: tsPattern.P.select({ type: tsPattern.P.not(types.AST_NODE_TYPES.VariableDeclaration) }) }, eff.identity).otherwise(() => eff._);
-      return getReportDescriptor(initExpression);
+      const variable = VAR2__namespace.findVariable(n.name, context.sourceCode.getScope(n));
+      const variableDefNode = variable?.defs.at(0)?.node;
+      return tsPattern.match(variableDefNode).with({ init: tsPattern.P.select({ type: tsPattern.P.not(types.AST_NODE_TYPES.VariableDeclaration) }) }, getReportDescriptor).otherwise(() => eff._);
     }).otherwise(() => eff._);
   }
-  const visitorFunction = eff.flow(getReportDescriptor, shared.createReport(context));
+  const visitorFunction = eff.flow(getReportDescriptor, kit.createReport(context));
   return {
     "JSXExpressionContainer > ConditionalExpression": visitorFunction,
     "JSXExpressionContainer > LogicalExpression": visitorFunction
   };
 }
-var RULE_NAME27 = "no-missing-component-display-name";
-var RULE_FEATURES27 = [];
+var RULE_NAME29 = "no-missing-component-display-name";
+var RULE_FEATURES29 = [];
 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_FEATURES27
+      [Symbol.for("rule_features")]: RULE_FEATURES29
     },
     messages: {
       noMissingComponentDisplayName: "Add missing 'displayName' for component."
     },
     schema: []
   },
-  name: RULE_NAME27,
-  create: create27,
+  name: RULE_NAME29,
+  create: create29,
   defaultOptions: []
 });
-function create27(context) {
+function create29(context) {
   if (!context.sourceCode.text.includes("memo") && !context.sourceCode.text.includes("forwardRef")) return {};
   const {
     ctx,
@@ -1656,25 +1730,25 @@ function create27(context) {
     }
   };
 }
-var RULE_NAME28 = "no-missing-context-display-name";
-var RULE_FEATURES28 = [];
+var RULE_NAME30 = "no-missing-context-display-name";
+var RULE_FEATURES30 = [];
 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_FEATURES28
+      [Symbol.for("rule_features")]: RULE_FEATURES30
     },
     messages: {
       noMissingContextDisplayName: "Add missing 'displayName' for context."
     },
     schema: []
   },
-  name: RULE_NAME28,
-  create: create28,
+  name: RULE_NAME30,
+  create: create30,
   defaultOptions: []
 });
-function create28(context) {
+function create30(context) {
   if (!context.sourceCode.text.includes("createContext")) return {};
   const createCalls = [];
   const displayNameAssignments = [];
@@ -1712,14 +1786,14 @@ function create28(context) {
     }
   };
 }
-var RULE_NAME29 = "no-missing-key";
-var RULE_FEATURES29 = [];
+var RULE_NAME31 = "no-missing-key";
+var RULE_FEATURES31 = [];
 var no_missing_key_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow missing `key` on items in list rendering.",
-      [Symbol.for("rule_features")]: RULE_FEATURES29
+      [Symbol.for("rule_features")]: RULE_FEATURES31
     },
     messages: {
       missingKey: "Missing 'key' for element when rendering list.",
@@ -1727,18 +1801,18 @@ var no_missing_key_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME29,
-  create: create29,
+  name: RULE_NAME31,
+  create: create31,
   defaultOptions: []
 });
-function create29(context) {
-  const report = shared.createReport(context);
+function create31(context) {
+  const report = kit.createReport(context);
   const state = { isWithinChildrenToArray: false };
   function checkIteratorElement(node) {
     switch (node.type) {
       case types.AST_NODE_TYPES.JSXElement: {
         const initialScope = context.sourceCode.getScope(node);
-        if (!JSX8__namespace.hasAttribute("key", node.openingElement.attributes, initialScope)) {
+        if (!JSX9__namespace.hasAttribute("key", node.openingElement.attributes, initialScope)) {
           return {
             messageId: "missingKey",
             node
@@ -1795,7 +1869,7 @@ function create29(context) {
       }
       const initialScope = context.sourceCode.getScope(node);
       for (const element of elements) {
-        if (!JSX8__namespace.hasAttribute("key", element.openingElement.attributes, initialScope)) {
+        if (!JSX9__namespace.hasAttribute("key", element.openingElement.attributes, initialScope)) {
           report({
             messageId: "missingKey",
             node: element
@@ -1808,7 +1882,7 @@ function create29(context) {
       if (state.isWithinChildrenToArray) {
         return;
       }
-      const isMapCall = AST11__namespace.isMapCallLoose(node);
+      const isMapCall = AST11__namespace.isArrayMapCallLoose(node);
       if (!isMapCall && !isArrayFromCall(node)) {
         return;
       }
@@ -1844,27 +1918,26 @@ function create29(context) {
 function isArrayFromCall(node) {
   return node.type === types.AST_NODE_TYPES.CallExpression && node.callee.type === types.AST_NODE_TYPES.MemberExpression && node.callee.property.type === types.AST_NODE_TYPES.Identifier && node.callee.property.name === "from";
 }
-var RULE_NAME30 = "no-nested-component-definitions";
-var RULE_FEATURES30 = [];
+var RULE_NAME32 = "no-nested-component-definitions";
+var RULE_FEATURES32 = [];
 var no_nested_component_definitions_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Disallow nesting component definitions inside other components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES30
+      [Symbol.for("rule_features")]: RULE_FEATURES32
     },
     messages: {
-      noNestedComponentDefinition: "Do not nest component definitions inside other components. Move it to the top level.",
-      noNestedComponentDefinitionInProps: "Do not nest component definitions inside props. Move it to the top level or pass it as a prop."
+      noNestedComponentDefinitions: "Do not nest component definitions inside other components or props. {{suggestion}}"
     },
     schema: []
   },
-  name: RULE_NAME30,
-  create: create30,
+  name: RULE_NAME32,
+  create: create32,
   defaultOptions: []
 });
-function create30(context) {
-  const hint = core.ERComponentHint.SkipMapCallback | core.ERComponentHint.SkipNullLiteral | core.ERComponentHint.SkipUndefined | core.ERComponentHint.SkipBooleanLiteral | core.ERComponentHint.SkipStringLiteral | core.ERComponentHint.SkipNumberLiteral | core.ERComponentHint.StrictLogical | core.ERComponentHint.StrictConditional;
+function create32(context) {
+  const hint = core.ERComponentHint.SkipArrayMapArgument | core.ERComponentHint.SkipNullLiteral | core.ERComponentHint.SkipUndefined | core.ERComponentHint.SkipBooleanLiteral | core.ERComponentHint.SkipStringLiteral | core.ERComponentHint.SkipNumberLiteral | core.ERComponentHint.StrictLogical | core.ERComponentHint.StrictConditional;
   const collector = core.useComponentCollector(context, { hint });
   const collectorLegacy = core.useComponentCollectorLegacy();
   return {
@@ -1889,10 +1962,11 @@ function create30(context) {
         if (isInsideJSXAttributeValue(component)) {
           if (!core.isDeclaredInRenderPropLoose(component)) {
             context.report({
-              messageId: "noNestedComponentDefinitionInProps",
+              messageId: "noNestedComponentDefinitions",
               node: component,
               data: {
-                name: name5
+                name: name5,
+                suggestion: "Move it to the top level or pass it as a prop."
               }
             });
           }
@@ -1900,10 +1974,11 @@ function create30(context) {
         }
         if (isInsideCreateElementProps(context, component)) {
           context.report({
-            messageId: "noNestedComponentDefinitionInProps",
+            messageId: "noNestedComponentDefinitions",
             node: component,
             data: {
-              name: name5
+              name: name5,
+              suggestion: "Move it to the top level or pass it as a prop."
             }
           });
           continue;
@@ -1911,20 +1986,22 @@ function create30(context) {
         const parentComponent = AST11__namespace.findParentNode(component, isFunctionComponent);
         if (parentComponent != null && !core.isDirectValueOfRenderPropertyLoose(parentComponent)) {
           context.report({
-            messageId: component.parent.type === types.AST_NODE_TYPES.Property ? "noNestedComponentDefinitionInProps" : "noNestedComponentDefinition",
+            messageId: "noNestedComponentDefinitions",
             node: component,
             data: {
-              name: name5
+              name: name5,
+              suggestion: component.parent.type === types.AST_NODE_TYPES.Property ? "Move it to the top level or pass it as a prop." : "Move it to the top level."
             }
           });
           continue;
         }
         if (core.isInsideRenderMethod(component)) {
           context.report({
-            messageId: "noNestedComponentDefinition",
+            messageId: "noNestedComponentDefinitions",
             node: component,
             data: {
-              name: name5
+              name: name5,
+              suggestion: "Move it to the top level."
             }
           });
         }
@@ -1934,10 +2011,11 @@ function create30(context) {
           continue;
         }
         context.report({
-          messageId: "noNestedComponentDefinition",
+          messageId: "noNestedComponentDefinitions",
           node: component,
           data: {
-            name: name5
+            name: name5,
+            suggestion: component.parent.type === types.AST_NODE_TYPES.Property ? "Move it to the top level or pass it as a prop." : "Move it to the top level."
           }
         });
       }
@@ -1945,7 +2023,7 @@ function create30(context) {
   };
 }
 function isInsideJSXAttributeValue(node) {
-  return node.parent.type === types.AST_NODE_TYPES.JSXAttribute || JSX8__namespace.findParentAttribute(node, (n) => n.value?.type === types.AST_NODE_TYPES.JSXExpressionContainer) != null;
+  return node.parent.type === types.AST_NODE_TYPES.JSXAttribute || JSX9__namespace.findParentAttribute(node, (n) => n.value?.type === types.AST_NODE_TYPES.JSXExpressionContainer) != null;
 }
 function isInsideCreateElementProps(context, node) {
   const call = AST11__namespace.findParentNode(node, core.isCreateElementCall(context));
@@ -1954,25 +2032,25 @@ function isInsideCreateElementProps(context, node) {
   if (prop == null) return false;
   return prop === call.arguments[1];
 }
-var RULE_NAME31 = "no-prop-types";
-var RULE_FEATURES31 = [];
+var RULE_NAME33 = "no-prop-types";
+var RULE_FEATURES33 = [];
 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_FEATURES31
+      [Symbol.for("rule_features")]: RULE_FEATURES33
     },
     messages: {
       noPropTypes: "[Deprecated] Use TypeScript or another type-checking solution instead."
     },
     schema: []
   },
-  name: RULE_NAME31,
-  create: create31,
+  name: RULE_NAME33,
+  create: create33,
   defaultOptions: []
 });
-function create31(context) {
+function create33(context) {
   if (!context.sourceCode.text.includes("propTypes")) {
     return {};
   }
@@ -1991,8 +2069,8 @@ function create31(context) {
       if (!core.isComponentNameLoose(object.name)) {
         return;
       }
-      const variable = VAR__namespace.findVariable(object.name, context.sourceCode.getScope(node));
-      const variableNode = VAR__namespace.getVariableInitNode(variable, 0);
+      const variable = VAR2__namespace.findVariable(object.name, context.sourceCode.getScope(node));
+      const variableNode = VAR2__namespace.getVariableInitNode(variable, 0);
       if (variableNode != null && (AST11__namespace.isFunction(variableNode) || core.isClassComponent(variableNode))) {
         context.report({ messageId: "noPropTypes", node: property });
       }
@@ -2008,8 +2086,8 @@ function create31(context) {
     }
   };
 }
-var RULE_NAME32 = "no-redundant-should-component-update";
-var RULE_FEATURES32 = [];
+var RULE_NAME34 = "no-redundant-should-component-update";
+var RULE_FEATURES34 = [];
 function isShouldComponentUpdate(node) {
   return AST11__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
 }
@@ -2018,18 +2096,18 @@ var no_redundant_should_component_update_default = createRule({
     type: "problem",
     docs: {
       description: "Disallow `shouldComponentUpdate` when extending `React.PureComponent`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES32
+      [Symbol.for("rule_features")]: RULE_FEATURES34
     },
     messages: {
       noRedundantShouldComponentUpdate: "'{{componentName}}' does not need 'shouldComponentUpdate' when extending 'React.PureComponent'."
     },
     schema: []
   },
-  name: RULE_NAME32,
-  create: create32,
+  name: RULE_NAME34,
+  create: create34,
   defaultOptions: []
 });
-function create32(context) {
+function create34(context) {
   if (!context.sourceCode.text.includes("shouldComponentUpdate")) return {};
   const { ctx, listeners } = core.useComponentCollectorLegacy();
   return {
@@ -2056,8 +2134,8 @@ function create32(context) {
     }
   };
 }
-var RULE_NAME33 = "no-set-state-in-component-did-mount";
-var RULE_FEATURES33 = [];
+var RULE_NAME35 = "no-set-state-in-component-did-mount";
+var RULE_FEATURES35 = [];
 function isComponentDidMount(node) {
   return AST11__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidMount";
 }
@@ -2066,18 +2144,18 @@ var no_set_state_in_component_did_mount_default = createRule({
     type: "problem",
     docs: {
       description: "Disallow calling `this.setState` in `componentDidMount` outside of functions, such as callbacks.",
-      [Symbol.for("rule_features")]: RULE_FEATURES33
+      [Symbol.for("rule_features")]: RULE_FEATURES35
     },
     messages: {
       noSetStateInComponentDidMount: "Do not call `this.setState` in `componentDidMount` outside of functions, such as callbacks."
     },
     schema: []
   },
-  name: RULE_NAME33,
-  create: create33,
+  name: RULE_NAME35,
+  create: create35,
   defaultOptions: []
 });
-function create33(context) {
+function create35(context) {
   if (!context.sourceCode.text.includes("componentDidMount")) return {};
   return {
     CallExpression(node) {
@@ -2098,8 +2176,8 @@ function create33(context) {
     }
   };
 }
-var RULE_NAME34 = "no-set-state-in-component-did-update";
-var RULE_FEATURES34 = [];
+var RULE_NAME36 = "no-set-state-in-component-did-update";
+var RULE_FEATURES36 = [];
 function isComponentDidUpdate(node) {
   return AST11__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentDidUpdate";
 }
@@ -2108,18 +2186,18 @@ var no_set_state_in_component_did_update_default = createRule({
     type: "problem",
     docs: {
       description: "Disallows calling `this.setState` in `componentDidUpdate` outside of functions, such as callbacks.",
-      [Symbol.for("rule_features")]: RULE_FEATURES34
+      [Symbol.for("rule_features")]: RULE_FEATURES36
     },
     messages: {
       noSetStateInComponentDidUpdate: "Do not call `this.setState` in `componentDidUpdate` outside of functions, such as callbacks."
     },
     schema: []
   },
-  name: RULE_NAME34,
-  create: create34,
+  name: RULE_NAME36,
+  create: create36,
   defaultOptions: []
 });
-function create34(context) {
+function create36(context) {
   if (!context.sourceCode.text.includes("componentDidUpdate")) return {};
   return {
     CallExpression(node) {
@@ -2140,8 +2218,8 @@ function create34(context) {
     }
   };
 }
-var RULE_NAME35 = "no-set-state-in-component-will-update";
-var RULE_FEATURES35 = [];
+var RULE_NAME37 = "no-set-state-in-component-will-update";
+var RULE_FEATURES37 = [];
 function isComponentWillUpdate3(node) {
   return AST11__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "componentWillUpdate";
 }
@@ -2150,18 +2228,18 @@ var no_set_state_in_component_will_update_default = createRule({
     type: "problem",
     docs: {
       description: "Disallows calling `this.setState` in `componentWillUpdate` outside of functions, such as callbacks.",
-      [Symbol.for("rule_features")]: RULE_FEATURES35
+      [Symbol.for("rule_features")]: RULE_FEATURES37
     },
     messages: {
       noSetStateInComponentWillUpdate: "Do not call `this.setState` in `componentWillUpdate` outside of functions, such as callbacks."
     },
     schema: []
   },
-  name: RULE_NAME35,
-  create: create35,
+  name: RULE_NAME37,
+  create: create37,
   defaultOptions: []
 });
-function create35(context) {
+function create37(context) {
   if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
   return {
     CallExpression(node) {
@@ -2182,8 +2260,8 @@ function create35(context) {
     }
   };
 }
-var RULE_NAME36 = "no-string-refs";
-var RULE_FEATURES36 = [];
+var RULE_NAME38 = "no-string-refs";
+var RULE_FEATURES38 = [];
 function containsStringLiteral({ value }) {
   return value?.type === types.AST_NODE_TYPES.Literal && typeof value.value === "string";
 }
@@ -2201,18 +2279,18 @@ var no_string_refs_default = createRule({
     type: "problem",
     docs: {
       description: "Disallow deprecated string `refs`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES36
+      [Symbol.for("rule_features")]: RULE_FEATURES38
     },
     messages: {
       noStringRefs: "[Deprecated] Use callback refs instead."
     },
     schema: []
   },
-  name: RULE_NAME36,
-  create: create36,
+  name: RULE_NAME38,
+  create: create38,
   defaultOptions: []
 });
-function create36(context) {
+function create38(context) {
   return {
     JSXAttribute(node) {
       if (node.name.name !== "ref") {
@@ -2227,8 +2305,8 @@ function create36(context) {
     }
   };
 }
-var RULE_NAME37 = "no-unsafe-component-will-mount";
-var RULE_FEATURES37 = [];
+var RULE_NAME39 = "no-unsafe-component-will-mount";
+var RULE_FEATURES39 = [];
 function isUnsafeComponentWillMount(node) {
   return AST11__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillMount";
 }
@@ -2237,18 +2315,18 @@ var no_unsafe_component_will_mount_default = createRule({
     type: "problem",
     docs: {
       description: "Warns the usage of `UNSAFE_componentWillMount` in class components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES37
+      [Symbol.for("rule_features")]: RULE_FEATURES39
     },
     messages: {
       noUnsafeComponentWillMount: "Do not use 'UNSAFE_componentWillMount'."
     },
     schema: []
   },
-  name: RULE_NAME37,
-  create: create37,
+  name: RULE_NAME39,
+  create: create39,
   defaultOptions: []
 });
-function create37(context) {
+function create39(context) {
   if (!context.sourceCode.text.includes("UNSAFE_componentWillMount")) return {};
   const { ctx, listeners } = core.useComponentCollectorLegacy();
   return {
@@ -2269,8 +2347,8 @@ function create37(context) {
     }
   };
 }
-var RULE_NAME38 = "no-unsafe-component-will-receive-props";
-var RULE_FEATURES38 = [];
+var RULE_NAME40 = "no-unsafe-component-will-receive-props";
+var RULE_FEATURES40 = [];
 function isUnsafeComponentWillReceiveProps(node) {
   return AST11__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillReceiveProps";
 }
@@ -2279,18 +2357,18 @@ var no_unsafe_component_will_receive_props_default = createRule({
     type: "problem",
     docs: {
       description: "Warns the usage of `UNSAFE_componentWillReceiveProps` in class components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES38
+      [Symbol.for("rule_features")]: RULE_FEATURES40
     },
     messages: {
       noUnsafeComponentWillReceiveProps: "Do not use 'UNSAFE_componentWillReceiveProps'."
     },
     schema: []
   },
-  name: RULE_NAME38,
-  create: create38,
+  name: RULE_NAME40,
+  create: create40,
   defaultOptions: []
 });
-function create38(context) {
+function create40(context) {
   if (!context.sourceCode.text.includes("UNSAFE_componentWillReceiveProps")) {
     return {};
   }
@@ -2313,8 +2391,8 @@ function create38(context) {
     }
   };
 }
-var RULE_NAME39 = "no-unsafe-component-will-update";
-var RULE_FEATURES39 = [];
+var RULE_NAME41 = "no-unsafe-component-will-update";
+var RULE_FEATURES41 = [];
 function isUnsafeComponentWillUpdate(node) {
   return AST11__namespace.isMethodOrProperty(node) && node.key.type === types.AST_NODE_TYPES.Identifier && node.key.name === "UNSAFE_componentWillUpdate";
 }
@@ -2323,18 +2401,18 @@ var no_unsafe_component_will_update_default = createRule({
     type: "problem",
     docs: {
       description: "Warns the usage of `UNSAFE_componentWillUpdate` in class components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES39
+      [Symbol.for("rule_features")]: RULE_FEATURES41
     },
     messages: {
       noUnsafeComponentWillUpdate: "Do not use 'UNSAFE_componentWillUpdate'."
     },
     schema: []
   },
-  name: RULE_NAME39,
-  create: create39,
+  name: RULE_NAME41,
+  create: create41,
   defaultOptions: []
 });
-function create39(context) {
+function create41(context) {
   if (!context.sourceCode.text.includes("UNSAFE_componentWillUpdate")) return {};
   const { ctx, listeners } = core.useComponentCollectorLegacy();
   return {
@@ -2355,25 +2433,25 @@ function create39(context) {
     }
   };
 }
-var RULE_NAME40 = "no-unstable-context-value";
-var RULE_FEATURES40 = [];
+var RULE_NAME42 = "no-unstable-context-value";
+var RULE_FEATURES42 = [];
 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_FEATURES40
+      [Symbol.for("rule_features")]: RULE_FEATURES42
     },
     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_NAME40,
-  create: create40,
+  name: RULE_NAME42,
+  create: create42,
   defaultOptions: []
 });
-function create40(context) {
+function create42(context) {
   const { version: version2 } = shared.getSettingsFromContext(context);
   const isReact18OrBelow = compareVersions.compare(version2, "19.0.0", "<");
   const { ctx, listeners } = core.useComponentCollector(context);
@@ -2381,7 +2459,7 @@ function create40(context) {
   return {
     ...listeners,
     JSXOpeningElement(node) {
-      const fullName = JSX8__namespace.getElementType(node.parent);
+      const fullName = JSX9__namespace.getElementType(node.parent);
       const selfName = fullName.split(".").at(-1);
       if (selfName == null) return;
       if (!isContextName(selfName, isReact18OrBelow)) return;
@@ -2395,7 +2473,7 @@ function create40(context) {
       if (value?.type !== types.AST_NODE_TYPES.JSXExpressionContainer) return;
       const valueExpression = value.expression;
       const initialScope = context.sourceCode.getScope(valueExpression);
-      const construction = VAR__namespace.getValueConstruction(valueExpression, initialScope);
+      const construction = VAR2__namespace.getValueConstruction(valueExpression, initialScope);
       if (construction == null) return;
       if (core.isReactHookCall(construction.node)) {
         return;
@@ -2428,25 +2506,25 @@ function isContextName(name5, isReact18OrBelow) {
   }
   return false;
 }
-var RULE_NAME41 = "no-unstable-default-props";
-var RULE_FEATURES41 = [];
+var RULE_NAME43 = "no-unstable-default-props";
+var RULE_FEATURES43 = [];
 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_FEATURES41
+      [Symbol.for("rule_features")]: RULE_FEATURES43
     },
     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_NAME41,
-  create: create41,
+  name: RULE_NAME43,
+  create: create43,
   defaultOptions: []
 });
-function create41(context) {
+function create43(context) {
   const { ctx, listeners } = core.useComponentCollector(context);
   const declarators = /* @__PURE__ */ new Map();
   return {
@@ -2469,10 +2547,10 @@ function create41(context) {
           const { value } = prop;
           const { right } = value;
           const initialScope = context.sourceCode.getScope(value);
-          const construction = VAR__namespace.getValueConstruction(
+          const construction = VAR2__namespace.getValueConstruction(
             value,
             initialScope,
-            VAR__namespace.ValueConstructionHint.StrictCallExpression
+            VAR2__namespace.ValueConstructionHint.StrictCallExpression
           );
           if (construction == null) {
             continue;
@@ -2502,8 +2580,8 @@ function create41(context) {
     }
   };
 }
-var RULE_NAME42 = "no-unused-class-component-members";
-var RULE_FEATURES42 = [];
+var RULE_NAME44 = "no-unused-class-component-members";
+var RULE_FEATURES44 = [];
 var LIFECYCLE_METHODS = /* @__PURE__ */ new Set([
   "componentDidCatch",
   "componentDidMount",
@@ -2529,18 +2607,18 @@ var no_unused_class_component_members_default = createRule({
     type: "problem",
     docs: {
       description: "Warns unused class component methods and properties.",
-      [Symbol.for("rule_features")]: RULE_FEATURES42
+      [Symbol.for("rule_features")]: RULE_FEATURES44
     },
     messages: {
       noUnusedClassComponentMembers: "Unused method or property '{{methodName}}'' of class '{{className}}'."
     },
     schema: []
   },
-  name: RULE_NAME42,
-  create: create42,
+  name: RULE_NAME44,
+  create: create44,
   defaultOptions: []
 });
-function create42(context) {
+function create44(context) {
   const classEntries = [];
   const methodEntries = [];
   const propertyDefs = /* @__PURE__ */ new WeakMap();
@@ -2650,8 +2728,8 @@ function create42(context) {
     }
   };
 }
-var RULE_NAME43 = "no-unused-state";
-var RULE_FEATURES43 = [];
+var RULE_NAME45 = "no-unused-state";
+var RULE_FEATURES45 = [];
 function isKeyLiteral3(node, key) {
   return tsPattern.match(key).with({ type: types.AST_NODE_TYPES.Literal }, eff.constTrue).with({ type: types.AST_NODE_TYPES.TemplateLiteral, expressions: [] }, eff.constTrue).with({ type: types.AST_NODE_TYPES.Identifier }, () => !node.computed).otherwise(eff.constFalse);
 }
@@ -2660,18 +2738,18 @@ var no_unused_state_default = createRule({
     type: "problem",
     docs: {
       description: "Warns unused class component state.",
-      [Symbol.for("rule_features")]: RULE_FEATURES43
+      [Symbol.for("rule_features")]: RULE_FEATURES45
     },
     messages: {
       noUnusedState: "Unused class component state in '{{className}}'"
     },
     schema: []
   },
-  name: RULE_NAME43,
-  create: create43,
+  name: RULE_NAME45,
+  create: create45,
   defaultOptions: []
 });
-function create43(context) {
+function create45(context) {
   const classEntries = [];
   const methodEntries = [];
   const constructorEntries = [];
@@ -2805,8 +2883,8 @@ function create43(context) {
     }
   };
 }
-var RULE_NAME44 = "no-use-context";
-var RULE_FEATURES44 = [
+var RULE_NAME46 = "no-use-context";
+var RULE_FEATURES46 = [
   "MOD"
 ];
 var no_use_context_default = createRule({
@@ -2814,7 +2892,7 @@ var no_use_context_default = createRule({
     type: "problem",
     docs: {
       description: "Replaces usages of `useContext` with `use`.",
-      [Symbol.for("rule_features")]: RULE_FEATURES44
+      [Symbol.for("rule_features")]: RULE_FEATURES46
     },
     fixable: "code",
     messages: {
@@ -2822,11 +2900,11 @@ var no_use_context_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME44,
-  create: create44,
+  name: RULE_NAME46,
+  create: create46,
   defaultOptions: []
 });
-function create44(context) {
+function create46(context) {
   if (!context.sourceCode.text.includes("useContext")) return {};
   const settings4 = shared.getSettingsFromContext(context);
   const useContextAlias = /* @__PURE__ */ new Set();
@@ -2904,25 +2982,25 @@ function getAssociatedTokens(context, node) {
     return tokens;
   }
 }
-var RULE_NAME45 = "no-useless-forward-ref";
-var RULE_FEATURES45 = [];
+var RULE_NAME47 = "no-useless-forward-ref";
+var RULE_FEATURES47 = [];
 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_FEATURES45
+      [Symbol.for("rule_features")]: RULE_FEATURES47
     },
     messages: {
       noUselessForwardRef: "A 'forwardRef' is used with this component but no 'ref' parameter is set."
     },
     schema: []
   },
-  name: RULE_NAME45,
-  create: create45,
+  name: RULE_NAME47,
+  create: create47,
   defaultOptions: []
 });
-function create45(context) {
+function create47(context) {
   return {
     CallExpression(node) {
       if (!core.isForwardRefCall(context, node)) {
@@ -2943,7 +3021,7 @@ function create45(context) {
     }
   };
 }
-var RULE_NAME46 = "no-useless-fragment";
+var RULE_NAME48 = "no-useless-fragment";
 var defaultOptions = [{
   allowExpressions: true
 }];
@@ -2969,15 +3047,15 @@ var no_useless_fragment_default = createRule({
       }
     }]
   },
-  name: RULE_NAME46,
-  create: create46,
+  name: RULE_NAME48,
+  create: create48,
   defaultOptions
 });
-function create46(context, [option]) {
+function create48(context, [option]) {
   const { allowExpressions = true } = option;
   return {
     JSXElement(node) {
-      if (!JSX8__namespace.isFragmentElement(node)) return;
+      if (!JSX9__namespace.isFragmentElement(node)) return;
       doCheck(context, node, allowExpressions);
     },
     JSXFragment(node) {
@@ -2999,12 +3077,12 @@ function doCheck(context, node, allowExpressions) {
         return null;
       }
       if (node.children.some(
-        (child) => JSX8__namespace.isLiteral(child) && !JSX8__namespace.isWhiteSpace(child) || AST11__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer)(child)
+        (child) => JSX9__namespace.isLiteral(child) && !JSX9__namespace.isWhiteSpace(child) || AST11__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer)(child)
       )) {
         return null;
       }
     }
-    if (JSX8__namespace.isUserDefinedElement(node.parent)) {
+    if (JSX9__namespace.isUserDefinedElement(node.parent)) {
       return null;
     }
     const opener = node.type === types.AST_NODE_TYPES.JSXFragment ? node.openingFragment : node.openingElement;
@@ -3013,10 +3091,10 @@ function doCheck(context, node, allowExpressions) {
     return fixer.replaceText(node, trimLikeReact(childrenText));
   }
   const initialScope = context.sourceCode.getScope(node);
-  if (JSX8__namespace.isKeyedElement(node, initialScope)) {
+  if (JSX9__namespace.isKeyedElement(node, initialScope)) {
     return;
   }
-  if (JSX8__namespace.isBuiltInElement(node.parent)) {
+  if (JSX9__namespace.isBuiltInElement(node.parent)) {
     context.report({
       messageId: "uselessFragment",
       node,
@@ -3040,7 +3118,7 @@ function doCheck(context, node, allowExpressions) {
   const isChildElement = AST11__namespace.isOneOf([types.AST_NODE_TYPES.JSXElement, types.AST_NODE_TYPES.JSXFragment])(node.parent);
   switch (true) {
     // <Foo content={<>ee eeee eeee ...</>} />
-    case (allowExpressions && !isChildElement && node.children.length === 1 && JSX8__namespace.isLiteral(node.children.at(0))): {
+    case (allowExpressions && !isChildElement && node.children.length === 1 && JSX9__namespace.isLiteral(node.children.at(0))): {
       return;
     }
     // <Foo><>hello, world</></Foo>
@@ -3067,7 +3145,7 @@ function doCheck(context, node, allowExpressions) {
       return;
     }
   }
-  const nonPaddingChildren = node.children.filter((child) => !JSX8__namespace.isPaddingSpaces(child));
+  const nonPaddingChildren = node.children.filter((child) => !JSX9__namespace.isPaddingSpaces(child));
   const firstNonPaddingChild = nonPaddingChildren.at(0);
   switch (true) {
     case nonPaddingChildren.length === 0:
@@ -3085,8 +3163,8 @@ function doCheck(context, node, allowExpressions) {
   }
   return;
 }
-var RULE_NAME47 = "prefer-destructuring-assignment";
-var RULE_FEATURES46 = [];
+var RULE_NAME49 = "prefer-destructuring-assignment";
+var RULE_FEATURES48 = [];
 function isMemberExpressionWithObjectName(node) {
   return node.object.type === types.AST_NODE_TYPES.Identifier && "name" in node.object;
 }
@@ -3095,18 +3173,18 @@ var prefer_destructuring_assignment_default = createRule({
     type: "problem",
     docs: {
       description: "Enforces destructuring assignment for component props and context.",
-      [Symbol.for("rule_features")]: RULE_FEATURES46
+      [Symbol.for("rule_features")]: RULE_FEATURES48
     },
     messages: {
       preferDestructuringAssignment: "Use destructuring assignment for {{name}}."
     },
     schema: []
   },
-  name: RULE_NAME47,
-  create: create47,
+  name: RULE_NAME49,
+  create: create49,
   defaultOptions: []
 });
-function create47(context) {
+function create49(context) {
   const { ctx, listeners } = core.useComponentCollector(context);
   const memberExpressionWithNames = [];
   return {
@@ -3166,16 +3244,17 @@ function create47(context) {
     }
   };
 }
-var RULE_NAME48 = "prefer-react-namespace-import";
-var RULE_FEATURES47 = [
-  "FIX"
+var RULE_NAME50 = "prefer-react-namespace-import";
+var RULE_FEATURES49 = [
+  "FIX",
+  "EXP"
 ];
 var prefer_react_namespace_import_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Enforces React is imported via a namespace import.",
-      [Symbol.for("rule_features")]: RULE_FEATURES47
+      [Symbol.for("rule_features")]: RULE_FEATURES49
     },
     fixable: "code",
     messages: {
@@ -3183,11 +3262,11 @@ var prefer_react_namespace_import_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME48,
-  create: create48,
+  name: RULE_NAME50,
+  create: create50,
   defaultOptions: []
 });
-function create48(context) {
+function create50(context) {
   const { importSource } = shared.getSettingsFromContext(context);
   return {
     [`ImportDeclaration[source.value="${importSource}"] ImportDefaultSpecifier`](node) {
@@ -3220,27 +3299,28 @@ ${importStringPrefix} ${specifiers} from ${importSourceQuoted}${semiColon}`
     }
   };
 }
-var RULE_NAME49 = "prefer-read-only-props";
-var RULE_FEATURES48 = [
-  "TSC"
+var RULE_NAME51 = "prefer-read-only-props";
+var RULE_FEATURES50 = [
+  "TSC",
+  "EXP"
 ];
 var prefer_read_only_props_default = createRule({
   meta: {
     type: "problem",
     docs: {
       description: "Enforces read-only props in components.",
-      [Symbol.for("rule_features")]: RULE_FEATURES48
+      [Symbol.for("rule_features")]: RULE_FEATURES50
     },
     messages: {
       preferReadOnlyProps: "A function component's props should be read-only."
     },
     schema: []
   },
-  name: RULE_NAME49,
-  create: create49,
+  name: RULE_NAME51,
+  create: create51,
   defaultOptions: []
 });
-function create49(context) {
+function create51(context) {
   const services = utils.ESLintUtils.getParserServices(context, false);
   const { ctx, listeners } = core.useComponentCollector(context);
   return {
@@ -3270,8 +3350,8 @@ function isTypeReadonlyLoose(services, type) {
     return true;
   }
 }
-var RULE_NAME50 = "prefer-shorthand-boolean";
-var RULE_FEATURES49 = [
+var RULE_NAME52 = "prefer-shorthand-boolean";
+var RULE_FEATURES51 = [
   "FIX"
 ];
 var prefer_shorthand_boolean_default = createRule({
@@ -3279,7 +3359,7 @@ var prefer_shorthand_boolean_default = createRule({
     type: "problem",
     docs: {
       description: "Enforces shorthand syntax for boolean attributes.",
-      [Symbol.for("rule_features")]: RULE_FEATURES49
+      [Symbol.for("rule_features")]: RULE_FEATURES51
     },
     fixable: "code",
     messages: {
@@ -3287,15 +3367,15 @@ var prefer_shorthand_boolean_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME50,
-  create: create50,
+  name: RULE_NAME52,
+  create: create52,
   defaultOptions: []
 });
-function create50(context) {
+function create52(context) {
   return {
     JSXAttribute(node) {
       const { value } = node;
-      const propName = JSX8__namespace.getAttributeName(node);
+      const propName = JSX9__namespace.getAttributeName(node);
       const hasValueTrue = value?.type === types.AST_NODE_TYPES.JSXExpressionContainer && value.expression.type === types.AST_NODE_TYPES.Literal && value.expression.value === true;
       if (!hasValueTrue) {
         return;
@@ -3311,8 +3391,8 @@ function create50(context) {
     }
   };
 }
-var RULE_NAME51 = "prefer-shorthand-fragment";
-var RULE_FEATURES50 = [
+var RULE_NAME53 = "prefer-shorthand-fragment";
+var RULE_FEATURES52 = [
   "FIX"
 ];
 var prefer_shorthand_fragment_default = createRule({
@@ -3320,7 +3400,7 @@ var prefer_shorthand_fragment_default = createRule({
     type: "problem",
     docs: {
       description: "Enforces shorthand syntax for fragments.",
-      [Symbol.for("rule_features")]: RULE_FEATURES50
+      [Symbol.for("rule_features")]: RULE_FEATURES52
     },
     fixable: "code",
     messages: {
@@ -3328,14 +3408,14 @@ var prefer_shorthand_fragment_default = createRule({
     },
     schema: []
   },
-  name: RULE_NAME51,
-  create: create51,
+  name: RULE_NAME53,
+  create: create53,
   defaultOptions: []
 });
-function create51(context) {
+function create53(context) {
   return {
     JSXElement(node) {
-      if (!JSX8__namespace.isFragmentElement(node)) return;
+      if (!JSX9__namespace.isFragmentElement(node)) return;
       const hasAttributes = node.openingElement.attributes.length > 0;
       if (hasAttributes) {
         return;
@@ -3357,46 +3437,6 @@ function create51(context) {
     }
   };
 }
-var RULE_NAME52 = "use-jsx-vars";
-var RULE_FEATURES51 = [];
-var use_jsx_vars_default = createRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Marks variables used in JSX as used.",
-      [Symbol.for("rule_features")]: RULE_FEATURES51
-    },
-    messages: {
-      useJsxVars: ""
-    },
-    schema: []
-  },
-  name: RULE_NAME52,
-  create: create52,
-  defaultOptions: []
-});
-function create52(context) {
-  return {
-    JSXOpeningElement(node) {
-      switch (node.name.type) {
-        case types.AST_NODE_TYPES.JSXIdentifier: {
-          if (/^[a-z]/u.test(node.name.name)) {
-            return;
-          }
-          context.sourceCode.markVariableAsUsed(node.name.name, node);
-          break;
-        }
-        case types.AST_NODE_TYPES.JSXMemberExpression: {
-          const { object } = node.name;
-          if (object.type === types.AST_NODE_TYPES.JSXIdentifier) {
-            context.sourceCode.markVariableAsUsed(object.name, node);
-          }
-          break;
-        }
-      }
-    }
-  };
-}
 
 // src/plugin.ts
 var plugin = {
@@ -3426,7 +3466,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-duplicate-jsx-props": no_duplicate_jsx_props_default,
     "no-duplicate-key": no_duplicate_key_default,
     "no-forward-ref": no_forward_ref_default,
     "no-implicit-key": no_implicit_key_default,
@@ -3456,18 +3495,21 @@ var plugin = {
     "prefer-read-only-props": prefer_read_only_props_default,
     "prefer-shorthand-boolean": prefer_shorthand_boolean_default,
     "prefer-shorthand-fragment": prefer_shorthand_fragment_default,
-    "use-jsx-vars": use_jsx_vars_default,
+    // Part: JSX only rules
+    "jsx-no-duplicate-props": jsx_no_duplicate_props_default,
+    "jsx-no-undef": jsx_no_undef_default,
+    "jsx-uses-vars": jsx_uses_vars_default,
     // Part: deprecated rules
     /** @deprecated Use `no-useless-forward-ref` instead */
     "ensure-forward-ref-using-ref": no_useless_forward_ref_default,
-    /** @deprecated Use `no-duplicate-jsx-props` instead */
-    "jsx-no-duplicate-props": no_duplicate_jsx_props_default,
-    /** @deprecated Use `use-jsx-vars` instead */
-    "jsx-uses-vars": use_jsx_vars_default,
     /** @deprecated Use `no-complex-conditional-rendering` instead */
     "no-complicated-conditional-rendering": no_complex_conditional_rendering_default,
+    /** @deprecated Use `jsx-no-duplicate-props` instead */
+    "no-duplicate-jsx-props": jsx_no_duplicate_props_default,
     /** @deprecated Use `no-nested-component-definitions` instead */
-    "no-nested-components": no_nested_component_definitions_default
+    "no-nested-components": no_nested_component_definitions_default,
+    /** @deprecated Use `jsx-uses-vars` instead */
+    "use-jsx-vars": jsx_uses_vars_default
   }
 };