oxlint-plugin-react-doctor 0.4.2-dev.6bfc03a → 0.4.2-dev.772385f

package/dist/index.js

@@ -823,6 +823,310 @@ const getElementType = (openingElement, settings) => {
 	return baseName;
 };
 //#endregion
+//#region src/plugin/utils/find-import-source-for-name.ts
+const collectFromProgram = (programRoot) => {
+	const lookup = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		if (node.type === "ImportDeclaration" && "source" in node && node.source) {
+			const source = node.source.value;
+			if (typeof source !== "string") return;
+			if ("specifiers" in node && Array.isArray(node.specifiers)) for (const specifier of node.specifiers) {
+				if (!("local" in specifier) || !specifier.local) continue;
+				const local = specifier.local;
+				if (typeof local.name !== "string") continue;
+				if (specifier.type === "ImportDefaultSpecifier") lookup.set(local.name, {
+					source,
+					imported: null,
+					isDefault: true,
+					isNamespace: false
+				});
+				else if (specifier.type === "ImportNamespaceSpecifier") lookup.set(local.name, {
+					source,
+					imported: null,
+					isDefault: false,
+					isNamespace: true
+				});
+				else if (specifier.type === "ImportSpecifier") {
+					const importedNode = specifier.imported;
+					const importedName = importedNode?.name ?? (typeof importedNode?.value === "string" ? importedNode.value : null);
+					lookup.set(local.name, {
+						source,
+						imported: importedName,
+						isDefault: false,
+						isNamespace: false
+					});
+				}
+			}
+			return;
+		}
+		const nodeRecord = node;
+		for (const key of Object.keys(nodeRecord)) {
+			if (key === "parent") continue;
+			const child = nodeRecord[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (isAstNode(item)) visit(item);
+			} else if (isAstNode(child)) visit(child);
+		}
+	};
+	visit(programRoot);
+	return lookup;
+};
+const importLookupCache = /* @__PURE__ */ new WeakMap();
+const getImportLookup = (node) => {
+	const programRoot = findProgramRoot(node);
+	if (!programRoot) return null;
+	let cached = importLookupCache.get(programRoot);
+	if (!cached) {
+		cached = collectFromProgram(programRoot);
+		importLookupCache.set(programRoot, cached);
+	}
+	return cached;
+};
+const isImportedFromModule = (contextNode, localIdentifierName, moduleSource) => {
+	const lookup = getImportLookup(contextNode);
+	if (!lookup) return false;
+	const info = lookup.get(localIdentifierName);
+	if (!info) return false;
+	return info.source === moduleSource;
+};
+const isNamespaceImportFromModule = (contextNode, localIdentifierName, moduleSource) => {
+	const lookup = getImportLookup(contextNode);
+	if (!lookup) return false;
+	const info = lookup.get(localIdentifierName);
+	if (!info) return false;
+	return info.isNamespace && info.source === moduleSource;
+};
+const isDefaultImportFromModule = (contextNode, localIdentifierName, moduleSource) => {
+	const lookup = getImportLookup(contextNode);
+	if (!lookup) return false;
+	const info = lookup.get(localIdentifierName);
+	if (!info) return false;
+	return info.isDefault && info.source === moduleSource;
+};
+const getImportedNameFromModule = (contextNode, localIdentifierName, moduleSource) => {
+	const lookup = getImportLookup(contextNode);
+	if (!lookup) return null;
+	const info = lookup.get(localIdentifierName);
+	if (!info) return null;
+	if (info.source !== moduleSource) return null;
+	return info.imported;
+};
+//#endregion
+//#region src/plugin/utils/find-variable-initializer.ts
+const FUNCTION_LIKE_TYPES$1 = new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression",
+	"MethodDefinition",
+	"Program"
+]);
+const findScopeOwner = (node) => {
+	let ancestor = node;
+	while (ancestor) {
+		if (FUNCTION_LIKE_TYPES$1.has(ancestor.type)) return ancestor;
+		ancestor = ancestor.parent ?? null;
+	}
+	return null;
+};
+const findBlockScopeOwner = (declaratorNode, declarationKind) => {
+	if (declarationKind !== "let" && declarationKind !== "const") return findScopeOwner(declaratorNode);
+	let ancestor = declaratorNode.parent;
+	while (ancestor) {
+		if (ancestor.type === "BlockStatement") {
+			const blockParent = ancestor.parent;
+			if (blockParent && (blockParent.type === "FunctionDeclaration" || blockParent.type === "FunctionExpression" || blockParent.type === "ArrowFunctionExpression" || blockParent.type === "MethodDefinition")) return findScopeOwner(declaratorNode);
+			return ancestor;
+		}
+		if (FUNCTION_LIKE_TYPES$1.has(ancestor.type)) return ancestor;
+		ancestor = ancestor.parent ?? null;
+	}
+	return null;
+};
+const collectFromBindingPattern = (pattern, initializer, scopeOwner, out) => {
+	if (isNodeOfType(pattern, "Identifier")) {
+		const list = out.get(pattern.name) ?? [];
+		list.push({
+			bindingIdentifier: pattern,
+			initializer,
+			scopeOwner
+		});
+		out.set(pattern.name, list);
+		return;
+	}
+	if (isNodeOfType(pattern, "ObjectPattern")) {
+		for (const property of pattern.properties) if (isNodeOfType(property, "Property")) {
+			const valueNode = property.value;
+			collectFromBindingPattern(valueNode, isNodeOfType(valueNode, "AssignmentPattern") ? valueNode.right : null, scopeOwner, out);
+		} else if (isNodeOfType(property, "RestElement")) collectFromBindingPattern(property.argument, null, scopeOwner, out);
+		return;
+	}
+	if (isNodeOfType(pattern, "ArrayPattern")) {
+		for (const element of pattern.elements) {
+			if (!element) continue;
+			collectFromBindingPattern(element, isNodeOfType(element, "AssignmentPattern") ? element.right ?? null : null, scopeOwner, out);
+		}
+		return;
+	}
+	if (isNodeOfType(pattern, "AssignmentPattern")) {
+		collectFromBindingPattern(pattern.left, pattern.right ?? null, scopeOwner, out);
+		return;
+	}
+	if (isNodeOfType(pattern, "RestElement")) collectFromBindingPattern(pattern.argument, null, scopeOwner, out);
+};
+const buildBindingIndex = (root) => {
+	const out = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		if (isNodeOfType(node, "VariableDeclarator")) {
+			const declaration = node.parent;
+			const scopeOwner = findBlockScopeOwner(node, declaration && isNodeOfType(declaration, "VariableDeclaration") ? declaration.kind : void 0);
+			if (scopeOwner) collectFromBindingPattern(node.id, node.init ?? null, scopeOwner, out);
+		}
+		if ((isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression")) && node.id) {
+			const enclosing = node.parent ? findScopeOwner(node.parent) : null;
+			if (enclosing) {
+				const list = out.get(node.id.name) ?? [];
+				list.push({
+					bindingIdentifier: node.id,
+					initializer: node,
+					scopeOwner: enclosing
+				});
+				out.set(node.id.name, list);
+			}
+		}
+		if ((isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression")) && node.id) {
+			const enclosing = node.parent ? findScopeOwner(node.parent) : null;
+			if (enclosing) {
+				const list = out.get(node.id.name) ?? [];
+				list.push({
+					bindingIdentifier: node.id,
+					initializer: node,
+					scopeOwner: enclosing
+				});
+				out.set(node.id.name, list);
+			}
+		}
+		if (isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression")) {
+			if (Array.isArray(node.params)) for (const param of node.params) {
+				if (!param) continue;
+				collectFromBindingPattern(param, null, node, out);
+				if (isNodeOfType(param, "AssignmentPattern")) collectFromBindingPattern(param.left ?? null, param.right ?? null, node, out);
+			}
+		}
+		if (isNodeOfType(node, "ImportDeclaration")) {
+			const scopeOwner = findScopeOwner(node);
+			if (scopeOwner && Array.isArray(node.specifiers)) for (const specifier of node.specifiers) {
+				const local = specifier.local;
+				if (local && isNodeOfType(local, "Identifier")) {
+					const list = out.get(local.name) ?? [];
+					list.push({
+						bindingIdentifier: local,
+						initializer: specifier,
+						scopeOwner
+					});
+					out.set(local.name, list);
+				}
+			}
+		}
+		if (node.type === "TSImportEqualsDeclaration" || node.type === "TSEnumDeclaration" || node.type === "TSModuleDeclaration") {
+			const idNode = node.id;
+			if (idNode && idNode.type === "Identifier") {
+				const idObject = idNode;
+				const scopeOwner = findScopeOwner(node);
+				if (scopeOwner && typeof idObject.name === "string") {
+					const list = out.get(idObject.name) ?? [];
+					list.push({
+						bindingIdentifier: idNode,
+						initializer: null,
+						scopeOwner
+					});
+					out.set(idObject.name, list);
+				}
+			}
+		}
+		const nodeRecord = node;
+		for (const key of Object.keys(nodeRecord)) {
+			if (key === "parent") continue;
+			const child = nodeRecord[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (isAstNode(item)) visit(item);
+			} else if (isAstNode(child)) visit(child);
+		}
+	};
+	visit(root);
+	return out;
+};
+const programRootCache = /* @__PURE__ */ new WeakMap();
+const getBindingIndex = (referenceNode) => {
+	const programRoot = findProgramRoot(referenceNode);
+	if (!programRoot) return null;
+	let index = programRootCache.get(programRoot);
+	if (!index) {
+		index = buildBindingIndex(programRoot);
+		programRootCache.set(programRoot, index);
+	}
+	return index;
+};
+const findVariableInitializer = (referenceNode, bindingName) => {
+	const index = getBindingIndex(referenceNode);
+	if (!index) return null;
+	const candidates = index.get(bindingName);
+	if (!candidates || candidates.length === 0) return null;
+	const referenceAncestors = /* @__PURE__ */ new Set();
+	let walker = referenceNode;
+	while (walker) {
+		referenceAncestors.add(walker);
+		walker = walker.parent ?? null;
+	}
+	let best = null;
+	for (const candidate of candidates) {
+		if (!referenceAncestors.has(candidate.scopeOwner)) continue;
+		if (best === null) {
+			best = candidate;
+			continue;
+		}
+		let cursor = candidate.scopeOwner;
+		while (cursor) {
+			if (cursor === best.scopeOwner) {
+				best = candidate;
+				break;
+			}
+			cursor = cursor.parent ?? null;
+		}
+	}
+	return best;
+};
+//#endregion
+//#region src/plugin/utils/flatten-jsx-name.ts
+/**
+* Flattens a JSX opener / member-expression chain into a dotted name.
+*
+*   `<Foo />`           → `"Foo"`
+*   `<Namespace.Foo />` → `"Namespace.Foo"`
+*   `<a.b.c />`         → `"a.b.c"`
+*
+* Returns `null` when the chain root isn't a `JSXIdentifier` (e.g.
+* the rare-but-valid `<this.x />` case, which JSX surfaces as a
+* `JSXThisExpression` root).
+*
+* Used by `forbid-elements` and `jsx-props-no-spreading`. Two other
+* rules (`forbid-component-props`, `utils/get-element-type`) keep
+* their own extended variants because they handle additional node
+* types (ThisExpression / JSXNamespacedName) and return a non-
+* nullable string with a sentinel value — semantically distinct.
+*/
+const flattenJsxName$1 = (node) => {
+	if (isNodeOfType(node, "JSXIdentifier")) return node.name;
+	if (isNodeOfType(node, "JSXMemberExpression")) {
+		const objectName = flattenJsxName$1(node.object);
+		if (!objectName) return null;
+		return `${objectName}.${node.property.name}`;
+	}
+	return null;
+};
+//#endregion
+//#region src/plugin/utils/is-member-property.ts
+const isMemberProperty = (node, propertyName) => Boolean(node && isNodeOfType(node, "MemberExpression") && isNodeOfType(node.property, "Identifier") && node.property.name === propertyName);
+//#endregion
 //#region src/plugin/utils/is-nextjs-metadata-image-route-filename.ts
 const isNextjsMetadataImageRouteFilename = (rawFilename) => {
 	if (!rawFilename) return false;
@@ -832,6 +1136,192 @@ const isNextjsMetadataImageRouteFilename = (rawFilename) => {
 //#region src/plugin/utils/normalize-filename.ts
 const normalizeFilename$1 = (filename) => filename.replaceAll("\\", "/");
 //#endregion
+//#region src/plugin/utils/strip-paren-expression.ts
+const TS_WRAPPER_TYPES = new Set([
+	"ParenthesizedExpression",
+	"TSAsExpression",
+	"TSSatisfiesExpression",
+	"TSTypeAssertion",
+	"TSNonNullExpression",
+	"TSInstantiationExpression"
+]);
+const stripParenExpression = (node) => {
+	let current = node;
+	while (true) {
+		if (TS_WRAPPER_TYPES.has(current.type) && "expression" in current && current.expression) {
+			current = current.expression;
+			continue;
+		}
+		if (isNodeOfType(current, "ChainExpression") && current.expression) {
+			current = current.expression;
+			continue;
+		}
+		break;
+	}
+	return current;
+};
+//#endregion
+//#region src/plugin/utils/is-generated-image-render-context.ts
+const IMAGE_RESPONSE_MODULES = ["next/og", "@vercel/og"];
+const SATORI_MODULE = "satori";
+const generatedImageJsxCache = /* @__PURE__ */ new WeakMap();
+const isGeneratedImageRenderFilename = (rawFilename) => {
+	if (!rawFilename) return false;
+	return isNextjsMetadataImageRouteFilename(normalizeFilename$1(rawFilename));
+};
+const isImageResponseCallee = (contextNode, callee) => {
+	if (isNodeOfType(callee, "Identifier")) return IMAGE_RESPONSE_MODULES.some((moduleSource) => getImportedNameFromModule(contextNode, callee.name, moduleSource) === "ImageResponse");
+	if (!isMemberProperty(callee, "ImageResponse")) return false;
+	if (!isNodeOfType(callee.object, "Identifier")) return false;
+	const namespaceIdentifierName = callee.object.name;
+	return IMAGE_RESPONSE_MODULES.some((moduleSource) => isNamespaceImportFromModule(contextNode, namespaceIdentifierName, moduleSource));
+};
+const isSatoriCallee = (contextNode, callee) => {
+	if (!isNodeOfType(callee, "Identifier")) return false;
+	if (getImportedNameFromModule(contextNode, callee.name, SATORI_MODULE) === "satori") return true;
+	return isDefaultImportFromModule(contextNode, callee.name, SATORI_MODULE);
+};
+const isGeneratedImageRendererCall = (node) => {
+	if (!isNodeOfType(node, "CallExpression") && !isNodeOfType(node, "NewExpression")) return false;
+	if (!isNodeOfType(node.callee, "Identifier") && !isNodeOfType(node.callee, "MemberExpression")) return false;
+	return isImageResponseCallee(node, node.callee) || isSatoriCallee(node, node.callee);
+};
+const isComponentIdentifierName = (name) => {
+	const firstCharacter = name[0];
+	return Boolean(firstCharacter && firstCharacter === firstCharacter.toUpperCase());
+};
+const isFunctionLike$3 = (node) => Boolean(node && (isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression")));
+const markFunctionReturnJsx = (functionNode, programRoot, generatedImageJsxNodes, visitedComponentNames) => {
+	if (!isFunctionLike$3(functionNode)) return;
+	if (isNodeOfType(functionNode, "ArrowFunctionExpression")) {
+		const body = stripParenExpression(functionNode.body);
+		if (!isNodeOfType(body, "BlockStatement")) {
+			markGeneratedImageExpression(body, programRoot, generatedImageJsxNodes, visitedComponentNames);
+			return;
+		}
+	}
+	const body = functionNode.body;
+	if (!isNodeOfType(body, "BlockStatement")) return;
+	walkAst(body, (descendantNode) => {
+		if (descendantNode !== body && isFunctionLike$3(descendantNode)) return false;
+		if (!isNodeOfType(descendantNode, "ReturnStatement")) return;
+		if (!descendantNode.argument) return;
+		markGeneratedImageExpression(stripParenExpression(descendantNode.argument), programRoot, generatedImageJsxNodes, visitedComponentNames);
+	});
+};
+const hasNormalJsxUsage = (programRoot, componentName, generatedImageJsxNodes) => {
+	let hasNormalUsage = false;
+	walkAst(programRoot, (descendantNode) => {
+		if (hasNormalUsage) return false;
+		if (!isNodeOfType(descendantNode, "JSXOpeningElement")) return;
+		if (generatedImageJsxNodes.has(descendantNode)) return;
+		if (flattenJsxName$1(descendantNode.name) !== componentName) return;
+		hasNormalUsage = true;
+		return false;
+	});
+	return hasNormalUsage;
+};
+const markComponentRenderJsx = (programRoot, openingElement, generatedImageJsxNodes, visitedComponentNames) => {
+	const tagName = flattenJsxName$1(openingElement.name);
+	if (!tagName || tagName.includes(".") || !isComponentIdentifierName(tagName)) return;
+	if (visitedComponentNames.has(tagName)) return;
+	if (hasNormalJsxUsage(programRoot, tagName, generatedImageJsxNodes)) return;
+	const binding = findVariableInitializer(openingElement, tagName);
+	if (!binding?.initializer) return;
+	visitedComponentNames.add(tagName);
+	markGeneratedImageExpression(stripParenExpression(binding.initializer), programRoot, generatedImageJsxNodes, visitedComponentNames);
+};
+const isInsideGeneratedImageRendererArgument = (node) => {
+	let cursor = node.parent;
+	while (cursor) {
+		if (isGeneratedImageRendererCall(cursor)) return true;
+		cursor = cursor.parent ?? null;
+	}
+	return false;
+};
+const hasNormalFunctionCallUsage = (programRoot, functionName) => {
+	let hasNormalUsage = false;
+	walkAst(programRoot, (descendantNode) => {
+		if (hasNormalUsage) return false;
+		if (!isNodeOfType(descendantNode, "CallExpression")) return;
+		if (!isNodeOfType(descendantNode.callee, "Identifier")) return;
+		if (descendantNode.callee.name !== functionName) return;
+		if (isInsideGeneratedImageRendererArgument(descendantNode)) return;
+		hasNormalUsage = true;
+		return false;
+	});
+	return hasNormalUsage;
+};
+const markJsxSubtree = (node, programRoot, generatedImageJsxNodes, visitedComponentNames) => {
+	walkAst(node, (descendantNode) => {
+		if (!isNodeOfType(descendantNode, "JSXOpeningElement")) return;
+		generatedImageJsxNodes.add(descendantNode);
+		markComponentRenderJsx(programRoot, descendantNode, generatedImageJsxNodes, visitedComponentNames);
+	});
+};
+const markGeneratedImageExpression = (expression, programRoot, generatedImageJsxNodes, visitedComponentNames) => {
+	const unwrappedExpression = stripParenExpression(expression);
+	if (isNodeOfType(unwrappedExpression, "JSXElement") || isNodeOfType(unwrappedExpression, "JSXFragment")) {
+		markJsxSubtree(unwrappedExpression, programRoot, generatedImageJsxNodes, visitedComponentNames);
+		return;
+	}
+	if (isFunctionLike$3(unwrappedExpression)) {
+		markFunctionReturnJsx(unwrappedExpression, programRoot, generatedImageJsxNodes, visitedComponentNames);
+		return;
+	}
+	if (isNodeOfType(unwrappedExpression, "ConditionalExpression")) {
+		markGeneratedImageExpression(unwrappedExpression.consequent, programRoot, generatedImageJsxNodes, visitedComponentNames);
+		markGeneratedImageExpression(unwrappedExpression.alternate, programRoot, generatedImageJsxNodes, visitedComponentNames);
+		return;
+	}
+	if (isNodeOfType(unwrappedExpression, "LogicalExpression")) {
+		markGeneratedImageExpression(unwrappedExpression.left, programRoot, generatedImageJsxNodes, visitedComponentNames);
+		markGeneratedImageExpression(unwrappedExpression.right, programRoot, generatedImageJsxNodes, visitedComponentNames);
+		return;
+	}
+	if (isNodeOfType(unwrappedExpression, "CallExpression")) {
+		const callee = unwrappedExpression.callee;
+		if (isFunctionLike$3(callee)) {
+			markFunctionReturnJsx(callee, programRoot, generatedImageJsxNodes, visitedComponentNames);
+			return;
+		}
+		if (!isNodeOfType(callee, "Identifier")) return;
+		if (visitedComponentNames.has(callee.name)) return;
+		if (hasNormalJsxUsage(programRoot, callee.name, generatedImageJsxNodes)) return;
+		if (hasNormalFunctionCallUsage(programRoot, callee.name)) return;
+		const binding = findVariableInitializer(callee, callee.name);
+		if (!binding?.initializer || !isFunctionLike$3(stripParenExpression(binding.initializer))) return;
+		visitedComponentNames.add(callee.name);
+		markFunctionReturnJsx(stripParenExpression(binding.initializer), programRoot, generatedImageJsxNodes, visitedComponentNames);
+		return;
+	}
+	if (isNodeOfType(unwrappedExpression, "Identifier")) {
+		if (visitedComponentNames.has(unwrappedExpression.name)) return;
+		visitedComponentNames.add(unwrappedExpression.name);
+		const binding = findVariableInitializer(unwrappedExpression, unwrappedExpression.name);
+		if (!binding?.initializer) return;
+		markGeneratedImageExpression(stripParenExpression(binding.initializer), programRoot, generatedImageJsxNodes, visitedComponentNames);
+	}
+};
+const collectGeneratedImageJsxNodes = (programRoot) => {
+	const cached = generatedImageJsxCache.get(programRoot);
+	if (cached) return cached;
+	const generatedImageJsxNodes = /* @__PURE__ */ new WeakSet();
+	walkAst(programRoot, (descendantNode) => {
+		if (!isGeneratedImageRendererCall(descendantNode)) return;
+		for (const argument of descendantNode.arguments) markGeneratedImageExpression(argument, programRoot, generatedImageJsxNodes, /* @__PURE__ */ new Set());
+	});
+	generatedImageJsxCache.set(programRoot, generatedImageJsxNodes);
+	return generatedImageJsxNodes;
+};
+const isGeneratedImageRenderContext = (context, node) => {
+	if (isGeneratedImageRenderFilename(context.filename)) return true;
+	if (!node) return false;
+	const programRoot = findProgramRoot(node);
+	if (!programRoot) return false;
+	return collectGeneratedImageJsxNodes(programRoot).has(node);
+};
+//#endregion
 //#region src/plugin/utils/is-hidden-from-screen-reader.ts
 const isHiddenFromScreenReader = (openingElement, settings) => {
 	if (getElementType(openingElement, settings).toLowerCase() === "input") {
@@ -887,7 +1377,7 @@ const PREFER_ALT = "Screen readers skip a decorative image more reliably with `a
 const MESSAGE_OBJECT = "Blind users can't use this `<object>` because screen readers can't describe it, so add `alt`, `aria-label`, `aria-labelledby`, `title`, or inner fallback text.";
 const MESSAGE_AREA = "Blind users can't use this `<area>` of the image map because screen readers can't describe it, so add `alt`, `aria-label`, or `aria-labelledby`.";
 const MESSAGE_INPUT_IMAGE = "Blind users can't use this image button because screen readers can't describe it, so add `alt`, `aria-label`, or `aria-labelledby`.";
-const resolveSettings$53 = (settings) => {
+const resolveSettings$52 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.altText ?? {} : {};
 };
@@ -1003,8 +1493,8 @@ const altText = defineRule({
 	recommendation: "Give every meaningful image an `alt`, `aria-label`, or `aria-labelledby`.",
 	category: "Accessibility",
 	create: (context) => {
-		if (isNextjsMetadataImageRouteFilename(normalizeFilename$1(context.filename ?? ""))) return {};
-		const settings = resolveSettings$53(context.settings);
+		if (isGeneratedImageRenderContext(context)) return {};
+		const settings = resolveSettings$52(context.settings);
 		const checkImg = !settings.elements || settings.elements.includes("img");
 		const checkObject = !settings.elements || settings.elements.includes("object");
 		const checkArea = !settings.elements || settings.elements.includes("area");
@@ -1014,6 +1504,7 @@ const altText = defineRule({
 		const areaAliases = new Set(settings.area ?? []);
 		const inputImageAliases = new Set(settings["input[type=\"image\"]"] ?? []);
 		return { JSXOpeningElement(node) {
+			if (isGeneratedImageRenderContext(context, node)) return;
 			const tag = getElementType(node, context.settings);
 			if (checkImg && (tag === "img" || imgAliases.has(tag))) {
 				imgRule(node, node, context);
@@ -1048,7 +1539,7 @@ const DEFAULT_AMBIGUOUS = [
 	"a link",
 	"learn more"
 ];
-const resolveSettings$52 = (settings) => {
+const resolveSettings$51 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { words: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.anchorAmbiguousText ?? {} : {}).words ?? DEFAULT_AMBIGUOUS };
 };
@@ -1089,7 +1580,7 @@ const anchorAmbiguousText = defineRule({
 	recommendation: "Name where a link goes. Avoid 'click here', 'learn more', and 'link'.",
 	category: "Accessibility",
 	create: (context) => {
-		const settings = resolveSettings$52(context.settings);
+		const settings = resolveSettings$51(context.settings);
 		const ambiguousSet = new Set(settings.words.map((word) => word.toLowerCase()));
 		return { JSXElement(node) {
 			if (getElementType(node.openingElement, context.settings) !== "a") return;
@@ -1139,7 +1630,7 @@ const getStaticTemplateLiteralValue = (templateLiteral) => {
 const MESSAGE_MISSING_HREF = "Keyboard users can't reach this link because it has no `href`, so add a real `href` (or use `<button>` for actions).";
 const MESSAGE_INCORRECT_HREF = "Keyboard users can't reach this link because its `href` goes nowhere (`#`, `javascript:`, or empty), so point it at a real destination.";
 const MESSAGE_CANT_BE_ANCHOR = "Keyboard users can't trigger this link because it's a click handler with no real `href`, so use `<button>` instead.";
-const resolveSettings$51 = (settings) => {
+const resolveSettings$50 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.anchorIsValid ?? {} : {};
 	const jsxA11y = settings?.["jsx-a11y"];
@@ -1178,7 +1669,7 @@ const anchorIsValid = defineRule({
 	recommendation: "Give links a real destination. Use `<button>` for in-page actions.",
 	category: "Accessibility",
 	create: (context) => {
-		const settings = resolveSettings$51(context.settings);
+		const settings = resolveSettings$50(context.settings);
 		return { JSXOpeningElement(node) {
 			if (getElementType(node, context.settings) !== "a") return;
 			let hrefAttribute;
@@ -2213,7 +2704,7 @@ const PRESENTATION_ROLES$2 = new Set(["presentation", "none"]);
 //#endregion
 //#region src/plugin/rules/a11y/aria-role.ts
 const buildBaseMessage = (suffix) => `Screen reader users get no help from this \`role\` because it isn't a valid ARIA role, so use a real, non-abstract role.${suffix}`;
-const resolveSettings$50 = (settings) => {
+const resolveSettings$49 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.ariaRole ?? {} : {};
 	return {
@@ -2229,7 +2720,7 @@ const ariaRole = defineRule({
 	recommendation: "Use a real, non-abstract ARIA role.",
 	category: "Accessibility",
 	create: (context) => {
-		const settings = resolveSettings$50(context.settings);
+		const settings = resolveSettings$49(context.settings);
 		return { JSXOpeningElement(node) {
 			const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
 			if (!roleAttribute) return;
@@ -2330,7 +2821,7 @@ const LOOP_TYPES = [
 	"WhileStatement",
 	"DoWhileStatement"
 ];
-const FUNCTION_LIKE_TYPES$1 = new Set([
+const FUNCTION_LIKE_TYPES = new Set([
 	"FunctionDeclaration",
 	"FunctionExpression",
 	"ArrowFunctionExpression"
@@ -3255,7 +3746,7 @@ const FORM_CONTROL_TAGS = new Set([
 	"select",
 	"form"
 ]);
-const resolveSettings$49 = (settings) => {
+const resolveSettings$48 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { inputComponents: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.autocompleteValid ?? {} : {}).inputComponents ?? [] };
 };
@@ -3267,7 +3758,7 @@ const autocompleteValid = defineRule({
 	recommendation: "Use a valid autofill token in `autoComplete`.",
 	category: "Accessibility",
 	create: (context) => {
-		const settings = resolveSettings$49(context.settings);
+		const settings = resolveSettings$48(context.settings);
 		return { JSXOpeningElement: (node) => {
 			const tag = getElementType(node, context.settings);
 			if (!FORM_CONTROL_TAGS.has(tag) && !settings.inputComponents.includes(tag)) return;
@@ -3320,7 +3811,7 @@ const isCreateElementCall = (node) => {
 //#region src/plugin/rules/react-builtins/button-has-type.ts
 const MISSING_MESSAGE$2 = "Your users can submit the form by accident because a `<button>` with no `type` defaults to submit.";
 const INVALID_MESSAGE = "This button's `type` is invalid.";
-const resolveSettings$48 = (settings) => {
+const resolveSettings$47 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.buttonHasType ?? {} : {};
 	return {
@@ -3362,7 +3853,7 @@ const buttonHasType = defineRule({
 	severity: "warn",
 	recommendation: "Always set a `type` on a `<button>`: `type=\"button\"`, `\"submit\"`, or `\"reset\"`.",
 	create: (context) => {
-		const settings = resolveSettings$48(context.settings);
+		const settings = resolveSettings$47(context.settings);
 		const isTestlikeFile = isTestlikeFilename(context.filename);
 		return {
 			JSXOpeningElement(node) {
@@ -3431,7 +3922,7 @@ const buttonHasType = defineRule({
 //#region src/plugin/rules/react-builtins/checked-requires-onchange-or-readonly.ts
 const MISSING_MESSAGE$1 = "Your users can't toggle this input because `checked` has no `onChange`.";
 const EXCLUSIVE_MESSAGE = "This input behaves unpredictably with both `checked` & `defaultChecked` set.";
-const resolveSettings$47 = (settings) => {
+const resolveSettings$46 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.checkedRequiresOnchangeOrReadonly ?? {} : {};
 	return {
@@ -3484,7 +3975,7 @@ const checkedRequiresOnchangeOrReadonly = defineRule({
 	recommendation: "Add `onChange` (controlled) or `readOnly` (display-only), or use `defaultChecked` for an uncontrolled checkbox.",
 	category: "Correctness",
 	create: (context) => {
-		const settings = resolveSettings$47(context.settings);
+		const settings = resolveSettings$46(context.settings);
 		const reportFromPresence = (presence) => {
 			if (presence.checkedNode && presence.defaultCheckedNode && !settings.ignoreExclusiveCheckedAttribute) context.report({
 				node: presence.checkedNode,
@@ -3628,9 +4119,6 @@ const clientLocalstorageNoVersion = defineRule({
 	} })
 });
 //#endregion
-//#region src/plugin/utils/is-member-property.ts
-const isMemberProperty = (node, propertyName) => Boolean(node && isNodeOfType(node, "MemberExpression") && isNodeOfType(node.property, "Identifier") && node.property.name === propertyName);
-//#endregion
 //#region src/plugin/rules/client/client-passive-event-listeners.ts
 const clientPassiveEventListeners = defineRule({
 	id: "client-passive-event-listeners",
@@ -3670,31 +4158,6 @@ const isReactComponentName = (name) => {
 	return firstCharacter >= 65 && firstCharacter <= 90;
 };
 //#endregion
-//#region src/plugin/utils/strip-paren-expression.ts
-const TS_WRAPPER_TYPES = new Set([
-	"ParenthesizedExpression",
-	"TSAsExpression",
-	"TSSatisfiesExpression",
-	"TSTypeAssertion",
-	"TSNonNullExpression",
-	"TSInstantiationExpression"
-]);
-const stripParenExpression = (node) => {
-	let current = node;
-	while (true) {
-		if (TS_WRAPPER_TYPES.has(current.type) && "expression" in current && current.expression) {
-			current = current.expression;
-			continue;
-		}
-		if (isNodeOfType(current, "ChainExpression") && current.expression) {
-			current = current.expression;
-			continue;
-		}
-		break;
-	}
-	return current;
-};
-//#endregion
 //#region src/plugin/rules/a11y/control-has-associated-label.ts
 const MESSAGE$48 = "Blind users can't tell what this control does because screen readers find no label, so add visible text, `aria-label`, or `aria-labelledby`.";
 const DEFAULT_IGNORE_ELEMENTS = ["link", "canvas"];
@@ -3708,7 +4171,7 @@ const HTML_FOR_ATTRIBUTE = "htmlFor";
 const LABEL_ELEMENT = "label";
 const DEFAULT_DEPTH = 5;
 const MAX_DEPTH = 25;
-const resolveSettings$46 = (settings) => {
+const resolveSettings$45 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.controlHasAssociatedLabel ?? {} : {};
 	return {
@@ -3828,7 +4291,7 @@ const controlHasAssociatedLabel = defineRule({
 	recommendation: "Give every interactive control a label screen readers can read.",
 	category: "Accessibility",
 	create: (context) => {
-		const settings = resolveSettings$46(context.settings);
+		const settings = resolveSettings$45(context.settings);
 		const isTestlikeFile = isTestlikeFilename(context.filename);
 		return { JSXElement(node) {
 			if (isTestlikeFile) return;
@@ -4199,7 +4662,7 @@ const DEFAULT_ADDITIONAL_HOCS = [
 	"lazy",
 	"withTracking"
 ];
-const resolveSettings$45 = (settings) => {
+const resolveSettings$44 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.displayName ?? {} : {};
 	const additionalHoCs = new Set(ruleSettings.additionalHoCs ?? DEFAULT_ADDITIONAL_HOCS);
@@ -4391,7 +4854,7 @@ const displayName = defineRule({
 	recommendation: "Give each component a `displayName` so DevTools shows a clear name.",
 	category: "Architecture",
 	create: (context) => {
-		const settings = resolveSettings$45(context.settings);
+		const settings = resolveSettings$44(context.settings);
 		const ignoreNamed = settings.ignoreTranspilerName ? false : true;
 		const reportAt = (node) => {
 			context.report({
@@ -6263,7 +6726,7 @@ const compileGlob = (pattern) => {
 //#endregion
 //#region src/plugin/rules/react-builtins/forbid-component-props.ts
 const DEFAULT_FORBID_PROPS = ["className", "style"];
-const resolveSettings$44 = (settings) => {
+const resolveSettings$43 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const forbid = (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.forbidComponentProps ?? {} : {}).forbid;
 	if (!forbid || forbid.length === 0) return { forbid: DEFAULT_FORBID_PROPS };
@@ -6301,9 +6764,9 @@ const isForbiddenForTag = (entry, tag) => {
 	if (entry.allowedForPatterns.some((regex) => regex.test(tag))) return false;
 	return true;
 };
-const flattenJsxName$1 = (name) => {
+const flattenJsxName = (name) => {
 	if (isNodeOfType(name, "JSXIdentifier")) return name.name;
-	if (isNodeOfType(name, "JSXMemberExpression")) return `${flattenJsxName$1(name.object)}.${name.property.name}`;
+	if (isNodeOfType(name, "JSXMemberExpression")) return `${flattenJsxName(name.object)}.${name.property.name}`;
 	if (name.type === "ThisExpression" || name.type === "JSXThisExpression") return "this";
 	return "";
 };
@@ -6317,11 +6780,11 @@ const forbidComponentProps = defineRule({
 	recommendation: "List the props you want to block per component in the `forbidComponentProps.forbid` setting.",
 	category: "Architecture",
 	create: (context) => {
-		const entries = resolveSettings$44(context.settings).forbid.map(normalizeEntry);
+		const entries = resolveSettings$43(context.settings).forbid.map(normalizeEntry);
 		return { JSXOpeningElement(node) {
 			if (entries.length === 0) return;
 			if (!isSupportedJsxName(node.name)) return;
-			const tag = flattenJsxName$1(node.name);
+			const tag = flattenJsxName(node.name);
 			if (!tag) return;
 			if (!(isReactComponentName(tag.split(".")[0]) || tag.includes("."))) return;
 			for (const attribute of node.attributes) {
@@ -6346,7 +6809,7 @@ const forbidComponentProps = defineRule({
 //#endregion
 //#region src/plugin/rules/react-builtins/forbid-dom-props.ts
 const buildMessage$23 = (propName, customMessage) => customMessage ?? `Your project blocks the \`${propName}\` prop on plain HTML tags.`;
-const resolveSettings$43 = (settings) => {
+const resolveSettings$42 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.forbidDomProps ?? {} : {};
 	const map = /* @__PURE__ */ new Map();
@@ -6368,7 +6831,7 @@ const forbidDomProps = defineRule({
 	recommendation: "List the HTML props you want to block in the `forbidDomProps.forbid` setting.",
 	category: "Architecture",
 	create: (context) => {
-		const forbidMap = resolveSettings$43(context.settings);
+		const forbidMap = resolveSettings$42(context.settings);
 		return { JSXOpeningElement(node) {
 			if (forbidMap.size === 0) return;
 			if (!isNodeOfType(node.name, "JSXIdentifier")) return;
@@ -6416,34 +6879,6 @@ const flattenCalleeName = (callee) => {
 	return null;
 };
 //#endregion
-//#region src/plugin/utils/flatten-jsx-name.ts
-/**
-* Flattens a JSX opener / member-expression chain into a dotted name.
-*
-*   `<Foo />`           → `"Foo"`
-*   `<Namespace.Foo />` → `"Namespace.Foo"`
-*   `<a.b.c />`         → `"a.b.c"`
-*
-* Returns `null` when the chain root isn't a `JSXIdentifier` (e.g.
-* the rare-but-valid `<this.x />` case, which JSX surfaces as a
-* `JSXThisExpression` root).
-*
-* Used by `forbid-elements` and `jsx-props-no-spreading`. Two other
-* rules (`forbid-component-props`, `utils/get-element-type`) keep
-* their own extended variants because they handle additional node
-* types (ThisExpression / JSXNamespacedName) and return a non-
-* nullable string with a sentinel value — semantically distinct.
-*/
-const flattenJsxName = (node) => {
-	if (isNodeOfType(node, "JSXIdentifier")) return node.name;
-	if (isNodeOfType(node, "JSXMemberExpression")) {
-		const objectName = flattenJsxName(node.object);
-		if (!objectName) return null;
-		return `${objectName}.${node.property.name}`;
-	}
-	return null;
-};
-//#endregion
 //#region src/plugin/utils/is-react-function-call.ts
 const PRAGMA = "React";
 const isReactFunctionCall = (node, expectedCall) => {
@@ -6455,7 +6890,7 @@ const isReactFunctionCall = (node, expectedCall) => {
 //#endregion
 //#region src/plugin/rules/react-builtins/forbid-elements.ts
 const buildMessage$22 = (element, customHelp) => customHelp ? `Your project blocks \`<${element}>\` here. ${customHelp}` : `Your project blocks \`<${element}>\` here.`;
-const resolveSettings$42 = (settings) => {
+const resolveSettings$41 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.forbidElements ?? {} : {};
 	const map = /* @__PURE__ */ new Map();
@@ -6471,11 +6906,11 @@ const forbidElements = defineRule({
 	recommendation: "List the element names you want to block in the `forbidElements.forbid` setting.",
 	category: "Architecture",
 	create: (context) => {
-		const forbidMap = resolveSettings$42(context.settings);
+		const forbidMap = resolveSettings$41(context.settings);
 		return {
 			JSXOpeningElement(node) {
 				if (forbidMap.size === 0) return;
-				const fullName = flattenJsxName(node.name);
+				const fullName = flattenJsxName$1(node.name);
 				if (!fullName || !forbidMap.has(fullName)) return;
 				context.report({
 					node: node.name,
@@ -6542,7 +6977,7 @@ const DEFAULT_HEADING_TAGS = [
 	"h5",
 	"h6"
 ];
-const resolveSettings$41 = (settings) => {
+const resolveSettings$40 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.headingHasContent ?? {} : {};
 	return { headingTags: [...DEFAULT_HEADING_TAGS, ...ruleSettings.components ?? []] };
@@ -6555,7 +6990,7 @@ const headingHasContent = defineRule({
 	recommendation: "Put readable text in every heading.",
 	category: "Accessibility",
 	create: (context) => {
-		const settings = resolveSettings$41(context.settings);
+		const settings = resolveSettings$40(context.settings);
 		return { JSXOpeningElement(node) {
 			const elementType = getElementType(node, context.settings);
 			if (!settings.headingTags.includes(elementType)) return;
@@ -6575,7 +7010,7 @@ const headingHasContent = defineRule({
 //#region src/plugin/rules/react-builtins/hook-use-state.ts
 const REQUIRE_DESTRUCTURE_MESSAGE = "This `useState` result is hard to follow.";
 const NAMING_CONVENTION_MESSAGE = "The setter here is hard to spot.";
-const resolveSettings$40 = (settings) => {
+const resolveSettings$39 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { allowDestructuredState: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.hookUseState ?? {} : {}).allowDestructuredState ?? false };
 };
@@ -6602,7 +7037,7 @@ const hookUseState = defineRule({
 	recommendation: "Destructure useState as `const [thing, setThing] = useState(…)`.",
 	category: "Architecture",
 	create: (context) => {
-		const { allowDestructuredState } = resolveSettings$40(context.settings);
+		const { allowDestructuredState } = resolveSettings$39(context.settings);
 		return { CallExpression(node) {
 			if (!isReactFunctionCall(node, "useState")) return;
 			const parent = node.parent;
@@ -6705,7 +7140,7 @@ const hooksNoNanInDeps = defineRule({
 //#endregion
 //#region src/plugin/rules/a11y/html-has-lang.ts
 const MESSAGE$44 = "Screen readers may mispronounce this page because it doesn't declare a language, so add a `lang` attribute like `en`.";
-const resolveSettings$39 = (settings) => {
+const resolveSettings$38 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { htmlTags: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.htmlHasLang ?? {} : {}).htmlTags ?? ["html"] };
 };
@@ -6742,7 +7177,7 @@ const htmlHasLang = defineRule({
 	recommendation: "Set `<html lang=\"…\">` so screen readers know the page language.",
 	category: "Accessibility",
 	create: (context) => {
-		const settings = resolveSettings$39(context.settings);
+		const settings = resolveSettings$38(context.settings);
 		const tagSet = new Set(settings.htmlTags);
 		return { JSXOpeningElement(node) {
 			const tag = getElementType(node, context.settings);
@@ -7138,7 +7573,7 @@ const DEFAULT_REDUNDANT_WORDS = [
 	"photo",
 	"picture"
 ];
-const resolveSettings$38 = (settings) => {
+const resolveSettings$37 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.imgRedundantAlt ?? {} : {};
 	return {
@@ -7185,8 +7620,10 @@ const imgRedundantAlt = defineRule({
 	recommendation: "Do not put 'image' or 'photo' in alt text. Describe what is shown.",
 	category: "Accessibility",
 	create: (context) => {
-		const settings = resolveSettings$38(context.settings);
+		if (isGeneratedImageRenderContext(context)) return {};
+		const settings = resolveSettings$37(context.settings);
 		return { JSXOpeningElement(node) {
+			if (isGeneratedImageRenderContext(context, node)) return;
 			const tag = getElementType(node, context.settings);
 			if (!settings.components.includes(tag)) return;
 			if (isHiddenFromScreenReader(node, context.settings)) return;
@@ -7275,7 +7712,7 @@ const DEFAULT_TABBABLE_ROLES = [
 	"switch",
 	"textbox"
 ];
-const resolveSettings$37 = (settings) => {
+const resolveSettings$36 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { tabbable: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.interactiveSupportsFocus ?? {} : {}).tabbable ?? DEFAULT_TABBABLE_ROLES };
 };
@@ -7287,7 +7724,7 @@ const interactiveSupportsFocus = defineRule({
 	recommendation: "Add `tabIndex` to elements with interactive roles and handlers.",
 	category: "Accessibility",
 	create: (context) => {
-		const settings = resolveSettings$37(context.settings);
+		const settings = resolveSettings$36(context.settings);
 		const tabbableSet = new Set(settings.tabbable);
 		return { JSXOpeningElement(node) {
 			const roleAttribute = hasJsxPropIgnoreCase(node.attributes, "role");
@@ -7308,88 +7745,6 @@ const interactiveSupportsFocus = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/find-import-source-for-name.ts
-const collectFromProgram = (programRoot) => {
-	const lookup = /* @__PURE__ */ new Map();
-	const visit = (node) => {
-		if (node.type === "ImportDeclaration" && "source" in node && node.source) {
-			const source = node.source.value;
-			if (typeof source !== "string") return;
-			if ("specifiers" in node && Array.isArray(node.specifiers)) for (const specifier of node.specifiers) {
-				if (!("local" in specifier) || !specifier.local) continue;
-				const local = specifier.local;
-				if (typeof local.name !== "string") continue;
-				if (specifier.type === "ImportDefaultSpecifier") lookup.set(local.name, {
-					source,
-					imported: null,
-					isDefault: true,
-					isNamespace: false
-				});
-				else if (specifier.type === "ImportNamespaceSpecifier") lookup.set(local.name, {
-					source,
-					imported: null,
-					isDefault: false,
-					isNamespace: true
-				});
-				else if (specifier.type === "ImportSpecifier") {
-					const importedNode = specifier.imported;
-					const importedName = importedNode?.name ?? (typeof importedNode?.value === "string" ? importedNode.value : null);
-					lookup.set(local.name, {
-						source,
-						imported: importedName,
-						isDefault: false,
-						isNamespace: false
-					});
-				}
-			}
-			return;
-		}
-		const nodeRecord = node;
-		for (const key of Object.keys(nodeRecord)) {
-			if (key === "parent") continue;
-			const child = nodeRecord[key];
-			if (Array.isArray(child)) {
-				for (const item of child) if (isAstNode(item)) visit(item);
-			} else if (isAstNode(child)) visit(child);
-		}
-	};
-	visit(programRoot);
-	return lookup;
-};
-const importLookupCache = /* @__PURE__ */ new WeakMap();
-const getImportLookup = (node) => {
-	const programRoot = findProgramRoot(node);
-	if (!programRoot) return null;
-	let cached = importLookupCache.get(programRoot);
-	if (!cached) {
-		cached = collectFromProgram(programRoot);
-		importLookupCache.set(programRoot, cached);
-	}
-	return cached;
-};
-const isImportedFromModule = (contextNode, localIdentifierName, moduleSource) => {
-	const lookup = getImportLookup(contextNode);
-	if (!lookup) return false;
-	const info = lookup.get(localIdentifierName);
-	if (!info) return false;
-	return info.source === moduleSource;
-};
-const isNamespaceImportFromModule = (contextNode, localIdentifierName, moduleSource) => {
-	const lookup = getImportLookup(contextNode);
-	if (!lookup) return false;
-	const info = lookup.get(localIdentifierName);
-	if (!info) return false;
-	return info.isNamespace && info.source === moduleSource;
-};
-const getImportedNameFromModule = (contextNode, localIdentifierName, moduleSource) => {
-	const lookup = getImportLookup(contextNode);
-	if (!lookup) return null;
-	const info = lookup.get(localIdentifierName);
-	if (!info) return null;
-	if (info.source !== moduleSource) return null;
-	return info.imported;
-};
-//#endregion
 //#region src/plugin/rules/jotai/jotai-derived-atom-returns-fresh-object.ts
 const isAtomFromJotai = (callExpression) => {
 	if (!isNodeOfType(callExpression.callee, "Identifier")) return false;
@@ -8585,7 +8940,7 @@ const jsTosortedImmutable = defineRule({
 const NEVER_MESSAGE$2 = () => `This prop is written inconsistently.`;
 const ALWAYS_MESSAGE$2 = () => `This prop is written inconsistently.`;
 const FALSE_OMITTED_MESSAGE = (attributeName) => `\`${attributeName}={false}\` does nothing.`;
-const resolveSettings$36 = (settings) => {
+const resolveSettings$35 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxBooleanValue ?? {} : {};
 	return {
@@ -8603,7 +8958,7 @@ const jsxBooleanValue = defineRule({
 	recommendation: "Pick a single boolean-attribute style across the codebase (default: omit `={true}`).",
 	category: "Architecture",
 	create: (context) => {
-		const settings = resolveSettings$36(context.settings);
+		const settings = resolveSettings$35(context.settings);
 		const alwaysSet = new Set(settings.always);
 		const neverSet = new Set(settings.never);
 		return { JSXAttribute(node) {
@@ -8657,7 +9012,7 @@ const jsxBooleanValue = defineRule({
 const UNNECESSARY_BRACES_MESSAGE = "These curly braces do nothing here.";
 const REQUIRED_BRACES_MESSAGE = "This value needs curly braces `{ }` to read as an expression.";
 const isAllowedMode = (value) => value === "always" || value === "never" || value === "ignore";
-const resolveSettings$35 = (settings) => {
+const resolveSettings$34 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettingsRaw = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxCurlyBracePresence : void 0;
 	if (isAllowedMode(ruleSettingsRaw)) return {
@@ -8753,7 +9108,7 @@ const jsxCurlyBracePresence = defineRule({
 	recommendation: "Pick a consistent quoting style for JSX literal values.",
 	category: "Architecture",
 	create: (context) => {
-		const settings = resolveSettings$35(context.settings);
+		const settings = resolveSettings$34(context.settings);
 		return {
 			JSXAttribute(node) {
 				const value = node.value;
@@ -8836,7 +9191,7 @@ const containsJsxElement = (root) => {
 //#region src/plugin/rules/react-builtins/jsx-filename-extension.ts
 const JSX_NOT_ALLOWED = (extension) => `This file has JSX but a \`${extension}\` name.`;
 const EXTENSION_ONLY_FOR_JSX = (extension) => `\`${extension}\` files are meant for JSX, but this one has none.`;
-const resolveSettings$34 = (settings) => {
+const resolveSettings$33 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxFilenameExtension ?? {} : {};
 	return {
@@ -8858,7 +9213,7 @@ const jsxFilenameExtension = defineRule({
 	recommendation: "Name files with JSX `.jsx` or `.tsx`, or whatever extension your project uses.",
 	category: "Architecture",
 	create: (context) => {
-		const settings = resolveSettings$34(context.settings);
+		const settings = resolveSettings$33(context.settings);
 		const allowedExtensions = normalizeExtensions(settings.extensions);
 		const filename = normalizeFilename$1(context.filename ?? "fixture.tsx");
 		const extensionOnly = path.extname(filename).slice(1);
@@ -8912,7 +9267,7 @@ const isJsxFragmentElement = (node) => {
 //#region src/plugin/rules/react-builtins/jsx-fragments.ts
 const SYNTAX_MESSAGE = "This fragment is written inconsistently.";
 const ELEMENT_MESSAGE = "This fragment is written inconsistently.";
-const resolveSettings$33 = (settings) => {
+const resolveSettings$32 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { mode: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxFragments ?? {} : {}).mode ?? "syntax" };
 };
@@ -8924,7 +9279,7 @@ const jsxFragments = defineRule({
 	recommendation: "Pick one fragment style across the codebase.",
 	category: "Architecture",
 	create: (context) => {
-		const { mode } = resolveSettings$33(context.settings);
+		const { mode } = resolveSettings$32(context.settings);
 		return {
 			JSXElement(node) {
 				if (mode !== "syntax") return;
@@ -8968,7 +9323,7 @@ const buildPropRegex = (handlerPropPrefix) => {
 	const escaped = tokens.map((token) => token.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("|");
 	return new RegExp(`^(${escaped})[A-Z].*$`);
 };
-const resolveSettings$32 = (settings) => {
+const resolveSettings$31 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxHandlerNames ?? {} : {};
 	let handlerPrefix = DEFAULT_HANDLER_PREFIX;
@@ -9044,7 +9399,7 @@ const jsxHandlerNames = defineRule({
 	recommendation: "Use the `on…` prefix for event-handler props and `handle…` for handlers.",
 	category: "Architecture",
 	create: (context) => {
-		const settings = resolveSettings$32(context.settings);
+		const settings = resolveSettings$31(context.settings);
 		return { JSXAttribute(node) {
 			if (settings.ignoreComponentNames.length > 0) {
 				const opening = node.parent;
@@ -9129,7 +9484,7 @@ const MISSING_KEY_ARRAY = "Your users can see the wrong data when this array reo
 const MISSING_KEY_ITERATOR = "Your users can see the wrong data when this list reorders.";
 const KEY_BEFORE_SPREAD = "The `{...spread}` can overwrite this `key` & break React's tracking.";
 const DUPLICATE_KEY = (keyValue) => `Your users can see the wrong data because two elements share the key "${keyValue}".`;
-const resolveSettings$31 = (settings) => {
+const resolveSettings$30 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxKey ?? {} : {};
 	return {
@@ -9277,7 +9632,7 @@ const jsxKey = defineRule({
 	severity: "error",
 	recommendation: "Add a `key={...}` prop to each element produced inside `.map` / array literal.",
 	create: (context) => {
-		const settings = resolveSettings$31(context.settings);
+		const settings = resolveSettings$30(context.settings);
 		return {
 			JSXElement(node) {
 				const openingElement = node.openingElement;
@@ -9327,194 +9682,10 @@ const jsxKey = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/utils/find-variable-initializer.ts
-const FUNCTION_LIKE_TYPES = new Set([
-	"FunctionDeclaration",
-	"FunctionExpression",
-	"ArrowFunctionExpression",
-	"MethodDefinition",
-	"Program"
-]);
-const findScopeOwner = (node) => {
-	let ancestor = node;
-	while (ancestor) {
-		if (FUNCTION_LIKE_TYPES.has(ancestor.type)) return ancestor;
-		ancestor = ancestor.parent ?? null;
-	}
-	return null;
-};
-const findBlockScopeOwner = (declaratorNode, declarationKind) => {
-	if (declarationKind !== "let" && declarationKind !== "const") return findScopeOwner(declaratorNode);
-	let ancestor = declaratorNode.parent;
-	while (ancestor) {
-		if (ancestor.type === "BlockStatement") {
-			const blockParent = ancestor.parent;
-			if (blockParent && (blockParent.type === "FunctionDeclaration" || blockParent.type === "FunctionExpression" || blockParent.type === "ArrowFunctionExpression" || blockParent.type === "MethodDefinition")) return findScopeOwner(declaratorNode);
-			return ancestor;
-		}
-		if (FUNCTION_LIKE_TYPES.has(ancestor.type)) return ancestor;
-		ancestor = ancestor.parent ?? null;
-	}
-	return null;
-};
-const collectFromBindingPattern = (pattern, initializer, scopeOwner, out) => {
-	if (isNodeOfType(pattern, "Identifier")) {
-		const list = out.get(pattern.name) ?? [];
-		list.push({
-			bindingIdentifier: pattern,
-			initializer,
-			scopeOwner
-		});
-		out.set(pattern.name, list);
-		return;
-	}
-	if (isNodeOfType(pattern, "ObjectPattern")) {
-		for (const property of pattern.properties) if (isNodeOfType(property, "Property")) {
-			const valueNode = property.value;
-			collectFromBindingPattern(valueNode, isNodeOfType(valueNode, "AssignmentPattern") ? valueNode.right : null, scopeOwner, out);
-		} else if (isNodeOfType(property, "RestElement")) collectFromBindingPattern(property.argument, null, scopeOwner, out);
-		return;
-	}
-	if (isNodeOfType(pattern, "ArrayPattern")) {
-		for (const element of pattern.elements) {
-			if (!element) continue;
-			collectFromBindingPattern(element, isNodeOfType(element, "AssignmentPattern") ? element.right ?? null : null, scopeOwner, out);
-		}
-		return;
-	}
-	if (isNodeOfType(pattern, "AssignmentPattern")) {
-		collectFromBindingPattern(pattern.left, pattern.right ?? null, scopeOwner, out);
-		return;
-	}
-	if (isNodeOfType(pattern, "RestElement")) collectFromBindingPattern(pattern.argument, null, scopeOwner, out);
-};
-const buildBindingIndex = (root) => {
-	const out = /* @__PURE__ */ new Map();
-	const visit = (node) => {
-		if (isNodeOfType(node, "VariableDeclarator")) {
-			const declaration = node.parent;
-			const scopeOwner = findBlockScopeOwner(node, declaration && isNodeOfType(declaration, "VariableDeclaration") ? declaration.kind : void 0);
-			if (scopeOwner) collectFromBindingPattern(node.id, node.init ?? null, scopeOwner, out);
-		}
-		if ((isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression")) && node.id) {
-			const enclosing = node.parent ? findScopeOwner(node.parent) : null;
-			if (enclosing) {
-				const list = out.get(node.id.name) ?? [];
-				list.push({
-					bindingIdentifier: node.id,
-					initializer: node,
-					scopeOwner: enclosing
-				});
-				out.set(node.id.name, list);
-			}
-		}
-		if ((isNodeOfType(node, "ClassDeclaration") || isNodeOfType(node, "ClassExpression")) && node.id) {
-			const enclosing = node.parent ? findScopeOwner(node.parent) : null;
-			if (enclosing) {
-				const list = out.get(node.id.name) ?? [];
-				list.push({
-					bindingIdentifier: node.id,
-					initializer: node,
-					scopeOwner: enclosing
-				});
-				out.set(node.id.name, list);
-			}
-		}
-		if (isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression")) {
-			if (Array.isArray(node.params)) for (const param of node.params) {
-				if (!param) continue;
-				collectFromBindingPattern(param, null, node, out);
-				if (isNodeOfType(param, "AssignmentPattern")) collectFromBindingPattern(param.left ?? null, param.right ?? null, node, out);
-			}
-		}
-		if (isNodeOfType(node, "ImportDeclaration")) {
-			const scopeOwner = findScopeOwner(node);
-			if (scopeOwner && Array.isArray(node.specifiers)) for (const specifier of node.specifiers) {
-				const local = specifier.local;
-				if (local && isNodeOfType(local, "Identifier")) {
-					const list = out.get(local.name) ?? [];
-					list.push({
-						bindingIdentifier: local,
-						initializer: specifier,
-						scopeOwner
-					});
-					out.set(local.name, list);
-				}
-			}
-		}
-		if (node.type === "TSImportEqualsDeclaration" || node.type === "TSEnumDeclaration" || node.type === "TSModuleDeclaration") {
-			const idNode = node.id;
-			if (idNode && idNode.type === "Identifier") {
-				const idObject = idNode;
-				const scopeOwner = findScopeOwner(node);
-				if (scopeOwner && typeof idObject.name === "string") {
-					const list = out.get(idObject.name) ?? [];
-					list.push({
-						bindingIdentifier: idNode,
-						initializer: null,
-						scopeOwner
-					});
-					out.set(idObject.name, list);
-				}
-			}
-		}
-		const nodeRecord = node;
-		for (const key of Object.keys(nodeRecord)) {
-			if (key === "parent") continue;
-			const child = nodeRecord[key];
-			if (Array.isArray(child)) {
-				for (const item of child) if (isAstNode(item)) visit(item);
-			} else if (isAstNode(child)) visit(child);
-		}
-	};
-	visit(root);
-	return out;
-};
-const programRootCache = /* @__PURE__ */ new WeakMap();
-const getBindingIndex = (referenceNode) => {
-	const programRoot = findProgramRoot(referenceNode);
-	if (!programRoot) return null;
-	let index = programRootCache.get(programRoot);
-	if (!index) {
-		index = buildBindingIndex(programRoot);
-		programRootCache.set(programRoot, index);
-	}
-	return index;
-};
-const findVariableInitializer = (referenceNode, bindingName) => {
-	const index = getBindingIndex(referenceNode);
-	if (!index) return null;
-	const candidates = index.get(bindingName);
-	if (!candidates || candidates.length === 0) return null;
-	const referenceAncestors = /* @__PURE__ */ new Set();
-	let walker = referenceNode;
-	while (walker) {
-		referenceAncestors.add(walker);
-		walker = walker.parent ?? null;
-	}
-	let best = null;
-	for (const candidate of candidates) {
-		if (!referenceAncestors.has(candidate.scopeOwner)) continue;
-		if (best === null) {
-			best = candidate;
-			continue;
-		}
-		let cursor = candidate.scopeOwner;
-		while (cursor) {
-			if (cursor === best.scopeOwner) {
-				best = candidate;
-				break;
-			}
-			cursor = cursor.parent ?? null;
-		}
-	}
-	return best;
-};
-//#endregion
 //#region src/plugin/rules/react-builtins/jsx-max-depth.ts
 const buildMessage$18 = (depth, max) => `This JSX is hard to read at ${depth} levels deep, past the limit of ${max}.`;
 const DEFAULT_MAX_DEPTH = 14;
-const resolveSettings$30 = (settings) => {
+const resolveSettings$29 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	return { max: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxMaxDepth ?? {} : {}).max ?? DEFAULT_MAX_DEPTH };
 };
@@ -9574,7 +9745,7 @@ const jsxMaxDepth = defineRule({
 	recommendation: "Pull deeply nested JSX into smaller components so it's easier to read.",
 	category: "Architecture",
 	create: (context) => {
-		const { max } = resolveSettings$30(context.settings);
+		const { max } = resolveSettings$29(context.settings);
 		const checkNode = (node) => {
 			if (!isLeafJsxNode(node)) return;
 			const total = computeJsxAncestorDepth(node) + computeChildrenDepth(node.children ?? [], /* @__PURE__ */ new Set());
@@ -11269,7 +11440,7 @@ const jsxNoNewObjectAsProp = defineRule({
 //#region src/plugin/rules/react-builtins/jsx-no-script-url.ts
 const MESSAGE$35 = "A `javascript:` URL is an XSS hole that runs injected input as code.";
 const JAVASCRIPT_URL_PATTERN = /j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i;
-const resolveSettings$29 = (settings) => {
+const resolveSettings$28 = (settings) => {
 	const reactDoctor = settings?.["react-doctor"];
 	if (typeof reactDoctor !== "object" || reactDoctor === null) return {};
 	return reactDoctor.jsxNoScriptUrl ?? {};
@@ -11295,7 +11466,7 @@ const jsxNoScriptUrl = defineRule({
 	recommendation: "Replace `javascript:` URLs with `onClick` or `onSubmit` handlers. React 19 blocks them anyway.",
 	category: "Security",
 	create: (context) => {
-		const options = resolveSettings$29(context.settings);
+		const options = resolveSettings$28(context.settings);
 		return { JSXOpeningElement(node) {
 			const elementName = getElementName(node);
 			if (!elementName) return;
@@ -11315,287 +11486,6 @@ const jsxNoScriptUrl = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/react-builtins/jsx-no-target-blank.ts
-const NOREFERRER_MESSAGE = "`target=\"_blank\"` without `rel=\"noreferrer\"` lets the linked page hijack your tab to a phishing site.";
-const NOOPENER_MESSAGE = "`target=\"_blank\"` without `rel` lets the linked page hijack your tab to a phishing site.";
-const SPREAD_MESSAGE = "A spread here can add `target=\"_blank\"`, letting the linked page hijack your tab to a phishing site.";
-const resolveSettings$28 = (settings) => {
-	const reactDoctor = settings?.["react-doctor"];
-	const ruleSettings = typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.jsxNoTargetBlank ?? {} : {};
-	const reactSettings = typeof settings?.react === "object" && settings.react !== null ? settings.react : {};
-	const linkComponents = /* @__PURE__ */ new Map();
-	for (const entry of reactSettings.linkComponents ?? []) if (typeof entry === "string") linkComponents.set(entry, ["href"]);
-	else if (typeof entry === "object" && entry !== null) {
-		const linkAttribute = entry.linkAttribute ?? "href";
-		linkComponents.set(entry.name, Array.isArray(linkAttribute) ? linkAttribute : [linkAttribute]);
-	}
-	const formComponents = /* @__PURE__ */ new Map();
-	for (const entry of reactSettings.formComponents ?? []) if (typeof entry === "string") formComponents.set(entry, ["action"]);
-	else if (typeof entry === "object" && entry !== null) {
-		const formAttribute = entry.formAttribute ?? "action";
-		formComponents.set(entry.name, Array.isArray(formAttribute) ? formAttribute : [formAttribute]);
-	}
-	return {
-		enforceDynamicLinks: ruleSettings.enforceDynamicLinks ?? "always",
-		warnOnSpreadAttributes: ruleSettings.warnOnSpreadAttributes ?? false,
-		allowReferrer: ruleSettings.allowReferrer ?? false,
-		links: ruleSettings.links ?? true,
-		forms: ruleSettings.forms ?? false,
-		linkComponents,
-		formComponents
-	};
-};
-const isExternalLink = (href) => href.includes("//");
-const matchHrefExpression = (expression, state) => {
-	if (isNodeOfType(expression, "Literal") && typeof expression.value === "string") {
-		if (isExternalLink(expression.value)) state.isExternal = true;
-		return;
-	}
-	if (isNodeOfType(expression, "Identifier")) {
-		state.isDynamic = true;
-		return;
-	}
-	if (isNodeOfType(expression, "ConditionalExpression")) {
-		matchHrefExpression(expression.consequent, state);
-		matchHrefExpression(expression.alternate, state);
-	}
-};
-const checkHref = (attributeValue, enforceDynamicLinks) => {
-	const state = {
-		isExternal: false,
-		isDynamic: false
-	};
-	if (isNodeOfType(attributeValue, "Literal") && typeof attributeValue.value === "string") state.isExternal = isExternalLink(attributeValue.value);
-	else if (isNodeOfType(attributeValue, "JSXExpressionContainer")) matchHrefExpression(attributeValue.expression, state);
-	if (enforceDynamicLinks === "never") return !state.isExternal || state.isDynamic;
-	return !(state.isExternal || state.isDynamic);
-};
-const checkRelValue = (text, allowReferrer) => {
-	const tokens = text.split(/\s+/);
-	if (allowReferrer) return tokens.includes("noopener") || tokens.includes("noreferrer");
-	return tokens.some((token) => token.toLowerCase() === "noreferrer");
-};
-const matchRelExpression = (expression, allowReferrer) => {
-	const empty = {
-		combined: false,
-		testName: "",
-		consequent: false,
-		alternate: false
-	};
-	if (isNodeOfType(expression, "Literal") && typeof expression.value === "string") return {
-		combined: checkRelValue(expression.value, allowReferrer),
-		testName: "",
-		consequent: false,
-		alternate: false
-	};
-	if (isNodeOfType(expression, "ConditionalExpression")) {
-		const consequent = matchRelExpression(expression.consequent, allowReferrer);
-		const alternate = matchRelExpression(expression.alternate, allowReferrer);
-		const test = expression.test;
-		if (isNodeOfType(test, "Identifier")) return {
-			combined: consequent.combined && alternate.combined,
-			testName: test.name,
-			consequent: consequent.combined,
-			alternate: alternate.combined
-		};
-		return {
-			combined: consequent.combined && alternate.combined,
-			testName: "",
-			consequent: consequent.combined,
-			alternate: alternate.combined
-		};
-	}
-	return empty;
-};
-const checkRel = (attributeValue, allowReferrer) => {
-	const empty = {
-		combined: false,
-		testName: "",
-		consequent: false,
-		alternate: false
-	};
-	if (isNodeOfType(attributeValue, "Literal") && typeof attributeValue.value === "string") return {
-		combined: checkRelValue(attributeValue.value, allowReferrer),
-		testName: "",
-		consequent: false,
-		alternate: false
-	};
-	if (isNodeOfType(attributeValue, "JSXExpressionContainer")) {
-		const expression = attributeValue.expression;
-		if (expression.type === "JSXEmptyExpression") return empty;
-		return matchRelExpression(expression, allowReferrer);
-	}
-	return empty;
-};
-const matchTargetExpression = (expression) => {
-	const empty = {
-		combined: false,
-		testName: "",
-		consequent: false,
-		alternate: false
-	};
-	if (isNodeOfType(expression, "Literal") && typeof expression.value === "string") return {
-		combined: expression.value.toLowerCase() === "_blank",
-		testName: "",
-		consequent: false,
-		alternate: false
-	};
-	if (isNodeOfType(expression, "ConditionalExpression")) {
-		const consequent = matchTargetExpression(expression.consequent);
-		const alternate = matchTargetExpression(expression.alternate);
-		const test = expression.test;
-		const combined = consequent.combined || alternate.combined;
-		if (isNodeOfType(test, "Identifier")) return {
-			combined,
-			testName: test.name,
-			consequent: consequent.combined,
-			alternate: alternate.combined
-		};
-		return {
-			combined,
-			testName: "",
-			consequent: consequent.combined,
-			alternate: alternate.combined
-		};
-	}
-	return empty;
-};
-const checkTarget = (attributeValue) => {
-	if (isNodeOfType(attributeValue, "Literal") && typeof attributeValue.value === "string") return {
-		combined: attributeValue.value.toLowerCase() === "_blank",
-		testName: "",
-		consequent: false,
-		alternate: false
-	};
-	if (isNodeOfType(attributeValue, "JSXExpressionContainer")) {
-		const expression = attributeValue.expression;
-		if (expression.type === "JSXEmptyExpression") return {
-			combined: false,
-			testName: "",
-			consequent: false,
-			alternate: false
-		};
-		return matchTargetExpression(expression);
-	}
-	return {
-		combined: false,
-		testName: "",
-		consequent: false,
-		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",
-	severity: "warn",
-	recommendation: "Add `rel=\"noreferrer\"` (or `\"noopener\"`) when using `target=\"_blank\"`.",
-	category: "Security",
-	create: (context) => {
-		const settings = resolveSettings$28(context.settings);
-		const isLink = (tagName) => {
-			if (!settings.links) return false;
-			if (tagName === "a") return true;
-			return settings.linkComponents.has(tagName);
-		};
-		const isForm = (tagName) => {
-			if (!settings.forms) return false;
-			if (tagName === "form") return true;
-			return settings.formComponents.has(tagName);
-		};
-		return { JSXOpeningElement(node) {
-			const tagName = getOpeningElementName(node);
-			if (!tagName) return;
-			if (!isLink(tagName) && !isForm(tagName)) return;
-			const linkAttributeNames = settings.linkComponents.get(tagName) ?? ["href"];
-			const formAttributeNames = settings.formComponents.get(tagName) ?? ["action"];
-			let targetTuple = {
-				combined: false,
-				testName: "",
-				consequent: false,
-				alternate: false
-			};
-			let relTuple = {
-				combined: false,
-				testName: "",
-				consequent: false,
-				alternate: false
-			};
-			let isHrefValid = true;
-			let hasHrefValue = false;
-			let warnSpread = false;
-			let targetReportNode = node.name;
-			let spreadReportNode = null;
-			for (const attribute of node.attributes) {
-				if (isNodeOfType(attribute, "JSXSpreadAttribute")) {
-					if (settings.warnOnSpreadAttributes) {
-						warnSpread = true;
-						spreadReportNode = attribute;
-						targetTuple = {
-							combined: false,
-							testName: "",
-							consequent: false,
-							alternate: false
-						};
-						relTuple = {
-							combined: false,
-							testName: "",
-							consequent: false,
-							alternate: false
-						};
-						isHrefValid = false;
-						hasHrefValue = true;
-					}
-					continue;
-				}
-				if (!isNodeOfType(attribute, "JSXAttribute")) continue;
-				const attributeName = attribute.name;
-				if (!isNodeOfType(attributeName, "JSXIdentifier")) continue;
-				const propName = attributeName.name;
-				const value = attribute.value;
-				if (propName === "target") {
-					if (value) {
-						targetTuple = checkTarget(value);
-						targetReportNode = value;
-					}
-				} else if (propName === "href" || propName === "action" || linkAttributeNames.includes(propName) || formAttributeNames.includes(propName)) {
-					if (value) {
-						hasHrefValue = true;
-						isHrefValid = checkHref(value, settings.enforceDynamicLinks);
-					}
-				} else if (propName === "rel" && value) relTuple = checkRel(value, settings.allowReferrer);
-			}
-			if (warnSpread) {
-				if (hasHrefValue && isHrefValid || relTuple.combined) return;
-				context.report({
-					node: spreadReportNode ?? node,
-					message: SPREAD_MESSAGE
-				});
-				return;
-			}
-			if (!isHrefValid) {
-				if (targetTuple.testName !== "" && targetTuple.testName === relTuple.testName) {
-					const consequentBad = targetTuple.consequent && !relTuple.consequent;
-					const alternateBad = targetTuple.alternate && !relTuple.alternate;
-					if (consequentBad || alternateBad) context.report({
-						node: targetReportNode,
-						message: settings.allowReferrer ? NOOPENER_MESSAGE : NOREFERRER_MESSAGE
-					});
-					return;
-				}
-				if (targetTuple.combined && !relTuple.combined) context.report({
-					node: targetReportNode,
-					message: settings.allowReferrer ? NOOPENER_MESSAGE : NOREFERRER_MESSAGE
-				});
-			}
-		} };
-	}
-});
-//#endregion
 //#region src/plugin/rules/react-builtins/jsx-no-undef.ts
 const buildMessage$17 = (name) => `\`${name}\` crashes at runtime because it isn't defined here.`;
 const KNOWN_GLOBALS = new Set([
@@ -11925,7 +11815,7 @@ const jsxPropsNoSpreading = defineRule({
 	create: (context) => {
 		const settings = resolveSettings$25(context.settings);
 		return { JSXOpeningElement(node) {
-			const tagName = flattenJsxName(node.name);
+			const tagName = flattenJsxName$1(node.name);
 			if (!tagName) return;
 			const isCustom = isReactComponentName(tagName) || tagName.includes(".");
 			const isHtml = !isCustom;
@@ -12515,7 +12405,6 @@ const nextjsAsyncClientComponent = defineRule({
 const PAGE_FILE_PATTERN = /\/page\.(tsx?|jsx?)$/;
 const PAGE_OR_LAYOUT_FILE_PATTERN = /\/(page|layout)\.(tsx?|jsx?)$/;
 const INTERNAL_PAGE_PATH_PATTERN = /\/(?:(?:\((?:dashboard|admin|settings|account|internal|manage|console|portal|auth|onboarding|app|ee|protected)\))|(?:dashboard|admin|settings|account|internal|manage|console|portal))\//i;
-const OG_ROUTE_PATTERN = /\/og\b/i;
 const PAGES_DIRECTORY_PATTERN = /\/pages\//;
 const NEXTJS_NAVIGATION_FUNCTIONS = new Set([
 	"redirect",
@@ -12952,11 +12841,9 @@ const nextjsNoImgElement = defineRule({
 	severity: "warn",
 	recommendation: "`import Image from 'next/image'` for automatic WebP/AVIF, lazy loading, and responsive srcset",
 	create: (context) => {
-		const filename = normalizeFilename$1(context.filename ?? "");
-		const isOgRoute = OG_ROUTE_PATTERN.test(filename);
-		const isMetadataImageRoute = isNextjsMetadataImageRouteFilename(filename);
+		if (isGeneratedImageRenderContext(context)) return {};
 		return { JSXOpeningElement(node) {
-			if (isOgRoute || isMetadataImageRoute) return;
+			if (isGeneratedImageRenderContext(context, node)) return;
 			if (isNodeOfType(node.name, "JSXIdentifier") && node.name.name === "img") context.report({
 				node,
 				message: "Plain <img> ships unoptimized, oversized images to your users."
@@ -23799,7 +23686,7 @@ const noUnknownProperty = defineRule({
 	create: (context) => {
 		const { ignore = [], requireDataLowercase = false } = resolveSettings$10(context.settings);
 		const ignoreSet = new Set(ignore);
-		if (isNextjsMetadataImageRouteFilename(context.filename)) ignoreSet.add("tw");
+		if (isGeneratedImageRenderContext(context)) ignoreSet.add("tw");
 		let fileIsNonReactJsx = false;
 		return {
 			Program(node) {
@@ -23834,6 +23721,7 @@ const noUnknownProperty = defineRule({
 					if (!isNodeOfType(attribute, "JSXAttribute")) continue;
 					const actualName = getJsxAttributeName(attribute.name);
 					if (!actualName) continue;
+					if (actualName === "tw" && isGeneratedImageRenderContext(context, node)) continue;
 					if (ignoreSet.has(actualName)) continue;
 					if (isValidDataAttribute(actualName)) {
 						if (requireDataLowercase && hasUppercaseChar(actualName)) context.report({
@@ -25455,12 +25343,12 @@ const doesFunctionReturnsObjectLiteral = (functionNode) => {
 			const child = nodeRecord[key];
 			if (Array.isArray(child)) for (const item of child) {
 				if (!isAstNode(item)) continue;
-				if (FUNCTION_LIKE_TYPES$1.has(item.type)) continue;
+				if (FUNCTION_LIKE_TYPES.has(item.type)) continue;
 				visit(item);
 				if (returnsObject) return;
 			}
 			else if (isAstNode(child)) {
-				if (FUNCTION_LIKE_TYPES$1.has(child.type)) continue;
+				if (FUNCTION_LIKE_TYPES.has(child.type)) continue;
 				visit(child);
 			}
 		}
@@ -26882,12 +26770,12 @@ const functionBodyHasReturnWithValue = (functionNode) => {
 			const child = nodeRecord[key];
 			if (Array.isArray(child)) for (const item of child) {
 				if (!isAstNode(item)) continue;
-				if (FUNCTION_LIKE_TYPES$1.has(item.type)) continue;
+				if (FUNCTION_LIKE_TYPES.has(item.type)) continue;
 				visit(item);
 				if (didFindReturn) return;
 			}
 			else if (isAstNode(child)) {
-				if (FUNCTION_LIKE_TYPES$1.has(child.type)) continue;
+				if (FUNCTION_LIKE_TYPES.has(child.type)) continue;
 				visit(child);
 			}
 		}
@@ -28637,7 +28525,7 @@ const isExpoUiNamespaceImport = (contextNode, localName) => {
 };
 const isExpoUiComponentElement = (openingElement, contextNode, componentName) => {
 	if (!openingElement.name) return false;
-	const dottedName = flattenJsxName(openingElement.name);
+	const dottedName = flattenJsxName$1(openingElement.name);
 	if (!dottedName) return false;
 	const [rootLocalName, secondName] = dottedName.split(".");
 	if (isNamedImportOf(contextNode, rootLocalName, componentName)) return true;
@@ -28727,7 +28615,7 @@ const collectTopLevelReturnExpressions = (functionNode) => {
 	if (!block || !isNodeOfType(block, "BlockStatement")) return [];
 	const returnExpressions = [];
 	const visit = (node) => {
-		if (FUNCTION_LIKE_TYPES$1.has(node.type)) return;
+		if (FUNCTION_LIKE_TYPES.has(node.type)) return;
 		if (isNodeOfType(node, "ReturnStatement") && node.argument) returnExpressions.push(node.argument);
 		const nodeRecord = node;
 		for (const fieldName of Object.keys(nodeRecord)) {
@@ -35999,17 +35887,6 @@ const reactDoctorRules = [
 			category: "Security"
 		}
 	},
-	{
-		key: "react-doctor/jsx-no-target-blank",
-		id: "jsx-no-target-blank",
-		source: "react-doctor",
-		originallyExternal: true,
-		rule: {
-			...jsxNoTargetBlank,
-			framework: "global",
-			category: "Security"
-		}
-	},
 	{
 		key: "react-doctor/jsx-no-undef",
 		id: "jsx-no-undef",