oxlint-plugin-react-doctor 0.7.6-dev.e877ca7 → 0.7.6-dev.f215ace

package/dist/index.js

@@ -1518,6 +1518,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 +1561,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 +2397,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 +5754,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 +5944,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) {
@@ -6929,6 +6955,30 @@ const corsCookieTrustRisk = defineRule({
 	})
 });
 //#endregion
+//#region src/plugin/rules/security-scan/utils/find-matching-bracket.ts
+const findMatchingBracket = (content, openIndex) => {
+	const open = content[openIndex];
+	const close = open === "(" ? ")" : open === "{" ? "}" : open === "[" ? "]" : "";
+	if (close === "") return -1;
+	let depth = 0;
+	let stringDelimiter = null;
+	for (let index = openIndex; index < content.length; index += 1) {
+		const character = content[index];
+		if (stringDelimiter !== null) {
+			if (character === "\\") index += 1;
+			else if (character === stringDelimiter) stringDelimiter = null;
+			continue;
+		}
+		if (character === "\"" || character === "'" || character === "`") stringDelimiter = character;
+		else if (character === open) depth += 1;
+		else if (character === close) {
+			depth -= 1;
+			if (depth === 0) return index;
+		}
+	}
+	return -1;
+};
+//#endregion
 //#region src/plugin/rules/security-scan/dangerous-html-sink.ts
 const DANGEROUS_HTML_PATTERN = /dangerouslySetInnerHTML|(?:\.(?:inner|outer)HTML|\[\s*["'](?:inner|outer)HTML["']\s*\])\s*[+]?=(?!=)|\.insertAdjacentHTML\s*\(|\bdocument\.write(?:ln)?\s*\(|\.(?:createContextualFragment|setHTMLUnsafe)\s*\(/;
 const HTML_VALUE_START_PATTERN = /(?:__html\s*:|(?:\.(?:inner|outer)HTML|\[\s*["'](?:inner|outer)HTML["']\s*\])\s*[+]?=(?!=)|\.insertAdjacentHTML\s*\(\s*[^,]*,|\bdocument\.write(?:ln)?\s*\(|\.(?:createContextualFragment|setHTMLUnsafe)\s*\()\s*([\s\S]*)/;
@@ -6944,6 +6994,7 @@ const I18N_VALUE_PATTERN = /\b(?:t|i18n|translate|formatMessage|intl)\s*[.(]/;
 const ESCAPING_SERIALIZER_CALL_PATTERN = /^(?:[\w$.]+\.)?(?:toHtml|render[A-Za-z]*(?:Html|HTML)|renderToString|renderToStaticMarkup|codeToHtml|codeToHast|highlight[A-Za-z]*)\s*\(/;
 const HIGHLIGHTER_LIBRARY_PATTERN = /\b(?:shiki|prism|hljs|highlightjs|getHighlighter|codeToHtml|codeToHast|refractor|lowlight|starry-night)\b|highlight\.js/i;
 const SERIALIZER_ASSIGNMENT_PATTERN = /[:=]\s*[^\n;]*(?:\b(?:katex|shiki|hljs|prism|mermaid)\b|hast-util-to-html|renderHtmlFromRichText|(?:toHtml|render[A-Za-z]*(?:Html|HTML)|renderToString|renderToStaticMarkup|codeToHtml|codeToHast)\s*\()/i;
+const SERIALIZER_CALL_PROVENANCE_PATTERN = /\b(?:(?:katex|shiki|hljs|prism|mermaid|highlighter)[\w$]*\.(?:render\w*|highlight\w*|codeTo(?:Html|Hast))|(?:toHtml|render(?:Html|HTML)[A-Za-z]*|render[A-Za-z]*(?:Html|HTML)|renderToString|renderToStaticMarkup|codeToHtml|codeToHast|highlight[A-Za-z]*))\s*\(/i;
 const BARE_IDENTIFIER_VALUE_PATTERN = /^[\w$]+\s*(?:[;,})\n]|$)/;
 const IDENTIFIER_WITH_LITERAL_FALLBACK_PATTERN = /^[\w$]+\s*(?:\|\||\?\?)\s*(?:"[^"\n]*"|'[^'\n]*'|`[^`$]*`)\s*(?:[;,})\n]|$)/;
 const MEMBER_OR_INDEX_ACCESS_VALUE_PATTERN = /^[\w$]+(?:\.[\w$]+|\[[^\]]*\])+\s*(?:[;,})\n]|$)/;
@@ -7103,22 +7154,66 @@ const findContainingBlockEndIndex = (fileContent, targetIndex) => {
 	return openingBraceIndex === void 0 ? fileContent.length : findMatchingBraceIndex(fileContent, openingBraceIndex);
 };
 const findVisibleIdentifierDeclaration = (identifier, sinkIndex, fileContent) => {
-	const initializerPattern = new RegExp(`(?:const|let|var)\\s+${escapeRegExp(identifier)}\\s*(?::[^=\\n]*)?=\\s*([^;\\n]+)`, "g");
+	const initializerPattern = new RegExp(`(const|let|var)\\s+${escapeRegExp(identifier)}\\s*(?::[^=\\n]*)?=\\s*([^;\\n]+)`, "g");
 	let nearestDeclaration = null;
 	let nearestDeclarationIndex = -1;
 	for (const match of fileContent.matchAll(initializerPattern)) {
 		const declarationIndex = match.index;
 		if (declarationIndex === void 0 || declarationIndex >= sinkIndex || declarationIndex <= nearestDeclarationIndex || findContainingBlockEndIndex(fileContent, declarationIndex) < sinkIndex) continue;
 		nearestDeclarationIndex = declarationIndex;
-		const initializer = match[1];
+		const initializer = match[2];
 		if (initializer === void 0) continue;
 		nearestDeclaration = {
+			declarationIndex,
 			initializer,
-			initializerStartIndex: declarationIndex + match[0].length - initializer.length
+			initializerStartIndex: declarationIndex + match[0].length - initializer.length,
+			isImmutable: match[1] === "const"
 		};
 	}
 	return nearestDeclaration;
 };
+const isDeclarationStable = (identifier, declaration, usageIndex, fileContent) => {
+	if (declaration.isImmutable) return true;
+	const textAfterInitializer = fileContent.slice(declaration.initializerStartIndex + declaration.initializer.length, usageIndex);
+	return !new RegExp(`(?:^|[^\\w$.])${escapeRegExp(identifier)}\\s*=(?!=)`).test(textAfterInitializer);
+};
+const isTrustedHighlighterValue = (valueExpression, fileContent, sinkIndex) => {
+	if (!/highlight/i.test(valueExpression)) return false;
+	const identifier = valueExpression.match(/^([\w$]+)/)?.[1];
+	if (identifier === void 0) return false;
+	const declaration = findVisibleIdentifierDeclaration(identifier, sinkIndex, fileContent);
+	if (declaration !== null) return isDeclarationStable(identifier, declaration, sinkIndex, fileContent) && SERIALIZER_CALL_PROVENANCE_PATTERN.test(declaration.initializer);
+	return /highlighted/i.test(valueExpression) || HIGHLIGHTER_LIBRARY_PATTERN.test(fileContent);
+};
+const isExplicitlyTrustedHtmlValue = (valueExpression, fileContent, sinkIndex, visitedIdentifiers = /* @__PURE__ */ new Set()) => {
+	const trimmedExpression = valueExpression.trim();
+	const concatenatedParts = splitTopLevelByPlus(trimmedExpression);
+	if (concatenatedParts.length > 1) return concatenatedParts.every((part) => isExplicitlyTrustedHtmlValue(part, fileContent, sinkIndex, visitedIdentifiers));
+	const interpolationParts = [...trimmedExpression.matchAll(/\$\{([^}]*)\}/g)].flatMap((match) => match[1] === void 0 ? [] : [match[1]]);
+	if (interpolationParts.length > 1) return interpolationParts.every((part) => isExplicitlyTrustedHtmlValue(part, fileContent, sinkIndex, visitedIdentifiers));
+	const identifier = trimmedExpression.match(/^([\w$]+)(?:(?:\??\.[\w$]+)|(?:\[\s*(?:"[^"\n]*"|'[^'\n]*'|\d+)\s*\]))*$/)?.[1];
+	if (identifier && !visitedIdentifiers.has(identifier)) {
+		const declaration = findVisibleIdentifierDeclaration(identifier, sinkIndex, fileContent);
+		if (declaration && isDeclarationStable(identifier, declaration, sinkIndex, fileContent)) {
+			const nextVisitedIdentifiers = new Set(visitedIdentifiers);
+			nextVisitedIdentifiers.add(identifier);
+			return isExplicitlyTrustedHtmlValue(declaration.initializer, fileContent, declaration.initializerStartIndex, nextVisitedIdentifiers);
+		}
+	}
+	if (STRING_LITERAL_VALUE_PATTERN.test(`${trimmedExpression};`) || MODULE_CONSTANT_VALUE_PATTERN.test(`${trimmedExpression};`) || SANITIZER_PATTERN.test(trimmedExpression) || ENV_CONFIG_VALUE_PATTERN.test(trimmedExpression) || I18N_VALUE_PATTERN.test(trimmedExpression) || ESCAPING_SERIALIZER_CALL_PATTERN.test(trimmedExpression) || isTrustedHighlighterValue(trimmedExpression, fileContent, sinkIndex)) return true;
+	return false;
+};
+const doesExpressionAliasIdentifier = (expression, targetIdentifier, expressionIndex, fileContent, visitedIdentifiers = /* @__PURE__ */ new Set()) => {
+	const identifier = expression.trim().match(/^([\w$]+)$/)?.[1];
+	if (!identifier) return false;
+	if (identifier === targetIdentifier) return true;
+	if (visitedIdentifiers.has(identifier)) return false;
+	const declaration = findVisibleIdentifierDeclaration(identifier, expressionIndex, fileContent);
+	if (!declaration?.isImmutable) return false;
+	const nextVisitedIdentifiers = new Set(visitedIdentifiers);
+	nextVisitedIdentifiers.add(identifier);
+	return doesExpressionAliasIdentifier(declaration.initializer, targetIdentifier, declaration.initializerStartIndex, fileContent, nextVisitedIdentifiers);
+};
 const findContainingFunctionParameterSource = (identifier, sinkIndex, fileContent) => {
 	const patterns = [/function\s+([\w$]+)\s*\(([^)]*)\)\s*\{/g, /(?:const|let|var)\s+([\w$]+)\s*=\s*(?:async\s*)?\(([^)]*)\)\s*=>\s*\{/g];
 	let closestSource = null;
@@ -7126,12 +7221,16 @@ const findContainingFunctionParameterSource = (identifier, sinkIndex, fileConten
 	for (const pattern of patterns) for (const match of fileContent.matchAll(pattern)) {
 		const matchIndex = match.index;
 		if (matchIndex === void 0 || matchIndex >= sinkIndex || matchIndex < closestStartIndex) continue;
-		if (findMatchingBraceIndex(fileContent, matchIndex + match[0].lastIndexOf("{")) < sinkIndex) continue;
+		const bodyEndIndex = findMatchingBraceIndex(fileContent, matchIndex + match[0].lastIndexOf("{"));
+		if (bodyEndIndex < sinkIndex) continue;
 		const parameterIndex = (match[2] ?? "").split(",").findIndex((parameter) => parameter.trim().match(/^(?:\.\.\.)?([\w$]+)/)?.[1] === identifier);
 		if (parameterIndex < 0) continue;
 		closestStartIndex = matchIndex;
+		const functionName = match[1] ?? "";
 		closestSource = {
-			functionName: match[1] ?? "",
+			bodyEndIndex,
+			declarationNameIndex: matchIndex + match[0].indexOf(functionName),
+			functionName,
 			parameterIndex
 		};
 	}
@@ -7162,28 +7261,56 @@ const splitTopLevelArguments = (argumentText) => {
 	argumentsList.push(argumentText.slice(startIndex).trim());
 	return argumentsList;
 };
-const isHtmlTainted = (expression, fileContent, sinkIndex, visitedIdentifiers) => {
-	const trimmedExpression = expression.trim();
-	if (STRING_LITERAL_VALUE_PATTERN.test(`${trimmedExpression};`)) return false;
-	if (MODULE_CONSTANT_VALUE_PATTERN.test(`${trimmedExpression};`)) return false;
-	if (SANITIZER_PATTERN.test(trimmedExpression)) return false;
-	if (ENV_CONFIG_VALUE_PATTERN.test(trimmedExpression)) return false;
-	if (I18N_VALUE_PATTERN.test(trimmedExpression)) return false;
-	if (ESCAPING_SERIALIZER_CALL_PATTERN.test(trimmedExpression)) return false;
-	if (HTML_TAINT_PATTERN.test(trimmedExpression)) return true;
-	const identifier = trimmedExpression.match(/^([\w$]+)\s*(?:[;,})\n]|$)/)?.[1];
+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;
+	const identifier = trimmedExpression.match(/^([\w$]+)(?:\.|\s*(?:[;,})\n]|$))/)?.[1];
+	if (identifier === void 0) return HTML_TAINT_PATTERN.test(trimmedExpression);
+	if (visitedIdentifiers.has(identifier)) return false;
 	visitedIdentifiers.add(identifier);
 	const declaration = findVisibleIdentifierDeclaration(identifier, sinkIndex, fileContent);
-	if (declaration !== null && isHtmlTainted(declaration.initializer, fileContent, sinkIndex, visitedIdentifiers)) return true;
 	const parameterSource = findContainingFunctionParameterSource(identifier, sinkIndex, fileContent);
-	if (parameterSource === null || parameterSource.functionName.length === 0) return false;
-	const callPattern = new RegExp(`\\b${escapeRegExp(parameterSource.functionName)}\\s*\\(([^)]*)\\)`, "g");
-	for (const callMatch of fileContent.matchAll(callPattern)) {
-		const argument = splitTopLevelArguments(callMatch[1] ?? "")[parameterSource.parameterIndex];
-		if (argument !== void 0 && isHtmlTainted(argument, fileContent, sinkIndex, new Set(visitedIdentifiers))) return true;
-	}
-	return false;
+	if (declaration !== null && (parameterSource === null || declaration.declarationIndex > parameterSource.declarationNameIndex)) {
+		if (isDeclarationStable(identifier, declaration, sinkIndex, fileContent) && isExplicitlyTrustedHtmlValue(declaration.initializer, fileContent, declaration.initializerStartIndex)) return false;
+		if (!isDeclarationStable(identifier, declaration, sinkIndex, fileContent)) return true;
+		if (isHtmlTainted(declaration.initializer, fileContent, declaration.initializerStartIndex, visitedIdentifiers, visitedCallSites)) return true;
+		if (isBackedByFunctionParameter(declaration.initializer, declaration.initializerStartIndex, fileContent)) return false;
+		return HTML_TAINT_PATTERN.test(trimmedExpression);
+	}
+	if (parameterSource !== null && parameterSource.functionName.length > 0) {
+		const callPattern = new RegExp(`\\b${escapeRegExp(parameterSource.functionName)}\\s*\\(`, "g");
+		let didInspectCallArgument = false;
+		let didInspectOnlyExplicitlyTrustedArguments = true;
+		for (const callMatch of fileContent.matchAll(callPattern)) {
+			if (callMatch.index === parameterSource.declarationNameIndex || visitedCallSites.has(callMatch.index)) continue;
+			const openingParenthesisIndex = callMatch.index + callMatch[0].lastIndexOf("(");
+			const closingParenthesisIndex = findMatchingBracket(fileContent, openingParenthesisIndex);
+			if (closingParenthesisIndex < 0) continue;
+			const argument = splitTopLevelArguments(fileContent.slice(openingParenthesisIndex + 1, closingParenthesisIndex))[parameterSource.parameterIndex];
+			if (argument === void 0) continue;
+			if (callMatch.index >= parameterSource.declarationNameIndex && callMatch.index <= parameterSource.bodyEndIndex && doesExpressionAliasIdentifier(argument, identifier, callMatch.index, fileContent)) continue;
+			didInspectCallArgument = true;
+			didInspectOnlyExplicitlyTrustedArguments &&= isExplicitlyTrustedHtmlValue(argument, fileContent, callMatch.index);
+			const callVisitedIdentifiers = new Set(visitedIdentifiers);
+			callVisitedIdentifiers.delete(identifier);
+			const nextVisitedCallSites = new Set(visitedCallSites);
+			nextVisitedCallSites.add(callMatch.index);
+			if (isHtmlTainted(argument, fileContent, callMatch.index, callVisitedIdentifiers, nextVisitedCallSites)) return true;
+		}
+		if (didInspectCallArgument) return !didInspectOnlyExplicitlyTrustedArguments && HTML_TAINT_PATTERN.test(trimmedExpression);
+		return HTML_TAINT_PATTERN.test(trimmedExpression);
+	}
+	return HTML_TAINT_PATTERN.test(trimmedExpression);
 };
 const dangerousHtmlSink = defineRule({
 	id: "dangerous-html-sink",
@@ -7222,7 +7349,7 @@ const dangerousHtmlSink = defineRule({
 			const longValueTail = HTML_VALUE_START_PATTERN.exec(lines.slice(lineIndex, lineIndex + 1 + STATIC_TEMPLATE_LOOKAHEAD_LINES).join("\n"))?.[1]?.trimStart();
 			let templateInterpolations = getTemplateInterpolations(longValueTail ?? fullValueTail);
 			const valueIdentifier = BARE_IDENTIFIER_VALUE_PATTERN.test(valueExpression) || MEMBER_OR_INDEX_ACCESS_VALUE_PATTERN.test(valueExpression) || IDENTIFIER_WITH_LITERAL_FALLBACK_PATTERN.test(valueExpression) ? valueExpression.match(/^[\w$]+/)?.[0] : void 0;
-			if (templateInterpolations === null && valueIdentifier !== void 0 && BARE_IDENTIFIER_VALUE_PATTERN.test(valueExpression)) {
+			if (templateInterpolations === null && valueIdentifier !== void 0 && BARE_IDENTIFIER_VALUE_PATTERN.test(valueExpression) && findContainingFunctionParameterSource(valueIdentifier, sinkIndex, file.content) === null) {
 				const declarationInitializer = getIdentifierDeclarationInitializer(valueIdentifier, sinkIndex, file.content);
 				if (declarationInitializer !== null) {
 					if (isPureStringLiteralConcat(declarationInitializer)) continue;
@@ -7231,17 +7358,23 @@ const dangerousHtmlSink = defineRule({
 			}
 			if (templateInterpolations === "") continue;
 			const judgedExpression = templateInterpolations ?? valueExpression;
-			if (SANITIZER_PATTERN.test(judgedExpression)) continue;
-			if (ENV_CONFIG_VALUE_PATTERN.test(judgedExpression)) continue;
-			if (I18N_VALUE_PATTERN.test(judgedExpression)) continue;
-			if (!isHtmlTainted(judgedExpression, file.content, sinkIndex, /* @__PURE__ */ new Set())) continue;
+			const doesJudgedExpressionCombineValues = splitTopLevelByPlus(judgedExpression).length > 1 || (templateInterpolations?.match(/\$\{/g)?.length ?? 0) > 1;
+			if (!doesJudgedExpressionCombineValues && SANITIZER_PATTERN.test(judgedExpression)) continue;
+			if (!doesJudgedExpressionCombineValues && ENV_CONFIG_VALUE_PATTERN.test(judgedExpression)) continue;
+			if (!doesJudgedExpressionCombineValues && I18N_VALUE_PATTERN.test(judgedExpression)) continue;
+			if (!isHtmlTainted(judgedExpression, file.content, sinkIndex, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set())) continue;
 			if (ESCAPING_SERIALIZER_CALL_PATTERN.test(valueExpression)) continue;
-			if (/highlighted/i.test(valueExpression)) continue;
-			if (/highlight/i.test(valueExpression) && HIGHLIGHTER_LIBRARY_PATTERN.test(file.content)) continue;
+			if (isTrustedHighlighterValue(valueExpression, file.content, sinkIndex)) continue;
 			if (valueIdentifier !== void 0) {
 				const escapedIdentifier = escapeRegExp(valueIdentifier);
-				if (new RegExp(`\\b${escapedIdentifier}\\b\\s*${SERIALIZER_ASSIGNMENT_PATTERN.source}`, "i").test(file.content)) continue;
-				if (new RegExp(`\\b${escapedIdentifier}\\b\\s*${SANITIZED_ASSIGNMENT_PATTERN.source}`, "i").test(file.content)) continue;
+				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) : 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) : 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;
 			}
@@ -7326,7 +7459,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;
@@ -7578,7 +7711,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;
@@ -11810,7 +11943,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;
@@ -11888,7 +12021,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,
@@ -12250,8 +12383,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;
@@ -12272,8 +12404,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({
@@ -12304,7 +12435,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;
 };
@@ -12334,7 +12465,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;
@@ -12416,8 +12547,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;
@@ -12438,8 +12568,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({
@@ -12554,7 +12683,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"));
@@ -12790,30 +12919,6 @@ const insecureCryptoRisk = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/security-scan/utils/find-matching-bracket.ts
-const findMatchingBracket = (content, openIndex) => {
-	const open = content[openIndex];
-	const close = open === "(" ? ")" : open === "{" ? "}" : open === "[" ? "]" : "";
-	if (close === "") return -1;
-	let depth = 0;
-	let stringDelimiter = null;
-	for (let index = openIndex; index < content.length; index += 1) {
-		const character = content[index];
-		if (stringDelimiter !== null) {
-			if (character === "\\") index += 1;
-			else if (character === stringDelimiter) stringDelimiter = null;
-			continue;
-		}
-		if (character === "\"" || character === "'" || character === "`") stringDelimiter = character;
-		else if (character === open) depth += 1;
-		else if (character === close) {
-			depth -= 1;
-			if (depth === 0) return index;
-		}
-	}
-	return -1;
-};
-//#endregion
 //#region src/plugin/rules/security-scan/insecure-session-cookie.ts
 const AUTH_COOKIE_NAME_TOKEN = `(?<![A-Za-z0-9])(?:session|sess|sid|connect\\.sid|auth|jwt|access[_-]?token|refresh[_-]?token|id[_-]?token)(?![A-Za-z0-9])`;
 const AUTH_COOKIE_NAME_LITERAL = `[\`"'][^\`"']*?${AUTH_COOKIE_NAME_TOKEN}[^\`"']*[\`"']`;
@@ -13570,6 +13675,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",
@@ -13754,9 +13881,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));
@@ -13768,15 +13905,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;
@@ -14472,6 +14611,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;
@@ -14482,7 +14633,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;
@@ -15174,9 +15325,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;
@@ -15342,8 +15505,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;
 };
@@ -15395,8 +15558,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;
@@ -18523,10 +18686,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];
@@ -18546,7 +18705,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;
@@ -18733,11 +18893,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",
@@ -18757,7 +18912,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"];
@@ -20232,9 +20388,6 @@ 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"));
 //#endregion
@@ -20567,7 +20720,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) {
@@ -20763,7 +20916,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;
@@ -20871,7 +21024,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;
@@ -21046,7 +21199,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;
@@ -21093,8 +21246,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;
@@ -22902,10 +23055,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) => {
@@ -25902,6 +26060,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",
@@ -25921,12 +26129,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;
 		}
@@ -25937,7 +26146,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
@@ -28402,7 +28611,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;
@@ -28792,7 +29001,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);
@@ -31574,7 +31783,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");
@@ -31815,7 +32024,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;
@@ -32887,11 +33096,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;
@@ -32902,7 +33113,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) {
@@ -33024,7 +33235,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;
@@ -33038,7 +33249,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;
@@ -35654,7 +35865,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;
@@ -37139,7 +37350,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;
@@ -37488,7 +37699,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;
@@ -38118,9 +38329,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;
@@ -38508,8 +38720,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;
@@ -38570,7 +38781,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;
@@ -39785,7 +39996,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);
@@ -39963,20 +40174,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
 			};
@@ -40215,7 +40427,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({
@@ -40226,7 +40438,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);
@@ -41486,7 +41698,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;
@@ -41506,7 +41718,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");
@@ -41663,8 +41875,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;
@@ -41925,7 +42138,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;
@@ -43962,7 +44175,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"
@@ -45255,14 +45468,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;
@@ -45340,7 +45549,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);
@@ -45406,8 +45615,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;
@@ -45913,8 +46125,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;
@@ -53521,10 +53733,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",
@@ -53536,7 +53744,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);
@@ -54241,7 +54450,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;
@@ -54862,8 +55071,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);

package/package.json

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