oxlint-plugin-react-doctor 0.7.6-dev.0a8d30b → 0.7.6-dev.17418

package/dist/index.js

@@ -1180,8 +1180,8 @@ const stripParenExpression = (node) => {
 	return current;
 };
 //#endregion
-//#region src/plugin/utils/get-root-identifier.ts
-const getRootIdentifier$1 = (node, options) => {
+//#region src/plugin/utils/get-root-identifier-name.ts
+const getRootIdentifierName = (node, options) => {
 	if (!node) return null;
 	const followCallChains = options?.followCallChains === true;
 	let cursor = node;
@@ -1192,18 +1192,16 @@ const getRootIdentifier$1 = (node, options) => {
 			continue;
 		}
 		if (followCallChains && isNodeOfType(cursor, "CallExpression")) {
-			if (!isNodeOfType(cursor.callee, "MemberExpression")) return null;
-			cursor = cursor.callee.object;
+			const callee = cursor.callee;
+			if (!isNodeOfType(callee, "MemberExpression")) return null;
+			cursor = callee.object;
 			continue;
 		}
 		break;
 	}
-	return isNodeOfType(cursor, "Identifier") ? cursor : null;
+	return isNodeOfType(cursor, "Identifier") ? cursor.name : null;
 };
 //#endregion
-//#region src/plugin/utils/get-root-identifier-name.ts
-const getRootIdentifierName = (node, options) => getRootIdentifier$1(node, options)?.name ?? null;
-//#endregion
 //#region src/plugin/rules/state-and-effects/advanced-event-handler-refs.ts
 const STABLE_HANDLER_HOOK_NAMES = new Set([
 	"useCallback",
@@ -1520,37 +1518,6 @@ const hasJsxPropIgnoreCase = (attributes, targetProp) => {
 	}
 };
 //#endregion
-//#region src/plugin/utils/is-uppercase-name.ts
-const isUppercaseName = (name) => UPPERCASE_PATTERN.test(name);
-//#endregion
-//#region src/plugin/utils/resolve-jsx-element-type.ts
-const resolveConstantStringBinding = (name) => {
-	const binding = findVariableInitializer(name, name.name);
-	if (!binding?.initializer) return null;
-	const declarator = binding.bindingIdentifier.parent;
-	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator")) return null;
-	if (declarator.id !== binding.bindingIdentifier) return null;
-	const declaration = declarator.parent;
-	if (!declaration || !isNodeOfType(declaration, "VariableDeclaration")) return null;
-	if (declaration.kind !== "const") return null;
-	const initializer = stripParenExpression(binding.initializer);
-	return isNodeOfType(initializer, "Literal") && typeof initializer.value === "string" ? initializer.value : null;
-};
-const flattenJsxName$2 = (name) => {
-	if (isNodeOfType(name, "JSXIdentifier")) return name.name;
-	if (isNodeOfType(name, "JSXMemberExpression")) return `${flattenJsxName$2(name.object)}.${name.property.name}`;
-	if (isNodeOfType(name, "JSXNamespacedName")) return `${name.namespace.name}:${name.name.name}`;
-	return "";
-};
-const resolveJsxElementType = (openingElement) => {
-	const name = openingElement.name;
-	if (isNodeOfType(name, "JSXIdentifier")) {
-		if (!isUppercaseName(name.name)) return name.name;
-		return resolveConstantStringBinding(name) ?? name.name;
-	}
-	return flattenJsxName$2(name);
-};
-//#endregion
 //#region src/plugin/utils/get-element-type.ts
 const EMPTY_JSX_A11Y_SETTINGS = Object.freeze({});
 const jsxA11ySettingsCache = /* @__PURE__ */ new WeakMap();
@@ -1563,8 +1530,14 @@ const readJsxA11ySettings = (settings) => {
 	jsxA11ySettingsCache.set(settings, a11ySettings);
 	return a11ySettings;
 };
+const flattenJsxName$2 = (name) => {
+	if (isNodeOfType(name, "JSXIdentifier")) return name.name;
+	if (isNodeOfType(name, "JSXMemberExpression")) return `${flattenJsxName$2(name.object)}.${name.property.name}`;
+	if (isNodeOfType(name, "JSXNamespacedName")) return `${name.namespace.name}:${name.name.name}`;
+	return "";
+};
 const computeElementType = (openingElement, a11ySettings) => {
-	const baseName = resolveJsxElementType(openingElement);
+	const baseName = flattenJsxName$2(openingElement.name);
 	if (a11ySettings.polymorphicPropName) {
 		const polymorphicAttribute = hasJsxPropIgnoreCase(openingElement.attributes, a11ySettings.polymorphicPropName);
 		if (polymorphicAttribute) {
@@ -2399,9 +2372,8 @@ const anchorIsValid = defineRule({
 		const isTestlikeFile = isTestlikeFilename(context.filename);
 		return { JSXOpeningElement(node) {
 			if (isTestlikeFile) return;
-			const tag = getElementType(node, context.settings);
-			if (!fileHasJsxA11ySettings && tag !== "a") return;
-			if (tag !== "a") return;
+			if (!fileHasJsxA11ySettings && (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a")) return;
+			if (getElementType(node, context.settings) !== "a") return;
 			let hrefAttribute;
 			for (const attributeName of settings.hrefAttributeNames) {
 				hrefAttribute = hasJsxPropIgnoreCase(node.attributes, attributeName);
@@ -5756,7 +5728,7 @@ const buttonHasType = defineRule({
 		return {
 			JSXOpeningElement(node) {
 				if (isTestlikeFile) return;
-				if (resolveJsxElementType(node) !== "button") return;
+				if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "button") return;
 				const typeAttr = hasJsxPropIgnoreCase(node.attributes, "type");
 				if (!typeAttr) {
 					if (hasJsxSpreadAttribute$1(node.attributes)) {
@@ -5946,7 +5918,7 @@ const checkedRequiresOnchangeOrReadonly = defineRule({
 		};
 		return {
 			JSXOpeningElement(node) {
-				if (resolveJsxElementType(node) !== "input") return;
+				if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "input") return;
 				reportFromPresence(collectFromJsxAttributes(node.attributes));
 			},
 			CallExpression(node) {
@@ -5964,7 +5936,7 @@ 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")) return null;
+	if (!isNodeOfType(node, "Property")) return null;
 	if (node.computed) {
 		if (options.allowComputedString && isNodeOfType(node.key, "Literal") && typeof node.key.value === "string") return node.key.value;
 		return null;
@@ -6023,7 +5995,7 @@ const isPureEventBlockerHandler = (attribute) => {
 //#endregion
 //#region src/plugin/utils/resolve-const-identifier-alias.ts
 const resolveConstIdentifierAlias = (identifier, scopes) => {
-	if (!isNodeOfType(identifier, "Identifier") && !isNodeOfType(identifier, "JSXIdentifier")) return null;
+	if (!isNodeOfType(identifier, "Identifier")) return null;
 	const visitedSymbolIds = /* @__PURE__ */ new Set();
 	let symbol = scopes.symbolFor(identifier);
 	while (symbol?.kind === "const") {
@@ -6298,131 +6270,6 @@ const isGlobalMethodCall = (node, objectName, methodName) => {
 	return isNodeOfType(receiver, "Identifier") && receiver.name === objectName && isNodeOfType(callee.property, "Identifier") && callee.property.name === methodName;
 };
 //#endregion
-//#region src/plugin/utils/collect-safely-validated-local-storage-keys.ts
-const isLocalStorageCall = (node, methodName) => {
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	const callee = stripParenExpression(node.callee);
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	const receiver = stripParenExpression(callee.object);
-	return isNodeOfType(receiver, "Identifier") && receiver.name === "localStorage" && isNodeOfType(callee.property, "Identifier") && callee.property.name === methodName;
-};
-const catchReturnsFallback = (tryStatement) => {
-	const handler = tryStatement.handler;
-	if (!handler) return false;
-	let hasReturn = false;
-	let hasThrow = false;
-	walkAst(handler.body, (child) => {
-		if (isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "ReturnStatement")) hasReturn = true;
-		if (isNodeOfType(child, "ThrowStatement")) hasThrow = true;
-	});
-	return hasReturn && !hasThrow;
-};
-const resolveValidatorFunction = (callee, scopes) => {
-	const unwrappedCallee = stripParenExpression(callee);
-	if (!isNodeOfType(unwrappedCallee, "Identifier")) return null;
-	const symbol = scopes.symbolFor(unwrappedCallee);
-	if (!symbol) return null;
-	const candidate = symbol.kind === "function" ? symbol.declarationNode : symbol.initializer;
-	return isFunctionLike$1(candidate) ? candidate : null;
-};
-const validatorChecksPayloadProperties = (validatorFunction, scopes) => {
-	if (!isFunctionLike$1(validatorFunction)) return false;
-	const firstParameter = validatorFunction.params?.[0];
-	if (!firstParameter || !isNodeOfType(firstParameter, "Identifier")) return false;
-	const parameterSymbol = scopes.symbolFor(firstParameter);
-	if (!parameterSymbol) return false;
-	const payloadSymbolIds = new Set([parameterSymbol.id]);
-	let hasPropertyTypeCheck = false;
-	walkAst(validatorFunction.body, (child) => {
-		if (isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier") && child.init) {
-			const initializer = stripParenExpression(child.init);
-			if (isNodeOfType(initializer, "Identifier")) {
-				const initializerSymbol = scopes.symbolFor(initializer);
-				if (initializerSymbol && payloadSymbolIds.has(initializerSymbol.id)) {
-					const aliasSymbol = scopes.symbolFor(child.id);
-					if (aliasSymbol) payloadSymbolIds.add(aliasSymbol.id);
-				}
-			}
-		}
-		if (!isNodeOfType(child, "UnaryExpression") || child.operator !== "typeof") return;
-		const checkedValue = stripParenExpression(child.argument);
-		if (!isNodeOfType(checkedValue, "MemberExpression")) return;
-		const receiver = stripParenExpression(checkedValue.object);
-		if (!isNodeOfType(receiver, "Identifier")) return;
-		const receiverSymbol = scopes.symbolFor(receiver);
-		if (receiverSymbol && payloadSymbolIds.has(receiverSymbol.id)) hasPropertyTypeCheck = true;
-	});
-	return hasPropertyTypeCheck;
-};
-const incrementCount = (counts, keyValue) => {
-	counts.set(keyValue, (counts.get(keyValue) ?? 0) + 1);
-};
-const isReturnedExpression = (expression) => {
-	const parent = expression.parent;
-	return Boolean(parent && isNodeOfType(parent, "ReturnStatement") && parent.argument === expression);
-};
-const collectSafelyValidatedLocalStorageKeys = ({ programNode, scopes, resolveKey }) => {
-	const readCountsByKey = /* @__PURE__ */ new Map();
-	const safeReadCountsByKey = /* @__PURE__ */ new Map();
-	const safeReadSymbolIds = /* @__PURE__ */ new Set();
-	walkAst(programNode, (child) => {
-		if (!isNodeOfType(child, "CallExpression") || !isLocalStorageCall(child, "getItem")) return;
-		const keyArgument = child.arguments?.[0];
-		if (!keyArgument) return;
-		const keyValue = resolveKey(keyArgument);
-		if (keyValue !== null) incrementCount(readCountsByKey, keyValue);
-	});
-	walkAst(programNode, (child) => {
-		if (!isNodeOfType(child, "TryStatement") || !catchReturnsFallback(child)) return;
-		const rawValueKeys = /* @__PURE__ */ new Map();
-		const parsedValueSources = /* @__PURE__ */ new Map();
-		walkAst(child.block, (tryChild) => {
-			if (isFunctionLike$1(tryChild)) return false;
-			if (isNodeOfType(tryChild, "VariableDeclarator") && isNodeOfType(tryChild.id, "Identifier") && tryChild.init) {
-				const initializer = stripParenExpression(tryChild.init);
-				if (isNodeOfType(initializer, "CallExpression") && isLocalStorageCall(initializer, "getItem")) {
-					const keyArgument = initializer.arguments?.[0];
-					const bindingSymbol = scopes.symbolFor(tryChild.id);
-					if (keyArgument && bindingSymbol) {
-						const keyValue = resolveKey(keyArgument);
-						if (keyValue !== null) rawValueKeys.set(bindingSymbol.id, keyValue);
-					}
-				}
-				if (isNodeOfType(initializer, "CallExpression") && isGlobalMethodCall(initializer, "JSON", "parse")) {
-					const rawValueArgument = initializer.arguments?.[0];
-					const parsedValueSymbol = scopes.symbolFor(tryChild.id);
-					if (rawValueArgument && isNodeOfType(rawValueArgument, "Identifier") && parsedValueSymbol) {
-						const rawValueSymbol = scopes.symbolFor(rawValueArgument);
-						if (rawValueSymbol && rawValueKeys.has(rawValueSymbol.id)) parsedValueSources.set(parsedValueSymbol.id, rawValueSymbol.id);
-					}
-				}
-			}
-			if (!isNodeOfType(tryChild, "ConditionalExpression") || !isReturnedExpression(tryChild)) return;
-			const test = stripParenExpression(tryChild.test);
-			if (!isNodeOfType(test, "CallExpression")) return;
-			const testedValue = test.arguments?.[0];
-			if (!testedValue || !isNodeOfType(testedValue, "Identifier")) return;
-			const parsedValueSymbol = scopes.symbolFor(testedValue);
-			if (!parsedValueSymbol) return;
-			const rawValueSymbolId = parsedValueSources.get(parsedValueSymbol.id);
-			if (rawValueSymbolId === void 0) return;
-			const returnedValue = stripParenExpression(tryChild.consequent);
-			if (!isNodeOfType(returnedValue, "Identifier") || scopes.symbolFor(returnedValue)?.id !== parsedValueSymbol.id) return;
-			const validatorFunction = resolveValidatorFunction(test.callee, scopes);
-			if (!validatorFunction || !validatorChecksPayloadProperties(validatorFunction, scopes)) return;
-			const keyValue = rawValueKeys.get(rawValueSymbolId);
-			if (keyValue === void 0 || safeReadSymbolIds.has(rawValueSymbolId)) return;
-			safeReadSymbolIds.add(rawValueSymbolId);
-			incrementCount(safeReadCountsByKey, keyValue);
-		});
-	});
-	const safeKeys = /* @__PURE__ */ new Set();
-	for (const [keyValue, readCount] of readCountsByKey) if (safeReadCountsByKey.get(keyValue) === readCount) safeKeys.add(keyValue);
-	return safeKeys;
-};
-//#endregion
 //#region src/plugin/rules/client/client-localstorage-no-version.ts
 const VERSIONED_KEY_PATTERN = /(?:[._:-]v\d+|@\d+|\bv\d+\b)/i;
 const CAMEL_CASE_VERSIONED_KEY_PATTERN = /[a-z]V\d+/;
@@ -6444,39 +6291,26 @@ const clientLocalstorageNoVersion = defineRule({
 	severity: "warn",
 	category: "Correctness",
 	recommendation: "Put a version in the storage key (e.g. \"myKey:v1\"). If you change the data shape later, old saved data can be ignored instead of crashing the app.",
-	create: (context) => {
-		let safelyValidatedStorageKeys = /* @__PURE__ */ new Set();
-		return {
-			Program(node) {
-				safelyValidatedStorageKeys = collectSafelyValidatedLocalStorageKeys({
-					programNode: node,
-					scopes: context.scopes,
-					resolveKey: (keyNode) => resolveStringKey(keyNode, context)
-				});
-			},
-			CallExpression(node) {
-				if (!isNodeOfType(node.callee, "MemberExpression")) return;
-				const receiver = stripParenExpression(node.callee.object);
-				if (!isNodeOfType(receiver, "Identifier")) return;
-				if (receiver.name !== "localStorage") return;
-				if (!isNodeOfType(node.callee.property, "Identifier")) return;
-				if (node.callee.property.name !== "setItem") return;
-				const keyArg = node.arguments?.[0];
-				if (!keyArg) return;
-				const keyValue = resolveStringKey(keyArg, context);
-				if (keyValue === null) return;
-				if (isVersionedKey(keyValue)) return;
-				if (safelyValidatedStorageKeys.has(keyValue)) return;
-				const valueArg = node.arguments?.[1];
-				if (!valueArg) return;
-				if (!isJsonStringifyCall(valueArg)) return;
-				context.report({
-					node: keyArg,
-					message: `${receiver.name}.setItem("${keyValue}", JSON.stringify(...)) has no version, so changing the data shape later crashes your users' saved sessions. Add one to the key (e.g. "${keyValue}:v1").`
-				});
-			}
-		};
-	}
+	create: (context) => ({ CallExpression(node) {
+		if (!isNodeOfType(node.callee, "MemberExpression")) return;
+		const receiver = stripParenExpression(node.callee.object);
+		if (!isNodeOfType(receiver, "Identifier")) return;
+		if (receiver.name !== "localStorage") return;
+		if (!isNodeOfType(node.callee.property, "Identifier")) return;
+		if (node.callee.property.name !== "setItem") return;
+		const keyArg = node.arguments?.[0];
+		if (!keyArg) return;
+		const keyValue = resolveStringKey(keyArg, context);
+		if (keyValue === null) return;
+		if (isVersionedKey(keyValue)) return;
+		const valueArg = node.arguments?.[1];
+		if (!valueArg) return;
+		if (!isJsonStringifyCall(valueArg)) return;
+		context.report({
+			node: keyArg,
+			message: `${receiver.name}.setItem("${keyValue}", JSON.stringify(...)) has no version, so changing the data shape later crashes your users' saved sessions. Add one to the key (e.g. "${keyValue}:v1").`
+		});
+	} })
 });
 //#endregion
 //#region src/plugin/rules/client/client-passive-event-listeners.ts
@@ -7312,17 +7146,12 @@ const findVisibleIdentifierDeclaration = (identifier, sinkIndex, fileContent) =>
 	}
 	return nearestDeclaration;
 };
-const isDeclarationStable = (identifier, declaration, usageIndex, fileContent) => {
-	if (declaration.isImmutable) return true;
-	const textAfterInitializer = fileContent.slice(declaration.initializerStartIndex + declaration.initializer.length, usageIndex);
-	return !new RegExp(`(?:^|[^\\w$.])${escapeRegExp(identifier)}\\s*=(?!=)`).test(textAfterInitializer);
-};
 const isTrustedHighlighterValue = (valueExpression, fileContent, sinkIndex) => {
 	if (!/highlight/i.test(valueExpression)) return false;
 	const identifier = valueExpression.match(/^([\w$]+)/)?.[1];
 	if (identifier === void 0) return false;
 	const declaration = findVisibleIdentifierDeclaration(identifier, sinkIndex, fileContent);
-	if (declaration !== null) return isDeclarationStable(identifier, declaration, sinkIndex, fileContent) && SERIALIZER_CALL_PROVENANCE_PATTERN.test(declaration.initializer);
+	if (declaration !== null) return SERIALIZER_CALL_PROVENANCE_PATTERN.test(declaration.initializer);
 	return /highlighted/i.test(valueExpression) || HIGHLIGHTER_LIBRARY_PATTERN.test(fileContent);
 };
 const isExplicitlyTrustedHtmlValue = (valueExpression, fileContent, sinkIndex, visitedIdentifiers = /* @__PURE__ */ new Set()) => {
@@ -7334,7 +7163,7 @@ const isExplicitlyTrustedHtmlValue = (valueExpression, fileContent, sinkIndex, v
 	const identifier = trimmedExpression.match(/^([\w$]+)(?:(?:\??\.[\w$]+)|(?:\[\s*(?:"[^"\n]*"|'[^'\n]*'|\d+)\s*\]))*$/)?.[1];
 	if (identifier && !visitedIdentifiers.has(identifier)) {
 		const declaration = findVisibleIdentifierDeclaration(identifier, sinkIndex, fileContent);
-		if (declaration && isDeclarationStable(identifier, declaration, sinkIndex, fileContent)) {
+		if (declaration) {
 			const nextVisitedIdentifiers = new Set(visitedIdentifiers);
 			nextVisitedIdentifiers.add(identifier);
 			return isExplicitlyTrustedHtmlValue(declaration.initializer, fileContent, declaration.initializerStartIndex, nextVisitedIdentifiers);
@@ -7401,16 +7230,6 @@ const splitTopLevelArguments = (argumentText) => {
 	argumentsList.push(argumentText.slice(startIndex).trim());
 	return argumentsList;
 };
-const isBackedByFunctionParameter = (expression, expressionIndex, fileContent, visitedIdentifiers = /* @__PURE__ */ new Set()) => {
-	const identifier = expression.trim().match(/^([\w$]+)$/)?.[1];
-	if (identifier === void 0 || visitedIdentifiers.has(identifier)) return false;
-	if (findContainingFunctionParameterSource(identifier, expressionIndex, fileContent) !== null) return true;
-	const declaration = findVisibleIdentifierDeclaration(identifier, expressionIndex, fileContent);
-	if (!declaration || !isDeclarationStable(identifier, declaration, expressionIndex, fileContent)) return false;
-	const nextVisitedIdentifiers = new Set(visitedIdentifiers);
-	nextVisitedIdentifiers.add(identifier);
-	return isBackedByFunctionParameter(declaration.initializer, declaration.initializerStartIndex, fileContent, nextVisitedIdentifiers);
-};
 const isHtmlTainted = (expression, fileContent, sinkIndex, visitedIdentifiers, visitedCallSites) => {
 	const trimmedExpression = expression.trim();
 	if (isExplicitlyTrustedHtmlValue(trimmedExpression, fileContent, sinkIndex)) return false;
@@ -7421,11 +7240,8 @@ const isHtmlTainted = (expression, fileContent, sinkIndex, visitedIdentifiers, v
 	const declaration = findVisibleIdentifierDeclaration(identifier, sinkIndex, fileContent);
 	const parameterSource = findContainingFunctionParameterSource(identifier, sinkIndex, fileContent);
 	if (declaration !== null && (parameterSource === null || declaration.declarationIndex > parameterSource.declarationNameIndex)) {
-		if (isDeclarationStable(identifier, declaration, sinkIndex, fileContent) && isExplicitlyTrustedHtmlValue(declaration.initializer, fileContent, declaration.initializerStartIndex)) return false;
-		if (!isDeclarationStable(identifier, declaration, sinkIndex, fileContent)) return true;
-		if (isHtmlTainted(declaration.initializer, fileContent, declaration.initializerStartIndex, visitedIdentifiers, visitedCallSites)) return true;
-		if (isBackedByFunctionParameter(declaration.initializer, declaration.initializerStartIndex, fileContent)) return false;
-		return HTML_TAINT_PATTERN.test(trimmedExpression);
+		if (isExplicitlyTrustedHtmlValue(declaration.initializer, fileContent, declaration.initializerStartIndex)) return false;
+		return isHtmlTainted(declaration.initializer, fileContent, declaration.initializerStartIndex, visitedIdentifiers, visitedCallSites) || HTML_TAINT_PATTERN.test(trimmedExpression);
 	}
 	if (parameterSource !== null && parameterSource.functionName.length > 0) {
 		const callPattern = new RegExp(`\\b${escapeRegExp(parameterSource.functionName)}\\s*\\(`, "g");
@@ -7507,13 +7323,12 @@ const dangerousHtmlSink = defineRule({
 			if (isTrustedHighlighterValue(valueExpression, file.content, sinkIndex)) continue;
 			if (valueIdentifier !== void 0) {
 				const escapedIdentifier = escapeRegExp(valueIdentifier);
-				const visibleDeclaration = findVisibleIdentifierDeclaration(valueIdentifier, sinkIndex, file.content);
-				const visibleInitializer = visibleDeclaration?.initializer;
+				const visibleInitializer = findVisibleIdentifierDeclaration(valueIdentifier, sinkIndex, file.content)?.initializer;
 				if (!(visibleInitializer !== void 0 && (splitTopLevelByPlus(visibleInitializer).length > 1 || (visibleInitializer.match(/\$\{/g)?.length ?? 0) > 1))) {
 					const fromSerializer = new RegExp(`\\b${escapedIdentifier}\\b\\s*${SERIALIZER_ASSIGNMENT_PATTERN.source}`, "i");
-					if (visibleInitializer === void 0 ? fromSerializer.test(file.content) : visibleDeclaration !== null && isDeclarationStable(valueIdentifier, visibleDeclaration, sinkIndex, file.content) && SERIALIZER_CALL_PROVENANCE_PATTERN.test(visibleInitializer)) continue;
+					if (visibleInitializer === void 0 ? fromSerializer.test(file.content) : SERIALIZER_CALL_PROVENANCE_PATTERN.test(visibleInitializer)) continue;
 					const fromSanitizer = new RegExp(`\\b${escapedIdentifier}\\b\\s*${SANITIZED_ASSIGNMENT_PATTERN.source}`, "i");
-					if (visibleInitializer === void 0 ? fromSanitizer.test(file.content) : visibleDeclaration !== null && isDeclarationStable(valueIdentifier, visibleDeclaration, sinkIndex, file.content) && SANITIZED_ASSIGNMENT_PATTERN.test(`=${visibleInitializer}`)) continue;
+					if (visibleInitializer === void 0 ? fromSanitizer.test(file.content) : SANITIZED_ASSIGNMENT_PATTERN.test(`=${visibleInitializer}`)) continue;
 				}
 				if (new RegExp(`\\b${escapedIdentifier}\\b\\s*${DOM_CONTENT_ASSIGNMENT_PATTERN.source}`).test(file.content)) continue;
 				if (new RegExp(`highlight[\\w$]*\\s*\\.map\\(\\s*(?:async\\s+)?\\(?\\s*${escapedIdentifier}\\b`, "i").test(file.content) && HIGHLIGHTER_LIBRARY_PATTERN.test(file.content)) continue;
@@ -7599,7 +7414,7 @@ const findJsxAttribute = (attributes, attributeName) => attributes?.find((attrib
 const getOpeningElementTagName = (openingElement) => {
 	if (!openingElement) return null;
 	if (!isNodeOfType(openingElement, "JSXOpeningElement")) return null;
-	if (isNodeOfType(openingElement.name, "JSXIdentifier")) return resolveJsxElementType(openingElement);
+	if (isNodeOfType(openingElement.name, "JSXIdentifier")) return openingElement.name.name;
 	if (isNodeOfType(openingElement.name, "JSXMemberExpression")) {
 		let cursor = openingElement.name;
 		while (isNodeOfType(cursor, "JSXMemberExpression")) cursor = cursor.property;
@@ -7851,7 +7666,7 @@ const dialogHasAccessibleName = defineRule({
 		if (isTestlikeFilename(context.filename)) return {};
 		return { JSXOpeningElement(node) {
 			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-			const tagName = resolveJsxElementType(node);
+			const tagName = node.name.name;
 			if (tagName[0] !== tagName[0]?.toLowerCase()) return;
 			const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
 			const roleValue = roleAttribute ? getJsxPropStringValue(roleAttribute) : null;
@@ -12083,7 +11898,7 @@ const forbidDomProps = defineRule({
 		return { JSXOpeningElement(node) {
 			if (forbidMap.size === 0) return;
 			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-			const elementName = resolveJsxElementType(node);
+			const elementName = node.name.name;
 			if (isReactComponentName(elementName)) return;
 			for (const attribute of node.attributes) {
 				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
@@ -12161,7 +11976,7 @@ const forbidElements = defineRule({
 		return {
 			JSXOpeningElement(node) {
 				if (forbidMap.size === 0) return;
-				const fullName = resolveJsxElementType(node);
+				const fullName = flattenJsxName$1(node.name);
 				if (!fullName || !forbidMap.has(fullName)) return;
 				context.report({
 					node: node.name,
@@ -12523,7 +12338,8 @@ const buildMessage$22 = (childTagName) => `Your users get reshuffled HTML becaus
 const isParagraphElement = (candidate) => {
 	if (!isNodeOfType(candidate, "JSXElement")) return false;
 	const opening = candidate.openingElement;
-	return resolveJsxElementType(opening) === "p";
+	if (!isNodeOfType(opening.name, "JSXIdentifier")) return false;
+	return opening.name.name === "p";
 };
 const findEnclosingParagraph = (openingElement) => {
 	const owningElement = openingElement.parent;
@@ -12544,7 +12360,8 @@ const htmlNoInvalidParagraphChild = defineRule({
 	severity: "warn",
 	recommendation: "Swap the `<p>` for a `<div>`, or move the child outside the paragraph.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		const childTagName = resolveJsxElementType(node);
+		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+		const childTagName = node.name.name;
 		if (!BLOCK_LEVEL_ELEMENTS.has(childTagName)) return;
 		if (!findEnclosingParagraph(node)) return;
 		context.report({
@@ -12575,7 +12392,7 @@ const getHostTagName = (jsxElement) => {
 	if (!isNodeOfType(jsxElement, "JSXElement")) return null;
 	const opening = jsxElement.openingElement;
 	if (!isNodeOfType(opening.name, "JSXIdentifier")) return null;
-	const tagName = resolveJsxElementType(opening);
+	const tagName = opening.name.name;
 	if (tagName.length === 0 || tagName[0] !== tagName[0].toLowerCase()) return null;
 	return tagName;
 };
@@ -12605,7 +12422,7 @@ const findClosestHostAncestor = (jsxElement) => {
 		if (isNodeOfType(ancestor, "JSXElement")) {
 			const opening = ancestor.openingElement;
 			if (isNodeOfType(opening.name, "JSXIdentifier")) {
-				const ancestorTag = resolveJsxElementType(opening);
+				const ancestorTag = opening.name.name;
 				if (ancestorTag.length === 0) {
 					previous = ancestor;
 					ancestor = ancestor.parent ?? null;
@@ -12687,7 +12504,8 @@ const buildMessage$20 = (tagName) => `Your users get broken clicks, focus & scre
 const isJsxElementWithTagName = (candidate, tagName) => {
 	if (!isNodeOfType(candidate, "JSXElement")) return false;
 	const opening = candidate.openingElement;
-	return resolveJsxElementType(opening) === tagName;
+	if (!isNodeOfType(opening.name, "JSXIdentifier")) return false;
+	return opening.name.name === tagName;
 };
 const findEnclosingSameTag = (openingElement, tagName) => {
 	const owningElement = openingElement.parent;
@@ -12708,7 +12526,8 @@ const htmlNoNestedInteractive = defineRule({
 	severity: "warn",
 	recommendation: "Move the inner `<a>` or `<button>` so it's a sibling, or change the outer one to a plain `<div>` or `<span>`.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		const tagName = resolveJsxElementType(node);
+		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+		const tagName = node.name.name;
 		if (tagName !== "a" && tagName !== "button") return;
 		if (!findEnclosingSameTag(node, tagName)) return;
 		context.report({
@@ -12823,7 +12642,7 @@ const iframeMissingSandbox = defineRule({
 	matchByOccurrence: true,
 	create: skipNonProductionFiles((context) => ({
 		JSXOpeningElement(node) {
-			if (resolveJsxElementType(node) !== "iframe") return;
+			if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "iframe") return;
 			const sandboxAttr = hasJsxPropIgnoreCase(node.attributes, "sandbox");
 			if (!sandboxAttr) {
 				const hasExplicitSrc = Boolean(hasJsxPropIgnoreCase(node.attributes, "src"));
@@ -13815,28 +13634,6 @@ const jsAsyncReduceWithoutAwaitedAcc = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/unwrap-discarded-expression.ts
-const unwrapDiscardedExpression = (node) => {
-	let expression = isNodeOfType(node, "ExpressionStatement") ? node.expression : node;
-	for (;;) {
-		expression = stripParenExpression(expression);
-		if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") {
-			expression = expression.argument;
-			continue;
-		}
-		if (isNodeOfType(expression, "SequenceExpression")) {
-			const expressions = expression.expressions ?? [];
-			const finalExpression = expressions.at(-1);
-			const prefixExpressions = expressions.slice(0, -1);
-			if (finalExpression && prefixExpressions.length > 0 && prefixExpressions.every((prefixExpression) => isNodeOfType(stripParenExpression(prefixExpression), "Literal"))) {
-				expression = finalExpression;
-				continue;
-			}
-		}
-		return expression;
-	}
-};
-//#endregion
 //#region src/plugin/rules/js-performance/js-batch-dom-css.ts
 const ITERATOR_METHOD_NAMES$2 = new Set([
 	"forEach",
@@ -14021,19 +13818,9 @@ const hasAttachmentBefore = (scopeOwner, elementName, beforeStart) => {
 	});
 	return foundAttachment;
 };
-const getStyleAssignment = (node) => {
-	if (!isNodeOfType(node, "ExpressionStatement")) return null;
-	const expression = unwrapDiscardedExpression(node);
-	if (!isNodeOfType(expression, "AssignmentExpression")) return null;
-	if (!isNodeOfType(expression.left, "MemberExpression")) return null;
-	if (!isNodeOfType(expression.left.object, "MemberExpression")) return null;
-	if (!isNodeOfType(expression.left.object.property, "Identifier")) return null;
-	return expression.left.object.property.name === "style" ? expression : null;
-};
 const isProvablyDetachedAtWrite = (styleWriteStatement) => {
-	const assignment = getStyleAssignment(styleWriteStatement);
-	if (!assignment || !isNodeOfType(assignment.left, "MemberExpression") || !isNodeOfType(assignment.left.object, "MemberExpression")) return false;
-	const elementExpression = assignment.left.object.object;
+	if (!isNodeOfType(styleWriteStatement, "ExpressionStatement") || !isNodeOfType(styleWriteStatement.expression, "AssignmentExpression") || !isNodeOfType(styleWriteStatement.expression.left, "MemberExpression") || !isNodeOfType(styleWriteStatement.expression.left.object, "MemberExpression")) return false;
+	const elementExpression = styleWriteStatement.expression.left.object.object;
 	const creationRoot = resolveDetachedCreationRoot(elementExpression, 0);
 	if (!creationRoot) return false;
 	return !hasAttachmentBefore(creationRoot.scopeOwner, creationRoot.rootName, getNodeStart$1(styleWriteStatement));
@@ -14045,17 +13832,15 @@ const jsBatchDomCss = defineRule({
 	severity: "warn",
 	recommendation: "Do all your reads first, then all your writes. Mixing them inside a loop makes the browser recalculate the layout again and again, which is slow",
 	create: (context) => {
-		const writesLayoutAffectingProperty = (node) => {
-			const assignment = getStyleAssignment(node);
-			return assignment !== null && isNodeOfType(assignment.left, "MemberExpression") && isNodeOfType(assignment.left.property, "Identifier") && !LAYOUT_NEUTRAL_STYLE_PROPERTY_NAMES.has(assignment.left.property.name);
-		};
+		const isStyleAssignment = (node) => isNodeOfType(node, "ExpressionStatement") && isNodeOfType(node.expression, "AssignmentExpression") && isNodeOfType(node.expression.left, "MemberExpression") && isNodeOfType(node.expression.left.object, "MemberExpression") && isNodeOfType(node.expression.left.object.property, "Identifier") && node.expression.left.object.property.name === "style";
+		const writesLayoutAffectingProperty = (node) => isNodeOfType(node, "ExpressionStatement") && isNodeOfType(node.expression, "AssignmentExpression") && isNodeOfType(node.expression.left, "MemberExpression") && isNodeOfType(node.expression.left.property, "Identifier") && !LAYOUT_NEUTRAL_STYLE_PROPERTY_NAMES.has(node.expression.left.property.name);
 		return { BlockStatement(node) {
 			const perIterationBody = findEnclosingPerIterationBody(node);
 			if (!perIterationBody) return;
 			const statements = node.body ?? [];
 			let layoutReads = null;
 			for (let statementIndex = 1; statementIndex < statements.length; statementIndex++) {
-				if (getStyleAssignment(statements[statementIndex]) === null || getStyleAssignment(statements[statementIndex - 1]) === null) continue;
+				if (!isStyleAssignment(statements[statementIndex]) || !isStyleAssignment(statements[statementIndex - 1])) continue;
 				if (!writesLayoutAffectingProperty(statements[statementIndex]) && !writesLayoutAffectingProperty(statements[statementIndex - 1])) continue;
 				layoutReads ??= scanPerIterationLayoutReads(perIterationBody);
 				if (!layoutReads.hasUsedLayoutRead || layoutReads.hasDeliberateForcedReflow) return;
@@ -14751,18 +14536,6 @@ const jsHoistRegexp = defineRule({
 	}, { treatIteratorCallbacksAsLoops: true })
 });
 //#endregion
-//#region src/plugin/utils/resolve-first-argument-binding.ts
-const resolveFirstArgumentBinding = (firstParameter) => {
-	if (!firstParameter) return null;
-	if (!isNodeOfType(firstParameter, "RestElement")) return firstParameter;
-	if (!isNodeOfType(firstParameter.argument, "ArrayPattern")) return null;
-	const elements = firstParameter.argument.elements ?? [];
-	if (elements.length !== 1) return null;
-	const firstBinding = elements[0];
-	if (!firstBinding || isNodeOfType(firstBinding, "RestElement")) return null;
-	return firstBinding;
-};
-//#endregion
 //#region src/plugin/rules/js-performance/js-index-maps.ts
 const referencesParameter = (expression, parameterName) => {
 	if (!expression) return false;
@@ -14773,7 +14546,7 @@ const referencesParameter = (expression, parameterName) => {
 const isSingleFieldEqualityPredicate = (node) => {
 	const callback = node.arguments?.[0];
 	if (!isInlineFunctionExpression(callback)) return false;
-	const firstParameter = resolveFirstArgumentBinding(callback.params?.[0]);
+	const firstParameter = callback.params?.[0];
 	if (!firstParameter || !isNodeOfType(firstParameter, "Identifier")) return false;
 	let predicate = null;
 	const body = callback.body;
@@ -15465,21 +15238,9 @@ const isSmallFixedListMember = (receiver) => {
 };
 const getResolvedInitializer = (receiver) => {
 	if (!isNodeOfType(receiver, "Identifier")) return null;
-	const binding = findVariableInitializer(receiver, receiver.name);
-	const initializer = binding?.initializer ?? null;
-	if (!binding || !initializer) return null;
-	const isDefault = isNodeOfType(binding.bindingIdentifier.parent, "AssignmentPattern");
-	if (isNodeOfType(initializer, "Identifier")) {
-		const aliased = findVariableInitializer(initializer, initializer.name);
-		if (aliased?.initializer) return {
-			initializer: aliased.initializer,
-			isDefault: isDefault || isNodeOfType(aliased.bindingIdentifier.parent, "AssignmentPattern")
-		};
-	}
-	return {
-		initializer,
-		isDefault
-	};
+	const initializer = findVariableInitializer(receiver, receiver.name)?.initializer ?? null;
+	if (initializer && isNodeOfType(initializer, "Identifier")) return findVariableInitializer(initializer, initializer.name)?.initializer ?? initializer;
+	return initializer;
 };
 const isSplitCall = (expression) => {
 	if (!expression) return false;
@@ -15645,8 +15406,8 @@ const isBoundedConstantCollection = (collection) => {
 	if (isScreamingSnakeCaseConstantReceiver(stripped)) return true;
 	if (isSmallInlineLiteralArray(stripped)) return true;
 	if (isNodeOfType(stripped, "Identifier")) {
-		const resolved = getResolvedInitializer(stripped);
-		if (resolved && !resolved.isDefault && isSmallInlineLiteralArray(resolved.initializer)) return true;
+		const initializer = getResolvedInitializer(stripped);
+		if (initializer && isSmallInlineLiteralArray(initializer)) return true;
 	}
 	return false;
 };
@@ -15698,8 +15459,8 @@ const jsSetMapLookups = defineRule({
 			if (isIndexedArrayElementWithStringArgument(receiver, node.arguments?.[0])) return;
 			const resolvedInitializer = getResolvedInitializer(receiver);
 			if (resolvedInitializer) {
-				if (isLikelyStringReceiver(resolvedInitializer.initializer)) return;
-				if (!resolvedInitializer.isDefault && isSmallInlineLiteralArray(resolvedInitializer.initializer)) return;
+				if (isLikelyStringReceiver(resolvedInitializer)) return;
+				if (isSmallInlineLiteralArray(resolvedInitializer)) return;
 			}
 			if (isStringElementOfSplitIteration(receiver)) return;
 			if (isReceiverDeclaredInNearestLoop(receiver, node)) return;
@@ -16112,21 +15873,14 @@ const jsxFilenameExtension = defineRule({
 });
 //#endregion
 //#region src/plugin/utils/is-jsx-fragment-element.ts
-const isJsxFragmentElement = (node, scopes) => {
+const isJsxFragmentElement = (node) => {
 	if (!isNodeOfType(node, "JSXOpeningElement")) return false;
 	const elementName = node.name;
-	if (isNodeOfType(elementName, "JSXIdentifier")) {
-		if (!scopes) return elementName.name === "Fragment";
-		const symbol = resolveConstIdentifierAlias(elementName, scopes);
-		if (!symbol) return elementName.name === "Fragment" && scopes.isGlobalReference(elementName);
-		return isImportedFromReact(symbol) && getImportedName(symbol.declarationNode) === "Fragment";
-	}
+	if (isNodeOfType(elementName, "JSXIdentifier")) return elementName.name === "Fragment";
 	if (isNodeOfType(elementName, "JSXMemberExpression")) {
 		if (!isNodeOfType(elementName.object, "JSXIdentifier")) return false;
-		if (elementName.property.name !== "Fragment") return false;
-		if (!scopes) return elementName.object.name === "React";
-		if (isReactNamespaceImport(elementName.object, scopes)) return true;
-		return elementName.object.name === "React" && scopes.isGlobalReference(elementName.object);
+		if (elementName.object.name !== "React") return false;
+		return elementName.property.name === "Fragment";
 	}
 	return false;
 };
@@ -16152,7 +15906,7 @@ const jsxFragments = defineRule({
 				if (mode !== "syntax") return;
 				if (!node.closingElement) return;
 				const openingElement = node.openingElement;
-				if (!isJsxFragmentElement(openingElement, context.scopes)) return;
+				if (!isJsxFragmentElement(openingElement)) return;
 				if (openingElement.attributes.length > 0) return;
 				context.report({
 					node: openingElement,
@@ -18833,6 +18587,10 @@ const resolveSettings$29 = (settings) => {
 	if (typeof reactDoctor !== "object" || reactDoctor === null) return {};
 	return reactDoctor.jsxNoScriptUrl ?? {};
 };
+const getElementName = (node) => {
+	if (isNodeOfType(node.name, "JSXIdentifier")) return node.name.name;
+	return null;
+};
 const isLinkPropForElement = (elementName, attributeName, options) => {
 	if (elementName === "a" && attributeName === "href") return true;
 	const explicit = options.components?.[elementName];
@@ -18852,8 +18610,7 @@ const jsxNoScriptUrl = defineRule({
 	create: (context) => {
 		const options = resolveSettings$29(context.settings);
 		return { JSXOpeningElement(node) {
-			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-			const elementName = resolveJsxElementType(node);
+			const elementName = getElementName(node);
 			if (!elementName) return;
 			for (const attribute of node.attributes) {
 				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
@@ -19040,6 +18797,11 @@ const checkTarget = (attributeValue) => {
 		alternate: false
 	};
 };
+const getOpeningElementName = (node) => {
+	const name = node.name;
+	if (isNodeOfType(name, "JSXIdentifier")) return name.name;
+	return null;
+};
 const jsxNoTargetBlank = defineRule({
 	id: "jsx-no-target-blank",
 	title: "Unsafe target=_blank link",
@@ -19059,8 +18821,7 @@ const jsxNoTargetBlank = defineRule({
 			return settings.formComponents.has(tagName);
 		};
 		return { JSXOpeningElement(node) {
-			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-			const tagName = resolveJsxElementType(node);
+			const tagName = getOpeningElementName(node);
 			if (!tagName) return;
 			if (!isLink(tagName) && !isForm(tagName)) return;
 			const linkAttributeNames = settings.linkComponents.get(tagName) ?? ["href"];
@@ -19293,7 +19054,7 @@ const jsxNoUselessFragment = defineRule({
 		return {
 			JSXElement(node) {
 				const openingElement = node.openingElement;
-				if (!isJsxFragmentElement(openingElement, context.scopes)) return;
+				if (!isJsxFragmentElement(openingElement)) return;
 				if (hasJsxKeyAttribute(openingElement)) return;
 				if (checkChildren(node, openingElement, node.children)) return;
 				if (isChildOfHtmlElement(node)) context.report({
@@ -20535,24 +20296,11 @@ 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 unwrapObjectIntegrityExpression = (node, scopes, methodNames = OBJECT_INTEGRITY_METHOD_NAMES) => {
-	let expression = stripParenExpression(node);
-	while (isNodeOfType(expression, "CallExpression")) {
-		const callee = stripParenExpression(expression.callee);
-		if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.object, "Identifier") || callee.object.name !== "Object" || !scopes.isGlobalReference(callee.object) || !isNodeOfType(callee.property, "Identifier") || !methodNames.has(callee.property.name)) break;
-		const wrappedExpression = expression.arguments[0];
-		if (!wrappedExpression || isNodeOfType(wrappedExpression, "SpreadElement")) break;
-		expression = stripParenExpression(wrappedExpression);
-	}
-	return expression;
-};
+//#region src/plugin/utils/is-uppercase-name.ts
+const isUppercaseName = (name) => UPPERCASE_PATTERN.test(name);
+//#endregion
+//#region src/plugin/utils/is-component-assignment.ts
+const isComponentAssignment = (node) => isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && isUppercaseName(node.id.name) && Boolean(node.init) && (isNodeOfType(node.init, "ArrowFunctionExpression") || isNodeOfType(node.init, "FunctionExpression"));
 //#endregion
 //#region src/plugin/rules/nextjs/nextjs-async-client-component.ts
 const nextjsAsyncClientComponent = defineRule({
@@ -20578,10 +20326,10 @@ const nextjsAsyncClientComponent = defineRule({
 			},
 			VariableDeclarator(node) {
 				if (!fileHasUseClient) return;
+				if (!isComponentAssignment(node)) return;
+				if (!isInlineFunctionExpression(node.init)) return;
+				if (!node.init.async) return;
 				if (!isNodeOfType(node.id, "Identifier")) return;
-				if (!isUppercaseName(node.id.name) || !node.init) return;
-				const componentFunction = unwrapObjectIntegrityExpression(node.init, context.scopes, OBJECT_FREEZE_OR_SEAL_METHOD_NAMES);
-				if (!isInlineFunctionExpression(componentFunction) || !componentFunction.async) return;
 				context.report({
 					node,
 					message: `Async client component "${node.id.name}" fails to render because client components can't be async.`
@@ -20883,7 +20631,7 @@ const nextjsNoAElement = defineRule({
 	severity: "warn",
 	recommendation: "`import Link from 'next/link'` for client-side navigation, prefetching, and preserved scroll position",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (resolveJsxElementType(node) !== "a") return;
+		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a") return;
 		const attributes = node.attributes ?? [];
 		const downloadAttribute = findJsxAttribute(attributes, "download");
 		if (downloadAttribute) {
@@ -21079,7 +20827,7 @@ const nextjsNoCssLink = defineRule({
 	severity: "warn",
 	recommendation: "Import CSS directly or use CSS Modules so Next.js can bundle, order, and optimize the stylesheet.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (resolveJsxElementType(node) !== "link") return;
+		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "link") return;
 		const attributes = node.attributes ?? [];
 		const relAttribute = findJsxAttribute(attributes, "rel");
 		if (!relAttribute?.value) return;
@@ -21187,7 +20935,7 @@ const nextjsNoFontLink = defineRule({
 	severity: "warn",
 	recommendation: "`import { Inter } from \"next/font/google\"` for self-hosting, zero layout shift, and no render-blocking requests",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (resolveJsxElementType(node) !== "link") return;
+		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "link") return;
 		const attributes = node.attributes ?? [];
 		const hrefAttribute = findJsxAttribute(attributes, "href");
 		if (!hrefAttribute?.value) return;
@@ -21362,7 +21110,7 @@ const nextjsNoImgElement = defineRule({
 	create: (context) => {
 		if (isGeneratedImageRenderContext(context)) return {};
 		return { JSXOpeningElement(node) {
-			if (resolveJsxElementType(node) !== "img") return;
+			if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "img") return;
 			if (isGeneratedImageRenderContext(context, node)) return;
 			const programRoot = findProgramRoot(node);
 			if (programRoot && hasEmailTemplateImport(programRoot)) return;
@@ -21409,8 +21157,8 @@ const nextjsNoPolyfillScript = defineRule({
 	severity: "warn",
 	recommendation: "Next.js includes polyfills for fetch, Promise, Object.assign, Array.from, and 50+ others automatically",
 	create: (context) => ({ JSXOpeningElement(node) {
-		const elementName = resolveJsxElementType(node);
-		if (elementName !== "script" && elementName !== "Script") return;
+		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+		if (node.name.name !== "script" && node.name.name !== "Script") return;
 		const srcAttribute = findJsxAttribute(node.attributes ?? [], "src");
 		if (!srcAttribute?.value) return;
 		const srcValue = isNodeOfType(srcAttribute.value, "Literal") ? srcAttribute.value.value : null;
@@ -23218,15 +22966,10 @@ const isProp = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	if (!declaringNode) return false;
 	return isReactFunctionalComponent(declaringNode) && !isReactFunctionalHOC(analysis, declaringNode) || isCustomHook(declaringNode);
 }));
-const isWholePropsParameterBinding = (bindingNode) => {
-	if (isFunctionLike$1(bindingNode.parent)) return true;
-	let declaringFunction = bindingNode.parent;
-	while (declaringFunction && !isFunctionLike$1(declaringFunction)) declaringFunction = declaringFunction.parent;
-	return Boolean(declaringFunction && resolveFirstArgumentBinding(declaringFunction.params?.[0]) === bindingNode);
-};
 const isWholePropsObjectReference = (analysis, ref) => isProp(analysis, ref) && Boolean(ref.resolved?.defs.some((def) => {
 	if (def.type !== "Parameter") return false;
-	return isWholePropsParameterBinding(def.name);
+	const bindingParent = def.name.parent;
+	return isFunctionLike$1(bindingParent);
 }));
 const isIdentifierOrMemberExpression = (node) => isNodeOfType(node, "Identifier") || isNodeOfType(node, "MemberExpression");
 const isPropAlias = (analysis, ref) => {
@@ -26223,56 +25966,6 @@ const noBarrelImport = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/function-returns-matching-expression.ts
-const collectReturnedExpressions = (functionNode) => {
-	if (!isFunctionLike$1(functionNode)) return [];
-	const body = functionNode.body;
-	if (!body) return [];
-	if (!isNodeOfType(body, "BlockStatement")) return [body];
-	const returnedExpressions = [];
-	walkAst(body, (node) => {
-		if (node !== body && (isFunctionLike$1(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
-		if (isNodeOfType(node, "ReturnStatement") && node.argument) returnedExpressions.push(node.argument);
-	});
-	return returnedExpressions;
-};
-const functionReturnsMatchingExpression = (functionNode, scopes, matchesExpression) => {
-	const visitedExpressions = /* @__PURE__ */ new Set();
-	const visitedFunctions = /* @__PURE__ */ new Set();
-	const functionMatches = (candidateFunction) => {
-		if (visitedFunctions.has(candidateFunction)) return false;
-		visitedFunctions.add(candidateFunction);
-		return collectReturnedExpressions(candidateFunction).some(expressionMatches);
-	};
-	const expressionMatches = (expression) => {
-		const unwrappedExpression = stripParenExpression(expression);
-		if (visitedExpressions.has(unwrappedExpression)) return false;
-		visitedExpressions.add(unwrappedExpression);
-		if (matchesExpression(unwrappedExpression)) return true;
-		if (isNodeOfType(unwrappedExpression, "Identifier")) {
-			const symbol = scopes.symbolFor(unwrappedExpression);
-			if (!symbol || symbol.kind !== "const" || !symbol.initializer) return false;
-			const initializer = stripParenExpression(symbol.initializer);
-			if (isFunctionLike$1(initializer)) return false;
-			return expressionMatches(initializer);
-		}
-		if (isNodeOfType(unwrappedExpression, "CallExpression")) {
-			if (unwrappedExpression.arguments.length !== 0) return false;
-			if (!isNodeOfType(unwrappedExpression.callee, "Identifier")) return false;
-			const symbol = scopes.symbolFor(unwrappedExpression.callee);
-			if (!symbol || symbol.kind !== "const" && symbol.kind !== "function") return false;
-			const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
-			const candidateFunction = isFunctionLike$1(initializer) ? initializer : isFunctionLike$1(symbol.declarationNode) ? symbol.declarationNode : null;
-			if (!candidateFunction || candidateFunction.async || candidateFunction.generator || candidateFunction.params.length !== 0) return false;
-			return functionMatches(candidateFunction);
-		}
-		if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) return expressionMatches(unwrappedExpression.consequent) || expressionMatches(unwrappedExpression.alternate);
-		if (isNodeOfType(unwrappedExpression, "LogicalExpression")) return expressionMatches(unwrappedExpression.left) || expressionMatches(unwrappedExpression.right);
-		return false;
-	};
-	return functionMatches(functionNode);
-};
-//#endregion
 //#region src/plugin/utils/function-contains-react-render-output.ts
 const NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES = new Set([
 	"FunctionDeclaration",
@@ -26292,13 +25985,12 @@ const isCallArgumentFunctionExpression = (node) => {
 	return parent.arguments.some((argumentNode) => argumentNode === node);
 };
 const isNestedRenderEvidenceBoundary = (node) => NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES.has(node.type) && !isCallArgumentFunctionExpression(node);
-const isRenderOutputExpression = (node, scopes) => node.type === "JSXElement" || node.type === "JSXFragment" || isReactApiCall(node, "createElement", scopes, REACT_CREATE_ELEMENT_OPTIONS);
 const containsRenderOutput$1 = (rootNode, scopes) => {
 	let hasRenderOutput = false;
 	walkAst(rootNode, (node) => {
 		if (hasRenderOutput) return false;
 		if (node !== rootNode && isNestedRenderEvidenceBoundary(node)) return false;
-		if (isRenderOutputExpression(node, scopes)) {
+		if (node.type === "JSXElement" || node.type === "JSXFragment" || isReactApiCall(node, "createElement", scopes, REACT_CREATE_ELEMENT_OPTIONS)) {
 			hasRenderOutput = true;
 			return false;
 		}
@@ -26309,7 +26001,7 @@ const renderOutputCache = /* @__PURE__ */ new WeakMap();
 const functionContainsReactRenderOutput = (functionNode, scopes) => {
 	const cachedEntry = renderOutputCache.get(functionNode);
 	if (cachedEntry && cachedEntry.scopes === scopes) return cachedEntry.hasRenderOutput;
-	const hasRenderOutput = containsRenderOutput$1(functionNode, scopes) || functionReturnsMatchingExpression(functionNode, scopes, (expression) => isRenderOutputExpression(expression, scopes));
+	const hasRenderOutput = containsRenderOutput$1(functionNode, scopes);
 	renderOutputCache.set(functionNode, {
 		scopes,
 		hasRenderOutput
@@ -26317,9 +26009,6 @@ const functionContainsReactRenderOutput = (functionNode, scopes) => {
 	return hasRenderOutput;
 };
 //#endregion
-//#region src/plugin/utils/is-component-assignment.ts
-const isComponentAssignment = (node) => isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && isUppercaseName(node.id.name) && Boolean(node.init) && (isNodeOfType(node.init, "ArrowFunctionExpression") || isNodeOfType(node.init, "FunctionExpression"));
-//#endregion
 //#region src/plugin/utils/is-component-declaration.ts
 const isComponentDeclaration = (node) => isNodeOfType(node, "FunctionDeclaration") && node.id !== null && Boolean(node.id?.name) && isUppercaseName(node.id.name);
 //#endregion
@@ -28777,7 +28466,7 @@ const noDisabledZoom = defineRule({
 	category: "Accessibility",
 	recommendation: "Remove `user-scalable=no` and `maximum-scale` from the viewport meta tag. If the layout breaks at 200% zoom, fix the layout instead.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (resolveJsxElementType(node) !== "meta") return;
+		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "meta") return;
 		const nameAttr = findJsxAttribute(node.attributes ?? [], "name");
 		if (!nameAttr?.value) return;
 		if ((isNodeOfType(nameAttr.value, "Literal") ? nameAttr.value.value : null) !== "viewport") return;
@@ -29167,7 +28856,7 @@ const findTopLevelEffectCalls = (componentBody) => {
 	if (!isNodeOfType(componentBody, "BlockStatement")) return effectCalls;
 	for (const statement of componentBody.body ?? []) {
 		if (!isNodeOfType(statement, "ExpressionStatement")) continue;
-		const expression = unwrapDiscardedExpression(statement);
+		const expression = statement.expression;
 		if (!isNodeOfType(expression, "CallExpression")) continue;
 		if (!isHookCall$2(expression, EFFECT_HOOK_NAMES$1)) continue;
 		effectCalls.push(expression);
@@ -31949,7 +31638,7 @@ const noImgLazyWithHighFetchpriority = defineRule({
 	severity: "warn",
 	recommendation: "Don't combine `loading=\"lazy\"` with `fetchPriority=\"high\"`. A high-priority image (usually the LCP) should load eagerly; a lazy image is by definition not high priority.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (resolveJsxElementType(node) !== "img") return;
+		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "img") return;
 		const loadingAttribute = hasJsxPropIgnoreCase(node.attributes, "loading");
 		if (!loadingAttribute || getJsxPropStringValue(loadingAttribute)?.toLowerCase() !== "lazy") return;
 		const fetchPriorityAttribute = hasJsxPropIgnoreCase(node.attributes, "fetchPriority");
@@ -31961,26 +31650,6 @@ const noImgLazyWithHighFetchpriority = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/react-ref-origin.ts
-const resolveReactRefSymbol = (memberExpression, scopes) => {
-	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
-	if (!isNodeOfType(memberExpression, "MemberExpression") || getStaticPropertyName(memberExpression) !== "current" || !isNodeOfType(receiver, "Identifier")) return null;
-	const symbol = resolveConstIdentifierAlias(receiver, scopes);
-	if (!symbol?.initializer) return null;
-	const initializer = stripParenExpression(symbol.initializer);
-	if (!isNodeOfType(initializer, "CallExpression")) return null;
-	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
-};
-const hasReactRefCurrentOrigin = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(node);
-	if (resolveReactRefSymbol(expression, scopes)) return true;
-	if (!isNodeOfType(expression, "Identifier")) return false;
-	const symbol = resolveConstIdentifierAlias(expression, scopes);
-	if (!symbol?.initializer || visitedSymbolIds.has(symbol.id)) return false;
-	visitedSymbolIds.add(symbol.id);
-	return hasReactRefCurrentOrigin(symbol.initializer, scopes, visitedSymbolIds);
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-impure-state-updater.ts
 const TIMER_FUNCTION_NAMES = new Set([
 	"cancelAnimationFrame",
@@ -32012,33 +31681,6 @@ const NOTIFICATION_METHOD_NAMES = new Set([
 	"success",
 	"warning"
 ]);
-const NOTIFICATION_MODULE_SOURCES = new Set([
-	"@chakra-ui/react",
-	"@heroui/react",
-	"@mantine/notifications",
-	"antd",
-	"react-hot-toast",
-	"react-toastify",
-	"sonner"
-]);
-const SYNCHRONOUS_ARRAY_METHOD_NAMES = new Set([
-	"every",
-	"filter",
-	"find",
-	"findIndex",
-	"flatMap",
-	"forEach",
-	"map",
-	"reduce",
-	"reduceRight",
-	"some",
-	"sort"
-]);
-const isNotificationModuleSource = (source) => {
-	if (!source) return false;
-	for (const moduleSource of NOTIFICATION_MODULE_SOURCES) if (source === moduleSource || source.startsWith(`${moduleSource}/`)) return true;
-	return /(?:^|[/_.-])(?:notification|toast)s?(?:$|[/_.-])/i.test(source);
-};
 const getMemberCall = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return null;
 	if (!isNodeOfType(node.callee, "MemberExpression") || node.callee.computed) return null;
@@ -32050,37 +31692,27 @@ const getMemberCall = (node) => {
 };
 const isNotificationReceiver = (receiver, scopes) => {
 	if (!isNodeOfType(receiver, "Identifier")) return false;
-	const importBinding = getImportBindingForName(receiver, receiver.name);
-	if (importBinding) return isNotificationModuleSource(importBinding.source) && (importBinding.exportedName === "default" || importBinding.exportedName !== null && NOTIFICATION_RECEIVER_NAMES.has(importBinding.exportedName));
+	if (!NOTIFICATION_RECEIVER_NAMES.has(receiver.name)) return false;
 	const symbol = scopes.symbolFor(receiver);
+	if (symbol?.kind === "import") return true;
 	if (!isNodeOfType(symbol?.initializer, "CallExpression")) return false;
 	const callee = symbol.initializer.callee;
-	if (!isNodeOfType(callee, "Identifier")) return false;
-	const hookImport = getImportBindingForName(callee, callee.name);
-	return Boolean(hookImport && isNotificationModuleSource(hookImport.source) && hookImport.exportedName !== null && /^use(?:Message|Notification|Toast)$/.test(hookImport.exportedName));
-};
-const isKnownGlobalObject = (node, expectedName, scopes) => isNodeOfType(node, "Identifier") && node.name === expectedName && scopes.isGlobalReference(node);
-const isGlobalMember = (node, expectedPropertyName, scopes) => isNodeOfType(node, "MemberExpression") && !node.computed && isNodeOfType(node.property, "Identifier") && node.property.name === expectedPropertyName && (isKnownGlobalObject(node.object, "window", scopes) || isKnownGlobalObject(node.object, "globalThis", scopes));
-const isStorageReceiver = (node, scopes) => {
-	if (isNodeOfType(node, "Identifier") && STORAGE_RECEIVER_NAMES.has(node.name) && scopes.isGlobalReference(node)) return true;
-	for (const receiverName of STORAGE_RECEIVER_NAMES) if (isGlobalMember(node, receiverName, scopes)) return true;
-	return false;
+	return isNodeOfType(callee, "Identifier") && /^use(?:Message|Notification|Toast)$/.test(callee.name);
 };
 const getKnownImpureCall = (callExpression, scopes) => {
 	if (isNodeOfType(callExpression.callee, "Identifier") && TIMER_FUNCTION_NAMES.has(callExpression.callee.name) && scopes.isGlobalReference(callExpression.callee)) return `${callExpression.callee.name}()`;
-	if (isNodeOfType(callExpression.callee, "MemberExpression") && !callExpression.callee.computed && isNodeOfType(callExpression.callee.property, "Identifier") && TIMER_FUNCTION_NAMES.has(callExpression.callee.property.name) && (isKnownGlobalObject(callExpression.callee.object, "window", scopes) || isKnownGlobalObject(callExpression.callee.object, "globalThis", scopes))) return `${callExpression.callee.property.name}()`;
 	const memberCall = getMemberCall(callExpression);
 	if (!memberCall) return null;
 	const { methodName, receiver } = memberCall;
-	if (STORAGE_MUTATION_METHOD_NAMES.has(methodName) && isStorageReceiver(receiver, scopes)) return `${methodName}()`;
-	if (EXTERNAL_READ_METHOD_NAMES.has(methodName) && hasReactRefCurrentOrigin(receiver, scopes)) return `.${methodName}()`;
-	const receiverRoot = getRootIdentifier$1(receiver);
-	if (EXTERNAL_READ_METHOD_NAMES.has(methodName) && receiverRoot !== null && isKnownGlobalObject(receiverRoot, "document", scopes)) return `.${methodName}()`;
-	if (NOTIFICATION_METHOD_NAMES.has(methodName) && isNotificationReceiver(receiver, scopes)) return `${methodName}()`;
+	if (STORAGE_MUTATION_METHOD_NAMES.has(methodName) && isNodeOfType(receiver, "Identifier") && STORAGE_RECEIVER_NAMES.has(receiver.name) && scopes.isGlobalReference(receiver)) return `${receiver.name}.${methodName}()`;
+	if (EXTERNAL_READ_METHOD_NAMES.has(methodName)) return `.${methodName}()`;
+	if (NOTIFICATION_METHOD_NAMES.has(methodName) && isNodeOfType(receiver, "Identifier") && isNotificationReceiver(receiver, scopes)) return `${receiver.name}.${methodName}()`;
 	return null;
 };
 const getExternalAssignmentDescription = (assignmentTarget, updater, scopes) => {
-	const rootIdentifier = getRootIdentifier$1(assignmentTarget);
+	let rootIdentifier = null;
+	if (isNodeOfType(assignmentTarget, "Identifier")) rootIdentifier = assignmentTarget;
+	else if (isNodeOfType(assignmentTarget, "MemberExpression") && isNodeOfType(assignmentTarget.object, "Identifier")) rootIdentifier = assignmentTarget.object;
 	if (!rootIdentifier) return null;
 	const updaterScope = scopes.ownScopeFor(updater);
 	if (!updaterScope) return null;
@@ -32089,26 +31721,12 @@ const getExternalAssignmentDescription = (assignmentTarget, updater, scopes) =>
 	if (symbol.kind === "parameter" && symbol.scope === updaterScope) return `the updater argument "${rootIdentifier.name}"`;
 	return isDescendantScope(symbol.scope, updaterScope) ? null : `the captured value "${rootIdentifier.name}"`;
 };
-const isArrayValue = (node, scopes) => {
-	const expression = stripParenExpression(node);
-	if (isNodeOfType(expression, "ArrayExpression")) return true;
-	if (!isNodeOfType(expression, "Identifier")) return false;
-	return isNodeOfType(resolveConstIdentifierAlias(expression, scopes)?.initializer, "ArrayExpression");
-};
-const isDefinitelySynchronousCallback = (callback, scopes) => {
-	const parent = callback.parent;
-	if (!parent) return false;
-	if (isNodeOfType(parent, "CallExpression") && parent.callee === callback) return true;
-	if (!isNodeOfType(parent, "CallExpression") || !parent.arguments?.some((argument) => argument === callback)) return false;
-	if (isNodeOfType(parent.callee, "MemberExpression") && !parent.callee.computed && isNodeOfType(parent.callee.property, "Identifier") && SYNCHRONOUS_ARRAY_METHOD_NAMES.has(parent.callee.property.name) && isArrayValue(parent.callee.object, scopes)) return true;
-	return isNodeOfType(parent.callee, "MemberExpression") && !parent.callee.computed && isNodeOfType(parent.callee.object, "Identifier") && parent.callee.object.name === "Array" && scopes.isGlobalReference(parent.callee.object) && isNodeOfType(parent.callee.property, "Identifier") && parent.callee.property.name === "from" && parent.arguments[1] === callback;
-};
 const findImpureUpdaterOperation = (updater, scopes) => {
 	const analysis = getProgramAnalysis(updater);
 	let operation = null;
 	walkAst(updater, (child) => {
 		if (operation) return false;
-		if (child !== updater && isFunctionLike$1(child) && !isDefinitelySynchronousCallback(child, scopes)) return false;
+		if (child !== updater && isFunctionLike$1(child) && !executesDuringRender(child, scopes)) return false;
 		if (isNodeOfType(child, "CallExpression")) {
 			if (isNodeOfType(child.callee, "Identifier") && analysis) {
 				const calleeReference = getRef(analysis, child.callee);
@@ -32140,25 +31758,18 @@ const noImpureStateUpdater = defineRule({
 	severity: "error",
 	recommendation: "Keep state updater callbacks pure and return only the next state. Move notifications, storage, timers, ref writes, and other external work into the event or effect that queues the update.",
 	create: (context) => ({ CallExpression(node) {
-		const updaterArgument = node.arguments?.[0];
-		if (!updaterArgument) return;
+		const updater = node.arguments?.[0];
+		if (!updater || !isFunctionLike$1(updater)) return;
 		const analysis = getProgramAnalysis(node);
 		if (!analysis || !isNodeOfType(node.callee, "Identifier")) return;
 		const calleeReference = getRef(analysis, node.callee);
 		if (!calleeReference || !isStateSetterCall(analysis, calleeReference)) return;
 		const stateDeclarator = getUseStateDecl(analysis, calleeReference);
 		if (!isNodeOfType(stateDeclarator, "VariableDeclarator") || !isNodeOfType(stateDeclarator.init, "CallExpression") || !isReactApiCall(stateDeclarator.init, "useState", context.scopes, { allowGlobalReactNamespace: true })) return;
-		let updater = null;
-		if (isFunctionLike$1(updaterArgument)) updater = updaterArgument;
-		else if (isNodeOfType(updaterArgument, "Identifier")) {
-			const updaterReference = getRef(analysis, updaterArgument);
-			if (updaterReference) updater = resolveToFunction(updaterReference);
-		}
-		if (!updater) return;
 		const operation = findImpureUpdaterOperation(updater, context.scopes);
 		if (!operation) return;
 		context.report({
-			node: updaterArgument,
+			node: updater,
 			message: `This state updater performs ${operation}. React may run updater functions more than once, so side effects here can repeat or observe inconsistent external state.`
 		});
 	} })
@@ -32268,7 +31879,7 @@ const noIndeterminateAttribute = defineRule({
 		if (classifyReactNativeFileTarget(context) === "react-native") return {};
 		return {
 			JSXOpeningElement(node) {
-				if (resolveJsxElementType(node) !== "input") return;
+				if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "input") return;
 				let typeAttribute = null;
 				let typeAttributeIndex = null;
 				let indeterminateAttribute = null;
@@ -32447,12 +32058,11 @@ const isMemoCall = (node) => {
 };
 const isDefaultEquivalentComparator = (comparator) => isNodeOfType(comparator, "Identifier") && (comparator.name === "undefined" || comparator.name === "shallowEqual");
 const hasCustomComparator = (node) => isNodeOfType(node, "CallExpression") && (node.arguments?.length ?? 0) >= 2 && !isDefaultEquivalentComparator(node.arguments?.[1]);
-const isInlineReference = (node, scopes) => {
-	const referenceNode = unwrapObjectIntegrityExpression(node, scopes);
-	if (isNodeOfType(referenceNode, "ArrowFunctionExpression") || isNodeOfType(referenceNode, "FunctionExpression") || isNodeOfType(referenceNode, "CallExpression") && isNodeOfType(referenceNode.callee, "MemberExpression") && isNodeOfType(referenceNode.callee.property, "Identifier") && referenceNode.callee.property.name === "bind") return "functions";
-	if (isNodeOfType(referenceNode, "ObjectExpression")) return "objects";
-	if (isNodeOfType(referenceNode, "ArrayExpression")) return "Arrays";
-	if (isNodeOfType(referenceNode, "JSXElement") || isNodeOfType(referenceNode, "JSXFragment")) return "JSX";
+const isInlineReference = (node) => {
+	if (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "bind") return "functions";
+	if (isNodeOfType(node, "ObjectExpression")) return "objects";
+	if (isNodeOfType(node, "ArrayExpression")) return "Arrays";
+	if (isNodeOfType(node, "JSXElement") || isNodeOfType(node, "JSXFragment")) return "JSX";
 	return null;
 };
 const noInlinePropOnMemoComponent = defineRule({
@@ -32482,7 +32092,7 @@ const noInlinePropOnMemoComponent = defineRule({
 				let elementName = null;
 				if (isNodeOfType(openingElement.name, "JSXIdentifier")) elementName = openingElement.name.name;
 				if (!elementName || !memoizedComponentNames.has(elementName)) return;
-				const propType = isInlineReference(node.value.expression, context.scopes);
+				const propType = isInlineReference(node.value.expression);
 				if (propType) context.report({
 					node: node.value.expression,
 					message: `This redraws ${elementName} on every render because the prop is ${propType} built right here, so memo() can't skip it. Move it to a stable value with useMemo, useCallback, or module scope`
@@ -33003,18 +32613,6 @@ const INTL_FORMAT_METHOD_NAMES = new Set([
 	"formatToParts",
 	"formatRange"
 ]);
-const ABSENT_PROPERTY_PROOF = { status: "absent" };
-const PRESENT_PROPERTY_PROOF = { status: "present" };
-const UNDEFINED_PROPERTY_PROOF = { status: "undefined" };
-const UNKNOWN_PROPERTY_PROOF = { status: "unknown" };
-const READ_ONLY_OBJECT_METHOD_NAMES = new Set([
-	"hasOwnProperty",
-	"isPrototypeOf",
-	"propertyIsEnumerable",
-	"toLocaleString",
-	"toString",
-	"valueOf"
-]);
 const isProvableDateExpression = (expression) => {
 	if (!expression) return false;
 	const unwrapped = stripParenExpression(expression);
@@ -33029,290 +32627,32 @@ const receiverNameLooksDateFlavored = (expression) => {
 	if (isNodeOfType(unwrapped, "CallExpression")) return receiverNameLooksDateFlavored(unwrapped.callee);
 	return false;
 };
-const isStaticUndefined = (node, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const expression = stripParenExpression(node);
-	if (isNodeOfType(expression, "UnaryExpression") && expression.operator === "void") return true;
-	if (!isNodeOfType(expression, "Identifier")) return false;
-	if (expression.name === "undefined" && scopes.isGlobalReference(expression)) return true;
-	const symbol = scopes.symbolFor(expression);
-	if (symbol?.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || !isNodeOfType(symbol.declarationNode.id, "Identifier") || visitedSymbolIds.has(symbol.id)) return false;
-	visitedSymbolIds.add(symbol.id);
-	return isStaticUndefined(symbol.initializer, scopes, visitedSymbolIds);
-};
-const isNestedAssignmentTarget = (expression) => {
-	let target = expression;
-	let parent = target.parent;
-	while (parent) {
-		if (isNodeOfType(parent, "AssignmentExpression")) return parent.left === target;
-		if (isNodeOfType(parent, "ForInStatement") || isNodeOfType(parent, "ForOfStatement")) return parent.left === target;
-		if (isNodeOfType(parent, "AssignmentPattern")) {
-			if (parent.left !== target) return false;
-		} else if (isNodeOfType(parent, "RestElement")) {
-			if (parent.argument !== target) return false;
-		} else if (isNodeOfType(parent, "ArrayPattern")) {
-			if (!parent.elements?.some((element) => element === target)) return false;
-		} else if (isNodeOfType(parent, "Property")) {
-			if (parent.value !== target || !isNodeOfType(parent.parent, "ObjectPattern")) return false;
-		} else if (isNodeOfType(parent, "ObjectPattern")) {
-			if (!parent.properties?.some((property) => property === target)) return false;
-		} else return false;
-		target = parent;
-		parent = target.parent;
-	}
-	return false;
-};
-const isPotentialMutationReference = (identifier, readNode) => {
-	let expression = identifier;
-	let parent = expression.parent;
-	while (parent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type) && "expression" in parent && parent.expression === expression) {
-		expression = parent;
-		parent = expression.parent;
-	}
-	const rootExpression = expression;
-	let memberDepth = 0;
-	while (parent && isNodeOfType(parent, "MemberExpression") && parent.object === expression) {
-		memberDepth += 1;
-		expression = parent;
-		parent = expression.parent;
-		while (parent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type) && "expression" in parent && parent.expression === expression) {
-			expression = parent;
-			parent = expression.parent;
-		}
-	}
-	if (!parent || isAstDescendant(identifier, readNode)) return false;
-	if (isNestedAssignmentTarget(expression)) return true;
-	if (isNodeOfType(parent, "AssignmentExpression") && parent.left === expression) return true;
-	if (isNodeOfType(parent, "UpdateExpression") && parent.argument === expression) return true;
-	if (isNodeOfType(parent, "UnaryExpression") && parent.operator === "delete" && parent.argument === expression) return true;
-	if (isNodeOfType(parent, "CallExpression")) {
-		if (parent.callee === expression) {
-			if (memberDepth === 0) return true;
-			const memberExpression = stripParenExpression(expression);
-			return memberDepth === 1 && isNodeOfType(memberExpression, "MemberExpression") && !READ_ONLY_OBJECT_METHOD_NAMES.has(getStaticPropertyName(memberExpression) ?? "");
-		}
-		return memberDepth === 0 && parent.arguments?.some((argument) => argument === rootExpression);
-	}
-	if (isNodeOfType(parent, "NewExpression")) return memberDepth === 0 && parent.arguments?.some((argument) => argument === rootExpression);
-	if (isNodeOfType(parent, "AssignmentExpression") && parent.right === rootExpression) return true;
-	return false;
-};
-const getSimpleAlias = (identifier, scopes) => {
-	let expression = identifier;
-	let parent = expression.parent;
-	while (parent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type) && "expression" in parent && parent.expression === expression) {
-		expression = parent;
-		parent = expression.parent;
-	}
-	if (!isNodeOfType(parent, "VariableDeclarator") || parent.init !== expression || !isNodeOfType(parent.id, "Identifier")) return null;
-	const symbol = scopes.symbolFor(parent.id);
-	return symbol ? {
-		symbol,
-		readNode: parent.id
-	} : null;
-};
-const getDirectCallForExpression = (expression) => {
-	let callee = expression;
-	let parent = callee.parent;
-	while (parent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(parent.type) && "expression" in parent && parent.expression === callee) {
-		callee = parent;
-		parent = callee.parent;
-	}
-	return isNodeOfType(parent, "CallExpression") && parent.callee === callee ? parent : null;
-};
-const getMethodOwner = (functionNode, scopes) => {
-	const methodNode = functionNode.parent;
-	if (isNodeOfType(methodNode, "Property") && methodNode.value === functionNode && isNodeOfType(methodNode.parent, "ObjectExpression")) {
-		const objectParent = methodNode.parent.parent;
-		if (!isNodeOfType(objectParent, "VariableDeclarator") || objectParent.init !== methodNode.parent || !isNodeOfType(objectParent.id, "Identifier")) return null;
-		const ownerSymbol = scopes.symbolFor(objectParent.id);
-		const methodName = getStaticPropertyKeyName(methodNode, { allowComputedString: true });
-		return ownerSymbol && methodName ? {
-			methodName,
-			ownerKind: "object",
-			ownerSymbol,
-			isStatic: false
-		} : null;
-	}
-	if (!isNodeOfType(methodNode, "MethodDefinition") || methodNode.value !== functionNode || !isNodeOfType(methodNode.parent, "ClassBody")) return null;
-	const classNode = methodNode.parent.parent;
-	if (!isNodeOfType(classNode, "ClassDeclaration") && !isNodeOfType(classNode, "ClassExpression")) return null;
-	let bindingIdentifier = isNodeOfType(classNode.id, "Identifier") ? classNode.id : null;
-	if (!bindingIdentifier && isNodeOfType(classNode.parent, "VariableDeclarator")) bindingIdentifier = isNodeOfType(classNode.parent.id, "Identifier") ? classNode.parent.id : null;
-	if (!bindingIdentifier) return null;
-	const ownerSymbol = scopes.symbolFor(bindingIdentifier);
-	const methodName = getStaticPropertyKeyName(methodNode, { allowComputedString: true });
-	return ownerSymbol && methodName ? {
-		methodName,
-		ownerKind: "class",
-		ownerSymbol,
-		isStatic: Boolean(methodNode.static)
-	} : null;
-};
-const doesSymbolResolveToOwner = (symbol, ownerSymbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	if (!symbol) return false;
-	if (symbol.declarationNode === ownerSymbol.declarationNode) return true;
-	if (symbol.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id)) return false;
-	visitedSymbolIds.add(symbol.id);
-	const initializer = stripParenExpression(symbol.initializer);
-	return isNodeOfType(initializer, "Identifier") && doesSymbolResolveToOwner(scopes.symbolFor(initializer), ownerSymbol, scopes, visitedSymbolIds);
-};
-const isClassInstanceExpression = (expression, ownerSymbol, scopes, visitedSymbolIds = /* @__PURE__ */ new Set()) => {
-	const candidate = stripParenExpression(expression);
-	if (isNodeOfType(candidate, "NewExpression") && isNodeOfType(candidate.callee, "Identifier")) return doesSymbolResolveToOwner(scopes.symbolFor(candidate.callee), ownerSymbol, scopes);
-	if (!isNodeOfType(candidate, "Identifier")) return false;
-	const symbol = scopes.symbolFor(candidate);
-	if (symbol?.kind !== "const" || !symbol.initializer || visitedSymbolIds.has(symbol.id)) return false;
-	visitedSymbolIds.add(symbol.id);
-	return isClassInstanceExpression(symbol.initializer, ownerSymbol, scopes, visitedSymbolIds);
-};
-const getMethodCalls = (functionNode, scopes) => {
-	const owner = getMethodOwner(functionNode, scopes);
-	if (!owner) return [];
-	const calls = [];
-	walkAst(scopes.rootScope.node, (child) => {
-		if (!isNodeOfType(child, "MemberExpression")) return;
-		if (getStaticPropertyName(child) !== owner.methodName) return;
-		const receiver = stripParenExpression(child.object);
-		let doesReceiverMatch = isNodeOfType(receiver, "Identifier") && doesSymbolResolveToOwner(scopes.symbolFor(receiver), owner.ownerSymbol, scopes);
-		if (owner.ownerKind === "class" && !owner.isStatic) doesReceiverMatch = isClassInstanceExpression(receiver, owner.ownerSymbol, scopes);
-		if (!doesReceiverMatch) return;
-		const call = getDirectCallForExpression(child);
-		if (call) calls.push(call);
-	});
-	return calls;
-};
-const isFunctionInvokedBeforeUsage = (functionNode, usageNode, usageBoundary, scopes, visitedSymbolIds, visitedFunctionNodes = /* @__PURE__ */ new Set()) => {
-	if (visitedFunctionNodes.has(functionNode)) return false;
-	visitedFunctionNodes.add(functionNode);
-	const usageFunction = findEnclosingFunction(usageNode);
-	const immediateCall = getDirectCallForExpression(functionNode);
-	if (immediateCall) {
-		const immediateCallFunction = findEnclosingFunction(immediateCall);
-		if (immediateCallFunction === usageFunction) {
-			const immediateCallStart = getRangeStart(immediateCall);
-			return immediateCallStart === null || immediateCallStart < usageBoundary;
-		}
-		if (!immediateCallFunction) return usageFunction !== null;
-		return isFunctionInvokedBeforeUsage(immediateCallFunction, usageNode, usageBoundary, scopes, visitedSymbolIds, new Set(visitedFunctionNodes));
-	}
-	for (const methodCall of getMethodCalls(functionNode, scopes)) {
-		const methodCallFunction = findEnclosingFunction(methodCall);
-		if (methodCallFunction === usageFunction) {
-			const methodCallStart = getRangeStart(methodCall);
-			if (methodCallStart === null || methodCallStart < usageBoundary) return true;
-			continue;
-		}
-		if (!methodCallFunction) {
-			if (usageFunction) return true;
-			continue;
-		}
-		if (isFunctionInvokedBeforeUsage(methodCallFunction, usageNode, usageBoundary, scopes, new Set(visitedSymbolIds), new Set(visitedFunctionNodes))) return true;
-	}
-	const bindingIdentifier = getFunctionBindingIdentifier(functionNode);
-	if (!bindingIdentifier) return false;
-	const symbol = scopes.symbolFor(bindingIdentifier);
-	if (!symbol || visitedSymbolIds.has(symbol.id)) return false;
-	visitedSymbolIds.add(symbol.id);
-	let wasInvokedBeforeUsage = false;
-	walkAst(scopes.rootScope.node, (child) => {
-		if (wasInvokedBeforeUsage || !isNodeOfType(child, "Identifier")) return;
-		if (scopes.symbolFor(child)?.declarationNode !== symbol.declarationNode) return;
-		const call = getDirectCallForExpression(child);
-		if (!call) return false;
-		const callFunction = findEnclosingFunction(call);
-		if (callFunction === usageFunction) {
-			const callStart = getRangeStart(call);
-			wasInvokedBeforeUsage = callStart === null || callStart < usageBoundary;
-			return;
-		}
-		if (!callFunction) {
-			wasInvokedBeforeUsage = usageFunction !== null;
-			return;
-		}
-		wasInvokedBeforeUsage = isFunctionInvokedBeforeUsage(callFunction, usageNode, usageBoundary, scopes, new Set(visitedSymbolIds), new Set(visitedFunctionNodes));
-	});
-	return wasInvokedBeforeUsage;
-};
-const getMutationUsageBoundary = (usageNode, readNode) => {
-	const readStart = getRangeStart(readNode);
-	let readExpression = readNode;
-	let readParent = readExpression.parent;
-	while (readParent && TRANSPARENT_EXPRESSION_WRAPPER_TYPES.has(readParent.type) && "expression" in readParent && readParent.expression === readExpression) {
-		readExpression = readParent;
-		readParent = readExpression.parent;
-	}
-	if ((isNodeOfType(usageNode, "CallExpression") || isNodeOfType(usageNode, "NewExpression")) && usageNode.arguments?.some((argument) => argument === readExpression)) return usageNode.range?.[1] ?? null;
-	if (isAstDescendant(readNode, usageNode)) return readStart;
-	return getRangeStart(usageNode);
-};
-const wasMutatedBeforeUsage = (symbol, usageNode, readNode, scopes, visitedMutationSymbolIds = /* @__PURE__ */ new Set(), inheritedUsageBoundary, readNodesBySymbolId = /* @__PURE__ */ new Map()) => {
-	if (visitedMutationSymbolIds.has(symbol.id)) return false;
-	visitedMutationSymbolIds.add(symbol.id);
-	const usageBoundary = inheritedUsageBoundary === void 0 ? getMutationUsageBoundary(usageNode, readNode) : inheritedUsageBoundary;
-	if (typeof usageBoundary !== "number") return true;
-	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(reference.identifier);
-		if (mutationFunction === usageFunction) return referenceStart < usageBoundary;
-		if (!mutationFunction) return usageFunction !== null;
-		if (usageFunction && isAstDescendant(usageFunction, mutationFunction)) return true;
-		return isFunctionInvokedBeforeUsage(mutationFunction, usageNode, usageBoundary, scopes, /* @__PURE__ */ new Set());
-	});
-};
-const getObjectPropertyProof = (objectExpression, propertyName, scopes, usageNode, visitedSymbolIds = /* @__PURE__ */ new Set(), inheritedUsageBoundary, readNodesBySymbolId = /* @__PURE__ */ new Map()) => {
-	if (!objectExpression) return ABSENT_PROPERTY_PROOF;
+const objectLiteralHasProperty = (objectExpression, propertyName) => {
+	if (!objectExpression) return false;
 	const unwrapped = stripParenExpression(objectExpression);
-	if (isNodeOfType(unwrapped, "Literal") || isStaticUndefined(unwrapped, scopes)) return ABSENT_PROPERTY_PROOF;
-	if (isNodeOfType(unwrapped, "Identifier")) {
-		const symbol = scopes.symbolFor(unwrapped);
-		const nextReadNodesBySymbolId = new Map(readNodesBySymbolId);
-		if (symbol) nextReadNodesBySymbolId.set(symbol.id, unwrapped);
-		const usageBoundary = inheritedUsageBoundary === void 0 ? getMutationUsageBoundary(usageNode, unwrapped) : inheritedUsageBoundary;
-		if (symbol?.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || !isNodeOfType(symbol.declarationNode.id, "Identifier") || visitedSymbolIds.has(symbol.id) || wasMutatedBeforeUsage(symbol, usageNode, unwrapped, scopes, /* @__PURE__ */ new Set(), usageBoundary, nextReadNodesBySymbolId)) return UNKNOWN_PROPERTY_PROOF;
-		visitedSymbolIds.add(symbol.id);
-		return getObjectPropertyProof(symbol.initializer, propertyName, scopes, usageNode, visitedSymbolIds, usageBoundary, nextReadNodesBySymbolId);
-	}
-	if (isNodeOfType(unwrapped, "ConditionalExpression")) {
-		const consequent = getObjectPropertyProof(unwrapped.consequent, propertyName, scopes, usageNode, new Set(visitedSymbolIds), inheritedUsageBoundary, new Map(readNodesBySymbolId));
-		const alternate = getObjectPropertyProof(unwrapped.alternate, propertyName, scopes, usageNode, new Set(visitedSymbolIds), inheritedUsageBoundary, new Map(readNodesBySymbolId));
-		return consequent.status === alternate.status ? consequent : UNKNOWN_PROPERTY_PROOF;
-	}
-	if (isNodeOfType(unwrapped, "CallExpression") && isNodeOfType(unwrapped.callee, "MemberExpression") && !unwrapped.callee.computed && isNodeOfType(unwrapped.callee.object, "Identifier") && unwrapped.callee.object.name === "Object" && scopes.isGlobalReference(unwrapped.callee.object) && isNodeOfType(unwrapped.callee.property, "Identifier") && unwrapped.callee.property.name === "freeze") return getObjectPropertyProof(unwrapped.arguments?.[0], propertyName, scopes, usageNode, visitedSymbolIds, inheritedUsageBoundary, readNodesBySymbolId);
-	if (!isNodeOfType(unwrapped, "ObjectExpression")) return UNKNOWN_PROPERTY_PROOF;
-	const properties = unwrapped.properties ?? [];
-	for (let propertyIndex = properties.length - 1; propertyIndex >= 0; propertyIndex -= 1) {
-		const property = properties[propertyIndex];
-		if (!property) continue;
-		if (isNodeOfType(property, "SpreadElement")) {
-			const spreadProof = getObjectPropertyProof(property.argument, propertyName, scopes, unwrapped, new Set(visitedSymbolIds), void 0);
-			if (spreadProof.status !== "absent") return spreadProof;
-			continue;
-		}
-		if (!isNodeOfType(property, "Property") || getStaticPropertyKeyName(property) !== propertyName) continue;
-		return isStaticUndefined(property.value, scopes) ? UNDEFINED_PROPERTY_PROOF : PRESENT_PROPERTY_PROOF;
+	if (!isNodeOfType(unwrapped, "ObjectExpression")) return false;
+	for (const property of unwrapped.properties ?? []) {
+		if (!isNodeOfType(property, "Property")) continue;
+		if (property.computed) continue;
+		if (isNodeOfType(property.key, "Identifier") && property.key.name === propertyName) return true;
+		if (isNodeOfType(property.key, "Literal") && property.key.value === propertyName) return true;
 	}
-	return ABSENT_PROPERTY_PROOF;
+	return false;
 };
-const objectHasExplicitProperty = (objectExpression, propertyName, scopes, usageNode) => getObjectPropertyProof(objectExpression, propertyName, scopes, usageNode).status === "present";
-const hasExplicitLocaleArgument = (argument, scopes) => {
+const hasExplicitLocaleArgument = (argument) => {
 	if (!argument) return false;
 	const unwrapped = stripParenExpression(argument);
-	if (isNodeOfType(unwrapped, "Identifier") && unwrapped.name === "undefined" && scopes.isGlobalReference(unwrapped) || isNodeOfType(unwrapped, "UnaryExpression") && unwrapped.operator === "void") return false;
+	if (isNodeOfType(unwrapped, "Identifier") && unwrapped.name === "undefined") return false;
 	return true;
 };
-const isDeterministicLocaleMethodCall = (call, methodName, receiverIsProvablyDate, scopes) => {
+const isDeterministicLocaleMethodCall = (call, methodName, receiverIsProvablyDate) => {
 	const localeArgument = call.arguments?.[0];
-	if (!hasExplicitLocaleArgument(localeArgument, scopes)) return false;
+	if (!hasExplicitLocaleArgument(localeArgument)) return false;
 	const optionsArgument = call.arguments?.[1];
-	if (objectHasExplicitProperty(optionsArgument, "timeZone", scopes, call)) return true;
+	if (objectLiteralHasProperty(optionsArgument, "timeZone")) return true;
 	return !DATE_ONLY_LOCALE_METHOD_NAMES.has(methodName) && !receiverIsProvablyDate;
 };
-const matchLocaleMethodCall = (call, scopes) => {
+const matchLocaleMethodCall = (call) => {
 	const callee = call.callee;
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return null;
 	if (!isNodeOfType(callee.property, "Identifier")) return null;
@@ -33320,7 +32660,7 @@ const matchLocaleMethodCall = (call, scopes) => {
 	if (!LOCALE_FORMAT_METHOD_NAMES.has(methodName)) return null;
 	const receiverIsProvablyDate = isProvableDateExpression(callee.object);
 	if (methodName === "toLocaleString" && !receiverIsProvablyDate && !receiverNameLooksDateFlavored(callee.object)) return null;
-	if (isDeterministicLocaleMethodCall(call, methodName, receiverIsProvablyDate, scopes)) return null;
+	if (isDeterministicLocaleMethodCall(call, methodName, receiverIsProvablyDate)) return null;
 	return {
 		node: call,
 		display: `${methodName}()`
@@ -33336,13 +32676,13 @@ const getIntlFormatterName = (expression) => {
 	if (!isNodeOfType(callee.property, "Identifier")) return null;
 	return INTL_FORMATTER_NAMES.has(callee.property.name) ? callee.property.name : null;
 };
-const isDeterministicIntlConstruction = (construction, formatterName, scopes) => {
+const isDeterministicIntlConstruction = (construction, formatterName) => {
 	if (!isNodeOfType(construction, "CallExpression") && !isNodeOfType(construction, "NewExpression")) return false;
-	if (!hasExplicitLocaleArgument(construction.arguments?.[0], scopes)) return false;
+	if (!hasExplicitLocaleArgument(construction.arguments?.[0])) return false;
 	if (formatterName !== "DateTimeFormat") return true;
-	return objectHasExplicitProperty(construction.arguments?.[1], "timeZone", scopes, construction);
+	return objectLiteralHasProperty(construction.arguments?.[1], "timeZone");
 };
-const matchIntlFormatCall = (call, scopes) => {
+const matchIntlFormatCall = (call) => {
 	const callee = call.callee;
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed) return null;
 	if (!isNodeOfType(callee.property, "Identifier")) return null;
@@ -33355,7 +32695,7 @@ const matchIntlFormatCall = (call, scopes) => {
 	if (!construction) return null;
 	const formatterName = getIntlFormatterName(construction);
 	if (!formatterName) return null;
-	if (isDeterministicIntlConstruction(construction, formatterName, scopes)) return null;
+	if (isDeterministicIntlConstruction(construction, formatterName)) return null;
 	return {
 		node: call,
 		display: `Intl.${formatterName}().${callee.property.name}()`
@@ -33424,7 +32764,7 @@ const noLocaleFormatInRender = defineRule({
 				fileIsEmailTemplate = hasEmailTemplateImport(node);
 			},
 			CallExpression(node) {
-				const match = matchLocaleMethodCall(node, context.scopes) ?? matchIntlFormatCall(node, context.scopes) ?? matchDateDefaultStringification(node);
+				const match = matchLocaleMethodCall(node) ?? matchIntlFormatCall(node) ?? matchDateDefaultStringification(node);
 				if (match) reportIfRenderPhase(match);
 			},
 			TemplateLiteral(node) {
@@ -33444,7 +32784,7 @@ const noLocaleFormatInRender = defineRule({
 				walkAst(helperNode.body ?? helperNode, (child) => {
 					if (isFunctionLike$1(child)) return false;
 					if (!isNodeOfType(child, "CallExpression")) return;
-					const match = matchLocaleMethodCall(child, context.scopes) ?? matchIntlFormatCall(child, context.scopes);
+					const match = matchLocaleMethodCall(child) ?? matchIntlFormatCall(child);
 					if (!match || reportedNodes.has(match.node)) return;
 					if (fileIsEmailTemplate) return;
 					if (!hasClientRenderEvidence(componentOrHookNode, fileHasUseClientDirective)) return;
@@ -33611,13 +32951,11 @@ const noManyBooleanProps = defineRule({
 		};
 		const checkComponent = (functionNode, param, body, componentName, reportNode) => {
 			if (!param) return;
-			const propsBinding = resolveFirstArgumentBinding(param);
-			if (!propsBinding) return;
 			if (!functionContainsReactRenderOutput(functionNode, context.scopes)) return;
-			if (isNodeOfType(propsBinding, "ObjectPattern")) {
+			if (isNodeOfType(param, "ObjectPattern")) {
 				const callbackUsedNames = collectCallbackUsedNames(body, param, context.scopes);
 				const booleanLikePropNames = [];
-				for (const property of propsBinding.properties ?? []) {
+				for (const property of param.properties ?? []) {
 					if (!isNodeOfType(property, "Property")) continue;
 					const keyName = isNodeOfType(property.key, "Identifier") ? property.key.name : null;
 					if (!keyName) continue;
@@ -33628,7 +32966,7 @@ const noManyBooleanProps = defineRule({
 				reportIfMany(booleanLikePropNames, componentName, reportNode);
 				return;
 			}
-			if (isNodeOfType(propsBinding, "Identifier")) reportIfMany([...collectBooleanLikePropsFromBody(body, propsBinding.name)], componentName, reportNode);
+			if (isNodeOfType(param, "Identifier")) reportIfMany([...collectBooleanLikePropsFromBody(body, param.name)], componentName, reportNode);
 		};
 		return {
 			FunctionDeclaration(node) {
@@ -33750,7 +33088,7 @@ const noMirrorPropEffect = defineRule({
 			if (mirrorBindings.length === 0) return;
 			for (const statement of componentBody.body ?? []) {
 				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
-				const effectCall = unwrapDiscardedExpression(statement);
+				const effectCall = statement.expression;
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
 				if (!isHookCall$2(effectCall, EFFECT_HOOK_NAMES$1)) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
@@ -33764,7 +33102,7 @@ const noMirrorPropEffect = defineRule({
 				const bodyStatements = getCallbackStatements(callback);
 				if (bodyStatements.length !== 1) continue;
 				const onlyStatement = bodyStatements[0];
-				const expression = unwrapDiscardedExpression(onlyStatement);
+				const expression = isNodeOfType(onlyStatement, "ExpressionStatement") ? onlyStatement.expression : onlyStatement;
 				if (!isNodeOfType(expression, "CallExpression")) continue;
 				if (!isNodeOfType(expression.callee, "Identifier")) continue;
 				if (!isSetterIdentifier(expression.callee.name)) continue;
@@ -36380,7 +35718,7 @@ const noPreventDefault = defineRule({
 		const isServerActionsFramework = hasCapability(context.settings, "server-actions");
 		const formMessage = isServerActionsFramework ? FORM_MESSAGE_SERVER_CAPABLE : FORM_MESSAGE_GENERIC;
 		return { JSXOpeningElement(node) {
-			const elementName = resolveJsxElementType(node);
+			const elementName = isNodeOfType(node.name, "JSXIdentifier") ? node.name.name : null;
 			if (!elementName) return;
 			const targetEventProps = PREVENT_DEFAULT_ELEMENTS.get(elementName);
 			if (!targetEventProps) return;
@@ -37270,85 +36608,28 @@ const noRedundantShouldComponentUpdate = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-ref-current-in-render.ts
-const REPEATED_ANCESTOR_TYPES = new Set([
-	"DoWhileStatement",
-	"ForInStatement",
-	"ForOfStatement",
-	"ForStatement",
-	"WhileStatement"
-]);
+const resolveReactRefSymbol = (memberExpression, scopes) => {
+	const receiver = isNodeOfType(memberExpression, "MemberExpression") ? stripParenExpression(memberExpression.object) : null;
+	if (!isNodeOfType(memberExpression, "MemberExpression") || memberExpression.computed || !isNodeOfType(memberExpression.property, "Identifier") || memberExpression.property.name !== "current" || !isNodeOfType(receiver, "Identifier")) return null;
+	const symbol = resolveConstIdentifierAlias(receiver, scopes);
+	if (!symbol?.initializer) return null;
+	const initializer = stripParenExpression(symbol.initializer);
+	if (!isNodeOfType(initializer, "CallExpression")) return null;
+	return isReactApiCall(initializer, "useRef", scopes, { allowGlobalReactNamespace: true }) ? symbol : null;
+};
 const isSameRefCurrentMember = (node, refSymbol, scopes) => {
-	if (!isNodeOfType(node, "MemberExpression") || getStaticPropertyName(node) !== "current") return false;
+	if (!isNodeOfType(node, "MemberExpression") || node.computed || !isNodeOfType(node.property, "Identifier") || node.property.name !== "current") return false;
 	const receiver = stripParenExpression(node.object);
 	return isNodeOfType(receiver, "Identifier") && resolveConstIdentifierAlias(receiver, scopes)?.id === refSymbol.id;
 };
-const isSameRefCurrentAlias = (node, refSymbol, scopes) => {
-	if (isSameRefCurrentMember(node, refSymbol, scopes)) return true;
-	if (!isNodeOfType(node, "Identifier")) return false;
-	const aliasSymbol = scopes.symbolFor(node);
-	return aliasSymbol?.kind === "const" && aliasSymbol.initializer !== null && isSameRefCurrentMember(stripParenExpression(aliasSymbol.initializer), refSymbol, scopes);
-};
-const isEmptySentinel = (node, scopes) => isNodeOfType(node, "Literal") && node.value === null || isNodeOfType(node, "Identifier") && node.name === "undefined" && scopes.isGlobalReference(node);
-const hasRepeatedExecutionAncestor = (node, stop) => {
-	let ancestor = node.parent;
-	while (ancestor && ancestor !== stop) {
-		if (isFunctionLike$1(ancestor) || REPEATED_ANCESTOR_TYPES.has(ancestor.type)) return true;
-		ancestor = ancestor.parent;
-	}
-	return ancestor !== stop;
-};
-const getBranchConstraints = (node, branchRoot) => {
-	const constraints = /* @__PURE__ */ new Map();
-	let descendant = node;
-	let ancestor = descendant.parent;
-	while (ancestor && descendant !== branchRoot) {
-		if (isNodeOfType(ancestor, "IfStatement")) {
-			if (ancestor.consequent === descendant) constraints.set(ancestor, true);
-			if (ancestor.alternate === descendant) constraints.set(ancestor, false);
-		}
-		descendant = ancestor;
-		ancestor = ancestor.parent;
-	}
-	return constraints;
-};
-const canExecuteTogether = (firstConstraints, secondConstraints) => {
-	for (const [statement, branch] of firstConstraints) {
-		const otherBranch = secondConstraints.get(statement);
-		if (otherBranch !== void 0 && otherBranch !== branch) return false;
-	}
-	return true;
-};
-const hasNoPriorCoExecutableWrite = (assignmentExpression, branchRoot, refSymbol, scopes) => {
-	const assignmentConstraints = getBranchConstraints(assignmentExpression, branchRoot);
-	const assignmentStart = getRangeStart(assignmentExpression);
-	let hasCoExecutableWrite = false;
-	walkAst(branchRoot, (child) => {
-		if (hasCoExecutableWrite) return false;
-		const childStart = getRangeStart(child);
-		if (child === assignmentExpression || !isNodeOfType(child, "AssignmentExpression") || assignmentStart === null || childStart === null || childStart >= assignmentStart || resolveReactRefSymbol(child.left, scopes)?.id !== refSymbol.id || hasRepeatedExecutionAncestor(child, branchRoot)) return;
-		if (canExecuteTogether(assignmentConstraints, getBranchConstraints(child, branchRoot))) {
-			hasCoExecutableWrite = true;
-			return false;
-		}
-	});
-	return !hasCoExecutableWrite;
-};
 const isDocumentedLazyInitialization = (assignmentExpression, refSymbol, scopes) => {
-	if (assignmentExpression.operator === "??=" || assignmentExpression.operator === "||=") return true;
-	if (assignmentExpression.operator !== "=") return false;
+	if (assignmentExpression.operator !== "=" || !isNodeOfType(assignmentExpression.right, "NewExpression")) return false;
 	let descendant = assignmentExpression;
 	let ancestor = descendant.parent;
 	while (ancestor) {
-		if (isNodeOfType(ancestor, "IfStatement") && isNodeOfType(ancestor.test, "BinaryExpression") && [
-			"===",
-			"==",
-			"!==",
-			"!="
-		].includes(ancestor.test.operator)) {
+		if (isNodeOfType(ancestor, "IfStatement") && ancestor.consequent === descendant && isNodeOfType(ancestor.test, "BinaryExpression") && (ancestor.test.operator === "===" || ancestor.test.operator === "==")) {
 			const { left, right } = ancestor.test;
-			const comparesEmptySentinel = isSameRefCurrentAlias(left, refSymbol, scopes) && isEmptySentinel(right, scopes) || isSameRefCurrentAlias(right, refSymbol, scopes) && isEmptySentinel(left, scopes);
-			const guardedBranch = ancestor.test.operator === "===" || ancestor.test.operator === "==" ? ancestor.consequent : ancestor.alternate;
-			if (comparesEmptySentinel && guardedBranch === descendant && guardedBranch && !hasRepeatedExecutionAncestor(assignmentExpression, guardedBranch) && hasNoPriorCoExecutableWrite(assignmentExpression, guardedBranch, refSymbol, scopes)) return true;
+			if (isSameRefCurrentMember(left, refSymbol, scopes) && isNodeOfType(right, "Literal") && right.value === null || isSameRefCurrentMember(right, refSymbol, scopes) && isNodeOfType(left, "Literal") && left.value === null) return true;
 		}
 		descendant = ancestor;
 		ancestor = descendant.parent;
@@ -37922,7 +37203,7 @@ const isNonSettlingSetterArgument = (setterCall, stateName) => {
 	return expressionReadsStateValue(argument, stateName);
 };
 const getUnconditionalSetterCall = (statement, setterNames) => {
-	const expression = unwrapDiscardedExpression(statement);
+	const expression = stripParenExpression(isNodeOfType(statement, "ExpressionStatement") ? statement.expression : statement);
 	if (!isNodeOfType(expression, "CallExpression")) return null;
 	if (!isNodeOfType(expression.callee, "Identifier")) return null;
 	if (!setterNames.has(expression.callee.name)) return null;
@@ -38271,7 +37552,7 @@ const noSelfUpdatingEffect = defineRule({
 			const setterNames = new Set(setterNameToStateName.keys());
 			for (const statement of functionBody.body ?? []) {
 				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
-				const effectCall = unwrapDiscardedExpression(statement);
+				const effectCall = statement.expression;
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
 				if (!isHookCall$2(effectCall, EFFECT_HOOK_NAMES$1)) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
@@ -38901,10 +38182,9 @@ const noStringFalseOnBooleanAttribute = defineRule({
 	recommendation: "Use the boolean form on boolean attributes: `disabled` / `disabled={true}` / `disabled={false}`, not `disabled=\"false\"`. A non-empty string is truthy, so `=\"false\"` actually turns the attribute ON.",
 	create: (context) => ({ JSXOpeningElement(node) {
 		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-		const elementName = resolveJsxElementType(node);
-		const firstCharacter = elementName.charCodeAt(0);
+		const firstCharacter = node.name.name.charCodeAt(0);
 		if (firstCharacter < 97 || firstCharacter > 122) return;
-		if (elementName.includes("-")) return;
+		if (node.name.name.includes("-")) return;
 		for (const attribute of node.attributes) {
 			if (!isNodeOfType(attribute, "JSXAttribute")) continue;
 			if (!isNodeOfType(attribute.name, "JSXIdentifier")) continue;
@@ -39292,7 +38572,8 @@ const noUncontrolledInput = defineRule({
 			const undefinedInitialStateNames = isNodeOfType(componentBody, "BlockStatement") ? collectUndefinedInitialStateNames(componentBody) : /* @__PURE__ */ new Set();
 			walkAst(componentBody, (child) => {
 				if (!isNodeOfType(child, "JSXOpeningElement")) return;
-				const tagName = resolveJsxElementType(child);
+				if (!isNodeOfType(child.name, "JSXIdentifier")) return;
+				const tagName = child.name.name;
 				if (!UNCONTROLLED_INPUT_TAGS.has(tagName)) return;
 				const attributes = child.attributes ?? [];
 				if (hasJsxSpreadAttribute(attributes)) return;
@@ -39353,7 +38634,7 @@ const noUndeferredThirdParty = defineRule({
 	severity: "warn",
 	recommendation: "Use `next/script` with `strategy=\"lazyOnload\"`, or add the `defer` attribute.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (resolveJsxElementType(node) !== "script") return;
+		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "script") return;
 		const attributes = node.attributes ?? [];
 		const srcAttribute = findJsxAttribute(attributes, "src");
 		if (!srcAttribute) return;
@@ -40568,7 +39849,7 @@ const noUnknownProperty = defineRule({
 				}
 				if (fileIsNonReactJsx) return;
 				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-				const elementType = resolveJsxElementType(node);
+				const elementType = node.name.name;
 				const firstCharacter = elementType.charCodeAt(0);
 				if (!(firstCharacter >= 97 && firstCharacter <= 122) || elementType === "fbt" || elementType === "fbs") return;
 				let isValidHtmlTag = isKnownDomTag(elementType);
@@ -40746,21 +40027,20 @@ const expressionContainsJsxOrCreateElement = (root) => {
 	});
 	return found;
 };
-const functionContainsJsxOrCreateElement = (functionNode, scopes) => expressionContainsJsxOrCreateElement(functionNode) || functionReturnsMatchingExpression(functionNode, scopes, expressionContainsJsxOrCreateElement);
 const isReactClassComponent = (classNode) => {
 	if (isEs6Component(classNode)) return true;
 	return expressionContainsJsxOrCreateElement(classNode);
 };
-const findEnclosingComponent = (node, scopes) => {
+const findEnclosingComponent = (node) => {
 	let walker = node.parent;
 	while (walker) {
 		if (isFunctionLike$1(walker)) {
 			const componentName = inferFunctionLikeName(walker);
-			if (componentName && isReactComponentName(componentName) && functionContainsJsxOrCreateElement(walker, scopes)) return {
+			if (componentName && isReactComponentName(componentName) && expressionContainsJsxOrCreateElement(walker)) return {
 				component: walker,
 				name: componentName
 			};
-			if (!componentName && functionContainsJsxOrCreateElement(walker, scopes) && walker.parent && isNodeOfType(walker.parent, "ExportDefaultDeclaration")) return {
+			if (!componentName && expressionContainsJsxOrCreateElement(walker) && walker.parent && isNodeOfType(walker.parent, "ExportDefaultDeclaration")) return {
 				component: walker,
 				name: null
 			};
@@ -40999,7 +40279,7 @@ const noUnstableNestedComponents = defineRule({
 				if (renderPropRegex.test(propInfo.propName)) return;
 				if (settings.allowAsProps) return;
 			}
-			const enclosing = findEnclosingComponent(candidateNode, context.scopes);
+			const enclosing = findEnclosingComponent(candidateNode);
 			if (!enclosing) return;
 			const gatedName = propInfo ? null : requiredInstantiationName;
 			queuedReports.push({
@@ -41010,7 +40290,7 @@ const noUnstableNestedComponents = defineRule({
 			});
 		};
 		const checkFunctionLike = (node) => {
-			if (!functionContainsJsxOrCreateElement(node, context.scopes)) return;
+			if (!expressionContainsJsxOrCreateElement(node)) return;
 			const inferredName = inferFunctionLikeName(node);
 			const propInfo = isComponentDeclaredInProp(node);
 			const isObjectCallback = isObjectCallbackCandidate(node);
@@ -42270,7 +41550,7 @@ const preactPreferOndblclick = defineRule({
 	recommendation: "Rename `onDoubleClick` to `onDblClick` because Preact core listens for the DOM `dblclick` event name and `onDoubleClick` never fires.",
 	create: (context) => ({ JSXOpeningElement(node) {
 		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-		const tagName = resolveJsxElementType(node);
+		const tagName = node.name.name;
 		if (tagName.length === 0 || tagName[0] !== tagName[0].toLowerCase()) return;
 		const onDoubleClickAttribute = findJsxAttribute(node.attributes, "onDoubleClick");
 		if (!onDoubleClickAttribute) return;
@@ -42290,7 +41570,7 @@ const COMPAT_EXEMPT_INPUT_TYPES = new Set([
 ]);
 const isTextLikeInput = (openingElement) => {
 	if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return false;
-	const tagName = resolveJsxElementType(openingElement);
+	const tagName = openingElement.name.name;
 	if (tagName === "textarea") return true;
 	if (tagName !== "input") return false;
 	const typeAttribute = findJsxAttribute(openingElement.attributes, "type");
@@ -42447,9 +41727,8 @@ const CROSS_CUTTING_STATE_BOOLEAN_NAMES = new Set([
 ]);
 const collectBooleanPropBindings = (param) => {
 	const bindings = /* @__PURE__ */ new Set();
-	const propsBinding = resolveFirstArgumentBinding(param);
-	if (!isNodeOfType(propsBinding, "ObjectPattern")) return bindings;
-	for (const property of propsBinding.properties ?? []) {
+	if (!param || !isNodeOfType(param, "ObjectPattern")) return bindings;
+	for (const property of param.properties ?? []) {
 		if (!isNodeOfType(property, "Property")) continue;
 		if (property.computed) continue;
 		if (!isNodeOfType(property.key, "Identifier")) continue;
@@ -42710,7 +41989,7 @@ const preferHtmlDialog = defineRule({
 			},
 			JSXOpeningElement(node) {
 				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-				const tagName = resolveJsxElementType(node);
+				const tagName = node.name.name;
 				if (tagName === "dialog") return;
 				if (tagName.length === 0 || tagName[0] !== tagName[0].toLowerCase()) return;
 				if (!HTML_TAGS.has(tagName)) return;
@@ -44257,13 +43536,13 @@ const resolveTanstackQueryHookName = (callExpression) => {
 	}
 	return null;
 };
-const resolveHookNameFromInitializer = (initializer, scopes) => {
+const resolveHookNameFromInitializer = (initializer) => {
 	if (isNodeOfType(initializer, "CallExpression")) return resolveTanstackQueryHookName(initializer);
 	if (!isNodeOfType(initializer, "Identifier")) return null;
-	const resolvedSymbol = resolveConstIdentifierAlias(initializer, scopes);
-	if (resolvedSymbol?.kind !== "const" || !resolvedSymbol.initializer) return null;
-	if (!isNodeOfType(resolvedSymbol.initializer, "CallExpression")) return null;
-	return resolveTanstackQueryHookName(resolvedSymbol.initializer);
+	const binding = findVariableInitializer(initializer, initializer.name);
+	if (!binding?.initializer || !isConstDeclaredBinding(binding)) return null;
+	if (!isNodeOfType(binding.initializer, "CallExpression")) return null;
+	return resolveTanstackQueryHookName(binding.initializer);
 };
 const queryNoRestDestructuring = defineRule({
 	id: "query-no-rest-destructuring",
@@ -44276,7 +43555,7 @@ const queryNoRestDestructuring = defineRule({
 		if (!isNodeOfType(node.id, "ObjectPattern")) return;
 		if (!node.init) return;
 		if (!node.id.properties?.some((property) => isNodeOfType(property, "RestElement"))) return;
-		const hookName = resolveHookNameFromInitializer(node.init, context.scopes);
+		const hookName = resolveHookNameFromInitializer(node.init);
 		if (!hookName) return;
 		context.report({
 			node: node.id,
@@ -44747,7 +44026,7 @@ const renderingAnimateSvgWrapper = defineRule({
 	severity: "warn",
 	recommendation: "Wrap the SVG in a motion element so animation props apply to a stable wrapper instead of the SVG node itself.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (resolveJsxElementType(node) !== "svg") return;
+		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "svg") return;
 		if (node.attributes?.some((attribute) => isNodeOfType(attribute, "JSXAttribute") && isNodeOfType(attribute.name, "JSXIdentifier") && MOTION_ANIMATE_PROPS.has(attribute.name.name))) context.report({
 			node,
 			message: "This is slow to render because you animate <svg> directly, so wrap it in a <div> or <motion.div> & animate that instead"
@@ -45631,7 +44910,7 @@ const DEFERRABLE_HOOK_NAMES = new Set([
 	"useParams",
 	"usePathname"
 ]);
-const findHookCallBindings = (componentBody, scopes) => {
+const findHookCallBindings = (componentBody) => {
 	const bindings = [];
 	if (!isNodeOfType(componentBody, "BlockStatement")) return bindings;
 	for (const statement of componentBody.body ?? []) {
@@ -45642,10 +44921,8 @@ const findHookCallBindings = (componentBody, scopes) => {
 			const callee = declarator.init.callee;
 			if (!isNodeOfType(callee, "Identifier")) continue;
 			if (!DEFERRABLE_HOOK_NAMES.has(callee.name)) continue;
-			const valueSymbol = scopes.symbolFor(declarator.id);
-			if (!valueSymbol) continue;
 			bindings.push({
-				valueSymbol,
+				valueName: declarator.id.name,
 				hookName: callee.name,
 				declarator
 			});
@@ -45653,49 +44930,6 @@ const findHookCallBindings = (componentBody, scopes) => {
 	}
 	return bindings;
 };
-const collectExactAliasSymbols = (componentBody, sourceSymbol, scopes) => {
-	const symbols = [sourceSymbol];
-	const symbolIds = new Set([sourceSymbol.id]);
-	const aliasSourceIdentifiers = /* @__PURE__ */ new Set();
-	if (!isNodeOfType(componentBody, "BlockStatement")) return {
-		symbols,
-		aliasSourceIdentifiers
-	};
-	let didFindAlias = true;
-	while (didFindAlias) {
-		didFindAlias = false;
-		for (const statement of componentBody.body ?? []) {
-			if (!isNodeOfType(statement, "VariableDeclaration") || statement.kind !== "const") continue;
-			for (const declarator of statement.declarations ?? []) {
-				let aliasIdentifier = null;
-				let sourceIdentifier = null;
-				const initializer = declarator.init ? stripParenExpression(declarator.init) : null;
-				const arrayBinding = isNodeOfType(declarator.id, "ArrayPattern") ? declarator.id.elements[0] : null;
-				const arrayValueNode = isNodeOfType(initializer, "ArrayExpression") ? initializer.elements[0] : null;
-				const arrayValue = arrayValueNode && !isNodeOfType(arrayValueNode, "SpreadElement") ? stripParenExpression(arrayValueNode) : null;
-				if (isNodeOfType(declarator.id, "Identifier") && isNodeOfType(initializer, "Identifier")) {
-					aliasIdentifier = declarator.id;
-					sourceIdentifier = initializer;
-				} else if (isNodeOfType(declarator.id, "ArrayPattern") && declarator.id.elements.length === 1 && isNodeOfType(arrayBinding, "Identifier") && isNodeOfType(initializer, "ArrayExpression") && initializer.elements.length === 1 && isNodeOfType(arrayValue, "Identifier")) {
-					aliasIdentifier = arrayBinding;
-					sourceIdentifier = arrayValue;
-				}
-				if (!aliasIdentifier || !sourceIdentifier) continue;
-				const referencedSymbol = scopes.symbolFor(sourceIdentifier);
-				const aliasSymbol = scopes.symbolFor(aliasIdentifier);
-				if (!referencedSymbol || !symbolIds.has(referencedSymbol.id) || !aliasSymbol || aliasSymbol.kind !== "const" || symbolIds.has(aliasSymbol.id)) continue;
-				symbolIds.add(aliasSymbol.id);
-				symbols.push(aliasSymbol);
-				aliasSourceIdentifiers.add(sourceIdentifier);
-				didFindAlias = true;
-			}
-		}
-	}
-	return {
-		symbols,
-		aliasSourceIdentifiers
-	};
-};
 const rerenderDeferReadsHook = defineRule({
 	id: "rerender-defer-reads-hook",
 	title: "URL hook value only read in handlers",
@@ -45706,13 +44940,15 @@ const rerenderDeferReadsHook = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const bindings = findHookCallBindings(componentBody, context.scopes);
+			const bindings = findHookCallBindings(componentBody);
 			if (bindings.length === 0) return;
 			const handlerBindingNames = collectHandlerBindingNames(componentBody);
 			for (const binding of bindings) {
-				const { symbols, aliasSourceIdentifiers } = collectExactAliasSymbols(componentBody, binding.valueSymbol, context.scopes);
 				const referenceLocations = [];
-				for (const symbol of symbols) for (const reference of symbol.references) if (!aliasSourceIdentifiers.has(reference.identifier)) referenceLocations.push(reference.identifier);
+				walkAst(componentBody, (child) => {
+					if (isNodeOfType(binding.declarator, "VariableDeclarator") && child === binding.declarator.id) return;
+					if (isNodeOfType(child, "Identifier") && child.name === binding.valueName) referenceLocations.push(child);
+				});
 				if (referenceLocations.length === 0) continue;
 				if (!referenceLocations.every((ref) => isInsideEventHandler(ref, handlerBindingNames))) continue;
 				context.report({
@@ -46083,10 +45319,14 @@ const rerenderLazyStateInit = defineRule({
 //#endregion
 //#region src/plugin/rules/performance/rerender-memo-before-early-return.ts
 const isJsxExpression = (node) => Boolean(node && isJsxElementOrFragment(stripParenExpression(node)));
-const callbackReturnsJsx = (callback, scopes) => {
+const callbackReturnsJsx = (callback) => {
 	if (!callback) return false;
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
-	return functionReturnsMatchingExpression(callback, scopes, isJsxExpression);
+	const body = callback.body;
+	if (isJsxExpression(body)) return true;
+	if (!isNodeOfType(body, "BlockStatement")) return false;
+	for (const stmt of body.body ?? []) if (isNodeOfType(stmt, "ReturnStatement") && isJsxExpression(stmt.argument)) return true;
+	return false;
 };
 const returnArgumentUsesAnyName = (returnStatement, names) => {
 	if (!isNodeOfType(returnStatement, "ReturnStatement") || !returnStatement.argument) return false;
@@ -46164,7 +45404,7 @@ const rerenderMemoBeforeEarlyReturn = defineRule({
 					if (!isNodeOfType(stmt, "VariableDeclaration")) continue;
 					for (const declarator of stmt.declarations ?? []) {
 						const init = declarator.init;
-						if (isNodeOfType(init, "CallExpression") && isHookCall$2(init, "useMemo") && callbackReturnsJsx(init.arguments?.[0], context.scopes)) {
+						if (isNodeOfType(init, "CallExpression") && isHookCall$2(init, "useMemo") && callbackReturnsJsx(init.arguments?.[0])) {
 							memoNode = declarator;
 							callbackGuardTests = collectLeadingCallbackGuardTests(init.arguments?.[0]);
 							if (isNodeOfType(declarator.id, "Identifier")) memoConsumerNames.add(declarator.id.name);
@@ -46230,11 +45470,8 @@ const collectFromObjectPattern = (pattern, bindings) => {
 const collectDefaultedEmptyBindings = (functionNode) => {
 	const bindings = /* @__PURE__ */ new Map();
 	const params = functionNode.params ?? [];
-	for (const [parameterIndex, param] of params.entries()) {
-		const parameterBinding = parameterIndex === 0 ? resolveFirstArgumentBinding(param) : param;
-		if (parameterBinding) collectFromObjectPattern(parameterBinding, bindings);
-	}
-	const propsParam = resolveFirstArgumentBinding(params[0]);
+	for (const param of params) collectFromObjectPattern(param, bindings);
+	const propsParam = params[0];
 	const body = functionNode.body;
 	if (!propsParam || !isNodeOfType(propsParam, "Identifier") || !body) return bindings;
 	if (!isNodeOfType(body, "BlockStatement")) return bindings;
@@ -46740,8 +45977,8 @@ const rnAnimationReactionAsDerived = defineRule({
 			if (statements.length !== 1) return;
 			const onlyStatement = statements[0];
 			if (!isNodeOfType(onlyStatement, "ExpressionStatement")) return;
-			singleAssignment = unwrapDiscardedExpression(onlyStatement);
-		} else if (body) singleAssignment = unwrapDiscardedExpression(body);
+			singleAssignment = onlyStatement.expression;
+		} else if (body) singleAssignment = body;
 		if (!singleAssignment) return;
 		const isValueAssignment = isNodeOfType(singleAssignment, "AssignmentExpression") && isNodeOfType(singleAssignment.left, "MemberExpression") && isNodeOfType(singleAssignment.left.object, "Identifier") && isNodeOfType(singleAssignment.left.property, "Identifier") && singleAssignment.left.property.name === "value";
 		const isSetCall = isNodeOfType(singleAssignment, "CallExpression") && isNodeOfType(singleAssignment.callee, "MemberExpression") && isNodeOfType(singleAssignment.callee.property, "Identifier") && singleAssignment.callee.property.name === "set" && (singleAssignment.arguments?.length ?? 0) === 1;
@@ -53661,8 +52898,7 @@ const serverCacheWithObjectLiteral = defineRule({
 				if (!isNodeOfType(node.callee, "Identifier")) return;
 				if (!cachedFunctionNames.has(node.callee.name)) return;
 				const firstArg = node.arguments?.[0];
-				if (!firstArg || isNodeOfType(firstArg, "SpreadElement")) return;
-				if (!isNodeOfType(unwrapObjectIntegrityExpression(firstArg, context.scopes, OBJECT_FREEZE_OR_SEAL_METHOD_NAMES), "ObjectExpression")) return;
+				if (!isNodeOfType(firstArg, "ObjectExpression")) return;
 				context.report({
 					node,
 					message: `Passing a new object to React.cache() each render misses the cache, so it refetches every request.`
@@ -54349,6 +53585,10 @@ const isInvalidStyleExpression = (expression) => {
 	}
 	return false;
 };
+const getJsxOpeningElementName = (node) => {
+	if (isNodeOfType(node.name, "JSXIdentifier")) return node.name.name;
+	return null;
+};
 const stylePropObject = defineRule({
 	id: "style-prop-object",
 	title: "Style prop is not an object",
@@ -54360,8 +53600,7 @@ const stylePropObject = defineRule({
 		const allowSet = new Set(allow);
 		return {
 			JSXOpeningElement(node) {
-				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-				const elementName = resolveJsxElementType(node);
+				const elementName = getJsxOpeningElementName(node);
 				if (elementName && allowSet.has(elementName)) return;
 				if (elementName) {
 					const firstCharCode = elementName.charCodeAt(0);
@@ -55066,7 +54305,7 @@ const tanstackStartNoAnchorElement = defineRule({
 	create: (context) => {
 		if (!isInProjectDirectory(context, "routes")) return {};
 		return { JSXOpeningElement(node) {
-			if (resolveJsxElementType(node) !== "a") return;
+			if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a") return;
 			const attributes = node.attributes ?? [];
 			const hrefAttribute = findJsxAttribute(attributes, "href");
 			if (!hrefAttribute?.value) return;
@@ -55687,7 +54926,8 @@ const voidDomElementsNoChildren = defineRule({
 	create: (context) => ({
 		JSXElement(node) {
 			const openingElement = node.openingElement;
-			const tagName = resolveJsxElementType(openingElement);
+			if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return;
+			const tagName = openingElement.name.name;
 			if (!VOID_DOM_ELEMENTS.has(tagName)) return;
 			const hasChildrenContent = node.children.some(isMeaningfulJsxChild);
 			const hasChildrenLikeProp = findChildrenLikePropName(openingElement.attributes);