oxlint-plugin-react-doctor 0.7.9-dev.0ff57fa → 0.7.9-dev.11388bf

package/dist/index.js

@@ -7637,7 +7637,6 @@ const areExpressionsStructurallyEqual = (a, b) => {
 	if (a.type !== b.type) return false;
 	if (isNodeOfType(a, "ThisExpression")) return true;
 	if (isNodeOfType(a, "Identifier") && isNodeOfType(b, "Identifier")) return a.name === b.name;
-	if (isNodeOfType(a, "PrivateIdentifier") && isNodeOfType(b, "PrivateIdentifier")) return a.name === b.name;
 	if (isNodeOfType(a, "Literal") && isNodeOfType(b, "Literal")) return a.value === b.value;
 	if (isNodeOfType(a, "MemberExpression") && isNodeOfType(b, "MemberExpression")) {
 		if (a.computed !== b.computed) return false;
@@ -8959,7 +8958,7 @@ const isReactNamespaceImport = (identifier, scopes) => {
 	if (!symbol || !isImportedFromReact(symbol)) return false;
 	return isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier") || getImportedName(symbol.declarationNode) === "default";
 };
-const isReactNamespaceReceiver$1 = (receiver, scopes, options) => {
+const isReactNamespaceReceiver = (receiver, scopes, options) => {
 	if (!isNodeOfType(receiver, "Identifier")) return false;
 	if (isReactNamespaceImport(receiver, scopes)) return true;
 	return Boolean(options.allowGlobalReactNamespace && receiver.name === "React" && scopes.isGlobalReference(receiver));
@@ -8972,7 +8971,7 @@ const isDestructuredReactApiBinding = (identifier, apiNames, scopes, options) =>
 	for (const property of pattern.properties) {
 		if (!isNodeOfType(property, "Property") || property.value !== symbol.bindingIdentifier) continue;
 		const propertyName = getStaticPropertyKeyName(property);
-		return Boolean(propertyName && includesApiName(apiNames, propertyName) && isReactNamespaceReceiver$1(stripParenExpression(symbol.initializer), scopes, options));
+		return Boolean(propertyName && includesApiName(apiNames, propertyName) && isReactNamespaceReceiver(stripParenExpression(symbol.initializer), scopes, options));
 	}
 	return false;
 };
@@ -8996,7 +8995,7 @@ const isReactApiCallee = (rawCallee, apiNames, scopes, options, visitedSymbolIds
 		return Boolean(options.allowUnboundBareCalls && includesApiName(apiNames, callee.name) && scopes.isGlobalReference(callee));
 	}
 	if (!isNodeOfType(callee, "MemberExpression") || !includesApiName(apiNames, getStaticPropertyName(callee) ?? "")) return false;
-	return isReactNamespaceReceiver$1(stripParenExpression(callee.object), scopes, options);
+	return isReactNamespaceReceiver(stripParenExpression(callee.object), scopes, options);
 };
 //#endregion
 //#region src/plugin/utils/is-proven-browser-api-receiver.ts
@@ -29422,7 +29421,7 @@ const nextjsNoVercelOgImport = defineRule({
 //#endregion
 //#region src/plugin/rules/a11y/no-access-key.ts
 const MESSAGE$39 = "Screen reader users can lose their shortcuts because `accessKey` clashes with them, so remove it.";
-const isUndefinedIdentifier$1 = (expression) => isNodeOfType(expression, "Identifier") && expression.name === "undefined";
+const isUndefinedIdentifier = (expression) => isNodeOfType(expression, "Identifier") && expression.name === "undefined";
 const noAccessKey = defineRule({
 	id: "no-access-key",
 	title: "accessKey attribute used",
@@ -29447,7 +29446,7 @@ const noAccessKey = defineRule({
 			if (isNodeOfType(attributeValue, "JSXExpressionContainer")) {
 				const expression = attributeValue.expression;
 				if (!expression || expression.type === "JSXEmptyExpression") return;
-				if (isUndefinedIdentifier$1(expression)) return;
+				if (isUndefinedIdentifier(expression)) return;
 				context.report({
 					node: accessKey,
 					message: MESSAGE$39
@@ -30212,12 +30211,6 @@ const isReactNamespaceImportReference = (ref) => Boolean(ref?.resolved?.defs.som
 	const importDeclaration = declarationNode.parent;
 	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && isNodeOfType(importDeclaration.source, "Literal") && importDeclaration.source.value === "react");
 }));
-const isReactNamespaceReceiver = (analysis, node) => {
-	const receiver = stripParenExpression(node);
-	if (!isNodeOfType(receiver, "Identifier")) return false;
-	const namespaceReference = getRef(analysis, receiver);
-	return namespaceReference?.resolved ? isReactNamespaceImportReference(namespaceReference) : receiver.name === "React";
-};
 const isGenuineReactHookDeclarator = (analysis, declarator, hookName) => {
 	if (!isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.init, "CallExpression")) return false;
 	const callee = stripParenExpression(declarator.init.callee);
@@ -30226,20 +30219,24 @@ const isGenuineReactHookDeclarator = (analysis, declarator, hookName) => {
 		if (!reference?.resolved) return callee.name === hookName;
 		return isReactNamedImportReference(reference, hookName);
 	}
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== hookName) return false;
-	return isReactNamespaceReceiver(analysis, callee.object);
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.object, "Identifier") || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== hookName) return false;
+	const namespaceReference = getRef(analysis, callee.object);
+	if (!namespaceReference?.resolved) return callee.object.name === "React";
+	return isReactNamespaceImportReference(namespaceReference);
 };
 const isHookCallee$1 = (analysis, node, hookName) => {
 	if (!node) return false;
 	if (isNodeOfType(node, "Identifier")) {
 		if (node.name === hookName) return true;
 		if (isReactNamedImportReference(getRef(analysis, node), hookName)) return true;
-		const receiverRoot = findTransparentExpressionRoot(node);
-		const parent = receiverRoot.parent;
-		if (parent && isNodeOfType(parent, "MemberExpression") && parent.object === receiverRoot && isReactNamespaceReceiver(analysis, node) && isNodeOfType(parent.property, "Identifier") && parent.property.name === hookName) return true;
+		const parent = node.parent;
+		if (parent && isNodeOfType(parent, "MemberExpression") && isNodeOfType(parent.object, "Identifier") && parent.object.name === "React" && isNodeOfType(parent.property, "Identifier") && parent.property.name === hookName) return true;
 		return false;
 	}
-	if (isNodeOfType(node, "MemberExpression")) return isReactNamespaceReceiver(analysis, node.object) && isNodeOfType(node.property, "Identifier") && node.property.name === hookName;
+	if (isNodeOfType(node, "MemberExpression")) {
+		const receiver = stripParenExpression(node.object);
+		return isNodeOfType(receiver, "Identifier") && receiver.name === "React" && isNodeOfType(node.property, "Identifier") && node.property.name === hookName;
+	}
 	return false;
 };
 const isUseEffect = (node) => {
@@ -30663,88 +30660,7 @@ const isIndependentWriterIdentifier = (componentFunction, identifier, includeDef
 	if (HANDLER_BINDING_NAME_PATTERN.test(bindingName)) return true;
 	return isSetterWiredToJsxHandler(componentFunction, bindingName);
 };
-const isSynchronousFunction = (functionNode) => {
-	const functionMetadata = functionNode;
-	return functionMetadata.async !== true && functionMetadata.generator !== true;
-};
-const findBindingVariable = (analysis, bindingIdentifier) => {
-	for (const scope of analysis.scopeManager.scopes) for (const variable of scope.variables) if (variable.identifiers.includes(bindingIdentifier)) return variable;
-	return null;
-};
-const getImmutableFunctionVariable = (analysis, componentFunction, functionNode) => {
-	if (!isSynchronousFunction(functionNode) || !isAstDescendant(functionNode, componentFunction)) return null;
-	const bindingIdentifier = getFunctionBindingIdentifier$1(functionNode);
-	if (!bindingIdentifier) return null;
-	const variable = findBindingVariable(analysis, bindingIdentifier);
-	if (!variable || variable.defs.length !== 1 || variable.references.some((reference) => reference.isWrite() && !reference.init)) return null;
-	const definition = variable.defs[0];
-	if (definition.type === "FunctionName") return definition.node === functionNode ? variable : null;
-	if (definition.type !== "Variable") return null;
-	const declarator = definition.node;
-	if (!isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.parent, "VariableDeclaration") || declarator.parent.kind !== "const") return null;
-	if (declarator.init === functionNode) return variable;
-	if (isNodeOfType(declarator.init, "CallExpression") && declarator.init.arguments?.[0] === functionNode && isGenuineReactHookDeclarator(analysis, declarator, "useCallback")) return variable;
-	return null;
-};
-const getJsxEventValueAttribute = (identifier) => {
-	const expression = findTransparentExpressionRoot(identifier);
-	const expressionContainer = expression.parent;
-	if (!isNodeOfType(expressionContainer, "JSXExpressionContainer") || expressionContainer.expression !== expression) return null;
-	const attribute = expressionContainer.parent;
-	if (!isNodeOfType(attribute, "JSXAttribute")) return null;
-	const attributeName = getJsxAttributeName(attribute.name);
-	return attributeName && isEventHandlerName(attributeName) ? attribute : null;
-};
-const getInlineJsxEventCallbackAttribute = (callExpression) => {
-	const callbackFunction = findEnclosingFunction$1(callExpression);
-	if (!callbackFunction || !isSynchronousFunction(callbackFunction)) return null;
-	return getJsxEventValueAttribute(callbackFunction);
-};
-const isReactHookDependencyReference = (identifier) => {
-	const expression = findTransparentExpressionRoot(identifier);
-	const dependencyArray = expression.parent;
-	if (!isNodeOfType(dependencyArray, "ArrayExpression") || !(dependencyArray.elements ?? []).includes(expression)) return false;
-	const hookCall = dependencyArray.parent;
-	if (!isNodeOfType(hookCall, "CallExpression") || hookCall.arguments?.[1] !== dependencyArray) return false;
-	const callee = hookCall.callee;
-	if (isNodeOfType(callee, "Identifier")) return /^use[A-Z0-9]/.test(callee.name);
-	return Boolean(isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier") && /^use[A-Z0-9]/.test(callee.property.name));
-};
-const hasReachableJsxEventCallPath = (analysis, context, componentFunction, functionVariable, visitedVariables) => {
-	if (visitedVariables.has(functionVariable)) return false;
-	const nextVisitedVariables = new Set(visitedVariables).add(functionVariable);
-	const callExpressions = [];
-	let hasDirectJsxEventReference = false;
-	for (const reference of functionVariable.references) {
-		if (reference.init) continue;
-		const identifier = reference.identifier;
-		if (reference.isWrite()) return false;
-		const jsxEventValueAttribute = getJsxEventValueAttribute(identifier);
-		if (jsxEventValueAttribute) {
-			if (isNodeReachableWithinFunction(jsxEventValueAttribute, context)) hasDirectJsxEventReference = true;
-			continue;
-		}
-		if (isReactHookDependencyReference(identifier)) continue;
-		const callExpression = getCallExpr(reference);
-		if (!callExpression) return false;
-		const jsxEventCallbackAttribute = getInlineJsxEventCallbackAttribute(callExpression);
-		if (jsxEventCallbackAttribute) {
-			if (isNodeReachableWithinFunction(callExpression, context) && isNodeReachableWithinFunction(jsxEventCallbackAttribute, context)) hasDirectJsxEventReference = true;
-			continue;
-		}
-		callExpressions.push(callExpression);
-	}
-	if (hasDirectJsxEventReference) return true;
-	for (const callExpression of callExpressions) {
-		if (!isNodeReachableWithinFunction(callExpression, context)) continue;
-		const callerFunction = findEnclosingFunction$1(callExpression);
-		if (!callerFunction || callerFunction === componentFunction) continue;
-		const callerVariable = getImmutableFunctionVariable(analysis, componentFunction, callerFunction);
-		if (callerVariable && hasReachableJsxEventCallPath(analysis, context, componentFunction, callerVariable, nextVisitedVariables)) return true;
-	}
-	return false;
-};
-const hasUserInputSetterWriter = (analysis, context, setterRef, effectNode, includeDeferredWriters = false) => {
+const hasUserInputSetterWriter = (setterRef, effectNode, includeDeferredWriters = false) => {
 	if (!setterRef.resolved) return false;
 	const componentFunction = findEnclosingFunction$1(effectNode);
 	if (!componentFunction) return false;
@@ -30753,11 +30669,6 @@ const hasUserInputSetterWriter = (analysis, context, setterRef, effectNode, incl
 		const identifier = reference.identifier;
 		if (isAstDescendant(identifier, effectNode)) continue;
 		if (isIndependentWriterIdentifier(componentFunction, identifier, includeDeferredWriters)) return true;
-		if (!isNodeReachableWithinFunction(identifier, context)) continue;
-		const writerFunction = findEnclosingFunction$1(identifier);
-		if (!writerFunction || writerFunction === componentFunction) continue;
-		const writerVariable = getImmutableFunctionVariable(analysis, componentFunction, writerFunction);
-		if (writerVariable && hasReachableJsxEventCallPath(analysis, context, componentFunction, writerVariable, /* @__PURE__ */ new Set())) return true;
 	}
 	return false;
 };
@@ -31647,7 +31558,7 @@ const areInMutuallyExclusiveBranches = (leftNode, rightNode) => {
 	}
 	return false;
 };
-const collectEffectStateWriteFacts = (analysis, context, effectNode, currentFilename) => {
+const collectEffectStateWriteFacts = (analysis, effectNode, currentFilename) => {
 	const frames = collectBoundedEffectExecutionFrames(analysis, effectNode, currentFilename);
 	if (frames.length === 0) return [];
 	const effectHasCleanup = hasCleanup(analysis, effectNode);
@@ -31677,7 +31588,7 @@ const collectEffectStateWriteFacts = (analysis, context, effectNode, currentFile
 			for (const returnedExpression of returnedExpressions) mergeEvidence(valueEvidence, collectValueEvidence(analysis, returnedExpression, updaterFrame, remainingValueCallFrames));
 		} else valueEvidence = collectValueEvidence(analysis, writtenValue, frame, remainingValueCallFrames);
 		const sourceReferences = [...valueEvidence.sourceReferences].filter((sourceReference) => getUseStateDecl(analysis, sourceReference) !== stateDeclarator);
-		const hasIndependentWriter = hasUserInputSetterWriter(analysis, context, setterReference, effectNode, true);
+		const hasIndependentWriter = hasUserInputSetterWriter(setterReference, effectNode, true);
 		const doesMatchStateInitializer = matchesStateInitializer(analysis, callExpression, stateDeclarator);
 		if (effectHasCleanup && (frame.isDeferred || valueEvidence.hasUnknownSource || valueEvidence.hasDeferredIntroducedValue || valueEvidence.readsExternalValue)) cleanupManagedStateDeclarators.add(stateDeclarator);
 		const isRenderKnownCopy = sourceReferences.length > 0 && !frame.isDeferred && !valueEvidence.hasUnknownSource && !valueEvidence.hasDeferredIntroducedValue && !valueEvidence.readsExternalValue && !hasIndependentWriter;
@@ -31718,7 +31629,7 @@ const noAdjustStateOnPropChange = defineRule({
 		const dependencyReferences = getEffectDepsRefs(analysis, node);
 		if (!dependencyReferences) return;
 		if (!dependencyReferences.flatMap((reference) => isState(analysis, reference) ? [] : getUpstreamRefs(analysis, reference)).some((reference) => isProp(analysis, reference))) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, context, node, context.filename)) {
+		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
 			if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
 			context.report({
 				node: fact.callExpression,
@@ -36292,7 +36203,7 @@ const noDerivedState = defineRule({
 				if (!isUseEffect(node)) return;
 				const analysis = getProgramAnalysis(node);
 				if (!analysis) return;
-				for (const fact of collectEffectStateWriteFacts(analysis, context, node, context.filename)) {
+				for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
 					if (!fact.isRenderKnownCopy || fact.resetsSourceState) continue;
 					reportStateWrite(fact.callExpression, fact.stateDeclarator);
 				}
@@ -36312,7 +36223,7 @@ const noDerivedStateEffect = defineRule({
 		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
-		if (!collectEffectStateWriteFacts(analysis, context, node, context.filename).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
+		if (!collectEffectStateWriteFacts(analysis, node, context.filename).find((fact) => fact.isRenderKnownCopy && !fact.resetsSourceState)) return;
 		context.report({
 			node,
 			message: "You pay an extra render for state you can derive from other values."
@@ -36788,20 +36699,9 @@ const noDidMountSetState = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/find-enclosing-class.ts
-const findEnclosingClass = (node) => {
-	let ancestor = node.parent;
-	while (ancestor) {
-		if (isNodeOfType(ancestor, "ClassDeclaration") || isNodeOfType(ancestor, "ClassExpression")) return ancestor;
-		ancestor = ancestor.parent ?? null;
-	}
-	return null;
-};
-//#endregion
 //#region src/plugin/rules/react-builtins/no-did-update-set-state.ts
 const LIFECYCLE_NAMES$1 = new Set(["componentDidUpdate"]);
 const MESSAGE$27 = "Calling setState in componentDidUpdate can trigger another update immediately, loop forever, and freeze the component.";
-const DIFFERENCE_OPERATORS = new Set(["!=", "!=="]);
 const EQUALITY_OPERATORS = new Set([
 	"==",
 	"===",
@@ -36813,8 +36713,6 @@ const FUNCTION_NODE_TYPES = new Set([
 	"FunctionExpression",
 	"ArrowFunctionExpression"
 ]);
-const CLASS_NODE_TYPES = new Set(["ClassDeclaration", "ClassExpression"]);
-const callbackRefFieldNamesByClass = /* @__PURE__ */ new WeakMap();
 const isLifecycleMethodFunction = (node) => {
 	if (!FUNCTION_NODE_TYPES.has(node.type)) return false;
 	const parent = node.parent;
@@ -36870,187 +36768,6 @@ const getStaticMemberName = (node) => {
 	if (!isNodeOfType(node, "MemberExpression") || node.computed === true) return null;
 	return isNodeOfType(node.property, "Identifier") ? node.property.name : null;
 };
-const getMemberIdentity = (property) => {
-	const propertyName = getPropertyKeyName$2(property);
-	if (propertyName !== void 0) return isNodeOfType(property, "PrivateIdentifier") ? `#${propertyName}` : propertyName;
-	return isNodeOfType(property, "Literal") && typeof property.value === "string" ? property.value : null;
-};
-const collectPreviousSourcePaths = (pattern, domain, members, previousSourcePaths) => {
-	if (!pattern) return;
-	const unwrappedPattern = stripParenExpression(pattern);
-	if (isNodeOfType(unwrappedPattern, "Identifier")) {
-		previousSourcePaths.set(unwrappedPattern.name, {
-			domain,
-			members: [...members],
-			source: "previous"
-		});
-		return;
-	}
-	if (isNodeOfType(unwrappedPattern, "AssignmentPattern")) {
-		collectPreviousSourcePaths(unwrappedPattern.left, domain, members, previousSourcePaths);
-		return;
-	}
-	if (!isNodeOfType(unwrappedPattern, "ObjectPattern")) return;
-	for (const property of unwrappedPattern.properties) {
-		if (!isNodeOfType(property, "Property")) continue;
-		const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
-		if (!propertyName) continue;
-		collectPreviousSourcePaths(property.value, domain, [...members, propertyName], previousSourcePaths);
-	}
-};
-const getStateSourcePath = (node, previousSourcePaths) => {
-	let currentNode = stripParenExpression(node);
-	const members = [];
-	while (isNodeOfType(currentNode, "MemberExpression")) {
-		const memberName = getStaticMemberName(currentNode);
-		if (!memberName) return null;
-		members.unshift(memberName);
-		currentNode = stripParenExpression(currentNode.object);
-	}
-	if (isNodeOfType(currentNode, "ThisExpression")) {
-		const [domain, ...pathMembers] = members;
-		if (domain !== "props" && domain !== "state") return null;
-		return {
-			domain,
-			members: pathMembers,
-			source: "current"
-		};
-	}
-	if (!isNodeOfType(currentNode, "Identifier")) return null;
-	const previousSourcePath = previousSourcePaths.get(currentNode.name);
-	return previousSourcePath ? {
-		...previousSourcePath,
-		members: [...previousSourcePath.members, ...members]
-	} : null;
-};
-const haveMatchingStateSourcePaths = (left, right) => left.domain === right.domain && left.members.length === right.members.length && left.members.every((member, index) => member === right.members[index]);
-const collectConjunctiveStateSourceComparisons = (test, previousSourcePaths, comparisons) => {
-	const expression = stripParenExpression(test);
-	if (isNodeOfType(expression, "LogicalExpression") && expression.operator === "&&") {
-		collectConjunctiveStateSourceComparisons(expression.left, previousSourcePaths, comparisons);
-		collectConjunctiveStateSourceComparisons(expression.right, previousSourcePaths, comparisons);
-		return;
-	}
-	if (!isNodeOfType(expression, "BinaryExpression") || !EQUALITY_OPERATORS.has(expression.operator)) return;
-	const leftPath = getStateSourcePath(expression.left, previousSourcePaths);
-	const rightPath = getStateSourcePath(expression.right, previousSourcePaths);
-	if (Boolean(leftPath) === Boolean(rightPath)) return;
-	const path = leftPath ?? rightPath;
-	if (!path) return;
-	comparisons.push({
-		comparedValue: leftPath ? expression.right : expression.left,
-		isDifference: DIFFERENCE_OPERATORS.has(expression.operator),
-		path
-	});
-};
-const isHistoricalToCurrentTransitionGuard = (test, previousSourcePaths) => {
-	const expression = stripParenExpression(test);
-	if (isNodeOfType(expression, "LogicalExpression") && expression.operator === "||") return isHistoricalToCurrentTransitionGuard(expression.left, previousSourcePaths) && isHistoricalToCurrentTransitionGuard(expression.right, previousSourcePaths);
-	const comparisons = [];
-	collectConjunctiveStateSourceComparisons(expression, previousSourcePaths, comparisons);
-	return comparisons.some((comparison, index) => comparisons.slice(index + 1).some((candidate) => comparison.path.source !== candidate.path.source && comparison.isDifference !== candidate.isDifference && haveMatchingStateSourcePaths(comparison.path, candidate.path) && areExpressionsStructurallyEqual(comparison.comparedValue, candidate.comparedValue)));
-};
-const getThisFieldName = (node) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (!isNodeOfType(unwrappedNode, "MemberExpression") || unwrappedNode.computed === true || !isNodeOfType(stripParenExpression(unwrappedNode.object), "ThisExpression")) return null;
-	return getMemberIdentity(unwrappedNode.property);
-};
-const isUndefinedIdentifier = (node) => {
-	const unwrappedNode = stripParenExpression(node);
-	return isNodeOfType(unwrappedNode, "Identifier") && unwrappedNode.name === "undefined";
-};
-const isDirectRefParameterValue = (node, parameterSymbolId, scopes) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (isNodeOfType(unwrappedNode, "Identifier")) return scopes.symbolFor(unwrappedNode)?.id === parameterSymbolId;
-	if (!isNodeOfType(unwrappedNode, "LogicalExpression") || unwrappedNode.operator !== "??") return false;
-	const left = stripParenExpression(unwrappedNode.left);
-	return isNodeOfType(left, "Identifier") && scopes.symbolFor(left)?.id === parameterSymbolId && isUndefinedIdentifier(unwrappedNode.right);
-};
-const getCallbackRefAssignedFields = (callback, scopes) => {
-	const firstParameter = (callback.params ?? [])[0];
-	if (!firstParameter) return /* @__PURE__ */ new Set();
-	const parameterIdentifier = isNodeOfType(firstParameter, "AssignmentPattern") ? firstParameter.left : firstParameter;
-	if (!isNodeOfType(parameterIdentifier, "Identifier")) return /* @__PURE__ */ new Set();
-	const parameterSymbolId = scopes.symbolFor(parameterIdentifier)?.id;
-	if (parameterSymbolId === void 0) return /* @__PURE__ */ new Set();
-	const body = callback.body;
-	if (!body) return /* @__PURE__ */ new Set();
-	const assignedFieldNames = /* @__PURE__ */ new Set();
-	walkAst(body, (node) => {
-		if (node !== body && (FUNCTION_NODE_TYPES.has(node.type) && !isImmediatelyInvokedFunction(node) || CLASS_NODE_TYPES.has(node.type))) return false;
-		const assignmentTarget = isNodeOfType(node, "AssignmentExpression") && node.left || isNodeOfType(node, "UpdateExpression") && node.argument || isNodeOfType(node, "UnaryExpression") && node.operator === "delete" && node.argument || null;
-		if (!assignmentTarget) return;
-		const fieldName = getThisFieldName(assignmentTarget);
-		if (!fieldName) return;
-		if (isNodeOfType(node, "AssignmentExpression") && node.operator === "=" && isDirectRefParameterValue(node.right, parameterSymbolId, scopes)) {
-			assignedFieldNames.add(fieldName);
-			return;
-		}
-		assignedFieldNames.delete(fieldName);
-	});
-	return assignedFieldNames;
-};
-const getClassMemberCallback = (classNode, memberName) => {
-	const classBody = classNode.body?.body ?? [];
-	for (const member of classBody) {
-		if (!isNodeOfType(member, "MethodDefinition") && !isNodeOfType(member, "PropertyDefinition")) continue;
-		if (member.static === true) continue;
-		const key = member.key;
-		if (getMemberIdentity(key) !== memberName) continue;
-		const value = member.value;
-		return value && FUNCTION_NODE_TYPES.has(value.type) ? value : null;
-	}
-	return null;
-};
-const collectCallbackRefFieldsFromExpression = (expression, classNode, fieldNames, scopes) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (FUNCTION_NODE_TYPES.has(unwrappedExpression.type)) {
-		for (const fieldName of getCallbackRefAssignedFields(unwrappedExpression, scopes)) fieldNames.add(fieldName);
-		return;
-	}
-	const handlerName = getThisFieldName(unwrappedExpression);
-	if (handlerName) {
-		const callback = getClassMemberCallback(classNode, handlerName);
-		if (callback) for (const fieldName of getCallbackRefAssignedFields(callback, scopes)) fieldNames.add(fieldName);
-		return;
-	}
-	if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) {
-		collectCallbackRefFieldsFromExpression(unwrappedExpression.consequent, classNode, fieldNames, scopes);
-		collectCallbackRefFieldsFromExpression(unwrappedExpression.alternate, classNode, fieldNames, scopes);
-		return;
-	}
-	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
-		if (unwrappedExpression.operator !== "&&") collectCallbackRefFieldsFromExpression(unwrappedExpression.left, classNode, fieldNames, scopes);
-		collectCallbackRefFieldsFromExpression(unwrappedExpression.right, classNode, fieldNames, scopes);
-	}
-};
-const getCallbackRefFieldNames = (classNode, scopes) => {
-	if (!classNode) return /* @__PURE__ */ new Set();
-	const cachedFieldNames = callbackRefFieldNamesByClass.get(classNode);
-	if (cachedFieldNames) return cachedFieldNames;
-	const fieldNames = /* @__PURE__ */ new Set();
-	const classBody = classNode.body;
-	if (classBody) walkAst(classBody, (node) => {
-		if (node !== classBody && CLASS_NODE_TYPES.has(node.type)) return false;
-		if (!isNodeOfType(node, "JSXAttribute") || !isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "ref" || !node.value || !isNodeOfType(node.value, "JSXExpressionContainer") || !node.value.expression) return;
-		collectCallbackRefFieldsFromExpression(node.value.expression, classNode, fieldNames, scopes);
-	});
-	callbackRefFieldNamesByClass.set(classNode, fieldNames);
-	return fieldNames;
-};
-const collectLifecycleWrittenFieldNames = (lifecycleFunction) => {
-	const fieldNames = /* @__PURE__ */ new Set();
-	const body = lifecycleFunction.body;
-	if (!body) return fieldNames;
-	walkAst(body, (node) => {
-		if (FUNCTION_NODE_TYPES.has(node.type) && !isImmediatelyInvokedFunction(node)) return false;
-		const target = isNodeOfType(node, "AssignmentExpression") && node.left || isNodeOfType(node, "UpdateExpression") && node.argument || null;
-		if (!target) return;
-		const fieldName = getThisFieldName(target);
-		if (fieldName) fieldNames.add(fieldName);
-	});
-	return fieldNames;
-};
 const getThisStateFieldName = (node) => {
 	const unwrappedNode = stripParenExpression(node);
 	if (!isNodeOfType(unwrappedNode, "MemberExpression")) return null;
@@ -37068,17 +36785,15 @@ const collectLocalInitializers = (lifecycleFunction) => {
 	});
 	return initializers;
 };
-const derivesFromPostMountValue = (node, localInitializers, callbackRefFieldNames, visitedNames = /* @__PURE__ */ new Set()) => {
+const derivesFromPostMountValue = (node, localInitializers, visitedNames = /* @__PURE__ */ new Set()) => {
 	if (readsPostMountValue(node)) return true;
-	const fieldName = getThisFieldName(node);
-	if (fieldName && callbackRefFieldNames.has(fieldName)) return true;
 	const referencedNames = /* @__PURE__ */ new Set();
 	collectReferenceIdentifierNames(node, referencedNames);
 	for (const referencedName of referencedNames) {
 		if (visitedNames.has(referencedName)) continue;
 		const initializer = localInitializers.get(referencedName);
 		if (!initializer) continue;
-		if (derivesFromPostMountValue(initializer, localInitializers, callbackRefFieldNames, new Set([...visitedNames, referencedName]))) return true;
+		if (derivesFromPostMountValue(initializer, localInitializers, new Set([...visitedNames, referencedName]))) return true;
 	}
 	return false;
 };
@@ -37092,84 +36807,50 @@ const getSetStateFieldValue = (setStateCall, fieldName) => {
 	}
 	return null;
 };
-const isConvergentPostMountGuard = (test, setStateCall, localInitializers, callbackRefFieldNames, isTruthfulBranch) => {
-	const expression = stripParenExpression(test);
-	if (isNodeOfType(expression, "LogicalExpression")) {
-		if (expression.operator !== "&&" && expression.operator !== "||") return false;
-		const leftIsConvergent = isConvergentPostMountGuard(expression.left, setStateCall, localInitializers, callbackRefFieldNames, isTruthfulBranch);
-		const rightIsConvergent = isConvergentPostMountGuard(expression.right, setStateCall, localInitializers, callbackRefFieldNames, isTruthfulBranch);
-		return isTruthfulBranch && expression.operator === "||" || !isTruthfulBranch && expression.operator === "&&" ? leftIsConvergent && rightIsConvergent : leftIsConvergent || rightIsConvergent;
-	}
-	if (!isNodeOfType(expression, "BinaryExpression") || !(isTruthfulBranch ? DIFFERENCE_OPERATORS.has(expression.operator) : EQUALITY_OPERATORS.has(expression.operator) && !DIFFERENCE_OPERATORS.has(expression.operator))) return false;
-	const leftFieldName = getThisStateFieldName(expression.left);
-	const rightFieldName = getThisStateFieldName(expression.right);
-	const fieldName = leftFieldName ?? rightFieldName;
-	const comparedValue = leftFieldName ? expression.right : expression.left;
-	if (!fieldName) return false;
-	const assignedValue = getSetStateFieldValue(setStateCall, fieldName);
-	if (!assignedValue || !areExpressionsStructurallyEqual(comparedValue, assignedValue)) return false;
-	return isUndefinedIdentifier(comparedValue) || derivesFromPostMountValue(comparedValue, localInitializers, callbackRefFieldNames);
-};
-const containsPositiveStateFieldTest = (test, fieldName) => {
-	const unwrappedTest = stripParenExpression(test);
-	if (getThisStateFieldName(unwrappedTest) === fieldName) return true;
-	return isNodeOfType(unwrappedTest, "LogicalExpression") && unwrappedTest.operator === "&&" && (containsPositiveStateFieldTest(unwrappedTest.left, fieldName) || containsPositiveStateFieldTest(unwrappedTest.right, fieldName));
-};
-const isConvergentUndefinedClearGuard = (test, setStateCall) => {
-	if (!isNodeOfType(setStateCall, "CallExpression")) return false;
-	const argument = setStateCall.arguments?.[0];
-	if (!argument || !isNodeOfType(argument, "ObjectExpression")) return false;
-	for (const property of argument.properties ?? []) {
-		if (!isNodeOfType(property, "Property") || property.computed === true || !isUndefinedIdentifier(property.value)) continue;
-		const fieldName = isNodeOfType(property.key, "Identifier") && property.key.name || isNodeOfType(property.key, "Literal") && typeof property.key.value === "string" && property.key.value || null;
-		if (fieldName && containsPositiveStateFieldTest(test, fieldName)) return true;
-	}
-	return false;
-};
-const isDiffGuardTest = (test, paramNames, derivedNames, isTruthfulBranch) => {
-	const expression = stripParenExpression(test);
-	if (isNodeOfType(expression, "LogicalExpression")) {
-		if (expression.operator !== "&&" && expression.operator !== "||") return false;
-		const leftIsDiffGuard = isDiffGuardTest(expression.left, paramNames, derivedNames, isTruthfulBranch);
-		const rightIsDiffGuard = isDiffGuardTest(expression.right, paramNames, derivedNames, isTruthfulBranch);
-		return isTruthfulBranch && expression.operator === "||" || !isTruthfulBranch && expression.operator === "&&" ? leftIsDiffGuard && rightIsDiffGuard : leftIsDiffGuard || rightIsDiffGuard;
-	}
-	if (!isNodeOfType(expression, "BinaryExpression") || !(isTruthfulBranch ? DIFFERENCE_OPERATORS.has(expression.operator) : EQUALITY_OPERATORS.has(expression.operator) && !DIFFERENCE_OPERATORS.has(expression.operator))) return false;
-	return isStatefulOperand(expression.left, paramNames, derivedNames) && isStatefulOperand(expression.right, paramNames, derivedNames) && (referencesAnyName(expression.left, paramNames) || referencesAnyName(expression.right, paramNames) || referencesAnyName(expression.left, derivedNames) || referencesAnyName(expression.right, derivedNames));
+const isConvergentPostMountGuard = (test, setStateCall, localInitializers) => {
+	let qualifies = false;
+	walkAst(test, (node) => {
+		if (qualifies) return false;
+		if (!isNodeOfType(node, "BinaryExpression") || !EQUALITY_OPERATORS.has(node.operator)) return;
+		const leftFieldName = getThisStateFieldName(node.left);
+		const rightFieldName = getThisStateFieldName(node.right);
+		const fieldName = leftFieldName ?? rightFieldName;
+		const comparedValue = leftFieldName ? node.right : node.left;
+		if (!fieldName || !leftFieldName && !rightFieldName) return;
+		const assignedValue = getSetStateFieldValue(setStateCall, fieldName);
+		if (!assignedValue || !areExpressionsStructurallyEqual(comparedValue, assignedValue)) return;
+		if (!derivesFromPostMountValue(comparedValue, localInitializers)) return;
+		qualifies = true;
+		return false;
+	});
+	return qualifies;
+};
+const isDiffGuardTest = (test, paramNames, derivedNames) => {
+	if (referencesAnyName(test, paramNames)) return true;
+	let qualifies = false;
+	walkAst(test, (node) => {
+		if (qualifies) return false;
+		if (!isNodeOfType(node, "BinaryExpression")) return;
+		if (!EQUALITY_OPERATORS.has(node.operator)) return;
+		if (isStatefulOperand(node.left, paramNames, derivedNames) && isStatefulOperand(node.right, paramNames, derivedNames) && (referencesAnyName(node.left, derivedNames) || referencesAnyName(node.right, derivedNames))) {
+			qualifies = true;
+			return false;
+		}
+	});
+	return qualifies;
 };
-const isInsideDiffGuard = (setStateCall, scopes) => {
+const isInsideDiffGuard = (setStateCall) => {
 	const lifecycleFunction = findEnclosingLifecycleFunction(setStateCall);
 	if (!lifecycleFunction) return false;
 	const paramNames = /* @__PURE__ */ new Set();
-	const parameters = lifecycleFunction.params ?? [];
-	for (const param of parameters) collectPatternNames(param, paramNames);
-	const previousSourcePaths = /* @__PURE__ */ new Map();
-	const [previousPropsParameter, previousStateParameter] = parameters;
-	collectPreviousSourcePaths(previousPropsParameter, "props", [], previousSourcePaths);
-	collectPreviousSourcePaths(previousStateParameter, "state", [], previousSourcePaths);
+	for (const param of lifecycleFunction.params ?? []) collectPatternNames(param, paramNames);
 	const derivedNames = collectDiffSourceLocalNames(lifecycleFunction, paramNames);
 	const localInitializers = collectLocalInitializers(lifecycleFunction);
-	const lifecycleWrittenFieldNames = collectLifecycleWrittenFieldNames(lifecycleFunction);
-	const callbackRefFieldNames = new Set([...getCallbackRefFieldNames(findEnclosingClass(lifecycleFunction), scopes)].filter((fieldName) => !lifecycleWrittenFieldNames.has(fieldName)));
 	let child = setStateCall;
 	let ancestor = setStateCall.parent;
 	while (ancestor && ancestor !== lifecycleFunction) {
-		let guardTest = null;
-		let isTruthfulBranch = true;
-		if (isNodeOfType(ancestor, "IfStatement")) {
-			if (child === ancestor.consequent) guardTest = ancestor.test;
-			else if (child === ancestor.alternate) {
-				guardTest = ancestor.test;
-				isTruthfulBranch = false;
-			}
-		} else if (isNodeOfType(ancestor, "ConditionalExpression")) {
-			if (child === ancestor.consequent) guardTest = ancestor.test;
-			else if (child === ancestor.alternate) {
-				guardTest = ancestor.test;
-				isTruthfulBranch = false;
-			}
-		} else if (isNodeOfType(ancestor, "LogicalExpression") && ancestor.operator === "&&" && child === ancestor.right) guardTest = ancestor.left;
-		if (guardTest && (isDiffGuardTest(guardTest, paramNames, derivedNames, isTruthfulBranch) || isTruthfulBranch && isHistoricalToCurrentTransitionGuard(guardTest, previousSourcePaths) || isConvergentPostMountGuard(guardTest, setStateCall, localInitializers, callbackRefFieldNames, isTruthfulBranch) || isTruthfulBranch && isConvergentUndefinedClearGuard(guardTest, setStateCall))) return true;
+		const guardTest = isNodeOfType(ancestor, "IfStatement") && child !== ancestor.test && ancestor.test || isNodeOfType(ancestor, "ConditionalExpression") && child !== ancestor.test && ancestor.test || isNodeOfType(ancestor, "LogicalExpression") && ancestor.operator === "&&" && child === ancestor.right && ancestor.left || null;
+		if (guardTest && (isDiffGuardTest(guardTest, paramNames, derivedNames) || isConvergentPostMountGuard(guardTest, setStateCall, localInitializers))) return true;
 		child = ancestor;
 		ancestor = ancestor.parent ?? null;
 	}
@@ -37191,7 +36872,7 @@ const noDidUpdateSetState = defineRule({
 			if (!isNodeOfType(stripParenExpression(node.callee.object), "ThisExpression")) return;
 			if (!isNodeOfType(node.callee.property, "Identifier") || node.callee.property.name !== "setState") return;
 			if (!isSetStateCallInLifecycle(node, LIFECYCLE_NAMES$1, { disallowInNestedFunctions: mode === "disallow-in-func" })) return;
-			if (isInsideDiffGuard(node, context.scopes)) return;
+			if (isInsideDiffGuard(node)) return;
 			context.report({
 				node: node.callee,
 				message: MESSAGE$27
@@ -40913,223 +40594,41 @@ const readLogicalConditionResult = (operator, leftResult, rightResult) => {
 	if (leftResult === false && rightResult === false) return false;
 	return null;
 };
-const readHydrationConditionResult = (expression, context, runtime, state) => {
+const readHydrationConditionResult = (expression, context, runtime) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	const predicateMatch = matchBrowserPredicate(unwrappedExpression, context);
 	if (predicateMatch) return predicateMatch[`${runtime}Result`];
 	const staticResult = readInitialStateBoolean(unwrappedExpression, context.scopes);
 	if (staticResult !== null) return staticResult;
-	const expressionSymbol = isNodeOfType(unwrappedExpression, "Identifier") ? context.scopes.symbolFor(unwrappedExpression) : null;
-	const parameterValue = expressionSymbol ? state.parameterValuesBySymbolId.get(expressionSymbol.id) : null;
-	if (expressionSymbol && parameterValue && !state.visitedSymbolIds.has(expressionSymbol.id)) {
-		state.visitedSymbolIds.add(expressionSymbol.id);
-		const result = readHydrationConditionResult(parameterValue, context, runtime, state);
-		state.visitedSymbolIds.delete(expressionSymbol.id);
-		return result;
-	}
-	if (expressionSymbol && expressionSymbol.kind === "const" && expressionSymbol.initializer && expressionSymbol.references.every((reference) => reference.flag === "read") && !state.visitedSymbolIds.has(expressionSymbol.id)) {
-		state.visitedSymbolIds.add(expressionSymbol.id);
-		const result = readHydrationConditionResult(expressionSymbol.initializer, context, runtime, state);
-		state.visitedSymbolIds.delete(expressionSymbol.id);
-		return result;
-	}
-	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
-		const callArguments = unwrappedExpression.arguments ?? [];
-		if (isReactApiCall(unwrappedExpression, "useMemo", context.scopes, {
-			allowGlobalReactNamespace: true,
-			resolveNamedAliases: true
-		})) {
-			const callbackArgument = callArguments[0];
-			if (!callbackArgument || isNodeOfType(callbackArgument, "SpreadElement")) return null;
-			const callbackFunction = resolveExactLocalFunction(callbackArgument, context.scopes);
-			return isFunctionLike$1(callbackFunction) && callbackFunction.params.length === 0 ? readHydrationFunctionResult(callbackFunction, context, runtime, state) : null;
-		}
-		const callee = stripParenExpression(unwrappedExpression.callee);
-		if (isNodeOfType(callee, "Identifier") && callee.name === "Boolean" && context.scopes.isGlobalReference(callee) && callArguments.length === 1 && !isNodeOfType(callArguments[0], "SpreadElement")) return readHydrationConditionResult(callArguments[0], context, runtime, state);
-		const helperFunction = resolveExactLocalFunction(callee, context.scopes);
-		if (!isFunctionLike$1(helperFunction) || helperFunction.async || isNodeOfType(helperFunction, "FunctionDeclaration") && helperFunction.generator || isNodeOfType(helperFunction, "FunctionExpression") && helperFunction.generator || helperFunction.params.some((parameter) => !isNodeOfType(parameter, "Identifier")) || callArguments.some((argument) => isNodeOfType(argument, "SpreadElement"))) return null;
-		const parameterValuesBySymbolId = new Map(state.parameterValuesBySymbolId);
-		for (let parameterIndex = 0; parameterIndex < helperFunction.params.length; parameterIndex++) {
-			const parameter = helperFunction.params[parameterIndex];
-			const argument = callArguments[parameterIndex];
-			if (!argument || !isNodeOfType(parameter, "Identifier")) continue;
-			const parameterSymbol = context.scopes.symbolFor(parameter);
-			if (parameterSymbol) parameterValuesBySymbolId.set(parameterSymbol.id, argument);
-		}
-		return readHydrationFunctionResult(helperFunction, context, runtime, {
-			...state,
-			parameterValuesBySymbolId
-		});
-	}
 	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") {
-		const argumentResult = readHydrationConditionResult(unwrappedExpression.argument, context, runtime, state);
+		const argumentResult = readHydrationConditionResult(unwrappedExpression.argument, context, runtime);
 		return argumentResult === null ? null : !argumentResult;
 	}
 	if (!isNodeOfType(unwrappedExpression, "LogicalExpression") || unwrappedExpression.operator !== "&&" && unwrappedExpression.operator !== "||") return null;
-	return readLogicalConditionResult(unwrappedExpression.operator, readHydrationConditionResult(unwrappedExpression.left, context, runtime, state), readHydrationConditionResult(unwrappedExpression.right, context, runtime, state));
-};
-const readHydrationStatementResult = (statement, context, runtime, state) => {
-	if (isNodeOfType(statement, "ReturnStatement")) return {
-		didReturn: true,
-		value: statement.argument ? readHydrationConditionResult(statement.argument, context, runtime, state) : null
-	};
-	if (isNodeOfType(statement, "BlockStatement")) {
-		for (const childStatement of statement.body) {
-			const result = readHydrationStatementResult(childStatement, context, runtime, state);
-			if (result.didReturn) return result;
-			if (statementAlwaysExits(childStatement)) break;
-		}
-		return {
-			didReturn: false,
-			value: null
-		};
-	}
-	if (!isNodeOfType(statement, "IfStatement")) return {
-		didReturn: false,
-		value: null
-	};
-	const conditionResult = readHydrationConditionResult(statement.test, context, runtime, state);
-	if (conditionResult !== null) {
-		const selectedBranch = conditionResult ? statement.consequent : statement.alternate;
-		return selectedBranch ? readHydrationStatementResult(selectedBranch, context, runtime, state) : {
-			didReturn: false,
-			value: null
-		};
-	}
-	const consequentResult = readHydrationStatementResult(statement.consequent, context, runtime, state);
-	const alternateResult = statement.alternate ? readHydrationStatementResult(statement.alternate, context, runtime, state) : {
-		didReturn: false,
-		value: null
-	};
-	return consequentResult.didReturn && alternateResult.didReturn && consequentResult.value !== null && consequentResult.value === alternateResult.value ? consequentResult : {
-		didReturn: consequentResult.didReturn || alternateResult.didReturn,
-		value: null
-	};
-};
-const readHydrationFunctionResult = (functionNode, context, runtime, state) => {
-	if (!isFunctionLike$1(functionNode) || state.visitedFunctionNodes.has(functionNode)) return null;
-	state.visitedFunctionNodes.add(functionNode);
-	const result = isNodeOfType(functionNode.body, "BlockStatement") ? readHydrationStatementResult(functionNode.body, context, runtime, state).value : readHydrationConditionResult(functionNode.body, context, runtime, state);
-	state.visitedFunctionNodes.delete(functionNode);
-	return result;
-};
-const doEquivalentExpressionBindingsMatch = (leftExpression, rightExpression, scopes) => {
-	const left = stripParenExpression(leftExpression);
-	const right = stripParenExpression(rightExpression);
-	if (isNodeOfType(left, "Identifier") && isNodeOfType(right, "Identifier")) {
-		const leftSymbol = scopes.symbolFor(left);
-		const rightSymbol = scopes.symbolFor(right);
-		return leftSymbol || rightSymbol ? leftSymbol?.id === rightSymbol?.id : true;
-	}
-	if (isNodeOfType(left, "MemberExpression") && isNodeOfType(right, "MemberExpression")) return doEquivalentExpressionBindingsMatch(left.object, right.object, scopes) && (!left.computed || doEquivalentExpressionBindingsMatch(left.property, right.property, scopes));
-	if (isNodeOfType(left, "CallExpression") && isNodeOfType(right, "CallExpression")) {
-		const rightArguments = right.arguments ?? [];
-		return doEquivalentExpressionBindingsMatch(left.callee, right.callee, scopes) && (left.arguments ?? []).every((argument, index) => {
-			const rightArgument = rightArguments[index];
-			return Boolean(rightArgument && doEquivalentExpressionBindingsMatch(argument, rightArgument, scopes));
-		});
-	}
-	return true;
+	return readLogicalConditionResult(unwrappedExpression.operator, readHydrationConditionResult(unwrappedExpression.left, context, runtime), readHydrationConditionResult(unwrappedExpression.right, context, runtime));
 };
-const areHelperReturnValuesEquivalent = (leftValue, rightValue, context) => {
-	if (areExpressionsStructurallyEqual(leftValue, rightValue)) return doEquivalentExpressionBindingsMatch(leftValue, rightValue, context.scopes);
-	const leftBoolean = readInitialStateBoolean(leftValue, context.scopes);
-	const rightBoolean = readInitialStateBoolean(rightValue, context.scopes);
-	return leftBoolean !== null && rightBoolean !== null && leftBoolean === rightBoolean;
-};
-const doHelperReturnValuesDiffer = (leftValues, rightValues, context) => {
-	const everyValueHasEquivalent = (values, candidateValues) => values.every((value) => candidateValues.some((candidateValue) => areHelperReturnValuesEquivalent(value, candidateValue, context)));
-	return !everyValueHasEquivalent(leftValues, rightValues) || !everyValueHasEquivalent(rightValues, leftValues);
-};
-const matchHydrationConditionInternal = (expression, context, state) => {
+const matchHydrationCondition = (expression, context) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	const predicateMatch = matchBrowserPredicate(unwrappedExpression, context);
 	if (predicateMatch) return {
 		predicateMatch,
 		predicateNode: unwrappedExpression
 	};
-	if (isNodeOfType(unwrappedExpression, "Identifier")) {
-		const symbol = context.scopes.symbolFor(unwrappedExpression);
-		const parameterValue = symbol ? state.parameterValuesBySymbolId.get(symbol.id) : null;
-		if (symbol && parameterValue && !state.visitedSymbolIds.has(symbol.id)) {
-			state.visitedSymbolIds.add(symbol.id);
-			const match = matchHydrationConditionInternal(parameterValue, context, state);
-			state.visitedSymbolIds.delete(symbol.id);
-			return match;
-		}
-		if (!symbol || symbol.kind !== "const" || !symbol.initializer || symbol.references.some((reference) => reference.flag !== "read") || state.visitedSymbolIds.has(symbol.id)) return null;
-		state.visitedSymbolIds.add(symbol.id);
-		const match = matchHydrationConditionInternal(symbol.initializer, context, state);
-		state.visitedSymbolIds.delete(symbol.id);
-		return match;
-	}
-	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
-		const callArguments = unwrappedExpression.arguments ?? [];
-		if (isReactApiCall(unwrappedExpression, "useMemo", context.scopes, {
-			allowGlobalReactNamespace: true,
-			resolveNamedAliases: true
-		})) {
-			const callbackArgument = callArguments[0];
-			if (!callbackArgument || isNodeOfType(callbackArgument, "SpreadElement")) return null;
-			const callbackFunction = resolveExactLocalFunction(callbackArgument, context.scopes);
-			return isFunctionLike$1(callbackFunction) && callbackFunction.params.length === 0 ? matchHydrationFunctionResult(callbackFunction, context, state) : null;
-		}
-		const callee = stripParenExpression(unwrappedExpression.callee);
-		if (isNodeOfType(callee, "Identifier") && callee.name === "Boolean" && context.scopes.isGlobalReference(callee) && callArguments.length === 1 && !isNodeOfType(callArguments[0], "SpreadElement")) return matchHydrationConditionInternal(callArguments[0], context, state);
-		const helperFunction = resolveExactLocalFunction(callee, context.scopes);
-		if (!isFunctionLike$1(helperFunction) || helperFunction.async || isNodeOfType(helperFunction, "FunctionDeclaration") && helperFunction.generator || isNodeOfType(helperFunction, "FunctionExpression") && helperFunction.generator || helperFunction.params.some((parameter) => !isNodeOfType(parameter, "Identifier")) || callArguments.some((argument) => isNodeOfType(argument, "SpreadElement"))) return null;
-		const parameterValuesBySymbolId = new Map(state.parameterValuesBySymbolId);
-		for (let parameterIndex = 0; parameterIndex < helperFunction.params.length; parameterIndex++) {
-			const parameter = helperFunction.params[parameterIndex];
-			const argument = callArguments[parameterIndex];
-			if (!argument || !isNodeOfType(parameter, "Identifier")) continue;
-			const parameterSymbol = context.scopes.symbolFor(parameter);
-			if (parameterSymbol) parameterValuesBySymbolId.set(parameterSymbol.id, argument);
-		}
-		return matchHydrationFunctionResult(helperFunction, context, {
-			...state,
-			parameterValuesBySymbolId
-		});
-	}
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return matchHydrationConditionInternal(unwrappedExpression.argument, context, state);
+	if (isNodeOfType(unwrappedExpression, "UnaryExpression") && unwrappedExpression.operator === "!") return matchHydrationCondition(unwrappedExpression.argument, context);
 	if (!isNodeOfType(unwrappedExpression, "LogicalExpression") || unwrappedExpression.operator !== "&&" && unwrappedExpression.operator !== "||") return null;
-	const leftMatch = matchHydrationConditionInternal(unwrappedExpression.left, context, state);
-	const rightMatch = matchHydrationConditionInternal(unwrappedExpression.right, context, state);
+	const leftMatch = matchHydrationCondition(unwrappedExpression.left, context);
+	const rightMatch = matchHydrationCondition(unwrappedExpression.right, context);
+	if (leftMatch && rightMatch) {
+		const clientResult = readHydrationConditionResult(unwrappedExpression, context, "client");
+		const serverResult = readHydrationConditionResult(unwrappedExpression, context, "server");
+		return clientResult !== null && serverResult !== null && clientResult !== serverResult ? leftMatch : null;
+	}
 	const nestedMatch = leftMatch ?? rightMatch;
 	if (!nestedMatch) return null;
-	const clientResult = readHydrationConditionResult(unwrappedExpression, context, "client", state);
-	const serverResult = readHydrationConditionResult(unwrappedExpression, context, "server", state);
-	return clientResult !== null && serverResult !== null && clientResult === serverResult ? null : nestedMatch;
-};
-const matchHydrationReturningStatement = (statement, context, state) => {
-	if (isNodeOfType(statement, "ReturnStatement")) return statement.argument ? matchHydrationConditionInternal(statement.argument, context, state) : null;
-	if (isNodeOfType(statement, "IfStatement")) {
-		const conditionMatch = matchHydrationConditionInternal(statement.test, context, state);
-		const consequentValues = getReturnedValues(statement.consequent);
-		const alternateValues = statement.alternate ? getReturnedValues(statement.alternate) : findFollowingReturnedValues(statement);
-		if (conditionMatch && consequentValues.length > 0 && alternateValues.length > 0 && doHelperReturnValuesDiffer(consequentValues, alternateValues, context)) return conditionMatch;
-		return matchHydrationReturningStatement(statement.consequent, context, state) ?? (statement.alternate ? matchHydrationReturningStatement(statement.alternate, context, state) : null);
-	}
-	if (!isNodeOfType(statement, "BlockStatement")) return null;
-	for (const childStatement of statement.body) {
-		const match = matchHydrationReturningStatement(childStatement, context, state);
-		if (match) return match;
-		if (statementAlwaysExits(childStatement)) break;
-	}
-	return null;
+	const otherResult = readInitialStateBoolean(leftMatch ? unwrappedExpression.right : unwrappedExpression.left, context.scopes);
+	if (unwrappedExpression.operator === "&&" && otherResult === false || unwrappedExpression.operator === "||" && otherResult === true) return null;
+	return nestedMatch;
 };
-const matchHydrationFunctionResult = (functionNode, context, state) => {
-	if (!isFunctionLike$1(functionNode) || state.visitedFunctionNodes.has(functionNode)) return null;
-	state.visitedFunctionNodes.add(functionNode);
-	const match = isNodeOfType(functionNode.body, "BlockStatement") ? matchHydrationReturningStatement(functionNode.body, context, state) : matchHydrationConditionInternal(functionNode.body, context, state);
-	state.visitedFunctionNodes.delete(functionNode);
-	return match;
-};
-const matchHydrationCondition = (expression, context) => matchHydrationConditionInternal(expression, context, {
-	parameterValuesBySymbolId: /* @__PURE__ */ new Map(),
-	visitedFunctionNodes: /* @__PURE__ */ new Set(),
-	visitedSymbolIds: /* @__PURE__ */ new Set()
-});
 const areNodeArraysEquivalent = (leftNodes, rightNodes) => leftNodes.length === rightNodes.length && leftNodes.every((leftNode, index) => areRenderedBranchesEquivalent(leftNode, rightNodes[index]));
 const areRenderedBranchesEquivalent = (leftNode, rightNode) => {
 	if (!leftNode || !rightNode) return leftNode === rightNode;
@@ -41272,17 +40771,17 @@ const noHydrationBranchOnBrowserGlobal = defineRule({
 			const { predicateMatch, predicateNode } = conditionMatch;
 			if (reportedNodes.has(predicateNode)) return;
 			if (rightBranch && areRenderedBranchesEquivalent(leftBranch, rightBranch)) return;
-			const componentOrHookNode = findRenderPhaseComponentOrHook(conditionNode, context.scopes);
+			const componentOrHookNode = findRenderPhaseComponentOrHook(predicateNode, context.scopes);
 			if (!componentOrHookNode) return;
 			if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
-			if (requiresRenderedContext && !isInRenderedOutput(conditionNode, componentOrHookNode, context.scopes)) return;
+			if (requiresRenderedContext && !isInRenderedOutput(predicateNode, componentOrHookNode, context.scopes)) return;
 			if (!isRenderedValue(leftBranch) && (!rightBranch || !isRenderedValue(rightBranch))) {
-				const attribute = findEnclosingJsxAttribute(conditionNode);
+				const attribute = findEnclosingJsxAttribute(predicateNode);
 				if (!attribute || isEventHandlerAttribute(attribute)) return;
 			}
-			if (fileIsEmailTemplate || isGatedByFalsyInitialState(conditionNode, context.scopes)) return;
-			if (isAfterClientOnlyEarlyReturn(conditionNode, componentOrHookNode, context.scopes)) return;
-			const openingElement = findEnclosingJsxOpeningElement(conditionNode);
+			if (fileIsEmailTemplate || isGatedByFalsyInitialState(predicateNode, context.scopes)) return;
+			if (isAfterClientOnlyEarlyReturn(predicateNode, componentOrHookNode, context.scopes)) return;
+			const openingElement = findEnclosingJsxOpeningElement(predicateNode);
 			if (hasSuppressHydrationWarningAttribute(openingElement) && !isStructuralRenderedValue(leftBranch) && !isStructuralRenderedValue(rightBranch)) return;
 			if (branchRootsSuppressSameElement(leftBranch, rightBranch)) return;
 			if (isGeneratedImageRenderContext(context, openingElement ?? leftBranch)) return;
@@ -41664,7 +41163,7 @@ const noInitializeState = defineRule({
 		if (!dependencies || !isNodeOfType(dependencies, "ArrayExpression") || (dependencies.elements ?? []).length !== 0) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
-		for (const fact of collectEffectStateWriteFacts(analysis, context, node, context.filename)) {
+		for (const fact of collectEffectStateWriteFacts(analysis, node, context.filename)) {
 			if (!fact.isRenderKnownCopy || fact.matchesStateInitializer || fact.resetsSourceState) continue;
 			const stateName = getStateName(fact.stateDeclarator);
 			context.report({
@@ -57229,39 +56728,8 @@ const isUseStateSetterInScope = (node, setterName) => isHookBindingInScope(node,
 	destructureIndex: 1
 });
 //#endregion
-//#region src/plugin/utils/unwrap-return-expression.ts
-const unwrapReturnExpression = (node) => isNodeOfType(node, "ReturnStatement") && node.argument ? node.argument : node;
-//#endregion
 //#region src/plugin/rules/performance/rendering-hydration-no-flicker.ts
 const USE_EFFECT_ONLY = new Set(["useEffect"]);
-const USE_CALLBACK_ONLY = new Set(["useCallback"]);
-const USE_STATE_ONLY = new Set(["useState"]);
-const REACT_API_CALL_OPTIONS = {
-	allowGlobalReactNamespace: true,
-	allowUnboundBareCalls: true,
-	resolveNamedAliases: true
-};
-const expressionReadsDerivedSymbol = (context, expression, stateDerivedSymbolIds) => {
-	let readsDerivedSymbol = false;
-	walkAst(expression, (node) => {
-		if (readsDerivedSymbol) return false;
-		if (node !== expression && isFunctionLike$1(node)) return false;
-		if (isNodeOfType(node, "Identifier") && stateDerivedSymbolIds.has(context.scopes.symbolFor(node)?.id ?? -1)) readsDerivedSymbol = true;
-	});
-	return readsDerivedSymbol;
-};
-const getStaticObjectPropertyName = (property) => {
-	if (!isNodeOfType(property, "Property") || property.computed || property.method || property.kind !== "init") return null;
-	if (isNodeOfType(property.key, "Identifier")) return property.key.name;
-	if (isNodeOfType(property.key, "Literal") && (typeof property.key.value === "string" || typeof property.key.value === "number")) return String(property.key.value);
-	return null;
-};
-const isNonVisibleJsxSpreadProperty = (propertyName) => propertyName === "id" || propertyName.startsWith("aria-") || /^on[A-Z]/.test(propertyName);
-const isTransparentAssignmentTarget = (identifier) => {
-	const expressionRoot = findTransparentExpressionRoot(identifier);
-	const parent = expressionRoot.parent;
-	return Boolean(isNodeOfType(parent, "AssignmentExpression") && parent.left === expressionRoot || isNodeOfType(parent, "UpdateExpression") && parent.argument === expressionRoot || isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" && parent.argument === expressionRoot);
-};
 const argumentsReadRefCurrent = (callArguments) => callArguments.some((argument) => {
 	let readsCurrent = false;
 	walkAst(argument, (child) => {
@@ -57313,166 +56781,6 @@ const isStateUsedOnlyInIdOrAriaAttributes = (setterCall, setterName) => {
 	});
 	return referenceCount > 0 && !nonAriaReferenceFound;
 };
-const isGlobalWindowMember = (context, node, propertyName) => {
-	const member = stripParenExpression(node);
-	if (!isNodeOfType(member, "MemberExpression") || member.computed) return false;
-	const receiver = stripParenExpression(member.object);
-	return isNodeOfType(receiver, "Identifier") && receiver.name === "window" && context.scopes.isGlobalReference(receiver) && isNodeOfType(member.property, "Identifier") && member.property.name === propertyName;
-};
-const getDirectWindowWidthSetter = (context, statement) => {
-	const call = unwrapDiscardedExpression(statement);
-	if (!isNodeOfType(call, "CallExpression") || call.arguments?.length !== 1) return null;
-	if (!isNodeOfType(call.callee, "Identifier") || !isSetterCall(call)) return null;
-	const argument = call.arguments[0];
-	return isGlobalWindowMember(context, argument, "innerWidth") ? call : null;
-};
-const getResizeListenerHandler = (context, statement, methodName) => {
-	const call = unwrapDiscardedExpression(statement);
-	if (!isNodeOfType(call, "CallExpression") || call.arguments?.length !== 2) return null;
-	if (!isGlobalWindowMember(context, call.callee, methodName)) return null;
-	const eventName = call.arguments[0];
-	const handler = call.arguments[1];
-	if (!isNodeOfType(eventName, "Literal") || eventName.value !== "resize") return null;
-	return isNodeOfType(handler, "Identifier") ? handler : null;
-};
-const getCleanupResizeHandler = (context, statement) => {
-	if (!isNodeOfType(statement, "ReturnStatement") || !isFunctionLike$1(statement.argument)) return null;
-	const cleanupStatements = getCallbackStatements(statement.argument);
-	if (cleanupStatements.length !== 1) return null;
-	return getResizeListenerHandler(context, unwrapReturnExpression(cleanupStatements[0]), "removeEventListener");
-};
-const findExactViewportState = (context, componentFunction, setterCall) => {
-	if (!isFunctionLike$1(componentFunction) || !isNodeOfType(componentFunction.body, "BlockStatement")) return null;
-	const componentBody = componentFunction.body;
-	if (!isNodeOfType(setterCall.callee, "Identifier")) return null;
-	const setterSymbol = context.scopes.symbolFor(setterCall.callee);
-	if (!setterSymbol || setterSymbol.kind !== "const" || !isNodeOfType(setterSymbol.declarationNode, "VariableDeclarator")) return null;
-	const declarator = setterSymbol.declarationNode;
-	if (!isNodeOfType(declarator.id, "ArrayPattern")) return null;
-	const stateIdentifier = declarator.id.elements?.[0];
-	const setterIdentifier = declarator.id.elements?.[1];
-	if (!isNodeOfType(stateIdentifier, "Identifier") || !isNodeOfType(setterIdentifier, "Identifier") || setterIdentifier !== setterSymbol.bindingIdentifier || !isNodeOfType(declarator.init, "CallExpression") || !isReactApiCall(declarator.init, USE_STATE_ONLY, context.scopes, REACT_API_CALL_OPTIONS)) return null;
-	const initializer = declarator.init.arguments?.[0];
-	if (!isNodeOfType(initializer, "Literal") || initializer.value !== 0) return null;
-	const stateSymbol = context.scopes.symbolFor(stateIdentifier);
-	if (!stateSymbol) return null;
-	const stateDerivedSymbolIds = new Set([stateSymbol.id]);
-	let didAddDerivedSymbol = true;
-	while (didAddDerivedSymbol) {
-		didAddDerivedSymbol = false;
-		for (const statement of componentBody.body ?? []) {
-			if (!isNodeOfType(statement, "VariableDeclaration")) continue;
-			for (const candidateDeclarator of statement.declarations ?? []) {
-				if (!isNodeOfType(candidateDeclarator.id, "Identifier") || !candidateDeclarator.init) continue;
-				const candidateInitializer = stripParenExpression(candidateDeclarator.init);
-				if (isFunctionLike$1(candidateInitializer) || isNodeOfType(candidateInitializer, "CallExpression") && isReactApiCall(candidateInitializer, USE_CALLBACK_ONLY, context.scopes, REACT_API_CALL_OPTIONS)) continue;
-				if (!expressionReadsDerivedSymbol(context, candidateInitializer, stateDerivedSymbolIds)) continue;
-				const candidateSymbol = context.scopes.symbolFor(candidateDeclarator.id);
-				if (candidateSymbol?.kind === "const" && candidateSymbol.references.every((reference) => reference.flag === "read" && !isTransparentAssignmentTarget(reference.identifier)) && !stateDerivedSymbolIds.has(candidateSymbol.id)) {
-					stateDerivedSymbolIds.add(candidateSymbol.id);
-					didAddDerivedSymbol = true;
-				}
-			}
-		}
-	}
-	const staticSpreadVisibilityBySymbolId = /* @__PURE__ */ new Map();
-	const hasOnlyStaticObjectReferences = (identifier, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-		const symbol = context.scopes.symbolFor(identifier);
-		if (!symbol) return false;
-		if (visitedSymbolIds.has(symbol.id)) return true;
-		const nextVisitedSymbolIds = new Set(visitedSymbolIds);
-		nextVisitedSymbolIds.add(symbol.id);
-		let hasUnknownReference = false;
-		walkAst(componentBody, (node) => {
-			if (hasUnknownReference || !isNodeOfType(node, "Identifier") || context.scopes.symbolFor(node)?.id !== symbol.id || node === symbol.bindingIdentifier) return;
-			const referenceRoot = findTransparentExpressionRoot(node);
-			const parent = referenceRoot.parent;
-			if (isNodeOfType(parent, "JSXSpreadAttribute") && parent.argument === referenceRoot) return;
-			if (isNodeOfType(parent, "VariableDeclarator") && parent.init === referenceRoot && isNodeOfType(parent.id, "Identifier") && isNodeOfType(parent.parent, "VariableDeclaration") && parent.parent.kind === "const" && hasOnlyStaticObjectReferences(parent.id, nextVisitedSymbolIds)) return;
-			hasUnknownReference = true;
-			return false;
-		});
-		return !hasUnknownReference;
-	};
-	const classifyStaticSpreadObject = (identifier, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-		const symbol = context.scopes.symbolFor(identifier);
-		if (!symbol || visitedSymbolIds.has(symbol.id)) return "unknown";
-		const cachedVisibility = staticSpreadVisibilityBySymbolId.get(symbol.id);
-		if (cachedVisibility) return cachedVisibility;
-		if (symbol.kind !== "const" || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || !isNodeOfType(symbol.declarationNode.id, "Identifier") || symbol.declarationNode.id !== symbol.bindingIdentifier || !symbol.declarationNode.init) return "unknown";
-		if (!hasOnlyStaticObjectReferences(identifier)) return "unknown";
-		const initializer = stripParenExpression(symbol.declarationNode.init);
-		const nextVisitedSymbolIds = new Set(visitedSymbolIds);
-		nextVisitedSymbolIds.add(symbol.id);
-		if (isNodeOfType(initializer, "Identifier")) {
-			const visibility = classifyStaticSpreadObject(initializer, nextVisitedSymbolIds);
-			staticSpreadVisibilityBySymbolId.set(symbol.id, visibility);
-			return visibility;
-		}
-		if (!isNodeOfType(initializer, "ObjectExpression")) return "unknown";
-		let visibility = "non-visible";
-		for (const property of initializer.properties ?? []) {
-			const propertyName = getStaticObjectPropertyName(property);
-			if (!isNodeOfType(property, "Property") || !propertyName) {
-				visibility = "unknown";
-				break;
-			}
-			if (expressionReadsDerivedSymbol(context, property.value, stateDerivedSymbolIds) && !isNonVisibleJsxSpreadProperty(propertyName)) visibility = "visible";
-		}
-		staticSpreadVisibilityBySymbolId.set(symbol.id, visibility);
-		return visibility;
-	};
-	let hasNonAriaReference = false;
-	walkAst(componentBody, (node) => {
-		if (hasNonAriaReference) return false;
-		if (!isNodeOfType(node, "Identifier") || !stateDerivedSymbolIds.has(context.scopes.symbolFor(node)?.id ?? -1)) return;
-		if (findEnclosingFunction$1(node) !== componentFunction) return;
-		const parent = node.parent;
-		if (parent && (isNodeOfType(parent, "MemberExpression") && parent.property === node && !parent.computed || isNodeOfType(parent, "Property") && parent.key === node && !parent.computed)) return;
-		let cursor = parent;
-		while (cursor && cursor !== componentBody) {
-			if (isFunctionLike$1(cursor)) return;
-			if (isNodeOfType(cursor, "JSXSpreadAttribute")) {
-				if (isNodeOfType(node, "Identifier") && classifyStaticSpreadObject(node) === "visible") hasNonAriaReference = true;
-				return;
-			}
-			if (isNodeOfType(cursor, "JSXAttribute")) {
-				if (isEventHandlerAttribute(cursor)) return;
-				if (!isInsideIdOrAriaAttribute(node)) hasNonAriaReference = true;
-				return;
-			}
-			if (isNodeOfType(cursor, "ReturnStatement")) {
-				hasNonAriaReference = true;
-				return;
-			}
-			cursor = cursor.parent;
-		}
-	});
-	return hasNonAriaReference ? stateIdentifier.name : null;
-};
-const isExactViewportSubscriptionEffect = (context, effectCall, callback) => {
-	if (!isReactApiCall(effectCall, USE_EFFECT_ONLY, context.scopes, REACT_API_CALL_OPTIONS)) return false;
-	if (!isFunctionLike$1(callback) || callback.async || !isNodeOfType(callback.body, "BlockStatement")) return false;
-	const statements = getCallbackStatements(callback);
-	if (statements.length !== 4) return false;
-	const handlerDeclaration = statements[0];
-	if (!isNodeOfType(handlerDeclaration, "VariableDeclaration") || handlerDeclaration.kind !== "const" || handlerDeclaration.declarations?.length !== 1) return false;
-	const handlerDeclarator = handlerDeclaration.declarations[0];
-	if (!isNodeOfType(handlerDeclarator.id, "Identifier") || !isFunctionLike$1(handlerDeclarator.init)) return false;
-	const handlerStatements = getCallbackStatements(handlerDeclarator.init);
-	if (handlerStatements.length !== 1) return false;
-	const handlerSetter = getDirectWindowWidthSetter(context, unwrapReturnExpression(handlerStatements[0]));
-	const subscribedHandler = getResizeListenerHandler(context, statements[1], "addEventListener");
-	const immediateSetter = getDirectWindowWidthSetter(context, statements[2]);
-	const cleanupHandler = getCleanupResizeHandler(context, statements[3]);
-	if (!handlerSetter || !subscribedHandler || !immediateSetter || !cleanupHandler) return false;
-	const handlerSymbol = context.scopes.symbolFor(handlerDeclarator.id);
-	if (!handlerSymbol || context.scopes.symbolFor(subscribedHandler) !== handlerSymbol || context.scopes.symbolFor(cleanupHandler) !== handlerSymbol) return false;
-	if (!isNodeOfType(handlerSetter.callee, "Identifier") || !isNodeOfType(immediateSetter.callee, "Identifier") || context.scopes.symbolFor(handlerSetter.callee) !== context.scopes.symbolFor(immediateSetter.callee)) return false;
-	const componentFunction = findEnclosingFunction$1(effectCall);
-	if (!isFunctionLike$1(componentFunction) || !isNodeOfType(componentFunction.body, "BlockStatement")) return false;
-	return findExactViewportState(context, componentFunction, immediateSetter) !== null;
-};
 const renderingHydrationNoFlicker = defineRule({
 	id: "rendering-hydration-no-flicker",
 	title: "useEffect setState flashes on mount",
@@ -57485,14 +56793,7 @@ const renderingHydrationNoFlicker = defineRule({
 		if (!isNodeOfType(depsNode, "ArrayExpression") || depsNode.elements?.length !== 0) return;
 		const callback = getEffectCallback(node);
 		if (!callback || !isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return;
-		if (isExactViewportSubscriptionEffect(context, node, callback)) {
-			context.report({
-				node,
-				message: "This flashes for your users because useEffect(setState, []) runs after the first paint, so use useSyncExternalStore, or add suppressHydrationWarning"
-			});
-			return;
-		}
-		const bodyStatements = getCallbackStatements(callback);
+		const bodyStatements = (isNodeOfType(callback.body, "BlockStatement") ? callback.body.body ?? [] : [callback.body]).filter((statement) => !isNoOpStatement(statement));
 		if (bodyStatements.length !== 1) return;
 		const soleStatement = bodyStatements[0];
 		if (!isNodeOfType(soleStatement, "ExpressionStatement")) return;
@@ -67324,6 +66625,14 @@ const isStateKey = (key) => {
 	if (isNodeOfType(key, "Literal") && typeof key.value === "string") return key.value === "state";
 	return false;
 };
+const findEnclosingClass = (node) => {
+	let ancestor = node.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "ClassDeclaration") || isNodeOfType(ancestor, "ClassExpression")) return ancestor;
+		ancestor = ancestor.parent ?? null;
+	}
+	return null;
+};
 const isInConstructor = (node) => {
 	let ancestor = node.parent;
 	while (ancestor) {

package/package.json

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