oxlint-plugin-react-doctor 0.7.7-dev.a468589 → 0.7.7-dev.af58965

package/dist/index.js

@@ -1194,7 +1194,7 @@ const findVariableInitializer = (referenceNode, bindingName) => {
 * (`FUNCTION_LIKE_TYPES.has(node.type)`) and as a type-guard. The
 * type-guard form covers both shapes without callers paying a cast.
 */
-const isFunctionLike$2 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")));
+const isFunctionLike$1 = (node) => Boolean(node && (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")));
 //#endregion
 //#region src/plugin/utils/strip-paren-expression.ts
 const TRANSPARENT_EXPRESSION_WRAPPER_TYPES = new Set([
@@ -1230,13 +1230,13 @@ const resolveConstIdentifierAlias = (identifier, scopes) => {
 //#region src/plugin/utils/resolve-exact-local-function.ts
 const resolveExactLocalFunction = (expression, scopes) => {
 	const unwrappedExpression = stripParenExpression(expression);
-	if (isFunctionLike$2(unwrappedExpression)) return unwrappedExpression;
+	if (isFunctionLike$1(unwrappedExpression)) return unwrappedExpression;
 	if (!isNodeOfType(unwrappedExpression, "Identifier")) return null;
 	const symbol = resolveConstIdentifierAlias(unwrappedExpression, scopes);
-	if (symbol?.kind === "function") return !symbol.references.some((reference) => reference.flag !== "read") && isFunctionLike$2(symbol.declarationNode) ? symbol.declarationNode : null;
+	if (symbol?.kind === "function") return !symbol.references.some((reference) => reference.flag !== "read") && isFunctionLike$1(symbol.declarationNode) ? symbol.declarationNode : null;
 	if (symbol?.kind !== "const" || !symbol.initializer) return null;
 	const unwrappedInitializer = stripParenExpression(symbol.initializer);
-	return isFunctionLike$2(unwrappedInitializer) ? unwrappedInitializer : null;
+	return isFunctionLike$1(unwrappedInitializer) ? unwrappedInitializer : null;
 };
 //#endregion
 //#region src/plugin/utils/get-effect-callback.ts
@@ -1921,9 +1921,9 @@ const isComponentIdentifierName = (name) => {
 	const firstCharacter = name[0];
 	return Boolean(firstCharacter && firstCharacter === firstCharacter.toUpperCase());
 };
-const isFunctionLike$1 = (node) => Boolean(node && (isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression")));
+const isFunctionLike = (node) => Boolean(node && (isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression")));
 const markFunctionReturnJsx = (functionNode, programRoot, generatedImageJsxNodes, visitedComponentNames) => {
-	if (!isFunctionLike$1(functionNode)) return;
+	if (!isFunctionLike(functionNode)) return;
 	if (isNodeOfType(functionNode, "ArrowFunctionExpression")) {
 		const body = stripParenExpression(functionNode.body);
 		if (!isNodeOfType(body, "BlockStatement")) {
@@ -1934,7 +1934,7 @@ const markFunctionReturnJsx = (functionNode, programRoot, generatedImageJsxNodes
 	const body = functionNode.body;
 	if (!isNodeOfType(body, "BlockStatement")) return;
 	walkAst(body, (descendantNode) => {
-		if (descendantNode !== body && isFunctionLike$1(descendantNode)) return false;
+		if (descendantNode !== body && isFunctionLike(descendantNode)) return false;
 		if (!isNodeOfType(descendantNode, "ReturnStatement")) return;
 		if (!descendantNode.argument) return;
 		markGeneratedImageExpression(stripParenExpression(descendantNode.argument), programRoot, generatedImageJsxNodes, visitedComponentNames);
@@ -1996,7 +1996,7 @@ const markGeneratedImageExpression = (expression, programRoot, generatedImageJsx
 		markJsxSubtree(unwrappedExpression, programRoot, generatedImageJsxNodes, visitedComponentNames);
 		return;
 	}
-	if (isFunctionLike$1(unwrappedExpression)) {
+	if (isFunctionLike(unwrappedExpression)) {
 		markFunctionReturnJsx(unwrappedExpression, programRoot, generatedImageJsxNodes, visitedComponentNames);
 		return;
 	}
@@ -2012,7 +2012,7 @@ const markGeneratedImageExpression = (expression, programRoot, generatedImageJsx
 	}
 	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
 		const callee = unwrappedExpression.callee;
-		if (isFunctionLike$1(callee)) {
+		if (isFunctionLike(callee)) {
 			markFunctionReturnJsx(callee, programRoot, generatedImageJsxNodes, visitedComponentNames);
 			return;
 		}
@@ -2021,7 +2021,7 @@ const markGeneratedImageExpression = (expression, programRoot, generatedImageJsx
 		if (hasNormalJsxUsage(programRoot, callee.name, generatedImageJsxNodes)) return;
 		if (hasNormalFunctionCallUsage(programRoot, callee.name)) return;
 		const binding = findVariableInitializer(callee, callee.name);
-		if (!binding?.initializer || !isFunctionLike$1(stripParenExpression(binding.initializer))) return;
+		if (!binding?.initializer || !isFunctionLike(stripParenExpression(binding.initializer))) return;
 		visitedComponentNames.add(callee.name);
 		markFunctionReturnJsx(stripParenExpression(binding.initializer), programRoot, generatedImageJsxNodes, visitedComponentNames);
 		return;
@@ -4480,7 +4480,7 @@ const getPotentiallyAliasedSymbols = (identifier, scopes) => {
 const findExecutionBoundary = (node) => {
 	let current = node;
 	while (current) {
-		if (isFunctionLike$2(current) || isNodeOfType(current, "Program")) return current;
+		if (isFunctionLike$1(current) || isNodeOfType(current, "Program")) return current;
 		current = current.parent ?? null;
 	}
 	return null;
@@ -4509,7 +4509,7 @@ const findDirectCall = (identifier) => {
 	return parent && isNodeOfType(parent, "CallExpression") && parent.callee === callee ? parent : null;
 };
 const isFunctionSynchronouslyInvokedBefore = (functionNode, referenceNode, scopes, visitedFunctionNodes = /* @__PURE__ */ new Set()) => {
-	if (visitedFunctionNodes.has(functionNode) || !isFunctionLike$2(functionNode) || functionNode.generator) return false;
+	if (visitedFunctionNodes.has(functionNode) || !isFunctionLike$1(functionNode) || functionNode.generator) return false;
 	visitedFunctionNodes.add(functionNode);
 	const referenceBoundary = findExecutionBoundary(referenceNode);
 	if (!referenceBoundary) return false;
@@ -4528,7 +4528,7 @@ const isFunctionSynchronouslyInvokedBefore = (functionNode, referenceNode, scope
 		const callBoundary = findExecutionBoundary(call);
 		if (!callBoundary) return false;
 		if (callBoundary === referenceBoundary) return true;
-		if (!isFunctionLike$2(callBoundary)) return false;
+		if (!isFunctionLike$1(callBoundary)) return false;
 		return isFunctionSynchronouslyInvokedBefore(callBoundary, referenceNode, scopes, new Set(visitedFunctionNodes));
 	});
 };
@@ -4556,7 +4556,7 @@ const symbolHasStaticPropertyWriteBefore = (symbol, propertyName, referenceNode,
 	const referenceBoundary = findExecutionBoundary(referenceNode);
 	if (!writeBoundary || !referenceBoundary || !isOnUnconditionalPath(writeTarget, writeBoundary)) return false;
 	if (writeBoundary === referenceBoundary) return writeTarget.range[0] < referenceNode.range[0];
-	return isFunctionLike$2(writeBoundary) && isFunctionSynchronouslyInvokedBefore(writeBoundary, referenceNode, scopes);
+	return isFunctionLike$1(writeBoundary) && isFunctionSynchronouslyInvokedBefore(writeBoundary, referenceNode, scopes);
 });
 const isStableStaticPropertyReference = (identifier) => {
 	if (isDirectAliasSourceReference(identifier)) return true;
@@ -4597,7 +4597,7 @@ const hasStaticPropertyWriteBefore = (identifier, propertyName, referenceNode, s
 const findEnclosingFunction$1 = (node) => {
 	let cursor = node.parent;
 	while (cursor) {
-		if (isFunctionLike$2(cursor)) return cursor;
+		if (isFunctionLike$1(cursor)) return cursor;
 		cursor = cursor.parent ?? null;
 	}
 	return null;
@@ -4656,7 +4656,7 @@ const isCommutativeParameterMutation = (statement, parameterNames) => {
 	return isNodeOfType(receiver, "Identifier") && parameterNames.has(receiver.name) && isNodeOfType(stripParenExpression(statement.expression.right), "Literal");
 };
 const isOrderIndependentFunction = (functionNode, scopes) => {
-	if (!isFunctionLike$2(functionNode)) return false;
+	if (!isFunctionLike$1(functionNode)) return false;
 	const parameterNames = /* @__PURE__ */ new Set();
 	for (const parameter of functionNode.params) {
 		if (!isNodeOfType(parameter, "Identifier")) return false;
@@ -4704,7 +4704,7 @@ const resolveOrderIndependentObjectPropertyFunction = (objectExpression, propert
 	}
 	if (!matchingProperty || !isNodeOfType(matchingProperty, "Property")) return null;
 	const propertyValue = stripParenExpression(matchingProperty.value);
-	if (isFunctionLike$2(propertyValue)) return isOrderIndependentFunction(propertyValue, scopes) ? propertyValue : null;
+	if (isFunctionLike$1(propertyValue)) return isOrderIndependentFunction(propertyValue, scopes) ? propertyValue : null;
 	return resolveOrderIndependentLocalFunction(propertyValue, callExpression, scopes, visitedSymbolIds);
 };
 const resolveOrderIndependentLocalFunction = (callee, callExpression, scopes, visitedSymbolIds) => {
@@ -4722,7 +4722,7 @@ const resolveOrderIndependentLocalFunction = (callee, callExpression, scopes, vi
 	const initializer = stripParenExpression(symbol.initializer);
 	const destructuredPropertyName = getDestructuredBindingPropertyName(symbol.bindingIdentifier);
 	if (destructuredPropertyName !== null) return resolveOrderIndependentObjectPropertyFunction(initializer, destructuredPropertyName, callExpression, scopes, visitedSymbolIds);
-	if (isFunctionLike$2(initializer)) return isOrderIndependentFunction(initializer, scopes) ? initializer : null;
+	if (isFunctionLike$1(initializer)) return isOrderIndependentFunction(initializer, scopes) ? initializer : null;
 	if (symbol.kind !== "const") return null;
 	return resolveOrderIndependentLocalFunction(initializer, callExpression, scopes, visitedSymbolIds);
 };
@@ -4755,7 +4755,7 @@ const findFirstAwaitOutsideNestedFunctions = (block, skipNestedLoops = false) =>
 	let firstAwait = null;
 	walkAst(block, (child) => {
 		if (firstAwait) return false;
-		if (child !== block && isFunctionLike$2(child)) return false;
+		if (child !== block && isFunctionLike$1(child)) return false;
 		if (skipNestedLoops && child !== block && LOOP_STATEMENT_TYPES.has(child.type)) return false;
 		if (isNodeOfType(child, "AwaitExpression")) firstAwait = child;
 	});
@@ -4835,7 +4835,7 @@ const ARRAY_MUTATION_METHOD_NAMES = new Set([
 const addDerivedBindings = (block, names) => {
 	const declaratorBindings = [];
 	walkAst(block, (child) => {
-		if (child !== block && isFunctionLike$2(child)) return false;
+		if (child !== block && isFunctionLike$1(child)) return false;
 		if (!isNodeOfType(child, "VariableDeclarator") || !child.init) return;
 		if (!isNodeOfType(child.id, "Identifier")) return;
 		const referencedNames = /* @__PURE__ */ new Set();
@@ -4862,7 +4862,7 @@ const hasLoopCarriedDependency = (block) => {
 	const carried = /* @__PURE__ */ new Set();
 	const awaitedReferences = /* @__PURE__ */ new Set();
 	walkAst(block, (child) => {
-		if (child !== block && isFunctionLike$2(child)) return false;
+		if (child !== block && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "AssignmentExpression") && child.left) {
 			collectPatternIdentifiers(child.left, carried);
 			return;
@@ -4884,7 +4884,7 @@ const NESTED_LOOP_OR_SWITCH_TYPES = new Set([...LOOP_TYPES, "SwitchStatement"]);
 const collectAwaitAssignedBindingNames = (block) => {
 	const awaitAssignedNames = /* @__PURE__ */ new Set();
 	walkAst(block, (child) => {
-		if (child !== block && isFunctionLike$2(child)) return false;
+		if (child !== block && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "VariableDeclarator") && child.id && containsDirectAwait(child.init)) collectPatternIdentifiers(child.id, awaitAssignedNames);
 		if (isNodeOfType(child, "AssignmentExpression") && child.left && containsDirectAwait(child.right)) collectPatternIdentifiers(child.left, awaitAssignedNames);
 	});
@@ -4954,7 +4954,7 @@ const loopBodyHasAwaitDependentEarlyExit = (block, loopLabelName) => {
 	let hasAwaitDependentExit = false;
 	walkAst(block, (child) => {
 		if (hasAwaitDependentExit) return false;
-		if (child !== block && isFunctionLike$2(child)) return false;
+		if (child !== block && isFunctionLike$1(child)) return false;
 		if (!(isNodeOfType(child, "ReturnStatement") || isNodeOfType(child, "BreakStatement") && doesBreakExitInspectedLoop(child, block, loopLabelName))) return;
 		if (isExitAwaitDependent(child, block, awaitAssignedNames)) {
 			hasAwaitDependentExit = true;
@@ -4976,7 +4976,7 @@ const MUTATING_ARRAY_METHOD_NAMES$1 = new Set([
 const collectBodyWrittenBindingNames = (block) => {
 	const writtenNames = /* @__PURE__ */ new Set();
 	walkAst(block, (child) => {
-		if (child !== block && isFunctionLike$2(child)) return false;
+		if (child !== block && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "AssignmentExpression") && child.left) {
 			collectPatternIdentifiers(child.left, writtenNames);
 			const assignedRootName = getRootObjectIdentifierName(child.left);
@@ -5072,7 +5072,7 @@ const resolvePromiseFlowNode = (mapCall) => {
 };
 const findEnclosingFunctionOrProgram = (node) => {
 	let current = node;
-	while (current.parent && !isFunctionLike$2(current)) current = current.parent;
+	while (current.parent && !isFunctionLike$1(current)) current = current.parent;
 	return current;
 };
 const isBindingCombinedWithPromiseConcurrency = (bindingName, scope) => {
@@ -5101,7 +5101,7 @@ const isWrappedInPromiseConcurrency = (mapCall) => {
 };
 const isLoopInsideWorkerPoolFunction = (loopNode) => {
 	const enclosingFunction = findEnclosingFunctionOrProgram(loopNode);
-	if (!isFunctionLike$2(enclosingFunction)) return false;
+	if (!isFunctionLike$1(enclosingFunction)) return false;
 	let functionBindingName = null;
 	if (isNodeOfType(enclosingFunction, "FunctionDeclaration") && isNodeOfType(enclosingFunction.id, "Identifier")) functionBindingName = enclosingFunction.id.name;
 	else if (isNodeOfType(enclosingFunction.parent, "VariableDeclarator") && isNodeOfType(enclosingFunction.parent.id, "Identifier")) functionBindingName = enclosingFunction.parent.id.name;
@@ -5369,7 +5369,7 @@ const guardConsequentPerformsSideEffects = (consequent) => {
 	let performsSideEffects = false;
 	walkAst(consequent, (child) => {
 		if (performsSideEffects) return false;
-		if (isFunctionLike$2(child)) return false;
+		if (isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "ThrowStatement")) return false;
 		if (isNodeOfType(child, "CallExpression") || isNodeOfType(child, "NewExpression") || isNodeOfType(child, "AssignmentExpression") || isNodeOfType(child, "UpdateExpression")) {
 			performsSideEffects = true;
@@ -5381,7 +5381,7 @@ const guardConsequentPerformsSideEffects = (consequent) => {
 const findEnclosingFunction = (node) => {
 	let ancestor = node.parent;
 	while (ancestor) {
-		if (isFunctionLike$2(ancestor)) return ancestor;
+		if (isFunctionLike$1(ancestor)) return ancestor;
 		ancestor = ancestor.parent;
 	}
 	return null;
@@ -5392,7 +5392,7 @@ const guardTestReadsReassignedLocal = (test, guardStatement) => {
 	collectReferenceIdentifierNames(test, testIdentifierNames);
 	if (testIdentifierNames.size === 0) return false;
 	const enclosingFunction = findEnclosingFunction(guardStatement);
-	if (!enclosingFunction || !isFunctionLike$2(enclosingFunction) || !enclosingFunction.body) return false;
+	if (!enclosingFunction || !isFunctionLike$1(enclosingFunction) || !enclosingFunction.body) return false;
 	let readsReassignedLocal = false;
 	walkAst(enclosingFunction.body, (child) => {
 		if (readsReassignedLocal) return false;
@@ -5487,13 +5487,13 @@ const asyncDeferAwait = defineRule({
 		const inspectAllStatementBlocks = (functionBody) => {
 			if (!functionBody) return;
 			walkAst(functionBody, (descendant) => {
-				if (isFunctionLike$2(descendant)) return false;
+				if (isFunctionLike$1(descendant)) return false;
 				if (isNodeOfType(descendant, "BlockStatement")) inspectStatements(descendant.body ?? []);
 				else if (isNodeOfType(descendant, "SwitchCase")) inspectStatements(descendant.consequent ?? []);
 			});
 		};
 		const enterFunction = (node) => {
-			if (!isFunctionLike$2(node)) return;
+			if (!isFunctionLike$1(node)) return;
 			if (!node.async) return;
 			if (!isNodeOfType(node.body, "BlockStatement")) return;
 			inspectAllStatementBlocks(node.body);
@@ -5598,7 +5598,7 @@ const sequenceContainsSerializationSignal = (statements, context) => {
 const isInsideTransactionCallback = (node) => {
 	let current = node.parent;
 	while (current) {
-		if (isFunctionLike$2(current)) {
+		if (isFunctionLike$1(current)) {
 			const callParent = current.parent;
 			if (callParent && isNodeOfType(callParent, "CallExpression")) {
 				const callee = callParent.callee;
@@ -6937,7 +6937,7 @@ const catchReturnsFallback = (tryStatement) => {
 	let hasReturn = false;
 	let hasThrow = false;
 	walkAst(handler.body, (child) => {
-		if (isFunctionLike$2(child)) return false;
+		if (isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "ReturnStatement")) hasReturn = true;
 		if (isNodeOfType(child, "ThrowStatement")) hasThrow = true;
 	});
@@ -6949,10 +6949,10 @@ const resolveValidatorFunction = (callee, scopes) => {
 	const symbol = scopes.symbolFor(unwrappedCallee);
 	if (!symbol) return null;
 	const candidate = symbol.kind === "function" ? symbol.declarationNode : symbol.initializer;
-	return isFunctionLike$2(candidate) ? candidate : null;
+	return isFunctionLike$1(candidate) ? candidate : null;
 };
 const validatorChecksPayloadProperties = (validatorFunction, scopes) => {
-	if (!isFunctionLike$2(validatorFunction)) return false;
+	if (!isFunctionLike$1(validatorFunction)) return false;
 	const firstParameter = validatorFunction.params?.[0];
 	if (!firstParameter || !isNodeOfType(firstParameter, "Identifier")) return false;
 	const parameterSymbol = scopes.symbolFor(firstParameter);
@@ -6960,7 +6960,7 @@ const validatorChecksPayloadProperties = (validatorFunction, scopes) => {
 	const payloadSymbolIds = new Set([parameterSymbol.id]);
 	let hasPropertyTypeCheck = false;
 	walkAst(validatorFunction.body, (child) => {
-		if (isFunctionLike$2(child)) return false;
+		if (isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier") && child.init) {
 			const initializer = stripParenExpression(child.init);
 			if (isNodeOfType(initializer, "Identifier")) {
@@ -7004,7 +7004,7 @@ const collectSafelyValidatedLocalStorageKeys = ({ programNode, scopes, resolveKe
 		const rawValueKeys = /* @__PURE__ */ new Map();
 		const parsedValueSources = /* @__PURE__ */ new Map();
 		walkAst(child.block, (tryChild) => {
-			if (isFunctionLike$2(tryChild)) return false;
+			if (isFunctionLike$1(tryChild)) return false;
 			if (isNodeOfType(tryChild, "VariableDeclarator") && isNodeOfType(tryChild.id, "Identifier") && tryChild.init) {
 				const initializer = stripParenExpression(tryChild.init);
 				if (isNodeOfType(initializer, "CallExpression") && isLocalStorageCall(initializer, "getItem")) {
@@ -7144,7 +7144,7 @@ const resolveExpressionKey$1 = (expression, context, visitedSymbolIds = /* @__PU
 	}
 	if (isNodeOfType(unwrappedExpression, "ThisExpression")) return "this";
 	if (isNodeOfType(unwrappedExpression, "Literal") && (typeof unwrappedExpression.value === "string" || typeof unwrappedExpression.value === "number")) return `literal:${String(unwrappedExpression.value)}`;
-	if (isFunctionLike$2(unwrappedExpression)) {
+	if (isFunctionLike$1(unwrappedExpression)) {
 		const rangeStart = getRangeStart(unwrappedExpression);
 		return rangeStart === null ? null : `function:${rangeStart}`;
 	}
@@ -7306,15 +7306,15 @@ const getLocalCalledFunction = (callExpression, context) => {
 	if (!isNodeOfType(callee, "Identifier")) return null;
 	const symbol = context.scopes.symbolFor(callee);
 	const candidate = symbol?.initializer ?? symbol?.declarationNode;
-	return candidate && isFunctionLike$2(stripParenExpression(candidate)) ? stripParenExpression(candidate) : null;
+	return candidate && isFunctionLike$1(stripParenExpression(candidate)) ? stripParenExpression(candidate) : null;
 };
 const hasDominatingEscapeMutation = (symbol, callNode, context, mutationIndex) => getSymbolEscapeCalls(symbol, context).some((escape) => escape.callExpression !== callNode && mutationDominatesCall(escape.callExpression, callNode, context) && callMayMutateArgument(escape.callExpression, escape.argumentIndex, context, mutationIndex, /* @__PURE__ */ new Map()));
 const factoryReturnsMutatedReceiver = (receiver, methodName, context, mutationIndex) => {
 	const factory = getLocalCalledFunction(stripParenExpression(receiver), context);
-	if (!factory || !isFunctionLike$2(factory)) return false;
+	if (!factory || !isFunctionLike$1(factory)) return false;
 	const returnStatements = [];
 	walkAst(factory.body, (node) => {
-		if (node !== factory.body && isFunctionLike$2(node)) return false;
+		if (node !== factory.body && isFunctionLike$1(node)) return false;
 		if (isNodeOfType(node, "ReturnStatement") && node.argument) returnStatements.push(node);
 	});
 	return returnStatements.length > 0 && returnStatements.every((returnStatement) => {
@@ -7395,11 +7395,11 @@ const getSymbolEscapeCalls = (symbol, context, visitedSymbols = /* @__PURE__ */
 	return result;
 };
 const functionReturnsParameter = (functionNode, parameterIdentity, context) => {
-	if (!isFunctionLike$2(functionNode)) return false;
+	if (!isFunctionLike$1(functionNode)) return false;
 	if (isNodeOfType(functionNode, "ArrowFunctionExpression") && !isNodeOfType(functionNode.body, "BlockStatement")) return resolveExpressionKey$1(functionNode.body, context) === parameterIdentity;
 	const returnStatements = [];
 	walkAst(functionNode.body, (node) => {
-		if (node !== functionNode.body && isFunctionLike$2(node)) return false;
+		if (node !== functionNode.body && isFunctionLike$1(node)) return false;
 		if (isNodeOfType(node, "ReturnStatement")) returnStatements.push(node);
 	});
 	return returnStatements.length > 0 && returnStatements.every((returnStatement) => isNodeOfType(returnStatement, "ReturnStatement") && returnStatement.argument && resolveExpressionKey$1(returnStatement.argument, context) === parameterIdentity);
@@ -7419,7 +7419,7 @@ const getCallResultSymbol = (callExpression, context) => {
 };
 const callMayMutateArgument = (callExpression, argumentIndex, context, mutationIndex, visitedParameterIndexesByFunction) => {
 	const calledFunction = getLocalCalledFunction(callExpression, context);
-	if (!calledFunction || !isFunctionLike$2(calledFunction)) return true;
+	if (!calledFunction || !isFunctionLike$1(calledFunction)) return true;
 	if (calledFunction.generator) return false;
 	const visitedParameterIndexes = visitedParameterIndexesByFunction.get(calledFunction) ?? /* @__PURE__ */ new Set();
 	if (visitedParameterIndexes.has(argumentIndex)) return false;
@@ -7496,10 +7496,10 @@ const createMethodMutationAnalysis = (context) => {
 //#endregion
 //#region src/plugin/utils/collect-function-return-statements.ts
 const collectFunctionReturnStatements = (functionNode) => {
-	if (!isFunctionLike$2(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return [];
+	if (!isFunctionLike$1(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return [];
 	const returnStatements = [];
 	walkAst(functionNode.body, (node) => {
-		if (node !== functionNode.body && (isFunctionLike$2(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
+		if (node !== functionNode.body && (isFunctionLike$1(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
 		if (isNodeOfType(node, "ReturnStatement")) returnStatements.push(node);
 	});
 	return returnStatements;
@@ -7517,7 +7517,7 @@ const statementAlwaysExits = (statement) => {
 const REASSIGNABLE_BINDING_KINDS = new Set(["let", "var"]);
 const CONDITIONAL_EXPRESSION_TYPES = new Set(["ConditionalExpression", "LogicalExpression"]);
 const collectReturnedExpressions = (functionNode) => {
-	if (!isFunctionLike$2(functionNode) || !functionNode.body) return [];
+	if (!isFunctionLike$1(functionNode) || !functionNode.body) return [];
 	if (!isNodeOfType(functionNode.body, "BlockStatement")) return [functionNode.body];
 	return collectFunctionReturnStatements(functionNode).flatMap((returnStatement) => returnStatement.argument ? [returnStatement.argument] : []);
 };
@@ -7619,11 +7619,11 @@ const collectPossibleAssignedExpressions = (symbol, referenceNode, controlFlow)
 	return [...applyDefinitions(incomingDefinitionsByBlock.get(referenceBlock) ?? /* @__PURE__ */ new Set(), definitionsBeforeReference)].map((definition) => definition.expression);
 };
 const functionHasBareReturn = (functionNode) => {
-	if (!isFunctionLike$2(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return false;
+	if (!isFunctionLike$1(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return false;
 	let didFindBareReturn = false;
 	walkAst(functionNode.body, (node) => {
 		if (didFindBareReturn) return false;
-		if (node !== functionNode.body && isFunctionLike$2(node)) return false;
+		if (node !== functionNode.body && isFunctionLike$1(node)) return false;
 		if (isNodeOfType(node, "ReturnStatement") && !node.argument) didFindBareReturn = true;
 	});
 	return didFindBareReturn;
@@ -7635,7 +7635,7 @@ const functionReturnsMatchingExpression = (functionNode, scopes, matchesExpressi
 		if (visitedFunctions.has(candidateFunction)) return false;
 		visitedFunctions.add(candidateFunction);
 		const returnedExpressions = collectReturnedExpressions(candidateFunction);
-		if (matchMode === "every" && isFunctionLike$2(candidateFunction) && isNodeOfType(candidateFunction.body, "BlockStatement") && (!statementAlwaysExits(candidateFunction.body) || functionHasBareReturn(candidateFunction))) return false;
+		if (matchMode === "every" && isFunctionLike$1(candidateFunction) && isNodeOfType(candidateFunction.body, "BlockStatement") && (!statementAlwaysExits(candidateFunction.body) || functionHasBareReturn(candidateFunction))) return false;
 		return returnedExpressions.length > 0 && (matchMode === "every" ? returnedExpressions.every(expressionMatches) : returnedExpressions.some(expressionMatches));
 	};
 	const expressionMatches = (expression) => {
@@ -7648,7 +7648,7 @@ const functionReturnsMatchingExpression = (functionNode, scopes, matchesExpressi
 			if (!symbol || symbol.kind !== "const" && !REASSIGNABLE_BINDING_KINDS.has(symbol.kind)) return false;
 			return collectPossibleAssignedExpressions(symbol, unwrappedExpression, controlFlow).some((assignedExpression) => {
 				const assignedValue = stripParenExpression(assignedExpression);
-				return !isFunctionLike$2(assignedValue) && expressionMatches(assignedValue);
+				return !isFunctionLike$1(assignedValue) && expressionMatches(assignedValue);
 			});
 		}
 		if (isNodeOfType(unwrappedExpression, "CallExpression")) {
@@ -7657,7 +7657,7 @@ const functionReturnsMatchingExpression = (functionNode, scopes, matchesExpressi
 			const symbol = scopes.symbolFor(unwrappedExpression.callee);
 			if (!symbol || symbol.kind !== "const" && symbol.kind !== "function") return false;
 			const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
-			const candidateFunction = isFunctionLike$2(initializer) ? initializer : isFunctionLike$2(symbol.declarationNode) ? symbol.declarationNode : null;
+			const candidateFunction = isFunctionLike$1(initializer) ? initializer : isFunctionLike$1(symbol.declarationNode) ? symbol.declarationNode : null;
 			if (!candidateFunction || candidateFunction.async || candidateFunction.generator || candidateFunction.params.length !== 0) return false;
 			return functionMatches(candidateFunction);
 		}
@@ -7988,7 +7988,7 @@ const getSameFileCalledFunction = (callExpression, scopes, visitedSymbolIds) =>
 	if (!symbol || visitedSymbolIds.has(symbol.id)) return null;
 	if (symbol.kind !== "const" && !(symbol.kind === "function" && symbol.references.every((reference) => reference.flag === "read"))) return null;
 	const candidate = symbol.initializer ?? symbol.declarationNode;
-	if (!isFunctionLike$2(candidate) || candidate.async || candidate.generator) return null;
+	if (!isFunctionLike$1(candidate) || candidate.async || candidate.generator) return null;
 	visitedSymbolIds.add(symbol.id);
 	return candidate;
 };
@@ -8071,12 +8071,8 @@ const isProvenBrowserApiReceiver = (receiver, receiverKind, scopes, visitedSymbo
 const GENERATED_DOCS_ARCHIVE_PATH_PATTERN = /(?:^|\/)(?:docs?|documentation)\/archive\/[^/]+\/static\/(?:[^/]+\/)*docs\.js$/i;
 const isGeneratedDocsArchiveFilename = (filename) => GENERATED_DOCS_ARCHIVE_PATH_PATTERN.test(normalizeFilename(filename ?? ""));
 //#endregion
-//#region src/plugin/utils/find-exported-function-body.ts
-const isFunctionLike = (node) => {
-	if (!node) return false;
-	return isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression");
-};
-const findExportedFunctionBody = (programRoot, exportedName) => {
+//#region src/plugin/utils/find-exported-value.ts
+const findExportedValue = (programRoot, exportedName) => {
 	if (!isNodeOfType(programRoot, "Program")) return null;
 	const localBindings = /* @__PURE__ */ new Map();
 	const namedExports = /* @__PURE__ */ new Map();
@@ -8085,9 +8081,8 @@ const findExportedFunctionBody = (programRoot, exportedName) => {
 	const recordVariableDeclaration = (declaration) => {
 		for (const declarator of declaration.declarations ?? []) {
 			if (!isNodeOfType(declarator, "VariableDeclarator")) continue;
-			if (!isNodeOfType(declarator.id, "Identifier")) continue;
-			const initializer = declarator.init ? stripParenExpression(declarator.init) : null;
-			if (initializer && isFunctionLike(initializer)) localBindings.set(declarator.id.name, initializer);
+			if (!isNodeOfType(declarator.id, "Identifier") || !declarator.init) continue;
+			localBindings.set(declarator.id.name, stripParenExpression(declarator.init));
 		}
 	};
 	for (const statement of programRoot.body ?? []) {
@@ -8114,33 +8109,22 @@ const findExportedFunctionBody = (programRoot, exportedName) => {
 				namedExports.set(declaration.id.name, declaration.id.name);
 			}
 			for (const specifier of statement.specifiers ?? []) {
-				if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
-				if (specifier.exportKind === "type") continue;
-				const local = specifier.local;
-				const exported = specifier.exported;
-				if (!isNodeOfType(local, "Identifier")) continue;
-				const exportedNameSpec = isNodeOfType(exported, "Identifier") ? exported.name : isNodeOfType(exported, "Literal") && typeof exported.value === "string" ? exported.value : null;
-				if (!exportedNameSpec) continue;
-				namedExports.set(exportedNameSpec, local.name);
+				if (!isNodeOfType(specifier, "ExportSpecifier") || specifier.exportKind === "type") continue;
+				const localName = isNodeOfType(specifier.local, "Identifier") ? specifier.local.name : null;
+				let exportedSpecifierName = null;
+				if (isNodeOfType(specifier.exported, "Identifier")) exportedSpecifierName = specifier.exported.name;
+				else if (isNodeOfType(specifier.exported, "Literal") && typeof specifier.exported.value === "string") exportedSpecifierName = specifier.exported.value;
+				if (localName && exportedSpecifierName) namedExports.set(exportedSpecifierName, localName);
 			}
 			continue;
 		}
-		if (isNodeOfType(statement, "ExportDefaultDeclaration")) {
-			const declaration = statement.declaration;
-			if (!declaration) continue;
-			if (isNodeOfType(declaration, "FunctionDeclaration") && declaration.id) {
-				localBindings.set(declaration.id.name, declaration);
-				defaultExport = declaration;
-				continue;
-			}
-			if (isFunctionLike(declaration)) {
-				defaultExport = declaration;
-				continue;
-			}
-			if (isNodeOfType(declaration, "Identifier")) {
-				defaultExportIdentifierName = declaration.name;
-				continue;
-			}
+		if (!isNodeOfType(statement, "ExportDefaultDeclaration")) continue;
+		const declaration = statement.declaration;
+		if (!declaration) continue;
+		if (isNodeOfType(declaration, "Identifier")) defaultExportIdentifierName = declaration.name;
+		else {
+			if ((isNodeOfType(declaration, "FunctionDeclaration") || isNodeOfType(declaration, "ClassDeclaration")) && declaration.id) localBindings.set(declaration.id.name, declaration);
+			defaultExport = stripParenExpression(declaration);
 		}
 	}
 	if (exportedName === "default") {
@@ -8151,9 +8135,10 @@ const findExportedFunctionBody = (programRoot, exportedName) => {
 		}
 	}
 	const localName = namedExports.get(exportedName);
-	if (!localName) return null;
-	return localBindings.get(localName) ?? null;
+	return localName ? localBindings.get(localName) ?? null : null;
 };
+//#endregion
+//#region src/plugin/utils/find-exported-function-body.ts
 const resolveImportedExportName = (importSpecifier) => {
 	if (isNodeOfType(importSpecifier, "ImportSpecifier")) {
 		const imported = importSpecifier.imported;
@@ -8610,28 +8595,44 @@ const resolveModulePath = (fromFilename, source) => {
 };
 //#endregion
 //#region src/plugin/utils/resolve-cross-file-function-export.ts
-const resolveFunctionExportInFile = (filePath, exportedName, visitedFilePaths) => {
+const resolveValueExportInFile = (filePath, exportedName, visitedFilePaths) => {
 	if (visitedFilePaths.size >= 4) return null;
 	if (visitedFilePaths.has(filePath)) return null;
 	visitedFilePaths.add(filePath);
 	const programRoot = parseSourceFile(filePath);
 	if (!programRoot) return null;
-	const exported = findExportedFunctionBody(programRoot, exportedName);
-	if (exported) return exported;
-	const resolvedCandidates = /* @__PURE__ */ new Set();
+	const exported = findExportedValue(programRoot, exportedName);
+	if (exported) return {
+		filePath,
+		exportedNode: exported,
+		programNode: programRoot
+	};
+	const resolvedCandidates = /* @__PURE__ */ new Map();
 	for (const target of findReExportTargetsForName(programRoot, exportedName)) {
 		const nextFilePath = resolveModulePath(filePath, target.source);
 		if (!nextFilePath) continue;
-		const resolved = resolveFunctionExportInFile(nextFilePath, target.importedName, new Set(visitedFilePaths));
-		if (resolved) resolvedCandidates.add(resolved);
+		const resolved = resolveValueExportInFile(nextFilePath, target.importedName, new Set(visitedFilePaths));
+		if (resolved) resolvedCandidates.set(resolved.exportedNode, resolved);
 	}
 	if (resolvedCandidates.size !== 1) return null;
 	return resolvedCandidates.values().next().value ?? null;
 };
 const resolveCrossFileFunctionExport = (fromFilename, source, exportedName) => {
+	return resolveCrossFileFunctionExportWithFilePath(fromFilename, source, exportedName)?.functionNode ?? null;
+};
+const resolveCrossFileFunctionExportWithFilePath = (fromFilename, source, exportedName) => {
+	const resolved = resolveCrossFileValueExportWithFilePath(fromFilename, source, exportedName);
+	if (!resolved || !isFunctionLike$1(resolved.exportedNode)) return null;
+	return {
+		filePath: resolved.filePath,
+		functionNode: resolved.exportedNode,
+		programNode: resolved.programNode
+	};
+};
+const resolveCrossFileValueExportWithFilePath = (fromFilename, source, exportedName) => {
 	const resolvedFilePath = resolveModulePath(fromFilename, source);
 	if (!resolvedFilePath) return null;
-	return resolveFunctionExportInFile(resolvedFilePath, exportedName, /* @__PURE__ */ new Set());
+	return resolveValueExportInFile(resolvedFilePath, exportedName, /* @__PURE__ */ new Set());
 };
 //#endregion
 //#region src/plugin/utils/is-proven-pure-imported-predicate-call.ts
@@ -8682,7 +8683,7 @@ const isProvenPureImportedPredicateCall = (callExpression, eventArgumentIndex, c
 	const exportedName = resolveImportedExportName(importSpecifier);
 	if (!exportedName || !isNodeOfType(importDeclaration, "ImportDeclaration") || typeof importDeclaration.source.value !== "string") return false;
 	const importedFunction = resolveCrossFileFunctionExport(context.filename, importDeclaration.source.value, exportedName);
-	if (!importedFunction || !isFunctionLike$2(importedFunction)) return false;
+	if (!importedFunction || !isFunctionLike$1(importedFunction)) return false;
 	const parameter = importedFunction.params[eventArgumentIndex];
 	if (!isNodeOfType(parameter, "Identifier")) return false;
 	const aliasNames = new Set([parameter.name]);
@@ -8736,11 +8737,11 @@ const PROMISE_DEFERRED_METHOD_NAMES = new Set([
 ]);
 const EMPTY_VISITORS$7 = {};
 const handlerCallsPreventDefault = (handler) => {
-	if (!isFunctionLike$2(handler)) return false;
+	if (!isFunctionLike$1(handler)) return false;
 	let didFindPreventDefault = false;
 	walkAst(handler, (child) => {
 		if (didFindPreventDefault) return false;
-		if (child !== handler && isFunctionLike$2(child)) return false;
+		if (child !== handler && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "MemberExpression") && getStaticPropertyName(child.callee) === "preventDefault") didFindPreventDefault = true;
 	});
 	return didFindPreventDefault;
@@ -8771,18 +8772,18 @@ const handlerArgumentCallsPreventDefault = (handler) => {
 const resolveHandlerFunction = (handler, context) => {
 	if (!handler) return void 0;
 	const unwrappedHandler = stripParenExpression(handler);
-	if (isFunctionLike$2(unwrappedHandler)) return unwrappedHandler;
+	if (isFunctionLike$1(unwrappedHandler)) return unwrappedHandler;
 	if (isNodeOfType(unwrappedHandler, "Identifier")) {
 		const symbol = context.scopes.symbolFor(unwrappedHandler);
 		const candidate = symbol?.initializer ?? symbol?.declarationNode;
-		if (candidate && isFunctionLike$2(candidate)) return candidate;
+		if (candidate && isFunctionLike$1(candidate)) return candidate;
 		const binding = findVariableInitializer(unwrappedHandler, unwrappedHandler.name);
 		let assignedFunction;
 		if (symbol && binding) walkAst(binding.scopeOwner, (child) => {
 			if (child.range[0] >= unwrappedHandler.range[0]) return false;
 			if (isNodeOfType(child, "AssignmentExpression") && child.operator === "=" && isNodeOfType(child.left, "Identifier") && context.scopes.symbolFor(child.left) === symbol) {
 				const assignedValue = stripParenExpression(child.right);
-				assignedFunction = isFunctionLike$2(assignedValue) ? assignedValue : void 0;
+				assignedFunction = isFunctionLike$1(assignedValue) ? assignedValue : void 0;
 			}
 		});
 		return assignedFunction;
@@ -8813,7 +8814,7 @@ const handlerMayExposeEvent = (handler, context) => {
 	const visitedParameterIndexesByFunction = /* @__PURE__ */ new Map();
 	const isAsyncFunctionReference = (rawExpression, visitedSymbolIds) => {
 		const expression = stripParenExpression(rawExpression);
-		if (isFunctionLike$2(expression)) return expression.async;
+		if (isFunctionLike$1(expression)) return expression.async;
 		if (!isNodeOfType(expression, "Identifier")) return false;
 		const symbol = context.scopes.symbolFor(expression);
 		if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
@@ -8883,7 +8884,7 @@ const handlerMayExposeEvent = (handler, context) => {
 		return true;
 	};
 	const functionMayExposeParameter = (functionNode, parameterIndex, isRootHandler = false) => {
-		if (!isFunctionLike$2(functionNode)) return false;
+		if (!isFunctionLike$1(functionNode)) return false;
 		const visitedParameterIndexes = visitedParameterIndexesByFunction.get(functionNode) ?? /* @__PURE__ */ new Set();
 		if (visitedParameterIndexes.has(parameterIndex)) return false;
 		visitedParameterIndexes.add(parameterIndex);
@@ -8970,7 +8971,7 @@ const handlerMayExposeEvent = (handler, context) => {
 		let didExposeEvent = false;
 		walkAst(functionNode.body, (child) => {
 			if (didExposeEvent) return false;
-			if (child !== functionNode.body && isFunctionLike$2(child) && !shouldVisitNestedFunction(child)) return false;
+			if (child !== functionNode.body && isFunctionLike$1(child) && !shouldVisitNestedFunction(child)) return false;
 			if (isNodeOfType(child, "VariableDeclarator") && child.init) {
 				addAliasesFromPattern(child.id, child.init);
 				return;
@@ -10988,7 +10989,7 @@ const resolveAliasedSymbol = (identifier, context, visitedSymbolIds) => {
 const resolveCallbackIdentity = (callbackNode, context) => {
 	if (!callbackNode) return null;
 	const unwrappedCallback = stripParenExpression(callbackNode);
-	if (isFunctionLike$2(unwrappedCallback)) return {
+	if (isFunctionLike$1(unwrappedCallback)) return {
 		node: unwrappedCallback,
 		isConcreteFunction: true
 	};
@@ -10996,7 +10997,7 @@ const resolveCallbackIdentity = (callbackNode, context) => {
 	const symbol = resolveAliasedSymbol(unwrappedCallback, context, /* @__PURE__ */ new Set());
 	if (!symbol) return null;
 	const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
-	if (initializer && isFunctionLike$2(initializer)) return {
+	if (initializer && isFunctionLike$1(initializer)) return {
 		node: initializer,
 		isConcreteFunction: true
 	};
@@ -11226,12 +11227,12 @@ const readDestructuredRemovalCandidate = (node, context) => {
 const resolveReturnedCleanupBody = (returnedValue, context) => {
 	if (!returnedValue) return null;
 	const unwrappedValue = stripParenExpression(returnedValue);
-	if (isFunctionLike$2(unwrappedValue)) return unwrappedValue.body;
+	if (isFunctionLike$1(unwrappedValue)) return unwrappedValue.body;
 	if (!isNodeOfType(unwrappedValue, "Identifier")) return null;
 	const symbol = resolveAliasedSymbol(unwrappedValue, context, /* @__PURE__ */ new Set());
 	if (!symbol || !symbol.initializer) return null;
 	const initializer = stripParenExpression(symbol.initializer);
-	return isFunctionLike$2(initializer) ? initializer.body : null;
+	return isFunctionLike$1(initializer) ? initializer.body : null;
 };
 const collectEffectListenerInputs = (effectBody, context) => {
 	const registrations = [];
@@ -11247,7 +11248,7 @@ const collectEffectListenerInputs = (effectBody, context) => {
 	const finalEffectStatement = effectBody.body[effectBody.body.length - 1];
 	const hasCanonicalCleanupReturn = isNodeOfType(finalEffectStatement, "ReturnStatement");
 	walkAst(effectBody, (child) => {
-		if (child !== effectBody && isFunctionLike$2(child)) return false;
+		if (child !== effectBody && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "ClassDeclaration") || isNodeOfType(child, "ClassExpression")) return false;
 		if (isNodeOfType(child, "CallExpression")) {
 			if (isListenerPathAmbiguous(child, effectBody)) return;
@@ -11295,7 +11296,7 @@ const resolveCalledCleanup = (callNode, context) => {
 	const cleanupSymbol = resolveAliasedSymbol(callee, context, /* @__PURE__ */ new Set());
 	if (!cleanupSymbol?.initializer || cleanupSymbol.kind !== "const" && cleanupSymbol.kind !== "function") return null;
 	const initializer = stripParenExpression(cleanupSymbol.initializer);
-	if (!isFunctionLike$2(initializer) || initializer.async || initializer.generator) return null;
+	if (!isFunctionLike$1(initializer) || initializer.async || initializer.generator) return null;
 	return {
 		body: initializer.body,
 		symbolId: cleanupSymbol.id
@@ -11342,7 +11343,7 @@ const analyzeCleanupBody = (cleanupBody, context, visitedCleanupSymbolIds = /* @
 		return false;
 	};
 	walkAst(cleanupBody, (child) => {
-		if (child !== cleanupBody && isFunctionLike$2(child)) return false;
+		if (child !== cleanupBody && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "ClassDeclaration") || isNodeOfType(child, "ClassExpression")) return false;
 		if (isNodeOfType(child, "ReturnStatement") && child === finalCleanupStatement) return;
 		if (isNodeOfType(child, "ReturnStatement") || isNodeOfType(child, "ThrowStatement") || isLoopBody && (isNodeOfType(child, "BreakStatement") || isNodeOfType(child, "ContinueStatement"))) {
@@ -11452,7 +11453,7 @@ const effectListenerCleanupMismatch = defineRule({
 	create: (context) => ({ CallExpression(node) {
 		if (!isReactApiCall(node, LISTENER_EFFECT_HOOK_NAMES, context.scopes)) return;
 		const effectCallback = getEffectCallback(node);
-		if (!isFunctionLike$2(effectCallback)) return;
+		if (!isFunctionLike$1(effectCallback)) return;
 		const listenerAnalysis = analyzeEffectListeners(effectCallback.body, context);
 		if (!listenerAnalysis) return;
 		for (const registration of listenerAnalysis.registrations) {
@@ -11514,7 +11515,7 @@ const collectEffectInvokedFunctions = (effectCallback) => {
 	const pendingFunctions = [effectCallback];
 	const enqueue = (candidate) => {
 		const strippedCandidate = candidate ? stripParenExpression(candidate) : candidate;
-		if (!isFunctionLike$2(strippedCandidate) || invokedFunctions.has(strippedCandidate)) return;
+		if (!isFunctionLike$1(strippedCandidate) || invokedFunctions.has(strippedCandidate)) return;
 		invokedFunctions.add(strippedCandidate);
 		pendingFunctions.push(strippedCandidate);
 	};
@@ -11522,18 +11523,18 @@ const collectEffectInvokedFunctions = (effectCallback) => {
 		const currentFunction = pendingFunctions.pop();
 		if (!currentFunction) break;
 		walkAst(currentFunction, (child) => {
-			if (child !== currentFunction && isFunctionLike$2(child)) {
+			if (child !== currentFunction && isFunctionLike$1(child)) {
 				if (isNodeOfType(child, "FunctionDeclaration") && isNodeOfType(child.id, "Identifier")) localFunctionBindings.set(child.id.name, child);
 				return false;
 			}
 			if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier")) {
 				const initializer = child.init ? stripParenExpression(child.init) : null;
-				if (isFunctionLike$2(initializer)) localFunctionBindings.set(child.id.name, initializer);
+				if (isFunctionLike$1(initializer)) localFunctionBindings.set(child.id.name, initializer);
 				return;
 			}
 			if (!isNodeOfType(child, "CallExpression")) return;
 			const callee = stripParenExpression(child.callee);
-			if (isFunctionLike$2(callee)) {
+			if (isFunctionLike$1(callee)) {
 				enqueue(callee);
 				return;
 			}
@@ -11695,7 +11696,7 @@ const hasReactRefCurrentOrigin = (node, scopes, visitedSymbolIds = /* @__PURE__
 //#region src/plugin/utils/walk-inside-statement-blocks.ts
 const walkInsideStatementBlocks = (node, visitor) => {
 	if (!node || typeof node !== "object") return;
-	if (isFunctionLike$2(node)) return;
+	if (isFunctionLike$1(node)) return;
 	visitor(node);
 	const nodeRecord = node;
 	for (const key of Object.keys(nodeRecord)) {
@@ -11810,7 +11811,7 @@ const resolveExpressionKey = (expression, context, visitedSymbolIds = /* @__PURE
 	}
 	if (isNodeOfType(unwrappedExpression, "ThisExpression")) return "this";
 	if (isNodeOfType(unwrappedExpression, "Literal") && (typeof unwrappedExpression.value === "string" || typeof unwrappedExpression.value === "number")) return `literal:${String(unwrappedExpression.value)}`;
-	if (isFunctionLike$2(unwrappedExpression)) {
+	if (isFunctionLike$1(unwrappedExpression)) {
 		const rangeStart = getRangeStart(unwrappedExpression);
 		return rangeStart === null ? null : `function:${rangeStart}`;
 	}
@@ -11853,7 +11854,7 @@ const findSubscribeLikeUsages = (callback, context) => {
 	}
 	const effectInvokedFunctions = collectEffectInvokedFunctions(callback);
 	walkAst(callback, (child) => {
-		if (child !== callback && isFunctionLike$2(child)) {
+		if (child !== callback && isFunctionLike$1(child)) {
 			if (child === cleanupArgument) return false;
 			if (!effectInvokedFunctions.has(child) && !isSynchronousIteratorCallback(child)) return false;
 		}
@@ -12016,7 +12017,7 @@ const isAssignmentFormForOfIteratorReference = (expression, context) => {
 		return didAssignReferencedSymbol;
 	};
 	let currentNode = unwrappedExpression.parent;
-	while (currentNode && !isFunctionLike$2(currentNode)) {
+	while (currentNode && !isFunctionLike$1(currentNode)) {
 		if (isNodeOfType(currentNode, "ForOfStatement")) {
 			const loopTarget = stripParenExpression(currentNode.left);
 			if (!isNodeOfType(loopTarget, "VariableDeclaration") && (assignsReferencedSymbol(loopTarget, false) || assignsReferencedSymbol(currentNode.body, true))) return true;
@@ -12085,8 +12086,8 @@ const resolveIteratorCollectionKey = (expression, context) => {
 	const symbol = context.scopes.symbolFor(unwrappedExpression);
 	if (!symbol || symbol.kind !== "parameter") return null;
 	let callbackNode = symbol.bindingIdentifier.parent;
-	while (callbackNode && !isFunctionLike$2(callbackNode)) callbackNode = callbackNode.parent;
-	if (!callbackNode || !isFunctionLike$2(callbackNode)) return null;
+	while (callbackNode && !isFunctionLike$1(callbackNode)) callbackNode = callbackNode.parent;
+	if (!callbackNode || !isFunctionLike$1(callbackNode)) return null;
 	const callNode = callbackNode.parent;
 	if (!isNodeOfType(callNode, "CallExpression")) return null;
 	const callee = stripParenExpression(callNode.callee);
@@ -12116,7 +12117,7 @@ const isDirectExhaustiveForOfRelease = (releaseNode, forOfStatement) => {
 	let hasAbruptLoopExit = false;
 	walkAst(forOfStatement.body, (child) => {
 		if (hasAbruptLoopExit) return false;
-		if (child !== forOfStatement.body && isFunctionLike$2(child)) return false;
+		if (child !== forOfStatement.body && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "BreakStatement") || isNodeOfType(child, "ContinueStatement") || isNodeOfType(child, "ReturnStatement") || isNodeOfType(child, "ThrowStatement")) {
 			hasAbruptLoopExit = true;
 			return false;
@@ -12145,7 +12146,7 @@ const findMappedResourceCollectionKey = (resourceNode, context) => {
 		if (!isNodeOfType(resourceDeclarator, "VariableDeclarator") || resourceDeclarator.init !== resourceRoot || !isNodeOfType(resourceDeclarator.id, "Identifier") || !isNodeOfType(resourceDeclaration, "VariableDeclaration") || resourceDeclaration.kind !== "const" || resourceDeclaration.parent !== callbackNode.body) return null;
 		const returnStatements = [];
 		walkAst(callbackNode.body, (child) => {
-			if (child !== callbackNode.body && isFunctionLike$2(child)) return false;
+			if (child !== callbackNode.body && isFunctionLike$1(child)) return false;
 			if (isNodeOfType(child, "ReturnStatement")) returnStatements.push(child);
 		});
 		const returnStatement = returnStatements[0];
@@ -12164,7 +12165,7 @@ const findContainingCollectionKey = (resourceNode, context) => {
 	let currentNode = resourceNode;
 	let parentNode = currentNode.parent;
 	while (parentNode) {
-		if (isFunctionLike$2(parentNode)) return null;
+		if (isFunctionLike$1(parentNode)) return null;
 		if (isNodeOfType(parentNode, "VariableDeclarator") && parentNode.init === currentNode) return resolveExpressionKey(parentNode.id, context);
 		currentNode = parentNode;
 		parentNode = currentNode.parent;
@@ -12189,7 +12190,7 @@ const resolveStableValue = (expression, context, visitedSymbolIds = /* @__PURE__
 	if (!isNodeOfType(unwrappedExpression, "Identifier")) return unwrappedExpression;
 	const symbol = context.scopes.symbolFor(unwrappedExpression);
 	const isUnreassignedMutableBinding = (symbol?.kind === "let" || symbol?.kind === "var") && isNodeOfType(symbol.declarationNode, "VariableDeclarator") && symbol.declarationNode.id === symbol.bindingIdentifier && symbol.references.every((reference) => reference.flag === "read" && !isWithinAssignmentTarget(reference.identifier)) && symbol.scope.symbols.filter((candidate) => candidate.name === symbol.name).length === 1;
-	const recursiveFunctionSymbol = symbol?.kind === "function" && isFunctionLike$2(symbol.declarationNode) ? context.scopes.ownScopeFor(symbol.declarationNode)?.symbols.find((candidate) => candidate.name === symbol.name && candidate.declarationNode === symbol.declarationNode) : null;
+	const recursiveFunctionSymbol = symbol?.kind === "function" && isFunctionLike$1(symbol.declarationNode) ? context.scopes.ownScopeFor(symbol.declarationNode)?.symbols.find((candidate) => candidate.name === symbol.name && candidate.declarationNode === symbol.declarationNode) : null;
 	const isUnreassignedFunctionBinding = symbol?.kind === "function" && symbol.references.every((reference) => reference.flag === "read" && !isWithinAssignmentTarget(reference.identifier)) && (!recursiveFunctionSymbol || recursiveFunctionSymbol.references.every((reference) => reference.flag === "read" && !isWithinAssignmentTarget(reference.identifier))) && symbol.scope.symbols.filter((candidate) => candidate.name === symbol.name).length === 1;
 	if (!symbol || symbol.kind !== "const" && !isUnreassignedMutableBinding && !isUnreassignedFunctionBinding || !symbol.initializer || visitedSymbolIds.has(symbol.id)) return unwrappedExpression;
 	visitedSymbolIds.add(symbol.id);
@@ -12265,16 +12266,16 @@ const resolveSingleAssignedCleanupFunction = (expression, usage, context) => {
 	const assignmentNode = assignmentTarget.parent;
 	if (!isNodeOfType(assignmentNode, "AssignmentExpression") || assignmentNode.operator !== "=" || assignmentNode.left !== assignmentTarget || findEnclosingFunction$1(assignmentNode) !== findEnclosingFunction$1(usage.node) || !doMatchingNodesCoverEveryPathAfterUsage(usage.node, [assignmentNode], context)) return null;
 	const assignedValue = stripParenExpression(assignmentNode.right);
-	return isFunctionLike$2(assignedValue) ? assignedValue : null;
+	return isFunctionLike$1(assignedValue) ? assignedValue : null;
 };
 const doesCleanupFunctionReleaseUsage = (cleanupFunction, usage, context, visitedFunctions = /* @__PURE__ */ new Set()) => {
-	if (!isFunctionLike$2(cleanupFunction) || visitedFunctions.has(cleanupFunction)) return false;
+	if (!isFunctionLike$1(cleanupFunction) || visitedFunctions.has(cleanupFunction)) return false;
 	visitedFunctions.add(cleanupFunction);
 	let didCleanupFunctionMatch = false;
 	const matchingLoopOrHelperAnchors = [];
 	walkAst(cleanupFunction.body, (cleanupChild) => {
 		if (didCleanupFunctionMatch) return false;
-		if (cleanupChild !== cleanupFunction.body && isFunctionLike$2(cleanupChild) && !isSynchronousIteratorCallback(cleanupChild)) return false;
+		if (cleanupChild !== cleanupFunction.body && isFunctionLike$1(cleanupChild) && !isSynchronousIteratorCallback(cleanupChild)) return false;
 		const cleanupCall = isNodeOfType(cleanupChild, "ChainExpression") ? cleanupChild.expression : cleanupChild;
 		if (doesReleaseCallMatchUsage(cleanupChild, usage, context)) {
 			const cleanupForOfStatement = findForOfStatementForIteratorExpression(isNodeOfType(cleanupCall, "CallExpression") ? cleanupCall.arguments?.[0] : null, context);
@@ -12288,7 +12289,7 @@ const doesCleanupFunctionReleaseUsage = (cleanupFunction, usage, context, visite
 		if (!isNodeOfType(cleanupCall, "CallExpression")) return;
 		const stableHelperFunction = resolveStableValue(cleanupCall.callee, context);
 		const helperFunction = isNodeOfType(stableHelperFunction, "Identifier") ? resolveSingleAssignedCleanupFunction(stableHelperFunction, usage, context) : stableHelperFunction;
-		if (helperFunction && isFunctionLike$2(helperFunction) && !helperFunction.async && !helperFunction.generator && doesCleanupFunctionReleaseUsage(helperFunction, usage, context, new Set(visitedFunctions))) matchingLoopOrHelperAnchors.push(cleanupCall);
+		if (helperFunction && isFunctionLike$1(helperFunction) && !helperFunction.async && !helperFunction.generator && doesCleanupFunctionReleaseUsage(helperFunction, usage, context, new Set(visitedFunctions))) matchingLoopOrHelperAnchors.push(cleanupCall);
 	});
 	return didCleanupFunctionMatch || doMatchingNodesCoverEveryPathFromFunctionEntry(cleanupFunction, matchingLoopOrHelperAnchors, context);
 };
@@ -12312,7 +12313,7 @@ const callbackReturnsCleanupForUsage = (callback, usage, context) => {
 		if (doesBoundCleanupReleaseUsage(returnedValue, usage, context)) return true;
 		const cleanupFunction = resolveStableValue(returnedValue, context);
 		if (cleanupFunction && doesBoundCleanupReleaseUsage(cleanupFunction, usage, context)) return true;
-		return Boolean(cleanupFunction && isFunctionLike$2(cleanupFunction) && doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context));
+		return Boolean(cleanupFunction && isFunctionLike$1(cleanupFunction) && doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context));
 	};
 	if (!isNodeOfType(callback.body, "BlockStatement")) return doesReturnedValueReleaseUsage(stripParenExpression(callback.body));
 	const matchingCleanupReturns = [];
@@ -12347,7 +12348,7 @@ const hasRerunReleaseBeforeUsage = (callback, usage, context) => {
 			return;
 		}
 		const helperFunction = resolveStableValue(child.callee, context);
-		if (helperFunction && isFunctionLike$2(helperFunction) && doesCleanupFunctionReleaseUsage(helperFunction, usage, context)) matchingReleaseAnchors.push(handleGuard ?? child);
+		if (helperFunction && isFunctionLike$1(helperFunction) && doesCleanupFunctionReleaseUsage(helperFunction, usage, context)) matchingReleaseAnchors.push(handleGuard ?? child);
 	});
 	return doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingReleaseAnchors, context);
 };
@@ -12405,10 +12406,10 @@ const isDirectEarlyReturnConsequent = (ifStatement) => {
 	return isNodeOfType(ifStatement.consequent, "BlockStatement") && ifStatement.consequent.body.length === 1 && isNodeOfType(ifStatement.consequent.body[0], "ReturnStatement");
 };
 const collectDeferredUsageGuardStates = (callback, usageNode, context) => {
-	if (!isFunctionLike$2(callback) || callback.async) return [];
+	if (!isFunctionLike$1(callback) || callback.async) return [];
 	const guardStates = [];
 	walkAst(callback.body, (child) => {
-		if (child !== callback.body && isFunctionLike$2(child)) return false;
+		if (child !== callback.body && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "IfStatement") && isDirectEarlyReturnConsequent(child) && doMatchingNodesCoverEveryPathBeforeUsage(usageNode, [child], callback, context)) guardStates.push(...collectBlockingBooleanStates(child.test, true, context));
 	});
 	let descendant = usageNode;
@@ -12423,11 +12424,11 @@ const collectDeferredUsageGuardStates = (callback, usageNode, context) => {
 const cleanupReturnInvalidatesGuard = (cleanupReturn, guardState, context) => {
 	if (!isNodeOfType(cleanupReturn, "ReturnStatement") || !cleanupReturn.argument) return false;
 	const cleanupFunction = resolveStableValue(cleanupReturn.argument, context);
-	if (!cleanupFunction || !isFunctionLike$2(cleanupFunction) || cleanupFunction.async) return false;
+	if (!cleanupFunction || !isFunctionLike$1(cleanupFunction) || cleanupFunction.async) return false;
 	let didInvalidateGuard = false;
 	walkAst(cleanupFunction.body, (child) => {
 		if (didInvalidateGuard) return false;
-		if (child !== cleanupFunction.body && isFunctionLike$2(child)) return false;
+		if (child !== cleanupFunction.body && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "AssignmentExpression") && child.operator === "=" && resolveExpressionKey(child.left, context) === guardState.key && readStaticBoolean(child.right) === guardState.value && context.cfg.isUnconditionalFromEntry(child)) {
 			didInvalidateGuard = true;
 			return false;
@@ -12437,11 +12438,11 @@ const cleanupReturnInvalidatesGuard = (cleanupReturn, guardState, context) => {
 };
 const deferredUsageWritesGuardBeforeUsage = (callback, usageNode, guardState, context) => {
 	const usageStart = getRangeStart(usageNode);
-	if (!isFunctionLike$2(callback) || usageStart === null) return true;
+	if (!isFunctionLike$1(callback) || usageStart === null) return true;
 	let didWriteGuard = false;
 	walkAst(callback.body, (child) => {
 		if (didWriteGuard) return false;
-		if (child !== callback.body && isFunctionLike$2(child)) return false;
+		if (child !== callback.body && isFunctionLike$1(child)) return false;
 		const childStart = getRangeStart(child);
 		if (childStart === null || childStart >= usageStart) return;
 		const writtenExpression = isNodeOfType(child, "AssignmentExpression") ? child.left : isNodeOfType(child, "UpdateExpression") ? child.argument : null;
@@ -12494,7 +12495,7 @@ const effectHasCleanupForUsage = (callback, usage, context) => {
 			matchingCleanupReturns.push(child);
 			return;
 		}
-		if (!cleanupFunction || !isFunctionLike$2(cleanupFunction)) return;
+		if (!cleanupFunction || !isFunctionLike$1(cleanupFunction)) return;
 		if (doesCleanupFunctionReleaseUsage(cleanupFunction, usage, context)) matchingCleanupReturns.push(child);
 	});
 	if (hasGuardedDeferredCleanup(callback, usage, matchingCleanupReturns, context)) return true;
@@ -12664,19 +12665,19 @@ const fileContainsReleaseForUsage = (usage, context) => {
 };
 const resolveRefOwnedCleanupFunction = (expression, context) => {
 	const resolvedExpression = resolveStableValue(expression, context);
-	if (isFunctionLike$2(resolvedExpression)) return resolvedExpression;
+	if (isFunctionLike$1(resolvedExpression)) return resolvedExpression;
 	if (!isNodeOfType(resolvedExpression, "CallExpression") || !isReactApiCall(resolvedExpression, "useCallback", context.scopes)) return null;
 	return getEffectCallback(resolvedExpression);
 };
 const findRefOwnedHandlerStorage = (retainedFunction, usage, context) => {
-	if (!isFunctionLike$2(retainedFunction) || usage.kind !== "subscribe" || usage.registrationVerbName !== "addEventListener" || usage.handlerKey === null || !usage.receiverKey?.startsWith("global:") || !usage.eventKey?.startsWith("literal:")) return null;
+	if (!isFunctionLike$1(retainedFunction) || usage.kind !== "subscribe" || usage.registrationVerbName !== "addEventListener" || usage.handlerKey === null || !usage.receiverKey?.startsWith("global:") || !usage.eventKey?.startsWith("literal:")) return null;
 	const usageStart = getRangeStart(usage.node);
 	const functionCfg = context.cfg.cfgFor(retainedFunction);
 	const usageBlock = functionCfg?.blockOf(usage.node);
 	if (usageStart === null || !functionCfg || !usageBlock) return null;
 	const matchingStorage = [];
 	walkAst(retainedFunction.body, (child) => {
-		if (child !== retainedFunction.body && isFunctionLike$2(child)) return false;
+		if (child !== retainedFunction.body && isFunctionLike$1(child)) return false;
 		if (!isNodeOfType(child, "AssignmentExpression") || child.operator !== "=") return;
 		const assignmentStart = getRangeStart(child);
 		const refCurrentExpression = stripParenExpression(child.left);
@@ -12733,17 +12734,17 @@ const doMatchingNodesCoverEveryPathBeforeUsage = (usageNode, matchingNodes, owne
 	return true;
 };
 const retainedFunctionReleasesPreviousRefOwnedUsage = (retainedFunction, cleanupFunction, storageNode, context) => {
-	if (!isFunctionLike$2(retainedFunction)) return false;
+	if (!isFunctionLike$1(retainedFunction)) return false;
 	const retainedFunctionBody = retainedFunction.body;
 	const cleanupCalls = [];
 	walkAst(retainedFunctionBody, (child) => {
-		if (child !== retainedFunctionBody && isFunctionLike$2(child)) return false;
+		if (child !== retainedFunctionBody && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "CallExpression") && resolveRefOwnedCleanupFunction(child.callee, context) === cleanupFunction) cleanupCalls.push(child);
 	});
 	return doMatchingNodesCoverEveryPathBeforeUsage(storageNode, cleanupCalls, retainedFunction, context);
 };
 const isDirectRefOwnedRelease = (releaseNode, cleanupFunction, usage, storedHandlerKey, refCurrentKey, context) => {
-	if (!isFunctionLike$2(cleanupFunction)) return false;
+	if (!isFunctionLike$1(cleanupFunction)) return false;
 	const releaseCall = isNodeOfType(releaseNode, "ChainExpression") ? releaseNode.expression : releaseNode;
 	if (!isNodeOfType(releaseCall, "CallExpression") || !isNodeOfType(releaseCall.callee, "MemberExpression") || releaseCall.callee.computed || !isNodeOfType(releaseCall.callee.property, "Identifier") || releaseCall.callee.property.name !== "removeEventListener" || !isNodeOfType(usage.node, "CallExpression") || usage.node.arguments?.[2] !== void 0 || releaseCall.arguments?.[2] !== void 0) return false;
 	const releaseStatement = findTransparentExpressionRoot(releaseNode).parent;
@@ -12763,13 +12764,13 @@ const isRefPresenceGuardedEarlyReturn = (returnStatement, refCurrentKey, context
 	return isNodeOfType(guardTest, "UnaryExpression") && guardTest.operator === "!" && resolveExpressionKey(guardTest.argument, context) === refCurrentKey;
 };
 const hasUnprovenReturnBeforeRefOwnedRelease = (cleanupFunction, releaseNode, refCurrentKey, context) => {
-	if (!isFunctionLike$2(cleanupFunction)) return true;
+	if (!isFunctionLike$1(cleanupFunction)) return true;
 	const releaseStart = getRangeStart(releaseNode);
 	if (releaseStart === null) return true;
 	let hasUnprovenEarlyReturn = false;
 	walkAst(cleanupFunction.body, (child) => {
 		if (hasUnprovenEarlyReturn) return false;
-		if (child !== cleanupFunction.body && isFunctionLike$2(child)) return false;
+		if (child !== cleanupFunction.body && isFunctionLike$1(child)) return false;
 		if (!isNodeOfType(child, "ReturnStatement")) return;
 		const returnStart = getRangeStart(child);
 		if ((returnStart === null || returnStart < releaseStart) && !isRefPresenceGuardedEarlyReturn(child, refCurrentKey, context)) {
@@ -12780,14 +12781,14 @@ const hasUnprovenReturnBeforeRefOwnedRelease = (cleanupFunction, releaseNode, re
 	return hasUnprovenEarlyReturn;
 };
 const cleanupFunctionReleasesRefOwnedUsage = (cleanupFunction, componentFunction, retainedFunction, usage, context) => {
-	if (!isFunctionLike$2(cleanupFunction) || !isFunctionLike$2(componentFunction) || cleanupFunction.async || cleanupFunction.generator) return false;
+	if (!isFunctionLike$1(cleanupFunction) || !isFunctionLike$1(componentFunction) || cleanupFunction.async || cleanupFunction.generator) return false;
 	const storage = findRefOwnedHandlerStorage(retainedFunction, usage, context);
 	if (!storage) return false;
 	if (!retainedFunctionReleasesPreviousRefOwnedUsage(retainedFunction, cleanupFunction, storage.assignmentNode, context)) return false;
 	let releaseNode = null;
 	walkAst(cleanupFunction.body, (child) => {
 		if (releaseNode) return false;
-		if (child !== cleanupFunction.body && isFunctionLike$2(child)) return false;
+		if (child !== cleanupFunction.body && isFunctionLike$1(child)) return false;
 		if (isDirectRefOwnedRelease(child, cleanupFunction, usage, storage.handlerKey, storage.refCurrentKey, context)) {
 			releaseNode = child;
 			return false;
@@ -12844,7 +12845,7 @@ const effectReturnsRefOwnedCleanup = (effectCallback, componentFunction, retaine
 		const cleanupFunction = resolveRefOwnedCleanupFunction(returnedValue, context);
 		return Boolean(cleanupFunction && cleanupFunctionReleasesRefOwnedUsage(cleanupFunction, componentFunction, retainedFunction, usage, context));
 	};
-	if (!isFunctionLike$2(effectCallback)) return false;
+	if (!isFunctionLike$1(effectCallback)) return false;
 	if (!isNodeOfType(effectCallback.body, "BlockStatement")) return matchesReturnedCleanup(stripParenExpression(effectCallback.body));
 	const matchingReturns = [];
 	walkInsideStatementBlocks(effectCallback.body, (child) => {
@@ -12854,7 +12855,7 @@ const effectReturnsRefOwnedCleanup = (effectCallback, componentFunction, retaine
 };
 const hasGuaranteedRefOwnedUnmountCleanup = (retainedFunction, usage, context) => {
 	const componentFunction = findEnclosingFunction$1(retainedFunction);
-	if (!componentFunction || !isFunctionLike$2(componentFunction)) return false;
+	if (!componentFunction || !isFunctionLike$1(componentFunction)) return false;
 	let didFindCleanupEffect = false;
 	walkAst(componentFunction.body, (child) => {
 		if (didFindCleanupEffect) return false;
@@ -12903,7 +12904,7 @@ const doesResourceResultEscape = (resourceNode, allowConciseReturnEscape) => {
 	return false;
 };
 const findRetainedFunctionLeak = (retainedFunction, context) => {
-	if (!isFunctionLike$2(retainedFunction)) return null;
+	if (!isFunctionLike$1(retainedFunction)) return null;
 	const body = retainedFunction.body;
 	if (!body) return null;
 	let leak = null;
@@ -12912,7 +12913,7 @@ const findRetainedFunctionLeak = (retainedFunction, context) => {
 	const hasReleaseForUsage = (usage) => isExternalStoreSubscribeFunction ? effectHasCleanupForUsage(retainedFunction, usage, context) : fileContainsReleaseForUsage(usage, context) || hasGuaranteedRefOwnedUnmountCleanup(retainedFunction, usage, context);
 	walkAst(body, (child) => {
 		if (leak !== null) return false;
-		if (isFunctionLike$2(child)) return false;
+		if (isFunctionLike$1(child)) return false;
 		if (isSocketConstruction(child) && !doesResourceResultEscape(child, false)) {
 			const socketUsage = {
 				kind: "socket",
@@ -12973,7 +12974,7 @@ const isDirectJsxEventHandlerValue = (expression) => {
 	return isNodeOfType(expressionContainer, "JSXExpressionContainer") && expressionContainer.expression === expressionRoot && isEventHandlerAttribute(expressionContainer.parent);
 };
 const isInlineRetainedHandlerFunction = (functionNode, context) => {
-	if (!isFunctionLike$2(functionNode)) return false;
+	if (!isFunctionLike$1(functionNode)) return false;
 	const functionRoot = findTransparentExpressionRoot(functionNode);
 	const callbackCall = functionRoot.parent;
 	if (isNodeOfType(callbackCall, "CallExpression") && callbackCall.arguments?.[0] === functionRoot && isHookCall$2(callbackCall, "useCallback") && isDirectJsxEventHandlerValue(callbackCall)) return true;
@@ -13166,7 +13167,7 @@ const recordReference = (state, identifier, flag) => {
 };
 const isFunctionBodyBlock = (block) => {
 	if (!block.parent) return false;
-	return isFunctionLike$2(block.parent);
+	return isFunctionLike$1(block.parent);
 };
 const isCatchClauseBlock = (block) => block.parent !== null && block.parent !== void 0 && block.parent.type === "CatchClause";
 const handleVariableDeclaration = (declaration, state) => {
@@ -13321,7 +13322,7 @@ const walkParameterReferences = (pattern, state) => {
 	if (isNodeOfType(pattern, "RestElement")) walkParameterReferences(pattern.argument, state);
 };
 const walk = (node, state) => {
-	if (isFunctionLike$2(node)) {
+	if (isFunctionLike$1(node)) {
 		if (isNodeOfType(node, "FunctionDeclaration") && node.id) handleFunctionDeclaration(node, state);
 		const functionParams = node.params ?? [];
 		for (const param of functionParams) {
@@ -13555,7 +13556,7 @@ const computeClosureCaptures = (functionNode, scopes) => {
 	const out = [];
 	const seen = /* @__PURE__ */ new Set();
 	walkAst(functionNode, (node) => {
-		if (node !== functionNode && isFunctionLike$2(node)) {
+		if (node !== functionNode && isFunctionLike$1(node)) {
 			const innerCaptures = closureCaptures(node, scopes);
 			for (const reference of innerCaptures) if (reference.resolvedSymbol && !isDescendantScope(reference.resolvedSymbol.scope, functionScope)) {
 				if (!seen.has(reference.id)) {
@@ -13591,6 +13592,768 @@ const closureCaptures = (functionNode, scopes) => {
 	return computedCaptures;
 };
 //#endregion
+//#region src/plugin/semantic/control-flow-graph.ts
+let nextBlockId = 0;
+const createBlock = (builder) => {
+	const block = {
+		id: nextBlockId++,
+		nodes: [],
+		successors: [],
+		predecessors: []
+	};
+	builder.blocks.push(block);
+	return block;
+};
+const addEdge = (from, to, kind) => {
+	const edge = {
+		from,
+		to,
+		kind
+	};
+	from.successors.push(edge);
+	to.predecessors.push(edge);
+};
+const appendNode = (builder, block, node) => {
+	block.nodes.push(node);
+	if (!builder.nodeBlock.has(node)) builder.nodeBlock.set(node, block);
+};
+const mapDescendantsToBlock = (builder, node, block) => {
+	builder.nodeBlock.set(node, block);
+	if (isFunctionLike$1(node)) {
+		builder.nestedFunctions.push(node);
+		return;
+	}
+	const record = node;
+	for (const key of Object.keys(record)) {
+		if (key === "parent") continue;
+		const child = record[key];
+		if (Array.isArray(child)) {
+			for (const item of child) if (isAstNode(item)) mapDescendantsToBlock(builder, item, block);
+		} else if (isAstNode(child)) mapDescendantsToBlock(builder, child, block);
+	}
+};
+const hasInternalControlFlow = (node) => {
+	switch (node.type) {
+		case "IfStatement":
+		case "WhileStatement":
+		case "DoWhileStatement":
+		case "ForStatement":
+		case "ForInStatement":
+		case "ForOfStatement":
+		case "SwitchStatement":
+		case "TryStatement":
+		case "ReturnStatement":
+		case "ThrowStatement":
+		case "BreakStatement":
+		case "ContinueStatement":
+		case "BlockStatement":
+		case "LabeledStatement": return true;
+		default: return false;
+	}
+};
+const findLabel = (builder, name) => {
+	if (name === null) {
+		if (builder.loopStack.length > 0) {
+			const top = builder.loopStack[builder.loopStack.length - 1];
+			return {
+				merge: top.merge,
+				header: top.header
+			};
+		}
+		if (builder.switchStack.length > 0) return {
+			merge: builder.switchStack[builder.switchStack.length - 1].merge,
+			header: null
+		};
+		return null;
+	}
+	for (let i = builder.labelStack.length - 1; i >= 0; i--) {
+		const entry = builder.labelStack[i];
+		if (entry.label === name) return {
+			merge: entry.merge,
+			header: entry.header
+		};
+	}
+	return null;
+};
+const buildStatements = (builder, statements, current) => {
+	let cursor = current;
+	for (const statement of statements) cursor = buildStatement(builder, statement, cursor);
+	return cursor;
+};
+const buildStatement = (builder, statement, current) => {
+	builder.nodeBlock.set(statement, current);
+	if (!hasInternalControlFlow(statement)) {
+		appendNode(builder, current, statement);
+		mapDescendantsToBlock(builder, statement, current);
+		return current;
+	}
+	if (isNodeOfType(statement, "BlockStatement")) return buildStatements(builder, statement.body, current);
+	if (isNodeOfType(statement, "LabeledStatement")) {
+		const merge = createBlock(builder);
+		const labelEntry = {
+			label: statement.label.name,
+			merge,
+			header: null
+		};
+		builder.labelStack.push(labelEntry);
+		const body = statement.body;
+		const end = buildStatement(builder, body, current);
+		builder.labelStack.pop();
+		addEdge(end, merge, "uncond");
+		return merge;
+	}
+	if (isNodeOfType(statement, "ReturnStatement")) {
+		if (statement.argument) mapDescendantsToBlock(builder, statement.argument, current);
+		addEdge(current, builder.exit, "uncond");
+		return createBlock(builder);
+	}
+	if (isNodeOfType(statement, "ThrowStatement")) {
+		if (statement.argument) mapDescendantsToBlock(builder, statement.argument, current);
+		const top = builder.tryStack[builder.tryStack.length - 1];
+		if (top?.catch) addEdge(current, top.catch, "uncond");
+		else if (top?.finally) addEdge(current, top.finally, "uncond");
+		else addEdge(current, builder.exit, "throw");
+		return createBlock(builder);
+	}
+	if (isNodeOfType(statement, "BreakStatement")) {
+		const target = findLabel(builder, statement.label ? statement.label.name : null);
+		if (target) addEdge(current, target.merge, "uncond");
+		else addEdge(current, builder.exit, "uncond");
+		return createBlock(builder);
+	}
+	if (isNodeOfType(statement, "ContinueStatement")) {
+		const target = findLabel(builder, statement.label ? statement.label.name : null);
+		if (target?.header) addEdge(current, target.header, "uncond");
+		return createBlock(builder);
+	}
+	if (isNodeOfType(statement, "IfStatement")) {
+		mapDescendantsToBlock(builder, statement.test, current);
+		const thenBlock = createBlock(builder);
+		const merge = createBlock(builder);
+		addEdge(current, thenBlock, "cond");
+		addEdge(buildStatement(builder, statement.consequent, thenBlock), merge, "uncond");
+		if (statement.alternate) {
+			const elseBlock = createBlock(builder);
+			addEdge(current, elseBlock, "cond");
+			addEdge(buildStatement(builder, statement.alternate, elseBlock), merge, "uncond");
+		} else addEdge(current, merge, "cond");
+		return merge;
+	}
+	if (isNodeOfType(statement, "WhileStatement") || isNodeOfType(statement, "DoWhileStatement")) {
+		const isDoWhile = isNodeOfType(statement, "DoWhileStatement");
+		mapDescendantsToBlock(builder, statement.test, current);
+		const header = createBlock(builder);
+		const body = createBlock(builder);
+		const merge = createBlock(builder);
+		if (isDoWhile) addEdge(current, body, "uncond");
+		else {
+			addEdge(current, header, "uncond");
+			addEdge(header, body, "cond");
+			addEdge(header, merge, "cond");
+		}
+		builder.loopStack.push({
+			header,
+			merge,
+			label: null
+		});
+		const bodyEnd = buildStatement(builder, statement.body, body);
+		builder.loopStack.pop();
+		if (isDoWhile) {
+			addEdge(bodyEnd, header, "uncond");
+			addEdge(header, body, "cond");
+			addEdge(header, merge, "cond");
+		} else addEdge(bodyEnd, header, "uncond");
+		return merge;
+	}
+	if (isNodeOfType(statement, "ForStatement")) {
+		if (statement.init) mapDescendantsToBlock(builder, statement.init, current);
+		if (statement.test) mapDescendantsToBlock(builder, statement.test, current);
+		const header = createBlock(builder);
+		const body = createBlock(builder);
+		const merge = createBlock(builder);
+		addEdge(current, header, "uncond");
+		addEdge(header, body, "cond");
+		addEdge(header, merge, "cond");
+		builder.loopStack.push({
+			header,
+			merge,
+			label: null
+		});
+		const bodyEnd = buildStatement(builder, statement.body, body);
+		builder.loopStack.pop();
+		if (statement.update) mapDescendantsToBlock(builder, statement.update, header);
+		addEdge(bodyEnd, header, "uncond");
+		return merge;
+	}
+	if (isNodeOfType(statement, "ForInStatement") || isNodeOfType(statement, "ForOfStatement")) {
+		mapDescendantsToBlock(builder, statement.right, current);
+		mapDescendantsToBlock(builder, statement.left, current);
+		const header = createBlock(builder);
+		const body = createBlock(builder);
+		const merge = createBlock(builder);
+		addEdge(current, header, "uncond");
+		addEdge(header, body, "cond");
+		addEdge(header, merge, "cond");
+		builder.loopStack.push({
+			header,
+			merge,
+			label: null
+		});
+		const bodyEnd = buildStatement(builder, statement.body, body);
+		builder.loopStack.pop();
+		addEdge(bodyEnd, header, "uncond");
+		return merge;
+	}
+	if (isNodeOfType(statement, "SwitchStatement")) {
+		mapDescendantsToBlock(builder, statement.discriminant, current);
+		const merge = createBlock(builder);
+		builder.switchStack.push({
+			merge,
+			label: null
+		});
+		let previousCaseEnd = null;
+		let hasDefault = false;
+		for (const switchCase of statement.cases) {
+			const caseBlock = createBlock(builder);
+			addEdge(current, caseBlock, "cond");
+			if (previousCaseEnd) addEdge(previousCaseEnd, caseBlock, "uncond");
+			previousCaseEnd = buildStatements(builder, switchCase.consequent, caseBlock);
+			if (switchCase.test === null) hasDefault = true;
+		}
+		builder.switchStack.pop();
+		if (previousCaseEnd) addEdge(previousCaseEnd, merge, "uncond");
+		if (!hasDefault) addEdge(current, merge, "cond");
+		return merge;
+	}
+	if (isNodeOfType(statement, "TryStatement")) {
+		const tryBlock = createBlock(builder);
+		const merge = createBlock(builder);
+		let catchBlock = null;
+		let finallyBlock = null;
+		if (statement.handler) catchBlock = createBlock(builder);
+		if (statement.finalizer) finallyBlock = createBlock(builder);
+		addEdge(current, tryBlock, "uncond");
+		builder.tryStack.push({
+			catch: catchBlock,
+			finally: finallyBlock
+		});
+		const tryEnd = buildStatements(builder, statement.block.body, tryBlock);
+		builder.tryStack.pop();
+		if (catchBlock) addEdge(tryBlock, catchBlock, "cond");
+		if (statement.handler && catchBlock) {
+			const handlerBody = statement.handler.body;
+			const catchEnd = buildStatement(builder, handlerBody, catchBlock);
+			if (finallyBlock) addEdge(catchEnd, finallyBlock, "uncond");
+			else addEdge(catchEnd, merge, "uncond");
+		}
+		if (finallyBlock && statement.finalizer) {
+			addEdge(tryEnd, finallyBlock, "uncond");
+			addEdge(buildStatements(builder, statement.finalizer.body, finallyBlock), merge, "uncond");
+		} else addEdge(tryEnd, merge, "uncond");
+		return merge;
+	}
+	appendNode(builder, current, statement);
+	mapDescendantsToBlock(builder, statement, current);
+	return current;
+};
+const buildFunctionCfg = (functionNode, body, nestedFunctionSink) => {
+	const builder = {
+		blocks: [],
+		entry: null,
+		exit: null,
+		nestedFunctions: nestedFunctionSink,
+		nodeBlock: /* @__PURE__ */ new Map(),
+		loopStack: [],
+		switchStack: [],
+		tryStack: [],
+		labelStack: []
+	};
+	const entry = createBlock(builder);
+	const exit = createBlock(builder);
+	builder.entry = entry;
+	builder.exit = exit;
+	let bodyEnd;
+	if (isNodeOfType(body, "BlockStatement")) bodyEnd = buildStatements(builder, body.body, entry);
+	else {
+		mapDescendantsToBlock(builder, body, entry);
+		bodyEnd = entry;
+	}
+	addEdge(bodyEnd, exit, "uncond");
+	return {
+		owner: functionNode,
+		entry,
+		exit,
+		blocks: builder.blocks,
+		blockOf: (node) => builder.nodeBlock.get(node) ?? null
+	};
+};
+const computeUnconditionalSet = (cfg) => {
+	const reachableFromEntry = (excluded) => {
+		const visited = /* @__PURE__ */ new Set();
+		const queue = [];
+		if (cfg.entry !== excluded) queue.push(cfg.entry);
+		while (queue.length > 0) {
+			const block = queue.shift();
+			if (visited.has(block)) continue;
+			visited.add(block);
+			for (const edge of block.successors) {
+				if (edge.kind === "throw") continue;
+				if (edge.to === excluded) continue;
+				queue.push(edge.to);
+			}
+		}
+		return visited;
+	};
+	const reachableFromEntryFull = reachableFromEntry(null);
+	const unconditional = /* @__PURE__ */ new Set();
+	unconditional.add(cfg.entry);
+	unconditional.add(cfg.exit);
+	for (const block of cfg.blocks) {
+		if (unconditional.has(block)) continue;
+		if (!reachableFromEntryFull.has(block)) {
+			unconditional.add(block);
+			continue;
+		}
+		if (!reachableFromEntry(block).has(cfg.exit)) unconditional.add(block);
+	}
+	return unconditional;
+};
+const analyzeControlFlow = (program) => {
+	nextBlockId = 0;
+	const functionCfgs = /* @__PURE__ */ new Map();
+	const pendingFunctions = [];
+	const buildFor = (functionNode, body) => {
+		const cfg = buildFunctionCfg(functionNode, body, pendingFunctions);
+		functionCfgs.set(functionNode, {
+			cfg,
+			unconditionalSet: computeUnconditionalSet(cfg)
+		});
+	};
+	if (isNodeOfType(program, "Program")) buildFor(program, {
+		type: "BlockStatement",
+		body: program.body
+	});
+	for (let functionIndex = 0; functionIndex < pendingFunctions.length; functionIndex += 1) {
+		const functionNode = pendingFunctions[functionIndex];
+		if (!isFunctionLike$1(functionNode) || !functionNode.body || functionCfgs.has(functionNode)) continue;
+		buildFor(functionNode, functionNode.body);
+	}
+	const getFunctionEntry = (functionNode) => {
+		const existingEntry = functionCfgs.get(functionNode);
+		if (existingEntry) return existingEntry;
+		if (!isFunctionLike$1(functionNode) || !functionNode.body) return null;
+		buildFor(functionNode, functionNode.body);
+		return functionCfgs.get(functionNode) ?? null;
+	};
+	const enclosingFunction = (node) => {
+		let current = node;
+		while (current) {
+			if (isFunctionLike$1(current)) return current;
+			if (isNodeOfType(current, "Program")) return current;
+			current = current.parent ?? null;
+		}
+		return null;
+	};
+	const cfgFor = (functionLike) => {
+		return getFunctionEntry(functionLike)?.cfg ?? null;
+	};
+	const isUnconditionalFromEntry = (node) => {
+		const owner = enclosingFunction(node);
+		if (!owner) return true;
+		const entry = getFunctionEntry(owner);
+		if (!entry) return true;
+		const block = entry.cfg.blockOf(node);
+		if (!block) return true;
+		return entry.unconditionalSet.has(block);
+	};
+	return {
+		cfgFor,
+		enclosingFunction,
+		isUnconditionalFromEntry
+	};
+};
+//#endregion
+//#region src/plugin/utils/resolve-fresh-render-value.ts
+const classifyFreshRenderValue = (expression) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "ObjectExpression")) return "object";
+	if (isNodeOfType(candidate, "ArrayExpression")) return "array";
+	if (isNodeOfType(candidate, "ArrowFunctionExpression") || isNodeOfType(candidate, "FunctionExpression")) return "function";
+	if (isNodeOfType(candidate, "JSXElement") || isNodeOfType(candidate, "JSXFragment")) return "JSX";
+	if (isNodeOfType(candidate, "NewExpression")) return "instance";
+	return null;
+};
+const resolveFreshRenderValue = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const directKind = classifyFreshRenderValue(expression);
+	if (directKind) return {
+		bindingName: null,
+		kind: directKind
+	};
+	const candidate = stripParenExpression(expression);
+	if (!isNodeOfType(candidate, "Identifier")) return null;
+	const symbol = scopes.symbolFor(candidate);
+	if (!symbol || symbol.scope.kind === "module" || symbol.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || symbol.references.some((reference) => reference.flag !== "read") || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return null;
+	visitedSymbolIds.add(symbol.id);
+	const resolved = resolveFreshRenderValue(symbol.initializer, scopes, visitedSymbolIds);
+	return resolved ? {
+		bindingName: candidate.name,
+		kind: resolved.kind
+	} : null;
+};
+//#endregion
+//#region src/plugin/utils/find-forwarded-fresh-hook-dependencies.ts
+const DEPENDENCY_HOOK_NAMES = new Set([
+	...HOOKS_WITH_DEPS,
+	"useImperativeHandle",
+	"useInsertionEffect"
+]);
+const crossFileScopes = /* @__PURE__ */ new WeakMap();
+const crossFileControlFlow = /* @__PURE__ */ new WeakMap();
+const forwardedFreshDependencyCache = /* @__PURE__ */ new WeakMap();
+const getCrossFileScopes = (resolved) => {
+	const cached = crossFileScopes.get(resolved.programNode);
+	if (cached) return cached;
+	const scopes = analyzeScopes(resolved.programNode);
+	crossFileScopes.set(resolved.programNode, scopes);
+	return scopes;
+};
+const getCrossFileControlFlow = (resolved) => {
+	const cached = crossFileControlFlow.get(resolved.programNode);
+	if (cached) return cached;
+	const cfg = analyzeControlFlow(resolved.programNode);
+	crossFileControlFlow.set(resolved.programNode, cfg);
+	return cfg;
+};
+const isNodeReachable = (node, cfg) => {
+	const owner = cfg.enclosingFunction(node);
+	if (!owner) return true;
+	const functionCfg = cfg.cfgFor(owner);
+	if (!functionCfg) return true;
+	const targetBlock = functionCfg.blockOf(node);
+	if (!targetBlock) return true;
+	const visitedBlocks = new Set([functionCfg.entry]);
+	const pendingBlocks = [functionCfg.entry];
+	while (pendingBlocks.length > 0) {
+		const currentBlock = pendingBlocks.pop();
+		if (!currentBlock) break;
+		if (currentBlock === targetBlock) return true;
+		for (const edge of currentBlock.successors) {
+			if (visitedBlocks.has(edge.to)) continue;
+			visitedBlocks.add(edge.to);
+			pendingBlocks.push(edge.to);
+		}
+	}
+	return false;
+};
+const isCustomHookFunction = (functionNode, fallbackName) => {
+	const displayName = componentOrHookDisplayNameForFunction(functionNode) ?? fallbackName ?? "";
+	return /^use[A-Z0-9]/.test(displayName);
+};
+const getImportedHookBinding = (callee, scopes) => {
+	if (!isNodeOfType(callee, "Identifier")) return null;
+	const importedSymbol = resolveConstIdentifierAlias(callee, scopes);
+	if (importedSymbol?.kind !== "import" || !importedSymbol.initializer) return null;
+	const importDeclaration = importedSymbol.initializer.parent;
+	if (!importDeclaration || !isNodeOfType(importDeclaration, "ImportDeclaration")) return null;
+	const source = importDeclaration.source?.value;
+	if (typeof source !== "string") return null;
+	const exportedName = resolveImportedExportName(importedSymbol.initializer);
+	return exportedName ? {
+		exportedName,
+		source
+	} : null;
+};
+const resolveImportedHookFunction = (callee, scopes, currentFilename) => {
+	if (!currentFilename) return null;
+	const importedBinding = getImportedHookBinding(callee, scopes);
+	if (!importedBinding) return null;
+	const resolved = resolveCrossFileFunctionExportWithFilePath(currentFilename, importedBinding.source, importedBinding.exportedName);
+	if (!resolved || !isCustomHookFunction(resolved.functionNode, importedBinding.exportedName)) return null;
+	return {
+		cfg: getCrossFileControlFlow(resolved),
+		filePath: resolved.filePath,
+		functionNode: resolved.functionNode,
+		programNode: resolved.programNode,
+		scopes: getCrossFileScopes(resolved)
+	};
+};
+const dependencyIndexForReactHookReference = (expression, scopes, dependencyHookNames, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Identifier")) {
+		const symbol = resolveConstIdentifierAlias(candidate, scopes);
+		if (!symbol || visitedSymbolIds.has(symbol.id)) return null;
+		if (isImportedFromReact(symbol)) {
+			const importedName = getImportedName(symbol.declarationNode);
+			if (!importedName || !dependencyHookNames.has(importedName)) return null;
+			return importedName === "useImperativeHandle" ? 2 : 1;
+		}
+		if (symbol.kind !== "const" || !symbol.initializer || isSymbolMutated(symbol)) return null;
+		visitedSymbolIds.add(symbol.id);
+		return dependencyIndexForReactHookReference(symbol.initializer, scopes, dependencyHookNames, visitedSymbolIds);
+	}
+	if (isNodeOfType(candidate, "MemberExpression")) {
+		const hookName = getStaticPropertyName(candidate);
+		if (!hookName || !dependencyHookNames.has(hookName)) return null;
+		const receiver = stripParenExpression(candidate.object);
+		if (!isNodeOfType(receiver, "Identifier") || !isReactNamespaceImport(receiver, scopes)) return null;
+		return hookName === "useImperativeHandle" ? 2 : 1;
+	}
+	if (!isNodeOfType(candidate, "ConditionalExpression")) return null;
+	const consequentIndex = dependencyIndexForReactHookReference(candidate.consequent, scopes, dependencyHookNames, new Set(visitedSymbolIds));
+	const alternateIndex = dependencyIndexForReactHookReference(candidate.alternate, scopes, dependencyHookNames, new Set(visitedSymbolIds));
+	return consequentIndex !== null && consequentIndex === alternateIndex ? consequentIndex : null;
+};
+const getImportedReactDependencyIndex = (callExpression, scopes, currentFilename, dependencyHookNames) => {
+	if (!currentFilename) return null;
+	const importedBinding = getImportedHookBinding(stripParenExpression(callExpression.callee), scopes);
+	if (!importedBinding) return null;
+	const resolved = resolveCrossFileValueExportWithFilePath(currentFilename, importedBinding.source, importedBinding.exportedName);
+	if (!resolved) return null;
+	return dependencyIndexForReactHookReference(resolved.exportedNode, getCrossFileScopes(resolved), dependencyHookNames);
+};
+const resolveHookFunction = (callExpression, scopes, cfg, currentFilename) => {
+	const callee = stripParenExpression(callExpression.callee);
+	const localFunction = resolveExactLocalFunction(callee, scopes);
+	if (localFunction && isCustomHookFunction(localFunction)) {
+		const programNode = findProgramRoot(localFunction);
+		if (!programNode) return null;
+		return {
+			cfg,
+			filePath: currentFilename,
+			functionNode: localFunction,
+			programNode,
+			scopes
+		};
+	}
+	return resolveImportedHookFunction(callee, scopes, currentFilename);
+};
+const collectParameterBindings = (functionNode) => {
+	if (!isFunctionLike$1(functionNode)) return [];
+	const bindings = [];
+	for (const [parameterIndex, rawParameter] of (functionNode.params ?? []).entries()) {
+		const parameter = stripParenExpression(rawParameter);
+		if (isNodeOfType(parameter, "Identifier")) {
+			bindings.push({
+				bindingIdentifier: parameter,
+				defaultExpression: null,
+				parameterIndex,
+				propertyName: null
+			});
+			continue;
+		}
+		if (isNodeOfType(parameter, "AssignmentPattern") && isNodeOfType(parameter.left, "Identifier")) {
+			bindings.push({
+				bindingIdentifier: parameter.left,
+				defaultExpression: parameter.right,
+				parameterIndex,
+				propertyName: null
+			});
+			continue;
+		}
+		if (!isNodeOfType(parameter, "ObjectPattern")) continue;
+		for (const property of parameter.properties ?? []) {
+			if (!isNodeOfType(property, "Property")) continue;
+			const propertyName = getStaticPropertyKeyName(property, { allowComputedString: true });
+			if (!propertyName) continue;
+			const value = stripParenExpression(property.value);
+			if (isNodeOfType(value, "Identifier")) bindings.push({
+				bindingIdentifier: value,
+				defaultExpression: null,
+				parameterIndex,
+				propertyName
+			});
+			else if (isNodeOfType(value, "AssignmentPattern") && isNodeOfType(value.left, "Identifier")) bindings.push({
+				bindingIdentifier: value.left,
+				defaultExpression: value.right,
+				parameterIndex,
+				propertyName
+			});
+		}
+	}
+	return bindings;
+};
+const resolveConstObjectExpression = (expression, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "ObjectExpression")) return candidate;
+	if (!isNodeOfType(candidate, "Identifier")) return null;
+	const symbol = scopes.symbolFor(candidate);
+	if (!symbol || symbol.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || isSymbolMutated(symbol)) return null;
+	visitedSymbolIds.add(symbol.id);
+	return resolveConstObjectExpression(symbol.initializer, scopes, visitedSymbolIds);
+};
+const findObjectPropertyValue = (objectExpression, propertyName) => {
+	for (let propertyIndex = objectExpression.properties.length - 1; propertyIndex >= 0; propertyIndex--) {
+		const property = objectExpression.properties[propertyIndex];
+		if (isNodeOfType(property, "SpreadElement")) return {
+			expression: null,
+			isProvenOmitted: false
+		};
+		if (isNodeOfType(property, "Property") && getStaticPropertyKeyName(property, { allowComputedString: true }) === propertyName) return {
+			expression: property.value,
+			isProvenOmitted: false
+		};
+	}
+	return {
+		expression: null,
+		isProvenOmitted: true
+	};
+};
+const resolveArgumentValue = (callExpression, parameter, callerScopes) => {
+	if ((callExpression.arguments ?? []).slice(0, parameter.parameterIndex + 1).some((argument) => isNodeOfType(argument, "SpreadElement"))) return {
+		expression: null,
+		isProvenOmitted: false
+	};
+	const argument = callExpression.arguments?.[parameter.parameterIndex];
+	if (!argument) return {
+		expression: null,
+		isProvenOmitted: true
+	};
+	if (parameter.propertyName === null) return {
+		expression: argument,
+		isProvenOmitted: false
+	};
+	const objectExpression = resolveConstObjectExpression(argument, callerScopes);
+	if (!objectExpression) return {
+		expression: null,
+		isProvenOmitted: false
+	};
+	return findObjectPropertyValue(objectExpression, parameter.propertyName);
+};
+const isSymbolMutated = (symbol) => {
+	if (symbol.references.some((reference) => reference.flag !== "read")) return true;
+	for (const reference of symbol.references) {
+		let expression = reference.identifier;
+		while (expression.parent && isNodeOfType(expression.parent, "MemberExpression") && expression.parent.object === expression) expression = expression.parent;
+		const parent = expression.parent;
+		if (isNodeOfType(parent, "AssignmentExpression") && parent.left === expression || isNodeOfType(parent, "UpdateExpression") && parent.argument === expression || isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" && parent.argument === expression) return true;
+		if (isNodeOfType(parent, "CallExpression") && parent.callee === expression && isNodeOfType(expression, "MemberExpression")) {
+			const methodName = getStaticPropertyName(expression);
+			if (methodName && (MUTATING_ARRAY_METHODS.has(methodName) || MUTATING_COLLECTION_METHODS.has(methodName))) return true;
+		}
+	}
+	return false;
+};
+const expressionHasTaint = (expression, mode, scopes, taint, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const candidate = stripParenExpression(expression);
+	if (!isNodeOfType(candidate, "Identifier")) return false;
+	const symbol = scopes.symbolFor(candidate);
+	if (!symbol || visitedSymbolIds.has(symbol.id) || isSymbolMutated(symbol)) return false;
+	if ((mode === "value" ? taint.valueSymbolIds : taint.listSymbolIds).has(symbol.id)) return true;
+	if (symbol.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || symbol.declarationNode.id !== symbol.bindingIdentifier) return false;
+	visitedSymbolIds.add(symbol.id);
+	return expressionHasTaint(symbol.initializer, mode, scopes, taint, visitedSymbolIds);
+};
+const dependencyListContainsTaint = (expression, scopes, taint, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	if (expressionHasTaint(expression, "list", scopes, taint)) return true;
+	const candidate = stripParenExpression(expression);
+	if (isNodeOfType(candidate, "Identifier")) {
+		const symbol = scopes.symbolFor(candidate);
+		if (!symbol || visitedSymbolIds.has(symbol.id) || symbol.kind !== "const" || !symbol.initializer || isSymbolMutated(symbol)) return false;
+		visitedSymbolIds.add(symbol.id);
+		return dependencyListContainsTaint(symbol.initializer, scopes, taint, visitedSymbolIds);
+	}
+	if (!isNodeOfType(candidate, "ArrayExpression")) return false;
+	return (candidate.elements ?? []).some((element) => {
+		if (!element) return false;
+		if (isNodeOfType(element, "SpreadElement")) return expressionHasTaint(element.argument, "list", scopes, taint);
+		return expressionHasTaint(element, "value", scopes, taint);
+	});
+};
+const buildForwardedTaint = (callExpression, target, callerScopes, callerTaint) => {
+	const forwardedTaint = {
+		listSymbolIds: /* @__PURE__ */ new Set(),
+		valueSymbolIds: /* @__PURE__ */ new Set()
+	};
+	for (const parameter of collectParameterBindings(target.functionNode)) {
+		const argument = resolveArgumentValue(callExpression, parameter, callerScopes);
+		if (!argument.expression) continue;
+		const targetSymbol = target.scopes.symbolFor(parameter.bindingIdentifier);
+		if (!targetSymbol || isSymbolMutated(targetSymbol)) continue;
+		if (expressionHasTaint(argument.expression, "value", callerScopes, callerTaint)) forwardedTaint.valueSymbolIds.add(targetSymbol.id);
+		if (expressionHasTaint(argument.expression, "list", callerScopes, callerTaint) || dependencyListContainsTaint(argument.expression, callerScopes, callerTaint)) forwardedTaint.listSymbolIds.add(targetSymbol.id);
+	}
+	return forwardedTaint;
+};
+const taintReachesBuiltInDependency = (target, taint, remainingDepth, visitedFunctions, dependencyHookNames) => {
+	if (!isFunctionLike$1(target.functionNode)) return false;
+	const functionNode = target.functionNode;
+	if (remainingDepth < 0 || visitedFunctions.has(functionNode) || [...taint.valueSymbolIds, ...taint.listSymbolIds].some((symbolId) => {
+		const symbol = target.scopes.ownScopeFor(target.functionNode)?.symbols.find((candidate) => candidate.id === symbolId);
+		return symbol ? isSymbolMutated(symbol) : false;
+	})) return false;
+	const nextVisitedFunctions = new Set(visitedFunctions);
+	nextVisitedFunctions.add(functionNode);
+	let didReachDependency = false;
+	walkAst(functionNode.body, (node) => {
+		if (didReachDependency) return false;
+		if (node !== functionNode.body && isFunctionLike$1(node)) return false;
+		if (!isNodeOfType(node, "CallExpression")) return;
+		if (!isNodeReachable(node, target.cfg)) return;
+		if (isReactApiCall(node, dependencyHookNames, target.scopes, { allowGlobalReactNamespace: true })) {
+			const callee = stripParenExpression(node.callee);
+			const dependencyIndex = (isNodeOfType(callee, "Identifier") ? callee.name : isNodeOfType(callee, "MemberExpression") ? getStaticPropertyName(callee) : null) === "useImperativeHandle" ? 2 : 1;
+			const dependencies = node.arguments?.[dependencyIndex];
+			if (dependencies && !isNodeOfType(dependencies, "SpreadElement") && dependencyListContainsTaint(dependencies, target.scopes, taint)) {
+				didReachDependency = true;
+				return false;
+			}
+			return;
+		}
+		const importedDependencyIndex = getImportedReactDependencyIndex(node, target.scopes, target.filePath, dependencyHookNames);
+		if (importedDependencyIndex !== null) {
+			const dependencies = node.arguments?.[importedDependencyIndex];
+			if (dependencies && !isNodeOfType(dependencies, "SpreadElement") && dependencyListContainsTaint(dependencies, target.scopes, taint)) {
+				didReachDependency = true;
+				return false;
+			}
+			return;
+		}
+		if (remainingDepth === 0) return;
+		const nestedTarget = resolveHookFunction(node, target.scopes, target.cfg, target.filePath);
+		if (!nestedTarget) return;
+		const forwardedTaint = buildForwardedTaint(node, nestedTarget, target.scopes, taint);
+		if (forwardedTaint.valueSymbolIds.size === 0 && forwardedTaint.listSymbolIds.size === 0) return;
+		if (taintReachesBuiltInDependency(nestedTarget, forwardedTaint, remainingDepth - 1, nextVisitedFunctions, dependencyHookNames)) {
+			didReachDependency = true;
+			return false;
+		}
+	});
+	return didReachDependency;
+};
+const findForwardedFreshHookDependencies = (callExpression, context, dependencyHookNames = DEPENDENCY_HOOK_NAMES) => {
+	const cacheKey = [...dependencyHookNames].sort().join("\0");
+	const cacheForCall = forwardedFreshDependencyCache.get(callExpression);
+	const cached = cacheForCall?.get(cacheKey);
+	if (cached) return cached;
+	const findings = [];
+	if (cacheForCall) cacheForCall.set(cacheKey, findings);
+	else forwardedFreshDependencyCache.set(callExpression, new Map([[cacheKey, findings]]));
+	if (!findRenderPhaseComponentOrHook(callExpression, context.scopes)) return findings;
+	if (!isNodeReachable(callExpression, context.cfg)) return findings;
+	const target = resolveHookFunction(callExpression, context.scopes, context.cfg, context.filename);
+	if (!target) return findings;
+	for (const parameter of collectParameterBindings(target.functionNode)) {
+		const targetSymbol = target.scopes.symbolFor(parameter.bindingIdentifier);
+		if (!targetSymbol || isSymbolMutated(targetSymbol)) continue;
+		const argument = resolveArgumentValue(callExpression, parameter, context.scopes);
+		const sourceExpression = argument.expression ?? (argument.isProvenOmitted ? parameter.defaultExpression : null);
+		if (!sourceExpression) continue;
+		const freshness = resolveFreshRenderValue(sourceExpression, argument.expression ? context.scopes : target.scopes);
+		if (!freshness) continue;
+		if (!taintReachesBuiltInDependency(target, {
+			listSymbolIds: /* @__PURE__ */ new Set(),
+			valueSymbolIds: new Set([targetSymbol.id])
+		}, 4, /* @__PURE__ */ new Set(), dependencyHookNames)) continue;
+		findings.push({
+			bindingName: freshness.bindingName ?? (isNodeOfType(parameter.bindingIdentifier, "Identifier") ? parameter.bindingIdentifier.name : "dependency"),
+			kind: freshness.kind,
+			origin: argument.expression ? "argument" : "default",
+			reportNode: argument.expression ?? callExpression
+		});
+	}
+	return findings;
+};
+//#endregion
 //#region src/plugin/utils/is-react-hoc-callback-argument.ts
 const reactHocCalleeName = (callee) => {
 	if (isNodeOfType(callee, "Identifier")) return callee.name;
@@ -13605,6 +14368,22 @@ const isReactHocCallbackArgument = (functionNode) => {
 	return calleeName !== null && REACT_HOC_NAMES.has(calleeName);
 };
 //#endregion
+//#region src/plugin/utils/is-outside-all-functions.ts
+const FUNCTION_SCOPE_KINDS = new Set([
+	"function",
+	"arrow-function",
+	"method"
+]);
+const isOutsideAllFunctions = (symbol) => {
+	let scope = symbol.scope;
+	while (scope) {
+		if (FUNCTION_SCOPE_KINDS.has(scope.kind)) return false;
+		if (scope.kind === "module") return true;
+		scope = scope.parent;
+	}
+	return true;
+};
+//#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps-low-level.ts
 /**
 * Lowest-level helpers consumed by both the main `exhaustive-deps`
@@ -13657,25 +14436,6 @@ const getHookName = (callee, scopes) => {
 	if (isNodeOfType(strippedCallee, "MemberExpression") && !strippedCallee.computed && isNodeOfType(strippedCallee.property, "Identifier")) return strippedCallee.property.name;
 	return null;
 };
-const FUNCTION_SCOPE_KINDS = new Set([
-	"function",
-	"arrow-function",
-	"method"
-]);
-/**
-* True for symbols declared at module scope (outside any function
-* scope). Module-scope bindings don't change between renders so they
-* don't need to live in dependency arrays.
-*/
-const isOutsideAllFunctions = (symbol) => {
-	let scope = symbol.scope;
-	while (scope) {
-		if (FUNCTION_SCOPE_KINDS.has(scope.kind)) return false;
-		if (scope.kind === "module") return true;
-		scope = scope.parent ?? null;
-	}
-	return true;
-};
 //#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps-messages.ts
 const buildMissingDepMessage = (hookName, depName) => `\`${hookName}\` can run with a stale \`${depName}\` & show your users old data.`;
@@ -13693,6 +14453,7 @@ const buildComplexDepMessage = (hookName) => `A complex expression in \`${hookNa
 const buildAsyncEffectMessage = (hookName) => `\`${hookName}\` was given an async function, so its cleanup breaks.`;
 const buildUnknownCallbackMessage = (hookName) => `\`${hookName}\`'s callback is defined elsewhere, so dependencies can't be checked and stale values can slip through.`;
 const buildUnstableDepMessage = (hookName, depName) => `\`${depName}\` is rebuilt every render, so \`${hookName}\` runs every time.`;
+const buildForwardedUnstableDepMessage = (depName) => `\`${depName}\` is rebuilt every render and reaches a Hook dependency inside this custom Hook.`;
 const buildSetStateWithoutDepsMessage = (hookName, setterName) => `\`${hookName}\` calls \`${setterName}\` with no dependency array, so it can loop forever & freeze the component.`;
 const buildRefCleanupMessage = (depName) => `Your cleanup may read the wrong node since the ref \`${depName}\` can change before it runs.`;
 const buildAssignmentMessage = (name) => `Assigning to \`${name}\` inside a hook is thrown away after each render, so the next render reads the old value.`;
@@ -14784,6 +15545,10 @@ If the missing value is recreated every render, move it inside the hook or stabi
 		};
 		const isAutoDependenciesHook = (hookName) => settings.experimental_autoDependenciesHooks.includes(hookName);
 		return { CallExpression(node) {
+			for (const finding of findForwardedFreshHookDependencies(node, context, EFFECT_HOOK_NAMES$1)) context.report({
+				node: finding.reportNode,
+				message: buildForwardedUnstableDepMessage(finding.bindingName)
+			});
 			const hookName = getHookName(node.callee, context.scopes);
 			if (!hookName || !isHookOfInterest(hookName, node.callee)) return;
 			if (HOOKS_REQUIRING_DEPS_MATCH.has(hookName) && !isReactApiCall(node, HOOKS_REQUIRING_DEPS_MATCH, context.scopes, {
@@ -16659,7 +17424,7 @@ const classifyReturnedExpression = (expression) => {
 const collectTopLevelReturnExpressions$1 = (block) => {
 	const returns = [];
 	walkAst(block, (child) => {
-		if (isFunctionLike$2(child)) return false;
+		if (isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "ReturnStatement")) returns.push(child.argument);
 	});
 	return returns;
@@ -16684,7 +17449,7 @@ const functionBodyReferencesGetParameter = (fn, getParameterName) => {
 	let found = false;
 	walkAst(body, (child) => {
 		if (found) return false;
-		if (isFunctionLike$2(child) && child !== fn) return false;
+		if (isFunctionLike$1(child) && child !== fn) return false;
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (!isNodeOfType(child.callee, "Identifier")) return;
 		if (child.callee.name === getParameterName) {
@@ -16845,7 +17610,7 @@ const jotaiSelectAtomInRenderBody = defineRule({
 			if (isBindingUsedAsHandler(nearestFunctionLike)) return;
 			let outerCursor = nearestFunctionLike;
 			while (outerCursor) {
-				if (isFunctionLike$2(outerCursor) && containingFunctionIsComponentOrHook(outerCursor)) {
+				if (isFunctionLike$1(outerCursor) && containingFunctionIsComponentOrHook(outerCursor)) {
 					context.report({
 						node,
 						message: "`selectAtom(...)` runs in a component or hook without `useMemo`, so every render makes a new atom & re-subscribes forever, freezing the page for your users. Lift it to module scope, or wrap it in `useMemo(() => selectAtom(...), [deps])`."
@@ -17181,7 +17946,7 @@ const findEnclosingPerIterationBody = (node) => {
 	let current = node.parent;
 	while (current) {
 		if (isNodeOfType(current, "ForStatement") || isNodeOfType(current, "ForInStatement") || isNodeOfType(current, "ForOfStatement") || isNodeOfType(current, "WhileStatement") || isNodeOfType(current, "DoWhileStatement")) return current.body ?? null;
-		if (isFunctionLike$2(current)) {
+		if (isFunctionLike$1(current)) {
 			if (isIteratorCallback$1(current)) return current.body ?? null;
 			return null;
 		}
@@ -17222,7 +17987,7 @@ const scanPerIterationLayoutReads = (body) => {
 	let hasUsedLayoutRead = false;
 	let hasDeliberateForcedReflow = false;
 	walkAst(body, (child) => {
-		const isNestedFunction = child !== body && isFunctionLike$2(child);
+		const isNestedFunction = child !== body && isFunctionLike$1(child);
 		const valueNode = getLayoutReadValueNode(child);
 		if (valueNode) {
 			if (isDiscardedValue(valueNode)) hasDeliberateForcedReflow = true;
@@ -17347,7 +18112,7 @@ const buildMemberAccessKey = (node) => {
 const isNameShadowedByEnclosingFunctionParameter = (node, name, boundary) => {
 	let ancestor = node.parent;
 	while (ancestor && ancestor !== boundary) {
-		if (isFunctionLike$2(ancestor)) {
+		if (isFunctionLike$1(ancestor)) {
 			const parameterNames = /* @__PURE__ */ new Set();
 			for (const parameter of ancestor.params ?? []) collectPatternNames(parameter, parameterNames);
 			if (parameterNames.has(name)) return true;
@@ -17840,7 +18605,7 @@ const isInsideCacheMemo = (node) => {
 	let child = node;
 	let cursor = node.parent ?? null;
 	while (cursor) {
-		if (isFunctionLike$2(cursor)) return false;
+		if (isFunctionLike$1(cursor)) return false;
 		if (isNodeOfType(cursor, "AssignmentExpression") && cursor.right === child) {
 			if (MEMO_ASSIGNMENT_OPERATORS.has(cursor.operator)) return true;
 			if (cursor.operator === "=" && isNodeOfType(cursor.left, "Identifier") && isIdentifierInitializedFromCacheLookup(cursor.left)) return true;
@@ -17859,7 +18624,7 @@ const isDiscardedProbeInsideTry = (node) => {
 	if (!isNodeOfType(statement, "ExpressionStatement")) return false;
 	let child = statement;
 	let cursor = statement.parent ?? null;
-	while (cursor && !isFunctionLike$2(cursor)) {
+	while (cursor && !isFunctionLike$1(cursor)) {
 		if (isNodeOfType(cursor, "TryStatement") && cursor.block === child) return true;
 		child = cursor;
 		cursor = cursor.parent ?? null;
@@ -17875,7 +18640,7 @@ const getFunctionName = (functionNode) => {
 };
 const isUncacheableOptionsMergeUtility = (node) => {
 	const enclosingFunction = findEnclosingFunction$1(node);
-	if (!enclosingFunction || !isFunctionLike$2(enclosingFunction)) return false;
+	if (!enclosingFunction || !isFunctionLike$1(enclosingFunction)) return false;
 	const functionName = getFunctionName(enclosingFunction);
 	if (!functionName || isComponentOrHookName(functionName)) return false;
 	const parameterNames = /* @__PURE__ */ new Set();
@@ -17903,7 +18668,7 @@ const jsHoistIntl = defineRule({
 		let cursor = node.parent ?? null;
 		let inFunctionBody = false;
 		while (cursor) {
-			if (isFunctionLike$2(cursor)) {
+			if (isFunctionLike$1(cursor)) {
 				inFunctionBody = true;
 				const fnParent = cursor.parent;
 				if (fnParent && isNodeOfType(fnParent, "CallExpression") && fnParent.arguments?.[0] === cursor) {
@@ -18250,7 +19015,7 @@ const getLoopBoundNames = (loop) => {
 		if (isNodeOfType(child, "Identifier")) names.add(child.name);
 	});
 	walkAst(loop, (child) => {
-		if (child !== loop && isFunctionLike$2(child)) return false;
+		if (child !== loop && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "VariableDeclarator") && child.id) {
 			walkAst(child.id, (idNode) => {
 				if (isNodeOfType(idNode, "Identifier")) names.add(idNode.name);
@@ -18500,7 +19265,7 @@ const hasDominatingLengthGuard = (callNode, receiverArray, indexedArray) => {
 	let child = callNode;
 	let ancestor = callNode.parent;
 	while (ancestor) {
-		if (isFunctionLike$2(ancestor)) {
+		if (isFunctionLike$1(ancestor)) {
 			const parameterNames = /* @__PURE__ */ new Set();
 			for (const parameter of ancestor.params ?? []) collectPatternNames(parameter, parameterNames);
 			if (comparedRootNames.some((rootName) => parameterNames.has(rootName))) return false;
@@ -18583,7 +19348,7 @@ const findConstInitializer = (identifierName, fromNode) => {
 	let child = fromNode;
 	let ancestor = fromNode.parent;
 	while (ancestor) {
-		if (isFunctionLike$2(ancestor)) {
+		if (isFunctionLike$1(ancestor)) {
 			const parameterNames = /* @__PURE__ */ new Set();
 			for (const parameter of ancestor.params ?? []) collectPatternNames(parameter, parameterNames);
 			if (parameterNames.has(identifierName)) return null;
@@ -18619,7 +19384,7 @@ const PREFIX_INTENT_NAME_PATTERN = /prefix|startswith/i;
 const isInsidePrefixNamedFunction = (node) => {
 	let ancestor = node.parent;
 	while (ancestor) {
-		if (isFunctionLike$2(ancestor)) {
+		if (isFunctionLike$1(ancestor)) {
 			if (isNodeOfType(ancestor, "FunctionDeclaration") && isNodeOfType(ancestor.id, "Identifier") && PREFIX_INTENT_NAME_PATTERN.test(ancestor.id.name)) return true;
 			const holder = ancestor.parent;
 			if (holder && isNodeOfType(holder, "VariableDeclarator") && isNodeOfType(holder.id, "Identifier") && PREFIX_INTENT_NAME_PATTERN.test(holder.id.name)) return true;
@@ -19348,7 +20113,7 @@ const hasWriteBeforeQuery = (body, identifier) => {
 		if (hasEarlierWrite) return false;
 		const childStart = getRangeStart(child);
 		if (childStart !== null && childStart >= queryStart) return false;
-		if (child !== body && isFunctionLike$2(child)) return false;
+		if (child !== body && isFunctionLike$1(child)) return false;
 		const writeTarget = isNodeOfType(child, "AssignmentExpression") ? child.left : isNodeOfType(child, "UpdateExpression") ? child.argument : isNodeOfType(child, "ForInStatement") || isNodeOfType(child, "ForOfStatement") ? child.left : null;
 		if (writeTarget && writeTargetContainsIdentifierBinding(writeTarget, identifier)) {
 			hasEarlierWrite = true;
@@ -19361,7 +20126,7 @@ const isProtectedByRelationalLoopGuard = (identifier) => {
 	let descendant = identifier;
 	let ancestor = identifier.parent;
 	while (ancestor) {
-		if (isFunctionLike$2(ancestor)) return false;
+		if (isFunctionLike$1(ancestor)) return false;
 		if ((isNodeOfType(ancestor, "ForStatement") || isNodeOfType(ancestor, "WhileStatement")) && ancestor.body === descendant && testProvesIdentifierIsNotNaN(ancestor.test, identifier)) return !hasWriteBeforeQuery(ancestor.body, identifier);
 		descendant = ancestor;
 		ancestor = ancestor.parent;
@@ -19405,7 +20170,7 @@ const isKnownUserlandMembershipReceiver = (receiver, methodName) => {
 const findTypeParameter = (reference, typeName) => {
 	let ancestor = reference.parent;
 	while (ancestor) {
-		if (isFunctionLike$2(ancestor) || isNodeOfType(ancestor, "ClassDeclaration") || isNodeOfType(ancestor, "ClassExpression")) {
+		if (isFunctionLike$1(ancestor) || isNodeOfType(ancestor, "ClassDeclaration") || isNodeOfType(ancestor, "ClassExpression")) {
 			const matchingTypeParameter = ancestor.typeParameters?.params?.find((typeParameter) => isNodeOfType(typeParameter, "TSTypeParameter") && isNodeOfType(typeParameter.name, "Identifier") && typeParameter.name.name === typeName);
 			if (matchingTypeParameter && isNodeOfType(matchingTypeParameter, "TSTypeParameter")) return matchingTypeParameter;
 		}
@@ -19756,7 +20521,7 @@ const hasSizeReadOnSameExpression = (spreadArgument) => {
 	let ancestor = spreadArgument.parent;
 	while (ancestor) {
 		scopeOwner = ancestor;
-		if (isFunctionLike$2(ancestor)) break;
+		if (isFunctionLike$1(ancestor)) break;
 		ancestor = ancestor.parent ?? null;
 	}
 	let didFindSizeRead = false;
@@ -21208,7 +21973,7 @@ const unwrapReactHocFunction = (node, scopes) => resolveReactHocFunction(node, s
 //#endregion
 //#region src/plugin/utils/build-same-file-jsx-slot-prop-registry.ts
 const REACT_SLOT_TYPE_NAMES = new Set(["ReactNode", "ReactElement"]);
-const unwrapTopLevelDeclaration = (statement) => {
+const unwrapTopLevelDeclaration$1 = (statement) => {
 	if (isNodeOfType(statement, "ExportNamedDeclaration")) return statement.declaration;
 	if (isNodeOfType(statement, "ExportDefaultDeclaration")) return statement.declaration;
 	return statement;
@@ -21245,7 +22010,7 @@ const buildReactSlotTypeEnvironment = (program) => {
 			}
 			continue;
 		}
-		const declaration = unwrapTopLevelDeclaration(statement);
+		const declaration = unwrapTopLevelDeclaration$1(statement);
 		if (!declaration) continue;
 		if ((isNodeOfType(declaration, "TSInterfaceDeclaration") || isNodeOfType(declaration, "TSTypeAliasDeclaration")) && isNodeOfType(declaration.id, "Identifier")) sameFileTypeDeclarations.set(declaration.id.name, declaration);
 		if (isNodeOfType(declaration, "TSModuleDeclaration") && isNodeOfType(declaration.id, "Identifier") && declaration.id.name === "JSX") hasLocalJsxNamespace = true;
@@ -21337,7 +22102,7 @@ const buildSameFileJsxSlotPropRegistry = (program, memoRegistry, scopes) => {
 	if (!isNodeOfType(program, "Program")) return registry;
 	const environment = buildReactSlotTypeEnvironment(program);
 	for (const statement of program.body) {
-		const declaration = unwrapTopLevelDeclaration(statement);
+		const declaration = unwrapTopLevelDeclaration$1(statement);
 		if (!declaration || !isNodeOfType(declaration, "VariableDeclaration")) continue;
 		for (const declarator of declaration.declarations) {
 			if (!isNodeOfType(declarator.id, "Identifier") || memoRegistry.get(declarator.id.name) !== "memoised" || !declarator.init) continue;
@@ -24864,7 +25629,7 @@ const containsFetchCall = (node, options) => {
 	let didFindFetchCall = false;
 	walkAst(node, (child) => {
 		if (didFindFetchCall) return false;
-		if (effectInvokedFunctions && child !== node && isFunctionLike$2(child) && !effectInvokedFunctions.has(child)) return false;
+		if (effectInvokedFunctions && child !== node && isFunctionLike$1(child) && !effectInvokedFunctions.has(child)) return false;
 		if (isFetchCall$1(child)) {
 			didFindFetchCall = true;
 			return false;
@@ -24962,7 +25727,7 @@ const isInsidePollingLoop = (navigationNode, effectCallback, timerScheduledNames
 	if (timerScheduledNames.size === 0) return false;
 	let cursor = navigationNode.parent;
 	while (cursor && cursor !== effectCallback) {
-		if (isFunctionLike$2(cursor)) {
+		if (isFunctionLike$1(cursor)) {
 			const bindingName = getFunctionBindingName(cursor);
 			if (bindingName && timerScheduledNames.has(bindingName)) return true;
 		}
@@ -25002,7 +25767,7 @@ const nextjsNoClientSideRedirect = defineRule({
 			const effectInvokedFunctions = collectEffectInvokedFunctions(callback);
 			const timerScheduledNames = collectTimerScheduledFunctionNames(callback);
 			walkAst(callback, (child) => {
-				if (child !== callback && isFunctionLike$2(child) && !effectInvokedFunctions.has(child)) return false;
+				if (child !== callback && isFunctionLike$1(child) && !effectInvokedFunctions.has(child)) return false;
 				const navigationDescription = describeClientSideNavigation(child);
 				if (navigationDescription) {
 					if (isNodeOfType(child, "CallExpression")) {
@@ -25392,7 +26157,7 @@ const catchClauseRethrowsCaught = (handler) => {
 	let didRethrow = false;
 	walkAst(handler.body, (child) => {
 		if (didRethrow) return false;
-		if (child !== handler.body && isFunctionLike$2(child)) return false;
+		if (child !== handler.body && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "ThrowStatement") && isNodeOfType(child.argument, "Identifier") && child.argument.name === caughtBindingName && doesThrowEscapeCatchClause(child, handler)) {
 			didRethrow = true;
 			return false;
@@ -25417,7 +26182,7 @@ const findGuardingTryStatement = (node) => {
 	let child = node;
 	let ancestor = node.parent;
 	while (ancestor) {
-		if (isFunctionLike$2(ancestor) && !isImmediatelyInvokedFunction(ancestor)) return null;
+		if (isFunctionLike$1(ancestor) && !isImmediatelyInvokedFunction(ancestor)) return null;
 		if (isNodeOfType(ancestor, "TryStatement") && ancestor.block === child && ancestor.handler && !catchClauseRethrowsCaught(ancestor.handler)) return ancestor;
 		child = ancestor;
 		ancestor = ancestor.parent ?? null;
@@ -25716,7 +26481,7 @@ const collectChainedGetHandlerBodies = (initNode) => {
 };
 const resolveBodiesFromExpression = (expression, resolveBinding, remainingDepth) => {
 	if (remainingDepth <= 0) return [];
-	if (isFunctionLike$2(expression)) return expression.body ? [expression.body] : [];
+	if (isFunctionLike$1(expression)) return expression.body ? [expression.body] : [];
 	if (isNodeOfType(expression, "CallExpression")) {
 		for (const callArgument of expression.arguments ?? []) {
 			if (isNodeOfType(callArgument, "ArrowFunctionExpression") || isNodeOfType(callArgument, "FunctionExpression")) {
@@ -25762,7 +26527,7 @@ const collectCalledSameFileHelperBodies = (handlerBody, resolveBinding) => {
 		if (visitedHelperNames.has(helperName)) return;
 		visitedHelperNames.add(helperName);
 		const helperBinding = resolveBinding(helperName);
-		if (!isFunctionLike$2(helperBinding) || !helperBinding.body) return;
+		if (!isFunctionLike$1(helperBinding) || !helperBinding.body) return;
 		if (helperBinding.body === handlerBody) return;
 		helperBodies.push(helperBinding.body);
 	});
@@ -26166,7 +26931,7 @@ const HOOK_NAME_PATTERN$2 = /^use[A-Z0-9]/;
 const isInsideCallbackArgumentOf = (identifier, initializer) => {
 	if (!isNodeOfType(initializer, "CallExpression") && !isNodeOfType(initializer, "NewExpression")) return false;
 	if (isNodeOfType(initializer, "CallExpression") && isNodeOfType(initializer.callee, "Identifier") && HOOK_NAME_PATTERN$2.test(initializer.callee.name)) return false;
-	const callbackArguments = (initializer.arguments ?? []).filter((argument) => isFunctionLike$2(argument));
+	const callbackArguments = (initializer.arguments ?? []).filter((argument) => isFunctionLike$1(argument));
 	if (callbackArguments.length === 0) return false;
 	let node = identifier;
 	while (node && node !== initializer) {
@@ -26302,10 +27067,10 @@ const resolveToFunction = (ref) => {
 	if (!definition || hasParameterDefinition(ref)) return null;
 	const definitionNode = definition.node;
 	if (!definitionNode) return null;
-	if (isFunctionLike$2(definitionNode)) return definitionNode;
+	if (isFunctionLike$1(definitionNode)) return definitionNode;
 	if (isNodeOfType(definitionNode, "VariableDeclarator")) {
 		const initializer = unwrapUseCallback(definitionNode.init);
-		if (isFunctionLike$2(initializer)) return initializer;
+		if (isFunctionLike$1(initializer)) return initializer;
 	}
 	return null;
 };
@@ -26397,7 +27162,7 @@ const isDeferredCallbackFunction = (analysis, fn) => {
 const isInsideDeferredCallback$1 = (analysis, node, boundary) => {
 	let current = parentOf(node);
 	while (current && current !== boundary) {
-		if (isFunctionLike$2(current) && isDeferredCallbackFunction(analysis, current)) return true;
+		if (isFunctionLike$1(current) && isDeferredCallbackFunction(analysis, current)) return true;
 		current = parentOf(current);
 	}
 	return false;
@@ -26637,9 +27402,9 @@ const isProp = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	return isReactFunctionalComponent(declaringNode) && !isReactFunctionalHOC(analysis, declaringNode) || isCustomHook(declaringNode);
 }));
 const isWholePropsParameterBinding = (bindingNode) => {
-	if (isFunctionLike$2(bindingNode.parent)) return true;
+	if (isFunctionLike$1(bindingNode.parent)) return true;
 	let declaringFunction = bindingNode.parent;
-	while (declaringFunction && !isFunctionLike$2(declaringFunction)) declaringFunction = declaringFunction.parent;
+	while (declaringFunction && !isFunctionLike$1(declaringFunction)) declaringFunction = declaringFunction.parent;
 	return Boolean(declaringFunction && resolveFirstArgumentBinding(declaringFunction.params?.[0]) === bindingNode);
 };
 const isWholePropsObjectReference = (analysis, ref) => isProp(analysis, ref) && Boolean(ref.resolved?.defs.some((def) => {
@@ -26706,7 +27471,7 @@ const getUseStateDecl = (analysis, ref) => {
 	return node ?? null;
 };
 const isCleanupReturnArgument = (analysis, node) => {
-	if (isFunctionLike$2(node)) return true;
+	if (isFunctionLike$1(node)) return true;
 	if (isNodeOfType(node, "MemberExpression")) return true;
 	if (isNodeOfType(node, "Identifier")) {
 		const ref = getRef(analysis, node);
@@ -26719,7 +27484,7 @@ const hasCleanupReturn = (analysis, node, visited = /* @__PURE__ */ new WeakSet(
 	if (visited.has(node)) return false;
 	visited.add(node);
 	if (isNodeOfType(node, "ReturnStatement") && node.argument != null) return isCleanupReturnArgument(analysis, node.argument);
-	if (!isNodeOfType(node, "BlockStatement") && isFunctionLike$2(node)) return false;
+	if (!isNodeOfType(node, "BlockStatement") && isFunctionLike$1(node)) return false;
 	const record = node;
 	const childKeys = getAstChildKeys(node);
 	for (let keyIndex = 0; keyIndex < childKeys.length; keyIndex += 1) {
@@ -26734,7 +27499,7 @@ const hasCleanupReturn = (analysis, node, visited = /* @__PURE__ */ new WeakSet(
 };
 const hasCleanup = (analysis, node) => {
 	const fn = getEffectFn(analysis, node);
-	if (!isFunctionLike$2(fn)) return false;
+	if (!isFunctionLike$1(fn)) return false;
 	if (!isNodeOfType(fn.body, "BlockStatement")) return isCleanupReturnArgument(analysis, fn.body);
 	return hasCleanupReturn(analysis, fn.body);
 };
@@ -26774,9 +27539,9 @@ const getOwnScopeBoundNames = (functionNode) => {
 	const cached = ownScopeBoundNamesCache.get(functionNode);
 	if (cached) return cached;
 	const boundNames = /* @__PURE__ */ new Set();
-	if (isFunctionLike$2(functionNode)) for (const param of functionNode.params ?? []) collectPatternNames(param, boundNames);
+	if (isFunctionLike$1(functionNode)) for (const param of functionNode.params ?? []) collectPatternNames(param, boundNames);
 	walkAst(functionNode, (child) => {
-		if (child !== functionNode && isFunctionLike$2(child)) return false;
+		if (child !== functionNode && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "VariableDeclarator")) collectPatternNames(child.id, boundNames);
 	});
 	ownScopeBoundNamesCache.set(functionNode, boundNames);
@@ -26794,7 +27559,7 @@ const referencesIdentifierNamed = (root, identifierName) => {
 	let isReferenced = false;
 	walkAst(root, (child) => {
 		if (isReferenced) return false;
-		if (child !== root && isFunctionLike$2(child) && declaresBindingNamed(child, identifierName)) return false;
+		if (child !== root && isFunctionLike$1(child) && declaresBindingNamed(child, identifierName)) return false;
 		if (isNodeOfType(child, "Identifier") && child.name === identifierName && !isPropertyNamePosition(child)) {
 			isReferenced = true;
 			return false;
@@ -26806,7 +27571,7 @@ const isSetterWiredToJsxHandler = (componentFunction, setterName) => {
 	let isWired = false;
 	walkAst(componentFunction, (child) => {
 		if (isWired) return false;
-		if (child !== componentFunction && isFunctionLike$2(child) && declaresBindingNamed(child, setterName)) return false;
+		if (child !== componentFunction && isFunctionLike$1(child) && declaresBindingNamed(child, setterName)) return false;
 		if (!isNodeOfType(child, "JSXAttribute") || !child.value) return;
 		const attributeName = getJsxAttributeName(child.name);
 		if (!attributeName || !isEventHandlerName(attributeName)) return;
@@ -26853,7 +27618,7 @@ const isIndependentWriterIdentifier = (componentFunction, identifier, includeDef
 		}
 		if (isEventHandlerPropertyKey(cursor)) return true;
 		if (includeDeferredWriters && isDeferredCallbackArgumentOf(cursor, previous)) return true;
-		if (isFunctionLike$2(cursor)) {
+		if (isFunctionLike$1(cursor)) {
 			outermostFunctionBelowComponent = cursor;
 			if (includeDeferredWriters && cursor.async === true) return true;
 		}
@@ -27048,7 +27813,7 @@ const getCallCalleeName$1 = (callExpression) => {
 	if (isNodeOfType(callee, "Identifier")) return callee.name;
 	return getStaticMemberName$1(callee);
 };
-const getFunctionParameters = (functionNode) => isFunctionLike$2(functionNode) ? functionNode.params ?? [] : [];
+const getFunctionParameters = (functionNode) => isFunctionLike$1(functionNode) ? functionNode.params ?? [] : [];
 const getIdentifierBindingIdentity = (analysis, identifier) => {
 	if (!isNodeOfType(identifier, "Identifier")) return null;
 	return getRef(analysis, identifier)?.resolved ?? null;
@@ -27065,7 +27830,7 @@ const isAsyncOrGeneratorFunction = (functionNode) => Boolean(functionNode.async
 const isModuleFunction = (functionNode) => {
 	let ancestor = functionNode.parent;
 	while (ancestor) {
-		if (isFunctionLike$2(ancestor)) return false;
+		if (isFunctionLike$1(ancestor)) return false;
 		if (isNodeOfType(ancestor, "Program")) return true;
 		ancestor = ancestor.parent;
 	}
@@ -27138,7 +27903,7 @@ const localUseEventPreservesCallback = (analysis, callee) => {
 	const callbackBinding = getParameterBindingIdentity(analysis, implementation, callbackParameter);
 	const callbackRefDeclarators = [];
 	walkAst(implementation, (child) => {
-		if (child !== implementation && isFunctionLike$2(child)) return false;
+		if (child !== implementation && isFunctionLike$1(child)) return false;
 		if (!isNodeOfType(child, "VariableDeclarator")) return;
 		if (!isNodeOfType(child.id, "Identifier")) return;
 		if (!isNodeOfType(child.init, "CallExpression")) return;
@@ -27154,11 +27919,11 @@ const localUseEventPreservesCallback = (analysis, callee) => {
 		const returnedCalleeName = getCallCalleeName$1(returnedCall);
 		if (returnedCalleeName !== "useCallback" && returnedCalleeName !== "useEffectEvent") return false;
 		const stableCallback = returnedCall.arguments?.[0];
-		if (!stableCallback || !isFunctionLike$2(stableCallback)) return false;
+		if (!stableCallback || !isFunctionLike$1(stableCallback)) return false;
 		let forwardsCallback = false;
 		walkAst(stableCallback, (child) => {
 			if (forwardsCallback) return false;
-			if (child !== stableCallback && isFunctionLike$2(child)) return false;
+			if (child !== stableCallback && isFunctionLike$1(child)) return false;
 			if (!isNodeOfType(child, "CallExpression")) return;
 			const forwardedCallee = stripParenExpression(child.callee);
 			if (!isNodeOfType(forwardedCallee, "MemberExpression")) return;
@@ -27178,7 +27943,7 @@ const localUseEventPreservesCallback = (analysis, callee) => {
 };
 const resolveWrappedCallable = (analysis, node) => {
 	const candidate = stripParenExpression(node);
-	if (isFunctionLike$2(candidate)) return candidate;
+	if (isFunctionLike$1(candidate)) return candidate;
 	if (isNodeOfType(candidate, "Identifier")) {
 		const reference = getRef(analysis, candidate);
 		if (!reference) return null;
@@ -27191,7 +27956,7 @@ const resolveWrappedCallable = (analysis, node) => {
 		if (!initializer || !isNodeOfType(initializer, "CallExpression")) return null;
 		if (!isReactUseEffectEventCallee(analysis, initializer.callee) && !localUseEventPreservesCallback(analysis, initializer.callee)) return null;
 		const callback = initializer.arguments?.[0];
-		return callback && isFunctionLike$2(callback) ? callback : null;
+		return callback && isFunctionLike$1(callback) ? callback : null;
 	}
 	if (!isNodeOfType(candidate, "MemberExpression")) return null;
 	if (getStaticMemberName$1(candidate) !== "current") return null;
@@ -27202,7 +27967,7 @@ const resolveWrappedCallable = (analysis, node) => {
 	if (!isNodeOfType(declarator.init, "CallExpression")) return null;
 	if (getCallCalleeName$1(declarator.init) !== "useRef") return null;
 	const initializer = declarator.init.arguments?.[0];
-	if (!initializer || !isFunctionLike$2(initializer)) return null;
+	if (!initializer || !isFunctionLike$1(initializer)) return null;
 	return Boolean(reference?.resolved?.references.some((candidateReference) => {
 		const member = candidateReference.identifier.parent;
 		const assignment = member?.parent;
@@ -27213,7 +27978,7 @@ const functionInvokesItself = (analysis, functionNode) => {
 	let invokesItself = false;
 	walkAst(functionNode, (child) => {
 		if (invokesItself) return false;
-		if (child !== functionNode && isFunctionLike$2(child)) return false;
+		if (child !== functionNode && isFunctionLike$1(child)) return false;
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (resolveWrappedCallable(analysis, child.callee) === functionNode) {
 			invokesItself = true;
@@ -27229,7 +27994,7 @@ const collectIntroducedBindings = (analysis, functionNode) => {
 };
 const collectBoundedEffectExecutionFrames = (analysis, effectNode, currentFilename) => {
 	const effectFunction = getEffectFn(analysis, effectNode);
-	if (!effectFunction || !isFunctionLike$2(effectFunction) || effectFunction.async === true) return [];
+	if (!effectFunction || !isFunctionLike$1(effectFunction) || effectFunction.async === true) return [];
 	const invokedFunctionEvidence = collectEffectInvokedFunctions(effectFunction);
 	const rootFrame = {
 		functionNode: effectFunction,
@@ -27241,7 +28006,7 @@ const collectBoundedEffectExecutionFrames = (analysis, effectNode, currentFilena
 	};
 	const frames = [rootFrame];
 	walkAst(effectFunction, (child) => {
-		if (child !== effectFunction && isFunctionLike$2(child)) return false;
+		if (child !== effectFunction && isFunctionLike$1(child)) return false;
 		if (!isNodeOfType(child, "CallExpression")) return;
 		const callee = stripParenExpression(child.callee);
 		const calleeName = getCallCalleeName$1(child);
@@ -27262,7 +28027,7 @@ const collectBoundedEffectExecutionFrames = (analysis, effectNode, currentFilena
 				currentFilename
 			});
 		};
-		if (isFunctionLike$2(callee)) {
+		if (isFunctionLike$1(callee)) {
 			enqueueFrame(callee, child.arguments ?? [], false, /* @__PURE__ */ new Set());
 			return;
 		}
@@ -27299,11 +28064,11 @@ const mergeEvidence = (target, source) => {
 	target.readsExternalValue ||= source.readsExternalValue;
 };
 const getReturnedExpressions = (functionNode) => {
-	if (!isFunctionLike$2(functionNode)) return [];
+	if (!isFunctionLike$1(functionNode)) return [];
 	if (!isNodeOfType(functionNode.body, "BlockStatement")) return [functionNode.body];
 	const returnedExpressions = [];
 	walkAst(functionNode.body, (child) => {
-		if (child !== functionNode.body && isFunctionLike$2(child)) return false;
+		if (child !== functionNode.body && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "ReturnStatement") && child.argument) returnedExpressions.push(child.argument);
 	});
 	return returnedExpressions;
@@ -27388,7 +28153,7 @@ const analyzeHelperExpression = (expression, environment, usedParameterIndices)
 		if (!analyzeHelperExpression(node.object, environment, usedParameterIndices)) return false;
 		return !node.computed || analyzeHelperExpression(node.property, environment, usedParameterIndices);
 	}
-	if (isFunctionLike$2(node)) {
+	if (isFunctionLike$1(node)) {
 		if (isAsyncOrGeneratorFunction(node)) return false;
 		const callbackParameterIndices = new Map(environment.parameterIndices);
 		for (const parameter of getFunctionParameters(node)) {
@@ -27426,7 +28191,7 @@ const analyzeHelperExpression = (expression, environment, usedParameterIndices)
 };
 const helperSummaryCache = /* @__PURE__ */ new WeakMap();
 const summarizeHelperReturn = (functionNode) => {
-	if (!isFunctionLike$2(functionNode) || !isModuleFunction(functionNode)) return null;
+	if (!isFunctionLike$1(functionNode) || !isModuleFunction(functionNode)) return null;
 	if (helperSummaryCache.has(functionNode)) return helperSummaryCache.get(functionNode) ?? null;
 	if (isAsyncOrGeneratorFunction(functionNode)) {
 		helperSummaryCache.set(functionNode, null);
@@ -27616,7 +28381,7 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 		if (isPureGlobalCall || isPureMemberTransform) {
 			if (isPureMemberTransform && isNodeOfType(callee, "MemberExpression")) mergeEvidence(evidence, collectValueEvidence(analysis, callee.object, frame, remainingCallFrames, new Set(visitedBindings)));
 			for (const argument of node.arguments ?? []) {
-				if (isFunctionLike$2(argument)) continue;
+				if (isFunctionLike$1(argument)) continue;
 				mergeEvidence(evidence, collectValueEvidence(analysis, argument, frame, remainingCallFrames, new Set(visitedBindings)));
 			}
 			return evidence;
@@ -27673,7 +28438,7 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 		for (const argument of node.arguments ?? []) mergeEvidence(evidence, collectValueEvidence(analysis, argument, frame, remainingCallFrames, new Set(visitedBindings)));
 		return evidence;
 	}
-	if (isFunctionLike$2(node) || isNodeOfType(node, "AwaitExpression")) {
+	if (isFunctionLike$1(node) || isNodeOfType(node, "AwaitExpression")) {
 		evidence.hasUnknownSource = true;
 		return evidence;
 	}
@@ -27740,7 +28505,7 @@ const matchesStateInitializer = (analysis, callExpression, stateDeclarator) => {
 const collectFrameSetterCalls = (analysis, frame) => {
 	const calls = [];
 	walkAst(frame.functionNode, (child) => {
-		if (child !== frame.functionNode && isFunctionLike$2(child)) return false;
+		if (child !== frame.functionNode && isFunctionLike$1(child)) return false;
 		if (!isNodeOfType(child, "CallExpression")) return;
 		const setterReference = findStateSetterReference(analysis, child);
 		if (setterReference) calls.push({
@@ -27779,7 +28544,7 @@ const collectEffectStateWriteFacts = (analysis, effectNode, currentFilename) =>
 		if (!stateDeclarator) continue;
 		const remainingValueCallFrames = frame === frames[0] ? 1 : 0;
 		let valueEvidence;
-		if (isFunctionLike$2(writtenValue)) {
+		if (isFunctionLike$1(writtenValue)) {
 			const updaterFrame = {
 				functionNode: writtenValue,
 				invocation: callExpression,
@@ -28346,13 +29111,13 @@ const hasEmptyDependencyArray = (useMemoCall) => {
 const useMemoReturnsArrayLiteral = (useMemoCall) => {
 	if (!isNodeOfType(useMemoCall, "CallExpression")) return false;
 	const factory = useMemoCall.arguments?.[0];
-	if (!factory || !isFunctionLike$2(factory)) return false;
+	if (!factory || !isFunctionLike$1(factory)) return false;
 	const body = factory.body;
 	if (!isNodeOfType(body, "BlockStatement")) return isSpreadFreeArrayLiteral(body);
 	let didFindReturn = false;
 	let allReturnsAreFixedArrays = true;
 	walkAst(body, (child) => {
-		if (isFunctionLike$2(child)) return false;
+		if (isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "ReturnStatement")) {
 			didFindReturn = true;
 			if (!child.argument || !isSpreadFreeArrayLiteral(child.argument)) allReturnsAreFixedArrays = false;
@@ -28495,7 +29260,7 @@ const findEnclosingParameter = (bindingIdentifier) => {
 	let current = bindingIdentifier;
 	while (current.parent) {
 		const parent = current.parent;
-		if (isFunctionLike$2(parent)) {
+		if (isFunctionLike$1(parent)) {
 			const parameterPosition = (parent.params ?? []).indexOf(current);
 			return parameterPosition >= 0 ? {
 				functionNode: parent,
@@ -28731,7 +29496,7 @@ const isNumericForLoopCounter = (attributeNode, indexName) => {
 const EMPTY_NAME_SET = /* @__PURE__ */ new Set();
 const findIteratorItemNamesOfBinding = (binding) => {
 	const names = /* @__PURE__ */ new Set();
-	if (!binding.bindingFunction || !isFunctionLike$2(binding.bindingFunction)) return names;
+	if (!binding.bindingFunction || !isFunctionLike$1(binding.bindingFunction)) return names;
 	if (binding.indexParameterPosition === null || binding.indexParameterPosition < 1) return names;
 	const firstParameter = (binding.bindingFunction.params ?? [])[0];
 	if (firstParameter) collectPatternNames(firstParameter, names);
@@ -28745,7 +29510,7 @@ const collectDerivedRowContentNames = (bindingFunction, itemNames) => {
 	walkAst(bindingFunction, (child) => {
 		if (budget <= 0) return false;
 		budget -= 1;
-		if (isFunctionLike$2(child) && child !== bindingFunction) return false;
+		if (isFunctionLike$1(child) && child !== bindingFunction) return false;
 		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier") && child.init) {
 			const rootName = getRootIdentifierName(child.init, { followCallChains: true });
 			if (rootName !== null && itemNames.has(rootName)) names.add(child.id.name);
@@ -28777,7 +29542,7 @@ const callbackFiltersRows = (bindingFunction) => {
 	let didFindNullReturn = false;
 	walkAst(bindingFunction, (child) => {
 		if (didFindNullReturn) return false;
-		if (isFunctionLike$2(child) && child !== bindingFunction) return false;
+		if (isFunctionLike$1(child) && child !== bindingFunction) return false;
 		if (isNodeOfType(child, "ReturnStatement") && child.argument && isNodeOfType(child.argument, "Literal") && child.argument.value === null) {
 			didFindNullReturn = true;
 			return false;
@@ -28800,7 +29565,7 @@ const hasAriaHiddenAncestor = (attributeNode) => {
 	let current = attributeNode.parent;
 	while (current) {
 		if (isNodeOfType(current, "Program")) return false;
-		if (isFunctionLike$2(current)) {
+		if (isFunctionLike$1(current)) {
 			const parent = current.parent;
 			if (!(isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current))) return false;
 		}
@@ -29766,7 +30531,7 @@ const symbolIsLocalComponent = (symbol, context) => {
 const isModuleScopeDeclaration = (declaration) => {
 	let current = declaration?.parent;
 	while (current) {
-		if (isFunctionLike$2(current)) return false;
+		if (isFunctionLike$1(current)) return false;
 		current = current.parent ?? null;
 	}
 	return true;
@@ -29788,12 +30553,12 @@ const declarationBodyContainsHookCall = (symbol) => {
 };
 const declarationTakesMultiplePositionalArguments = (symbol) => {
 	const componentFunction = isComponentDeclaration(symbol.declarationNode) ? symbol.declarationNode : symbol.initializer;
-	if (!componentFunction || !isFunctionLike$2(componentFunction)) return false;
+	if (!componentFunction || !isFunctionLike$1(componentFunction)) return false;
 	return (componentFunction.params?.length ?? 0) >= 2;
 };
 const declarationIsAsyncFunction = (symbol) => {
 	const componentFunction = isComponentDeclaration(symbol.declarationNode) ? symbol.declarationNode : symbol.initializer;
-	if (!componentFunction || !isFunctionLike$2(componentFunction)) return false;
+	if (!componentFunction || !isFunctionLike$1(componentFunction)) return false;
 	return componentFunction.async === true;
 };
 const isReturnedFromUseCallbackAdapter = (callNode) => {
@@ -29898,7 +30663,7 @@ const isSimpleExpression$1 = (analysis, expression, effectFn, visitedDeclarators
 	let isSimple = true;
 	walkAst(expression, (child) => {
 		if (!isSimple) return false;
-		if (isFunctionLike$2(child) || isNodeOfType(child, "AwaitExpression") || isNodeOfType(child, "NewExpression")) {
+		if (isFunctionLike$1(child) || isNodeOfType(child, "AwaitExpression") || isNodeOfType(child, "NewExpression")) {
 			isSimple = false;
 			return false;
 		}
@@ -30683,7 +31448,7 @@ const isFunctionAssignedToComponent = (functionNode) => {
 	return isNodeOfType(cursor, "ExportDefaultDeclaration");
 };
 const isComponentFunction$1 = (node) => {
-	if (!isFunctionLike$2(node)) return false;
+	if (!isFunctionLike$1(node)) return false;
 	if (isNodeOfType(node, "FunctionDeclaration")) return !node.id || node.id.name === "default" || isUppercaseName(node.id.name) || isNodeOfType(node.parent, "ExportDefaultDeclaration");
 	return isFunctionAssignedToComponent(node);
 };
@@ -30696,7 +31461,7 @@ const extractDestructuredPropNames = (params) => {
 };
 const getInlineFunctionNode = (node) => {
 	if (!node) return null;
-	if (isFunctionLike$2(node)) return node;
+	if (isFunctionLike$1(node)) return node;
 	if (!isNodeOfType(node, "CallExpression")) return null;
 	for (const argument of node.arguments ?? []) {
 		const inlineFunctionNode = getInlineFunctionNode(argument);
@@ -30707,7 +31472,7 @@ const getInlineFunctionNode = (node) => {
 const getNearestComponentFunction = (node) => {
 	let cursor = node.parent ?? null;
 	while (cursor) {
-		if (isFunctionLike$2(cursor)) return cursor;
+		if (isFunctionLike$1(cursor)) return cursor;
 		cursor = cursor.parent ?? null;
 	}
 	return null;
@@ -30949,7 +31714,7 @@ const getStateInitializer = (stateDeclarator) => {
 	return initializer ? initializer : null;
 };
 const collectRenderStateWriteFacts = (analysis, componentBody, currentFilename) => {
-	if (!isNodeOfType(componentBody, "BlockStatement") || !componentBody.parent || !isFunctionLike$2(componentBody.parent)) return [];
+	if (!isNodeOfType(componentBody, "BlockStatement") || !componentBody.parent || !isFunctionLike$1(componentBody.parent)) return [];
 	const componentFunction = componentBody.parent;
 	const facts = [];
 	for (const statement of componentBody.body ?? []) {
@@ -30964,7 +31729,7 @@ const collectRenderStateWriteFacts = (analysis, componentBody, currentFilename)
 			if (!stateDeclarator || !isGenuineReactHookDeclarator(analysis, stateDeclarator, "useState") || guard.tracker.kind === "state" && stateDeclarator === guard.tracker.declarator) continue;
 			const writtenValue = callExpression.arguments?.[0];
 			const initializer = getStateInitializer(stateDeclarator);
-			if (!writtenValue || !initializer || isFunctionLike$2(writtenValue) || !doesEvidenceMatchSource(collectRenderValueEvidence(analysis, writtenValue, componentFunction, currentFilename), guard.source) || !doesEvidenceMatchSource(collectRenderValueEvidence(analysis, initializer, componentFunction, currentFilename), guard.source)) continue;
+			if (!writtenValue || !initializer || isFunctionLike$1(writtenValue) || !doesEvidenceMatchSource(collectRenderValueEvidence(analysis, writtenValue, componentFunction, currentFilename), guard.source) || !doesEvidenceMatchSource(collectRenderValueEvidence(analysis, initializer, componentFunction, currentFilename), guard.source)) continue;
 			facts.push({
 				callExpression,
 				stateDeclarator
@@ -31104,7 +31869,7 @@ const isComponentScopeValueArgument = (setterCall, componentFunction, argument)
 	if (rootName === null) return false;
 	let cursor = setterCall.parent ?? null;
 	while (cursor && cursor !== componentFunction) {
-		if (isFunctionLike$2(cursor)) {
+		if (isFunctionLike$1(cursor)) {
 			const nestedParamNames = /* @__PURE__ */ new Set();
 			for (const param of cursor.params ?? []) collectPatternNames(param, nestedParamNames);
 			if (nestedParamNames.has(rootName)) return false;
@@ -31147,7 +31912,7 @@ const hasSessionDismissProp = (propNames) => {
 const getEnclosingEffectHookCallback = (node, componentFunction) => {
 	let cursor = node.parent ?? null;
 	while (cursor && cursor !== componentFunction) {
-		if (isFunctionLike$2(cursor)) {
+		if (isFunctionLike$1(cursor)) {
 			const parent = cursor.parent ?? null;
 			if (parent && isNodeOfType(parent, "CallExpression")) {
 				const calleeName = getCalleeName$2(parent);
@@ -31228,7 +31993,7 @@ const isHandlerShapedReseed = (setterCall, componentFunction) => {
 	let hasNestedFunction = false;
 	let cursor = setterCall.parent ?? null;
 	while (cursor && cursor !== componentFunction) {
-		if (isFunctionLike$2(cursor)) {
+		if (isFunctionLike$1(cursor)) {
 			hasNestedFunction = true;
 			if (isNonHandlerHookCallback(cursor)) return false;
 		}
@@ -31239,7 +32004,7 @@ const isHandlerShapedReseed = (setterCall, componentFunction) => {
 const isInRenderScope = (node, componentFunction) => {
 	let cursor = node.parent ?? null;
 	while (cursor && cursor !== componentFunction) {
-		if (isFunctionLike$2(cursor)) return false;
+		if (isFunctionLike$1(cursor)) return false;
 		cursor = cursor.parent ?? null;
 	}
 	return true;
@@ -31253,10 +32018,10 @@ const getStateValueName = (useStateCall) => {
 	return valueElement.name;
 };
 const isHookDrivenFunctionalUpdate = (setterCall, componentFunction, argument) => {
-	if (!argument || !isFunctionLike$2(argument)) return false;
+	if (!argument || !isFunctionLike$1(argument)) return false;
 	let cursor = setterCall.parent ?? null;
 	while (cursor && cursor !== componentFunction) {
-		if (isFunctionLike$2(cursor) && isNonHandlerHookCallback(cursor)) return true;
+		if (isFunctionLike$1(cursor) && isNonHandlerHookCallback(cursor)) return true;
 		cursor = cursor.parent ?? null;
 	}
 	return false;
@@ -31378,7 +32143,7 @@ const getNodeStart = (node) => "start" in node && typeof node.start === "number"
 const getEnclosingLifecycleFunction = (setStateCall) => {
 	let ancestor = setStateCall.parent;
 	while (ancestor) {
-		if (isFunctionLike$2(ancestor)) {
+		if (isFunctionLike$1(ancestor)) {
 			const parent = ancestor.parent;
 			if ((isNodeOfType(parent, "MethodDefinition") || isNodeOfType(parent, "PropertyDefinition") || isNodeOfType(parent, "Property")) && isNodeOfType(parent.key, "Identifier") && LIFECYCLE_NAMES$2.has(parent.key.name)) return ancestor;
 		}
@@ -31462,7 +32227,7 @@ const argumentDerivesFromPostMountSource = (setStateCall, lifecycleFunction) =>
 	return false;
 };
 const isAfterAwaitInAsyncLifecycle = (setStateCall, lifecycleFunction) => {
-	if (!isFunctionLike$2(lifecycleFunction) || lifecycleFunction.async !== true) return false;
+	if (!isFunctionLike$1(lifecycleFunction) || lifecycleFunction.async !== true) return false;
 	const callStart = getNodeStart(setStateCall);
 	if (callStart < 0) return false;
 	let didFindPrecedingAwait = false;
@@ -31906,7 +32671,7 @@ const collectBlockScopedBindings = (node) => {
 const walkComponentRespectingShadows = (node, shadowedStateNames, visit, isComponentBodyRoot = false) => {
 	if (!node || typeof node !== "object") return;
 	let nextShadowedStateNames = shadowedStateNames;
-	const localBindings = isComponentBodyRoot ? null : isFunctionLike$2(node) ? collectFunctionLocalBindings(node) : collectBlockScopedBindings(node);
+	const localBindings = isComponentBodyRoot ? null : isFunctionLike$1(node) ? collectFunctionLocalBindings(node) : collectBlockScopedBindings(node);
 	if (localBindings && localBindings.size > 0) {
 		const merged = new Set(shadowedStateNames);
 		for (const localName of localBindings) merged.add(localName);
@@ -32443,7 +33208,7 @@ const containsReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubs
 	let didFindRelease = false;
 	walkAst(node, (child) => {
 		if (didFindRelease) return false;
-		if (child !== node && isFunctionLike$2(child) && !isIteratorCallbackArgument(child)) return false;
+		if (child !== node && isFunctionLike$1(child) && !isIteratorCallbackArgument(child)) return false;
 		if (isReleaseLikeCall(child, knownCleanupFunctionNames, knownBoundSubscriptionNames)) {
 			didFindRelease = true;
 			return false;
@@ -32452,16 +33217,16 @@ const containsReleaseLikeCall = (node, knownCleanupFunctionNames, knownBoundSubs
 	return didFindRelease;
 };
 const isCleanupFunctionLike = (node, knownCleanupFunctionNames, knownBoundSubscriptionNames) => {
-	if (!isFunctionLike$2(node)) return false;
+	if (!isFunctionLike$1(node)) return false;
 	return containsReleaseLikeCall(node.body, knownCleanupFunctionNames, knownBoundSubscriptionNames);
 };
 const isProvablyNoOpCleanupFunction = (node) => {
-	if (!isFunctionLike$2(node)) return false;
+	if (!isFunctionLike$1(node)) return false;
 	let sawNoOpRemoval = false;
 	let sawOtherCall = false;
 	walkAst(node.body, (child) => {
 		if (sawOtherCall) return false;
-		if (isFunctionLike$2(child)) return false;
+		if (isFunctionLike$1(child)) return false;
 		const callNode = unwrapChainExpression$2(child);
 		if (!isNodeOfType(callNode, "CallExpression")) return;
 		const callee = unwrapChainExpression$2(callNode.callee);
@@ -32515,12 +33280,12 @@ const collectSynchronouslyInvokedFunctions = (effectCallback, scopes) => {
 	const pendingFunctions = [effectCallback];
 	while (pendingFunctions.length > 0) {
 		const currentFunction = pendingFunctions.pop();
-		if (!currentFunction || !isFunctionLike$2(currentFunction)) continue;
+		if (!currentFunction || !isFunctionLike$1(currentFunction)) continue;
 		walkInsideStatementBlocks(currentFunction.body, (child) => {
 			if (!isNodeOfType(child, "CallExpression")) return;
 			const invokedFunction = resolveExactLocalFunction(child.callee, scopes);
 			if (!invokedFunction || analysisFunctions.has(invokedFunction)) return;
-			if (isFunctionLike$2(invokedFunction) && invokedFunction.async) return;
+			if (isFunctionLike$1(invokedFunction) && invokedFunction.async) return;
 			analysisFunctions.add(invokedFunction);
 			pendingFunctions.push(invokedFunction);
 		});
@@ -32529,7 +33294,7 @@ const collectSynchronouslyInvokedFunctions = (effectCallback, scopes) => {
 };
 const visitSynchronousFunctionBodies = (analysisFunctions, visitor) => {
 	for (const analysisFunction of analysisFunctions) {
-		if (!isFunctionLike$2(analysisFunction)) continue;
+		if (!isFunctionLike$1(analysisFunction)) continue;
 		walkInsideStatementBlocks(analysisFunction.body, visitor);
 	}
 };
@@ -32608,7 +33373,7 @@ const isExternalSyncNode = (node) => {
 	return receiverRootName !== null && EXTERNAL_SYNC_HTTP_CLIENT_RECEIVERS.has(receiverRootName);
 };
 const isExternalSyncEffect = (effectCallback, analysisFunctions, setterToStateName) => {
-	if (!isFunctionLike$2(effectCallback)) return false;
+	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;
@@ -32635,7 +33400,7 @@ const noEffectChain = defineRule({
 			const effectInfos = [];
 			for (const effectCall of findTopLevelEffectCalls(componentBody)) {
 				const callback = getEffectCallback(effectCall, context.scopes);
-				if (!callback || !isFunctionLike$2(callback) || callback.async) continue;
+				if (!callback || !isFunctionLike$1(callback) || callback.async) continue;
 				const analysisFunctions = collectSynchronouslyInvokedFunctions(callback, context.scopes);
 				const writtenStateNames = collectWrittenStateNamesInEffect(analysisFunctions, setterToStateName);
 				effectInfos.push({
@@ -33111,6 +33876,10 @@ const noEffectWithFreshDeps = defineRule({
 	category: "State & Effects",
 	recommendation: "Move the value inside the hook body and depend on its simple inputs instead, or wrap it in useMemo / useCallback so it stays the same between renders.",
 	create: (context) => ({ CallExpression(node) {
+		for (const finding of findForwardedFreshHookDependencies(node, context, EFFECT_HOOK_NAMES$1)) context.report({
+			node: finding.reportNode,
+			message: `A dependency inside this custom Hook changes every render because \`${finding.bindingName}\` is a new ${finding.kind} built fresh each time.`
+		});
 		if (!isHookCall$2(node, HOOKS_WITH_DEPS)) return;
 		const args = node.arguments ?? [];
 		if (args.length < 2) return;
@@ -33199,7 +33968,7 @@ const findFunctionDefinitionNode = (functionNode) => {
 	let current = functionNode;
 	while (current) {
 		if (isNodeOfType(current, "VariableDeclarator")) return current;
-		if (isNodeOfType(current, "Program") || isFunctionLike$2(current) && current !== functionNode) return null;
+		if (isNodeOfType(current, "Program") || isFunctionLike$1(current) && current !== functionNode) return null;
 		current = current.parent;
 	}
 	return null;
@@ -33219,7 +33988,7 @@ const isFunctionWiredToEventAttribute = (analysis, functionNode) => {
 	if (!variable) return false;
 	return variable.references.some((reference) => {
 		let current = reference.identifier;
-		while (current && !isFunctionLike$2(current)) {
+		while (current && !isFunctionLike$1(current)) {
 			if (isEventAttribute(current) || isEventProperty(current)) return true;
 			current = current.parent;
 		}
@@ -33262,7 +34031,7 @@ const isInsideProvenEventHandler = (analysis, node, componentFunction, allowOneC
 	if (isInsideInlineEventHandler(node, componentFunction)) return true;
 	let current = node.parent;
 	while (current && current !== componentFunction) {
-		if (isFunctionLike$2(current)) {
+		if (isFunctionLike$1(current)) {
 			if (isFunctionWiredToEventAttribute(analysis, current) && !isFunctionUsedOutsideHandlers(analysis, current, componentFunction)) return true;
 			return allowOneCallFrame && isFunctionCalledOnlyFromHandlers(analysis, current, componentFunction);
 		}
@@ -33275,7 +34044,7 @@ const isSetterWriterUsage = (identifier) => {
 	if (!parent) return false;
 	if (isNodeOfType(parent, "CallExpression")) return parent.callee === identifier || (parent.arguments ?? []).includes(identifier);
 	let current = identifier;
-	while (current && !isFunctionLike$2(current)) {
+	while (current && !isFunctionLike$1(current)) {
 		if (isEventAttribute(current) || isEventProperty(current)) return true;
 		current = current.parent;
 	}
@@ -33329,7 +34098,7 @@ const consequentHasTransferableWork = (analysis, consequent) => {
 	let hasTransferableWork = false;
 	walkAst(consequent, (child) => {
 		if (hasTransferableWork) return false;
-		if (child !== consequent && isFunctionLike$2(child)) return false;
+		if (child !== consequent && isFunctionLike$1(child)) return false;
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (isNodeOfType(child.callee, "Identifier")) {
 			const calleeReference = getRef(analysis, child.callee);
@@ -33356,7 +34125,7 @@ const consequentHasAdditionalReactiveGuard = (analysis, consequent, handlerState
 	let hasAdditionalGuard = false;
 	walkAst(consequent, (child) => {
 		if (hasAdditionalGuard) return false;
-		if (child !== consequent && isFunctionLike$2(child)) return false;
+		if (child !== consequent && isFunctionLike$1(child)) return false;
 		if (!isNodeOfType(child, "IfStatement")) return;
 		if (guardHasOtherReactiveSource(analysis, child.test, handlerStateDeclarator)) {
 			hasAdditionalGuard = true;
@@ -33380,7 +34149,7 @@ const noEventHandler = defineRule({
 			let reported = false;
 			walkAst(frame.functionNode, (child) => {
 				if (reported) return false;
-				if (child !== frame.functionNode && isFunctionLike$2(child)) return false;
+				if (child !== frame.functionNode && isFunctionLike$1(child)) return false;
 				if (!isNodeOfType(child, "IfStatement") || child.alternate) return;
 				if (!consequentHasTransferableWork(analysis, child.consequent)) return;
 				const stateReferences = collectGuardStateReferences(analysis, child.test);
@@ -33694,7 +34463,7 @@ const addIteratorMutationDependencies = (graph, expression, scope, eventHandlerR
 	for (const argument of expression.arguments ?? []) {
 		if (!isNodeOfType(argument, "ArrowFunctionExpression") && !isNodeOfType(argument, "FunctionExpression")) continue;
 		walkAst(argument.body, (node) => {
-			if (node !== argument.body && isFunctionLike$2(node)) return false;
+			if (node !== argument.body && isFunctionLike$1(node)) return false;
 			if (!isNodeOfType(node, "CallExpression")) return;
 			if (!isNodeOfType(node.callee, "MemberExpression")) return;
 			const nestedMethodName = getStaticMemberPropertyName(node.callee);
@@ -34155,12 +34924,12 @@ const isNetworkRequest = (node) => isRealFetchCall(node) || isXmlHttpRequestCons
 const resolveLocalFunction = (expression, context) => {
 	if (!expression) return null;
 	const unwrappedExpression = stripParenExpression(expression);
-	if (isFunctionLike$2(unwrappedExpression)) return unwrappedExpression;
+	if (isFunctionLike$1(unwrappedExpression)) return unwrappedExpression;
 	if (!isNodeOfType(unwrappedExpression, "Identifier")) return null;
 	const initializer = context.scopes.symbolFor(unwrappedExpression)?.initializer;
 	if (!initializer) return null;
 	const unwrappedInitializer = stripParenExpression(initializer);
-	return isFunctionLike$2(unwrappedInitializer) ? unwrappedInitializer : null;
+	return isFunctionLike$1(unwrappedInitializer) ? unwrappedInitializer : null;
 };
 const collectEffectAnalysisFunctions = (effectCallback, context) => {
 	const analysisFunctions = /* @__PURE__ */ new Set();
@@ -34177,7 +34946,7 @@ const collectEffectAnalysisFunctions = (effectCallback, context) => {
 		const currentFunction = pendingFunctions.pop();
 		if (!currentFunction) break;
 		walkAst(currentFunction, (child) => {
-			if (child !== currentFunction && isFunctionLike$2(child)) return false;
+			if (child !== currentFunction && isFunctionLike$1(child)) return false;
 			if (!isNodeOfType(child, "CallExpression")) return;
 			const calledFunction = resolveLocalFunction(child.callee, context);
 			if (calledFunction) enqueueFunction(calledFunction);
@@ -34193,7 +34962,7 @@ const collectNodesFromAnalysisFunctions = (analysisFunctions, predicate) => {
 	const nodes = [];
 	const seenNodes = /* @__PURE__ */ new Set();
 	for (const analysisFunction of analysisFunctions) walkAst(analysisFunction, (child) => {
-		if (child !== analysisFunction && isFunctionLike$2(child)) return false;
+		if (child !== analysisFunction && isFunctionLike$1(child)) return false;
 		if (!seenNodes.has(child) && predicate(child)) {
 			seenNodes.add(child);
 			nodes.push(child);
@@ -34202,19 +34971,19 @@ const collectNodesFromAnalysisFunctions = (analysisFunctions, predicate) => {
 	return nodes;
 };
 const findEffectCleanupFunction = (callback) => {
-	if (!isFunctionLike$2(callback)) return null;
+	if (!isFunctionLike$1(callback)) return null;
 	const body = callback.body;
-	if (isFunctionLike$2(body)) return body;
+	if (isFunctionLike$1(body)) return body;
 	let cleanup = null;
 	walkAst(body, (child) => {
-		if (child !== body && isFunctionLike$2(child)) return false;
-		if (isNodeOfType(child, "ReturnStatement") && child.argument && isFunctionLike$2(child.argument)) cleanup = child.argument;
+		if (child !== body && isFunctionLike$1(child)) return false;
+		if (isNodeOfType(child, "ReturnStatement") && child.argument && isFunctionLike$1(child.argument)) cleanup = child.argument;
 	});
 	return cleanup;
 };
 const collectEffectCancellationFlagKeys = (effectCallback, context) => {
 	const flagKeys = /* @__PURE__ */ new Set();
-	if (!isFunctionLike$2(effectCallback)) return flagKeys;
+	if (!isFunctionLike$1(effectCallback)) return flagKeys;
 	const body = effectCallback.body;
 	if (!isNodeOfType(body, "BlockStatement")) return flagKeys;
 	for (const statement of body.body ?? []) {
@@ -34298,7 +35067,7 @@ const isCompletionSinkInsideCancellationGuard = (completionSink, cancellationFla
 	let currentNode = completionSink;
 	let parentNode = currentNode.parent;
 	while (parentNode) {
-		if (isFunctionLike$2(parentNode)) return false;
+		if (isFunctionLike$1(parentNode)) return false;
 		if (isNodeOfType(parentNode, "IfStatement")) {
 			const cancellationResult = readCancellationCondition(parentNode.test, cancellationFlagKey, context);
 			if (currentNode === parentNode.consequent && cancellationResult === false) return true;
@@ -34323,7 +35092,7 @@ const isCompletionSinkAfterCancellationEarlyExit = (completionSink, cancellation
 	let currentNode = completionSink;
 	let parentNode = currentNode.parent;
 	while (parentNode) {
-		if (isFunctionLike$2(parentNode)) return false;
+		if (isFunctionLike$1(parentNode)) return false;
 		if (isNodeOfType(parentNode, "BlockStatement")) {
 			const statementIndex = parentNode.body.findIndex((statement) => statement === currentNode);
 			if (statementIndex >= 0) for (const statement of parentNode.body.slice(0, statementIndex)) {
@@ -34494,7 +35263,7 @@ const collectMeasuringFunctionNames = (program) => {
 		if (!isNodeOfType(child, "VariableDeclarator") || !isNodeOfType(child.id, "Identifier")) return;
 		let functionValue = child.init;
 		if (functionValue && isNodeOfType(functionValue, "CallExpression") && isNodeOfType(functionValue.callee, "Identifier") && /^use[A-Z]/.test(functionValue.callee.name)) functionValue = functionValue.arguments?.[0];
-		if (functionValue && isFunctionLike$2(functionValue) && subtreeReadsDomMeasurement(functionValue.body)) names.add(child.id.name);
+		if (functionValue && isFunctionLike$1(functionValue) && subtreeReadsDomMeasurement(functionValue.body)) names.add(child.id.name);
 	});
 	return names;
 };
@@ -34521,7 +35290,7 @@ const isInsideStartViewTransition = (node) => {
 const enclosingFunctionChainReadsMeasurement = (node, measuringFunctionNames) => {
 	let cursor = node.parent;
 	while (cursor) {
-		if (isFunctionLike$2(cursor)) {
+		if (isFunctionLike$1(cursor)) {
 			const body = cursor.body;
 			if (subtreeReadsDomMeasurement(body) || callsAnyName(body, measuringFunctionNames)) return true;
 		}
@@ -34963,7 +35732,7 @@ const hasClientRenderEvidence = (componentOrHookNode, fileHasUseClientDirective)
 	const displayName = componentOrHookDisplayNameForFunction(componentOrHookNode);
 	if (displayName && isReactHookName(displayName)) return true;
 	let callsHook = false;
-	walkAst((isFunctionLike$2(componentOrHookNode) ? componentOrHookNode.body : null) ?? componentOrHookNode, (child) => {
+	walkAst((isFunctionLike$1(componentOrHookNode) ? componentOrHookNode.body : null) ?? componentOrHookNode, (child) => {
 		if (callsHook) return false;
 		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && isReactHookName(child.callee.name)) {
 			callsHook = true;
@@ -35033,7 +35802,7 @@ const readInitialStateBoolean = (expression, scopes) => readInitialStateBooleanI
 //#endregion
 //#region src/plugin/utils/is-after-client-only-early-return.ts
 const isAfterClientOnlyEarlyReturn = (node, componentOrHookNode, scopes) => {
-	const body = isFunctionLike$2(componentOrHookNode) ? componentOrHookNode.body : null;
+	const body = isFunctionLike$1(componentOrHookNode) ? componentOrHookNode.body : null;
 	if (!isNodeOfType(body, "BlockStatement")) return false;
 	const ancestors = /* @__PURE__ */ new Set();
 	let currentNode = node;
@@ -35066,7 +35835,7 @@ const isGatedByFalsyInitialState = (node, scopes) => {
 };
 //#endregion
 //#region src/plugin/rules/performance/no-hydration-branch-on-browser-global.ts
-const evaluateEquality = (operator, left, right) => {
+const evaluateEquality$1 = (operator, left, right) => {
 	if (operator === "===" || operator === "==") return left === right;
 	if (operator === "!==" || operator === "!=") return left !== right;
 	return null;
@@ -35097,8 +35866,8 @@ const matchBrowserPredicate = (expression, context) => {
 	const browserGlobalName = leftGlobalName && typeof rightString === "string" ? leftGlobalName : rightGlobalName && typeof leftString === "string" ? rightGlobalName : null;
 	const comparedType = leftGlobalName && typeof rightString === "string" ? rightString : rightGlobalName && typeof leftString === "string" ? leftString : null;
 	if (!browserGlobalName || !comparedType) return null;
-	const clientResult = evaluateEquality(unwrappedExpression.operator, "object", comparedType);
-	const serverResult = evaluateEquality(unwrappedExpression.operator, "undefined", comparedType);
+	const clientResult = evaluateEquality$1(unwrappedExpression.operator, "object", comparedType);
+	const serverResult = evaluateEquality$1(unwrappedExpression.operator, "undefined", comparedType);
 	if (clientResult === null || serverResult === null || clientResult === serverResult) return null;
 	return {
 		browserGlobalName,
@@ -35197,7 +35966,7 @@ const findEnclosingJsxAttribute = (node) => {
 	let currentNode = node.parent;
 	while (currentNode) {
 		if (isNodeOfType(currentNode, "JSXAttribute")) return currentNode;
-		if (isNodeOfType(currentNode, "JSXElement") || isNodeOfType(currentNode, "JSXFragment") || isFunctionLike$2(currentNode)) return null;
+		if (isNodeOfType(currentNode, "JSXElement") || isNodeOfType(currentNode, "JSXFragment") || isFunctionLike$1(currentNode)) return null;
 		currentNode = currentNode.parent;
 	}
 	return null;
@@ -35213,8 +35982,8 @@ const isInRenderedOutput = (node, componentOrHookNode, scopes) => {
 		if (isNodeOfType(parentNode, "ReturnStatement")) {
 			if (findEnclosingFunction$1(parentNode) === componentOrHookNode) return true;
 		}
-		if (parentNode === componentOrHookNode) return isFunctionLike$2(componentOrHookNode) && !isNodeOfType(componentOrHookNode.body, "BlockStatement") && componentOrHookNode.body === currentNode;
-		if (isFunctionLike$2(parentNode) && !executesDuringRender(parentNode, scopes)) return false;
+		if (parentNode === componentOrHookNode) return isFunctionLike$1(componentOrHookNode) && !isNodeOfType(componentOrHookNode.body, "BlockStatement") && componentOrHookNode.body === currentNode;
+		if (isFunctionLike$1(parentNode) && !executesDuringRender(parentNode, scopes)) return false;
 		currentNode = parentNode;
 		parentNode = currentNode.parent;
 	}
@@ -35492,7 +36261,7 @@ const findImpureUpdaterOperation = (updater, scopes) => {
 	let operation = null;
 	walkAst(updater, (child) => {
 		if (operation) return false;
-		if (child !== updater && isFunctionLike$2(child) && !isDefinitelySynchronousCallback(child, scopes)) return false;
+		if (child !== updater && isFunctionLike$1(child) && !isDefinitelySynchronousCallback(child, scopes)) return false;
 		if (isNodeOfType(child, "CallExpression")) {
 			if (isNodeOfType(child.callee, "Identifier") && analysis) {
 				const calleeReference = getRef(analysis, child.callee);
@@ -35533,7 +36302,7 @@ const noImpureStateUpdater = defineRule({
 		const stateDeclarator = getUseStateDecl(analysis, calleeReference);
 		if (!isNodeOfType(stateDeclarator, "VariableDeclarator") || !isNodeOfType(stateDeclarator.init, "CallExpression") || !isReactApiCall(stateDeclarator.init, "useState", context.scopes, { allowGlobalReactNamespace: true })) return;
 		let updater = null;
-		if (isFunctionLike$2(updaterArgument)) updater = updaterArgument;
+		if (isFunctionLike$1(updaterArgument)) updater = updaterArgument;
 		else if (isNodeOfType(updaterArgument, "Identifier")) {
 			const updaterReference = getRef(analysis, updaterArgument);
 			if (updaterReference) updater = resolveToFunction(updaterReference);
@@ -35966,7 +36735,7 @@ const isCatchParameterRoundTrip = (stringifyCall) => {
 	if (!argument || !isNodeOfType(argument, "Identifier")) return false;
 	let current = stringifyCall.parent;
 	while (current) {
-		if (isFunctionLike$2(current) && (current.params ?? []).some((parameter) => isNodeOfType(parameter, "Identifier") && parameter.name === argument.name)) return false;
+		if (isFunctionLike$1(current) && (current.params ?? []).some((parameter) => isNodeOfType(parameter, "Identifier") && parameter.name === argument.name)) return false;
 		if (isNodeOfType(current, "CatchClause") && isNodeOfType(current.param, "Identifier") && current.param.name === argument.name) return true;
 		current = current.parent ?? null;
 	}
@@ -35980,7 +36749,7 @@ const getName = (candidate) => {
 const isInsideSnapshotHelper = (node) => {
 	let current = node.parent;
 	while (current) {
-		if (isFunctionLike$2(current)) {
+		if (isFunctionLike$1(current)) {
 			const directName = isNodeOfType(current, "ArrowFunctionExpression") ? null : getName(current.id);
 			const parent = current.parent;
 			let boundName = directName;
@@ -36003,9 +36772,9 @@ const noJsonParseStringifyClone = defineRule({
 		const firstArgument = node.arguments?.[0];
 		if (!firstArgument || !isJsonMethodCall(firstArgument, "stringify")) return;
 		const replacer = firstArgument.arguments?.[1];
-		if (isFunctionLike$2(replacer) || isNodeOfType(replacer, "ArrayExpression")) return;
+		if (isFunctionLike$1(replacer) || isNodeOfType(replacer, "ArrayExpression")) return;
 		const reviver = node.arguments?.[1];
-		if (isFunctionLike$2(reviver)) return;
+		if (isFunctionLike$1(reviver)) return;
 		if (isInsideSnapshotHelper(node)) return;
 		if (isAssignedToNormalizationBinding(node)) return;
 		if (isCatchParameterRoundTrip(firstArgument)) return;
@@ -36332,11 +37101,11 @@ const isProvenReactClassComponent = (classNode, scopes, visitedClassNodes = /* @
 //#endregion
 //#region src/plugin/utils/function-contains-proven-react-hook-call.ts
 const functionContainsProvenReactHookCall = (functionNode, scopes) => {
-	if (!isFunctionLike$2(functionNode)) return false;
+	if (!isFunctionLike$1(functionNode)) return false;
 	let containsReactHookCall = false;
 	walkAst(functionNode.body, (node) => {
 		if (containsReactHookCall) return false;
-		if (node !== functionNode.body && (isFunctionLike$2(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
+		if (node !== functionNode.body && (isFunctionLike$1(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
 		if (isNodeOfType(node, "CallExpression") && isReactApiCall(node, BUILTIN_HOOK_NAMES, scopes, { resolveNamedAliases: true })) {
 			containsReactHookCall = true;
 			return false;
@@ -36347,7 +37116,7 @@ const functionContainsProvenReactHookCall = (functionNode, scopes) => {
 //#endregion
 //#region src/plugin/utils/function-returns-props-children.ts
 const functionReturnsPropsChildren = (functionNode, scopes, controlFlow) => {
-	if (!isFunctionLike$2(functionNode) || functionNode.params.length === 0) return false;
+	if (!isFunctionLike$1(functionNode) || functionNode.params.length === 0) return false;
 	const firstParameter = stripParenExpression(functionNode.params[0]);
 	const firstParameterPattern = isNodeOfType(firstParameter, "AssignmentPattern") ? stripParenExpression(firstParameter.left) : firstParameter;
 	const propsParameterSymbol = isNodeOfType(firstParameterPattern, "Identifier") ? scopes.symbolFor(firstParameterPattern) : null;
@@ -36383,7 +37152,7 @@ const isNullExpression = (expression) => {
 	return isNodeOfType(candidate, "Literal") && candidate.value === null;
 };
 const functionReturnsOnlyNull = (functionNode) => {
-	if (!isFunctionLike$2(functionNode)) return false;
+	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)));
@@ -37024,10 +37793,10 @@ const noLocaleFormatInRender = defineRule({
 				const componentOrHookNode = findRenderPhaseComponentOrHook(node, context.scopes);
 				if (!componentOrHookNode) return;
 				const helperNode = findVariableInitializer(expression.callee, helperName)?.initializer;
-				if (!helperNode || !isFunctionLike$2(helperNode)) return;
+				if (!helperNode || !isFunctionLike$1(helperNode)) return;
 				if (componentOrHookDisplayNameForFunction(helperNode)) return;
 				walkAst(helperNode.body ?? helperNode, (child) => {
-					if (isFunctionLike$2(child)) return false;
+					if (isFunctionLike$1(child)) return false;
 					if (!isNodeOfType(child, "CallExpression")) return;
 					const match = matchLocaleMethodCall(child, context.scopes) ?? matchIntlFormatCall(child, context.scopes);
 					if (!match || reportedNodes.has(match.node)) return;
@@ -37250,7 +38019,7 @@ const findDirectMatchMediaCall = (root, context) => {
 	let matchMediaCall = null;
 	walkAst(root, (visitedNode) => {
 		if (matchMediaCall) return false;
-		if (isFunctionLike$2(visitedNode)) return false;
+		if (isFunctionLike$1(visitedNode)) return false;
 		if (isGlobalMatchMediaCall(visitedNode, context.scopes)) {
 			matchMediaCall = visitedNode;
 			return false;
@@ -37260,7 +38029,7 @@ const findDirectMatchMediaCall = (root, context) => {
 };
 const findMatchMediaCallDuringInitialization = (initializer, context) => {
 	const rootInitializer = stripParenExpression(initializer);
-	if (!isFunctionLike$2(rootInitializer)) return findDirectMatchMediaCall(rootInitializer, context);
+	if (!isFunctionLike$1(rootInitializer)) return findDirectMatchMediaCall(rootInitializer, context);
 	if (rootInitializer.async || rootInitializer.generator) return null;
 	return findDirectMatchMediaCall(rootInitializer.body, context);
 };
@@ -37921,7 +38690,7 @@ const isLodashMutatorCall = (callExpression) => {
 const resolveReducerFunction = (node, currentFilename) => {
 	if (!node) return null;
 	const unwrappedNode = stripParenExpression(node);
-	if (isFunctionLike$2(unwrappedNode)) return {
+	if (isFunctionLike$1(unwrappedNode)) return {
 		functionNode: unwrappedNode,
 		crossFileSourceDisplay: null
 	};
@@ -37929,7 +38698,7 @@ const resolveReducerFunction = (node, currentFilename) => {
 	const initializer = findVariableInitializer(unwrappedNode, unwrappedNode.name)?.initializer;
 	if (!initializer) return null;
 	const unwrappedInitializer = stripParenExpression(initializer);
-	if (isFunctionLike$2(unwrappedInitializer)) return {
+	if (isFunctionLike$1(unwrappedInitializer)) return {
 		functionNode: unwrappedInitializer,
 		crossFileSourceDisplay: null
 	};
@@ -38040,11 +38809,11 @@ const canExpressionReturnOriginalReducerStateReference = (node, state) => {
 	return false;
 };
 const collectReducerStateMutationsInExpressionOrStatement = (node, state) => {
-	if (isFunctionLike$2(node)) return [];
+	if (isFunctionLike$1(node)) return [];
 	const mutations = [];
 	walkAst(node, (child) => {
 		const unwrappedChild = stripParenExpression(child);
-		if (child !== node && isFunctionLike$2(unwrappedChild)) return false;
+		if (child !== node && isFunctionLike$1(unwrappedChild)) return false;
 		if (isNodeOfType(unwrappedChild, "AssignmentExpression")) {
 			if (isNodeOfType(stripParenExpression(unwrappedChild.left), "MemberExpression") && isExpressionRootedInMutableReducerStateSource(unwrappedChild.left, state)) mutations.push({ node: unwrappedChild });
 			return;
@@ -38150,7 +38919,7 @@ const updateReducerStateIdentityForIdentifierAssignment = (assignment, state) =>
 	if (isExpressionReachableFromOriginalReducerState(assignment.right, state)) state.mutableStateSourceNames.add(name);
 };
 const analyzeReactUseReducerFunctionForStateMutation = (context, functionNode, reportedNodes, options) => {
-	if (!isFunctionLike$2(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return;
+	if (!isFunctionLike$1(functionNode) || !isNodeOfType(functionNode.body, "BlockStatement")) return;
 	const firstParam = functionNode.params?.[0];
 	const stateName = isNodeOfType(firstParam, "Identifier") ? firstParam.name : isNodeOfType(firstParam, "AssignmentPattern") && isNodeOfType(firstParam.left, "Identifier") ? firstParam.left.name : null;
 	if (!stateName) return;
@@ -38819,7 +39588,7 @@ const rendersFocusManagerInSameFunction = (styleAttribute) => {
 	let ancestor = styleAttribute.parent;
 	while (ancestor) {
 		scopeOwner = ancestor;
-		if (isFunctionLike$2(ancestor)) break;
+		if (isFunctionLike$1(ancestor)) break;
 		ancestor = ancestor.parent ?? null;
 	}
 	let didFindFocusManager = false;
@@ -39156,7 +39925,7 @@ const getWrapperHookWrappedFunction = (initializer) => {
 	const calleeName = isNodeOfType(callee, "Identifier") ? callee.name : isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") ? callee.property.name : null;
 	if (!calleeName || !FUNCTION_WRAPPER_HOOK_NAMES$1.has(calleeName)) return null;
 	const wrapped = initializer.arguments?.[0];
-	if (!wrapped || !isFunctionLike$2(wrapped)) return null;
+	if (!wrapped || !isFunctionLike$1(wrapped)) return null;
 	return wrapped;
 };
 const HANDLER_NAMED_PROP_PATTERN = /^(on|handle)[A-Z]/;
@@ -39310,7 +40079,7 @@ const getCallbackRefProvenance = (analysis, effectCall, callExpression, isReactU
 	if (!bindingProvenance) return null;
 	const { refCall, variables } = bindingProvenance;
 	const componentFunction = findEnclosingFunction$1(effectCall);
-	if (!componentFunction || !isFunctionLike$2(componentFunction) || !isComponentFunction$1(componentFunction) || !isNodeOfType(componentFunction.body, "BlockStatement")) return null;
+	if (!componentFunction || !isFunctionLike$1(componentFunction) || !isComponentFunction$1(componentFunction) || !isNodeOfType(componentFunction.body, "BlockStatement")) return null;
 	if (!getDirectComponentBodyStatement(effectCall, componentFunction.body)) return null;
 	const callbackPropNames = /* @__PURE__ */ new Set();
 	const initializer = refCall.arguments?.[0];
@@ -39348,7 +40117,7 @@ const isHandlerBagArgument = (analysis, argument) => {
 	return properties.every((property) => {
 		if (!isNodeOfType(property, "Property")) return false;
 		const value = property.value;
-		if (isFunctionLike$2(value)) return true;
+		if (isFunctionLike$1(value)) return true;
 		if (isNodeOfType(value, "Identifier")) {
 			const valueRef = getRef(analysis, value);
 			return Boolean(valueRef && resolveToFunction(valueRef));
@@ -39451,7 +40220,7 @@ const noPassDataToParent = defineRule({
 				const isSetterNamedCallee = callbackRefProvenance ? [...callbackRefProvenance.callbackPropNames].every((callbackPropName) => SETTER_NAMED_PROP_PATTERN.test(callbackPropName)) : Boolean((isNodeOfType(identifier, "Identifier") ? identifier.name : methodName) && SETTER_NAMED_PROP_PATTERN.test((isNodeOfType(identifier, "Identifier") ? identifier.name : methodName) ?? ""));
 				const isLeafRef = (argRef) => getUpstreamRefs(analysis, argRef).length === 1;
 				const argsUpstreamRefs = (callExpr.arguments ?? []).flatMap((argument) => {
-					if (isFunctionLike$2(argument)) {
+					if (isFunctionLike$1(argument)) {
 						if (!isSetterNamedCallee) return [];
 						return getFunctionalUpdaterDataRefs(analysis, argument);
 					}
@@ -39568,7 +40337,7 @@ const collectPropCallbackBoundStateRefs = (analysis, ref, isPropCallbackRef) =>
 		if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
 		if (!(getEventualCallRefsTo(analysis, upRef, isPropCallbackRef).length > 0)) continue;
 		for (const argument of callExpr.arguments ?? []) {
-			if (isFunctionLike$2(argument)) continue;
+			if (isFunctionLike$1(argument)) continue;
 			for (const argRef of getDownstreamRefs(analysis, argument)) {
 				if (resolveToFunction(argRef)) continue;
 				collectUpstreamStateRefs(analysis, argRef, stateRefs, /* @__PURE__ */ new Set());
@@ -39585,7 +40354,7 @@ const isSetterNamedCallbackReceivingData = (callbackRef) => {
 	if (!isCustomHookParameter(callbackRef)) return false;
 	const firstArgument = (callExpr.arguments ?? [])[0];
 	if (!firstArgument) return false;
-	return !isNodeOfType(firstArgument, "Literal") && !isNodeOfType(firstArgument, "TemplateLiteral") && !isFunctionLike$2(firstArgument);
+	return !isNodeOfType(firstArgument, "Literal") && !isNodeOfType(firstArgument, "TemplateLiteral") && !isFunctionLike$1(firstArgument);
 };
 const FUNCTION_WRAPPER_HOOK_NAMES = new Set([
 	"useCallback",
@@ -39765,14 +40534,25 @@ const isPropsChildrenLength = (node, scopes) => {
 	const unwrappedNode = stripParenExpression(node);
 	return isNodeOfType(unwrappedNode, "MemberExpression") && !unwrappedNode.computed && isNodeOfType(unwrappedNode.property, "Identifier") && unwrappedNode.property.name === "length" && resolvesToPropsChildren(stripParenExpression(unwrappedNode.object), scopes);
 };
+const resolveStaticNumericValue = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const unwrappedNode = stripParenExpression(node);
+	if (isNodeOfType(unwrappedNode, "Literal") && typeof unwrappedNode.value === "number") return Number.isFinite(unwrappedNode.value) ? unwrappedNode.value : null;
+	if (!isNodeOfType(unwrappedNode, "Identifier")) return null;
+	const symbol = scopes.symbolFor(unwrappedNode);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return null;
+	const initializer = getDirectConstInitializer(symbol);
+	if (!initializer) return null;
+	return resolveStaticNumericValue(initializer, scopes, new Set(visitedSymbolIds).add(symbol.id));
+};
 const isLargeTextLengthComparison = (node, scopes) => {
 	const unwrappedNode = stripParenExpression(node);
 	if (!isNodeOfType(unwrappedNode, "BinaryExpression")) return false;
 	const leftIsLength = isPropsChildrenLength(unwrappedNode.left, scopes);
 	const rightIsLength = isPropsChildrenLength(unwrappedNode.right, scopes);
 	const thresholdNode = leftIsLength ? unwrappedNode.right : unwrappedNode.left;
-	if (!leftIsLength && !rightIsLength || !isNodeOfType(thresholdNode, "Literal")) return false;
-	if (typeof thresholdNode.value !== "number" || thresholdNode.value < 1e3) return false;
+	if (!leftIsLength && !rightIsLength) return false;
+	const thresholdValue = resolveStaticNumericValue(thresholdNode, scopes);
+	if (thresholdValue === null || thresholdValue < 1e3) return false;
 	return leftIsLength ? unwrappedNode.operator === ">" || unwrappedNode.operator === ">=" : unwrappedNode.operator === "<" || unwrappedNode.operator === "<=";
 };
 const isLargeStringOptimizationGuard = (comparison, scopes) => {
@@ -39859,7 +40639,7 @@ const collectEnclosingParameterNames = (handlerExpression) => {
 	const parameterNames = /* @__PURE__ */ new Set();
 	let ancestor = handlerExpression;
 	while (ancestor) {
-		if (isFunctionLike$2(ancestor)) for (const parameter of ancestor.params ?? []) collectPatternNames(parameter, parameterNames);
+		if (isFunctionLike$1(ancestor)) for (const parameter of ancestor.params ?? []) collectPatternNames(parameter, parameterNames);
 		ancestor = ancestor.parent ?? null;
 	}
 	return parameterNames;
@@ -39921,7 +40701,7 @@ const containsControlledInput = (formOpeningElement) => {
 	return didFindControlledInput;
 };
 const containsAsynchronousWork = (handlerExpression) => {
-	if (isFunctionLike$2(handlerExpression) && handlerExpression.async === true) return true;
+	if (isFunctionLike$1(handlerExpression) && handlerExpression.async === true) return true;
 	let didFindAsynchronousWork = false;
 	walkAst(handlerExpression, (child) => {
 		if (didFindAsynchronousWork) return;
@@ -40136,7 +40916,7 @@ const noPropCallbackInRender = defineRule({
 		const analysis = getProgramAnalysis(node);
 		if (!analysis) return;
 		const callee = stripParenExpression(node.callee);
-		if (isFunctionLike$2(callee)) return;
+		if (isFunctionLike$1(callee)) return;
 		if (!getDownstreamRefs(analysis, callee).some((reference) => isPropCallbackInvocationRef(analysis, reference))) return;
 		context.report({
 			node,
@@ -40319,7 +41099,7 @@ const findFreshCallInSubtree = (root) => {
 	let foundDescription = null;
 	walkAst(root, (child) => {
 		if (foundDescription) return false;
-		if (child !== root && isFunctionLike$2(child)) return false;
+		if (child !== root && isFunctionLike$1(child)) return false;
 		const description = isAlwaysFreshExpression(child);
 		if (description) {
 			foundDescription = description;
@@ -40863,7 +41643,7 @@ const isEmptySentinel = (node, scopes) => isNodeOfType(node, "Literal") && node.
 const hasRepeatedExecutionAncestor = (node, stop) => {
 	let ancestor = node.parent;
 	while (ancestor && ancestor !== stop) {
-		if (isFunctionLike$2(ancestor) || REPEATED_ANCESTOR_TYPES.has(ancestor.type)) return true;
+		if (isFunctionLike$1(ancestor) || REPEATED_ANCESTOR_TYPES.has(ancestor.type)) return true;
 		ancestor = ancestor.parent;
 	}
 	return ancestor !== stop;
@@ -40958,15 +41738,15 @@ const noRefCurrentInRender = defineRule({
 const isInsideComponentContext = (node) => {
 	let cursor = node.parent;
 	while (cursor) {
-		if (isFunctionLike$2(cursor) && isComponentFunction$1(cursor)) return true;
+		if (isFunctionLike$1(cursor) && isComponentFunction$1(cursor)) return true;
 		if (isEs5Component(cursor) || isEs6Component(cursor)) return true;
 		cursor = cursor.parent ?? null;
 	}
 	return false;
 };
 const functionBodyOf = (node) => {
-	if (isFunctionLike$2(node)) return node.body ?? null;
-	if (isNodeOfType(node, "VariableDeclarator") && node.init && isFunctionLike$2(node.init)) return node.init.body ?? null;
+	if (isFunctionLike$1(node)) return node.body ?? null;
+	if (isNodeOfType(node, "VariableDeclarator") && node.init && isFunctionLike$1(node.init)) return node.init.body ?? null;
 	return null;
 };
 const isHookCallee = (callee) => {
@@ -40978,7 +41758,7 @@ const containsHookCall = (body) => {
 	let found = false;
 	walkAst(body, (child) => {
 		if (found) return false;
-		if (child !== body && isFunctionLike$2(child) && isComponentFunction$1(child)) return false;
+		if (child !== body && isFunctionLike$1(child) && isComponentFunction$1(child)) return false;
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (isHookCallee(child.callee)) found = true;
 	});
@@ -41100,18 +41880,107 @@ const getNodeText$1 = (node) => {
 		return value;
 	});
 };
-const isLiteralConstantIdentifier = (analysis, identifier) => {
-	const definitions = getRef(analysis, identifier)?.resolved?.defs;
-	if (!definitions || definitions.length !== 1) return false;
-	const definition = definitions[0];
-	if (definition.type !== "Variable") return false;
-	const declarator = definition.node;
-	if (!isNodeOfType(declarator, "VariableDeclarator")) return false;
-	const declaration = declarator.parent;
-	if (!isNodeOfType(declaration, "VariableDeclaration") || declaration.kind !== "const") return false;
-	return isNodeOfType(declarator.init, "Literal");
+const normalizeAsBoolean = (identity) => ({
+	...identity,
+	booleanNormalization: identity.booleanNormalization === "identity" ? "normalized" : identity.booleanNormalization
+});
+const negateBoolean = (identity) => ({
+	...identity,
+	booleanNormalization: identity.booleanNormalization === "negated" ? "normalized" : "negated"
+});
+const getLivePropExpressionIdentity = (analysis, context, node, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(node);
+	if (isNodeOfType(expression, "Identifier")) {
+		const reference = getRef(analysis, expression);
+		const symbol = context.scopes.symbolFor(expression);
+		if (!reference || !symbol) return null;
+		if (isProp(analysis, reference)) return {
+			propSymbolId: symbol.id,
+			memberPath: [],
+			booleanNormalization: "identity"
+		};
+		if (visitedSymbolIds.has(symbol.id) || symbol.kind !== "const") return null;
+		visitedSymbolIds.add(symbol.id);
+		const initializer = getDirectConstInitializer(symbol);
+		if (initializer) return getLivePropExpressionIdentity(analysis, context, initializer, visitedSymbolIds);
+		return getUpstreamRefs(analysis, reference).some((upstreamReference) => isProp(analysis, upstreamReference)) ? {
+			propSymbolId: symbol.id,
+			memberPath: [],
+			booleanNormalization: "identity"
+		} : null;
+	}
+	if (isNodeOfType(expression, "MemberExpression")) {
+		const propertyName = getStaticMemberPropertyName(expression);
+		if (!propertyName) return null;
+		const objectIdentity = getLivePropExpressionIdentity(analysis, context, expression.object, visitedSymbolIds);
+		if (!objectIdentity) return null;
+		return {
+			...objectIdentity,
+			memberPath: [...objectIdentity.memberPath, propertyName]
+		};
+	}
+	if (isNodeOfType(expression, "CallExpression") && isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "Boolean" && context.scopes.isGlobalReference(expression.callee) && expression.arguments?.length === 1) {
+		const argument = expression.arguments[0];
+		const argumentIdentity = getLivePropExpressionIdentity(analysis, context, argument, visitedSymbolIds);
+		return argumentIdentity ? normalizeAsBoolean(argumentIdentity) : null;
+	}
+	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "!") {
+		const argumentIdentity = getLivePropExpressionIdentity(analysis, context, expression.argument, visitedSymbolIds);
+		return argumentIdentity ? negateBoolean(argumentIdentity) : null;
+	}
+	return null;
+};
+const isMountSnapshotInitializer = (context, node) => {
+	if (!isReactApiCall(node, "useMemo", context.scopes, { resolveNamedAliases: true }) || !isNodeOfType(node, "CallExpression")) return false;
+	const dependencies = node.arguments?.[1];
+	return isNodeOfType(dependencies, "ArrayExpression") && dependencies.elements.length === 0;
 };
-const isSetStateToInitialValue = (analysis, setterRef) => {
+const isMountSnapshotBinding = (context, identifier, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const symbol = context.scopes.symbolFor(identifier);
+	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+	visitedSymbolIds.add(symbol.id);
+	const initializer = getDirectConstInitializer(symbol);
+	if (!initializer) return false;
+	if (isMountSnapshotInitializer(context, initializer)) return true;
+	const expression = stripParenExpression(initializer);
+	return isNodeOfType(expression, "Identifier") && isMountSnapshotBinding(context, expression, visitedSymbolIds);
+};
+const isConstantBooleanExpression = (context, node, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
+	const expression = stripParenExpression(node);
+	if (isNodeOfType(expression, "Literal")) return true;
+	if (isNodeOfType(expression, "Identifier")) {
+		const symbol = context.scopes.symbolFor(expression);
+		if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
+		visitedSymbolIds.add(symbol.id);
+		const initializer = getDirectConstInitializer(symbol);
+		return Boolean(initializer && isConstantBooleanExpression(context, initializer, visitedSymbolIds));
+	}
+	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "!") return isConstantBooleanExpression(context, expression.argument, visitedSymbolIds);
+	if (isNodeOfType(expression, "CallExpression") && isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "Boolean" && context.scopes.isGlobalReference(expression.callee) && expression.arguments?.length === 1) return isConstantBooleanExpression(context, expression.arguments[0], visitedSymbolIds);
+	return false;
+};
+const isProvenLiveBinding = (analysis, context, identifier) => {
+	const reference = getRef(analysis, identifier);
+	const symbol = context.scopes.symbolFor(identifier);
+	if (!reference || !symbol || symbol.kind !== "const" || isOutsideAllFunctions(symbol)) return false;
+	const initializer = symbol.initializer;
+	if (!initializer || isMountSnapshotBinding(context, identifier)) return false;
+	if (getDownstreamRefs(analysis, initializer).some((initializerReference) => isRefCurrent(initializerReference))) return false;
+	return !isConstantBooleanExpression(context, initializer);
+};
+const areSameProvenLiveBinding = (analysis, context, left, right) => {
+	const leftExpression = stripParenExpression(left);
+	const rightExpression = stripParenExpression(right);
+	if (!isNodeOfType(leftExpression, "Identifier") || !isNodeOfType(rightExpression, "Identifier")) return false;
+	const leftSymbol = context.scopes.symbolFor(leftExpression);
+	const rightSymbol = context.scopes.symbolFor(rightExpression);
+	return Boolean(leftSymbol && leftSymbol === rightSymbol && isProvenLiveBinding(analysis, context, leftExpression));
+};
+const haveSameLivePropExpressionIdentity = (left, right) => {
+	if (left.propSymbolId !== right.propSymbolId || left.booleanNormalization !== right.booleanNormalization || left.memberPath.length !== right.memberPath.length) return false;
+	return left.memberPath.every((propertyName, index) => propertyName === right.memberPath[index]);
+};
+const isSetStateToInitialValue = (analysis, context, setterRef) => {
 	const callExpr = getCallExpr(setterRef);
 	if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) return false;
 	const setStateToValue = callExpr.arguments?.[0];
@@ -41122,7 +41991,12 @@ const isSetStateToInitialValue = (analysis, setterRef) => {
 	if (isUndefinedNode(setStateToValue) && isUndefinedNode(stateInitialValue)) return true;
 	if (setStateToValue == null && stateInitialValue == null) return true;
 	if (setStateToValue && !stateInitialValue || !setStateToValue && stateInitialValue) return false;
-	if (stateInitialValue && isNodeOfType(stateInitialValue, "Identifier") && stateInitialValue.name !== "undefined" && !isLiteralConstantIdentifier(analysis, stateInitialValue)) return false;
+	if (stateInitialValue && setStateToValue) {
+		const initialLivePropIdentity = getLivePropExpressionIdentity(analysis, context, stateInitialValue);
+		const nextLivePropIdentity = getLivePropExpressionIdentity(analysis, context, setStateToValue);
+		if (initialLivePropIdentity && nextLivePropIdentity && haveSameLivePropExpressionIdentity(initialLivePropIdentity, nextLivePropIdentity)) return false;
+		if (areSameProvenLiveBinding(analysis, context, stateInitialValue, setStateToValue)) return false;
+	}
 	return getNodeText$1(setStateToValue) === getNodeText$1(stateInitialValue);
 };
 const countUseStates = (analysis, componentNode) => {
@@ -41131,10 +42005,10 @@ const countUseStates = (analysis, componentNode) => {
 	for (const ref of getDownstreamRefs(analysis, componentNode)) if (isState(analysis, ref)) stateVariables.add(ref.resolved);
 	return stateVariables.size;
 };
-const findPropUsedToResetAllState = (analysis, effectFnRefs, depsRefs, useEffectNode, effectFn) => {
+const findPropUsedToResetAllState = (analysis, context, effectFnRefs, depsRefs, useEffectNode, effectFn) => {
 	const stateSetterRefs = effectFnRefs.filter((ref) => isSyncStateSetterCall(analysis, ref, effectFn));
 	if (stateSetterRefs.length === 0) return null;
-	if (!stateSetterRefs.every((ref) => isSetStateToInitialValue(analysis, ref))) return null;
+	if (!stateSetterRefs.every((ref) => isSetStateToInitialValue(analysis, context, ref))) return null;
 	if (stateSetterRefs.every((setterRef) => effectFnRefs.some((otherRef) => otherRef !== setterRef && otherRef.resolved === setterRef.resolved && Boolean(getCallExpr(otherRef)) && !isSyncStateSetterCall(analysis, otherRef, effectFn)))) return null;
 	const containing = findContainingNode(analysis, useEffectNode);
 	if (new Set(stateSetterRefs.map((setterRef) => setterRef.resolved)).size !== countUseStates(analysis, containing)) return null;
@@ -41158,7 +42032,7 @@ const noResetAllStateOnPropChange = defineRule({
 		if (containing && isCustomHook(containing)) return;
 		const effectFn = getEffectFn(analysis, node);
 		if (!effectFn) return;
-		if (!findPropUsedToResetAllState(analysis, effectFnRefs, depsRefs, node, effectFn)) return;
+		if (!findPropUsedToResetAllState(analysis, context, effectFnRefs, depsRefs, node, effectFn)) return;
 		context.report({
 			node,
 			message: `Your users briefly see stale state when a prop changes because this useEffect clears all state.`
@@ -41350,7 +42224,7 @@ const isTanStackServerFnHandler = (node) => {
 const isInsideServerOnlyScope = (node) => {
 	let currentNode = node.parent ?? null;
 	while (currentNode) {
-		if (isFunctionLike$2(currentNode)) {
+		if (isFunctionLike$1(currentNode)) {
 			if (hasUseServerDirective(currentNode) || isTanStackServerFnHandler(currentNode)) return true;
 		}
 		currentNode = currentNode.parent ?? null;
@@ -42185,7 +43059,7 @@ const isEffectCallbackFunction = (functionNode) => {
 	return isHookCall$2(parent, EFFECT_HOOK_NAMES$1) && getEffectCallback(parent) === functionNode;
 };
 const doesEffectCallbackReturnName = (effectCallback, name) => {
-	if (!isFunctionLike$2(effectCallback)) return false;
+	if (!isFunctionLike$1(effectCallback)) return false;
 	let isReturnedByName = false;
 	walkInsideStatementBlocks(effectCallback.body, (child) => {
 		if (isReturnedByName || !isNodeOfType(child, "ReturnStatement") || !child.argument) return;
@@ -42195,7 +43069,7 @@ const doesEffectCallbackReturnName = (effectCallback, name) => {
 	return isReturnedByName;
 };
 const isFunctionReturnedFromEffectCallback = (functionNode, effectCallback) => {
-	if (!isFunctionLike$2(effectCallback)) return false;
+	if (!isFunctionLike$1(effectCallback)) return false;
 	if (isNodeOfType(functionNode.parent, "ReturnStatement")) return true;
 	if (effectCallback.body === functionNode) return true;
 	const cleanupBindingName = getFunctionBindingName$1(functionNode);
@@ -42225,7 +43099,7 @@ const isInsideEffectCleanupReturn = (node, ownerScope) => {
 };
 const hasRefCurrentReassignmentAfterClear = (clearCall, refName) => {
 	const enclosingFunction = findEnclosingFunction$1(clearCall);
-	if (!isFunctionLike$2(enclosingFunction)) return false;
+	if (!isFunctionLike$1(enclosingFunction)) return false;
 	if (!isNodeOfType(enclosingFunction.body, "BlockStatement")) return false;
 	const clearStart = getRangeStart(clearCall);
 	if (clearStart === null) return false;
@@ -43040,7 +43914,7 @@ const isInsideAvailabilityGuard = (node, browserGlobalName, context) => {
 	let currentNode = node;
 	let parentNode = currentNode.parent;
 	while (parentNode) {
-		if (isFunctionLike$2(parentNode) && !executesDuringRender(parentNode, context.scopes)) break;
+		if (isFunctionLike$1(parentNode) && !executesDuringRender(parentNode, context.scopes)) break;
 		if (isNodeOfType(parentNode, "LogicalExpression") && (parentNode.operator === "&&" || parentNode.operator === "||") && parentNode.right === currentNode && readAvailabilityWhenPredicate(parentNode.left, browserGlobalName, context, parentNode.operator === "&&") === true) return true;
 		if (isNodeOfType(parentNode, "ConditionalExpression")) {
 			if (parentNode.consequent === currentNode && readAvailabilityWhenPredicate(parentNode.test, browserGlobalName, context, true) === true || parentNode.alternate === currentNode && readAvailabilityWhenPredicate(parentNode.test, browserGlobalName, context, false) === true) return true;
@@ -43055,7 +43929,7 @@ const isInsideAvailabilityGuard = (node, browserGlobalName, context) => {
 };
 const isAfterAvailabilityEarlyExit = (node, componentOrHookNode, browserGlobalName, context) => {
 	const enclosingFunction = findEnclosingFunction$1(node);
-	if (!enclosingFunction || enclosingFunction !== componentOrHookNode && !executesDuringRender(enclosingFunction, context.scopes) || !isFunctionLike$2(enclosingFunction) || !isNodeOfType(enclosingFunction.body, "BlockStatement")) return false;
+	if (!enclosingFunction || enclosingFunction !== componentOrHookNode && !executesDuringRender(enclosingFunction, context.scopes) || !isFunctionLike$1(enclosingFunction) || !isNodeOfType(enclosingFunction.body, "BlockStatement")) return false;
 	let currentNode = node;
 	while (currentNode !== enclosingFunction) {
 		const parentNode = currentNode.parent;
@@ -44349,7 +45223,7 @@ const isReactClassComponent = (classNode, scopes) => {
 const findEnclosingComponent = (node, scopes, controlFlow) => {
 	let walker = node.parent;
 	while (walker) {
-		if (isFunctionLike$2(walker)) {
+		if (isFunctionLike$1(walker)) {
 			const componentName = inferFunctionLikeName(walker);
 			if (componentName && isReactComponentName(componentName) && functionContainsJsxOrCreateElement(walker, scopes, controlFlow)) return {
 				component: walker,
@@ -45694,7 +46568,7 @@ const isComponentLikeFunction = (functionNode) => {
 const hasComponentLikeAncestorFunction = (node) => {
 	let cursor = node.parent;
 	while (cursor) {
-		if (isFunctionLike$2(cursor) && isComponentLikeFunction(cursor)) return true;
+		if (isFunctionLike$1(cursor) && isComponentLikeFunction(cursor)) return true;
 		cursor = cursor.parent ?? null;
 	}
 	return false;
@@ -45705,7 +46579,7 @@ const isDeclaringFunctionComponentLike = (declaringFunction) => {
 	return hasComponentLikeAncestorFunction(declaringFunction);
 };
 const destructuresChildrenAsFirstParam = (functionNode) => {
-	if (!isFunctionLike$2(functionNode)) return false;
+	if (!isFunctionLike$1(functionNode)) return false;
 	const firstParam = functionNode.params[0];
 	if (!firstParam || !isNodeOfType(firstParam, "ObjectPattern")) return false;
 	return firstParam.properties.some((property) => isNodeOfType(property, "Property") && isNodeOfType(property.key, "Identifier") && property.key.name === "children");
@@ -45720,7 +46594,7 @@ const findChildrenDestructuringFunction = (identifier, scopes) => {
 	}
 	let cursor = identifier.parent;
 	while (cursor) {
-		if (isFunctionLike$2(cursor)) {
+		if (isFunctionLike$1(cursor)) {
 			if (destructuresChildrenAsFirstParam(cursor)) return cursor;
 			return null;
 		}
@@ -47120,7 +47994,7 @@ const isListenerCollectionInitializer = (init) => {
 	return isNodeOfType(init, "NewExpression") && isNodeOfType(init.callee, "Identifier") && init.callee.name === "Set";
 };
 const functionRegistersParameterIntoCollection = (functionNode, listenerCollectionNames) => {
-	if (!isFunctionLike$2(functionNode)) return false;
+	if (!isFunctionLike$1(functionNode)) return false;
 	const firstParam = functionNode.params?.[0];
 	if (!isNodeOfType(firstParam, "Identifier")) return false;
 	const listenerParamName = firstParam.name;
@@ -47156,7 +48030,7 @@ const buildModuleScopeStoreIndex = (programRoot) => {
 		for (const declarator of unwrapped.declarations ?? []) {
 			if (!isNodeOfType(declarator.id, "Identifier")) continue;
 			const init = declarator.init ?? null;
-			if ((unwrapped.kind === "let" || unwrapped.kind === "var") && init && !isFunctionLike$2(init)) {
+			if ((unwrapped.kind === "let" || unwrapped.kind === "var") && init && !isFunctionLike$1(init)) {
 				mutableBindingNames.add(declarator.id.name);
 				continue;
 			}
@@ -47164,7 +48038,7 @@ const buildModuleScopeStoreIndex = (programRoot) => {
 				listenerCollectionNames.add(declarator.id.name);
 				continue;
 			}
-			if (init && isFunctionLike$2(init)) moduleFunctionsByName.set(declarator.id.name, init);
+			if (init && isFunctionLike$1(init)) moduleFunctionsByName.set(declarator.id.name, init);
 		}
 	}
 	const subscribeFunctionNames = /* @__PURE__ */ new Set();
@@ -47177,7 +48051,7 @@ const buildModuleScopeStoreIndex = (programRoot) => {
 const getModuleStoreSnapshotName = (useStateCall, storeIndex) => {
 	if (!isNodeOfType(useStateCall, "CallExpression")) return null;
 	let initialArgument = stripParenExpression(useStateCall.arguments?.[0]);
-	if (initialArgument && isFunctionLike$2(initialArgument) && !isNodeOfType(initialArgument.body, "BlockStatement")) initialArgument = stripParenExpression(initialArgument.body);
+	if (initialArgument && isFunctionLike$1(initialArgument) && !isNodeOfType(initialArgument.body, "BlockStatement")) initialArgument = stripParenExpression(initialArgument.body);
 	if (!isNodeOfType(initialArgument, "Identifier")) return null;
 	if (!storeIndex.mutableBindingNames.has(initialArgument.name)) return null;
 	const binding = findVariableInitializer(initialArgument, initialArgument.name);
@@ -47188,7 +48062,7 @@ const argumentForwardsSetter = (argument, setterName) => {
 	if (!argument) return false;
 	const unwrapped = stripParenExpression(argument);
 	if (isNodeOfType(unwrapped, "Identifier")) return unwrapped.name === setterName;
-	if (!isFunctionLike$2(unwrapped)) return false;
+	if (!isFunctionLike$1(unwrapped)) return false;
 	let callsSetter = false;
 	walkAst(unwrapped.body, (child) => {
 		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && child.callee.name === setterName) {
@@ -47200,7 +48074,7 @@ const argumentForwardsSetter = (argument, setterName) => {
 };
 const findModuleSubscribeCallForwardingSetter = (effectCallback, setterName, storeIndex) => {
 	let matchedCall = null;
-	walkAst((isFunctionLike$2(effectCallback) ? effectCallback.body : null) ?? effectCallback, (child) => {
+	walkAst((isFunctionLike$1(effectCallback) ? effectCallback.body : null) ?? effectCallback, (child) => {
 		if (matchedCall) return false;
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (!isNodeOfType(child.callee, "Identifier")) return;
@@ -47304,7 +48178,7 @@ const preferUseSyncExternalStore = defineRule({
 				if (!isNodeOfType(depsNode, "ArrayExpression")) continue;
 				if ((depsNode.elements?.length ?? 0) !== 0) continue;
 				const callback = getEffectCallback(effectCall);
-				if (!callback || !isFunctionLike$2(callback)) continue;
+				if (!callback || !isFunctionLike$1(callback)) continue;
 				for (const { binding, storeName } of snapshotBindings) {
 					if (reportedDeclarators.has(binding.declarator)) continue;
 					if (!findModuleSubscribeCallForwardingSetter(callback, binding.setterName, storeIndex)) continue;
@@ -47372,7 +48246,7 @@ const findLargestCoUpdatedSetterGroup = (componentBody, setterNames, initializer
 			}
 			if (hasDataCarryingWrite) largestGroupSize = Math.max(largestGroupSize, groupSetterNames.size);
 		}
-		const enteringNestedFunction = isInsideNestedFunction || isFunctionLike$2(node);
+		const enteringNestedFunction = isInsideNestedFunction || isFunctionLike$1(node);
 		const record = node;
 		for (const key of Object.keys(record)) {
 			if (key === "parent" || key === "type") continue;
@@ -47827,21 +48701,21 @@ const isTanstackQueryResult = (expression, context) => Boolean(resolveTanstackQu
 const isStaticRefetchMember = (memberExpression) => getStaticPropertyKeyName(memberExpression, { allowComputedString: true }) === "refetch";
 const resolveCalledFunction = (callee, context) => {
 	const unwrappedCallee = stripParenExpression(callee);
-	if (isFunctionLike$2(unwrappedCallee)) return unwrappedCallee;
+	if (isFunctionLike$1(unwrappedCallee)) return unwrappedCallee;
 	if (!isNodeOfType(unwrappedCallee, "Identifier")) return null;
 	const symbol = resolveConstIdentifierAlias(unwrappedCallee, context.scopes);
 	if (!symbol) return null;
 	const candidate = symbol.kind === "function" ? symbol.declarationNode : symbol.initializer;
-	return candidate && isFunctionLike$2(candidate) ? candidate : null;
+	return candidate && isFunctionLike$1(candidate) ? candidate : null;
 };
 const hasSuspensionBefore = (functionNode, boundary, context) => {
-	if (!isFunctionLike$2(functionNode)) return true;
+	if (!isFunctionLike$1(functionNode)) return true;
 	if (functionNode.generator) return true;
 	const boundaryStart = getRangeStart(boundary);
 	if (boundaryStart === null) return true;
 	let hasSuspension = false;
 	walkAst(functionNode, (node) => {
-		if (node !== functionNode && isFunctionLike$2(node)) return false;
+		if (node !== functionNode && isFunctionLike$1(node)) return false;
 		if (!isNodeOfType(node, "AwaitExpression") || !isNodeReachableWithinFunction(node, context)) return;
 		const suspensionStart = getRangeStart(node);
 		if (suspensionStart !== null && suspensionStart < boundaryStart) {
@@ -47865,7 +48739,7 @@ const functionInvokesTarget = (callerFunction, targetFunction, context, visitedF
 	visitedFunctions.add(callerFunction);
 	let invokesTarget = false;
 	walkAst(callerFunction, (node) => {
-		if (node !== callerFunction && isFunctionLike$2(node)) return false;
+		if (node !== callerFunction && isFunctionLike$1(node)) return false;
 		if (!isNodeOfType(node, "CallExpression")) return;
 		if (!isNodeReachableWithinFunction(node, context) || !isUnconditionallyExecuted(node, callerFunction, context) || !canCrossSuspension && hasSuspensionBefore(callerFunction, node, context)) return;
 		const calledFunction = resolveCalledFunction(node.callee, context);
@@ -47882,7 +48756,7 @@ const isFunctionInvokedBefore = (invokedFunction, boundary, context) => {
 	if (!boundaryFunction || boundaryStart === null) return false;
 	let isInvokedBefore = false;
 	walkAst(boundaryFunction, (node) => {
-		if (node !== boundaryFunction && isFunctionLike$2(node)) return false;
+		if (node !== boundaryFunction && isFunctionLike$1(node)) return false;
 		if (!isNodeOfType(node, "CallExpression")) return;
 		const callStart = getRangeStart(node);
 		if (callStart === null || callStart >= boundaryStart || !isNodeReachableWithinFunction(node, context) || !isUnconditionallyExecuted(node, boundaryFunction, context) || hasSuspensionBefore(boundaryFunction, node, context)) return;
@@ -47899,7 +48773,7 @@ const isFunctionInvokedAfter = (invokedFunction, boundary, callerFunction, conte
 	if (boundaryStart === null) return false;
 	let isInvokedAfter = false;
 	walkAst(callerFunction, (node) => {
-		if (node !== callerFunction && isFunctionLike$2(node)) return false;
+		if (node !== callerFunction && isFunctionLike$1(node)) return false;
 		if (!isNodeOfType(node, "CallExpression")) return;
 		const callStart = getRangeStart(node);
 		if (callStart === null || callStart <= boundaryStart || !isNodeReachableWithinFunction(node, context) || !isUnconditionallyExecuted(node, callerFunction, context)) return;
@@ -48033,7 +48907,7 @@ const queryNoQueryInEffect = defineRule({
 		if (!callback) return;
 		const effectInvokedFunctions = collectEffectInvokedFunctions(callback);
 		walkAst(callback, (child) => {
-			if (child !== callback && isFunctionLike$2(child) && !effectInvokedFunctions.has(child)) return false;
+			if (child !== callback && isFunctionLike$1(child) && !effectInvokedFunctions.has(child)) return false;
 			if (!isNodeOfType(child, "CallExpression")) return;
 			if (isTanstackRefetchCall(child, context, callback)) context.report({
 				node: child,
@@ -48623,7 +49497,7 @@ const reduxUseselectorInlineDerivation = defineRule({
 				if (!body) return;
 				const returnedExpressions = [];
 				if (isNodeOfType(body, "BlockStatement")) walkAst(body, (node) => {
-					if (node !== body && isFunctionLike$2(node)) return false;
+					if (node !== body && isFunctionLike$1(node)) return false;
 					if (isNodeOfType(node, "ReturnStatement")) {
 						if (node.argument) returnedExpressions.push(node.argument);
 						return false;
@@ -48915,7 +49789,7 @@ const renderingHydrationMismatchTime = defineRule({
 				return;
 			}
 			walkAst(node.expression, (child) => {
-				if (isFunctionLike$2(child) && !executesDuringRender(child, context.scopes)) return false;
+				if (isFunctionLike$1(child) && !executesDuringRender(child, context.scopes)) return false;
 				for (const pattern of NONDETERMINISTIC_RENDER_PATTERNS) if (pattern.matches(child)) {
 					if (hasSuppressHydrationWarningAttribute(findOpeningElementOfChild(node))) return;
 					if (isGatedByFalsyInitialState(child, context.scopes)) return;
@@ -49186,7 +50060,7 @@ const hasOwnAwait = (functionBody) => {
 	let found = false;
 	walkAst(functionBody, (child) => {
 		if (found) return;
-		if (child !== functionBody && isFunctionLike$2(child)) return false;
+		if (child !== functionBody && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "AwaitExpression")) found = true;
 	});
 	return found;
@@ -49236,7 +50110,7 @@ const hasAsyncLoadingWork = (fnBody, setterName) => {
 					return false;
 				}
 				if (setterName !== null && PROMISE_CHAIN_METHOD_NAMES.has(callee.property.name)) for (const argument of child.arguments ?? []) {
-					if (!isFunctionLike$2(argument)) continue;
+					if (!isFunctionLike$1(argument)) continue;
 					if (callsIdentifier(argument.body, setterName)) {
 						found = true;
 						return false;
@@ -49245,7 +50119,7 @@ const hasAsyncLoadingWork = (fnBody, setterName) => {
 			}
 			return;
 		}
-		if (setterName !== null && isFunctionLike$2(child)) {
+		if (setterName !== null && isFunctionLike$1(child)) {
 			const functionBody = child.body;
 			if ((Boolean(child.async) || hasOwnAwait(functionBody)) && callsIdentifier(functionBody, setterName)) {
 				found = true;
@@ -49310,7 +50184,7 @@ const collectAsyncSignalNames = (fnBody) => {
 		if (!isNodeOfType(child, "VariableDeclarator") || !isNodeOfType(child.id, "Identifier")) return;
 		const init = child.init;
 		if (!init) return;
-		if (isFunctionLike$2(init) && Boolean(init.async)) {
+		if (isFunctionLike$1(init) && Boolean(init.async)) {
 			names.add(child.id.name);
 			return;
 		}
@@ -49333,7 +50207,7 @@ const setterCalledAlongsideAsyncSignal = (fnBody, setterName) => {
 	let found = false;
 	walkAst(fnBody, (child) => {
 		if (found) return false;
-		if (!isFunctionLike$2(child)) return;
+		if (!isFunctionLike$1(child)) return;
 		const functionBody = child.body;
 		if (callsIdentifier(functionBody, setterName) && callsAnyIdentifier(functionBody, asyncSignalNames)) {
 			found = true;
@@ -49350,7 +50224,7 @@ const setterCalledInEventListenerHandler = (fnBody, setterName) => {
 		if (!isNodeOfType(child, "CallExpression") || !isNodeOfType(child.callee, "MemberExpression") || !isNodeOfType(child.callee.property, "Identifier") || child.callee.property.name !== "addEventListener") return;
 		const handler = child.arguments?.[1];
 		if (!handler) return;
-		if (isFunctionLike$2(handler)) {
+		if (isFunctionLike$1(handler)) {
 			if (callsIdentifier(handler.body, setterName)) foundInline = true;
 			return;
 		}
@@ -49361,7 +50235,7 @@ const setterCalledInEventListenerHandler = (fnBody, setterName) => {
 	let foundNamed = false;
 	walkAst(fnBody, (child) => {
 		if (foundNamed) return false;
-		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier") && handlerNames.has(child.id.name) && child.init && isFunctionLike$2(child.init) && callsIdentifier(child.init.body, setterName)) {
+		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier") && handlerNames.has(child.id.name) && child.init && isFunctionLike$1(child.init) && callsIdentifier(child.init.body, setterName)) {
 			foundNamed = true;
 			return false;
 		}
@@ -50183,6 +51057,357 @@ const rerenderMemoBeforeEarlyReturn = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/build-same-file-memo-comparator-registry.ts
+const unwrapTopLevelDeclaration = (statement) => {
+	if (isNodeOfType(statement, "ExportNamedDeclaration")) return statement.declaration;
+	return statement;
+};
+const buildSameFileMemoComparatorRegistry = (program) => {
+	const registry = /* @__PURE__ */ new Map();
+	if (!isNodeOfType(program, "Program")) return registry;
+	const memoBindings = /* @__PURE__ */ new Set();
+	const reactNamespaceBindings = /* @__PURE__ */ new Set();
+	for (const statement of program.body) {
+		if (!isNodeOfType(statement, "ImportDeclaration") || statement.source.value !== "react") continue;
+		for (const specifier of statement.specifiers) if (isNodeOfType(specifier, "ImportDefaultSpecifier") || isNodeOfType(specifier, "ImportNamespaceSpecifier")) reactNamespaceBindings.add(specifier.local.name);
+		else if (isNodeOfType(specifier, "ImportSpecifier") && getImportedName(specifier) === "memo") memoBindings.add(specifier.local.name);
+	}
+	for (const statement of program.body) {
+		const declaration = unwrapTopLevelDeclaration(statement);
+		if (!declaration || !isNodeOfType(declaration, "VariableDeclaration")) continue;
+		for (const declarator of declaration.declarations ?? []) {
+			if (!isNodeOfType(declarator, "VariableDeclarator") || !isNodeOfType(declarator.id, "Identifier") || !declarator.init) continue;
+			const initializer = stripParenExpression(declarator.init);
+			if (!isNodeOfType(initializer, "CallExpression")) continue;
+			const callee = stripParenExpression(initializer.callee);
+			const isNamedMemo = isNodeOfType(callee, "Identifier") && memoBindings.has(callee.name);
+			const isNamespaceMemo = isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.object, "Identifier") && reactNamespaceBindings.has(callee.object.name) && isNodeOfType(callee.property, "Identifier") && callee.property.name === "memo";
+			if (!isNamedMemo && !isNamespaceMemo) continue;
+			const comparator = initializer.arguments?.[1];
+			if (!comparator || isNodeOfType(comparator, "SpreadElement")) continue;
+			registry.set(declarator.id.name, {
+				bindingIdentifier: declarator.id,
+				comparator
+			});
+		}
+	}
+	return registry;
+};
+//#endregion
+//#region src/plugin/utils/comparator-proves-empty-prop-equality.ts
+const UNKNOWN_VALUE = { kind: "unknown" };
+const TRUE_VALUE = {
+	kind: "boolean",
+	value: true
+};
+const FALSE_VALUE = {
+	kind: "boolean",
+	value: false
+};
+const UNDEFINED_VALUE = { kind: "undefined" };
+const PREVIOUS_PROPS_VALUE = { kind: "previous-props" };
+const NEXT_PROPS_VALUE = { kind: "next-props" };
+const OBJECT_PROTOTYPE_PROPERTY_NAMES = new Set([
+	"__defineGetter__",
+	"__defineSetter__",
+	"__lookupGetter__",
+	"__lookupSetter__",
+	"__proto__",
+	"constructor",
+	"hasOwnProperty",
+	"isPrototypeOf",
+	"propertyIsEnumerable",
+	"toLocaleString",
+	"toString",
+	"valueOf"
+]);
+const PROVABLY_CALLABLE_GLOBAL_NAMES = new Set([
+	"Boolean",
+	"Number",
+	"String"
+]);
+const booleanValue = (value) => value ? TRUE_VALUE : FALSE_VALUE;
+const constantBooleanFormula = (value) => ({
+	kind: "constant",
+	value
+});
+const getBooleanFormula = (value) => {
+	if (value.kind === "boolean") return constantBooleanFormula(value.value === true);
+	return value.kind === "boolean-formula" && value.formula ? value.formula : null;
+};
+const booleanFormulaValue = (formula) => formula.kind === "constant" ? booleanValue(formula.value === true) : {
+	kind: "boolean-formula",
+	formula
+};
+const negateBooleanFormula = (formula) => {
+	if (formula.kind === "constant") return constantBooleanFormula(formula.value !== true);
+	if (formula.kind === "not" && formula.operand) return formula.operand;
+	return {
+		kind: "not",
+		operand: formula
+	};
+};
+const combineBooleanFormulas = (operator, left, right) => {
+	if (left.kind === "constant") {
+		if (operator === "and") return left.value === true ? right : left;
+		return left.value === true ? left : right;
+	}
+	if (right.kind === "constant") {
+		if (operator === "and") return right.value === true ? left : right;
+		return right.value === true ? right : left;
+	}
+	return {
+		kind: operator,
+		left,
+		right
+	};
+};
+const conditionalBooleanFormula = (test, consequent, alternate) => {
+	if (test.kind === "constant") return test.value === true ? consequent : alternate;
+	return {
+		kind: "conditional",
+		test,
+		consequent,
+		alternate
+	};
+};
+const collectBooleanFormulaAtomKeys = (formula, atomKeys) => {
+	if (formula.kind === "atom") {
+		if (formula.atomKey) atomKeys.add(formula.atomKey);
+		return;
+	}
+	if (formula.operand) collectBooleanFormulaAtomKeys(formula.operand, atomKeys);
+	if (formula.left) collectBooleanFormulaAtomKeys(formula.left, atomKeys);
+	if (formula.right) collectBooleanFormulaAtomKeys(formula.right, atomKeys);
+	if (formula.test) collectBooleanFormulaAtomKeys(formula.test, atomKeys);
+	if (formula.consequent) collectBooleanFormulaAtomKeys(formula.consequent, atomKeys);
+	if (formula.alternate) collectBooleanFormulaAtomKeys(formula.alternate, atomKeys);
+};
+const evaluateBooleanFormula = (formula, atomValues) => {
+	if (formula.kind === "constant") return formula.value ?? null;
+	if (formula.kind === "atom") return formula.atomKey ? atomValues.get(formula.atomKey) ?? null : null;
+	if (formula.kind === "not") {
+		const operand = formula.operand ? evaluateBooleanFormula(formula.operand, atomValues) : null;
+		return operand === null ? null : !operand;
+	}
+	if (formula.kind === "and" || formula.kind === "or") {
+		const left = formula.left ? evaluateBooleanFormula(formula.left, atomValues) : null;
+		const right = formula.right ? evaluateBooleanFormula(formula.right, atomValues) : null;
+		if (left === null || right === null) return null;
+		return formula.kind === "and" ? left && right : left || right;
+	}
+	const test = formula.test ? evaluateBooleanFormula(formula.test, atomValues) : null;
+	if (test === null) return null;
+	const branch = test ? formula.consequent : formula.alternate;
+	return branch ? evaluateBooleanFormula(branch, atomValues) : null;
+};
+const couldStableTargetReferencePreventRender = (distinctReferenceFormula, sharedReferenceFormula) => {
+	const atomKeys = /* @__PURE__ */ new Set();
+	collectBooleanFormulaAtomKeys(distinctReferenceFormula, atomKeys);
+	collectBooleanFormulaAtomKeys(sharedReferenceFormula, atomKeys);
+	if (atomKeys.size > 8) return true;
+	const orderedAtomKeys = [...atomKeys];
+	const assignmentCount = 2 ** orderedAtomKeys.length;
+	for (let assignmentIndex = 0; assignmentIndex < assignmentCount; assignmentIndex += 1) {
+		const atomValues = /* @__PURE__ */ new Map();
+		for (const [atomIndex, atomKey] of orderedAtomKeys.entries()) atomValues.set(atomKey, Boolean(assignmentIndex & 1 << atomIndex));
+		const distinctReferenceResult = evaluateBooleanFormula(distinctReferenceFormula, atomValues);
+		const sharedReferenceResult = evaluateBooleanFormula(sharedReferenceFormula, atomValues);
+		if (distinctReferenceResult === null || sharedReferenceResult === null) return true;
+		if (!distinctReferenceResult && sharedReferenceResult) return true;
+	}
+	return false;
+};
+const emptyReferenceValue = (kind, referenceOrigin) => ({
+	kind,
+	referenceOrigin
+});
+const evaluateEquality = (left, right, emptyReferencesAreEqual, equalityKind) => {
+	if (left.kind === "unknown" || right.kind === "unknown") return UNKNOWN_VALUE;
+	const leftBooleanFormula = getBooleanFormula(left);
+	const rightBooleanFormula = getBooleanFormula(right);
+	if (leftBooleanFormula || rightBooleanFormula) {
+		if (!leftBooleanFormula || !rightBooleanFormula) return UNKNOWN_VALUE;
+		return booleanFormulaValue(combineBooleanFormulas("or", combineBooleanFormulas("and", leftBooleanFormula, rightBooleanFormula), combineBooleanFormulas("and", negateBooleanFormula(leftBooleanFormula), negateBooleanFormula(rightBooleanFormula))));
+	}
+	if (left.kind === "prop-symbol" || right.kind === "prop-symbol") {
+		if (left.kind !== "prop-symbol" || right.kind !== "prop-symbol") return UNKNOWN_VALUE;
+		if (left.propOwner === right.propOwner && left.value === right.value) return TRUE_VALUE;
+		if (left.propOwner === right.propOwner || left.value !== right.value) return UNKNOWN_VALUE;
+		return booleanFormulaValue({
+			kind: "atom",
+			atomKey: `${equalityKind}:${String(left.value)}`
+		});
+	}
+	if (left.kind === "empty-array" || left.kind === "empty-object") {
+		if (left.kind !== right.kind) return FALSE_VALUE;
+		if (left.referenceOrigin === right.referenceOrigin) return TRUE_VALUE;
+		return booleanValue((left.referenceOrigin === "previous-target" && right.referenceOrigin === "next-target" || left.referenceOrigin === "next-target" && right.referenceOrigin === "previous-target") && emptyReferencesAreEqual);
+	}
+	if (right.kind === "empty-array" || right.kind === "empty-object") return FALSE_VALUE;
+	if (left.kind !== right.kind) return FALSE_VALUE;
+	if (left.kind === "previous-props" || left.kind === "next-props") return UNKNOWN_VALUE;
+	if (left.kind === "symbol" && left.value !== right.value) return UNKNOWN_VALUE;
+	return booleanValue(left.value === right.value);
+};
+const getReturnedExpression = (functionNode) => {
+	if (!isFunctionLike$1(functionNode)) return null;
+	if (isNodeOfType(functionNode, "ArrowFunctionExpression")) {
+		const body = functionNode.body;
+		if (!isNodeOfType(body, "BlockStatement")) return body;
+	}
+	const body = functionNode.body;
+	if (!isNodeOfType(body, "BlockStatement") || body.body.length !== 1) return null;
+	const returnStatement = body.body[0];
+	return isNodeOfType(returnStatement, "ReturnStatement") && returnStatement.argument ? returnStatement.argument : null;
+};
+const isProvablyCallable = (expression, state) => {
+	const node = stripParenExpression(expression);
+	if (isFunctionLike$1(node)) return true;
+	if (isNodeOfType(node, "Identifier") && PROVABLY_CALLABLE_GLOBAL_NAMES.has(node.name) && state.scopes.isGlobalReference(node)) return true;
+	return isFunctionLike$1(resolveExactLocalFunction(node, state.scopes));
+};
+const evaluateExpression = (expression, state) => {
+	const node = stripParenExpression(expression);
+	if (isNodeOfType(node, "Literal")) {
+		if (typeof node.value === "boolean") return booleanValue(node.value);
+		if (typeof node.value === "number") return {
+			kind: "number",
+			value: node.value
+		};
+		if (typeof node.value === "string") return {
+			kind: "string",
+			value: node.value
+		};
+		return node.value === void 0 ? UNDEFINED_VALUE : UNKNOWN_VALUE;
+	}
+	if (isNodeOfType(node, "Identifier")) {
+		if (node.name === "undefined" && state.scopes.isGlobalReference(node)) return UNDEFINED_VALUE;
+		return state.bindings.get(node.name) ?? UNKNOWN_VALUE;
+	}
+	if (isNodeOfType(node, "MemberExpression")) {
+		const objectValue = evaluateExpression(node.object, state);
+		if ((objectValue.kind === "empty-array" || objectValue.kind === "empty-object") && node.computed && isNodeOfType(node.property, "Literal") && (typeof node.property.value === "number" || typeof node.property.value === "string" && /^\d+$/.test(node.property.value))) return UNDEFINED_VALUE;
+		const propertyName = getStaticPropertyName(node);
+		if (propertyName === null) return UNKNOWN_VALUE;
+		if (objectValue.kind === "previous-props" || objectValue.kind === "next-props") {
+			if (propertyName === state.propName) {
+				const referenceOrigin = objectValue.kind === "previous-props" ? "previous-target" : "next-target";
+				return emptyReferenceValue(state.emptyLiteralKind === "array" ? "empty-array" : "empty-object", referenceOrigin);
+			}
+			return {
+				kind: "prop-symbol",
+				propOwner: objectValue.kind === "previous-props" ? "previous" : "next",
+				value: propertyName
+			};
+		}
+		if (objectValue.kind === "empty-array" && propertyName === "length") return {
+			kind: "number",
+			value: 0
+		};
+		if (objectValue.kind === "empty-object" && !OBJECT_PROTOTYPE_PROPERTY_NAMES.has(propertyName)) return UNDEFINED_VALUE;
+		return UNKNOWN_VALUE;
+	}
+	if (isNodeOfType(node, "UnaryExpression") && node.operator === "!") {
+		const argumentFormula = getBooleanFormula(evaluateExpression(node.argument, state));
+		return argumentFormula ? booleanFormulaValue(negateBooleanFormula(argumentFormula)) : UNKNOWN_VALUE;
+	}
+	if (isNodeOfType(node, "LogicalExpression")) {
+		const leftFormula = getBooleanFormula(evaluateExpression(node.left, state));
+		if (!leftFormula) return UNKNOWN_VALUE;
+		if (node.operator === "&&") {
+			if (leftFormula.kind === "constant" && leftFormula.value === false) return FALSE_VALUE;
+			const rightFormula = getBooleanFormula(evaluateExpression(node.right, state));
+			return rightFormula ? booleanFormulaValue(combineBooleanFormulas("and", leftFormula, rightFormula)) : UNKNOWN_VALUE;
+		}
+		if (node.operator === "||") {
+			if (leftFormula.kind === "constant" && leftFormula.value === true) return TRUE_VALUE;
+			const rightFormula = getBooleanFormula(evaluateExpression(node.right, state));
+			return rightFormula ? booleanFormulaValue(combineBooleanFormulas("or", leftFormula, rightFormula)) : UNKNOWN_VALUE;
+		}
+		return UNKNOWN_VALUE;
+	}
+	if (isNodeOfType(node, "BinaryExpression")) {
+		const left = evaluateExpression(node.left, state);
+		const right = evaluateExpression(node.right, state);
+		if ([
+			"===",
+			"==",
+			"!==",
+			"!="
+		].includes(node.operator)) {
+			const equality = evaluateEquality(left, right, state.emptyReferencesAreEqual, node.operator === "===" || node.operator === "!==" ? "strict" : "loose");
+			if (node.operator === "===" || node.operator === "==") return equality;
+			const equalityFormula = getBooleanFormula(equality);
+			return equalityFormula ? booleanFormulaValue(negateBooleanFormula(equalityFormula)) : UNKNOWN_VALUE;
+		}
+		if (left.kind !== "number" || right.kind !== "number") return UNKNOWN_VALUE;
+		if (node.operator === "<") return booleanValue(Number(left.value) < Number(right.value));
+		if (node.operator === "<=") return booleanValue(Number(left.value) <= Number(right.value));
+		if (node.operator === ">") return booleanValue(Number(left.value) > Number(right.value));
+		if (node.operator === ">=") return booleanValue(Number(left.value) >= Number(right.value));
+		return UNKNOWN_VALUE;
+	}
+	if (isNodeOfType(node, "ConditionalExpression")) {
+		const testFormula = getBooleanFormula(evaluateExpression(node.test, state));
+		if (!testFormula) return UNKNOWN_VALUE;
+		if (testFormula.kind === "constant") return evaluateExpression(testFormula.value === true ? node.consequent : node.alternate, state);
+		const consequentFormula = getBooleanFormula(evaluateExpression(node.consequent, state));
+		const alternateFormula = getBooleanFormula(evaluateExpression(node.alternate, state));
+		return consequentFormula && alternateFormula ? booleanFormulaValue(conditionalBooleanFormula(testFormula, consequentFormula, alternateFormula)) : UNKNOWN_VALUE;
+	}
+	if (!isNodeOfType(node, "CallExpression")) return UNKNOWN_VALUE;
+	const callee = stripParenExpression(node.callee);
+	if (isNodeOfType(callee, "MemberExpression")) {
+		const receiver = evaluateExpression(callee.object, state);
+		const methodName = getStaticPropertyName(callee);
+		const callback = node.arguments[0];
+		if (receiver.kind === "empty-array" && (methodName === "every" || methodName === "some") && callback && !isNodeOfType(callback, "SpreadElement") && isProvablyCallable(callback, state)) return methodName === "every" ? TRUE_VALUE : FALSE_VALUE;
+		if (isNodeOfType(callee.object, "Identifier") && callee.object.name === "Object" && state.scopes.isGlobalReference(callee.object) && (methodName === "keys" || methodName === "values") && node.arguments.length === 1 && !isNodeOfType(node.arguments[0], "SpreadElement")) {
+			if (evaluateExpression(node.arguments[0], state).kind === "empty-object") return emptyReferenceValue("empty-array", node);
+		}
+		return UNKNOWN_VALUE;
+	}
+	if (!isNodeOfType(callee, "Identifier")) return UNKNOWN_VALUE;
+	const localFunction = resolveExactLocalFunction(callee, state.scopes);
+	if (!isFunctionLike$1(localFunction) || localFunction.async || localFunction.generator || state.activeFunctions.has(localFunction)) return UNKNOWN_VALUE;
+	const returnedExpression = getReturnedExpression(localFunction);
+	if (!returnedExpression) return UNKNOWN_VALUE;
+	const parameters = localFunction.params ?? [];
+	if (parameters.length !== node.arguments.length) return UNKNOWN_VALUE;
+	const bindings = new Map(state.bindings);
+	for (const [parameterIndex, parameter] of parameters.entries()) {
+		const argument = node.arguments[parameterIndex];
+		if (!isNodeOfType(parameter, "Identifier") || !argument || isNodeOfType(argument, "SpreadElement")) return UNKNOWN_VALUE;
+		bindings.set(parameter.name, evaluateExpression(argument, state));
+	}
+	return evaluateExpression(returnedExpression, {
+		...state,
+		activeFunctions: new Set([...state.activeFunctions, localFunction]),
+		bindings
+	});
+};
+const comparatorProvesEmptyPropDoesNotBreakMemo = (comparatorExpression, propName, emptyLiteralKind, scopes) => {
+	const comparator = resolveExactLocalFunction(comparatorExpression, scopes);
+	if (!isFunctionLike$1(comparator) || comparator.async || comparator.generator) return false;
+	const returnedExpression = getReturnedExpression(comparator);
+	if (!returnedExpression) return false;
+	const parameters = comparator.params ?? [];
+	if (parameters.length !== 2 || !isNodeOfType(parameters[0], "Identifier") || !isNodeOfType(parameters[1], "Identifier")) return false;
+	const bindings = new Map([[parameters[0].name, PREVIOUS_PROPS_VALUE], [parameters[1].name, NEXT_PROPS_VALUE]]);
+	const evaluateComparator = (emptyReferencesAreEqual) => evaluateExpression(returnedExpression, {
+		activeFunctions: new Set([comparator]),
+		bindings,
+		emptyLiteralKind,
+		emptyReferencesAreEqual,
+		propName,
+		scopes
+	});
+	const distinctReferenceFormula = getBooleanFormula(evaluateComparator(false));
+	const sharedReferenceFormula = getBooleanFormula(evaluateComparator(true));
+	return Boolean(distinctReferenceFormula && sharedReferenceFormula && !couldStableTargetReferencePreventRender(distinctReferenceFormula, sharedReferenceFormula));
+};
+//#endregion
 //#region src/plugin/rules/performance/rerender-memo-with-default-value.ts
 const DEP_TAKING_HOOK_NAMES = new Set([
 	...HOOKS_WITH_DEPS,
@@ -50260,7 +51485,7 @@ const markCandidateIdentifier = (expression, candidateNames, shadowedNames, use,
 	if (!candidateNames.has(stripped.name)) return;
 	if (!into.has(stripped.name)) into.set(stripped.name, use);
 };
-const collectIdentitySensitiveUses = (node, candidateNames, shadowedNames, memoRegistry, into) => {
+const collectIdentitySensitiveUses = (node, candidateNames, shadowedNames, memoRegistry, memoComparatorRegistry, defaultedBindings, context, into) => {
 	let innerShadowedNames = shadowedNames;
 	if (isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression")) {
 		const parameterNames = /* @__PURE__ */ new Set();
@@ -50275,12 +51500,21 @@ const collectIdentitySensitiveUses = (node, candidateNames, shadowedNames, memoR
 	if (isNodeOfType(node, "JSXOpeningElement")) {
 		const openingName = node.name;
 		const memoStatus = memoStatusForJsxOpeningName(memoRegistry, openingName);
-		if (!isIntrinsicJsxElementName(openingName) && memoStatus !== "not-memoised") for (const attribute of node.attributes ?? []) {
-			if (!isNodeOfType(attribute, "JSXAttribute")) continue;
-			if (!attribute.value || !isNodeOfType(attribute.value, "JSXExpressionContainer")) continue;
-			const attributeExpression = attribute.value.expression;
-			if (!attributeExpression || attributeExpression.type === "JSXEmptyExpression") continue;
-			markCandidateIdentifier(attributeExpression, candidateNames, innerShadowedNames, "memoized-prop", into);
+		if (!isIntrinsicJsxElementName(openingName) && memoStatus !== "not-memoised") {
+			const comparatorDescriptor = isNodeOfType(openingName, "JSXIdentifier") ? memoComparatorRegistry.get(openingName.name) : void 0;
+			const comparator = comparatorDescriptor && context.scopes.symbolFor(openingName)?.bindingIdentifier === comparatorDescriptor.bindingIdentifier ? comparatorDescriptor.comparator : void 0;
+			for (const attribute of node.attributes ?? []) {
+				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
+				if (!attribute.value || !isNodeOfType(attribute.value, "JSXExpressionContainer")) continue;
+				const attributeExpression = attribute.value.expression;
+				if (!attributeExpression || attributeExpression.type === "JSXEmptyExpression") continue;
+				const strippedAttributeExpression = stripParenExpression(attributeExpression);
+				if (comparator && isNodeOfType(attribute.name, "JSXIdentifier") && isNodeOfType(strippedAttributeExpression, "Identifier") && !innerShadowedNames.has(strippedAttributeExpression.name)) {
+					const binding = defaultedBindings.get(strippedAttributeExpression.name);
+					if (binding && comparatorProvesEmptyPropDoesNotBreakMemo(comparator, attribute.name.name, binding.literalKind, context.scopes)) continue;
+				}
+				markCandidateIdentifier(attributeExpression, candidateNames, innerShadowedNames, "memoized-prop", into);
+			}
 		}
 	}
 	const nodeRecord = node;
@@ -50288,8 +51522,8 @@ const collectIdentitySensitiveUses = (node, candidateNames, shadowedNames, memoR
 		if (key === "parent") continue;
 		const child = nodeRecord[key];
 		if (Array.isArray(child)) {
-			for (const item of child) if (isAstNode(item)) collectIdentitySensitiveUses(item, candidateNames, innerShadowedNames, memoRegistry, into);
-		} else if (isAstNode(child)) collectIdentitySensitiveUses(child, candidateNames, innerShadowedNames, memoRegistry, into);
+			for (const item of child) if (isAstNode(item)) collectIdentitySensitiveUses(item, candidateNames, innerShadowedNames, memoRegistry, memoComparatorRegistry, defaultedBindings, context, into);
+		} else if (isAstNode(child)) collectIdentitySensitiveUses(child, candidateNames, innerShadowedNames, memoRegistry, memoComparatorRegistry, defaultedBindings, context, into);
 	}
 };
 const buildMessage$2 = (literalKind, use) => {
@@ -50306,13 +51540,14 @@ const rerenderMemoWithDefaultValue = defineRule({
 	recommendation: "Move it to the top of the file: `const EMPTY_ITEMS: Item[] = []`, then use that as the default value",
 	create: (context) => {
 		let memoRegistry = /* @__PURE__ */ new Map();
+		let memoComparatorRegistry = /* @__PURE__ */ new Map();
 		const checkComponentFunction = (functionNode) => {
 			if (!isNodeOfType(functionNode, "FunctionDeclaration") && !isNodeOfType(functionNode, "FunctionExpression") && !isNodeOfType(functionNode, "ArrowFunctionExpression")) return;
 			const defaultedBindings = collectDefaultedEmptyBindings(functionNode);
 			if (defaultedBindings.size === 0) return;
 			if (!functionNode.body) return;
 			const identitySensitiveUses = /* @__PURE__ */ new Map();
-			collectIdentitySensitiveUses(functionNode.body, new Set(defaultedBindings.keys()), /* @__PURE__ */ new Set(), memoRegistry, identitySensitiveUses);
+			collectIdentitySensitiveUses(functionNode.body, new Set(defaultedBindings.keys()), /* @__PURE__ */ new Set(), memoRegistry, memoComparatorRegistry, defaultedBindings, context, identitySensitiveUses);
 			for (const [bindingName, binding] of defaultedBindings) {
 				const use = identitySensitiveUses.get(bindingName);
 				if (!use) continue;
@@ -50325,6 +51560,17 @@ const rerenderMemoWithDefaultValue = defineRule({
 		return {
 			Program(node) {
 				memoRegistry = buildSameFileMemoRegistry(node);
+				memoComparatorRegistry = buildSameFileMemoComparatorRegistry(node);
+			},
+			CallExpression(node) {
+				for (const finding of findForwardedFreshHookDependencies(node, context)) {
+					if (finding.origin !== "default") continue;
+					if (finding.kind !== "array" && finding.kind !== "object") continue;
+					context.report({
+						node: finding.reportNode,
+						message: `This custom Hook default creates a new ${finding.kind} every render and forwards it to a Hook dependency.`
+					});
+				}
 			},
 			FunctionDeclaration(node) {
 				if (!node.id?.name || !isUppercaseName(node.id.name)) return;
@@ -50414,7 +51660,7 @@ const isSetterCalledDuringRender = (root, setterName) => {
 	let found = false;
 	walkAst(root, (child) => {
 		if (found) return false;
-		if (child !== root && isFunctionLike$2(child)) return false;
+		if (child !== root && isFunctionLike$1(child)) return false;
 		if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && child.callee.name === setterName) {
 			found = true;
 			return false;
@@ -50454,7 +51700,7 @@ const collectEffectDependencyInfos = (componentBody, setterNames) => {
 		const effectCallback = child.arguments?.[0];
 		if (isNodeOfType(effectCallback, "ArrowFunctionExpression") || isNodeOfType(effectCallback, "FunctionExpression")) {
 			walkAst(effectCallback.body, (bodyNode) => {
-				if (bodyNode !== effectCallback.body && isFunctionLike$2(bodyNode)) return false;
+				if (bodyNode !== effectCallback.body && isFunctionLike$1(bodyNode)) return false;
 				if (isNodeOfType(bodyNode, "CallExpression") && isNodeOfType(bodyNode.callee, "Identifier")) synchronouslyCalledFunctionNames.add(bodyNode.callee.name);
 			});
 			walkAst(effectCallback.body, (bodyNode) => {
@@ -50462,7 +51708,7 @@ const collectEffectDependencyInfos = (componentBody, setterNames) => {
 				if (!isNodeOfType(bodyNode.callee, "Identifier")) return;
 				let ancestor = bodyNode.parent;
 				while (ancestor && ancestor !== effectCallback.body) {
-					if (isFunctionLike$2(ancestor)) {
+					if (isFunctionLike$1(ancestor)) {
 						nestedCallbackCalledFunctionNames.add(bodyNode.callee.name);
 						return;
 					}
@@ -50523,7 +51769,7 @@ const hasRenderPhaseNonHookCall = (componentBody) => {
 	let didFindRenderPhaseCall = false;
 	walkAst(componentBody, (child) => {
 		if (didFindRenderPhaseCall) return false;
-		if (child !== componentBody && isFunctionLike$2(child)) return false;
+		if (child !== componentBody && isFunctionLike$1(child)) return false;
 		if (!isNodeOfType(child, "CallExpression")) return;
 		const calleeName = isNodeOfType(child.callee, "Identifier") ? child.callee.name : isNodeOfType(child.callee, "MemberExpression") && isNodeOfType(child.callee.property, "Identifier") ? child.callee.property.name : null;
 		if (calleeName !== null && isReactHookName(calleeName)) return;
@@ -52627,7 +53873,7 @@ const isReduceBuildingJsxRows = (node) => {
 	if (!isNodeOfType(node.callee, "MemberExpression")) return false;
 	if (!isNodeOfType(node.callee.property, "Identifier") || node.callee.property.name !== "reduce") return false;
 	const rowBuilder = node.arguments?.[0];
-	if (!rowBuilder || !isFunctionLike$2(rowBuilder)) return false;
+	if (!rowBuilder || !isFunctionLike$1(rowBuilder)) return false;
 	let buildsJsx = false;
 	walkAst(rowBuilder, (child) => {
 		if (isNodeOfType(child, "JSXElement")) buildsJsx = true;
@@ -56852,7 +58098,7 @@ const countOwnScopeHookCalls = (functionNode, scopes, settings, countedFunctionN
 	let count = 0;
 	walkAst(functionNode, (child) => {
 		if (child === functionNode) return;
-		if (isFunctionLike$2(child)) return false;
+		if (isFunctionLike$1(child)) return false;
 		if (!isHookCall$1(child, scopes, settings)) return;
 		if (isNodeOfType(child, "CallExpression") && isLocalNonHookFunctionCallee(child, scopes, settings, countedFunctionNodes)) return;
 		count += 1;
@@ -56866,7 +58112,7 @@ const isLocalNonHookFunctionCallee = (call, scopes, settings, countedFunctionNod
 	if (!isNodeOfType(callee, "Identifier")) return false;
 	const symbol = scopes.symbolFor(callee);
 	if (!symbol) return false;
-	const localFunction = symbol.initializer && isFunctionLike$2(symbol.initializer) ? symbol.initializer : null;
+	const localFunction = symbol.initializer && isFunctionLike$1(symbol.initializer) ? symbol.initializer : null;
 	if (!localFunction) return false;
 	return countOwnScopeHookCalls(localFunction, scopes, settings, countedFunctionNodes) === 0;
 };
@@ -56941,7 +58187,7 @@ const isInsideLoop = (descendant, ancestor) => {
 const findEnclosingComponentOrHookFunction = (node) => {
 	let current = node.parent;
 	while (current) {
-		if (isFunctionLike$2(current)) {
+		if (isFunctionLike$1(current)) {
 			if (isReactHocCallbackArgument(current)) return current;
 			const resolvedName = inferFunctionName(current);
 			if (resolvedName !== null && isComponentOrHookDisplayName(resolvedName, current)) return current;
@@ -56963,7 +58209,7 @@ const isCallbackArgumentForAllowedEffectEventHook = (functionNode, additionalEff
 const isInsideAllowedEffectEventCallback = (node, additionalEffectHooksRegex) => {
 	let current = node.parent;
 	while (current) {
-		if (isFunctionLike$2(current) && isCallbackArgumentForAllowedEffectEventHook(current, additionalEffectHooksRegex)) return true;
+		if (isFunctionLike$1(current) && isCallbackArgumentForAllowedEffectEventHook(current, additionalEffectHooksRegex)) return true;
 		current = current.parent ?? null;
 	}
 	return false;
@@ -57379,7 +58625,7 @@ const isNonPrivilegedServerAction = (functionNode) => {
 	let hasPrivilegedEffect = false;
 	walkAst(functionBody, (child) => {
 		if (hasPrivilegedEffect) return false;
-		if (child !== functionBody && isFunctionLike$2(child)) return false;
+		if (child !== functionBody && isFunctionLike$1(child)) return false;
 		if (isCacheOrNavigationCall(child)) {
 			hasNonDataEffectCall = true;
 			return;
@@ -57451,7 +58697,7 @@ const containsAuthCheck = (rootNodes, allowedFunctionNames, genericMethodNames)
 	let foundAuthCall = false;
 	for (const rootNode of rootNodes) walkAst(rootNode, (child) => {
 		if (foundAuthCall) return;
-		if (isFunctionLike$2(child)) return false;
+		if (isFunctionLike$1(child)) return false;
 		if (!isNodeOfType(child, "CallExpression")) return;
 		if (getAuthCallName(child, allowedFunctionNames, genericMethodNames)) foundAuthCall = true;
 	});
@@ -57902,7 +59148,7 @@ const serverHoistStaticIo = defineRule({
 		ExportDefaultDeclaration(node) {
 			if (!isInProjectDirectory(context, "pages/api")) return;
 			const declaration = node.declaration;
-			if (!isFunctionLike$2(declaration)) return;
+			if (!isFunctionLike$1(declaration)) return;
 			if (!declaration.async) return;
 			const body = declaration.body;
 			if (!isNodeOfType(body, "BlockStatement")) return;
@@ -58085,7 +59331,7 @@ const isKnownPropertyObjectMutation = (callExpression, methodName, writablePrope
 const runsAfterModuleInitialization = (node, boundaryNode = null) => {
 	let ancestor = node.parent;
 	while (ancestor && ancestor !== boundaryNode) {
-		if (isFunctionLike$2(ancestor) && !isImmediatelyInvokedFunction(ancestor)) return true;
+		if (isFunctionLike$1(ancestor) && !isImmediatelyInvokedFunction(ancestor)) return true;
 		ancestor = ancestor.parent ?? null;
 	}
 	return false;
@@ -58105,7 +59351,7 @@ const isMutatedThroughCallArgument = (referenceIdentifier, scopes, mayFollowCall
 	const calleeSymbol = scopes.symbolFor(callee);
 	if (!calleeSymbol) return false;
 	const calleeFunction = calleeSymbol.initializer;
-	if (!isFunctionLike$2(calleeFunction)) return false;
+	if (!isFunctionLike$1(calleeFunction)) return false;
 	const parameter = calleeFunction.params?.[referenceArgumentIndex];
 	if (!parameter || !isNodeOfType(parameter, "Identifier")) return false;
 	const parameterSymbol = scopes.symbolFor(parameter);
@@ -59287,8 +60533,8 @@ const tanstackStartNoNavigateInRender = defineRule({
 		};
 		const isEventHandlerAttribute = (node) => isNodeOfType(node, "JSXAttribute") && isNodeOfType(node.name, "JSXIdentifier") && REACT_HANDLER_PROP_PATTERN.test(node.name.name);
 		const isEventHandlerNamedProperty = (node) => isNodeOfType(node, "Property") && (isNodeOfType(node.key, "Identifier") && typeof node.key.name === "string" && REACT_HANDLER_PROP_PATTERN.test(node.key.name) || isNodeOfType(node.key, "Literal") && typeof node.key.value === "string" && REACT_HANDLER_PROP_PATTERN.test(node.key.value));
-		const isEventHandlerProperty = (node) => isNodeOfType(node, "Property") && isFunctionLike$2(node.value) && isEventHandlerNamedProperty(node);
-		const isHandlerNamedVariableDeclarator = (node) => isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && typeof node.id.name === "string" && HANDLER_FUNCTION_NAME_PATTERN.test(node.id.name) && isFunctionLike$2(node.init);
+		const isEventHandlerProperty = (node) => isNodeOfType(node, "Property") && isFunctionLike$1(node.value) && isEventHandlerNamedProperty(node);
+		const isHandlerNamedVariableDeclarator = (node) => isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && typeof node.id.name === "string" && HANDLER_FUNCTION_NAME_PATTERN.test(node.id.name) && isFunctionLike$1(node.init);
 		const isHandlerNamedFunctionDeclaration = (node) => isNodeOfType(node, "FunctionDeclaration") && isNodeOfType(node.id, "Identifier") && typeof node.id.name === "string" && HANDLER_FUNCTION_NAME_PATTERN.test(node.id.name);
 		const isInsideEventHandlerValue = (identifier) => {
 			let cursor = identifier.parent;
@@ -59466,7 +60712,7 @@ const tanstackStartNoUseEffectFetch = defineRule({
 			const effectInvokedFunctions = collectEffectInvokedFunctions(callback);
 			walkAst(callback, (child) => {
 				if (hasFetchCall) return false;
-				if (child !== callback && isFunctionLike$2(child) && !effectInvokedFunctions.has(child)) return false;
+				if (child !== callback && isFunctionLike$1(child) && !effectInvokedFunctions.has(child)) return false;
 				if (isNodeOfType(child, "CallExpression") && isNodeOfType(child.callee, "Identifier") && child.callee.name === "fetch") hasFetchCall = true;
 			});
 			if (hasFetchCall) context.report({
@@ -65041,387 +66287,6 @@ const wrapReactNativeRule = (rule) => {
 	};
 };
 //#endregion
-//#region src/plugin/semantic/control-flow-graph.ts
-let nextBlockId = 0;
-const createBlock = (builder) => {
-	const block = {
-		id: nextBlockId++,
-		nodes: [],
-		successors: [],
-		predecessors: []
-	};
-	builder.blocks.push(block);
-	return block;
-};
-const addEdge = (from, to, kind) => {
-	const edge = {
-		from,
-		to,
-		kind
-	};
-	from.successors.push(edge);
-	to.predecessors.push(edge);
-};
-const appendNode = (builder, block, node) => {
-	block.nodes.push(node);
-	if (!builder.nodeBlock.has(node)) builder.nodeBlock.set(node, block);
-};
-const mapDescendantsToBlock = (builder, node, block) => {
-	builder.nodeBlock.set(node, block);
-	if (isFunctionLike$2(node)) {
-		builder.nestedFunctions.push(node);
-		return;
-	}
-	const record = node;
-	for (const key of Object.keys(record)) {
-		if (key === "parent") continue;
-		const child = record[key];
-		if (Array.isArray(child)) {
-			for (const item of child) if (isAstNode(item)) mapDescendantsToBlock(builder, item, block);
-		} else if (isAstNode(child)) mapDescendantsToBlock(builder, child, block);
-	}
-};
-const hasInternalControlFlow = (node) => {
-	switch (node.type) {
-		case "IfStatement":
-		case "WhileStatement":
-		case "DoWhileStatement":
-		case "ForStatement":
-		case "ForInStatement":
-		case "ForOfStatement":
-		case "SwitchStatement":
-		case "TryStatement":
-		case "ReturnStatement":
-		case "ThrowStatement":
-		case "BreakStatement":
-		case "ContinueStatement":
-		case "BlockStatement":
-		case "LabeledStatement": return true;
-		default: return false;
-	}
-};
-const findLabel = (builder, name) => {
-	if (name === null) {
-		if (builder.loopStack.length > 0) {
-			const top = builder.loopStack[builder.loopStack.length - 1];
-			return {
-				merge: top.merge,
-				header: top.header
-			};
-		}
-		if (builder.switchStack.length > 0) return {
-			merge: builder.switchStack[builder.switchStack.length - 1].merge,
-			header: null
-		};
-		return null;
-	}
-	for (let i = builder.labelStack.length - 1; i >= 0; i--) {
-		const entry = builder.labelStack[i];
-		if (entry.label === name) return {
-			merge: entry.merge,
-			header: entry.header
-		};
-	}
-	return null;
-};
-const buildStatements = (builder, statements, current) => {
-	let cursor = current;
-	for (const statement of statements) cursor = buildStatement(builder, statement, cursor);
-	return cursor;
-};
-const buildStatement = (builder, statement, current) => {
-	builder.nodeBlock.set(statement, current);
-	if (!hasInternalControlFlow(statement)) {
-		appendNode(builder, current, statement);
-		mapDescendantsToBlock(builder, statement, current);
-		return current;
-	}
-	if (isNodeOfType(statement, "BlockStatement")) return buildStatements(builder, statement.body, current);
-	if (isNodeOfType(statement, "LabeledStatement")) {
-		const merge = createBlock(builder);
-		const labelEntry = {
-			label: statement.label.name,
-			merge,
-			header: null
-		};
-		builder.labelStack.push(labelEntry);
-		const body = statement.body;
-		const end = buildStatement(builder, body, current);
-		builder.labelStack.pop();
-		addEdge(end, merge, "uncond");
-		return merge;
-	}
-	if (isNodeOfType(statement, "ReturnStatement")) {
-		if (statement.argument) mapDescendantsToBlock(builder, statement.argument, current);
-		addEdge(current, builder.exit, "uncond");
-		return createBlock(builder);
-	}
-	if (isNodeOfType(statement, "ThrowStatement")) {
-		if (statement.argument) mapDescendantsToBlock(builder, statement.argument, current);
-		const top = builder.tryStack[builder.tryStack.length - 1];
-		if (top?.catch) addEdge(current, top.catch, "uncond");
-		else if (top?.finally) addEdge(current, top.finally, "uncond");
-		else addEdge(current, builder.exit, "throw");
-		return createBlock(builder);
-	}
-	if (isNodeOfType(statement, "BreakStatement")) {
-		const target = findLabel(builder, statement.label ? statement.label.name : null);
-		if (target) addEdge(current, target.merge, "uncond");
-		else addEdge(current, builder.exit, "uncond");
-		return createBlock(builder);
-	}
-	if (isNodeOfType(statement, "ContinueStatement")) {
-		const target = findLabel(builder, statement.label ? statement.label.name : null);
-		if (target?.header) addEdge(current, target.header, "uncond");
-		return createBlock(builder);
-	}
-	if (isNodeOfType(statement, "IfStatement")) {
-		mapDescendantsToBlock(builder, statement.test, current);
-		const thenBlock = createBlock(builder);
-		const merge = createBlock(builder);
-		addEdge(current, thenBlock, "cond");
-		addEdge(buildStatement(builder, statement.consequent, thenBlock), merge, "uncond");
-		if (statement.alternate) {
-			const elseBlock = createBlock(builder);
-			addEdge(current, elseBlock, "cond");
-			addEdge(buildStatement(builder, statement.alternate, elseBlock), merge, "uncond");
-		} else addEdge(current, merge, "cond");
-		return merge;
-	}
-	if (isNodeOfType(statement, "WhileStatement") || isNodeOfType(statement, "DoWhileStatement")) {
-		const isDoWhile = isNodeOfType(statement, "DoWhileStatement");
-		mapDescendantsToBlock(builder, statement.test, current);
-		const header = createBlock(builder);
-		const body = createBlock(builder);
-		const merge = createBlock(builder);
-		if (isDoWhile) addEdge(current, body, "uncond");
-		else {
-			addEdge(current, header, "uncond");
-			addEdge(header, body, "cond");
-			addEdge(header, merge, "cond");
-		}
-		builder.loopStack.push({
-			header,
-			merge,
-			label: null
-		});
-		const bodyEnd = buildStatement(builder, statement.body, body);
-		builder.loopStack.pop();
-		if (isDoWhile) {
-			addEdge(bodyEnd, header, "uncond");
-			addEdge(header, body, "cond");
-			addEdge(header, merge, "cond");
-		} else addEdge(bodyEnd, header, "uncond");
-		return merge;
-	}
-	if (isNodeOfType(statement, "ForStatement")) {
-		if (statement.init) mapDescendantsToBlock(builder, statement.init, current);
-		if (statement.test) mapDescendantsToBlock(builder, statement.test, current);
-		const header = createBlock(builder);
-		const body = createBlock(builder);
-		const merge = createBlock(builder);
-		addEdge(current, header, "uncond");
-		addEdge(header, body, "cond");
-		addEdge(header, merge, "cond");
-		builder.loopStack.push({
-			header,
-			merge,
-			label: null
-		});
-		const bodyEnd = buildStatement(builder, statement.body, body);
-		builder.loopStack.pop();
-		if (statement.update) mapDescendantsToBlock(builder, statement.update, header);
-		addEdge(bodyEnd, header, "uncond");
-		return merge;
-	}
-	if (isNodeOfType(statement, "ForInStatement") || isNodeOfType(statement, "ForOfStatement")) {
-		mapDescendantsToBlock(builder, statement.right, current);
-		mapDescendantsToBlock(builder, statement.left, current);
-		const header = createBlock(builder);
-		const body = createBlock(builder);
-		const merge = createBlock(builder);
-		addEdge(current, header, "uncond");
-		addEdge(header, body, "cond");
-		addEdge(header, merge, "cond");
-		builder.loopStack.push({
-			header,
-			merge,
-			label: null
-		});
-		const bodyEnd = buildStatement(builder, statement.body, body);
-		builder.loopStack.pop();
-		addEdge(bodyEnd, header, "uncond");
-		return merge;
-	}
-	if (isNodeOfType(statement, "SwitchStatement")) {
-		mapDescendantsToBlock(builder, statement.discriminant, current);
-		const merge = createBlock(builder);
-		builder.switchStack.push({
-			merge,
-			label: null
-		});
-		let previousCaseEnd = null;
-		let hasDefault = false;
-		for (const switchCase of statement.cases) {
-			const caseBlock = createBlock(builder);
-			addEdge(current, caseBlock, "cond");
-			if (previousCaseEnd) addEdge(previousCaseEnd, caseBlock, "uncond");
-			previousCaseEnd = buildStatements(builder, switchCase.consequent, caseBlock);
-			if (switchCase.test === null) hasDefault = true;
-		}
-		builder.switchStack.pop();
-		if (previousCaseEnd) addEdge(previousCaseEnd, merge, "uncond");
-		if (!hasDefault) addEdge(current, merge, "cond");
-		return merge;
-	}
-	if (isNodeOfType(statement, "TryStatement")) {
-		const tryBlock = createBlock(builder);
-		const merge = createBlock(builder);
-		let catchBlock = null;
-		let finallyBlock = null;
-		if (statement.handler) catchBlock = createBlock(builder);
-		if (statement.finalizer) finallyBlock = createBlock(builder);
-		addEdge(current, tryBlock, "uncond");
-		builder.tryStack.push({
-			catch: catchBlock,
-			finally: finallyBlock
-		});
-		const tryEnd = buildStatements(builder, statement.block.body, tryBlock);
-		builder.tryStack.pop();
-		if (catchBlock) addEdge(tryBlock, catchBlock, "cond");
-		if (statement.handler && catchBlock) {
-			const handlerBody = statement.handler.body;
-			const catchEnd = buildStatement(builder, handlerBody, catchBlock);
-			if (finallyBlock) addEdge(catchEnd, finallyBlock, "uncond");
-			else addEdge(catchEnd, merge, "uncond");
-		}
-		if (finallyBlock && statement.finalizer) {
-			addEdge(tryEnd, finallyBlock, "uncond");
-			addEdge(buildStatements(builder, statement.finalizer.body, finallyBlock), merge, "uncond");
-		} else addEdge(tryEnd, merge, "uncond");
-		return merge;
-	}
-	appendNode(builder, current, statement);
-	mapDescendantsToBlock(builder, statement, current);
-	return current;
-};
-const buildFunctionCfg = (functionNode, body, nestedFunctionSink) => {
-	const builder = {
-		blocks: [],
-		entry: null,
-		exit: null,
-		nestedFunctions: nestedFunctionSink,
-		nodeBlock: /* @__PURE__ */ new Map(),
-		loopStack: [],
-		switchStack: [],
-		tryStack: [],
-		labelStack: []
-	};
-	const entry = createBlock(builder);
-	const exit = createBlock(builder);
-	builder.entry = entry;
-	builder.exit = exit;
-	let bodyEnd;
-	if (isNodeOfType(body, "BlockStatement")) bodyEnd = buildStatements(builder, body.body, entry);
-	else {
-		mapDescendantsToBlock(builder, body, entry);
-		bodyEnd = entry;
-	}
-	addEdge(bodyEnd, exit, "uncond");
-	return {
-		owner: functionNode,
-		entry,
-		exit,
-		blocks: builder.blocks,
-		blockOf: (node) => builder.nodeBlock.get(node) ?? null
-	};
-};
-const computeUnconditionalSet = (cfg) => {
-	const reachableFromEntry = (excluded) => {
-		const visited = /* @__PURE__ */ new Set();
-		const queue = [];
-		if (cfg.entry !== excluded) queue.push(cfg.entry);
-		while (queue.length > 0) {
-			const block = queue.shift();
-			if (visited.has(block)) continue;
-			visited.add(block);
-			for (const edge of block.successors) {
-				if (edge.kind === "throw") continue;
-				if (edge.to === excluded) continue;
-				queue.push(edge.to);
-			}
-		}
-		return visited;
-	};
-	const reachableFromEntryFull = reachableFromEntry(null);
-	const unconditional = /* @__PURE__ */ new Set();
-	unconditional.add(cfg.entry);
-	unconditional.add(cfg.exit);
-	for (const block of cfg.blocks) {
-		if (unconditional.has(block)) continue;
-		if (!reachableFromEntryFull.has(block)) {
-			unconditional.add(block);
-			continue;
-		}
-		if (!reachableFromEntry(block).has(cfg.exit)) unconditional.add(block);
-	}
-	return unconditional;
-};
-const analyzeControlFlow = (program) => {
-	nextBlockId = 0;
-	const functionCfgs = /* @__PURE__ */ new Map();
-	const pendingFunctions = [];
-	const buildFor = (functionNode, body) => {
-		const cfg = buildFunctionCfg(functionNode, body, pendingFunctions);
-		functionCfgs.set(functionNode, {
-			cfg,
-			unconditionalSet: computeUnconditionalSet(cfg)
-		});
-	};
-	if (isNodeOfType(program, "Program")) buildFor(program, {
-		type: "BlockStatement",
-		body: program.body
-	});
-	for (let functionIndex = 0; functionIndex < pendingFunctions.length; functionIndex += 1) {
-		const functionNode = pendingFunctions[functionIndex];
-		if (!isFunctionLike$2(functionNode) || !functionNode.body || functionCfgs.has(functionNode)) continue;
-		buildFor(functionNode, functionNode.body);
-	}
-	const getFunctionEntry = (functionNode) => {
-		const existingEntry = functionCfgs.get(functionNode);
-		if (existingEntry) return existingEntry;
-		if (!isFunctionLike$2(functionNode) || !functionNode.body) return null;
-		buildFor(functionNode, functionNode.body);
-		return functionCfgs.get(functionNode) ?? null;
-	};
-	const enclosingFunction = (node) => {
-		let current = node;
-		while (current) {
-			if (isFunctionLike$2(current)) return current;
-			if (isNodeOfType(current, "Program")) return current;
-			current = current.parent ?? null;
-		}
-		return null;
-	};
-	const cfgFor = (functionLike) => {
-		return getFunctionEntry(functionLike)?.cfg ?? null;
-	};
-	const isUnconditionalFromEntry = (node) => {
-		const owner = enclosingFunction(node);
-		if (!owner) return true;
-		const entry = getFunctionEntry(owner);
-		if (!entry) return true;
-		const block = entry.cfg.blockOf(node);
-		if (!block) return true;
-		return entry.unconditionalSet.has(block);
-	};
-	return {
-		cfgFor,
-		enclosingFunction,
-		isUnconditionalFromEntry
-	};
-};
-//#endregion
 //#region src/plugin/utils/wrap-with-semantic-context.ts
 const buildFallbackScopes = () => ({
 	rootScope: {
@@ -65623,6 +66488,7 @@ const REACT_COMPILER_RULES = toRuleMap(collectExternalRulesBySource("react-compi
 //#region src/plugin/constants/cross-file-rule-ids.ts
 const CROSS_FILE_RULE_IDS = new Set([
 	"client-passive-event-listeners",
+	"exhaustive-deps",
 	"no-barrel-import",
 	"nextjs-missing-metadata",
 	"nextjs-no-use-search-params-without-suspense",
@@ -65636,11 +66502,13 @@ const CROSS_FILE_RULE_IDS = new Set([
 	"no-derived-state",
 	"no-derived-state-effect",
 	"no-event-handler",
+	"no-effect-with-fresh-deps",
 	"no-initialize-state",
 	"no-mutating-reducer-state",
 	"no-unguarded-browser-global-in-render-or-hook-init",
 	"prefer-dynamic-import",
 	"rendering-hydration-mismatch-time",
+	"rerender-memo-with-default-value",
 	"rn-no-legacy-shadow-styles",
 	"rn-no-raw-text",
 	"rn-prefer-expo-image",
@@ -65693,6 +66561,46 @@ const collectNextjsSearchParamsDependencies = ({ absoluteFilePath, staticImports
 const collectEffectValueHelperDependencies = ({ absoluteFilePath, staticImports }) => {
 	for (const entry of flattenImportEntries(staticImports)) resolveCrossFileFunctionExport(absoluteFilePath, entry.source, entry.exportedName);
 };
+const flattenProgramImportEntries = (program) => {
+	const entries = [];
+	for (const statement of program.body ?? []) {
+		if (statement.type !== "ImportDeclaration") continue;
+		const source = statement.source?.value;
+		if (typeof source !== "string") continue;
+		for (const specifier of statement.specifiers ?? []) if (specifier.type === "ImportDefaultSpecifier") entries.push({
+			source,
+			exportedName: "default"
+		});
+		else if (specifier.type === "ImportSpecifier") {
+			const imported = specifier.imported;
+			let exportedName = null;
+			if (typeof imported?.name === "string") exportedName = imported.name;
+			else if (typeof imported?.value === "string") exportedName = imported.value;
+			if (exportedName) entries.push({
+				source,
+				exportedName
+			});
+		}
+	}
+	return entries;
+};
+const collectForwardedHookDependencies = ({ absoluteFilePath, staticImports }) => {
+	const greatestTraversedDepthByFilePath = /* @__PURE__ */ new Map();
+	const collectProgramDependencies = (filePath, program, remainingDepth) => {
+		if ((greatestTraversedDepthByFilePath.get(filePath) ?? -1) >= remainingDepth) return;
+		greatestTraversedDepthByFilePath.set(filePath, remainingDepth);
+		for (const entry of flattenProgramImportEntries(program)) {
+			const resolved = resolveCrossFileValueExportWithFilePath(filePath, entry.source, entry.exportedName);
+			if (!resolved || remainingDepth === 0) continue;
+			collectProgramDependencies(resolved.filePath, resolved.programNode, remainingDepth - 1);
+		}
+	};
+	for (const entry of flattenImportEntries(staticImports)) {
+		const resolved = resolveCrossFileValueExportWithFilePath(absoluteFilePath, entry.source, entry.exportedName);
+		if (!resolved) continue;
+		collectProgramDependencies(resolved.filePath, resolved.programNode, 4);
+	}
+};
 const collectMutatingReducerDependencies = ({ absoluteFilePath, sourceText, staticImports, program }) => {
 	const namedUseReducerLocals = /* @__PURE__ */ new Set();
 	const reactObjectLocals = /* @__PURE__ */ new Set();
@@ -65771,6 +66679,7 @@ const collectLegacyArchDependencies = ({ absoluteFilePath }) => {
 };
 const CROSS_FILE_DEPENDENCY_COLLECTORS = new Map([
 	["client-passive-event-listeners", collectEffectValueHelperDependencies],
+	["exhaustive-deps", collectForwardedHookDependencies],
 	["no-barrel-import", collectNoBarrelImportDependencies],
 	["nextjs-missing-metadata", collectNextjsMissingMetadataDependencies],
 	["nextjs-no-use-search-params-without-suspense", collectNextjsSearchParamsDependencies],
@@ -65784,11 +66693,13 @@ const CROSS_FILE_DEPENDENCY_COLLECTORS = new Map([
 	["no-derived-state", collectEffectValueHelperDependencies],
 	["no-derived-state-effect", collectEffectValueHelperDependencies],
 	["no-event-handler", collectEffectValueHelperDependencies],
+	["no-effect-with-fresh-deps", collectForwardedHookDependencies],
 	["no-initialize-state", collectEffectValueHelperDependencies],
 	["no-mutating-reducer-state", collectMutatingReducerDependencies],
 	["no-unguarded-browser-global-in-render-or-hook-init", collectNearestManifestDependencies],
 	["prefer-dynamic-import", collectNearestManifestDependencies],
 	["rendering-hydration-mismatch-time", collectNearestManifestDependencies],
+	["rerender-memo-with-default-value", collectForwardedHookDependencies],
 	["rn-no-legacy-shadow-styles", collectLegacyArchDependencies],
 	["rn-no-raw-text", collectRnNoRawTextDependencies],
 	["rn-prefer-expo-image", collectNearestManifestDependencies],