oxlint-plugin-react-doctor 0.7.6-dev.81e6647 → 0.7.6-dev.82e10cd

package/dist/index.js

@@ -1518,37 +1518,6 @@ const hasJsxPropIgnoreCase = (attributes, targetProp) => {
 	}
 };
 //#endregion
-//#region src/plugin/utils/is-uppercase-name.ts
-const isUppercaseName = (name) => UPPERCASE_PATTERN.test(name);
-//#endregion
-//#region src/plugin/utils/resolve-jsx-element-type.ts
-const resolveConstantStringBinding = (name) => {
-	const binding = findVariableInitializer(name, name.name);
-	if (!binding?.initializer) return null;
-	const declarator = binding.bindingIdentifier.parent;
-	if (!declarator || !isNodeOfType(declarator, "VariableDeclarator")) return null;
-	if (declarator.id !== binding.bindingIdentifier) return null;
-	const declaration = declarator.parent;
-	if (!declaration || !isNodeOfType(declaration, "VariableDeclaration")) return null;
-	if (declaration.kind !== "const") return null;
-	const initializer = stripParenExpression(binding.initializer);
-	return isNodeOfType(initializer, "Literal") && typeof initializer.value === "string" ? initializer.value : null;
-};
-const flattenJsxName$2 = (name) => {
-	if (isNodeOfType(name, "JSXIdentifier")) return name.name;
-	if (isNodeOfType(name, "JSXMemberExpression")) return `${flattenJsxName$2(name.object)}.${name.property.name}`;
-	if (isNodeOfType(name, "JSXNamespacedName")) return `${name.namespace.name}:${name.name.name}`;
-	return "";
-};
-const resolveJsxElementType = (openingElement) => {
-	const name = openingElement.name;
-	if (isNodeOfType(name, "JSXIdentifier")) {
-		if (!isUppercaseName(name.name)) return name.name;
-		return resolveConstantStringBinding(name) ?? name.name;
-	}
-	return flattenJsxName$2(name);
-};
-//#endregion
 //#region src/plugin/utils/get-element-type.ts
 const EMPTY_JSX_A11Y_SETTINGS = Object.freeze({});
 const jsxA11ySettingsCache = /* @__PURE__ */ new WeakMap();
@@ -1561,8 +1530,14 @@ const readJsxA11ySettings = (settings) => {
 	jsxA11ySettingsCache.set(settings, a11ySettings);
 	return a11ySettings;
 };
+const flattenJsxName$2 = (name) => {
+	if (isNodeOfType(name, "JSXIdentifier")) return name.name;
+	if (isNodeOfType(name, "JSXMemberExpression")) return `${flattenJsxName$2(name.object)}.${name.property.name}`;
+	if (isNodeOfType(name, "JSXNamespacedName")) return `${name.namespace.name}:${name.name.name}`;
+	return "";
+};
 const computeElementType = (openingElement, a11ySettings) => {
-	const baseName = resolveJsxElementType(openingElement);
+	const baseName = flattenJsxName$2(openingElement.name);
 	if (a11ySettings.polymorphicPropName) {
 		const polymorphicAttribute = hasJsxPropIgnoreCase(openingElement.attributes, a11ySettings.polymorphicPropName);
 		if (polymorphicAttribute) {
@@ -2397,9 +2372,8 @@ const anchorIsValid = defineRule({
 		const isTestlikeFile = isTestlikeFilename(context.filename);
 		return { JSXOpeningElement(node) {
 			if (isTestlikeFile) return;
-			const tag = getElementType(node, context.settings);
-			if (!fileHasJsxA11ySettings && tag !== "a") return;
-			if (tag !== "a") return;
+			if (!fileHasJsxA11ySettings && (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a")) return;
+			if (getElementType(node, context.settings) !== "a") return;
 			let hrefAttribute;
 			for (const attributeName of settings.hrefAttributeNames) {
 				hrefAttribute = hasJsxPropIgnoreCase(node.attributes, attributeName);
@@ -5754,7 +5728,7 @@ const buttonHasType = defineRule({
 		return {
 			JSXOpeningElement(node) {
 				if (isTestlikeFile) return;
-				if (resolveJsxElementType(node) !== "button") return;
+				if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "button") return;
 				const typeAttr = hasJsxPropIgnoreCase(node.attributes, "type");
 				if (!typeAttr) {
 					if (hasJsxSpreadAttribute$1(node.attributes)) {
@@ -5944,7 +5918,7 @@ const checkedRequiresOnchangeOrReadonly = defineRule({
 		};
 		return {
 			JSXOpeningElement(node) {
-				if (resolveJsxElementType(node) !== "input") return;
+				if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "input") return;
 				reportFromPresence(collectFromJsxAttributes(node.attributes));
 			},
 			CallExpression(node) {
@@ -6021,7 +5995,7 @@ const isPureEventBlockerHandler = (attribute) => {
 //#endregion
 //#region src/plugin/utils/resolve-const-identifier-alias.ts
 const resolveConstIdentifierAlias = (identifier, scopes) => {
-	if (!isNodeOfType(identifier, "Identifier") && !isNodeOfType(identifier, "JSXIdentifier")) return null;
+	if (!isNodeOfType(identifier, "Identifier")) return null;
 	const visitedSymbolIds = /* @__PURE__ */ new Set();
 	let symbol = scopes.symbolFor(identifier);
 	while (symbol?.kind === "const") {
@@ -6296,131 +6270,6 @@ const isGlobalMethodCall = (node, objectName, methodName) => {
 	return isNodeOfType(receiver, "Identifier") && receiver.name === objectName && isNodeOfType(callee.property, "Identifier") && callee.property.name === methodName;
 };
 //#endregion
-//#region src/plugin/utils/collect-safely-validated-local-storage-keys.ts
-const isLocalStorageCall = (node, methodName) => {
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	const callee = stripParenExpression(node.callee);
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	const receiver = stripParenExpression(callee.object);
-	return isNodeOfType(receiver, "Identifier") && receiver.name === "localStorage" && isNodeOfType(callee.property, "Identifier") && callee.property.name === methodName;
-};
-const catchReturnsFallback = (tryStatement) => {
-	const handler = tryStatement.handler;
-	if (!handler) return false;
-	let hasReturn = false;
-	let hasThrow = false;
-	walkAst(handler.body, (child) => {
-		if (isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "ReturnStatement")) hasReturn = true;
-		if (isNodeOfType(child, "ThrowStatement")) hasThrow = true;
-	});
-	return hasReturn && !hasThrow;
-};
-const resolveValidatorFunction = (callee, scopes) => {
-	const unwrappedCallee = stripParenExpression(callee);
-	if (!isNodeOfType(unwrappedCallee, "Identifier")) return null;
-	const symbol = scopes.symbolFor(unwrappedCallee);
-	if (!symbol) return null;
-	const candidate = symbol.kind === "function" ? symbol.declarationNode : symbol.initializer;
-	return isFunctionLike$1(candidate) ? candidate : null;
-};
-const validatorChecksPayloadProperties = (validatorFunction, scopes) => {
-	if (!isFunctionLike$1(validatorFunction)) return false;
-	const firstParameter = validatorFunction.params?.[0];
-	if (!firstParameter || !isNodeOfType(firstParameter, "Identifier")) return false;
-	const parameterSymbol = scopes.symbolFor(firstParameter);
-	if (!parameterSymbol) return false;
-	const payloadSymbolIds = new Set([parameterSymbol.id]);
-	let hasPropertyTypeCheck = false;
-	walkAst(validatorFunction.body, (child) => {
-		if (isFunctionLike$1(child)) return false;
-		if (isNodeOfType(child, "VariableDeclarator") && isNodeOfType(child.id, "Identifier") && child.init) {
-			const initializer = stripParenExpression(child.init);
-			if (isNodeOfType(initializer, "Identifier")) {
-				const initializerSymbol = scopes.symbolFor(initializer);
-				if (initializerSymbol && payloadSymbolIds.has(initializerSymbol.id)) {
-					const aliasSymbol = scopes.symbolFor(child.id);
-					if (aliasSymbol) payloadSymbolIds.add(aliasSymbol.id);
-				}
-			}
-		}
-		if (!isNodeOfType(child, "UnaryExpression") || child.operator !== "typeof") return;
-		const checkedValue = stripParenExpression(child.argument);
-		if (!isNodeOfType(checkedValue, "MemberExpression")) return;
-		const receiver = stripParenExpression(checkedValue.object);
-		if (!isNodeOfType(receiver, "Identifier")) return;
-		const receiverSymbol = scopes.symbolFor(receiver);
-		if (receiverSymbol && payloadSymbolIds.has(receiverSymbol.id)) hasPropertyTypeCheck = true;
-	});
-	return hasPropertyTypeCheck;
-};
-const incrementCount = (counts, keyValue) => {
-	counts.set(keyValue, (counts.get(keyValue) ?? 0) + 1);
-};
-const isReturnedExpression = (expression) => {
-	const parent = expression.parent;
-	return Boolean(parent && isNodeOfType(parent, "ReturnStatement") && parent.argument === expression);
-};
-const collectSafelyValidatedLocalStorageKeys = ({ programNode, scopes, resolveKey }) => {
-	const readCountsByKey = /* @__PURE__ */ new Map();
-	const safeReadCountsByKey = /* @__PURE__ */ new Map();
-	const safeReadSymbolIds = /* @__PURE__ */ new Set();
-	walkAst(programNode, (child) => {
-		if (!isNodeOfType(child, "CallExpression") || !isLocalStorageCall(child, "getItem")) return;
-		const keyArgument = child.arguments?.[0];
-		if (!keyArgument) return;
-		const keyValue = resolveKey(keyArgument);
-		if (keyValue !== null) incrementCount(readCountsByKey, keyValue);
-	});
-	walkAst(programNode, (child) => {
-		if (!isNodeOfType(child, "TryStatement") || !catchReturnsFallback(child)) return;
-		const rawValueKeys = /* @__PURE__ */ new Map();
-		const parsedValueSources = /* @__PURE__ */ new Map();
-		walkAst(child.block, (tryChild) => {
-			if (isFunctionLike$1(tryChild)) return false;
-			if (isNodeOfType(tryChild, "VariableDeclarator") && isNodeOfType(tryChild.id, "Identifier") && tryChild.init) {
-				const initializer = stripParenExpression(tryChild.init);
-				if (isNodeOfType(initializer, "CallExpression") && isLocalStorageCall(initializer, "getItem")) {
-					const keyArgument = initializer.arguments?.[0];
-					const bindingSymbol = scopes.symbolFor(tryChild.id);
-					if (keyArgument && bindingSymbol) {
-						const keyValue = resolveKey(keyArgument);
-						if (keyValue !== null) rawValueKeys.set(bindingSymbol.id, keyValue);
-					}
-				}
-				if (isNodeOfType(initializer, "CallExpression") && isGlobalMethodCall(initializer, "JSON", "parse")) {
-					const rawValueArgument = initializer.arguments?.[0];
-					const parsedValueSymbol = scopes.symbolFor(tryChild.id);
-					if (rawValueArgument && isNodeOfType(rawValueArgument, "Identifier") && parsedValueSymbol) {
-						const rawValueSymbol = scopes.symbolFor(rawValueArgument);
-						if (rawValueSymbol && rawValueKeys.has(rawValueSymbol.id)) parsedValueSources.set(parsedValueSymbol.id, rawValueSymbol.id);
-					}
-				}
-			}
-			if (!isNodeOfType(tryChild, "ConditionalExpression") || !isReturnedExpression(tryChild)) return;
-			const test = stripParenExpression(tryChild.test);
-			if (!isNodeOfType(test, "CallExpression")) return;
-			const testedValue = test.arguments?.[0];
-			if (!testedValue || !isNodeOfType(testedValue, "Identifier")) return;
-			const parsedValueSymbol = scopes.symbolFor(testedValue);
-			if (!parsedValueSymbol) return;
-			const rawValueSymbolId = parsedValueSources.get(parsedValueSymbol.id);
-			if (rawValueSymbolId === void 0) return;
-			const returnedValue = stripParenExpression(tryChild.consequent);
-			if (!isNodeOfType(returnedValue, "Identifier") || scopes.symbolFor(returnedValue)?.id !== parsedValueSymbol.id) return;
-			const validatorFunction = resolveValidatorFunction(test.callee, scopes);
-			if (!validatorFunction || !validatorChecksPayloadProperties(validatorFunction, scopes)) return;
-			const keyValue = rawValueKeys.get(rawValueSymbolId);
-			if (keyValue === void 0 || safeReadSymbolIds.has(rawValueSymbolId)) return;
-			safeReadSymbolIds.add(rawValueSymbolId);
-			incrementCount(safeReadCountsByKey, keyValue);
-		});
-	});
-	const safeKeys = /* @__PURE__ */ new Set();
-	for (const [keyValue, readCount] of readCountsByKey) if (safeReadCountsByKey.get(keyValue) === readCount) safeKeys.add(keyValue);
-	return safeKeys;
-};
-//#endregion
 //#region src/plugin/rules/client/client-localstorage-no-version.ts
 const VERSIONED_KEY_PATTERN = /(?:[._:-]v\d+|@\d+|\bv\d+\b)/i;
 const CAMEL_CASE_VERSIONED_KEY_PATTERN = /[a-z]V\d+/;
@@ -6442,39 +6291,26 @@ const clientLocalstorageNoVersion = defineRule({
 	severity: "warn",
 	category: "Correctness",
 	recommendation: "Put a version in the storage key (e.g. \"myKey:v1\"). If you change the data shape later, old saved data can be ignored instead of crashing the app.",
-	create: (context) => {
-		let safelyValidatedStorageKeys = /* @__PURE__ */ new Set();
-		return {
-			Program(node) {
-				safelyValidatedStorageKeys = collectSafelyValidatedLocalStorageKeys({
-					programNode: node,
-					scopes: context.scopes,
-					resolveKey: (keyNode) => resolveStringKey(keyNode, context)
-				});
-			},
-			CallExpression(node) {
-				if (!isNodeOfType(node.callee, "MemberExpression")) return;
-				const receiver = stripParenExpression(node.callee.object);
-				if (!isNodeOfType(receiver, "Identifier")) return;
-				if (receiver.name !== "localStorage") return;
-				if (!isNodeOfType(node.callee.property, "Identifier")) return;
-				if (node.callee.property.name !== "setItem") return;
-				const keyArg = node.arguments?.[0];
-				if (!keyArg) return;
-				const keyValue = resolveStringKey(keyArg, context);
-				if (keyValue === null) return;
-				if (isVersionedKey(keyValue)) return;
-				if (safelyValidatedStorageKeys.has(keyValue)) return;
-				const valueArg = node.arguments?.[1];
-				if (!valueArg) return;
-				if (!isJsonStringifyCall(valueArg)) return;
-				context.report({
-					node: keyArg,
-					message: `${receiver.name}.setItem("${keyValue}", JSON.stringify(...)) has no version, so changing the data shape later crashes your users' saved sessions. Add one to the key (e.g. "${keyValue}:v1").`
-				});
-			}
-		};
-	}
+	create: (context) => ({ CallExpression(node) {
+		if (!isNodeOfType(node.callee, "MemberExpression")) return;
+		const receiver = stripParenExpression(node.callee.object);
+		if (!isNodeOfType(receiver, "Identifier")) return;
+		if (receiver.name !== "localStorage") return;
+		if (!isNodeOfType(node.callee.property, "Identifier")) return;
+		if (node.callee.property.name !== "setItem") return;
+		const keyArg = node.arguments?.[0];
+		if (!keyArg) return;
+		const keyValue = resolveStringKey(keyArg, context);
+		if (keyValue === null) return;
+		if (isVersionedKey(keyValue)) return;
+		const valueArg = node.arguments?.[1];
+		if (!valueArg) return;
+		if (!isJsonStringifyCall(valueArg)) return;
+		context.report({
+			node: keyArg,
+			message: `${receiver.name}.setItem("${keyValue}", JSON.stringify(...)) has no version, so changing the data shape later crashes your users' saved sessions. Add one to the key (e.g. "${keyValue}:v1").`
+		});
+	} })
 });
 //#endregion
 //#region src/plugin/rules/client/client-passive-event-listeners.ts
@@ -7597,7 +7433,7 @@ const findJsxAttribute = (attributes, attributeName) => attributes?.find((attrib
 const getOpeningElementTagName = (openingElement) => {
 	if (!openingElement) return null;
 	if (!isNodeOfType(openingElement, "JSXOpeningElement")) return null;
-	if (isNodeOfType(openingElement.name, "JSXIdentifier")) return resolveJsxElementType(openingElement);
+	if (isNodeOfType(openingElement.name, "JSXIdentifier")) return openingElement.name.name;
 	if (isNodeOfType(openingElement.name, "JSXMemberExpression")) {
 		let cursor = openingElement.name;
 		while (isNodeOfType(cursor, "JSXMemberExpression")) cursor = cursor.property;
@@ -7849,7 +7685,7 @@ const dialogHasAccessibleName = defineRule({
 		if (isTestlikeFilename(context.filename)) return {};
 		return { JSXOpeningElement(node) {
 			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-			const tagName = resolveJsxElementType(node);
+			const tagName = node.name.name;
 			if (tagName[0] !== tagName[0]?.toLowerCase()) return;
 			const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
 			const roleValue = roleAttribute ? getJsxPropStringValue(roleAttribute) : null;
@@ -12081,7 +11917,7 @@ const forbidDomProps = defineRule({
 		return { JSXOpeningElement(node) {
 			if (forbidMap.size === 0) return;
 			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-			const elementName = resolveJsxElementType(node);
+			const elementName = node.name.name;
 			if (isReactComponentName(elementName)) return;
 			for (const attribute of node.attributes) {
 				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
@@ -12159,7 +11995,7 @@ const forbidElements = defineRule({
 		return {
 			JSXOpeningElement(node) {
 				if (forbidMap.size === 0) return;
-				const fullName = resolveJsxElementType(node);
+				const fullName = flattenJsxName$1(node.name);
 				if (!fullName || !forbidMap.has(fullName)) return;
 				context.report({
 					node: node.name,
@@ -12521,7 +12357,8 @@ const buildMessage$22 = (childTagName) => `Your users get reshuffled HTML becaus
 const isParagraphElement = (candidate) => {
 	if (!isNodeOfType(candidate, "JSXElement")) return false;
 	const opening = candidate.openingElement;
-	return resolveJsxElementType(opening) === "p";
+	if (!isNodeOfType(opening.name, "JSXIdentifier")) return false;
+	return opening.name.name === "p";
 };
 const findEnclosingParagraph = (openingElement) => {
 	const owningElement = openingElement.parent;
@@ -12542,7 +12379,8 @@ const htmlNoInvalidParagraphChild = defineRule({
 	severity: "warn",
 	recommendation: "Swap the `<p>` for a `<div>`, or move the child outside the paragraph.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		const childTagName = resolveJsxElementType(node);
+		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+		const childTagName = node.name.name;
 		if (!BLOCK_LEVEL_ELEMENTS.has(childTagName)) return;
 		if (!findEnclosingParagraph(node)) return;
 		context.report({
@@ -12573,7 +12411,7 @@ const getHostTagName = (jsxElement) => {
 	if (!isNodeOfType(jsxElement, "JSXElement")) return null;
 	const opening = jsxElement.openingElement;
 	if (!isNodeOfType(opening.name, "JSXIdentifier")) return null;
-	const tagName = resolveJsxElementType(opening);
+	const tagName = opening.name.name;
 	if (tagName.length === 0 || tagName[0] !== tagName[0].toLowerCase()) return null;
 	return tagName;
 };
@@ -12603,7 +12441,7 @@ const findClosestHostAncestor = (jsxElement) => {
 		if (isNodeOfType(ancestor, "JSXElement")) {
 			const opening = ancestor.openingElement;
 			if (isNodeOfType(opening.name, "JSXIdentifier")) {
-				const ancestorTag = resolveJsxElementType(opening);
+				const ancestorTag = opening.name.name;
 				if (ancestorTag.length === 0) {
 					previous = ancestor;
 					ancestor = ancestor.parent ?? null;
@@ -12685,7 +12523,8 @@ const buildMessage$20 = (tagName) => `Your users get broken clicks, focus & scre
 const isJsxElementWithTagName = (candidate, tagName) => {
 	if (!isNodeOfType(candidate, "JSXElement")) return false;
 	const opening = candidate.openingElement;
-	return resolveJsxElementType(opening) === tagName;
+	if (!isNodeOfType(opening.name, "JSXIdentifier")) return false;
+	return opening.name.name === tagName;
 };
 const findEnclosingSameTag = (openingElement, tagName) => {
 	const owningElement = openingElement.parent;
@@ -12706,7 +12545,8 @@ const htmlNoNestedInteractive = defineRule({
 	severity: "warn",
 	recommendation: "Move the inner `<a>` or `<button>` so it's a sibling, or change the outer one to a plain `<div>` or `<span>`.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		const tagName = resolveJsxElementType(node);
+		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+		const tagName = node.name.name;
 		if (tagName !== "a" && tagName !== "button") return;
 		if (!findEnclosingSameTag(node, tagName)) return;
 		context.report({
@@ -12821,7 +12661,7 @@ const iframeMissingSandbox = defineRule({
 	matchByOccurrence: true,
 	create: skipNonProductionFiles((context) => ({
 		JSXOpeningElement(node) {
-			if (resolveJsxElementType(node) !== "iframe") return;
+			if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "iframe") return;
 			const sandboxAttr = hasJsxPropIgnoreCase(node.attributes, "sandbox");
 			if (!sandboxAttr) {
 				const hasExplicitSrc = Boolean(hasJsxPropIgnoreCase(node.attributes, "src"));
@@ -14749,18 +14589,6 @@ const jsHoistRegexp = defineRule({
 	}, { treatIteratorCallbacksAsLoops: true })
 });
 //#endregion
-//#region src/plugin/utils/resolve-first-argument-binding.ts
-const resolveFirstArgumentBinding = (firstParameter) => {
-	if (!firstParameter) return null;
-	if (!isNodeOfType(firstParameter, "RestElement")) return firstParameter;
-	if (!isNodeOfType(firstParameter.argument, "ArrayPattern")) return null;
-	const elements = firstParameter.argument.elements ?? [];
-	if (elements.length !== 1) return null;
-	const firstBinding = elements[0];
-	if (!firstBinding || isNodeOfType(firstBinding, "RestElement")) return null;
-	return firstBinding;
-};
-//#endregion
 //#region src/plugin/rules/js-performance/js-index-maps.ts
 const referencesParameter = (expression, parameterName) => {
 	if (!expression) return false;
@@ -14771,7 +14599,7 @@ const referencesParameter = (expression, parameterName) => {
 const isSingleFieldEqualityPredicate = (node) => {
 	const callback = node.arguments?.[0];
 	if (!isInlineFunctionExpression(callback)) return false;
-	const firstParameter = resolveFirstArgumentBinding(callback.params?.[0]);
+	const firstParameter = callback.params?.[0];
 	if (!firstParameter || !isNodeOfType(firstParameter, "Identifier")) return false;
 	let predicate = null;
 	const body = callback.body;
@@ -15463,21 +15291,9 @@ const isSmallFixedListMember = (receiver) => {
 };
 const getResolvedInitializer = (receiver) => {
 	if (!isNodeOfType(receiver, "Identifier")) return null;
-	const binding = findVariableInitializer(receiver, receiver.name);
-	const initializer = binding?.initializer ?? null;
-	if (!binding || !initializer) return null;
-	const isDefault = isNodeOfType(binding.bindingIdentifier.parent, "AssignmentPattern");
-	if (isNodeOfType(initializer, "Identifier")) {
-		const aliased = findVariableInitializer(initializer, initializer.name);
-		if (aliased?.initializer) return {
-			initializer: aliased.initializer,
-			isDefault: isDefault || isNodeOfType(aliased.bindingIdentifier.parent, "AssignmentPattern")
-		};
-	}
-	return {
-		initializer,
-		isDefault
-	};
+	const initializer = findVariableInitializer(receiver, receiver.name)?.initializer ?? null;
+	if (initializer && isNodeOfType(initializer, "Identifier")) return findVariableInitializer(initializer, initializer.name)?.initializer ?? initializer;
+	return initializer;
 };
 const isSplitCall = (expression) => {
 	if (!expression) return false;
@@ -15643,8 +15459,8 @@ const isBoundedConstantCollection = (collection) => {
 	if (isScreamingSnakeCaseConstantReceiver(stripped)) return true;
 	if (isSmallInlineLiteralArray(stripped)) return true;
 	if (isNodeOfType(stripped, "Identifier")) {
-		const resolved = getResolvedInitializer(stripped);
-		if (resolved && !resolved.isDefault && isSmallInlineLiteralArray(resolved.initializer)) return true;
+		const initializer = getResolvedInitializer(stripped);
+		if (initializer && isSmallInlineLiteralArray(initializer)) return true;
 	}
 	return false;
 };
@@ -15696,8 +15512,8 @@ const jsSetMapLookups = defineRule({
 			if (isIndexedArrayElementWithStringArgument(receiver, node.arguments?.[0])) return;
 			const resolvedInitializer = getResolvedInitializer(receiver);
 			if (resolvedInitializer) {
-				if (isLikelyStringReceiver(resolvedInitializer.initializer)) return;
-				if (!resolvedInitializer.isDefault && isSmallInlineLiteralArray(resolvedInitializer.initializer)) return;
+				if (isLikelyStringReceiver(resolvedInitializer)) return;
+				if (isSmallInlineLiteralArray(resolvedInitializer)) return;
 			}
 			if (isStringElementOfSplitIteration(receiver)) return;
 			if (isReceiverDeclaredInNearestLoop(receiver, node)) return;
@@ -16110,21 +15926,14 @@ const jsxFilenameExtension = defineRule({
 });
 //#endregion
 //#region src/plugin/utils/is-jsx-fragment-element.ts
-const isJsxFragmentElement = (node, scopes) => {
+const isJsxFragmentElement = (node) => {
 	if (!isNodeOfType(node, "JSXOpeningElement")) return false;
 	const elementName = node.name;
-	if (isNodeOfType(elementName, "JSXIdentifier")) {
-		if (!scopes) return elementName.name === "Fragment";
-		const symbol = resolveConstIdentifierAlias(elementName, scopes);
-		if (!symbol) return elementName.name === "Fragment" && scopes.isGlobalReference(elementName);
-		return isImportedFromReact(symbol) && getImportedName(symbol.declarationNode) === "Fragment";
-	}
+	if (isNodeOfType(elementName, "JSXIdentifier")) return elementName.name === "Fragment";
 	if (isNodeOfType(elementName, "JSXMemberExpression")) {
 		if (!isNodeOfType(elementName.object, "JSXIdentifier")) return false;
-		if (elementName.property.name !== "Fragment") return false;
-		if (!scopes) return elementName.object.name === "React";
-		if (isReactNamespaceImport(elementName.object, scopes)) return true;
-		return elementName.object.name === "React" && scopes.isGlobalReference(elementName.object);
+		if (elementName.object.name !== "React") return false;
+		return elementName.property.name === "Fragment";
 	}
 	return false;
 };
@@ -16150,7 +15959,7 @@ const jsxFragments = defineRule({
 				if (mode !== "syntax") return;
 				if (!node.closingElement) return;
 				const openingElement = node.openingElement;
-				if (!isJsxFragmentElement(openingElement, context.scopes)) return;
+				if (!isJsxFragmentElement(openingElement)) return;
 				if (openingElement.attributes.length > 0) return;
 				context.report({
 					node: openingElement,
@@ -18831,6 +18640,10 @@ const resolveSettings$29 = (settings) => {
 	if (typeof reactDoctor !== "object" || reactDoctor === null) return {};
 	return reactDoctor.jsxNoScriptUrl ?? {};
 };
+const getElementName = (node) => {
+	if (isNodeOfType(node.name, "JSXIdentifier")) return node.name.name;
+	return null;
+};
 const isLinkPropForElement = (elementName, attributeName, options) => {
 	if (elementName === "a" && attributeName === "href") return true;
 	const explicit = options.components?.[elementName];
@@ -18850,8 +18663,7 @@ const jsxNoScriptUrl = defineRule({
 	create: (context) => {
 		const options = resolveSettings$29(context.settings);
 		return { JSXOpeningElement(node) {
-			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-			const elementName = resolveJsxElementType(node);
+			const elementName = getElementName(node);
 			if (!elementName) return;
 			for (const attribute of node.attributes) {
 				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
@@ -19038,6 +18850,11 @@ const checkTarget = (attributeValue) => {
 		alternate: false
 	};
 };
+const getOpeningElementName = (node) => {
+	const name = node.name;
+	if (isNodeOfType(name, "JSXIdentifier")) return name.name;
+	return null;
+};
 const jsxNoTargetBlank = defineRule({
 	id: "jsx-no-target-blank",
 	title: "Unsafe target=_blank link",
@@ -19057,8 +18874,7 @@ const jsxNoTargetBlank = defineRule({
 			return settings.formComponents.has(tagName);
 		};
 		return { JSXOpeningElement(node) {
-			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-			const tagName = resolveJsxElementType(node);
+			const tagName = getOpeningElementName(node);
 			if (!tagName) return;
 			if (!isLink(tagName) && !isForm(tagName)) return;
 			const linkAttributeNames = settings.linkComponents.get(tagName) ?? ["href"];
@@ -19291,7 +19107,7 @@ const jsxNoUselessFragment = defineRule({
 		return {
 			JSXElement(node) {
 				const openingElement = node.openingElement;
-				if (!isJsxFragmentElement(openingElement, context.scopes)) return;
+				if (!isJsxFragmentElement(openingElement)) return;
 				if (hasJsxKeyAttribute(openingElement)) return;
 				if (checkChildren(node, openingElement, node.children)) return;
 				if (isChildOfHtmlElement(node)) context.report({
@@ -20533,24 +20349,11 @@ const hasDirective = (programNode, directive) => {
 	return Boolean(programNode.body?.some((statement) => isNodeOfType(statement, "ExpressionStatement") && isNodeOfType(statement.expression, "Literal") && statement.expression.value === directive));
 };
 //#endregion
-//#region src/plugin/utils/unwrap-object-integrity-expression.ts
-const OBJECT_INTEGRITY_METHOD_NAMES = new Set([
-	"freeze",
-	"seal",
-	"preventExtensions"
-]);
-const OBJECT_FREEZE_OR_SEAL_METHOD_NAMES = new Set(["freeze", "seal"]);
-const unwrapObjectIntegrityExpression = (node, scopes, methodNames = OBJECT_INTEGRITY_METHOD_NAMES) => {
-	let expression = stripParenExpression(node);
-	while (isNodeOfType(expression, "CallExpression")) {
-		const callee = stripParenExpression(expression.callee);
-		if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.object, "Identifier") || callee.object.name !== "Object" || !scopes.isGlobalReference(callee.object) || !isNodeOfType(callee.property, "Identifier") || !methodNames.has(callee.property.name)) break;
-		const wrappedExpression = expression.arguments[0];
-		if (!wrappedExpression || isNodeOfType(wrappedExpression, "SpreadElement")) break;
-		expression = stripParenExpression(wrappedExpression);
-	}
-	return expression;
-};
+//#region src/plugin/utils/is-uppercase-name.ts
+const isUppercaseName = (name) => UPPERCASE_PATTERN.test(name);
+//#endregion
+//#region src/plugin/utils/is-component-assignment.ts
+const isComponentAssignment = (node) => isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && isUppercaseName(node.id.name) && Boolean(node.init) && (isNodeOfType(node.init, "ArrowFunctionExpression") || isNodeOfType(node.init, "FunctionExpression"));
 //#endregion
 //#region src/plugin/rules/nextjs/nextjs-async-client-component.ts
 const nextjsAsyncClientComponent = defineRule({
@@ -20576,10 +20379,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.`
@@ -20881,7 +20684,7 @@ const nextjsNoAElement = defineRule({
 	severity: "warn",
 	recommendation: "`import Link from 'next/link'` for client-side navigation, prefetching, and preserved scroll position",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (resolveJsxElementType(node) !== "a") return;
+		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a") return;
 		const attributes = node.attributes ?? [];
 		const downloadAttribute = findJsxAttribute(attributes, "download");
 		if (downloadAttribute) {
@@ -21077,7 +20880,7 @@ const nextjsNoCssLink = defineRule({
 	severity: "warn",
 	recommendation: "Import CSS directly or use CSS Modules so Next.js can bundle, order, and optimize the stylesheet.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (resolveJsxElementType(node) !== "link") return;
+		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "link") return;
 		const attributes = node.attributes ?? [];
 		const relAttribute = findJsxAttribute(attributes, "rel");
 		if (!relAttribute?.value) return;
@@ -21185,7 +20988,7 @@ const nextjsNoFontLink = defineRule({
 	severity: "warn",
 	recommendation: "`import { Inter } from \"next/font/google\"` for self-hosting, zero layout shift, and no render-blocking requests",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (resolveJsxElementType(node) !== "link") return;
+		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "link") return;
 		const attributes = node.attributes ?? [];
 		const hrefAttribute = findJsxAttribute(attributes, "href");
 		if (!hrefAttribute?.value) return;
@@ -21360,7 +21163,7 @@ const nextjsNoImgElement = defineRule({
 	create: (context) => {
 		if (isGeneratedImageRenderContext(context)) return {};
 		return { JSXOpeningElement(node) {
-			if (resolveJsxElementType(node) !== "img") return;
+			if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "img") return;
 			if (isGeneratedImageRenderContext(context, node)) return;
 			const programRoot = findProgramRoot(node);
 			if (programRoot && hasEmailTemplateImport(programRoot)) return;
@@ -21407,8 +21210,8 @@ const nextjsNoPolyfillScript = defineRule({
 	severity: "warn",
 	recommendation: "Next.js includes polyfills for fetch, Promise, Object.assign, Array.from, and 50+ others automatically",
 	create: (context) => ({ JSXOpeningElement(node) {
-		const elementName = resolveJsxElementType(node);
-		if (elementName !== "script" && elementName !== "Script") return;
+		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+		if (node.name.name !== "script" && node.name.name !== "Script") return;
 		const srcAttribute = findJsxAttribute(node.attributes ?? [], "src");
 		if (!srcAttribute?.value) return;
 		const srcValue = isNodeOfType(srcAttribute.value, "Literal") ? srcAttribute.value.value : null;
@@ -23216,15 +23019,10 @@ const isProp = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
 	if (!declaringNode) return false;
 	return isReactFunctionalComponent(declaringNode) && !isReactFunctionalHOC(analysis, declaringNode) || isCustomHook(declaringNode);
 }));
-const isWholePropsParameterBinding = (bindingNode) => {
-	if (isFunctionLike$1(bindingNode.parent)) return true;
-	let declaringFunction = bindingNode.parent;
-	while (declaringFunction && !isFunctionLike$1(declaringFunction)) declaringFunction = declaringFunction.parent;
-	return Boolean(declaringFunction && resolveFirstArgumentBinding(declaringFunction.params?.[0]) === bindingNode);
-};
 const isWholePropsObjectReference = (analysis, ref) => isProp(analysis, ref) && Boolean(ref.resolved?.defs.some((def) => {
 	if (def.type !== "Parameter") return false;
-	return isWholePropsParameterBinding(def.name);
+	const bindingParent = def.name.parent;
+	return isFunctionLike$1(bindingParent);
 }));
 const isIdentifierOrMemberExpression = (node) => isNodeOfType(node, "Identifier") || isNodeOfType(node, "MemberExpression");
 const isPropAlias = (analysis, ref) => {
@@ -26221,56 +26019,6 @@ const noBarrelImport = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/function-returns-matching-expression.ts
-const collectReturnedExpressions = (functionNode) => {
-	if (!isFunctionLike$1(functionNode)) return [];
-	const body = functionNode.body;
-	if (!body) return [];
-	if (!isNodeOfType(body, "BlockStatement")) return [body];
-	const returnedExpressions = [];
-	walkAst(body, (node) => {
-		if (node !== body && (isFunctionLike$1(node) || isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression"))) return false;
-		if (isNodeOfType(node, "ReturnStatement") && node.argument) returnedExpressions.push(node.argument);
-	});
-	return returnedExpressions;
-};
-const functionReturnsMatchingExpression = (functionNode, scopes, matchesExpression) => {
-	const visitedExpressions = /* @__PURE__ */ new Set();
-	const visitedFunctions = /* @__PURE__ */ new Set();
-	const functionMatches = (candidateFunction) => {
-		if (visitedFunctions.has(candidateFunction)) return false;
-		visitedFunctions.add(candidateFunction);
-		return collectReturnedExpressions(candidateFunction).some(expressionMatches);
-	};
-	const expressionMatches = (expression) => {
-		const unwrappedExpression = stripParenExpression(expression);
-		if (visitedExpressions.has(unwrappedExpression)) return false;
-		visitedExpressions.add(unwrappedExpression);
-		if (matchesExpression(unwrappedExpression)) return true;
-		if (isNodeOfType(unwrappedExpression, "Identifier")) {
-			const symbol = scopes.symbolFor(unwrappedExpression);
-			if (!symbol || symbol.kind !== "const" || !symbol.initializer) return false;
-			const initializer = stripParenExpression(symbol.initializer);
-			if (isFunctionLike$1(initializer)) return false;
-			return expressionMatches(initializer);
-		}
-		if (isNodeOfType(unwrappedExpression, "CallExpression")) {
-			if (unwrappedExpression.arguments.length !== 0) return false;
-			if (!isNodeOfType(unwrappedExpression.callee, "Identifier")) return false;
-			const symbol = scopes.symbolFor(unwrappedExpression.callee);
-			if (!symbol || symbol.kind !== "const" && symbol.kind !== "function") return false;
-			const initializer = symbol.initializer ? stripParenExpression(symbol.initializer) : null;
-			const candidateFunction = isFunctionLike$1(initializer) ? initializer : isFunctionLike$1(symbol.declarationNode) ? symbol.declarationNode : null;
-			if (!candidateFunction || candidateFunction.async || candidateFunction.generator || candidateFunction.params.length !== 0) return false;
-			return functionMatches(candidateFunction);
-		}
-		if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) return expressionMatches(unwrappedExpression.consequent) || expressionMatches(unwrappedExpression.alternate);
-		if (isNodeOfType(unwrappedExpression, "LogicalExpression")) return expressionMatches(unwrappedExpression.left) || expressionMatches(unwrappedExpression.right);
-		return false;
-	};
-	return functionMatches(functionNode);
-};
-//#endregion
 //#region src/plugin/utils/function-contains-react-render-output.ts
 const NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES = new Set([
 	"FunctionDeclaration",
@@ -26290,13 +26038,12 @@ const isCallArgumentFunctionExpression = (node) => {
 	return parent.arguments.some((argumentNode) => argumentNode === node);
 };
 const isNestedRenderEvidenceBoundary = (node) => NESTED_RENDER_EVIDENCE_BOUNDARY_TYPES.has(node.type) && !isCallArgumentFunctionExpression(node);
-const isRenderOutputExpression = (node, scopes) => node.type === "JSXElement" || node.type === "JSXFragment" || isReactApiCall(node, "createElement", scopes, REACT_CREATE_ELEMENT_OPTIONS);
 const containsRenderOutput$1 = (rootNode, scopes) => {
 	let hasRenderOutput = false;
 	walkAst(rootNode, (node) => {
 		if (hasRenderOutput) return false;
 		if (node !== rootNode && isNestedRenderEvidenceBoundary(node)) return false;
-		if (isRenderOutputExpression(node, scopes)) {
+		if (node.type === "JSXElement" || node.type === "JSXFragment" || isReactApiCall(node, "createElement", scopes, REACT_CREATE_ELEMENT_OPTIONS)) {
 			hasRenderOutput = true;
 			return false;
 		}
@@ -26307,7 +26054,7 @@ const renderOutputCache = /* @__PURE__ */ new WeakMap();
 const functionContainsReactRenderOutput = (functionNode, scopes) => {
 	const cachedEntry = renderOutputCache.get(functionNode);
 	if (cachedEntry && cachedEntry.scopes === scopes) return cachedEntry.hasRenderOutput;
-	const hasRenderOutput = containsRenderOutput$1(functionNode, scopes) || functionReturnsMatchingExpression(functionNode, scopes, (expression) => isRenderOutputExpression(expression, scopes));
+	const hasRenderOutput = containsRenderOutput$1(functionNode, scopes);
 	renderOutputCache.set(functionNode, {
 		scopes,
 		hasRenderOutput
@@ -26315,9 +26062,6 @@ const functionContainsReactRenderOutput = (functionNode, scopes) => {
 	return hasRenderOutput;
 };
 //#endregion
-//#region src/plugin/utils/is-component-assignment.ts
-const isComponentAssignment = (node) => isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && isUppercaseName(node.id.name) && Boolean(node.init) && (isNodeOfType(node.init, "ArrowFunctionExpression") || isNodeOfType(node.init, "FunctionExpression"));
-//#endregion
 //#region src/plugin/utils/is-component-declaration.ts
 const isComponentDeclaration = (node) => isNodeOfType(node, "FunctionDeclaration") && node.id !== null && Boolean(node.id?.name) && isUppercaseName(node.id.name);
 //#endregion
@@ -28775,7 +28519,7 @@ const noDisabledZoom = defineRule({
 	category: "Accessibility",
 	recommendation: "Remove `user-scalable=no` and `maximum-scale` from the viewport meta tag. If the layout breaks at 200% zoom, fix the layout instead.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (resolveJsxElementType(node) !== "meta") return;
+		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "meta") return;
 		const nameAttr = findJsxAttribute(node.attributes ?? [], "name");
 		if (!nameAttr?.value) return;
 		if ((isNodeOfType(nameAttr.value, "Literal") ? nameAttr.value.value : null) !== "viewport") return;
@@ -31947,7 +31691,7 @@ const noImgLazyWithHighFetchpriority = defineRule({
 	severity: "warn",
 	recommendation: "Don't combine `loading=\"lazy\"` with `fetchPriority=\"high\"`. A high-priority image (usually the LCP) should load eagerly; a lazy image is by definition not high priority.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (resolveJsxElementType(node) !== "img") return;
+		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "img") return;
 		const loadingAttribute = hasJsxPropIgnoreCase(node.attributes, "loading");
 		if (!loadingAttribute || getJsxPropStringValue(loadingAttribute)?.toLowerCase() !== "lazy") return;
 		const fetchPriorityAttribute = hasJsxPropIgnoreCase(node.attributes, "fetchPriority");
@@ -32188,7 +31932,7 @@ const noIndeterminateAttribute = defineRule({
 		if (classifyReactNativeFileTarget(context) === "react-native") return {};
 		return {
 			JSXOpeningElement(node) {
-				if (resolveJsxElementType(node) !== "input") return;
+				if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "input") return;
 				let typeAttribute = null;
 				let typeAttributeIndex = null;
 				let indeterminateAttribute = null;
@@ -32367,12 +32111,11 @@ const isMemoCall = (node) => {
 };
 const isDefaultEquivalentComparator = (comparator) => isNodeOfType(comparator, "Identifier") && (comparator.name === "undefined" || comparator.name === "shallowEqual");
 const hasCustomComparator = (node) => isNodeOfType(node, "CallExpression") && (node.arguments?.length ?? 0) >= 2 && !isDefaultEquivalentComparator(node.arguments?.[1]);
-const isInlineReference = (node, scopes) => {
-	const referenceNode = unwrapObjectIntegrityExpression(node, scopes);
-	if (isNodeOfType(referenceNode, "ArrowFunctionExpression") || isNodeOfType(referenceNode, "FunctionExpression") || isNodeOfType(referenceNode, "CallExpression") && isNodeOfType(referenceNode.callee, "MemberExpression") && isNodeOfType(referenceNode.callee.property, "Identifier") && referenceNode.callee.property.name === "bind") return "functions";
-	if (isNodeOfType(referenceNode, "ObjectExpression")) return "objects";
-	if (isNodeOfType(referenceNode, "ArrayExpression")) return "Arrays";
-	if (isNodeOfType(referenceNode, "JSXElement") || isNodeOfType(referenceNode, "JSXFragment")) return "JSX";
+const isInlineReference = (node) => {
+	if (isNodeOfType(node, "ArrowFunctionExpression") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "bind") return "functions";
+	if (isNodeOfType(node, "ObjectExpression")) return "objects";
+	if (isNodeOfType(node, "ArrayExpression")) return "Arrays";
+	if (isNodeOfType(node, "JSXElement") || isNodeOfType(node, "JSXFragment")) return "JSX";
 	return null;
 };
 const noInlinePropOnMemoComponent = defineRule({
@@ -32402,7 +32145,7 @@ const noInlinePropOnMemoComponent = defineRule({
 				let elementName = null;
 				if (isNodeOfType(openingElement.name, "JSXIdentifier")) elementName = openingElement.name.name;
 				if (!elementName || !memoizedComponentNames.has(elementName)) return;
-				const propType = isInlineReference(node.value.expression, context.scopes);
+				const propType = isInlineReference(node.value.expression);
 				if (propType) context.report({
 					node: node.value.expression,
 					message: `This redraws ${elementName} on every render because the prop is ${propType} built right here, so memo() can't skip it. Move it to a stable value with useMemo, useCallback, or module scope`
@@ -33261,13 +33004,11 @@ const noManyBooleanProps = defineRule({
 		};
 		const checkComponent = (functionNode, param, body, componentName, reportNode) => {
 			if (!param) return;
-			const propsBinding = resolveFirstArgumentBinding(param);
-			if (!propsBinding) return;
 			if (!functionContainsReactRenderOutput(functionNode, context.scopes)) return;
-			if (isNodeOfType(propsBinding, "ObjectPattern")) {
+			if (isNodeOfType(param, "ObjectPattern")) {
 				const callbackUsedNames = collectCallbackUsedNames(body, param, context.scopes);
 				const booleanLikePropNames = [];
-				for (const property of propsBinding.properties ?? []) {
+				for (const property of param.properties ?? []) {
 					if (!isNodeOfType(property, "Property")) continue;
 					const keyName = isNodeOfType(property.key, "Identifier") ? property.key.name : null;
 					if (!keyName) continue;
@@ -33278,7 +33019,7 @@ const noManyBooleanProps = defineRule({
 				reportIfMany(booleanLikePropNames, componentName, reportNode);
 				return;
 			}
-			if (isNodeOfType(propsBinding, "Identifier")) reportIfMany([...collectBooleanLikePropsFromBody(body, propsBinding.name)], componentName, reportNode);
+			if (isNodeOfType(param, "Identifier")) reportIfMany([...collectBooleanLikePropsFromBody(body, param.name)], componentName, reportNode);
 		};
 		return {
 			FunctionDeclaration(node) {
@@ -36030,7 +35771,7 @@ const noPreventDefault = defineRule({
 		const isServerActionsFramework = hasCapability(context.settings, "server-actions");
 		const formMessage = isServerActionsFramework ? FORM_MESSAGE_SERVER_CAPABLE : FORM_MESSAGE_GENERIC;
 		return { JSXOpeningElement(node) {
-			const elementName = resolveJsxElementType(node);
+			const elementName = isNodeOfType(node.name, "JSXIdentifier") ? node.name.name : null;
 			if (!elementName) return;
 			const targetEventProps = PREVENT_DEFAULT_ELEMENTS.get(elementName);
 			if (!targetEventProps) return;
@@ -38494,10 +38235,9 @@ const noStringFalseOnBooleanAttribute = defineRule({
 	recommendation: "Use the boolean form on boolean attributes: `disabled` / `disabled={true}` / `disabled={false}`, not `disabled=\"false\"`. A non-empty string is truthy, so `=\"false\"` actually turns the attribute ON.",
 	create: (context) => ({ JSXOpeningElement(node) {
 		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-		const elementName = resolveJsxElementType(node);
-		const firstCharacter = elementName.charCodeAt(0);
+		const firstCharacter = node.name.name.charCodeAt(0);
 		if (firstCharacter < 97 || firstCharacter > 122) return;
-		if (elementName.includes("-")) return;
+		if (node.name.name.includes("-")) return;
 		for (const attribute of node.attributes) {
 			if (!isNodeOfType(attribute, "JSXAttribute")) continue;
 			if (!isNodeOfType(attribute.name, "JSXIdentifier")) continue;
@@ -38885,7 +38625,8 @@ const noUncontrolledInput = defineRule({
 			const undefinedInitialStateNames = isNodeOfType(componentBody, "BlockStatement") ? collectUndefinedInitialStateNames(componentBody) : /* @__PURE__ */ new Set();
 			walkAst(componentBody, (child) => {
 				if (!isNodeOfType(child, "JSXOpeningElement")) return;
-				const tagName = resolveJsxElementType(child);
+				if (!isNodeOfType(child.name, "JSXIdentifier")) return;
+				const tagName = child.name.name;
 				if (!UNCONTROLLED_INPUT_TAGS.has(tagName)) return;
 				const attributes = child.attributes ?? [];
 				if (hasJsxSpreadAttribute(attributes)) return;
@@ -38946,7 +38687,7 @@ const noUndeferredThirdParty = defineRule({
 	severity: "warn",
 	recommendation: "Use `next/script` with `strategy=\"lazyOnload\"`, or add the `defer` attribute.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (resolveJsxElementType(node) !== "script") return;
+		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "script") return;
 		const attributes = node.attributes ?? [];
 		const srcAttribute = findJsxAttribute(attributes, "src");
 		if (!srcAttribute) return;
@@ -40161,7 +39902,7 @@ const noUnknownProperty = defineRule({
 				}
 				if (fileIsNonReactJsx) return;
 				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-				const elementType = resolveJsxElementType(node);
+				const elementType = node.name.name;
 				const firstCharacter = elementType.charCodeAt(0);
 				if (!(firstCharacter >= 97 && firstCharacter <= 122) || elementType === "fbt" || elementType === "fbs") return;
 				let isValidHtmlTag = isKnownDomTag(elementType);
@@ -40339,21 +40080,20 @@ const expressionContainsJsxOrCreateElement = (root) => {
 	});
 	return found;
 };
-const functionContainsJsxOrCreateElement = (functionNode, scopes) => expressionContainsJsxOrCreateElement(functionNode) || functionReturnsMatchingExpression(functionNode, scopes, expressionContainsJsxOrCreateElement);
 const isReactClassComponent = (classNode) => {
 	if (isEs6Component(classNode)) return true;
 	return expressionContainsJsxOrCreateElement(classNode);
 };
-const findEnclosingComponent = (node, scopes) => {
+const findEnclosingComponent = (node) => {
 	let walker = node.parent;
 	while (walker) {
 		if (isFunctionLike$1(walker)) {
 			const componentName = inferFunctionLikeName(walker);
-			if (componentName && isReactComponentName(componentName) && functionContainsJsxOrCreateElement(walker, scopes)) return {
+			if (componentName && isReactComponentName(componentName) && expressionContainsJsxOrCreateElement(walker)) return {
 				component: walker,
 				name: componentName
 			};
-			if (!componentName && functionContainsJsxOrCreateElement(walker, scopes) && walker.parent && isNodeOfType(walker.parent, "ExportDefaultDeclaration")) return {
+			if (!componentName && expressionContainsJsxOrCreateElement(walker) && walker.parent && isNodeOfType(walker.parent, "ExportDefaultDeclaration")) return {
 				component: walker,
 				name: null
 			};
@@ -40592,7 +40332,7 @@ const noUnstableNestedComponents = defineRule({
 				if (renderPropRegex.test(propInfo.propName)) return;
 				if (settings.allowAsProps) return;
 			}
-			const enclosing = findEnclosingComponent(candidateNode, context.scopes);
+			const enclosing = findEnclosingComponent(candidateNode);
 			if (!enclosing) return;
 			const gatedName = propInfo ? null : requiredInstantiationName;
 			queuedReports.push({
@@ -40603,7 +40343,7 @@ const noUnstableNestedComponents = defineRule({
 			});
 		};
 		const checkFunctionLike = (node) => {
-			if (!functionContainsJsxOrCreateElement(node, context.scopes)) return;
+			if (!expressionContainsJsxOrCreateElement(node)) return;
 			const inferredName = inferFunctionLikeName(node);
 			const propInfo = isComponentDeclaredInProp(node);
 			const isObjectCallback = isObjectCallbackCandidate(node);
@@ -41863,7 +41603,7 @@ const preactPreferOndblclick = defineRule({
 	recommendation: "Rename `onDoubleClick` to `onDblClick` because Preact core listens for the DOM `dblclick` event name and `onDoubleClick` never fires.",
 	create: (context) => ({ JSXOpeningElement(node) {
 		if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-		const tagName = resolveJsxElementType(node);
+		const tagName = node.name.name;
 		if (tagName.length === 0 || tagName[0] !== tagName[0].toLowerCase()) return;
 		const onDoubleClickAttribute = findJsxAttribute(node.attributes, "onDoubleClick");
 		if (!onDoubleClickAttribute) return;
@@ -41883,7 +41623,7 @@ const COMPAT_EXEMPT_INPUT_TYPES = new Set([
 ]);
 const isTextLikeInput = (openingElement) => {
 	if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return false;
-	const tagName = resolveJsxElementType(openingElement);
+	const tagName = openingElement.name.name;
 	if (tagName === "textarea") return true;
 	if (tagName !== "input") return false;
 	const typeAttribute = findJsxAttribute(openingElement.attributes, "type");
@@ -42040,9 +41780,8 @@ const CROSS_CUTTING_STATE_BOOLEAN_NAMES = new Set([
 ]);
 const collectBooleanPropBindings = (param) => {
 	const bindings = /* @__PURE__ */ new Set();
-	const propsBinding = resolveFirstArgumentBinding(param);
-	if (!isNodeOfType(propsBinding, "ObjectPattern")) return bindings;
-	for (const property of propsBinding.properties ?? []) {
+	if (!param || !isNodeOfType(param, "ObjectPattern")) return bindings;
+	for (const property of param.properties ?? []) {
 		if (!isNodeOfType(property, "Property")) continue;
 		if (property.computed) continue;
 		if (!isNodeOfType(property.key, "Identifier")) continue;
@@ -42303,7 +42042,7 @@ const preferHtmlDialog = defineRule({
 			},
 			JSXOpeningElement(node) {
 				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-				const tagName = resolveJsxElementType(node);
+				const tagName = node.name.name;
 				if (tagName === "dialog") return;
 				if (tagName.length === 0 || tagName[0] !== tagName[0].toLowerCase()) return;
 				if (!HTML_TAGS.has(tagName)) return;
@@ -43850,13 +43589,13 @@ const resolveTanstackQueryHookName = (callExpression) => {
 	}
 	return null;
 };
-const resolveHookNameFromInitializer = (initializer, scopes) => {
+const resolveHookNameFromInitializer = (initializer) => {
 	if (isNodeOfType(initializer, "CallExpression")) return resolveTanstackQueryHookName(initializer);
 	if (!isNodeOfType(initializer, "Identifier")) return null;
-	const resolvedSymbol = resolveConstIdentifierAlias(initializer, scopes);
-	if (resolvedSymbol?.kind !== "const" || !resolvedSymbol.initializer) return null;
-	if (!isNodeOfType(resolvedSymbol.initializer, "CallExpression")) return null;
-	return resolveTanstackQueryHookName(resolvedSymbol.initializer);
+	const binding = findVariableInitializer(initializer, initializer.name);
+	if (!binding?.initializer || !isConstDeclaredBinding(binding)) return null;
+	if (!isNodeOfType(binding.initializer, "CallExpression")) return null;
+	return resolveTanstackQueryHookName(binding.initializer);
 };
 const queryNoRestDestructuring = defineRule({
 	id: "query-no-rest-destructuring",
@@ -43869,7 +43608,7 @@ const queryNoRestDestructuring = defineRule({
 		if (!isNodeOfType(node.id, "ObjectPattern")) return;
 		if (!node.init) return;
 		if (!node.id.properties?.some((property) => isNodeOfType(property, "RestElement"))) return;
-		const hookName = resolveHookNameFromInitializer(node.init, context.scopes);
+		const hookName = resolveHookNameFromInitializer(node.init);
 		if (!hookName) return;
 		context.report({
 			node: node.id,
@@ -44340,7 +44079,7 @@ const renderingAnimateSvgWrapper = defineRule({
 	severity: "warn",
 	recommendation: "Wrap the SVG in a motion element so animation props apply to a stable wrapper instead of the SVG node itself.",
 	create: (context) => ({ JSXOpeningElement(node) {
-		if (resolveJsxElementType(node) !== "svg") return;
+		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "svg") return;
 		if (node.attributes?.some((attribute) => isNodeOfType(attribute, "JSXAttribute") && isNodeOfType(attribute.name, "JSXIdentifier") && MOTION_ANIMATE_PROPS.has(attribute.name.name))) context.report({
 			node,
 			message: "This is slow to render because you animate <svg> directly, so wrap it in a <div> or <motion.div> & animate that instead"
@@ -45224,7 +44963,7 @@ const DEFERRABLE_HOOK_NAMES = new Set([
 	"useParams",
 	"usePathname"
 ]);
-const findHookCallBindings = (componentBody, scopes) => {
+const findHookCallBindings = (componentBody) => {
 	const bindings = [];
 	if (!isNodeOfType(componentBody, "BlockStatement")) return bindings;
 	for (const statement of componentBody.body ?? []) {
@@ -45235,10 +44974,8 @@ const findHookCallBindings = (componentBody, scopes) => {
 			const callee = declarator.init.callee;
 			if (!isNodeOfType(callee, "Identifier")) continue;
 			if (!DEFERRABLE_HOOK_NAMES.has(callee.name)) continue;
-			const valueSymbol = scopes.symbolFor(declarator.id);
-			if (!valueSymbol) continue;
 			bindings.push({
-				valueSymbol,
+				valueName: declarator.id.name,
 				hookName: callee.name,
 				declarator
 			});
@@ -45246,49 +44983,6 @@ const findHookCallBindings = (componentBody, scopes) => {
 	}
 	return bindings;
 };
-const collectExactAliasSymbols = (componentBody, sourceSymbol, scopes) => {
-	const symbols = [sourceSymbol];
-	const symbolIds = new Set([sourceSymbol.id]);
-	const aliasSourceIdentifiers = /* @__PURE__ */ new Set();
-	if (!isNodeOfType(componentBody, "BlockStatement")) return {
-		symbols,
-		aliasSourceIdentifiers
-	};
-	let didFindAlias = true;
-	while (didFindAlias) {
-		didFindAlias = false;
-		for (const statement of componentBody.body ?? []) {
-			if (!isNodeOfType(statement, "VariableDeclaration") || statement.kind !== "const") continue;
-			for (const declarator of statement.declarations ?? []) {
-				let aliasIdentifier = null;
-				let sourceIdentifier = null;
-				const initializer = declarator.init ? stripParenExpression(declarator.init) : null;
-				const arrayBinding = isNodeOfType(declarator.id, "ArrayPattern") ? declarator.id.elements[0] : null;
-				const arrayValueNode = isNodeOfType(initializer, "ArrayExpression") ? initializer.elements[0] : null;
-				const arrayValue = arrayValueNode && !isNodeOfType(arrayValueNode, "SpreadElement") ? stripParenExpression(arrayValueNode) : null;
-				if (isNodeOfType(declarator.id, "Identifier") && isNodeOfType(initializer, "Identifier")) {
-					aliasIdentifier = declarator.id;
-					sourceIdentifier = initializer;
-				} else if (isNodeOfType(declarator.id, "ArrayPattern") && declarator.id.elements.length === 1 && isNodeOfType(arrayBinding, "Identifier") && isNodeOfType(initializer, "ArrayExpression") && initializer.elements.length === 1 && isNodeOfType(arrayValue, "Identifier")) {
-					aliasIdentifier = arrayBinding;
-					sourceIdentifier = arrayValue;
-				}
-				if (!aliasIdentifier || !sourceIdentifier) continue;
-				const referencedSymbol = scopes.symbolFor(sourceIdentifier);
-				const aliasSymbol = scopes.symbolFor(aliasIdentifier);
-				if (!referencedSymbol || !symbolIds.has(referencedSymbol.id) || !aliasSymbol || aliasSymbol.kind !== "const" || symbolIds.has(aliasSymbol.id)) continue;
-				symbolIds.add(aliasSymbol.id);
-				symbols.push(aliasSymbol);
-				aliasSourceIdentifiers.add(sourceIdentifier);
-				didFindAlias = true;
-			}
-		}
-	}
-	return {
-		symbols,
-		aliasSourceIdentifiers
-	};
-};
 const rerenderDeferReadsHook = defineRule({
 	id: "rerender-defer-reads-hook",
 	title: "URL hook value only read in handlers",
@@ -45299,13 +44993,15 @@ const rerenderDeferReadsHook = defineRule({
 	create: (context) => {
 		const checkComponent = (componentBody) => {
 			if (!componentBody || !isNodeOfType(componentBody, "BlockStatement")) return;
-			const bindings = findHookCallBindings(componentBody, context.scopes);
+			const bindings = findHookCallBindings(componentBody);
 			if (bindings.length === 0) return;
 			const handlerBindingNames = collectHandlerBindingNames(componentBody);
 			for (const binding of bindings) {
-				const { symbols, aliasSourceIdentifiers } = collectExactAliasSymbols(componentBody, binding.valueSymbol, context.scopes);
 				const referenceLocations = [];
-				for (const symbol of symbols) for (const reference of symbol.references) if (!aliasSourceIdentifiers.has(reference.identifier)) referenceLocations.push(reference.identifier);
+				walkAst(componentBody, (child) => {
+					if (isNodeOfType(binding.declarator, "VariableDeclarator") && child === binding.declarator.id) return;
+					if (isNodeOfType(child, "Identifier") && child.name === binding.valueName) referenceLocations.push(child);
+				});
 				if (referenceLocations.length === 0) continue;
 				if (!referenceLocations.every((ref) => isInsideEventHandler(ref, handlerBindingNames))) continue;
 				context.report({
@@ -45676,10 +45372,14 @@ const rerenderLazyStateInit = defineRule({
 //#endregion
 //#region src/plugin/rules/performance/rerender-memo-before-early-return.ts
 const isJsxExpression = (node) => Boolean(node && isJsxElementOrFragment(stripParenExpression(node)));
-const callbackReturnsJsx = (callback, scopes) => {
+const callbackReturnsJsx = (callback) => {
 	if (!callback) return false;
 	if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return false;
-	return functionReturnsMatchingExpression(callback, scopes, isJsxExpression);
+	const body = callback.body;
+	if (isJsxExpression(body)) return true;
+	if (!isNodeOfType(body, "BlockStatement")) return false;
+	for (const stmt of body.body ?? []) if (isNodeOfType(stmt, "ReturnStatement") && isJsxExpression(stmt.argument)) return true;
+	return false;
 };
 const returnArgumentUsesAnyName = (returnStatement, names) => {
 	if (!isNodeOfType(returnStatement, "ReturnStatement") || !returnStatement.argument) return false;
@@ -45757,7 +45457,7 @@ const rerenderMemoBeforeEarlyReturn = defineRule({
 					if (!isNodeOfType(stmt, "VariableDeclaration")) continue;
 					for (const declarator of stmt.declarations ?? []) {
 						const init = declarator.init;
-						if (isNodeOfType(init, "CallExpression") && isHookCall$2(init, "useMemo") && callbackReturnsJsx(init.arguments?.[0], context.scopes)) {
+						if (isNodeOfType(init, "CallExpression") && isHookCall$2(init, "useMemo") && callbackReturnsJsx(init.arguments?.[0])) {
 							memoNode = declarator;
 							callbackGuardTests = collectLeadingCallbackGuardTests(init.arguments?.[0]);
 							if (isNodeOfType(declarator.id, "Identifier")) memoConsumerNames.add(declarator.id.name);
@@ -45823,11 +45523,8 @@ const collectFromObjectPattern = (pattern, bindings) => {
 const collectDefaultedEmptyBindings = (functionNode) => {
 	const bindings = /* @__PURE__ */ new Map();
 	const params = functionNode.params ?? [];
-	for (const [parameterIndex, param] of params.entries()) {
-		const parameterBinding = parameterIndex === 0 ? resolveFirstArgumentBinding(param) : param;
-		if (parameterBinding) collectFromObjectPattern(parameterBinding, bindings);
-	}
-	const propsParam = resolveFirstArgumentBinding(params[0]);
+	for (const param of params) collectFromObjectPattern(param, bindings);
+	const propsParam = params[0];
 	const body = functionNode.body;
 	if (!propsParam || !isNodeOfType(propsParam, "Identifier") || !body) return bindings;
 	if (!isNodeOfType(body, "BlockStatement")) return bindings;
@@ -53254,8 +52951,7 @@ const serverCacheWithObjectLiteral = defineRule({
 				if (!isNodeOfType(node.callee, "Identifier")) return;
 				if (!cachedFunctionNames.has(node.callee.name)) return;
 				const firstArg = node.arguments?.[0];
-				if (!firstArg || isNodeOfType(firstArg, "SpreadElement")) return;
-				if (!isNodeOfType(unwrapObjectIntegrityExpression(firstArg, context.scopes, OBJECT_FREEZE_OR_SEAL_METHOD_NAMES), "ObjectExpression")) return;
+				if (!isNodeOfType(firstArg, "ObjectExpression")) return;
 				context.report({
 					node,
 					message: `Passing a new object to React.cache() each render misses the cache, so it refetches every request.`
@@ -53942,6 +53638,10 @@ const isInvalidStyleExpression = (expression) => {
 	}
 	return false;
 };
+const getJsxOpeningElementName = (node) => {
+	if (isNodeOfType(node.name, "JSXIdentifier")) return node.name.name;
+	return null;
+};
 const stylePropObject = defineRule({
 	id: "style-prop-object",
 	title: "Style prop is not an object",
@@ -53953,8 +53653,7 @@ const stylePropObject = defineRule({
 		const allowSet = new Set(allow);
 		return {
 			JSXOpeningElement(node) {
-				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
-				const elementName = resolveJsxElementType(node);
+				const elementName = getJsxOpeningElementName(node);
 				if (elementName && allowSet.has(elementName)) return;
 				if (elementName) {
 					const firstCharCode = elementName.charCodeAt(0);
@@ -54659,7 +54358,7 @@ const tanstackStartNoAnchorElement = defineRule({
 	create: (context) => {
 		if (!isInProjectDirectory(context, "routes")) return {};
 		return { JSXOpeningElement(node) {
-			if (resolveJsxElementType(node) !== "a") return;
+			if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "a") return;
 			const attributes = node.attributes ?? [];
 			const hrefAttribute = findJsxAttribute(attributes, "href");
 			if (!hrefAttribute?.value) return;
@@ -55280,7 +54979,8 @@ const voidDomElementsNoChildren = defineRule({
 	create: (context) => ({
 		JSXElement(node) {
 			const openingElement = node.openingElement;
-			const tagName = resolveJsxElementType(openingElement);
+			if (!isNodeOfType(openingElement.name, "JSXIdentifier")) return;
+			const tagName = openingElement.name.name;
 			if (!VOID_DOM_ELEMENTS.has(tagName)) return;
 			const hasChildrenContent = node.children.some(isMeaningfulJsxChild);
 			const hasChildrenLikeProp = findChildrenLikePropName(openingElement.attributes);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.6-dev.81e6647",
+  "version": "0.7.6-dev.82e10cd",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",