oxlint-plugin-react-doctor 0.7.7-dev.bdd1321 → 0.7.7-dev.ce4179b

package/dist/index.js

@@ -7,6 +7,13 @@ import { analyze } from "eslint-scope";
 //#region src/plugin/utils/is-node-of-type.ts
 const isNodeOfType = (node, type) => node !== null && typeof node === "object" && "type" in node && node.type === type;
 //#endregion
+//#region src/plugin/utils/is-type-only-import.ts
+const isEverySpecifierInlineType = (specifiers, specifierType, kindField) => {
+	if (!specifiers || specifiers.length === 0) return false;
+	return specifiers.every((specifier) => isNodeOfType(specifier, specifierType) && specifier[kindField] === "type");
+};
+const isTypeOnlyImport = (node) => node.importKind === "type" || isEverySpecifierInlineType(node.specifiers, "ImportSpecifier", "importKind");
+//#endregion
 //#region src/plugin/utils/non-react-jsx-dialect.ts
 const NON_REACT_JSX_DIALECT_PACKAGES = new Set([
 	"solid-js",
@@ -21,17 +28,33 @@ const NON_REACT_JSX_DIALECT_PACKAGES = new Set([
 	"vidode"
 ]);
 const NON_REACT_JSX_DIALECT_PACKAGE_PREFIXES = ["solid-js", "@builder.io/qwik"];
+const REACT_JSX_DIALECT_PACKAGE_PREFIXES = [
+	"react",
+	"react-dom",
+	"preact"
+];
 const startsWithAny = (source, prefixes) => prefixes.some((prefix) => source === prefix || source.startsWith(`${prefix}/`));
-const fileImportsNonReactJsxDialect = (program) => {
+const collectJsxRuntimeImports = (program) => {
+	let hasNonReactRuntime = false;
+	let hasReactRuntime = false;
 	for (const statement of program.body) {
 		if (!isNodeOfType(statement, "ImportDeclaration")) continue;
-		const source = statement.source;
+		const importDeclaration = statement;
+		if (isTypeOnlyImport(importDeclaration)) continue;
+		const source = importDeclaration.source;
 		const value = source && typeof source.value === "string" ? source.value : null;
 		if (!value) continue;
-		if (NON_REACT_JSX_DIALECT_PACKAGES.has(value)) return true;
-		if (startsWithAny(value, NON_REACT_JSX_DIALECT_PACKAGE_PREFIXES)) return true;
+		if (NON_REACT_JSX_DIALECT_PACKAGES.has(value) || startsWithAny(value, NON_REACT_JSX_DIALECT_PACKAGE_PREFIXES)) hasNonReactRuntime = true;
+		if (startsWithAny(value, REACT_JSX_DIALECT_PACKAGE_PREFIXES)) hasReactRuntime = true;
 	}
-	return false;
+	return {
+		hasNonReactRuntime,
+		hasReactRuntime
+	};
+};
+const fileImportsNonReactJsxDialect = (program) => {
+	const runtimeImports = collectJsxRuntimeImports(program);
+	return runtimeImports.hasNonReactRuntime && !runtimeImports.hasReactRuntime;
 };
 const jsxAttributeIsNonReactDialectMarker = (openingNode) => {
 	for (const attribute of openingNode.attributes) {
@@ -244,6 +267,7 @@ const VISITOR_NODE_NAME_PATTERN = /^[A-Z]/;
 const wrapCreateForReactJsxOnly = (create) => ((context) => {
 	const innerVisitors = create(context);
 	let fileIsNonReactJsx = false;
+	let fileImportsReactRuntime = false;
 	const wrappedVisitors = {};
 	for (const [key, visitor] of Object.entries(innerVisitors)) {
 		if (typeof visitor !== "function") {
@@ -256,14 +280,16 @@ const wrapCreateForReactJsxOnly = (create) => ((context) => {
 		}
 		if (key === "Program") {
 			wrappedVisitors.Program = (node) => {
-				fileIsNonReactJsx = fileImportsNonReactJsxDialect(node);
+				const runtimeImports = collectJsxRuntimeImports(node);
+				fileImportsReactRuntime = runtimeImports.hasReactRuntime;
+				fileIsNonReactJsx = runtimeImports.hasNonReactRuntime && !runtimeImports.hasReactRuntime;
 				visitor(node);
 			};
 			continue;
 		}
 		if (key === "JSXOpeningElement") {
 			wrappedVisitors.JSXOpeningElement = (node) => {
-				if (!fileIsNonReactJsx && jsxAttributeIsNonReactDialectMarker(node)) fileIsNonReactJsx = true;
+				if (!fileImportsReactRuntime && !fileIsNonReactJsx && jsxAttributeIsNonReactDialectMarker(node)) fileIsNonReactJsx = true;
 				if (fileIsNonReactJsx) return;
 				visitor(node);
 			};
@@ -275,7 +301,9 @@ const wrapCreateForReactJsxOnly = (create) => ((context) => {
 		};
 	}
 	if (!("Program" in wrappedVisitors)) wrappedVisitors.Program = (node) => {
-		fileIsNonReactJsx = fileImportsNonReactJsxDialect(node);
+		const runtimeImports = collectJsxRuntimeImports(node);
+		fileImportsReactRuntime = runtimeImports.hasReactRuntime;
+		fileIsNonReactJsx = runtimeImports.hasNonReactRuntime && !runtimeImports.hasReactRuntime;
 	};
 	return wrappedVisitors;
 });
@@ -2312,7 +2340,7 @@ const anchorAmbiguousText = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/anchor-has-content.ts
-const MESSAGE$61 = "Blind users can't follow this link because screen readers announce nothing, so add visible text, `aria-label`, or `aria-labelledby`.";
+const MESSAGE$62 = "Blind users can't follow this link because screen readers announce nothing, so add visible text, `aria-label`, or `aria-labelledby`.";
 const isTransComponentsTemplate = (node) => {
 	let current = node.parent;
 	while (current) {
@@ -2348,7 +2376,7 @@ const anchorHasContent = defineRule({
 			if (isTransComponentsTemplate(node)) return;
 			context.report({
 				node: opening.name,
-				message: MESSAGE$61
+				message: MESSAGE$62
 			});
 		} };
 	}
@@ -2780,7 +2808,7 @@ const parseJsxValue = (value) => {
 };
 //#endregion
 //#region src/plugin/rules/a11y/aria-activedescendant-has-tabindex.ts
-const MESSAGE$60 = "Keyboard users can't focus this element with `aria-activedescendant` because it isn't tabbable, so add `tabIndex={0}`.";
+const MESSAGE$61 = "Keyboard users can't focus this element with `aria-activedescendant` because it isn't tabbable, so add `tabIndex={0}`.";
 const mayBeContentEditable = (node) => {
 	const attribute = hasJsxPropIgnoreCase(node.attributes, "contenteditable");
 	if (!attribute) return false;
@@ -2811,7 +2839,7 @@ const ariaActivedescendantHasTabindex = defineRule({
 			if (tabIndexValue === null || tabIndexValue >= -1) return;
 			context.report({
 				node: node.name,
-				message: MESSAGE$60
+				message: MESSAGE$61
 			});
 			return;
 		}
@@ -2819,7 +2847,7 @@ const ariaActivedescendantHasTabindex = defineRule({
 		if (mayBeContentEditable(node)) return;
 		context.report({
 			node: node.name,
-			message: MESSAGE$60
+			message: MESSAGE$61
 		});
 	} })
 });
@@ -4314,6 +4342,397 @@ const findTransparentExpressionRoot = (node) => {
 	return current;
 };
 //#endregion
+//#region src/plugin/utils/get-static-property-key-name.ts
+const getStaticPropertyKeyName = (node, options = {}) => {
+	if (!isNodeOfType(node, "Property") && !isNodeOfType(node, "MethodDefinition") && !isNodeOfType(node, "MemberExpression")) return null;
+	const key = isNodeOfType(node, "MemberExpression") ? node.property : node.key;
+	if (node.computed) {
+		if (options.allowComputedString && isNodeOfType(key, "Literal") && typeof key.value === "string") return key.value;
+		if (options.allowComputedString && isNodeOfType(key, "TemplateLiteral") && key.expressions.length === 0) return key.quasis[0]?.value.cooked ?? key.quasis[0]?.value.raw ?? null;
+		return null;
+	}
+	if (isNodeOfType(key, "Identifier")) return key.name;
+	if (isNodeOfType(key, "Literal")) {
+		if (typeof key.value === "string") return key.value;
+		if (options.stringifyNonStringLiterals) return String(key.value);
+	}
+	return null;
+};
+//#endregion
+//#region src/plugin/utils/get-destructured-binding-property-name.ts
+const getDestructuredBindingPropertyName = (bindingIdentifier) => {
+	let bindingNode = bindingIdentifier;
+	if (isNodeOfType(bindingNode.parent, "AssignmentPattern") && bindingNode.parent.left === bindingNode) bindingNode = bindingNode.parent;
+	const property = bindingNode.parent;
+	if (!property || !isNodeOfType(property, "Property") || property.value !== bindingNode || !property.parent || !isNodeOfType(property.parent, "ObjectPattern")) return null;
+	return getStaticPropertyKeyName(property, { allowComputedString: true });
+};
+//#endregion
+//#region src/plugin/utils/get-static-property-name.ts
+const getStaticPropertyName = (memberExpression) => {
+	const property = memberExpression.property;
+	if (!memberExpression.computed && isNodeOfType(property, "Identifier")) return property.name;
+	if (memberExpression.computed && isNodeOfType(property, "Literal")) return typeof property.value === "string" ? property.value : null;
+	if (memberExpression.computed && isNodeOfType(property, "TemplateLiteral") && property.expressions.length === 0) return property.quasis[0]?.value.cooked ?? property.quasis[0]?.value.raw ?? null;
+	return null;
+};
+//#endregion
+//#region src/plugin/utils/has-static-property-write-before.ts
+const equivalentSymbolsByAnalysis = /* @__PURE__ */ new WeakMap();
+const potentiallyAliasedSymbolsByAnalysis = /* @__PURE__ */ new WeakMap();
+const CONDITIONAL_EXECUTION_NODE_TYPES = new Set([
+	"CatchClause",
+	"ConditionalExpression",
+	"DoWhileStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"ForStatement",
+	"IfStatement",
+	"LogicalExpression",
+	"SwitchCase",
+	"SwitchStatement",
+	"TryStatement",
+	"WhileStatement"
+]);
+const getResolvedStaticPropertyName = (memberExpression, scopes) => {
+	if (!isNodeOfType(memberExpression, "MemberExpression")) return null;
+	const directPropertyName = getStaticPropertyName(memberExpression);
+	if (directPropertyName || !memberExpression.computed) return directPropertyName;
+	const property = stripParenExpression(memberExpression.property);
+	if (!isNodeOfType(property, "Identifier")) return null;
+	const propertySymbol = resolveConstIdentifierAlias(property, scopes);
+	const initializer = propertySymbol?.initializer ? stripParenExpression(propertySymbol.initializer) : null;
+	return initializer && isNodeOfType(initializer, "Literal") && typeof initializer.value === "string" ? initializer.value : null;
+};
+const collectScopeSymbols = (scope, symbols) => {
+	symbols.push(...scope.symbols);
+	for (const childScope of scope.children) collectScopeSymbols(childScope, symbols);
+};
+const getEquivalentSymbols = (identifier, scopes) => {
+	const rootSymbol = resolveConstIdentifierAlias(identifier, scopes);
+	if (!rootSymbol) return [];
+	let symbolsByRootId = equivalentSymbolsByAnalysis.get(scopes);
+	if (!symbolsByRootId) {
+		symbolsByRootId = /* @__PURE__ */ new Map();
+		equivalentSymbolsByAnalysis.set(scopes, symbolsByRootId);
+	}
+	const cachedSymbols = symbolsByRootId.get(rootSymbol.id);
+	if (cachedSymbols) return cachedSymbols;
+	const allSymbols = [];
+	collectScopeSymbols(scopes.rootScope, allSymbols);
+	const equivalentSymbols = allSymbols.filter((symbol) => resolveConstIdentifierAlias(symbol.bindingIdentifier, scopes)?.id === rootSymbol.id);
+	symbolsByRootId.set(rootSymbol.id, equivalentSymbols);
+	return equivalentSymbols;
+};
+const getDirectAliasSourceSymbol = (expression, scopes) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	return isNodeOfType(unwrappedExpression, "Identifier") ? scopes.symbolFor(unwrappedExpression) : null;
+};
+const getDirectAssignmentSourceSymbol = (identifier, scopes) => {
+	const assignmentTarget = findTransparentExpressionRoot(identifier);
+	const parent = assignmentTarget.parent;
+	if (!parent || !isNodeOfType(parent, "AssignmentExpression") || parent.operator !== "=" || parent.left !== assignmentTarget) return null;
+	return getDirectAliasSourceSymbol(parent.right, scopes);
+};
+const isDirectAliasSourceReference = (identifier) => {
+	const aliasSource = findTransparentExpressionRoot(identifier);
+	const parent = aliasSource.parent;
+	if (parent && isNodeOfType(parent, "VariableDeclarator") && parent.init === aliasSource && (isNodeOfType(parent.id, "Identifier") || isNodeOfType(parent.id, "ObjectPattern"))) return true;
+	return Boolean(parent && isNodeOfType(parent, "AssignmentExpression") && parent.operator === "=" && parent.right === aliasSource && isNodeOfType(stripParenExpression(parent.left), "Identifier"));
+};
+const isDirectAliasOfKnownSymbol = (symbol, knownSymbolIds, scopes) => {
+	if (symbol.initializer && isNodeOfType(symbol.declarationNode, "VariableDeclarator") && symbol.declarationNode.id === symbol.bindingIdentifier) {
+		const initializerSymbol = getDirectAliasSourceSymbol(symbol.initializer, scopes);
+		if (initializerSymbol && knownSymbolIds.has(initializerSymbol.id)) return true;
+	}
+	return symbol.references.some((reference) => {
+		const assignmentSourceSymbol = getDirectAssignmentSourceSymbol(reference.identifier, scopes);
+		return Boolean(assignmentSourceSymbol && knownSymbolIds.has(assignmentSourceSymbol.id));
+	});
+};
+const getPotentiallyAliasedSymbols = (identifier, scopes) => {
+	const rootSymbol = resolveConstIdentifierAlias(identifier, scopes);
+	if (!rootSymbol) return [];
+	let symbolsByRootId = potentiallyAliasedSymbolsByAnalysis.get(scopes);
+	if (!symbolsByRootId) {
+		symbolsByRootId = /* @__PURE__ */ new Map();
+		potentiallyAliasedSymbolsByAnalysis.set(scopes, symbolsByRootId);
+	}
+	const cachedSymbols = symbolsByRootId.get(rootSymbol.id);
+	if (cachedSymbols) return cachedSymbols;
+	const allSymbols = [];
+	collectScopeSymbols(scopes.rootScope, allSymbols);
+	const aliasedSymbolIds = new Set([rootSymbol.id]);
+	let didAddAlias = true;
+	while (didAddAlias) {
+		didAddAlias = false;
+		for (const symbol of allSymbols) {
+			if (aliasedSymbolIds.has(symbol.id)) continue;
+			if (!isDirectAliasOfKnownSymbol(symbol, aliasedSymbolIds, scopes)) continue;
+			aliasedSymbolIds.add(symbol.id);
+			didAddAlias = true;
+		}
+	}
+	const aliasedSymbols = allSymbols.filter((symbol) => aliasedSymbolIds.has(symbol.id));
+	symbolsByRootId.set(rootSymbol.id, aliasedSymbols);
+	return aliasedSymbols;
+};
+const findExecutionBoundary = (node) => {
+	let current = node;
+	while (current) {
+		if (isFunctionLike$2(current) || isNodeOfType(current, "Program")) return current;
+		current = current.parent ?? null;
+	}
+	return null;
+};
+const isOnUnconditionalPath = (node, boundary) => {
+	let current = node.parent ?? null;
+	while (current && current !== boundary) {
+		if (CONDITIONAL_EXECUTION_NODE_TYPES.has(current.type)) return false;
+		current = current.parent ?? null;
+	}
+	return current === boundary;
+};
+const findFunctionBindingIdentifier = (functionNode) => {
+	if (isNodeOfType(functionNode, "FunctionDeclaration")) return functionNode.id ?? null;
+	const parent = functionNode.parent;
+	if (parent && isNodeOfType(parent, "VariableDeclarator") && parent.init === functionNode && isNodeOfType(parent.id, "Identifier")) return parent.id;
+	return null;
+};
+const findDirectCall = (identifier) => {
+	let callee = identifier;
+	let parent = callee.parent;
+	while (parent && stripParenExpression(parent) === identifier) {
+		callee = parent;
+		parent = callee.parent;
+	}
+	return parent && isNodeOfType(parent, "CallExpression") && parent.callee === callee ? parent : null;
+};
+const isFunctionSynchronouslyInvokedBefore = (functionNode, referenceNode, scopes, visitedFunctionNodes = /* @__PURE__ */ new Set()) => {
+	if (visitedFunctionNodes.has(functionNode) || !isFunctionLike$2(functionNode) || functionNode.generator) return false;
+	visitedFunctionNodes.add(functionNode);
+	const referenceBoundary = findExecutionBoundary(referenceNode);
+	if (!referenceBoundary) return false;
+	const invocationCalls = [];
+	const bindingIdentifier = findFunctionBindingIdentifier(functionNode);
+	if (bindingIdentifier) for (const symbol of getEquivalentSymbols(bindingIdentifier, scopes)) for (const reference of symbol.references) {
+		const call = findDirectCall(reference.identifier);
+		if (call) invocationCalls.push(call);
+	}
+	else {
+		const call = findDirectCall(functionNode);
+		if (call) invocationCalls.push(call);
+	}
+	return invocationCalls.some((call) => {
+		if (call.range[0] >= referenceNode.range[0]) return false;
+		const callBoundary = findExecutionBoundary(call);
+		if (!callBoundary) return false;
+		if (callBoundary === referenceBoundary) return true;
+		if (!isFunctionLike$2(callBoundary)) return false;
+		return isFunctionSynchronouslyInvokedBefore(callBoundary, referenceNode, scopes, new Set(visitedFunctionNodes));
+	});
+};
+const isMemberWriteTarget = (memberExpression) => {
+	const parent = memberExpression.parent;
+	if (!parent) return false;
+	if (isNodeOfType(parent, "AssignmentExpression")) return parent.left === memberExpression;
+	if (isNodeOfType(parent, "UpdateExpression")) return parent.argument === memberExpression;
+	return isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" && parent.argument === memberExpression;
+};
+const getMemberWriteTarget = (identifier) => {
+	let parent = identifier.parent;
+	while (parent && stripParenExpression(parent) === identifier) parent = parent.parent;
+	if (!parent || !isNodeOfType(parent, "MemberExpression") || stripParenExpression(parent.object) !== identifier || !isMemberWriteTarget(parent)) return null;
+	return parent;
+};
+const getStaticPropertyWriteTarget = (identifier, propertyName, scopes) => {
+	const writeTarget = getMemberWriteTarget(identifier);
+	return writeTarget && getResolvedStaticPropertyName(writeTarget, scopes) === propertyName ? writeTarget : null;
+};
+const symbolHasStaticPropertyWriteBefore = (symbol, propertyName, referenceNode, scopes) => symbol.references.some((reference) => {
+	const writeTarget = getStaticPropertyWriteTarget(reference.identifier, propertyName, scopes);
+	if (!writeTarget) return false;
+	const writeBoundary = findExecutionBoundary(writeTarget);
+	const referenceBoundary = findExecutionBoundary(referenceNode);
+	if (!writeBoundary || !referenceBoundary || !isOnUnconditionalPath(writeTarget, writeBoundary)) return false;
+	if (writeBoundary === referenceBoundary) return writeTarget.range[0] < referenceNode.range[0];
+	return isFunctionLike$2(writeBoundary) && isFunctionSynchronouslyInvokedBefore(writeBoundary, referenceNode, scopes);
+});
+const isStableStaticPropertyReference = (identifier) => {
+	if (isDirectAliasSourceReference(identifier)) return true;
+	const identifierRoot = findTransparentExpressionRoot(identifier);
+	const memberExpression = identifierRoot.parent;
+	return Boolean(memberExpression && isNodeOfType(memberExpression, "MemberExpression") && stripParenExpression(memberExpression.object) === identifierRoot);
+};
+const hasPossibleStaticPropertyWrite = (identifier, propertyName, scopes) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	return getPotentiallyAliasedSymbols(identifier, scopes).some((symbol) => symbol.references.some((reference) => {
+		const writeTarget = getMemberWriteTarget(reference.identifier);
+		if (!writeTarget) return false;
+		const writtenPropertyName = getResolvedStaticPropertyName(writeTarget, scopes);
+		return writtenPropertyName === null || writtenPropertyName === propertyName;
+	}));
+};
+const hasPossibleStaticPropertyMutationOrEscape = (identifier, propertyName, scopes) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	if (hasPossibleStaticPropertyWrite(identifier, propertyName, scopes)) return true;
+	return getPotentiallyAliasedSymbols(identifier, scopes).some((symbol) => symbol.references.some((reference) => !isStableStaticPropertyReference(reference.identifier)));
+};
+const hasPossibleStaticMemberCallWrite = (callExpression, scopes) => {
+	const unwrappedCallExpression = stripParenExpression(callExpression);
+	if (!isNodeOfType(unwrappedCallExpression, "CallExpression")) return false;
+	const callee = stripParenExpression(unwrappedCallExpression.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	const propertyName = getStaticPropertyName(callee);
+	if (propertyName === null) return false;
+	const receiver = stripParenExpression(callee.object);
+	return isNodeOfType(receiver, "Identifier") && hasPossibleStaticPropertyWrite(receiver, propertyName, scopes);
+};
+const hasStaticPropertyWriteBefore = (identifier, propertyName, referenceNode, scopes) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	return getEquivalentSymbols(identifier, scopes).some((symbol) => symbolHasStaticPropertyWriteBefore(symbol, propertyName, referenceNode, scopes));
+};
+//#endregion
+//#region src/plugin/utils/find-enclosing-function.ts
+const findEnclosingFunction$1 = (node) => {
+	let cursor = node.parent;
+	while (cursor) {
+		if (isFunctionLike$2(cursor)) return cursor;
+		cursor = cursor.parent ?? null;
+	}
+	return null;
+};
+//#endregion
+//#region src/plugin/utils/has-symbol-write-before.ts
+const hasSymbolWriteBefore = (symbol, referenceNode, scopes) => symbol.references.some((reference) => {
+	if (reference.flag === "read") return false;
+	const writeFunction = findEnclosingFunction$1(reference.identifier);
+	if (writeFunction === findEnclosingFunction$1(referenceNode)) return reference.identifier.range[0] < referenceNode.range[0];
+	if (!writeFunction) return true;
+	return isFunctionSynchronouslyInvokedBefore(writeFunction, referenceNode, scopes);
+});
+//#endregion
+//#region src/plugin/utils/get-order-independent-local-function.ts
+const COMMUTATIVE_COMPOUND_ASSIGNMENT_OPERATORS = new Set([
+	"+=",
+	"-=",
+	"*=",
+	"/=",
+	"%=",
+	"&=",
+	"^=",
+	"|="
+]);
+const isPureParameterExpression = (expression, parameterNames) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "Literal")) return true;
+	if (isNodeOfType(unwrappedExpression, "Identifier")) return parameterNames.has(unwrappedExpression.name);
+	if (isNodeOfType(unwrappedExpression, "BinaryExpression") || isNodeOfType(unwrappedExpression, "LogicalExpression")) return isPureParameterExpression(unwrappedExpression.left, parameterNames) && isPureParameterExpression(unwrappedExpression.right, parameterNames);
+	if (isNodeOfType(unwrappedExpression, "UnaryExpression")) return unwrappedExpression.operator !== "delete" && isPureParameterExpression(unwrappedExpression.argument, parameterNames);
+	if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) return isPureParameterExpression(unwrappedExpression.test, parameterNames) && isPureParameterExpression(unwrappedExpression.consequent, parameterNames) && isPureParameterExpression(unwrappedExpression.alternate, parameterNames);
+	if (isNodeOfType(unwrappedExpression, "TemplateLiteral")) return unwrappedExpression.expressions.every((nestedExpression) => isPureParameterExpression(nestedExpression, parameterNames));
+	return false;
+};
+const isOrderIndependentPromiseResolveCall = (expression, parameterNames, scopes) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(unwrappedExpression, "CallExpression")) return false;
+	if (!unwrappedExpression.arguments.every((argument) => !isNodeOfType(argument, "SpreadElement") && isPureParameterExpression(argument, parameterNames))) return false;
+	const callee = stripParenExpression(unwrappedExpression.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	if (getStaticPropertyName(callee) !== "resolve") return false;
+	const receiver = stripParenExpression(callee.object);
+	return isNodeOfType(receiver, "Identifier") && receiver.name === "Promise" && scopes.isGlobalReference(receiver);
+};
+const isHarmlessPromiseResolveAwait = (statement, parameterNames, scopes) => {
+	if (!isNodeOfType(statement, "ExpressionStatement") || !isNodeOfType(statement.expression, "AwaitExpression")) return false;
+	return isOrderIndependentPromiseResolveCall(statement.expression.argument, parameterNames, scopes);
+};
+const isCommutativeParameterMutation = (statement, parameterNames) => {
+	if (!isNodeOfType(statement, "ExpressionStatement") || !isNodeOfType(statement.expression, "AssignmentExpression") || !COMMUTATIVE_COMPOUND_ASSIGNMENT_OPERATORS.has(statement.expression.operator)) return false;
+	const mutationTarget = stripParenExpression(statement.expression.left);
+	if (!isNodeOfType(mutationTarget, "MemberExpression")) return false;
+	if (getStaticPropertyName(mutationTarget) === null) return false;
+	const receiver = stripParenExpression(mutationTarget.object);
+	return isNodeOfType(receiver, "Identifier") && parameterNames.has(receiver.name) && isNodeOfType(stripParenExpression(statement.expression.right), "Literal");
+};
+const isOrderIndependentFunction = (functionNode, scopes) => {
+	if (!isFunctionLike$2(functionNode)) return false;
+	const parameterNames = /* @__PURE__ */ new Set();
+	for (const parameter of functionNode.params) {
+		if (!isNodeOfType(parameter, "Identifier")) return false;
+		parameterNames.add(parameter.name);
+	}
+	if (!functionNode.async) {
+		if (!isNodeOfType(functionNode.body, "BlockStatement")) return isOrderIndependentPromiseResolveCall(functionNode.body, parameterNames, scopes);
+		if (functionNode.body.body.length !== 1) return false;
+		const [returnStatement] = functionNode.body.body;
+		return Boolean(isNodeOfType(returnStatement, "ReturnStatement") && returnStatement.argument && isOrderIndependentPromiseResolveCall(returnStatement.argument, parameterNames, scopes));
+	}
+	if (!isNodeOfType(functionNode.body, "BlockStatement")) return isPureParameterExpression(functionNode.body, parameterNames);
+	const statements = functionNode.body.body;
+	for (let statementIndex = 0; statementIndex < statements.length; statementIndex++) {
+		const statement = statements[statementIndex];
+		const isTerminalStatement = statementIndex === statements.length - 1;
+		if (isHarmlessPromiseResolveAwait(statement, parameterNames, scopes)) continue;
+		if (isNodeOfType(statement, "ExpressionStatement") && isPureParameterExpression(statement.expression, parameterNames)) continue;
+		if (isCommutativeParameterMutation(statement, parameterNames)) return isTerminalStatement;
+		if (!isNodeOfType(statement, "ReturnStatement") || !isTerminalStatement) return false;
+		return !statement.argument || isPureParameterExpression(statement.argument, parameterNames) || isOrderIndependentPromiseResolveCall(statement.argument, parameterNames, scopes);
+	}
+	return true;
+};
+const getObjectPropertyName = (property) => {
+	if (!isNodeOfType(property, "Property")) return null;
+	return getStaticPropertyKeyName(property, { allowComputedString: true });
+};
+const resolveOrderIndependentObjectPropertyFunction = (objectExpression, propertyName, callExpression, scopes, visitedSymbolIds) => {
+	const unwrappedObject = stripParenExpression(objectExpression);
+	if (isNodeOfType(unwrappedObject, "Identifier")) {
+		const symbol = scopes.symbolFor(unwrappedObject);
+		if (!symbol || symbol.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, callExpression, scopes) || hasPossibleStaticPropertyMutationOrEscape(unwrappedObject, propertyName, scopes)) return null;
+		visitedSymbolIds.add(symbol.id);
+		return resolveOrderIndependentObjectPropertyFunction(symbol.initializer, propertyName, callExpression, scopes, visitedSymbolIds);
+	}
+	if (!isNodeOfType(unwrappedObject, "ObjectExpression")) return null;
+	let matchingProperty = null;
+	for (const property of unwrappedObject.properties) {
+		if (!isNodeOfType(property, "Property")) return null;
+		if (property.kind !== "init") return null;
+		const candidatePropertyName = getObjectPropertyName(property);
+		if (candidatePropertyName === null) return null;
+		if (candidatePropertyName === propertyName) matchingProperty = property;
+	}
+	if (!matchingProperty || !isNodeOfType(matchingProperty, "Property")) return null;
+	const propertyValue = stripParenExpression(matchingProperty.value);
+	if (isFunctionLike$2(propertyValue)) return isOrderIndependentFunction(propertyValue, scopes) ? propertyValue : null;
+	return resolveOrderIndependentLocalFunction(propertyValue, callExpression, scopes, visitedSymbolIds);
+};
+const resolveOrderIndependentLocalFunction = (callee, callExpression, scopes, visitedSymbolIds) => {
+	const unwrappedCallee = stripParenExpression(callee);
+	if (isNodeOfType(unwrappedCallee, "MemberExpression")) {
+		const propertyName = getStaticPropertyName(unwrappedCallee);
+		if (propertyName === null) return null;
+		return resolveOrderIndependentObjectPropertyFunction(stripParenExpression(unwrappedCallee.object), propertyName, callExpression, scopes, visitedSymbolIds);
+	}
+	if (!isNodeOfType(unwrappedCallee, "Identifier")) return null;
+	const symbol = scopes.symbolFor(unwrappedCallee);
+	if (!symbol || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, callExpression, scopes)) return null;
+	visitedSymbolIds.add(symbol.id);
+	if (!symbol.initializer) return null;
+	const initializer = stripParenExpression(symbol.initializer);
+	const destructuredPropertyName = getDestructuredBindingPropertyName(symbol.bindingIdentifier);
+	if (destructuredPropertyName !== null) return resolveOrderIndependentObjectPropertyFunction(initializer, destructuredPropertyName, callExpression, scopes, visitedSymbolIds);
+	if (isFunctionLike$2(initializer)) return isOrderIndependentFunction(initializer, scopes) ? initializer : null;
+	if (symbol.kind !== "const") return null;
+	return resolveOrderIndependentLocalFunction(initializer, callExpression, scopes, visitedSymbolIds);
+};
+const getOrderIndependentLocalFunction = (callExpression, scopes) => {
+	const unwrappedCall = stripParenExpression(callExpression);
+	if (!isNodeOfType(unwrappedCall, "CallExpression")) return null;
+	if (hasPossibleStaticMemberCallWrite(unwrappedCall, scopes)) return null;
+	return resolveOrderIndependentLocalFunction(unwrappedCall.callee, unwrappedCall, scopes, /* @__PURE__ */ new Set());
+};
+//#endregion
 //#region src/plugin/utils/is-inline-function-expression.ts
 /**
 * Type-guard for the two "inline function expression" ESTree forms:
@@ -4347,13 +4766,15 @@ const isIntentionalSequencingCallee = (callee) => {
 	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return INTENTIONAL_SEQUENCING_CALLEE_NAMES.has(callee.property.name);
 	return false;
 };
-const isAwaitingSleepLikeCall = (awaitNode) => {
+const isAwaitingSleepLikeCall = (awaitNode, context) => {
 	if (!isNodeOfType(awaitNode, "AwaitExpression")) return false;
 	const argument = awaitNode.argument;
 	if (!argument) return false;
 	if (!isNodeOfType(argument, "CallExpression")) return false;
+	if (getOrderIndependentLocalFunction(argument, context.scopes) !== null) return false;
 	return isIntentionalSequencingCallee(argument.callee);
 };
+const isAwaitingPossiblyMutatedMemberCall = (awaitNode, context) => isNodeOfType(awaitNode, "AwaitExpression") && Boolean(awaitNode.argument) && hasPossibleStaticMemberCallWrite(awaitNode.argument, context.scopes);
 const PROMISE_CONCURRENCY_METHODS = new Set([
 	"all",
 	"allSettled",
@@ -4396,7 +4817,7 @@ const isAwaitingManualPromiseWait = (awaitNode) => {
 	});
 	return isWaitLike;
 };
-const isIntentionallySequentialAwait = (awaitNode) => isAwaitingSleepLikeCall(awaitNode) || isAwaitingPromiseConcurrencyCall(awaitNode) || isAwaitingManualPromiseWait(awaitNode);
+const isIntentionallySequentialAwait = (awaitNode, context) => isAwaitingPossiblyMutatedMemberCall(awaitNode, context) || isAwaitingSleepLikeCall(awaitNode, context) || isAwaitingPromiseConcurrencyCall(awaitNode) || isAwaitingManualPromiseWait(awaitNode);
 const collectPatternIdentifiers = (pattern, target) => {
 	if (isNodeOfType(pattern, "Identifier")) target.add(pattern.name);
 	else if (isNodeOfType(pattern, "ObjectPattern")) {
@@ -4587,12 +5008,12 @@ const getLoopLabelName = (loopNode) => {
 	if (isNodeOfType(parent, "LabeledStatement") && isNodeOfType(parent.label, "Identifier")) return parent.label.name;
 	return null;
 };
-const loopBodyHasIntentionallySequentialAwait = (block) => {
+const loopBodyHasIntentionallySequentialAwait = (block, context) => {
 	let foundIntentional = false;
 	walkAst(block, (child) => {
 		if (foundIntentional) return false;
 		if (isInlineFunctionExpression(child) || isNodeOfType(child, "FunctionDeclaration")) return false;
-		if (isNodeOfType(child, "AwaitExpression") && isIntentionallySequentialAwait(child)) {
+		if (isNodeOfType(child, "AwaitExpression") && isIntentionallySequentialAwait(child, context)) {
 			foundIntentional = true;
 			return false;
 		}
@@ -4697,7 +5118,7 @@ const asyncAwaitInLoop = defineRule({
 		const inspectLoop = (loopNode, label) => {
 			const loopBody = loopNode.body;
 			if (!loopBody) return;
-			if (loopBodyHasIntentionallySequentialAwait(loopBody)) return;
+			if (loopBodyHasIntentionallySequentialAwait(loopBody, context)) return;
 			if ((isNodeOfType(loopNode, "WhileStatement") || isNodeOfType(loopNode, "DoWhileStatement")) && isLoopTestDependentOnBodyState(loopNode.test, loopBody)) return;
 			if (hasLoopCarriedDependency(loopBody)) return;
 			if (loopBodyHasAwaitDependentEarlyExit(loopBody, getLoopLabelName(loopNode))) return;
@@ -4957,7 +5378,7 @@ const guardConsequentPerformsSideEffects = (consequent) => {
 	});
 	return performsSideEffects;
 };
-const findEnclosingFunction$1 = (node) => {
+const findEnclosingFunction = (node) => {
 	let ancestor = node.parent;
 	while (ancestor) {
 		if (isFunctionLike$2(ancestor)) return ancestor;
@@ -4970,7 +5391,7 @@ const guardTestReadsReassignedLocal = (test, guardStatement) => {
 	const testIdentifierNames = /* @__PURE__ */ new Set();
 	collectReferenceIdentifierNames(test, testIdentifierNames);
 	if (testIdentifierNames.size === 0) return false;
-	const enclosingFunction = findEnclosingFunction$1(guardStatement);
+	const enclosingFunction = findEnclosingFunction(guardStatement);
 	if (!enclosingFunction || !isFunctionLike$2(enclosingFunction) || !enclosingFunction.body) return false;
 	let readsReassignedLocal = false;
 	walkAst(enclosingFunction.body, (child) => {
@@ -5141,19 +5562,36 @@ const isIntentionalSequencingAwait = (awaitedCall) => {
 	return getCalleeIdentifierTrail(awaitedCall).some((name) => INTENTIONAL_SEQUENCING_CALLEE_NAMES.has(name));
 };
 const isBareExpressionAwait = (statement) => isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "AwaitExpression");
+const hasOrderIndependentBareAwaitArguments = (callExpression) => {
+	const unwrappedCallExpression = stripParenExpression(callExpression);
+	if (!isNodeOfType(unwrappedCallExpression, "CallExpression")) return false;
+	return unwrappedCallExpression.arguments.every((argument) => {
+		if (isNodeOfType(argument, "SpreadElement")) return false;
+		const unwrappedArgument = stripParenExpression(argument);
+		return isNodeOfType(unwrappedArgument, "Identifier") || isNodeOfType(unwrappedArgument, "Literal");
+	});
+};
 const isNonCallAwait = (statement) => {
 	const awaitedExpression = getAwaitedCall(statement);
 	if (!awaitedExpression) return false;
 	const stripped = stripParenExpression(awaitedExpression);
 	return !isNodeOfType(stripped, "CallExpression") && !isNodeOfType(stripped, "NewExpression") && !isNodeOfType(stripped, "ImportExpression");
 };
-const sequenceContainsSerializationSignal = (statements) => {
+const sequenceContainsSerializationSignal = (statements, context) => {
+	let bareAwaitFunction = null;
 	for (const statement of statements) {
-		if (isBareExpressionAwait(statement)) return true;
 		if (isNonCallAwait(statement)) return true;
 		const awaitedCall = getAwaitedCall(statement);
+		if (awaitedCall && hasPossibleStaticMemberCallWrite(awaitedCall, context.scopes)) return true;
+		const orderIndependentFunction = awaitedCall ? getOrderIndependentLocalFunction(awaitedCall, context.scopes) : null;
+		if (isBareExpressionAwait(statement)) {
+			if (orderIndependentFunction === null) return true;
+			if (!awaitedCall || !hasOrderIndependentBareAwaitArguments(awaitedCall)) return true;
+			if (bareAwaitFunction !== null && bareAwaitFunction !== orderIndependentFunction) return true;
+			bareAwaitFunction = orderIndependentFunction;
+		}
 		if (isOrderedUiFlowAwait(awaitedCall)) return true;
-		if (isIntentionalSequencingAwait(awaitedCall)) return true;
+		if (isIntentionalSequencingAwait(awaitedCall) && orderIndependentFunction === null) return true;
 	}
 	return false;
 };
@@ -5211,7 +5649,7 @@ const asyncParallel = defineRule({
 				const consecutiveAwaitStatements = [];
 				const flushConsecutiveAwaits = () => {
 					if (consecutiveAwaitStatements.length >= 3) {
-						if (!sequenceContainsSerializationSignal(consecutiveAwaitStatements)) reportIfIndependent(consecutiveAwaitStatements, context);
+						if (!sequenceContainsSerializationSignal(consecutiveAwaitStatements, context)) reportIfIndependent(consecutiveAwaitStatements, context);
 					}
 					consecutiveAwaitStatements.length = 0;
 				};
@@ -5224,7 +5662,7 @@ const asyncParallel = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/security/auth-token-in-web-storage.ts
-const MESSAGE$59 = "Storing an auth token in `localStorage`/`sessionStorage` exposes it to any XSS on the page: JavaScript can read web storage and exfiltrate the token. Keep tokens in an `HttpOnly`, `Secure`, `SameSite` cookie instead.";
+const MESSAGE$60 = "Storing an auth token in `localStorage`/`sessionStorage` exposes it to any XSS on the page: JavaScript can read web storage and exfiltrate the token. Keep tokens in an `HttpOnly`, `Secure`, `SameSite` cookie instead.";
 const STORAGE_NAMES = new Set(["localStorage", "sessionStorage"]);
 const STORAGE_GLOBALS = new Set([
 	"window",
@@ -5289,7 +5727,7 @@ const authTokenInWebStorage = defineRule({
 			if (keyString === null || !isAuthCredentialKey(keyString)) return;
 			context.report({
 				node,
-				message: MESSAGE$59
+				message: MESSAGE$60
 			});
 		},
 		AssignmentExpression(node) {
@@ -5300,7 +5738,7 @@ const authTokenInWebStorage = defineRule({
 			if (!propertyName || !isAuthCredentialKey(propertyName)) return;
 			context.report({
 				node: target,
-				message: MESSAGE$59
+				message: MESSAGE$60
 			});
 		}
 	}))
@@ -5439,7 +5877,7 @@ const CI_INSTALL_NEAR_SECRET_PATTERN = /(?:npm|pnpm|yarn|bun)\s+(?:install|ci)\b
 const INSTALL_COMMAND_PATTERN = /(?:npm|pnpm|yarn|bun)\s+(?:install|ci)\b/i;
 const SECRET_REFERENCE_PATTERN = /\bsecrets\.[A-Z0-9_]+/;
 const IGNORE_SCRIPTS_FLAG_PATTERN = /--ignore-scripts\b/;
-const MESSAGE$58 = "The build or install pipeline can execute package lifecycle code while CI secrets may be present.";
+const MESSAGE$59 = "The build or install pipeline can execute package lifecycle code while CI secrets may be present.";
 const isWorkflowPath = (relativePath) => /(?:^|\/)\.github\/workflows\/[^/]+\.ya?ml$/i.test(relativePath);
 const scanWorkflowContent = (content) => {
 	const lines = content.split("\n");
@@ -5484,7 +5922,7 @@ const scanWorkflowContent = (content) => {
 		const installLineOffset = Math.max(step.lines.findIndex((stepLine) => INSTALL_COMMAND_PATTERN.test(stepLine)), 0);
 		const installColumnIndex = step.lines[installLineOffset].search(INSTALL_COMMAND_PATTERN);
 		return [{
-			message: MESSAGE$58,
+			message: MESSAGE$59,
 			line: step.startLineIndex + installLineOffset + 1,
 			column: (installColumnIndex === -1 ? 0 : installColumnIndex) + 1
 		}];
@@ -5494,7 +5932,7 @@ const scanWorkflowContent = (content) => {
 const scanNonWorkflowConfig = scanByPattern({
 	shouldScan: (file) => isConfigOrCiPath(file.relativePath) && !file.relativePath.endsWith("package.json") && !isWorkflowPath(file.relativePath),
 	pattern: CI_INSTALL_NEAR_SECRET_PATTERN,
-	message: MESSAGE$58
+	message: MESSAGE$59
 });
 const scan = (file) => {
 	if (isWorkflowPath(file.relativePath)) return scanWorkflowContent(file.content);
@@ -5989,21 +6427,6 @@ const checkedRequiresOnchangeOrReadonly = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/get-static-property-key-name.ts
-const getStaticPropertyKeyName = (node, options = {}) => {
-	if (!isNodeOfType(node, "Property") && !isNodeOfType(node, "MethodDefinition")) return null;
-	if (node.computed) {
-		if (options.allowComputedString && isNodeOfType(node.key, "Literal") && typeof node.key.value === "string") return node.key.value;
-		return null;
-	}
-	if (isNodeOfType(node.key, "Identifier")) return node.key.name;
-	if (isNodeOfType(node.key, "Literal")) {
-		if (typeof node.key.value === "string") return node.key.value;
-		if (options.stringifyNonStringLiterals) return String(node.key.value);
-	}
-	return null;
-};
-//#endregion
 //#region src/plugin/utils/are-expressions-structurally-equal.ts
 const areExpressionsStructurallyEqual = (a, b) => {
 	if (!a || !b) return a === b;
@@ -6261,7 +6684,7 @@ const isPureEventBlockerHandler = (attribute) => {
 };
 //#endregion
 //#region src/plugin/rules/a11y/click-events-have-key-events.ts
-const MESSAGE$57 = "Keyboard users can't trigger this click handler because there's no keyboard one, so add `onKeyUp`, `onKeyDown`, or `onKeyPress`.";
+const MESSAGE$58 = "Keyboard users can't trigger this click handler because there's no keyboard one, so add `onKeyUp`, `onKeyDown`, or `onKeyPress`.";
 const KEY_HANDLERS = [
 	"onKeyUp",
 	"onKeyDown",
@@ -6472,7 +6895,7 @@ const clickEventsHaveKeyEvents = defineRule({
 			if (KEY_HANDLERS.some((handler) => hasJsxPropIgnoreCase(node.attributes, handler) || spreadEventValues.has(handler.toLowerCase()))) return;
 			context.report({
 				node: node.name,
-				message: MESSAGE$57
+				message: MESSAGE$58
 			});
 		} };
 	}
@@ -6687,15 +7110,6 @@ const getDirectConstInitializer = (symbol) => {
 	return symbol.initializer;
 };
 //#endregion
-//#region src/plugin/utils/get-static-property-name.ts
-const getStaticPropertyName = (memberExpression) => {
-	const property = memberExpression.property;
-	if (!memberExpression.computed && isNodeOfType(property, "Identifier")) return property.name;
-	if (memberExpression.computed && isNodeOfType(property, "Literal")) return typeof property.value === "string" ? property.value : null;
-	if (memberExpression.computed && isNodeOfType(property, "TemplateLiteral") && property.expressions.length === 0) return property.quasis[0]?.value.cooked ?? property.quasis[0]?.value.raw ?? null;
-	return null;
-};
-//#endregion
 //#region src/plugin/utils/get-range-start.ts
 const getRangeStart = (node) => {
 	const rangeStart = node.range?.[0];
@@ -7091,16 +7505,6 @@ const collectFunctionReturnStatements = (functionNode) => {
 	return returnStatements;
 };
 //#endregion
-//#region src/plugin/utils/find-enclosing-function.ts
-const findEnclosingFunction = (node) => {
-	let cursor = node.parent;
-	while (cursor) {
-		if (isFunctionLike$2(cursor)) return cursor;
-		cursor = cursor.parent ?? null;
-	}
-	return null;
-};
-//#endregion
 //#region src/plugin/utils/statement-always-exits.ts
 const statementAlwaysExits = (statement) => {
 	if (isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement")) return true;
@@ -7146,8 +7550,8 @@ const applyDefinitions = (incomingDefinitions, definitions) => {
 const collectPossibleAssignedExpressions = (symbol, referenceNode, controlFlow) => {
 	if (!REASSIGNABLE_BINDING_KINDS.has(symbol.kind)) return symbol.initializer ? [symbol.initializer] : [];
 	if (!controlFlow) return [];
-	const referenceFunction = findEnclosingFunction(referenceNode);
-	if (findEnclosingFunction(symbol.bindingIdentifier) !== referenceFunction) return [];
+	const referenceFunction = findEnclosingFunction$1(referenceNode);
+	if (findEnclosingFunction$1(symbol.bindingIdentifier) !== referenceFunction) return [];
 	if (!referenceFunction) return [];
 	const functionControlFlow = controlFlow.cfgFor(referenceFunction);
 	if (!functionControlFlow) return [];
@@ -7171,7 +7575,7 @@ const collectPossibleAssignedExpressions = (symbol, referenceNode, controlFlow)
 	if (symbol.initializer) addDefinition(symbol.initializer, symbol.bindingIdentifier, bindingPosition);
 	for (const reference of symbol.references) {
 		const writePosition = getRangeStart(reference.identifier);
-		if (reference.flag === "read" || findEnclosingFunction(reference.identifier) !== referenceFunction || writePosition === null || writePosition >= referencePosition) continue;
+		if (reference.flag === "read" || findEnclosingFunction$1(reference.identifier) !== referenceFunction || writePosition === null || writePosition >= referencePosition) continue;
 		const assignedExpression = getAssignedExpressionForWrite(reference.identifier);
 		if (!assignedExpression) continue;
 		addDefinition(assignedExpression, reference.identifier, writePosition);
@@ -8725,7 +9129,7 @@ const getClassNameLiteral = (classAttribute) => {
 };
 //#endregion
 //#region src/plugin/rules/a11y/control-has-associated-label.ts
-const MESSAGE$56 = "Blind users can't tell what this control does because screen readers find no label, so add visible text, `aria-label`, or `aria-labelledby`.";
+const MESSAGE$57 = "Blind users can't tell what this control does because screen readers find no label, so add visible text, `aria-label`, or `aria-labelledby`.";
 const NON_OPERABLE_ELEMENTS = new Set([
 	"td",
 	"th",
@@ -8843,6 +9247,7 @@ const HTML_FOR_ATTRIBUTE = "htmlFor";
 const LABEL_ELEMENT = "label";
 const LABEL_COMPONENT_NAME = "Label";
 const POLYMORPHIC_COMPONENT_PROP = "component";
+const TITLE_ATTRIBUTE = "title";
 const WRAPPER_LABEL_PROP = "label";
 const SELECT_ELEMENT = "select";
 const DEFAULT_DEPTH = 5;
@@ -8888,6 +9293,96 @@ const hasNonEmptyPropValue = (attribute) => {
 	}
 	return true;
 };
+const getLastJsxPropIgnoreCase = (attributes, targetProp) => {
+	const targetPropLower = targetProp.toLowerCase();
+	for (let attributeIndex = attributes.length - 1; attributeIndex >= 0; attributeIndex -= 1) {
+		const attribute = attributes[attributeIndex];
+		if (!attribute || !isNodeOfType(attribute, "JSXAttribute")) continue;
+		if (getJsxAttributeName(attribute.name)?.toLowerCase() === targetPropLower) return attribute;
+	}
+};
+const getStaticNativeTitleArrayValue = (expression, scopes) => {
+	const elementValues = [];
+	for (const rawElement of expression.elements) {
+		if (rawElement === null) {
+			elementValues.push("");
+			continue;
+		}
+		if (isNodeOfType(rawElement, "SpreadElement")) return null;
+		const element = stripParenExpression(rawElement);
+		if (isNodeOfType(element, "Literal")) {
+			elementValues.push(element.value === null ? "" : String(element.value));
+			continue;
+		}
+		if (isNodeOfType(element, "TemplateLiteral")) {
+			const staticValue = getStaticTemplateLiteralValue(element);
+			if (staticValue === null) return null;
+			elementValues.push(staticValue);
+			continue;
+		}
+		if (isNodeOfType(element, "Identifier") && element.name === "undefined" && scopes.isGlobalReference(element) || isNodeOfType(element, "UnaryExpression") && element.operator === "void") {
+			elementValues.push("");
+			continue;
+		}
+		if (isNodeOfType(element, "ArrayExpression")) {
+			const nestedValue = getStaticNativeTitleArrayValue(element, scopes);
+			if (nestedValue === null) return null;
+			elementValues.push(nestedValue);
+			continue;
+		}
+		return null;
+	}
+	return elementValues.join(",");
+};
+const isGlobalSymbolExpression = (expression, scopes) => {
+	if (isNodeOfType(expression, "Identifier")) return expression.name === "Symbol" && scopes.isGlobalReference(expression);
+	if (!isNodeOfType(expression, "MemberExpression")) return false;
+	const object = stripParenExpression(expression.object);
+	return isNodeOfType(object, "Identifier") && object.name === "Symbol" && scopes.isGlobalReference(object);
+};
+const hasNonEmptyNativeTitleExpression = (rawExpression, scopes) => {
+	const expression = stripParenExpression(rawExpression);
+	if (isNodeOfType(expression, "Literal")) {
+		if (typeof expression.value === "string") return expression.value.trim().length > 0;
+		return expression.value !== null && typeof expression.value !== "boolean";
+	}
+	if (isNodeOfType(expression, "TemplateLiteral")) {
+		const staticValue = getStaticTemplateLiteralValue(expression);
+		return staticValue === null || staticValue.trim().length > 0;
+	}
+	if (isNodeOfType(expression, "Identifier")) return expression.name !== "undefined" || !scopes.isGlobalReference(expression);
+	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") return false;
+	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "!") return false;
+	if (isNodeOfType(expression, "ArrowFunctionExpression")) return false;
+	if (isNodeOfType(expression, "FunctionExpression")) return false;
+	if (isNodeOfType(expression, "ClassExpression")) return false;
+	if (isNodeOfType(expression, "ArrayExpression")) {
+		const staticValue = getStaticNativeTitleArrayValue(expression, scopes);
+		return staticValue === null || staticValue.trim().length > 0;
+	}
+	if (isGlobalSymbolExpression(expression, scopes)) return false;
+	if (isNodeOfType(expression, "CallExpression") && isGlobalSymbolExpression(expression.callee, scopes)) return false;
+	if (isNodeOfType(expression, "ConditionalExpression")) return hasNonEmptyNativeTitleExpression(expression.consequent, scopes) && hasNonEmptyNativeTitleExpression(expression.alternate, scopes);
+	if (isNodeOfType(expression, "SequenceExpression")) {
+		const finalExpression = expression.expressions.at(-1);
+		return finalExpression ? hasNonEmptyNativeTitleExpression(finalExpression, scopes) : false;
+	}
+	if (isNodeOfType(expression, "LogicalExpression")) {
+		const leftExpression = stripParenExpression(expression.left);
+		if (!isNodeOfType(leftExpression, "Literal")) return expression.operator !== "&&";
+		if (expression.operator === "??") return hasNonEmptyNativeTitleExpression(leftExpression.value === null ? expression.right : leftExpression, scopes);
+		const leftValueIsTruthy = Boolean(leftExpression.value);
+		if (expression.operator === "&&") return hasNonEmptyNativeTitleExpression(leftValueIsTruthy ? expression.right : leftExpression, scopes);
+		return hasNonEmptyNativeTitleExpression(leftValueIsTruthy ? leftExpression : expression.right, scopes);
+	}
+	return true;
+};
+const hasNonEmptyNativeTitle = (attribute, scopes) => {
+	if (!attribute?.value) return false;
+	if (isNodeOfType(attribute.value, "Literal")) return typeof attribute.value.value === "string" && attribute.value.value.trim().length > 0;
+	if (isNodeOfType(attribute.value, "JSXExpressionContainer")) return hasNonEmptyNativeTitleExpression(attribute.value.expression, scopes);
+	return true;
+};
 const toAttributeMatchKey = (kind, value) => {
 	const trimmedValue = value.trim();
 	return trimmedValue.length > 0 ? `${kind}:${trimmedValue}` : null;
@@ -9144,6 +9639,7 @@ const controlHasAssociatedLabel = defineRule({
 					if (typeValue === "submit" || typeValue === "reset") return;
 					if (typeValue === "button" && hasNonEmptyPropValue(hasJsxPropIgnoreCase(opening.attributes, "value"))) return;
 				}
+				if (isDomElement && hasNonEmptyNativeTitle(getLastJsxPropIgnoreCase(opening.attributes, TITLE_ATTRIBUTE), context.scopes)) return;
 				if (supportsPlaceholderNameFallback(tagName, opening) && hasNonEmptyPropValue(hasJsxPropIgnoreCase(opening.attributes, "placeholder"))) return;
 				if (hasLabellingProp(opening.attributes, settings.labelAttributes)) return;
 				if (isInsideJsxAttribute(node)) return;
@@ -9163,7 +9659,7 @@ const controlHasAssociatedLabel = defineRule({
 					if (candidate.enclosingBindingName !== null && labelEmbeddedNames.has(candidate.enclosingBindingName)) continue;
 					context.report({
 						node: candidate.opening,
-						message: MESSAGE$56
+						message: MESSAGE$57
 					});
 				}
 			}
@@ -9924,7 +10420,7 @@ const noVagueButtonLabel = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/dialog-has-accessible-name.ts
-const MESSAGE$55 = "This dialog has no accessible name, so screen readers announce it as just “dialog.” Add `aria-label` or point `aria-labelledby` at its heading.";
+const MESSAGE$56 = "This dialog has no accessible name, so screen readers announce it as just “dialog.” Add `aria-label` or point `aria-labelledby` at its heading.";
 const DIALOG_ROLES = new Set(["dialog", "alertdialog"]);
 const NAME_PROVIDING_ATTRIBUTES = [
 	"aria-label",
@@ -9949,7 +10445,7 @@ const dialogHasAccessibleName = defineRule({
 			if (NAME_PROVIDING_ATTRIBUTES.some((attribute) => hasJsxPropIgnoreCase(node.attributes, attribute))) return;
 			context.report({
 				node: node.name,
-				message: MESSAGE$55
+				message: MESSAGE$56
 			});
 		} };
 	}
@@ -9989,7 +10485,7 @@ const isEs6Component = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/display-name.ts
-const MESSAGE$54 = "This component shows up as Anonymous in React DevTools because it has no `displayName`.";
+const MESSAGE$55 = "This component shows up as Anonymous in React DevTools because it has no `displayName`.";
 const DEFAULT_ADDITIONAL_HOCS = [
 	"observer",
 	"lazy",
@@ -10182,7 +10678,7 @@ const displayName = defineRule({
 		const reportAt = (node) => {
 			context.report({
 				node,
-				message: MESSAGE$54
+				message: MESSAGE$55
 			});
 		};
 		return {
@@ -11003,6 +11499,14 @@ const PROMISE_CHAIN_METHOD_NAMES$1 = new Set([
 	"catch",
 	"finally"
 ]);
+const isPromiseChainCall = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && PROMISE_CHAIN_METHOD_NAMES$1.has(callee.property.name) && isNodeOfType(stripParenExpression(callee.object), "CallExpression");
+const getPromiseChainCallForCallback = (candidate) => {
+	let callbackContainer = candidate.parent;
+	while (callbackContainer && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(callbackContainer.type)) callbackContainer = callbackContainer.parent;
+	if (!isNodeOfType(callbackContainer, "CallExpression")) return null;
+	if (!callbackContainer.arguments?.some((argument) => stripParenExpression(argument) === candidate)) return null;
+	return isPromiseChainCall(stripParenExpression(callbackContainer.callee)) ? callbackContainer : null;
+};
 const collectEffectInvokedFunctions = (effectCallback) => {
 	const invokedFunctions = new Set([effectCallback]);
 	const localFunctionBindings = /* @__PURE__ */ new Map();
@@ -11014,7 +11518,6 @@ const collectEffectInvokedFunctions = (effectCallback) => {
 		invokedFunctions.add(strippedCandidate);
 		pendingFunctions.push(strippedCandidate);
 	};
-	const isPromiseChainCall = (callee) => isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && PROMISE_CHAIN_METHOD_NAMES$1.has(callee.property.name) && isNodeOfType(stripParenExpression(callee.object), "CallExpression");
 	while (pendingFunctions.length > 0) {
 		const currentFunction = pendingFunctions.pop();
 		if (!currentFunction) break;
@@ -11086,7 +11589,7 @@ const componentOrHookDisplayNameForFunction = (functionNode) => {
 //#endregion
 //#region src/plugin/utils/enclosing-component-or-hook-name.ts
 const enclosingComponentOrHookName = (node) => {
-	const functionNode = findEnclosingFunction(node);
+	const functionNode = findEnclosingFunction$1(node);
 	return functionNode ? componentOrHookDisplayNameForFunction(functionNode) : null;
 };
 //#endregion
@@ -11143,11 +11646,11 @@ const executesDuringRender = (functionNode, scopes) => {
 //#endregion
 //#region src/plugin/utils/find-render-phase-component-or-hook.ts
 const findRenderPhaseComponentOrHook = (node, scopes) => {
-	let functionNode = findEnclosingFunction(node);
+	let functionNode = findEnclosingFunction$1(node);
 	while (functionNode) {
 		if (componentOrHookDisplayNameForFunction(functionNode)) return functionNode;
 		if (!executesDuringRender(functionNode, scopes)) return null;
-		functionNode = findEnclosingFunction(functionNode);
+		functionNode = findEnclosingFunction$1(functionNode);
 	}
 	return null;
 };
@@ -11222,6 +11725,50 @@ const isCleanupReturningSubscribeLikeCallExpression = (node) => {
 	return true;
 };
 //#endregion
+//#region src/plugin/utils/is-node-reachable-within-function.ts
+const isInsideStaticallyUnreachableBranch = (node) => {
+	let child = node;
+	let parent = node.parent;
+	while (parent) {
+		if (isNodeOfType(parent, "IfStatement") && isNodeOfType(parent.test, "Literal")) {
+			if (parent.test.value === false && parent.consequent === child) return true;
+			if (parent.test.value === true && parent.alternate === child) return true;
+		}
+		if (isNodeOfType(parent, "ConditionalExpression") && isNodeOfType(parent.test, "Literal")) {
+			if (parent.test.value === false && parent.consequent === child) return true;
+			if (parent.test.value === true && parent.alternate === child) return true;
+		}
+		if (isNodeOfType(parent, "LogicalExpression") && parent.right === child) {
+			if (isNodeOfType(parent.left, "Literal") && (parent.operator === "&&" && !parent.left.value || parent.operator === "||" && Boolean(parent.left.value))) return true;
+		}
+		child = parent;
+		parent = parent.parent;
+	}
+	return false;
+};
+const isNodeReachableWithinFunction = (node, context) => {
+	if (isInsideStaticallyUnreachableBranch(node)) return false;
+	const owner = context.cfg.enclosingFunction(node);
+	if (!owner) return true;
+	const functionCfg = context.cfg.cfgFor(owner);
+	if (!functionCfg) return true;
+	const targetBlock = functionCfg.blockOf(node);
+	if (!targetBlock) return true;
+	const visitedBlocks = new Set([functionCfg.entry]);
+	const pendingBlocks = [functionCfg.entry];
+	while (pendingBlocks.length > 0) {
+		const currentBlock = pendingBlocks.pop();
+		if (!currentBlock) break;
+		if (currentBlock === targetBlock) return true;
+		for (const edge of currentBlock.successors) {
+			if (visitedBlocks.has(edge.to)) continue;
+			visitedBlocks.add(edge.to);
+			pendingBlocks.push(edge.to);
+		}
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/effect-needs-cleanup.ts
 const OBSERVER_REGISTRATION_METHOD_NAME = "observe";
 const CLEANUP_EFFECT_HOOK_NAMES = new Set([...EFFECT_HOOK_NAMES$1, "useInsertionEffect"]);
@@ -11350,36 +11897,15 @@ const findSubscribeLikeUsages = (callback, context) => {
 	});
 	return usages.filter((usage) => isNodeReachableWithinFunction(usage.node, context));
 };
-const isNodeReachableWithinFunction = (node, context) => {
-	const owner = context.cfg.enclosingFunction(node);
-	if (!owner) return true;
-	const functionCfg = context.cfg.cfgFor(owner);
-	if (!functionCfg) return true;
-	const targetBlock = functionCfg.blockOf(node);
-	if (!targetBlock) return true;
-	const visitedBlocks = new Set([functionCfg.entry]);
-	const pendingBlocks = [functionCfg.entry];
-	while (pendingBlocks.length > 0) {
-		const currentBlock = pendingBlocks.pop();
-		if (!currentBlock) break;
-		if (currentBlock === targetBlock) return true;
-		for (const edge of currentBlock.successors) {
-			if (visitedBlocks.has(edge.to)) continue;
-			visitedBlocks.add(edge.to);
-			pendingBlocks.push(edge.to);
-		}
-	}
-	return false;
-};
 const doMatchingNodesCoverEveryPathAfterUsage = (usageNode, matchingNodes, context) => {
 	let pathAnchor = usageNode;
-	let pathOwner = findEnclosingFunction(pathAnchor);
+	let pathOwner = findEnclosingFunction$1(pathAnchor);
 	while (pathOwner && isSynchronousIteratorCallback(pathOwner)) {
 		if (matchingNodes.length > 0 && matchingNodes.every((matchingNode) => context.cfg.enclosingFunction(matchingNode) === pathOwner)) break;
 		const iteratorCall = pathOwner.parent;
 		if (!isNodeOfType(iteratorCall, "CallExpression")) break;
 		pathAnchor = iteratorCall;
-		pathOwner = findEnclosingFunction(pathAnchor);
+		pathOwner = findEnclosingFunction$1(pathAnchor);
 	}
 	const owner = context.cfg.enclosingFunction(pathAnchor);
 	if (!owner) return false;
@@ -11608,7 +12134,7 @@ const findCollectionMappingCall = (callbackNode) => {
 	return callee.property.name === "map" && callNode.arguments?.[0] === callbackNode ? callNode : null;
 };
 const findMappedResourceCollectionKey = (resourceNode, context) => {
-	const callbackNode = findEnclosingFunction(resourceNode);
+	const callbackNode = findEnclosingFunction$1(resourceNode);
 	if (!callbackNode || !isNodeOfType(callbackNode, "ArrowFunctionExpression") && !isNodeOfType(callbackNode, "FunctionExpression")) return null;
 	const mappingCall = findCollectionMappingCall(callbackNode);
 	if (!mappingCall) return null;
@@ -11719,10 +12245,10 @@ const findSingleDirectInvocation = (functionNode, caller, context) => {
 	});
 	if (invocationCalls.length !== 1) return null;
 	const invocationCall = invocationCalls[0];
-	return findEnclosingFunction(invocationCall) === caller && isNodeReachableWithinFunction(invocationCall, context) ? invocationCall : null;
+	return findEnclosingFunction$1(invocationCall) === caller && isNodeReachableWithinFunction(invocationCall, context) ? invocationCall : null;
 };
 const resolveCleanupPathAnchor = (usageNode, effectCallback, context) => {
-	const usageFunction = findEnclosingFunction(usageNode);
+	const usageFunction = findEnclosingFunction$1(usageNode);
 	if (!usageFunction || usageFunction === effectCallback) return usageNode;
 	return findSingleDirectInvocation(usageFunction, effectCallback, context) ?? usageNode;
 };
@@ -11737,7 +12263,7 @@ const resolveSingleAssignedCleanupFunction = (expression, usage, context) => {
 	const assignmentReference = assignmentReferences[0];
 	const assignmentTarget = findTransparentExpressionRoot(assignmentReference.identifier);
 	const assignmentNode = assignmentTarget.parent;
-	if (!isNodeOfType(assignmentNode, "AssignmentExpression") || assignmentNode.operator !== "=" || assignmentNode.left !== assignmentTarget || findEnclosingFunction(assignmentNode) !== findEnclosingFunction(usage.node) || !doMatchingNodesCoverEveryPathAfterUsage(usage.node, [assignmentNode], context)) return null;
+	if (!isNodeOfType(assignmentNode, "AssignmentExpression") || assignmentNode.operator !== "=" || assignmentNode.left !== assignmentTarget || findEnclosingFunction$1(assignmentNode) !== findEnclosingFunction$1(usage.node) || !doMatchingNodesCoverEveryPathAfterUsage(usage.node, [assignmentNode], context)) return null;
 	const assignedValue = stripParenExpression(assignmentNode.right);
 	return isFunctionLike$2(assignedValue) ? assignedValue : null;
 };
@@ -11826,12 +12352,12 @@ const hasRerunReleaseBeforeUsage = (callback, usage, context) => {
 	return doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingReleaseAnchors, context);
 };
 const hasStableUnmountCleanupForUsage = (callback, usage, context) => {
-	const componentFunction = findEnclosingFunction(callback);
+	const componentFunction = findEnclosingFunction$1(callback);
 	if (!componentFunction || !isNodeOfType(componentFunction, "ArrowFunctionExpression") && !isNodeOfType(componentFunction, "FunctionExpression") && !isNodeOfType(componentFunction, "FunctionDeclaration")) return false;
 	let didFindUnmountCleanup = false;
 	walkAst(componentFunction.body, (child) => {
 		if (didFindUnmountCleanup) return false;
-		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction(child) !== componentFunction) return;
+		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction$1(child) !== componentFunction) return;
 		if (!isHookCall$2(child, CLEANUP_EFFECT_HOOK_NAMES)) return;
 		const dependencyList = child.arguments?.[1];
 		if (!isNodeOfType(dependencyList, "ArrayExpression") || dependencyList.elements.length > 0) return;
@@ -11844,10 +12370,98 @@ const hasStableUnmountCleanupForUsage = (callback, usage, context) => {
 	return didFindUnmountCleanup;
 };
 const hasSplitLifecycleCleanup = (callback, usage, context) => usage.handleKey !== null && hasRerunReleaseBeforeUsage(callback, usage, context) && hasStableUnmountCleanupForUsage(callback, usage, context);
+const collectBlockingBooleanStates = (expression, blockedExpressionValue, context) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return collectBlockingBooleanStates(unwrappedExpression.argument, !blockedExpressionValue, context);
+	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
+		if (!(unwrappedExpression.operator === "||" && blockedExpressionValue || unwrappedExpression.operator === "&&" && !blockedExpressionValue)) return [];
+		return [...collectBlockingBooleanStates(unwrappedExpression.left, blockedExpressionValue, context), ...collectBlockingBooleanStates(unwrappedExpression.right, blockedExpressionValue, context)];
+	}
+	if (isNodeOfType(unwrappedExpression, "BinaryExpression") && [
+		"===",
+		"==",
+		"!==",
+		"!="
+	].includes(unwrappedExpression.operator)) {
+		const leftValue = readStaticBoolean(unwrappedExpression.left);
+		const rightValue = readStaticBoolean(unwrappedExpression.right);
+		const booleanValue = leftValue ?? rightValue;
+		const comparedKey = resolveExpressionKey(leftValue === null ? unwrappedExpression.left : unwrappedExpression.right, context);
+		if (booleanValue === null || comparedKey === null) return [];
+		return [{
+			key: comparedKey,
+			value: (unwrappedExpression.operator === "===" || unwrappedExpression.operator === "==") === blockedExpressionValue ? booleanValue : !booleanValue
+		}];
+	}
+	const expressionKey = resolveExpressionKey(unwrappedExpression, context);
+	return expressionKey === null ? [] : [{
+		key: expressionKey,
+		value: blockedExpressionValue
+	}];
+};
+const isDirectEarlyReturnConsequent = (ifStatement) => {
+	if (!isNodeOfType(ifStatement, "IfStatement") || ifStatement.alternate) return false;
+	if (isNodeOfType(ifStatement.consequent, "ReturnStatement")) return true;
+	return isNodeOfType(ifStatement.consequent, "BlockStatement") && ifStatement.consequent.body.length === 1 && isNodeOfType(ifStatement.consequent.body[0], "ReturnStatement");
+};
+const collectDeferredUsageGuardStates = (callback, usageNode, context) => {
+	if (!isFunctionLike$2(callback) || callback.async) return [];
+	const guardStates = [];
+	walkAst(callback.body, (child) => {
+		if (child !== callback.body && isFunctionLike$2(child)) return false;
+		if (isNodeOfType(child, "IfStatement") && isDirectEarlyReturnConsequent(child) && doMatchingNodesCoverEveryPathBeforeUsage(usageNode, [child], callback, context)) guardStates.push(...collectBlockingBooleanStates(child.test, true, context));
+	});
+	let descendant = usageNode;
+	let ancestor = descendant.parent;
+	while (ancestor && ancestor !== callback) {
+		if (isNodeOfType(ancestor, "IfStatement") && ancestor.consequent === descendant) guardStates.push(...collectBlockingBooleanStates(ancestor.test, false, context));
+		descendant = ancestor;
+		ancestor = ancestor.parent;
+	}
+	return guardStates;
+};
+const cleanupReturnInvalidatesGuard = (cleanupReturn, guardState, context) => {
+	if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return false;
+	const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
+	if (!cleanupFunction || !isFunctionLike$2(cleanupFunction) || cleanupFunction.async) return false;
+	let didInvalidateGuard = false;
+	walkAst(cleanupFunction.body, (child) => {
+		if (didInvalidateGuard) return false;
+		if (child !== cleanupFunction.body && isFunctionLike$2(child)) return false;
+		if (isNodeOfType(child, "AssignmentExpression") && child.operator === "=" && resolveExpressionKey(child.left, context) === guardState.key && readStaticBoolean(child.right) === guardState.value && context.cfg.isUnconditionalFromEntry(child)) {
+			didInvalidateGuard = true;
+			return false;
+		}
+	});
+	return didInvalidateGuard;
+};
+const deferredUsageWritesGuardBeforeUsage = (callback, usageNode, guardState, context) => {
+	const usageStart = getRangeStart(usageNode);
+	if (!isFunctionLike$2(callback) || usageStart === null) return true;
+	let didWriteGuard = false;
+	walkAst(callback.body, (child) => {
+		if (didWriteGuard) return false;
+		if (child !== callback.body && isFunctionLike$2(child)) return false;
+		const childStart = getRangeStart(child);
+		if (childStart === null || childStart >= usageStart) return;
+		const writtenExpression = isNodeOfType(child, "AssignmentExpression") ? child.left : isNodeOfType(child, "UpdateExpression") ? child.argument : null;
+		if (writtenExpression && resolveExpressionKey(writtenExpression, context) === guardState.key) {
+			didWriteGuard = true;
+			return false;
+		}
+	});
+	return didWriteGuard;
+};
+const hasGuardedDeferredCleanup = (callback, usage, cleanupReturns, context) => {
+	const usageFunction = findEnclosingFunction$1(usage.node);
+	const promiseChainCall = usageFunction ? getPromiseChainCallForCallback(usageFunction) : null;
+	if (usage.handleKey === null || !usageFunction || usageFunction === callback || !promiseChainCall || !collectEffectInvokedFunctions(callback).has(usageFunction) || !doMatchingNodesCoverEveryPathAfterUsage(promiseChainCall, cleanupReturns, context)) return false;
+	return collectDeferredUsageGuardStates(usageFunction, usage.node, context).some((guardState) => !deferredUsageWritesGuardBeforeUsage(usageFunction, usage.node, guardState, context) && cleanupReturns.every((cleanupReturn) => cleanupReturnInvalidatesGuard(cleanupReturn, guardState, context)));
+};
 const effectHasCleanupForUsage = (callback, usage, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
 	if (callback.async) return false;
-	if (usage.kind === "subscribe" && findEnclosingFunction(usage.node) === callback && doesResourceResultEscape(usage.node, true) && isCleanupReturningSubscribeLikeCallExpression(usage.node)) return true;
+	if (usage.kind === "subscribe" && findEnclosingFunction$1(usage.node) === callback && doesResourceResultEscape(usage.node, true) && isCleanupReturningSubscribeLikeCallExpression(usage.node)) return true;
 	if (!isNodeOfType(callback.body, "BlockStatement")) return callback.body === usage.node && isCleanupReturningSubscribeLikeCallExpression(callback.body);
 	const matchingCleanupReturns = [];
 	walkInsideStatementBlocks(callback.body, (child) => {
@@ -11883,6 +12497,7 @@ const effectHasCleanupForUsage = (callback, usage, context) => {
 		if (!cleanupFunction || !isFunctionLike$2(cleanupFunction)) return;
 		if (doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context)) matchingCleanupReturns.push(child);
 	});
+	if (hasGuardedDeferredCleanup(callback, usage, matchingCleanupReturns, context)) return true;
 	return doMatchingNodesCoverEveryPathAfterUsage(resolveCleanupPathAnchor(usage.node, callback, context), matchingCleanupReturns, context);
 };
 const findFirstUsageWithoutCleanup = (callback, usages, context) => {
@@ -12015,7 +12630,7 @@ const isReturnedEffectCleanupFunction = (functionNode) => {
 		parentNode = currentNode.parent;
 	}
 	if (!isNodeOfType(parentNode, "ReturnStatement") || parentNode.argument !== currentNode) return false;
-	const effectCallback = findEnclosingFunction(parentNode);
+	const effectCallback = findEnclosingFunction$1(parentNode);
 	const effectCall = effectCallback?.parent;
 	return Boolean(effectCallback && isNodeOfType(effectCall, "CallExpression") && isHookCall$2(effectCall, CLEANUP_EFFECT_HOOK_NAMES));
 };
@@ -12025,13 +12640,13 @@ const isPotentiallyReachableFunction = (functionNode, context) => {
 	if (!bindingIdentifier) return false;
 	const symbol = context.scopes.symbolFor(bindingIdentifier);
 	if (!symbol) return false;
-	return symbol.references.some((reference) => findEnclosingFunction(reference.identifier) !== functionNode);
+	return symbol.references.some((reference) => findEnclosingFunction$1(reference.identifier) !== functionNode);
 };
 const isReleaseReachableForUsage = (releaseNode, usage, context) => {
 	if (!isNodeReachableWithinFunction(releaseNode, context)) return false;
-	const releaseFunction = findEnclosingFunction(releaseNode);
+	const releaseFunction = findEnclosingFunction$1(releaseNode);
 	if (!releaseFunction) return true;
-	if (releaseFunction === findEnclosingFunction(usage.node)) return true;
+	if (releaseFunction === findEnclosingFunction$1(usage.node)) return true;
 	return isPotentiallyReachableFunction(releaseFunction, context);
 };
 const fileContainsReleaseForUsage = (usage, context) => {
@@ -12214,10 +12829,10 @@ const cleanupFunctionReleasesRefOwnedUsage = (cleanupFunction, componentFunction
 		}
 		if (assignedKey !== storage.refCurrentKey) return;
 		const assignedValue = stripParenExpression(child.right);
-		if (isNodeOfType(assignedValue, "Literal") && assignedValue.value === null && findEnclosingFunction(child) === cleanupFunction) return;
+		if (isNodeOfType(assignedValue, "Literal") && assignedValue.value === null && findEnclosingFunction$1(child) === cleanupFunction) return;
 		const assignedSessionProperties = (isNodeOfType(assignedValue, "ObjectExpression") ? assignedValue : null)?.properties ?? [];
 		const storesMatchingHandler = assignedSessionProperties.every((property) => isNodeOfType(property, "Property")) && assignedSessionProperties.some((property) => isNodeOfType(property, "Property") && `${storage.refCurrentKey}.${getStaticPropertyKeyName(property) ?? ""}` === storage.handlerKey && resolveExpressionKey(property.value, context) === usage.handlerKey);
-		if (findEnclosingFunction(child) !== retainedFunction || !storesMatchingHandler) {
+		if (findEnclosingFunction$1(child) !== retainedFunction || !storesMatchingHandler) {
 			hasUnsafeRefWrite = true;
 			return false;
 		}
@@ -12238,12 +12853,12 @@ const effectReturnsRefOwnedCleanup = (effectCallback, componentFunction, retaine
 	return doMatchingNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
 };
 const hasGuaranteedRefOwnedUnmountCleanup = (retainedFunction, usage, context) => {
-	const componentFunction = findEnclosingFunction(retainedFunction);
+	const componentFunction = findEnclosingFunction$1(retainedFunction);
 	if (!componentFunction || !isFunctionLike$2(componentFunction)) return false;
 	let didFindCleanupEffect = false;
 	walkAst(componentFunction.body, (child) => {
 		if (didFindCleanupEffect) return false;
-		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction(child) !== componentFunction || !isReactApiCall(child, "useEffect", context.scopes)) return;
+		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction$1(child) !== componentFunction || !isReactApiCall(child, "useEffect", context.scopes)) return;
 		const effectStatement = findTransparentExpressionRoot(child).parent;
 		if (!isNodeOfType(effectStatement, "ExpressionStatement") || effectStatement.parent !== componentFunction.body) return;
 		const effectCallback = getEffectCallback(child);
@@ -13097,6 +13712,202 @@ const resolveExhaustiveDepsSettings = (settings) => {
 	};
 };
 //#endregion
+//#region src/plugin/utils/is-ast-descendant.ts
+/**
+* True when `inner` is `outer` itself or any descendant in the AST
+* `parent` chain. Walks `inner.parent` upward and stops at either a
+* match (`true`) or the chain's root (`false`).
+*
+* Was duplicated byte-identical in:
+* - exhaustive-deps-symbol-stability.ts
+* - semantic/closure-captures.ts
+*/
+const isAstDescendant = (inner, outer) => {
+	let current = inner;
+	while (current) {
+		if (current === outer) return true;
+		current = current.parent ?? null;
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/rules/react-builtins/exhaustive-deps-sole-writer-guard.ts
+const EQUALITY_BINARY_OPERATORS = new Set(["===", "!=="]);
+const getUseStateSetterSymbol = (stateSymbol, scopes) => {
+	const declaration = stateSymbol.declarationNode;
+	if (!isNodeOfType(declaration, "VariableDeclarator")) return null;
+	if (!isNodeOfType(declaration.id, "ArrayPattern")) return null;
+	const stateBinding = declaration.id.elements[0];
+	const setterBinding = declaration.id.elements[1];
+	if (stateBinding !== stateSymbol.bindingIdentifier || !isNodeOfType(setterBinding, "Identifier")) return null;
+	const initializer = declaration.init ? stripParenExpression(declaration.init) : null;
+	if (!initializer || !isReactApiCall(initializer, "useState", scopes, {
+		allowGlobalReactNamespace: true,
+		allowUnboundBareCalls: true,
+		resolveNamedAliases: true
+	})) return null;
+	return scopes.symbolFor(setterBinding);
+};
+const getDirectSetterCall = (setterSymbol, callback) => {
+	if (setterSymbol.references.length !== 1) return null;
+	const setterReference = setterSymbol.references[0];
+	if (setterReference.flag !== "read") return null;
+	const referenceRoot = findTransparentExpressionRoot(setterReference.identifier);
+	const callExpression = referenceRoot.parent;
+	if (!isNodeOfType(callExpression, "CallExpression") || callExpression.callee !== referenceRoot || callExpression.arguments.length !== 1 || findEnclosingFunction$1(callExpression) !== callback) return null;
+	const writtenValue = stripParenExpression(callExpression.arguments[0]);
+	if (isNodeOfType(writtenValue, "ArrowFunctionExpression") || isNodeOfType(writtenValue, "FunctionExpression") || isNodeOfType(writtenValue, "SpreadElement")) return null;
+	return {
+		callExpression,
+		writtenValue
+	};
+};
+const isGlobalObjectIsCall = (callExpression, scopes) => {
+	if (!isNodeOfType(callExpression, "CallExpression")) return false;
+	const callee = stripParenExpression(callExpression.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	const propertyName = getStaticPropertyName(callee);
+	const receiver = stripParenExpression(callee.object);
+	return Boolean(propertyName === "is" && isNodeOfType(receiver, "Identifier") && receiver.name === "Object" && scopes.isGlobalReference(receiver));
+};
+const isGlobalNaNReference = (expression, scopes) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	return isNodeOfType(unwrappedExpression, "Identifier") && unwrappedExpression.name === "NaN" && scopes.isGlobalReference(unwrappedExpression);
+};
+const getEqualityComparison = (stateReference, candidate, scopes) => {
+	const unwrappedStateReference = stripParenExpression(stateReference);
+	if (isNodeOfType(candidate, "BinaryExpression") && EQUALITY_BINARY_OPERATORS.has(candidate.operator)) {
+		if (stripParenExpression(candidate.left) === unwrappedStateReference) return isGlobalNaNReference(candidate.right, scopes) ? null : {
+			comparison: candidate,
+			counterpart: candidate.right,
+			areValuesEqualWhenTruthy: candidate.operator === "==="
+		};
+		if (stripParenExpression(candidate.right) === unwrappedStateReference) return isGlobalNaNReference(candidate.left, scopes) ? null : {
+			comparison: candidate,
+			counterpart: candidate.left,
+			areValuesEqualWhenTruthy: candidate.operator === "==="
+		};
+		return null;
+	}
+	if (!isNodeOfType(candidate, "CallExpression") || !isGlobalObjectIsCall(candidate, scopes) || candidate.arguments.length !== 2) return null;
+	const firstArgument = candidate.arguments[0];
+	const secondArgument = candidate.arguments[1];
+	if (isNodeOfType(firstArgument, "SpreadElement") || isNodeOfType(secondArgument, "SpreadElement")) return null;
+	if (stripParenExpression(firstArgument) === unwrappedStateReference) return {
+		comparison: candidate,
+		counterpart: secondArgument,
+		areValuesEqualWhenTruthy: true
+	};
+	if (stripParenExpression(secondArgument) === unwrappedStateReference) return {
+		comparison: candidate,
+		counterpart: firstArgument,
+		areValuesEqualWhenTruthy: true
+	};
+	return null;
+};
+const findEqualityComparison = (stateReference, test, scopes) => {
+	let current = stateReference.parent;
+	while (current && isAstDescendant(current, test)) {
+		const comparison = getEqualityComparison(stateReference, current, scopes);
+		if (comparison) return comparison;
+		if (current === test) break;
+		current = current.parent;
+	}
+	return null;
+};
+const doesTestOutcomeRequireComparisonOutcome = (comparison, test, testOutcome, comparisonOutcome) => {
+	let requiredChildOutcome = testOutcome;
+	let current = comparison;
+	while (current !== test) {
+		const parent = current.parent;
+		if (!parent || !isAstDescendant(parent, test)) return false;
+		if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "!") requiredChildOutcome = !requiredChildOutcome;
+		else if (isNodeOfType(parent, "LogicalExpression")) {
+			if (parent.operator === "&&" && !requiredChildOutcome) return false;
+			if (parent.operator === "||" && requiredChildOutcome) return false;
+			if (parent.operator !== "&&" && parent.operator !== "||") return false;
+		} else if (!TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type)) return false;
+		current = parent;
+	}
+	return requiredChildOutcome === comparisonOutcome;
+};
+const resolveImmutableAliasExpression = (expression, scopes) => {
+	const visitedSymbolIds = /* @__PURE__ */ new Set();
+	let current = stripParenExpression(expression);
+	while (isNodeOfType(current, "Identifier")) {
+		const symbol = scopes.symbolFor(current);
+		if (!symbol || visitedSymbolIds.has(symbol.id)) break;
+		const initializer = getDirectConstInitializer(symbol);
+		if (!initializer || !isNodeOfType(stripParenExpression(initializer), "Identifier")) break;
+		visitedSymbolIds.add(symbol.id);
+		current = stripParenExpression(initializer);
+	}
+	return current;
+};
+const referencesSameValue = (leftExpression, rightExpression, scopes) => {
+	const left = resolveImmutableAliasExpression(leftExpression, scopes);
+	const right = resolveImmutableAliasExpression(rightExpression, scopes);
+	if (left === right) return true;
+	if (isNodeOfType(left, "Identifier") && isNodeOfType(right, "Identifier")) {
+		const leftSymbol = scopes.symbolFor(left);
+		const rightSymbol = scopes.symbolFor(right);
+		if (leftSymbol || rightSymbol) return leftSymbol?.id === rightSymbol?.id;
+		return left.name === right.name;
+	}
+	if (isNodeOfType(left, "Literal") && isNodeOfType(right, "Literal")) return Object.is(left.value, right.value);
+	return false;
+};
+const hasDeclaredTriggerDependency = (callback) => {
+	const hookCall = findTransparentExpressionRoot(callback).parent;
+	if (!isNodeOfType(hookCall, "CallExpression")) return false;
+	const dependencyArray = hookCall.arguments[1];
+	return Boolean(isNodeOfType(dependencyArray, "ArrayExpression") && dependencyArray.elements.length);
+};
+const doesBranchExitEffect = (branch) => {
+	if (isNodeOfType(branch, "ReturnStatement") || isNodeOfType(branch, "ThrowStatement")) return true;
+	if (!isNodeOfType(branch, "BlockStatement")) return false;
+	const terminalStatement = branch.body.at(-1);
+	return Boolean(terminalStatement && doesBranchExitEffect(terminalStatement));
+};
+const doesGuardDominateLaterSetter = (guard, setterCall) => {
+	if (!isNodeOfType(guard, "IfStatement") || guard.alternate) return false;
+	if (!doesBranchExitEffect(guard.consequent)) return false;
+	const block = guard.parent;
+	if (!isNodeOfType(block, "BlockStatement")) return false;
+	const guardIndex = block.body.findIndex((statement) => statement === guard);
+	return block.body.some((statement, statementIndex) => statementIndex > guardIndex && isAstDescendant(setterCall, statement));
+};
+const findDominatingGuardCounterpart = (stateReference, setterCall, callback, scopes) => {
+	let current = stateReference.parent;
+	while (current && current !== callback) {
+		if (isNodeOfType(current, "IfStatement") && isAstDescendant(stateReference, current.test) && (isAstDescendant(setterCall, current.consequent) || Boolean(current.alternate && isAstDescendant(setterCall, current.alternate)) || doesGuardDominateLaterSetter(current, setterCall))) {
+			const setterRunsWhenTestTruthy = isAstDescendant(setterCall, current.consequent);
+			if (setterRunsWhenTestTruthy === (Boolean(current.alternate && isAstDescendant(setterCall, current.alternate)) || doesGuardDominateLaterSetter(current, setterCall))) return null;
+			const equalityComparison = findEqualityComparison(stateReference, current.test, scopes);
+			if (!equalityComparison) return null;
+			const comparisonOutcomeForDifferentValues = !equalityComparison.areValuesEqualWhenTruthy;
+			if (!doesTestOutcomeRequireComparisonOutcome(equalityComparison.comparison, current.test, setterRunsWhenTestTruthy, comparisonOutcomeForDifferentValues)) return null;
+			return equalityComparison.counterpart;
+		}
+		current = current.parent;
+	}
+	return null;
+};
+const isSoleWriterEffectGuardCapture = (stateSymbol, callback, scopes) => {
+	if (!hasDeclaredTriggerDependency(callback)) return false;
+	if (stateSymbol.references.some((reference) => reference.flag !== "read")) return false;
+	const setterSymbol = getUseStateSetterSymbol(stateSymbol, scopes);
+	if (!setterSymbol) return false;
+	const setterWrite = getDirectSetterCall(setterSymbol, callback);
+	if (!setterWrite) return false;
+	const callbackStateReferences = stateSymbol.references.filter((reference) => isAstDescendant(reference.identifier, callback));
+	if (callbackStateReferences.length !== 1) return false;
+	const stateReferenceRoot = findTransparentExpressionRoot(callbackStateReferences[0].identifier);
+	if (isNodeOfType(stateReferenceRoot.parent, "MemberExpression") && stateReferenceRoot.parent.object === stateReferenceRoot) return false;
+	const counterpart = findDominatingGuardCounterpart(callbackStateReferences[0].identifier, setterWrite.callExpression, callback, scopes);
+	return Boolean(counterpart && referencesSameValue(counterpart, setterWrite.writtenValue, scopes));
+};
+//#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps-suppression.ts
 const DISABLE_COMMENT_RULE_NAME_PATTERN$1 = /(?:^|[\s,/])exhaustive-deps(?:$|[\s,:])/;
 const DISABLE_NEXT_LINE_PATTERN$1 = /\b(?:eslint|oxlint)-disable-next-line\b([^\n]*)/;
@@ -13168,25 +13979,6 @@ const isExhaustiveDepsSuppressedAt = (filename, nodeStartOffset) => {
 	return index.suppressedLines.has(lineForOffset$1(nodeStartOffset, index.utf16NewlineOffsets)) || index.suppressedLines.has(lineForOffset$1(nodeStartOffset, index.utf8NewlineOffsets));
 };
 //#endregion
-//#region src/plugin/utils/is-ast-descendant.ts
-/**
-* True when `inner` is `outer` itself or any descendant in the AST
-* `parent` chain. Walks `inner.parent` upward and stops at either a
-* match (`true`) or the chain's root (`false`).
-*
-* Was duplicated byte-identical in:
-* - exhaustive-deps-symbol-stability.ts
-* - semantic/closure-captures.ts
-*/
-const isAstDescendant = (inner, outer) => {
-	let current = inner;
-	while (current) {
-		if (current === outer) return true;
-		current = current.parent ?? null;
-	}
-	return false;
-};
-//#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps-symbol-stability.ts
 /**
 * Symbol-stability helpers consumed by the `exhaustive-deps` rule.
@@ -13367,6 +14159,7 @@ const EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS = new Set([
 	"useLayoutEffect",
 	"useInsertionEffect"
 ]);
+const SOLE_WRITER_GUARD_HOOKS = new Set(["useEffect", "useLayoutEffect"]);
 const buildAdditionalHooksRegex = (additional) => {
 	if (!additional) return null;
 	try {
@@ -13503,7 +14296,7 @@ const stringifyMemberChain = (node) => {
 	}
 	return null;
 };
-const collectCaptureDepKeys = (callback, scopes, declaredExactBindingKeys) => {
+const collectCaptureDepKeys = (callback, scopes, declaredExactBindingKeys, allowSoleWriterEffectGuards = false) => {
 	const keys = /* @__PURE__ */ new Set();
 	const stableCapturedNames = /* @__PURE__ */ new Set();
 	const moduleScopeCapturedNames = /* @__PURE__ */ new Set();
@@ -13514,6 +14307,10 @@ const collectCaptureDepKeys = (callback, scopes, declaredExactBindingKeys) => {
 		const symbol = reference.resolvedSymbol;
 		if (!symbol) continue;
 		if (isRecursiveInitializerCapture(symbol, callback)) continue;
+		if (allowSoleWriterEffectGuards && isSoleWriterEffectGuardCapture(symbol, callback, scopes)) {
+			stableCapturedNames.add(symbol.name);
+			continue;
+		}
 		if (symbolHasStableValue(symbol, scopes)) {
 			stableCapturedNames.add(symbol.name);
 			continue;
@@ -14186,7 +14983,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				if (isNodeOfType(stripped, "Identifier")) declaredExactBindingKeys.add(key);
 				declaredKeyToReportNode.set(key, elementNode);
 			}
-			const { keys: captureKeys, stableCapturedNames, moduleScopeCapturedNames, outerFunctionCapturedNames } = collectCaptureDepKeys(callbackToAnalyze ?? callbackArgument, context.scopes, declaredExactBindingKeys);
+			const { keys: captureKeys, stableCapturedNames, moduleScopeCapturedNames, outerFunctionCapturedNames } = collectCaptureDepKeys(callbackToAnalyze ?? callbackArgument, context.scopes, declaredExactBindingKeys, SOLE_WRITER_GUARD_HOOKS.has(hookName));
 			for (const forcedCaptureKey of forcedCaptureKeys) captureKeys.add(forcedCaptureKey);
 			addAggregatePropsDependency(captureKeys, declaredKeys, callbackToAnalyze ?? callbackArgument, context.scopes);
 			const missingCaptureKeys = [];
@@ -14626,7 +15423,7 @@ const forbidElements = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/forward-ref-uses-ref.ts
-const MESSAGE$53 = "The parent can't reach this component's node because the `forwardRef` wrapper ignores `ref`.";
+const MESSAGE$54 = "The parent can't reach this component's node because the `forwardRef` wrapper ignores `ref`.";
 const forwardRefUsesRef = defineRule({
 	id: "forward-ref-uses-ref",
 	title: "forwardRef without ref parameter",
@@ -14649,7 +15446,7 @@ const forwardRefUsesRef = defineRule({
 		if (isNodeOfType(onlyParam, "RestElement")) return;
 		context.report({
 			node: inner,
-			message: MESSAGE$53
+			message: MESSAGE$54
 		});
 	} })
 });
@@ -14690,7 +15487,7 @@ const gitProviderUrlInjectionRisk = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/heading-has-content.ts
-const MESSAGE$52 = "Blind users can't use this heading to navigate because screen readers skip it empty, so add text, `aria-label`, or `aria-labelledby`.";
+const MESSAGE$53 = "Blind users can't use this heading to navigate because screen readers skip it empty, so add text, `aria-label`, or `aria-labelledby`.";
 const DEFAULT_HEADING_TAGS = [
 	"h1",
 	"h2",
@@ -14724,7 +15521,7 @@ const headingHasContent = defineRule({
 			for (const attribute of ["aria-label", "aria-labelledby"]) if (hasJsxPropIgnoreCase(node.attributes, attribute)) return;
 			context.report({
 				node,
-				message: MESSAGE$52
+				message: MESSAGE$53
 			});
 		} };
 	}
@@ -14888,7 +15685,7 @@ const hooksNoNanInDeps = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/html-has-lang.ts
-const MESSAGE$51 = "Screen readers may mispronounce this page because it doesn't declare a language, so add a `lang` attribute like `en`.";
+const MESSAGE$52 = "Screen readers may mispronounce this page because it doesn't declare a language, so add a `lang` attribute like `en`.";
 const resolveSettings$39 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { htmlTags: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.htmlHasLang ?? {} : {}).htmlTags ?? ["html"] };
@@ -14935,13 +15732,13 @@ const htmlHasLang = defineRule({
 			if (!lang) {
 				context.report({
 					node: node.name,
-					message: MESSAGE$51
+					message: MESSAGE$52
 				});
 				return;
 			}
 			if (evaluateLang(lang.value) === "empty") context.report({
 				node: lang,
-				message: MESSAGE$51
+				message: MESSAGE$52
 			});
 		} };
 	}
@@ -15181,7 +15978,7 @@ const htmlNoNestedInteractive = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/iframe-has-title.ts
-const MESSAGE$50 = "Screen reader users cannot identify this `<iframe>` because it has no title. Add a `title` that describes its content.";
+const MESSAGE$51 = "Screen reader users cannot identify this `<iframe>` because it has no title. Add a `title` that describes its content.";
 const evaluateTitleValue = (value) => {
 	if (!value) return "missing";
 	if (isNodeOfType(value, "Literal")) {
@@ -15221,14 +16018,14 @@ const iframeHasTitle = defineRule({
 		if (!titleAttr) {
 			if (hasSpread || tag === "iframe") context.report({
 				node: node.name,
-				message: MESSAGE$50
+				message: MESSAGE$51
 			});
 			return;
 		}
 		const verdict = evaluateTitleValue(titleAttr.value);
 		if (verdict === "missing" || verdict === "empty") context.report({
 			node: titleAttr,
-			message: MESSAGE$50
+			message: MESSAGE$51
 		});
 	} })
 });
@@ -15353,7 +16150,7 @@ const iframeMissingSandbox = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/img-redundant-alt.ts
-const MESSAGE$49 = "Screen reader users hear \"image\" or \"photo\" twice because they already announce it, so describe what the image shows instead.";
+const MESSAGE$50 = "Screen reader users hear \"image\" or \"photo\" twice because they already announce it, so describe what the image shows instead.";
 const DEFAULT_COMPONENTS = ["img"];
 const DEFAULT_REDUNDANT_WORDS = [
 	"image",
@@ -15418,7 +16215,7 @@ const imgRedundantAlt = defineRule({
 			if (!altAttribute) return;
 			if (altValueRedundant(altAttribute, settings.words)) context.report({
 				node: altAttribute,
-				message: MESSAGE$49
+				message: MESSAGE$50
 			});
 		} };
 	}
@@ -16000,14 +16797,14 @@ const isBindingInvokedOnRenderPath = (root, bindingName) => {
 		if (didFindRenderPathInvocation) return false;
 		if (!isNodeOfType(node, "CallExpression")) return;
 		if (!isNodeOfType(node.callee, "Identifier") || node.callee.name !== bindingName) return;
-		let enclosingFunction = findEnclosingFunction(node);
+		let enclosingFunction = findEnclosingFunction$1(node);
 		while (enclosingFunction) {
 			if (isDeferredCallbackPosition$1(enclosingFunction) || getHandlerNamedBindingName(enclosingFunction)) return;
 			if (containingFunctionIsComponentOrHook(enclosingFunction)) {
 				didFindRenderPathInvocation = true;
 				return;
 			}
-			enclosingFunction = findEnclosingFunction(enclosingFunction);
+			enclosingFunction = findEnclosingFunction$1(enclosingFunction);
 		}
 	});
 	return didFindRenderPathInvocation;
@@ -16042,7 +16839,7 @@ const jotaiSelectAtomInRenderBody = defineRule({
 		};
 		return { CallExpression(node) {
 			if (!isImportedSelectAtom(node)) return;
-			const nearestFunctionLike = findEnclosingFunction(node);
+			const nearestFunctionLike = findEnclosingFunction$1(node);
 			if (!nearestFunctionLike) return;
 			if (isDeferredCallback(nearestFunctionLike)) return;
 			if (isBindingUsedAsHandler(nearestFunctionLike)) return;
@@ -17039,7 +17836,7 @@ const isPersistentCacheSetWrite = (callExpression, newExpression, enclosingFunct
 	return !isAstDescendant(receiverBinding.scopeOwner, enclosingFunction);
 };
 const isInsideCacheMemo = (node) => {
-	const enclosingFunction = findEnclosingFunction(node);
+	const enclosingFunction = findEnclosingFunction$1(node);
 	let child = node;
 	let cursor = node.parent ?? null;
 	while (cursor) {
@@ -17077,7 +17874,7 @@ const getFunctionName = (functionNode) => {
 	return null;
 };
 const isUncacheableOptionsMergeUtility = (node) => {
-	const enclosingFunction = findEnclosingFunction(node);
+	const enclosingFunction = findEnclosingFunction$1(node);
 	if (!enclosingFunction || !isFunctionLike$2(enclosingFunction)) return false;
 	const functionName = getFunctionName(enclosingFunction);
 	if (!functionName || isComponentOrHookName(functionName)) return false;
@@ -17201,7 +17998,7 @@ const GLOBAL_BUILTIN_NAMES = new Set([
 ]);
 const STRING_PROTOTYPE_PATH = "String.prototype";
 const REGEXP_PROTOTYPE_PATH = "RegExp.prototype";
-const getStaticStringValue = (argument) => {
+const getStaticStringValue$1 = (argument) => {
 	if (!argument) return null;
 	const unwrappedArgument = stripParenExpression(argument);
 	if (isNodeOfType(unwrappedArgument, "Literal") && typeof unwrappedArgument.value === "string") return unwrappedArgument.value;
@@ -17209,7 +18006,7 @@ const getStaticStringValue = (argument) => {
 	return null;
 };
 const getEffectiveRegExpFlags = (patternArgument, flagsArgument) => {
-	if (flagsArgument) return getStaticStringValue(flagsArgument);
+	if (flagsArgument) return getStaticStringValue$1(flagsArgument);
 	if (!patternArgument) return "";
 	const unwrappedPattern = stripParenExpression(patternArgument);
 	if (isNodeOfType(unwrappedPattern, "Literal") && unwrappedPattern.value instanceof RegExp) return unwrappedPattern.value.flags;
@@ -17268,13 +18065,6 @@ const isSafeStatefulReplaceAllSearch = (node, flags, context) => {
 	const callee = stripParenExpression(replaceAllCall.callee);
 	return isNodeOfType(callee, "MemberExpression") && !callee.computed && !callee.optional && !replaceAllCall.optional && isNodeOfType(callee.property, "Identifier") && callee.property.name === "replaceAll" && isProvenNativeStringReceiver(callee.object, context);
 };
-const getDestructuredBindingPropertyName = (bindingIdentifier) => {
-	let bindingNode = bindingIdentifier;
-	if (isNodeOfType(bindingNode.parent, "AssignmentPattern") && bindingNode.parent.left === bindingNode) bindingNode = bindingNode.parent;
-	const property = bindingNode.parent;
-	if (!isNodeOfType(property, "Property") || property.value !== bindingNode || !isNodeOfType(property.parent, "ObjectPattern")) return null;
-	return getStaticPropertyKeyName(property, { allowComputedString: true });
-};
 const extendGlobalPath = (basePath, propertyName) => {
 	if (basePath === "global") {
 		if (propertyName === null || GLOBAL_OBJECT_NAMES.has(propertyName)) return "global";
@@ -17359,7 +18149,7 @@ const getCallRegExpHazard = (node, context, symbolCache) => {
 	const mutationHazard = targetPath === "global" ? "globalRegExpReplaced" : "replaceAllIntegrityLost";
 	const guardedPropertyName = targetPath === "global" ? "RegExp" : "replaceAll";
 	if (isSinglePropertyMutation) {
-		const propertyName = getStaticStringValue(node.arguments?.[1]);
+		const propertyName = getStaticStringValue$1(node.arguments?.[1]);
 		return propertyName === null || propertyName === guardedPropertyName ? mutationHazard : "none";
 	}
 	if (!isPropertyCollectionMutation) return "none";
@@ -17388,7 +18178,7 @@ const getHoistableRegExpConstructionKind = (node, context) => {
 	if (!STATEFUL_REGEXP_FLAGS_PATTERN.test(effectiveFlags)) return "stateless";
 	return isSafeStatefulReplaceAllSearch(node, effectiveFlags, context) ? "statefulReplaceAll" : null;
 };
-const MESSAGE$48 = "`new RegExp()` rebuilds the pattern on every loop pass. Move it to a constant outside the loop.";
+const MESSAGE$49 = "`new RegExp()` rebuilds the pattern on every loop pass. Move it to a constant outside the loop.";
 const jsHoistRegexp = defineRule({
 	id: "js-hoist-regexp",
 	title: "RegExp built inside a loop",
@@ -17405,7 +18195,7 @@ const jsHoistRegexp = defineRule({
 			if (constructionKind === "statefulReplaceAll" && cachedEnvironmentHazard === "replaceAllIntegrityLost") return;
 			context.report({
 				node,
-				message: MESSAGE$48
+				message: MESSAGE$49
 			});
 		};
 		return createLoopAwareVisitors({
@@ -18333,6 +19123,26 @@ const MEMBERSHIP_COMPARISON_OPERATORS = new Set([
 ]);
 const isNegativeOneLiteral = (expression) => Boolean(expression) && isNodeOfType(expression, "UnaryExpression") && expression.operator === "-" && isNodeOfType(expression.argument, "Literal") && expression.argument.value === 1;
 const isZeroLiteral = (expression) => Boolean(expression) && isNodeOfType(expression, "Literal") && expression.value === 0;
+const isToIntegerOrInfinityZero = (value) => Number.isNaN(value) || Math.trunc(value) === 0;
+const isZeroFromIndex = (expression) => {
+	if (!expression) return false;
+	const strippedExpression = stripParenExpression(expression);
+	if (isNodeOfType(strippedExpression, "Literal")) {
+		if (typeof strippedExpression.value === "number") return isToIntegerOrInfinityZero(strippedExpression.value);
+		if (typeof strippedExpression.value === "string") return isToIntegerOrInfinityZero(Number(strippedExpression.value));
+		return strippedExpression.value === null || strippedExpression.value === false;
+	}
+	if (isNodeOfType(strippedExpression, "UnaryExpression") && strippedExpression.operator === "void") return true;
+	if (isNodeOfType(strippedExpression, "UnaryExpression") && (strippedExpression.operator === "-" || strippedExpression.operator === "+") && isNodeOfType(strippedExpression.argument, "Literal") && typeof strippedExpression.argument.value === "number") return isToIntegerOrInfinityZero(strippedExpression.operator === "-" ? -strippedExpression.argument.value : strippedExpression.argument.value);
+	if (isNodeOfType(strippedExpression, "Identifier")) return (strippedExpression.name === "undefined" || strippedExpression.name === "NaN") && findVariableInitializer(strippedExpression, strippedExpression.name) === null;
+	return isNodeOfType(strippedExpression, "MemberExpression") && !strippedExpression.computed && isNodeOfType(strippedExpression.object, "Identifier") && strippedExpression.object.name === "Number" && isNodeOfType(strippedExpression.property, "Identifier") && strippedExpression.property.name === "NaN" && findVariableInitializer(strippedExpression.object, strippedExpression.object.name) === null;
+};
+const hasSemanticsPreservingIncludesArguments = (node) => {
+	if (node.arguments.length === 1) return !isNodeOfType(node.arguments[0], "SpreadElement");
+	if (node.arguments.length !== 2) return false;
+	if (isNodeOfType(node.arguments[0], "SpreadElement") || isNodeOfType(node.arguments[1], "SpreadElement")) return false;
+	return isZeroFromIndex(node.arguments[1]);
+};
 const PARENT_WRAPPER_TYPES = new Set([
 	"ParenthesizedExpression",
 	"ChainExpression",
@@ -18353,6 +19163,306 @@ const isIndexOfResultUsedAsMembershipTest = (node) => {
 	if (isNegativeOneLiteral(otherOperand)) return true;
 	return isZeroLiteral(otherOperand) && (parent.operator === ">=" || parent.operator === "<");
 };
+const getTypeAnnotation = (node) => {
+	if (!node || !("typeAnnotation" in node)) return null;
+	const annotation = node.typeAnnotation;
+	if (!annotation || !isNodeOfType(annotation, "TSTypeAnnotation")) return null;
+	return annotation.typeAnnotation;
+};
+const getDeclaredPropertyType = (members, propertyName) => {
+	for (const member of members) if (isNodeOfType(member, "TSPropertySignature") && isNodeOfType(member.key, "Identifier") && member.key.name === propertyName) return getTypeAnnotation(member);
+	return null;
+};
+const getArrayElementType = (typeNode) => {
+	if (!typeNode) return null;
+	if (isNodeOfType(typeNode, "TSArrayType")) return typeNode.elementType;
+	if (isNodeOfType(typeNode, "TSTypeReference") && isNodeOfType(typeNode.typeName, "Identifier") && (typeNode.typeName.name === "Array" || typeNode.typeName.name === "ReadonlyArray")) return typeNode.typeArguments?.params?.[0] ?? null;
+	if (isNodeOfType(typeNode, "TSUnionType")) {
+		const arrayElementTypes = typeNode.types.map(getArrayElementType).filter(Boolean);
+		return arrayElementTypes.length === 1 ? arrayElementTypes[0] : null;
+	}
+	return null;
+};
+const getDestructuredDeclaredType = (identifier) => {
+	const binding = findVariableInitializer(identifier, identifier.name);
+	if (!binding) return null;
+	const property = binding.bindingIdentifier.parent;
+	const objectPattern = property?.parent;
+	if (!isNodeOfType(property, "Property") || !isNodeOfType(property.key, "Identifier") || !isNodeOfType(objectPattern, "ObjectPattern")) return null;
+	const propsType = getTypeAnnotation(objectPattern);
+	if (!propsType) return null;
+	if (isNodeOfType(propsType, "TSTypeLiteral")) return getDeclaredPropertyType(propsType.members ?? [], property.key.name);
+	if (!isNodeOfType(propsType, "TSTypeReference") || !isNodeOfType(propsType.typeName, "Identifier")) return null;
+	const program = findProgramRoot(identifier);
+	if (!program) return null;
+	for (const statement of program.body) {
+		const declaration = isNodeOfType(statement, "ExportNamedDeclaration") ? statement.declaration : statement;
+		if (isNodeOfType(declaration, "TSInterfaceDeclaration") && isNodeOfType(declaration.id, "Identifier") && declaration.id.name === propsType.typeName.name) return getDeclaredPropertyType(declaration.body.body, property.key.name);
+		if (isNodeOfType(declaration, "TSTypeAliasDeclaration") && isNodeOfType(declaration.id, "Identifier") && declaration.id.name === propsType.typeName.name && isNodeOfType(declaration.typeAnnotation, "TSTypeLiteral")) return getDeclaredPropertyType(declaration.typeAnnotation.members ?? [], property.key.name);
+	}
+	return null;
+};
+const getIdentifierDeclaredType = (identifier, visitedBindingIdentifiers = /* @__PURE__ */ new Set()) => {
+	const binding = findVariableInitializer(identifier, identifier.name);
+	if (!binding || visitedBindingIdentifiers.has(binding.bindingIdentifier)) return null;
+	visitedBindingIdentifiers.add(binding.bindingIdentifier);
+	const directType = getTypeAnnotation(binding.bindingIdentifier);
+	if (directType) return directType;
+	const initializer = binding.initializer;
+	if (isNodeOfType(initializer, "TSAsExpression") || isNodeOfType(initializer, "TSTypeAssertion") || isNodeOfType(initializer, "TSSatisfiesExpression")) return initializer.typeAnnotation;
+	const destructuredType = getDestructuredDeclaredType(identifier);
+	if (destructuredType) return destructuredType;
+	const declarator = binding.bindingIdentifier.parent;
+	const declaration = declarator?.parent;
+	const forOfStatement = declaration?.parent;
+	if (isNodeOfType(declarator, "VariableDeclarator") && isNodeOfType(declaration, "VariableDeclaration") && isNodeOfType(forOfStatement, "ForOfStatement") && forOfStatement.left === declaration && isNodeOfType(forOfStatement.right, "Identifier")) return getArrayElementType(getIdentifierDeclaredType(forOfStatement.right, visitedBindingIdentifiers));
+	return null;
+};
+const isNativeIterationIndex = (identifier) => {
+	const binding = findVariableInitializer(identifier, identifier.name);
+	if (!binding) return false;
+	const callback = binding.bindingIdentifier.parent;
+	if (!isInlineFunctionExpression(callback)) return false;
+	const callbackCall = callback.parent;
+	if (!isNodeOfType(callbackCall, "CallExpression") || !isIterationCallbackCall(callbackCall) || !isNodeOfType(callbackCall.callee, "MemberExpression") || !isNodeOfType(callbackCall.callee.property, "Identifier")) return false;
+	const indexParameterPosition = callbackCall.callee.property.name === "reduce" || callbackCall.callee.property.name === "reduceRight" ? 2 : 1;
+	return callback.params?.[indexParameterPosition] === binding.bindingIdentifier;
+};
+const hasSameIdentifierBinding = (leftIdentifier, rightIdentifier) => {
+	if (leftIdentifier.name !== rightIdentifier.name) return false;
+	const leftBinding = findVariableInitializer(leftIdentifier, leftIdentifier.name);
+	const rightBinding = findVariableInitializer(rightIdentifier, rightIdentifier.name);
+	return Boolean(leftBinding && rightBinding && leftBinding.bindingIdentifier === rightBinding.bindingIdentifier);
+};
+const NON_NAN_RELATIONAL_OPERATORS = new Set([
+	"<",
+	"<=",
+	">",
+	">="
+]);
+const testProvesIdentifierIsNotNaN = (test, identifier) => {
+	if (!test) return false;
+	const strippedTest = stripParenExpression(test);
+	if (isNodeOfType(strippedTest, "LogicalExpression") && strippedTest.operator === "&&") return testProvesIdentifierIsNotNaN(strippedTest.left, identifier) || testProvesIdentifierIsNotNaN(strippedTest.right, identifier);
+	if (!isNodeOfType(strippedTest, "BinaryExpression") || !NON_NAN_RELATIONAL_OPERATORS.has(strippedTest.operator)) return false;
+	return isNodeOfType(strippedTest.left, "Identifier") && hasSameIdentifierBinding(strippedTest.left, identifier) || isNodeOfType(strippedTest.right, "Identifier") && hasSameIdentifierBinding(strippedTest.right, identifier);
+};
+const writeTargetContainsIdentifierBinding = (writeTarget, identifier) => {
+	let containsBinding = false;
+	walkAst(writeTarget, (child) => {
+		if (isNodeOfType(child, "Identifier") && hasSameIdentifierBinding(child, identifier)) {
+			containsBinding = true;
+			return false;
+		}
+	});
+	return containsBinding;
+};
+const hasWriteBeforeQuery = (body, identifier) => {
+	const queryStart = getRangeStart(identifier);
+	if (queryStart === null) return true;
+	let hasEarlierWrite = false;
+	walkAst(body, (child) => {
+		if (hasEarlierWrite) return false;
+		const childStart = getRangeStart(child);
+		if (childStart !== null && childStart >= queryStart) return false;
+		if (child !== body && isFunctionLike$2(child)) return false;
+		const writeTarget = isNodeOfType(child, "AssignmentExpression") ? child.left : isNodeOfType(child, "UpdateExpression") ? child.argument : isNodeOfType(child, "ForInStatement") || isNodeOfType(child, "ForOfStatement") ? child.left : null;
+		if (writeTarget && writeTargetContainsIdentifierBinding(writeTarget, identifier)) {
+			hasEarlierWrite = true;
+			return false;
+		}
+	});
+	return hasEarlierWrite;
+};
+const isProtectedByRelationalLoopGuard = (identifier) => {
+	let descendant = identifier;
+	let ancestor = identifier.parent;
+	while (ancestor) {
+		if (isFunctionLike$2(ancestor)) return false;
+		if ((isNodeOfType(ancestor, "ForStatement") || isNodeOfType(ancestor, "WhileStatement")) && ancestor.body === descendant && testProvesIdentifierIsNotNaN(ancestor.test, identifier)) return !hasWriteBeforeQuery(ancestor.body, identifier);
+		descendant = ancestor;
+		ancestor = ancestor.parent;
+	}
+	return false;
+};
+const isKnownSafeIndexOfQuery = (query) => {
+	if (!query) return false;
+	const strippedQuery = stripParenExpression(query);
+	if (isNodeOfType(strippedQuery, "Literal")) return typeof strippedQuery.value !== "number" || Number.isFinite(strippedQuery.value);
+	if (!isNodeOfType(strippedQuery, "Identifier")) return false;
+	if (isNativeIterationIndex(strippedQuery)) return true;
+	return isProtectedByRelationalLoopGuard(strippedQuery);
+};
+const findSameFileTypeAlias = (reference, typeName) => {
+	const program = findProgramRoot(reference);
+	if (!program) return null;
+	for (const statement of program.body) {
+		const declaration = isNodeOfType(statement, "ExportNamedDeclaration") ? statement.declaration : statement;
+		if (declaration && isNodeOfType(declaration, "TSTypeAliasDeclaration") && isNodeOfType(declaration.id, "Identifier") && declaration.id.name === typeName) return declaration;
+	}
+	return null;
+};
+const hasDeclaredMembershipMethod = (members, methodName) => members.some((member) => (isNodeOfType(member, "TSMethodSignature") || isNodeOfType(member, "TSPropertySignature")) && isNodeOfType(member.key, "Identifier") && member.key.name === methodName);
+const isKnownUserlandMembershipReceiver = (receiver, methodName) => {
+	if (!isNodeOfType(receiver, "Identifier")) return false;
+	const declaredType = getIdentifierDeclaredType(receiver);
+	if (!declaredType) return false;
+	if (isNodeOfType(declaredType, "TSTypeLiteral")) return hasDeclaredMembershipMethod(declaredType.members ?? [], methodName);
+	if (!isNodeOfType(declaredType, "TSTypeReference") || !isNodeOfType(declaredType.typeName, "Identifier")) return false;
+	const typeAlias = findSameFileTypeAlias(receiver, declaredType.typeName.name);
+	if (typeAlias && isNodeOfType(typeAlias.typeAnnotation, "TSTypeLiteral")) return hasDeclaredMembershipMethod(typeAlias.typeAnnotation.members ?? [], methodName);
+	const program = findProgramRoot(receiver);
+	if (!program) return false;
+	for (const statement of program.body) {
+		const declaration = isNodeOfType(statement, "ExportNamedDeclaration") ? statement.declaration : statement;
+		if (declaration && isNodeOfType(declaration, "TSInterfaceDeclaration") && isNodeOfType(declaration.id, "Identifier") && declaration.id.name === declaredType.typeName.name) return hasDeclaredMembershipMethod(declaration.body.body, methodName);
+	}
+	return false;
+};
+const findTypeParameter = (reference, typeName) => {
+	let ancestor = reference.parent;
+	while (ancestor) {
+		if (isFunctionLike$2(ancestor) || isNodeOfType(ancestor, "ClassDeclaration") || isNodeOfType(ancestor, "ClassExpression")) {
+			const matchingTypeParameter = ancestor.typeParameters?.params?.find((typeParameter) => isNodeOfType(typeParameter, "TSTypeParameter") && isNodeOfType(typeParameter.name, "Identifier") && typeParameter.name.name === typeName);
+			if (matchingTypeParameter && isNodeOfType(matchingTypeParameter, "TSTypeParameter")) return matchingTypeParameter;
+		}
+		ancestor = ancestor.parent;
+	}
+	return null;
+};
+const POSSIBLY_NUMERIC_TYPE_REFERENCE_NAMES = new Set(["NonNullable", "PropertyKey"]);
+const buildTypeAliasArguments = (typeAlias, typeReference, inheritedArguments) => {
+	const typeArguments = new Map(inheritedArguments);
+	for (const [index, typeParameter] of (typeAlias.typeParameters?.params ?? []).entries()) {
+		if (!isNodeOfType(typeParameter, "TSTypeParameter")) continue;
+		if (!isNodeOfType(typeParameter.name, "Identifier")) continue;
+		const argument = typeReference.typeArguments?.params?.[index] ?? typeParameter.default;
+		if (argument) typeArguments.set(typeParameter.name.name, argument);
+	}
+	return typeArguments;
+};
+const typeCanHaveSameValueZeroDifference = (typeNode, reference, activeTypeNodes, typeArguments = /* @__PURE__ */ new Map()) => {
+	if (!typeNode) return false;
+	if (isNodeOfType(typeNode, "TSNumberKeyword") || isNodeOfType(typeNode, "TSAnyKeyword") || isNodeOfType(typeNode, "TSUnknownKeyword")) return true;
+	if (isNodeOfType(typeNode, "TSStringKeyword") || isNodeOfType(typeNode, "TSBooleanKeyword") || isNodeOfType(typeNode, "TSBigIntKeyword") || isNodeOfType(typeNode, "TSSymbolKeyword") || isNodeOfType(typeNode, "TSNullKeyword") || isNodeOfType(typeNode, "TSUndefinedKeyword") || isNodeOfType(typeNode, "TSObjectKeyword") || isNodeOfType(typeNode, "TSLiteralType") || isNodeOfType(typeNode, "TSFunctionType")) return false;
+	if (isNodeOfType(typeNode, "TSTypeLiteral")) return (typeNode.members?.length ?? 0) === 0;
+	if (isNodeOfType(typeNode, "TSTypeOperator") && typeNode.operator === "keyof") return false;
+	if (isNodeOfType(typeNode, "TSUnionType") || isNodeOfType(typeNode, "TSIntersectionType")) return typeNode.types.some((memberType) => typeCanHaveSameValueZeroDifference(memberType, reference, activeTypeNodes, typeArguments));
+	if (isNodeOfType(typeNode, "TSOptionalType") || isNodeOfType(typeNode, "TSRestType")) return typeCanHaveSameValueZeroDifference(typeNode.typeAnnotation, reference, activeTypeNodes, typeArguments);
+	if (isNodeOfType(typeNode, "TSNamedTupleMember")) return typeCanHaveSameValueZeroDifference(typeNode.elementType, reference, activeTypeNodes, typeArguments);
+	if (!isNodeOfType(typeNode, "TSTypeReference")) return true;
+	if (!isNodeOfType(typeNode.typeName, "Identifier")) return false;
+	const substitutedType = typeArguments.get(typeNode.typeName.name);
+	if (substitutedType) {
+		const remainingArguments = new Map(typeArguments);
+		remainingArguments.delete(typeNode.typeName.name);
+		return typeCanHaveSameValueZeroDifference(substitutedType, reference, activeTypeNodes, remainingArguments);
+	}
+	const typeParameter = findTypeParameter(reference, typeNode.typeName.name);
+	if (typeParameter) {
+		if (!typeParameter.constraint || activeTypeNodes.has(typeParameter)) return true;
+		activeTypeNodes.add(typeParameter);
+		const constraintCanDiffer = typeCanHaveSameValueZeroDifference(typeParameter.constraint, reference, activeTypeNodes, typeArguments);
+		activeTypeNodes.delete(typeParameter);
+		return constraintCanDiffer;
+	}
+	const typeAlias = findSameFileTypeAlias(reference, typeNode.typeName.name);
+	if (!typeAlias) return POSSIBLY_NUMERIC_TYPE_REFERENCE_NAMES.has(typeNode.typeName.name) || /(?:number|numeric)/i.test(typeNode.typeName.name);
+	if (activeTypeNodes.has(typeAlias)) return true;
+	activeTypeNodes.add(typeAlias);
+	const canDiffer = typeCanHaveSameValueZeroDifference(typeAlias.typeAnnotation, reference, activeTypeNodes, buildTypeAliasArguments(typeAlias, typeNode, typeArguments));
+	activeTypeNodes.delete(typeAlias);
+	return canDiffer;
+};
+const arrayTypeCanHaveSameValueZeroDifference = (typeNode, reference, activeTypeNodes, typeArguments = /* @__PURE__ */ new Map()) => {
+	if (!typeNode) return false;
+	if (isNodeOfType(typeNode, "TSArrayType")) return typeCanHaveSameValueZeroDifference(typeNode.elementType, reference, activeTypeNodes, typeArguments);
+	if (isNodeOfType(typeNode, "TSTupleType")) return typeNode.elementTypes.some((elementType) => {
+		if (isNodeOfType(elementType, "TSRestType")) return arrayTypeCanHaveSameValueZeroDifference(elementType.typeAnnotation, reference, activeTypeNodes, typeArguments);
+		if (isNodeOfType(elementType, "TSNamedTupleMember")) return typeCanHaveSameValueZeroDifference(elementType.elementType, reference, activeTypeNodes, typeArguments);
+		return typeCanHaveSameValueZeroDifference(elementType, reference, activeTypeNodes, typeArguments);
+	});
+	if (isNodeOfType(typeNode, "TSTypeOperator")) return arrayTypeCanHaveSameValueZeroDifference(typeNode.typeAnnotation ?? null, reference, activeTypeNodes, typeArguments);
+	if (isNodeOfType(typeNode, "TSUnionType") || isNodeOfType(typeNode, "TSIntersectionType")) return typeNode.types.some((memberType) => arrayTypeCanHaveSameValueZeroDifference(memberType, reference, activeTypeNodes, typeArguments));
+	if (!isNodeOfType(typeNode, "TSTypeReference") || !isNodeOfType(typeNode.typeName, "Identifier")) return false;
+	const substitutedType = typeArguments.get(typeNode.typeName.name);
+	if (substitutedType) {
+		const remainingArguments = new Map(typeArguments);
+		remainingArguments.delete(typeNode.typeName.name);
+		return arrayTypeCanHaveSameValueZeroDifference(substitutedType, reference, activeTypeNodes, remainingArguments);
+	}
+	if (typeNode.typeName.name === "Array" || typeNode.typeName.name === "ReadonlyArray") return typeCanHaveSameValueZeroDifference(typeNode.typeArguments?.params?.[0] ?? null, reference, activeTypeNodes, typeArguments);
+	const typeAlias = findSameFileTypeAlias(reference, typeNode.typeName.name);
+	if (!typeAlias || activeTypeNodes.has(typeAlias)) return false;
+	activeTypeNodes.add(typeAlias);
+	const canDiffer = arrayTypeCanHaveSameValueZeroDifference(typeAlias.typeAnnotation, reference, activeTypeNodes, buildTypeAliasArguments(typeAlias, typeNode, typeArguments));
+	activeTypeNodes.delete(typeAlias);
+	return canDiffer;
+};
+const isKnownArrayType = (typeNode, reference, activeTypeNodes, typeArguments = /* @__PURE__ */ new Map()) => {
+	if (!typeNode) return false;
+	if (isNodeOfType(typeNode, "TSArrayType") || isNodeOfType(typeNode, "TSTupleType")) return true;
+	if (isNodeOfType(typeNode, "TSTypeOperator")) return isKnownArrayType(typeNode.typeAnnotation ?? null, reference, activeTypeNodes, typeArguments);
+	if (isNodeOfType(typeNode, "TSUnionType")) {
+		const nonNullishTypes = typeNode.types.filter((memberType) => !isNodeOfType(memberType, "TSNullKeyword") && !isNodeOfType(memberType, "TSUndefinedKeyword"));
+		return nonNullishTypes.length > 0 && nonNullishTypes.every((memberType) => isKnownArrayType(memberType, reference, activeTypeNodes, typeArguments));
+	}
+	if (isNodeOfType(typeNode, "TSIntersectionType")) return typeNode.types.some((memberType) => isKnownArrayType(memberType, reference, activeTypeNodes, typeArguments));
+	if (!isNodeOfType(typeNode, "TSTypeReference") || !isNodeOfType(typeNode.typeName, "Identifier")) return false;
+	const substitutedType = typeArguments.get(typeNode.typeName.name);
+	if (substitutedType) {
+		const remainingArguments = new Map(typeArguments);
+		remainingArguments.delete(typeNode.typeName.name);
+		return isKnownArrayType(substitutedType, reference, activeTypeNodes, remainingArguments);
+	}
+	if (typeNode.typeName.name === "Array" || typeNode.typeName.name === "ReadonlyArray") return true;
+	const typeParameter = findTypeParameter(reference, typeNode.typeName.name);
+	if (typeParameter?.constraint) {
+		if (activeTypeNodes.has(typeParameter)) return false;
+		activeTypeNodes.add(typeParameter);
+		const isConstraintArray = isKnownArrayType(typeParameter.constraint, reference, activeTypeNodes, typeArguments);
+		activeTypeNodes.delete(typeParameter);
+		return isConstraintArray;
+	}
+	const typeAlias = findSameFileTypeAlias(reference, typeNode.typeName.name);
+	if (!typeAlias || activeTypeNodes.has(typeAlias)) return false;
+	activeTypeNodes.add(typeAlias);
+	const isArray = isKnownArrayType(typeAlias.typeAnnotation, reference, activeTypeNodes, buildTypeAliasArguments(typeAlias, typeNode, typeArguments));
+	activeTypeNodes.delete(typeAlias);
+	return isArray;
+};
+const isKnownNativeArrayReceiver = (receiver) => {
+	if (isNodeOfType(receiver, "ArrayExpression")) return true;
+	if (isNodeOfType(receiver, "Identifier") && isKnownArrayType(getIdentifierDeclaredType(receiver), receiver, /* @__PURE__ */ new Set())) return true;
+	const initializer = getResolvedInitializer(receiver)?.initializer;
+	if (!initializer) return false;
+	const strippedInitializer = stripParenExpression(initializer);
+	if (isNodeOfType(strippedInitializer, "ArrayExpression")) return true;
+	if (isNodeOfType(strippedInitializer, "NewExpression") && isNodeOfType(strippedInitializer.callee, "Identifier") && strippedInitializer.callee.name === "Array" && findVariableInitializer(strippedInitializer.callee, strippedInitializer.callee.name) === null) return true;
+	return isNodeOfType(strippedInitializer, "CallExpression") && isNodeOfType(strippedInitializer.callee, "MemberExpression") && isNodeOfType(strippedInitializer.callee.object, "Identifier") && strippedInitializer.callee.object.name === "Array" && isNodeOfType(strippedInitializer.callee.property, "Identifier") && (strippedInitializer.callee.property.name === "from" || strippedInitializer.callee.property.name === "of") && findVariableInitializer(strippedInitializer.callee.object, strippedInitializer.callee.object.name) === null;
+};
+const isKnownDenseArrayReceiver = (receiver) => {
+	const initializer = isNodeOfType(receiver, "Identifier") ? getResolvedInitializer(receiver)?.initializer : receiver;
+	if (!initializer) return false;
+	const strippedInitializer = stripParenExpression(initializer);
+	if (isNodeOfType(strippedInitializer, "ArrayExpression")) return (strippedInitializer.elements ?? []).every((element) => element !== null && !isNodeOfType(element, "SpreadElement"));
+	return isNodeOfType(strippedInitializer, "CallExpression") && isNodeOfType(strippedInitializer.callee, "MemberExpression") && isNodeOfType(strippedInitializer.callee.object, "Identifier") && strippedInitializer.callee.object.name === "Array" && isNodeOfType(strippedInitializer.callee.property, "Identifier") && (strippedInitializer.callee.property.name === "from" || strippedInitializer.callee.property.name === "of") && findVariableInitializer(strippedInitializer.callee.object, strippedInitializer.callee.object.name) === null;
+};
+const isKnownUnsafeIndexOfQuery = (query, receiver) => {
+	if (!query) return true;
+	const strippedQuery = stripParenExpression(query);
+	if (isNodeOfType(strippedQuery, "Identifier")) {
+		if (strippedQuery.name === "undefined" && findVariableInitializer(strippedQuery, strippedQuery.name) === null) return !isKnownDenseArrayReceiver(receiver);
+		if (strippedQuery.name === "NaN" && findVariableInitializer(strippedQuery, strippedQuery.name) === null) return true;
+		return typeCanHaveSameValueZeroDifference(getIdentifierDeclaredType(strippedQuery), strippedQuery, /* @__PURE__ */ new Set());
+	}
+	if (isNodeOfType(strippedQuery, "MemberExpression")) return !strippedQuery.computed && isNodeOfType(strippedQuery.object, "Identifier") && strippedQuery.object.name === "Number" && isNodeOfType(strippedQuery.property, "Identifier") && strippedQuery.property.name === "NaN" && findVariableInitializer(strippedQuery.object, strippedQuery.object.name) === null;
+	return true;
+};
+const isKnownUnsafeIndexOfReceiver = (receiver) => {
+	if (!isNodeOfType(receiver, "Identifier")) return false;
+	return arrayTypeCanHaveSameValueZeroDifference(getIdentifierDeclaredType(receiver), receiver, /* @__PURE__ */ new Set());
+};
 const ITERATION_CALLBACK_METHOD_NAMES = new Set([
 	"forEach",
 	"map",
@@ -18481,16 +19591,22 @@ const jsSetMapLookups = defineRule({
 			if (!isNodeOfType(node.callee, "MemberExpression") || !isNodeOfType(node.callee.property, "Identifier")) return;
 			const methodName = node.callee.property.name;
 			if (methodName !== "includes" && methodName !== "indexOf") return;
-			if (methodName === "indexOf" && !isIndexOfResultUsedAsMembershipTest(node)) return;
+			if (methodName === "includes" && !hasSemanticsPreservingIncludesArguments(node)) return;
+			if (methodName === "indexOf" && (node.arguments.length !== 1 || isNodeOfType(node.arguments[0], "SpreadElement") || !isIndexOfResultUsedAsMembershipTest(node))) return;
 			const rawReceiver = node.callee.object;
 			if (!rawReceiver) return;
 			const receiver = stripParenExpression(rawReceiver);
+			const isKnownNativeArray = isKnownNativeArrayReceiver(receiver);
+			if (isKnownUserlandMembershipReceiver(receiver, methodName)) return;
+			if (methodName === "includes" && node.arguments.length === 2 && !isKnownNativeArray) return;
+			const query = node.arguments[0];
+			if (methodName === "indexOf" && !isKnownSafeIndexOfQuery(query) && (isKnownUnsafeIndexOfQuery(query, receiver) || isKnownUnsafeIndexOfReceiver(receiver))) return;
 			if (isLikelyStringReceiver(receiver)) return;
 			if (isSmallInlineLiteralArray(receiver)) return;
 			if (isScreamingSnakeCaseConstantReceiver(receiver)) return;
 			if (isSmallFixedListMember(receiver)) return;
-			if (isSubstringSearchLiteral(node.arguments?.[0])) return;
-			if (isIndexedArrayElementWithStringArgument(receiver, node.arguments?.[0])) return;
+			if (isSubstringSearchLiteral(query)) return;
+			if (isIndexedArrayElementWithStringArgument(receiver, query)) return;
 			const resolvedInitializer = getResolvedInitializer(receiver);
 			if (resolvedInitializer) {
 				if (isLikelyStringReceiver(resolvedInitializer.initializer)) return;
@@ -19699,7 +20815,7 @@ const jsxMaxDepth = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-comment-textnodes.ts
-const MESSAGE$47 = "Your users see this comment as text on the page because `//` & `/*` aren't hidden in JSX.";
+const MESSAGE$48 = "Your users see this comment as text on the page because `//` & `/*` aren't hidden in JSX.";
 const LITERAL_TEXT_TAGS = new Set([
 	"code",
 	"pre",
@@ -19769,7 +20885,7 @@ const jsxNoCommentTextnodes = defineRule({
 		if (isDeliberateStyledCommentToken(node)) return;
 		context.report({
 			node,
-			message: MESSAGE$47
+			message: MESSAGE$48
 		});
 	} })
 });
@@ -19800,7 +20916,7 @@ const isInsideFunctionScope = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-constructed-context-values.ts
-const MESSAGE$46 = "Every reader of this context redraws on each render because you build its `value` inline.";
+const MESSAGE$47 = "Every reader of this context redraws on each render because you build its `value` inline.";
 const CONTEXT_MODULES$1 = [
 	"react",
 	"use-context-selector",
@@ -19898,7 +21014,7 @@ const jsxNoConstructedContextValues = defineRule({
 					if (!isConstructedValue(innerExpression)) continue;
 					context.report({
 						node: attribute,
-						message: MESSAGE$46
+						message: MESSAGE$47
 					});
 				}
 			}
@@ -20753,7 +21869,7 @@ const DATA_ARRAY_PROP_SUFFIXES = [
 ];
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-new-array-as-prop.ts
-const MESSAGE$45 = "This child redraws every render because the prop gets a brand new array each time.";
+const MESSAGE$46 = "This child redraws every render because the prop gets a brand new array each time.";
 const isDataArrayPropName = (propName) => {
 	if (DATA_ARRAY_PROP_NAMES.has(propName)) return true;
 	for (const suffix of DATA_ARRAY_PROP_SUFFIXES) if (propName.length > suffix.length && propName.endsWith(suffix)) return true;
@@ -20840,7 +21956,7 @@ const jsxNoNewArrayAsProp = defineRule({
 				if (!isArrayProducingExpression(expressionNode) && !followsRenderLocalArrayBinding(expressionNode, node)) return;
 				context.report({
 					node,
-					message: MESSAGE$45
+					message: MESSAGE$46
 				});
 			}
 		};
@@ -21098,7 +22214,7 @@ const SAFE_RECEIVER_NAMES = new Set([
 ]);
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-new-function-as-prop.ts
-const MESSAGE$44 = "This child redraws every render because the prop gets a brand new function each time.";
+const MESSAGE$45 = "This child redraws every render because the prop gets a brand new function each time.";
 const isAccessorPredicateName = (propName) => {
 	for (const prefix of ACCESSOR_PREDICATE_PREFIXES) {
 		if (propName.length <= prefix.length) continue;
@@ -21304,7 +22420,7 @@ const jsxNoNewFunctionAsProp = defineRule({
 				if (!isFunctionProducingExpression(expressionNode) && !followsRenderLocalFunctionBinding(expressionNode, node)) return;
 				context.report({
 					node,
-					message: MESSAGE$44
+					message: MESSAGE$45
 				});
 			}
 		};
@@ -21524,7 +22640,7 @@ const CONFIG_OBJECT_PROP_SUFFIXES = [
 ];
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-new-object-as-prop.ts
-const MESSAGE$43 = "This child redraws every render because the prop gets a brand new object each time.";
+const MESSAGE$44 = "This child redraws every render because the prop gets a brand new object each time.";
 const isConfigObjectPropName = (propName) => {
 	if (CONFIG_OBJECT_PROP_NAMES.has(propName)) return true;
 	for (const suffix of CONFIG_OBJECT_PROP_SUFFIXES) if (propName.length > suffix.length && propName.endsWith(suffix)) return true;
@@ -21613,7 +22729,7 @@ const jsxNoNewObjectAsProp = defineRule({
 				if (!isObjectProducingExpression(expressionNode) && !followsRenderLocalObjectBinding(expressionNode, node)) return;
 				context.report({
 					node,
-					message: MESSAGE$43
+					message: MESSAGE$44
 				});
 			}
 		};
@@ -21621,7 +22737,7 @@ const jsxNoNewObjectAsProp = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-script-url.ts
-const MESSAGE$42 = "A `javascript:` URL is an XSS hole that runs injected input as code.";
+const MESSAGE$43 = "A `javascript:` URL is an XSS hole that runs injected input as code.";
 const JAVASCRIPT_URL_PATTERN = /^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i;
 const resolveSettings$29 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
@@ -21659,7 +22775,7 @@ const jsxNoScriptUrl = defineRule({
 				if (!value || !isNodeOfType(value, "Literal") || typeof value.value !== "string") continue;
 				if (JAVASCRIPT_URL_PATTERN.test(value.value)) context.report({
 					node: attribute,
-					message: MESSAGE$42
+					message: MESSAGE$43
 				});
 			}
 		} };
@@ -22279,7 +23395,7 @@ const jsxPropsNoSpreadMulti = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/jsx-props-no-spreading.ts
-const MESSAGE$41 = "You can't tell what props reach this element when you spread them.";
+const MESSAGE$42 = "You can't tell what props reach this element when you spread them.";
 const resolveSettings$25 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxPropsNoSpreading ?? {} : {};
@@ -22322,7 +23438,7 @@ const jsxPropsNoSpreading = defineRule({
 				}
 				context.report({
 					node: attribute,
-					message: MESSAGE$41
+					message: MESSAGE$42
 				});
 				didReportInFile = true;
 				return;
@@ -22598,7 +23714,7 @@ const labelHasAssociatedControl = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/lang.ts
-const MESSAGE$40 = "Screen readers can't pick the right voice because this `lang` isn't a real language code, so use a valid one like `en` or `en-US`.";
+const MESSAGE$41 = "Screen readers can't pick the right voice because this `lang` isn't a real language code, so use a valid one like `en` or `en-US`.";
 const COMMON_LANGUAGE_PRIMARY_TAGS = new Set([
 	"aa",
 	"ab",
@@ -23078,7 +24194,7 @@ const lang = defineRule({
 			if (expression.type === "Identifier" && expression.name === "undefined" || expression.type === "Literal" && expression.value === null) {
 				context.report({
 					node: langAttr,
-					message: MESSAGE$40
+					message: MESSAGE$41
 				});
 				return;
 			}
@@ -23087,7 +24203,7 @@ const lang = defineRule({
 		if (value === null) return;
 		if (!isValidLangTag(value)) context.report({
 			node: langAttr,
-			message: MESSAGE$40
+			message: MESSAGE$41
 		});
 	} })
 });
@@ -23138,7 +24254,7 @@ const mdxSsrExecutionRisk = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/media-has-caption.ts
-const MESSAGE$39 = "Deaf and hard-of-hearing users need captions for this media. Add a `<track kind=\"captions\">` inside the `<audio>` or `<video>`.";
+const MESSAGE$40 = "Deaf and hard-of-hearing users need captions for this media. Add a `<track kind=\"captions\">` inside the `<audio>` or `<video>`.";
 const DEFAULT_AUDIO = ["audio"];
 const DEFAULT_VIDEO = ["video"];
 const DEFAULT_TRACK = ["track"];
@@ -23227,7 +24343,7 @@ const mediaHasCaption = defineRule({
 			if (!parent || !isNodeOfType(parent, "JSXElement")) {
 				context.report({
 					node: node.name,
-					message: MESSAGE$39
+					message: MESSAGE$40
 				});
 				return;
 			}
@@ -23246,7 +24362,7 @@ const mediaHasCaption = defineRule({
 				return kindValue.value.toLowerCase() === "captions";
 			})) context.report({
 				node: node.name,
-				message: MESSAGE$39
+				message: MESSAGE$40
 			});
 		} };
 	}
@@ -24789,7 +25905,7 @@ const nextjsNoVercelOgImport = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-access-key.ts
-const MESSAGE$38 = "Screen reader users can lose their shortcuts because `accessKey` clashes with them, so remove it.";
+const MESSAGE$39 = "Screen reader users can lose their shortcuts because `accessKey` clashes with them, so remove it.";
 const isUndefinedIdentifier = (expression) => isNodeOfType(expression, "Identifier") && expression.name === "undefined";
 const noAccessKey = defineRule({
 	id: "no-access-key",
@@ -24808,7 +25924,7 @@ const noAccessKey = defineRule({
 			if (isNodeOfType(attributeValue, "Literal") && typeof attributeValue.value === "string") {
 				context.report({
 					node: accessKey,
-					message: MESSAGE$38
+					message: MESSAGE$39
 				});
 				return;
 			}
@@ -24818,7 +25934,7 @@ const noAccessKey = defineRule({
 				if (isUndefinedIdentifier(expression)) return;
 				context.report({
 					node: accessKey,
-					message: MESSAGE$38
+					message: MESSAGE$39
 				});
 			}
 		} };
@@ -25123,8 +26239,11 @@ const unwrapUseCallback = (node) => {
 	const callee = node.callee;
 	return isNodeOfType(callee, "Identifier") && callee.name === "useCallback" || isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "useCallback" ? node.arguments?.[0] : node;
 };
+const hasParameterDefinition = (ref) => Boolean(ref.resolved?.defs.some((definition) => definition.type === "Parameter"));
 const resolveToFunction = (ref) => {
-	const definitionNode = ref.resolved?.defs[0]?.node;
+	const definition = ref.resolved?.defs[0];
+	if (!definition || hasParameterDefinition(ref)) return null;
+	const definitionNode = definition.node;
 	if (!definitionNode) return null;
 	if (isFunctionLike$2(definitionNode)) return definitionNode;
 	if (isNodeOfType(definitionNode, "VariableDeclarator")) {
@@ -25534,7 +26653,7 @@ const isCleanupReturnArgument = (analysis, node) => {
 	if (isNodeOfType(node, "MemberExpression")) return true;
 	if (isNodeOfType(node, "Identifier")) {
 		const ref = getRef(analysis, node);
-		if (ref && resolveToFunction(ref)) return true;
+		if (ref && (hasParameterDefinition(ref) || resolveToFunction(ref))) return true;
 	}
 	if (isNodeOfType(node, "ConditionalExpression")) return isCleanupReturnArgument(analysis, node.consequent) || isCleanupReturnArgument(analysis, node.alternate);
 	return false;
@@ -25692,7 +26811,7 @@ const isIndependentWriterIdentifier = (componentFunction, identifier, includeDef
 };
 const hasUserInputSetterWriter = (setterRef, effectNode, includeDeferredWriters = false) => {
 	if (!setterRef.resolved) return false;
-	const componentFunction = findEnclosingFunction(effectNode);
+	const componentFunction = findEnclosingFunction$1(effectNode);
 	if (!componentFunction) return false;
 	for (const reference of setterRef.resolved.references) {
 		if (reference.init) continue;
@@ -26006,7 +27125,7 @@ const resolveWrappedCallable = (analysis, node) => {
 	if (isNodeOfType(candidate, "Identifier")) {
 		const reference = getRef(analysis, candidate);
 		if (!reference) return null;
-		if (reference.resolved?.defs.some((definition) => definition.type === "Parameter" || definition.type === "ImportBinding")) return null;
+		if (reference.resolved?.defs.some((definition) => definition.type === "ImportBinding")) return null;
 		const resolved = resolveToFunction(reference);
 		if (resolved) return resolved;
 		const definitionNode = reference.resolved?.defs[0]?.node;
@@ -26670,7 +27789,7 @@ const noAdjustStateOnPropChange = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-aria-hidden-on-focusable.ts
-const MESSAGE$37 = "Screen reader users tab to this focusable element but hear nothing because `aria-hidden` skips it, so remove `aria-hidden` or stop it being focusable.";
+const MESSAGE$38 = "Screen reader users tab to this focusable element but hear nothing because `aria-hidden` skips it, so remove `aria-hidden` or stop it being focusable.";
 const ALWAYS_FOCUSABLE_TAGS = new Set([
 	"button",
 	"embed",
@@ -26782,7 +27901,7 @@ const noAriaHiddenOnFocusable = defineRule({
 		const isImplicitlyFocusable = isNativelyFocusable(tag, node);
 		if (isExplicitlyFocusable || isImplicitlyFocusable) context.report({
 			node: ariaHidden,
-			message: MESSAGE$37
+			message: MESSAGE$38
 		});
 	} })
 });
@@ -27704,7 +28823,7 @@ const isAllLiteralArrayExpression = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/no-array-index-key.ts
-const MESSAGE$36 = "Your users can see & submit the wrong data when this list reorders.";
+const MESSAGE$37 = "Your users can see & submit the wrong data when this list reorders.";
 const SECOND_INDEX_METHODS = new Set([
 	"every",
 	"filter",
@@ -27823,14 +28942,14 @@ const noArrayIndexKey = defineRule({
 			if (propName !== "key") continue;
 			if (expressionUsesIndex(property.value, indexBinding.name)) context.report({
 				node: property,
-				message: MESSAGE$36
+				message: MESSAGE$37
 			});
 		}
 	} })
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-async-effect-callback.ts
-const MESSAGE$35 = "The `useEffect` callback is `async`, so it returns a Promise instead of a cleanup function. React calls that Promise as cleanup (a no-op) and the effect can race on unmount. Put the async work in an inner function and call it.";
+const MESSAGE$36 = "The `useEffect` callback is `async`, so it returns a Promise instead of a cleanup function. React calls that Promise as cleanup (a no-op) and the effect can race on unmount. Put the async work in an inner function and call it.";
 const noAsyncEffectCallback = defineRule({
 	id: "no-async-effect-callback",
 	title: "Async effect callback",
@@ -27848,13 +28967,13 @@ const noAsyncEffectCallback = defineRule({
 		if (!callback.async) return;
 		context.report({
 			node: callback,
-			message: MESSAGE$35
+			message: MESSAGE$36
 		});
 	} })
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-autofocus.ts
-const MESSAGE$34 = "`autoFocus` moves focus on load, which can disrupt screen reader and keyboard users. Remove it and let users choose where to focus.";
+const MESSAGE$35 = "`autoFocus` moves focus on load, which can disrupt screen reader and keyboard users. Remove it and let users choose where to focus.";
 const resolveSettings$21 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { ignoreNonDOM: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noAutofocus ?? {} : {}).ignoreNonDOM ?? true };
@@ -27951,7 +29070,7 @@ const noAutofocus = defineRule({
 			if (isConditionallyRendered(node)) return;
 			context.report({
 				node: autoFocusAttribute,
-				message: MESSAGE$34
+				message: MESSAGE$35
 			});
 		} };
 	}
@@ -28465,138 +29584,6 @@ const noBarrelImport = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/has-static-property-write-before.ts
-const equivalentSymbolsByAnalysis = /* @__PURE__ */ new WeakMap();
-const CONDITIONAL_EXECUTION_NODE_TYPES = new Set([
-	"CatchClause",
-	"ConditionalExpression",
-	"DoWhileStatement",
-	"ForInStatement",
-	"ForOfStatement",
-	"ForStatement",
-	"IfStatement",
-	"LogicalExpression",
-	"SwitchCase",
-	"SwitchStatement",
-	"TryStatement",
-	"WhileStatement"
-]);
-const getResolvedStaticPropertyName = (memberExpression, scopes) => {
-	if (!isNodeOfType(memberExpression, "MemberExpression")) return null;
-	const directPropertyName = getStaticPropertyName(memberExpression);
-	if (directPropertyName || !memberExpression.computed) return directPropertyName;
-	const property = stripParenExpression(memberExpression.property);
-	if (!isNodeOfType(property, "Identifier")) return null;
-	const propertySymbol = resolveConstIdentifierAlias(property, scopes);
-	const initializer = propertySymbol?.initializer ? stripParenExpression(propertySymbol.initializer) : null;
-	return initializer && isNodeOfType(initializer, "Literal") && typeof initializer.value === "string" ? initializer.value : null;
-};
-const collectScopeSymbols = (scope, symbols) => {
-	symbols.push(...scope.symbols);
-	for (const childScope of scope.children) collectScopeSymbols(childScope, symbols);
-};
-const getEquivalentSymbols = (identifier, scopes) => {
-	const rootSymbol = resolveConstIdentifierAlias(identifier, scopes);
-	if (!rootSymbol) return [];
-	let symbolsByRootId = equivalentSymbolsByAnalysis.get(scopes);
-	if (!symbolsByRootId) {
-		symbolsByRootId = /* @__PURE__ */ new Map();
-		equivalentSymbolsByAnalysis.set(scopes, symbolsByRootId);
-	}
-	const cachedSymbols = symbolsByRootId.get(rootSymbol.id);
-	if (cachedSymbols) return cachedSymbols;
-	const allSymbols = [];
-	collectScopeSymbols(scopes.rootScope, allSymbols);
-	const equivalentSymbols = allSymbols.filter((symbol) => resolveConstIdentifierAlias(symbol.bindingIdentifier, scopes)?.id === rootSymbol.id);
-	symbolsByRootId.set(rootSymbol.id, equivalentSymbols);
-	return equivalentSymbols;
-};
-const findExecutionBoundary = (node) => {
-	let current = node;
-	while (current) {
-		if (isFunctionLike$2(current) || isNodeOfType(current, "Program")) return current;
-		current = current.parent ?? null;
-	}
-	return null;
-};
-const isOnUnconditionalPath = (node, boundary) => {
-	let current = node.parent ?? null;
-	while (current && current !== boundary) {
-		if (CONDITIONAL_EXECUTION_NODE_TYPES.has(current.type)) return false;
-		current = current.parent ?? null;
-	}
-	return current === boundary;
-};
-const findFunctionBindingIdentifier = (functionNode) => {
-	if (isNodeOfType(functionNode, "FunctionDeclaration")) return functionNode.id ?? null;
-	const parent = functionNode.parent;
-	if (parent && isNodeOfType(parent, "VariableDeclarator") && parent.init === functionNode && isNodeOfType(parent.id, "Identifier")) return parent.id;
-	return null;
-};
-const findDirectCall = (identifier) => {
-	let callee = identifier;
-	let parent = callee.parent;
-	while (parent && stripParenExpression(parent) === identifier) {
-		callee = parent;
-		parent = callee.parent;
-	}
-	return parent && isNodeOfType(parent, "CallExpression") && parent.callee === callee ? parent : null;
-};
-const isFunctionSynchronouslyInvokedBefore = (functionNode, referenceNode, scopes, visitedFunctionNodes = /* @__PURE__ */ new Set()) => {
-	if (visitedFunctionNodes.has(functionNode) || !isFunctionLike$2(functionNode) || functionNode.generator) return false;
-	visitedFunctionNodes.add(functionNode);
-	const referenceBoundary = findExecutionBoundary(referenceNode);
-	if (!referenceBoundary) return false;
-	const invocationCalls = [];
-	const bindingIdentifier = findFunctionBindingIdentifier(functionNode);
-	if (bindingIdentifier) for (const symbol of getEquivalentSymbols(bindingIdentifier, scopes)) for (const reference of symbol.references) {
-		const call = findDirectCall(reference.identifier);
-		if (call) invocationCalls.push(call);
-	}
-	else {
-		const call = findDirectCall(functionNode);
-		if (call) invocationCalls.push(call);
-	}
-	return invocationCalls.some((call) => {
-		if (call.range[0] >= referenceNode.range[0]) return false;
-		const callBoundary = findExecutionBoundary(call);
-		if (!callBoundary) return false;
-		if (callBoundary === referenceBoundary) return true;
-		if (!isFunctionLike$2(callBoundary)) return false;
-		return isFunctionSynchronouslyInvokedBefore(callBoundary, referenceNode, scopes, new Set(visitedFunctionNodes));
-	});
-};
-const isMemberWriteTarget = (memberExpression) => {
-	const parent = memberExpression.parent;
-	if (!parent) return false;
-	if (isNodeOfType(parent, "AssignmentExpression")) return parent.left === memberExpression;
-	if (isNodeOfType(parent, "UpdateExpression")) return parent.argument === memberExpression;
-	return isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" && parent.argument === memberExpression;
-};
-const symbolHasStaticPropertyWriteBefore = (symbol, propertyName, referenceNode, scopes) => symbol.references.some((reference) => {
-	let parent = reference.identifier.parent;
-	while (parent && stripParenExpression(parent) === reference.identifier) parent = parent.parent;
-	if (!parent || !isNodeOfType(parent, "MemberExpression") || stripParenExpression(parent.object) !== reference.identifier || getResolvedStaticPropertyName(parent, scopes) !== propertyName || !isMemberWriteTarget(parent)) return false;
-	const writeBoundary = findExecutionBoundary(parent);
-	const referenceBoundary = findExecutionBoundary(referenceNode);
-	if (!writeBoundary || !referenceBoundary || !isOnUnconditionalPath(parent, writeBoundary)) return false;
-	if (writeBoundary === referenceBoundary) return parent.range[0] < referenceNode.range[0];
-	return isFunctionLike$2(writeBoundary) && isFunctionSynchronouslyInvokedBefore(writeBoundary, referenceNode, scopes);
-});
-const hasStaticPropertyWriteBefore = (identifier, propertyName, referenceNode, scopes) => {
-	if (!isNodeOfType(identifier, "Identifier")) return false;
-	return getEquivalentSymbols(identifier, scopes).some((symbol) => symbolHasStaticPropertyWriteBefore(symbol, propertyName, referenceNode, scopes));
-};
-//#endregion
-//#region src/plugin/utils/has-symbol-write-before.ts
-const hasSymbolWriteBefore = (symbol, referenceNode, scopes) => symbol.references.some((reference) => {
-	if (reference.flag === "read") return false;
-	const writeFunction = findEnclosingFunction(reference.identifier);
-	if (writeFunction === findEnclosingFunction(referenceNode)) return reference.identifier.range[0] < referenceNode.range[0];
-	if (!writeFunction) return true;
-	return isFunctionSynchronouslyInvokedBefore(writeFunction, referenceNode, scopes);
-});
-//#endregion
 //#region src/plugin/utils/has-stable-call-target.ts
 const hasStableCallTarget = (callExpression, scopes) => {
 	if (!isNodeOfType(callExpression, "CallExpression")) return false;
@@ -28924,7 +29911,7 @@ const noChainStateUpdates = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-children-prop.ts
-const MESSAGE$33 = "A `children` prop can override or hide nested children, so the component may render different content than the JSX shows.";
+const MESSAGE$34 = "A `children` prop can override or hide nested children, so the component may render different content than the JSX shows.";
 const noChildrenProp = defineRule({
 	id: "no-children-prop",
 	title: "Children passed as a prop",
@@ -28936,7 +29923,7 @@ const noChildrenProp = defineRule({
 			if (node.name.name !== "children") return;
 			context.report({
 				node: node.name,
-				message: MESSAGE$33
+				message: MESSAGE$34
 			});
 		},
 		CallExpression(node) {
@@ -28949,7 +29936,7 @@ const noChildrenProp = defineRule({
 				const propertyKey = property.key;
 				if (isNodeOfType(propertyKey, "Identifier") && propertyKey.name === "children" || isNodeOfType(propertyKey, "Literal") && propertyKey.value === "children") context.report({
 					node: propertyKey,
-					message: MESSAGE$33
+					message: MESSAGE$34
 				});
 			}
 		}
@@ -28957,7 +29944,7 @@ const noChildrenProp = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-clone-element.ts
-const MESSAGE$32 = "`React.cloneElement` couples the parent to the child's prop shape, so child prop changes can silently break injected behavior.";
+const MESSAGE$33 = "`React.cloneElement` couples the parent to the child's prop shape, so child prop changes can silently break injected behavior.";
 const noCloneElement = defineRule({
 	id: "no-clone-element",
 	title: "cloneElement makes child props fragile",
@@ -28970,7 +29957,7 @@ const noCloneElement = defineRule({
 		if (isNodeOfType(callee, "Identifier") && callee.name === "cloneElement") {
 			if (isImportedFromModule(node, "cloneElement", "react")) context.report({
 				node: callee,
-				message: MESSAGE$32
+				message: MESSAGE$33
 			});
 			return;
 		}
@@ -28983,7 +29970,7 @@ const noCloneElement = defineRule({
 			if (!isImportedFromModule(node, callee.object.name, "react")) return;
 			context.report({
 				node: callee,
-				message: MESSAGE$32
+				message: MESSAGE$33
 			});
 		}
 	} })
@@ -29003,7 +29990,7 @@ const getCallMethodName = (callee) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-create-context-in-render.ts
-const MESSAGE$31 = "createContext() builds a new context every render, so every consumer gets cut off & resets.";
+const MESSAGE$32 = "createContext() builds a new context every render, so every consumer gets cut off & resets.";
 const CONTEXT_MODULES = [
 	"react",
 	"use-context-selector",
@@ -29051,13 +30038,13 @@ const noCreateContextInRender = defineRule({
 		if (!componentOrHookName) return;
 		context.report({
 			node,
-			message: `${MESSAGE$31} (called inside "${componentOrHookName}")`
+			message: `${MESSAGE$32} (called inside "${componentOrHookName}")`
 		});
 	} })
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-create-ref-in-function-component.ts
-const MESSAGE$30 = "`createRef()` in a function component allocates a brand-new ref on every render, so it never holds a value between renders. Use the `useRef()` hook instead.";
+const MESSAGE$31 = "`createRef()` in a function component allocates a brand-new ref on every render, so it never holds a value between renders. Use the `useRef()` hook instead.";
 const isUseMemoCallbackArgument = (functionNode) => {
 	const parent = functionNode.parent;
 	if (!parent || !isNodeOfType(parent, "CallExpression")) return false;
@@ -29065,8 +30052,8 @@ const isUseMemoCallbackArgument = (functionNode) => {
 	return isReactFunctionCall(parent, "useMemo");
 };
 const findEnclosingRenderFunction = (node) => {
-	let enclosingFunction = findEnclosingFunction(node);
-	while (enclosingFunction && isUseMemoCallbackArgument(enclosingFunction)) enclosingFunction = findEnclosingFunction(enclosingFunction);
+	let enclosingFunction = findEnclosingFunction$1(node);
+	while (enclosingFunction && isUseMemoCallbackArgument(enclosingFunction)) enclosingFunction = findEnclosingFunction$1(enclosingFunction);
 	return enclosingFunction;
 };
 const noCreateRefInFunctionComponent = defineRule({
@@ -29087,7 +30074,7 @@ const noCreateRefInFunctionComponent = defineRule({
 		if (!(isReactHookName(displayName) || functionContainsReactRenderOutput(enclosingFunction, context.scopes, context.cfg))) return;
 		context.report({
 			node,
-			message: MESSAGE$30
+			message: MESSAGE$31
 		});
 	} })
 });
@@ -29227,7 +30214,7 @@ const noCreateStoreInRender = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-danger.ts
-const MESSAGE$29 = "`dangerouslySetInnerHTML` is an XSS hole that runs attacker-controlled HTML in your users' browsers.";
+const MESSAGE$30 = "`dangerouslySetInnerHTML` is an XSS hole that runs attacker-controlled HTML in your users' browsers.";
 const noDanger = defineRule({
 	id: "no-danger",
 	title: "Raw HTML injection can run unsafe markup",
@@ -29241,7 +30228,7 @@ const noDanger = defineRule({
 			if (!propAttribute) return;
 			context.report({
 				node: propAttribute.name,
-				message: MESSAGE$29
+				message: MESSAGE$30
 			});
 		},
 		CallExpression(node) {
@@ -29253,7 +30240,7 @@ const noDanger = defineRule({
 				const propertyKey = property.key;
 				if (isNodeOfType(propertyKey, "Identifier") && propertyKey.name === "dangerouslySetInnerHTML" || isNodeOfType(propertyKey, "Literal") && propertyKey.value === "dangerouslySetInnerHTML") context.report({
 					node: propertyKey,
-					message: MESSAGE$29
+					message: MESSAGE$30
 				});
 			}
 		}
@@ -29276,7 +30263,7 @@ const isMeaningfulJsxChild = (child) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/no-danger-with-children.ts
-const MESSAGE$28 = "React throws an error when you set both children & `dangerouslySetInnerHTML`.";
+const MESSAGE$29 = "React throws an error when you set both children & `dangerouslySetInnerHTML`.";
 const mergePropsShape = (target, source) => {
 	target.hasDangerously ||= source.hasDangerously;
 	target.hasChildren ||= source.hasChildren;
@@ -29351,7 +30338,7 @@ const noDangerWithChildren = defineRule({
 			if (!hasChildrenProp && !hasNestedChildren) return;
 			if (hasJsxPropIgnoreCase(opening.attributes, "dangerouslySetInnerHTML") || spreadPropsShape.hasDangerously) context.report({
 				node: opening,
-				message: MESSAGE$28
+				message: MESSAGE$29
 			});
 		},
 		CallExpression(node) {
@@ -29364,7 +30351,7 @@ const noDangerWithChildren = defineRule({
 			const positionalChildren = node.arguments.slice(2);
 			if (positionalChildren.length > 1 || positionalChildren.some((argument) => !isNullishExpression(argument)) || propsShape.hasChildren) context.report({
 				node,
-				message: MESSAGE$28
+				message: MESSAGE$29
 			});
 		}
 	})
@@ -30117,7 +31104,7 @@ const getEnclosingEffectHookCallback = (node, componentFunction) => {
 const isEffectDrivenResync = (useStateCall) => {
 	const setterName = getStateSetterName(useStateCall);
 	if (!setterName) return false;
-	const componentFunction = findEnclosingFunction(useStateCall);
+	const componentFunction = findEnclosingFunction$1(useStateCall);
 	if (!componentFunction) return false;
 	let isExempt = false;
 	walkAst(componentFunction, (child) => {
@@ -30221,7 +31208,7 @@ const isDraftReseedOrRenderAdjusted = (useStateCall, isPropName) => {
 	const setterName = getStateSetterName(useStateCall);
 	if (!setterName) return false;
 	const stateValueName = getStateValueName(useStateCall);
-	const componentFunction = findEnclosingFunction(useStateCall);
+	const componentFunction = findEnclosingFunction$1(useStateCall);
 	if (!componentFunction) return false;
 	let isExempt = false;
 	walkAst(componentFunction, (child) => {
@@ -30267,7 +31254,7 @@ const noDerivedUseState = defineRule({
 					if (isDraftReseedOrRenderAdjusted(node, propStackTracker.isPropName)) return;
 					if (isEffectDrivenResync(node)) return;
 					if (isNextjsDataFetchingPage(node)) return;
-					const componentFunction = findEnclosingFunction(node);
+					const componentFunction = findEnclosingFunction$1(node);
 					if (componentFunction) {
 						if (isDefaultedDestructuredProp(componentFunction, propName)) return;
 						if (isDraftCommittedToParent(componentFunction, getStateValueName(node), propStackTracker.isPropName)) return;
@@ -30329,7 +31316,7 @@ const isSetStateCallInLifecycle = (setStateCall, lifecycleNames, options = {}) =
 //#endregion
 //#region src/plugin/rules/react-builtins/no-did-mount-set-state.ts
 const LIFECYCLE_NAMES$2 = new Set(["componentDidMount"]);
-const MESSAGE$27 = "Your users see an extra render right after mount when you call `setState` in `componentDidMount`.";
+const MESSAGE$28 = "Your users see an extra render right after mount when you call `setState` in `componentDidMount`.";
 const getNodeStart = (node) => "start" in node && typeof node.start === "number" ? node.start : -1;
 const getEnclosingLifecycleFunction = (setStateCall) => {
 	let ancestor = setStateCall.parent;
@@ -30457,7 +31444,7 @@ const noDidMountSetState = defineRule({
 			}
 			context.report({
 				node: node.callee,
-				message: MESSAGE$27
+				message: MESSAGE$28
 			});
 		} };
 	}
@@ -30465,7 +31452,7 @@ const noDidMountSetState = defineRule({
 //#endregion
 //#region src/plugin/rules/react-builtins/no-did-update-set-state.ts
 const LIFECYCLE_NAMES$1 = new Set(["componentDidUpdate"]);
-const MESSAGE$26 = "Calling setState in componentDidUpdate can trigger another update immediately, loop forever, and freeze the component.";
+const MESSAGE$27 = "Calling setState in componentDidUpdate can trigger another update immediately, loop forever, and freeze the component.";
 const EQUALITY_OPERATORS = new Set([
 	"==",
 	"===",
@@ -30639,7 +31626,7 @@ const noDidUpdateSetState = defineRule({
 			if (isInsideDiffGuard(node)) return;
 			context.report({
 				node: node.callee,
-				message: MESSAGE$26
+				message: MESSAGE$27
 			});
 		} };
 	}
@@ -30662,7 +31649,7 @@ const isStateMemberExpression = (node) => {
 };
 //#endregion
 //#region src/plugin/rules/react-builtins/no-direct-mutation-state.ts
-const MESSAGE$25 = "Mutating `this.state` by hand never triggers a redraw on its own & a later setState can overwrite it, so use `this.setState` instead.";
+const MESSAGE$26 = "Mutating `this.state` by hand never triggers a redraw on its own & a later setState can overwrite it, so use `this.setState` instead.";
 const shouldIgnoreMutation = (node) => {
 	let isConstructor = false;
 	let isInsideCallExpression = false;
@@ -30684,7 +31671,7 @@ const reportIfStateMutation = (context, reportNode, target) => {
 	if (shouldIgnoreMutation(reportNode)) return;
 	context.report({
 		node: reportNode,
-		message: MESSAGE$25
+		message: MESSAGE$26
 	});
 };
 const noDirectMutationState = defineRule({
@@ -31035,7 +32022,7 @@ const noDocumentStartViewTransition = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/js-performance/no-document-write.ts
-const MESSAGE$24 = "`document.write()` blocks parsing, is ignored (or wipes the page) after load, and is flagged by browsers as a performance anti-pattern. Build DOM nodes or set `innerHTML`/`textContent` on a target element instead.";
+const MESSAGE$25 = "`document.write()` blocks parsing, is ignored (or wipes the page) after load, and is flagged by browsers as a performance anti-pattern. Build DOM nodes or set `innerHTML`/`textContent` on a target element instead.";
 const WRITE_METHODS = new Set(["write", "writeln"]);
 const isGlobalDocumentReference = (node, context) => node.name === "document" && context.scopes.isGlobalReference(node);
 const noDocumentWrite = defineRule({
@@ -31052,7 +32039,7 @@ const noDocumentWrite = defineRule({
 		if (methodName === null || !WRITE_METHODS.has(methodName)) return;
 		context.report({
 			node,
-			message: MESSAGE$24
+			message: MESSAGE$25
 		});
 	} })
 });
@@ -32105,7 +33092,7 @@ const isFunctionUsedOutsideHandlers = (analysis, functionNode, componentFunction
 		if (isInsideInlineEventHandler(identifier, componentFunction)) return false;
 		const parent = identifier.parent;
 		if (parent && isNodeOfType(parent, "CallExpression") && parent.callee === identifier) {
-			if (findEnclosingFunction(parent) === functionNode) return false;
+			if (findEnclosingFunction$1(parent) === functionNode) return false;
 			if (isInsideProvenEventHandler(analysis, parent, componentFunction, false)) return false;
 		}
 		return true;
@@ -32151,7 +33138,7 @@ const isStateWrittenOnlyFromEventHandlers = (analysis, stateReference) => {
 	if (!setterVariable) return false;
 	const stateDeclarator = getUseStateDecl(analysis, stateReference);
 	if (!stateDeclarator) return false;
-	const componentFunction = findEnclosingFunction(stateDeclarator);
+	const componentFunction = findEnclosingFunction$1(stateDeclarator);
 	if (!componentFunction) return false;
 	let hasWriter = false;
 	for (const reference of setterVariable.references) {
@@ -33213,8 +34200,8 @@ const isAwaitedInFunction = (request, functionNode) => {
 	return false;
 };
 const isCompletionSinkForRequest = (completionSink, request) => {
-	const requestFunction = findEnclosingFunction(request);
-	const completionSinkFunction = findEnclosingFunction(completionSink);
+	const requestFunction = findEnclosingFunction$1(request);
+	const completionSinkFunction = findEnclosingFunction$1(completionSink);
 	if (!requestFunction || !completionSinkFunction) return false;
 	if (requestFunction === completionSinkFunction) {
 		if (!isAwaitedInFunction(request, requestFunction)) return false;
@@ -33270,7 +34257,7 @@ const ALLOWED_NAMESPACES = new Set([
 	"ReactDOM",
 	"ReactDom"
 ]);
-const MESSAGE$23 = "`findDOMNode` crashes your app in React 19 because it was removed.";
+const MESSAGE$24 = "`findDOMNode` crashes your app in React 19 because it was removed.";
 const noFindDomNode = defineRule({
 	id: "no-find-dom-node",
 	title: "findDOMNode breaks component encapsulation",
@@ -33281,7 +34268,7 @@ const noFindDomNode = defineRule({
 		if (isNodeOfType(callee, "Identifier") && callee.name === "findDOMNode") {
 			if (isImportedFromModule(node, callee.name, "react-dom")) context.report({
 				node: callee,
-				message: MESSAGE$23
+				message: MESSAGE$24
 			});
 			return;
 		}
@@ -33292,7 +34279,7 @@ const noFindDomNode = defineRule({
 			if (callee.property.name !== "findDOMNode") return;
 			context.report({
 				node: callee.property,
-				message: MESSAGE$23
+				message: MESSAGE$24
 			});
 		}
 	} })
@@ -33501,13 +34488,6 @@ const isPublishedLibraryPackage = (filename) => {
 	return manifest.private !== true && typeof manifest.peerDependencies === "object" && manifest.peerDependencies !== null && "react" in manifest.peerDependencies;
 };
 //#endregion
-//#region src/plugin/utils/is-type-only-import.ts
-const isEverySpecifierInlineType = (specifiers, specifierType, kindField) => {
-	if (!specifiers || specifiers.length === 0) return false;
-	return specifiers.every((specifier) => isNodeOfType(specifier, specifierType) && specifier[kindField] === "type");
-};
-const isTypeOnlyImport = (node) => node.importKind === "type" || isEverySpecifierInlineType(node.specifiers, "ImportSpecifier", "importKind");
-//#endregion
 //#region src/plugin/rules/bundle-size/no-full-lodash-import.ts
 const isLibraryDevPage = (filename) => {
 	if (!filename) return false;
@@ -34071,7 +35051,7 @@ const isInRenderedOutput = (node, componentOrHookNode, scopes) => {
 			return attribute ? !isEventHandlerAttribute(attribute) : true;
 		}
 		if (isNodeOfType(parentNode, "ReturnStatement")) {
-			if (findEnclosingFunction(parentNode) === componentOrHookNode) return true;
+			if (findEnclosingFunction$1(parentNode) === componentOrHookNode) return true;
 		}
 		if (parentNode === componentOrHookNode) return isFunctionLike$2(componentOrHookNode) && !isNodeOfType(componentOrHookNode.body, "BlockStatement") && componentOrHookNode.body === currentNode;
 		if (isFunctionLike$2(parentNode) && !executesDuringRender(parentNode, scopes)) return false;
@@ -34194,7 +35174,7 @@ const noHydrationBranchOnBrowserGlobal = defineRule({
 				if (consequentValues.length === 0 || alternateValues.length === 0) return;
 				const componentOrHookNode = findRenderPhaseComponentOrHook(node.test, context.scopes);
 				if (!componentOrHookNode) return;
-				const enclosingFunction = findEnclosingFunction(node);
+				const enclosingFunction = findEnclosingFunction$1(node);
 				if (enclosingFunction !== componentOrHookNode && (!enclosingFunction || !isInRenderedOutput(enclosingFunction, componentOrHookNode, context.scopes))) return;
 				for (const consequentValue of consequentValues) for (const alternateValue of alternateValues) {
 					if (!isRenderedValue(consequentValue) && !isRenderedValue(alternateValue)) continue;
@@ -34206,7 +35186,7 @@ const noHydrationBranchOnBrowserGlobal = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/performance/no-img-lazy-with-high-fetchpriority.ts
-const MESSAGE$22 = "`<img loading=\"lazy\">` defers the request while `fetchPriority=\"high\"` asks the browser to rush it, so the two directives contradict each other. Drop one: keep `fetchPriority=\"high\"` (and eager loading) for an LCP image, or `loading=\"lazy\"` for a below-the-fold one.";
+const MESSAGE$23 = "`<img loading=\"lazy\">` defers the request while `fetchPriority=\"high\"` asks the browser to rush it, so the two directives contradict each other. Drop one: keep `fetchPriority=\"high\"` (and eager loading) for an LCP image, or `loading=\"lazy\"` for a below-the-fold one.";
 const noImgLazyWithHighFetchpriority = defineRule({
 	id: "no-img-lazy-with-high-fetchpriority",
 	title: "Lazy image with high fetchPriority",
@@ -34220,7 +35200,7 @@ const noImgLazyWithHighFetchpriority = defineRule({
 		if (!fetchPriorityAttribute || getJsxPropStringValue(fetchPriorityAttribute)?.toLowerCase() !== "high") return;
 		context.report({
 			node: node.name,
-			message: MESSAGE$22
+			message: MESSAGE$23
 		});
 	} })
 });
@@ -34409,7 +35389,7 @@ const noImpureStateUpdater = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/correctness/no-indeterminate-attribute.ts
-const MESSAGE$21 = "The `indeterminate` HTML attribute does not set a checkbox's visual state. Assign the `HTMLInputElement.indeterminate` DOM property instead.";
+const MESSAGE$22 = "The `indeterminate` HTML attribute does not set a checkbox's visual state. Assign the `HTMLInputElement.indeterminate` DOM property instead.";
 const REACT_USE_REF_OPTIONS = {
 	allowGlobalReactNamespace: false,
 	allowUnboundBareCalls: false
@@ -34510,7 +35490,7 @@ const noIndeterminateAttribute = defineRule({
 				if (!inputTypeValues || !inputTypeValues.every((inputTypeValue) => inputTypeValue.toLowerCase() === "checkbox")) return;
 				context.report({
 					node: indeterminateAttribute,
-					message: MESSAGE$21
+					message: MESSAGE$22
 				});
 			},
 			CallExpression(node) {
@@ -34519,7 +35499,7 @@ const noIndeterminateAttribute = defineRule({
 				if (!isProvenHtmlInputElement(receiver, context.scopes)) return;
 				context.report({
 					node,
-					message: MESSAGE$21
+					message: MESSAGE$22
 				});
 			}
 		};
@@ -34642,10 +35622,10 @@ const isInsideInstanceField = (node) => {
 	return false;
 };
 const isOneShotModuleInitialization = (node, context) => {
-	let functionNode = findEnclosingFunction(node);
+	let functionNode = findEnclosingFunction$1(node);
 	while (functionNode) {
 		if (!executesDuringRender(functionNode, context.scopes)) return false;
-		functionNode = findEnclosingFunction(functionNode);
+		functionNode = findEnclosingFunction$1(functionNode);
 	}
 	return !isInsideInstanceField(node);
 };
@@ -34807,7 +35787,7 @@ const noIsMounted = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/js-performance/no-json-parse-stringify-clone.ts
-const MESSAGE$20 = "`JSON.parse(JSON.stringify(x))` deep-clones by re-serializing: it is slow on large objects and silently drops `undefined`, functions, `Date`/`Map`/`Set`, and cyclic references. Use `structuredClone(x)`.";
+const MESSAGE$21 = "`JSON.parse(JSON.stringify(x))` deep-clones by re-serializing: it is slow on large objects and silently drops `undefined`, functions, `Date`/`Map`/`Set`, and cyclic references. Use `structuredClone(x)`.";
 const isJsonMethodCall = (node, method) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
 	const callee = node.callee;
@@ -34871,13 +35851,13 @@ const noJsonParseStringifyClone = defineRule({
 		if (isCatchParameterRoundTrip(firstArgument)) return;
 		context.report({
 			node,
-			message: MESSAGE$20
+			message: MESSAGE$21
 		});
 	} })
 });
 //#endregion
 //#region src/plugin/rules/correctness/no-jsx-element-type.ts
-const MESSAGE$19 = "`JSX.Element` is too narrow: it excludes `null`, strings, numbers, and fragments that components commonly return. Use `React.ReactNode` instead.";
+const MESSAGE$20 = "`JSX.Element` is too narrow: it excludes `null`, strings, numbers, and fragments that components commonly return. Use `React.ReactNode` instead.";
 const isJsxElementTypeReference = (node) => {
 	if (!isNodeOfType(node, "TSTypeReference")) return false;
 	const typeName = node.typeName;
@@ -34931,7 +35911,7 @@ const noJsxElementType = defineRule({
 				if (isJsxImported) return;
 				for (const typeAnnotation of flaggedAnnotations) context.report({
 					node: typeAnnotation,
-					message: MESSAGE$19
+					message: MESSAGE$20
 				});
 			}
 		};
@@ -35163,6 +36143,221 @@ const noLegacyClassLifecycles = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/is-proven-react-class-component.ts
+const REACT_COMPONENT_CLASS_NAMES = new Set(["Component", "PureComponent"]);
+const isReactComponentClassValue = (node, scopes, visitedClassNodes, visitedSymbolIds) => {
+	const expression = stripParenExpression(node);
+	if (isNodeOfType(expression, "MemberExpression")) {
+		const propertyName = getStaticPropertyName(expression);
+		const receiver = stripParenExpression(expression.object);
+		return Boolean(propertyName && REACT_COMPONENT_CLASS_NAMES.has(propertyName) && isNodeOfType(receiver, "Identifier") && !hasStaticPropertyWriteBefore(receiver, propertyName, expression, scopes) && isReactNamespaceImport(receiver, scopes));
+	}
+	if (isNodeOfType(expression, "ClassExpression")) return isProvenReactClassComponent(expression, scopes, visitedClassNodes, visitedSymbolIds);
+	if (!isNodeOfType(expression, "Identifier")) return false;
+	const symbol = scopes.symbolFor(expression);
+	if (!symbol || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, expression, scopes)) return false;
+	visitedSymbolIds.add(symbol.id);
+	if (isImportedFromReact(symbol)) {
+		const importedName = getImportedName(symbol.declarationNode);
+		return Boolean(importedName && REACT_COMPONENT_CLASS_NAMES.has(importedName));
+	}
+	if (isNodeOfType(symbol.declarationNode, "ClassDeclaration") || isNodeOfType(symbol.declarationNode, "ClassExpression")) return isProvenReactClassComponent(symbol.declarationNode, scopes, visitedClassNodes, visitedSymbolIds);
+	return Boolean(symbol.kind === "const" && symbol.initializer && isReactComponentClassValue(symbol.initializer, scopes, visitedClassNodes, visitedSymbolIds));
+};
+const isProvenReactClassComponent = (classNode, scopes, visitedClassNodes = /* @__PURE__ */ new Set(), visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (!isNodeOfType(classNode, "ClassDeclaration") && !isNodeOfType(classNode, "ClassExpression") || visitedClassNodes.has(classNode) || !classNode.superClass) return false;
+	visitedClassNodes.add(classNode);
+	return isReactComponentClassValue(classNode.superClass, scopes, visitedClassNodes, visitedSymbolIds);
+};
+//#endregion
+//#region src/plugin/utils/function-contains-proven-react-hook-call.ts
+const functionContainsProvenReactHookCall = (functionNode, scopes) => {
+	if (!isFunctionLike$2(functionNode)) return false;
+	let containsReactHookCall = false;
+	walkAst(functionNode.body, (node) => {
+		if (containsReactHookCall) return false;
+		if (node !== functionNode.body && (isFunctionLike$2(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
+		if (isNodeOfType(node, "CallExpression") && isReactApiCall(node, BUILTIN_HOOK_NAMES, scopes, { resolveNamedAliases: true })) {
+			containsReactHookCall = true;
+			return false;
+		}
+	});
+	return containsReactHookCall;
+};
+//#endregion
+//#region src/plugin/utils/function-returns-props-children.ts
+const functionReturnsPropsChildren = (functionNode, scopes, controlFlow) => {
+	if (!isFunctionLike$2(functionNode) || functionNode.params.length === 0) return false;
+	const firstParameter = stripParenExpression(functionNode.params[0]);
+	const firstParameterPattern = isNodeOfType(firstParameter, "AssignmentPattern") ? stripParenExpression(firstParameter.left) : firstParameter;
+	const propsParameterSymbol = isNodeOfType(firstParameterPattern, "Identifier") ? scopes.symbolFor(firstParameterPattern) : null;
+	const childrenBindingSymbolIds = /* @__PURE__ */ new Set();
+	if (isNodeOfType(firstParameterPattern, "ObjectPattern")) {
+		for (const property of firstParameterPattern.properties) if (isNodeOfType(property, "Property") && getStaticPropertyKeyName(property, { allowComputedString: true }) === "children") {
+			const propertyValue = stripParenExpression(property.value);
+			const childrenBinding = isNodeOfType(propertyValue, "AssignmentPattern") ? stripParenExpression(propertyValue.left) : propertyValue;
+			if (!isNodeOfType(childrenBinding, "Identifier")) continue;
+			const childrenBindingSymbol = scopes.symbolFor(childrenBinding);
+			if (childrenBindingSymbol) childrenBindingSymbolIds.add(childrenBindingSymbol.id);
+		}
+	}
+	return functionReturnsMatchingExpression(functionNode, scopes, (expression) => {
+		const candidate = stripParenExpression(expression);
+		if (isNodeOfType(candidate, "Identifier")) {
+			const symbol = scopes.symbolFor(candidate);
+			return Boolean(symbol && childrenBindingSymbolIds.has(symbol.id) && !hasSymbolWriteBefore(symbol, candidate, scopes));
+		}
+		if (!isNodeOfType(candidate, "MemberExpression")) return false;
+		if (getStaticPropertyName(candidate) !== "children") return false;
+		const receiver = stripParenExpression(candidate.object);
+		if (!isNodeOfType(receiver, "Identifier")) return false;
+		const receiverSymbol = scopes.symbolFor(receiver);
+		if (!receiverSymbol || !propsParameterSymbol) return false;
+		return receiverSymbol.id === propsParameterSymbol.id && !hasSymbolWriteBefore(receiverSymbol, candidate, scopes) && !hasStaticPropertyWriteBefore(receiver, "children", candidate, scopes);
+	}, controlFlow);
+};
+//#endregion
+//#region src/plugin/utils/function-returns-only-null.ts
+const isNullExpression = (expression) => {
+	const candidate = stripParenExpression(expression);
+	return isNodeOfType(candidate, "Literal") && candidate.value === null;
+};
+const functionReturnsOnlyNull = (functionNode) => {
+	if (!isFunctionLike$2(functionNode)) return false;
+	if (!isNodeOfType(functionNode.body, "BlockStatement")) return isNullExpression(functionNode.body);
+	const returnStatements = collectFunctionReturnStatements(functionNode);
+	return returnStatements.length > 0 && returnStatements.every((returnStatement) => Boolean(returnStatement.argument && isNullExpression(returnStatement.argument)));
+};
+//#endregion
+//#region src/plugin/utils/is-proven-styled-component-expression.ts
+const findFactoryRoot = (node) => {
+	const candidate = stripParenExpression(node);
+	if (isNodeOfType(candidate, "Identifier")) return candidate;
+	if (isNodeOfType(candidate, "MemberExpression")) return findFactoryRoot(candidate.object);
+	if (isNodeOfType(candidate, "CallExpression")) return findFactoryRoot(candidate.callee);
+	return null;
+};
+const findFactoryPropertyName = (node) => {
+	const candidate = stripParenExpression(node);
+	if (isNodeOfType(candidate, "MemberExpression")) return findFactoryPropertyName(candidate.object) ?? getStaticPropertyName(candidate);
+	if (isNodeOfType(candidate, "CallExpression")) return findFactoryPropertyName(candidate.callee);
+	return null;
+};
+const isProvenStyledComponentExpression = (expression, scopes) => {
+	const candidate = stripParenExpression(expression);
+	if (!isNodeOfType(candidate, "TaggedTemplateExpression")) return false;
+	const factoryRoot = findFactoryRoot(candidate.tag);
+	if (!factoryRoot) return false;
+	const factoryPropertyName = findFactoryPropertyName(candidate.tag);
+	if (factoryPropertyName && hasStaticPropertyWriteBefore(factoryRoot, factoryPropertyName, candidate, scopes)) return false;
+	const symbol = resolveConstIdentifierAlias(factoryRoot, scopes);
+	if (!symbol || symbol.kind !== "import") return false;
+	if (!(isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || getImportedName(symbol.declarationNode) === "styled")) return false;
+	const importDeclaration = symbol.declarationNode.parent;
+	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && importDeclaration.source.value === "styled-components");
+};
+//#endregion
+//#region src/plugin/utils/is-proven-react-component-symbol.ts
+const REACT_COMPONENT_HOC_NAMES = new Set(["memo", "forwardRef"]);
+const LEGACY_REACT_COMPONENT_FACTORY_NAMES = new Set(["createClass", "createReactClass"]);
+const functionHasComponentEvidence = (functionNode, scopes, controlFlow) => functionContainsReactRenderOutput(functionNode, scopes, controlFlow) || functionReturnsPropsChildren(functionNode, scopes, controlFlow) || functionContainsProvenReactHookCall(functionNode, scopes) && functionReturnsOnlyNull(functionNode);
+const isProvenReactComponentExpression = (expression, scopes, controlFlow, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isInlineFunctionExpression(candidate)) return functionHasComponentEvidence(candidate, scopes, controlFlow);
+	if (isNodeOfType(candidate, "ClassExpression")) return isProvenReactClassComponent(candidate, scopes);
+	if (isProvenStyledComponentExpression(candidate, scopes)) return true;
+	if (isNodeOfType(candidate, "Identifier")) {
+		const symbol = scopes.symbolFor(candidate);
+		if (!symbol || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, candidate, scopes)) return false;
+		visitedSymbolIds.add(symbol.id);
+		if (isNodeOfType(symbol.declarationNode, "FunctionDeclaration")) return functionHasComponentEvidence(symbol.declarationNode, scopes, controlFlow);
+		if (isNodeOfType(symbol.declarationNode, "ClassDeclaration") || isNodeOfType(symbol.declarationNode, "ClassExpression")) return isProvenReactClassComponent(symbol.declarationNode, scopes);
+		return Boolean(symbol.initializer && isProvenReactComponentExpression(symbol.initializer, scopes, controlFlow, visitedSymbolIds));
+	}
+	if (!isNodeOfType(candidate, "CallExpression")) return false;
+	if (!hasStableCallTarget(candidate, scopes)) return false;
+	const factoryCallee = stripParenExpression(candidate.callee);
+	if (isNodeOfType(factoryCallee, "Identifier") && isDefaultImportFromModule(factoryCallee, factoryCallee.name, "create-react-class") || isReactApiCall(candidate, LEGACY_REACT_COMPONENT_FACTORY_NAMES, scopes)) return true;
+	if (isReactApiCall(candidate, REACT_COMPONENT_HOC_NAMES, scopes, { resolveNamedAliases: true })) {
+		const wrappedComponent = candidate.arguments[0];
+		return Boolean(wrappedComponent && !isNodeOfType(wrappedComponent, "SpreadElement") && isProvenReactComponentExpression(wrappedComponent, scopes, controlFlow, visitedSymbolIds));
+	}
+	if (!isReactApiCall(candidate, "useMemo", scopes, { resolveNamedAliases: true })) return false;
+	const factory = candidate.arguments[0];
+	if (!factory || isNodeOfType(factory, "SpreadElement")) return false;
+	const unwrappedFactory = stripParenExpression(factory);
+	if (!isInlineFunctionExpression(unwrappedFactory)) return false;
+	if (!isNodeOfType(unwrappedFactory.body, "BlockStatement")) return isProvenReactComponentExpression(unwrappedFactory.body, scopes, controlFlow, visitedSymbolIds);
+	const returnStatements = collectFunctionReturnStatements(unwrappedFactory);
+	const returnedExpression = returnStatements[0]?.argument;
+	return Boolean(returnStatements.length === 1 && returnedExpression && isProvenReactComponentExpression(returnedExpression, scopes, controlFlow, visitedSymbolIds));
+};
+const isProvenReactComponentSymbol = (symbol, scopes, controlFlow, componentReference) => {
+	const candidateSymbols = symbol.kind === "ts-module" ? symbol.scope.symbols.filter((candidateSymbol) => candidateSymbol.name === symbol.name && candidateSymbol.kind !== "ts-module") : [symbol];
+	for (const candidateSymbol of candidateSymbols) {
+		if (hasSymbolWriteBefore(candidateSymbol, componentReference, scopes)) continue;
+		if (isComponentDeclaration(candidateSymbol.declarationNode)) {
+			if (functionHasComponentEvidence(candidateSymbol.declarationNode, scopes, controlFlow)) return true;
+			continue;
+		}
+		const initializer = candidateSymbol.initializer ? stripParenExpression(candidateSymbol.initializer) : null;
+		if (isNodeOfType(candidateSymbol.declarationNode, "VariableDeclarator") && isNodeOfType(candidateSymbol.declarationNode.id, "Identifier") && isUppercaseName(candidateSymbol.declarationNode.id.name) && initializer) {
+			if (isProvenReactComponentExpression(initializer, scopes, controlFlow)) return true;
+			continue;
+		}
+		if (isNodeOfType(candidateSymbol.declarationNode, "ClassDeclaration") || isNodeOfType(candidateSymbol.declarationNode, "ClassExpression")) {
+			if (isProvenReactClassComponent(candidateSymbol.declarationNode, scopes)) return true;
+			continue;
+		}
+		if (initializer && isNodeOfType(initializer, "ClassExpression") && isProvenReactClassComponent(initializer, scopes)) return true;
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/utils/symbol-has-react-component-type-annotation.ts
+const REACT_COMPONENT_TYPE_NAMES = new Set([
+	"ComponentClass",
+	"ComponentType",
+	"FC",
+	"FunctionComponent"
+]);
+const findVisibleSymbol = (identifier, scopes) => {
+	if (!isNodeOfType(identifier, "Identifier")) return null;
+	let scope = scopes.scopeFor(identifier);
+	while (true) {
+		const symbol = scope.symbolsByName.get(identifier.name);
+		if (symbol) return symbol;
+		if (!scope.parent) return null;
+		scope = scope.parent;
+	}
+};
+const isReactNamespaceType = (identifier, scopes) => {
+	const symbol = findVisibleSymbol(identifier, scopes);
+	return Boolean(symbol && isImportedFromReact(symbol) && (isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier")));
+};
+const isReactComponentType = (typeNode, scopes, visitedSymbolIds) => {
+	if (!typeNode) return false;
+	if (isNodeOfType(typeNode, "TSTypeAnnotation")) return isReactComponentType(typeNode.typeAnnotation, scopes, visitedSymbolIds);
+	if (isNodeOfType(typeNode, "TSIntersectionType")) return (typeNode.types ?? []).some((member) => isReactComponentType(member, scopes, visitedSymbolIds));
+	if (!isNodeOfType(typeNode, "TSTypeReference")) return false;
+	const typeName = typeNode.typeName;
+	if (isNodeOfType(typeName, "TSQualifiedName")) return isNodeOfType(typeName.left, "Identifier") && isNodeOfType(typeName.right, "Identifier") && REACT_COMPONENT_TYPE_NAMES.has(typeName.right.name) && isReactNamespaceType(typeName.left, scopes);
+	if (!isNodeOfType(typeName, "Identifier")) return false;
+	const typeSymbol = findVisibleSymbol(typeName, scopes);
+	if (!typeSymbol || visitedSymbolIds.has(typeSymbol.id)) return false;
+	if (isImportedFromReact(typeSymbol)) {
+		const importedName = getImportedName(typeSymbol.declarationNode);
+		return Boolean(importedName && REACT_COMPONENT_TYPE_NAMES.has(importedName));
+	}
+	if (!isNodeOfType(typeSymbol.declarationNode, "TSTypeAliasDeclaration")) return false;
+	visitedSymbolIds.add(typeSymbol.id);
+	return isReactComponentType(typeSymbol.declarationNode.typeAnnotation, scopes, visitedSymbolIds);
+};
+const symbolHasReactComponentTypeAnnotation = (symbol, scopes) => {
+	const bindingIdentifier = symbol.bindingIdentifier;
+	return isNodeOfType(bindingIdentifier, "Identifier") && isReactComponentType(bindingIdentifier.typeAnnotation, scopes, /* @__PURE__ */ new Set());
+};
+//#endregion
 //#region src/plugin/rules/architecture/no-legacy-context-api.ts
 const LEGACY_CONTEXT_NAMES = new Set([
 	"childContextTypes",
@@ -35173,15 +36368,6 @@ const buildLegacyContextMessage = (memberName) => {
 	if (memberName === "childContextTypes" || memberName === "getChildContext") return `${memberName} uses the old context API that React 19 removes, so your provider stops passing data. Switch to \`createContext\` with \`<MyContext.Provider value={...}>\` & read it with \`useContext()\`, moving every consumer together.`;
 	return "contextTypes uses the old context API that React 19 removes, so your component stops receiving context. Use `static contextType = MyContext` or `useContext()` in a function component, & update the provider too.";
 };
-const isInsideClassBody = (node) => {
-	let current = node.parent;
-	while (current) {
-		if (isNodeOfType(current, "ClassBody")) return true;
-		if (isFunctionLike$2(current)) return false;
-		current = current.parent;
-	}
-	return false;
-};
 const noLegacyContextApi = defineRule({
 	id: "no-legacy-context-api",
 	title: "Legacy context API",
@@ -35196,6 +36382,7 @@ const noLegacyContextApi = defineRule({
 			if (!isNodeOfType(memberNode, "MethodDefinition") && !isNodeOfType(memberNode, "PropertyDefinition")) return;
 			if (!isNodeOfType(memberNode.key, "Identifier")) return;
 			if (!LEGACY_CONTEXT_NAMES.has(memberNode.key.name)) return;
+			if (memberNode.key.name === "getChildContext" ? memberNode.static : !memberNode.static) return;
 			context.report({
 				node: memberNode.key,
 				message: buildLegacyContextMessage(memberNode.key.name)
@@ -35203,6 +36390,8 @@ const noLegacyContextApi = defineRule({
 		};
 		return {
 			ClassBody(node) {
+				const classNode = node.parent;
+				if (!classNode || !isProvenReactClassComponent(classNode, context.scopes)) return;
 				for (const member of node.body ?? []) checkMember(member);
 			},
 			AssignmentExpression(node) {
@@ -35212,9 +36401,11 @@ const noLegacyContextApi = defineRule({
 				if (left.computed) return;
 				if (!isNodeOfType(left.property, "Identifier")) return;
 				if (!LEGACY_CONTEXT_NAMES.has(left.property.name)) return;
-				if (!isNodeOfType(left.object, "Identifier")) return;
-				if (!isUppercaseName(left.object.name)) return;
-				if (isInsideClassBody(node)) return;
+				if (left.property.name === "getChildContext") return;
+				const component = stripParenExpression(left.object);
+				if (!isNodeOfType(component, "Identifier")) return;
+				const symbol = context.scopes.symbolFor(component);
+				if (!symbol || !isProvenReactComponentSymbol(symbol, context.scopes, context.cfg, component) && (hasSymbolWriteBefore(symbol, component, context.scopes) || !symbolHasReactComponentTypeAnnotation(symbol, context.scopes))) return;
 				context.report({
 					node: left,
 					message: buildLegacyContextMessage(left.property.name)
@@ -35418,10 +36609,10 @@ const getMethodCalls = (functionNode, scopes) => {
 const isFunctionInvokedBeforeUsage = (functionNode, usageNode, usageBoundary, scopes, visitedSymbolIds, visitedFunctionNodes = /* @__PURE__ */ new Set()) => {
 	if (visitedFunctionNodes.has(functionNode)) return false;
 	visitedFunctionNodes.add(functionNode);
-	const usageFunction = findEnclosingFunction(usageNode);
+	const usageFunction = findEnclosingFunction$1(usageNode);
 	const immediateCall = getDirectCallForExpression(functionNode);
 	if (immediateCall) {
-		const immediateCallFunction = findEnclosingFunction(immediateCall);
+		const immediateCallFunction = findEnclosingFunction$1(immediateCall);
 		if (immediateCallFunction === usageFunction) {
 			const immediateCallStart = getRangeStart(immediateCall);
 			return immediateCallStart === null || immediateCallStart < usageBoundary;
@@ -35430,7 +36621,7 @@ const isFunctionInvokedBeforeUsage = (functionNode, usageNode, usageBoundary, sc
 		return isFunctionInvokedBeforeUsage(immediateCallFunction, usageNode, usageBoundary, scopes, visitedSymbolIds, new Set(visitedFunctionNodes));
 	}
 	for (const methodCall of getMethodCalls(functionNode, scopes)) {
-		const methodCallFunction = findEnclosingFunction(methodCall);
+		const methodCallFunction = findEnclosingFunction$1(methodCall);
 		if (methodCallFunction === usageFunction) {
 			const methodCallStart = getRangeStart(methodCall);
 			if (methodCallStart === null || methodCallStart < usageBoundary) return true;
@@ -35453,7 +36644,7 @@ const isFunctionInvokedBeforeUsage = (functionNode, usageNode, usageBoundary, sc
 		if (scopes.symbolFor(child)?.declarationNode !== symbol.declarationNode) return;
 		const call = getDirectCallForExpression(child);
 		if (!call) return false;
-		const callFunction = findEnclosingFunction(call);
+		const callFunction = findEnclosingFunction$1(call);
 		if (callFunction === usageFunction) {
 			const callStart = getRangeStart(call);
 			wasInvokedBeforeUsage = callStart === null || callStart < usageBoundary;
@@ -35484,14 +36675,14 @@ const wasMutatedBeforeUsage = (symbol, usageNode, readNode, scopes, visitedMutat
 	visitedMutationSymbolIds.add(symbol.id);
 	const usageBoundary = inheritedUsageBoundary === void 0 ? getMutationUsageBoundary(usageNode, readNode) : inheritedUsageBoundary;
 	if (typeof usageBoundary !== "number") return true;
-	const usageFunction = findEnclosingFunction(usageNode);
+	const usageFunction = findEnclosingFunction$1(usageNode);
 	return symbol.references.some((reference) => {
 		const referenceStart = getRangeStart(reference.identifier);
 		const simpleAlias = getSimpleAlias(reference.identifier, scopes);
 		if (simpleAlias) return wasMutatedBeforeUsage(simpleAlias.symbol, usageNode, readNodesBySymbolId.get(simpleAlias.symbol.id) ?? simpleAlias.readNode, scopes, new Set(visitedMutationSymbolIds), usageBoundary, readNodesBySymbolId);
 		if (!isPotentialMutationReference(reference.identifier, readNode)) return false;
 		if (referenceStart === null) return true;
-		const mutationFunction = findEnclosingFunction(reference.identifier);
+		const mutationFunction = findEnclosingFunction$1(reference.identifier);
 		if (mutationFunction === usageFunction) return referenceStart < usageBoundary;
 		if (!mutationFunction) return usageFunction !== null;
 		if (usageFunction && isAstDescendant(usageFunction, mutationFunction)) return true;
@@ -36036,7 +37227,7 @@ const noMoment = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-multi-comp.ts
-const MESSAGE$18 = "This file declares several components, so each component is harder to find, test, and change.";
+const MESSAGE$19 = "This file declares several components, so each component is harder to find, test, and change.";
 const resolveSettings$16 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { ignoreStateless: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noMultiComp ?? {} : {}).ignoreStateless ?? false };
@@ -36073,13 +37264,6 @@ const isReactNamespaceExpression = (node, scopes) => {
 	return isReactNamespaceImport(node, scopes);
 };
 const isReactHocMemberReference = (node, scopes) => Boolean(isNodeOfType(node, "MemberExpression") && !node.computed && isNodeOfType(node.property, "Identifier") && REACT_HOC_NAMES.has(node.property.name) && isReactNamespaceExpression(node.object, scopes));
-const getDestructuredPropertyName$1 = (symbol) => {
-	const property = symbol.bindingIdentifier.parent;
-	if (!property || !isNodeOfType(property, "Property") || !property.parent || !isNodeOfType(property.parent, "ObjectPattern")) return null;
-	if (isNodeOfType(property.key, "Identifier") && !property.computed) return property.key.name;
-	if (isNodeOfType(property.key, "Literal") && typeof property.key.value === "string") return property.key.value;
-	return null;
-};
 const symbolMapsToHoc = (symbol, scopes, visitedSymbolIds) => {
 	if (visitedSymbolIds.has(symbol.id)) return false;
 	visitedSymbolIds.add(symbol.id);
@@ -36089,7 +37273,7 @@ const symbolMapsToHoc = (symbol, scopes, visitedSymbolIds) => {
 	}
 	const init = symbol.initializer;
 	if (!init) return false;
-	const destructuredPropertyName = getDestructuredPropertyName$1(symbol);
+	const destructuredPropertyName = getDestructuredBindingPropertyName(symbol.bindingIdentifier);
 	if (destructuredPropertyName && REACT_HOC_NAMES.has(destructuredPropertyName) && isReactNamespaceExpression(init, scopes)) return true;
 	if (isReactHocMemberReference(init, scopes)) return true;
 	if (isNodeOfType(init, "Identifier")) {
@@ -36395,7 +37579,7 @@ const noMultiComp = defineRule({
 			if (isSmallFeatureModule || isLargeFeatureModule || isVeryLargeFeatureModule) return;
 			for (const component of flagged.slice(1)) context.report({
 				node: component.reportNode,
-				message: MESSAGE$18
+				message: MESSAGE$19
 			});
 		} };
 	}
@@ -36608,7 +37792,7 @@ const resolveReducerFunction = (node, currentFilename) => {
 };
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-mutating-reducer-state.ts
-const MESSAGE$17 = "This reducer changes state in place, so your update is silently skipped.";
+const MESSAGE$18 = "This reducer changes state in place, so your update is silently skipped.";
 const SAME_REFERENCE_ARRAY_RETURN_METHODS = new Set([
 	"copyWithin",
 	"fill",
@@ -36817,7 +38001,7 @@ const analyzeReactUseReducerFunctionForStateMutation = (context, functionNode, r
 			reportedNodes.add(options.crossFileConsumerCallSite);
 			context.report({
 				node: options.crossFileConsumerCallSite,
-				message: `${MESSAGE$17} (mutation in imported reducer at \`${options.crossFileSourceDisplay}\`)`
+				message: `${MESSAGE$18} (mutation in imported reducer at \`${options.crossFileSourceDisplay}\`)`
 			});
 			return;
 		}
@@ -36826,7 +38010,7 @@ const analyzeReactUseReducerFunctionForStateMutation = (context, functionNode, r
 			reportedNodes.add(mutation.node);
 			context.report({
 				node: mutation.node,
-				message: MESSAGE$17
+				message: MESSAGE$18
 			});
 		}
 	};
@@ -37233,7 +38417,7 @@ const noNoninteractiveElementToInteractiveRole = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/a11y/no-noninteractive-tabindex.ts
-const MESSAGE$16 = "Keyboard users get stuck focusing this element they can't act on because `tabIndex` makes it tabbable, so remove it.";
+const MESSAGE$17 = "Keyboard users get stuck focusing this element they can't act on because `tabIndex` makes it tabbable, so remove it.";
 const KEYBOARD_HANDLER_PROP_NAMES = [
 	"onKeyDown",
 	"onKeyUp",
@@ -37352,7 +38536,7 @@ const noNoninteractiveTabindex = defineRule({
 			if (numeric === null) {
 				if (isNodeOfType(tabIndexValue, "JSXExpressionContainer") && !settings.allowExpressionValues && !isKeyboardOperable(node) && !isFocusOperable(node) && !hasJsxSpreadAttribute$1(node.attributes)) context.report({
 					node: tabIndex,
-					message: MESSAGE$16
+					message: MESSAGE$17
 				});
 				return;
 			}
@@ -37374,7 +38558,7 @@ const noNoninteractiveTabindex = defineRule({
 			if (!roleAttribute) {
 				context.report({
 					node: tabIndex,
-					message: MESSAGE$16
+					message: MESSAGE$17
 				});
 				return;
 			}
@@ -37388,7 +38572,7 @@ const noNoninteractiveTabindex = defineRule({
 			}
 			context.report({
 				node: tabIndex,
-				message: MESSAGE$16
+				message: MESSAGE$17
 			});
 		} };
 	}
@@ -37815,8 +38999,6 @@ const getWrapperHookWrappedFunction = (initializer) => {
 	if (!wrapped || !isFunctionLike$2(wrapped)) return null;
 	return wrapped;
 };
-const hasParameterDef = (ref) => Boolean(ref.resolved?.defs.some((def) => def.type === "Parameter"));
-const resolvesToFunctionBinding = (ref) => !hasParameterDef(ref) && Boolean(resolveToFunction(ref));
 const HANDLER_NAMED_PROP_PATTERN = /^(on|handle)[A-Z]/;
 const wrappedFunctionNotifiesParent = (analysis, wrappedFunction) => getDownstreamRefs(analysis, wrappedFunction).some((innerRef) => {
 	if (!isProp(analysis, innerRef)) return false;
@@ -37845,12 +39027,6 @@ const getDeclarationKind = (declarator) => {
 	return declaration && isNodeOfType(declaration, "VariableDeclaration") ? declaration.kind : null;
 };
 const hasMutableBindingWrite = (reference) => Boolean(reference.resolved?.references.some((candidateReference) => candidateReference.isWrite() && !candidateReference.init));
-const getDestructuredPropertyName = (bindingIdentifier) => {
-	const property = bindingIdentifier.parent;
-	if (!property || !isNodeOfType(property, "Property")) return null;
-	if (property.computed) return isNodeOfType(property.key, "Literal") && typeof property.key.value === "string" ? String(property.key.value) : null;
-	return isNodeOfType(property.key, "Identifier") ? property.key.name : null;
-};
 const getParentCallbackPropName = (analysis, expression, visitedVariables = /* @__PURE__ */ new Set()) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	if (isNodeOfType(unwrappedExpression, "Identifier")) {
@@ -37860,7 +39036,7 @@ const getParentCallbackPropName = (analysis, expression, visitedVariables = /* @
 		if (isProp(analysis, callbackReference)) {
 			if (isWholePropsObjectReference(analysis, callbackReference)) return null;
 			const bindingIdentifier = callbackVariable.defs.find((definition) => definition.type === "Parameter")?.name;
-			return (bindingIdentifier && getDestructuredPropertyName(bindingIdentifier)) ?? unwrappedExpression.name;
+			return (bindingIdentifier && getDestructuredBindingPropertyName(bindingIdentifier)) ?? unwrappedExpression.name;
 		}
 		if (hasMutableBindingWrite(callbackReference)) return null;
 		const definitions = callbackVariable.defs.map((definition) => definition.node).filter((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
@@ -37870,7 +39046,7 @@ const getParentCallbackPropName = (analysis, expression, visitedVariables = /* @
 		visitedVariables.add(callbackVariable);
 		if (isNodeOfType(declarator.id, "ObjectPattern")) {
 			const bindingIdentifier = callbackVariable.defs[0]?.name;
-			const propertyName = bindingIdentifier ? getDestructuredPropertyName(bindingIdentifier) : null;
+			const propertyName = bindingIdentifier ? getDestructuredBindingPropertyName(bindingIdentifier) : null;
 			const propsReference = getDownstreamRefs(analysis, declarator.init).find((candidateReference) => isWholePropsObjectReference(analysis, candidateReference));
 			return propertyName && propsReference ? propertyName : null;
 		}
@@ -37973,7 +39149,7 @@ const getCallbackRefProvenance = (analysis, effectCall, callExpression, isReactU
 	const bindingProvenance = getRefBindingProvenance(analysis, stripParenExpression(callee.object), isReactUseRefCall);
 	if (!bindingProvenance) return null;
 	const { refCall, variables } = bindingProvenance;
-	const componentFunction = findEnclosingFunction(effectCall);
+	const componentFunction = findEnclosingFunction$1(effectCall);
 	if (!componentFunction || !isFunctionLike$2(componentFunction) || !isComponentFunction$1(componentFunction) || !isNodeOfType(componentFunction.body, "BlockStatement")) return null;
 	if (!getDirectComponentBodyStatement(effectCall, componentFunction.body)) return null;
 	const callbackPropNames = /* @__PURE__ */ new Set();
@@ -38137,7 +39313,7 @@ const noPassDataToParent = defineRule({
 					if (isConstant(argRef)) return false;
 					if (isParentWiredHookResultRef(analysis, argRef)) return false;
 					if (isParentWiredHookCalleeRef(analysis, argRef)) return false;
-					if (resolvesToFunctionBinding(argRef)) return false;
+					if (resolveToFunction(argRef)) return false;
 					const argIdentifier = argRef.identifier;
 					if (isImportBindingRef(argRef) && !isCalleePosition(argIdentifier)) return false;
 					if (isNodeOfType(argIdentifier, "Identifier") && argIdentifier.name === "undefined") return false;
@@ -38809,174 +39985,6 @@ const noPropCallbackInRender = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/is-proven-react-class-component.ts
-const REACT_COMPONENT_CLASS_NAMES = new Set(["Component", "PureComponent"]);
-const isReactComponentClassValue = (node, scopes, visitedClassNodes, visitedSymbolIds) => {
-	const expression = stripParenExpression(node);
-	if (isNodeOfType(expression, "MemberExpression")) {
-		const propertyName = getStaticPropertyName(expression);
-		const receiver = stripParenExpression(expression.object);
-		return Boolean(propertyName && REACT_COMPONENT_CLASS_NAMES.has(propertyName) && isNodeOfType(receiver, "Identifier") && !hasStaticPropertyWriteBefore(receiver, propertyName, expression, scopes) && isReactNamespaceImport(receiver, scopes));
-	}
-	if (isNodeOfType(expression, "ClassExpression")) return isProvenReactClassComponent(expression, scopes, visitedClassNodes, visitedSymbolIds);
-	if (!isNodeOfType(expression, "Identifier")) return false;
-	const symbol = scopes.symbolFor(expression);
-	if (!symbol || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, expression, scopes)) return false;
-	visitedSymbolIds.add(symbol.id);
-	if (isImportedFromReact(symbol)) {
-		const importedName = getImportedName(symbol.declarationNode);
-		return Boolean(importedName && REACT_COMPONENT_CLASS_NAMES.has(importedName));
-	}
-	if (isNodeOfType(symbol.declarationNode, "ClassDeclaration") || isNodeOfType(symbol.declarationNode, "ClassExpression")) return isProvenReactClassComponent(symbol.declarationNode, scopes, visitedClassNodes, visitedSymbolIds);
-	return Boolean(symbol.kind === "const" && symbol.initializer && isReactComponentClassValue(symbol.initializer, scopes, visitedClassNodes, visitedSymbolIds));
-};
-const isProvenReactClassComponent = (classNode, scopes, visitedClassNodes = /* @__PURE__ */ new Set(), visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	if (!isNodeOfType(classNode, "ClassDeclaration") && !isNodeOfType(classNode, "ClassExpression") || visitedClassNodes.has(classNode) || !classNode.superClass) return false;
-	visitedClassNodes.add(classNode);
-	return isReactComponentClassValue(classNode.superClass, scopes, visitedClassNodes, visitedSymbolIds);
-};
-//#endregion
-//#region src/plugin/utils/function-contains-proven-react-hook-call.ts
-const functionContainsProvenReactHookCall = (functionNode, scopes) => {
-	if (!isFunctionLike$2(functionNode)) return false;
-	let containsReactHookCall = false;
-	walkAst(functionNode.body, (node) => {
-		if (containsReactHookCall) return false;
-		if (node !== functionNode.body && (isFunctionLike$2(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
-		if (isNodeOfType(node, "CallExpression") && isReactApiCall(node, BUILTIN_HOOK_NAMES, scopes, { resolveNamedAliases: true })) {
-			containsReactHookCall = true;
-			return false;
-		}
-	});
-	return containsReactHookCall;
-};
-//#endregion
-//#region src/plugin/utils/function-returns-props-children.ts
-const functionReturnsPropsChildren = (functionNode, scopes, controlFlow) => {
-	if (!isFunctionLike$2(functionNode) || functionNode.params.length === 0) return false;
-	const firstParameter = stripParenExpression(functionNode.params[0]);
-	const firstParameterPattern = isNodeOfType(firstParameter, "AssignmentPattern") ? stripParenExpression(firstParameter.left) : firstParameter;
-	const propsParameterSymbol = isNodeOfType(firstParameterPattern, "Identifier") ? scopes.symbolFor(firstParameterPattern) : null;
-	const childrenBindingSymbolIds = /* @__PURE__ */ new Set();
-	if (isNodeOfType(firstParameterPattern, "ObjectPattern")) {
-		for (const property of firstParameterPattern.properties) if (isNodeOfType(property, "Property") && getStaticPropertyKeyName(property, { allowComputedString: true }) === "children") {
-			const propertyValue = stripParenExpression(property.value);
-			const childrenBinding = isNodeOfType(propertyValue, "AssignmentPattern") ? stripParenExpression(propertyValue.left) : propertyValue;
-			if (!isNodeOfType(childrenBinding, "Identifier")) continue;
-			const childrenBindingSymbol = scopes.symbolFor(childrenBinding);
-			if (childrenBindingSymbol) childrenBindingSymbolIds.add(childrenBindingSymbol.id);
-		}
-	}
-	return functionReturnsMatchingExpression(functionNode, scopes, (expression) => {
-		const candidate = stripParenExpression(expression);
-		if (isNodeOfType(candidate, "Identifier")) {
-			const symbol = scopes.symbolFor(candidate);
-			return Boolean(symbol && childrenBindingSymbolIds.has(symbol.id) && !hasSymbolWriteBefore(symbol, candidate, scopes));
-		}
-		if (!isNodeOfType(candidate, "MemberExpression")) return false;
-		if (getStaticPropertyName(candidate) !== "children") return false;
-		const receiver = stripParenExpression(candidate.object);
-		if (!isNodeOfType(receiver, "Identifier")) return false;
-		const receiverSymbol = scopes.symbolFor(receiver);
-		if (!receiverSymbol || !propsParameterSymbol) return false;
-		return receiverSymbol.id === propsParameterSymbol.id && !hasSymbolWriteBefore(receiverSymbol, candidate, scopes) && !hasStaticPropertyWriteBefore(receiver, "children", candidate, scopes);
-	}, controlFlow);
-};
-//#endregion
-//#region src/plugin/utils/function-returns-only-null.ts
-const isNullExpression = (expression) => {
-	const candidate = stripParenExpression(expression);
-	return isNodeOfType(candidate, "Literal") && candidate.value === null;
-};
-const functionReturnsOnlyNull = (functionNode) => {
-	if (!isFunctionLike$2(functionNode)) return false;
-	if (!isNodeOfType(functionNode.body, "BlockStatement")) return isNullExpression(functionNode.body);
-	const returnStatements = collectFunctionReturnStatements(functionNode);
-	return returnStatements.length > 0 && returnStatements.every((returnStatement) => Boolean(returnStatement.argument && isNullExpression(returnStatement.argument)));
-};
-//#endregion
-//#region src/plugin/utils/is-proven-styled-component-expression.ts
-const findFactoryRoot = (node) => {
-	const candidate = stripParenExpression(node);
-	if (isNodeOfType(candidate, "Identifier")) return candidate;
-	if (isNodeOfType(candidate, "MemberExpression")) return findFactoryRoot(candidate.object);
-	if (isNodeOfType(candidate, "CallExpression")) return findFactoryRoot(candidate.callee);
-	return null;
-};
-const findFactoryPropertyName = (node) => {
-	const candidate = stripParenExpression(node);
-	if (isNodeOfType(candidate, "MemberExpression")) return findFactoryPropertyName(candidate.object) ?? getStaticPropertyName(candidate);
-	if (isNodeOfType(candidate, "CallExpression")) return findFactoryPropertyName(candidate.callee);
-	return null;
-};
-const isProvenStyledComponentExpression = (expression, scopes) => {
-	const candidate = stripParenExpression(expression);
-	if (!isNodeOfType(candidate, "TaggedTemplateExpression")) return false;
-	const factoryRoot = findFactoryRoot(candidate.tag);
-	if (!factoryRoot) return false;
-	const factoryPropertyName = findFactoryPropertyName(candidate.tag);
-	if (factoryPropertyName && hasStaticPropertyWriteBefore(factoryRoot, factoryPropertyName, candidate, scopes)) return false;
-	const symbol = resolveConstIdentifierAlias(factoryRoot, scopes);
-	if (!symbol || symbol.kind !== "import") return false;
-	if (!(isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || getImportedName(symbol.declarationNode) === "styled")) return false;
-	const importDeclaration = symbol.declarationNode.parent;
-	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && importDeclaration.source.value === "styled-components");
-};
-//#endregion
-//#region src/plugin/utils/is-proven-react-component-symbol.ts
-const REACT_COMPONENT_HOC_NAMES = new Set(["memo", "forwardRef"]);
-const functionHasComponentEvidence = (functionNode, scopes, controlFlow) => functionContainsReactRenderOutput(functionNode, scopes, controlFlow) || functionReturnsPropsChildren(functionNode, scopes, controlFlow) || functionContainsProvenReactHookCall(functionNode, scopes) && functionReturnsOnlyNull(functionNode);
-const isProvenReactComponentExpression = (expression, scopes, controlFlow, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const candidate = stripParenExpression(expression);
-	if (isInlineFunctionExpression(candidate)) return functionHasComponentEvidence(candidate, scopes, controlFlow);
-	if (isNodeOfType(candidate, "ClassExpression")) return isProvenReactClassComponent(candidate, scopes);
-	if (isProvenStyledComponentExpression(candidate, scopes)) return true;
-	if (isNodeOfType(candidate, "Identifier")) {
-		const symbol = scopes.symbolFor(candidate);
-		if (!symbol || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, candidate, scopes)) return false;
-		visitedSymbolIds.add(symbol.id);
-		if (isNodeOfType(symbol.declarationNode, "FunctionDeclaration")) return functionHasComponentEvidence(symbol.declarationNode, scopes, controlFlow);
-		if (isNodeOfType(symbol.declarationNode, "ClassDeclaration") || isNodeOfType(symbol.declarationNode, "ClassExpression")) return isProvenReactClassComponent(symbol.declarationNode, scopes);
-		return Boolean(symbol.initializer && isProvenReactComponentExpression(symbol.initializer, scopes, controlFlow, visitedSymbolIds));
-	}
-	if (!isNodeOfType(candidate, "CallExpression")) return false;
-	if (!hasStableCallTarget(candidate, scopes)) return false;
-	if (isReactApiCall(candidate, REACT_COMPONENT_HOC_NAMES, scopes, { resolveNamedAliases: true })) {
-		const wrappedComponent = candidate.arguments[0];
-		return Boolean(wrappedComponent && !isNodeOfType(wrappedComponent, "SpreadElement") && isProvenReactComponentExpression(wrappedComponent, scopes, controlFlow, visitedSymbolIds));
-	}
-	if (!isReactApiCall(candidate, "useMemo", scopes, { resolveNamedAliases: true })) return false;
-	const factory = candidate.arguments[0];
-	if (!factory || isNodeOfType(factory, "SpreadElement")) return false;
-	const unwrappedFactory = stripParenExpression(factory);
-	if (!isInlineFunctionExpression(unwrappedFactory)) return false;
-	if (!isNodeOfType(unwrappedFactory.body, "BlockStatement")) return isProvenReactComponentExpression(unwrappedFactory.body, scopes, controlFlow, visitedSymbolIds);
-	const returnStatements = collectFunctionReturnStatements(unwrappedFactory);
-	const returnedExpression = returnStatements[0]?.argument;
-	return Boolean(returnStatements.length === 1 && returnedExpression && isProvenReactComponentExpression(returnedExpression, scopes, controlFlow, visitedSymbolIds));
-};
-const isProvenReactComponentSymbol = (symbol, scopes, controlFlow, componentReference) => {
-	const candidateSymbols = symbol.kind === "ts-module" ? symbol.scope.symbols.filter((candidateSymbol) => candidateSymbol.name === symbol.name && candidateSymbol.kind !== "ts-module") : [symbol];
-	for (const candidateSymbol of candidateSymbols) {
-		if (hasSymbolWriteBefore(candidateSymbol, componentReference, scopes)) continue;
-		if (isComponentDeclaration(candidateSymbol.declarationNode)) {
-			if (functionHasComponentEvidence(candidateSymbol.declarationNode, scopes, controlFlow)) return true;
-			continue;
-		}
-		const initializer = candidateSymbol.initializer ? stripParenExpression(candidateSymbol.initializer) : null;
-		if (isNodeOfType(candidateSymbol.declarationNode, "VariableDeclarator") && isNodeOfType(candidateSymbol.declarationNode.id, "Identifier") && isUppercaseName(candidateSymbol.declarationNode.id.name) && initializer) {
-			if (isProvenReactComponentExpression(initializer, scopes, controlFlow)) return true;
-			continue;
-		}
-		if (isNodeOfType(candidateSymbol.declarationNode, "ClassDeclaration") || isNodeOfType(candidateSymbol.declarationNode, "ClassExpression")) {
-			if (isProvenReactClassComponent(candidateSymbol.declarationNode, scopes)) return true;
-			continue;
-		}
-		if (initializer && isNodeOfType(initializer, "ClassExpression") && isProvenReactClassComponent(initializer, scopes)) return true;
-	}
-	return false;
-};
-//#endregion
 //#region src/plugin/rules/architecture/no-prop-types.ts
 const PROP_TYPES_PROPERTY = "propTypes";
 const isPropTypesKey = (key, computed) => {
@@ -39129,7 +40137,7 @@ const isModuleScopedBinding = (identifier) => {
 	const binding = findVariableInitializer(identifier, identifier.name);
 	if (!binding) return false;
 	if (isNodeOfType(binding.scopeOwner, "Program")) return true;
-	if (isNodeOfType(binding.scopeOwner, "BlockStatement")) return findEnclosingFunction(binding.scopeOwner) === null;
+	if (isNodeOfType(binding.scopeOwner, "BlockStatement")) return findEnclosingFunction$1(binding.scopeOwner) === null;
 	return false;
 };
 const looksLikeFreshUpdateExpression = (expression) => {
@@ -39184,7 +40192,7 @@ const noRandomKey = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-react-children.ts
-const MESSAGE$15 = "`React.Children` traversal depends on the runtime child shape, so wrapping or unwrapping a child can silently change what gets visited.";
+const MESSAGE$16 = "`React.Children` traversal depends on the runtime child shape, so wrapping or unwrapping a child can silently change what gets visited.";
 const isChildrenIdentifier = (node, contextNode) => {
 	if (!isNodeOfType(node, "Identifier") || node.name !== "Children") return false;
 	return isImportedFromModule(contextNode, "Children", "react");
@@ -39210,13 +40218,13 @@ const noReactChildren = defineRule({
 		if (isChildrenIdentifier(memberObject, node)) {
 			context.report({
 				node: calleeOuter,
-				message: MESSAGE$15
+				message: MESSAGE$16
 			});
 			return;
 		}
 		if (isReactNamespaceMember(memberObject, node)) context.report({
 			node: calleeOuter,
-			message: MESSAGE$15
+			message: MESSAGE$16
 		});
 	} })
 });
@@ -39897,7 +40905,7 @@ const noRenderPropChildren = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-render-return-value.ts
-const MESSAGE$14 = "Your app breaks in React 19 because `ReactDOM.render` returns nothing there.";
+const MESSAGE$15 = "Your app breaks in React 19 because `ReactDOM.render` returns nothing there.";
 const isReactDomRenderCall = (node) => isGlobalMethodCall(node, "ReactDOM", "render");
 const isUsedAsReturnValue = (parent) => {
 	if (!parent) return false;
@@ -39915,7 +40923,7 @@ const noRenderReturnValue = defineRule({
 		if (!isUsedAsReturnValue(node.parent)) return;
 		context.report({
 			node: node.callee,
-			message: MESSAGE$14
+			message: MESSAGE$15
 		});
 	} })
 });
@@ -40724,7 +41732,7 @@ const noSelfUpdatingEffect = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-set-state.ts
-const MESSAGE$13 = "`this.setState` keeps local class state in a project that forbids it, so state ownership becomes harder to reason about.";
+const MESSAGE$14 = "`this.setState` keeps local class state in a project that forbids it, so state ownership becomes harder to reason about.";
 const noSetState = defineRule({
 	id: "no-set-state",
 	title: "Local class state forbidden",
@@ -40739,7 +41747,7 @@ const noSetState = defineRule({
 		if (!getParentComponent(node)) return;
 		context.report({
 			node: node.callee,
-			message: MESSAGE$13
+			message: MESSAGE$14
 		});
 	} })
 });
@@ -41046,9 +42054,9 @@ const isReturnedFromAnyEffectInScope = (functionNode, ownerScope) => {
 	return isReturnedFromEffect;
 };
 const isInsideEffectCleanupReturn = (node, ownerScope) => {
-	let functionNode = findEnclosingFunction(node);
+	let functionNode = findEnclosingFunction$1(node);
 	while (functionNode) {
-		const outerFunction = findEnclosingFunction(functionNode);
+		const outerFunction = findEnclosingFunction$1(functionNode);
 		if (outerFunction && isEffectCallbackFunction(outerFunction) && isFunctionReturnedFromEffectCallback(functionNode, outerFunction)) return true;
 		if (isReturnedFromAnyEffectInScope(functionNode, ownerScope)) return true;
 		functionNode = outerFunction;
@@ -41056,7 +42064,7 @@ const isInsideEffectCleanupReturn = (node, ownerScope) => {
 	return false;
 };
 const hasRefCurrentReassignmentAfterClear = (clearCall, refName) => {
-	const enclosingFunction = findEnclosingFunction(clearCall);
+	const enclosingFunction = findEnclosingFunction$1(clearCall);
 	if (!isFunctionLike$2(enclosingFunction)) return false;
 	if (!isNodeOfType(enclosingFunction.body, "BlockStatement")) return false;
 	const clearStart = getRangeStart(clearCall);
@@ -41109,7 +42117,7 @@ const isAbstractRole = (openingElement, settings) => {
 };
 //#endregion
 //#region src/plugin/rules/a11y/no-static-element-interactions.ts
-const MESSAGE$12 = "Screen reader users can't tell this click handler is interactive because it has no `role`, so add a `role` or use a button or link.";
+const MESSAGE$13 = "Screen reader users can't tell this click handler is interactive because it has no `role`, so add a `role` or use a button or link.";
 const DEFAULT_HANDLERS = [
 	"onClick",
 	"onMouseDown",
@@ -41224,7 +42232,7 @@ const noStaticElementInteractions = defineRule({
 			if (!roleAttribute || !roleAttribute.value) {
 				context.report({
 					node: node.name,
-					message: MESSAGE$12
+					message: MESSAGE$13
 				});
 				return;
 			}
@@ -41234,7 +42242,7 @@ const noStaticElementInteractions = defineRule({
 				if (isRecognizedRoleString(attributeValue.value)) return;
 				context.report({
 					node: node.name,
-					message: MESSAGE$12
+					message: MESSAGE$13
 				});
 				return;
 			}
@@ -41242,7 +42250,7 @@ const noStaticElementInteractions = defineRule({
 				if (!settings.allowExpressionValues) {
 					context.report({
 						node: node.name,
-						message: MESSAGE$12
+						message: MESSAGE$13
 					});
 					return;
 				}
@@ -41250,7 +42258,7 @@ const noStaticElementInteractions = defineRule({
 				if (isStaticNullishExpression(expression)) {
 					context.report({
 						node: node.name,
-						message: MESSAGE$12
+						message: MESSAGE$13
 					});
 					return;
 				}
@@ -41260,7 +42268,7 @@ const noStaticElementInteractions = defineRule({
 					if (branches.some((branch) => branch.role !== null && isRecognizedRoleString(branch.role))) return;
 					context.report({
 						node: node.name,
-						message: MESSAGE$12
+						message: MESSAGE$13
 					});
 					return;
 				}
@@ -41268,7 +42276,7 @@ const noStaticElementInteractions = defineRule({
 			}
 			context.report({
 				node: node.name,
-				message: MESSAGE$12
+				message: MESSAGE$13
 			});
 		} };
 	}
@@ -41374,7 +42382,7 @@ const noStringRefs = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/js-performance/no-sync-xhr.ts
-const MESSAGE$11 = "A synchronous `XMLHttpRequest` (`.open(method, url, false)`) freezes the main thread until the request finishes, blocking all rendering and input. Use `fetch()` or an async XHR (`open(method, url, true)`).";
+const MESSAGE$12 = "A synchronous `XMLHttpRequest` (`.open(method, url, false)`) freezes the main thread until the request finishes, blocking all rendering and input. Use `fetch()` or an async XHR (`open(method, url, true)`).";
 const isFalseLiteral = (node) => isNodeOfType(node, "Literal") && node.value === false;
 const PUBLIC_ASSET_PATH_PATTERN = /(?:^|\/)public\//i;
 const noSyncXhr = defineRule({
@@ -41395,7 +42403,7 @@ const noSyncXhr = defineRule({
 			if (!asyncArgument || !isFalseLiteral(stripParenExpression(asyncArgument))) return;
 			context.report({
 				node,
-				message: MESSAGE$11
+				message: MESSAGE$12
 			});
 		};
 		return {
@@ -41420,7 +42428,7 @@ const noSyncXhr = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/no-this-in-sfc.ts
-const MESSAGE$10 = "This value is `undefined` because function components have no `this`.";
+const MESSAGE$11 = "This value is `undefined` because function components have no `this`.";
 const isInsideClassMethod = (node, customClassFactoryNames) => {
 	let ancestor = node.parent;
 	while (ancestor) {
@@ -41508,7 +42516,7 @@ const noThisInSfc = defineRule({
 			if (functionHasOwnThisMemberWrite(enclosingFunction)) return;
 			context.report({
 				node,
-				message: MESSAGE$10
+				message: MESSAGE$11
 			});
 		} };
 	}
@@ -41886,7 +42894,7 @@ const isInsideAvailabilityGuard = (node, browserGlobalName, context) => {
 	return false;
 };
 const isAfterAvailabilityEarlyExit = (node, componentOrHookNode, browserGlobalName, context) => {
-	const enclosingFunction = findEnclosingFunction(node);
+	const enclosingFunction = findEnclosingFunction$1(node);
 	if (!enclosingFunction || enclosingFunction !== componentOrHookNode && !executesDuringRender(enclosingFunction, context.scopes) || !isFunctionLike$2(enclosingFunction) || !isNodeOfType(enclosingFunction.body, "BlockStatement")) return false;
 	let currentNode = node;
 	while (currentNode !== enclosingFunction) {
@@ -43153,7 +44161,11 @@ const resolveSettings$8 = (settings) => {
 		propNamePattern: ruleSettings.propNamePattern ?? "render*"
 	};
 };
-const expressionContainsJsxOrCreateElement = (root) => {
+const isReactCreateElementCall = (node, scopes) => isReactApiCall(node, "createElement", scopes, {
+	allowGlobalReactNamespace: true,
+	resolveNamedAliases: true
+});
+const expressionContainsJsxOrCreateElement = (root, scopes) => {
 	let found = false;
 	walkAst(root, (node) => {
 		if (found) return false;
@@ -43162,17 +44174,17 @@ const expressionContainsJsxOrCreateElement = (root) => {
 			found = true;
 			return false;
 		}
-		if (isNodeOfType(node, "CallExpression") && isCreateElementCall(node)) {
+		if (isNodeOfType(node, "CallExpression") && isReactCreateElementCall(node, scopes)) {
 			found = true;
 			return false;
 		}
 	});
 	return found;
 };
-const functionContainsJsxOrCreateElement = (functionNode, scopes, controlFlow) => expressionContainsJsxOrCreateElement(functionNode) || functionReturnsMatchingExpression(functionNode, scopes, expressionContainsJsxOrCreateElement, controlFlow);
-const isReactClassComponent = (classNode) => {
+const functionContainsJsxOrCreateElement = (functionNode, scopes, controlFlow) => expressionContainsJsxOrCreateElement(functionNode, scopes) || functionReturnsMatchingExpression(functionNode, scopes, (expression) => expressionContainsJsxOrCreateElement(expression, scopes), controlFlow);
+const isReactClassComponent = (classNode, scopes) => {
 	if (isEs6Component(classNode)) return true;
-	return expressionContainsJsxOrCreateElement(classNode);
+	return expressionContainsJsxOrCreateElement(classNode, scopes);
 };
 const findEnclosingComponent = (node, scopes, controlFlow) => {
 	let walker = node.parent;
@@ -43189,7 +44201,7 @@ const findEnclosingComponent = (node, scopes, controlFlow) => {
 			};
 		}
 		if (isNodeOfType(walker, "ClassDeclaration") || isNodeOfType(walker, "ClassExpression")) {
-			if (walker.id && isReactComponentName(walker.id.name) && isReactClassComponent(walker)) return {
+			if (walker.id && isReactComponentName(walker.id.name) && isReactClassComponent(walker, scopes)) return {
 				component: walker,
 				name: walker.id.name
 			};
@@ -43278,12 +44290,12 @@ const isObjectCallbackCandidate = (node) => {
 	}
 	return false;
 };
-const hocCallContainsComponent = (call) => {
+const hocCallContainsComponent = (call, scopes) => {
 	const firstArgument = call.arguments[0];
 	if (!firstArgument) return false;
-	if (isNodeOfType(firstArgument, "FunctionExpression") || isNodeOfType(firstArgument, "ArrowFunctionExpression") || isNodeOfType(firstArgument, "ClassExpression")) return expressionContainsJsxOrCreateElement(firstArgument);
-	if (isNodeOfType(firstArgument, "CallExpression") && isHocCallee$1(firstArgument)) return hocCallContainsComponent(firstArgument);
-	return expressionContainsJsxOrCreateElement(firstArgument);
+	if (isNodeOfType(firstArgument, "FunctionExpression") || isNodeOfType(firstArgument, "ArrowFunctionExpression") || isNodeOfType(firstArgument, "ClassExpression")) return expressionContainsJsxOrCreateElement(firstArgument, scopes);
+	if (isNodeOfType(firstArgument, "CallExpression") && isHocCallee$1(firstArgument)) return hocCallContainsComponent(firstArgument, scopes);
+	return expressionContainsJsxOrCreateElement(firstArgument, scopes);
 };
 const isFirstArgumentOfHocCall = (node) => {
 	const parent = node.parent;
@@ -43316,19 +44328,35 @@ const isReturnOfMapCallback = (node) => {
 	}
 	return false;
 };
-const isCloneElementCall = (node) => {
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	const callee = node.callee;
-	if (isNodeOfType(callee, "Identifier")) return callee.name === "cloneElement";
-	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "cloneElement";
-};
 const TS_VALUE_PASSTHROUGH_TYPES = new Set([
 	"TSAsExpression",
 	"TSNonNullExpression",
 	"TSSatisfiesExpression",
 	"TSTypeAssertion"
 ]);
-const isRenderFlowingReadReference = (identifier) => {
+const ELEMENT_TYPE_PROP_NAMES = new Set([
+	"as",
+	"body",
+	"calendarcontainer",
+	"component",
+	"fallback",
+	"tooltip"
+]);
+const isElementTypeJsxAttribute = (node) => {
+	if (!isNodeOfType(node, "JSXAttribute")) return false;
+	if (!isNodeOfType(node.name, "JSXIdentifier")) return false;
+	const attributeName = node.name.name;
+	return ELEMENT_TYPE_PROP_NAMES.has(attributeName.toLowerCase()) || attributeName.endsWith("Component");
+};
+const isReactUseMemoCallback = (call, valueNode, scopes) => call.arguments[0] === valueNode && isReactApiCall(call, "useMemo", scopes, {
+	allowGlobalReactNamespace: true,
+	resolveNamedAliases: true
+});
+const isReactLazyCall = (call, scopes) => isReactApiCall(call, "lazy", scopes, {
+	allowGlobalReactNamespace: true,
+	resolveNamedAliases: true
+});
+const isRenderFlowingReadReference = (identifier, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
 	let valueNode = identifier;
 	let parent = valueNode.parent;
 	while (parent) {
@@ -43338,20 +44366,26 @@ const isRenderFlowingReadReference = (identifier) => {
 			continue;
 		}
 		switch (parent.type) {
-			case "JSXExpressionContainer":
-			case "ReturnStatement": return true;
-			case "ArrowFunctionExpression": return parent.body === valueNode;
+			case "JSXOpeningElement": return parent.name === valueNode;
+			case "JSXExpressionContainer": return Boolean(parent.parent && isElementTypeJsxAttribute(parent.parent));
+			case "ReturnStatement": return false;
+			case "ArrowFunctionExpression": return false;
 			case "CallExpression":
 				if (parent.callee === valueNode) return false;
-				if (isCreateElementCall(parent) || isCloneElementCall(parent)) return true;
+				if (isReactUseMemoCallback(parent, valueNode, scopes)) return false;
+				if (isReactCreateElementCall(parent, scopes)) return true;
 				valueNode = parent;
 				parent = parent.parent;
 				continue;
-			case "VariableDeclarator": return parent.init === valueNode && isNodeOfType(parent.id, "Identifier") && isReactComponentName(parent.id.name);
-			case "AssignmentExpression": {
-				const assignmentTarget = parent.left;
-				return parent.right === valueNode && isNodeOfType(assignmentTarget, "Identifier") && isReactComponentName(assignmentTarget.name);
+			case "VariableDeclarator": {
+				if (parent.init !== valueNode || !isNodeOfType(parent.id, "Identifier")) return false;
+				const aliasSymbol = scopes.symbolFor(parent.id);
+				if (!aliasSymbol || aliasSymbol.kind !== "const" || visitedSymbols.has(aliasSymbol.id)) return false;
+				const nextVisitedSymbols = new Set(visitedSymbols);
+				nextVisitedSymbols.add(aliasSymbol.id);
+				return aliasSymbol.references.some((reference) => reference.flag === "read" && isRenderFlowingReadReference(reference.identifier, scopes, nextVisitedSymbols));
 			}
+			case "AssignmentExpression": return false;
 			case "Property":
 				if (parent.value !== valueNode) return false;
 				valueNode = parent;
@@ -43389,6 +44423,7 @@ const noUnstableNestedComponents = defineRule({
 	severity: "warn",
 	recommendation: "Move nested components to module scope so React does not remount them and lose state on every render.",
 	category: "Performance",
+	tags: ["react-jsx-only"],
 	create: (context) => {
 		const settings = resolveSettings$8(context.settings);
 		const renderPropRegex = compileGlob(settings.propNamePattern);
@@ -43451,7 +44486,7 @@ const noUnstableNestedComponents = defineRule({
 			},
 			Identifier(node) {
 				if (!isReactComponentName(node.name)) return;
-				if (!isRenderFlowingReadReference(node)) return;
+				if (!isRenderFlowingReadReference(node, context.scopes)) return;
 				recordInstantiation(node, node.name);
 			},
 			FunctionDeclaration: checkFunctionLike,
@@ -43460,28 +44495,33 @@ const noUnstableNestedComponents = defineRule({
 			ClassDeclaration(node) {
 				if (!node.id) return;
 				if (!isReactComponentName(node.id.name)) return;
-				if (!isReactClassComponent(node)) return;
+				if (!isReactClassComponent(node, context.scopes)) return;
 				enqueueCandidate(node, null);
 			},
 			ClassExpression(node) {
 				const inferredName = node.id?.name ?? inferFunctionLikeName(node);
 				if (!inferredName || !isReactComponentName(inferredName)) return;
-				if (!isReactClassComponent(node)) return;
+				if (!isReactClassComponent(node, context.scopes)) return;
 				enqueueCandidate(node, null);
 			},
 			CallExpression(node) {
-				if (isCreateElementCall(node)) {
+				if (isReactCreateElementCall(node, context.scopes)) {
 					const firstArgument = node.arguments[0];
 					if (firstArgument && isNodeOfType(firstArgument, "Identifier")) recordInstantiation(firstArgument, firstArgument.name);
 					else if (firstArgument && isNodeOfType(firstArgument, "MemberExpression")) recordMemberChainInstantiation(firstArgument);
 				}
-				if (!isHocCallee$1(node)) return;
-				if (!hocCallContainsComponent(node)) return;
-				enqueueCandidate(node, null);
+				const isReactLazy = isReactLazyCall(node, context.scopes);
+				if (!isReactLazy && !isHocCallee$1(node)) return;
+				if (!isReactLazy && !hocCallContainsComponent(node, context.scopes)) return;
+				const inferredName = inferFunctionLikeName(node);
+				const propInfo = isComponentDeclaredInProp(node);
+				if (propInfo === null && (!inferredName || !isReactComponentName(inferredName))) return;
+				enqueueCandidate(node, propInfo === null ? inferredName : null);
 			},
 			"Program:exit"() {
 				for (const report of queuedReports) {
 					if (report.requiredInstantiationName !== null) {
+						if ((report.requiredInstantiationBinding ? context.scopes.symbolFor(report.requiredInstantiationBinding) : null)?.references.some((reference) => reference.flag === "write" || reference.flag === "read-write")) continue;
 						if (!(report.requiredInstantiationBinding !== null ? instantiatedBindingIdentifiers.has(report.requiredInstantiationBinding) : instantiatedComponentNames.has(report.requiredInstantiationName))) continue;
 					}
 					context.report({
@@ -43655,7 +44695,7 @@ const noWideLetterSpacing = defineRule({
 //#endregion
 //#region src/plugin/rules/react-builtins/no-will-update-set-state.ts
 const LIFECYCLE_NAMES = new Set(["componentWillUpdate", "UNSAFE_componentWillUpdate"]);
-const MESSAGE$9 = "Calling setState in componentWillUpdate can trigger another update immediately, loop forever, and freeze the component.";
+const MESSAGE$10 = "Calling setState in componentWillUpdate can trigger another update immediately, loop forever, and freeze the component.";
 const resolveSettings$7 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { mode: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noWillUpdateSetState ?? {} : {}).mode ?? "allowed" };
@@ -43689,7 +44729,7 @@ const noWillUpdateSetState = defineRule({
 			if (!isSetStateCallInLifecycle(node, activeLifecycleNames, { disallowInNestedFunctions: mode === "disallow-in-func" })) return;
 			context.report({
 				node: node.callee,
-				message: MESSAGE$9
+				message: MESSAGE$10
 			});
 		} };
 	}
@@ -44514,7 +45554,7 @@ const findChildrenDestructuringFunction = (identifier, scopes) => {
 	const symbol = scopes.symbolFor(identifier);
 	if (symbol) {
 		if (symbol.kind !== "parameter") return null;
-		const declaringFunction = findEnclosingFunction(symbol.bindingIdentifier);
+		const declaringFunction = findEnclosingFunction$1(symbol.bindingIdentifier);
 		if (declaringFunction && destructuresChildrenAsFirstParam(declaringFunction)) return declaringFunction;
 		return null;
 	}
@@ -44560,7 +45600,7 @@ const isChildrenMemberExpression = (node, scopes) => {
 		const symbol = scopes.symbolFor(propsObject);
 		if (symbol) {
 			if (symbol.kind !== "parameter") return false;
-			const declaringFunction = findEnclosingFunction(symbol.bindingIdentifier);
+			const declaringFunction = findEnclosingFunction$1(symbol.bindingIdentifier);
 			return declaringFunction ? isDeclaringFunctionComponentLike(declaringFunction) : false;
 		}
 		return hasComponentLikeAncestorFunction(node);
@@ -44685,7 +45725,7 @@ const preactNoRenderArguments = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/preact/preact-prefer-ondblclick.ts
-const MESSAGE$8 = "Your users get no response from `onDoubleClick` in Preact core, where it never fires, so use `onDblClick` instead, which matches the DOM event name.";
+const MESSAGE$9 = "Your users get no response from `onDoubleClick` in Preact core, where it never fires, so use `onDblClick` instead, which matches the DOM event name.";
 const preactPreferOndblclick = defineRule({
 	id: "preact-prefer-ondblclick",
 	title: "onDoubleClick instead of onDblClick",
@@ -44700,7 +45740,7 @@ const preactPreferOndblclick = defineRule({
 		if (!onDoubleClickAttribute) return;
 		context.report({
 			node: onDoubleClickAttribute,
-			message: MESSAGE$8
+			message: MESSAGE$9
 		});
 	} })
 });
@@ -44951,7 +45991,7 @@ const preferExplicitVariants = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/prefer-function-component.ts
-const MESSAGE$7 = "This class component keeps behavior in lifecycle methods, so state and effects are harder to follow than in a hook-based function component.";
+const MESSAGE$8 = "This class component keeps behavior in lifecycle methods, so state and effects are harder to follow than in a hook-based function component.";
 const resolveSettings$4 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.preferFunctionComponent ?? {} : {};
@@ -44990,7 +46030,7 @@ const preferFunctionComponent = defineRule({
 			const reportNode = node.id ?? node;
 			context.report({
 				node: reportNode,
-				message: MESSAGE$7
+				message: MESSAGE$8
 			});
 		};
 		return {
@@ -45212,7 +46252,7 @@ const doesFunctionReturnsObjectLiteral = (functionNode) => {
 //#endregion
 //#region src/plugin/utils/enclosing-component-or-hook-scope.ts
 const enclosingComponentOrHookScope = (startNode, ownScopeFor) => {
-	const functionNode = findEnclosingFunction(startNode);
+	const functionNode = findEnclosingFunction$1(startNode);
 	if (!functionNode) return null;
 	const displayName = componentOrHookDisplayNameForFunction(functionNode);
 	if (!displayName) return null;
@@ -46274,7 +47314,7 @@ const isTanstackQuerySource = (source) => TANSTACK_QUERY_PACKAGE_PATTERN.test(so
 //#region src/plugin/rules/tanstack-query/query-destructure-result.ts
 const isHookReturnForwardingSpread = (objectExpression) => {
 	const objectParent = objectExpression.parent;
-	const enclosingFunction = findEnclosingFunction(objectExpression);
+	const enclosingFunction = findEnclosingFunction$1(objectExpression);
 	if (!enclosingFunction) return false;
 	if (!(isNodeOfType(objectParent, "ReturnStatement") || isNodeOfType(enclosingFunction, "ArrowFunctionExpression") && enclosingFunction.body === objectExpression)) return false;
 	const enclosingName = componentOrHookDisplayNameForFunction(enclosingFunction);
@@ -46568,7 +47608,258 @@ const queryMutationMissingInvalidation = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/is-node-conditionally-executed.ts
+const isNodeConditionallyExecuted = (node, boundary) => {
+	let child = node;
+	let parent = child.parent ?? null;
+	while (parent && parent !== boundary) {
+		if (isNodeOfType(parent, "ConditionalExpression") && (parent.consequent === child || parent.alternate === child)) return true;
+		if (isNodeOfType(parent, "LogicalExpression") && parent.right === child) return true;
+		if (isNodeOfType(parent, "AssignmentPattern") && parent.right === child) return true;
+		child = parent;
+		parent = child.parent ?? null;
+	}
+	return false;
+};
+//#endregion
+//#region src/plugin/rules/tanstack-query/utils/resolve-tanstack-query-hook-name.ts
+const resolveTanstackNamespaceHookName = (memberExpression, contextNode, scopes) => {
+	const hookName = getStaticPropertyKeyName(memberExpression, { allowComputedString: true });
+	const namespaceObject = stripParenExpression(memberExpression.object);
+	if (!hookName || !TANSTACK_QUERY_HOOKS.has(hookName)) return null;
+	if (!isNodeOfType(namespaceObject, "Identifier")) return null;
+	const resolvedNamespaceSymbol = resolveConstIdentifierAlias(namespaceObject, scopes);
+	if (resolvedNamespaceSymbol?.kind !== "import") return null;
+	const namespaceBinding = getImportBindingForName(contextNode, resolvedNamespaceSymbol.name);
+	return namespaceBinding?.isNamespace && isTanstackQuerySource(namespaceBinding.source) ? hookName : null;
+};
+const resolveTanstackQueryHookName = (callExpression, scopes) => {
+	const callee = stripParenExpression(callExpression.callee);
+	if (isNodeOfType(callee, "Identifier")) {
+		const resolvedSymbol = resolveConstIdentifierAlias(callee, scopes);
+		if (!resolvedSymbol) return null;
+		if (resolvedSymbol.kind === "const" && resolvedSymbol.initializer) {
+			const initializer = stripParenExpression(resolvedSymbol.initializer);
+			return isNodeOfType(initializer, "MemberExpression") ? resolveTanstackNamespaceHookName(initializer, callExpression, scopes) : null;
+		}
+		if (resolvedSymbol.kind !== "import") return null;
+		const importBinding = getImportBindingForName(callExpression, resolvedSymbol.name);
+		if (importBinding === null) return null;
+		if (importBinding.isNamespace || !isTanstackQuerySource(importBinding.source)) return null;
+		return importBinding.exportedName !== null && TANSTACK_QUERY_HOOKS.has(importBinding.exportedName) ? importBinding.exportedName : null;
+	}
+	if (isNodeOfType(callee, "MemberExpression")) return resolveTanstackNamespaceHookName(callee, callExpression, scopes);
+	return null;
+};
+const resolveTanstackQueryHookNameFromInitializer = (initializer, scopes) => {
+	const unwrappedInitializer = stripParenExpression(initializer);
+	if (isNodeOfType(unwrappedInitializer, "CallExpression")) return resolveTanstackQueryHookName(unwrappedInitializer, scopes);
+	if (!isNodeOfType(unwrappedInitializer, "Identifier")) return null;
+	const resolvedSymbol = resolveConstIdentifierAlias(unwrappedInitializer, scopes);
+	if (resolvedSymbol?.kind !== "const" || !resolvedSymbol.initializer) return null;
+	const resolvedInitializer = stripParenExpression(resolvedSymbol.initializer);
+	if (!isNodeOfType(resolvedInitializer, "CallExpression")) return null;
+	return resolveTanstackQueryHookName(resolvedInitializer, scopes);
+};
+//#endregion
 //#region src/plugin/rules/tanstack-query/query-no-query-in-effect.ts
+const isTanstackQueryResult = (expression, context) => Boolean(resolveTanstackQueryHookNameFromInitializer(expression, context.scopes));
+const isStaticRefetchMember = (memberExpression) => getStaticPropertyKeyName(memberExpression, { allowComputedString: true }) === "refetch";
+const resolveCalledFunction = (callee, context) => {
+	const unwrappedCallee = stripParenExpression(callee);
+	if (isFunctionLike$2(unwrappedCallee)) return unwrappedCallee;
+	if (!isNodeOfType(unwrappedCallee, "Identifier")) return null;
+	const symbol = resolveConstIdentifierAlias(unwrappedCallee, context.scopes);
+	if (!symbol) return null;
+	const candidate = symbol.kind === "function" ? symbol.declarationNode : symbol.initializer;
+	return candidate && isFunctionLike$2(candidate) ? candidate : null;
+};
+const hasSuspensionBefore = (functionNode, boundary, context) => {
+	if (!isFunctionLike$2(functionNode)) return true;
+	if (functionNode.generator) return true;
+	const boundaryStart = getRangeStart(boundary);
+	if (boundaryStart === null) return true;
+	let hasSuspension = false;
+	walkAst(functionNode, (node) => {
+		if (node !== functionNode && isFunctionLike$2(node)) return false;
+		if (!isNodeOfType(node, "AwaitExpression") || !isNodeReachableWithinFunction(node, context)) return;
+		const suspensionStart = getRangeStart(node);
+		if (suspensionStart !== null && suspensionStart < boundaryStart) {
+			hasSuspension = true;
+			return false;
+		}
+	});
+	return hasSuspension;
+};
+const isFunctionAncestor = (ancestor, functionNode) => {
+	let enclosingFunction = findEnclosingFunction$1(functionNode);
+	while (enclosingFunction) {
+		if (enclosingFunction === ancestor) return true;
+		enclosingFunction = findEnclosingFunction$1(enclosingFunction);
+	}
+	return false;
+};
+const isUnconditionallyExecuted = (node, functionNode, context) => context.cfg.isUnconditionalFromEntry(node) && !isNodeConditionallyExecuted(node, functionNode) && !(isNodeOfType(node, "MemberExpression") && isNodeOfType(node.parent, "AssignmentExpression") && node.parent.left === node && (node.parent.operator === "&&=" || node.parent.operator === "||=" || node.parent.operator === "??="));
+const functionInvokesTarget = (callerFunction, targetFunction, context, visitedFunctions, canCrossSuspension = false) => {
+	if (visitedFunctions.has(callerFunction)) return false;
+	visitedFunctions.add(callerFunction);
+	let invokesTarget = false;
+	walkAst(callerFunction, (node) => {
+		if (node !== callerFunction && isFunctionLike$2(node)) return false;
+		if (!isNodeOfType(node, "CallExpression")) return;
+		if (!isNodeReachableWithinFunction(node, context) || !isUnconditionallyExecuted(node, callerFunction, context) || !canCrossSuspension && hasSuspensionBefore(callerFunction, node, context)) return;
+		const calledFunction = resolveCalledFunction(node.callee, context);
+		if (calledFunction === targetFunction || calledFunction && functionInvokesTarget(calledFunction, targetFunction, context, visitedFunctions, canCrossSuspension)) {
+			invokesTarget = true;
+			return false;
+		}
+	});
+	return invokesTarget;
+};
+const isFunctionInvokedBefore = (invokedFunction, boundary, context) => {
+	const boundaryFunction = findEnclosingFunction$1(boundary);
+	const boundaryStart = getRangeStart(boundary);
+	if (!boundaryFunction || boundaryStart === null) return false;
+	let isInvokedBefore = false;
+	walkAst(boundaryFunction, (node) => {
+		if (node !== boundaryFunction && isFunctionLike$2(node)) return false;
+		if (!isNodeOfType(node, "CallExpression")) return;
+		const callStart = getRangeStart(node);
+		if (callStart === null || callStart >= boundaryStart || !isNodeReachableWithinFunction(node, context) || !isUnconditionallyExecuted(node, boundaryFunction, context) || hasSuspensionBefore(boundaryFunction, node, context)) return;
+		const calledFunction = resolveCalledFunction(node.callee, context);
+		if (calledFunction === invokedFunction || calledFunction && functionInvokesTarget(calledFunction, invokedFunction, context, /* @__PURE__ */ new Set())) {
+			isInvokedBefore = true;
+			return false;
+		}
+	});
+	return isInvokedBefore;
+};
+const isFunctionInvokedAfter = (invokedFunction, boundary, callerFunction, context) => {
+	const boundaryStart = getRangeStart(boundary);
+	if (boundaryStart === null) return false;
+	let isInvokedAfter = false;
+	walkAst(callerFunction, (node) => {
+		if (node !== callerFunction && isFunctionLike$2(node)) return false;
+		if (!isNodeOfType(node, "CallExpression")) return;
+		const callStart = getRangeStart(node);
+		if (callStart === null || callStart <= boundaryStart || !isNodeReachableWithinFunction(node, context) || !isUnconditionallyExecuted(node, callerFunction, context)) return;
+		const calledFunction = resolveCalledFunction(node.callee, context);
+		if (calledFunction === invokedFunction || calledFunction && functionInvokesTarget(calledFunction, invokedFunction, context, /* @__PURE__ */ new Set(), true)) {
+			isInvokedAfter = true;
+			return false;
+		}
+	});
+	return isInvokedAfter;
+};
+const isWriteExecutedBefore = (writeNode, boundary, context, deferredExecutionFunction) => {
+	const writeStart = getRangeStart(writeNode);
+	const boundaryStart = getRangeStart(boundary);
+	const writeFunction = findEnclosingFunction$1(writeNode);
+	const writeExecutionBoundary = writeFunction ?? findProgramRoot(writeNode);
+	if (writeStart === null || boundaryStart === null || !writeExecutionBoundary || !isNodeReachableWithinFunction(writeNode, context) || !isUnconditionallyExecuted(writeNode, writeExecutionBoundary, context)) return false;
+	const boundaryFunction = findEnclosingFunction$1(boundary);
+	const renderFunction = deferredExecutionFunction ? findEnclosingFunction$1(deferredExecutionFunction) : null;
+	if (writeFunction === boundaryFunction) return writeStart < boundaryStart;
+	if (!writeFunction) return writeStart < boundaryStart;
+	if (boundaryFunction && isFunctionAncestor(writeFunction, boundaryFunction)) {
+		if (Boolean(renderFunction && (writeFunction === renderFunction || isFunctionAncestor(writeFunction, renderFunction)))) return true;
+		if (deferredExecutionFunction && boundaryFunction !== deferredExecutionFunction) {
+			if (hasSuspensionBefore(boundaryFunction, boundary, context) && isFunctionInvokedBefore(boundaryFunction, writeNode, context)) return true;
+			return isFunctionInvokedAfter(boundaryFunction, writeNode, writeFunction, context);
+		}
+		return writeStart < boundaryStart;
+	}
+	if (renderFunction && isFunctionAncestor(renderFunction, writeFunction) && !hasSuspensionBefore(writeFunction, writeNode, context) && functionInvokesTarget(renderFunction, writeFunction, context, /* @__PURE__ */ new Set())) return true;
+	return !hasSuspensionBefore(writeFunction, writeNode, context) && isFunctionInvokedBefore(writeFunction, boundary, context);
+};
+const getStaticStringValue = (node) => {
+	const unwrappedNode = stripParenExpression(node);
+	if (isNodeOfType(unwrappedNode, "Literal") && typeof unwrappedNode.value === "string") return unwrappedNode.value;
+	if (isNodeOfType(unwrappedNode, "TemplateLiteral") && unwrappedNode.expressions.length === 0) return getStaticTemplateLiteralValue(unwrappedNode);
+	return null;
+};
+const isSameRefetchMember = (target, candidate, context) => {
+	const unwrappedTarget = stripParenExpression(target);
+	const unwrappedCandidate = stripParenExpression(candidate);
+	if (!isNodeOfType(unwrappedTarget, "Identifier") || !isNodeOfType(unwrappedCandidate, "MemberExpression") || !isStaticRefetchMember(unwrappedCandidate)) return false;
+	const candidateTarget = stripParenExpression(unwrappedCandidate.object);
+	if (!isNodeOfType(candidateTarget, "Identifier")) return false;
+	const targetSymbol = resolveConstIdentifierAlias(unwrappedTarget, context.scopes);
+	const candidateSymbol = resolveConstIdentifierAlias(candidateTarget, context.scopes);
+	return Boolean(targetSymbol && candidateSymbol?.id === targetSymbol.id);
+};
+const getRefetchMutationTarget = (node, context) => {
+	if (isNodeOfType(node, "MemberExpression") && isStaticRefetchMember(node)) {
+		const parent = node.parent;
+		if (isNodeOfType(parent, "AssignmentExpression") && parent.left === node && isSameRefetchMember(node.object, parent.right, context)) return null;
+		return isNodeOfType(parent, "AssignmentExpression") && parent.left === node || isNodeOfType(parent, "UpdateExpression") && parent.argument === node || isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" ? node.object : null;
+	}
+	if (!isNodeOfType(node, "CallExpression")) return null;
+	const callee = stripParenExpression(node.callee);
+	if (!isNodeOfType(callee, "MemberExpression")) return null;
+	const receiver = stripParenExpression(callee.object);
+	if (!isNodeOfType(receiver, "Identifier") || receiver.name !== "Object" || context.scopes.symbolFor(receiver)) return null;
+	const methodName = getStaticPropertyKeyName(callee, { allowComputedString: true });
+	const target = node.arguments[0];
+	if (!target || isNodeOfType(target, "SpreadElement")) return null;
+	if (methodName === "defineProperty") {
+		const propertyKey = node.arguments[1];
+		if (!propertyKey || getStaticStringValue(propertyKey) !== "refetch") return null;
+		const descriptor = node.arguments[2];
+		if (isNodeOfType(descriptor, "ObjectExpression")) {
+			const valueProperty = descriptor.properties.find((property) => isNodeOfType(property, "Property") && getStaticPropertyKeyName(property, { allowComputedString: true }) === "value");
+			if (isNodeOfType(valueProperty, "Property") && isSameRefetchMember(target, valueProperty.value, context)) return null;
+		}
+		return target;
+	}
+	if (methodName !== "assign") return null;
+	let finalRefetchValue = null;
+	for (const source of node.arguments.slice(1)) {
+		if (!isNodeOfType(source, "ObjectExpression")) continue;
+		for (const property of source.properties) if (isNodeOfType(property, "Property") && getStaticPropertyKeyName(property, { allowComputedString: true }) === "refetch") finalRefetchValue = property.value;
+	}
+	if (!finalRefetchValue || isSameRefetchMember(target, finalRefetchValue, context)) return null;
+	return target;
+};
+const hasRefetchMemberWriteBefore = (expression, boundary, context, deferredExecutionFunction) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(unwrappedExpression, "Identifier")) return false;
+	const resultSymbol = resolveConstIdentifierAlias(unwrappedExpression, context.scopes);
+	if (!resultSymbol) return false;
+	const program = findProgramRoot(expression);
+	if (!program) return true;
+	if (getRangeStart(boundary) === null) return true;
+	let hasWrite = false;
+	walkAst(program, (node) => {
+		const mutationTarget = getRefetchMutationTarget(node, context);
+		if (!mutationTarget) return;
+		if (!isWriteExecutedBefore(node, boundary, context, deferredExecutionFunction)) return;
+		const object = stripParenExpression(mutationTarget);
+		if (!isNodeOfType(object, "Identifier")) return;
+		if (resolveConstIdentifierAlias(object, context.scopes)?.id === resultSymbol.id) {
+			hasWrite = true;
+			return false;
+		}
+	});
+	return hasWrite;
+};
+const isTanstackRefetchExpression = (expression, context, deferredExecutionFunction, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "MemberExpression")) return isStaticRefetchMember(unwrappedExpression) && isTanstackQueryResult(unwrappedExpression.object, context) && !hasRefetchMemberWriteBefore(unwrappedExpression.object, unwrappedExpression, context, deferredExecutionFunction);
+	if (!isNodeOfType(unwrappedExpression, "Identifier")) return false;
+	const symbol = context.scopes.symbolFor(unwrappedExpression);
+	if (!symbol || symbol.kind !== "const" || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read") || !isNodeOfType(symbol.declarationNode, "VariableDeclarator")) return false;
+	visitedSymbolIds.add(symbol.id);
+	const bindingProperty = symbol.bindingIdentifier.parent;
+	if (isNodeOfType(bindingProperty, "Property") && getStaticPropertyKeyName(bindingProperty, { allowComputedString: true }) === "refetch") {
+		const initializer = symbol.declarationNode.init;
+		return Boolean(initializer && isTanstackQueryResult(initializer, context) && !hasRefetchMemberWriteBefore(initializer, symbol.declarationNode, context, null));
+	}
+	return Boolean(symbol.declarationNode.id === symbol.bindingIdentifier && symbol.initializer && isTanstackRefetchExpression(symbol.initializer, context, null, visitedSymbolIds));
+};
+const isTanstackRefetchCall = (callExpression, context, effectCallback) => {
+	return isTanstackRefetchExpression(callExpression.callee, context, effectCallback);
+};
 const queryNoQueryInEffect = defineRule({
 	id: "query-no-query-in-effect",
 	title: "Query refetch inside useEffect",
@@ -46584,8 +47875,7 @@ const queryNoQueryInEffect = defineRule({
 		walkAst(callback, (child) => {
 			if (child !== callback && isFunctionLike$2(child) && !effectInvokedFunctions.has(child)) return false;
 			if (!isNodeOfType(child, "CallExpression")) return;
-			const callee = child.callee;
-			if (isNodeOfType(callee, "Identifier") && callee.name === "refetch" || isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && callee.property.name === "refetch") context.report({
+			if (isTanstackRefetchCall(child, context, callback)) context.report({
 				node: child,
 				message: "refetch() inside useEffect duplicates work React Query already does, causing extra fetches."
 			});
@@ -46594,28 +47884,6 @@ const queryNoQueryInEffect = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/tanstack-query/query-no-rest-destructuring.ts
-const resolveTanstackQueryHookName = (callExpression) => {
-	const callee = callExpression.callee;
-	if (isNodeOfType(callee, "Identifier")) {
-		const importBinding = getImportBindingForName(callExpression, callee.name);
-		if (importBinding === null) return TANSTACK_QUERY_HOOKS.has(callee.name) ? callee.name : null;
-		if (importBinding.isNamespace || !isTanstackQuerySource(importBinding.source)) return null;
-		return importBinding.exportedName !== null && TANSTACK_QUERY_HOOKS.has(importBinding.exportedName) ? importBinding.exportedName : null;
-	}
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && TANSTACK_QUERY_HOOKS.has(callee.property.name) && isNodeOfType(callee.object, "Identifier")) {
-		const namespaceBinding = getImportBindingForName(callExpression, callee.object.name);
-		if (namespaceBinding?.isNamespace && isTanstackQuerySource(namespaceBinding.source)) return callee.property.name;
-	}
-	return null;
-};
-const resolveHookNameFromInitializer = (initializer, scopes) => {
-	if (isNodeOfType(initializer, "CallExpression")) return resolveTanstackQueryHookName(initializer);
-	if (!isNodeOfType(initializer, "Identifier")) return null;
-	const resolvedSymbol = resolveConstIdentifierAlias(initializer, scopes);
-	if (resolvedSymbol?.kind !== "const" || !resolvedSymbol.initializer) return null;
-	if (!isNodeOfType(resolvedSymbol.initializer, "CallExpression")) return null;
-	return resolveTanstackQueryHookName(resolvedSymbol.initializer);
-};
 const queryNoRestDestructuring = defineRule({
 	id: "query-no-rest-destructuring",
 	title: "Rest destructuring on query result",
@@ -46627,7 +47895,7 @@ const queryNoRestDestructuring = defineRule({
 		if (!isNodeOfType(node.id, "ObjectPattern")) return;
 		if (!node.init) return;
 		if (!node.id.properties?.some((property) => isNodeOfType(property, "RestElement"))) return;
-		const hookName = resolveHookNameFromInitializer(node.init, context.scopes);
+		const hookName = resolveTanstackQueryHookNameFromInitializer(node.init, context.scopes);
 		if (!hookName) return;
 		context.report({
 			node: node.id,
@@ -46762,8 +48030,8 @@ const queryStableQueryClient = defineRule({
 	create: (context) => ({ NewExpression(node) {
 		if (!isNodeOfType(node.callee, "Identifier") || node.callee.name !== "QueryClient") return;
 		if (isStableHookWrapperArgument(node)) return;
-		let enclosingFunction = findEnclosingFunction(node);
-		while (enclosingFunction && isImmediatelyInvokedFunction(enclosingFunction)) enclosingFunction = findEnclosingFunction(enclosingFunction);
+		let enclosingFunction = findEnclosingFunction$1(node);
+		while (enclosingFunction && isImmediatelyInvokedFunction(enclosingFunction)) enclosingFunction = findEnclosingFunction$1(enclosingFunction);
 		if (!enclosingFunction) return;
 		if (!isComponentFunction(enclosingFunction)) return;
 		context.report({
@@ -46858,7 +48126,7 @@ const reactCompilerNoManualMemoization = defineRule({
 			const comparatorArgument = node.arguments?.[1];
 			if (comparatorArgument && !isNullishComparatorArgument(comparatorArgument)) return;
 		} else {
-			const enclosingFunction = findEnclosingFunction(node);
+			const enclosingFunction = findEnclosingFunction$1(node);
 			if (!enclosingFunction || !isCompilerInferableFunction(enclosingFunction)) return;
 		}
 		const removalMessage = REMOVAL_MESSAGE_BY_REACT_API_NAME.get(apiName);
@@ -46871,7 +48139,7 @@ const reactCompilerNoManualMemoization = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/react-builtins/react-in-jsx-scope.ts
-const MESSAGE$6 = "This JSX crashes because `React` isn't in scope.";
+const MESSAGE$7 = "This JSX crashes because `React` isn't in scope.";
 const reactInJsxScope = defineRule({
 	id: "react-in-jsx-scope",
 	title: "React not in scope for JSX",
@@ -46883,19 +48151,190 @@ const reactInJsxScope = defineRule({
 			if (findVariableInitializer(node, "React")) return;
 			context.report({
 				node: node.name,
-				message: MESSAGE$6
+				message: MESSAGE$7
 			});
 		},
 		JSXFragment(node) {
 			if (findVariableInitializer(node, "React")) return;
 			context.report({
 				node: node.openingFragment,
-				message: MESSAGE$6
+				message: MESSAGE$7
 			});
 		}
 	})
 });
 //#endregion
+//#region src/plugin/rules/security/react-markdown-unsanitized-raw-html.ts
+const MESSAGE$6 = "React Markdown parses dynamic raw HTML when `rehype-raw` is enabled. Add `rehype-sanitize` to `rehypePlugins` or sanitize the markdown before rendering it.";
+const REACT_MARKDOWN_MODULE = "react-markdown";
+const REHYPE_RAW_MODULE = "rehype-raw";
+const REHYPE_SANITIZE_MODULE = "rehype-sanitize";
+const DOMPURIFY_MODULES = new Set(["dompurify", "isomorphic-dompurify"]);
+const REACT_MARKDOWN_NAMED_EXPORTS = new Set(["MarkdownAsync", "MarkdownHooks"]);
+const REACT_MARKDOWN_NAMESPACE_EXPORTS = new Set(["default", ...REACT_MARKDOWN_NAMED_EXPORTS]);
+const DEFAULT_EXPORT_NAMES = new Set(["default"]);
+const getImportDeclaration = (symbol) => {
+	if (symbol.kind !== "import") return null;
+	const importDeclaration = symbol.declarationNode.parent;
+	return isNodeOfType(importDeclaration, "ImportDeclaration") ? importDeclaration : null;
+};
+const isImportFromModule = (symbol, moduleName) => getImportDeclaration(symbol)?.source.value === moduleName;
+const isDefaultImportSymbol = (symbol, moduleName) => {
+	if (!isImportFromModule(symbol, moduleName)) return false;
+	return isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || getImportedName(symbol.declarationNode) === "default";
+};
+const resolveImportedIdentifier = (node, scopes) => {
+	if (!isNodeOfType(node, "Identifier") && !isNodeOfType(node, "JSXIdentifier")) return null;
+	const symbol = resolveConstIdentifierAlias(node, scopes);
+	return symbol?.kind === "import" ? symbol : null;
+};
+const getStaticMemberParts = (node) => {
+	if (isNodeOfType(node, "MemberExpression")) {
+		if (node.computed || !isNodeOfType(node.property, "Identifier")) return null;
+		return {
+			object: node.object,
+			propertyName: node.property.name
+		};
+	}
+	if (isNodeOfType(node, "JSXMemberExpression")) {
+		if (!isNodeOfType(node.property, "JSXIdentifier")) return null;
+		return {
+			object: node.object,
+			propertyName: node.property.name
+		};
+	}
+	return null;
+};
+const isNamespaceMemberFromModule = (node, moduleName, memberNames, scopes) => {
+	const memberParts = getStaticMemberParts(node);
+	if (!memberParts || !memberNames.has(memberParts.propertyName)) return false;
+	const namespaceSymbol = resolveImportedIdentifier(memberParts.object, scopes);
+	return Boolean(namespaceSymbol && isImportFromModule(namespaceSymbol, moduleName) && isNodeOfType(namespaceSymbol.declarationNode, "ImportNamespaceSpecifier"));
+};
+const isReactMarkdownComponent = (node, scopes) => {
+	if (isNodeOfType(node, "JSXIdentifier")) {
+		const symbol = resolveImportedIdentifier(node, scopes);
+		if (!symbol || !isImportFromModule(symbol, REACT_MARKDOWN_MODULE)) return false;
+		if (isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier")) return true;
+		const importedName = getImportedName(symbol.declarationNode);
+		return importedName === "default" || Boolean(importedName && REACT_MARKDOWN_NAMED_EXPORTS.has(importedName));
+	}
+	return isNamespaceMemberFromModule(node, REACT_MARKDOWN_MODULE, REACT_MARKDOWN_NAMESPACE_EXPORTS, scopes);
+};
+const isPluginFromModule = (rawNode, moduleName, scopes, visitedSymbolIds) => {
+	const node = stripParenExpression(rawNode);
+	if (isNodeOfType(node, "Identifier")) {
+		const symbol = resolveConstIdentifierAlias(node, scopes);
+		if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+		if (isDefaultImportSymbol(symbol, moduleName)) return true;
+		if (symbol.kind !== "const" || !symbol.initializer) return false;
+		visitedSymbolIds.add(symbol.id);
+		return isPluginFromModule(symbol.initializer, moduleName, scopes, visitedSymbolIds);
+	}
+	if (isNamespaceMemberFromModule(node, moduleName, DEFAULT_EXPORT_NAMES, scopes)) return true;
+	if (!isNodeOfType(node, "ArrayExpression")) return false;
+	for (const element of node.elements) {
+		if (!element || isNodeOfType(element, "SpreadElement")) continue;
+		return isPluginFromModule(element, moduleName, scopes, visitedSymbolIds);
+	}
+	return false;
+};
+const collectPluginEntries = (rawNode, scopes, visitedSymbolIds) => {
+	const node = stripParenExpression(rawNode);
+	if (isNodeOfType(node, "Identifier")) {
+		const symbol = scopes.referenceFor(node)?.resolvedSymbol;
+		if (!symbol || symbol.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
+		visitedSymbolIds.add(symbol.id);
+		return collectPluginEntries(symbol.initializer, scopes, visitedSymbolIds);
+	}
+	if (!isNodeOfType(node, "ArrayExpression")) return null;
+	const entries = [];
+	for (const element of node.elements) {
+		if (!element) continue;
+		if (isNodeOfType(element, "SpreadElement")) {
+			const spreadEntries = collectPluginEntries(element.argument, scopes, new Set(visitedSymbolIds));
+			if (spreadEntries === null) return null;
+			entries.push(...spreadEntries);
+			continue;
+		}
+		entries.push(element);
+	}
+	return entries;
+};
+const findEffectiveExplicitAttribute = (attributes, attributeName) => {
+	for (let attributeIndex = attributes.length - 1; attributeIndex >= 0; attributeIndex -= 1) {
+		const attribute = attributes[attributeIndex];
+		if (!attribute || isNodeOfType(attribute, "JSXSpreadAttribute")) return null;
+		if (isNodeOfType(attribute, "JSXAttribute") && isNodeOfType(attribute.name, "JSXIdentifier") && attribute.name.name === attributeName) return attribute;
+	}
+	return null;
+};
+const getAttributeExpression = (attribute) => {
+	if (!isNodeOfType(attribute.value, "JSXExpressionContainer")) return null;
+	return isNodeOfType(attribute.value.expression, "JSXEmptyExpression") ? null : attribute.value.expression;
+};
+const isDomPurifyNamespace = (node, scopes) => {
+	const symbol = resolveImportedIdentifier(node, scopes);
+	if (!symbol) return false;
+	const importDeclaration = getImportDeclaration(symbol);
+	if (!importDeclaration || !DOMPURIFY_MODULES.has(String(importDeclaration.source.value))) return false;
+	return isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier") || getImportedName(symbol.declarationNode) === "default";
+};
+const isDomPurifySanitizeCall = (node, scopes) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const memberParts = getStaticMemberParts(stripParenExpression(node.callee));
+	return Boolean(memberParts && memberParts.propertyName === "sanitize" && isDomPurifyNamespace(memberParts.object, scopes));
+};
+const isStaticOrSanitizedMarkdownExpression = (rawNode, scopes, visitedSymbolIds) => {
+	const node = stripParenExpression(rawNode);
+	if (isNodeOfType(node, "Literal")) return true;
+	if (isNodeOfType(node, "TemplateLiteral")) return node.expressions.every((expression) => isStaticOrSanitizedMarkdownExpression(expression, scopes, new Set(visitedSymbolIds)));
+	if (isDomPurifySanitizeCall(node, scopes)) return true;
+	if (isNodeOfType(node, "ConditionalExpression")) return isStaticOrSanitizedMarkdownExpression(node.consequent, scopes, new Set(visitedSymbolIds)) && isStaticOrSanitizedMarkdownExpression(node.alternate, scopes, new Set(visitedSymbolIds));
+	if (isNodeOfType(node, "BinaryExpression") && node.operator === "+") return isStaticOrSanitizedMarkdownExpression(node.left, scopes, new Set(visitedSymbolIds)) && isStaticOrSanitizedMarkdownExpression(node.right, scopes, new Set(visitedSymbolIds));
+	if (!isNodeOfType(node, "Identifier")) return false;
+	const symbol = scopes.referenceFor(node)?.resolvedSymbol;
+	if (!symbol || symbol.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return false;
+	visitedSymbolIds.add(symbol.id);
+	return isStaticOrSanitizedMarkdownExpression(symbol.initializer, scopes, visitedSymbolIds);
+};
+const hasDynamicUnsanitizedChildren = (openingElement, scopes) => {
+	const jsxElement = openingElement.parent;
+	if (!isNodeOfType(jsxElement, "JSXElement")) return false;
+	const meaningfulChildren = jsxElement.children.filter((child) => !isNodeOfType(child, "JSXText") || child.value.trim().length > 0);
+	if (meaningfulChildren.length > 0) return meaningfulChildren.some((child) => {
+		if (isNodeOfType(child, "JSXText")) return false;
+		if (!isNodeOfType(child, "JSXExpressionContainer")) return true;
+		if (isNodeOfType(child.expression, "JSXEmptyExpression")) return false;
+		return !isStaticOrSanitizedMarkdownExpression(child.expression, scopes, /* @__PURE__ */ new Set());
+	});
+	const childrenAttribute = findEffectiveExplicitAttribute(openingElement.attributes, "children");
+	if (!childrenAttribute) return false;
+	const childrenExpression = getAttributeExpression(childrenAttribute);
+	return Boolean(childrenExpression && !isStaticOrSanitizedMarkdownExpression(childrenExpression, scopes, /* @__PURE__ */ new Set()));
+};
+const reactMarkdownUnsanitizedRawHtml = defineRule({
+	id: "react-markdown-unsanitized-raw-html",
+	title: "Unsanitized raw HTML in React Markdown",
+	severity: "warn",
+	recommendation: "Add `rehype-sanitize` to `rehypePlugins` or sanitize dynamic markdown before rendering. `skipHtml` does not disable HTML already parsed by `rehype-raw`.",
+	create: skipNonProductionFiles((context) => ({ JSXOpeningElement(node) {
+		if (!isReactMarkdownComponent(node.name, context.scopes)) return;
+		const pluginsAttribute = findEffectiveExplicitAttribute(node.attributes, "rehypePlugins");
+		if (!pluginsAttribute) return;
+		const pluginsExpression = getAttributeExpression(pluginsAttribute);
+		if (!pluginsExpression) return;
+		const pluginEntries = collectPluginEntries(pluginsExpression, context.scopes, /* @__PURE__ */ new Set());
+		if (pluginEntries === null) return;
+		if (!pluginEntries.some((entry) => isPluginFromModule(entry, REHYPE_RAW_MODULE, context.scopes, /* @__PURE__ */ new Set()))) return;
+		if (pluginEntries.some((entry) => isPluginFromModule(entry, REHYPE_SANITIZE_MODULE, context.scopes, /* @__PURE__ */ new Set())) || !hasDynamicUnsanitizedChildren(node, context.scopes)) return;
+		context.report({
+			node,
+			message: MESSAGE$6
+		});
+	} }))
+});
+//#endregion
 //#region src/plugin/utils/collect-react-redux-selector-aliases.ts
 const REACT_REDUX_MODULE = "react-redux";
 const collectReactReduxSelectorAliases = (programRoot) => {
@@ -49792,7 +51231,7 @@ const isReactNativeDimensionsCallee = (node, callee) => {
 };
 const STYLE_FACTORY_CALLEE_PATTERN$1 = /(?:^|\.)(?:make|create)(?:Use)?Styles$/;
 const isInsideStyleFactoryCallback = (node) => {
-	const enclosingFunction = findEnclosingFunction(node);
+	const enclosingFunction = findEnclosingFunction$1(node);
 	if (!enclosingFunction) return false;
 	const callExpression = enclosingFunction.parent;
 	if (!callExpression || !isNodeOfType(callExpression, "CallExpression")) return false;
@@ -55323,22 +56762,6 @@ const isInsideClassComponent = (node) => {
 	}
 	return false;
 };
-const hasShortCircuitAncestor = (descendant, ancestor) => {
-	let current = descendant.parent;
-	while (current && current !== ancestor) {
-		if (isNodeOfType(current, "ConditionalExpression") && (isWithinRange(descendant, current.consequent) || isWithinRange(descendant, current.alternate))) return true;
-		if (isNodeOfType(current, "LogicalExpression") && (current.operator === "&&" || current.operator === "||" || current.operator === "??") && isWithinRange(descendant, current.right)) return true;
-		if (isNodeOfType(current, "AssignmentPattern") && isWithinRange(descendant, current.right)) return true;
-		current = current.parent ?? null;
-	}
-	return false;
-};
-const isWithinRange = (descendant, sibling) => {
-	const descendantSpan = descendant;
-	const siblingSpan = sibling;
-	if (typeof descendantSpan.start !== "number" || typeof siblingSpan.start !== "number" || typeof siblingSpan.end !== "number") return false;
-	return descendantSpan.start >= siblingSpan.start && (descendantSpan.end ?? siblingSpan.end) <= siblingSpan.end;
-};
 const isInsideTry = (descendant, ancestor) => {
 	let current = descendant.parent;
 	while (current && current !== ancestor) {
@@ -55530,7 +56953,7 @@ const rulesOfHooks = defineRule({
 					});
 					return;
 				}
-				if (hasShortCircuitAncestor(node, enclosing.node)) {
+				if (isNodeConditionallyExecuted(node, enclosing.node)) {
 					context.report({
 						node: node.callee,
 						message: buildConditionalMessage(hookName)
@@ -56664,12 +58087,14 @@ const declarationAwaitsRequestScopedCall = (declaration) => {
 	}
 	return false;
 };
-const declarationAwaitsGate = (declaration) => {
+const declarationAwaitsGate = (declaration, context) => {
 	if (!isNodeOfType(declaration, "VariableDeclaration")) return false;
 	for (const declarator of declaration.declarations ?? []) {
 		if (!isNodeOfType(declarator.init, "AwaitExpression")) continue;
 		const argument = declarator.init.argument;
 		if (!isNodeOfType(argument, "CallExpression")) continue;
+		if (hasPossibleStaticMemberCallWrite(argument, context.scopes)) return true;
+		if (getOrderIndependentLocalFunction(argument, context.scopes) !== null) continue;
 		const calleeName = getCalleeName$2(argument);
 		if (!calleeName) continue;
 		if (isAuthGuardName(calleeName)) return true;
@@ -56697,7 +58122,7 @@ const serverSequentialIndependentAwait = defineRule({
 				if (declarationReadsAnyName(nextStatement, declaredNames)) continue;
 				if (declarationAwaitsExistingPromise(nextStatement)) continue;
 				if (declarationAwaitsRequestScopedCall(currentStatement) || declarationAwaitsRequestScopedCall(nextStatement)) continue;
-				if (declarationAwaitsGate(currentStatement)) continue;
+				if (declarationAwaitsGate(currentStatement, context)) continue;
 				context.report({
 					node: nextStatement,
 					message: "This await doesn't use the previous result, so your users wait twice as long for nothing."
@@ -57683,7 +59108,7 @@ const tanstackStartNoNavigateInRender = defineRule({
 		const isReturnedFromCustomHook = (functionNode) => {
 			const parent = functionNode.parent;
 			if (isNodeOfType(parent, "ReturnStatement")) {
-				const outerFunction = findEnclosingFunction(parent);
+				const outerFunction = findEnclosingFunction$1(parent);
 				const hookName = outerFunction ? getFunctionBindingName$1(outerFunction) : null;
 				return Boolean(hookName && HOOK_NAME_PATTERN$3.test(hookName));
 			}
@@ -57700,13 +59125,13 @@ const tanstackStartNoNavigateInRender = defineRule({
 			return parent.callee === functionNode || (parent.arguments ?? []).some((callArgument) => callArgument === functionNode);
 		};
 		const isDeferredNavigateCall = (callNode) => {
-			let enclosingFunction = findEnclosingFunction(callNode);
+			let enclosingFunction = findEnclosingFunction$1(callNode);
 			while (enclosingFunction) {
 				if (isDeferredCallbackPosition(enclosingFunction)) return true;
 				if (isWiredAsEventHandler(enclosingFunction)) return true;
 				if (isReturnedFromCustomHook(enclosingFunction)) return true;
 				if (!isSynchronouslyInvokedAnonymousWrapper(enclosingFunction)) return false;
-				enclosingFunction = findEnclosingFunction(enclosingFunction);
+				enclosingFunction = findEnclosingFunction$1(enclosingFunction);
 			}
 			return false;
 		};
@@ -62145,6 +63570,17 @@ const reactDoctorRules = [
 			requires: [...new Set(["react", ...reactInJsxScope.requires ?? []])]
 		}
 	},
+	{
+		key: "react-doctor/react-markdown-unsanitized-raw-html",
+		id: "react-markdown-unsanitized-raw-html",
+		source: "react-doctor",
+		originallyExternal: false,
+		rule: {
+			...reactMarkdownUnsanitizedRawHtml,
+			framework: "global",
+			category: "Security"
+		}
+	},
 	{
 		key: "react-doctor/redux-useselector-inline-derivation",
 		id: "redux-useselector-inline-derivation",