eslint-plugin-react-x 3.0.0-next.28 → 3.0.0-next.31

package/dist/index.js

@@ -6,12 +6,12 @@ import { P, isMatching, match } from "ts-pattern";
 import ts from "typescript";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { findEnclosingAssignmentTarget, findVariable, getChildScopes, getObjectType, getVariableInitializer, isAssignmentTargetEqual } from "@eslint-react/var";
+import { DefinitionType } from "@typescript-eslint/scope-manager";
 import { constFalse, constTrue, constVoid, flow, getOrElseUpdate, identity, not, unit } from "@eslint-react/eff";
 import { compare } from "compare-versions";
-import { getConstrainedTypeAtLocation, isTypeReadonly } from "@typescript-eslint/type-utils";
-import { isPropertyReadonlyInType, unionConstituents } from "ts-api-utils";
+import { getConstrainedTypeAtLocation } from "@typescript-eslint/type-utils";
+import { unionConstituents } from "ts-api-utils";
 import { getStaticValue, isIdentifier, isVariableDeclarator } from "@typescript-eslint/utils/ast-utils";
-import { getTypeImmutability, isImmutable, isReadonlyDeep, isReadonlyShallow, isUnknown } from "is-immutable-type";
 import { snakeCase } from "string-ts";
 
 //#region \0rolldown/runtime.js
@@ -39,6 +39,7 @@ var disable_experimental_exports = /* @__PURE__ */ __exportAll({
 const name$8 = "react-x/disable-experimental";
 const rules$8 = {
 	"react-x/exhaustive-deps": "off",
+	"react-x/immutability": "off",
 	"react-x/jsx-key-before-spread": "off",
 	"react-x/no-duplicate-key": "off",
 	"react-x/no-implicit-key": "off",
@@ -46,7 +47,6 @@ const rules$8 = {
 	"react-x/no-unnecessary-use-callback": "off",
 	"react-x/no-unnecessary-use-memo": "off",
 	"react-x/no-unused-props": "off",
-	"react-x/prefer-read-only-props": "off",
 	"react-x/refs": "off",
 	"react-x/rules-of-hooks": "off",
 	"react-x/set-state-in-render": "off"
@@ -62,14 +62,13 @@ const name$7 = "react-x/disable-type-checked";
 const rules$7 = {
 	"react-x/no-implicit-key": "off",
 	"react-x/no-leaked-conditional-rendering": "off",
-	"react-x/no-unused-props": "off",
-	"react-x/prefer-read-only-props": "off"
+	"react-x/no-unused-props": "off"
 };
 
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "3.0.0-next.28";
+var version = "3.0.0-next.31";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -226,7 +225,7 @@ function getTypeVariants(types) {
 
 //#endregion
 //#region src/rules/component-hook-factories.ts
-const RULE_NAME$64 = "component-hook-factories";
+const RULE_NAME$62 = "component-hook-factories";
 var component_hook_factories_default = createRule({
 	meta: {
 		type: "problem",
@@ -237,11 +236,11 @@ var component_hook_factories_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$64,
-	create: create$64,
+	name: RULE_NAME$62,
+	create: create$62,
 	defaultOptions: []
 });
-function create$64(context) {
+function create$62(context) {
 	const hint = core.ComponentDetectionHint.DoNotIncludeJsxWithNumberValue | core.ComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | core.ComponentDetectionHint.DoNotIncludeJsxWithNullValue | core.ComponentDetectionHint.DoNotIncludeJsxWithStringValue | core.ComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | core.ComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx | core.ComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayPattern | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayExpression | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback;
 	const fCollector = core.useComponentCollector(context, { hint });
 	const cCollector = core.useComponentCollectorLegacy(context);
@@ -285,7 +284,7 @@ function create$64(context) {
 
 //#endregion
 //#region src/rules/error-boundaries.ts
-const RULE_NAME$63 = "error-boundaries";
+const RULE_NAME$61 = "error-boundaries";
 var error_boundaries_default = createRule({
 	meta: {
 		type: "problem",
@@ -296,11 +295,11 @@ var error_boundaries_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$63,
-	create: create$63,
+	name: RULE_NAME$61,
+	create: create$61,
 	defaultOptions: []
 });
-function create$63(context) {
+function create$61(context) {
 	if (!context.sourceCode.text.includes("try")) return {};
 	const { ctx, visitor } = core.useComponentCollector(context);
 	const reported = /* @__PURE__ */ new Set();
@@ -1238,9 +1237,173 @@ function getUnknownDependenciesMessage(reactiveHookName) {
 	return `React Hook ${reactiveHookName} received a function whose dependencies are unknown. Pass an inline function instead.`;
 }
 
+//#endregion
+//#region src/rules/immutability.ts
+const RULE_NAME$60 = "immutability";
+/**
+* Array methods that mutate the array in place.
+* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
+*/
+const MUTATING_ARRAY_METHODS = new Set([
+	"copyWithin",
+	"fill",
+	"pop",
+	"push",
+	"reverse",
+	"shift",
+	"sort",
+	"splice",
+	"unshift"
+]);
+/**
+* Get the root identifier of a (possibly nested) member expression.
+* For `a.b.c`, returns the `a` Identifier node.
+* @param node The expression to analyze
+* @returns The root Identifier node, or null if it cannot be determined (e.g. non-identifier root)
+*/
+function getRootIdentifier(node) {
+	switch (node.type) {
+		case AST_NODE_TYPES.Identifier: return node;
+		case AST_NODE_TYPES.MemberExpression: return getRootIdentifier(node.object);
+		default: return null;
+	}
+}
+var immutability_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Validates against mutating props, state, and other values that are immutable." },
+		messages: {
+			mutatingArrayMethod: "Do not call '{{method}}()' on '{{name}}'. Props and state are immutable — create a new array instead.",
+			mutatingAssignment: "Do not mutate '{{name}}' directly. Props and state are immutable — create a new object instead."
+		},
+		schema: []
+	},
+	name: RULE_NAME$60,
+	create: create$60,
+	defaultOptions: []
+});
+function create$60(context) {
+	const { additionalStateHooks } = getSettingsFromContext(context);
+	const hCollector = core.useHookCollector(context);
+	const cCollector = core.useComponentCollector(context);
+	/**
+	* Violations accumulated while traversing. Each entry records the node to
+	* report and the enclosing function so we can filter at Program:exit.
+	*/
+	const violations = [];
+	function isUseStateCall(node) {
+		return core.isUseStateLikeCall(node, additionalStateHooks);
+	}
+	/**
+	* Return true when `id` is the *value* variable (index 0) produced by a
+	* `useState(…)` call, i.e. the first element of `const [value, setter] = useState(…)`.
+	* @param id The identifier to check. May be a reference to the state variable, e.g. used inside an event handler nested in the component body — scope resolution will trace it back to the original declaration.
+	* @returns True if `id` is a state variable, false otherwise.
+	*/
+	function isStateValue(id) {
+		const initNode = getVariableInitializer(findVariable(id, context.sourceCode.getScope(id)), 0);
+		if (initNode == null || initNode.type !== AST_NODE_TYPES.CallExpression) return false;
+		if (!isUseStateCall(initNode)) return false;
+		const declarator = initNode.parent;
+		if (!("id" in declarator) || declarator.id?.type !== AST_NODE_TYPES.ArrayPattern) return true;
+		return declarator.id.elements.findIndex((el) => el?.type === AST_NODE_TYPES.Identifier && el.name === id.name) === 0;
+	}
+	/**
+	* Return true when `id` is a direct (non-destructured) props parameter at
+	* position 0 of any ancestor function.
+	*
+	* Uses scope resolution so that references to `props` inside nested arrow
+	* functions (e.g. event handlers) are correctly traced back to the component
+	* parameter, e.g.:
+	*
+	*   function Component(props) {        // ← props defined here
+	*     const handleClick = () => {
+	*       props.items.push(4); // ← props resolved via scope to Component's param
+	*     };
+	*   }
+	* @param id The identifier to check. May be a reference to the props parameter, e.g. used inside an event handler nested in the component body — scope resolution will trace it back to the original declaration.
+	* @returns True if `id` is a props parameter, false otherwise.
+	*/
+	function isPropsObject(id) {
+		const variable = findVariable(id, context.sourceCode.getScope(id));
+		if (variable == null) return false;
+		for (const def of variable.defs) {
+			if (def.type !== DefinitionType.Parameter) continue;
+			if (!ast.isFunction(def.node)) continue;
+			const firstParam = def.node.params.at(0);
+			return firstParam?.type === AST_NODE_TYPES.Identifier && firstParam.name === id.name;
+		}
+		return false;
+	}
+	return defineRuleListener(hCollector.visitor, cCollector.visitor, {
+		CallExpression(node) {
+			if (node.callee.type !== AST_NODE_TYPES.MemberExpression) return;
+			const { object, property } = node.callee;
+			if (property.type !== AST_NODE_TYPES.Identifier) return;
+			if (!MUTATING_ARRAY_METHODS.has(property.name)) return;
+			const rootId = getRootIdentifier(object);
+			if (rootId == null) return;
+			if (rootId.name === "draft") return;
+			const enclosingFn = ast.findParentNode(node, ast.isFunction);
+			if (enclosingFn == null) return;
+			const isState = isStateValue(rootId);
+			const isProps = isPropsObject(rootId);
+			if (!isState && !isProps) return;
+			violations.push({
+				messageId: "mutatingArrayMethod",
+				node,
+				data: {
+					name: context.sourceCode.getText(object),
+					method: property.name
+				},
+				func: enclosingFn
+			});
+		},
+		AssignmentExpression(node) {
+			if (node.left.type !== AST_NODE_TYPES.MemberExpression) return;
+			const rootId = getRootIdentifier(node.left);
+			if (rootId == null) return;
+			if (rootId.name === "draft") return;
+			const enclosingFn = ast.findParentNode(node, ast.isFunction);
+			if (enclosingFn == null) return;
+			const isState = isStateValue(rootId);
+			const isProps = isPropsObject(rootId);
+			if (!isState && !isProps) return;
+			violations.push({
+				messageId: "mutatingAssignment",
+				node,
+				data: { name: context.sourceCode.getText(node.left.object) },
+				func: enclosingFn
+			});
+		},
+		"Program:exit"(program) {
+			const components = cCollector.ctx.getAllComponents(program);
+			const hooks = hCollector.ctx.getAllHooks(program);
+			const componentAndHookFns = new Set([...components.map((c) => c.node), ...hooks.map((h) => h.node)]);
+			for (const { messageId, node, data, func } of violations) {
+				let current = func;
+				let insideComponentOrHook = false;
+				while (current != null) {
+					if (componentAndHookFns.has(current)) {
+						insideComponentOrHook = true;
+						break;
+					}
+					current = ast.findParentNode(current, ast.isFunction);
+				}
+				if (!insideComponentOrHook) continue;
+				context.report({
+					messageId,
+					node,
+					data
+				});
+			}
+		}
+	});
+}
+
 //#endregion
 //#region src/rules/jsx-dollar.ts
-const RULE_NAME$62 = "jsx-dollar";
+const RULE_NAME$59 = "jsx-dollar";
 var jsx_dollar_default = createRule({
 	meta: {
 		type: "problem",
@@ -1253,11 +1416,11 @@ var jsx_dollar_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$62,
-	create: create$62,
+	name: RULE_NAME$59,
+	create: create$59,
 	defaultOptions: []
 });
-function create$62(context) {
+function create$59(context) {
 	/**
 	* Visitor function for JSXElement and JSXFragment nodes
 	* @param node The JSXElement or JSXFragment node to be checked
@@ -1298,7 +1461,7 @@ function create$62(context) {
 
 //#endregion
 //#region src/rules/jsx-key-before-spread.ts
-const RULE_NAME$61 = "jsx-key-before-spread";
+const RULE_NAME$58 = "jsx-key-before-spread";
 var jsx_key_before_spread_default = createRule({
 	meta: {
 		type: "problem",
@@ -1306,11 +1469,11 @@ var jsx_key_before_spread_default = createRule({
 		messages: { default: "The 'key' prop must be placed before any spread props when using the new JSX transform." },
 		schema: []
 	},
-	name: RULE_NAME$61,
-	create: create$61,
+	name: RULE_NAME$58,
+	create: create$58,
 	defaultOptions: []
 });
-function create$61(context) {
+function create$58(context) {
 	const { jsx } = {
 		...core.getJsxConfigFromContext(context),
 		...core.getJsxConfigFromAnnotation(context)
@@ -1334,7 +1497,7 @@ function create$61(context) {
 
 //#endregion
 //#region src/rules/jsx-no-comment-textnodes.ts
-const RULE_NAME$60 = "jsx-no-comment-textnodes";
+const RULE_NAME$57 = "jsx-no-comment-textnodes";
 var jsx_no_comment_textnodes_default = createRule({
 	meta: {
 		type: "problem",
@@ -1342,11 +1505,11 @@ var jsx_no_comment_textnodes_default = createRule({
 		messages: { default: "Possible misused comment in text node. Comments inside children section of tag should be placed inside braces." },
 		schema: []
 	},
-	name: RULE_NAME$60,
-	create: create$60,
+	name: RULE_NAME$57,
+	create: create$57,
 	defaultOptions: []
 });
-function create$60(context) {
+function create$57(context) {
 	function hasCommentLike(node) {
 		if (ast.isOneOf([AST_NODE_TYPES.JSXAttribute, AST_NODE_TYPES.JSXExpressionContainer])(node.parent)) return false;
 		return /^\s*\/(?:\/|\*)/mu.test(context.sourceCode.getText(node));
@@ -1367,7 +1530,7 @@ function create$60(context) {
 
 //#endregion
 //#region src/rules/jsx-no-duplicate-props.ts
-const RULE_NAME$59 = "jsx-no-duplicate-props";
+const RULE_NAME$56 = "jsx-no-duplicate-props";
 var jsx_no_duplicate_props_default = createRule({
 	meta: {
 		type: "problem",
@@ -1375,11 +1538,11 @@ var jsx_no_duplicate_props_default = createRule({
 		messages: { default: "This JSX property is assigned multiple times." },
 		schema: []
 	},
-	name: RULE_NAME$59,
-	create: create$59,
+	name: RULE_NAME$56,
+	create: create$56,
 	defaultOptions: []
 });
-function create$59(context) {
+function create$56(context) {
 	return defineRuleListener({ JSXOpeningElement(node) {
 		const props = [];
 		for (const attr of node.attributes) {
@@ -1398,40 +1561,9 @@ function create$59(context) {
 	} });
 }
 
-//#endregion
-//#region src/rules/jsx-no-undef.ts
-const RULE_NAME$58 = "jsx-no-undef";
-var jsx_no_undef_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Prevents using variables in JSX that are not defined in the scope." },
-		messages: { default: "JSX variable '{{name}}' is not defined." },
-		schema: []
-	},
-	name: RULE_NAME$58,
-	create: create$58,
-	defaultOptions: []
-});
-function create$58(context) {
-	return defineRuleListener({ JSXOpeningElement(node) {
-		const name = 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 (name == null) return;
-		if (name === "this") return;
-		if (/^[a-z]/u.test(name)) return;
-		if (findVariable(name, context.sourceCode.getScope(node)) == null) context.report({
-			messageId: "default",
-			node,
-			data: { name }
-		});
-	} });
-}
-
 //#endregion
 //#region src/rules/jsx-shorthand-boolean.ts
-const RULE_NAME$57 = "jsx-shorthand-boolean";
+const RULE_NAME$55 = "jsx-shorthand-boolean";
 const defaultOptions$4 = [1];
 const schema$4 = [{
 	type: "integer",
@@ -1445,11 +1577,11 @@ var jsx_shorthand_boolean_default = createRule({
 		messages: { default: "{{message}}" },
 		schema: schema$4
 	},
-	name: RULE_NAME$57,
-	create: create$57,
+	name: RULE_NAME$55,
+	create: create$55,
 	defaultOptions: defaultOptions$4
 });
-function create$57(context) {
+function create$55(context) {
 	const policy = context.options[0] ?? defaultOptions$4[0];
 	return defineRuleListener({ JSXAttribute(node) {
 		const { value } = node;
@@ -1477,7 +1609,7 @@ function create$57(context) {
 
 //#endregion
 //#region src/rules/jsx-shorthand-fragment.ts
-const RULE_NAME$56 = "jsx-shorthand-fragment";
+const RULE_NAME$54 = "jsx-shorthand-fragment";
 const defaultOptions$3 = [1];
 const schema$3 = [{
 	type: "integer",
@@ -1491,11 +1623,11 @@ var jsx_shorthand_fragment_default = createRule({
 		messages: { default: "{{message}}" },
 		schema: schema$3
 	},
-	name: RULE_NAME$56,
-	create: create$56,
+	name: RULE_NAME$54,
+	create: create$54,
 	defaultOptions: defaultOptions$3
 });
-function create$56(context) {
+function create$54(context) {
 	const policy = context.options[0] ?? defaultOptions$3[0];
 	const jsxConfig = {
 		...core.getJsxConfigFromContext(context),
@@ -1530,7 +1662,7 @@ function create$56(context) {
 
 //#endregion
 //#region src/rules/jsx-uses-react.ts
-const RULE_NAME$55 = "jsx-uses-react";
+const RULE_NAME$53 = "jsx-uses-react";
 var jsx_uses_react_default = createRule({
 	meta: {
 		type: "problem",
@@ -1538,11 +1670,11 @@ var jsx_uses_react_default = createRule({
 		messages: { default: "Marked {{name}} as used." },
 		schema: []
 	},
-	name: RULE_NAME$55,
-	create: create$55,
+	name: RULE_NAME$53,
+	create: create$53,
 	defaultOptions: []
 });
-function create$55(context) {
+function create$53(context) {
 	const { jsx, jsxFactory, jsxFragmentFactory } = {
 		...core.getJsxConfigFromContext(context),
 		...core.getJsxConfigFromAnnotation(context)
@@ -1573,7 +1705,7 @@ function debugReport(context, node, name) {
 
 //#endregion
 //#region src/rules/jsx-uses-vars.ts
-const RULE_NAME$54 = "jsx-uses-vars";
+const RULE_NAME$52 = "jsx-uses-vars";
 var jsx_uses_vars_default = createRule({
 	meta: {
 		type: "problem",
@@ -1581,11 +1713,11 @@ var jsx_uses_vars_default = createRule({
 		messages: { default: "An identifier in JSX is marked as used." },
 		schema: []
 	},
-	name: RULE_NAME$54,
-	create: create$54,
+	name: RULE_NAME$52,
+	create: create$52,
 	defaultOptions: []
 });
-function create$54(context) {
+function create$52(context) {
 	return defineRuleListener({ JSXOpeningElement(node) {
 		switch (node.name.type) {
 			case AST_NODE_TYPES.JSXIdentifier:
@@ -1603,7 +1735,7 @@ function create$54(context) {
 
 //#endregion
 //#region src/rules/no-access-state-in-setstate.ts
-const RULE_NAME$53 = "no-access-state-in-setstate";
+const RULE_NAME$51 = "no-access-state-in-setstate";
 function isKeyLiteral$2(node, key) {
 	return match(key).with({ type: AST_NODE_TYPES.Literal }, constTrue).with({
 		type: AST_NODE_TYPES.TemplateLiteral,
@@ -1617,11 +1749,11 @@ var no_access_state_in_setstate_default = createRule({
 		messages: { default: "Do not access 'this.state' within 'setState'. Use the update function instead." },
 		schema: []
 	},
-	name: RULE_NAME$53,
-	create: create$53,
+	name: RULE_NAME$51,
+	create: create$51,
 	defaultOptions: []
 });
-function create$53(context) {
+function create$51(context) {
 	if (!context.sourceCode.text.includes("setState")) return {};
 	const classStack = [];
 	const methodStack = [];
@@ -1692,7 +1824,7 @@ function create$53(context) {
 
 //#endregion
 //#region src/rules/no-array-index-key.ts
-const RULE_NAME$52 = "no-array-index-key";
+const RULE_NAME$50 = "no-array-index-key";
 const REACT_CHILDREN_METHOD = ["forEach", "map"];
 function getIndexParamPosition(methodName) {
 	switch (methodName) {
@@ -1751,11 +1883,11 @@ var no_array_index_key_default = createRule({
 		messages: { default: "Do not use item index in the array as its key." },
 		schema: []
 	},
-	name: RULE_NAME$52,
-	create: create$52,
+	name: RULE_NAME$50,
+	create: create$50,
 	defaultOptions: []
 });
-function create$52(context) {
+function create$50(context) {
 	const indexParamNames = [];
 	function isArrayIndex(node) {
 		return node.type === AST_NODE_TYPES.Identifier && indexParamNames.some((name) => name != null && name === node.name);
@@ -1821,7 +1953,7 @@ function create$52(context) {
 
 //#endregion
 //#region src/rules/no-children-count.ts
-const RULE_NAME$51 = "no-children-count";
+const RULE_NAME$49 = "no-children-count";
 var no_children_count_default = createRule({
 	meta: {
 		type: "problem",
@@ -1829,11 +1961,11 @@ var no_children_count_default = createRule({
 		messages: { default: "Using 'Children.count' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$51,
-	create: create$51,
+	name: RULE_NAME$49,
+	create: create$49,
 	defaultOptions: []
 });
-function create$51(context) {
+function create$49(context) {
 	return defineRuleListener({ MemberExpression(node) {
 		if (core.isChildrenCount(context, node)) context.report({
 			messageId: "default",
@@ -1844,7 +1976,7 @@ function create$51(context) {
 
 //#endregion
 //#region src/rules/no-children-for-each.ts
-const RULE_NAME$50 = "no-children-for-each";
+const RULE_NAME$48 = "no-children-for-each";
 var no_children_for_each_default = createRule({
 	meta: {
 		type: "problem",
@@ -1852,11 +1984,11 @@ var no_children_for_each_default = createRule({
 		messages: { default: "Using 'Children.forEach' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$50,
-	create: create$50,
+	name: RULE_NAME$48,
+	create: create$48,
 	defaultOptions: []
 });
-function create$50(context) {
+function create$48(context) {
 	return defineRuleListener({ MemberExpression(node) {
 		if (core.isChildrenForEach(context, node)) context.report({
 			messageId: "default",
@@ -1867,7 +1999,7 @@ function create$50(context) {
 
 //#endregion
 //#region src/rules/no-children-map.ts
-const RULE_NAME$49 = "no-children-map";
+const RULE_NAME$47 = "no-children-map";
 var no_children_map_default = createRule({
 	meta: {
 		type: "problem",
@@ -1875,11 +2007,11 @@ var no_children_map_default = createRule({
 		messages: { default: "Using 'Children.map' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$49,
-	create: create$49,
+	name: RULE_NAME$47,
+	create: create$47,
 	defaultOptions: []
 });
-function create$49(context) {
+function create$47(context) {
 	return defineRuleListener({ MemberExpression(node) {
 		if (core.isChildrenMap(context, node)) context.report({
 			messageId: "default",
@@ -1890,7 +2022,7 @@ function create$49(context) {
 
 //#endregion
 //#region src/rules/no-children-only.ts
-const RULE_NAME$48 = "no-children-only";
+const RULE_NAME$46 = "no-children-only";
 var no_children_only_default = createRule({
 	meta: {
 		type: "problem",
@@ -1898,11 +2030,11 @@ var no_children_only_default = createRule({
 		messages: { default: "Using 'Children.only' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$48,
-	create: create$48,
+	name: RULE_NAME$46,
+	create: create$46,
 	defaultOptions: []
 });
-function create$48(context) {
+function create$46(context) {
 	return defineRuleListener({ MemberExpression(node) {
 		if (core.isChildrenOnly(context, node)) context.report({
 			messageId: "default",
@@ -1913,7 +2045,7 @@ function create$48(context) {
 
 //#endregion
 //#region src/rules/no-children-prop.ts
-const RULE_NAME$47 = "no-children-prop";
+const RULE_NAME$45 = "no-children-prop";
 var no_children_prop_default = createRule({
 	meta: {
 		type: "problem",
@@ -1921,11 +2053,11 @@ var no_children_prop_default = createRule({
 		messages: { default: "Do not pass 'children' as props." },
 		schema: []
 	},
-	name: RULE_NAME$47,
-	create: create$47,
+	name: RULE_NAME$45,
+	create: create$45,
 	defaultOptions: []
 });
-function create$47(context) {
+function create$45(context) {
 	return defineRuleListener({ JSXElement(node) {
 		const childrenProp = core.getJsxAttribute(context, node)("children");
 		if (childrenProp != null) context.report({
@@ -1937,7 +2069,7 @@ function create$47(context) {
 
 //#endregion
 //#region src/rules/no-children-to-array.ts
-const RULE_NAME$46 = "no-children-to-array";
+const RULE_NAME$44 = "no-children-to-array";
 var no_children_to_array_default = createRule({
 	meta: {
 		type: "problem",
@@ -1945,11 +2077,11 @@ var no_children_to_array_default = createRule({
 		messages: { default: "Using 'Children.toArray' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$46,
-	create: create$46,
+	name: RULE_NAME$44,
+	create: create$44,
 	defaultOptions: []
 });
-function create$46(context) {
+function create$44(context) {
 	return defineRuleListener({ MemberExpression(node) {
 		if (core.isChildrenToArray(context, node)) context.report({
 			messageId: "default",
@@ -1960,7 +2092,7 @@ function create$46(context) {
 
 //#endregion
 //#region src/rules/no-class-component.ts
-const RULE_NAME$45 = "no-class-component";
+const RULE_NAME$43 = "no-class-component";
 var no_class_component_default = createRule({
 	meta: {
 		type: "problem",
@@ -1968,11 +2100,11 @@ var no_class_component_default = createRule({
 		messages: { default: "Avoid using class components. Use function components instead." },
 		schema: []
 	},
-	name: RULE_NAME$45,
-	create: create$45,
+	name: RULE_NAME$43,
+	create: create$43,
 	defaultOptions: []
 });
-function create$45(context) {
+function create$43(context) {
 	if (!context.sourceCode.text.includes("Component")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -1989,7 +2121,7 @@ function create$45(context) {
 
 //#endregion
 //#region src/rules/no-clone-element.ts
-const RULE_NAME$44 = "no-clone-element";
+const RULE_NAME$42 = "no-clone-element";
 var no_clone_element_default = createRule({
 	meta: {
 		type: "problem",
@@ -1997,11 +2129,11 @@ var no_clone_element_default = createRule({
 		messages: { default: "Using 'cloneElement' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$44,
-	create: create$44,
+	name: RULE_NAME$42,
+	create: create$42,
 	defaultOptions: []
 });
-function create$44(context) {
+function create$42(context) {
 	return defineRuleListener({ CallExpression(node) {
 		if (core.isCloneElementCall(context, node)) context.report({
 			messageId: "default",
@@ -2012,7 +2144,7 @@ function create$44(context) {
 
 //#endregion
 //#region src/rules/no-component-will-mount.ts
-const RULE_NAME$43 = "no-component-will-mount";
+const RULE_NAME$41 = "no-component-will-mount";
 var no_component_will_mount_default = createRule({
 	meta: {
 		type: "problem",
@@ -2021,11 +2153,11 @@ var no_component_will_mount_default = createRule({
 		messages: { default: "[Deprecated] Use 'UNSAFE_componentWillMount' instead." },
 		schema: []
 	},
-	name: RULE_NAME$43,
-	create: create$43,
+	name: RULE_NAME$41,
+	create: create$41,
 	defaultOptions: []
 });
-function create$43(context) {
+function create$41(context) {
 	if (!context.sourceCode.text.includes("componentWillMount")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -2045,7 +2177,7 @@ function create$43(context) {
 
 //#endregion
 //#region src/rules/no-component-will-receive-props.ts
-const RULE_NAME$42 = "no-component-will-receive-props";
+const RULE_NAME$40 = "no-component-will-receive-props";
 var no_component_will_receive_props_default = createRule({
 	meta: {
 		type: "problem",
@@ -2054,11 +2186,11 @@ var no_component_will_receive_props_default = createRule({
 		messages: { default: "[Deprecated] Use 'UNSAFE_componentWillReceiveProps' instead." },
 		schema: []
 	},
-	name: RULE_NAME$42,
-	create: create$42,
+	name: RULE_NAME$40,
+	create: create$40,
 	defaultOptions: []
 });
-function create$42(context) {
+function create$40(context) {
 	if (!context.sourceCode.text.includes("componentWillReceiveProps")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -2078,7 +2210,7 @@ function create$42(context) {
 
 //#endregion
 //#region src/rules/no-component-will-update.ts
-const RULE_NAME$41 = "no-component-will-update";
+const RULE_NAME$39 = "no-component-will-update";
 var no_component_will_update_default = createRule({
 	meta: {
 		type: "problem",
@@ -2087,11 +2219,11 @@ var no_component_will_update_default = createRule({
 		messages: { default: "[Deprecated] Use 'UNSAFE_componentWillUpdate' instead." },
 		schema: []
 	},
-	name: RULE_NAME$41,
-	create: create$41,
+	name: RULE_NAME$39,
+	create: create$39,
 	defaultOptions: []
 });
-function create$41(context) {
+function create$39(context) {
 	if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -2111,7 +2243,7 @@ function create$41(context) {
 
 //#endregion
 //#region src/rules/no-context-provider.ts
-const RULE_NAME$40 = "no-context-provider";
+const RULE_NAME$38 = "no-context-provider";
 var no_context_provider_default = createRule({
 	meta: {
 		type: "problem",
@@ -2120,11 +2252,11 @@ var no_context_provider_default = createRule({
 		messages: { default: "In React 19, you can render '<Context>' as a provider instead of '<Context.Provider>'." },
 		schema: []
 	},
-	name: RULE_NAME$40,
-	create: create$40,
+	name: RULE_NAME$38,
+	create: create$38,
 	defaultOptions: []
 });
-function create$40(context) {
+function create$38(context) {
 	if (!context.sourceCode.text.includes("Provider")) return {};
 	const { version } = getSettingsFromContext(context);
 	if (compare(version, "19.0.0", "<")) return {};
@@ -2151,7 +2283,7 @@ function create$40(context) {
 
 //#endregion
 //#region src/rules/no-create-ref.ts
-const RULE_NAME$39 = "no-create-ref";
+const RULE_NAME$37 = "no-create-ref";
 var no_create_ref_default = createRule({
 	meta: {
 		type: "problem",
@@ -2159,11 +2291,11 @@ var no_create_ref_default = createRule({
 		messages: { default: "[Deprecated] Use 'useRef' instead." },
 		schema: []
 	},
-	name: RULE_NAME$39,
-	create: create$39,
+	name: RULE_NAME$37,
+	create: create$37,
 	defaultOptions: []
 });
-function create$39(context) {
+function create$37(context) {
 	return defineRuleListener({ CallExpression(node) {
 		if (core.isCreateRefCall(context, node) && ast.findParentNode(node, core.isClassComponent) == null) context.report({
 			messageId: "default",
@@ -2174,7 +2306,7 @@ function create$39(context) {
 
 //#endregion
 //#region src/rules/no-direct-mutation-state.ts
-const RULE_NAME$38 = "no-direct-mutation-state";
+const RULE_NAME$36 = "no-direct-mutation-state";
 function isConstructorFunction(node) {
 	return ast.isOneOf([AST_NODE_TYPES.FunctionDeclaration, AST_NODE_TYPES.FunctionExpression])(node) && ast.isMethodOrProperty(node.parent) && node.parent.key.type === AST_NODE_TYPES.Identifier && node.parent.key.name === "constructor";
 }
@@ -2185,11 +2317,11 @@ var no_direct_mutation_state_default = createRule({
 		messages: { default: "Do not mutate state directly. Use 'setState()' instead." },
 		schema: []
 	},
-	name: RULE_NAME$38,
-	create: create$38,
+	name: RULE_NAME$36,
+	create: create$36,
 	defaultOptions: []
 });
-function create$38(context) {
+function create$36(context) {
 	return defineRuleListener({ AssignmentExpression(node) {
 		if (!core.isAssignmentToThisState(node)) return;
 		const parentClass = ast.findParentNode(node, ast.isOneOf([AST_NODE_TYPES.ClassDeclaration, AST_NODE_TYPES.ClassExpression]));
@@ -2203,7 +2335,7 @@ function create$38(context) {
 
 //#endregion
 //#region src/rules/no-duplicate-key.ts
-const RULE_NAME$37 = "no-duplicate-key";
+const RULE_NAME$35 = "no-duplicate-key";
 var no_duplicate_key_default = createRule({
 	meta: {
 		type: "problem",
@@ -2211,11 +2343,11 @@ var no_duplicate_key_default = createRule({
 		messages: { default: "The 'key' prop must be unique to its sibling elements." },
 		schema: []
 	},
-	name: RULE_NAME$37,
-	create: create$37,
+	name: RULE_NAME$35,
+	create: create$35,
 	defaultOptions: []
 });
-function create$37(context) {
+function create$35(context) {
 	if (!context.sourceCode.text.includes("key=")) return {};
 	const keyedEntries = /* @__PURE__ */ new Map();
 	function isKeyValueEqual(a, b) {
@@ -2270,7 +2402,7 @@ function create$37(context) {
 
 //#endregion
 //#region src/rules/no-forward-ref.ts
-const RULE_NAME$36 = "no-forward-ref";
+const RULE_NAME$34 = "no-forward-ref";
 var no_forward_ref_default = createRule({
 	meta: {
 		type: "problem",
@@ -2279,11 +2411,11 @@ var no_forward_ref_default = createRule({
 		messages: { default: "In React 19, 'forwardRef' is no longer necessary. Pass 'ref' as a prop instead." },
 		schema: []
 	},
-	name: RULE_NAME$36,
-	create: create$36,
+	name: RULE_NAME$34,
+	create: create$34,
 	defaultOptions: []
 });
-function create$36(context) {
+function create$34(context) {
 	if (!context.sourceCode.text.includes("forwardRef")) return {};
 	const { version } = getSettingsFromContext(context);
 	if (compare(version, "19.0.0", "<")) return {};
@@ -2378,7 +2510,7 @@ function getComponentPropsFixes(context, fixer, node, typeArguments) {
 
 //#endregion
 //#region src/rules/no-implicit-key.ts
-const RULE_NAME$35 = "no-implicit-key";
+const RULE_NAME$33 = "no-implicit-key";
 var no_implicit_key_default = createRule({
 	meta: {
 		type: "problem",
@@ -2386,11 +2518,11 @@ var no_implicit_key_default = createRule({
 		messages: { default: "This spread attribute implicitly passes the 'key' prop to a component, this could lead to unexpected behavior. If you intend to pass the 'key' prop, use 'key={value}'." },
 		schema: []
 	},
-	name: RULE_NAME$35,
-	create: create$35,
+	name: RULE_NAME$33,
+	create: create$33,
 	defaultOptions: []
 });
-function create$35(context) {
+function create$33(context) {
 	const services = ESLintUtils.getParserServices(context, false);
 	const checker = services.program.getTypeChecker();
 	return defineRuleListener({ JSXSpreadAttribute(node) {
@@ -2408,7 +2540,7 @@ function create$35(context) {
 
 //#endregion
 //#region src/rules/no-leaked-conditional-rendering.ts
-const RULE_NAME$34 = "no-leaked-conditional-rendering";
+const RULE_NAME$32 = "no-leaked-conditional-rendering";
 var no_leaked_conditional_rendering_default = createRule({
 	meta: {
 		type: "problem",
@@ -2416,11 +2548,11 @@ var no_leaked_conditional_rendering_default = createRule({
 		messages: { default: "Potential leaked value {{value}} that might cause unintentionally rendered values or rendering crashes." },
 		schema: []
 	},
-	name: RULE_NAME$34,
-	create: create$34,
+	name: RULE_NAME$32,
+	create: create$32,
 	defaultOptions: []
 });
-function create$34(context) {
+function create$32(context) {
 	if (!context.sourceCode.text.includes("&&")) return {};
 	const { version } = getSettingsFromContext(context);
 	const allowedVariants = [
@@ -2477,7 +2609,7 @@ function create$34(context) {
 
 //#endregion
 //#region src/rules/no-missing-component-display-name.ts
-const RULE_NAME$33 = "no-missing-component-display-name";
+const RULE_NAME$31 = "no-missing-component-display-name";
 var no_missing_component_display_name_default = createRule({
 	meta: {
 		type: "problem",
@@ -2485,11 +2617,11 @@ var no_missing_component_display_name_default = createRule({
 		messages: { default: "Add missing 'displayName' for component." },
 		schema: []
 	},
-	name: RULE_NAME$33,
-	create: create$33,
+	name: RULE_NAME$31,
+	create: create$31,
 	defaultOptions: []
 });
-function create$33(context) {
+function create$31(context) {
 	if (!context.sourceCode.text.includes("memo") && !context.sourceCode.text.includes("forwardRef")) return {};
 	const { ctx, visitor } = core.useComponentCollector(context, {
 		collectDisplayName: true,
@@ -2511,7 +2643,7 @@ function create$33(context) {
 
 //#endregion
 //#region src/rules/no-missing-context-display-name.ts
-const RULE_NAME$32 = "no-missing-context-display-name";
+const RULE_NAME$30 = "no-missing-context-display-name";
 var no_missing_context_display_name_default = createRule({
 	meta: {
 		type: "problem",
@@ -2520,11 +2652,11 @@ var no_missing_context_display_name_default = createRule({
 		messages: { default: "Add missing 'displayName' for context." },
 		schema: []
 	},
-	name: RULE_NAME$32,
-	create: create$32,
+	name: RULE_NAME$30,
+	create: create$30,
 	defaultOptions: []
 });
-function create$32(context) {
+function create$30(context) {
 	if (!context.sourceCode.text.includes("createContext")) return {};
 	const createCalls = [];
 	const displayNameAssignments = [];
@@ -2576,7 +2708,7 @@ function create$32(context) {
 
 //#endregion
 //#region src/rules/no-missing-key.ts
-const RULE_NAME$31 = "no-missing-key";
+const RULE_NAME$29 = "no-missing-key";
 var no_missing_key_default = createRule({
 	meta: {
 		type: "problem",
@@ -2587,11 +2719,11 @@ var no_missing_key_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$31,
-	create: create$31,
+	name: RULE_NAME$29,
+	create: create$29,
 	defaultOptions: []
 });
-function create$31(ctx) {
+function create$29(ctx) {
 	let inChildrenToArray = false;
 	function check(node) {
 		if (node.type === AST_NODE_TYPES.JSXElement) return core.getJsxAttribute(ctx, node)("key") == null ? {
@@ -2662,7 +2794,7 @@ function create$31(ctx) {
 
 //#endregion
 //#region src/rules/no-misused-capture-owner-stack.ts
-const RULE_NAME$30 = "no-misused-capture-owner-stack";
+const RULE_NAME$28 = "no-misused-capture-owner-stack";
 var no_misused_capture_owner_stack_default = createRule({
 	meta: {
 		type: "problem",
@@ -2673,11 +2805,11 @@ var no_misused_capture_owner_stack_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$30,
-	create: create$30,
+	name: RULE_NAME$28,
+	create: create$28,
 	defaultOptions: []
 });
-function create$30(context) {
+function create$28(context) {
 	if (!context.sourceCode.text.includes("captureOwnerStack")) return {};
 	const { importSource } = getSettingsFromContext(context);
 	return defineRuleListener({
@@ -2708,7 +2840,7 @@ function isDevelopmentOnlyCheck(node) {
 
 //#endregion
 //#region src/rules/no-nested-component-definitions.ts
-const RULE_NAME$29 = "no-nested-component-definitions";
+const RULE_NAME$27 = "no-nested-component-definitions";
 var no_nested_component_definitions_default = createRule({
 	meta: {
 		type: "problem",
@@ -2716,23 +2848,24 @@ var no_nested_component_definitions_default = createRule({
 		messages: { default: "Do not nest component definitions inside other components or props. {{suggestion}}" },
 		schema: []
 	},
-	name: RULE_NAME$29,
-	create: create$29,
+	name: RULE_NAME$27,
+	create: create$27,
 	defaultOptions: []
 });
-function create$29(context) {
+function create$27(context) {
 	const hint = core.ComponentDetectionHint.DoNotIncludeJsxWithNumberValue | core.ComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | core.ComponentDetectionHint.DoNotIncludeJsxWithNullValue | core.ComponentDetectionHint.DoNotIncludeJsxWithStringValue | core.ComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | core.ComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx | core.ComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayPattern | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayExpression | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback;
 	const fCollector = core.useComponentCollector(context, { hint });
 	const cCollector = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(fCollector.visitor, cCollector.visitor, { "Program:exit"(program) {
 		const fComponents = [...fCollector.ctx.getAllComponents(program)];
 		const cComponents = [...cCollector.ctx.getAllComponents(program)];
-		const isFunctionComponent = (node) => {
-			return ast.isFunction(node) && fComponents.some((component) => component.node === node);
-		};
-		const isClassComponent = (node) => {
-			return ast.isClass(node) && cComponents.some((component) => component.node === node);
-		};
+		function findEnclosingComponent(node) {
+			return ast.findParentNode(node, (n) => {
+				if (ast.isFunction(n)) return fComponents.some((c) => c.node === n);
+				if (ast.isClass(n)) return cComponents.some((c) => c.node === n);
+				return false;
+			});
+		}
 		for (const { name, node: component } of fComponents) {
 			if (name == null) continue;
 			if (core.isDirectValueOfRenderPropertyLoose(component)) continue;
@@ -2758,8 +2891,8 @@ function create$29(context) {
 				});
 				continue;
 			}
-			const parentComponent = ast.findParentNode(component, isFunctionComponent);
-			if (parentComponent != null && !core.isDirectValueOfRenderPropertyLoose(parentComponent)) {
+			const enclosingComponent = findEnclosingComponent(component);
+			if (enclosingComponent != null && !core.isDirectValueOfRenderPropertyLoose(enclosingComponent)) {
 				context.report({
 					messageId: "default",
 					node: component,
@@ -2780,7 +2913,7 @@ function create$29(context) {
 			});
 		}
 		for (const { name = "unknown", node: component } of cComponents) {
-			if (ast.findParentNode(component, (n) => isClassComponent(n) || isFunctionComponent(n)) == null) continue;
+			if (findEnclosingComponent(component) == null) continue;
 			context.report({
 				messageId: "default",
 				node: component,
@@ -2825,7 +2958,7 @@ function isInsideCreateElementProps(context, node) {
 
 //#endregion
 //#region src/rules/no-nested-lazy-component-declarations.ts
-const RULE_NAME$28 = "no-nested-lazy-component-declarations";
+const RULE_NAME$26 = "no-nested-lazy-component-declarations";
 var no_nested_lazy_component_declarations_default = createRule({
 	meta: {
 		type: "problem",
@@ -2833,11 +2966,11 @@ var no_nested_lazy_component_declarations_default = createRule({
 		messages: { default: "Do not declare lazy components inside other components. Instead, always declare them at the top level of your module." },
 		schema: []
 	},
-	name: RULE_NAME$28,
-	create: create$28,
+	name: RULE_NAME$26,
+	create: create$26,
 	defaultOptions: []
 });
-function create$28(context) {
+function create$26(context) {
 	const hint = core.ComponentDetectionHint.None;
 	const collector = core.useComponentCollector(context, { hint });
 	const collectorLegacy = core.useComponentCollectorLegacy(context);
@@ -2866,7 +2999,7 @@ function create$28(context) {
 
 //#endregion
 //#region src/rules/no-redundant-should-component-update.ts
-const RULE_NAME$27 = "no-redundant-should-component-update";
+const RULE_NAME$25 = "no-redundant-should-component-update";
 function isShouldComponentUpdate(node) {
 	return ast.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
 }
@@ -2877,11 +3010,11 @@ var no_redundant_should_component_update_default = createRule({
 		messages: { default: "'{{componentName}}' does not need 'shouldComponentUpdate' when extending 'React.PureComponent'." },
 		schema: []
 	},
-	name: RULE_NAME$27,
-	create: create$27,
+	name: RULE_NAME$25,
+	create: create$25,
 	defaultOptions: []
 });
-function create$27(context) {
+function create$25(context) {
 	if (!context.sourceCode.text.includes("shouldComponentUpdate")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -2899,7 +3032,7 @@ function create$27(context) {
 
 //#endregion
 //#region src/rules/no-set-state-in-component-did-mount.ts
-const RULE_NAME$26 = "no-set-state-in-component-did-mount";
+const RULE_NAME$24 = "no-set-state-in-component-did-mount";
 var no_set_state_in_component_did_mount_default = createRule({
 	meta: {
 		type: "problem",
@@ -2907,11 +3040,11 @@ var no_set_state_in_component_did_mount_default = createRule({
 		messages: { default: "Do not call `this.setState` in `componentDidMount` outside functions such as callbacks." },
 		schema: []
 	},
-	name: RULE_NAME$26,
-	create: create$26,
+	name: RULE_NAME$24,
+	create: create$24,
 	defaultOptions: []
 });
-function create$26(context) {
+function create$24(context) {
 	if (!context.sourceCode.text.includes("componentDidMount")) return {};
 	return defineRuleListener({ CallExpression(node) {
 		if (!core.isThisSetState(node)) return;
@@ -2929,7 +3062,7 @@ function create$26(context) {
 
 //#endregion
 //#region src/rules/no-set-state-in-component-did-update.ts
-const RULE_NAME$25 = "no-set-state-in-component-did-update";
+const RULE_NAME$23 = "no-set-state-in-component-did-update";
 var no_set_state_in_component_did_update_default = createRule({
 	meta: {
 		type: "problem",
@@ -2937,11 +3070,11 @@ var no_set_state_in_component_did_update_default = createRule({
 		messages: { default: "Do not call `this.setState` in `componentDidUpdate` outside functions such as callbacks." },
 		schema: []
 	},
-	name: RULE_NAME$25,
-	create: create$25,
+	name: RULE_NAME$23,
+	create: create$23,
 	defaultOptions: []
 });
-function create$25(context) {
+function create$23(context) {
 	if (!context.sourceCode.text.includes("componentDidUpdate")) return {};
 	return defineRuleListener({ CallExpression(node) {
 		if (!core.isThisSetState(node)) return;
@@ -2959,7 +3092,7 @@ function create$25(context) {
 
 //#endregion
 //#region src/rules/no-set-state-in-component-will-update.ts
-const RULE_NAME$24 = "no-set-state-in-component-will-update";
+const RULE_NAME$22 = "no-set-state-in-component-will-update";
 var no_set_state_in_component_will_update_default = createRule({
 	meta: {
 		type: "problem",
@@ -2967,11 +3100,11 @@ var no_set_state_in_component_will_update_default = createRule({
 		messages: { default: "Do not call `this.setState` in `componentWillUpdate` outside functions such as callbacks." },
 		schema: []
 	},
-	name: RULE_NAME$24,
-	create: create$24,
+	name: RULE_NAME$22,
+	create: create$22,
 	defaultOptions: []
 });
-function create$24(context) {
+function create$22(context) {
 	if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
 	return defineRuleListener({ CallExpression(node) {
 		if (!core.isThisSetState(node)) return;
@@ -2989,7 +3122,7 @@ function create$24(context) {
 
 //#endregion
 //#region src/rules/no-unnecessary-use-callback.ts
-const RULE_NAME$23 = "no-unnecessary-use-callback";
+const RULE_NAME$21 = "no-unnecessary-use-callback";
 var no_unnecessary_use_callback_default = createRule({
 	meta: {
 		type: "problem",
@@ -3000,11 +3133,11 @@ var no_unnecessary_use_callback_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$23,
-	create: create$23,
+	name: RULE_NAME$21,
+	create: create$21,
 	defaultOptions: []
 });
-function create$23(context) {
+function create$21(context) {
 	if (!context.sourceCode.text.includes("useCallback")) return {};
 	return defineRuleListener({ VariableDeclarator(node) {
 		const { id, init } = node;
@@ -3018,9 +3151,9 @@ function create$23(context) {
 		const [arg0, arg1] = init.arguments;
 		if (arg0 == null || arg1 == null) return;
 		if (!match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-			const variableNode = getVariableInitializer(findVariable(n.name, scope), 0);
-			if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) return false;
-			return variableNode.elements.length === 0;
+			const initNode = getVariableInitializer(findVariable(n.name, scope), 0);
+			if (initNode?.type !== AST_NODE_TYPES.ArrayExpression) return false;
+			return initNode.elements.length === 0;
 		}).otherwise(() => false)) {
 			report(context)(checkForUsageInsideUseEffectReport);
 			return;
@@ -3029,9 +3162,9 @@ function create$23(context) {
 			if (n.body.type === AST_NODE_TYPES.ArrowFunctionExpression) return n.body;
 			return n;
 		}).with({ type: AST_NODE_TYPES.FunctionExpression }, identity).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-			const variableNode = getVariableInitializer(findVariable(n.name, scope), 0);
-			if (variableNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && variableNode?.type !== AST_NODE_TYPES.FunctionExpression) return null;
-			return variableNode;
+			const initNode = getVariableInitializer(findVariable(n.name, scope), 0);
+			if (initNode?.type !== AST_NODE_TYPES.ArrowFunctionExpression && initNode?.type !== AST_NODE_TYPES.FunctionExpression) return null;
+			return initNode;
 		}).otherwise(() => null);
 		if (arg0Node == null) return;
 		if (!getChildScopes(context.sourceCode.getScope(arg0Node)).flatMap((x) => x.references).some((x) => x.resolved?.scope.block === component)) {
@@ -3066,7 +3199,7 @@ function checkForUsageInsideUseEffect$1(sourceCode, node) {
 
 //#endregion
 //#region src/rules/no-unnecessary-use-memo.ts
-const RULE_NAME$22 = "no-unnecessary-use-memo";
+const RULE_NAME$20 = "no-unnecessary-use-memo";
 var no_unnecessary_use_memo_default = createRule({
 	meta: {
 		type: "problem",
@@ -3077,11 +3210,11 @@ var no_unnecessary_use_memo_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$22,
-	create: create$22,
+	name: RULE_NAME$20,
+	create: create$20,
 	defaultOptions: []
 });
-function create$22(context) {
+function create$20(context) {
 	if (!context.sourceCode.text.includes("useMemo")) return {};
 	return defineRuleListener({ VariableDeclarator(node) {
 		const { id, init } = node;
@@ -3099,9 +3232,9 @@ function create$22(context) {
 			return;
 		}
 		if (!match(arg1).with({ type: AST_NODE_TYPES.ArrayExpression }, (n) => n.elements.length === 0).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-			const variableNode = getVariableInitializer(findVariable(n.name, scope), 0);
-			if (variableNode?.type !== AST_NODE_TYPES.ArrayExpression) return false;
-			return variableNode.elements.length === 0;
+			const initNode = getVariableInitializer(findVariable(n.name, scope), 0);
+			if (initNode?.type !== AST_NODE_TYPES.ArrayExpression) return false;
+			return initNode.elements.length === 0;
 		}).otherwise(() => false)) {
 			report(context)(checkForUsageInsideUseEffectReport);
 			return;
@@ -3147,7 +3280,7 @@ function checkForUsageInsideUseEffect(sourceCode, node) {
 
 //#endregion
 //#region src/rules/no-unnecessary-use-prefix.ts
-const RULE_NAME$21 = "no-unnecessary-use-prefix";
+const RULE_NAME$19 = "no-unnecessary-use-prefix";
 const WELL_KNOWN_HOOKS = ["useMDXComponents"];
 function containsUseComments(context, node) {
 	return context.sourceCode.getCommentsInside(node).some(({ value }) => /use\([\s\S]*?\)/u.test(value) || /use[A-Z0-9]\w*\([\s\S]*?\)/u.test(value));
@@ -3159,11 +3292,11 @@ var no_unnecessary_use_prefix_default = createRule({
 		messages: { default: "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_NAME$21,
-	create: create$21,
+	name: RULE_NAME$19,
+	create: create$19,
 	defaultOptions: []
 });
-function create$21(context) {
+function create$19(context) {
 	const { ctx, visitor } = core.useHookCollector(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
 		for (const { id, name, node, hookCalls } of ctx.getAllHooks(program)) {
@@ -3183,7 +3316,7 @@ function create$21(context) {
 
 //#endregion
 //#region src/rules/no-unsafe-component-will-mount.ts
-const RULE_NAME$20 = "no-unsafe-component-will-mount";
+const RULE_NAME$18 = "no-unsafe-component-will-mount";
 var no_unsafe_component_will_mount_default = createRule({
 	meta: {
 		type: "problem",
@@ -3191,11 +3324,11 @@ var no_unsafe_component_will_mount_default = createRule({
 		messages: { default: "Do not use 'UNSAFE_componentWillMount'." },
 		schema: []
 	},
-	name: RULE_NAME$20,
-	create: create$20,
+	name: RULE_NAME$18,
+	create: create$18,
 	defaultOptions: []
 });
-function create$20(context) {
+function create$18(context) {
 	if (!context.sourceCode.text.includes("UNSAFE_componentWillMount")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -3211,7 +3344,7 @@ function create$20(context) {
 
 //#endregion
 //#region src/rules/no-unsafe-component-will-receive-props.ts
-const RULE_NAME$19 = "no-unsafe-component-will-receive-props";
+const RULE_NAME$17 = "no-unsafe-component-will-receive-props";
 var no_unsafe_component_will_receive_props_default = createRule({
 	meta: {
 		type: "problem",
@@ -3219,11 +3352,11 @@ var no_unsafe_component_will_receive_props_default = createRule({
 		messages: { default: "Do not use 'UNSAFE_componentWillReceiveProps'." },
 		schema: []
 	},
-	name: RULE_NAME$19,
-	create: create$19,
+	name: RULE_NAME$17,
+	create: create$17,
 	defaultOptions: []
 });
-function create$19(context) {
+function create$17(context) {
 	if (!context.sourceCode.text.includes("UNSAFE_componentWillReceiveProps")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -3239,7 +3372,7 @@ function create$19(context) {
 
 //#endregion
 //#region src/rules/no-unsafe-component-will-update.ts
-const RULE_NAME$18 = "no-unsafe-component-will-update";
+const RULE_NAME$16 = "no-unsafe-component-will-update";
 var no_unsafe_component_will_update_default = createRule({
 	meta: {
 		type: "problem",
@@ -3247,11 +3380,11 @@ var no_unsafe_component_will_update_default = createRule({
 		messages: { default: "Do not use 'UNSAFE_componentWillUpdate'." },
 		schema: []
 	},
-	name: RULE_NAME$18,
-	create: create$18,
+	name: RULE_NAME$16,
+	create: create$16,
 	defaultOptions: []
 });
-function create$18(context) {
+function create$16(context) {
 	if (!context.sourceCode.text.includes("UNSAFE_componentWillUpdate")) return {};
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
@@ -3267,7 +3400,7 @@ function create$18(context) {
 
 //#endregion
 //#region src/rules/no-unstable-context-value.ts
-const RULE_NAME$17 = "no-unstable-context-value";
+const RULE_NAME$15 = "no-unstable-context-value";
 var no_unstable_context_value_default = createRule({
 	meta: {
 		type: "problem",
@@ -3275,11 +3408,11 @@ var no_unstable_context_value_default = createRule({
 		messages: { unstableContextValue: "A/an '{{kind}}' passed as the value prop to the context provider should not be constructed. It will change on every render. {{suggestion}}" },
 		schema: []
 	},
-	name: RULE_NAME$17,
-	create: create$17,
+	name: RULE_NAME$15,
+	create: create$15,
 	defaultOptions: []
 });
-function create$17(context) {
+function create$15(context) {
 	const { compilationMode, version } = getSettingsFromContext(context);
 	if (compilationMode === "infer" || compilationMode === "all") return {};
 	if (compilationMode === "annotation" && ast.isDirectiveInFile(context.sourceCode.ast, "use memo")) return {};
@@ -3331,7 +3464,7 @@ function isContextName(name, isReact18OrBelow) {
 
 //#endregion
 //#region src/rules/no-unstable-default-props.ts
-const RULE_NAME$16 = "no-unstable-default-props";
+const RULE_NAME$14 = "no-unstable-default-props";
 const defaultOptions$2 = [{ safeDefaultProps: [] }];
 const schema$2 = [{
 	type: "object",
@@ -3348,8 +3481,8 @@ var no_unstable_default_props_default = createRule({
 		messages: { default: "A/an '{{kind}}' as default prop. This could lead to potential infinite render loop in React. Use a variable instead of '{{kind}}'." },
 		schema: schema$2
 	},
-	name: RULE_NAME$16,
-	create: create$16,
+	name: RULE_NAME$14,
+	create: create$14,
 	defaultOptions: defaultOptions$2
 });
 function extractIdentifier(node) {
@@ -3360,7 +3493,7 @@ function extractIdentifier(node) {
 	}
 	return null;
 }
-function create$16(context, [options]) {
+function create$14(context, [options]) {
 	const { compilationMode } = getSettingsFromContext(context);
 	if (compilationMode === "infer" || compilationMode === "all") return {};
 	if (compilationMode === "annotation" && ast.isDirectiveInFile(context.sourceCode.ast, "use memo")) return {};
@@ -3406,7 +3539,7 @@ function create$16(context, [options]) {
 
 //#endregion
 //#region src/rules/no-unused-class-component-members.ts
-const RULE_NAME$15 = "no-unused-class-component-members";
+const RULE_NAME$13 = "no-unused-class-component-members";
 const LIFECYCLE_METHODS = new Set([
 	"componentDidCatch",
 	"componentDidMount",
@@ -3437,11 +3570,11 @@ var no_unused_class_component_members_default = createRule({
 		messages: { default: "Unused method or property '{{methodName}}'' of class '{{className}}'." },
 		schema: []
 	},
-	name: RULE_NAME$15,
-	create: create$15,
+	name: RULE_NAME$13,
+	create: create$13,
 	defaultOptions: []
 });
-function create$15(context) {
+function create$13(context) {
 	const classStack = [];
 	const methodStack = [];
 	const propertyDefs = /* @__PURE__ */ new WeakMap();
@@ -3522,7 +3655,7 @@ function create$15(context) {
 
 //#endregion
 //#region src/rules/no-unused-props.ts
-const RULE_NAME$14 = "no-unused-props";
+const RULE_NAME$12 = "no-unused-props";
 var no_unused_props_default = createRule({
 	meta: {
 		type: "problem",
@@ -3530,11 +3663,11 @@ var no_unused_props_default = createRule({
 		messages: { default: "Prop `{{name}}` is declared but never used" },
 		schema: []
 	},
-	name: RULE_NAME$14,
-	create: create$14,
+	name: RULE_NAME$12,
+	create: create$12,
 	defaultOptions: []
 });
-function create$14(context) {
+function create$12(context) {
 	const services = ESLintUtils.getParserServices(context, false);
 	const checker = services.program.getTypeChecker();
 	const { ctx, visitor } = core.useComponentCollector(context);
@@ -3634,7 +3767,7 @@ function reportUnusedProp(context, services, prop) {
 
 //#endregion
 //#region src/rules/no-unused-state.ts
-const RULE_NAME$13 = "no-unused-state";
+const RULE_NAME$11 = "no-unused-state";
 function isKeyLiteral(node, key) {
 	return match(key).with({ type: AST_NODE_TYPES.Literal }, constTrue).with({
 		type: AST_NODE_TYPES.TemplateLiteral,
@@ -3648,11 +3781,11 @@ var no_unused_state_default = createRule({
 		messages: { default: "Unused class component state in '{{className}}'" },
 		schema: []
 	},
-	name: RULE_NAME$13,
-	create: create$13,
+	name: RULE_NAME$11,
+	create: create$11,
 	defaultOptions: []
 });
-function create$13(context) {
+function create$11(context) {
 	const classStack = [];
 	const methodStack = [];
 	const constructorStack = [];
@@ -3761,7 +3894,7 @@ function create$13(context) {
 
 //#endregion
 //#region src/rules/no-use-context.ts
-const RULE_NAME$12 = "no-use-context";
+const RULE_NAME$10 = "no-use-context";
 var no_use_context_default = createRule({
 	meta: {
 		type: "problem",
@@ -3770,11 +3903,11 @@ var no_use_context_default = createRule({
 		messages: { default: "In React 19, 'use' is preferred over 'useContext' because it is more flexible." },
 		schema: []
 	},
-	name: RULE_NAME$12,
-	create: create$12,
+	name: RULE_NAME$10,
+	create: create$10,
 	defaultOptions: []
 });
-function create$12(context) {
+function create$10(context) {
 	if (!context.sourceCode.text.includes("useContext")) return {};
 	const settings = getSettingsFromContext(context);
 	if (compare(settings.version, "19.0.0", "<")) return {};
@@ -3837,36 +3970,9 @@ function getCorrelativeTokens(context, node) {
 	return tokens;
 }
 
-//#endregion
-//#region src/rules/no-useless-forward-ref.ts
-const RULE_NAME$11 = "no-useless-forward-ref";
-var no_useless_forward_ref_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Disallows useless 'forwardRef' calls on components that don't use 'ref's." },
-		messages: { default: "A 'forwardRef' is used with this component but no 'ref' parameter is set." },
-		schema: []
-	},
-	name: RULE_NAME$11,
-	create: create$11,
-	defaultOptions: []
-});
-function create$11(context) {
-	return defineRuleListener({ CallExpression(node) {
-		if (!core.isForwardRefCall(context, node)) return;
-		const [component] = node.arguments;
-		if (component == null || !ast.isFunction(component)) return;
-		if (component.params[1] != null) return;
-		context.report({
-			messageId: "default",
-			node: node.callee
-		});
-	} });
-}
-
 //#endregion
 //#region src/rules/no-useless-fragment.ts
-const RULE_NAME$10 = "no-useless-fragment";
+const RULE_NAME$9 = "no-useless-fragment";
 const defaultOptions$1 = [{
 	allowEmptyFragment: false,
 	allowExpressions: true
@@ -3894,11 +4000,11 @@ var no_useless_fragment_default = createRule({
 		messages: { default: "A fragment {{reason}} is useless." },
 		schema: schema$1
 	},
-	name: RULE_NAME$10,
-	create: create$10,
+	name: RULE_NAME$9,
+	create: create$9,
 	defaultOptions: defaultOptions$1
 });
-function create$10(context, [option]) {
+function create$9(context, [option]) {
 	const { allowEmptyFragment = false, allowExpressions = true } = option;
 	const jsxConfig = {
 		...core.getJsxConfigFromContext(context),
@@ -4006,7 +4112,7 @@ function trimLikeReact(text) {
 
 //#endregion
 //#region src/rules/prefer-destructuring-assignment.ts
-const RULE_NAME$9 = "prefer-destructuring-assignment";
+const RULE_NAME$8 = "prefer-destructuring-assignment";
 var prefer_destructuring_assignment_default = createRule({
 	meta: {
 		type: "problem",
@@ -4014,11 +4120,11 @@ var prefer_destructuring_assignment_default = createRule({
 		messages: { default: "Use destructuring assignment for component props." },
 		schema: []
 	},
-	name: RULE_NAME$9,
-	create: create$9,
+	name: RULE_NAME$8,
+	create: create$8,
 	defaultOptions: []
 });
-function create$9(context) {
+function create$8(context) {
 	const { ctx, visitor } = core.useComponentCollector(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
 		for (const component of ctx.getAllComponents(program)) {
@@ -4042,7 +4148,7 @@ function create$9(context) {
 
 //#endregion
 //#region src/rules/prefer-namespace-import.ts
-const RULE_NAME$8 = "prefer-namespace-import";
+const RULE_NAME$7 = "prefer-namespace-import";
 var prefer_namespace_import_default = createRule({
 	meta: {
 		type: "problem",
@@ -4051,11 +4157,11 @@ var prefer_namespace_import_default = createRule({
 		messages: { default: "Prefer importing React as 'import * as React from \"{{importSource}}\"';" },
 		schema: []
 	},
-	name: RULE_NAME$8,
-	create: create$8,
+	name: RULE_NAME$7,
+	create: create$7,
 	defaultOptions: []
 });
-function create$8(context) {
+function create$7(context) {
 	const { importSource } = getSettingsFromContext(context);
 	return defineRuleListener({ [`ImportDeclaration[source.value="${importSource}"] ImportDefaultSpecifier`](node) {
 		const hasOtherSpecifiers = node.parent.specifiers.length > 1;
@@ -4077,59 +4183,6 @@ function create$8(context) {
 	} });
 }
 
-//#endregion
-//#region src/rules/prefer-read-only-props.ts
-const RULE_NAME$7 = "prefer-read-only-props";
-var prefer_read_only_props_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Enforces read-only props in components." },
-		messages: { default: "A function component's props should be read-only." },
-		schema: []
-	},
-	name: RULE_NAME$7,
-	create: create$7,
-	defaultOptions: []
-});
-function create$7(context) {
-	const services = ESLintUtils.getParserServices(context, false);
-	const checker = services.program.getTypeChecker();
-	const { ctx, visitor } = core.useComponentCollector(context);
-	return defineRuleListener(visitor, { "Program:exit"(program) {
-		for (const component of ctx.getAllComponents(program)) {
-			const [props] = component.node.params;
-			if (component.id == null || component.name == null) continue;
-			if (props == null) continue;
-			const propsType = getConstrainedTypeAtLocation(services, props);
-			if (isTypeReadonly(services.program, propsType)) continue;
-			if (isTypeReadonlyLoose(services, propsType)) continue;
-			if (propsType.isClassOrInterface() && isClassOrInterfaceReadonlyLoose(checker, propsType)) continue;
-			context.report({
-				messageId: "default",
-				node: props
-			});
-		}
-	} });
-}
-function isTypeReadonlyLoose(services, type) {
-	try {
-		const im = getTypeImmutability(services.program, type);
-		return isUnknown(im) || isImmutable(im) || isReadonlyShallow(im) || isReadonlyDeep(im);
-	} catch {
-		return true;
-	}
-}
-function isClassOrInterfaceReadonlyLoose(checker, type) {
-	const props = type.getProperties();
-	const types = type.getBaseTypes() ?? [];
-	if (props.length === 0) return true;
-	if (types.length === 0) return props.every((p) => isPropertyReadonlyInType(type, p.getEscapedName(), checker));
-	return props.every((p) => {
-		if (isPropertyReadonlyInType(type, p.getEscapedName(), checker)) return true;
-		return types.every((t) => isPropertyReadonlyInType(t, p.getEscapedName(), checker));
-	});
-}
-
 //#endregion
 //#region src/rules/purity.ts
 const RULE_NAME$6 = "purity";
@@ -6853,11 +6906,11 @@ function create$4(context) {
 		}
 	}
 	function isIdFromUseStateCall(topLevelId, at) {
-		const variableNode = getVariableInitializer(findVariable(topLevelId, context.sourceCode.getScope(topLevelId)), 0);
-		if (variableNode == null) return false;
-		if (variableNode.type !== AST_NODE_TYPES.CallExpression) return false;
-		if (!isUseStateCall(variableNode)) return false;
-		const variableNodeParent = variableNode.parent;
+		const initNode = getVariableInitializer(findVariable(topLevelId, context.sourceCode.getScope(topLevelId)), 0);
+		if (initNode == null) return false;
+		if (initNode.type !== AST_NODE_TYPES.CallExpression) return false;
+		if (!isUseStateCall(initNode)) return false;
+		const variableNodeParent = initNode.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;
 	}
@@ -7035,13 +7088,13 @@ function create$3(context) {
 		return core.isUseStateLikeCall(node, additionalStateHooks);
 	}
 	function isIdFromUseStateCall(topLevelId, at) {
-		const variableNode = getVariableInitializer(findVariable(topLevelId, context.sourceCode.getScope(topLevelId)), 0);
-		if (variableNode == null) return false;
-		if (variableNode.type !== AST_NODE_TYPES.CallExpression) return false;
-		if (!isUseStateCall(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;
+		const initNode = getVariableInitializer(findVariable(topLevelId, context.sourceCode.getScope(topLevelId)), 0);
+		if (initNode == null) return false;
+		if (initNode.type !== AST_NODE_TYPES.CallExpression) return false;
+		if (!isUseStateCall(initNode)) return false;
+		const initNodeParent = initNode.parent;
+		if (!("id" in initNodeParent) || initNodeParent.id?.type !== AST_NODE_TYPES.ArrayPattern) return true;
+		return initNodeParent.id.elements.findIndex((e) => e?.type === AST_NODE_TYPES.Identifier && e.name === topLevelId.name) === at;
 	}
 	function isSetStateCall(node) {
 		switch (node.callee.type) {
@@ -7413,11 +7466,11 @@ const plugin = {
 		"component-hook-factories": component_hook_factories_default,
 		"error-boundaries": error_boundaries_default,
 		"exhaustive-deps": rule$1,
+		immutability: immutability_default,
 		"jsx-dollar": jsx_dollar_default,
 		"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-undef": jsx_no_undef_default,
 		"jsx-shorthand-boolean": jsx_shorthand_boolean_default,
 		"jsx-shorthand-fragment": jsx_shorthand_fragment_default,
 		"jsx-uses-react": jsx_uses_react_default,
@@ -7464,16 +7517,15 @@ const plugin = {
 		"no-unused-props": no_unused_props_default,
 		"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,
 		purity: purity_default,
 		refs: refs_default,
 		"rules-of-hooks": rule,
 		"set-state-in-effect": set_state_in_effect_default,
 		"set-state-in-render": set_state_in_render_default,
+		"static-components": no_nested_component_definitions_default,
 		"unsupported-syntax": unsupported_syntax_default,
 		"use-memo": use_memo_default,
 		"use-state": use_state_default
@@ -7524,8 +7576,8 @@ const rules$6 = {
 	"react-x/no-unsafe-component-will-mount": "warn",
 	"react-x/no-unsafe-component-will-receive-props": "warn",
 	"react-x/no-unsafe-component-will-update": "warn",
+	"react-x/no-unused-class-component-members": "warn",
 	"react-x/no-use-context": "warn",
-	"react-x/no-useless-forward-ref": "warn",
 	"react-x/purity": "warn",
 	"react-x/rules-of-hooks": "error",
 	"react-x/set-state-in-effect": "warn",
@@ -7544,7 +7596,6 @@ const settings$5 = { "react-x": DEFAULT_ESLINT_REACT_SETTINGS };
 */
 const rules$5 = {
 	"react-x/jsx-no-duplicate-props": "off",
-	"react-x/jsx-no-undef": "off",
 	"react-x/jsx-uses-react": "off",
 	"react-x/jsx-uses-vars": "off"
 };
@@ -7600,7 +7651,6 @@ const rules$2 = {
 	"react-x/no-unnecessary-use-memo": "warn",
 	"react-x/no-unstable-context-value": "warn",
 	"react-x/no-unstable-default-props": "warn",
-	"react-x/no-unused-class-component-members": "warn",
 	"react-x/no-unused-state": "warn",
 	"react-x/no-useless-fragment": "warn",
 	"react-x/prefer-destructuring-assignment": "warn"