oxlint-plugin-react-doctor 0.7.7-dev.79abd71 → 0.7.7-dev.89dbf08

package/dist/index.js

@@ -7,13 +7,6 @@ import { analyze } from "eslint-scope";
 //#region src/plugin/utils/is-node-of-type.ts
 const isNodeOfType = (node, type) => node !== null && typeof node === "object" && "type" in node && node.type === type;
 //#endregion
-//#region src/plugin/utils/is-type-only-import.ts
-const isEverySpecifierInlineType = (specifiers, specifierType, kindField) => {
-	if (!specifiers || specifiers.length === 0) return false;
-	return specifiers.every((specifier) => isNodeOfType(specifier, specifierType) && specifier[kindField] === "type");
-};
-const isTypeOnlyImport = (node) => node.importKind === "type" || isEverySpecifierInlineType(node.specifiers, "ImportSpecifier", "importKind");
-//#endregion
 //#region src/plugin/utils/non-react-jsx-dialect.ts
 const NON_REACT_JSX_DIALECT_PACKAGES = new Set([
 	"solid-js",
@@ -28,33 +21,17 @@ const NON_REACT_JSX_DIALECT_PACKAGES = new Set([
 	"vidode"
 ]);
 const NON_REACT_JSX_DIALECT_PACKAGE_PREFIXES = ["solid-js", "@builder.io/qwik"];
-const REACT_JSX_DIALECT_PACKAGE_PREFIXES = [
-	"react",
-	"react-dom",
-	"preact"
-];
 const startsWithAny = (source, prefixes) => prefixes.some((prefix) => source === prefix || source.startsWith(`${prefix}/`));
-const collectJsxRuntimeImports = (program) => {
-	let hasNonReactRuntime = false;
-	let hasReactRuntime = false;
+const fileImportsNonReactJsxDialect = (program) => {
 	for (const statement of program.body) {
 		if (!isNodeOfType(statement, "ImportDeclaration")) continue;
-		const importDeclaration = statement;
-		if (isTypeOnlyImport(importDeclaration)) continue;
-		const source = importDeclaration.source;
+		const source = statement.source;
 		const value = source && typeof source.value === "string" ? source.value : null;
 		if (!value) continue;
-		if (NON_REACT_JSX_DIALECT_PACKAGES.has(value) || startsWithAny(value, NON_REACT_JSX_DIALECT_PACKAGE_PREFIXES)) hasNonReactRuntime = true;
-		if (startsWithAny(value, REACT_JSX_DIALECT_PACKAGE_PREFIXES)) hasReactRuntime = true;
+		if (NON_REACT_JSX_DIALECT_PACKAGES.has(value)) return true;
+		if (startsWithAny(value, NON_REACT_JSX_DIALECT_PACKAGE_PREFIXES)) return true;
 	}
-	return {
-		hasNonReactRuntime,
-		hasReactRuntime
-	};
-};
-const fileImportsNonReactJsxDialect = (program) => {
-	const runtimeImports = collectJsxRuntimeImports(program);
-	return runtimeImports.hasNonReactRuntime && !runtimeImports.hasReactRuntime;
+	return false;
 };
 const jsxAttributeIsNonReactDialectMarker = (openingNode) => {
 	for (const attribute of openingNode.attributes) {
@@ -267,7 +244,6 @@ const VISITOR_NODE_NAME_PATTERN = /^[A-Z]/;
 const wrapCreateForReactJsxOnly = (create) => ((context) => {
 	const innerVisitors = create(context);
 	let fileIsNonReactJsx = false;
-	let fileImportsReactRuntime = false;
 	const wrappedVisitors = {};
 	for (const [key, visitor] of Object.entries(innerVisitors)) {
 		if (typeof visitor !== "function") {
@@ -280,16 +256,14 @@ const wrapCreateForReactJsxOnly = (create) => ((context) => {
 		}
 		if (key === "Program") {
 			wrappedVisitors.Program = (node) => {
-				const runtimeImports = collectJsxRuntimeImports(node);
-				fileImportsReactRuntime = runtimeImports.hasReactRuntime;
-				fileIsNonReactJsx = runtimeImports.hasNonReactRuntime && !runtimeImports.hasReactRuntime;
+				fileIsNonReactJsx = fileImportsNonReactJsxDialect(node);
 				visitor(node);
 			};
 			continue;
 		}
 		if (key === "JSXOpeningElement") {
 			wrappedVisitors.JSXOpeningElement = (node) => {
-				if (!fileImportsReactRuntime && !fileIsNonReactJsx && jsxAttributeIsNonReactDialectMarker(node)) fileIsNonReactJsx = true;
+				if (!fileIsNonReactJsx && jsxAttributeIsNonReactDialectMarker(node)) fileIsNonReactJsx = true;
 				if (fileIsNonReactJsx) return;
 				visitor(node);
 			};
@@ -301,9 +275,7 @@ const wrapCreateForReactJsxOnly = (create) => ((context) => {
 		};
 	}
 	if (!("Program" in wrappedVisitors)) wrappedVisitors.Program = (node) => {
-		const runtimeImports = collectJsxRuntimeImports(node);
-		fileImportsReactRuntime = runtimeImports.hasReactRuntime;
-		fileIsNonReactJsx = runtimeImports.hasNonReactRuntime && !runtimeImports.hasReactRuntime;
+		fileIsNonReactJsx = fileImportsNonReactJsxDialect(node);
 	};
 	return wrappedVisitors;
 });
@@ -4342,397 +4314,6 @@ const findTransparentExpressionRoot = (node) => {
 	return current;
 };
 //#endregion
-//#region src/plugin/utils/get-static-property-key-name.ts
-const getStaticPropertyKeyName = (node, options = {}) => {
-	if (!isNodeOfType(node, "Property") && !isNodeOfType(node, "MethodDefinition") && !isNodeOfType(node, "MemberExpression")) return null;
-	const key = isNodeOfType(node, "MemberExpression") ? node.property : node.key;
-	if (node.computed) {
-		if (options.allowComputedString && isNodeOfType(key, "Literal") && typeof key.value === "string") return key.value;
-		if (options.allowComputedString && isNodeOfType(key, "TemplateLiteral") && key.expressions.length === 0) return key.quasis[0]?.value.cooked ?? key.quasis[0]?.value.raw ?? null;
-		return null;
-	}
-	if (isNodeOfType(key, "Identifier")) return key.name;
-	if (isNodeOfType(key, "Literal")) {
-		if (typeof key.value === "string") return key.value;
-		if (options.stringifyNonStringLiterals) return String(key.value);
-	}
-	return null;
-};
-//#endregion
-//#region src/plugin/utils/get-destructured-binding-property-name.ts
-const getDestructuredBindingPropertyName = (bindingIdentifier) => {
-	let bindingNode = bindingIdentifier;
-	if (isNodeOfType(bindingNode.parent, "AssignmentPattern") && bindingNode.parent.left === bindingNode) bindingNode = bindingNode.parent;
-	const property = bindingNode.parent;
-	if (!property || !isNodeOfType(property, "Property") || property.value !== bindingNode || !property.parent || !isNodeOfType(property.parent, "ObjectPattern")) return null;
-	return getStaticPropertyKeyName(property, { allowComputedString: true });
-};
-//#endregion
-//#region src/plugin/utils/get-static-property-name.ts
-const getStaticPropertyName = (memberExpression) => {
-	const property = memberExpression.property;
-	if (!memberExpression.computed && isNodeOfType(property, "Identifier")) return property.name;
-	if (memberExpression.computed && isNodeOfType(property, "Literal")) return typeof property.value === "string" ? property.value : null;
-	if (memberExpression.computed && isNodeOfType(property, "TemplateLiteral") && property.expressions.length === 0) return property.quasis[0]?.value.cooked ?? property.quasis[0]?.value.raw ?? null;
-	return null;
-};
-//#endregion
-//#region src/plugin/utils/has-static-property-write-before.ts
-const equivalentSymbolsByAnalysis = /* @__PURE__ */ new WeakMap();
-const potentiallyAliasedSymbolsByAnalysis = /* @__PURE__ */ new WeakMap();
-const CONDITIONAL_EXECUTION_NODE_TYPES = new Set([
-	"CatchClause",
-	"ConditionalExpression",
-	"DoWhileStatement",
-	"ForInStatement",
-	"ForOfStatement",
-	"ForStatement",
-	"IfStatement",
-	"LogicalExpression",
-	"SwitchCase",
-	"SwitchStatement",
-	"TryStatement",
-	"WhileStatement"
-]);
-const getResolvedStaticPropertyName = (memberExpression, scopes) => {
-	if (!isNodeOfType(memberExpression, "MemberExpression")) return null;
-	const directPropertyName = getStaticPropertyName(memberExpression);
-	if (directPropertyName || !memberExpression.computed) return directPropertyName;
-	const property = stripParenExpression(memberExpression.property);
-	if (!isNodeOfType(property, "Identifier")) return null;
-	const propertySymbol = resolveConstIdentifierAlias(property, scopes);
-	const initializer = propertySymbol?.initializer ? stripParenExpression(propertySymbol.initializer) : null;
-	return initializer && isNodeOfType(initializer, "Literal") && typeof initializer.value === "string" ? initializer.value : null;
-};
-const collectScopeSymbols = (scope, symbols) => {
-	symbols.push(...scope.symbols);
-	for (const childScope of scope.children) collectScopeSymbols(childScope, symbols);
-};
-const getEquivalentSymbols = (identifier, scopes) => {
-	const rootSymbol = resolveConstIdentifierAlias(identifier, scopes);
-	if (!rootSymbol) return [];
-	let symbolsByRootId = equivalentSymbolsByAnalysis.get(scopes);
-	if (!symbolsByRootId) {
-		symbolsByRootId = /* @__PURE__ */ new Map();
-		equivalentSymbolsByAnalysis.set(scopes, symbolsByRootId);
-	}
-	const cachedSymbols = symbolsByRootId.get(rootSymbol.id);
-	if (cachedSymbols) return cachedSymbols;
-	const allSymbols = [];
-	collectScopeSymbols(scopes.rootScope, allSymbols);
-	const equivalentSymbols = allSymbols.filter((symbol) => resolveConstIdentifierAlias(symbol.bindingIdentifier, scopes)?.id === rootSymbol.id);
-	symbolsByRootId.set(rootSymbol.id, equivalentSymbols);
-	return equivalentSymbols;
-};
-const getDirectAliasSourceSymbol = (expression, scopes) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	return isNodeOfType(unwrappedExpression, "Identifier") ? scopes.symbolFor(unwrappedExpression) : null;
-};
-const getDirectAssignmentSourceSymbol = (identifier, scopes) => {
-	const assignmentTarget = findTransparentExpressionRoot(identifier);
-	const parent = assignmentTarget.parent;
-	if (!parent || !isNodeOfType(parent, "AssignmentExpression") || parent.operator !== "=" || parent.left !== assignmentTarget) return null;
-	return getDirectAliasSourceSymbol(parent.right, scopes);
-};
-const isDirectAliasSourceReference = (identifier) => {
-	const aliasSource = findTransparentExpressionRoot(identifier);
-	const parent = aliasSource.parent;
-	if (parent && isNodeOfType(parent, "VariableDeclarator") && parent.init === aliasSource && (isNodeOfType(parent.id, "Identifier") || isNodeOfType(parent.id, "ObjectPattern"))) return true;
-	return Boolean(parent && isNodeOfType(parent, "AssignmentExpression") && parent.operator === "=" && parent.right === aliasSource && isNodeOfType(stripParenExpression(parent.left), "Identifier"));
-};
-const isDirectAliasOfKnownSymbol = (symbol, knownSymbolIds, scopes) => {
-	if (symbol.initializer && isNodeOfType(symbol.declarationNode, "VariableDeclarator") && symbol.declarationNode.id === symbol.bindingIdentifier) {
-		const initializerSymbol = getDirectAliasSourceSymbol(symbol.initializer, scopes);
-		if (initializerSymbol && knownSymbolIds.has(initializerSymbol.id)) return true;
-	}
-	return symbol.references.some((reference) => {
-		const assignmentSourceSymbol = getDirectAssignmentSourceSymbol(reference.identifier, scopes);
-		return Boolean(assignmentSourceSymbol && knownSymbolIds.has(assignmentSourceSymbol.id));
-	});
-};
-const getPotentiallyAliasedSymbols = (identifier, scopes) => {
-	const rootSymbol = resolveConstIdentifierAlias(identifier, scopes);
-	if (!rootSymbol) return [];
-	let symbolsByRootId = potentiallyAliasedSymbolsByAnalysis.get(scopes);
-	if (!symbolsByRootId) {
-		symbolsByRootId = /* @__PURE__ */ new Map();
-		potentiallyAliasedSymbolsByAnalysis.set(scopes, symbolsByRootId);
-	}
-	const cachedSymbols = symbolsByRootId.get(rootSymbol.id);
-	if (cachedSymbols) return cachedSymbols;
-	const allSymbols = [];
-	collectScopeSymbols(scopes.rootScope, allSymbols);
-	const aliasedSymbolIds = new Set([rootSymbol.id]);
-	let didAddAlias = true;
-	while (didAddAlias) {
-		didAddAlias = false;
-		for (const symbol of allSymbols) {
-			if (aliasedSymbolIds.has(symbol.id)) continue;
-			if (!isDirectAliasOfKnownSymbol(symbol, aliasedSymbolIds, scopes)) continue;
-			aliasedSymbolIds.add(symbol.id);
-			didAddAlias = true;
-		}
-	}
-	const aliasedSymbols = allSymbols.filter((symbol) => aliasedSymbolIds.has(symbol.id));
-	symbolsByRootId.set(rootSymbol.id, aliasedSymbols);
-	return aliasedSymbols;
-};
-const findExecutionBoundary = (node) => {
-	let current = node;
-	while (current) {
-		if (isFunctionLike$2(current) || isNodeOfType(current, "Program")) return current;
-		current = current.parent ?? null;
-	}
-	return null;
-};
-const isOnUnconditionalPath = (node, boundary) => {
-	let current = node.parent ?? null;
-	while (current && current !== boundary) {
-		if (CONDITIONAL_EXECUTION_NODE_TYPES.has(current.type)) return false;
-		current = current.parent ?? null;
-	}
-	return current === boundary;
-};
-const findFunctionBindingIdentifier = (functionNode) => {
-	if (isNodeOfType(functionNode, "FunctionDeclaration")) return functionNode.id ?? null;
-	const parent = functionNode.parent;
-	if (parent && isNodeOfType(parent, "VariableDeclarator") && parent.init === functionNode && isNodeOfType(parent.id, "Identifier")) return parent.id;
-	return null;
-};
-const findDirectCall = (identifier) => {
-	let callee = identifier;
-	let parent = callee.parent;
-	while (parent && stripParenExpression(parent) === identifier) {
-		callee = parent;
-		parent = callee.parent;
-	}
-	return parent && isNodeOfType(parent, "CallExpression") && parent.callee === callee ? parent : null;
-};
-const isFunctionSynchronouslyInvokedBefore = (functionNode, referenceNode, scopes, visitedFunctionNodes = /* @__PURE__ */ new Set()) => {
-	if (visitedFunctionNodes.has(functionNode) || !isFunctionLike$2(functionNode) || functionNode.generator) return false;
-	visitedFunctionNodes.add(functionNode);
-	const referenceBoundary = findExecutionBoundary(referenceNode);
-	if (!referenceBoundary) return false;
-	const invocationCalls = [];
-	const bindingIdentifier = findFunctionBindingIdentifier(functionNode);
-	if (bindingIdentifier) for (const symbol of getEquivalentSymbols(bindingIdentifier, scopes)) for (const reference of symbol.references) {
-		const call = findDirectCall(reference.identifier);
-		if (call) invocationCalls.push(call);
-	}
-	else {
-		const call = findDirectCall(functionNode);
-		if (call) invocationCalls.push(call);
-	}
-	return invocationCalls.some((call) => {
-		if (call.range[0] >= referenceNode.range[0]) return false;
-		const callBoundary = findExecutionBoundary(call);
-		if (!callBoundary) return false;
-		if (callBoundary === referenceBoundary) return true;
-		if (!isFunctionLike$2(callBoundary)) return false;
-		return isFunctionSynchronouslyInvokedBefore(callBoundary, referenceNode, scopes, new Set(visitedFunctionNodes));
-	});
-};
-const isMemberWriteTarget = (memberExpression) => {
-	const parent = memberExpression.parent;
-	if (!parent) return false;
-	if (isNodeOfType(parent, "AssignmentExpression")) return parent.left === memberExpression;
-	if (isNodeOfType(parent, "UpdateExpression")) return parent.argument === memberExpression;
-	return isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" && parent.argument === memberExpression;
-};
-const getMemberWriteTarget = (identifier) => {
-	let parent = identifier.parent;
-	while (parent && stripParenExpression(parent) === identifier) parent = parent.parent;
-	if (!parent || !isNodeOfType(parent, "MemberExpression") || stripParenExpression(parent.object) !== identifier || !isMemberWriteTarget(parent)) return null;
-	return parent;
-};
-const getStaticPropertyWriteTarget = (identifier, propertyName, scopes) => {
-	const writeTarget = getMemberWriteTarget(identifier);
-	return writeTarget && getResolvedStaticPropertyName(writeTarget, scopes) === propertyName ? writeTarget : null;
-};
-const symbolHasStaticPropertyWriteBefore = (symbol, propertyName, referenceNode, scopes) => symbol.references.some((reference) => {
-	const writeTarget = getStaticPropertyWriteTarget(reference.identifier, propertyName, scopes);
-	if (!writeTarget) return false;
-	const writeBoundary = findExecutionBoundary(writeTarget);
-	const referenceBoundary = findExecutionBoundary(referenceNode);
-	if (!writeBoundary || !referenceBoundary || !isOnUnconditionalPath(writeTarget, writeBoundary)) return false;
-	if (writeBoundary === referenceBoundary) return writeTarget.range[0] < referenceNode.range[0];
-	return isFunctionLike$2(writeBoundary) && isFunctionSynchronouslyInvokedBefore(writeBoundary, referenceNode, scopes);
-});
-const isStableStaticPropertyReference = (identifier) => {
-	if (isDirectAliasSourceReference(identifier)) return true;
-	const identifierRoot = findTransparentExpressionRoot(identifier);
-	const memberExpression = identifierRoot.parent;
-	return Boolean(memberExpression && isNodeOfType(memberExpression, "MemberExpression") && stripParenExpression(memberExpression.object) === identifierRoot);
-};
-const hasPossibleStaticPropertyWrite = (identifier, propertyName, scopes) => {
-	if (!isNodeOfType(identifier, "Identifier")) return false;
-	return getPotentiallyAliasedSymbols(identifier, scopes).some((symbol) => symbol.references.some((reference) => {
-		const writeTarget = getMemberWriteTarget(reference.identifier);
-		if (!writeTarget) return false;
-		const writtenPropertyName = getResolvedStaticPropertyName(writeTarget, scopes);
-		return writtenPropertyName === null || writtenPropertyName === propertyName;
-	}));
-};
-const hasPossibleStaticPropertyMutationOrEscape = (identifier, propertyName, scopes) => {
-	if (!isNodeOfType(identifier, "Identifier")) return false;
-	if (hasPossibleStaticPropertyWrite(identifier, propertyName, scopes)) return true;
-	return getPotentiallyAliasedSymbols(identifier, scopes).some((symbol) => symbol.references.some((reference) => !isStableStaticPropertyReference(reference.identifier)));
-};
-const hasPossibleStaticMemberCallWrite = (callExpression, scopes) => {
-	const unwrappedCallExpression = stripParenExpression(callExpression);
-	if (!isNodeOfType(unwrappedCallExpression, "CallExpression")) return false;
-	const callee = stripParenExpression(unwrappedCallExpression.callee);
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	const propertyName = getStaticPropertyName(callee);
-	if (propertyName === null) return false;
-	const receiver = stripParenExpression(callee.object);
-	return isNodeOfType(receiver, "Identifier") && hasPossibleStaticPropertyWrite(receiver, propertyName, scopes);
-};
-const hasStaticPropertyWriteBefore = (identifier, propertyName, referenceNode, scopes) => {
-	if (!isNodeOfType(identifier, "Identifier")) return false;
-	return getEquivalentSymbols(identifier, scopes).some((symbol) => symbolHasStaticPropertyWriteBefore(symbol, propertyName, referenceNode, scopes));
-};
-//#endregion
-//#region src/plugin/utils/find-enclosing-function.ts
-const findEnclosingFunction$1 = (node) => {
-	let cursor = node.parent;
-	while (cursor) {
-		if (isFunctionLike$2(cursor)) return cursor;
-		cursor = cursor.parent ?? null;
-	}
-	return null;
-};
-//#endregion
-//#region src/plugin/utils/has-symbol-write-before.ts
-const hasSymbolWriteBefore = (symbol, referenceNode, scopes) => symbol.references.some((reference) => {
-	if (reference.flag === "read") return false;
-	const writeFunction = findEnclosingFunction$1(reference.identifier);
-	if (writeFunction === findEnclosingFunction$1(referenceNode)) return reference.identifier.range[0] < referenceNode.range[0];
-	if (!writeFunction) return true;
-	return isFunctionSynchronouslyInvokedBefore(writeFunction, referenceNode, scopes);
-});
-//#endregion
-//#region src/plugin/utils/get-order-independent-local-function.ts
-const COMMUTATIVE_COMPOUND_ASSIGNMENT_OPERATORS = new Set([
-	"+=",
-	"-=",
-	"*=",
-	"/=",
-	"%=",
-	"&=",
-	"^=",
-	"|="
-]);
-const isPureParameterExpression = (expression, parameterNames) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (isNodeOfType(unwrappedExpression, "Literal")) return true;
-	if (isNodeOfType(unwrappedExpression, "Identifier")) return parameterNames.has(unwrappedExpression.name);
-	if (isNodeOfType(unwrappedExpression, "BinaryExpression") || isNodeOfType(unwrappedExpression, "LogicalExpression")) return isPureParameterExpression(unwrappedExpression.left, parameterNames) && isPureParameterExpression(unwrappedExpression.right, parameterNames);
-	if (isNodeOfType(unwrappedExpression, "UnaryExpression")) return unwrappedExpression.operator !== "delete" && isPureParameterExpression(unwrappedExpression.argument, parameterNames);
-	if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) return isPureParameterExpression(unwrappedExpression.test, parameterNames) && isPureParameterExpression(unwrappedExpression.consequent, parameterNames) && isPureParameterExpression(unwrappedExpression.alternate, parameterNames);
-	if (isNodeOfType(unwrappedExpression, "TemplateLiteral")) return unwrappedExpression.expressions.every((nestedExpression) => isPureParameterExpression(nestedExpression, parameterNames));
-	return false;
-};
-const isOrderIndependentPromiseResolveCall = (expression, parameterNames, scopes) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	if (!isNodeOfType(unwrappedExpression, "CallExpression")) return false;
-	if (!unwrappedExpression.arguments.every((argument) => !isNodeOfType(argument, "SpreadElement") && isPureParameterExpression(argument, parameterNames))) return false;
-	const callee = stripParenExpression(unwrappedExpression.callee);
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	if (getStaticPropertyName(callee) !== "resolve") return false;
-	const receiver = stripParenExpression(callee.object);
-	return isNodeOfType(receiver, "Identifier") && receiver.name === "Promise" && scopes.isGlobalReference(receiver);
-};
-const isHarmlessPromiseResolveAwait = (statement, parameterNames, scopes) => {
-	if (!isNodeOfType(statement, "ExpressionStatement") || !isNodeOfType(statement.expression, "AwaitExpression")) return false;
-	return isOrderIndependentPromiseResolveCall(statement.expression.argument, parameterNames, scopes);
-};
-const isCommutativeParameterMutation = (statement, parameterNames) => {
-	if (!isNodeOfType(statement, "ExpressionStatement") || !isNodeOfType(statement.expression, "AssignmentExpression") || !COMMUTATIVE_COMPOUND_ASSIGNMENT_OPERATORS.has(statement.expression.operator)) return false;
-	const mutationTarget = stripParenExpression(statement.expression.left);
-	if (!isNodeOfType(mutationTarget, "MemberExpression")) return false;
-	if (getStaticPropertyName(mutationTarget) === null) return false;
-	const receiver = stripParenExpression(mutationTarget.object);
-	return isNodeOfType(receiver, "Identifier") && parameterNames.has(receiver.name) && isNodeOfType(stripParenExpression(statement.expression.right), "Literal");
-};
-const isOrderIndependentFunction = (functionNode, scopes) => {
-	if (!isFunctionLike$2(functionNode)) return false;
-	const parameterNames = /* @__PURE__ */ new Set();
-	for (const parameter of functionNode.params) {
-		if (!isNodeOfType(parameter, "Identifier")) return false;
-		parameterNames.add(parameter.name);
-	}
-	if (!functionNode.async) {
-		if (!isNodeOfType(functionNode.body, "BlockStatement")) return isOrderIndependentPromiseResolveCall(functionNode.body, parameterNames, scopes);
-		if (functionNode.body.body.length !== 1) return false;
-		const [returnStatement] = functionNode.body.body;
-		return Boolean(isNodeOfType(returnStatement, "ReturnStatement") && returnStatement.argument && isOrderIndependentPromiseResolveCall(returnStatement.argument, parameterNames, scopes));
-	}
-	if (!isNodeOfType(functionNode.body, "BlockStatement")) return isPureParameterExpression(functionNode.body, parameterNames);
-	const statements = functionNode.body.body;
-	for (let statementIndex = 0; statementIndex < statements.length; statementIndex++) {
-		const statement = statements[statementIndex];
-		const isTerminalStatement = statementIndex === statements.length - 1;
-		if (isHarmlessPromiseResolveAwait(statement, parameterNames, scopes)) continue;
-		if (isNodeOfType(statement, "ExpressionStatement") && isPureParameterExpression(statement.expression, parameterNames)) continue;
-		if (isCommutativeParameterMutation(statement, parameterNames)) return isTerminalStatement;
-		if (!isNodeOfType(statement, "ReturnStatement") || !isTerminalStatement) return false;
-		return !statement.argument || isPureParameterExpression(statement.argument, parameterNames) || isOrderIndependentPromiseResolveCall(statement.argument, parameterNames, scopes);
-	}
-	return true;
-};
-const getObjectPropertyName = (property) => {
-	if (!isNodeOfType(property, "Property")) return null;
-	return getStaticPropertyKeyName(property, { allowComputedString: true });
-};
-const resolveOrderIndependentObjectPropertyFunction = (objectExpression, propertyName, callExpression, scopes, visitedSymbolIds) => {
-	const unwrappedObject = stripParenExpression(objectExpression);
-	if (isNodeOfType(unwrappedObject, "Identifier")) {
-		const symbol = scopes.symbolFor(unwrappedObject);
-		if (!symbol || symbol.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, callExpression, scopes) || hasPossibleStaticPropertyMutationOrEscape(unwrappedObject, propertyName, scopes)) return null;
-		visitedSymbolIds.add(symbol.id);
-		return resolveOrderIndependentObjectPropertyFunction(symbol.initializer, propertyName, callExpression, scopes, visitedSymbolIds);
-	}
-	if (!isNodeOfType(unwrappedObject, "ObjectExpression")) return null;
-	let matchingProperty = null;
-	for (const property of unwrappedObject.properties) {
-		if (!isNodeOfType(property, "Property")) return null;
-		if (property.kind !== "init") return null;
-		const candidatePropertyName = getObjectPropertyName(property);
-		if (candidatePropertyName === null) return null;
-		if (candidatePropertyName === propertyName) matchingProperty = property;
-	}
-	if (!matchingProperty || !isNodeOfType(matchingProperty, "Property")) return null;
-	const propertyValue = stripParenExpression(matchingProperty.value);
-	if (isFunctionLike$2(propertyValue)) return isOrderIndependentFunction(propertyValue, scopes) ? propertyValue : null;
-	return resolveOrderIndependentLocalFunction(propertyValue, callExpression, scopes, visitedSymbolIds);
-};
-const resolveOrderIndependentLocalFunction = (callee, callExpression, scopes, visitedSymbolIds) => {
-	const unwrappedCallee = stripParenExpression(callee);
-	if (isNodeOfType(unwrappedCallee, "MemberExpression")) {
-		const propertyName = getStaticPropertyName(unwrappedCallee);
-		if (propertyName === null) return null;
-		return resolveOrderIndependentObjectPropertyFunction(stripParenExpression(unwrappedCallee.object), propertyName, callExpression, scopes, visitedSymbolIds);
-	}
-	if (!isNodeOfType(unwrappedCallee, "Identifier")) return null;
-	const symbol = scopes.symbolFor(unwrappedCallee);
-	if (!symbol || visitedSymbolIds.has(symbol.id) || hasSymbolWriteBefore(symbol, callExpression, scopes)) return null;
-	visitedSymbolIds.add(symbol.id);
-	if (!symbol.initializer) return null;
-	const initializer = stripParenExpression(symbol.initializer);
-	const destructuredPropertyName = getDestructuredBindingPropertyName(symbol.bindingIdentifier);
-	if (destructuredPropertyName !== null) return resolveOrderIndependentObjectPropertyFunction(initializer, destructuredPropertyName, callExpression, scopes, visitedSymbolIds);
-	if (isFunctionLike$2(initializer)) return isOrderIndependentFunction(initializer, scopes) ? initializer : null;
-	if (symbol.kind !== "const") return null;
-	return resolveOrderIndependentLocalFunction(initializer, callExpression, scopes, visitedSymbolIds);
-};
-const getOrderIndependentLocalFunction = (callExpression, scopes) => {
-	const unwrappedCall = stripParenExpression(callExpression);
-	if (!isNodeOfType(unwrappedCall, "CallExpression")) return null;
-	if (hasPossibleStaticMemberCallWrite(unwrappedCall, scopes)) return null;
-	return resolveOrderIndependentLocalFunction(unwrappedCall.callee, unwrappedCall, scopes, /* @__PURE__ */ new Set());
-};
-//#endregion
 //#region src/plugin/utils/is-inline-function-expression.ts
 /**
 * Type-guard for the two "inline function expression" ESTree forms:
@@ -4766,15 +4347,13 @@ const isIntentionalSequencingCallee = (callee) => {
 	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) return INTENTIONAL_SEQUENCING_CALLEE_NAMES.has(callee.property.name);
 	return false;
 };
-const isAwaitingSleepLikeCall = (awaitNode, context) => {
+const isAwaitingSleepLikeCall = (awaitNode) => {
 	if (!isNodeOfType(awaitNode, "AwaitExpression")) return false;
 	const argument = awaitNode.argument;
 	if (!argument) return false;
 	if (!isNodeOfType(argument, "CallExpression")) return false;
-	if (getOrderIndependentLocalFunction(argument, context.scopes) !== null) return false;
 	return isIntentionalSequencingCallee(argument.callee);
 };
-const isAwaitingPossiblyMutatedMemberCall = (awaitNode, context) => isNodeOfType(awaitNode, "AwaitExpression") && Boolean(awaitNode.argument) && hasPossibleStaticMemberCallWrite(awaitNode.argument, context.scopes);
 const PROMISE_CONCURRENCY_METHODS = new Set([
 	"all",
 	"allSettled",
@@ -4817,7 +4396,7 @@ const isAwaitingManualPromiseWait = (awaitNode) => {
 	});
 	return isWaitLike;
 };
-const isIntentionallySequentialAwait = (awaitNode, context) => isAwaitingPossiblyMutatedMemberCall(awaitNode, context) || isAwaitingSleepLikeCall(awaitNode, context) || isAwaitingPromiseConcurrencyCall(awaitNode) || isAwaitingManualPromiseWait(awaitNode);
+const isIntentionallySequentialAwait = (awaitNode) => isAwaitingSleepLikeCall(awaitNode) || isAwaitingPromiseConcurrencyCall(awaitNode) || isAwaitingManualPromiseWait(awaitNode);
 const collectPatternIdentifiers = (pattern, target) => {
 	if (isNodeOfType(pattern, "Identifier")) target.add(pattern.name);
 	else if (isNodeOfType(pattern, "ObjectPattern")) {
@@ -5008,12 +4587,12 @@ const getLoopLabelName = (loopNode) => {
 	if (isNodeOfType(parent, "LabeledStatement") && isNodeOfType(parent.label, "Identifier")) return parent.label.name;
 	return null;
 };
-const loopBodyHasIntentionallySequentialAwait = (block, context) => {
+const loopBodyHasIntentionallySequentialAwait = (block) => {
 	let foundIntentional = false;
 	walkAst(block, (child) => {
 		if (foundIntentional) return false;
 		if (isInlineFunctionExpression(child) || isNodeOfType(child, "FunctionDeclaration")) return false;
-		if (isNodeOfType(child, "AwaitExpression") && isIntentionallySequentialAwait(child, context)) {
+		if (isNodeOfType(child, "AwaitExpression") && isIntentionallySequentialAwait(child)) {
 			foundIntentional = true;
 			return false;
 		}
@@ -5118,7 +4697,7 @@ const asyncAwaitInLoop = defineRule({
 		const inspectLoop = (loopNode, label) => {
 			const loopBody = loopNode.body;
 			if (!loopBody) return;
-			if (loopBodyHasIntentionallySequentialAwait(loopBody, context)) return;
+			if (loopBodyHasIntentionallySequentialAwait(loopBody)) return;
 			if ((isNodeOfType(loopNode, "WhileStatement") || isNodeOfType(loopNode, "DoWhileStatement")) && isLoopTestDependentOnBodyState(loopNode.test, loopBody)) return;
 			if (hasLoopCarriedDependency(loopBody)) return;
 			if (loopBodyHasAwaitDependentEarlyExit(loopBody, getLoopLabelName(loopNode))) return;
@@ -5378,7 +4957,7 @@ const guardConsequentPerformsSideEffects = (consequent) => {
 	});
 	return performsSideEffects;
 };
-const findEnclosingFunction = (node) => {
+const findEnclosingFunction$1 = (node) => {
 	let ancestor = node.parent;
 	while (ancestor) {
 		if (isFunctionLike$2(ancestor)) return ancestor;
@@ -5391,7 +4970,7 @@ const guardTestReadsReassignedLocal = (test, guardStatement) => {
 	const testIdentifierNames = /* @__PURE__ */ new Set();
 	collectReferenceIdentifierNames(test, testIdentifierNames);
 	if (testIdentifierNames.size === 0) return false;
-	const enclosingFunction = findEnclosingFunction(guardStatement);
+	const enclosingFunction = findEnclosingFunction$1(guardStatement);
 	if (!enclosingFunction || !isFunctionLike$2(enclosingFunction) || !enclosingFunction.body) return false;
 	let readsReassignedLocal = false;
 	walkAst(enclosingFunction.body, (child) => {
@@ -5562,36 +5141,19 @@ const isIntentionalSequencingAwait = (awaitedCall) => {
 	return getCalleeIdentifierTrail(awaitedCall).some((name) => INTENTIONAL_SEQUENCING_CALLEE_NAMES.has(name));
 };
 const isBareExpressionAwait = (statement) => isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "AwaitExpression");
-const hasOrderIndependentBareAwaitArguments = (callExpression) => {
-	const unwrappedCallExpression = stripParenExpression(callExpression);
-	if (!isNodeOfType(unwrappedCallExpression, "CallExpression")) return false;
-	return unwrappedCallExpression.arguments.every((argument) => {
-		if (isNodeOfType(argument, "SpreadElement")) return false;
-		const unwrappedArgument = stripParenExpression(argument);
-		return isNodeOfType(unwrappedArgument, "Identifier") || isNodeOfType(unwrappedArgument, "Literal");
-	});
-};
 const isNonCallAwait = (statement) => {
 	const awaitedExpression = getAwaitedCall(statement);
 	if (!awaitedExpression) return false;
 	const stripped = stripParenExpression(awaitedExpression);
 	return !isNodeOfType(stripped, "CallExpression") && !isNodeOfType(stripped, "NewExpression") && !isNodeOfType(stripped, "ImportExpression");
 };
-const sequenceContainsSerializationSignal = (statements, context) => {
-	let bareAwaitFunction = null;
+const sequenceContainsSerializationSignal = (statements) => {
 	for (const statement of statements) {
+		if (isBareExpressionAwait(statement)) return true;
 		if (isNonCallAwait(statement)) return true;
 		const awaitedCall = getAwaitedCall(statement);
-		if (awaitedCall && hasPossibleStaticMemberCallWrite(awaitedCall, context.scopes)) return true;
-		const orderIndependentFunction = awaitedCall ? getOrderIndependentLocalFunction(awaitedCall, context.scopes) : null;
-		if (isBareExpressionAwait(statement)) {
-			if (orderIndependentFunction === null) return true;
-			if (!awaitedCall || !hasOrderIndependentBareAwaitArguments(awaitedCall)) return true;
-			if (bareAwaitFunction !== null && bareAwaitFunction !== orderIndependentFunction) return true;
-			bareAwaitFunction = orderIndependentFunction;
-		}
 		if (isOrderedUiFlowAwait(awaitedCall)) return true;
-		if (isIntentionalSequencingAwait(awaitedCall) && orderIndependentFunction === null) return true;
+		if (isIntentionalSequencingAwait(awaitedCall)) return true;
 	}
 	return false;
 };
@@ -5649,7 +5211,7 @@ const asyncParallel = defineRule({
 				const consecutiveAwaitStatements = [];
 				const flushConsecutiveAwaits = () => {
 					if (consecutiveAwaitStatements.length >= 3) {
-						if (!sequenceContainsSerializationSignal(consecutiveAwaitStatements, context)) reportIfIndependent(consecutiveAwaitStatements, context);
+						if (!sequenceContainsSerializationSignal(consecutiveAwaitStatements)) reportIfIndependent(consecutiveAwaitStatements, context);
 					}
 					consecutiveAwaitStatements.length = 0;
 				};
@@ -6427,6 +5989,23 @@ const checkedRequiresOnchangeOrReadonly = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/get-static-property-key-name.ts
+const getStaticPropertyKeyName = (node, options = {}) => {
+	if (!isNodeOfType(node, "Property") && !isNodeOfType(node, "MethodDefinition") && !isNodeOfType(node, "MemberExpression")) return null;
+	const key = isNodeOfType(node, "MemberExpression") ? node.property : node.key;
+	if (node.computed) {
+		if (options.allowComputedString && isNodeOfType(key, "Literal") && typeof key.value === "string") return key.value;
+		if (options.allowComputedString && isNodeOfType(key, "TemplateLiteral") && key.expressions.length === 0) return key.quasis[0]?.value.cooked ?? key.quasis[0]?.value.raw ?? null;
+		return null;
+	}
+	if (isNodeOfType(key, "Identifier")) return key.name;
+	if (isNodeOfType(key, "Literal")) {
+		if (typeof key.value === "string") return key.value;
+		if (options.stringifyNonStringLiterals) return String(key.value);
+	}
+	return null;
+};
+//#endregion
 //#region src/plugin/utils/are-expressions-structurally-equal.ts
 const areExpressionsStructurallyEqual = (a, b) => {
 	if (!a || !b) return a === b;
@@ -7110,6 +6689,15 @@ const getDirectConstInitializer = (symbol) => {
 	return symbol.initializer;
 };
 //#endregion
+//#region src/plugin/utils/get-static-property-name.ts
+const getStaticPropertyName = (memberExpression) => {
+	const property = memberExpression.property;
+	if (!memberExpression.computed && isNodeOfType(property, "Identifier")) return property.name;
+	if (memberExpression.computed && isNodeOfType(property, "Literal")) return typeof property.value === "string" ? property.value : null;
+	if (memberExpression.computed && isNodeOfType(property, "TemplateLiteral") && property.expressions.length === 0) return property.quasis[0]?.value.cooked ?? property.quasis[0]?.value.raw ?? null;
+	return null;
+};
+//#endregion
 //#region src/plugin/utils/get-range-start.ts
 const getRangeStart = (node) => {
 	const rangeStart = node.range?.[0];
@@ -7505,6 +7093,16 @@ const collectFunctionReturnStatements = (functionNode) => {
 	return returnStatements;
 };
 //#endregion
+//#region src/plugin/utils/find-enclosing-function.ts
+const findEnclosingFunction = (node) => {
+	let cursor = node.parent;
+	while (cursor) {
+		if (isFunctionLike$2(cursor)) return cursor;
+		cursor = cursor.parent ?? null;
+	}
+	return null;
+};
+//#endregion
 //#region src/plugin/utils/statement-always-exits.ts
 const statementAlwaysExits = (statement) => {
 	if (isNodeOfType(statement, "ReturnStatement") || isNodeOfType(statement, "ThrowStatement")) return true;
@@ -7550,8 +7148,8 @@ const applyDefinitions = (incomingDefinitions, definitions) => {
 const collectPossibleAssignedExpressions = (symbol, referenceNode, controlFlow) => {
 	if (!REASSIGNABLE_BINDING_KINDS.has(symbol.kind)) return symbol.initializer ? [symbol.initializer] : [];
 	if (!controlFlow) return [];
-	const referenceFunction = findEnclosingFunction$1(referenceNode);
-	if (findEnclosingFunction$1(symbol.bindingIdentifier) !== referenceFunction) return [];
+	const referenceFunction = findEnclosingFunction(referenceNode);
+	if (findEnclosingFunction(symbol.bindingIdentifier) !== referenceFunction) return [];
 	if (!referenceFunction) return [];
 	const functionControlFlow = controlFlow.cfgFor(referenceFunction);
 	if (!functionControlFlow) return [];
@@ -7575,7 +7173,7 @@ const collectPossibleAssignedExpressions = (symbol, referenceNode, controlFlow)
 	if (symbol.initializer) addDefinition(symbol.initializer, symbol.bindingIdentifier, bindingPosition);
 	for (const reference of symbol.references) {
 		const writePosition = getRangeStart(reference.identifier);
-		if (reference.flag === "read" || findEnclosingFunction$1(reference.identifier) !== referenceFunction || writePosition === null || writePosition >= referencePosition) continue;
+		if (reference.flag === "read" || findEnclosingFunction(reference.identifier) !== referenceFunction || writePosition === null || writePosition >= referencePosition) continue;
 		const assignedExpression = getAssignedExpressionForWrite(reference.identifier);
 		if (!assignedExpression) continue;
 		addDefinition(assignedExpression, reference.identifier, writePosition);
@@ -9247,7 +8845,6 @@ const HTML_FOR_ATTRIBUTE = "htmlFor";
 const LABEL_ELEMENT = "label";
 const LABEL_COMPONENT_NAME = "Label";
 const POLYMORPHIC_COMPONENT_PROP = "component";
-const TITLE_ATTRIBUTE = "title";
 const WRAPPER_LABEL_PROP = "label";
 const SELECT_ELEMENT = "select";
 const DEFAULT_DEPTH = 5;
@@ -9293,96 +8890,6 @@ const hasNonEmptyPropValue = (attribute) => {
 	}
 	return true;
 };
-const getLastJsxPropIgnoreCase = (attributes, targetProp) => {
-	const targetPropLower = targetProp.toLowerCase();
-	for (let attributeIndex = attributes.length - 1; attributeIndex >= 0; attributeIndex -= 1) {
-		const attribute = attributes[attributeIndex];
-		if (!attribute || !isNodeOfType(attribute, "JSXAttribute")) continue;
-		if (getJsxAttributeName(attribute.name)?.toLowerCase() === targetPropLower) return attribute;
-	}
-};
-const getStaticNativeTitleArrayValue = (expression, scopes) => {
-	const elementValues = [];
-	for (const rawElement of expression.elements) {
-		if (rawElement === null) {
-			elementValues.push("");
-			continue;
-		}
-		if (isNodeOfType(rawElement, "SpreadElement")) return null;
-		const element = stripParenExpression(rawElement);
-		if (isNodeOfType(element, "Literal")) {
-			elementValues.push(element.value === null ? "" : String(element.value));
-			continue;
-		}
-		if (isNodeOfType(element, "TemplateLiteral")) {
-			const staticValue = getStaticTemplateLiteralValue(element);
-			if (staticValue === null) return null;
-			elementValues.push(staticValue);
-			continue;
-		}
-		if (isNodeOfType(element, "Identifier") && element.name === "undefined" && scopes.isGlobalReference(element) || isNodeOfType(element, "UnaryExpression") && element.operator === "void") {
-			elementValues.push("");
-			continue;
-		}
-		if (isNodeOfType(element, "ArrayExpression")) {
-			const nestedValue = getStaticNativeTitleArrayValue(element, scopes);
-			if (nestedValue === null) return null;
-			elementValues.push(nestedValue);
-			continue;
-		}
-		return null;
-	}
-	return elementValues.join(",");
-};
-const isGlobalSymbolExpression = (expression, scopes) => {
-	if (isNodeOfType(expression, "Identifier")) return expression.name === "Symbol" && scopes.isGlobalReference(expression);
-	if (!isNodeOfType(expression, "MemberExpression")) return false;
-	const object = stripParenExpression(expression.object);
-	return isNodeOfType(object, "Identifier") && object.name === "Symbol" && scopes.isGlobalReference(object);
-};
-const hasNonEmptyNativeTitleExpression = (rawExpression, scopes) => {
-	const expression = stripParenExpression(rawExpression);
-	if (isNodeOfType(expression, "Literal")) {
-		if (typeof expression.value === "string") return expression.value.trim().length > 0;
-		return expression.value !== null && typeof expression.value !== "boolean";
-	}
-	if (isNodeOfType(expression, "TemplateLiteral")) {
-		const staticValue = getStaticTemplateLiteralValue(expression);
-		return staticValue === null || staticValue.trim().length > 0;
-	}
-	if (isNodeOfType(expression, "Identifier")) return expression.name !== "undefined" || !scopes.isGlobalReference(expression);
-	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") return false;
-	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "!") return false;
-	if (isNodeOfType(expression, "ArrowFunctionExpression")) return false;
-	if (isNodeOfType(expression, "FunctionExpression")) return false;
-	if (isNodeOfType(expression, "ClassExpression")) return false;
-	if (isNodeOfType(expression, "ArrayExpression")) {
-		const staticValue = getStaticNativeTitleArrayValue(expression, scopes);
-		return staticValue === null || staticValue.trim().length > 0;
-	}
-	if (isGlobalSymbolExpression(expression, scopes)) return false;
-	if (isNodeOfType(expression, "CallExpression") && isGlobalSymbolExpression(expression.callee, scopes)) return false;
-	if (isNodeOfType(expression, "ConditionalExpression")) return hasNonEmptyNativeTitleExpression(expression.consequent, scopes) && hasNonEmptyNativeTitleExpression(expression.alternate, scopes);
-	if (isNodeOfType(expression, "SequenceExpression")) {
-		const finalExpression = expression.expressions.at(-1);
-		return finalExpression ? hasNonEmptyNativeTitleExpression(finalExpression, scopes) : false;
-	}
-	if (isNodeOfType(expression, "LogicalExpression")) {
-		const leftExpression = stripParenExpression(expression.left);
-		if (!isNodeOfType(leftExpression, "Literal")) return expression.operator !== "&&";
-		if (expression.operator === "??") return hasNonEmptyNativeTitleExpression(leftExpression.value === null ? expression.right : leftExpression, scopes);
-		const leftValueIsTruthy = Boolean(leftExpression.value);
-		if (expression.operator === "&&") return hasNonEmptyNativeTitleExpression(leftValueIsTruthy ? expression.right : leftExpression, scopes);
-		return hasNonEmptyNativeTitleExpression(leftValueIsTruthy ? leftExpression : expression.right, scopes);
-	}
-	return true;
-};
-const hasNonEmptyNativeTitle = (attribute, scopes) => {
-	if (!attribute?.value) return false;
-	if (isNodeOfType(attribute.value, "Literal")) return typeof attribute.value.value === "string" && attribute.value.value.trim().length > 0;
-	if (isNodeOfType(attribute.value, "JSXExpressionContainer")) return hasNonEmptyNativeTitleExpression(attribute.value.expression, scopes);
-	return true;
-};
 const toAttributeMatchKey = (kind, value) => {
 	const trimmedValue = value.trim();
 	return trimmedValue.length > 0 ? `${kind}:${trimmedValue}` : null;
@@ -9639,7 +9146,6 @@ const controlHasAssociatedLabel = defineRule({
 					if (typeValue === "submit" || typeValue === "reset") return;
 					if (typeValue === "button" && hasNonEmptyPropValue(hasJsxPropIgnoreCase(opening.attributes, "value"))) return;
 				}
-				if (isDomElement && hasNonEmptyNativeTitle(getLastJsxPropIgnoreCase(opening.attributes, TITLE_ATTRIBUTE), context.scopes)) return;
 				if (supportsPlaceholderNameFallback(tagName, opening) && hasNonEmptyPropValue(hasJsxPropIgnoreCase(opening.attributes, "placeholder"))) return;
 				if (hasLabellingProp(opening.attributes, settings.labelAttributes)) return;
 				if (isInsideJsxAttribute(node)) return;
@@ -11589,7 +11095,7 @@ const componentOrHookDisplayNameForFunction = (functionNode) => {
 //#endregion
 //#region src/plugin/utils/enclosing-component-or-hook-name.ts
 const enclosingComponentOrHookName = (node) => {
-	const functionNode = findEnclosingFunction$1(node);
+	const functionNode = findEnclosingFunction(node);
 	return functionNode ? componentOrHookDisplayNameForFunction(functionNode) : null;
 };
 //#endregion
@@ -11646,11 +11152,11 @@ const executesDuringRender = (functionNode, scopes) => {
 //#endregion
 //#region src/plugin/utils/find-render-phase-component-or-hook.ts
 const findRenderPhaseComponentOrHook = (node, scopes) => {
-	let functionNode = findEnclosingFunction$1(node);
+	let functionNode = findEnclosingFunction(node);
 	while (functionNode) {
 		if (componentOrHookDisplayNameForFunction(functionNode)) return functionNode;
 		if (!executesDuringRender(functionNode, scopes)) return null;
-		functionNode = findEnclosingFunction$1(functionNode);
+		functionNode = findEnclosingFunction(functionNode);
 	}
 	return null;
 };
@@ -11899,13 +11405,13 @@ const findSubscribeLikeUsages = (callback, context) => {
 };
 const doMatchingNodesCoverEveryPathAfterUsage = (usageNode, matchingNodes, context) => {
 	let pathAnchor = usageNode;
-	let pathOwner = findEnclosingFunction$1(pathAnchor);
+	let pathOwner = findEnclosingFunction(pathAnchor);
 	while (pathOwner && isSynchronousIteratorCallback(pathOwner)) {
 		if (matchingNodes.length > 0 && matchingNodes.every((matchingNode) => context.cfg.enclosingFunction(matchingNode) === pathOwner)) break;
 		const iteratorCall = pathOwner.parent;
 		if (!isNodeOfType(iteratorCall, "CallExpression")) break;
 		pathAnchor = iteratorCall;
-		pathOwner = findEnclosingFunction$1(pathAnchor);
+		pathOwner = findEnclosingFunction(pathAnchor);
 	}
 	const owner = context.cfg.enclosingFunction(pathAnchor);
 	if (!owner) return false;
@@ -12134,7 +11640,7 @@ const findCollectionMappingCall = (callbackNode) => {
 	return callee.property.name === "map" && callNode.arguments?.[0] === callbackNode ? callNode : null;
 };
 const findMappedResourceCollectionKey = (resourceNode, context) => {
-	const callbackNode = findEnclosingFunction$1(resourceNode);
+	const callbackNode = findEnclosingFunction(resourceNode);
 	if (!callbackNode || !isNodeOfType(callbackNode, "ArrowFunctionExpression") && !isNodeOfType(callbackNode, "FunctionExpression")) return null;
 	const mappingCall = findCollectionMappingCall(callbackNode);
 	if (!mappingCall) return null;
@@ -12245,10 +11751,10 @@ const findSingleDirectInvocation = (functionNode, caller, context) => {
 	});
 	if (invocationCalls.length !== 1) return null;
 	const invocationCall = invocationCalls[0];
-	return findEnclosingFunction$1(invocationCall) === caller && isNodeReachableWithinFunction(invocationCall, context) ? invocationCall : null;
+	return findEnclosingFunction(invocationCall) === caller && isNodeReachableWithinFunction(invocationCall, context) ? invocationCall : null;
 };
 const resolveCleanupPathAnchor = (usageNode, effectCallback, context) => {
-	const usageFunction = findEnclosingFunction$1(usageNode);
+	const usageFunction = findEnclosingFunction(usageNode);
 	if (!usageFunction || usageFunction === effectCallback) return usageNode;
 	return findSingleDirectInvocation(usageFunction, effectCallback, context) ?? usageNode;
 };
@@ -12263,7 +11769,7 @@ const resolveSingleAssignedCleanupFunction = (expression, usage, context) => {
 	const assignmentReference = assignmentReferences[0];
 	const assignmentTarget = findTransparentExpressionRoot(assignmentReference.identifier);
 	const assignmentNode = assignmentTarget.parent;
-	if (!isNodeOfType(assignmentNode, "AssignmentExpression") || assignmentNode.operator !== "=" || assignmentNode.left !== assignmentTarget || findEnclosingFunction$1(assignmentNode) !== findEnclosingFunction$1(usage.node) || !doMatchingNodesCoverEveryPathAfterUsage(usage.node, [assignmentNode], context)) return null;
+	if (!isNodeOfType(assignmentNode, "AssignmentExpression") || assignmentNode.operator !== "=" || assignmentNode.left !== assignmentTarget || findEnclosingFunction(assignmentNode) !== findEnclosingFunction(usage.node) || !doMatchingNodesCoverEveryPathAfterUsage(usage.node, [assignmentNode], context)) return null;
 	const assignedValue = stripParenExpression(assignmentNode.right);
 	return isFunctionLike$2(assignedValue) ? assignedValue : null;
 };
@@ -12352,12 +11858,12 @@ const hasRerunReleaseBeforeUsage = (callback, usage, context) => {
 	return doMatchingNodesCoverEveryPathFromFunctionEntry(callback, matchingReleaseAnchors, context);
 };
 const hasStableUnmountCleanupForUsage = (callback, usage, context) => {
-	const componentFunction = findEnclosingFunction$1(callback);
+	const componentFunction = findEnclosingFunction(callback);
 	if (!componentFunction || !isNodeOfType(componentFunction, "ArrowFunctionExpression") && !isNodeOfType(componentFunction, "FunctionExpression") && !isNodeOfType(componentFunction, "FunctionDeclaration")) return false;
 	let didFindUnmountCleanup = false;
 	walkAst(componentFunction.body, (child) => {
 		if (didFindUnmountCleanup) return false;
-		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction$1(child) !== componentFunction) return;
+		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction(child) !== componentFunction) return;
 		if (!isHookCall$2(child, CLEANUP_EFFECT_HOOK_NAMES)) return;
 		const dependencyList = child.arguments?.[1];
 		if (!isNodeOfType(dependencyList, "ArrayExpression") || dependencyList.elements.length > 0) return;
@@ -12453,7 +11959,7 @@ const deferredUsageWritesGuardBeforeUsage = (callback, usageNode, guardState, co
 	return didWriteGuard;
 };
 const hasGuardedDeferredCleanup = (callback, usage, cleanupReturns, context) => {
-	const usageFunction = findEnclosingFunction$1(usage.node);
+	const usageFunction = findEnclosingFunction(usage.node);
 	const promiseChainCall = usageFunction ? getPromiseChainCallForCallback(usageFunction) : null;
 	if (usage.handleKey === null || !usageFunction || usageFunction === callback || !promiseChainCall || !collectEffectInvokedFunctions(callback).has(usageFunction) || !doMatchingNodesCoverEveryPathAfterUsage(promiseChainCall, cleanupReturns, context)) return false;
 	return collectDeferredUsageGuardStates(usageFunction, usage.node, context).some((guardState) => !deferredUsageWritesGuardBeforeUsage(usageFunction, usage.node, guardState, context) && cleanupReturns.every((cleanupReturn) => cleanupReturnInvalidatesGuard(cleanupReturn, guardState, context)));
@@ -12461,7 +11967,7 @@ const hasGuardedDeferredCleanup = (callback, usage, cleanupReturns, context) =>
 const effectHasCleanupForUsage = (callback, usage, context) => {
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
 	if (callback.async) return false;
-	if (usage.kind === "subscribe" && findEnclosingFunction$1(usage.node) === callback && doesResourceResultEscape(usage.node, true) && isCleanupReturningSubscribeLikeCallExpression(usage.node)) return true;
+	if (usage.kind === "subscribe" && findEnclosingFunction(usage.node) === callback && doesResourceResultEscape(usage.node, true) && isCleanupReturningSubscribeLikeCallExpression(usage.node)) return true;
 	if (!isNodeOfType(callback.body, "BlockStatement")) return callback.body === usage.node && isCleanupReturningSubscribeLikeCallExpression(callback.body);
 	const matchingCleanupReturns = [];
 	walkInsideStatementBlocks(callback.body, (child) => {
@@ -12630,7 +12136,7 @@ const isReturnedEffectCleanupFunction = (functionNode) => {
 		parentNode = currentNode.parent;
 	}
 	if (!isNodeOfType(parentNode, "ReturnStatement") || parentNode.argument !== currentNode) return false;
-	const effectCallback = findEnclosingFunction$1(parentNode);
+	const effectCallback = findEnclosingFunction(parentNode);
 	const effectCall = effectCallback?.parent;
 	return Boolean(effectCallback && isNodeOfType(effectCall, "CallExpression") && isHookCall$2(effectCall, CLEANUP_EFFECT_HOOK_NAMES));
 };
@@ -12640,13 +12146,13 @@ const isPotentiallyReachableFunction = (functionNode, context) => {
 	if (!bindingIdentifier) return false;
 	const symbol = context.scopes.symbolFor(bindingIdentifier);
 	if (!symbol) return false;
-	return symbol.references.some((reference) => findEnclosingFunction$1(reference.identifier) !== functionNode);
+	return symbol.references.some((reference) => findEnclosingFunction(reference.identifier) !== functionNode);
 };
 const isReleaseReachableForUsage = (releaseNode, usage, context) => {
 	if (!isNodeReachableWithinFunction(releaseNode, context)) return false;
-	const releaseFunction = findEnclosingFunction$1(releaseNode);
+	const releaseFunction = findEnclosingFunction(releaseNode);
 	if (!releaseFunction) return true;
-	if (releaseFunction === findEnclosingFunction$1(usage.node)) return true;
+	if (releaseFunction === findEnclosingFunction(usage.node)) return true;
 	return isPotentiallyReachableFunction(releaseFunction, context);
 };
 const fileContainsReleaseForUsage = (usage, context) => {
@@ -12829,10 +12335,10 @@ const cleanupFunctionReleasesRefOwnedUsage = (cleanupFunction, componentFunction
 		}
 		if (assignedKey !== storage.refCurrentKey) return;
 		const assignedValue = stripParenExpression(child.right);
-		if (isNodeOfType(assignedValue, "Literal") && assignedValue.value === null && findEnclosingFunction$1(child) === cleanupFunction) return;
+		if (isNodeOfType(assignedValue, "Literal") && assignedValue.value === null && findEnclosingFunction(child) === cleanupFunction) return;
 		const assignedSessionProperties = (isNodeOfType(assignedValue, "ObjectExpression") ? assignedValue : null)?.properties ?? [];
 		const storesMatchingHandler = assignedSessionProperties.every((property) => isNodeOfType(property, "Property")) && assignedSessionProperties.some((property) => isNodeOfType(property, "Property") && `${storage.refCurrentKey}.${getStaticPropertyKeyName(property) ?? ""}` === storage.handlerKey && resolveExpressionKey(property.value, context) === usage.handlerKey);
-		if (findEnclosingFunction$1(child) !== retainedFunction || !storesMatchingHandler) {
+		if (findEnclosingFunction(child) !== retainedFunction || !storesMatchingHandler) {
 			hasUnsafeRefWrite = true;
 			return false;
 		}
@@ -12853,12 +12359,12 @@ const effectReturnsRefOwnedCleanup = (effectCallback, componentFunction, retaine
 	return doMatchingNodesCoverEveryPathFromFunctionEntry(effectCallback, matchingReturns, context);
 };
 const hasGuaranteedRefOwnedUnmountCleanup = (retainedFunction, usage, context) => {
-	const componentFunction = findEnclosingFunction$1(retainedFunction);
+	const componentFunction = findEnclosingFunction(retainedFunction);
 	if (!componentFunction || !isFunctionLike$2(componentFunction)) return false;
 	let didFindCleanupEffect = false;
 	walkAst(componentFunction.body, (child) => {
 		if (didFindCleanupEffect) return false;
-		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction$1(child) !== componentFunction || !isReactApiCall(child, "useEffect", context.scopes)) return;
+		if (!isNodeOfType(child, "CallExpression") || findEnclosingFunction(child) !== componentFunction || !isReactApiCall(child, "useEffect", context.scopes)) return;
 		const effectStatement = findTransparentExpressionRoot(child).parent;
 		if (!isNodeOfType(effectStatement, "ExpressionStatement") || effectStatement.parent !== componentFunction.body) return;
 		const effectCallback = getEffectCallback(child);
@@ -13712,202 +13218,6 @@ const resolveExhaustiveDepsSettings = (settings) => {
 	};
 };
 //#endregion
-//#region src/plugin/utils/is-ast-descendant.ts
-/**
-* True when `inner` is `outer` itself or any descendant in the AST
-* `parent` chain. Walks `inner.parent` upward and stops at either a
-* match (`true`) or the chain's root (`false`).
-*
-* Was duplicated byte-identical in:
-* - exhaustive-deps-symbol-stability.ts
-* - semantic/closure-captures.ts
-*/
-const isAstDescendant = (inner, outer) => {
-	let current = inner;
-	while (current) {
-		if (current === outer) return true;
-		current = current.parent ?? null;
-	}
-	return false;
-};
-//#endregion
-//#region src/plugin/rules/react-builtins/exhaustive-deps-sole-writer-guard.ts
-const EQUALITY_BINARY_OPERATORS = new Set(["===", "!=="]);
-const getUseStateSetterSymbol = (stateSymbol, scopes) => {
-	const declaration = stateSymbol.declarationNode;
-	if (!isNodeOfType(declaration, "VariableDeclarator")) return null;
-	if (!isNodeOfType(declaration.id, "ArrayPattern")) return null;
-	const stateBinding = declaration.id.elements[0];
-	const setterBinding = declaration.id.elements[1];
-	if (stateBinding !== stateSymbol.bindingIdentifier || !isNodeOfType(setterBinding, "Identifier")) return null;
-	const initializer = declaration.init ? stripParenExpression(declaration.init) : null;
-	if (!initializer || !isReactApiCall(initializer, "useState", scopes, {
-		allowGlobalReactNamespace: true,
-		allowUnboundBareCalls: true,
-		resolveNamedAliases: true
-	})) return null;
-	return scopes.symbolFor(setterBinding);
-};
-const getDirectSetterCall = (setterSymbol, callback) => {
-	if (setterSymbol.references.length !== 1) return null;
-	const setterReference = setterSymbol.references[0];
-	if (setterReference.flag !== "read") return null;
-	const referenceRoot = findTransparentExpressionRoot(setterReference.identifier);
-	const callExpression = referenceRoot.parent;
-	if (!isNodeOfType(callExpression, "CallExpression") || callExpression.callee !== referenceRoot || callExpression.arguments.length !== 1 || findEnclosingFunction$1(callExpression) !== callback) return null;
-	const writtenValue = stripParenExpression(callExpression.arguments[0]);
-	if (isNodeOfType(writtenValue, "ArrowFunctionExpression") || isNodeOfType(writtenValue, "FunctionExpression") || isNodeOfType(writtenValue, "SpreadElement")) return null;
-	return {
-		callExpression,
-		writtenValue
-	};
-};
-const isGlobalObjectIsCall = (callExpression, scopes) => {
-	if (!isNodeOfType(callExpression, "CallExpression")) return false;
-	const callee = stripParenExpression(callExpression.callee);
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	const propertyName = getStaticPropertyName(callee);
-	const receiver = stripParenExpression(callee.object);
-	return Boolean(propertyName === "is" && isNodeOfType(receiver, "Identifier") && receiver.name === "Object" && scopes.isGlobalReference(receiver));
-};
-const isGlobalNaNReference = (expression, scopes) => {
-	const unwrappedExpression = stripParenExpression(expression);
-	return isNodeOfType(unwrappedExpression, "Identifier") && unwrappedExpression.name === "NaN" && scopes.isGlobalReference(unwrappedExpression);
-};
-const getEqualityComparison = (stateReference, candidate, scopes) => {
-	const unwrappedStateReference = stripParenExpression(stateReference);
-	if (isNodeOfType(candidate, "BinaryExpression") && EQUALITY_BINARY_OPERATORS.has(candidate.operator)) {
-		if (stripParenExpression(candidate.left) === unwrappedStateReference) return isGlobalNaNReference(candidate.right, scopes) ? null : {
-			comparison: candidate,
-			counterpart: candidate.right,
-			areValuesEqualWhenTruthy: candidate.operator === "==="
-		};
-		if (stripParenExpression(candidate.right) === unwrappedStateReference) return isGlobalNaNReference(candidate.left, scopes) ? null : {
-			comparison: candidate,
-			counterpart: candidate.left,
-			areValuesEqualWhenTruthy: candidate.operator === "==="
-		};
-		return null;
-	}
-	if (!isNodeOfType(candidate, "CallExpression") || !isGlobalObjectIsCall(candidate, scopes) || candidate.arguments.length !== 2) return null;
-	const firstArgument = candidate.arguments[0];
-	const secondArgument = candidate.arguments[1];
-	if (isNodeOfType(firstArgument, "SpreadElement") || isNodeOfType(secondArgument, "SpreadElement")) return null;
-	if (stripParenExpression(firstArgument) === unwrappedStateReference) return {
-		comparison: candidate,
-		counterpart: secondArgument,
-		areValuesEqualWhenTruthy: true
-	};
-	if (stripParenExpression(secondArgument) === unwrappedStateReference) return {
-		comparison: candidate,
-		counterpart: firstArgument,
-		areValuesEqualWhenTruthy: true
-	};
-	return null;
-};
-const findEqualityComparison = (stateReference, test, scopes) => {
-	let current = stateReference.parent;
-	while (current && isAstDescendant(current, test)) {
-		const comparison = getEqualityComparison(stateReference, current, scopes);
-		if (comparison) return comparison;
-		if (current === test) break;
-		current = current.parent;
-	}
-	return null;
-};
-const doesTestOutcomeRequireComparisonOutcome = (comparison, test, testOutcome, comparisonOutcome) => {
-	let requiredChildOutcome = testOutcome;
-	let current = comparison;
-	while (current !== test) {
-		const parent = current.parent;
-		if (!parent || !isAstDescendant(parent, test)) return false;
-		if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "!") requiredChildOutcome = !requiredChildOutcome;
-		else if (isNodeOfType(parent, "LogicalExpression")) {
-			if (parent.operator === "&&" && !requiredChildOutcome) return false;
-			if (parent.operator === "||" && requiredChildOutcome) return false;
-			if (parent.operator !== "&&" && parent.operator !== "||") return false;
-		} else if (!TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type)) return false;
-		current = parent;
-	}
-	return requiredChildOutcome === comparisonOutcome;
-};
-const resolveImmutableAliasExpression = (expression, scopes) => {
-	const visitedSymbolIds = /* @__PURE__ */ new Set();
-	let current = stripParenExpression(expression);
-	while (isNodeOfType(current, "Identifier")) {
-		const symbol = scopes.symbolFor(current);
-		if (!symbol || visitedSymbolIds.has(symbol.id)) break;
-		const initializer = getDirectConstInitializer(symbol);
-		if (!initializer || !isNodeOfType(stripParenExpression(initializer), "Identifier")) break;
-		visitedSymbolIds.add(symbol.id);
-		current = stripParenExpression(initializer);
-	}
-	return current;
-};
-const referencesSameValue = (leftExpression, rightExpression, scopes) => {
-	const left = resolveImmutableAliasExpression(leftExpression, scopes);
-	const right = resolveImmutableAliasExpression(rightExpression, scopes);
-	if (left === right) return true;
-	if (isNodeOfType(left, "Identifier") && isNodeOfType(right, "Identifier")) {
-		const leftSymbol = scopes.symbolFor(left);
-		const rightSymbol = scopes.symbolFor(right);
-		if (leftSymbol || rightSymbol) return leftSymbol?.id === rightSymbol?.id;
-		return left.name === right.name;
-	}
-	if (isNodeOfType(left, "Literal") && isNodeOfType(right, "Literal")) return Object.is(left.value, right.value);
-	return false;
-};
-const hasDeclaredTriggerDependency = (callback) => {
-	const hookCall = findTransparentExpressionRoot(callback).parent;
-	if (!isNodeOfType(hookCall, "CallExpression")) return false;
-	const dependencyArray = hookCall.arguments[1];
-	return Boolean(isNodeOfType(dependencyArray, "ArrayExpression") && dependencyArray.elements.length);
-};
-const doesBranchExitEffect = (branch) => {
-	if (isNodeOfType(branch, "ReturnStatement") || isNodeOfType(branch, "ThrowStatement")) return true;
-	if (!isNodeOfType(branch, "BlockStatement")) return false;
-	const terminalStatement = branch.body.at(-1);
-	return Boolean(terminalStatement && doesBranchExitEffect(terminalStatement));
-};
-const doesGuardDominateLaterSetter = (guard, setterCall) => {
-	if (!isNodeOfType(guard, "IfStatement") || guard.alternate) return false;
-	if (!doesBranchExitEffect(guard.consequent)) return false;
-	const block = guard.parent;
-	if (!isNodeOfType(block, "BlockStatement")) return false;
-	const guardIndex = block.body.findIndex((statement) => statement === guard);
-	return block.body.some((statement, statementIndex) => statementIndex > guardIndex && isAstDescendant(setterCall, statement));
-};
-const findDominatingGuardCounterpart = (stateReference, setterCall, callback, scopes) => {
-	let current = stateReference.parent;
-	while (current && current !== callback) {
-		if (isNodeOfType(current, "IfStatement") && isAstDescendant(stateReference, current.test) && (isAstDescendant(setterCall, current.consequent) || Boolean(current.alternate && isAstDescendant(setterCall, current.alternate)) || doesGuardDominateLaterSetter(current, setterCall))) {
-			const setterRunsWhenTestTruthy = isAstDescendant(setterCall, current.consequent);
-			if (setterRunsWhenTestTruthy === (Boolean(current.alternate && isAstDescendant(setterCall, current.alternate)) || doesGuardDominateLaterSetter(current, setterCall))) return null;
-			const equalityComparison = findEqualityComparison(stateReference, current.test, scopes);
-			if (!equalityComparison) return null;
-			const comparisonOutcomeForDifferentValues = !equalityComparison.areValuesEqualWhenTruthy;
-			if (!doesTestOutcomeRequireComparisonOutcome(equalityComparison.comparison, current.test, setterRunsWhenTestTruthy, comparisonOutcomeForDifferentValues)) return null;
-			return equalityComparison.counterpart;
-		}
-		current = current.parent;
-	}
-	return null;
-};
-const isSoleWriterEffectGuardCapture = (stateSymbol, callback, scopes) => {
-	if (!hasDeclaredTriggerDependency(callback)) return false;
-	if (stateSymbol.references.some((reference) => reference.flag !== "read")) return false;
-	const setterSymbol = getUseStateSetterSymbol(stateSymbol, scopes);
-	if (!setterSymbol) return false;
-	const setterWrite = getDirectSetterCall(setterSymbol, callback);
-	if (!setterWrite) return false;
-	const callbackStateReferences = stateSymbol.references.filter((reference) => isAstDescendant(reference.identifier, callback));
-	if (callbackStateReferences.length !== 1) return false;
-	const stateReferenceRoot = findTransparentExpressionRoot(callbackStateReferences[0].identifier);
-	if (isNodeOfType(stateReferenceRoot.parent, "MemberExpression") && stateReferenceRoot.parent.object === stateReferenceRoot) return false;
-	const counterpart = findDominatingGuardCounterpart(callbackStateReferences[0].identifier, setterWrite.callExpression, callback, scopes);
-	return Boolean(counterpart && referencesSameValue(counterpart, setterWrite.writtenValue, scopes));
-};
-//#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps-suppression.ts
 const DISABLE_COMMENT_RULE_NAME_PATTERN$1 = /(?:^|[\s,/])exhaustive-deps(?:$|[\s,:])/;
 const DISABLE_NEXT_LINE_PATTERN$1 = /\b(?:eslint|oxlint)-disable-next-line\b([^\n]*)/;
@@ -13979,6 +13289,25 @@ const isExhaustiveDepsSuppressedAt = (filename, nodeStartOffset) => {
 	return index.suppressedLines.has(lineForOffset$1(nodeStartOffset, index.utf16NewlineOffsets)) || index.suppressedLines.has(lineForOffset$1(nodeStartOffset, index.utf8NewlineOffsets));
 };
 //#endregion
+//#region src/plugin/utils/is-ast-descendant.ts
+/**
+* True when `inner` is `outer` itself or any descendant in the AST
+* `parent` chain. Walks `inner.parent` upward and stops at either a
+* match (`true`) or the chain's root (`false`).
+*
+* Was duplicated byte-identical in:
+* - exhaustive-deps-symbol-stability.ts
+* - semantic/closure-captures.ts
+*/
+const isAstDescendant = (inner, outer) => {
+	let current = inner;
+	while (current) {
+		if (current === outer) return true;
+		current = current.parent ?? null;
+	}
+	return false;
+};
+//#endregion
 //#region src/plugin/rules/react-builtins/exhaustive-deps-symbol-stability.ts
 /**
 * Symbol-stability helpers consumed by the `exhaustive-deps` rule.
@@ -14159,7 +13488,6 @@ const EFFECT_HOOKS_ALLOWING_EXTRA_REACTIVE_DEPS = new Set([
 	"useLayoutEffect",
 	"useInsertionEffect"
 ]);
-const SOLE_WRITER_GUARD_HOOKS = new Set(["useEffect", "useLayoutEffect"]);
 const buildAdditionalHooksRegex = (additional) => {
 	if (!additional) return null;
 	try {
@@ -14296,7 +13624,7 @@ const stringifyMemberChain = (node) => {
 	}
 	return null;
 };
-const collectCaptureDepKeys = (callback, scopes, declaredExactBindingKeys, allowSoleWriterEffectGuards = false) => {
+const collectCaptureDepKeys = (callback, scopes, declaredExactBindingKeys) => {
 	const keys = /* @__PURE__ */ new Set();
 	const stableCapturedNames = /* @__PURE__ */ new Set();
 	const moduleScopeCapturedNames = /* @__PURE__ */ new Set();
@@ -14307,10 +13635,6 @@ const collectCaptureDepKeys = (callback, scopes, declaredExactBindingKeys, allow
 		const symbol = reference.resolvedSymbol;
 		if (!symbol) continue;
 		if (isRecursiveInitializerCapture(symbol, callback)) continue;
-		if (allowSoleWriterEffectGuards && isSoleWriterEffectGuardCapture(symbol, callback, scopes)) {
-			stableCapturedNames.add(symbol.name);
-			continue;
-		}
 		if (symbolHasStableValue(symbol, scopes)) {
 			stableCapturedNames.add(symbol.name);
 			continue;
@@ -14983,7 +14307,7 @@ If the missing value is recreated every render, move it inside the hook or stabi
 				if (isNodeOfType(stripped, "Identifier")) declaredExactBindingKeys.add(key);
 				declaredKeyToReportNode.set(key, elementNode);
 			}
-			const { keys: captureKeys, stableCapturedNames, moduleScopeCapturedNames, outerFunctionCapturedNames } = collectCaptureDepKeys(callbackToAnalyze ?? callbackArgument, context.scopes, declaredExactBindingKeys, SOLE_WRITER_GUARD_HOOKS.has(hookName));
+			const { keys: captureKeys, stableCapturedNames, moduleScopeCapturedNames, outerFunctionCapturedNames } = collectCaptureDepKeys(callbackToAnalyze ?? callbackArgument, context.scopes, declaredExactBindingKeys);
 			for (const forcedCaptureKey of forcedCaptureKeys) captureKeys.add(forcedCaptureKey);
 			addAggregatePropsDependency(captureKeys, declaredKeys, callbackToAnalyze ?? callbackArgument, context.scopes);
 			const missingCaptureKeys = [];
@@ -16797,14 +16121,14 @@ const isBindingInvokedOnRenderPath = (root, bindingName) => {
 		if (didFindRenderPathInvocation) return false;
 		if (!isNodeOfType(node, "CallExpression")) return;
 		if (!isNodeOfType(node.callee, "Identifier") || node.callee.name !== bindingName) return;
-		let enclosingFunction = findEnclosingFunction$1(node);
+		let enclosingFunction = findEnclosingFunction(node);
 		while (enclosingFunction) {
 			if (isDeferredCallbackPosition$1(enclosingFunction) || getHandlerNamedBindingName(enclosingFunction)) return;
 			if (containingFunctionIsComponentOrHook(enclosingFunction)) {
 				didFindRenderPathInvocation = true;
 				return;
 			}
-			enclosingFunction = findEnclosingFunction$1(enclosingFunction);
+			enclosingFunction = findEnclosingFunction(enclosingFunction);
 		}
 	});
 	return didFindRenderPathInvocation;
@@ -16839,7 +16163,7 @@ const jotaiSelectAtomInRenderBody = defineRule({
 		};
 		return { CallExpression(node) {
 			if (!isImportedSelectAtom(node)) return;
-			const nearestFunctionLike = findEnclosingFunction$1(node);
+			const nearestFunctionLike = findEnclosingFunction(node);
 			if (!nearestFunctionLike) return;
 			if (isDeferredCallback(nearestFunctionLike)) return;
 			if (isBindingUsedAsHandler(nearestFunctionLike)) return;
@@ -17836,7 +17160,7 @@ const isPersistentCacheSetWrite = (callExpression, newExpression, enclosingFunct
 	return !isAstDescendant(receiverBinding.scopeOwner, enclosingFunction);
 };
 const isInsideCacheMemo = (node) => {
-	const enclosingFunction = findEnclosingFunction$1(node);
+	const enclosingFunction = findEnclosingFunction(node);
 	let child = node;
 	let cursor = node.parent ?? null;
 	while (cursor) {
@@ -17874,7 +17198,7 @@ const getFunctionName = (functionNode) => {
 	return null;
 };
 const isUncacheableOptionsMergeUtility = (node) => {
-	const enclosingFunction = findEnclosingFunction$1(node);
+	const enclosingFunction = findEnclosingFunction(node);
 	if (!enclosingFunction || !isFunctionLike$2(enclosingFunction)) return false;
 	const functionName = getFunctionName(enclosingFunction);
 	if (!functionName || isComponentOrHookName(functionName)) return false;
@@ -18065,6 +17389,13 @@ const isSafeStatefulReplaceAllSearch = (node, flags, context) => {
 	const callee = stripParenExpression(replaceAllCall.callee);
 	return isNodeOfType(callee, "MemberExpression") && !callee.computed && !callee.optional && !replaceAllCall.optional && isNodeOfType(callee.property, "Identifier") && callee.property.name === "replaceAll" && isProvenNativeStringReceiver(callee.object, context);
 };
+const getDestructuredBindingPropertyName = (bindingIdentifier) => {
+	let bindingNode = bindingIdentifier;
+	if (isNodeOfType(bindingNode.parent, "AssignmentPattern") && bindingNode.parent.left === bindingNode) bindingNode = bindingNode.parent;
+	const property = bindingNode.parent;
+	if (!isNodeOfType(property, "Property") || property.value !== bindingNode || !isNodeOfType(property.parent, "ObjectPattern")) return null;
+	return getStaticPropertyKeyName(property, { allowComputedString: true });
+};
 const extendGlobalPath = (basePath, propertyName) => {
 	if (basePath === "global") {
 		if (propertyName === null || GLOBAL_OBJECT_NAMES.has(propertyName)) return "global";
@@ -18354,89 +17685,7 @@ const collectEarlierAndGuardOperands = (node) => {
 	return earlierOperands;
 };
 //#endregion
-//#region src/plugin/utils/unwrap-object-integrity-expression.ts
-const OBJECT_INTEGRITY_METHOD_NAMES = new Set([
-	"freeze",
-	"seal",
-	"preventExtensions"
-]);
-const OBJECT_FREEZE_OR_SEAL_METHOD_NAMES = new Set(["freeze", "seal"]);
-const getObjectIntegrityMethodName = (node, scopes, methodNames = OBJECT_INTEGRITY_METHOD_NAMES) => {
-	const expression = stripParenExpression(node);
-	if (!isNodeOfType(expression, "CallExpression")) return null;
-	const callee = stripParenExpression(expression.callee);
-	const receiver = isNodeOfType(callee, "MemberExpression") ? stripParenExpression(callee.object) : callee;
-	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(receiver, "Identifier") || receiver.name !== "Object" || !scopes.isGlobalReference(receiver) || !isNodeOfType(callee.property, "Identifier") || !methodNames.has(callee.property.name)) return null;
-	return callee.property.name;
-};
-const unwrapObjectIntegrityExpression = (node, scopes, methodNames = OBJECT_INTEGRITY_METHOD_NAMES) => {
-	let expression = stripParenExpression(node);
-	while (isNodeOfType(expression, "CallExpression")) {
-		if (!getObjectIntegrityMethodName(expression, scopes, methodNames)) break;
-		const wrappedExpression = expression.arguments[0];
-		if (!wrappedExpression || isNodeOfType(wrappedExpression, "SpreadElement")) break;
-		expression = stripParenExpression(wrappedExpression);
-	}
-	return expression;
-};
-//#endregion
 //#region src/plugin/rules/js-performance/js-length-check-first.ts
-const OBJECT_CARDINALITY_PROJECTION_METHOD_NAMES = new Set(["keys", "values"]);
-const getGlobalObjectProjection = (expression, context) => {
-	const callExpression = stripParenExpression(expression);
-	if (!isNodeOfType(callExpression, "CallExpression")) return null;
-	const callee = stripParenExpression(callExpression.callee);
-	if (!isNodeOfType(callee, "MemberExpression")) return null;
-	const receiver = stripParenExpression(callee.object);
-	if (!isNodeOfType(receiver, "Identifier") || receiver.name !== "Object" || !context.scopes.isGlobalReference(receiver)) return null;
-	const methodName = getStaticPropertyName(callee);
-	if (!methodName || !OBJECT_CARDINALITY_PROJECTION_METHOD_NAMES.has(methodName)) return null;
-	const callArguments = callExpression.arguments ?? [];
-	if (callArguments.length !== 1 || isNodeOfType(callArguments[0], "SpreadElement")) return null;
-	return {
-		methodName,
-		source: callArguments[0]
-	};
-};
-const isPlainDataObjectLiteral = (expression) => {
-	const objectExpression = stripParenExpression(expression);
-	if (!isNodeOfType(objectExpression, "ObjectExpression")) return false;
-	return (objectExpression.properties ?? []).every((property) => {
-		if (!isNodeOfType(property, "Property") || property.kind !== "init" || property.method === true) return false;
-		const propertyValue = stripParenExpression(property.value);
-		return isNodeOfType(propertyValue, "Literal") || isNodeOfType(propertyValue, "TemplateLiteral") && propertyValue.expressions.length === 0;
-	});
-};
-const getGlobalObjectFreezeArgument = (expression, context) => {
-	const callExpression = stripParenExpression(expression);
-	if (!isNodeOfType(callExpression, "CallExpression")) return null;
-	if (getObjectIntegrityMethodName(callExpression, context.scopes) !== "freeze") return null;
-	const callArguments = callExpression.arguments ?? [];
-	if (callArguments.length !== 1 || isNodeOfType(callArguments[0], "SpreadElement")) return null;
-	return callArguments[0];
-};
-const resolveStablePlainObjectRootId = (expression, context, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const source = stripParenExpression(expression);
-	if (!isNodeOfType(source, "Identifier")) return null;
-	const symbol = context.scopes.symbolFor(source);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return null;
-	const directConstInitializer = getDirectConstInitializer(symbol);
-	if (!directConstInitializer) return null;
-	visitedSymbolIds.add(symbol.id);
-	const initializer = stripParenExpression(directConstInitializer);
-	const frozenValue = getGlobalObjectFreezeArgument(initializer, context);
-	if (frozenValue) return isPlainDataObjectLiteral(frozenValue) ? symbol.id : null;
-	return resolveStablePlainObjectRootId(initializer, context, visitedSymbolIds);
-};
-const areEqualCardinalityObjectProjections = (receiverArray, indexedArray, context) => {
-	const receiverProjection = getGlobalObjectProjection(receiverArray, context);
-	const indexedProjection = getGlobalObjectProjection(indexedArray, context);
-	if (!receiverProjection || !indexedProjection) return false;
-	if (receiverProjection.methodName === indexedProjection.methodName) return false;
-	const receiverRootId = resolveStablePlainObjectRootId(receiverProjection.source, context);
-	const indexedRootId = resolveStablePlainObjectRootId(indexedProjection.source, context);
-	return receiverRootId !== null && receiverRootId === indexedRootId;
-};
 const findIndexedArrayObject = (callbackBody, indexParameterName) => {
 	let indexedArrayObject = null;
 	walkAst(callbackBody, (child) => {
@@ -18651,7 +17900,6 @@ const jsLengthCheckFirst = defineRule({
 		const resolvedReceiverSource = resolveComparedArraySource(receiverArrayObject, node);
 		const resolvedIndexedSource = resolveComparedArraySource(indexedArrayObject, node);
 		if (areExpressionsStructurallyEqual(resolvedReceiverSource, resolvedIndexedSource)) return;
-		if (areEqualCardinalityObjectProjections(receiverArrayObject, indexedArrayObject, context) || areEqualCardinalityObjectProjections(resolvedReceiverSource, resolvedIndexedSource, context)) return;
 		const comparedArrayPairs = [[receiverArrayObject, indexedArrayObject], [resolvedReceiverSource, resolvedIndexedSource]];
 		if (collectEarlierAndGuardOperands(node).some((guardOperand) => comparedArrayPairs.some(([receiverSide, indexedSide]) => isLengthComparison(guardOperand, receiverSide, indexedSide, LENGTH_ANY_COMPARISON_OPERATORS)))) return;
 		if (collectEarlierOrOperands(node).some((guardOperand) => comparedArrayPairs.some(([receiverSide, indexedSide]) => isLengthComparison(guardOperand, receiverSide, indexedSide, LENGTH_MISMATCH_OPERATORS)))) return;
@@ -24529,6 +23777,32 @@ const hasDirective = (programNode, directive) => {
 	return Boolean(programNode.body?.some((statement) => isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "Literal") && statement.expression.value === directive));
 };
 //#endregion
+//#region src/plugin/utils/unwrap-object-integrity-expression.ts
+const OBJECT_INTEGRITY_METHOD_NAMES = new Set([
+	"freeze",
+	"seal",
+	"preventExtensions"
+]);
+const OBJECT_FREEZE_OR_SEAL_METHOD_NAMES = new Set(["freeze", "seal"]);
+const getObjectIntegrityMethodName = (node, scopes, methodNames = OBJECT_INTEGRITY_METHOD_NAMES) => {
+	const expression = stripParenExpression(node);
+	if (!isNodeOfType(expression, "CallExpression")) return null;
+	const callee = stripParenExpression(expression.callee);
+	const receiver = isNodeOfType(callee, "MemberExpression") ? stripParenExpression(callee.object) : callee;
+	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(receiver, "Identifier") || receiver.name !== "Object" || !scopes.isGlobalReference(receiver) || !isNodeOfType(callee.property, "Identifier") || !methodNames.has(callee.property.name)) return null;
+	return callee.property.name;
+};
+const unwrapObjectIntegrityExpression = (node, scopes, methodNames = OBJECT_INTEGRITY_METHOD_NAMES) => {
+	let expression = stripParenExpression(node);
+	while (isNodeOfType(expression, "CallExpression")) {
+		if (!getObjectIntegrityMethodName(expression, scopes, methodNames)) break;
+		const wrappedExpression = expression.arguments[0];
+		if (!wrappedExpression || isNodeOfType(wrappedExpression, "SpreadElement")) break;
+		expression = stripParenExpression(wrappedExpression);
+	}
+	return expression;
+};
+//#endregion
 //#region src/plugin/rules/nextjs/nextjs-async-client-component.ts
 const nextjsAsyncClientComponent = defineRule({
 	id: "nextjs-async-client-component",
@@ -26868,7 +26142,7 @@ const isIndependentWriterIdentifier = (componentFunction, identifier, includeDef
 };
 const hasUserInputSetterWriter = (setterRef, effectNode, includeDeferredWriters = false) => {
 	if (!setterRef.resolved) return false;
-	const componentFunction = findEnclosingFunction$1(effectNode);
+	const componentFunction = findEnclosingFunction(effectNode);
 	if (!componentFunction) return false;
 	for (const reference of setterRef.resolved.references) {
 		if (reference.init) continue;
@@ -29641,6 +28915,138 @@ const noBarrelImport = defineRule({
 	}
 });
 //#endregion
+//#region src/plugin/utils/has-static-property-write-before.ts
+const equivalentSymbolsByAnalysis = /* @__PURE__ */ new WeakMap();
+const CONDITIONAL_EXECUTION_NODE_TYPES = new Set([
+	"CatchClause",
+	"ConditionalExpression",
+	"DoWhileStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"ForStatement",
+	"IfStatement",
+	"LogicalExpression",
+	"SwitchCase",
+	"SwitchStatement",
+	"TryStatement",
+	"WhileStatement"
+]);
+const getResolvedStaticPropertyName = (memberExpression, scopes) => {
+	if (!isNodeOfType(memberExpression, "MemberExpression")) return null;
+	const directPropertyName = getStaticPropertyName(memberExpression);
+	if (directPropertyName || !memberExpression.computed) return directPropertyName;
+	const property = stripParenExpression(memberExpression.property);
+	if (!isNodeOfType(property, "Identifier")) return null;
+	const propertySymbol = resolveConstIdentifierAlias(property, scopes);
+	const initializer = propertySymbol?.initializer ? stripParenExpression(propertySymbol.initializer) : null;
+	return initializer && isNodeOfType(initializer, "Literal") && typeof initializer.value === "string" ? initializer.value : null;
+};
+const collectScopeSymbols = (scope, symbols) => {
+	symbols.push(...scope.symbols);
+	for (const childScope of scope.children) collectScopeSymbols(childScope, symbols);
+};
+const getEquivalentSymbols = (identifier, scopes) => {
+	const rootSymbol = resolveConstIdentifierAlias(identifier, scopes);
+	if (!rootSymbol) return [];
+	let symbolsByRootId = equivalentSymbolsByAnalysis.get(scopes);
+	if (!symbolsByRootId) {
+		symbolsByRootId = /* @__PURE__ */ new Map();
+		equivalentSymbolsByAnalysis.set(scopes, symbolsByRootId);
+	}
+	const cachedSymbols = symbolsByRootId.get(rootSymbol.id);
+	if (cachedSymbols) return cachedSymbols;
+	const allSymbols = [];
+	collectScopeSymbols(scopes.rootScope, allSymbols);
+	const equivalentSymbols = allSymbols.filter((symbol) => resolveConstIdentifierAlias(symbol.bindingIdentifier, scopes)?.id === rootSymbol.id);
+	symbolsByRootId.set(rootSymbol.id, equivalentSymbols);
+	return equivalentSymbols;
+};
+const findExecutionBoundary = (node) => {
+	let current = node;
+	while (current) {
+		if (isFunctionLike$2(current) || isNodeOfType(current, "Program")) return current;
+		current = current.parent ?? null;
+	}
+	return null;
+};
+const isOnUnconditionalPath = (node, boundary) => {
+	let current = node.parent ?? null;
+	while (current && current !== boundary) {
+		if (CONDITIONAL_EXECUTION_NODE_TYPES.has(current.type)) return false;
+		current = current.parent ?? null;
+	}
+	return current === boundary;
+};
+const findFunctionBindingIdentifier = (functionNode) => {
+	if (isNodeOfType(functionNode, "FunctionDeclaration")) return functionNode.id ?? null;
+	const parent = functionNode.parent;
+	if (parent && isNodeOfType(parent, "VariableDeclarator") && parent.init === functionNode && isNodeOfType(parent.id, "Identifier")) return parent.id;
+	return null;
+};
+const findDirectCall = (identifier) => {
+	let callee = identifier;
+	let parent = callee.parent;
+	while (parent && stripParenExpression(parent) === identifier) {
+		callee = parent;
+		parent = callee.parent;
+	}
+	return parent && isNodeOfType(parent, "CallExpression") && parent.callee === callee ? parent : null;
+};
+const isFunctionSynchronouslyInvokedBefore = (functionNode, referenceNode, scopes, visitedFunctionNodes = /* @__PURE__ */ new Set()) => {
+	if (visitedFunctionNodes.has(functionNode) || !isFunctionLike$2(functionNode) || functionNode.generator) return false;
+	visitedFunctionNodes.add(functionNode);
+	const referenceBoundary = findExecutionBoundary(referenceNode);
+	if (!referenceBoundary) return false;
+	const invocationCalls = [];
+	const bindingIdentifier = findFunctionBindingIdentifier(functionNode);
+	if (bindingIdentifier) for (const symbol of getEquivalentSymbols(bindingIdentifier, scopes)) for (const reference of symbol.references) {
+		const call = findDirectCall(reference.identifier);
+		if (call) invocationCalls.push(call);
+	}
+	else {
+		const call = findDirectCall(functionNode);
+		if (call) invocationCalls.push(call);
+	}
+	return invocationCalls.some((call) => {
+		if (call.range[0] >= referenceNode.range[0]) return false;
+		const callBoundary = findExecutionBoundary(call);
+		if (!callBoundary) return false;
+		if (callBoundary === referenceBoundary) return true;
+		if (!isFunctionLike$2(callBoundary)) return false;
+		return isFunctionSynchronouslyInvokedBefore(callBoundary, referenceNode, scopes, new Set(visitedFunctionNodes));
+	});
+};
+const isMemberWriteTarget = (memberExpression) => {
+	const parent = memberExpression.parent;
+	if (!parent) return false;
+	if (isNodeOfType(parent, "AssignmentExpression")) return parent.left === memberExpression;
+	if (isNodeOfType(parent, "UpdateExpression")) return parent.argument === memberExpression;
+	return isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" && parent.argument === memberExpression;
+};
+const symbolHasStaticPropertyWriteBefore = (symbol, propertyName, referenceNode, scopes) => symbol.references.some((reference) => {
+	let parent = reference.identifier.parent;
+	while (parent && stripParenExpression(parent) === reference.identifier) parent = parent.parent;
+	if (!parent || !isNodeOfType(parent, "MemberExpression") || stripParenExpression(parent.object) !== reference.identifier || getResolvedStaticPropertyName(parent, scopes) !== propertyName || !isMemberWriteTarget(parent)) return false;
+	const writeBoundary = findExecutionBoundary(parent);
+	const referenceBoundary = findExecutionBoundary(referenceNode);
+	if (!writeBoundary || !referenceBoundary || !isOnUnconditionalPath(parent, writeBoundary)) return false;
+	if (writeBoundary === referenceBoundary) return parent.range[0] < referenceNode.range[0];
+	return isFunctionLike$2(writeBoundary) && isFunctionSynchronouslyInvokedBefore(writeBoundary, referenceNode, scopes);
+});
+const hasStaticPropertyWriteBefore = (identifier, propertyName, referenceNode, scopes) => {
+	if (!isNodeOfType(identifier, "Identifier")) return false;
+	return getEquivalentSymbols(identifier, scopes).some((symbol) => symbolHasStaticPropertyWriteBefore(symbol, propertyName, referenceNode, scopes));
+};
+//#endregion
+//#region src/plugin/utils/has-symbol-write-before.ts
+const hasSymbolWriteBefore = (symbol, referenceNode, scopes) => symbol.references.some((reference) => {
+	if (reference.flag === "read") return false;
+	const writeFunction = findEnclosingFunction(reference.identifier);
+	if (writeFunction === findEnclosingFunction(referenceNode)) return reference.identifier.range[0] < referenceNode.range[0];
+	if (!writeFunction) return true;
+	return isFunctionSynchronouslyInvokedBefore(writeFunction, referenceNode, scopes);
+});
+//#endregion
 //#region src/plugin/utils/has-stable-call-target.ts
 const hasStableCallTarget = (callExpression, scopes) => {
 	if (!isNodeOfType(callExpression, "CallExpression")) return false;
@@ -30109,8 +29515,8 @@ const isUseMemoCallbackArgument = (functionNode) => {
 	return isReactFunctionCall(parent, "useMemo");
 };
 const findEnclosingRenderFunction = (node) => {
-	let enclosingFunction = findEnclosingFunction$1(node);
-	while (enclosingFunction && isUseMemoCallbackArgument(enclosingFunction)) enclosingFunction = findEnclosingFunction$1(enclosingFunction);
+	let enclosingFunction = findEnclosingFunction(node);
+	while (enclosingFunction && isUseMemoCallbackArgument(enclosingFunction)) enclosingFunction = findEnclosingFunction(enclosingFunction);
 	return enclosingFunction;
 };
 const noCreateRefInFunctionComponent = defineRule({
@@ -31161,7 +30567,7 @@ const getEnclosingEffectHookCallback = (node, componentFunction) => {
 const isEffectDrivenResync = (useStateCall) => {
 	const setterName = getStateSetterName(useStateCall);
 	if (!setterName) return false;
-	const componentFunction = findEnclosingFunction$1(useStateCall);
+	const componentFunction = findEnclosingFunction(useStateCall);
 	if (!componentFunction) return false;
 	let isExempt = false;
 	walkAst(componentFunction, (child) => {
@@ -31265,7 +30671,7 @@ const isDraftReseedOrRenderAdjusted = (useStateCall, isPropName) => {
 	const setterName = getStateSetterName(useStateCall);
 	if (!setterName) return false;
 	const stateValueName = getStateValueName(useStateCall);
-	const componentFunction = findEnclosingFunction$1(useStateCall);
+	const componentFunction = findEnclosingFunction(useStateCall);
 	if (!componentFunction) return false;
 	let isExempt = false;
 	walkAst(componentFunction, (child) => {
@@ -31311,7 +30717,7 @@ const noDerivedUseState = defineRule({
 					if (isDraftReseedOrRenderAdjusted(node, propStackTracker.isPropName)) return;
 					if (isEffectDrivenResync(node)) return;
 					if (isNextjsDataFetchingPage(node)) return;
-					const componentFunction = findEnclosingFunction$1(node);
+					const componentFunction = findEnclosingFunction(node);
 					if (componentFunction) {
 						if (isDefaultedDestructuredProp(componentFunction, propName)) return;
 						if (isDraftCommittedToParent(componentFunction, getStateValueName(node), propStackTracker.isPropName)) return;
@@ -33149,7 +32555,7 @@ const isFunctionUsedOutsideHandlers = (analysis, functionNode, componentFunction
 		if (isInsideInlineEventHandler(identifier, componentFunction)) return false;
 		const parent = identifier.parent;
 		if (parent && isNodeOfType(parent, "CallExpression") && parent.callee === identifier) {
-			if (findEnclosingFunction$1(parent) === functionNode) return false;
+			if (findEnclosingFunction(parent) === functionNode) return false;
 			if (isInsideProvenEventHandler(analysis, parent, componentFunction, false)) return false;
 		}
 		return true;
@@ -33195,7 +32601,7 @@ const isStateWrittenOnlyFromEventHandlers = (analysis, stateReference) => {
 	if (!setterVariable) return false;
 	const stateDeclarator = getUseStateDecl(analysis, stateReference);
 	if (!stateDeclarator) return false;
-	const componentFunction = findEnclosingFunction$1(stateDeclarator);
+	const componentFunction = findEnclosingFunction(stateDeclarator);
 	if (!componentFunction) return false;
 	let hasWriter = false;
 	for (const reference of setterVariable.references) {
@@ -34257,8 +33663,8 @@ const isAwaitedInFunction = (request, functionNode) => {
 	return false;
 };
 const isCompletionSinkForRequest = (completionSink, request) => {
-	const requestFunction = findEnclosingFunction$1(request);
-	const completionSinkFunction = findEnclosingFunction$1(completionSink);
+	const requestFunction = findEnclosingFunction(request);
+	const completionSinkFunction = findEnclosingFunction(completionSink);
 	if (!requestFunction || !completionSinkFunction) return false;
 	if (requestFunction === completionSinkFunction) {
 		if (!isAwaitedInFunction(request, requestFunction)) return false;
@@ -34545,6 +33951,13 @@ const isPublishedLibraryPackage = (filename) => {
 	return manifest.private !== true && typeof manifest.peerDependencies === "object" && manifest.peerDependencies !== null && "react" in manifest.peerDependencies;
 };
 //#endregion
+//#region src/plugin/utils/is-type-only-import.ts
+const isEverySpecifierInlineType = (specifiers, specifierType, kindField) => {
+	if (!specifiers || specifiers.length === 0) return false;
+	return specifiers.every((specifier) => isNodeOfType(specifier, specifierType) && specifier[kindField] === "type");
+};
+const isTypeOnlyImport = (node) => node.importKind === "type" || isEverySpecifierInlineType(node.specifiers, "ImportSpecifier", "importKind");
+//#endregion
 //#region src/plugin/rules/bundle-size/no-full-lodash-import.ts
 const isLibraryDevPage = (filename) => {
 	if (!filename) return false;
@@ -35108,7 +34521,7 @@ const isInRenderedOutput = (node, componentOrHookNode, scopes) => {
 			return attribute ? !isEventHandlerAttribute(attribute) : true;
 		}
 		if (isNodeOfType(parentNode, "ReturnStatement")) {
-			if (findEnclosingFunction$1(parentNode) === componentOrHookNode) return true;
+			if (findEnclosingFunction(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;
@@ -35231,7 +34644,7 @@ const noHydrationBranchOnBrowserGlobal = defineRule({
 				if (consequentValues.length === 0 || alternateValues.length === 0) return;
 				const componentOrHookNode = findRenderPhaseComponentOrHook(node.test, context.scopes);
 				if (!componentOrHookNode) return;
-				const enclosingFunction = findEnclosingFunction$1(node);
+				const enclosingFunction = findEnclosingFunction(node);
 				if (enclosingFunction !== componentOrHookNode && (!enclosingFunction || !isInRenderedOutput(enclosingFunction, componentOrHookNode, context.scopes))) return;
 				for (const consequentValue of consequentValues) for (const alternateValue of alternateValues) {
 					if (!isRenderedValue(consequentValue) && !isRenderedValue(alternateValue)) continue;
@@ -35679,10 +35092,10 @@ const isInsideInstanceField = (node) => {
 	return false;
 };
 const isOneShotModuleInitialization = (node, context) => {
-	let functionNode = findEnclosingFunction$1(node);
+	let functionNode = findEnclosingFunction(node);
 	while (functionNode) {
 		if (!executesDuringRender(functionNode, context.scopes)) return false;
-		functionNode = findEnclosingFunction$1(functionNode);
+		functionNode = findEnclosingFunction(functionNode);
 	}
 	return !isInsideInstanceField(node);
 };
@@ -36666,10 +36079,10 @@ const getMethodCalls = (functionNode, scopes) => {
 const isFunctionInvokedBeforeUsage = (functionNode, usageNode, usageBoundary, scopes, visitedSymbolIds, visitedFunctionNodes = /* @__PURE__ */ new Set()) => {
 	if (visitedFunctionNodes.has(functionNode)) return false;
 	visitedFunctionNodes.add(functionNode);
-	const usageFunction = findEnclosingFunction$1(usageNode);
+	const usageFunction = findEnclosingFunction(usageNode);
 	const immediateCall = getDirectCallForExpression(functionNode);
 	if (immediateCall) {
-		const immediateCallFunction = findEnclosingFunction$1(immediateCall);
+		const immediateCallFunction = findEnclosingFunction(immediateCall);
 		if (immediateCallFunction === usageFunction) {
 			const immediateCallStart = getRangeStart(immediateCall);
 			return immediateCallStart === null || immediateCallStart < usageBoundary;
@@ -36678,7 +36091,7 @@ const isFunctionInvokedBeforeUsage = (functionNode, usageNode, usageBoundary, sc
 		return isFunctionInvokedBeforeUsage(immediateCallFunction, usageNode, usageBoundary, scopes, visitedSymbolIds, new Set(visitedFunctionNodes));
 	}
 	for (const methodCall of getMethodCalls(functionNode, scopes)) {
-		const methodCallFunction = findEnclosingFunction$1(methodCall);
+		const methodCallFunction = findEnclosingFunction(methodCall);
 		if (methodCallFunction === usageFunction) {
 			const methodCallStart = getRangeStart(methodCall);
 			if (methodCallStart === null || methodCallStart < usageBoundary) return true;
@@ -36701,7 +36114,7 @@ const isFunctionInvokedBeforeUsage = (functionNode, usageNode, usageBoundary, sc
 		if (scopes.symbolFor(child)?.declarationNode !== symbol.declarationNode) return;
 		const call = getDirectCallForExpression(child);
 		if (!call) return false;
-		const callFunction = findEnclosingFunction$1(call);
+		const callFunction = findEnclosingFunction(call);
 		if (callFunction === usageFunction) {
 			const callStart = getRangeStart(call);
 			wasInvokedBeforeUsage = callStart === null || callStart < usageBoundary;
@@ -36732,14 +36145,14 @@ const wasMutatedBeforeUsage = (symbol, usageNode, readNode, scopes, visitedMutat
 	visitedMutationSymbolIds.add(symbol.id);
 	const usageBoundary = inheritedUsageBoundary === void 0 ? getMutationUsageBoundary(usageNode, readNode) : inheritedUsageBoundary;
 	if (typeof usageBoundary !== "number") return true;
-	const usageFunction = findEnclosingFunction$1(usageNode);
+	const usageFunction = findEnclosingFunction(usageNode);
 	return symbol.references.some((reference) => {
 		const referenceStart = getRangeStart(reference.identifier);
 		const simpleAlias = getSimpleAlias(reference.identifier, scopes);
 		if (simpleAlias) return wasMutatedBeforeUsage(simpleAlias.symbol, usageNode, readNodesBySymbolId.get(simpleAlias.symbol.id) ?? simpleAlias.readNode, scopes, new Set(visitedMutationSymbolIds), usageBoundary, readNodesBySymbolId);
 		if (!isPotentialMutationReference(reference.identifier, readNode)) return false;
 		if (referenceStart === null) return true;
-		const mutationFunction = findEnclosingFunction$1(reference.identifier);
+		const mutationFunction = findEnclosingFunction(reference.identifier);
 		if (mutationFunction === usageFunction) return referenceStart < usageBoundary;
 		if (!mutationFunction) return usageFunction !== null;
 		if (usageFunction && isAstDescendant(usageFunction, mutationFunction)) return true;
@@ -37321,6 +36734,13 @@ const isReactNamespaceExpression = (node, scopes) => {
 	return isReactNamespaceImport(node, scopes);
 };
 const isReactHocMemberReference = (node, scopes) => Boolean(isNodeOfType(node, "MemberExpression") && !node.computed && isNodeOfType(node.property, "Identifier") && REACT_HOC_NAMES.has(node.property.name) && isReactNamespaceExpression(node.object, scopes));
+const getDestructuredPropertyName$1 = (symbol) => {
+	const property = symbol.bindingIdentifier.parent;
+	if (!property || !isNodeOfType(property, "Property") || !property.parent || !isNodeOfType(property.parent, "ObjectPattern")) return null;
+	if (isNodeOfType(property.key, "Identifier") && !property.computed) return property.key.name;
+	if (isNodeOfType(property.key, "Literal") && typeof property.key.value === "string") return property.key.value;
+	return null;
+};
 const symbolMapsToHoc = (symbol, scopes, visitedSymbolIds) => {
 	if (visitedSymbolIds.has(symbol.id)) return false;
 	visitedSymbolIds.add(symbol.id);
@@ -37330,7 +36750,7 @@ const symbolMapsToHoc = (symbol, scopes, visitedSymbolIds) => {
 	}
 	const init = symbol.initializer;
 	if (!init) return false;
-	const destructuredPropertyName = getDestructuredBindingPropertyName(symbol.bindingIdentifier);
+	const destructuredPropertyName = getDestructuredPropertyName$1(symbol);
 	if (destructuredPropertyName && REACT_HOC_NAMES.has(destructuredPropertyName) && isReactNamespaceExpression(init, scopes)) return true;
 	if (isReactHocMemberReference(init, scopes)) return true;
 	if (isNodeOfType(init, "Identifier")) {
@@ -39084,6 +38504,12 @@ const getDeclarationKind = (declarator) => {
 	return declaration && isNodeOfType(declaration, "VariableDeclaration") ? declaration.kind : null;
 };
 const hasMutableBindingWrite = (reference) => Boolean(reference.resolved?.references.some((candidateReference) => candidateReference.isWrite() && !candidateReference.init));
+const getDestructuredPropertyName = (bindingIdentifier) => {
+	const property = bindingIdentifier.parent;
+	if (!property || !isNodeOfType(property, "Property")) return null;
+	if (property.computed) return isNodeOfType(property.key, "Literal") && typeof property.key.value === "string" ? String(property.key.value) : null;
+	return isNodeOfType(property.key, "Identifier") ? property.key.name : null;
+};
 const getParentCallbackPropName = (analysis, expression, visitedVariables = /* @__PURE__ */ new Set()) => {
 	const unwrappedExpression = stripParenExpression(expression);
 	if (isNodeOfType(unwrappedExpression, "Identifier")) {
@@ -39093,7 +38519,7 @@ const getParentCallbackPropName = (analysis, expression, visitedVariables = /* @
 		if (isProp(analysis, callbackReference)) {
 			if (isWholePropsObjectReference(analysis, callbackReference)) return null;
 			const bindingIdentifier = callbackVariable.defs.find((definition) => definition.type === "Parameter")?.name;
-			return (bindingIdentifier && getDestructuredBindingPropertyName(bindingIdentifier)) ?? unwrappedExpression.name;
+			return (bindingIdentifier && getDestructuredPropertyName(bindingIdentifier)) ?? unwrappedExpression.name;
 		}
 		if (hasMutableBindingWrite(callbackReference)) return null;
 		const definitions = callbackVariable.defs.map((definition) => definition.node).filter((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
@@ -39103,7 +38529,7 @@ const getParentCallbackPropName = (analysis, expression, visitedVariables = /* @
 		visitedVariables.add(callbackVariable);
 		if (isNodeOfType(declarator.id, "ObjectPattern")) {
 			const bindingIdentifier = callbackVariable.defs[0]?.name;
-			const propertyName = bindingIdentifier ? getDestructuredBindingPropertyName(bindingIdentifier) : null;
+			const propertyName = bindingIdentifier ? getDestructuredPropertyName(bindingIdentifier) : null;
 			const propsReference = getDownstreamRefs(analysis, declarator.init).find((candidateReference) => isWholePropsObjectReference(analysis, candidateReference));
 			return propertyName && propsReference ? propertyName : null;
 		}
@@ -39206,7 +38632,7 @@ const getCallbackRefProvenance = (analysis, effectCall, callExpression, isReactU
 	const bindingProvenance = getRefBindingProvenance(analysis, stripParenExpression(callee.object), isReactUseRefCall);
 	if (!bindingProvenance) return null;
 	const { refCall, variables } = bindingProvenance;
-	const componentFunction = findEnclosingFunction$1(effectCall);
+	const componentFunction = findEnclosingFunction(effectCall);
 	if (!componentFunction || !isFunctionLike$2(componentFunction) || !isComponentFunction$1(componentFunction) || !isNodeOfType(componentFunction.body, "BlockStatement")) return null;
 	if (!getDirectComponentBodyStatement(effectCall, componentFunction.body)) return null;
 	const callbackPropNames = /* @__PURE__ */ new Set();
@@ -40194,7 +39620,7 @@ const isModuleScopedBinding = (identifier) => {
 	const binding = findVariableInitializer(identifier, identifier.name);
 	if (!binding) return false;
 	if (isNodeOfType(binding.scopeOwner, "Program")) return true;
-	if (isNodeOfType(binding.scopeOwner, "BlockStatement")) return findEnclosingFunction$1(binding.scopeOwner) === null;
+	if (isNodeOfType(binding.scopeOwner, "BlockStatement")) return findEnclosingFunction(binding.scopeOwner) === null;
 	return false;
 };
 const looksLikeFreshUpdateExpression = (expression) => {
@@ -42111,9 +41537,9 @@ const isReturnedFromAnyEffectInScope = (functionNode, ownerScope) => {
 	return isReturnedFromEffect;
 };
 const isInsideEffectCleanupReturn = (node, ownerScope) => {
-	let functionNode = findEnclosingFunction$1(node);
+	let functionNode = findEnclosingFunction(node);
 	while (functionNode) {
-		const outerFunction = findEnclosingFunction$1(functionNode);
+		const outerFunction = findEnclosingFunction(functionNode);
 		if (outerFunction && isEffectCallbackFunction(outerFunction) && isFunctionReturnedFromEffectCallback(functionNode, outerFunction)) return true;
 		if (isReturnedFromAnyEffectInScope(functionNode, ownerScope)) return true;
 		functionNode = outerFunction;
@@ -42121,7 +41547,7 @@ const isInsideEffectCleanupReturn = (node, ownerScope) => {
 	return false;
 };
 const hasRefCurrentReassignmentAfterClear = (clearCall, refName) => {
-	const enclosingFunction = findEnclosingFunction$1(clearCall);
+	const enclosingFunction = findEnclosingFunction(clearCall);
 	if (!isFunctionLike$2(enclosingFunction)) return false;
 	if (!isNodeOfType(enclosingFunction.body, "BlockStatement")) return false;
 	const clearStart = getRangeStart(clearCall);
@@ -42951,7 +42377,7 @@ const isInsideAvailabilityGuard = (node, browserGlobalName, context) => {
 	return false;
 };
 const isAfterAvailabilityEarlyExit = (node, componentOrHookNode, browserGlobalName, context) => {
-	const enclosingFunction = findEnclosingFunction$1(node);
+	const enclosingFunction = findEnclosingFunction(node);
 	if (!enclosingFunction || enclosingFunction !== componentOrHookNode && !executesDuringRender(enclosingFunction, context.scopes) || !isFunctionLike$2(enclosingFunction) || !isNodeOfType(enclosingFunction.body, "BlockStatement")) return false;
 	let currentNode = node;
 	while (currentNode !== enclosingFunction) {
@@ -44218,11 +43644,7 @@ const resolveSettings$8 = (settings) => {
 		propNamePattern: ruleSettings.propNamePattern ?? "render*"
 	};
 };
-const isReactCreateElementCall = (node, scopes) => isReactApiCall(node, "createElement", scopes, {
-	allowGlobalReactNamespace: true,
-	resolveNamedAliases: true
-});
-const expressionContainsJsxOrCreateElement = (root, scopes) => {
+const expressionContainsJsxOrCreateElement = (root) => {
 	let found = false;
 	walkAst(root, (node) => {
 		if (found) return false;
@@ -44231,17 +43653,17 @@ const expressionContainsJsxOrCreateElement = (root, scopes) => {
 			found = true;
 			return false;
 		}
-		if (isNodeOfType(node, "CallExpression") && isReactCreateElementCall(node, scopes)) {
+		if (isNodeOfType(node, "CallExpression") && isCreateElementCall(node)) {
 			found = true;
 			return false;
 		}
 	});
 	return found;
 };
-const functionContainsJsxOrCreateElement = (functionNode, scopes, controlFlow) => expressionContainsJsxOrCreateElement(functionNode, scopes) || functionReturnsMatchingExpression(functionNode, scopes, (expression) => expressionContainsJsxOrCreateElement(expression, scopes), controlFlow);
-const isReactClassComponent = (classNode, scopes) => {
+const functionContainsJsxOrCreateElement = (functionNode, scopes, controlFlow) => expressionContainsJsxOrCreateElement(functionNode) || functionReturnsMatchingExpression(functionNode, scopes, expressionContainsJsxOrCreateElement, controlFlow);
+const isReactClassComponent = (classNode) => {
 	if (isEs6Component(classNode)) return true;
-	return expressionContainsJsxOrCreateElement(classNode, scopes);
+	return expressionContainsJsxOrCreateElement(classNode);
 };
 const findEnclosingComponent = (node, scopes, controlFlow) => {
 	let walker = node.parent;
@@ -44258,7 +43680,7 @@ const findEnclosingComponent = (node, scopes, controlFlow) => {
 			};
 		}
 		if (isNodeOfType(walker, "ClassDeclaration") || isNodeOfType(walker, "ClassExpression")) {
-			if (walker.id && isReactComponentName(walker.id.name) && isReactClassComponent(walker, scopes)) return {
+			if (walker.id && isReactComponentName(walker.id.name) && isReactClassComponent(walker)) return {
 				component: walker,
 				name: walker.id.name
 			};
@@ -44347,12 +43769,12 @@ const isObjectCallbackCandidate = (node) => {
 	}
 	return false;
 };
-const hocCallContainsComponent = (call, scopes) => {
+const hocCallContainsComponent = (call) => {
 	const firstArgument = call.arguments[0];
 	if (!firstArgument) return false;
-	if (isNodeOfType(firstArgument, "FunctionExpression") || isNodeOfType(firstArgument, "ArrowFunctionExpression") || isNodeOfType(firstArgument, "ClassExpression")) return expressionContainsJsxOrCreateElement(firstArgument, scopes);
-	if (isNodeOfType(firstArgument, "CallExpression") && isHocCallee$1(firstArgument)) return hocCallContainsComponent(firstArgument, scopes);
-	return expressionContainsJsxOrCreateElement(firstArgument, scopes);
+	if (isNodeOfType(firstArgument, "FunctionExpression") || isNodeOfType(firstArgument, "ArrowFunctionExpression") || isNodeOfType(firstArgument, "ClassExpression")) return expressionContainsJsxOrCreateElement(firstArgument);
+	if (isNodeOfType(firstArgument, "CallExpression") && isHocCallee$1(firstArgument)) return hocCallContainsComponent(firstArgument);
+	return expressionContainsJsxOrCreateElement(firstArgument);
 };
 const isFirstArgumentOfHocCall = (node) => {
 	const parent = node.parent;
@@ -44385,35 +43807,19 @@ const isReturnOfMapCallback = (node) => {
 	}
 	return false;
 };
+const isCloneElementCall = (node) => {
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = node.callee;
+	if (isNodeOfType(callee, "Identifier")) return callee.name === "cloneElement";
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "cloneElement";
+};
 const TS_VALUE_PASSTHROUGH_TYPES = new Set([
 	"TSAsExpression",
 	"TSNonNullExpression",
 	"TSSatisfiesExpression",
 	"TSTypeAssertion"
 ]);
-const ELEMENT_TYPE_PROP_NAMES = new Set([
-	"as",
-	"body",
-	"calendarcontainer",
-	"component",
-	"fallback",
-	"tooltip"
-]);
-const isElementTypeJsxAttribute = (node) => {
-	if (!isNodeOfType(node, "JSXAttribute")) return false;
-	if (!isNodeOfType(node.name, "JSXIdentifier")) return false;
-	const attributeName = node.name.name;
-	return ELEMENT_TYPE_PROP_NAMES.has(attributeName.toLowerCase()) || attributeName.endsWith("Component");
-};
-const isReactUseMemoCallback = (call, valueNode, scopes) => call.arguments[0] === valueNode && isReactApiCall(call, "useMemo", scopes, {
-	allowGlobalReactNamespace: true,
-	resolveNamedAliases: true
-});
-const isReactLazyCall = (call, scopes) => isReactApiCall(call, "lazy", scopes, {
-	allowGlobalReactNamespace: true,
-	resolveNamedAliases: true
-});
-const isRenderFlowingReadReference = (identifier, scopes, visitedSymbols = /* @__PURE__ */ new Set()) => {
+const isRenderFlowingReadReference = (identifier) => {
 	let valueNode = identifier;
 	let parent = valueNode.parent;
 	while (parent) {
@@ -44423,26 +43829,20 @@ const isRenderFlowingReadReference = (identifier, scopes, visitedSymbols = /* @_
 			continue;
 		}
 		switch (parent.type) {
-			case "JSXOpeningElement": return parent.name === valueNode;
-			case "JSXExpressionContainer": return Boolean(parent.parent && isElementTypeJsxAttribute(parent.parent));
-			case "ReturnStatement": return false;
-			case "ArrowFunctionExpression": return false;
+			case "JSXExpressionContainer":
+			case "ReturnStatement": return true;
+			case "ArrowFunctionExpression": return parent.body === valueNode;
 			case "CallExpression":
 				if (parent.callee === valueNode) return false;
-				if (isReactUseMemoCallback(parent, valueNode, scopes)) return false;
-				if (isReactCreateElementCall(parent, scopes)) return true;
+				if (isCreateElementCall(parent) || isCloneElementCall(parent)) return true;
 				valueNode = parent;
 				parent = parent.parent;
 				continue;
-			case "VariableDeclarator": {
-				if (parent.init !== valueNode || !isNodeOfType(parent.id, "Identifier")) return false;
-				const aliasSymbol = scopes.symbolFor(parent.id);
-				if (!aliasSymbol || aliasSymbol.kind !== "const" || visitedSymbols.has(aliasSymbol.id)) return false;
-				const nextVisitedSymbols = new Set(visitedSymbols);
-				nextVisitedSymbols.add(aliasSymbol.id);
-				return aliasSymbol.references.some((reference) => reference.flag === "read" && isRenderFlowingReadReference(reference.identifier, scopes, nextVisitedSymbols));
+			case "VariableDeclarator": return parent.init === valueNode && isNodeOfType(parent.id, "Identifier") && isReactComponentName(parent.id.name);
+			case "AssignmentExpression": {
+				const assignmentTarget = parent.left;
+				return parent.right === valueNode && isNodeOfType(assignmentTarget, "Identifier") && isReactComponentName(assignmentTarget.name);
 			}
-			case "AssignmentExpression": return false;
 			case "Property":
 				if (parent.value !== valueNode) return false;
 				valueNode = parent;
@@ -44480,7 +43880,6 @@ const noUnstableNestedComponents = defineRule({
 	severity: "warn",
 	recommendation: "Move nested components to module scope so React does not remount them and lose state on every render.",
 	category: "Performance",
-	tags: ["react-jsx-only"],
 	create: (context) => {
 		const settings = resolveSettings$8(context.settings);
 		const renderPropRegex = compileGlob(settings.propNamePattern);
@@ -44543,7 +43942,7 @@ const noUnstableNestedComponents = defineRule({
 			},
 			Identifier(node) {
 				if (!isReactComponentName(node.name)) return;
-				if (!isRenderFlowingReadReference(node, context.scopes)) return;
+				if (!isRenderFlowingReadReference(node)) return;
 				recordInstantiation(node, node.name);
 			},
 			FunctionDeclaration: checkFunctionLike,
@@ -44552,33 +43951,28 @@ const noUnstableNestedComponents = defineRule({
 			ClassDeclaration(node) {
 				if (!node.id) return;
 				if (!isReactComponentName(node.id.name)) return;
-				if (!isReactClassComponent(node, context.scopes)) return;
+				if (!isReactClassComponent(node)) return;
 				enqueueCandidate(node, null);
 			},
 			ClassExpression(node) {
 				const inferredName = node.id?.name ?? inferFunctionLikeName(node);
 				if (!inferredName || !isReactComponentName(inferredName)) return;
-				if (!isReactClassComponent(node, context.scopes)) return;
+				if (!isReactClassComponent(node)) return;
 				enqueueCandidate(node, null);
 			},
 			CallExpression(node) {
-				if (isReactCreateElementCall(node, context.scopes)) {
+				if (isCreateElementCall(node)) {
 					const firstArgument = node.arguments[0];
 					if (firstArgument && isNodeOfType(firstArgument, "Identifier")) recordInstantiation(firstArgument, firstArgument.name);
 					else if (firstArgument && isNodeOfType(firstArgument, "MemberExpression")) recordMemberChainInstantiation(firstArgument);
 				}
-				const isReactLazy = isReactLazyCall(node, context.scopes);
-				if (!isReactLazy && !isHocCallee$1(node)) return;
-				if (!isReactLazy && !hocCallContainsComponent(node, context.scopes)) return;
-				const inferredName = inferFunctionLikeName(node);
-				const propInfo = isComponentDeclaredInProp(node);
-				if (propInfo === null && (!inferredName || !isReactComponentName(inferredName))) return;
-				enqueueCandidate(node, propInfo === null ? inferredName : null);
+				if (!isHocCallee$1(node)) return;
+				if (!hocCallContainsComponent(node)) return;
+				enqueueCandidate(node, null);
 			},
 			"Program:exit"() {
 				for (const report of queuedReports) {
 					if (report.requiredInstantiationName !== null) {
-						if ((report.requiredInstantiationBinding ? context.scopes.symbolFor(report.requiredInstantiationBinding) : null)?.references.some((reference) => reference.flag === "write" || reference.flag === "read-write")) continue;
 						if (!(report.requiredInstantiationBinding !== null ? instantiatedBindingIdentifiers.has(report.requiredInstantiationBinding) : instantiatedComponentNames.has(report.requiredInstantiationName))) continue;
 					}
 					context.report({
@@ -45611,7 +45005,7 @@ const findChildrenDestructuringFunction = (identifier, scopes) => {
 	const symbol = scopes.symbolFor(identifier);
 	if (symbol) {
 		if (symbol.kind !== "parameter") return null;
-		const declaringFunction = findEnclosingFunction$1(symbol.bindingIdentifier);
+		const declaringFunction = findEnclosingFunction(symbol.bindingIdentifier);
 		if (declaringFunction && destructuresChildrenAsFirstParam(declaringFunction)) return declaringFunction;
 		return null;
 	}
@@ -45657,7 +45051,7 @@ const isChildrenMemberExpression = (node, scopes) => {
 		const symbol = scopes.symbolFor(propsObject);
 		if (symbol) {
 			if (symbol.kind !== "parameter") return false;
-			const declaringFunction = findEnclosingFunction$1(symbol.bindingIdentifier);
+			const declaringFunction = findEnclosingFunction(symbol.bindingIdentifier);
 			return declaringFunction ? isDeclaringFunctionComponentLike(declaringFunction) : false;
 		}
 		return hasComponentLikeAncestorFunction(node);
@@ -46309,7 +45703,7 @@ const doesFunctionReturnsObjectLiteral = (functionNode) => {
 //#endregion
 //#region src/plugin/utils/enclosing-component-or-hook-scope.ts
 const enclosingComponentOrHookScope = (startNode, ownScopeFor) => {
-	const functionNode = findEnclosingFunction$1(startNode);
+	const functionNode = findEnclosingFunction(startNode);
 	if (!functionNode) return null;
 	const displayName = componentOrHookDisplayNameForFunction(functionNode);
 	if (!displayName) return null;
@@ -47371,7 +46765,7 @@ const isTanstackQuerySource = (source) => TANSTACK_QUERY_PACKAGE_PATTERN.test(so
 //#region src/plugin/rules/tanstack-query/query-destructure-result.ts
 const isHookReturnForwardingSpread = (objectExpression) => {
 	const objectParent = objectExpression.parent;
-	const enclosingFunction = findEnclosingFunction$1(objectExpression);
+	const enclosingFunction = findEnclosingFunction(objectExpression);
 	if (!enclosingFunction) return false;
 	if (!(isNodeOfType(objectParent, "ReturnStatement") || isNodeOfType(enclosingFunction, "ArrowFunctionExpression") && enclosingFunction.body === objectExpression)) return false;
 	const enclosingName = componentOrHookDisplayNameForFunction(enclosingFunction);
@@ -47749,10 +47143,10 @@ const hasSuspensionBefore = (functionNode, boundary, context) => {
 	return hasSuspension;
 };
 const isFunctionAncestor = (ancestor, functionNode) => {
-	let enclosingFunction = findEnclosingFunction$1(functionNode);
+	let enclosingFunction = findEnclosingFunction(functionNode);
 	while (enclosingFunction) {
 		if (enclosingFunction === ancestor) return true;
-		enclosingFunction = findEnclosingFunction$1(enclosingFunction);
+		enclosingFunction = findEnclosingFunction(enclosingFunction);
 	}
 	return false;
 };
@@ -47774,7 +47168,7 @@ const functionInvokesTarget = (callerFunction, targetFunction, context, visitedF
 	return invokesTarget;
 };
 const isFunctionInvokedBefore = (invokedFunction, boundary, context) => {
-	const boundaryFunction = findEnclosingFunction$1(boundary);
+	const boundaryFunction = findEnclosingFunction(boundary);
 	const boundaryStart = getRangeStart(boundary);
 	if (!boundaryFunction || boundaryStart === null) return false;
 	let isInvokedBefore = false;
@@ -47811,11 +47205,11 @@ const isFunctionInvokedAfter = (invokedFunction, boundary, callerFunction, conte
 const isWriteExecutedBefore = (writeNode, boundary, context, deferredExecutionFunction) => {
 	const writeStart = getRangeStart(writeNode);
 	const boundaryStart = getRangeStart(boundary);
-	const writeFunction = findEnclosingFunction$1(writeNode);
+	const writeFunction = findEnclosingFunction(writeNode);
 	const writeExecutionBoundary = writeFunction ?? findProgramRoot(writeNode);
 	if (writeStart === null || boundaryStart === null || !writeExecutionBoundary || !isNodeReachableWithinFunction(writeNode, context) || !isUnconditionallyExecuted(writeNode, writeExecutionBoundary, context)) return false;
-	const boundaryFunction = findEnclosingFunction$1(boundary);
-	const renderFunction = deferredExecutionFunction ? findEnclosingFunction$1(deferredExecutionFunction) : null;
+	const boundaryFunction = findEnclosingFunction(boundary);
+	const renderFunction = deferredExecutionFunction ? findEnclosingFunction(deferredExecutionFunction) : null;
 	if (writeFunction === boundaryFunction) return writeStart < boundaryStart;
 	if (!writeFunction) return writeStart < boundaryStart;
 	if (boundaryFunction && isFunctionAncestor(writeFunction, boundaryFunction)) {
@@ -48087,8 +47481,8 @@ const queryStableQueryClient = defineRule({
 	create: (context) => ({ NewExpression(node) {
 		if (!isNodeOfType(node.callee, "Identifier") || node.callee.name !== "QueryClient") return;
 		if (isStableHookWrapperArgument(node)) return;
-		let enclosingFunction = findEnclosingFunction$1(node);
-		while (enclosingFunction && isImmediatelyInvokedFunction(enclosingFunction)) enclosingFunction = findEnclosingFunction$1(enclosingFunction);
+		let enclosingFunction = findEnclosingFunction(node);
+		while (enclosingFunction && isImmediatelyInvokedFunction(enclosingFunction)) enclosingFunction = findEnclosingFunction(enclosingFunction);
 		if (!enclosingFunction) return;
 		if (!isComponentFunction(enclosingFunction)) return;
 		context.report({
@@ -48183,7 +47577,7 @@ const reactCompilerNoManualMemoization = defineRule({
 			const comparatorArgument = node.arguments?.[1];
 			if (comparatorArgument && !isNullishComparatorArgument(comparatorArgument)) return;
 		} else {
-			const enclosingFunction = findEnclosingFunction$1(node);
+			const enclosingFunction = findEnclosingFunction(node);
 			if (!enclosingFunction || !isCompilerInferableFunction(enclosingFunction)) return;
 		}
 		const removalMessage = REMOVAL_MESSAGE_BY_REACT_API_NAME.get(apiName);
@@ -51288,7 +50682,7 @@ const isReactNativeDimensionsCallee = (node, callee) => {
 };
 const STYLE_FACTORY_CALLEE_PATTERN$1 = /(?:^|\.)(?:make|create)(?:Use)?Styles$/;
 const isInsideStyleFactoryCallback = (node) => {
-	const enclosingFunction = findEnclosingFunction$1(node);
+	const enclosingFunction = findEnclosingFunction(node);
 	if (!enclosingFunction) return false;
 	const callExpression = enclosingFunction.parent;
 	if (!callExpression || !isNodeOfType(callExpression, "CallExpression")) return false;
@@ -58144,14 +57538,12 @@ const declarationAwaitsRequestScopedCall = (declaration) => {
 	}
 	return false;
 };
-const declarationAwaitsGate = (declaration, context) => {
+const declarationAwaitsGate = (declaration) => {
 	if (!isNodeOfType(declaration, "VariableDeclaration")) return false;
 	for (const declarator of declaration.declarations ?? []) {
 		if (!isNodeOfType(declarator.init, "AwaitExpression")) continue;
 		const argument = declarator.init.argument;
 		if (!isNodeOfType(argument, "CallExpression")) continue;
-		if (hasPossibleStaticMemberCallWrite(argument, context.scopes)) return true;
-		if (getOrderIndependentLocalFunction(argument, context.scopes) !== null) continue;
 		const calleeName = getCalleeName$2(argument);
 		if (!calleeName) continue;
 		if (isAuthGuardName(calleeName)) return true;
@@ -58179,7 +57571,7 @@ const serverSequentialIndependentAwait = defineRule({
 				if (declarationReadsAnyName(nextStatement, declaredNames)) continue;
 				if (declarationAwaitsExistingPromise(nextStatement)) continue;
 				if (declarationAwaitsRequestScopedCall(currentStatement) || declarationAwaitsRequestScopedCall(nextStatement)) continue;
-				if (declarationAwaitsGate(currentStatement, context)) continue;
+				if (declarationAwaitsGate(currentStatement)) continue;
 				context.report({
 					node: nextStatement,
 					message: "This await doesn't use the previous result, so your users wait twice as long for nothing."
@@ -59165,7 +58557,7 @@ const tanstackStartNoNavigateInRender = defineRule({
 		const isReturnedFromCustomHook = (functionNode) => {
 			const parent = functionNode.parent;
 			if (isNodeOfType(parent, "ReturnStatement")) {
-				const outerFunction = findEnclosingFunction$1(parent);
+				const outerFunction = findEnclosingFunction(parent);
 				const hookName = outerFunction ? getFunctionBindingName$1(outerFunction) : null;
 				return Boolean(hookName && HOOK_NAME_PATTERN$3.test(hookName));
 			}
@@ -59182,13 +58574,13 @@ const tanstackStartNoNavigateInRender = defineRule({
 			return parent.callee === functionNode || (parent.arguments ?? []).some((callArgument) => callArgument === functionNode);
 		};
 		const isDeferredNavigateCall = (callNode) => {
-			let enclosingFunction = findEnclosingFunction$1(callNode);
+			let enclosingFunction = findEnclosingFunction(callNode);
 			while (enclosingFunction) {
 				if (isDeferredCallbackPosition(enclosingFunction)) return true;
 				if (isWiredAsEventHandler(enclosingFunction)) return true;
 				if (isReturnedFromCustomHook(enclosingFunction)) return true;
 				if (!isSynchronouslyInvokedAnonymousWrapper(enclosingFunction)) return false;
-				enclosingFunction = findEnclosingFunction$1(enclosingFunction);
+				enclosingFunction = findEnclosingFunction(enclosingFunction);
 			}
 			return false;
 		};