eslint-plugin-react-x 2.0.0-beta.172 → 2.0.0-beta.173

package/dist/index.js

@@ -45,7 +45,6 @@ const rules$2 = {
 	"react-x/no-children-only": "warn",
 	"react-x/no-children-to-array": "warn",
 	"react-x/no-clone-element": "warn",
-	"react-x/no-comment-textnodes": "warn",
 	"react-x/no-component-will-mount": "error",
 	"react-x/no-component-will-receive-props": "error",
 	"react-x/no-component-will-update": "error",
@@ -116,7 +115,7 @@ const settings = { ...settings$1 };
 //#endregion
 //#region package.json
 var name = "eslint-plugin-react-x";
-var version = "2.0.0-beta.172";
+var version = "2.0.0-beta.173";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -124,23 +123,23 @@ const createRule = ESLintUtils.RuleCreator(getDocsUrl("x"));
 
 //#endregion
 //#region src/rules/jsx-key-before-spread.ts
-const RULE_NAME$68 = "jsx-key-before-spread";
-const RULE_FEATURES$66 = ["EXP"];
+const RULE_NAME$61 = "jsx-key-before-spread";
+const RULE_FEATURES$59 = ["EXP"];
 var jsx_key_before_spread_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Enforces that the 'key' attribute is placed before the spread attribute in JSX elements.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$66
+			[Symbol.for("rule_features")]: RULE_FEATURES$59
 		},
 		messages: { jsxKeyBeforeSpread: "The 'key' attribute must be placed before the spread attribute." },
 		schema: []
 	},
-	name: RULE_NAME$68,
-	create: create$68,
+	name: RULE_NAME$61,
+	create: create$61,
 	defaultOptions: []
 });
-function create$68(context) {
+function create$61(context) {
 	return { JSXOpeningElement(node) {
 		let firstSpreadAttributeIndex = null;
 		for (const [index, attr] of node.attributes.entries()) {
@@ -159,23 +158,23 @@ function create$68(context) {
 
 //#endregion
 //#region src/rules/jsx-no-comment-textnodes.ts
-const RULE_NAME$67 = "jsx-no-comment-textnodes";
-const RULE_FEATURES$65 = [];
+const RULE_NAME$60 = "jsx-no-comment-textnodes";
+const RULE_FEATURES$58 = [];
 var jsx_no_comment_textnodes_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Prevents comments from being inserted as text nodes.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$65
+			[Symbol.for("rule_features")]: RULE_FEATURES$58
 		},
 		messages: { jsxNoCommentTextnodes: "Possible misused comment in text node. Comments inside children section of tag should be placed inside braces." },
 		schema: []
 	},
-	name: RULE_NAME$67,
-	create: create$67,
+	name: RULE_NAME$60,
+	create: create$60,
 	defaultOptions: []
 });
-function create$67(context) {
+function create$60(context) {
 	function hasCommentLike(node) {
 		if (AST.isOneOf([AST_NODE_TYPES.JSXAttribute, AST_NODE_TYPES.JSXExpressionContainer])(node.parent)) return false;
 		const rawValue = context.sourceCode.getText(node);
@@ -198,23 +197,23 @@ function create$67(context) {
 
 //#endregion
 //#region src/rules/jsx-no-duplicate-props.ts
-const RULE_NAME$66 = "jsx-no-duplicate-props";
-const RULE_FEATURES$64 = [];
+const RULE_NAME$59 = "jsx-no-duplicate-props";
+const RULE_FEATURES$57 = [];
 var jsx_no_duplicate_props_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow duplicate props in JSX elements.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$64
+			[Symbol.for("rule_features")]: RULE_FEATURES$57
 		},
 		messages: { jsxNoDuplicateProps: "This JSX property is assigned multiple times." },
 		schema: []
 	},
-	name: RULE_NAME$66,
-	create: create$66,
+	name: RULE_NAME$59,
+	create: create$59,
 	defaultOptions: []
 });
-function create$66(context) {
+function create$59(context) {
 	return { JSXOpeningElement(node) {
 		const props = [];
 		for (const attr of node.attributes) {
@@ -235,23 +234,23 @@ function create$66(context) {
 
 //#endregion
 //#region src/rules/jsx-no-iife.ts
-const RULE_NAME$65 = "jsx-no-iife";
-const RULE_FEATURES$63 = ["EXP"];
+const RULE_NAME$58 = "jsx-no-iife";
+const RULE_FEATURES$56 = ["EXP"];
 var jsx_no_iife_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallows 'IIFE' in JSX elements.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$63
+			[Symbol.for("rule_features")]: RULE_FEATURES$56
 		},
 		messages: { jsxNoIife: "Avoid using IIFE in JSX elements." },
 		schema: []
 	},
-	name: RULE_NAME$65,
-	create: create$65,
+	name: RULE_NAME$58,
+	create: create$58,
 	defaultOptions: []
 });
-function create$65(context) {
+function create$58(context) {
 	return {
 		"JSXElement :function"(node) {
 			if (node.parent.type === AST_NODE_TYPES.CallExpression && node.parent.callee === node) context.report({
@@ -270,23 +269,23 @@ function create$65(context) {
 
 //#endregion
 //#region src/rules/jsx-no-undef.ts
-const RULE_NAME$64 = "jsx-no-undef";
-const RULE_FEATURES$62 = [];
+const RULE_NAME$57 = "jsx-no-undef";
+const RULE_FEATURES$55 = [];
 var jsx_no_undef_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow undefined variables in JSX.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$62
+			[Symbol.for("rule_features")]: RULE_FEATURES$55
 		},
 		messages: { jsxNoUndef: "JSX variable '{{name}}' is not defined." },
 		schema: []
 	},
-	name: RULE_NAME$64,
-	create: create$64,
+	name: RULE_NAME$57,
+	create: create$57,
 	defaultOptions: []
 });
-function create$64(context) {
+function create$57(context) {
 	return { JSXOpeningElement(node) {
 		const name$4 = match(node.name).with({ type: AST_NODE_TYPES.JSXIdentifier }, (n) => n.name).with({
 			type: AST_NODE_TYPES.JSXMemberExpression,
@@ -305,8 +304,8 @@ function create$64(context) {
 
 //#endregion
 //#region src/rules/jsx-shorthand-boolean.ts
-const RULE_NAME$63 = "jsx-shorthand-boolean";
-const RULE_FEATURES$61 = ["CFG", "FIX"];
+const RULE_NAME$56 = "jsx-shorthand-boolean";
+const RULE_FEATURES$54 = ["CFG", "FIX"];
 const defaultOptions$3 = [1];
 const schema$1 = [{
 	type: "integer",
@@ -317,17 +316,17 @@ var jsx_shorthand_boolean_default = createRule({
 		type: "problem",
 		docs: {
 			description: "Enforces shorthand syntax for boolean attributes.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$61
+			[Symbol.for("rule_features")]: RULE_FEATURES$54
 		},
 		fixable: "code",
 		messages: { jsxShorthandBoolean: "{{message}}" },
 		schema: schema$1
 	},
-	name: RULE_NAME$63,
-	create: create$63,
+	name: RULE_NAME$56,
+	create: create$56,
 	defaultOptions: defaultOptions$3
 });
-function create$63(context) {
+function create$56(context) {
 	const policy = context.options[0] ?? defaultOptions$3[0];
 	return { JSXAttribute(node) {
 		const { value } = node;
@@ -355,8 +354,8 @@ function create$63(context) {
 
 //#endregion
 //#region src/rules/jsx-shorthand-fragment.ts
-const RULE_NAME$62 = "jsx-shorthand-fragment";
-const RULE_FEATURES$60 = ["CFG", "FIX"];
+const RULE_NAME$55 = "jsx-shorthand-fragment";
+const RULE_FEATURES$53 = ["CFG", "FIX"];
 const defaultOptions$2 = [1];
 const schema = [{
 	type: "integer",
@@ -367,17 +366,17 @@ var jsx_shorthand_fragment_default = createRule({
 		type: "problem",
 		docs: {
 			description: "Enforces shorthand syntax for fragments.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$60
+			[Symbol.for("rule_features")]: RULE_FEATURES$53
 		},
 		fixable: "code",
 		messages: { jsxShorthandFragment: "{{message}}" },
 		schema
 	},
-	name: RULE_NAME$62,
-	create: create$62,
+	name: RULE_NAME$55,
+	create: create$55,
 	defaultOptions: defaultOptions$2
 });
-function create$62(context) {
+function create$55(context) {
 	const policy = context.options[0] ?? defaultOptions$2[0];
 	const jsxConfig = {
 		...JsxConfig.getFromContext(context),
@@ -414,23 +413,23 @@ function create$62(context) {
 //#endregion
 //#region src/rules/jsx-uses-react.ts
 const { JsxEmit } = JsxConfig;
-const RULE_NAME$61 = "jsx-uses-react";
-const RULE_FEATURES$59 = [];
+const RULE_NAME$54 = "jsx-uses-react";
+const RULE_FEATURES$52 = [];
 var jsx_uses_react_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Marks React variables as used when JSX is used.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$59
+			[Symbol.for("rule_features")]: RULE_FEATURES$52
 		},
 		messages: { jsxUsesReact: "Marked {{name}} as used." },
 		schema: []
 	},
-	name: RULE_NAME$61,
-	create: create$61,
+	name: RULE_NAME$54,
+	create: create$54,
 	defaultOptions: []
 });
-function create$61(context) {
+function create$54(context) {
 	const jsxConfig = {
 		...JsxConfig.getFromContext(context),
 		...JsxConfig.getFromAnnotation(context)
@@ -462,23 +461,23 @@ function debugReport(context, node, name$4) {
 
 //#endregion
 //#region src/rules/jsx-uses-vars.ts
-const RULE_NAME$60 = "jsx-uses-vars";
-const RULE_FEATURES$58 = [];
+const RULE_NAME$53 = "jsx-uses-vars";
+const RULE_FEATURES$51 = [];
 var jsx_uses_vars_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Marks variables used in JSX elements as used.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$58
+			[Symbol.for("rule_features")]: RULE_FEATURES$51
 		},
 		messages: { jsxUsesVars: "An identifier in JSX is marked as used." },
 		schema: []
 	},
-	name: RULE_NAME$60,
-	create: create$60,
+	name: RULE_NAME$53,
+	create: create$53,
 	defaultOptions: []
 });
-function create$60(context) {
+function create$53(context) {
 	return { JSXOpeningElement(node) {
 		switch (node.name.type) {
 			case AST_NODE_TYPES.JSXIdentifier:
@@ -496,8 +495,8 @@ function create$60(context) {
 
 //#endregion
 //#region src/rules/no-access-state-in-setstate.ts
-const RULE_NAME$59 = "no-access-state-in-setstate";
-const RULE_FEATURES$57 = [];
+const RULE_NAME$52 = "no-access-state-in-setstate";
+const RULE_FEATURES$50 = [];
 function isKeyLiteral$2(node, key) {
 	return match(key).with({ type: AST_NODE_TYPES.Literal }, constTrue).with({
 		type: AST_NODE_TYPES.TemplateLiteral,
@@ -509,16 +508,16 @@ var no_access_state_in_setstate_default = createRule({
 		type: "problem",
 		docs: {
 			description: "Disallow accessing `this.state` inside `setState` calls.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$57
+			[Symbol.for("rule_features")]: RULE_FEATURES$50
 		},
 		messages: { noAccessStateInSetstate: "Do not access 'this.state' within 'setState'. Use the update function instead." },
 		schema: []
 	},
-	name: RULE_NAME$59,
-	create: create$59,
+	name: RULE_NAME$52,
+	create: create$52,
 	defaultOptions: []
 });
-function create$59(context) {
+function create$52(context) {
 	if (!context.sourceCode.text.includes("setState")) return {};
 	const classEntries = [];
 	const methodEntries = [];
@@ -590,8 +589,8 @@ function create$59(context) {
 
 //#endregion
 //#region src/rules/no-array-index-key.ts
-const RULE_NAME$58 = "no-array-index-key";
-const RULE_FEATURES$56 = [];
+const RULE_NAME$51 = "no-array-index-key";
+const RULE_FEATURES$49 = [];
 const REACT_CHILDREN_METHOD = ["forEach", "map"];
 function isReactChildrenMethod(name$4) {
 	return REACT_CHILDREN_METHOD.includes(name$4);
@@ -631,16 +630,16 @@ 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_FEATURES$56
+			[Symbol.for("rule_features")]: RULE_FEATURES$49
 		},
 		messages: { noArrayIndexKey: "Do not use item index in the array as its key." },
 		schema: []
 	},
-	name: RULE_NAME$58,
-	create: create$58,
+	name: RULE_NAME$51,
+	create: create$51,
 	defaultOptions: []
 });
-function create$58(context) {
+function create$51(context) {
 	const report = Reporter.make(context);
 	const indexParamNames = [];
 	function isArrayIndex(node) {
@@ -707,23 +706,23 @@ function create$58(context) {
 
 //#endregion
 //#region src/rules/no-children-count.ts
-const RULE_NAME$57 = "no-children-count";
-const RULE_FEATURES$55 = [];
+const RULE_NAME$50 = "no-children-count";
+const RULE_FEATURES$48 = [];
 var no_children_count_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow `Children.count`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$55
+			[Symbol.for("rule_features")]: RULE_FEATURES$48
 		},
 		messages: { noChildrenCount: "Using 'Children.count' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$57,
-	create: create$57,
+	name: RULE_NAME$50,
+	create: create$50,
 	defaultOptions: []
 });
-function create$57(context) {
+function create$50(context) {
 	return { MemberExpression(node) {
 		if (ER.isChildrenCount(context, node)) context.report({
 			messageId: "noChildrenCount",
@@ -734,23 +733,23 @@ function create$57(context) {
 
 //#endregion
 //#region src/rules/no-children-for-each.ts
-const RULE_NAME$56 = "no-children-for-each";
-const RULE_FEATURES$54 = [];
+const RULE_NAME$49 = "no-children-for-each";
+const RULE_FEATURES$47 = [];
 var no_children_for_each_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow 'Children.forEach'.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$54
+			[Symbol.for("rule_features")]: RULE_FEATURES$47
 		},
 		messages: { noChildrenForEach: "Using 'Children.forEach' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$56,
-	create: create$56,
+	name: RULE_NAME$49,
+	create: create$49,
 	defaultOptions: []
 });
-function create$56(context) {
+function create$49(context) {
 	return { MemberExpression(node) {
 		if (ER.isChildrenForEach(context, node)) context.report({
 			messageId: "noChildrenForEach",
@@ -761,23 +760,23 @@ function create$56(context) {
 
 //#endregion
 //#region src/rules/no-children-map.ts
-const RULE_NAME$55 = "no-children-map";
-const RULE_FEATURES$53 = [];
+const RULE_NAME$48 = "no-children-map";
+const RULE_FEATURES$46 = [];
 var no_children_map_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow `Children.map`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$53
+			[Symbol.for("rule_features")]: RULE_FEATURES$46
 		},
 		messages: { noChildrenMap: "Using 'Children.map' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$55,
-	create: create$55,
+	name: RULE_NAME$48,
+	create: create$48,
 	defaultOptions: []
 });
-function create$55(context) {
+function create$48(context) {
 	return { MemberExpression(node) {
 		if (ER.isChildrenMap(context, node)) context.report({
 			messageId: "noChildrenMap",
@@ -788,23 +787,23 @@ function create$55(context) {
 
 //#endregion
 //#region src/rules/no-children-only.ts
-const RULE_NAME$54 = "no-children-only";
-const RULE_FEATURES$52 = [];
+const RULE_NAME$47 = "no-children-only";
+const RULE_FEATURES$45 = [];
 var no_children_only_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow `Children.only`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$52
+			[Symbol.for("rule_features")]: RULE_FEATURES$45
 		},
 		messages: { noChildrenOnly: "Using 'Children.only' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$54,
-	create: create$54,
+	name: RULE_NAME$47,
+	create: create$47,
 	defaultOptions: []
 });
-function create$54(context) {
+function create$47(context) {
 	return { MemberExpression(node) {
 		if (ER.isChildrenOnly(context, node)) context.report({
 			messageId: "noChildrenOnly",
@@ -815,23 +814,23 @@ function create$54(context) {
 
 //#endregion
 //#region src/rules/no-children-prop.ts
-const RULE_NAME$53 = "no-children-prop";
-const RULE_FEATURES$51 = [];
+const RULE_NAME$46 = "no-children-prop";
+const RULE_FEATURES$44 = [];
 var no_children_prop_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow passing `children` as a prop.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$51
+			[Symbol.for("rule_features")]: RULE_FEATURES$44
 		},
 		messages: { noChildrenProp: "Do not pass 'children' as props." },
 		schema: []
 	},
-	name: RULE_NAME$53,
-	create: create$53,
+	name: RULE_NAME$46,
+	create: create$46,
 	defaultOptions: []
 });
-function create$53(context) {
+function create$46(context) {
 	return { JSXElement(node) {
 		const getAttribute = ER.getAttribute(context, node.openingElement.attributes, context.sourceCode.getScope(node));
 		const childrenProp = getAttribute("children");
@@ -844,23 +843,23 @@ function create$53(context) {
 
 //#endregion
 //#region src/rules/no-children-to-array.ts
-const RULE_NAME$52 = "no-children-to-array";
-const RULE_FEATURES$50 = [];
+const RULE_NAME$45 = "no-children-to-array";
+const RULE_FEATURES$43 = [];
 var no_children_to_array_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow `Children.toArray`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$50
+			[Symbol.for("rule_features")]: RULE_FEATURES$43
 		},
 		messages: { noChildrenToArray: "Using 'Children.toArray' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$52,
-	create: create$52,
+	name: RULE_NAME$45,
+	create: create$45,
 	defaultOptions: []
 });
-function create$52(context) {
+function create$45(context) {
 	return { MemberExpression(node) {
 		if (ER.isChildrenToArray(context, node)) context.report({
 			messageId: "noChildrenToArray",
@@ -871,23 +870,23 @@ function create$52(context) {
 
 //#endregion
 //#region src/rules/no-class-component.ts
-const RULE_NAME$51 = "no-class-component";
-const RULE_FEATURES$49 = [];
+const RULE_NAME$44 = "no-class-component";
+const RULE_FEATURES$42 = [];
 var no_class_component_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow class components except for error boundaries.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$49
+			[Symbol.for("rule_features")]: RULE_FEATURES$42
 		},
 		messages: { noClassComponent: "Avoid using class components. Use function components instead." },
 		schema: []
 	},
-	name: RULE_NAME$51,
-	create: create$51,
+	name: RULE_NAME$44,
+	create: create$44,
 	defaultOptions: []
 });
-function create$51(context) {
+function create$44(context) {
 	if (!context.sourceCode.text.includes("Component")) return {};
 	const { ctx, listeners } = ER.useComponentCollectorLegacy();
 	return {
@@ -908,23 +907,23 @@ function create$51(context) {
 
 //#endregion
 //#region src/rules/no-clone-element.ts
-const RULE_NAME$50 = "no-clone-element";
-const RULE_FEATURES$48 = [];
+const RULE_NAME$43 = "no-clone-element";
+const RULE_FEATURES$41 = [];
 var no_clone_element_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow `cloneElement`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$48
+			[Symbol.for("rule_features")]: RULE_FEATURES$41
 		},
 		messages: { noCloneElement: "Using 'cloneElement' is uncommon and can lead to fragile code. Use alternatives instead." },
 		schema: []
 	},
-	name: RULE_NAME$50,
-	create: create$50,
+	name: RULE_NAME$43,
+	create: create$43,
 	defaultOptions: []
 });
-function create$50(context) {
+function create$43(context) {
 	return { CallExpression(node) {
 		if (ER.isCloneElementCall(context, node)) context.report({
 			messageId: "noCloneElement",
@@ -935,24 +934,24 @@ function create$50(context) {
 
 //#endregion
 //#region src/rules/no-component-will-mount.ts
-const RULE_NAME$49 = "no-component-will-mount";
-const RULE_FEATURES$47 = ["MOD"];
+const RULE_NAME$42 = "no-component-will-mount";
+const RULE_FEATURES$40 = ["MOD"];
 var no_component_will_mount_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Replace usages of `componentWillMount` with `UNSAFE_componentWillMount`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$47
+			[Symbol.for("rule_features")]: RULE_FEATURES$40
 		},
 		fixable: "code",
 		messages: { noComponentWillMount: "[Deprecated] Use 'UNSAFE_componentWillMount' instead." },
 		schema: []
 	},
-	name: RULE_NAME$49,
-	create: create$49,
+	name: RULE_NAME$42,
+	create: create$42,
 	defaultOptions: []
 });
-function create$49(context) {
+function create$42(context) {
 	if (!context.sourceCode.text.includes("componentWillMount")) return {};
 	const { ctx, listeners } = ER.useComponentCollectorLegacy();
 	return {
@@ -976,24 +975,24 @@ function create$49(context) {
 
 //#endregion
 //#region src/rules/no-component-will-receive-props.ts
-const RULE_NAME$48 = "no-component-will-receive-props";
-const RULE_FEATURES$46 = ["MOD"];
+const RULE_NAME$41 = "no-component-will-receive-props";
+const RULE_FEATURES$39 = ["MOD"];
 var no_component_will_receive_props_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Replace usages of `componentWillReceiveProps` with `UNSAFE_componentWillReceiveProps`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$46
+			[Symbol.for("rule_features")]: RULE_FEATURES$39
 		},
 		fixable: "code",
 		messages: { noComponentWillReceiveProps: "[Deprecated] Use 'UNSAFE_componentWillReceiveProps' instead." },
 		schema: []
 	},
-	name: RULE_NAME$48,
-	create: create$48,
+	name: RULE_NAME$41,
+	create: create$41,
 	defaultOptions: []
 });
-function create$48(context) {
+function create$41(context) {
 	if (!context.sourceCode.text.includes("componentWillReceiveProps")) return {};
 	const { ctx, listeners } = ER.useComponentCollectorLegacy();
 	return {
@@ -1017,24 +1016,24 @@ function create$48(context) {
 
 //#endregion
 //#region src/rules/no-component-will-update.ts
-const RULE_NAME$47 = "no-component-will-update";
-const RULE_FEATURES$45 = ["MOD"];
+const RULE_NAME$40 = "no-component-will-update";
+const RULE_FEATURES$38 = ["MOD"];
 var no_component_will_update_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Replace usages of `componentWillUpdate` with `UNSAFE_componentWillUpdate`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$45
+			[Symbol.for("rule_features")]: RULE_FEATURES$38
 		},
 		fixable: "code",
 		messages: { noComponentWillUpdate: "[Deprecated] Use 'UNSAFE_componentWillUpdate' instead." },
 		schema: []
 	},
-	name: RULE_NAME$47,
-	create: create$47,
+	name: RULE_NAME$40,
+	create: create$40,
 	defaultOptions: []
 });
-function create$47(context) {
+function create$40(context) {
 	if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
 	const { ctx, listeners } = ER.useComponentCollectorLegacy();
 	return {
@@ -1058,24 +1057,24 @@ function create$47(context) {
 
 //#endregion
 //#region src/rules/no-context-provider.ts
-const RULE_NAME$46 = "no-context-provider";
-const RULE_FEATURES$44 = ["MOD"];
+const RULE_NAME$39 = "no-context-provider";
+const RULE_FEATURES$37 = ["MOD"];
 var no_context_provider_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Replace usages of `<Context.Provider>` with `<Context>`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$44
+			[Symbol.for("rule_features")]: RULE_FEATURES$37
 		},
 		fixable: "code",
 		messages: { noContextProvider: "In React 19, you can render '<Context>' as a provider instead of '<Context.Provider>'." },
 		schema: []
 	},
-	name: RULE_NAME$46,
-	create: create$46,
+	name: RULE_NAME$39,
+	create: create$39,
 	defaultOptions: []
 });
-function create$46(context) {
+function create$39(context) {
 	if (!context.sourceCode.text.includes("Provider")) return {};
 	const { version: version$1 } = getSettingsFromContext(context);
 	if (compare(version$1, "19.0.0", "<")) return {};
@@ -1103,23 +1102,23 @@ function create$46(context) {
 
 //#endregion
 //#region src/rules/no-create-ref.ts
-const RULE_NAME$45 = "no-create-ref";
-const RULE_FEATURES$43 = [];
+const RULE_NAME$38 = "no-create-ref";
+const RULE_FEATURES$36 = [];
 var no_create_ref_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow `createRef` in function components.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$43
+			[Symbol.for("rule_features")]: RULE_FEATURES$36
 		},
 		messages: { noCreateRef: "[Deprecated] Use 'useRef' instead." },
 		schema: []
 	},
-	name: RULE_NAME$45,
-	create: create$45,
+	name: RULE_NAME$38,
+	create: create$38,
 	defaultOptions: []
 });
-function create$45(context) {
+function create$38(context) {
 	return { CallExpression(node) {
 		if (ER.isCreateRefCall(context, node) && AST.findParentNode(node, ER.isClassComponent) == null) context.report({
 			messageId: "noCreateRef",
@@ -1130,23 +1129,23 @@ function create$45(context) {
 
 //#endregion
 //#region src/rules/no-default-props.ts
-const RULE_NAME$44 = "no-default-props";
-const RULE_FEATURES$42 = [];
+const RULE_NAME$37 = "no-default-props";
+const RULE_FEATURES$35 = [];
 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_FEATURES$42
+			[Symbol.for("rule_features")]: RULE_FEATURES$35
 		},
 		messages: { noDefaultProps: "[Deprecated] Use ES6 default parameters instead." },
 		schema: []
 	},
-	name: RULE_NAME$44,
-	create: create$44,
+	name: RULE_NAME$37,
+	create: create$37,
 	defaultOptions: []
 });
-function create$44(context) {
+function create$37(context) {
 	if (!context.sourceCode.text.includes("defaultProps")) return {};
 	return { AssignmentExpression(node) {
 		if (node.operator !== "=" || node.left.type !== AST_NODE_TYPES.MemberExpression) return;
@@ -1167,8 +1166,8 @@ function create$44(context) {
 
 //#endregion
 //#region src/rules/no-direct-mutation-state.ts
-const RULE_NAME$43 = "no-direct-mutation-state";
-const RULE_FEATURES$41 = [];
+const RULE_NAME$36 = "no-direct-mutation-state";
+const RULE_FEATURES$34 = [];
 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";
 }
@@ -1177,16 +1176,16 @@ var no_direct_mutation_state_default = createRule({
 		type: "problem",
 		docs: {
 			description: "Disallow direct mutation of `this.state`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$41
+			[Symbol.for("rule_features")]: RULE_FEATURES$34
 		},
 		messages: { noDirectMutationState: "Do not mutate state directly. Use 'setState()' instead." },
 		schema: []
 	},
-	name: RULE_NAME$43,
-	create: create$43,
+	name: RULE_NAME$36,
+	create: create$36,
 	defaultOptions: []
 });
-function create$43(context) {
+function create$36(context) {
 	return { AssignmentExpression(node) {
 		if (!ER.isAssignmentToThisState(node)) return;
 		const parentClass = AST.findParentNode(node, AST.isOneOf([AST_NODE_TYPES.ClassDeclaration, AST_NODE_TYPES.ClassExpression]));
@@ -1200,23 +1199,23 @@ function create$43(context) {
 
 //#endregion
 //#region src/rules/no-duplicate-key.ts
-const RULE_NAME$42 = "no-duplicate-key";
-const RULE_FEATURES$40 = [];
+const RULE_NAME$35 = "no-duplicate-key";
+const RULE_FEATURES$33 = [];
 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_FEATURES$40
+			[Symbol.for("rule_features")]: RULE_FEATURES$33
 		},
 		messages: { noDuplicateKey: "A key must be unique. '{{value}}' is duplicated." },
 		schema: []
 	},
-	name: RULE_NAME$42,
-	create: create$42,
+	name: RULE_NAME$35,
+	create: create$35,
 	defaultOptions: []
 });
-function create$42(context) {
+function create$35(context) {
 	if (!context.sourceCode.getText().includes("key=")) return {};
 	const keyedEntries = /* @__PURE__ */ new Map();
 	function isKeyValueEqual(a, b) {
@@ -1271,8 +1270,8 @@ function create$42(context) {
 
 //#endregion
 //#region src/rules/no-forbidden-props.ts
-const RULE_NAME$41 = "no-forbidden-props";
-const messageId = camelCase(RULE_NAME$41);
+const RULE_NAME$34 = "no-forbidden-props";
+const messageId = camelCase(RULE_NAME$34);
 const defaultOptions$1 = [{ forbid: [{ prop: "/_/" }] }];
 var no_forbidden_props_default = createRule({
 	meta: {
@@ -1316,11 +1315,11 @@ var no_forbidden_props_default = createRule({
 			} }
 		}]
 	},
-	name: RULE_NAME$41,
-	create: create$41,
+	name: RULE_NAME$34,
+	create: create$34,
 	defaultOptions: defaultOptions$1
 });
-function create$41(context, [option]) {
+function create$34(context, [option]) {
 	const { forbid = [{ prop: "/_/" }] } = option;
 	return { JSXOpeningElement(node) {
 		let nodeName = null;
@@ -1349,24 +1348,24 @@ function create$41(context, [option]) {
 
 //#endregion
 //#region src/rules/no-forward-ref.ts
-const RULE_NAME$40 = "no-forward-ref";
-const RULE_FEATURES$39 = ["MOD"];
+const RULE_NAME$33 = "no-forward-ref";
+const RULE_FEATURES$32 = ["MOD"];
 var no_forward_ref_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Replaces usages of `forwardRef` with passing `ref` as a prop.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$39
+			[Symbol.for("rule_features")]: RULE_FEATURES$32
 		},
 		fixable: "code",
 		messages: { noForwardRef: "In React 19, 'forwardRef' is no longer necessary. Pass 'ref' as a prop instead." },
 		schema: []
 	},
-	name: RULE_NAME$40,
-	create: create$40,
+	name: RULE_NAME$33,
+	create: create$33,
 	defaultOptions: []
 });
-function create$40(context) {
+function create$33(context) {
 	if (!context.sourceCode.text.includes("forwardRef")) return {};
 	const { version: version$1 } = getSettingsFromContext(context);
 	if (compare(version$1, "19.0.0", "<")) return {};
@@ -1447,23 +1446,23 @@ function getComponentPropsFixes(context, fixer, node, typeArguments) {
 
 //#endregion
 //#region src/rules/no-implicit-key.ts
-const RULE_NAME$39 = "no-implicit-key";
-const RULE_FEATURES$38 = ["EXP"];
+const RULE_NAME$32 = "no-implicit-key";
+const RULE_FEATURES$31 = ["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_FEATURES$38
+			[Symbol.for("rule_features")]: RULE_FEATURES$31
 		},
 		messages: { noImplicitKey: "Do not use implicit 'key' props." },
 		schema: []
 	},
-	name: RULE_NAME$39,
-	create: create$39,
+	name: RULE_NAME$32,
+	create: create$32,
 	defaultOptions: []
 });
-function create$39(context) {
+function create$32(context) {
 	return { JSXOpeningElement(node) {
 		const initialScope = context.sourceCode.getScope(node);
 		const keyProp = ER.getAttribute(context, node.attributes, initialScope)("key");
@@ -1477,23 +1476,23 @@ function create$39(context) {
 
 //#endregion
 //#region src/rules/no-leaked-conditional-rendering.ts
-const RULE_NAME$38 = "no-leaked-conditional-rendering";
-const RULE_FEATURES$37 = ["TSC"];
+const RULE_NAME$31 = "no-leaked-conditional-rendering";
+const RULE_FEATURES$30 = ["TSC"];
 var no_leaked_conditional_rendering_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Prevents problematic leaked values from being rendered.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$37
+			[Symbol.for("rule_features")]: RULE_FEATURES$30
 		},
 		messages: { noLeakedConditionalRendering: "Potential leaked value {{value}} that might cause unintentionally rendered values or rendering crashes." },
 		schema: []
 	},
-	name: RULE_NAME$38,
-	create: create$38,
+	name: RULE_NAME$31,
+	create: create$31,
 	defaultOptions: []
 });
-function create$38(context) {
+function create$31(context) {
 	if (!context.sourceCode.text.includes("&&")) return {};
 	const { version: version$1 } = getSettingsFromContext(context);
 	const allowedVariants = [
@@ -1549,23 +1548,23 @@ function create$38(context) {
 
 //#endregion
 //#region src/rules/no-missing-component-display-name.ts
-const RULE_NAME$37 = "no-missing-component-display-name";
-const RULE_FEATURES$36 = [];
+const RULE_NAME$30 = "no-missing-component-display-name";
+const RULE_FEATURES$29 = [];
 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_FEATURES$36
+			[Symbol.for("rule_features")]: RULE_FEATURES$29
 		},
 		messages: { noMissingComponentDisplayName: "Add missing 'displayName' for component." },
 		schema: []
 	},
-	name: RULE_NAME$37,
-	create: create$37,
+	name: RULE_NAME$30,
+	create: create$30,
 	defaultOptions: []
 });
-function create$37(context) {
+function create$30(context) {
 	if (!context.sourceCode.text.includes("memo") && !context.sourceCode.text.includes("forwardRef")) return {};
 	const { ctx, listeners } = ER.useComponentCollector(context, {
 		collectDisplayName: true,
@@ -1594,24 +1593,24 @@ function create$37(context) {
 
 //#endregion
 //#region src/rules/no-missing-context-display-name.ts
-const RULE_NAME$36 = "no-missing-context-display-name";
-const RULE_FEATURES$35 = ["FIX"];
+const RULE_NAME$29 = "no-missing-context-display-name";
+const RULE_FEATURES$28 = ["FIX"];
 var no_missing_context_display_name_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Enforces that all contexts have a `displayName` which can be used in devtools.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$35
+			[Symbol.for("rule_features")]: RULE_FEATURES$28
 		},
 		fixable: "code",
 		messages: { noMissingContextDisplayName: "Add missing 'displayName' for context." },
 		schema: []
 	},
-	name: RULE_NAME$36,
-	create: create$36,
-	defaultOptions: []
+	name: RULE_NAME$29,
+	create: create$29,
+	defaultOptions: []
 });
-function create$36(context) {
+function create$29(context) {
 	if (!context.sourceCode.text.includes("createContext")) return {};
 	const createCalls = [];
 	const displayNameAssignments = [];
@@ -1667,14 +1666,14 @@ function create$36(context) {
 
 //#endregion
 //#region src/rules/no-missing-key.ts
-const RULE_NAME$35 = "no-missing-key";
-const RULE_FEATURES$34 = [];
+const RULE_NAME$28 = "no-missing-key";
+const RULE_FEATURES$27 = [];
 var no_missing_key_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow missing `key` on items in list rendering.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$34
+			[Symbol.for("rule_features")]: RULE_FEATURES$27
 		},
 		messages: {
 			missingKey: "Missing 'key' for element when rendering list.",
@@ -1682,11 +1681,11 @@ var no_missing_key_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$35,
-	create: create$35,
+	name: RULE_NAME$28,
+	create: create$28,
 	defaultOptions: []
 });
-function create$35(context) {
+function create$28(context) {
 	const report = Reporter.make(context);
 	const state = { isWithinChildrenToArray: false };
 	function checkIteratorElement(node) {
@@ -1767,14 +1766,14 @@ function create$35(context) {
 
 //#endregion
 //#region src/rules/no-misused-capture-owner-stack.ts
-const RULE_NAME$34 = "no-misused-capture-owner-stack";
-const RULE_FEATURES$33 = ["EXP"];
+const RULE_NAME$27 = "no-misused-capture-owner-stack";
+const RULE_FEATURES$26 = ["EXP"];
 var no_misused_capture_owner_stack_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Prevents incorrect usage of `captureOwnerStack`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$33
+			[Symbol.for("rule_features")]: RULE_FEATURES$26
 		},
 		fixable: "code",
 		messages: {
@@ -1783,11 +1782,11 @@ var no_misused_capture_owner_stack_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$34,
-	create: create$34,
+	name: RULE_NAME$27,
+	create: create$27,
 	defaultOptions: []
 });
-function create$34(context) {
+function create$27(context) {
 	if (!context.sourceCode.text.includes("captureOwnerStack")) return {};
 	const { importSource } = getSettingsFromContext(context);
 	return {
@@ -1819,23 +1818,23 @@ function isDevelopmentOnlyCheck(node) {
 
 //#endregion
 //#region src/rules/no-nested-component-definitions.ts
-const RULE_NAME$33 = "no-nested-component-definitions";
-const RULE_FEATURES$32 = [];
+const RULE_NAME$26 = "no-nested-component-definitions";
+const RULE_FEATURES$25 = [];
 var no_nested_component_definitions_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow nesting component definitions inside other components.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$32
+			[Symbol.for("rule_features")]: RULE_FEATURES$25
 		},
 		messages: { noNestedComponentDefinitions: "Do not nest component definitions inside other components or props. {{suggestion}}" },
 		schema: []
 	},
-	name: RULE_NAME$33,
-	create: create$33,
+	name: RULE_NAME$26,
+	create: create$26,
 	defaultOptions: []
 });
-function create$33(context) {
+function create$26(context) {
 	const hint = ER.ComponentDetectionHint.SkipArrayMapArgument | ER.ComponentDetectionHint.SkipNullLiteral | ER.ComponentDetectionHint.SkipUndefined | ER.ComponentDetectionHint.SkipBooleanLiteral | ER.ComponentDetectionHint.SkipStringLiteral | ER.ComponentDetectionHint.SkipNumberLiteral | ER.ComponentDetectionHint.StrictLogical | ER.ComponentDetectionHint.StrictConditional;
 	const collector = ER.useComponentCollector(context, { hint });
 	const collectorLegacy = ER.useComponentCollectorLegacy();
@@ -1953,23 +1952,23 @@ function isInsideCreateElementProps(context, node) {
 
 //#endregion
 //#region src/rules/no-nested-lazy-component-declarations.ts
-const RULE_NAME$32 = "no-nested-lazy-component-declarations";
-const RULE_FEATURES$31 = [];
+const RULE_NAME$25 = "no-nested-lazy-component-declarations";
+const RULE_FEATURES$24 = [];
 var no_nested_lazy_component_declarations_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow nesting lazy component declarations inside other components.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$31
+			[Symbol.for("rule_features")]: RULE_FEATURES$24
 		},
 		messages: { noNestedLazyComponentDeclarations: "Do not declare lazy components inside other components. Instead, always declare them at the top level of your module." },
 		schema: []
 	},
-	name: RULE_NAME$32,
-	create: create$32,
+	name: RULE_NAME$25,
+	create: create$25,
 	defaultOptions: []
 });
-function create$32(context) {
+function create$25(context) {
 	const hint = ER.ComponentDetectionHint.None;
 	const collector = ER.useComponentCollector(context, { hint });
 	const collectorLegacy = ER.useComponentCollectorLegacy();
@@ -2003,23 +2002,23 @@ function create$32(context) {
 
 //#endregion
 //#region src/rules/no-prop-types.ts
-const RULE_NAME$31 = "no-prop-types";
-const RULE_FEATURES$30 = [];
+const RULE_NAME$24 = "no-prop-types";
+const RULE_FEATURES$23 = [];
 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_FEATURES$30
+			[Symbol.for("rule_features")]: RULE_FEATURES$23
 		},
 		messages: { noPropTypes: "[Deprecated] Use TypeScript or another type-checking solution instead." },
 		schema: []
 	},
-	name: RULE_NAME$31,
-	create: create$31,
+	name: RULE_NAME$24,
+	create: create$24,
 	defaultOptions: []
 });
-function create$31(context) {
+function create$24(context) {
 	if (!context.sourceCode.text.includes("propTypes")) return {};
 	return {
 		AssignmentExpression(node) {
@@ -2048,8 +2047,8 @@ function create$31(context) {
 
 //#endregion
 //#region src/rules/no-redundant-should-component-update.ts
-const RULE_NAME$30 = "no-redundant-should-component-update";
-const RULE_FEATURES$29 = [];
+const RULE_NAME$23 = "no-redundant-should-component-update";
+const RULE_FEATURES$22 = [];
 function isShouldComponentUpdate(node) {
 	return AST.isMethodOrProperty(node) && node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "shouldComponentUpdate";
 }
@@ -2058,16 +2057,16 @@ var no_redundant_should_component_update_default = createRule({
 		type: "problem",
 		docs: {
 			description: "Disallow `shouldComponentUpdate` when extending `React.PureComponent`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$29
+			[Symbol.for("rule_features")]: RULE_FEATURES$22
 		},
 		messages: { noRedundantShouldComponentUpdate: "'{{componentName}}' does not need 'shouldComponentUpdate' when extending 'React.PureComponent'." },
 		schema: []
 	},
-	name: RULE_NAME$30,
-	create: create$30,
+	name: RULE_NAME$23,
+	create: create$23,
 	defaultOptions: []
 });
-function create$30(context) {
+function create$23(context) {
 	if (!context.sourceCode.text.includes("shouldComponentUpdate")) return {};
 	const { ctx, listeners } = ER.useComponentCollectorLegacy();
 	return {
@@ -2089,23 +2088,23 @@ function create$30(context) {
 
 //#endregion
 //#region src/rules/no-set-state-in-component-did-mount.ts
-const RULE_NAME$29 = "no-set-state-in-component-did-mount";
-const RULE_FEATURES$28 = [];
+const RULE_NAME$22 = "no-set-state-in-component-did-mount";
+const RULE_FEATURES$21 = [];
 var no_set_state_in_component_did_mount_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow calling `this.setState` in `componentDidMount` outside of functions, such as callbacks.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$28
+			[Symbol.for("rule_features")]: RULE_FEATURES$21
 		},
 		messages: { noSetStateInComponentDidMount: "Do not call `this.setState` in `componentDidMount` outside of functions, such as callbacks." },
 		schema: []
 	},
-	name: RULE_NAME$29,
-	create: create$29,
+	name: RULE_NAME$22,
+	create: create$22,
 	defaultOptions: []
 });
-function create$29(context) {
+function create$22(context) {
 	if (!context.sourceCode.text.includes("componentDidMount")) return {};
 	return { CallExpression(node) {
 		if (!ER.isThisSetState(node)) return;
@@ -2123,23 +2122,23 @@ function create$29(context) {
 
 //#endregion
 //#region src/rules/no-set-state-in-component-did-update.ts
-const RULE_NAME$28 = "no-set-state-in-component-did-update";
-const RULE_FEATURES$27 = [];
+const RULE_NAME$21 = "no-set-state-in-component-did-update";
+const RULE_FEATURES$20 = [];
 var no_set_state_in_component_did_update_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow calling `this.setState` in `componentDidUpdate` outside of functions, such as callbacks.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$27
+			[Symbol.for("rule_features")]: RULE_FEATURES$20
 		},
 		messages: { noSetStateInComponentDidUpdate: "Do not call `this.setState` in `componentDidUpdate` outside of functions, such as callbacks." },
 		schema: []
 	},
-	name: RULE_NAME$28,
-	create: create$28,
+	name: RULE_NAME$21,
+	create: create$21,
 	defaultOptions: []
 });
-function create$28(context) {
+function create$21(context) {
 	if (!context.sourceCode.text.includes("componentDidUpdate")) return {};
 	return { CallExpression(node) {
 		if (!ER.isThisSetState(node)) return;
@@ -2157,23 +2156,23 @@ function create$28(context) {
 
 //#endregion
 //#region src/rules/no-set-state-in-component-will-update.ts
-const RULE_NAME$27 = "no-set-state-in-component-will-update";
-const RULE_FEATURES$26 = [];
+const RULE_NAME$20 = "no-set-state-in-component-will-update";
+const RULE_FEATURES$19 = [];
 var no_set_state_in_component_will_update_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallows calling `this.setState` in `componentWillUpdate` outside of functions, such as callbacks.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$26
+			[Symbol.for("rule_features")]: RULE_FEATURES$19
 		},
 		messages: { noSetStateInComponentWillUpdate: "Do not call `this.setState` in `componentWillUpdate` outside of functions, such as callbacks." },
 		schema: []
 	},
-	name: RULE_NAME$27,
-	create: create$27,
+	name: RULE_NAME$20,
+	create: create$20,
 	defaultOptions: []
 });
-function create$27(context) {
+function create$20(context) {
 	if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
 	return { CallExpression(node) {
 		if (!ER.isThisSetState(node)) return;
@@ -2191,24 +2190,24 @@ function create$27(context) {
 
 //#endregion
 //#region src/rules/no-string-refs.ts
-const RULE_NAME$26 = "no-string-refs";
-const RULE_FEATURES$25 = ["MOD"];
+const RULE_NAME$19 = "no-string-refs";
+const RULE_FEATURES$18 = ["MOD"];
 var no_string_refs_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Replaces string refs with callback refs.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$25
+			[Symbol.for("rule_features")]: RULE_FEATURES$18
 		},
 		fixable: "code",
 		messages: { noStringRefs: "[Deprecated] Use callback refs instead." },
 		schema: []
 	},
-	name: RULE_NAME$26,
-	create: create$26,
+	name: RULE_NAME$19,
+	create: create$19,
 	defaultOptions: []
 });
-function create$26(context) {
+function create$19(context) {
 	const state = { isWithinClassComponent: false };
 	function onClassBodyEnter(node) {
 		if (ER.isClassComponent(node.parent)) state.isWithinClassComponent = true;
@@ -2247,23 +2246,23 @@ function getAttributeValueText(context, node) {
 
 //#endregion
 //#region src/rules/no-unnecessary-key.ts
-const RULE_NAME$25 = "no-unnecessary-key";
-const RULE_FEATURES$24 = ["EXP"];
+const RULE_NAME$18 = "no-unnecessary-key";
+const RULE_FEATURES$17 = ["EXP"];
 var no_unnecessary_key_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Prevents the use of unnecessary `key` props on JSX elements when rendering lists.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$24
+			[Symbol.for("rule_features")]: RULE_FEATURES$17
 		},
 		messages: { noUnnecessaryKey: "Unnecessary `key` prop on this element. The `key` should be on the top-level element returned from the array." },
 		schema: []
 	},
-	name: RULE_NAME$25,
-	create: create$25,
+	name: RULE_NAME$18,
+	create: create$18,
 	defaultOptions: []
 });
-function create$25(context) {
+function create$18(context) {
 	if (!context.sourceCode.getText().includes("key=")) return {};
 	return { JSXAttribute(node) {
 		if (node.name.name !== "key") return;
@@ -2289,32 +2288,28 @@ function isMapCallback(node) {
 
 //#endregion
 //#region src/rules/no-unnecessary-use-callback.ts
-const RULE_NAME$24 = "no-unnecessary-use-callback";
-const RULE_FEATURES$23 = ["EXP"];
+const RULE_NAME$17 = "no-unnecessary-use-callback";
+const RULE_FEATURES$16 = ["EXP"];
 var no_unnecessary_use_callback_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow unnecessary usage of `useCallback`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$23
+			[Symbol.for("rule_features")]: RULE_FEATURES$16
 		},
 		messages: { noUnnecessaryUseCallback: "An 'useCallback' with empty deps and no references to the component scope may be unnecessary." },
 		schema: []
 	},
-	name: RULE_NAME$24,
-	create: create$24,
+	name: RULE_NAME$17,
+	create: create$17,
 	defaultOptions: []
 });
-function create$24(context) {
-	if (!context.sourceCode.text.includes("use")) return {};
-	const alias = getSettingsFromContext(context).additionalHooks.useCallback ?? [];
-	const isUseCallbackCall = ER.isReactHookCallWithNameAlias(context, "useCallback", alias);
+function create$17(context) {
+	if (!context.sourceCode.text.includes("useCallback")) return {};
 	return { CallExpression(node) {
-		if (!ER.isReactHookCall(node)) return;
+		if (!ER.isUseCallbackCall(node)) return;
 		const initialScope = context.sourceCode.getScope(node);
-		if (!isUseCallbackCall(node)) return;
-		const scope = context.sourceCode.getScope(node);
-		const component = scope.block;
+		const component = context.sourceCode.getScope(node).block;
 		if (!AST.isFunction(component)) return;
 		const [arg0, arg1] = node.arguments;
 		if (arg0 == null || arg1 == null) return;
@@ -2347,30 +2342,27 @@ function create$24(context) {
 
 //#endregion
 //#region src/rules/no-unnecessary-use-memo.ts
-const RULE_NAME$23 = "no-unnecessary-use-memo";
-const RULE_FEATURES$22 = ["EXP"];
+const RULE_NAME$16 = "no-unnecessary-use-memo";
+const RULE_FEATURES$15 = ["EXP"];
 var no_unnecessary_use_memo_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Disallow unnecessary usage of `useMemo`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$22
+			[Symbol.for("rule_features")]: RULE_FEATURES$15
 		},
 		messages: { noUnnecessaryUseMemo: "An 'useMemo' with empty deps and no references to the component scope may be unnecessary." },
 		schema: []
 	},
-	name: RULE_NAME$23,
-	create: create$23,
+	name: RULE_NAME$16,
+	create: create$16,
 	defaultOptions: []
 });
-function create$23(context) {
-	if (!context.sourceCode.text.includes("use")) return {};
-	const alias = getSettingsFromContext(context).additionalHooks.useMemo ?? [];
-	const isUseMemoCall = ER.isReactHookCallWithNameAlias(context, "useMemo", alias);
+function create$16(context) {
+	if (!context.sourceCode.text.includes("useMemo")) return {};
 	return { CallExpression(node) {
-		if (!ER.isReactHookCall(node)) return;
 		const initialScope = context.sourceCode.getScope(node);
-		if (!isUseMemoCall(node)) return;
+		if (!ER.isUseMemoCall(node)) return;
 		const scope = context.sourceCode.getScope(node);
 		const component = scope.block;
 		if (!AST.isFunction(component)) return;
@@ -2407,8 +2399,8 @@ function create$23(context) {
 
 //#endregion
 //#region src/rules/no-unnecessary-use-prefix.ts
-const RULE_NAME$22 = "no-unnecessary-use-prefix";
-const RULE_FEATURES$21 = [];
+const RULE_NAME$15 = "no-unnecessary-use-prefix";
+const RULE_FEATURES$14 = [];
 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));
@@ -2418,16 +2410,16 @@ var no_unnecessary_use_prefix_default = createRule({
 		type: "problem",
 		docs: {
 			description: "Enforces that a function with the `use` prefix should use at least one Hook inside of it.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$21
+			[Symbol.for("rule_features")]: RULE_FEATURES$14
 		},
 		messages: { noUnnecessaryUsePrefix: "If your function doesn't call any Hooks, avoid the 'use' prefix. Instead, write it as a regular function without the 'use' prefix." },
 		schema: []
 	},
-	name: RULE_NAME$22,
-	create: create$22,
+	name: RULE_NAME$15,
+	create: create$15,
 	defaultOptions: []
 });
-function create$22(context) {
+function create$15(context) {
 	const { ctx, listeners } = ER.useHookCollector();
 	return {
 		...listeners,
@@ -2451,23 +2443,23 @@ function create$22(context) {
 
 //#endregion
 //#region src/rules/no-unsafe-component-will-mount.ts
-const RULE_NAME$21 = "no-unsafe-component-will-mount";
-const RULE_FEATURES$20 = [];
+const RULE_NAME$14 = "no-unsafe-component-will-mount";
+const RULE_FEATURES$13 = [];
 var no_unsafe_component_will_mount_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Warns the usage of `UNSAFE_componentWillMount` in class components.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$20
+			[Symbol.for("rule_features")]: RULE_FEATURES$13
 		},
 		messages: { noUnsafeComponentWillMount: "Do not use 'UNSAFE_componentWillMount'." },
 		schema: []
 	},
-	name: RULE_NAME$21,
-	create: create$21,
+	name: RULE_NAME$14,
+	create: create$14,
 	defaultOptions: []
 });
-function create$21(context) {
+function create$14(context) {
 	if (!context.sourceCode.text.includes("UNSAFE_componentWillMount")) return {};
 	const { ctx, listeners } = ER.useComponentCollectorLegacy();
 	return {
@@ -2487,23 +2479,23 @@ function create$21(context) {
 
 //#endregion
 //#region src/rules/no-unsafe-component-will-receive-props.ts
-const RULE_NAME$20 = "no-unsafe-component-will-receive-props";
-const RULE_FEATURES$19 = [];
+const RULE_NAME$13 = "no-unsafe-component-will-receive-props";
+const RULE_FEATURES$12 = [];
 var no_unsafe_component_will_receive_props_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Warns the usage of `UNSAFE_componentWillReceiveProps` in class components.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$19
+			[Symbol.for("rule_features")]: RULE_FEATURES$12
 		},
 		messages: { noUnsafeComponentWillReceiveProps: "Do not use 'UNSAFE_componentWillReceiveProps'." },
 		schema: []
 	},
-	name: RULE_NAME$20,
-	create: create$20,
+	name: RULE_NAME$13,
+	create: create$13,
 	defaultOptions: []
 });
-function create$20(context) {
+function create$13(context) {
 	if (!context.sourceCode.text.includes("UNSAFE_componentWillReceiveProps")) return {};
 	const { ctx, listeners } = ER.useComponentCollectorLegacy();
 	return {
@@ -2523,23 +2515,23 @@ function create$20(context) {
 
 //#endregion
 //#region src/rules/no-unsafe-component-will-update.ts
-const RULE_NAME$19 = "no-unsafe-component-will-update";
-const RULE_FEATURES$18 = [];
+const RULE_NAME$12 = "no-unsafe-component-will-update";
+const RULE_FEATURES$11 = [];
 var no_unsafe_component_will_update_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Warns the usage of `UNSAFE_componentWillUpdate` in class components.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$18
+			[Symbol.for("rule_features")]: RULE_FEATURES$11
 		},
 		messages: { noUnsafeComponentWillUpdate: "Do not use 'UNSAFE_componentWillUpdate'." },
 		schema: []
 	},
-	name: RULE_NAME$19,
-	create: create$19,
+	name: RULE_NAME$12,
+	create: create$12,
 	defaultOptions: []
 });
-function create$19(context) {
+function create$12(context) {
 	if (!context.sourceCode.text.includes("UNSAFE_componentWillUpdate")) return {};
 	const { ctx, listeners } = ER.useComponentCollectorLegacy();
 	return {
@@ -2559,23 +2551,23 @@ function create$19(context) {
 
 //#endregion
 //#region src/rules/no-unstable-context-value.ts
-const RULE_NAME$18 = "no-unstable-context-value";
-const RULE_FEATURES$17 = [];
+const RULE_NAME$11 = "no-unstable-context-value";
+const RULE_FEATURES$10 = [];
 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_FEATURES$17
+			[Symbol.for("rule_features")]: RULE_FEATURES$10
 		},
 		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_NAME$18,
-	create: create$18,
+	name: RULE_NAME$11,
+	create: create$11,
 	defaultOptions: []
 });
-function create$18(context) {
+function create$11(context) {
 	const { version: version$1 } = getSettingsFromContext(context);
 	const isReact18OrBelow = compare(version$1, "19.0.0", "<");
 	const { ctx, listeners } = ER.useComponentCollector(context);
@@ -2625,23 +2617,23 @@ function isContextName(name$4, isReact18OrBelow) {
 
 //#endregion
 //#region src/rules/no-unstable-default-props.ts
-const RULE_NAME$17 = "no-unstable-default-props";
-const RULE_FEATURES$16 = [];
+const RULE_NAME$10 = "no-unstable-default-props";
+const RULE_FEATURES$9 = [];
 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_FEATURES$16
+			[Symbol.for("rule_features")]: RULE_FEATURES$9
 		},
 		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_NAME$17,
-	create: create$17,
+	name: RULE_NAME$10,
+	create: create$10,
 	defaultOptions: []
 });
-function create$17(context) {
+function create$10(context) {
 	const { ctx, listeners } = ER.useComponentCollector(context);
 	const declarators = /* @__PURE__ */ new WeakMap();
 	return {
@@ -2682,8 +2674,8 @@ function create$17(context) {
 
 //#endregion
 //#region src/rules/no-unused-class-component-members.ts
-const RULE_NAME$16 = "no-unused-class-component-members";
-const RULE_FEATURES$15 = [];
+const RULE_NAME$9 = "no-unused-class-component-members";
+const RULE_FEATURES$8 = [];
 const LIFECYCLE_METHODS = new Set([
 	"componentDidCatch",
 	"componentDidMount",
@@ -2712,16 +2704,16 @@ var no_unused_class_component_members_default = createRule({
 		type: "problem",
 		docs: {
 			description: "Warns unused class component methods and properties.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$15
+			[Symbol.for("rule_features")]: RULE_FEATURES$8
 		},
 		messages: { noUnusedClassComponentMembers: "Unused method or property '{{methodName}}'' of class '{{className}}'." },
 		schema: []
 	},
-	name: RULE_NAME$16,
-	create: create$16,
+	name: RULE_NAME$9,
+	create: create$9,
 	defaultOptions: []
 });
-function create$16(context) {
+function create$9(context) {
 	const classEntries = [];
 	const methodEntries = [];
 	const propertyDefs = /* @__PURE__ */ new WeakMap();
@@ -2802,23 +2794,23 @@ function create$16(context) {
 
 //#endregion
 //#region src/rules/no-unused-props.ts
-const RULE_NAME$15 = "no-unused-props";
-const RULE_FEATURES$14 = ["TSC", "EXP"];
+const RULE_NAME$8 = "no-unused-props";
+const RULE_FEATURES$7 = ["TSC", "EXP"];
 var no_unused_props_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Warns about unused component prop declarations.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$14
+			[Symbol.for("rule_features")]: RULE_FEATURES$7
 		},
 		messages: { noUnusedProps: "Prop `{{name}}` is declared but never used" },
 		schema: []
 	},
-	name: RULE_NAME$15,
-	create: create$15,
+	name: RULE_NAME$8,
+	create: create$8,
 	defaultOptions: []
 });
-function create$15(context) {
+function create$8(context) {
 	const services = ESLintUtils.getParserServices(context, false);
 	const { ctx, listeners } = ER.useComponentCollector(context);
 	return {
@@ -2922,8 +2914,8 @@ function reportUnusedProp(context, services, prop) {
 
 //#endregion
 //#region src/rules/no-unused-state.ts
-const RULE_NAME$14 = "no-unused-state";
-const RULE_FEATURES$13 = [];
+const RULE_NAME$7 = "no-unused-state";
+const RULE_FEATURES$6 = [];
 function isKeyLiteral(node, key) {
 	return match(key).with({ type: AST_NODE_TYPES.Literal }, constTrue).with({
 		type: AST_NODE_TYPES.TemplateLiteral,
@@ -2935,16 +2927,16 @@ var no_unused_state_default = createRule({
 		type: "problem",
 		docs: {
 			description: "Warns unused class component state.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$13
+			[Symbol.for("rule_features")]: RULE_FEATURES$6
 		},
 		messages: { noUnusedState: "Unused class component state in '{{className}}'" },
 		schema: []
 	},
-	name: RULE_NAME$14,
-	create: create$14,
+	name: RULE_NAME$7,
+	create: create$7,
 	defaultOptions: []
 });
-function create$14(context) {
+function create$7(context) {
 	const classEntries = [];
 	const methodEntries = [];
 	const constructorEntries = [];
@@ -3054,28 +3046,27 @@ function create$14(context) {
 
 //#endregion
 //#region src/rules/no-use-context.ts
-const RULE_NAME$13 = "no-use-context";
-const RULE_FEATURES$12 = ["MOD"];
+const RULE_NAME$6 = "no-use-context";
+const RULE_FEATURES$5 = ["MOD"];
 var no_use_context_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Replaces usages of `useContext` with `use`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$12
+			[Symbol.for("rule_features")]: RULE_FEATURES$5
 		},
 		fixable: "code",
 		messages: { noUseContext: "In React 19, 'use' is preferred over 'useContext' because it is more flexible." },
 		schema: []
 	},
-	name: RULE_NAME$13,
-	create: create$13,
+	name: RULE_NAME$6,
+	create: create$6,
 	defaultOptions: []
 });
-function create$13(context) {
+function create$6(context) {
 	if (!context.sourceCode.text.includes("useContext")) return {};
 	const settings$3 = getSettingsFromContext(context);
 	if (compare(settings$3.version, "19.0.0", "<")) return {};
-	const useContextNames = /* @__PURE__ */ new Set();
 	const hookCalls = /* @__PURE__ */ new Set();
 	return {
 		CallExpression(node) {
@@ -3091,30 +3082,26 @@ function create$13(context) {
 			for (const specifier of node.specifiers) {
 				if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) continue;
 				if (specifier.imported.type !== AST_NODE_TYPES.Identifier) continue;
-				if (specifier.imported.name === "useContext") {
-					if (specifier.local.name !== "useContext") useContextNames.add(specifier.local.name);
-					context.report({
-						messageId: "noUseContext",
-						node: specifier,
-						fix(fixer) {
-							if (isUseImported) {
-								const tokenBefore = context.sourceCode.getTokenBefore(specifier);
-								return [
-									fixer.remove(specifier),
-									...tokenBefore?.value === "," ? [fixer.replaceTextRange([tokenBefore.range[1], specifier.range[0]], "")] : [],
-									...getCorrelativeTokens(context, specifier).map((token) => fixer.remove(token))
-								];
-							}
-							return fixer.replaceText(specifier.imported, "use");
+				if (specifier.imported.name === "useContext") context.report({
+					messageId: "noUseContext",
+					node: specifier,
+					fix(fixer) {
+						if (isUseImported) {
+							const tokenBefore = context.sourceCode.getTokenBefore(specifier);
+							return [
+								fixer.remove(specifier),
+								...tokenBefore?.value === "," ? [fixer.replaceTextRange([tokenBefore.range[1], specifier.range[0]], "")] : [],
+								...getCorrelativeTokens(context, specifier).map((token) => fixer.remove(token))
+							];
 						}
-					});
-				}
+						return fixer.replaceText(specifier.imported, "use");
+					}
+				});
 			}
 		},
 		"Program:exit"() {
-			const isUseContextCall = ER.isReactHookCallWithNameAlias(context, "useContext", [...useContextNames]);
 			for (const node of hookCalls) {
-				if (!isUseContextCall(node)) continue;
+				if (!ER.isUseContextCall(node)) continue;
 				context.report({
 					messageId: "noUseContext",
 					node: node.callee,
@@ -3141,23 +3128,23 @@ function getCorrelativeTokens(context, node) {
 
 //#endregion
 //#region src/rules/no-useless-forward-ref.ts
-const RULE_NAME$12 = "no-useless-forward-ref";
-const RULE_FEATURES$11 = [];
+const RULE_NAME$5 = "no-useless-forward-ref";
+const RULE_FEATURES$4 = [];
 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_FEATURES$11
+			[Symbol.for("rule_features")]: RULE_FEATURES$4
 		},
 		messages: { noUselessForwardRef: "A 'forwardRef' is used with this component but no 'ref' parameter is set." },
 		schema: []
 	},
-	name: RULE_NAME$12,
-	create: create$12,
+	name: RULE_NAME$5,
+	create: create$5,
 	defaultOptions: []
 });
-function create$12(context) {
+function create$5(context) {
 	return { CallExpression(node) {
 		if (!ER.isForwardRefCall(context, node)) return;
 		const [component] = node.arguments;
@@ -3173,7 +3160,7 @@ function create$12(context) {
 
 //#endregion
 //#region src/rules/no-useless-fragment.ts
-const RULE_NAME$11 = "no-useless-fragment";
+const RULE_NAME$4 = "no-useless-fragment";
 const defaultOptions = [{ allowExpressions: true }];
 var no_useless_fragment_default = createRule({
 	meta: {
@@ -3191,11 +3178,11 @@ var no_useless_fragment_default = createRule({
 			} }
 		}]
 	},
-	name: RULE_NAME$11,
-	create: create$11,
+	name: RULE_NAME$4,
+	create: create$4,
 	defaultOptions
 });
-function create$11(context, [option]) {
+function create$4(context, [option]) {
 	const { allowExpressions = true } = option;
 	return {
 		JSXElement(node) {
@@ -3302,8 +3289,8 @@ function canFix(context, node) {
 
 //#endregion
 //#region src/rules/prefer-destructuring-assignment.ts
-const RULE_NAME$10 = "prefer-destructuring-assignment";
-const RULE_FEATURES$10 = [];
+const RULE_NAME$3 = "prefer-destructuring-assignment";
+const RULE_FEATURES$3 = [];
 function isMemberExpressionWithObjectName(node) {
 	return node.object.type === AST_NODE_TYPES.Identifier && "name" in node.object;
 }
@@ -3312,16 +3299,16 @@ var prefer_destructuring_assignment_default = createRule({
 		type: "problem",
 		docs: {
 			description: "Enforces destructuring assignment for component props and context.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$10
+			[Symbol.for("rule_features")]: RULE_FEATURES$3
 		},
 		messages: { preferDestructuringAssignment: "Use destructuring assignment for {{name}}." },
 		schema: []
 	},
-	name: RULE_NAME$10,
-	create: create$10,
+	name: RULE_NAME$3,
+	create: create$3,
 	defaultOptions: []
 });
-function create$10(context) {
+function create$3(context) {
 	const { ctx, listeners } = ER.useComponentCollector(context);
 	const memberExpressionWithNames = [];
 	return {
@@ -3368,24 +3355,24 @@ function create$10(context) {
 
 //#endregion
 //#region src/rules/prefer-namespace-import.ts
-const RULE_NAME$9 = "prefer-namespace-import";
-const RULE_FEATURES$9 = ["FIX"];
+const RULE_NAME$2 = "prefer-namespace-import";
+const RULE_FEATURES$2 = ["FIX"];
 var prefer_namespace_import_default = createRule({
 	meta: {
 		type: "problem",
 		docs: {
 			description: "Enforces React is imported via a namespace import.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$9
+			[Symbol.for("rule_features")]: RULE_FEATURES$2
 		},
 		fixable: "code",
 		messages: { preferNamespaceImport: "Prefer importing React as 'import * as React from \"{{importSource}}\"';" },
 		schema: []
 	},
-	name: RULE_NAME$9,
-	create: create$9,
+	name: RULE_NAME$2,
+	create: create$2,
 	defaultOptions: []
 });
-function create$9(context) {
+function create$2(context) {
 	const { importSource } = getSettingsFromContext(context);
 	return { [`ImportDeclaration[source.value="${importSource}"] ImportDefaultSpecifier`](node) {
 		const hasOtherSpecifiers = node.parent.specifiers.length > 1;
@@ -3410,23 +3397,23 @@ function create$9(context) {
 
 //#endregion
 //#region src/rules/prefer-read-only-props.ts
-const RULE_NAME$8 = "prefer-read-only-props";
-const RULE_FEATURES$8 = ["TSC", "EXP"];
+const RULE_NAME$1 = "prefer-read-only-props";
+const RULE_FEATURES$1 = ["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_FEATURES$8
+			[Symbol.for("rule_features")]: RULE_FEATURES$1
 		},
 		messages: { preferReadOnlyProps: "A function component's props should be read-only." },
 		schema: []
 	},
-	name: RULE_NAME$8,
-	create: create$8,
+	name: RULE_NAME$1,
+	create: create$1,
 	defaultOptions: []
 });
-function create$8(context) {
+function create$1(context) {
 	const services = ESLintUtils.getParserServices(context, false);
 	const { ctx, listeners } = ER.useComponentCollector(context);
 	return {
@@ -3460,8 +3447,8 @@ function isTypeReadonlyLoose(services, type) {
 
 //#endregion
 //#region src/rules/prefer-use-state-lazy-initialization.ts
-const RULE_NAME$7 = "prefer-use-state-lazy-initialization";
-const RULE_FEATURES$7 = ["EXP"];
+const RULE_NAME = "prefer-use-state-lazy-initialization";
+const RULE_FEATURES = ["EXP"];
 const ALLOW_LIST = [
 	"Boolean",
 	"String",
@@ -3472,27 +3459,24 @@ var prefer_use_state_lazy_initialization_default = createRule({
 		type: "problem",
 		docs: {
 			description: "Enforces function calls made inside `useState` to be wrapped in an `initializer function`.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$7
+			[Symbol.for("rule_features")]: RULE_FEATURES
 		},
 		messages: { preferUseStateLazyInitialization: "To prevent re-computation, consider using lazy initial state for useState calls that involve function calls. Ex: 'useState(() => getValue())'." },
 		schema: []
 	},
-	name: RULE_NAME$7,
-	create: create$7,
+	name: RULE_NAME,
+	create,
 	defaultOptions: []
 });
-function create$7(context) {
-	const alias = getSettingsFromContext(context).additionalHooks.useState ?? [];
-	const isUseStateCall = ER.isReactHookCallWithNameAlias(context, "useState", alias);
+function create(context) {
 	return { CallExpression(node) {
-		if (!ER.isReactHookCall(node)) return;
-		if (!isUseStateCall(node)) return;
+		if (!ER.isUseStateCall(node)) return;
 		const [useStateInput] = node.arguments;
 		if (useStateInput == null) return;
 		for (const expr of AST.getNestedNewExpressions(useStateInput)) {
 			if (!("name" in expr.callee)) continue;
 			if (ALLOW_LIST.includes(expr.callee.name)) continue;
-			if (AST.findParentNode(expr, (n) => ER.isUseCall(context, n)) != null) continue;
+			if (AST.findParentNode(expr, ER.isUseCall) != null) continue;
 			context.report({
 				messageId: "preferUseStateLazyInitialization",
 				node: expr
@@ -3502,7 +3486,7 @@ function create$7(context) {
 			if (!("name" in expr.callee)) continue;
 			if (ER.isReactHookName(expr.callee.name)) continue;
 			if (ALLOW_LIST.includes(expr.callee.name)) continue;
-			if (AST.findParentNode(expr, (n) => ER.isUseCall(context, n)) != null) continue;
+			if (AST.findParentNode(expr, ER.isUseCall) != null) continue;
 			context.report({
 				messageId: "preferUseStateLazyInitialization",
 				node: expr
@@ -3511,272 +3495,6 @@ function create$7(context) {
 	} };
 }
 
-//#endregion
-//#region src/rules-removed/avoid-shorthand-boolean.ts
-const RULE_NAME$6 = "avoid-shorthand-boolean";
-const RULE_FEATURES$6 = [];
-var avoid_shorthand_boolean_default = createRule({
-	meta: {
-		type: "problem",
-		deprecated: true,
-		docs: {
-			description: "Enforces explicit boolean values for boolean attributes.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$6
-		},
-		fixable: "code",
-		messages: { avoidShorthandBoolean: "Avoid using shorthand boolean attribute '{{propName}}'. Use '{{propName}}={true}' instead." },
-		replacedBy: ["react-x/jsx-shorthand-boolean"],
-		schema: []
-	},
-	name: RULE_NAME$6,
-	create: create$6,
-	defaultOptions: []
-});
-function create$6(context) {
-	return { JSXAttribute(node) {
-		if (node.value == null) context.report({
-			messageId: "avoidShorthandBoolean",
-			node,
-			data: { propName: ER.getAttributeName(context, node) },
-			fix: (fixer) => fixer.insertTextAfter(node.name, `={true}`)
-		});
-	} };
-}
-
-//#endregion
-//#region src/rules-removed/avoid-shorthand-fragment.ts
-const RULE_NAME$5 = "avoid-shorthand-fragment";
-const RULE_FEATURES$5 = [];
-var avoid_shorthand_fragment_default = createRule({
-	meta: {
-		type: "problem",
-		deprecated: true,
-		docs: {
-			description: "Enforces explicit `<Fragment>` components instead of the shorthand `<>` or `</>` syntax.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$5
-		},
-		messages: { avoidShorthandFragment: "Avoid using shorthand fragment syntax. Use '{{jsxFragmentFactory}}' component instead." },
-		replacedBy: ["react-x/jsx-shorthand-fragment"],
-		schema: []
-	},
-	name: RULE_NAME$5,
-	create: create$5,
-	defaultOptions: []
-});
-function create$5(context) {
-	const jsxConfigFromContext = JsxConfig.getFromContext(context);
-	const jsxConfigFromAnnotation = JsxConfig.getFromAnnotation(context);
-	const jsxConfig = {
-		...jsxConfigFromContext,
-		...jsxConfigFromAnnotation
-	};
-	return { JSXFragment(node) {
-		context.report({
-			messageId: "avoidShorthandFragment",
-			node,
-			data: { jsxFragmentFactory: jsxConfig.jsxFragmentFactory }
-		});
-	} };
-}
-
-//#endregion
-//#region src/rules-removed/no-comment-textnodes.ts
-const RULE_NAME$4 = "no-comment-textnodes";
-const RULE_FEATURES$4 = [];
-var no_comment_textnodes_default = createRule({
-	meta: {
-		type: "problem",
-		deprecated: true,
-		docs: {
-			description: "Prevents comments from being inserted as text nodes.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$4
-		},
-		messages: { noCommentTextnodes: "Possible misused comment in text node. Comments inside children section of tag should be placed inside braces." },
-		replacedBy: ["react-x/jsx-no-comment-textnodes"],
-		schema: []
-	},
-	name: RULE_NAME$4,
-	create: create$4,
-	defaultOptions: []
-});
-function create$4(context) {
-	function hasCommentLike(node) {
-		if (AST.isOneOf([AST_NODE_TYPES.JSXAttribute, AST_NODE_TYPES.JSXExpressionContainer])(node.parent)) return false;
-		const rawValue = context.sourceCode.getText(node);
-		return /^\s*\/(?:\/|\*)/mu.test(rawValue);
-	}
-	const visitorFunction = (node) => {
-		if (!AST.isOneOf([AST_NODE_TYPES.JSXElement, AST_NODE_TYPES.JSXFragment])(node.parent)) return;
-		if (!hasCommentLike(node)) return;
-		if (!node.parent.type.includes("JSX")) return;
-		context.report({
-			messageId: "noCommentTextnodes",
-			node
-		});
-	};
-	return {
-		JSXText: visitorFunction,
-		Literal: visitorFunction
-	};
-}
-
-//#endregion
-//#region src/rules-removed/no-complex-conditional-rendering.ts
-const RULE_NAME$3 = "no-complex-conditional-rendering";
-const RULE_FEATURES$3 = ["EXP"];
-var no_complex_conditional_rendering_default = createRule({
-	meta: {
-		type: "problem",
-		deprecated: true,
-		docs: {
-			description: "Disallow complex conditional rendering in JSX expressions.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$3
-		},
-		messages: { noComplexConditionalRendering: "Avoid complex conditional rendering. Extract the logic into separate elements or components." },
-		schema: []
-	},
-	name: RULE_NAME$3,
-	create: create$3,
-	defaultOptions: []
-});
-function create$3(context) {
-	const visitorFunction = (node) => {
-		const jsxExpContainer = node.parent?.parent;
-		if (!AST.is(AST_NODE_TYPES.JSXExpressionContainer)(jsxExpContainer)) return;
-		if (!AST.isOneOf([AST_NODE_TYPES.JSXElement, AST_NODE_TYPES.JSXFragment])(jsxExpContainer.parent)) return;
-		if (!jsxExpContainer.parent.children.includes(jsxExpContainer)) return;
-		context.report({
-			messageId: "noComplexConditionalRendering",
-			node: jsxExpContainer
-		});
-	};
-	return {
-		"JSXExpressionContainer > ConditionalExpression > ConditionalExpression": visitorFunction,
-		"JSXExpressionContainer > ConditionalExpression > LogicalExpression": visitorFunction,
-		"JSXExpressionContainer > LogicalExpression > ConditionalExpression": visitorFunction,
-		"JSXExpressionContainer > LogicalExpression[operator='&&'] > LogicalExpression[operator='||']": visitorFunction,
-		"JSXExpressionContainer > LogicalExpression[operator='||'] > LogicalExpression[operator='&&']": visitorFunction
-	};
-}
-
-//#endregion
-//#region src/rules-removed/prefer-react-namespace-import.ts
-const RULE_NAME$2 = "prefer-react-namespace-import";
-const RULE_FEATURES$2 = ["FIX"];
-var prefer_react_namespace_import_default = createRule({
-	meta: {
-		type: "problem",
-		deprecated: true,
-		docs: {
-			description: "Enforces React is imported via a namespace import.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$2
-		},
-		fixable: "code",
-		messages: { preferReactNamespaceImport: "Prefer importing React as 'import * as React from \"{{importSource}}\"';" },
-		replacedBy: ["react-x/prefer-namespace-import"],
-		schema: []
-	},
-	name: RULE_NAME$2,
-	create: create$2,
-	defaultOptions: []
-});
-function create$2(context) {
-	const { importSource } = getSettingsFromContext(context);
-	return { [`ImportDeclaration[source.value="${importSource}"] ImportDefaultSpecifier`](node) {
-		const hasOtherSpecifiers = node.parent.specifiers.length > 1;
-		context.report({
-			messageId: "preferReactNamespaceImport",
-			node: hasOtherSpecifiers ? node : node.parent,
-			data: { importSource },
-			fix(fixer) {
-				const importDeclarationText = context.sourceCode.getText(node.parent);
-				const semi = importDeclarationText.endsWith(";") ? ";" : "";
-				const quote = node.parent.source.raw.at(0) ?? "'";
-				const isTypeImport = node.parent.importKind === "type";
-				const importStringPrefix = `import${isTypeImport ? " type" : ""}`;
-				const importSourceQuoted = `${quote}${importSource}${quote}`;
-				if (!hasOtherSpecifiers) return fixer.replaceText(node.parent, `${importStringPrefix} * as ${node.local.name} from ${importSourceQuoted}${semi}`);
-				const specifiers = importDeclarationText.slice(importDeclarationText.indexOf("{"), importDeclarationText.indexOf("}") + 1);
-				return fixer.replaceText(node.parent, [`${importStringPrefix} * as ${node.local.name} from ${importSourceQuoted}${semi}`, `${importStringPrefix} ${specifiers} from ${importSourceQuoted}${semi}`].join("\n"));
-			}
-		});
-	} };
-}
-
-//#endregion
-//#region src/rules-removed/prefer-shorthand-boolean.ts
-const RULE_NAME$1 = "prefer-shorthand-boolean";
-const RULE_FEATURES$1 = ["FIX"];
-var prefer_shorthand_boolean_default = createRule({
-	meta: {
-		type: "problem",
-		deprecated: true,
-		docs: {
-			description: "Enforces shorthand syntax for boolean attributes.",
-			[Symbol.for("rule_features")]: RULE_FEATURES$1
-		},
-		fixable: "code",
-		messages: { preferShorthandBoolean: "Use shorthand boolean attribute '{{propName}}'." },
-		replacedBy: ["react-x/jsx-shorthand-boolean"],
-		schema: []
-	},
-	name: RULE_NAME$1,
-	create: create$1,
-	defaultOptions: []
-});
-function create$1(context) {
-	return { JSXAttribute(node) {
-		const { value } = node;
-		const propName = ER.getAttributeName(context, node);
-		const hasValueTrue = value?.type === AST_NODE_TYPES.JSXExpressionContainer && value.expression.type === AST_NODE_TYPES.Literal && value.expression.value === true;
-		if (!hasValueTrue) return;
-		context.report({
-			messageId: "preferShorthandBoolean",
-			node: node.value ?? node,
-			data: { propName },
-			fix: (fixer) => fixer.removeRange([node.name.range[1], value.range[1]])
-		});
-	} };
-}
-
-//#endregion
-//#region src/rules-removed/prefer-shorthand-fragment.ts
-const RULE_NAME = "prefer-shorthand-fragment";
-const RULE_FEATURES = ["FIX"];
-var prefer_shorthand_fragment_default = createRule({
-	meta: {
-		type: "problem",
-		deprecated: true,
-		docs: {
-			description: "Enforces shorthand syntax for fragments.",
-			[Symbol.for("rule_features")]: RULE_FEATURES
-		},
-		fixable: "code",
-		messages: { preferShorthandFragment: "Use fragment shorthand syntax instead of 'Fragment' component." },
-		replacedBy: ["react-x/jsx-shorthand-fragment"],
-		schema: []
-	},
-	name: RULE_NAME,
-	create,
-	defaultOptions: []
-});
-function create(context) {
-	return { JSXElement(node) {
-		if (!ER.isFragmentElement(context, node)) return;
-		const hasAttributes = node.openingElement.attributes.length > 0;
-		if (hasAttributes) return;
-		context.report({
-			messageId: "preferShorthandFragment",
-			node,
-			fix: (fixer) => {
-				const { closingElement, openingElement } = node;
-				if (closingElement == null) return [];
-				return [fixer.replaceTextRange([openingElement.range[0], openingElement.range[1]], "<>"), fixer.replaceTextRange([closingElement.range[0], closingElement.range[1]], "</>")];
-			}
-		});
-	} };
-}
-
 //#endregion
 //#region src/plugin.ts
 const plugin = {
@@ -3846,14 +3564,7 @@ const plugin = {
 		"prefer-destructuring-assignment": prefer_destructuring_assignment_default,
 		"prefer-namespace-import": prefer_namespace_import_default,
 		"prefer-read-only-props": prefer_read_only_props_default,
-		"prefer-use-state-lazy-initialization": prefer_use_state_lazy_initialization_default,
-		"avoid-shorthand-boolean": avoid_shorthand_boolean_default,
-		"avoid-shorthand-fragment": avoid_shorthand_fragment_default,
-		"no-comment-textnodes": no_comment_textnodes_default,
-		"no-complex-conditional-rendering": no_complex_conditional_rendering_default,
-		"prefer-react-namespace-import": prefer_react_namespace_import_default,
-		"prefer-shorthand-boolean": prefer_shorthand_boolean_default,
-		"prefer-shorthand-fragment": prefer_shorthand_fragment_default
+		"prefer-use-state-lazy-initialization": prefer_use_state_lazy_initialization_default
 	}
 };