oxlint-plugin-react-doctor 0.7.5-dev.654849 → 0.7.5-dev.76cd6be

package/dist/index.js

@@ -397,7 +397,6 @@ const isProductionFilePath = (relativePath, sourceFilePattern) => {
 //#endregion
 //#region src/plugin/rules/security-scan/utils/is-production-source-path.ts
 const isProductionSourcePath = (relativePath) => {
-	if (/\.d\.[cm]?[jt]s$/i.test(relativePath)) return false;
 	return isProductionFilePath(relativePath, SOURCE_FILE_PATTERN);
 };
 //#endregion
@@ -5179,10 +5178,8 @@ const STORAGE_GLOBALS = new Set([
 const SENSITIVE_KEY_PATTERN = /token|jwt|secret|password|passwd|credential|api[-_]?key|bearer|private[-_]?key/i;
 const NON_AUTH_TOKEN_PATTERN = /csrf|xsrf|device|fcm|apns|push|design|tokeniz|syntax|css|theme|color/i;
 const STRONG_AUTH_KEY_PATTERN = /jwt|secret|password|passwd|credential|private[-_]?key|api[-_]?key|bearer|access[-_]?token|refresh[-_]?token|auth[-_]?token|id[-_]?token|session/i;
-const PRODUCT_API_KEY_RECORDS_PATTERN = /(?:^|[._:-])(?:created|saved|integration|mailing)[-_]?api[-_]?keys$/i;
 const PRODUCT_API_KEY_COLLECTION_PATTERN = /[._:-](?:created|generated|saved)[-_]?api[-_]?keys$/i;
 const isAuthCredentialKey = (key) => {
-	if (PRODUCT_API_KEY_RECORDS_PATTERN.test(key)) return false;
 	if (!SENSITIVE_KEY_PATTERN.test(key)) return false;
 	if (PRODUCT_API_KEY_COLLECTION_PATTERN.test(key)) return false;
 	if (NON_AUTH_TOKEN_PATTERN.test(key) && !STRONG_AUTH_KEY_PATTERN.test(key)) return false;
@@ -6871,10 +6868,11 @@ const getTemplateInterpolations = (valueTail) => {
 	const interpolations = valueTail.slice(1, closingBacktickIndex).match(/\$\{[^}]*\}/g);
 	return interpolations === null ? "" : interpolations.join(" ");
 };
-const getIdentifierDeclarationInitializer = (identifier, sinkIndex, fileContent) => {
-	const declaration = findVisibleIdentifierDeclaration(identifier, sinkIndex, fileContent);
-	if (declaration === null) return null;
-	return fileContent.slice(declaration.initializerStartIndex, declaration.initializerStartIndex + STATIC_TEMPLATE_MAX_CHARS);
+const getIdentifierDeclarationInitializer = (identifier, fileContent) => {
+	const declarationMatch = new RegExp(`(?:const|let|var)\\s+${escapeRegExp(identifier)}\\s*(?::[^=\\n]{0,120})?=\\s*`).exec(fileContent);
+	if (declarationMatch === null) return null;
+	const initializerStartIndex = declarationMatch.index + declarationMatch[0].length;
+	return fileContent.slice(initializerStartIndex, initializerStartIndex + STATIC_TEMPLATE_MAX_CHARS);
 };
 const isPureStringLiteralConcat = (initializerText) => {
 	if (!/^["']/.test(initializerText)) return false;
@@ -6944,153 +6942,6 @@ const isAllOperandsDomContentConcat = (valueExpression) => {
 		return !HTML_TAINT_PATTERN.test(withoutCast.replace(DOM_CONTENT_SOURCE_VALUE_PATTERN, ""));
 	});
 };
-const findMatchingBraceIndex = (fileContent, openingBraceIndex) => {
-	let depth = 0;
-	let quote = null;
-	for (let index = openingBraceIndex; index < fileContent.length; index += 1) {
-		const character = fileContent[index];
-		if (quote !== null) {
-			if (character === quote && fileContent[index - 1] !== "\\") quote = null;
-			continue;
-		}
-		if (character === "\"" || character === "'" || character === "`") {
-			quote = character;
-			continue;
-		}
-		if (character === "{") depth += 1;
-		if (character === "}") {
-			depth -= 1;
-			if (depth === 0) return index;
-		}
-	}
-	return fileContent.length;
-};
-const findContainingBlockEndIndex = (fileContent, targetIndex) => {
-	const openingBraceIndexes = [];
-	let quote = null;
-	let isLineComment = false;
-	let isBlockComment = false;
-	for (let index = 0; index < targetIndex; index += 1) {
-		const character = fileContent[index];
-		const nextCharacter = fileContent[index + 1];
-		if (isLineComment) {
-			if (character === "\n") isLineComment = false;
-			continue;
-		}
-		if (isBlockComment) {
-			if (character === "*" && nextCharacter === "/") {
-				isBlockComment = false;
-				index += 1;
-			}
-			continue;
-		}
-		if (quote !== null) {
-			if (character === quote && fileContent[index - 1] !== "\\") quote = null;
-			continue;
-		}
-		if (character === "/" && nextCharacter === "/") {
-			isLineComment = true;
-			index += 1;
-			continue;
-		}
-		if (character === "/" && nextCharacter === "*") {
-			isBlockComment = true;
-			index += 1;
-			continue;
-		}
-		if (character === "\"" || character === "'" || character === "`") {
-			quote = character;
-			continue;
-		}
-		if (character === "{") openingBraceIndexes.push(index);
-		if (character === "}") openingBraceIndexes.pop();
-	}
-	const openingBraceIndex = openingBraceIndexes.at(-1);
-	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");
-	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];
-		if (initializer === void 0) continue;
-		nearestDeclaration = {
-			initializer,
-			initializerStartIndex: declarationIndex + match[0].length - initializer.length
-		};
-	}
-	return nearestDeclaration;
-};
-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;
-	let closestStartIndex = -1;
-	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 parameterIndex = (match[2] ?? "").split(",").findIndex((parameter) => parameter.trim().match(/^(?:\.\.\.)?([\w$]+)/)?.[1] === identifier);
-		if (parameterIndex < 0) continue;
-		closestStartIndex = matchIndex;
-		closestSource = {
-			functionName: match[1] ?? "",
-			parameterIndex
-		};
-	}
-	return closestSource;
-};
-const splitTopLevelArguments = (argumentText) => {
-	const argumentsList = [];
-	let startIndex = 0;
-	let depth = 0;
-	let quote = null;
-	for (let index = 0; index < argumentText.length; index += 1) {
-		const character = argumentText[index];
-		if (quote !== null) {
-			if (character === quote && argumentText[index - 1] !== "\\") quote = null;
-			continue;
-		}
-		if (character === "\"" || character === "'" || character === "`") {
-			quote = character;
-			continue;
-		}
-		if (character === "(" || character === "[" || character === "{") depth += 1;
-		if (character === ")" || character === "]" || character === "}") depth -= 1;
-		if (character === "," && depth === 0) {
-			argumentsList.push(argumentText.slice(startIndex, index).trim());
-			startIndex = index + 1;
-		}
-	}
-	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];
-	if (identifier === void 0 || 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;
-};
 const dangerousHtmlSink = defineRule({
 	id: "dangerous-html-sink",
 	title: "HTML injection sink with dynamic content",
@@ -7117,7 +6968,6 @@ const dangerousHtmlSink = defineRule({
 			const valueTail = fullValueTail.slice(0, VALUE_EXPRESSION_MAX_CHARS);
 			const terminatorIndex = valueTail.search(/[;}]/);
 			const valueExpression = terminatorIndex >= 0 ? valueTail.slice(0, terminatorIndex + 1) : valueTail;
-			const sinkIndex = lines.slice(0, lineIndex).join("\n").length + (lineIndex > 0 ? 1 : 0) + line.search(DANGEROUS_HTML_PATTERN);
 			if (STRING_LITERAL_VALUE_PATTERN.test(valueExpression)) continue;
 			if (MODULE_CONSTANT_VALUE_PATTERN.test(valueExpression)) continue;
 			if (DOM_CONTENT_SOURCE_VALUE_PATTERN.test(valueExpression) && !valueExpression.includes("+")) {
@@ -7129,7 +6979,7 @@ const dangerousHtmlSink = defineRule({
 			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)) {
-				const declarationInitializer = getIdentifierDeclarationInitializer(valueIdentifier, sinkIndex, file.content);
+				const declarationInitializer = getIdentifierDeclarationInitializer(valueIdentifier, file.content);
 				if (declarationInitializer !== null) {
 					if (isPureStringLiteralConcat(declarationInitializer)) continue;
 					templateInterpolations = getTemplateInterpolations(declarationInitializer);
@@ -7140,7 +6990,7 @@ const dangerousHtmlSink = defineRule({
 			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;
+			if (!HTML_TAINT_PATTERN.test(judgedExpression)) 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;
@@ -7587,7 +7437,7 @@ const containsJsx$1 = (root) => {
 	containsJsxCache.set(root, found);
 	return found;
 };
-const getStaticMemberName$2 = (node) => {
+const getStaticMemberName$1 = (node) => {
 	if (!isNodeOfType(node, "MemberExpression")) return null;
 	if (!node.computed && isNodeOfType(node.property, "Identifier")) return node.property.name;
 	if (node.computed && isNodeOfType(node.property, "Literal") && typeof node.property.value === "string") return node.property.value;
@@ -7601,7 +7451,7 @@ const getAssignedName = (node) => {
 	if (isNodeOfType(parent, "AssignmentExpression")) {
 		const left = parent.left;
 		if (isNodeOfType(left, "Identifier")) return left.name;
-		if (isNodeOfType(left, "MemberExpression")) return getStaticMemberName$2(left);
+		if (isNodeOfType(left, "MemberExpression")) return getStaticMemberName$1(left);
 	}
 	return null;
 };
@@ -7609,20 +7459,20 @@ const isModuleExportsAssignment = (node) => {
 	const parent = node.parent;
 	if (!parent || !isNodeOfType(parent, "AssignmentExpression")) return false;
 	const left = parent.left;
-	return isNodeOfType(left, "MemberExpression") && isNodeOfType(left.object, "Identifier") && left.object.name === "module" && getStaticMemberName$2(left) === "exports";
+	return isNodeOfType(left, "MemberExpression") && isNodeOfType(left.object, "Identifier") && left.object.name === "module" && getStaticMemberName$1(left) === "exports";
 };
 const isCreateClassLikeCall = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
 	if (isEs5Component(node)) return true;
 	const callee = node.callee;
-	if (isNodeOfType(callee, "MemberExpression")) return getStaticMemberName$2(callee) === "createClass";
+	if (isNodeOfType(callee, "MemberExpression")) return getStaticMemberName$1(callee) === "createClass";
 	return false;
 };
-const isCreateContextCall$1 = (node) => {
+const isCreateContextCall = (node) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
 	const callee = node.callee;
 	if (isNodeOfType(callee, "Identifier")) return callee.name === "createContext";
-	return isNodeOfType(callee, "MemberExpression") && getStaticMemberName$2(callee) === "createContext";
+	return isNodeOfType(callee, "MemberExpression") && getStaticMemberName$1(callee) === "createContext";
 };
 const isNamedFunctionLike = (node) => (isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "FunctionDeclaration")) && Boolean(node.id?.name);
 const firstCallArgument = (node) => {
@@ -7680,7 +7530,7 @@ const memberExpressionPath = (node) => {
 	if (isNodeOfType(node, "Identifier")) return [node.name];
 	if (!isNodeOfType(node, "MemberExpression")) return [];
 	const objectPath = memberExpressionPath(node.object);
-	const propertyName = getStaticMemberName$2(node);
+	const propertyName = getStaticMemberName$1(node);
 	return propertyName ? [...objectPath, propertyName] : objectPath;
 };
 const displayNameAssignmentIndexCache = /* @__PURE__ */ new WeakMap();
@@ -7690,7 +7540,7 @@ const getDisplayNameAssignmentIndex = (programRoot) => {
 	const identifierTargets = /* @__PURE__ */ new Set();
 	const memberPathSegments = /* @__PURE__ */ new Set();
 	const visit = (node) => {
-		if (isNodeOfType(node, "AssignmentExpression") && isNodeOfType(node.left, "MemberExpression") && getStaticMemberName$2(node.left) === "displayName") {
+		if (isNodeOfType(node, "AssignmentExpression") && isNodeOfType(node.left, "MemberExpression") && getStaticMemberName$1(node.left) === "displayName") {
 			if (isNodeOfType(node.left.object, "Identifier")) identifierTargets.add(node.left.object.name);
 			for (const segment of memberExpressionPath(node.left.object)) memberPathSegments.add(segment);
 		}
@@ -7795,7 +7645,7 @@ const displayName = defineRule({
 				}
 			},
 			CallExpression(node) {
-				if (settings.checkContextObjects && isReactVersionAtLeast$1(settings.reactVersion, 16, 3) && isCreateContextCall$1(node)) {
+				if (settings.checkContextObjects && isReactVersionAtLeast$1(settings.reactVersion, 16, 3) && isCreateContextCall(node)) {
 					const assignedName = getAssignedName(node);
 					if (assignedName) {
 						const programRoot = findProgramRoot(node);
@@ -7887,9 +7737,9 @@ const isImportedFromReact = (symbol) => {
 	const importDeclaration = symbol.declarationNode.parent;
 	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && typeof importDeclaration.source.value === "string" && REACT_RUNTIME_MODULE_SOURCES.has(importDeclaration.source.value));
 };
-const isNamedReactApiImport = (identifier, apiNames, scopes, resolveAliases) => {
+const isNamedReactApiImport = (identifier, apiNames, scopes) => {
 	if (!isNodeOfType(identifier, "Identifier")) return false;
-	const symbol = resolveAliases ? resolveConstIdentifierAlias(identifier, scopes) : scopes.symbolFor(identifier);
+	const symbol = scopes.symbolFor(identifier);
 	if (!symbol || !isImportedFromReact(symbol)) return false;
 	const importedName = getImportedName(symbol.declarationNode);
 	return Boolean(importedName && includesApiName(apiNames, importedName));
@@ -7903,7 +7753,7 @@ const isReactApiCall = (node, apiNames, scopes, options = {}) => {
 	if (!isNodeOfType(node, "CallExpression")) return false;
 	const callee = stripParenExpression(node.callee);
 	if (isNodeOfType(callee, "Identifier")) {
-		if (isNamedReactApiImport(callee, apiNames, scopes, Boolean(options.resolveNamedAliases))) return true;
+		if (isNamedReactApiImport(callee, apiNames, scopes)) return true;
 		return Boolean(options.allowUnboundBareCalls && includesApiName(apiNames, callee.name) && scopes.isGlobalReference(callee));
 	}
 	if (!isNodeOfType(callee, "MemberExpression") || callee.computed || !isNodeOfType(callee.property, "Identifier") || !includesApiName(apiNames, callee.property.name)) return false;
@@ -11112,11 +10962,6 @@ If the missing value is recreated every render, move it inside the hook or stabi
 		return { CallExpression(node) {
 			const hookName = getHookName(node.callee, context.scopes);
 			if (!hookName || !isHookOfInterest(hookName, node.callee)) return;
-			if (HOOKS_REQUIRING_DEPS_MATCH.has(hookName) && !isReactApiCall(node, HOOKS_REQUIRING_DEPS_MATCH, context.scopes, {
-				allowGlobalReactNamespace: true,
-				allowUnboundBareCalls: true,
-				resolveNamedAliases: true
-			})) return;
 			const callbackArgumentIndex = getCallbackArgumentIndex(hookName);
 			const depsArgumentIndex = getDepsArgumentIndex(hookName);
 			const callbackArgument = node.arguments[callbackArgumentIndex];
@@ -14411,11 +14256,7 @@ const jsIndexMaps = defineRule({
 //#region src/plugin/utils/are-expressions-structurally-equal.ts
 const areExpressionsStructurallyEqual = (a, b) => {
 	if (!a || !b) return a === b;
-	const unwrappedA = stripParenExpression(a);
-	const unwrappedB = stripParenExpression(b);
-	if (unwrappedA !== a || unwrappedB !== b) return areExpressionsStructurallyEqual(unwrappedA, unwrappedB);
 	if (a.type !== b.type) return false;
-	if (isNodeOfType(a, "ThisExpression")) return true;
 	if (isNodeOfType(a, "Identifier") && isNodeOfType(b, "Identifier")) return a.name === b.name;
 	if (isNodeOfType(a, "Literal") && isNodeOfType(b, "Literal")) return a.value === b.value;
 	if (isNodeOfType(a, "MemberExpression") && isNodeOfType(b, "MemberExpression")) {
@@ -20958,8 +20799,8 @@ const catchClauseRethrowsCaught = (handler) => {
 	return didRethrow;
 };
 //#endregion
-//#region src/plugin/utils/is-immediately-invoked-function.ts
-const isImmediatelyInvokedFunction = (functionNode) => {
+//#region src/plugin/utils/find-guarding-try-statement.ts
+const isImmediatelyInvokedFunctionCallee = (functionNode) => {
 	let wrappedCallee = functionNode;
 	let enclosing = functionNode.parent;
 	while (enclosing && stripParenExpression(enclosing) === functionNode) {
@@ -20968,13 +20809,11 @@ const isImmediatelyInvokedFunction = (functionNode) => {
 	}
 	return Boolean(enclosing && isNodeOfType(enclosing, "CallExpression") && enclosing.callee === wrappedCallee);
 };
-//#endregion
-//#region src/plugin/utils/find-guarding-try-statement.ts
 const findGuardingTryStatement = (node) => {
 	let child = node;
 	let ancestor = node.parent;
 	while (ancestor) {
-		if (isFunctionLike$1(ancestor) && !isImmediatelyInvokedFunction(ancestor)) return null;
+		if (isFunctionLike$1(ancestor) && !isImmediatelyInvokedFunctionCallee(ancestor)) return null;
 		if (isNodeOfType(ancestor, "TryStatement") && ancestor.block === child && ancestor.handler && !catchClauseRethrowsCaught(ancestor.handler)) return ancestor;
 		child = ancestor;
 		ancestor = ancestor.parent ?? null;
@@ -22107,8 +21946,6 @@ const DOM_QUERY_MEMBER_NAMES = new Set([
 ]);
 const LAYOUT_MEASUREMENT_MEMBER_NAMES = new Set([
 	"current",
-	"textContent",
-	"innerText",
 	"scrollWidth",
 	"clientWidth",
 	"offsetWidth",
@@ -22130,7 +21967,7 @@ const POST_MOUNT_GLOBAL_NAMES = new Set([
 	"navigator"
 ]);
 const REF_FACTORY_CALLEE_NAMES = new Set(["useRef", "createRef"]);
-const hasRefLikeName = (name) => name === "ref" || name.endsWith("Ref") || name.endsWith("ref") || name.endsWith("Node") || name.endsWith("node") || name.endsWith("Element") || name.endsWith("element");
+const hasRefLikeName = (name) => name === "ref" || name.endsWith("Ref") || name.endsWith("ref");
 const isRefFactoryInitializer = (init) => {
 	if (!init || !isNodeOfType(init, "CallExpression")) return false;
 	const callee = init.callee;
@@ -23107,7 +22944,7 @@ const STORAGE_GLOBAL_NAMES$1 = new Set([
 	"localStorage",
 	"sessionStorage"
 ]);
-const getStaticMemberName$1 = (node) => {
+const getStaticMemberName = (node) => {
 	if (!isNodeOfType(node, "MemberExpression")) return null;
 	if (!node.computed && isNodeOfType(node.property, "Identifier")) return node.property.name;
 	if (node.computed && isNodeOfType(node.property, "Literal")) return typeof node.property.value === "string" ? node.property.value : null;
@@ -23122,7 +22959,7 @@ const getCallCalleeName$1 = (callExpression) => {
 	if (!isNodeOfType(callExpression, "CallExpression")) return null;
 	const callee = stripParenExpression(callExpression.callee);
 	if (isNodeOfType(callee, "Identifier")) return callee.name;
-	return getStaticMemberName$1(callee);
+	return getStaticMemberName(callee);
 };
 const getFunctionParameters = (functionNode) => isFunctionLike$1(functionNode) ? functionNode.params ?? [] : [];
 const getIdentifierBindingIdentity = (analysis, identifier) => {
@@ -23238,14 +23075,14 @@ const localUseEventPreservesCallback = (analysis, callee) => {
 			if (!isNodeOfType(child, "CallExpression")) return;
 			const forwardedCallee = stripParenExpression(child.callee);
 			if (!isNodeOfType(forwardedCallee, "MemberExpression")) return;
-			if (getStaticMemberName$1(forwardedCallee) !== "current") return;
+			if (getStaticMemberName(forwardedCallee) !== "current") return;
 			if (!isNodeOfType(forwardedCallee.object, "Identifier")) return;
 			const refReference = getRef(analysis, forwardedCallee.object);
 			if (!callbackRefDeclarators.find((declarator) => refReference?.resolved?.defs.some((definition) => definition.node === declarator)) || !refReference?.resolved) return;
 			if (!refReference.resolved.references.some((candidateReference) => {
 				const memberExpression = candidateReference.identifier.parent;
 				const assignmentExpression = memberExpression?.parent;
-				if (!memberExpression || !isNodeOfType(memberExpression, "MemberExpression") || getStaticMemberName$1(memberExpression) !== "current" || !assignmentExpression || !isNodeOfType(assignmentExpression, "AssignmentExpression") || assignmentExpression.left !== memberExpression) return false;
+				if (!memberExpression || !isNodeOfType(memberExpression, "MemberExpression") || getStaticMemberName(memberExpression) !== "current" || !assignmentExpression || !isNodeOfType(assignmentExpression, "AssignmentExpression") || assignmentExpression.left !== memberExpression) return false;
 				return getIdentifierBindingIdentity(analysis, assignmentExpression.right) !== callbackBinding;
 			})) forwardsCallback = true;
 		});
@@ -23270,7 +23107,7 @@ const resolveWrappedCallable = (analysis, node) => {
 		return callback && isFunctionLike$1(callback) ? callback : null;
 	}
 	if (!isNodeOfType(candidate, "MemberExpression")) return null;
-	if (getStaticMemberName$1(candidate) !== "current") return null;
+	if (getStaticMemberName(candidate) !== "current") return null;
 	if (!isNodeOfType(candidate.object, "Identifier")) return null;
 	const reference = getRef(analysis, candidate.object);
 	const declarator = reference?.resolved?.defs.map((definition) => definition.node).find((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator"));
@@ -23282,7 +23119,7 @@ const resolveWrappedCallable = (analysis, node) => {
 	return Boolean(reference?.resolved?.references.some((candidateReference) => {
 		const member = candidateReference.identifier.parent;
 		const assignment = member?.parent;
-		return Boolean(member && isNodeOfType(member, "MemberExpression") && getStaticMemberName$1(member) === "current" && assignment && isNodeOfType(assignment, "AssignmentExpression") && assignment.left === member);
+		return Boolean(member && isNodeOfType(member, "MemberExpression") && getStaticMemberName(member) === "current" && assignment && isNodeOfType(assignment, "AssignmentExpression") && assignment.left === member);
 	})) ? null : initializer;
 };
 const functionInvokesItself = (analysis, functionNode) => {
@@ -23321,7 +23158,7 @@ const collectBoundedEffectExecutionFrames = (analysis, effectNode, currentFilena
 		if (!isNodeOfType(child, "CallExpression")) return;
 		const callee = stripParenExpression(child.callee);
 		const calleeName = getCallCalleeName$1(child);
-		const memberName = getStaticMemberName$1(callee);
+		const memberName = getStaticMemberName(callee);
 		const isDeferringCall = calleeName !== null && DEFERRING_CALLEE_NAMES.has(calleeName) || memberName !== null && DEFERRING_MEMBER_NAMES.has(memberName);
 		const isIteratorCall = memberName !== null && SYNCHRONOUS_ITERATOR_METHOD_NAMES$1.has(memberName) && isNodeOfType(callee, "MemberExpression");
 		const enqueueFrame = (callableNode, argumentsForCallable, isDeferred, introducedBindings, allowWithoutInvocationEvidence = false) => {
@@ -23485,9 +23322,9 @@ const analyzeHelperExpression = (expression, environment, usedParameterIndices)
 		const calleeRoot = getMemberRoot(callee);
 		const isPureGlobalCall = isNodeOfType(callee, "Identifier") && PURE_GLOBAL_CALLEE_NAMES.has(callee.name) && !environment.parameterIndices.has(callee.name) && !environment.recursiveNames.has(callee.name) && !environment.shadowedGlobalNames.has(callee.name);
 		const namespaceName = isNodeOfType(calleeRoot, "Identifier") && !environment.parameterIndices.has(calleeRoot.name) && !environment.recursiveNames.has(calleeRoot.name) && !environment.shadowedGlobalNames.has(calleeRoot.name) ? calleeRoot.name : null;
-		const namespaceMemberName = getStaticMemberName$1(callee);
+		const namespaceMemberName = getStaticMemberName(callee);
 		const isPureNamespaceCall = isNodeOfType(callee, "MemberExpression") && namespaceName !== null && namespaceMemberName !== null && PURE_HELPER_NAMESPACE_MEMBER_NAMES.get(namespaceName)?.has(namespaceMemberName) === true;
-		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName$1(callee) ?? "");
+		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName(callee) ?? "");
 		if (!isPureGlobalCall && !isPureNamespaceCall && !isPureMemberTransform) return false;
 		if (isPureMemberTransform && isNodeOfType(callee, "MemberExpression") && !analyzeHelperExpression(callee.object, environment, usedParameterIndices)) return false;
 		return (node.arguments ?? []).every((argument) => analyzeHelperExpression(argument, environment, usedParameterIndices));
@@ -23561,7 +23398,7 @@ const isLocallyConstructedObjectMember = (reference, memberExpression) => isNode
 	return isNodeOfType(definitionNode, "VariableDeclarator") && Boolean(definitionNode.init) && (isNodeOfType(definitionNode.init, "ObjectExpression") || isNodeOfType(definitionNode.init, "ArrayExpression"));
 }) === true;
 const getUseRefDeclarator = (analysis, memberExpression) => {
-	if (!isNodeOfType(memberExpression, "MemberExpression") || getStaticMemberName$1(memberExpression) !== "current" || !isNodeOfType(memberExpression.object, "Identifier")) return null;
+	if (!isNodeOfType(memberExpression, "MemberExpression") || getStaticMemberName(memberExpression) !== "current" || !isNodeOfType(memberExpression.object, "Identifier")) return null;
 	return getRef(analysis, memberExpression.object)?.resolved?.defs.map((definition) => definition.node).find((definitionNode) => isNodeOfType(definitionNode, "VariableDeclarator") && isNodeOfType(definitionNode.init, "CallExpression") && getCallCalleeName$1(definitionNode.init) === "useRef") ?? null;
 };
 const collectValueEvidence = (analysis, expression, frame, remainingCallFrames, visitedBindings = /* @__PURE__ */ new Set()) => {
@@ -23630,7 +23467,7 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 		return collectValueEvidence(analysis, initializer.init, frame, remainingCallFrames, visitedBindings);
 	}
 	if (isNodeOfType(node, "MemberExpression")) {
-		if (getStaticMemberName$1(node) === "current" && isNodeOfType(node.object, "Identifier")) {
+		if (getStaticMemberName(node) === "current" && isNodeOfType(node.object, "Identifier")) {
 			const refBinding = getRef(analysis, node.object)?.resolved;
 			const refDeclarator = useRefDeclarator;
 			if (refBinding && refDeclarator && isNodeOfType(refDeclarator, "VariableDeclarator") && isNodeOfType(refDeclarator.init, "CallExpression")) {
@@ -23646,7 +23483,7 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 					if (candidateReference.init) continue;
 					const identifier = candidateReference.identifier;
 					const member = identifier.parent;
-					if (!member || !isNodeOfType(member, "MemberExpression") || member.object !== identifier || getStaticMemberName$1(member) !== "current") {
+					if (!member || !isNodeOfType(member, "MemberExpression") || member.object !== identifier || getStaticMemberName(member) !== "current") {
 						evidence.hasUnknownSource = true;
 						continue;
 					}
@@ -23683,7 +23520,7 @@ const collectValueEvidence = (analysis, expression, frame, remainingCallFrames,
 		const callee = stripParenExpression(node.callee);
 		const calleeRoot = getMemberRoot(callee);
 		const isPureGlobalCall = isNodeOfType(callee, "Identifier") && PURE_GLOBAL_CALLEE_NAMES.has(callee.name) && getIdentifierBindingIdentity(analysis, callee) === null || isNodeOfType(calleeRoot, "Identifier") && PURE_GLOBAL_NAMESPACE_NAMES.has(calleeRoot.name) && getIdentifierBindingIdentity(analysis, calleeRoot) === null;
-		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName$1(callee) ?? "");
+		const isPureMemberTransform = isNodeOfType(callee, "MemberExpression") && PURE_MEMBER_TRANSFORM_NAMES.has(getStaticMemberName(callee) ?? "");
 		if (isPureGlobalCall || isPureMemberTransform) {
 			if (isPureMemberTransform && isNodeOfType(callee, "MemberExpression")) mergeEvidence(evidence, collectValueEvidence(analysis, callee.object, frame, remainingCallFrames, new Set(visitedBindings)));
 			for (const argument of node.arguments ?? []) {
@@ -24153,26 +23990,6 @@ const STATEFUL_HTML_DESCENDANT_TAGS = new Set([
 	"dialog",
 	"canvas"
 ]);
-const STATEFUL_HTML_ATTRIBUTE_NAMES = new Set([
-	"autofocus",
-	"contenteditable",
-	"draggable",
-	"tabindex"
-]);
-const isStaticallyFalseAttributeValue = (attribute) => {
-	if (!isNodeOfType(attribute, "JSXAttribute") || !attribute.value) return false;
-	const value = isNodeOfType(attribute.value, "JSXExpressionContainer") ? attribute.value.expression : attribute.value;
-	return isNodeOfType(value, "Literal") && (value.value === false || value.value === "false");
-};
-const hasStatefulHtmlAttribute = (openingElement) => {
-	if (!isNodeOfType(openingElement, "JSXOpeningElement")) return false;
-	return openingElement.attributes.some((attribute) => {
-		if (!isNodeOfType(attribute, "JSXAttribute") || !isNodeOfType(attribute.name, "JSXIdentifier")) return false;
-		const attributeName = attribute.name.name.toLowerCase();
-		if (!STATEFUL_HTML_ATTRIBUTE_NAMES.has(attributeName)) return false;
-		return attributeName === "tabindex" || !isStaticallyFalseAttributeValue(attribute);
-	});
-};
 const STATEFUL_DESCENDANT_SCAN_BUDGET = 200;
 const rootIdentifierNameOf = (expression) => {
 	let object = expression;
@@ -24190,8 +24007,7 @@ const containsStatefulDescendant = (jsxElement, options = {}) => {
 		budget -= 1;
 		const node = stack.pop();
 		if (isNodeOfType(node, "JSXElement")) {
-			const opening = node.openingElement;
-			const name = opening.name;
+			const name = node.openingElement.name;
 			if (name && isNodeOfType(name, "JSXIdentifier")) {
 				const tagName = name.name;
 				const firstChar = tagName.charCodeAt(0);
@@ -24199,7 +24015,6 @@ const containsStatefulDescendant = (jsxElement, options = {}) => {
 				if (STATEFUL_HTML_DESCENDANT_TAGS.has(tagName)) return true;
 			}
 			if (name && isNodeOfType(name, "JSXMemberExpression")) return true;
-			if (hasStatefulHtmlAttribute(opening)) return true;
 			const children = node.children ?? [];
 			for (const child of children) stack.push(child);
 			continue;
@@ -24759,14 +24574,6 @@ const templateHasOuterMemberIdentity = (template, bindingFunction) => {
 	}
 	return false;
 };
-const findBareItemNamesReferencedByTemplate = (template, itemNames) => {
-	const referencedItemNames = /* @__PURE__ */ new Set();
-	for (const expression of template.expressions ?? []) {
-		const unwrappedExpression = stripParenExpression(expression);
-		if (isNodeOfType(unwrappedExpression, "Identifier") && itemNames.has(unwrappedExpression.name)) referencedItemNames.add(unwrappedExpression.name);
-	}
-	return referencedItemNames;
-};
 const forLoopTestReadsDataLength = (test) => {
 	let didFindLengthRead = false;
 	walkAst(test, (child) => {
@@ -24903,11 +24710,9 @@ const noArrayIndexAsKey = defineRule({
 				} else if (STATELESS_HTML_LEAF_TAGS.has(elementName.name)) {
 					const jsxElement = openingElement.parent;
 					if (jsxElement && isNodeOfType(jsxElement, "JSXElement")) {
-						const isInlineTextRun = INLINE_TEXT_LEAF_TAGS.has(elementName.name);
-						const primitiveItemNames = keyTemplate ? findBareItemNamesReferencedByTemplate(keyTemplate, itemNames) : EMPTY_NAME_SET;
 						if (!containsStatefulDescendant(jsxElement, {
-							memberRootNames: isInlineTextRun ? itemNames : EMPTY_NAME_SET,
-							bareIdentifierNames: primitiveItemNames.size > 0 ? new Set([...derivedNames, ...primitiveItemNames]) : derivedNames
+							memberRootNames: INLINE_TEXT_LEAF_TAGS.has(elementName.name) ? itemNames : EMPTY_NAME_SET,
+							bareIdentifierNames: derivedNames
 						})) return;
 					}
 				}
@@ -25075,11 +24880,7 @@ const noAsyncEffectCallback = defineRule({
 	severity: "warn",
 	recommendation: "Don't make the effect callback `async`. Define an async function inside the effect and call it, then return a real cleanup function if you need one.",
 	create: (context) => ({ CallExpression(node) {
-		if (!isReactApiCall(node, EFFECT_HOOK_NAMES$1, context.scopes, {
-			allowGlobalReactNamespace: true,
-			allowUnboundBareCalls: true,
-			resolveNamedAliases: true
-		})) return;
+		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
 		const callback = getEffectCallback(node);
 		if (!callback) return;
 		if (!isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return;
@@ -26277,19 +26078,6 @@ const noCloneElement = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/get-call-method-name.ts
-/**
-* Returns the static method name of a call's callee when it's a
-* non-computed MemberExpression (`obj.method` → `"method"`), or
-* `null` otherwise. Used by `no-pass-data-to-parent` and
-* `no-pass-live-state-to-parent` to match the receiver-bound
-* method-call shape against an allow/block list.
-*/
-const getCallMethodName = (callee) => {
-	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
-	return null;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/no-create-context-in-render.ts
 const MESSAGE$31 = "createContext() builds a new context every render, so every consumer gets cut off & resets.";
 const CONTEXT_MODULES = [
@@ -26297,35 +26085,23 @@ const CONTEXT_MODULES = [
 	"use-context-selector",
 	"react-tracked"
 ];
-const getSupportedContextImportSource = (symbol) => {
-	if (symbol?.kind !== "import") return null;
-	const importDeclaration = symbol.declarationNode.parent;
-	if (!importDeclaration || !isNodeOfType(importDeclaration, "ImportDeclaration") || typeof importDeclaration.source.value !== "string" || !CONTEXT_MODULES.includes(importDeclaration.source.value)) return null;
-	return importDeclaration.source.value;
-};
-const isSupportedNamespaceSymbol = (symbol) => getSupportedContextImportSource(symbol) !== null && Boolean(symbol && (isNodeOfType(symbol.declarationNode, "ImportDefaultSpecifier") || isNodeOfType(symbol.declarationNode, "ImportNamespaceSpecifier")));
-const isDestructuredCreateContextBinding = (identifier, scopes) => {
-	if (!isNodeOfType(identifier, "Identifier")) return false;
-	const symbol = scopes.symbolFor(identifier);
-	if (symbol?.kind !== "const" || !symbol.initializer || !isNodeOfType(symbol.declarationNode, "VariableDeclarator") || !isNodeOfType(symbol.declarationNode.id, "ObjectPattern")) return false;
-	const property = symbol.bindingIdentifier.parent;
-	if (!property || !isNodeOfType(property, "Property") || getStaticPropertyKeyName(property, { allowComputedString: true }) !== "createContext") return false;
-	const initializer = stripParenExpression(symbol.initializer);
-	return isNodeOfType(initializer, "Identifier") && isSupportedNamespaceSymbol(resolveConstIdentifierAlias(initializer, scopes));
-};
-const isCreateContextCall = (node, scopes) => {
-	const callee = stripParenExpression(node.callee);
+const isCreateContextCallee = (callee) => {
 	if (isNodeOfType(callee, "Identifier")) {
-		if (isDestructuredCreateContextBinding(callee, scopes)) return true;
-		const symbol = resolveConstIdentifierAlias(callee, scopes);
-		return getSupportedContextImportSource(symbol) !== null && Boolean(symbol && getImportedName(symbol.declarationNode) === "createContext");
+		const binding = getImportBindingForName(callee, callee.name);
+		return binding !== null && binding.exportedName === "createContext" && CONTEXT_MODULES.includes(binding.source);
 	}
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	if ((getCallMethodName(callee) ?? (callee.computed && isNodeOfType(callee.property, "Literal") && typeof callee.property.value === "string" ? callee.property.value : null)) !== "createContext") return false;
-	const receiver = stripParenExpression(callee.object);
-	if (!isNodeOfType(receiver, "Identifier")) return false;
-	if (receiver.name === "React" && scopes.isGlobalReference(receiver)) return true;
-	return isSupportedNamespaceSymbol(resolveConstIdentifierAlias(receiver, scopes));
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed) {
+		const namespaceIdentifier = callee.object;
+		const propertyIdentifier = callee.property;
+		if (!isNodeOfType(namespaceIdentifier, "Identifier")) return false;
+		if (!isNodeOfType(propertyIdentifier, "Identifier")) return false;
+		if (propertyIdentifier.name !== "createContext") return false;
+		const namespaceName = namespaceIdentifier.name;
+		if (isCanonicalReactNamespaceName(namespaceName)) return true;
+		const importSource = getImportSourceForName(namespaceIdentifier, namespaceName);
+		return importSource !== null && CONTEXT_MODULES.includes(importSource);
+	}
+	return false;
 };
 const noCreateContextInRender = defineRule({
 	id: "no-create-context-in-render",
@@ -26334,7 +26110,7 @@ const noCreateContextInRender = defineRule({
 	category: "Correctness",
 	recommendation: "Move `createContext(...)` outside the component, to the top level of the file, so it stays the same on every render.",
 	create: (context) => ({ CallExpression(node) {
-		if (!isCreateContextCall(node, context.scopes)) return;
+		if (!isCreateContextCallee(node.callee)) return;
 		const componentOrHookName = enclosingComponentOrHookName(node);
 		if (!componentOrHookName) return;
 		context.report({
@@ -27569,7 +27345,7 @@ const isSetStateCallInLifecycle = (setStateCall, lifecycleNames, options = {}) =
 	let ancestor = setStateCall.parent;
 	while (ancestor) {
 		if (!lifecycleMember) {
-			if (FUNCTION_NODE_TYPES$1.has(ancestor.type) && (!isImmediatelyInvokedFunction(ancestor) || !("async" in ancestor) || ancestor.async === true)) nestedFunctionCount += 1;
+			if (FUNCTION_NODE_TYPES$1.has(ancestor.type)) nestedFunctionCount += 1;
 			if (isLifecycleMember(ancestor, lifecycleNames)) lifecycleMember = ancestor;
 		} else if (isEs5Component(ancestor) || isEs6Component(ancestor)) {
 			if (nestedFunctionCount > 1 && !options.disallowInNestedFunctions) return false;
@@ -27771,7 +27547,7 @@ const collectDiffSourceLocalNames = (lifecycleFunction, paramNames) => {
 	const body = lifecycleFunction.body;
 	if (!body) return derivedNames;
 	walkAst(body, (node) => {
-		if (FUNCTION_NODE_TYPES.has(node.type) && !isImmediatelyInvokedFunction(node)) return false;
+		if (FUNCTION_NODE_TYPES.has(node.type)) return false;
 		if (!isNodeOfType(node, "VariableDeclarator")) return;
 		const init = node.init;
 		if (!init) return;
@@ -27781,67 +27557,6 @@ const collectDiffSourceLocalNames = (lifecycleFunction, paramNames) => {
 	return derivedNames;
 };
 const isStatefulOperand = (node, paramNames, derivedNames) => referencesAnyName(node, paramNames) || referencesAnyName(node, derivedNames) || containsThisStateOrProps(node);
-const getStaticMemberName = (node) => {
-	if (!isNodeOfType(node, "MemberExpression") || node.computed === true) return null;
-	return isNodeOfType(node.property, "Identifier") ? node.property.name : null;
-};
-const getThisStateFieldName = (node) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (!isNodeOfType(unwrappedNode, "MemberExpression")) return null;
-	const object = stripParenExpression(unwrappedNode.object);
-	if (!isNodeOfType(object, "MemberExpression") || !isNodeOfType(stripParenExpression(object.object), "ThisExpression") || getStaticMemberName(object) !== "state") return null;
-	return getStaticMemberName(unwrappedNode);
-};
-const collectLocalInitializers = (lifecycleFunction) => {
-	const initializers = /* @__PURE__ */ new Map();
-	const body = lifecycleFunction.body;
-	if (!body) return initializers;
-	walkAst(body, (node) => {
-		if (FUNCTION_NODE_TYPES.has(node.type) && !isImmediatelyInvokedFunction(node)) return false;
-		if (isNodeOfType(node, "VariableDeclarator") && isNodeOfType(node.id, "Identifier") && node.init) initializers.set(node.id.name, node.init);
-	});
-	return initializers;
-};
-const derivesFromPostMountValue = (node, localInitializers, visitedNames = /* @__PURE__ */ new Set()) => {
-	if (readsPostMountValue(node)) return true;
-	const referencedNames = /* @__PURE__ */ new Set();
-	collectReferenceIdentifierNames(node, referencedNames);
-	for (const referencedName of referencedNames) {
-		if (visitedNames.has(referencedName)) continue;
-		const initializer = localInitializers.get(referencedName);
-		if (!initializer) continue;
-		if (derivesFromPostMountValue(initializer, localInitializers, new Set([...visitedNames, referencedName]))) return true;
-	}
-	return false;
-};
-const getSetStateFieldValue = (setStateCall, fieldName) => {
-	if (!isNodeOfType(setStateCall, "CallExpression")) return null;
-	const argument = setStateCall.arguments?.[0];
-	if (!argument || !isNodeOfType(argument, "ObjectExpression")) return null;
-	for (const property of argument.properties ?? []) {
-		if (!isNodeOfType(property, "Property") || property.computed === true) continue;
-		if ((isNodeOfType(property.key, "Identifier") && property.key.name || isNodeOfType(property.key, "Literal") && typeof property.key.value === "string" && property.key.value || null) === fieldName) return property.value;
-	}
-	return null;
-};
-const isConvergentPostMountGuard = (test, setStateCall, localInitializers) => {
-	let qualifies = false;
-	walkAst(test, (node) => {
-		if (qualifies) return false;
-		if (!isNodeOfType(node, "BinaryExpression") || !EQUALITY_OPERATORS.has(node.operator)) return;
-		const leftFieldName = getThisStateFieldName(node.left);
-		const rightFieldName = getThisStateFieldName(node.right);
-		const fieldName = leftFieldName ?? rightFieldName;
-		const comparedValue = leftFieldName ? node.right : node.left;
-		if (!fieldName || !leftFieldName && !rightFieldName) return;
-		const assignedValue = getSetStateFieldValue(setStateCall, fieldName);
-		if (!assignedValue || !areExpressionsStructurallyEqual(comparedValue, assignedValue)) return;
-		if (!derivesFromPostMountValue(comparedValue, localInitializers)) return;
-		qualifies = true;
-		return false;
-	});
-	return qualifies;
-};
 const isDiffGuardTest = (test, paramNames, derivedNames) => {
 	if (referencesAnyName(test, paramNames)) return true;
 	let qualifies = false;
@@ -27849,7 +27564,7 @@ const isDiffGuardTest = (test, paramNames, derivedNames) => {
 		if (qualifies) return false;
 		if (!isNodeOfType(node, "BinaryExpression")) return;
 		if (!EQUALITY_OPERATORS.has(node.operator)) return;
-		if (isStatefulOperand(node.left, paramNames, derivedNames) && isStatefulOperand(node.right, paramNames, derivedNames) && (referencesAnyName(node.left, derivedNames) || referencesAnyName(node.right, derivedNames))) {
+		if (isStatefulOperand(node.left, paramNames, derivedNames) && isStatefulOperand(node.right, paramNames, derivedNames)) {
 			qualifies = true;
 			return false;
 		}
@@ -27862,12 +27577,11 @@ const isInsideDiffGuard = (setStateCall) => {
 	const paramNames = /* @__PURE__ */ new Set();
 	for (const param of lifecycleFunction.params ?? []) collectPatternNames(param, paramNames);
 	const derivedNames = collectDiffSourceLocalNames(lifecycleFunction, paramNames);
-	const localInitializers = collectLocalInitializers(lifecycleFunction);
 	let child = setStateCall;
 	let ancestor = setStateCall.parent;
 	while (ancestor && ancestor !== lifecycleFunction) {
 		const guardTest = isNodeOfType(ancestor, "IfStatement") && child !== ancestor.test && ancestor.test || isNodeOfType(ancestor, "ConditionalExpression") && child !== ancestor.test && ancestor.test || isNodeOfType(ancestor, "LogicalExpression") && ancestor.operator === "&&" && child === ancestor.right && ancestor.left || null;
-		if (guardTest && (isDiffGuardTest(guardTest, paramNames, derivedNames) || isConvergentPostMountGuard(guardTest, setStateCall, localInitializers))) return true;
+		if (guardTest && isDiffGuardTest(guardTest, paramNames, derivedNames)) return true;
 		child = ancestor;
 		ancestor = ancestor.parent ?? null;
 	}
@@ -30385,11 +30099,7 @@ const noFetchInEffect = defineRule({
 	severity: "warn",
 	recommendation: "Use a data-fetching layer or Server Component so fetches do not race, double-fire, or leak from `useEffect`.",
 	create: (context) => ({ CallExpression(node) {
-		if (!isReactApiCall(node, EFFECT_HOOK_NAMES$1, context.scopes, {
-			allowGlobalReactNamespace: true,
-			allowUnboundBareCalls: true,
-			resolveNamedAliases: true
-		})) return;
+		if (!isHookCall$2(node, EFFECT_HOOK_NAMES$1)) return;
 		const callback = getEffectCallback(node);
 		if (!callback) return;
 		const analysisFunctions = collectEffectAnalysisFunctions(callback, context);
@@ -34599,6 +34309,19 @@ const DATA_SINK_METHOD_NAMES = new Set([
 	"deserialize"
 ]);
 //#endregion
+//#region src/plugin/utils/get-call-method-name.ts
+/**
+* Returns the static method name of a call's callee when it's a
+* non-computed MemberExpression (`obj.method` → `"method"`), or
+* `null` otherwise. Used by `no-pass-data-to-parent` and
+* `no-pass-live-state-to-parent` to match the receiver-bound
+* method-call shape against an allow/block list.
+*/
+const getCallMethodName = (callee) => {
+	if (isNodeOfType(callee, "MemberExpression") && !callee.computed && isNodeOfType(callee.property, "Identifier")) return callee.property.name;
+	return null;
+};
+//#endregion
 //#region src/plugin/rules/state-and-effects/no-pass-data-to-parent.ts
 const isUseStateIdentifier = (identifier) => {
 	if (!isNodeOfType(identifier, "Identifier")) return false;
@@ -35224,30 +34947,6 @@ const guardsRenderShape = (comparison) => {
 	}
 	return false;
 };
-const isPropsChildrenLength = (node, scopes) => {
-	const unwrappedNode = stripParenExpression(node);
-	return isNodeOfType(unwrappedNode, "MemberExpression") && !unwrappedNode.computed && isNodeOfType(unwrappedNode.property, "Identifier") && unwrappedNode.property.name === "length" && resolvesToPropsChildren(stripParenExpression(unwrappedNode.object), scopes);
-};
-const isLargeTextLengthComparison = (node, scopes) => {
-	const unwrappedNode = stripParenExpression(node);
-	if (!isNodeOfType(unwrappedNode, "BinaryExpression")) return false;
-	const leftIsLength = isPropsChildrenLength(unwrappedNode.left, scopes);
-	const rightIsLength = isPropsChildrenLength(unwrappedNode.right, scopes);
-	const thresholdNode = leftIsLength ? unwrappedNode.right : unwrappedNode.left;
-	if (!leftIsLength && !rightIsLength || !isNodeOfType(thresholdNode, "Literal")) return false;
-	if (typeof thresholdNode.value !== "number" || thresholdNode.value < 1e3) return false;
-	return leftIsLength ? unwrappedNode.operator === ">" || unwrappedNode.operator === ">=" : unwrappedNode.operator === "<" || unwrappedNode.operator === "<=";
-};
-const isLargeStringOptimizationGuard = (comparison, scopes) => {
-	let current = findTransparentExpressionRoot(comparison);
-	while (current.parent) {
-		const parent = current.parent;
-		if (!isNodeOfType(parent, "LogicalExpression") || parent.operator !== "&&") return false;
-		if (isLargeTextLengthComparison(parent.left === current ? parent.right : parent.left, scopes)) return true;
-		current = findTransparentExpressionRoot(parent);
-	}
-	return false;
-};
 const noPolymorphicChildren = defineRule({
 	id: "no-polymorphic-children",
 	title: "Children type checked at runtime",
@@ -35261,7 +34960,6 @@ const noPolymorphicChildren = defineRule({
 		const isStringLiteral = (operand) => isNodeOfType(operand, "Literal") && operand.value === "string";
 		if (!isStringLiteral(node.left) && !isStringLiteral(node.right)) return;
 		if (!guardsRenderShape(node)) return;
-		if (isLargeStringOptimizationGuard(node, context.scopes)) return;
 		context.report({
 			node,
 			message: "Your users hit inconsistent behavior because `typeof children === \"string\"` makes this component switch on what callers pass, so add clear subcomponents like `<Button.Text>` instead."
@@ -35479,27 +35177,6 @@ const hasPreviousValueDep = (effectNode, depElements) => {
 	}
 	return false;
 };
-const isStateLikeDependency = (analysis, element, isPropName) => {
-	if (!isNodeOfType(element, "Identifier") || isPropName(element.name)) return false;
-	if (!analysis) return true;
-	const reference = getRef(analysis, element);
-	if (!reference) return true;
-	const upstreamReferences = getUpstreamRefs(analysis, reference);
-	if (upstreamReferences.some((upstreamReference) => isState(analysis, upstreamReference))) return true;
-	return !upstreamReferences.some((upstreamReference) => isProp(analysis, upstreamReference));
-};
-const getRefHeldPropCallbackName = (callExpression, isPropName) => {
-	const callee = stripParenExpression(callExpression.callee);
-	if (!isNodeOfType(callee, "MemberExpression") || !isNodeOfType(callee.property, "Identifier") || callee.property.name !== "current") return null;
-	const receiver = stripParenExpression(callee.object);
-	if (!isNodeOfType(receiver, "Identifier")) return null;
-	const binding = findVariableInitializer(callExpression, receiver.name);
-	if (!binding?.initializer || !isNodeOfType(binding.initializer, "CallExpression")) return null;
-	if (getCalleeName$2(binding.initializer) !== "useRef") return null;
-	const callbackArgument = binding.initializer.arguments?.[0];
-	if (!callbackArgument || !isNodeOfType(callbackArgument, "Identifier")) return null;
-	return isPropName(callbackArgument.name) ? callbackArgument.name : null;
-};
 const noPropCallbackInEffect = defineRule({
 	id: "no-prop-callback-in-effect",
 	title: "Parent kept in sync with a callback effect",
@@ -35516,11 +35193,11 @@ const noPropCallbackInEffect = defineRule({
 				if (!callback || !isNodeOfType(callback, "ArrowFunctionExpression") && !isNodeOfType(callback, "FunctionExpression")) return;
 				const depsNode = node.arguments[1];
 				if (!isNodeOfType(depsNode, "ArrayExpression") || !depsNode.elements?.length) return;
-				const analysis = getProgramAnalysis(node);
-				const stateLikeDeps = (depsNode.elements ?? []).filter((element) => element && isStateLikeDependency(analysis, element, propStackTracker.isPropName));
+				const stateLikeDeps = (depsNode.elements ?? []).filter((element) => isNodeOfType(element, "Identifier") && !propStackTracker.isPropName(element.name));
 				if (stateLikeDeps.length === 0) return;
 				if (isRefLatchGuardedEffect(callback.body)) return;
 				if (hasPreviousValueDep(node, depsNode.elements ?? [])) return;
+				const analysis = getProgramAnalysis(node);
 				if (analysis) {
 					const stateLikeDepRefs = [];
 					for (const element of stateLikeDeps) {
@@ -35532,9 +35209,9 @@ const noPropCallbackInEffect = defineRule({
 				const reportedNodes = /* @__PURE__ */ new Set();
 				walkInsideStatementBlocks(callback.body, (child) => {
 					if (!isNodeOfType(child, "CallExpression")) return;
-					const directCallee = stripParenExpression(child.callee);
-					const calleeName = isNodeOfType(directCallee, "Identifier") && propStackTracker.isPropName(directCallee.name) && directCallee.name || getRefHeldPropCallbackName(child, propStackTracker.isPropName);
-					if (!calleeName) return;
+					if (!isNodeOfType(child.callee, "Identifier")) return;
+					const calleeName = child.callee.name;
+					if (!propStackTracker.isPropName(calleeName)) return;
 					if (!isResultDiscardedCall(child)) return;
 					if (reportedNodes.has(child)) return;
 					reportedNodes.add(child);
@@ -43375,6 +43052,15 @@ const isStableHookWrapperArgument = (node) => {
 	const parent = node.parent;
 	return isNodeOfType(parent, "CallExpression") && isNodeOfType(parent.callee, "Identifier") && STABLE_HOOK_WRAPPERS.has(parent.callee.name) && Boolean(parent.arguments?.some((argument) => argument === node));
 };
+const isImmediatelyInvokedFunction = (functionNode) => {
+	let wrappedCallee = functionNode;
+	let enclosing = functionNode.parent;
+	while (enclosing && stripParenExpression(enclosing) === functionNode) {
+		wrappedCallee = enclosing;
+		enclosing = enclosing.parent ?? null;
+	}
+	return Boolean(enclosing && isNodeOfType(enclosing, "CallExpression") && enclosing.callee === wrappedCallee);
+};
 const queryStableQueryClient = defineRule({
 	id: "query-stable-query-client",
 	title: "Unstable QueryClient in component",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.7.5-dev.0654849",
+  "version": "0.7.5-dev.76cd6be",
   "description": "React Doctor rules for oxlint.",
   "keywords": [
     "accessibility",