oxlint-plugin-react-doctor 0.7.9-dev.c7f61cd → 0.7.9-dev.d7d38d7

package/dist/index.js

@@ -579,22 +579,6 @@ const EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS = new Set([
 	"ResizeObserver",
 	"PerformanceObserver"
 ]);
-const EXTERNAL_SYNC_DOM_MEMBER_METHOD_NAMES = new Set([
-	"blur",
-	"focus",
-	"getBoundingClientRect",
-	"getClientRects",
-	"measure",
-	"measureInWindow",
-	"measureLayout",
-	"scroll",
-	"scrollBy",
-	"scrollIntoView",
-	"scrollTo",
-	"select",
-	"setRangeText",
-	"setSelectionRange"
-]);
 const STORAGE_OBJECTS = new Set(["localStorage", "sessionStorage"]);
 //#endregion
 //#region src/plugin/constants/react.ts
@@ -20012,28 +19996,6 @@ const jsLengthCheckFirst = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/is-proven-global-namespace-reference.ts
-const isProvenGlobalObjectReference = (expression, scopes, visitedSymbolIds = /* @__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" || visitedSymbolIds.has(symbol.id)) return false;
-	visitedSymbolIds.add(symbol.id);
-	return isProvenGlobalObjectReference(symbol.initializer, scopes, visitedSymbolIds);
-};
-const isProvenGlobalNamespaceReference = (expression, namespaceName, scopes, visitedSymbolIds = /* @__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" || visitedSymbolIds.has(symbol.id)) return false;
-		visitedSymbolIds.add(symbol.id);
-		return isProvenGlobalNamespaceReference(symbol.initializer, namespaceName, scopes, visitedSymbolIds);
-	}
-	return isNodeOfType(strippedExpression, "MemberExpression") && getStaticPropertyName(strippedExpression) === namespaceName && isProvenGlobalObjectReference(strippedExpression.object, scopes);
-};
-//#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"]);
@@ -20090,6 +20052,26 @@ const isSafeFreshNumericArray = (arrayExpression) => {
 	}
 	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")) {
@@ -20098,7 +20080,7 @@ const resolvesToGlobalMethod = (expression, namespaceName, methodNames, scopes,
 		visitedSymbols.add(symbol.id);
 		return resolvesToGlobalMethod(symbol.initializer, namespaceName, methodNames, scopes, visitedSymbols);
 	}
-	return isNodeOfType(strippedExpression, "MemberExpression") && methodNames.has(getStaticPropertyName(strippedExpression) ?? "") && isProvenGlobalNamespaceReference(strippedExpression.object, namespaceName, scopes);
+	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);
@@ -20110,7 +20092,7 @@ const resolvesToNativeArrayPrototype = (expression, scopes, visitedSymbols = /*
 	}
 	if (isNodeOfType(strippedExpression, "MemberExpression")) {
 		const propertyName = getStaticPropertyName(strippedExpression);
-		if (propertyName === "prototype") return isProvenGlobalNamespaceReference(strippedExpression.object, "Array", scopes);
+		if (propertyName === "prototype") return resolvesToGlobalNamespace(strippedExpression.object, "Array", scopes);
 		return propertyName === "__proto__" && isNodeOfType(stripParenExpression(strippedExpression.object), "ArrayExpression");
 	}
 	if (!isNodeOfType(strippedExpression, "CallExpression")) return false;
@@ -20121,23 +20103,23 @@ const resolvesToNativeArrayPrototype = (expression, scopes, visitedSymbols = /*
 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 && isProvenGlobalObjectReference(strippedTarget.object, scopes);
+	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 (isProvenGlobalNamespaceReference(strippedTarget.object, "Math", scopes)) return propertyName === null || propertyName === targetFunction;
-	return isProvenGlobalObjectReference(strippedTarget.object, scopes) && (propertyName === null || propertyName === "Math");
+	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 (isProvenGlobalNamespaceReference(target, "Math", scopes)) propertyName = targetFunction;
-	else if (isProvenGlobalObjectReference(target, scopes)) propertyName = "Math";
+	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;
@@ -20188,7 +20170,7 @@ 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 && isProvenGlobalNamespaceReference(symbol.initializer, "Math", scopes));
+		if (symbol && !RUNTIMELESS_SYMBOL_KINDS.has(symbol.kind)) return !(symbol.kind === "const" && symbol.initializer && resolvesToGlobalNamespace(symbol.initializer, "Math", scopes));
 		scope = scope.parent;
 	}
 	return false;
@@ -28485,11 +28467,7 @@ const isProvenNativeReadMethod = (ref, methodName) => Boolean(ref.resolved?.defs
 }));
 //#endregion
 //#region src/plugin/rules/state-and-effects/utils/effect/react.ts
-const KNOWN_COMPONENT_WRAPPER_NAMES = new Set([
-	"memo",
-	"forwardRef",
-	"observer"
-]);
+const KNOWN_PURE_HOC_NAMES = new Set(["memo", "forwardRef"]);
 const startsWithUppercase = (name) => Boolean(name && name.length > 0 && name[0] >= "A" && name[0] <= "Z");
 const isReactFunctionalComponent = (node) => {
 	if (!node) return false;
@@ -28511,7 +28489,7 @@ const isReactFunctionalHOC = (analysis, node) => {
 	const isWrappedInline = () => {
 		if (!isNodeOfType(init, "CallExpression")) return false;
 		if (!isNodeOfType(init.callee, "Identifier")) return false;
-		if (KNOWN_COMPONENT_WRAPPER_NAMES.has(init.callee.name)) return false;
+		if (KNOWN_PURE_HOC_NAMES.has(init.callee.name)) return false;
 		const firstArg = init.arguments?.[0];
 		if (!firstArg) return false;
 		return isNodeOfType(firstArg, "ArrowFunctionExpression") || isNodeOfType(firstArg, "FunctionExpression");
@@ -28531,7 +28509,7 @@ const isReactFunctionalHOC = (analysis, node) => {
 			if (!args.includes(refId)) continue;
 			const callee = parent.callee;
 			const calleeName = isNodeOfType(callee, "Identifier") ? callee.name : isNodeOfType(callee, "CallExpression") && isNodeOfType(callee.callee, "Identifier") ? callee.callee.name : null;
-			if (calleeName != null && !KNOWN_COMPONENT_WRAPPER_NAMES.has(calleeName)) return true;
+			if (calleeName != null && !KNOWN_PURE_HOC_NAMES.has(calleeName)) return true;
 		}
 		return false;
 	};
@@ -32959,18 +32937,6 @@ const isProvenIntrinsicJsxElement = (openingElement, scopes) => {
 	return isIntrinsicValue(openingElement.name);
 };
 //#endregion
-//#region src/plugin/utils/is-inline-intrinsic-ref-callback.ts
-const isInlineIntrinsicRefCallback = (functionNode, scopes) => {
-	const functionExpression = findTransparentExpressionRoot(functionNode);
-	if (!isFunctionLike$1(functionExpression) || functionExpression.async || functionExpression.generator) return false;
-	const container = functionExpression.parent;
-	if (!container || !isNodeOfType(container, "JSXExpressionContainer")) return false;
-	const attribute = container.parent;
-	if (!attribute || !isNodeOfType(attribute, "JSXAttribute") || getJsxAttributeName(attribute.name) !== "ref") return false;
-	const openingElement = attribute.parent;
-	return Boolean(openingElement && isNodeOfType(openingElement, "JSXOpeningElement") && isProvenIntrinsicJsxElement(openingElement, scopes));
-};
-//#endregion
 //#region src/plugin/rules/react-builtins/is-safe-create-ref-callback-current-write.ts
 const pathStartsWith$1 = (propertyPath, prefix) => prefix.every((propertyName, index) => propertyPath[index] === propertyName);
 const collectMemberExpression = (identifier) => {
@@ -32981,6 +32947,16 @@ const collectMemberExpression = (identifier) => {
 	}
 	return expression;
 };
+const isInlineIntrinsicRefCallback = (functionNode, scopes) => {
+	const functionExpression = findTransparentExpressionRoot(functionNode);
+	if (!isFunctionLike$1(functionExpression) || functionExpression.async || functionExpression.generator) return false;
+	const container = functionExpression.parent;
+	if (!container || !isNodeOfType(container, "JSXExpressionContainer")) return false;
+	const attribute = container.parent;
+	if (!attribute || !isNodeOfType(attribute, "JSXAttribute") || getJsxAttributeName(attribute.name) !== "ref") return false;
+	const openingElement = attribute.parent;
+	return Boolean(openingElement && isNodeOfType(openingElement, "JSXOpeningElement") && isProvenIntrinsicJsxElement(openingElement, scopes));
+};
 const isSafeCreateRefCallbackCurrentWrite = (referenceNode, accessedPropertyPath, targetPropertyPath, scopes) => {
 	if (accessedPropertyPath.length !== targetPropertyPath.length + 1 || !pathStartsWith$1(accessedPropertyPath, targetPropertyPath) || accessedPropertyPath[targetPropertyPath.length] !== "current") return false;
 	const memberExpression = collectMemberExpression(referenceNode);
@@ -35924,178 +35900,17 @@ const visitSynchronousFunctionBodies = (analysisFunctions, visitor) => {
 		walkInsideStatementBlocks(analysisFunction.body, visitor);
 	}
 };
-const readStaticEffectValue = (expression, scopes, stateSymbolId, stateValue, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "Literal")) {
-		const literalValue = unwrappedExpression.value;
-		if (literalValue === null || typeof literalValue === "boolean" || typeof literalValue === "number" || typeof literalValue === "string") return { value: literalValue };
-		return null;
-	}
-	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		if (scopes.symbolFor(unwrappedExpression)?.id === stateSymbolId) return stateValue;
-		if (unwrappedExpression.name === "undefined" && scopes.isGlobalReference(unwrappedExpression)) return { value: void 0 };
-		const immutableSymbol = scopes.symbolFor(unwrappedExpression);
-		if (immutableSymbol?.kind !== "const" || !immutableSymbol.initializer || !isNodeOfType(immutableSymbol.declarationNode, "VariableDeclarator") || immutableSymbol.declarationNode.id !== immutableSymbol.bindingIdentifier || immutableSymbol.declarationNode.init !== immutableSymbol.initializer || immutableSymbol.references.some((reference) => reference.flag !== "read") || visitedSymbolIds.has(immutableSymbol.id)) return null;
-		return readStaticEffectValue(immutableSymbol.initializer, scopes, stateSymbolId, stateValue, new Set(visitedSymbolIds).add(immutableSymbol.id));
-	}
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression")) {
-		if (unwrappedExpression.operator === "void") return { value: void 0 };
-		if (unwrappedExpression.operator !== "!") return null;
-		const argumentValue = readStaticEffectValue(unwrappedExpression.argument, scopes, stateSymbolId, stateValue, visitedSymbolIds);
-		return argumentValue ? { value: !argumentValue.value } : null;
-	}
-	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
-		if (isNodeOfType(unwrappedExpression.callee, "Identifier") && unwrappedExpression.callee.name === "Boolean" && scopes.isGlobalReference(unwrappedExpression.callee) && unwrappedExpression.arguments.length === 1 && unwrappedExpression.arguments[0] && !isNodeOfType(unwrappedExpression.arguments[0], "SpreadElement")) {
-			const argumentValue = readStaticEffectValue(unwrappedExpression.arguments[0], scopes, stateSymbolId, stateValue, visitedSymbolIds);
-			return argumentValue ? { value: Boolean(argumentValue.value) } : null;
-		}
-		return null;
-	}
-	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
-		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds);
-		if (!leftValue) return null;
-		if (unwrappedExpression.operator === "&&" && !leftValue.value) return leftValue;
-		if (unwrappedExpression.operator === "||" && leftValue.value) return leftValue;
-		if (unwrappedExpression.operator === "??" && leftValue.value !== null && leftValue.value !== void 0) return leftValue;
-		return readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds);
-	}
-	if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) {
-		const testValue = readStaticEffectValue(unwrappedExpression.test, scopes, stateSymbolId, stateValue, visitedSymbolIds);
-		if (!testValue) return null;
-		return readStaticEffectValue(testValue.value ? unwrappedExpression.consequent : unwrappedExpression.alternate, scopes, stateSymbolId, stateValue, visitedSymbolIds);
-	}
-	if (isNodeOfType(unwrappedExpression, "MemberExpression") && unwrappedExpression.optional) {
-		const objectValue = readStaticEffectValue(unwrappedExpression.object, scopes, stateSymbolId, stateValue, visitedSymbolIds);
-		if (objectValue?.value === null || objectValue?.value === void 0) return { value: void 0 };
-		return null;
-	}
-	if (isNodeOfType(unwrappedExpression, "BinaryExpression")) {
-		const leftValue = readStaticEffectValue(unwrappedExpression.left, scopes, stateSymbolId, stateValue, visitedSymbolIds);
-		const rightValue = readStaticEffectValue(unwrappedExpression.right, scopes, stateSymbolId, stateValue, visitedSymbolIds);
-		if (!leftValue || !rightValue) return null;
-		if (unwrappedExpression.operator === "===" || unwrappedExpression.operator === "!==") {
-			const areEqual = leftValue.value === rightValue.value;
-			return { value: unwrappedExpression.operator === "===" ? areEqual : !areEqual };
-		}
-		if (unwrappedExpression.operator === "==" || unwrappedExpression.operator === "!=") {
-			const isLeftNullish = leftValue.value === null || leftValue.value === void 0;
-			const isRightNullish = rightValue.value === null || rightValue.value === void 0;
-			if (!isLeftNullish && !isRightNullish && typeof leftValue.value !== typeof rightValue.value) return null;
-			const areEqual = isLeftNullish || isRightNullish ? isLeftNullish && isRightNullish : leftValue.value === rightValue.value;
-			return { value: unwrappedExpression.operator === "==" ? areEqual : !areEqual };
-		}
-	}
-	return null;
-};
-const readStaticUpdaterReturnValue = (updater, scopes) => {
-	if (!isFunctionLike$1(updater) || updater.async || updater.generator) return null;
-	if (!isNodeOfType(updater.body, "BlockStatement")) return readStaticEffectValue(updater.body, scopes, null, null);
-	if (updater.body.body.length === 0) return { value: void 0 };
-	if (updater.body.body.length !== 1) return null;
-	const returnStatement = updater.body.body[0];
-	if (!isNodeOfType(returnStatement, "ReturnStatement")) return null;
-	if (!returnStatement.argument) return { value: void 0 };
-	return readStaticEffectValue(returnStatement.argument, scopes, null, null);
-};
-const readStaticSetterValue = (setterCall, scopes) => {
-	const argument = setterCall.arguments[0];
-	if (!argument) return { value: void 0 };
-	if (isNodeOfType(argument, "SpreadElement")) return null;
-	const updater = resolveExactLocalFunction(argument, scopes);
-	if (updater) return readStaticUpdaterReturnValue(updater, scopes);
-	return readStaticEffectValue(argument, scopes, null, null);
-};
-const collectStateWritesInEffect = (analysisFunctions, setterToStateName, scopes) => {
-	const stateWrites = /* @__PURE__ */ new Map();
+const collectWrittenStateNamesInEffect = (analysisFunctions, setterToStateName) => {
+	const writtenStateNames = /* @__PURE__ */ new Set();
 	visitSynchronousFunctionBodies(analysisFunctions, (child) => {
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (!isNodeOfType(child.callee, "Identifier")) return;
 		const stateName = setterToStateName.get(child.callee.name);
-		if (!stateName) return;
-		const writeInfo = stateWrites.get(stateName) ?? {
-			values: /* @__PURE__ */ new Set(),
-			hasUnknownValue: false
-		};
-		const staticValue = readStaticSetterValue(child, scopes);
-		if (staticValue) writeInfo.values.add(staticValue.value);
-		else writeInfo.hasUnknownValue = true;
-		stateWrites.set(stateName, writeInfo);
+		if (stateName) writtenStateNames.add(stateName);
 	});
-	return stateWrites;
-};
-const isGlobalBooleanCall = (node, scopes) => {
-	return isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "Boolean" && scopes.isGlobalReference(node.callee);
-};
-const isWorkNodeReachableForStateValue = (workNode, stateSymbolId, stateValue, scopes) => {
-	let currentNode = workNode;
-	while (currentNode.parent) {
-		const parentNode = currentNode.parent;
-		if (isFunctionLike$1(parentNode)) break;
-		if (isNodeOfType(parentNode, "IfStatement")) {
-			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue);
-			if (testValue) {
-				if (currentNode === parentNode.consequent && !testValue.value) return false;
-				if (currentNode === parentNode.alternate && testValue.value) return false;
-			}
-		}
-		if (isNodeOfType(parentNode, "ConditionalExpression")) {
-			const testValue = readStaticEffectValue(parentNode.test, scopes, stateSymbolId, stateValue);
-			if (testValue) {
-				if (currentNode === parentNode.consequent && !testValue.value) return false;
-				if (currentNode === parentNode.alternate && testValue.value) return false;
-			}
-		}
-		if (isNodeOfType(parentNode, "LogicalExpression") && currentNode === parentNode.right) {
-			const leftValue = readStaticEffectValue(parentNode.left, scopes, stateSymbolId, stateValue);
-			if (leftValue) {
-				if (parentNode.operator === "&&" && !leftValue.value) return false;
-				if (parentNode.operator === "||" && leftValue.value) return false;
-				if (parentNode.operator === "??" && leftValue.value !== null && leftValue.value !== void 0) return false;
-			}
-		}
-		if (isNodeOfType(parentNode, "BlockStatement")) {
-			const statementIndex = parentNode.body.findIndex((statement) => statement === currentNode);
-			if (statementIndex >= 0) for (let index = 0; index < statementIndex; index += 1) {
-				const earlierStatement = parentNode.body[index];
-				if (!isNodeOfType(earlierStatement, "IfStatement") || earlierStatement.alternate || !statementAlwaysExits(earlierStatement.consequent)) continue;
-				if (readStaticEffectValue(earlierStatement.test, scopes, stateSymbolId, stateValue)?.value) return false;
-			}
-		}
-		currentNode = parentNode;
-	}
-	return true;
-};
-const isReaderWorkNode = (node, analysisFunctions, scopes) => {
-	if (isNodeOfType(node, "CallExpression")) {
-		if (isGlobalBooleanCall(node, scopes)) return false;
-		const invokedFunction = resolveExactLocalFunction(node.callee, scopes);
-		return !invokedFunction || !analysisFunctions.has(invokedFunction);
-	}
-	return isNodeOfType(node, "AssignmentExpression") || isNodeOfType(node, "UpdateExpression") || isNodeOfType(node, "NewExpression") || isNodeOfType(node, "TaggedTemplateExpression") || isNodeOfType(node, "ThrowStatement") || isNodeOfType(node, "UnaryExpression") && node.operator === "delete";
-};
-const canStateWriteReachReaderWork = (writeInfo, readerEffect, stateSymbolId, scopes) => {
-	if (writeInfo.hasUnknownValue || stateSymbolId === null) return true;
-	for (const writtenValue of writeInfo.values) {
-		const stateValue = { value: writtenValue };
-		let didFindReachableWork = false;
-		visitSynchronousFunctionBodies(readerEffect.analysisFunctions, (child) => {
-			if (didFindReachableWork || !isReaderWorkNode(child, readerEffect.analysisFunctions, scopes)) return;
-			if (isWorkNodeReachableForStateValue(child, stateSymbolId, stateValue, scopes)) didFindReachableWork = true;
-		});
-		if (didFindReachableWork) return true;
-	}
-	return false;
+	return writtenStateNames;
 };
 const EMPTY_CLEANUP_NAME_SET = /* @__PURE__ */ new Set();
-const NON_CONTAMINATING_MAP_METHOD_NAMES = new Set([
-	"clear",
-	"delete",
-	"entries",
-	"get",
-	"has",
-	"keys",
-	"values"
-]);
 const isFunctionShapedReturn = (returnedValue, setterToStateName, isExplicitReturnStatement) => {
 	if (isNodeOfType(returnedValue, "ArrowFunctionExpression") || isNodeOfType(returnedValue, "FunctionExpression")) return true;
 	if (isNodeOfType(returnedValue, "CallExpression")) {
@@ -36146,135 +35961,27 @@ const callsOpaqueExternalSetter = (analysisFunctions, setterToStateName) => {
 	});
 	return didFindOpaqueSetterCall;
 };
-const isReactRefCall = (expression, scopes) => isNodeOfType(expression, "CallExpression") && (isReactApiCall(expression, "useRef", scopes, {
-	allowGlobalReactNamespace: true,
-	allowUnboundBareCalls: true,
-	resolveNamedAliases: true
-}) || isReactApiCall(expression, "createRef", scopes, {
-	allowGlobalReactNamespace: true,
-	allowUnboundBareCalls: true,
-	resolveNamedAliases: true
-}));
-const getDirectReactRefSymbol = (rawExpression, scopes) => {
-	const expression = stripParenExpression(rawExpression);
-	if (!isNodeOfType(expression, "Identifier")) return null;
-	const symbol = scopes.symbolFor(expression);
-	if (!symbol) return null;
-	const initializer = getDirectUnreassignedInitializer(symbol);
-	return initializer && isReactRefCall(stripParenExpression(initializer), scopes) ? symbol : null;
-};
-const isReactNativeJsxElement = (openingElement, scopes) => {
-	if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return false;
-	const symbol = scopes.symbolFor(openingElement.name);
-	const importDeclaration = symbol?.declarationNode.parent;
-	return Boolean(symbol?.kind === "import" && importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && importDeclaration.source.value === "react-native");
-};
-const isDirectHostJsxRef = (symbol, scopes) => {
-	let hostRefCount = 0;
-	for (const reference of symbol.references) {
-		const expression = findTransparentExpressionRoot(reference.identifier);
-		const container = expression.parent;
-		if (isNodeOfType(container, "MemberExpression") && container.object === expression && getStaticPropertyName(container) === "current") continue;
-		if (!container || !isNodeOfType(container, "JSXExpressionContainer") || container.expression !== expression) return false;
-		const attribute = container.parent;
-		if (!attribute || !isNodeOfType(attribute, "JSXAttribute") || getJsxAttributeName(attribute.name) !== "ref") return false;
-		const openingElement = attribute.parent;
-		if (!openingElement || !isNodeOfType(openingElement, "JSXOpeningElement") || !isProvenIntrinsicJsxElement(openingElement, scopes) && !isReactNativeJsxElement(openingElement, scopes)) return false;
-		hostRefCount += 1;
-	}
-	return hostRefCount > 0;
-};
-const isIntrinsicRefCallbackParameter = (expression, scopes) => {
-	const identifier = stripParenExpression(expression);
-	if (!isNodeOfType(identifier, "Identifier")) return false;
-	const callback = findEnclosingFunction$1(identifier);
-	if (!callback || !isFunctionLike$1(callback) || !isInlineIntrinsicRefCallback(callback, scopes)) return false;
-	const rawFirstParameter = callback.params?.[0];
-	const firstParameter = isNodeOfType(rawFirstParameter, "AssignmentPattern") ? rawFirstParameter.left : rawFirstParameter;
-	const symbol = scopes.symbolFor(identifier);
-	return Boolean(firstParameter && symbol?.bindingIdentifier === firstParameter);
-};
-const getDirectReactRefCall = (symbol, scopes) => {
-	const initializer = getDirectUnreassignedInitializer(symbol);
-	if (!initializer) return null;
-	const expression = stripParenExpression(initializer);
-	return isNodeOfType(expression, "CallExpression") && isReactRefCall(expression, scopes) ? expression : null;
-};
-const storesOnlyIntrinsicRefCallbackValues = (symbol, scopes) => {
-	const initialValue = getDirectReactRefCall(symbol, scopes)?.arguments?.[0];
-	if (!initialValue || !isNodeOfType(initialValue, "NewExpression") || !isNodeOfType(initialValue.callee, "Identifier") || initialValue.callee.name !== "Map" || !scopes.isGlobalReference(initialValue.callee) || initialValue.arguments.length !== 0) return false;
-	let intrinsicValueWriteCount = 0;
-	for (const reference of symbol.references) {
-		const identifier = findTransparentExpressionRoot(reference.identifier);
-		const currentMember = identifier.parent;
-		if (!isNodeOfType(currentMember, "MemberExpression") || currentMember.object !== identifier || getStaticPropertyName(currentMember) !== "current") return false;
-		const currentExpression = findTransparentExpressionRoot(currentMember);
-		const methodMember = currentExpression.parent;
-		if (!isNodeOfType(methodMember, "MemberExpression") || methodMember.object !== currentExpression) return false;
-		const methodName = getStaticPropertyName(methodMember);
-		if (methodName === "size") continue;
-		const call = methodMember.parent;
-		if (!isNodeOfType(call, "CallExpression") || call.callee !== methodMember) return false;
-		if (methodName && NON_CONTAMINATING_MAP_METHOD_NAMES.has(methodName)) continue;
-		if (methodName !== "set") return false;
-		const storedValue = call.arguments[1];
-		if (!storedValue || isNodeOfType(storedValue, "SpreadElement") || !isIntrinsicRefCallbackParameter(storedValue, scopes)) return false;
-		intrinsicValueWriteCount += 1;
-	}
-	return intrinsicValueWriteCount > 0;
-};
-const isDerivedFromProvenDomRefCurrent = (rawExpression, scopes, didReadCollectionValue = false, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(rawExpression);
-	if (isNodeOfType(expression, "Identifier")) {
-		const symbol = scopes.symbolFor(expression);
-		if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-		const initializer = getDirectUnreassignedInitializer(symbol);
-		if (!initializer) return false;
-		visitedSymbolIds.add(symbol.id);
-		return isDerivedFromProvenDomRefCurrent(initializer, scopes, didReadCollectionValue, visitedSymbolIds);
-	}
-	if (isNodeOfType(expression, "MemberExpression")) {
-		if (getStaticPropertyName(expression) === "current") {
-			const symbol = getDirectReactRefSymbol(expression.object, scopes);
-			return Boolean(symbol && (isDirectHostJsxRef(symbol, scopes) || didReadCollectionValue && storesOnlyIntrinsicRefCallbackValues(symbol, scopes)));
-		}
-		return isDerivedFromProvenDomRefCurrent(expression.object, scopes, didReadCollectionValue, visitedSymbolIds);
-	}
-	if (!isNodeOfType(expression, "CallExpression")) return false;
-	const callee = stripParenExpression(expression.callee);
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	return isDerivedFromProvenDomRefCurrent(callee.object, scopes, didReadCollectionValue || getStaticPropertyName(callee) === "get", visitedSymbolIds);
-};
-const isCommittedDomSyncNode = (node, scopes) => {
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	const callee = stripParenExpression(node.callee);
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	const propertyName = getStaticPropertyName(callee);
-	if (propertyName === null || !EXTERNAL_SYNC_DOM_MEMBER_METHOD_NAMES.has(propertyName)) return false;
-	return isDerivedFromProvenDomRefCurrent(callee.object, scopes) || isProvenBrowserApiReceiver(callee.object, "dom-event-target", scopes);
-};
 const isExternalSyncNode = (node) => {
 	if (isNodeOfType(node, "NewExpression")) return isNodeOfType(node.callee, "Identifier") && EXTERNAL_SYNC_OBSERVER_CONSTRUCTORS.has(node.callee.name);
 	if (isNodeOfType(node, "AssignmentExpression")) return isNodeOfType(node.left, "MemberExpression") && isNodeOfType(node.left.property, "Identifier") && node.left.property.name === "current";
 	if (!isNodeOfType(node, "CallExpression")) return false;
 	if (isNodeOfType(node.callee, "Identifier")) return EXTERNAL_SYNC_DIRECT_CALLEE_NAMES.has(node.callee.name);
-	if (!isNodeOfType(node.callee, "MemberExpression")) return false;
-	const propertyName = getStaticPropertyName(node.callee);
-	if (propertyName === null) return false;
+	if (!isNodeOfType(node.callee, "MemberExpression") || !isNodeOfType(node.callee.property, "Identifier")) return false;
+	const propertyName = node.callee.property.name;
 	if (EXTERNAL_SYNC_MEMBER_METHOD_NAMES.has(propertyName)) return true;
 	if (isBrowserStorageReceiver(node.callee.object)) return true;
 	if (!EXTERNAL_SYNC_AMBIGUOUS_HTTP_METHOD_NAMES.has(propertyName)) return false;
 	const receiverRootName = getRootIdentifierName(node.callee.object);
 	return receiverRootName !== null && EXTERNAL_SYNC_HTTP_CLIENT_RECEIVERS.has(receiverRootName);
 };
-const isExternalSyncEffect = (effectCallback, analysisFunctions, setterToStateName, scopes, allowCommittedDomSync) => {
+const isExternalSyncEffect = (effectCallback, analysisFunctions, setterToStateName) => {
 	if (!isFunctionLike$1(effectCallback)) return false;
 	if (!isNodeOfType(effectCallback.body, "BlockStatement")) {
 		if (isFunctionShapedReturn(effectCallback.body, setterToStateName, false)) return true;
 	} else for (const statement of effectCallback.body.body ?? []) if (isNodeOfType(statement, "ReturnStatement") && statement.argument && isFunctionShapedReturn(statement.argument, setterToStateName, true)) return true;
 	let didFindExternalCall = false;
 	visitSynchronousFunctionBodies(analysisFunctions, (child) => {
-		if (isExternalSyncNode(child) || allowCommittedDomSync && isCommittedDomSyncNode(child, scopes)) didFindExternalCall = true;
+		if (isExternalSyncNode(child)) didFindExternalCall = true;
 	});
 	return didFindExternalCall;
 };
@@ -36290,45 +35997,32 @@ const noEffectChain = defineRule({
 			const useStateBindings = collectUseStateBindings(componentBody);
 			if (useStateBindings.length === 0) return;
 			const setterToStateName = /* @__PURE__ */ new Map();
-			const stateSymbolIds = /* @__PURE__ */ new Map();
-			for (const binding of useStateBindings) {
-				setterToStateName.set(binding.setterName, binding.valueName);
-				if (!isNodeOfType(binding.declarator.id, "ArrayPattern")) continue;
-				const stateIdentifier = binding.declarator.id.elements[0];
-				if (isNodeOfType(stateIdentifier, "Identifier")) {
-					const stateSymbol = context.scopes.symbolFor(stateIdentifier);
-					if (stateSymbol) stateSymbolIds.set(binding.valueName, stateSymbol.id);
-				}
-			}
+			for (const binding of useStateBindings) setterToStateName.set(binding.setterName, binding.valueName);
 			const storageSetterNames = collectStorageHookSetterNames(componentBody);
 			const effectInfos = [];
 			for (const effectCall of findTopLevelEffectCalls(componentBody)) {
 				const callback = getEffectCallback(effectCall, context.scopes);
 				if (!callback || !isFunctionLike$1(callback) || callback.async) continue;
 				const analysisFunctions = collectSynchronouslyInvokedFunctions(callback, context.scopes);
-				const stateWrites = collectStateWritesInEffect(analysisFunctions, setterToStateName, context.scopes);
-				const writtenStateNames = new Set(stateWrites.keys());
+				const writtenStateNames = collectWrittenStateNamesInEffect(analysisFunctions, setterToStateName);
 				effectInfos.push({
 					node: effectCall,
 					depNames: collectDepIdentifierNames(effectCall),
-					stateWrites,
-					analysisFunctions,
-					isExternalSync: isExternalSyncEffect(callback, analysisFunctions, setterToStateName, context.scopes, writtenStateNames.size === 0) || callsStorageHookSetter(analysisFunctions, storageSetterNames) || writtenStateNames.size === 0 && callsOpaqueExternalSetter(analysisFunctions, setterToStateName)
+					writtenStateNames,
+					isExternalSync: isExternalSyncEffect(callback, analysisFunctions, setterToStateName) || callsStorageHookSetter(analysisFunctions, storageSetterNames) || writtenStateNames.size === 0 && callsOpaqueExternalSetter(analysisFunctions, setterToStateName)
 				});
 			}
 			if (effectInfos.length < 2) return;
 			const reportedNodes = /* @__PURE__ */ new Set();
 			for (const writerEffect of effectInfos) {
 				if (writerEffect.isExternalSync) continue;
-				if (writerEffect.stateWrites.size === 0) continue;
+				if (writerEffect.writtenStateNames.size === 0) continue;
 				for (const readerEffect of effectInfos) {
 					if (readerEffect === writerEffect) continue;
 					if (readerEffect.isExternalSync) continue;
 					if (readerEffect.depNames.size === 0) continue;
 					let chainedStateName = null;
-					for (const [writtenName, writeInfo] of writerEffect.stateWrites) {
-						if (!readerEffect.depNames.has(writtenName)) continue;
-						if (!canStateWriteReachReaderWork(writeInfo, readerEffect, stateSymbolIds.get(writtenName) ?? null, context.scopes)) continue;
+					for (const writtenName of writerEffect.writtenStateNames) if (readerEffect.depNames.has(writtenName)) {
 						chainedStateName = writtenName;
 						break;
 					}
@@ -39995,18 +39689,6 @@ const functionContainsProvenReactHookCall = (functionNode, scopes) => {
 	return containsReactHookCall;
 };
 //#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$1(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/function-returns-props-children.ts
 const functionReturnsPropsChildren = (functionNode, scopes, controlFlow) => {
 	if (!isFunctionLike$1(functionNode) || functionNode.params.length === 0) return false;
@@ -40039,8 +39721,17 @@ const functionReturnsPropsChildren = (functionNode, scopes, controlFlow) => {
 	}, controlFlow);
 };
 //#endregion
-//#region src/plugin/utils/function-has-react-component-evidence.ts
-const functionHasReactComponentEvidence = (functionNode, scopes, controlFlow) => functionContainsReactRenderOutput(functionNode, scopes, controlFlow) || functionReturnsPropsChildren(functionNode, scopes, controlFlow) || functionContainsProvenReactHookCall(functionNode, scopes) && functionReturnsOnlyNull(functionNode);
+//#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$1(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) => {
@@ -40073,16 +39764,17 @@ const isProvenStyledComponentExpression = (expression, scopes) => {
 //#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 functionHasReactComponentEvidence(candidate, scopes, controlFlow);
+	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 functionHasReactComponentEvidence(symbol.declarationNode, scopes, controlFlow);
+		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));
 	}
@@ -40109,7 +39801,7 @@ const isProvenReactComponentSymbol = (symbol, scopes, controlFlow, componentRefe
 	for (const candidateSymbol of candidateSymbols) {
 		if (hasSymbolWriteBefore(candidateSymbol, componentReference, scopes)) continue;
 		if (isComponentDeclaration(candidateSymbol.declarationNode)) {
-			if (functionHasReactComponentEvidence(candidateSymbol.declarationNode, scopes, controlFlow)) return true;
+			if (functionHasComponentEvidence(candidateSymbol.declarationNode, scopes, controlFlow)) return true;
 			continue;
 		}
 		const initializer = candidateSymbol.initializer ? stripParenExpression(candidateSymbol.initializer) : null;
@@ -43895,53 +43587,6 @@ const noPropCallbackInEffect = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-prop-callback-in-render.ts
-const functionBindingSymbols = (functionNode, scopes) => {
-	let bindingIdentifier = null;
-	if (isNodeOfType(functionNode, "FunctionDeclaration") && functionNode.id) bindingIdentifier = functionNode.id;
-	else {
-		let bindingExpression = findTransparentExpressionRoot(functionNode);
-		let parent = bindingExpression.parent;
-		while (isNodeOfType(parent, "CallExpression") && parent.arguments[0] === bindingExpression) {
-			const callee = parent.callee;
-			const wrapperName = isNodeOfType(callee, "Identifier") ? callee.name : isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") ? callee.property.name : null;
-			if (!isReactApiCall(parent, REACT_HOC_NAMES, scopes, {
-				allowGlobalReactNamespace: true,
-				resolveNamedAliases: true
-			}) && (!wrapperName || REACT_HOC_NAMES.has(wrapperName) || !COMPONENT_HOC_WRAPPER_NAMES.has(wrapperName))) break;
-			bindingExpression = findTransparentExpressionRoot(parent);
-			parent = bindingExpression.parent;
-		}
-		if (isNodeOfType(parent, "VariableDeclarator") && parent.init === bindingExpression && isNodeOfType(parent.id, "Identifier")) bindingIdentifier = parent.id;
-	}
-	if (!bindingIdentifier) return [];
-	let scope = scopes.scopeFor(functionNode);
-	while (scope) {
-		const symbols = scope.symbols.filter((symbol) => symbol.bindingIdentifier === bindingIdentifier);
-		if (symbols.length > 0) return symbols;
-		scope = scope.parent;
-	}
-	return [];
-};
-const symbolHasReactComponentUse = (symbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	if (visitedSymbolIds.has(symbol.id)) return false;
-	visitedSymbolIds.add(symbol.id);
-	for (const reference of symbol.references) {
-		const identifier = reference.identifier;
-		if (hasSymbolWriteBefore(symbol, identifier, scopes)) continue;
-		const parent = identifier.parent;
-		if (isNodeOfType(parent, "JSXOpeningElement") && isNodeOfType(parent.name, "JSXIdentifier") && parent.name === identifier) return true;
-		const expression = findTransparentExpressionRoot(identifier);
-		const expressionParent = expression.parent;
-		if (isNodeOfType(expressionParent, "CallExpression") && expressionParent.arguments[0] === expression && isReactApiCall(expressionParent, "createElement", scopes, { resolveNamedAliases: true })) return true;
-		if (!isNodeOfType(expressionParent, "VariableDeclarator") || expressionParent.init !== expression || !isNodeOfType(expressionParent.id, "Identifier") || !isNodeOfType(expressionParent.parent, "VariableDeclaration") || expressionParent.parent.kind !== "const") continue;
-		const aliasSymbol = scopes.symbolFor(expressionParent.id);
-		if (aliasSymbol && symbolHasReactComponentUse(aliasSymbol, scopes, visitedSymbolIds)) return true;
-	}
-	return false;
-};
-const functionHasReactComponentUse = (functionNode, scopes) => {
-	return functionBindingSymbols(functionNode, scopes).some((symbol) => symbolHasReactComponentUse(symbol, scopes));
-};
 const isPreservedThroughConciseArrow = (callExpression, scopes) => {
 	let node = callExpression;
 	let parent = node.parent;
@@ -43988,10 +43633,7 @@ const noPropCallbackInRender = defineRule({
 	create: (context) => ({ CallExpression(node) {
 		if (!isResultDiscardedCall(node)) return;
 		if (isPreservedThroughConciseArrow(node, context.scopes)) return;
-		const renderPhaseOwner = findRenderPhaseComponentOrHook(node, context.scopes);
-		if (!renderPhaseOwner) return;
-		const renderPhaseOwnerName = componentOrHookDisplayNameForFunction(renderPhaseOwner);
-		if (!renderPhaseOwnerName || !isReactHookName(renderPhaseOwnerName) && !functionHasReactComponentEvidence(renderPhaseOwner, context.scopes, context.cfg) && !functionHasReactComponentUse(renderPhaseOwner, context.scopes)) return;
+		if (!findRenderPhaseComponentOrHook(node, context.scopes)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
 		const callee = stripParenExpression(node.callee);
@@ -44727,110 +44369,11 @@ const isSameRefCurrentMember = (node, refSymbol, scopes) => {
 	return isNodeOfType(receiver, "Identifier") && resolveConstIdentifierAlias(receiver, scopes)?.id === refSymbol.id;
 };
 const isSameRefCurrentAlias = (node, refSymbol, scopes) => {
-	const expression = stripParenExpression(node);
-	if (isSameRefCurrentMember(expression, refSymbol, scopes)) return true;
-	if (!isNodeOfType(expression, "Identifier")) return false;
-	const aliasSymbol = scopes.symbolFor(expression);
+	if (isSameRefCurrentMember(node, refSymbol, scopes)) return true;
+	if (!isNodeOfType(node, "Identifier")) return false;
+	const aliasSymbol = scopes.symbolFor(node);
 	return aliasSymbol?.kind === "const" && aliasSymbol.initializer !== null && isSameRefCurrentMember(stripParenExpression(aliasSymbol.initializer), refSymbol, scopes);
 };
-const resolveImmutableInitializationValue = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(node);
-	if (!isNodeOfType(expression, "Identifier")) return expression;
-	const symbol = scopes.symbolFor(expression);
-	if (!symbol || symbol.kind !== "const" || !symbol.initializer || symbol.references.some((reference) => reference.flag !== "read") || visitedSymbolIds.has(symbol.id)) return null;
-	visitedSymbolIds.add(symbol.id);
-	return resolveImmutableInitializationValue(symbol.initializer, scopes, visitedSymbolIds);
-};
-const isProvablyTruthyInitializationValue = (node, scopes) => {
-	const expression = resolveImmutableInitializationValue(node, scopes);
-	return Boolean(expression && (isNodeOfType(expression, "NewExpression") || isNodeOfType(expression, "ObjectExpression") || isNodeOfType(expression, "ArrayExpression") || isNodeOfType(expression, "ArrowFunctionExpression") || isNodeOfType(expression, "FunctionExpression") || isNodeOfType(expression, "ClassExpression")));
-};
-const getInitializationConstructorName = (node, scopes) => {
-	const expression = resolveImmutableInitializationValue(node, scopes);
-	if (!expression) return null;
-	if (isNodeOfType(expression, "NewExpression")) {
-		const callee = stripParenExpression(expression.callee);
-		return isNodeOfType(callee, "Identifier") ? callee.name : null;
-	}
-	return null;
-};
-const isClosedTruthyTypeDomain = (typeNode, initializationValue, scopes) => {
-	const initializationExpression = stripParenExpression(initializationValue);
-	if (isNodeOfType(typeNode, "TSTypeLiteral")) return isNodeOfType(initializationExpression, "ObjectExpression");
-	if (isNodeOfType(typeNode, "TSArrayType") || isNodeOfType(typeNode, "TSTupleType")) return isNodeOfType(initializationExpression, "ArrayExpression");
-	if (isNodeOfType(typeNode, "TSFunctionType") || isNodeOfType(typeNode, "TSConstructorType")) return isNodeOfType(initializationExpression, "ArrowFunctionExpression") || isNodeOfType(initializationExpression, "FunctionExpression") || isNodeOfType(initializationExpression, "ClassExpression");
-	if (isNodeOfType(typeNode, "TSObjectKeyword")) return true;
-	if (!isNodeOfType(typeNode, "TSTypeReference")) return false;
-	const typeName = typeNode.typeName;
-	return isNodeOfType(typeName, "Identifier") && typeName.name === getInitializationConstructorName(initializationExpression, scopes);
-};
-const refHasClosedFalsySentinelDomain = (refSymbol, initializationValue, scopes) => {
-	const initializer = refSymbol.initializer ? stripParenExpression(refSymbol.initializer) : null;
-	if (!initializer || !isNodeOfType(initializer, "CallExpression")) return false;
-	const [initialValue] = initializer.arguments ?? [];
-	if (!initialValue || isNodeOfType(initialValue, "SpreadElement") || !isEmptySentinel(initialValue, scopes)) return false;
-	const [declaredType] = initializer.typeArguments?.params ?? [];
-	if (!declaredType || !isNodeOfType(declaredType, "TSUnionType")) return false;
-	let hasEmptySentinel = false;
-	let hasTruthyDomain = false;
-	for (const memberType of declaredType.types ?? []) {
-		if (isNodeOfType(memberType, "TSNullKeyword") || isNodeOfType(memberType, "TSUndefinedKeyword")) {
-			hasEmptySentinel = true;
-			continue;
-		}
-		if (!isClosedTruthyTypeDomain(memberType, initializationValue, scopes)) return false;
-		hasTruthyDomain = true;
-	}
-	return hasEmptySentinel && hasTruthyDomain;
-};
-const isSafeRefIdentifierUse = (identifier) => {
-	const expressionRoot = findTransparentExpressionRoot(identifier);
-	const parent = expressionRoot.parent;
-	if (parent && isNodeOfType(parent, "VariableDeclarator") && parent.id === expressionRoot && parent.parent !== null && isNodeOfType(parent.parent, "VariableDeclaration") && parent.parent.kind === "const") return true;
-	if (parent && isNodeOfType(parent, "MemberExpression") && parent.object === expressionRoot && getStaticPropertyName(parent) === "current") return true;
-	if (!parent || !isNodeOfType(parent, "VariableDeclarator") || parent.init !== expressionRoot) return false;
-	return isNodeOfType(parent.id, "Identifier") && parent.parent !== null && isNodeOfType(parent.parent, "VariableDeclaration") && parent.parent.kind === "const";
-};
-const refDoesNotEscape = (branchRoot, refSymbol, scopes) => {
-	let didEscape = false;
-	walkAst(branchRoot, (child) => {
-		if (didEscape) return false;
-		if (!isNodeOfType(child, "Identifier")) return;
-		if (resolveConstIdentifierAlias(child, scopes)?.id !== refSymbol.id) return;
-		if (child === refSymbol.bindingIdentifier || isSafeRefIdentifierUse(child)) return;
-		didEscape = true;
-		return false;
-	});
-	return !didEscape;
-};
-const expressionContainsRefCurrent = (expression, refSymbol, scopes) => {
-	let didFindRefCurrent = false;
-	walkAst(expression, (child) => {
-		if (didFindRefCurrent) return false;
-		if (resolveReactRefSymbol(child, scopes)?.id !== refSymbol.id) return;
-		didFindRefCurrent = true;
-		return false;
-	});
-	return didFindRefCurrent;
-};
-const hasNoCompetingRefCurrentWrite = (branchRoot, assignmentExpression, refSymbol, scopes) => {
-	let writeCount = 0;
-	walkAst(branchRoot, (child) => {
-		if (writeCount > 1) return false;
-		if (isNodeOfType(child, "AssignmentExpression")) {
-			if (expressionContainsRefCurrent(child.left, refSymbol, scopes)) writeCount++;
-			return;
-		}
-		if (isNodeOfType(child, "UpdateExpression") || isNodeOfType(child, "UnaryExpression") && child.operator === "delete") {
-			if (expressionContainsRefCurrent(child.argument, refSymbol, scopes)) writeCount++;
-			return;
-		}
-		if (isNodeOfType(child, "ForInStatement") || isNodeOfType(child, "ForOfStatement")) {
-			if (expressionContainsRefCurrent(child.left, refSymbol, scopes)) writeCount++;
-		}
-	});
-	return writeCount === 1 && expressionContainsRefCurrent(assignmentExpression.left, refSymbol, scopes);
-};
 const isEmptySentinel = (node, scopes) => isNodeOfType(node, "Literal") && node.value === null || isNodeOfType(node, "Identifier") && node.name === "undefined" && scopes.isGlobalReference(node);
 const hasRepeatedExecutionAncestor = (node, stop) => {
 	let ancestor = node.parent;
@@ -44879,22 +44422,18 @@ const hasNoPriorCoExecutableWrite = (assignmentExpression, branchRoot, refSymbol
 const isDocumentedLazyInitialization = (assignmentExpression, refSymbol, scopes) => {
 	if (assignmentExpression.operator === "??=" || assignmentExpression.operator === "||=") return true;
 	if (assignmentExpression.operator !== "=") return false;
-	const renderOwner = findRenderPhaseComponentOrHook(assignmentExpression, scopes);
-	if (!renderOwner) return false;
 	let descendant = assignmentExpression;
 	let ancestor = descendant.parent;
 	while (ancestor) {
-		const test = isNodeOfType(ancestor, "IfStatement") ? stripParenExpression(ancestor.test) : null;
-		if (isNodeOfType(ancestor, "IfStatement") && test && isNodeOfType(test, "UnaryExpression") && test.operator === "!" && isSameRefCurrentAlias(test.argument, refSymbol, scopes) && ancestor.consequent === descendant && isProvablyTruthyInitializationValue(assignmentExpression.right, scopes) && refHasClosedFalsySentinelDomain(refSymbol, assignmentExpression.right, scopes) && !hasRepeatedExecutionAncestor(assignmentExpression, ancestor.consequent) && !hasRepeatedExecutionAncestor(ancestor, renderOwner) && hasNoPriorCoExecutableWrite(assignmentExpression, ancestor.consequent, refSymbol, scopes) && hasNoCompetingRefCurrentWrite(renderOwner, assignmentExpression, refSymbol, scopes) && refDoesNotEscape(renderOwner, refSymbol, scopes)) return true;
-		if (isNodeOfType(ancestor, "IfStatement") && isNodeOfType(test, "BinaryExpression") && [
+		if (isNodeOfType(ancestor, "IfStatement") && isNodeOfType(ancestor.test, "BinaryExpression") && [
 			"===",
 			"==",
 			"!==",
 			"!="
-		].includes(test.operator)) {
-			const { left, right } = test;
+		].includes(ancestor.test.operator)) {
+			const { left, right } = ancestor.test;
 			const comparesEmptySentinel = isSameRefCurrentAlias(left, refSymbol, scopes) && isEmptySentinel(right, scopes) || isSameRefCurrentAlias(right, refSymbol, scopes) && isEmptySentinel(left, scopes);
-			const guardedBranch = test.operator === "===" || test.operator === "==" ? ancestor.consequent : ancestor.alternate;
+			const guardedBranch = ancestor.test.operator === "===" || ancestor.test.operator === "==" ? ancestor.consequent : ancestor.alternate;
 			if (comparesEmptySentinel && guardedBranch === descendant && guardedBranch && !hasRepeatedExecutionAncestor(assignmentExpression, guardedBranch) && hasNoPriorCoExecutableWrite(assignmentExpression, guardedBranch, refSymbol, scopes)) return true;
 		}
 		descendant = ancestor;
@@ -52019,31 +51558,6 @@ const preferModuleScopePureFunction = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/get-require-call-source.ts
-const getRequireCallSource = (expression) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "MemberExpression")) return getRequireCallSource(unwrappedExpression.object);
-	if (!isNodeOfType(unwrappedExpression, "CallExpression")) return null;
-	if (!isNodeOfType(unwrappedExpression.callee, "Identifier") || unwrappedExpression.callee.name !== "require") return null;
-	const [firstArgument] = unwrappedExpression.arguments ?? [];
-	if (!firstArgument || !isNodeOfType(firstArgument, "Literal")) return null;
-	return typeof firstArgument.value === "string" ? firstArgument.value : null;
-};
-//#endregion
-//#region src/plugin/utils/is-proven-node-crypto-namespace-reference.ts
-const NODE_CRYPTO_MODULE_SOURCES = new Set(["crypto", "node:crypto"]);
-const isProvenNodeCryptoNamespaceReference = (expression, scopes) => {
-	const identifier = stripParenExpression(expression);
-	if (!isNodeOfType(identifier, "Identifier")) return false;
-	const symbol = resolveConstIdentifierAlias(identifier, scopes);
-	if (!symbol) return false;
-	if (symbol.kind === "import") {
-		const importBinding = getImportBindingForName(identifier, symbol.name);
-		return Boolean(importBinding && NODE_CRYPTO_MODULE_SOURCES.has(importBinding.source));
-	}
-	return Boolean(symbol.kind === "const" && symbol.initializer && NODE_CRYPTO_MODULE_SOURCES.has(getRequireCallSource(symbol.initializer) ?? ""));
-};
-//#endregion
 //#region src/plugin/rules/architecture/prefer-module-scope-static-value.ts
 const MUTATING_RECEIVER_METHOD_NAMES = new Set([...MUTATING_ARRAY_METHODS, ...MUTATING_COLLECTION_METHODS]);
 const isMutationContext = (referenceIdentifier) => {
@@ -52157,9 +51671,9 @@ const isImpureCall = (node, scopes) => {
 	const callee = node.callee;
 	if (isNodeOfType(callee, "Identifier")) return isImpureBareCallee(callee, scopes);
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return false;
+	if (!isNodeOfType(callee.object, "Identifier")) return false;
 	if (!isNodeOfType(callee.property, "Identifier")) return false;
-	for (const [receiverName, receiverMethodNames] of IMPURE_MEMBER_RECEIVERS) if (receiverMethodNames.has(callee.property.name) && (isProvenGlobalNamespaceReference(callee.object, receiverName, scopes) || receiverName === "crypto" && isProvenNodeCryptoNamespaceReference(callee.object, scopes))) return true;
-	return false;
+	return Boolean(IMPURE_MEMBER_RECEIVERS.get(callee.object.name)?.has(callee.property.name));
 };
 const containsImpureExpression = (expression, scopes) => {
 	let foundImpure = false;
@@ -56928,6 +56442,16 @@ const rnListCallbackPerRow = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/get-require-call-source.ts
+const getRequireCallSource = (expression) => {
+	if (isNodeOfType(expression, "MemberExpression")) return getRequireCallSource(expression.object);
+	if (!isNodeOfType(expression, "CallExpression")) return null;
+	if (!isNodeOfType(expression.callee, "Identifier") || expression.callee.name !== "require") return null;
+	const [firstArgument] = expression.arguments ?? [];
+	if (!firstArgument || !isNodeOfType(firstArgument, "Literal")) return null;
+	return typeof firstArgument.value === "string" ? firstArgument.value : null;
+};
+//#endregion
 //#region src/plugin/utils/get-initializer-module-source.ts
 const getInitializerModuleSource = (contextNode, initializer) => {
 	const requireSource = getRequireCallSource(initializer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.9-dev.c7f61cd",
+  "version": "0.7.9-dev.d7d38d7",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",