oxlint-plugin-react-doctor 0.7.6-dev.0d11bd5 → 0.7.6-dev.1d7b6e2

package/dist/index.js

@@ -6890,6 +6890,27 @@ const createMethodMutationAnalysis = (context) => {
 	};
 };
 //#endregion
+//#region src/plugin/utils/collect-function-return-statements.ts
+const collectFunctionReturnStatements = (functionNode) => {
+	if (!isFunctionLike$2(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return [];
+	const returnStatements = [];
+	walkAst(functionNode.body, (node) => {
+		if (node !== functionNode.body && (isFunctionLike$2(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
+		if (isNodeOfType(node, "ReturnStatement")) returnStatements.push(node);
+	});
+	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;
@@ -6899,17 +6920,109 @@ const statementAlwaysExits = (statement) => {
 };
 //#endregion
 //#region src/plugin/utils/function-returns-matching-expression.ts
+const REASSIGNABLE_BINDING_KINDS = new Set(["let", "var"]);
+const CONDITIONAL_EXPRESSION_TYPES = new Set(["ConditionalExpression", "LogicalExpression"]);
 const collectReturnedExpressions = (functionNode) => {
-	if (!isFunctionLike$2(functionNode)) return [];
-	const body = functionNode.body;
-	if (!body) return [];
-	if (!isNodeOfType(body, "BlockStatement")) return [body];
-	const returnedExpressions = [];
-	walkAst(body, (node) => {
-		if (node !== body && (isFunctionLike$2(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
-		if (isNodeOfType(node, "ReturnStatement") && node.argument) returnedExpressions.push(node.argument);
-	});
-	return returnedExpressions;
+	if (!isFunctionLike$2(functionNode) || !functionNode.body) return [];
+	if (!isNodeOfType(functionNode.body, "BlockStatement")) return [functionNode.body];
+	return collectFunctionReturnStatements(functionNode).flatMap((returnStatement) => returnStatement.argument ? [returnStatement.argument] : []);
+};
+const getAssignedExpressionForWrite = (writeIdentifier) => {
+	let assignmentTarget = writeIdentifier;
+	let parent = assignmentTarget.parent;
+	while (parent && stripParenExpression(parent) === writeIdentifier) {
+		assignmentTarget = parent;
+		parent = assignmentTarget.parent;
+	}
+	return parent && isNodeOfType(parent, "AssignmentExpression") && parent.operator === "=" && parent.left === assignmentTarget ? parent.right : null;
+};
+const isConditionalWithinBlock = (node, block, functionControlFlow) => {
+	let current = node.parent ?? null;
+	while (current && functionControlFlow.blockOf(current) === block) {
+		if (CONDITIONAL_EXPRESSION_TYPES.has(current.type)) return true;
+		current = current.parent ?? null;
+	}
+	return false;
+};
+const haveSameDefinitions = (left, right) => left.size === right.size && [...left].every((definition) => right.has(definition));
+const applyDefinitions = (incomingDefinitions, definitions) => {
+	let currentDefinitions = new Set(incomingDefinitions);
+	for (const definition of definitions) {
+		if (!definition.isConditionalWithinBlock) currentDefinitions = /* @__PURE__ */ new Set();
+		currentDefinitions.add(definition);
+	}
+	return currentDefinitions;
+};
+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 [];
+	if (!referenceFunction) return [];
+	const functionControlFlow = controlFlow.cfgFor(referenceFunction);
+	if (!functionControlFlow) return [];
+	const referenceBlock = functionControlFlow.blockOf(referenceNode);
+	if (!referenceBlock) return [];
+	const referencePosition = getRangeStart(referenceNode);
+	const bindingPosition = getRangeStart(symbol.bindingIdentifier);
+	if (referencePosition === null || bindingPosition === null) return [];
+	const definitionsByBlock = /* @__PURE__ */ new Map();
+	const addDefinition = (expression, definitionNode, position) => {
+		const block = functionControlFlow.blockOf(definitionNode);
+		if (!block) return;
+		const definitions = definitionsByBlock.get(block) ?? [];
+		definitions.push({
+			expression,
+			position,
+			isConditionalWithinBlock: isConditionalWithinBlock(definitionNode, block, functionControlFlow)
+		});
+		definitionsByBlock.set(block, definitions);
+	};
+	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;
+		const assignedExpression = getAssignedExpressionForWrite(reference.identifier);
+		if (!assignedExpression) continue;
+		addDefinition(assignedExpression, reference.identifier, writePosition);
+	}
+	for (const definitions of definitionsByBlock.values()) definitions.sort((left, right) => left.position - right.position);
+	const incomingDefinitionsByBlock = /* @__PURE__ */ new Map();
+	const outgoingDefinitionsByBlock = /* @__PURE__ */ new Map();
+	const reachableBlocks = new Set([functionControlFlow.entry]);
+	const pendingBlocks = [functionControlFlow.entry];
+	while (pendingBlocks.length > 0) {
+		const block = pendingBlocks.pop();
+		if (!block) break;
+		for (const edge of block.successors) {
+			if (reachableBlocks.has(edge.to)) continue;
+			reachableBlocks.add(edge.to);
+			pendingBlocks.push(edge.to);
+		}
+	}
+	if (!reachableBlocks.has(referenceBlock)) return [];
+	let didDefinitionsChange = true;
+	while (didDefinitionsChange) {
+		didDefinitionsChange = false;
+		for (const block of functionControlFlow.blocks) {
+			if (!reachableBlocks.has(block)) continue;
+			const incomingDefinitions = /* @__PURE__ */ new Set();
+			for (const predecessor of block.predecessors) {
+				if (!reachableBlocks.has(predecessor.from)) continue;
+				for (const definition of outgoingDefinitionsByBlock.get(predecessor.from) ?? []) incomingDefinitions.add(definition);
+			}
+			const outgoingDefinitions = applyDefinitions(incomingDefinitions, definitionsByBlock.get(block) ?? []);
+			const previousIncomingDefinitions = incomingDefinitionsByBlock.get(block) ?? /* @__PURE__ */ new Set();
+			const previousOutgoingDefinitions = outgoingDefinitionsByBlock.get(block) ?? /* @__PURE__ */ new Set();
+			if (!haveSameDefinitions(incomingDefinitions, previousIncomingDefinitions) || !haveSameDefinitions(outgoingDefinitions, previousOutgoingDefinitions)) {
+				incomingDefinitionsByBlock.set(block, incomingDefinitions);
+				outgoingDefinitionsByBlock.set(block, outgoingDefinitions);
+				didDefinitionsChange = true;
+			}
+		}
+	}
+	const definitionsBeforeReference = (definitionsByBlock.get(referenceBlock) ?? []).filter((definition) => definition.position < referencePosition);
+	return [...applyDefinitions(incomingDefinitionsByBlock.get(referenceBlock) ?? /* @__PURE__ */ new Set(), definitionsBeforeReference)].map((definition) => definition.expression);
 };
 const functionHasBareReturn = (functionNode) => {
 	if (!isFunctionLike$2(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return false;
@@ -6921,7 +7034,7 @@ const functionHasBareReturn = (functionNode) => {
 	});
 	return didFindBareReturn;
 };
-const functionReturnsMatchingExpression = (functionNode, scopes, matchesExpression, matchMode = "some") => {
+const functionReturnsMatchingExpression = (functionNode, scopes, matchesExpression, controlFlow, matchMode = "some") => {
 	const visitedExpressions = /* @__PURE__ */ new Set();
 	const visitedFunctions = /* @__PURE__ */ new Set();
 	const functionMatches = (candidateFunction) => {
@@ -6938,10 +7051,11 @@ const functionReturnsMatchingExpression = (functionNode, scopes, matchesExpressi
 		if (matchesExpression(unwrappedExpression)) return true;
 		if (isNodeOfType(unwrappedExpression, "Identifier")) {
 			const symbol = scopes.symbolFor(unwrappedExpression);
-			if (!symbol || symbol.kind !== "const" || !symbol.initializer) return false;
-			const initializer = stripParenExpression(symbol.initializer);
-			if (isFunctionLike$2(initializer)) return false;
-			return expressionMatches(initializer);
+			if (!symbol || symbol.kind !== "const" && !REASSIGNABLE_BINDING_KINDS.has(symbol.kind)) return false;
+			return collectPossibleAssignedExpressions(symbol, unwrappedExpression, controlFlow).some((assignedExpression) => {
+				const assignedValue = stripParenExpression(assignedExpression);
+				return !isFunctionLike$2(assignedValue) && expressionMatches(assignedValue);
+			});
 		}
 		if (isNodeOfType(unwrappedExpression, "CallExpression")) {
 			if (unwrappedExpression.arguments.length !== 0) return false;
@@ -7342,7 +7456,7 @@ const isProvenBrowserApiReceiver = (receiver, receiverKind, scopes, visitedSymbo
 		const callee = stripParenExpression(expression.callee);
 		if (isDomEventTarget && isNodeOfType(callee, "MemberExpression") && DOM_EVENT_TARGET_FACTORY_METHOD_NAMES.has(getStaticPropertyName(callee) ?? "") && isProvenBrowserApiReceiver(callee.object, receiverKind, scopes, visitedSymbolIds)) return true;
 		const calledFunction = getSameFileCalledFunction(expression, scopes, visitedSymbolIds);
-		return Boolean(calledFunction && functionReturnsMatchingExpression(calledFunction, scopes, (returnedExpression) => isProvenBrowserApiReceiver(returnedExpression, receiverKind, scopes, new Set(visitedSymbolIds)), "every"));
+		return Boolean(calledFunction && functionReturnsMatchingExpression(calledFunction, scopes, (returnedExpression) => isProvenBrowserApiReceiver(returnedExpression, receiverKind, scopes, new Set(visitedSymbolIds)), void 0, "every"));
 	}
 	if (!isNodeOfType(expression, "MemberExpression")) return false;
 	const classMember = getClassMemberDefinition(expression);
@@ -10816,16 +10930,6 @@ const componentOrHookDisplayNameForFunction = (functionNode) => {
 	return displayNameFromFunctionBinding(functionNode);
 };
 //#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/enclosing-component-or-hook-name.ts
 const enclosingComponentOrHookName = (node) => {
 	const functionNode = findEnclosingFunction(node);
@@ -16539,13 +16643,211 @@ const createLoopAwareVisitors = (innerVisitors, options = {}) => {
 //#region src/plugin/rules/js-performance/js-hoist-regexp.ts
 const isStaticPattern = (argument) => {
 	if (!argument) return false;
-	if (isNodeOfType(argument, "Literal")) return true;
-	return isNodeOfType(argument, "TemplateLiteral") && (argument.expressions?.length ?? 0) === 0;
+	const unwrappedArgument = stripParenExpression(argument);
+	return isNodeOfType(unwrappedArgument, "Literal") || isNodeOfType(unwrappedArgument, "TemplateLiteral") && (unwrappedArgument.expressions?.length ?? 0) === 0;
+};
+const STATEFUL_REGEXP_FLAGS_PATTERN = /[gy]/;
+const VALID_REGEXP_FLAGS_PATTERN = /^[dgimsuvy]*$/;
+const GLOBAL_OBJECT_NAMES = new Set([
+	"globalThis",
+	"global",
+	"window",
+	"self"
+]);
+const GLOBAL_BUILTIN_NAMES = new Set([
+	"Object",
+	"Reflect",
+	"String",
+	"RegExp"
+]);
+const STRING_PROTOTYPE_PATH = "String.prototype";
+const REGEXP_PROTOTYPE_PATH = "RegExp.prototype";
+const getStaticStringValue = (argument) => {
+	if (!argument) return null;
+	const unwrappedArgument = stripParenExpression(argument);
+	if (isNodeOfType(unwrappedArgument, "Literal") && typeof unwrappedArgument.value === "string") return unwrappedArgument.value;
+	if (isNodeOfType(unwrappedArgument, "TemplateLiteral")) return getStaticTemplateLiteralValue(unwrappedArgument);
+	return null;
+};
+const getEffectiveRegExpFlags = (patternArgument, flagsArgument) => {
+	if (flagsArgument) return getStaticStringValue(flagsArgument);
+	if (!patternArgument) return "";
+	const unwrappedPattern = stripParenExpression(patternArgument);
+	if (isNodeOfType(unwrappedPattern, "Literal") && unwrappedPattern.value instanceof RegExp) return unwrappedPattern.value.flags;
+	return "";
+};
+const hasValidRegExpFlags = (flags) => VALID_REGEXP_FLAGS_PATTERN.test(flags) && new Set(flags).size === flags.length && !(flags.includes("u") && flags.includes("v"));
+const globSyncReturnsStringPaths = (node, context) => {
+	if (node.arguments.some((argument) => isNodeOfType(argument, "SpreadElement"))) return false;
+	const callee = stripParenExpression(node.callee);
+	let isGlobSyncImport = false;
+	if (isNodeOfType(callee, "Identifier")) isGlobSyncImport = context.scopes.symbolFor(callee)?.kind === "import" && getImportedNameFromModule(callee, callee.name, "glob") === "globSync";
+	else if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.object, "Identifier") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "globSync") isGlobSyncImport = context.scopes.symbolFor(callee.object)?.kind === "import" && isNamespaceImportFromModule(callee.object, callee.object.name, "glob");
+	if (!isGlobSyncImport) return false;
+	const options = node.arguments[1];
+	if (!options) return true;
+	const unwrappedOptions = stripParenExpression(options);
+	if (!isNodeOfType(unwrappedOptions, "ObjectExpression")) return false;
+	for (const property of unwrappedOptions.properties) {
+		if (!isNodeOfType(property, "Property")) return false;
+		const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+		if (propertyName === null) return false;
+		if (propertyName !== "withFileTypes") continue;
+		const propertyValue = stripParenExpression(property.value);
+		if (!isNodeOfType(propertyValue, "Literal") || propertyValue.value !== false) return false;
+	}
+	return true;
+};
+const isGlobSyncStringIterationBinding = (bindingIdentifier, context) => {
+	const declarator = bindingIdentifier.parent;
+	if (!isNodeOfType(declarator, "VariableDeclarator") || declarator.id !== bindingIdentifier) return false;
+	const declaration = declarator.parent;
+	const loop = declaration?.parent;
+	if (!isNodeOfType(declaration, "VariableDeclaration") || declaration.kind !== "const" || !isNodeOfType(loop, "ForOfStatement") || loop.left !== declaration) return false;
+	const iteratedValue = stripParenExpression(loop.right);
+	return isNodeOfType(iteratedValue, "CallExpression") && globSyncReturnsStringPaths(iteratedValue, context);
+};
+const isProvenNativeStringReceiver = (node, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const receiver = stripParenExpression(node);
+	if (isNodeOfType(receiver, "Literal")) return typeof receiver.value === "string";
+	if (isNodeOfType(receiver, "TemplateLiteral")) return true;
+	if (isNodeOfType(receiver, "CallExpression") && isNodeOfType(receiver.callee, "Identifier") && receiver.callee.name === "String" && context.scopes.isGlobalReference(receiver.callee)) return true;
+	if (!isNodeOfType(receiver, "Identifier")) return false;
+	const symbol = context.scopes.symbolFor(receiver);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+	if (isNodeOfType(symbol.bindingIdentifier, "Identifier") && isNodeOfType(symbol.bindingIdentifier.typeAnnotation?.typeAnnotation, "TSStringKeyword")) return true;
+	if (isGlobSyncStringIterationBinding(symbol.bindingIdentifier, context)) return true;
+	if (symbol.kind !== "const" || !symbol.initializer) return false;
+	visitedSymbolIds.add(symbol.id);
+	return isProvenNativeStringReceiver(symbol.initializer, context, visitedSymbolIds);
+};
+const isSafeStatefulReplaceAllSearch = (node, flags, context) => {
+	if (!flags.includes("g")) return false;
+	const searchArgument = findTransparentExpressionRoot(node);
+	const replaceAllCall = searchArgument.parent;
+	if (!isNodeOfType(replaceAllCall, "CallExpression") || replaceAllCall.arguments[0] !== searchArgument) return false;
+	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";
+		return GLOBAL_BUILTIN_NAMES.has(propertyName) ? propertyName : null;
+	}
+	if ((basePath === "Object" || basePath === "Reflect") && propertyName) return `${basePath}.${propertyName}`;
+	if ((basePath === "String" || basePath === "RegExp") && propertyName === "prototype") return `${basePath}.prototype`;
+	if ((basePath === STRING_PROTOTYPE_PATH || basePath === REGEXP_PROTOTYPE_PATH) && propertyName) return `${basePath}.${propertyName}`;
+	return null;
+};
+const getGlobalPath = (node, context, symbolCache) => {
+	const unwrappedNode = stripParenExpression(node);
+	if (isNodeOfType(unwrappedNode, "Identifier")) {
+		if (context.scopes.isGlobalReference(unwrappedNode)) {
+			if (GLOBAL_OBJECT_NAMES.has(unwrappedNode.name)) return "global";
+			return GLOBAL_BUILTIN_NAMES.has(unwrappedNode.name) ? unwrappedNode.name : null;
+		}
+		const symbol = context.scopes.symbolFor(unwrappedNode);
+		if (symbol?.kind !== "const" || !symbol.initializer) return null;
+		const cachedResult = symbolCache.get(symbol.id);
+		if (cachedResult !== void 0) return cachedResult || null;
+		symbolCache.set(symbol.id, false);
+		if (!symbol.references.every((reference) => reference.flag === "read")) return null;
+		const initializerPath = getGlobalPath(symbol.initializer, context, symbolCache);
+		const destructuredPropertyName = getDestructuredBindingPropertyName(symbol.bindingIdentifier);
+		const resolvedPath = destructuredPropertyName ? initializerPath && extendGlobalPath(initializerPath, destructuredPropertyName) : initializerPath;
+		symbolCache.set(symbol.id, resolvedPath ?? false);
+		return resolvedPath;
+	}
+	if (!isNodeOfType(unwrappedNode, "MemberExpression")) return null;
+	const objectPath = getGlobalPath(unwrappedNode.object, context, symbolCache);
+	if (!objectPath) return null;
+	return extendGlobalPath(objectPath, getStaticPropertyName(unwrappedNode));
 };
-const isStaticRegExpConstruction = (node) => {
+const strongerRegExpEnvironmentHazard = (first, second) => {
+	if (first === "globalRegExpReplaced" || second === "globalRegExpReplaced") return "globalRegExpReplaced";
+	if (first === "replaceAllIntegrityLost" || second === "replaceAllIntegrityLost") return "replaceAllIntegrityLost";
+	return "none";
+};
+const getAssignmentTargetRegExpHazard = (node, context, symbolCache) => {
+	if (!node) return "none";
+	const target = stripParenExpression(node);
+	if (isNodeOfType(target, "MemberExpression")) {
+		const objectPath = getGlobalPath(target.object, context, symbolCache);
+		const propertyName = getStaticPropertyName(target);
+		if (objectPath === "global") return propertyName === null || propertyName === "RegExp" ? "globalRegExpReplaced" : "none";
+		if (objectPath === REGEXP_PROTOTYPE_PATH) return "replaceAllIntegrityLost";
+		return objectPath === STRING_PROTOTYPE_PATH && (propertyName === null || propertyName === "replaceAll") ? "replaceAllIntegrityLost" : "none";
+	}
+	if (isNodeOfType(target, "AssignmentPattern")) return getAssignmentTargetRegExpHazard(target.left, context, symbolCache);
+	if (isNodeOfType(target, "RestElement")) return getAssignmentTargetRegExpHazard(target.argument, context, symbolCache);
+	if (isNodeOfType(target, "ArrayPattern")) return target.elements.reduce((strongest, element) => strongerRegExpEnvironmentHazard(strongest, getAssignmentTargetRegExpHazard(element, context, symbolCache)), "none");
+	if (isNodeOfType(target, "ObjectPattern")) return target.properties.reduce((strongest, property) => strongerRegExpEnvironmentHazard(strongest, getAssignmentTargetRegExpHazard(isNodeOfType(property, "Property") ? property.value : property, context, symbolCache)), "none");
+	return "none";
+};
+const getWriteTarget = (node) => {
+	if (isNodeOfType(node, "AssignmentExpression")) return node.left;
+	if (isNodeOfType(node, "UpdateExpression")) return node.argument;
+	if (isNodeOfType(node, "UnaryExpression") && node.operator === "delete") return node.argument;
+	if (isNodeOfType(node, "ForInStatement") || isNodeOfType(node, "ForOfStatement")) return node.left;
+	return null;
+};
+const objectExpressionMayDefineProperty = (node, targetPropertyName) => {
+	if (!node) return true;
+	const unwrappedNode = stripParenExpression(node);
+	if (!isNodeOfType(unwrappedNode, "ObjectExpression")) return true;
+	return unwrappedNode.properties.some((property) => {
+		if (!isNodeOfType(property, "Property")) return true;
+		const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+		return propertyName === null || propertyName === targetPropertyName;
+	});
+};
+const getCallRegExpHazard = (node, context, symbolCache) => {
+	const methodName = getGlobalPath(node.callee, context, symbolCache);
+	const target = node.arguments?.[0];
+	if (!target) return "none";
+	const targetPath = getGlobalPath(target, context, symbolCache);
+	const isSinglePropertyMutation = methodName === "Object.defineProperty" || methodName === "Reflect.set" || methodName === "Reflect.defineProperty" || methodName === "Reflect.deleteProperty";
+	const isPropertyCollectionMutation = methodName === "Object.defineProperties" || methodName === "Object.assign";
+	if (targetPath === REGEXP_PROTOTYPE_PATH) return isSinglePropertyMutation || isPropertyCollectionMutation || methodName === "Object.setPrototypeOf" || methodName === "Reflect.setPrototypeOf" ? "replaceAllIntegrityLost" : "none";
+	if (targetPath !== STRING_PROTOTYPE_PATH && targetPath !== "global") return "none";
+	const mutationHazard = targetPath === "global" ? "globalRegExpReplaced" : "replaceAllIntegrityLost";
+	const guardedPropertyName = targetPath === "global" ? "RegExp" : "replaceAll";
+	if (isSinglePropertyMutation) {
+		const propertyName = getStaticStringValue(node.arguments?.[1]);
+		return propertyName === null || propertyName === guardedPropertyName ? mutationHazard : "none";
+	}
+	if (!isPropertyCollectionMutation) return "none";
+	return (methodName === "Object.defineProperties" && targetPath === "global" ? [node.arguments?.[1]] : node.arguments?.slice(1) ?? []).some((source) => objectExpressionMayDefineProperty(source, guardedPropertyName)) ? mutationHazard : "none";
+};
+const scopeTreeWritesGlobalRegExp = (scope) => scope.references.some((reference) => reference.resolvedSymbol === null && reference.flag !== "read" && isNodeOfType(reference.identifier, "Identifier") && reference.identifier.name === "RegExp") || scope.children.some(scopeTreeWritesGlobalRegExp);
+const scanRegExpEnvironmentHazard = (context) => {
+	if (scopeTreeWritesGlobalRegExp(context.scopes.rootScope)) return "globalRegExpReplaced";
+	let strongestHazard = "none";
+	const symbolCache = /* @__PURE__ */ new Map();
+	walkAst(context.scopes.rootScope.node, (node) => {
+		if (strongestHazard === "globalRegExpReplaced") return false;
+		const writeTarget = getWriteTarget(node);
+		const nodeHazard = writeTarget ? getAssignmentTargetRegExpHazard(writeTarget, context, symbolCache) : isNodeOfType(node, "CallExpression") ? getCallRegExpHazard(node, context, symbolCache) : "none";
+		strongestHazard = strongerRegExpEnvironmentHazard(strongestHazard, nodeHazard);
+		if (strongestHazard === "globalRegExpReplaced") return false;
+	});
+	return strongestHazard;
+};
+const getHoistableRegExpConstructionKind = (node, context) => {
 	const patternArgument = node.arguments?.[0];
 	const flagsArgument = node.arguments?.[1];
-	return isNodeOfType(node.callee, "Identifier") && node.callee.name === "RegExp" && isStaticPattern(patternArgument) && (flagsArgument === void 0 || isStaticPattern(flagsArgument));
+	const callee = stripParenExpression(node.callee);
+	const effectiveFlags = getEffectiveRegExpFlags(patternArgument, flagsArgument);
+	if (!isNodeOfType(callee, "Identifier") || callee.name !== "RegExp" || !context.scopes.isGlobalReference(callee) || !isStaticPattern(patternArgument) || effectiveFlags === null || !hasValidRegExpFlags(effectiveFlags)) return null;
+	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 jsHoistRegexp = defineRule({
@@ -16554,20 +16856,24 @@ const jsHoistRegexp = defineRule({
 	tags: ["test-noise"],
 	severity: "warn",
 	recommendation: "Move `new RegExp(...)` (or large regex literals) to a constant outside the loop so it isn't rebuilt on every pass",
-	create: (context) => createLoopAwareVisitors({
-		NewExpression(node) {
-			if (isStaticRegExpConstruction(node)) context.report({
-				node,
-				message: MESSAGE$48
-			});
-		},
-		CallExpression(node) {
-			if (isStaticRegExpConstruction(node)) context.report({
+	create: (context) => {
+		let cachedEnvironmentHazard = null;
+		const reportHoistableRegExpConstruction = (node) => {
+			const constructionKind = getHoistableRegExpConstructionKind(node, context);
+			if (constructionKind === null) return;
+			cachedEnvironmentHazard ??= scanRegExpEnvironmentHazard(context);
+			if (cachedEnvironmentHazard === "globalRegExpReplaced") return;
+			if (constructionKind === "statefulReplaceAll" && cachedEnvironmentHazard === "replaceAllIntegrityLost") return;
+			context.report({
 				node,
 				message: MESSAGE$48
 			});
-		}
-	}, { treatIteratorCallbacksAsLoops: true })
+		};
+		return createLoopAwareVisitors({
+			NewExpression: reportHoistableRegExpConstruction,
+			CallExpression: reportHoistableRegExpConstruction
+		}, { treatIteratorCallbacksAsLoops: true });
+	}
 });
 //#endregion
 //#region src/plugin/utils/resolve-first-argument-binding.ts
@@ -16971,12 +17277,23 @@ const jsLengthCheckFirst = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/js-performance/js-min-max-loop.ts
+const builtinMutationByProgram = /* @__PURE__ */ new WeakMap();
+const RUNTIMELESS_SYMBOL_KINDS = new Set(["ts-interface", "ts-type-alias"]);
+const PROTOTYPE_METHOD_NAMES = new Set(["getPrototypeOf"]);
+const OBJECT_ASSIGN_METHOD_NAMES = new Set(["assign"]);
+const OBJECT_DEFINE_PROPERTIES_METHOD_NAMES = new Set(["defineProperties"]);
+const KEYED_MUTATION_METHOD_NAMES = new Set([
+	"defineProperty",
+	"deleteProperty",
+	"set"
+]);
 const numericComparatorDirection = (comparator) => {
-	if (!isInlineFunctionExpression(comparator)) return null;
+	if (!isInlineFunctionExpression(comparator) || comparator.async || comparator.generator) return null;
 	const parameters = comparator.params ?? [];
 	if (parameters.length !== 2) return null;
 	const [firstParameter, secondParameter] = parameters;
 	if (!isNodeOfType(firstParameter, "Identifier") || !isNodeOfType(secondParameter, "Identifier")) return null;
+	if (firstParameter.name === secondParameter.name) return null;
 	let comparisonExpression = null;
 	const comparatorBody = stripParenExpression(comparator.body);
 	if (isNodeOfType(comparatorBody, "BinaryExpression")) comparisonExpression = comparatorBody;
@@ -16994,6 +17311,150 @@ const numericComparatorDirection = (comparator) => {
 	if (leftName === secondParameter.name && rightName === firstParameter.name) return "descending";
 	return null;
 };
+const getStaticFiniteNumericValue = (expression) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (isNodeOfType(strippedExpression, "Literal")) return typeof strippedExpression.value === "number" && Number.isFinite(strippedExpression.value) ? strippedExpression.value : null;
+	if (!isNodeOfType(strippedExpression, "UnaryExpression") || strippedExpression.operator !== "+" && strippedExpression.operator !== "-") return null;
+	const argumentValue = getStaticFiniteNumericValue(strippedExpression.argument);
+	if (argumentValue === null) return null;
+	return strippedExpression.operator === "-" ? -argumentValue : argumentValue;
+};
+const isSafeFreshNumericArray = (arrayExpression) => {
+	if (arrayExpression.elements.length === 0 || arrayExpression.elements.length > 1024) return false;
+	let didFindPositiveZero = false;
+	let didFindNegativeZero = false;
+	for (const element of arrayExpression.elements) {
+		if (!element || isNodeOfType(element, "SpreadElement")) return false;
+		const numericValue = getStaticFiniteNumericValue(element);
+		if (numericValue === null) return false;
+		if (Object.is(numericValue, 0)) didFindPositiveZero = true;
+		if (Object.is(numericValue, -0)) didFindNegativeZero = true;
+	}
+	return !(didFindPositiveZero && didFindNegativeZero);
+};
+const isGlobalObjectReference = (expression, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (!isNodeOfType(strippedExpression, "Identifier")) return false;
+	if ((strippedExpression.name === "globalThis" || strippedExpression.name === "window" || strippedExpression.name === "self" || strippedExpression.name === "global") && scopes.isGlobalReference(strippedExpression)) return true;
+	const symbol = scopes.symbolFor(strippedExpression);
+	if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbols.has(symbol.id)) return false;
+	visitedSymbols.add(symbol.id);
+	return isGlobalObjectReference(symbol.initializer, scopes, visitedSymbols);
+};
+const resolvesToGlobalNamespace = (expression, namespaceName, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (isNodeOfType(strippedExpression, "Identifier")) {
+		if (strippedExpression.name === namespaceName && scopes.isGlobalReference(strippedExpression)) return true;
+		const symbol = scopes.symbolFor(strippedExpression);
+		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbols.has(symbol.id)) return false;
+		visitedSymbols.add(symbol.id);
+		return resolvesToGlobalNamespace(symbol.initializer, namespaceName, scopes, visitedSymbols);
+	}
+	return isNodeOfType(strippedExpression, "MemberExpression") && getStaticPropertyName(strippedExpression) === namespaceName && isGlobalObjectReference(strippedExpression.object, scopes);
+};
+const resolvesToGlobalMethod = (expression, namespaceName, methodNames, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (isNodeOfType(strippedExpression, "Identifier")) {
+		const symbol = scopes.symbolFor(strippedExpression);
+		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbols.has(symbol.id)) return false;
+		visitedSymbols.add(symbol.id);
+		return resolvesToGlobalMethod(symbol.initializer, namespaceName, methodNames, scopes, visitedSymbols);
+	}
+	return isNodeOfType(strippedExpression, "MemberExpression") && methodNames.has(getStaticPropertyName(strippedExpression) ?? "") && resolvesToGlobalNamespace(strippedExpression.object, namespaceName, scopes);
+};
+const resolvesToNativeArrayPrototype = (expression, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
+	const strippedExpression = stripParenExpression(expression);
+	if (isNodeOfType(strippedExpression, "Identifier")) {
+		const symbol = scopes.symbolFor(strippedExpression);
+		if (!symbol?.initializer || symbol.kind !== "const" || visitedSymbols.has(symbol.id)) return false;
+		visitedSymbols.add(symbol.id);
+		return resolvesToNativeArrayPrototype(symbol.initializer, scopes, visitedSymbols);
+	}
+	if (isNodeOfType(strippedExpression, "MemberExpression")) {
+		const propertyName = getStaticPropertyName(strippedExpression);
+		if (propertyName === "prototype") return resolvesToGlobalNamespace(strippedExpression.object, "Array", scopes);
+		return propertyName === "__proto__" && isNodeOfType(stripParenExpression(strippedExpression.object), "ArrayExpression");
+	}
+	if (!isNodeOfType(strippedExpression, "CallExpression")) return false;
+	if (!resolvesToGlobalMethod(strippedExpression.callee, "Object", PROTOTYPE_METHOD_NAMES, scopes) && !resolvesToGlobalMethod(strippedExpression.callee, "Reflect", PROTOTYPE_METHOD_NAMES, scopes)) return false;
+	const argument = strippedExpression.arguments[0];
+	return Boolean(argument && isNodeOfType(stripParenExpression(argument), "ArrayExpression"));
+};
+const isGlobalNamespaceReplacementTarget = (target, namespaceName, scopes) => {
+	const strippedTarget = stripParenExpression(target);
+	if (isNodeOfType(strippedTarget, "Identifier")) return strippedTarget.name === namespaceName && scopes.isGlobalReference(strippedTarget);
+	return isNodeOfType(strippedTarget, "MemberExpression") && getStaticPropertyName(strippedTarget) === namespaceName && isGlobalObjectReference(strippedTarget.object, scopes);
+};
+const isUnsafeBuiltinMemberTarget = (target, targetFunction, scopes) => {
+	const strippedTarget = stripParenExpression(target);
+	if (!isNodeOfType(strippedTarget, "MemberExpression")) return false;
+	const propertyName = getStaticPropertyName(strippedTarget);
+	if (resolvesToNativeArrayPrototype(strippedTarget.object, scopes)) return propertyName === null || propertyName === "sort";
+	if (resolvesToGlobalNamespace(strippedTarget.object, "Math", scopes)) return propertyName === null || propertyName === targetFunction;
+	return isGlobalObjectReference(strippedTarget.object, scopes) && (propertyName === null || propertyName === "Math");
+};
+const isUnsafeBuiltinMutationApiCall = (callExpression, targetFunction, scopes) => {
+	const target = callExpression.arguments[0];
+	if (!target) return false;
+	let propertyName = null;
+	if (resolvesToNativeArrayPrototype(target, scopes)) propertyName = "sort";
+	else if (resolvesToGlobalNamespace(target, "Math", scopes)) propertyName = targetFunction;
+	else if (isGlobalObjectReference(target, scopes)) propertyName = "Math";
+	if (!propertyName) return false;
+	const canObjectExpressionSetProperty = (properties) => {
+		if (!isNodeOfType(properties, "ObjectExpression")) return true;
+		return properties.properties.some((property) => {
+			if (isNodeOfType(property, "SpreadElement")) return true;
+			const keyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+			return keyName === propertyName || keyName === null;
+		});
+	};
+	if (resolvesToGlobalMethod(callExpression.callee, "Object", OBJECT_ASSIGN_METHOD_NAMES, scopes)) return callExpression.arguments.slice(1).some((properties) => canObjectExpressionSetProperty(properties));
+	if (resolvesToGlobalMethod(callExpression.callee, "Object", OBJECT_DEFINE_PROPERTIES_METHOD_NAMES, scopes)) {
+		const properties = callExpression.arguments[1];
+		return !properties || canObjectExpressionSetProperty(properties);
+	}
+	if (!resolvesToGlobalMethod(callExpression.callee, "Object", KEYED_MUTATION_METHOD_NAMES, scopes) && !resolvesToGlobalMethod(callExpression.callee, "Reflect", KEYED_MUTATION_METHOD_NAMES, scopes)) return false;
+	const propertyArgument = callExpression.arguments[1];
+	if (!propertyArgument) return true;
+	return isNodeOfType(propertyArgument, "Literal") ? propertyArgument.value === propertyName : true;
+};
+const hasUnsafeBuiltinMutation = (node, targetFunction, scopes) => {
+	const programRoot = findProgramRoot(node);
+	if (!programRoot) return true;
+	let mutationByTargetFunction = builtinMutationByProgram.get(programRoot);
+	if (!mutationByTargetFunction) {
+		mutationByTargetFunction = /* @__PURE__ */ new Map();
+		builtinMutationByProgram.set(programRoot, mutationByTargetFunction);
+	}
+	const cachedResult = mutationByTargetFunction.get(targetFunction);
+	if (cachedResult !== void 0) return cachedResult;
+	let didFindUnsafeMutation = false;
+	walkAst(programRoot, (candidate) => {
+		if (didFindUnsafeMutation) return false;
+		if (isNodeOfType(candidate, "CallExpression")) {
+			didFindUnsafeMutation = isUnsafeBuiltinMutationApiCall(candidate, targetFunction, scopes);
+			return;
+		}
+		let mutationTarget = null;
+		if (isNodeOfType(candidate, "AssignmentExpression")) mutationTarget = candidate.left;
+		if (isNodeOfType(candidate, "UpdateExpression")) mutationTarget = candidate.argument;
+		if (isNodeOfType(candidate, "UnaryExpression") && candidate.operator === "delete") mutationTarget = candidate.argument;
+		if (!mutationTarget) return;
+		didFindUnsafeMutation = isUnsafeBuiltinMemberTarget(mutationTarget, targetFunction, scopes) || isGlobalNamespaceReplacementTarget(mutationTarget, "Math", scopes);
+	});
+	mutationByTargetFunction.set(targetFunction, didFindUnsafeMutation);
+	return didFindUnsafeMutation;
+};
+const hasUnsafeMathBinding = (node, scopes) => {
+	let scope = scopes.scopeFor(node);
+	while (scope) {
+		const symbol = scope.symbolsByName.get("Math");
+		if (symbol && !RUNTIMELESS_SYMBOL_KINDS.has(symbol.kind)) return !(symbol.kind === "const" && symbol.initializer && resolvesToGlobalNamespace(symbol.initializer, "Math", scopes));
+		scope = scope.parent;
+	}
+	return false;
+};
 const jsMinMaxLoop = defineRule({
 	id: "js-min-max-loop",
 	title: "sort() to find min or max",
@@ -17004,18 +17465,18 @@ const jsMinMaxLoop = defineRule({
 		if (!node.computed) return;
 		const object = node.object;
 		if (!isNodeOfType(object, "CallExpression") || !isMemberProperty(object.callee, "sort")) return;
+		const sortReceiver = stripParenExpression(object.callee.object);
+		if (!isNodeOfType(sortReceiver, "ArrayExpression") || !isSafeFreshNumericArray(sortReceiver)) return;
 		const comparator = object.arguments?.[0];
 		const direction = numericComparatorDirection(comparator);
 		if (!direction) return;
-		const isFirstElement = isNodeOfType(node.property, "Literal") && node.property.value === 0;
-		const isLastElement = isNodeOfType(node.property, "BinaryExpression") && node.property.operator === "-" && isNodeOfType(node.property.right, "Literal") && node.property.right.value === 1;
-		if (isFirstElement || isLastElement) {
-			const targetFunction = (direction === "ascending" ? isFirstElement : isLastElement) ? "min" : "max";
-			context.report({
-				node,
-				message: `This is slow because array.sort()[${isFirstElement ? "0" : "length-1"}] sorts the whole list just to grab the smallest or largest, so use Math.${targetFunction}(...array) instead`
-			});
-		}
+		if (!(isNodeOfType(node.property, "Literal") && node.property.value === 0)) return;
+		const targetFunction = direction === "ascending" ? "min" : "max";
+		if (hasUnsafeMathBinding(node, context.scopes) || hasUnsafeBuiltinMutation(node, targetFunction, context.scopes)) return;
+		context.report({
+			node,
+			message: `This is slow because array.sort()[0] sorts the whole list just to grab the smallest or largest, so use Math.${targetFunction}(...array) instead`
+		});
 	} })
 });
 //#endregion
@@ -27489,6 +27950,152 @@ 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;
+	const callee = stripParenExpression(callExpression.callee);
+	if (isNodeOfType(callee, "Identifier")) {
+		const symbol = scopes.symbolFor(callee);
+		return Boolean(symbol && !hasSymbolWriteBefore(symbol, callee, scopes));
+	}
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	const propertyName = getStaticPropertyName(callee);
+	const receiver = stripParenExpression(callee.object);
+	return Boolean(propertyName && isNodeOfType(receiver, "Identifier") && !hasStaticPropertyWriteBefore(receiver, propertyName, callee, scopes));
+};
+//#endregion
 //#region src/plugin/utils/function-contains-react-render-output.ts
 const NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES = new Set([
 	"FunctionDeclaration",
@@ -27501,19 +28108,68 @@ const REACT_CREATE_ELEMENT_OPTIONS = {
 	allowGlobalReactNamespace: false,
 	allowUnboundBareCalls: false
 };
-const isCallArgumentFunctionExpression = (node) => {
+const LODASH_SORT_BY_MODULE_SOURCES = new Set([
+	"lodash/sortBy",
+	"lodash/sortBy.js",
+	"lodash-es/sortBy",
+	"lodash-es/sortBy.js"
+]);
+const isArrayTypeAnnotation = (node) => {
+	if (isNodeOfType(node, "TSArrayType") || isNodeOfType(node, "TSTupleType")) return true;
+	if (!isNodeOfType(node, "TSTypeReference")) return false;
+	return isNodeOfType(node.typeName, "Identifier") && (node.typeName.name === "Array" || node.typeName.name === "ReadonlyArray");
+};
+const hasArrayTypeAnnotation = (identifier) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	const typeAnnotation = identifier.typeAnnotation;
+	return Boolean(typeAnnotation && isNodeOfType(typeAnnotation, "TSTypeAnnotation") && isArrayTypeAnnotation(typeAnnotation.typeAnnotation));
+};
+const isProvenArrayProducerCall = (node, scopes) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	const symbol = scopes.symbolFor(callee);
+	if (!symbol || hasSymbolWriteBefore(symbol, callee, scopes)) return false;
+	if (!isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") && !isNodeOfType(symbol.declarationNode, "ImportSpecifier")) return false;
+	const importBinding = getImportBindingForName(callee, callee.name);
+	if (!importBinding || importBinding.isNamespace) return false;
+	if (LODASH_SORT_BY_MODULE_SOURCES.has(importBinding.source) && importBinding.exportedName === "default") return true;
+	return (importBinding.source === "lodash" || importBinding.source === "lodash-es") && importBinding.exportedName === "sortBy";
+};
+const isProvenArrayExpression = (expression, scopes, referenceNode, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "ArrayExpression")) return true;
+	if (isProvenArrayProducerCall(candidate, scopes)) return true;
+	if (!isNodeOfType(candidate, "Identifier")) return false;
+	const symbol = scopes.symbolFor(candidate);
+	if (!symbol || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, referenceNode, scopes)) return false;
+	if (hasArrayTypeAnnotation(symbol.bindingIdentifier)) return true;
+	if (!symbol.initializer) return false;
+	visitedSymbolIds.add(symbol.id);
+	return isProvenArrayExpression(symbol.initializer, scopes, referenceNode, visitedSymbolIds);
+};
+const isProvenArrayMapCall = (node, scopes) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = stripParenExpression(node.callee);
+	if (!isNodeOfType(callee, "MemberExpression") || getStaticPropertyName(callee) !== "map") return false;
+	const receiver = stripParenExpression(callee.object);
+	if (!isProvenArrayExpression(receiver, scopes, node)) return false;
+	return !(isNodeOfType(receiver, "Identifier") && hasStaticPropertyWriteBefore(receiver, "map", node, scopes));
+};
+const isRenderPreservingCallArgumentFunction = (node, scopes) => {
 	if (node.type !== "ArrowFunctionExpression" && node.type !== "FunctionExpression") return false;
 	const parent = node.parent;
 	if (!isNodeOfType(parent, "CallExpression")) return false;
-	return parent.arguments.some((argumentNode) => argumentNode === node);
+	if (isReactApiCall(parent, "useMemo", scopes, { resolveNamedAliases: true }) && hasStableCallTarget(parent, scopes)) return parent.arguments[0] === node;
+	return parent.arguments.some((argumentNode) => argumentNode === node) && isProvenArrayMapCall(parent, scopes);
 };
-const isNestedRenderEvidenceBoundary = (node) => NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES.has(node.type) && !isCallArgumentFunctionExpression(node);
+const isNestedRenderEvidenceBoundary = (node, scopes) => NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES.has(node.type) && !isRenderPreservingCallArgumentFunction(node, scopes);
 const isRenderOutputExpression = (node, scopes) => node.type === "JSXElement" || node.type === "JSXFragment" || isReactApiCall(node, "createElement", scopes, REACT_CREATE_ELEMENT_OPTIONS);
 const containsRenderOutput$1 = (rootNode, scopes) => {
 	let hasRenderOutput = false;
 	walkAst(rootNode, (node) => {
 		if (hasRenderOutput) return false;
-		if (node !== rootNode && isNestedRenderEvidenceBoundary(node)) return false;
+		if (node !== rootNode && isNestedRenderEvidenceBoundary(node, scopes)) return false;
 		if (isRenderOutputExpression(node, scopes)) {
 			hasRenderOutput = true;
 			return false;
@@ -27522,12 +28178,13 @@ const containsRenderOutput$1 = (rootNode, scopes) => {
 	return hasRenderOutput;
 };
 const renderOutputCache = /* @__PURE__ */ new WeakMap();
-const functionContainsReactRenderOutput = (functionNode, scopes) => {
+const functionContainsReactRenderOutput = (functionNode, scopes, controlFlow) => {
 	const cachedEntry = renderOutputCache.get(functionNode);
-	if (cachedEntry && cachedEntry.scopes === scopes) return cachedEntry.hasRenderOutput;
-	const hasRenderOutput = containsRenderOutput$1(functionNode, scopes) || functionReturnsMatchingExpression(functionNode, scopes, (expression) => isRenderOutputExpression(expression, scopes));
+	if (cachedEntry && cachedEntry.scopes === scopes && cachedEntry.controlFlow === controlFlow) return cachedEntry.hasRenderOutput;
+	const hasRenderOutput = functionReturnsMatchingExpression(functionNode, scopes, (expression) => containsRenderOutput$1(expression, scopes), controlFlow);
 	renderOutputCache.set(functionNode, {
 		scopes,
+		controlFlow,
 		hasRenderOutput
 	});
 	return hasRenderOutput;
@@ -27543,8 +28200,8 @@ const isComponentDeclaration = (node) => isNodeOfType(node, "FunctionDeclaration
 const message = (name) => `\`${name}\` is a component, so calling it as a plain function (\`${name}(...)\`) runs it outside React: its hooks break, it gets no fiber/state, and memoization is lost. Render it as \`<${name} />\` instead.`;
 const symbolIsLocalComponent = (symbol, context) => {
 	const declaration = symbol.declarationNode;
-	if (isComponentDeclaration(declaration)) return functionContainsReactRenderOutput(declaration, context.scopes);
-	if (isComponentAssignment(declaration) && symbol.initializer) return functionContainsReactRenderOutput(symbol.initializer, context.scopes);
+	if (isComponentDeclaration(declaration)) return functionContainsReactRenderOutput(declaration, context.scopes, context.cfg);
+	if (isComponentAssignment(declaration) && symbol.initializer) return functionContainsReactRenderOutput(symbol.initializer, context.scopes, context.cfg);
 	return false;
 };
 const isModuleScopeDeclaration = (declaration) => {
@@ -28162,7 +28819,7 @@ const noCreateRefInFunctionComponent = defineRule({
 		if (!enclosingFunction) return;
 		const displayName = componentOrHookDisplayNameForFunction(enclosingFunction);
 		if (!displayName) return;
-		if (!(isReactHookName(displayName) || functionContainsReactRenderOutput(enclosingFunction, context.scopes))) return;
+		if (!(isReactHookName(displayName) || functionContainsReactRenderOutput(enclosingFunction, context.scopes, context.cfg))) return;
 		context.report({
 			node,
 			message: MESSAGE$30
@@ -32651,7 +33308,7 @@ const noGiantComponent = defineRule({
 			FunctionDeclaration(node) {
 				if (!node.id?.name || !isUppercaseName(node.id.name)) return;
 				if (getOversizedComponentLineCount(node) === null) return;
-				if (!functionContainsReactRenderOutput(node, context.scopes)) return;
+				if (!functionContainsReactRenderOutput(node, context.scopes, context.cfg)) return;
 				reportOversizedComponent(node.id, node.id.name);
 			},
 			VariableDeclarator(node) {
@@ -32659,7 +33316,7 @@ const noGiantComponent = defineRule({
 				const functionNode = unwrapReactHocFunction(node.init);
 				if (!functionNode) return;
 				if (getOversizedComponentLineCount(functionNode) === null) return;
-				if (!functionContainsReactRenderOutput(functionNode, context.scopes)) return;
+				if (!functionContainsReactRenderOutput(functionNode, context.scopes, context.cfg)) return;
 				reportOversizedComponent(node.id, node.id.name);
 			}
 		};
@@ -34939,7 +35596,7 @@ const noManyBooleanProps = defineRule({
 			if (!param) return;
 			const propsBinding = resolveFirstArgumentBinding(param);
 			if (!propsBinding) return;
-			if (!functionContainsReactRenderOutput(functionNode, context.scopes)) return;
+			if (!functionContainsReactRenderOutput(functionNode, context.scopes, context.cfg)) return;
 			if (isNodeOfType(propsBinding, "ObjectPattern")) {
 				const callbackUsedNames = collectCallbackUsedNames(body, param, context.scopes);
 				const booleanLikePropNames = [];
@@ -37901,6 +38558,174 @@ 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) => {
@@ -37908,20 +38733,19 @@ const isPropTypesKey = (key, computed) => {
 	if (computed) return isNodeOfType(key, "Literal") && key.value === PROP_TYPES_PROPERTY;
 	return isNodeOfType(key, "Identifier") && key.name === PROP_TYPES_PROPERTY;
 };
-const getComponentNameFromPropTypesAssignment = (left) => {
+const getComponentFromPropTypesAssignment = (left) => {
 	if (!isNodeOfType(left, "MemberExpression")) return null;
 	if (!isPropTypesKey(left.property, Boolean(left.computed))) return null;
-	if (!isNodeOfType(left.object, "Identifier")) return null;
-	if (!isUppercaseName(left.object.name)) return null;
-	return left.object.name;
+	const receiver = stripParenExpression(left.object);
+	if (!isNodeOfType(receiver, "Identifier")) return null;
+	if (!isUppercaseName(receiver.name)) return null;
+	return receiver;
 };
-const getComponentNameFromClassProperty = (node) => {
+const getComponentNameFromClassProperty = (node, scopes) => {
 	if (!node.static) return null;
 	if (!isPropTypesKey(node.key, Boolean(node.computed))) return null;
-	const classBody = node.parent;
-	if (!isNodeOfType(classBody, "ClassBody")) return null;
-	const classNode = classBody.parent;
-	if (!classNode) return null;
+	const classNode = isNodeOfType(node.parent, "ClassBody") ? node.parent.parent : null;
+	if (!classNode || !isProvenReactClassComponent(classNode, scopes)) return null;
 	if ((isNodeOfType(classNode, "ClassDeclaration") || isNodeOfType(classNode, "ClassExpression")) && classNode.id?.name && isUppercaseName(classNode.id.name)) return classNode.id.name;
 	if (!isNodeOfType(classNode, "ClassExpression")) return null;
 	const declarator = classNode.parent;
@@ -37942,15 +38766,17 @@ const noPropTypes = defineRule({
 	create: (context) => ({
 		AssignmentExpression(node) {
 			if (node.operator !== "=") return;
-			const componentName = getComponentNameFromPropTypesAssignment(node.left);
-			if (!componentName) return;
+			const component = getComponentFromPropTypesAssignment(node.left);
+			if (!component) return;
+			const symbol = context.scopes.symbolFor(component);
+			if (!symbol || !isProvenReactComponentSymbol(symbol, context.scopes, context.cfg, component)) return;
 			context.report({
 				node: node.left,
-				message: buildMessage$11(componentName)
+				message: buildMessage$11(component.name)
 			});
 		},
 		PropertyDefinition(node) {
-			const componentName = getComponentNameFromClassProperty(node);
+			const componentName = getComponentNameFromClassProperty(node, context.scopes);
 			if (!componentName) return;
 			context.report({
 				node: node.key,
@@ -40428,7 +41254,7 @@ const noThisInSfc = defineRule({
 			const enclosingFunction = findEnclosingFunctionComponent(node);
 			if (!enclosingFunction) return;
 			if (!looksLikeFunctionComponent(enclosingFunction)) return;
-			if (!functionContainsReactRenderOutput(enclosingFunction, context.scopes)) return;
+			if (!functionContainsReactRenderOutput(enclosingFunction, context.scopes, context.cfg)) return;
 			if (functionHasOwnThisMemberWrite(enclosingFunction)) return;
 			context.report({
 				node,
@@ -42093,21 +42919,21 @@ const expressionContainsJsxOrCreateElement = (root) => {
 	});
 	return found;
 };
-const functionContainsJsxOrCreateElement = (functionNode, scopes) => expressionContainsJsxOrCreateElement(functionNode) || functionReturnsMatchingExpression(functionNode, scopes, expressionContainsJsxOrCreateElement);
+const functionContainsJsxOrCreateElement = (functionNode, scopes, controlFlow) => expressionContainsJsxOrCreateElement(functionNode) || functionReturnsMatchingExpression(functionNode, scopes, expressionContainsJsxOrCreateElement, controlFlow);
 const isReactClassComponent = (classNode) => {
 	if (isEs6Component(classNode)) return true;
 	return expressionContainsJsxOrCreateElement(classNode);
 };
-const findEnclosingComponent = (node, scopes) => {
+const findEnclosingComponent = (node, scopes, controlFlow) => {
 	let walker = node.parent;
 	while (walker) {
 		if (isFunctionLike$2(walker)) {
 			const componentName = inferFunctionLikeName(walker);
-			if (componentName && isReactComponentName(componentName) && functionContainsJsxOrCreateElement(walker, scopes)) return {
+			if (componentName && isReactComponentName(componentName) && functionContainsJsxOrCreateElement(walker, scopes, controlFlow)) return {
 				component: walker,
 				name: componentName
 			};
-			if (!componentName && functionContainsJsxOrCreateElement(walker, scopes) && walker.parent && isNodeOfType(walker.parent, "ExportDefaultDeclaration")) return {
+			if (!componentName && functionContainsJsxOrCreateElement(walker, scopes, controlFlow) && walker.parent && isNodeOfType(walker.parent, "ExportDefaultDeclaration")) return {
 				component: walker,
 				name: null
 			};
@@ -42346,7 +43172,7 @@ const noUnstableNestedComponents = defineRule({
 				if (renderPropRegex.test(propInfo.propName)) return;
 				if (settings.allowAsProps) return;
 			}
-			const enclosing = findEnclosingComponent(candidateNode, context.scopes);
+			const enclosing = findEnclosingComponent(candidateNode, context.scopes, context.cfg);
 			if (!enclosing) return;
 			const gatedName = propInfo ? null : requiredInstantiationName;
 			queuedReports.push({
@@ -42357,7 +43183,7 @@ const noUnstableNestedComponents = defineRule({
 			});
 		};
 		const checkFunctionLike = (node) => {
-			if (!functionContainsJsxOrCreateElement(node, context.scopes)) return;
+			if (!functionContainsJsxOrCreateElement(node, context.scopes, context.cfg)) return;
 			const inferredName = inferFunctionLikeName(node);
 			const propInfo = isComponentDeclaredInProp(node);
 			const isObjectCallback = isObjectCallbackCandidate(node);
@@ -42968,7 +43794,7 @@ const objectExpressionBundlesComponents = (objectExpression, state) => {
 			continue;
 		}
 		if (!(!property.computed && isNodeOfType(property.key, "Identifier") && isReactComponentName(property.key.name))) continue;
-		if ((isNodeOfType(value, "ArrowFunctionExpression") || isNodeOfType(value, "FunctionExpression")) && functionContainsReactRenderOutput(value, state.scopes)) return true;
+		if ((isNodeOfType(value, "ArrowFunctionExpression") || isNodeOfType(value, "FunctionExpression")) && functionContainsReactRenderOutput(value, state.scopes, state.controlFlow)) return true;
 		if (isNodeOfType(value, "CallExpression") && isHocCallee(value.callee, state) && value.arguments.length > 0) return true;
 	}
 	return false;
@@ -43078,11 +43904,12 @@ const onlyExportComponents = defineRule({
 					allowExportNames: new Set(settings.allowExportNames),
 					allowConstantExport: settings.allowConstantExport,
 					localComponentNames,
-					scopes: context.scopes
+					scopes: context.scopes,
+					controlFlow: context.cfg
 				};
 				for (const child of componentCandidates) {
 					if (isNodeOfType(child, "FunctionDeclaration") && child.id) {
-						if (isReactComponentName(child.id.name) && !isInsideFunctionScope(child) && functionContainsReactRenderOutput(child, context.scopes)) localComponentNames.add(child.id.name);
+						if (isReactComponentName(child.id.name) && !isInsideFunctionScope(child) && functionContainsReactRenderOutput(child, context.scopes, context.cfg)) localComponentNames.add(child.id.name);
 					}
 					if (isNodeOfType(child, "ClassDeclaration") && child.id) {
 						if (isReactComponentName(child.id.name) && isEs6Component(child) && !isInsideFunctionScope(child)) localComponentNames.add(child.id.name);
@@ -43091,7 +43918,7 @@ const onlyExportComponents = defineRule({
 						const initializer = child.init;
 						if (isReactComponentName(child.id.name) && (canBeReactFunctionComponent(initializer, state) || (initializer ? isEs6Component(skipTsExpression(initializer)) : false)) && !isInsideFunctionScope(child)) {
 							const expression = initializer ? skipTsExpression(initializer) : null;
-							if (!(expression !== null && (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression"))) || functionContainsReactRenderOutput(expression, context.scopes)) localComponentNames.add(child.id.name);
+							if (!(expression !== null && (isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression"))) || functionContainsReactRenderOutput(expression, context.scopes, context.cfg)) localComponentNames.add(child.id.name);
 						}
 					}
 				}
@@ -47313,10 +48140,10 @@ const rerenderLazyStateInit = defineRule({
 //#endregion
 //#region src/plugin/rules/performance/rerender-memo-before-early-return.ts
 const isJsxExpression = (node) => Boolean(node && isJsxElementOrFragment(stripParenExpression(node)));
-const callbackReturnsJsx = (callback, scopes) => {
+const callbackReturnsJsx = (callback, scopes, controlFlow) => {
 	if (!callback) return false;
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
-	return functionReturnsMatchingExpression(callback, scopes, isJsxExpression);
+	return functionReturnsMatchingExpression(callback, scopes, isJsxExpression, controlFlow);
 };
 const returnArgumentUsesAnyName = (returnStatement, names) => {
 	if (!isNodeOfType(returnStatement, "ReturnStatement") || !returnStatement.argument) return false;
@@ -47394,7 +48221,7 @@ const rerenderMemoBeforeEarlyReturn = defineRule({
 					if (!isNodeOfType(stmt, "VariableDeclaration")) continue;
 					for (const declarator of stmt.declarations ?? []) {
 						const init = declarator.init;
-						if (isNodeOfType(init, "CallExpression") && isHookCall$2(init, "useMemo") && callbackReturnsJsx(init.arguments?.[0], context.scopes)) {
+						if (isNodeOfType(init, "CallExpression") && isHookCall$2(init, "useMemo") && callbackReturnsJsx(init.arguments?.[0], context.scopes, context.cfg)) {
 							memoNode = declarator;
 							callbackGuardTests = collectLeadingCallbackGuardTests(init.arguments?.[0]);
 							if (isNodeOfType(declarator.id, "Identifier")) memoConsumerNames.add(declarator.id.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.6-dev.0d11bd5",
+  "version": "0.7.6-dev.1d7b6e2",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",