oxlint-plugin-react-doctor 0.7.6-dev.17418 → 0.7.6-dev.1f14fa1

package/dist/index.js

@@ -1180,8 +1180,8 @@ const stripParenExpression = (node) => {
 	return current;
 };
 //#endregion
-//#region src/plugin/utils/get-root-identifier-name.ts
-const getRootIdentifierName = (node, options) => {
+//#region src/plugin/utils/get-root-identifier.ts
+const getRootIdentifier$1 = (node, options) => {
 	if (!node) return null;
 	const followCallChains = options?.followCallChains === true;
 	let cursor = node;
@@ -1192,16 +1192,18 @@ const getRootIdentifierName = (node, options) => {
 			continue;
 		}
 		if (followCallChains && isNodeOfType(cursor, "CallExpression")) {
-			const callee = cursor.callee;
-			if (!isNodeOfType(callee, "MemberExpression")) return null;
-			cursor = callee.object;
+			if (!isNodeOfType(cursor.callee, "MemberExpression")) return null;
+			cursor = cursor.callee.object;
 			continue;
 		}
 		break;
 	}
-	return isNodeOfType(cursor, "Identifier") ? cursor.name : null;
+	return isNodeOfType(cursor, "Identifier") ? cursor : 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",
@@ -1518,6 +1520,37 @@ 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();
@@ -1530,14 +1563,8 @@ 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 = flattenJsxName$2(openingElement.name);
+	const baseName = resolveJsxElementType(openingElement);
 	if (a11ySettings.polymorphicPropName) {
 		const polymorphicAttribute = hasJsxPropIgnoreCase(openingElement.attributes, a11ySettings.polymorphicPropName);
 		if (polymorphicAttribute) {
@@ -2372,8 +2399,9 @@ const anchorIsValid = defineRule({
 		const isTestlikeFile = isTestlikeFilename(context.filename);
 		return { JSXOpeningElement(node) {
 			if (isTestlikeFile) return;
-			if (!fileHasJsxA11ySettings && (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a")) return;
-			if (getElementType(node, context.settings) !== "a") return;
+			const tag = getElementType(node, context.settings);
+			if (!fileHasJsxA11ySettings && tag !== "a") return;
+			if (tag !== "a") return;
 			let hrefAttribute;
 			for (const attributeName of settings.hrefAttributeNames) {
 				hrefAttribute = hasJsxPropIgnoreCase(node.attributes, attributeName);
@@ -5728,7 +5756,7 @@ const buttonHasType = defineRule({
 		return {
 			JSXOpeningElement(node) {
 				if (isTestlikeFile) return;
-				if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "button") return;
+				if (resolveJsxElementType(node) !== "button") return;
 				const typeAttr = hasJsxPropIgnoreCase(node.attributes, "type");
 				if (!typeAttr) {
 					if (hasJsxSpreadAttribute$1(node.attributes)) {
@@ -5918,7 +5946,7 @@ const checkedRequiresOnchangeOrReadonly = defineRule({
 		};
 		return {
 			JSXOpeningElement(node) {
-				if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "input") return;
+				if (resolveJsxElementType(node) !== "input") return;
 				reportFromPresence(collectFromJsxAttributes(node.attributes));
 			},
 			CallExpression(node) {
@@ -5995,7 +6023,7 @@ const isPureEventBlockerHandler = (attribute) => {
 //#endregion
 //#region src/plugin/utils/resolve-const-identifier-alias.ts
 const resolveConstIdentifierAlias = (identifier, scopes) => {
-	if (!isNodeOfType(identifier, "Identifier")) return null;
+	if (!isNodeOfType(identifier, "Identifier") && !isNodeOfType(identifier, "JSXIdentifier")) return null;
 	const visitedSymbolIds = /* @__PURE__ */ new Set();
 	let symbol = scopes.symbolFor(identifier);
 	while (symbol?.kind === "const") {
@@ -6270,6 +6298,131 @@ 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+/;
@@ -6291,26 +6444,39 @@ 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) => ({ 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").`
-		});
-	} })
+	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").`
+				});
+			}
+		};
+	}
 });
 //#endregion
 //#region src/plugin/rules/client/client-passive-event-listeners.ts
@@ -7146,12 +7312,17 @@ 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 SERIALIZER_CALL_PROVENANCE_PATTERN.test(declaration.initializer);
+	if (declaration !== null) return isDeclarationStable(identifier, declaration, sinkIndex, fileContent) && 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()) => {
@@ -7163,7 +7334,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) {
+		if (declaration && isDeclarationStable(identifier, declaration, sinkIndex, fileContent)) {
 			const nextVisitedIdentifiers = new Set(visitedIdentifiers);
 			nextVisitedIdentifiers.add(identifier);
 			return isExplicitlyTrustedHtmlValue(declaration.initializer, fileContent, declaration.initializerStartIndex, nextVisitedIdentifiers);
@@ -7230,6 +7401,16 @@ 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;
@@ -7240,8 +7421,11 @@ 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 (isExplicitlyTrustedHtmlValue(declaration.initializer, fileContent, declaration.initializerStartIndex)) return false;
-		return isHtmlTainted(declaration.initializer, fileContent, declaration.initializerStartIndex, visitedIdentifiers, visitedCallSites) || HTML_TAINT_PATTERN.test(trimmedExpression);
+		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 (parameterSource !== null && parameterSource.functionName.length > 0) {
 		const callPattern = new RegExp(`\\b${escapeRegExp(parameterSource.functionName)}\\s*\\(`, "g");
@@ -7323,12 +7507,13 @@ const dangerousHtmlSink = defineRule({
 			if (isTrustedHighlighterValue(valueExpression, file.content, sinkIndex)) continue;
 			if (valueIdentifier !== void 0) {
 				const escapedIdentifier = escapeRegExp(valueIdentifier);
-				const visibleInitializer = findVisibleIdentifierDeclaration(valueIdentifier, sinkIndex, file.content)?.initializer;
+				const visibleDeclaration = findVisibleIdentifierDeclaration(valueIdentifier, sinkIndex, file.content);
+				const visibleInitializer = visibleDeclaration?.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) : SERIALIZER_CALL_PROVENANCE_PATTERN.test(visibleInitializer)) continue;
+					if (visibleInitializer === void 0 ? fromSerializer.test(file.content) : visibleDeclaration !== null && isDeclarationStable(valueIdentifier, visibleDeclaration, sinkIndex, 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) : SANITIZED_ASSIGNMENT_PATTERN.test(`=${visibleInitializer}`)) continue;
+					if (visibleInitializer === void 0 ? fromSanitizer.test(file.content) : visibleDeclaration !== null && isDeclarationStable(valueIdentifier, visibleDeclaration, sinkIndex, 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;
@@ -7414,7 +7599,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 openingElement.name.name;
+	if (isNodeOfType(openingElement.name, "JSXIdentifier")) return resolveJsxElementType(openingElement);
 	if (isNodeOfType(openingElement.name, "JSXMemberExpression")) {
 		let cursor = openingElement.name;
 		while (isNodeOfType(cursor, "JSXMemberExpression")) cursor = cursor.property;
@@ -7666,7 +7851,7 @@ const dialogHasAccessibleName = defineRule({
 		if (isTestlikeFilename(context.filename)) return {};
 		return { JSXOpeningElement(node) {
 			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-			const tagName = node.name.name;
+			const tagName = resolveJsxElementType(node);
 			if (tagName[0] !== tagName[0]?.toLowerCase()) return;
 			const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
 			const roleValue = roleAttribute ? getJsxPropStringValue(roleAttribute) : null;
@@ -11898,7 +12083,7 @@ const forbidDomProps = defineRule({
 		return { JSXOpeningElement(node) {
 			if (forbidMap.size === 0) return;
 			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-			const elementName = node.name.name;
+			const elementName = resolveJsxElementType(node);
 			if (isReactComponentName(elementName)) return;
 			for (const attribute of node.attributes) {
 				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
@@ -11976,7 +12161,7 @@ const forbidElements = defineRule({
 		return {
 			JSXOpeningElement(node) {
 				if (forbidMap.size === 0) return;
-				const fullName = flattenJsxName$1(node.name);
+				const fullName = resolveJsxElementType(node);
 				if (!fullName || !forbidMap.has(fullName)) return;
 				context.report({
 					node: node.name,
@@ -12338,8 +12523,7 @@ const buildMessage$22 = (childTagName) => `Your users get reshuffled HTML becaus
 const isParagraphElement = (candidate) => {
 	if (!isNodeOfType(candidate, "JSXElement")) return false;
 	const opening = candidate.openingElement;
-	if (!isNodeOfType(opening.name, "JSXIdentifier")) return false;
-	return opening.name.name === "p";
+	return resolveJsxElementType(opening) === "p";
 };
 const findEnclosingParagraph = (openingElement) => {
 	const owningElement = openingElement.parent;
@@ -12360,8 +12544,7 @@ const htmlNoInvalidParagraphChild = defineRule({
 	severity: "warn",
 	recommendation: "Swap the `<p>` for a `<div>`, or move the child outside the paragraph.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-		const childTagName = node.name.name;
+		const childTagName = resolveJsxElementType(node);
 		if (!BLOCK_LEVEL_ELEMENTS.has(childTagName)) return;
 		if (!findEnclosingParagraph(node)) return;
 		context.report({
@@ -12392,7 +12575,7 @@ const getHostTagName = (jsxElement) => {
 	if (!isNodeOfType(jsxElement, "JSXElement")) return null;
 	const opening = jsxElement.openingElement;
 	if (!isNodeOfType(opening.name, "JSXIdentifier")) return null;
-	const tagName = opening.name.name;
+	const tagName = resolveJsxElementType(opening);
 	if (tagName.length === 0 || tagName[0] !== tagName[0].toLowerCase()) return null;
 	return tagName;
 };
@@ -12422,7 +12605,7 @@ const findClosestHostAncestor = (jsxElement) => {
 		if (isNodeOfType(ancestor, "JSXElement")) {
 			const opening = ancestor.openingElement;
 			if (isNodeOfType(opening.name, "JSXIdentifier")) {
-				const ancestorTag = opening.name.name;
+				const ancestorTag = resolveJsxElementType(opening);
 				if (ancestorTag.length === 0) {
 					previous = ancestor;
 					ancestor = ancestor.parent ?? null;
@@ -12504,8 +12687,7 @@ 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;
-	if (!isNodeOfType(opening.name, "JSXIdentifier")) return false;
-	return opening.name.name === tagName;
+	return resolveJsxElementType(opening) === tagName;
 };
 const findEnclosingSameTag = (openingElement, tagName) => {
 	const owningElement = openingElement.parent;
@@ -12526,8 +12708,7 @@ 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) {
-		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-		const tagName = node.name.name;
+		const tagName = resolveJsxElementType(node);
 		if (tagName !== "a" && tagName !== "button") return;
 		if (!findEnclosingSameTag(node, tagName)) return;
 		context.report({
@@ -12642,7 +12823,7 @@ const iframeMissingSandbox = defineRule({
 	matchByOccurrence: true,
 	create: skipNonProductionFiles((context) => ({
 		JSXOpeningElement(node) {
-			if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "iframe") return;
+			if (resolveJsxElementType(node) !== "iframe") return;
 			const sandboxAttr = hasJsxPropIgnoreCase(node.attributes, "sandbox");
 			if (!sandboxAttr) {
 				const hasExplicitSrc = Boolean(hasJsxPropIgnoreCase(node.attributes, "src"));
@@ -13634,6 +13815,28 @@ 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",
@@ -13818,9 +14021,19 @@ 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) => {
-	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 assignment = getStyleAssignment(styleWriteStatement);
+	if (!assignment || !isNodeOfType(assignment.left, "MemberExpression") || !isNodeOfType(assignment.left.object, "MemberExpression")) return false;
+	const elementExpression = assignment.left.object.object;
 	const creationRoot = resolveDetachedCreationRoot(elementExpression, 0);
 	if (!creationRoot) return false;
 	return !hasAttachmentBefore(creationRoot.scopeOwner, creationRoot.rootName, getNodeStart$1(styleWriteStatement));
@@ -13832,15 +14045,17 @@ 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 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);
+		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);
+		};
 		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 (!isStyleAssignment(statements[statementIndex]) || !isStyleAssignment(statements[statementIndex - 1])) continue;
+				if (getStyleAssignment(statements[statementIndex]) === null || getStyleAssignment(statements[statementIndex - 1]) === null) continue;
 				if (!writesLayoutAffectingProperty(statements[statementIndex]) && !writesLayoutAffectingProperty(statements[statementIndex - 1])) continue;
 				layoutReads ??= scanPerIterationLayoutReads(perIterationBody);
 				if (!layoutReads.hasUsedLayoutRead || layoutReads.hasDeliberateForcedReflow) return;
@@ -14536,6 +14751,18 @@ 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;
@@ -14546,7 +14773,7 @@ const referencesParameter = (expression, parameterName) => {
 const isSingleFieldEqualityPredicate = (node) => {
 	const callback = node.arguments?.[0];
 	if (!isInlineFunctionExpression(callback)) return false;
-	const firstParameter = callback.params?.[0];
+	const firstParameter = resolveFirstArgumentBinding(callback.params?.[0]);
 	if (!firstParameter || !isNodeOfType(firstParameter, "Identifier")) return false;
 	let predicate = null;
 	const body = callback.body;
@@ -15238,9 +15465,21 @@ const isSmallFixedListMember = (receiver) => {
 };
 const getResolvedInitializer = (receiver) => {
 	if (!isNodeOfType(receiver, "Identifier")) return null;
-	const initializer = findVariableInitializer(receiver, receiver.name)?.initializer ?? null;
-	if (initializer && isNodeOfType(initializer, "Identifier")) return findVariableInitializer(initializer, initializer.name)?.initializer ?? initializer;
-	return initializer;
+	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 isSplitCall = (expression) => {
 	if (!expression) return false;
@@ -15406,8 +15645,8 @@ const isBoundedConstantCollection = (collection) => {
 	if (isScreamingSnakeCaseConstantReceiver(stripped)) return true;
 	if (isSmallInlineLiteralArray(stripped)) return true;
 	if (isNodeOfType(stripped, "Identifier")) {
-		const initializer = getResolvedInitializer(stripped);
-		if (initializer && isSmallInlineLiteralArray(initializer)) return true;
+		const resolved = getResolvedInitializer(stripped);
+		if (resolved && !resolved.isDefault && isSmallInlineLiteralArray(resolved.initializer)) return true;
 	}
 	return false;
 };
@@ -15459,8 +15698,8 @@ const jsSetMapLookups = defineRule({
 			if (isIndexedArrayElementWithStringArgument(receiver, node.arguments?.[0])) return;
 			const resolvedInitializer = getResolvedInitializer(receiver);
 			if (resolvedInitializer) {
-				if (isLikelyStringReceiver(resolvedInitializer)) return;
-				if (isSmallInlineLiteralArray(resolvedInitializer)) return;
+				if (isLikelyStringReceiver(resolvedInitializer.initializer)) return;
+				if (!resolvedInitializer.isDefault && isSmallInlineLiteralArray(resolvedInitializer.initializer)) return;
 			}
 			if (isStringElementOfSplitIteration(receiver)) return;
 			if (isReceiverDeclaredInNearestLoop(receiver, node)) return;
@@ -15873,14 +16112,21 @@ const jsxFilenameExtension = defineRule({
 });
 //#endregion
 //#region src/plugin/utils/is-jsx-fragment-element.ts
-const isJsxFragmentElement = (node) => {
+const isJsxFragmentElement = (node, scopes) => {
 	if (!isNodeOfType(node, "JSXOpeningElement")) return false;
 	const elementName = node.name;
-	if (isNodeOfType(elementName, "JSXIdentifier")) return elementName.name === "Fragment";
+	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, "JSXMemberExpression")) {
 		if (!isNodeOfType(elementName.object, "JSXIdentifier")) return false;
-		if (elementName.object.name !== "React") return false;
-		return elementName.property.name === "Fragment";
+		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);
 	}
 	return false;
 };
@@ -15906,7 +16152,7 @@ const jsxFragments = defineRule({
 				if (mode !== "syntax") return;
 				if (!node.closingElement) return;
 				const openingElement = node.openingElement;
-				if (!isJsxFragmentElement(openingElement)) return;
+				if (!isJsxFragmentElement(openingElement, context.scopes)) return;
 				if (openingElement.attributes.length > 0) return;
 				context.report({
 					node: openingElement,
@@ -18587,10 +18833,6 @@ 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];
@@ -18610,7 +18852,8 @@ const jsxNoScriptUrl = defineRule({
 	create: (context) => {
 		const options = resolveSettings$29(context.settings);
 		return { JSXOpeningElement(node) {
-			const elementName = getElementName(node);
+			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+			const elementName = resolveJsxElementType(node);
 			if (!elementName) return;
 			for (const attribute of node.attributes) {
 				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
@@ -18797,11 +19040,6 @@ 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",
@@ -18821,7 +19059,8 @@ const jsxNoTargetBlank = defineRule({
 			return settings.formComponents.has(tagName);
 		};
 		return { JSXOpeningElement(node) {
-			const tagName = getOpeningElementName(node);
+			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+			const tagName = resolveJsxElementType(node);
 			if (!tagName) return;
 			if (!isLink(tagName) && !isForm(tagName)) return;
 			const linkAttributeNames = settings.linkComponents.get(tagName) ?? ["href"];
@@ -19054,7 +19293,7 @@ const jsxNoUselessFragment = defineRule({
 		return {
 			JSXElement(node) {
 				const openingElement = node.openingElement;
-				if (!isJsxFragmentElement(openingElement)) return;
+				if (!isJsxFragmentElement(openingElement, context.scopes)) return;
 				if (hasJsxKeyAttribute(openingElement)) return;
 				if (checkChildren(node, openingElement, node.children)) return;
 				if (isChildOfHtmlElement(node)) context.report({
@@ -20296,11 +20535,24 @@ 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/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"));
+//#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;
+};
 //#endregion
 //#region src/plugin/rules/nextjs/nextjs-async-client-component.ts
 const nextjsAsyncClientComponent = defineRule({
@@ -20326,10 +20578,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.`
@@ -20631,7 +20883,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 (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a") return;
+		if (resolveJsxElementType(node) !== "a") return;
 		const attributes = node.attributes ?? [];
 		const downloadAttribute = findJsxAttribute(attributes, "download");
 		if (downloadAttribute) {
@@ -20827,7 +21079,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 (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "link") return;
+		if (resolveJsxElementType(node) !== "link") return;
 		const attributes = node.attributes ?? [];
 		const relAttribute = findJsxAttribute(attributes, "rel");
 		if (!relAttribute?.value) return;
@@ -20935,7 +21187,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 (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "link") return;
+		if (resolveJsxElementType(node) !== "link") return;
 		const attributes = node.attributes ?? [];
 		const hrefAttribute = findJsxAttribute(attributes, "href");
 		if (!hrefAttribute?.value) return;
@@ -21110,7 +21362,7 @@ const nextjsNoImgElement = defineRule({
 	create: (context) => {
 		if (isGeneratedImageRenderContext(context)) return {};
 		return { JSXOpeningElement(node) {
-			if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "img") return;
+			if (resolveJsxElementType(node) !== "img") return;
 			if (isGeneratedImageRenderContext(context, node)) return;
 			const programRoot = findProgramRoot(node);
 			if (programRoot && hasEmailTemplateImport(programRoot)) return;
@@ -21157,8 +21409,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) {
-		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-		if (node.name.name !== "script" && node.name.name !== "Script") return;
+		const elementName = resolveJsxElementType(node);
+		if (elementName !== "script" && elementName !== "Script") return;
 		const srcAttribute = findJsxAttribute(node.attributes ?? [], "src");
 		if (!srcAttribute?.value) return;
 		const srcValue = isNodeOfType(srcAttribute.value, "Literal") ? srcAttribute.value.value : null;
@@ -22966,10 +23218,15 @@ 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;
-	const bindingParent = def.name.parent;
-	return isFunctionLike$1(bindingParent);
+	return isWholePropsParameterBinding(def.name);
 }));
 const isIdentifierOrMemberExpression = (node) => isNodeOfType(node, "Identifier") || isNodeOfType(node, "MemberExpression");
 const isPropAlias = (analysis, ref) => {
@@ -25966,6 +26223,56 @@ 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",
@@ -25985,12 +26292,13 @@ 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 (node.type === "JSXElement" || node.type === "JSXFragment" || isReactApiCall(node, "createElement", scopes, REACT_CREATE_ELEMENT_OPTIONS)) {
+		if (isRenderOutputExpression(node, scopes)) {
 			hasRenderOutput = true;
 			return false;
 		}
@@ -26001,7 +26309,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);
+	const hasRenderOutput = containsRenderOutput$1(functionNode, scopes) || functionReturnsMatchingExpression(functionNode, scopes, (expression) => isRenderOutputExpression(expression, scopes));
 	renderOutputCache.set(functionNode, {
 		scopes,
 		hasRenderOutput
@@ -26009,6 +26317,9 @@ 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
@@ -28466,7 +28777,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 (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "meta") return;
+		if (resolveJsxElementType(node) !== "meta") return;
 		const nameAttr = findJsxAttribute(node.attributes ?? [], "name");
 		if (!nameAttr?.value) return;
 		if ((isNodeOfType(nameAttr.value, "Literal") ? nameAttr.value.value : null) !== "viewport") return;
@@ -28856,7 +29167,7 @@ const findTopLevelEffectCalls = (componentBody) => {
 	if (!isNodeOfType(componentBody, "BlockStatement")) return effectCalls;
 	for (const statement of componentBody.body ?? []) {
 		if (!isNodeOfType(statement, "ExpressionStatement")) continue;
-		const expression = statement.expression;
+		const expression = unwrapDiscardedExpression(statement);
 		if (!isNodeOfType(expression, "CallExpression")) continue;
 		if (!isHookCall$2(expression, EFFECT_HOOK_NAMES$1)) continue;
 		effectCalls.push(expression);
@@ -31638,7 +31949,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 (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "img") return;
+		if (resolveJsxElementType(node) !== "img") return;
 		const loadingAttribute = hasJsxPropIgnoreCase(node.attributes, "loading");
 		if (!loadingAttribute || getJsxPropStringValue(loadingAttribute)?.toLowerCase() !== "lazy") return;
 		const fetchPriorityAttribute = hasJsxPropIgnoreCase(node.attributes, "fetchPriority");
@@ -31650,6 +31961,26 @@ 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",
@@ -31681,6 +32012,33 @@ 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;
@@ -31692,27 +32050,37 @@ const getMemberCall = (node) => {
 };
 const isNotificationReceiver = (receiver, scopes) => {
 	if (!isNodeOfType(receiver, "Identifier")) return false;
-	if (!NOTIFICATION_RECEIVER_NAMES.has(receiver.name)) 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));
 	const symbol = scopes.symbolFor(receiver);
-	if (symbol?.kind === "import") return true;
 	if (!isNodeOfType(symbol?.initializer, "CallExpression")) return false;
 	const callee = symbol.initializer.callee;
-	return isNodeOfType(callee, "Identifier") && /^use(?:Message|Notification|Toast)$/.test(callee.name);
+	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;
 };
 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) && 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}()`;
+	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}()`;
 	return null;
 };
 const getExternalAssignmentDescription = (assignmentTarget, updater, scopes) => {
-	let rootIdentifier = null;
-	if (isNodeOfType(assignmentTarget, "Identifier")) rootIdentifier = assignmentTarget;
-	else if (isNodeOfType(assignmentTarget, "MemberExpression") && isNodeOfType(assignmentTarget.object, "Identifier")) rootIdentifier = assignmentTarget.object;
+	const rootIdentifier = getRootIdentifier$1(assignmentTarget);
 	if (!rootIdentifier) return null;
 	const updaterScope = scopes.ownScopeFor(updater);
 	if (!updaterScope) return null;
@@ -31721,12 +32089,26 @@ 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) && !executesDuringRender(child, scopes)) return false;
+		if (child !== updater && isFunctionLike$1(child) && !isDefinitelySynchronousCallback(child, scopes)) return false;
 		if (isNodeOfType(child, "CallExpression")) {
 			if (isNodeOfType(child.callee, "Identifier") && analysis) {
 				const calleeReference = getRef(analysis, child.callee);
@@ -31758,18 +32140,25 @@ 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 updater = node.arguments?.[0];
-		if (!updater || !isFunctionLike$1(updater)) return;
+		const updaterArgument = node.arguments?.[0];
+		if (!updaterArgument) 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: updater,
+			node: updaterArgument,
 			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.`
 		});
 	} })
@@ -31879,7 +32268,7 @@ const noIndeterminateAttribute = defineRule({
 		if (classifyReactNativeFileTarget(context) === "react-native") return {};
 		return {
 			JSXOpeningElement(node) {
-				if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "input") return;
+				if (resolveJsxElementType(node) !== "input") return;
 				let typeAttribute = null;
 				let typeAttributeIndex = null;
 				let indeterminateAttribute = null;
@@ -32058,11 +32447,12 @@ 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) => {
-	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";
+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";
 	return null;
 };
 const noInlinePropOnMemoComponent = defineRule({
@@ -32092,7 +32482,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);
+				const propType = isInlineReference(node.value.expression, context.scopes);
 				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`
@@ -32951,11 +33341,13 @@ 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(param, "ObjectPattern")) {
+			if (isNodeOfType(propsBinding, "ObjectPattern")) {
 				const callbackUsedNames = collectCallbackUsedNames(body, param, context.scopes);
 				const booleanLikePropNames = [];
-				for (const property of param.properties ?? []) {
+				for (const property of propsBinding.properties ?? []) {
 					if (!isNodeOfType(property, "Property")) continue;
 					const keyName = isNodeOfType(property.key, "Identifier") ? property.key.name : null;
 					if (!keyName) continue;
@@ -32966,7 +33358,7 @@ const noManyBooleanProps = defineRule({
 				reportIfMany(booleanLikePropNames, componentName, reportNode);
 				return;
 			}
-			if (isNodeOfType(param, "Identifier")) reportIfMany([...collectBooleanLikePropsFromBody(body, param.name)], componentName, reportNode);
+			if (isNodeOfType(propsBinding, "Identifier")) reportIfMany([...collectBooleanLikePropsFromBody(body, propsBinding.name)], componentName, reportNode);
 		};
 		return {
 			FunctionDeclaration(node) {
@@ -33088,7 +33480,7 @@ const noMirrorPropEffect = defineRule({
 			if (mirrorBindings.length === 0) return;
 			for (const statement of componentBody.body ?? []) {
 				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
-				const effectCall = statement.expression;
+				const effectCall = unwrapDiscardedExpression(statement);
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
 				if (!isHookCall$2(effectCall, EFFECT_HOOK_NAMES$1)) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
@@ -33102,7 +33494,7 @@ const noMirrorPropEffect = defineRule({
 				const bodyStatements = getCallbackStatements(callback);
 				if (bodyStatements.length !== 1) continue;
 				const onlyStatement = bodyStatements[0];
-				const expression = isNodeOfType(onlyStatement, "ExpressionStatement") ? onlyStatement.expression : onlyStatement;
+				const expression = unwrapDiscardedExpression(onlyStatement);
 				if (!isNodeOfType(expression, "CallExpression")) continue;
 				if (!isNodeOfType(expression.callee, "Identifier")) continue;
 				if (!isSetterIdentifier(expression.callee.name)) continue;
@@ -35718,7 +36110,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 = isNodeOfType(node.name, "JSXIdentifier") ? node.name.name : null;
+			const elementName = resolveJsxElementType(node);
 			if (!elementName) return;
 			const targetEventProps = PREVENT_DEFAULT_ELEMENTS.get(elementName);
 			if (!targetEventProps) return;
@@ -36608,28 +37000,85 @@ const noRedundantShouldComponentUpdate = defineRule({
 });
 //#endregion
 //#region src/plugin/rules/state-and-effects/no-ref-current-in-render.ts
-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 REPEATED_ANCESTOR_TYPES = new Set([
+	"DoWhileStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"ForStatement",
+	"WhileStatement"
+]);
 const isSameRefCurrentMember = (node, refSymbol, scopes) => {
-	if (!isNodeOfType(node, "MemberExpression") || node.computed || !isNodeOfType(node.property, "Identifier") || node.property.name !== "current") return false;
+	if (!isNodeOfType(node, "MemberExpression") || getStaticPropertyName(node) !== "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 !== "=" || !isNodeOfType(assignmentExpression.right, "NewExpression")) return false;
+	if (assignmentExpression.operator === "??=" || assignmentExpression.operator === "||=") return true;
+	if (assignmentExpression.operator !== "=") return false;
 	let descendant = assignmentExpression;
 	let ancestor = descendant.parent;
 	while (ancestor) {
-		if (isNodeOfType(ancestor, "IfStatement") && ancestor.consequent === descendant && isNodeOfType(ancestor.test, "BinaryExpression") && (ancestor.test.operator === "===" || ancestor.test.operator === "==")) {
+		if (isNodeOfType(ancestor, "IfStatement") && isNodeOfType(ancestor.test, "BinaryExpression") && [
+			"===",
+			"==",
+			"!==",
+			"!="
+		].includes(ancestor.test.operator)) {
 			const { left, right } = ancestor.test;
-			if (isSameRefCurrentMember(left, refSymbol, scopes) && isNodeOfType(right, "Literal") && right.value === null || isSameRefCurrentMember(right, refSymbol, scopes) && isNodeOfType(left, "Literal") && left.value === null) return true;
+			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;
 		}
 		descendant = ancestor;
 		ancestor = descendant.parent;
@@ -37203,7 +37652,7 @@ const isNonSettlingSetterArgument = (setterCall, stateName) => {
 	return expressionReadsStateValue(argument, stateName);
 };
 const getUnconditionalSetterCall = (statement, setterNames) => {
-	const expression = stripParenExpression(isNodeOfType(statement, "ExpressionStatement") ? statement.expression : statement);
+	const expression = unwrapDiscardedExpression(statement);
 	if (!isNodeOfType(expression, "CallExpression")) return null;
 	if (!isNodeOfType(expression.callee, "Identifier")) return null;
 	if (!setterNames.has(expression.callee.name)) return null;
@@ -37552,7 +38001,7 @@ const noSelfUpdatingEffect = defineRule({
 			const setterNames = new Set(setterNameToStateName.keys());
 			for (const statement of functionBody.body ?? []) {
 				if (!isNodeOfType(statement, "ExpressionStatement")) continue;
-				const effectCall = statement.expression;
+				const effectCall = unwrapDiscardedExpression(statement);
 				if (!isNodeOfType(effectCall, "CallExpression")) continue;
 				if (!isHookCall$2(effectCall, EFFECT_HOOK_NAMES$1)) continue;
 				if ((effectCall.arguments?.length ?? 0) < 2) continue;
@@ -38182,9 +38631,10 @@ 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 firstCharacter = node.name.name.charCodeAt(0);
+		const elementName = resolveJsxElementType(node);
+		const firstCharacter = elementName.charCodeAt(0);
 		if (firstCharacter < 97 || firstCharacter > 122) return;
-		if (node.name.name.includes("-")) return;
+		if (elementName.includes("-")) return;
 		for (const attribute of node.attributes) {
 			if (!isNodeOfType(attribute, "JSXAttribute")) continue;
 			if (!isNodeOfType(attribute.name, "JSXIdentifier")) continue;
@@ -38572,8 +39022,7 @@ const noUncontrolledInput = defineRule({
 			const undefinedInitialStateNames = isNodeOfType(componentBody, "BlockStatement") ? collectUndefinedInitialStateNames(componentBody) : /* @__PURE__ */ new Set();
 			walkAst(componentBody, (child) => {
 				if (!isNodeOfType(child, "JSXOpeningElement")) return;
-				if (!isNodeOfType(child.name, "JSXIdentifier")) return;
-				const tagName = child.name.name;
+				const tagName = resolveJsxElementType(child);
 				if (!UNCONTROLLED_INPUT_TAGS.has(tagName)) return;
 				const attributes = child.attributes ?? [];
 				if (hasJsxSpreadAttribute(attributes)) return;
@@ -38634,7 +39083,7 @@ const noUndeferredThirdParty = defineRule({
 	severity: "warn",
 	recommendation: "Use `next/script` with `strategy=\"lazyOnload\"`, or add the `defer` attribute.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "script") return;
+		if (resolveJsxElementType(node) !== "script") return;
 		const attributes = node.attributes ?? [];
 		const srcAttribute = findJsxAttribute(attributes, "src");
 		if (!srcAttribute) return;
@@ -39849,7 +40298,7 @@ const noUnknownProperty = defineRule({
 				}
 				if (fileIsNonReactJsx) return;
 				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-				const elementType = node.name.name;
+				const elementType = resolveJsxElementType(node);
 				const firstCharacter = elementType.charCodeAt(0);
 				if (!(firstCharacter >= 97 && firstCharacter <= 122) || elementType === "fbt" || elementType === "fbs") return;
 				let isValidHtmlTag = isKnownDomTag(elementType);
@@ -40027,20 +40476,21 @@ 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) => {
+const findEnclosingComponent = (node, scopes) => {
 	let walker = node.parent;
 	while (walker) {
 		if (isFunctionLike$1(walker)) {
 			const componentName = inferFunctionLikeName(walker);
-			if (componentName && isReactComponentName(componentName) && expressionContainsJsxOrCreateElement(walker)) return {
+			if (componentName && isReactComponentName(componentName) && functionContainsJsxOrCreateElement(walker, scopes)) return {
 				component: walker,
 				name: componentName
 			};
-			if (!componentName && expressionContainsJsxOrCreateElement(walker) && walker.parent && isNodeOfType(walker.parent, "ExportDefaultDeclaration")) return {
+			if (!componentName && functionContainsJsxOrCreateElement(walker, scopes) && walker.parent && isNodeOfType(walker.parent, "ExportDefaultDeclaration")) return {
 				component: walker,
 				name: null
 			};
@@ -40279,7 +40729,7 @@ const noUnstableNestedComponents = defineRule({
 				if (renderPropRegex.test(propInfo.propName)) return;
 				if (settings.allowAsProps) return;
 			}
-			const enclosing = findEnclosingComponent(candidateNode);
+			const enclosing = findEnclosingComponent(candidateNode, context.scopes);
 			if (!enclosing) return;
 			const gatedName = propInfo ? null : requiredInstantiationName;
 			queuedReports.push({
@@ -40290,7 +40740,7 @@ const noUnstableNestedComponents = defineRule({
 			});
 		};
 		const checkFunctionLike = (node) => {
-			if (!expressionContainsJsxOrCreateElement(node)) return;
+			if (!functionContainsJsxOrCreateElement(node, context.scopes)) return;
 			const inferredName = inferFunctionLikeName(node);
 			const propInfo = isComponentDeclaredInProp(node);
 			const isObjectCallback = isObjectCallbackCandidate(node);
@@ -41550,7 +42000,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 = node.name.name;
+		const tagName = resolveJsxElementType(node);
 		if (tagName.length === 0 || tagName[0] !== tagName[0].toLowerCase()) return;
 		const onDoubleClickAttribute = findJsxAttribute(node.attributes, "onDoubleClick");
 		if (!onDoubleClickAttribute) return;
@@ -41570,7 +42020,7 @@ const COMPAT_EXEMPT_INPUT_TYPES = new Set([
 ]);
 const isTextLikeInput = (openingElement) => {
 	if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return false;
-	const tagName = openingElement.name.name;
+	const tagName = resolveJsxElementType(openingElement);
 	if (tagName === "textarea") return true;
 	if (tagName !== "input") return false;
 	const typeAttribute = findJsxAttribute(openingElement.attributes, "type");
@@ -41727,8 +42177,9 @@ const CROSS_CUTTING_STATE_BOOLEAN_NAMES = new Set([
 ]);
 const collectBooleanPropBindings = (param) => {
 	const bindings = /* @__PURE__ */ new Set();
-	if (!param || !isNodeOfType(param, "ObjectPattern")) return bindings;
-	for (const property of param.properties ?? []) {
+	const propsBinding = resolveFirstArgumentBinding(param);
+	if (!isNodeOfType(propsBinding, "ObjectPattern")) return bindings;
+	for (const property of propsBinding.properties ?? []) {
 		if (!isNodeOfType(property, "Property")) continue;
 		if (property.computed) continue;
 		if (!isNodeOfType(property.key, "Identifier")) continue;
@@ -41989,7 +42440,7 @@ const preferHtmlDialog = defineRule({
 			},
 			JSXOpeningElement(node) {
 				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-				const tagName = node.name.name;
+				const tagName = resolveJsxElementType(node);
 				if (tagName === "dialog") return;
 				if (tagName.length === 0 || tagName[0] !== tagName[0].toLowerCase()) return;
 				if (!HTML_TAGS.has(tagName)) return;
@@ -43536,13 +43987,13 @@ const resolveTanstackQueryHookName = (callExpression) => {
 	}
 	return null;
 };
-const resolveHookNameFromInitializer = (initializer) => {
+const resolveHookNameFromInitializer = (initializer, scopes) => {
 	if (isNodeOfType(initializer, "CallExpression")) return resolveTanstackQueryHookName(initializer);
 	if (!isNodeOfType(initializer, "Identifier")) return null;
-	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 resolvedSymbol = resolveConstIdentifierAlias(initializer, scopes);
+	if (resolvedSymbol?.kind !== "const" || !resolvedSymbol.initializer) return null;
+	if (!isNodeOfType(resolvedSymbol.initializer, "CallExpression")) return null;
+	return resolveTanstackQueryHookName(resolvedSymbol.initializer);
 };
 const queryNoRestDestructuring = defineRule({
 	id: "query-no-rest-destructuring",
@@ -43555,7 +44006,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);
+		const hookName = resolveHookNameFromInitializer(node.init, context.scopes);
 		if (!hookName) return;
 		context.report({
 			node: node.id,
@@ -44026,7 +44477,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 (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "svg") return;
+		if (resolveJsxElementType(node) !== "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"
@@ -44910,7 +45361,7 @@ const DEFERRABLE_HOOK_NAMES = new Set([
 	"useParams",
 	"usePathname"
 ]);
-const findHookCallBindings = (componentBody) => {
+const findHookCallBindings = (componentBody, scopes) => {
 	const bindings = [];
 	if (!isNodeOfType(componentBody, "BlockStatement")) return bindings;
 	for (const statement of componentBody.body ?? []) {
@@ -44921,8 +45372,10 @@ const findHookCallBindings = (componentBody) => {
 			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({
-				valueName: declarator.id.name,
+				valueSymbol,
 				hookName: callee.name,
 				declarator
 			});
@@ -44930,6 +45383,49 @@ const findHookCallBindings = (componentBody) => {
 	}
 	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",
@@ -44940,15 +45436,13 @@ const rerenderDeferReadsHook = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const bindings = findHookCallBindings(componentBody);
+			const bindings = findHookCallBindings(componentBody, context.scopes);
 			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 = [];
-				walkAst(componentBody, (child) => {
-					if (isNodeOfType(binding.declarator, "VariableDeclarator") && child === binding.declarator.id) return;
-					if (isNodeOfType(child, "Identifier") && child.name === binding.valueName) referenceLocations.push(child);
-				});
+				for (const symbol of symbols) for (const reference of symbol.references) if (!aliasSourceIdentifiers.has(reference.identifier)) referenceLocations.push(reference.identifier);
 				if (referenceLocations.length === 0) continue;
 				if (!referenceLocations.every((ref) => isInsideEventHandler(ref, handlerBindingNames))) continue;
 				context.report({
@@ -45319,14 +45813,10 @@ 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) => {
+const callbackReturnsJsx = (callback, scopes) => {
 	if (!callback) return false;
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
-	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;
+	return functionReturnsMatchingExpression(callback, scopes, isJsxExpression);
 };
 const returnArgumentUsesAnyName = (returnStatement, names) => {
 	if (!isNodeOfType(returnStatement, "ReturnStatement") || !returnStatement.argument) return false;
@@ -45404,7 +45894,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])) {
+						if (isNodeOfType(init, "CallExpression") && isHookCall$2(init, "useMemo") && callbackReturnsJsx(init.arguments?.[0], context.scopes)) {
 							memoNode = declarator;
 							callbackGuardTests = collectLeadingCallbackGuardTests(init.arguments?.[0]);
 							if (isNodeOfType(declarator.id, "Identifier")) memoConsumerNames.add(declarator.id.name);
@@ -45470,8 +45960,11 @@ const collectFromObjectPattern = (pattern, bindings) => {
 const collectDefaultedEmptyBindings = (functionNode) => {
 	const bindings = /* @__PURE__ */ new Map();
 	const params = functionNode.params ?? [];
-	for (const param of params) collectFromObjectPattern(param, bindings);
-	const propsParam = params[0];
+	for (const [parameterIndex, param] of params.entries()) {
+		const parameterBinding = parameterIndex === 0 ? resolveFirstArgumentBinding(param) : param;
+		if (parameterBinding) collectFromObjectPattern(parameterBinding, bindings);
+	}
+	const propsParam = resolveFirstArgumentBinding(params[0]);
 	const body = functionNode.body;
 	if (!propsParam || !isNodeOfType(propsParam, "Identifier") || !body) return bindings;
 	if (!isNodeOfType(body, "BlockStatement")) return bindings;
@@ -45977,8 +46470,8 @@ const rnAnimationReactionAsDerived = defineRule({
 			if (statements.length !== 1) return;
 			const onlyStatement = statements[0];
 			if (!isNodeOfType(onlyStatement, "ExpressionStatement")) return;
-			singleAssignment = onlyStatement.expression;
-		} else if (body) singleAssignment = body;
+			singleAssignment = unwrapDiscardedExpression(onlyStatement);
+		} else if (body) singleAssignment = unwrapDiscardedExpression(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;
@@ -52898,7 +53391,8 @@ const serverCacheWithObjectLiteral = defineRule({
 				if (!isNodeOfType(node.callee, "Identifier")) return;
 				if (!cachedFunctionNames.has(node.callee.name)) return;
 				const firstArg = node.arguments?.[0];
-				if (!isNodeOfType(firstArg, "ObjectExpression")) return;
+				if (!firstArg || isNodeOfType(firstArg, "SpreadElement")) return;
+				if (!isNodeOfType(unwrapObjectIntegrityExpression(firstArg, context.scopes, OBJECT_FREEZE_OR_SEAL_METHOD_NAMES), "ObjectExpression")) return;
 				context.report({
 					node,
 					message: `Passing a new object to React.cache() each render misses the cache, so it refetches every request.`
@@ -53585,10 +54079,6 @@ 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",
@@ -53600,7 +54090,8 @@ const stylePropObject = defineRule({
 		const allowSet = new Set(allow);
 		return {
 			JSXOpeningElement(node) {
-				const elementName = getJsxOpeningElementName(node);
+				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+				const elementName = resolveJsxElementType(node);
 				if (elementName && allowSet.has(elementName)) return;
 				if (elementName) {
 					const firstCharCode = elementName.charCodeAt(0);
@@ -54305,7 +54796,7 @@ const tanstackStartNoAnchorElement = defineRule({
 	create: (context) => {
 		if (!isInProjectDirectory(context, "routes")) return {};
 		return { JSXOpeningElement(node) {
-			if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a") return;
+			if (resolveJsxElementType(node) !== "a") return;
 			const attributes = node.attributes ?? [];
 			const hrefAttribute = findJsxAttribute(attributes, "href");
 			if (!hrefAttribute?.value) return;
@@ -54926,8 +55417,7 @@ const voidDomElementsNoChildren = defineRule({
 	create: (context) => ({
 		JSXElement(node) {
 			const openingElement = node.openingElement;
-			if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return;
-			const tagName = openingElement.name.name;
+			const tagName = resolveJsxElementType(openingElement);
 			if (!VOID_DOM_ELEMENTS.has(tagName)) return;
 			const hasChildrenContent = node.children.some(isMeaningfulJsxChild);
 			const hasChildrenLikeProp = findChildrenLikePropName(openingElement.attributes);