oxlint-plugin-react-doctor 0.4.0-dev.ee980d9 → 0.4.0-dev.ee9ab33

package/dist/index.js

@@ -1,8 +1,8 @@
 import * as path from "node:path";
-import { analyze } from "eslint-scope";
-import * as eslintVisitorKeys from "eslint-visitor-keys";
 import * as fs from "node:fs";
 import { parseSync } from "oxc-parser";
+import { analyze } from "eslint-scope";
+import * as eslintVisitorKeys from "eslint-visitor-keys";
 //#region src/plugin/utils/is-testlike-filename.ts
 const NON_PRODUCTION_PATH_SEGMENTS = [
 	"/test/",
@@ -13367,1572 +13367,2071 @@ const nextjsNoSideEffectInGetHandler = defineRule({
 	}
 });
 //#endregion
-//#region src/plugin/rules/nextjs/nextjs-no-use-search-params-without-suspense.ts
-const fileMentionsSuspense = (programNode) => {
-	let didSee = false;
-	walkAst(programNode, (child) => {
-		if (didSee) return false;
-		if (isNodeOfType(child, "JSXOpeningElement") && isNodeOfType(child.name, "JSXIdentifier") && child.name.name === "Suspense") {
-			didSee = true;
-			return false;
+//#region src/plugin/utils/find-exported-function-body.ts
+const isFunctionLike = (node) => {
+	if (!node) return false;
+	return isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression");
+};
+const findExportedFunctionBody = (programRoot, exportedName) => {
+	if (!isNodeOfType(programRoot, "Program")) return null;
+	const localBindings = /* @__PURE__ */ new Map();
+	const namedExports = /* @__PURE__ */ new Map();
+	let defaultExport = null;
+	let defaultExportIdentifierName = null;
+	const recordVariableDeclaration = (declaration) => {
+		for (const declarator of declaration.declarations ?? []) {
+			if (!isNodeOfType(declarator, "VariableDeclarator")) continue;
+			if (!isNodeOfType(declarator.id, "Identifier")) continue;
+			const initializer = declarator.init ? stripParenExpression(declarator.init) : null;
+			if (initializer && isFunctionLike(initializer)) localBindings.set(declarator.id.name, initializer);
 		}
-		if (isNodeOfType(child, "ImportDeclaration") && child.source?.value === "react") {
-			if ((child.specifiers ?? []).some((specifier) => isNodeOfType(specifier, "ImportSpecifier") && getImportedName$1(specifier) === "Suspense")) {
-				didSee = true;
-				return false;
+	};
+	for (const statement of programRoot.body ?? []) {
+		if (isNodeOfType(statement, "VariableDeclaration")) {
+			recordVariableDeclaration(statement);
+			continue;
+		}
+		if (isNodeOfType(statement, "FunctionDeclaration") && statement.id) {
+			localBindings.set(statement.id.name, statement);
+			continue;
+		}
+		if (isNodeOfType(statement, "ExportNamedDeclaration")) {
+			const declaration = statement.declaration;
+			if (declaration && isNodeOfType(declaration, "VariableDeclaration")) {
+				recordVariableDeclaration(declaration);
+				for (const declarator of declaration.declarations ?? []) {
+					if (!isNodeOfType(declarator, "VariableDeclarator")) continue;
+					if (!isNodeOfType(declarator.id, "Identifier")) continue;
+					namedExports.set(declarator.id.name, declarator.id.name);
+				}
+			} else if (declaration && isNodeOfType(declaration, "FunctionDeclaration") && declaration.id) {
+				localBindings.set(declaration.id.name, declaration);
+				namedExports.set(declaration.id.name, declaration.id.name);
+			}
+			for (const specifier of statement.specifiers ?? []) {
+				if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
+				const local = specifier.local;
+				const exported = specifier.exported;
+				if (!isNodeOfType(local, "Identifier")) continue;
+				const exportedNameSpec = isNodeOfType(exported, "Identifier") ? exported.name : isNodeOfType(exported, "Literal") && typeof exported.value === "string" ? exported.value : null;
+				if (!exportedNameSpec) continue;
+				namedExports.set(exportedNameSpec, local.name);
 			}
+			continue;
 		}
-	});
-	return didSee;
-};
-const nextjsNoUseSearchParamsWithoutSuspense = defineRule({
-	id: "nextjs-no-use-search-params-without-suspense",
-	title: "useSearchParams without Suspense",
-	tags: ["test-noise"],
-	requires: ["nextjs"],
-	severity: "warn",
-	recommendation: "Wrap the component using useSearchParams: `<Suspense fallback={<Skeleton />}><SearchComponent /></Suspense>`",
-	create: (context) => {
-		let hasSuspenseInFile = false;
-		return {
-			Program(programNode) {
-				hasSuspenseInFile = fileMentionsSuspense(programNode);
-			},
-			CallExpression(node) {
-				if (hasSuspenseInFile) return;
-				if (!isHookCall$1(node, "useSearchParams")) return;
-				context.report({
-					node,
-					message: "useSearchParams() without a <Suspense> boundary forces the whole page into client-side rendering."
-				});
+		if (isNodeOfType(statement, "ExportDefaultDeclaration")) {
+			const declaration = statement.declaration;
+			if (!declaration) continue;
+			if (isNodeOfType(declaration, "FunctionDeclaration") && declaration.id) {
+				localBindings.set(declaration.id.name, declaration);
+				defaultExport = declaration;
+				continue;
+			}
+			if (isFunctionLike(declaration)) {
+				defaultExport = declaration;
+				continue;
+			}
+			if (isNodeOfType(declaration, "Identifier")) {
+				defaultExportIdentifierName = declaration.name;
+				continue;
 			}
-		};
-	}
-});
-//#endregion
-//#region src/plugin/rules/nextjs/nextjs-no-vercel-og-import.ts
-const nextjsNoVercelOgImport = defineRule({
-	id: "nextjs-no-vercel-og-import",
-	title: "@vercel/og import instead of next/og",
-	tags: ["test-noise"],
-	requires: ["nextjs"],
-	severity: "warn",
-	recommendation: "Use `import { ImageResponse } from \"next/og\"`. The `@vercel/og` package is built into Next.js and should not be imported directly",
-	create: (context) => ({ ImportDeclaration(node) {
-		if (node.source?.value !== "@vercel/og") return;
-		context.report({
-			node,
-			message: "@vercel/og is bundled into Next.js. Import from \"next/og\" instead to avoid duplicate code and version mismatch."
-		});
-	} })
-});
-//#endregion
-//#region src/plugin/rules/a11y/no-access-key.ts
-const MESSAGE$31 = "Screen reader users can lose their shortcuts because `accessKey` clashes with them, so remove it.";
-const isUndefinedIdentifier = (expression) => isNodeOfType(expression, "Identifier") && expression.name === "undefined";
-const noAccessKey = defineRule({
-	id: "no-access-key",
-	title: "accessKey attribute used",
-	tags: ["react-jsx-only"],
-	severity: "warn",
-	recommendation: "Do not use `accessKey`. It conflicts with assistive tech shortcuts.",
-	category: "Accessibility",
-	create: (context) => ({ JSXOpeningElement(node) {
-		const accessKey = hasJsxPropIgnoreCase(node.attributes, "accessKey");
-		if (!accessKey) return;
-		const attributeValue = accessKey.value;
-		if (!attributeValue) return;
-		if (isNodeOfType(attributeValue, "Literal") && typeof attributeValue.value === "string") {
-			context.report({
-				node: accessKey,
-				message: MESSAGE$31
-			});
-			return;
 		}
-		if (isNodeOfType(attributeValue, "JSXExpressionContainer")) {
-			const expression = attributeValue.expression;
-			if (!expression || expression.type === "JSXEmptyExpression") return;
-			if (isUndefinedIdentifier(expression)) return;
-			context.report({
-				node: accessKey,
-				message: MESSAGE$31
-			});
+	}
+	if (exportedName === "default") {
+		if (defaultExport) return defaultExport;
+		if (defaultExportIdentifierName) {
+			const binding = localBindings.get(defaultExportIdentifierName);
+			if (binding) return binding;
 		}
-	} })
-});
-//#endregion
-//#region src/plugin/rules/state-and-effects/utils/effect/constants.ts
-const TYPESCRIPT_VISITOR_KEYS = {
-	TSAsExpression: ["expression", "typeAnnotation"],
-	TSNonNullExpression: ["expression"],
-	TSSatisfiesExpression: ["expression", "typeAnnotation"],
-	TSTypeAssertion: ["typeAnnotation", "expression"],
-	TSInstantiationExpression: ["expression", "typeArguments"]
+	}
+	const localName = namedExports.get(exportedName);
+	if (!localName) return null;
+	return localBindings.get(localName) ?? null;
 };
-const VISITOR_KEYS = {
-	...eslintVisitorKeys.KEYS,
-	...TYPESCRIPT_VISITOR_KEYS
+const resolveImportedExportName = (importSpecifier) => {
+	if (isNodeOfType(importSpecifier, "ImportSpecifier")) {
+		const imported = importSpecifier.imported;
+		if (isNodeOfType(imported, "Identifier")) return imported.name;
+		if (isNodeOfType(imported, "Literal") && typeof imported.value === "string") return imported.value;
+		return null;
+	}
+	if (isNodeOfType(importSpecifier, "ImportDefaultSpecifier")) return "default";
+	return null;
 };
-//#endregion
-//#region src/plugin/rules/state-and-effects/utils/effect/get-program-analysis.ts
-const programToAnalysis = /* @__PURE__ */ new WeakMap();
-const stripAndRecordParents = (root) => {
-	const restorations = [];
-	const seen = /* @__PURE__ */ new WeakSet();
-	const visit = (value) => {
-		if (!value || typeof value !== "object") return;
-		if (seen.has(value)) return;
-		seen.add(value);
-		if (Array.isArray(value)) {
-			for (const item of value) visit(item);
-			return;
+const findReExportSourcesForName = (programRoot, exportedName) => {
+	if (!isNodeOfType(programRoot, "Program")) return [];
+	const exportAllSources = [];
+	for (const statement of programRoot.body ?? []) {
+		if (isNodeOfType(statement, "ExportNamedDeclaration") && statement.source) {
+			const sourceValue = statement.source.value;
+			if (typeof sourceValue !== "string") continue;
+			for (const specifier of statement.specifiers ?? []) {
+				if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
+				const exported = specifier.exported;
+				if ((isNodeOfType(exported, "Identifier") ? exported.name : isNodeOfType(exported, "Literal") && typeof exported.value === "string" ? exported.value : null) === exportedName) return [sourceValue];
+			}
 		}
-		const record = value;
-		if (!("type" in record)) return;
-		if ("parent" in record) {
-			restorations.push({
-				node: record,
-				originalParent: record.parent
-			});
-			record.parent = null;
+		if (isNodeOfType(statement, "ExportAllDeclaration") && statement.source) {
+			const sourceValue = statement.source.value;
+			if (typeof sourceValue === "string") exportAllSources.push(sourceValue);
 		}
-		for (const key of Object.keys(record)) {
+	}
+	return exportAllSources;
+};
+//#endregion
+//#region src/plugin/utils/attach-parent-references.ts
+const attachParentReferences = (root) => {
+	const visit = (node, parent) => {
+		const writableNode = node;
+		writableNode.parent = parent;
+		const nodeRecord = node;
+		for (const key of Object.keys(nodeRecord)) {
 			if (key === "parent") continue;
-			visit(record[key]);
+			const child = nodeRecord[key];
+			if (Array.isArray(child)) {
+				for (const item of child) if (isAstNode(item)) visit(item, node);
+			} else if (isAstNode(child)) visit(child, node);
 		}
 	};
-	visit(root);
-	return restorations;
+	visit(root, null);
 };
-const restoreParents = (restorations) => {
-	for (const restoration of restorations) restoration.node.parent = restoration.originalParent;
+//#endregion
+//#region src/plugin/utils/parse-source-file.ts
+const FILENAME_TO_LANG = {
+	".ts": "ts",
+	".tsx": "tsx",
+	".js": "js",
+	".jsx": "jsx",
+	".mjs": "js",
+	".cjs": "js",
+	".mts": "ts",
+	".cts": "ts"
 };
-const getProgramAnalysis = (anyNode) => {
-	const programNode = findProgramRoot(anyNode);
-	if (!programNode) return null;
-	const cached = programToAnalysis.get(programNode);
-	if (cached) return cached;
-	const restorations = stripAndRecordParents(programNode);
-	let scopeManager;
-	try {
-		scopeManager = analyze(programNode, {
-			ecmaVersion: 2024,
-			sourceType: "module",
-			childVisitorKeys: VISITOR_KEYS,
-			fallback: "iteration"
+const resolveLang = (filename) => {
+	return FILENAME_TO_LANG[path.extname(filename).toLowerCase()] ?? "tsx";
+};
+const parseCache = /* @__PURE__ */ new Map();
+const parseSourceFile = (absoluteFilePath) => {
+	let fileStat;
+	try {
+		fileStat = fs.statSync(absoluteFilePath);
+	} catch {
+		return null;
+	}
+	if (!fileStat.isFile()) return null;
+	if (fileStat.size > 2e6) return null;
+	const cached = parseCache.get(absoluteFilePath);
+	if (cached && cached.mtimeMs === fileStat.mtimeMs && cached.size === fileStat.size) return cached.program;
+	if (absoluteFilePath.endsWith(".d.ts") || absoluteFilePath.endsWith(".d.mts") || absoluteFilePath.endsWith(".d.cts")) {
+		parseCache.set(absoluteFilePath, {
+			mtimeMs: fileStat.mtimeMs,
+			size: fileStat.size,
+			program: null
 		});
-	} finally {
-		restoreParents(restorations);
+		return null;
 	}
-	const analysis = {
-		programNode,
-		scopeManager
-	};
-	programToAnalysis.set(programNode, analysis);
-	return analysis;
-};
-const getScopeForNode = (node, manager) => {
-	if (!node.range) return null;
-	let bestScope = null;
-	let bestSize = Infinity;
-	for (const scope of manager.scopes) {
-		const block = scope.block;
-		if (!block?.range) continue;
-		if (node.range[0] < block.range[0] || node.range[1] > block.range[1]) continue;
-		const size = block.range[1] - block.range[0];
-		if (size <= bestSize) {
-			bestSize = size;
-			bestScope = scope;
+	let sourceText;
+	try {
+		sourceText = fs.readFileSync(absoluteFilePath, "utf8");
+	} catch {
+		parseCache.set(absoluteFilePath, {
+			mtimeMs: fileStat.mtimeMs,
+			size: fileStat.size,
+			program: null
+		});
+		return null;
+	}
+	let parsedProgram = null;
+	try {
+		const result = parseSync(absoluteFilePath, sourceText, {
+			astType: "ts",
+			lang: resolveLang(absoluteFilePath)
+		});
+		if (!result.errors.some((parseError) => parseError.severity === "Error")) {
+			parsedProgram = result.program;
+			attachParentReferences(parsedProgram);
 		}
+	} catch {
+		parsedProgram = null;
 	}
-	return bestScope;
+	parseCache.set(absoluteFilePath, {
+		mtimeMs: fileStat.mtimeMs,
+		size: fileStat.size,
+		program: parsedProgram
+	});
+	return parsedProgram;
 };
 //#endregion
-//#region src/plugin/rules/state-and-effects/utils/effect/ast.ts
-const getChildKeys = (node) => VISITOR_KEYS[node.type] ?? Object.keys(node).filter((key) => key !== "parent");
-const ascend = (analysis, ref, visit, visited = /* @__PURE__ */ new Set()) => {
-	if (visited.has(ref)) return;
-	const result = visit(ref);
-	visited.add(ref);
-	if (result === false) return;
-	const defs = ref.resolved?.defs ?? [];
-	for (const def of defs) {
-		if (def.type === "ImportBinding") continue;
-		if (def.type === "Parameter") continue;
-		const defNode = def.node;
-		const next = defNode.init ?? defNode.body;
-		if (!next) continue;
-		for (const innerRef of getDownstreamRefs(analysis, next)) ascend(analysis, innerRef, visit, visited);
-	}
+//#region src/plugin/utils/parse-export-specifiers.ts
+const getSpecifierName = (rawName) => rawName.replace(/^type\s+/, "").trim();
+const parseExportSpecifiers = (specifiersText, declarationIsTypeOnly) => specifiersText.split(",").map((specifierText) => specifierText.trim()).filter(Boolean).map((specifierText) => {
+	const isTypeOnly = declarationIsTypeOnly || specifierText.startsWith("type ");
+	const [rawLocalName, rawExportedName] = specifierText.split(/\s+as\s+/);
+	const localName = getSpecifierName(rawLocalName ?? "");
+	return {
+		localName,
+		exportedName: getSpecifierName(rawExportedName ?? localName),
+		isTypeOnly
+	};
+});
+//#endregion
+//#region src/plugin/utils/strip-js-comments.ts
+const BLOCK_COMMENT_PATTERN = /\/\*[\s\S]*?\*\//g;
+const LINE_COMMENT_PATTERN = /^\s*\/\/.*$/gm;
+const stripJsComments = (sourceText) => sourceText.replace(BLOCK_COMMENT_PATTERN, "").replace(LINE_COMMENT_PATTERN, "");
+//#endregion
+//#region src/plugin/utils/does-module-export-name.ts
+const DEFAULT_EXPORT_DECLARATION_PATTERN = /^\s*export\s+default\b/m;
+const NAMED_EXPORT_DECLARATION_PATTERN = /^\s*export\s+(?:declare\s+)?(?:(?:async\s+)?function|(?:abstract\s+)?class|const|let|var|enum|interface|type)\s+([\w$]+)/gm;
+const LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN$1 = /^\s*export\s+(?:type\s+)?\{([\s\S]*?)\}(?:\s+from\s+["'][^"']+["'])?\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
+const doesSourceTextExportName = (sourceText, exportedName) => {
+	const strippedSource = stripJsComments(sourceText);
+	if (exportedName === "default" && DEFAULT_EXPORT_DECLARATION_PATTERN.test(strippedSource)) return true;
+	for (const match of strippedSource.matchAll(NAMED_EXPORT_DECLARATION_PATTERN)) if (match[1] === exportedName) return true;
+	for (const match of strippedSource.matchAll(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN$1)) if (parseExportSpecifiers(match[1] ?? "", false).map((specifier) => specifier.exportedName).includes(exportedName)) return true;
+	return false;
 };
-const descend = (node, visit, visited = /* @__PURE__ */ new Set()) => {
-	if (visited.has(node)) return;
-	visit(node);
-	visited.add(node);
-	const keys = getChildKeys(node);
-	const record = node;
-	for (const key of keys) {
-		const child = record[key];
-		if (!child) continue;
-		if (Array.isArray(child)) {
-			for (const item of child) if (item && isAstNode(item)) descend(item, visit, visited);
-		} else if (isAstNode(child)) descend(child, visit, visited);
+const doesModuleExportName = (filePath, exportedName) => {
+	try {
+		return doesSourceTextExportName(fs.readFileSync(filePath, "utf8"), exportedName);
+	} catch {
+		return false;
 	}
 };
-const getUpstreamRefs = (analysis, ref) => {
-	const refs = [];
-	ascend(analysis, ref, (upRef) => {
-		refs.push(upRef);
+//#endregion
+//#region src/plugin/utils/is-barrel-index-module.ts
+const INDEX_MODULE_FILE_PATTERN = /^index\.(?:[cm]?[jt]sx?|mjs)$/;
+const BINDING_IMPORT_DECLARATION_PATTERN = /^\s*import\s+(type\s+)?(?!["'])([^;]*?)\s+from\s+["']([^"']+)["']\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
+const BARREL_REEXPORT_DECLARATION_PATTERN = /^\s*export\s+(type\s+)?(?:\*(?:\s+as\s+([\w$]+))?|\{([\s\S]*?)\})\s+from\s+["']([^"']+)["']\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
+const LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN = /^\s*export\s+(type\s+)?\{([\s\S]*?)\}\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
+const barrelIndexModuleInfoCache = /* @__PURE__ */ new Map();
+const isIndexModuleFilePath = (filePath) => INDEX_MODULE_FILE_PATTERN.test(path.basename(filePath));
+const createNonBarrelInfo = () => ({
+	isBarrel: false,
+	exportsByName: /* @__PURE__ */ new Map(),
+	starExportSources: []
+});
+const addImportedBinding = (importedBindings, binding) => {
+	importedBindings.set(binding.localName, {
+		...binding,
+		didExport: false
 	});
-	return refs;
 };
-const findDownstreamNodes = (topNode, type) => {
-	const nodes = [];
-	descend(topNode, (node) => {
-		if (node.type === type) nodes.push(node);
+const collectNamedImportBindings = (namedSpecifiersText, source, declarationIsTypeOnly, importedBindings) => {
+	for (const specifier of parseExportSpecifiers(namedSpecifiersText, declarationIsTypeOnly)) addImportedBinding(importedBindings, {
+		localName: specifier.exportedName,
+		importedName: specifier.localName,
+		source,
+		isTypeOnly: specifier.isTypeOnly
 	});
-	return nodes;
-};
-const getRef = (analysis, identifier) => {
-	const scope = getScopeForNode(identifier, analysis.scopeManager);
-	if (!scope) return null;
-	for (const reference of scope.references) if (reference.identifier === identifier) return reference;
-	return null;
-};
-const downstreamRefsCache = /* @__PURE__ */ new WeakMap();
-const getDownstreamRefs = (analysis, node) => {
-	let perNode = downstreamRefsCache.get(analysis);
-	if (!perNode) {
-		perNode = /* @__PURE__ */ new WeakMap();
-		downstreamRefsCache.set(analysis, perNode);
-	}
-	const cached = perNode.get(node);
-	if (cached) return cached;
-	const refs = [];
-	for (const identifier of findDownstreamNodes(node, "Identifier")) {
-		const ref = getRef(analysis, identifier);
-		if (ref) refs.push(ref);
-	}
-	perNode.set(node, refs);
-	return refs;
-};
-const getCallExpr = (ref, current = ref.identifier.parent) => {
-	if (!current) return null;
-	if (isNodeOfType(current, "CallExpression")) {
-		let node = ref.identifier;
-		let parent = node.parent;
-		while (parent && isNodeOfType(parent, "MemberExpression")) {
-			node = parent;
-			parent = node.parent;
-		}
-		if (current.callee === node) return current;
-	}
-	if (isNodeOfType(current, "MemberExpression")) return getCallExpr(ref, current.parent);
-	return null;
-};
-const getArgsUpstreamRefs = (analysis, ref) => {
-	const result = [];
-	for (const upRef of getUpstreamRefs(analysis, ref)) {
-		const callExpr = getCallExpr(upRef);
-		if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
-		for (const argument of callExpr.arguments ?? []) for (const argRef of getDownstreamRefs(analysis, argument)) for (const innerRef of getUpstreamRefs(analysis, argRef)) result.push(innerRef);
-	}
-	return result;
-};
-const isSynchronous = (node, within) => {
-	if (!node) return false;
-	if (node === within) return true;
-	if (node.async === true) return false;
-	if (isNodeOfType(node, "AwaitExpression") || isNodeOfType(node, "UnaryExpression") && node.operator === "void" || isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression")) return false;
-	return isSynchronous(node.parent, within);
 };
-const isEventualCallTo = (analysis, ref, predicate) => {
-	const callExprRefs = [];
-	ascend(analysis, ref, (upRef) => {
-		if (getCallExpr(upRef)) callExprRefs.push(upRef);
-		else return false;
+const collectImportBindings = (importClause, source, declarationIsTypeOnly, importedBindings) => {
+	const trimmedImportClause = importClause.trim();
+	const namespaceMatch = trimmedImportClause.match(/(?:^|,\s*)\*\s+as\s+([\w$]+)/);
+	if (namespaceMatch?.[1]) addImportedBinding(importedBindings, {
+		localName: namespaceMatch[1],
+		importedName: "*",
+		source,
+		isTypeOnly: declarationIsTypeOnly
+	});
+	const namedImportMatch = trimmedImportClause.match(/\{([\s\S]*?)\}/);
+	if (namedImportMatch?.[1]) collectNamedImportBindings(namedImportMatch[1], source, declarationIsTypeOnly, importedBindings);
+	const defaultImportName = trimmedImportClause.split(",")[0]?.trim();
+	if (defaultImportName && !defaultImportName.startsWith("{") && !defaultImportName.startsWith("*")) addImportedBinding(importedBindings, {
+		localName: defaultImportName,
+		importedName: "default",
+		source,
+		isTypeOnly: declarationIsTypeOnly
 	});
-	return callExprRefs.some(predicate);
 };
-//#endregion
-//#region src/plugin/rules/state-and-effects/utils/effect/react.ts
-const getOuterScopeContaining = (analysis, node) => {
-	if (!node.range) return null;
-	let best = null;
-	let bestSize = Infinity;
-	for (const scope of analysis.scopeManager.scopes) {
-		const block = scope.block;
-		if (!block?.range) continue;
-		if (node.range[0] < block.range[0] || node.range[1] > block.range[1]) continue;
-		const size = block.range[1] - block.range[0];
-		if (size <= bestSize) {
-			bestSize = size;
-			best = scope;
-		}
-	}
-	return best;
+const replaceKnownDeclarations = (sourceText, importedBindings, exportsByName, starExportSources) => {
+	let withoutKnownDeclarations = sourceText.replace(BINDING_IMPORT_DECLARATION_PATTERN, (_match, typeKeyword, importClause, source) => {
+		collectImportBindings(importClause, source, Boolean(typeKeyword), importedBindings);
+		return "";
+	});
+	withoutKnownDeclarations = withoutKnownDeclarations.replace(BARREL_REEXPORT_DECLARATION_PATTERN, (_match, typeKeyword, namespaceExportName, specifiersText, source) => {
+		const isTypeOnly = Boolean(typeKeyword);
+		if (namespaceExportName) {
+			exportsByName.set(namespaceExportName, {
+				exportedName: namespaceExportName,
+				importedName: "*",
+				source,
+				isTypeOnly
+			});
+			return "";
+		}
+		if (specifiersText) {
+			for (const specifier of parseExportSpecifiers(specifiersText, isTypeOnly)) exportsByName.set(specifier.exportedName, {
+				exportedName: specifier.exportedName,
+				importedName: specifier.localName,
+				source,
+				isTypeOnly: specifier.isTypeOnly
+			});
+			return "";
+		}
+		starExportSources.push(source);
+		return "";
+	});
+	withoutKnownDeclarations = withoutKnownDeclarations.replace(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN, (_match, typeKeyword, specifiersText) => {
+		for (const specifier of parseExportSpecifiers(specifiersText, Boolean(typeKeyword))) {
+			const importedBinding = importedBindings.get(specifier.localName);
+			if (!importedBinding) return _match;
+			importedBinding.didExport = true;
+			exportsByName.set(specifier.exportedName, {
+				exportedName: specifier.exportedName,
+				importedName: importedBinding.importedName,
+				source: importedBinding.source,
+				isTypeOnly: specifier.isTypeOnly || importedBinding.isTypeOnly
+			});
+		}
+		return "";
+	});
+	return withoutKnownDeclarations;
 };
-const KNOWN_PURE_HOC_NAMES = new Set(["memo", "forwardRef"]);
-const startsWithUppercase = (name) => Boolean(name && name.length > 0 && name[0] >= "A" && name[0] <= "Z");
-const isReactFunctionalComponent = (node) => {
-	if (!node) return false;
-	if (isNodeOfType(node, "FunctionDeclaration")) return Boolean(node.id && startsWithUppercase(node.id.name));
-	if (isNodeOfType(node, "VariableDeclarator")) {
-		if (!isNodeOfType(node.id, "Identifier")) return false;
-		if (!startsWithUppercase(node.id.name)) return false;
-		const init = node.init;
-		if (!init) return false;
-		return isNodeOfType(init, "ArrowFunctionExpression") || isNodeOfType(init, "CallExpression");
-	}
+const hasUnexportedRuntimeImport = (importedBindings) => {
+	for (const binding of importedBindings.values()) if (!binding.isTypeOnly && !binding.didExport) return true;
 	return false;
 };
-const isReactFunctionalHOC = (analysis, node) => {
-	if (!isReactFunctionalComponent(node)) return false;
-	if (!isNodeOfType(node, "VariableDeclarator")) return false;
-	const init = node.init;
-	if (!init) return false;
-	const isWrappedInline = () => {
-		if (!isNodeOfType(init, "CallExpression")) return false;
-		if (!isNodeOfType(init.callee, "Identifier")) return false;
-		if (KNOWN_PURE_HOC_NAMES.has(init.callee.name)) return false;
-		const firstArg = init.arguments?.[0];
-		if (!firstArg) return false;
-		return isNodeOfType(firstArg, "ArrowFunctionExpression") || isNodeOfType(firstArg, "FunctionExpression");
-	};
-	const isWrappedSeparately = () => {
-		if (!isNodeOfType(node.id, "Identifier")) return false;
-		const bindingName = node.id.name;
-		const containingScope = getOuterScopeContaining(analysis, node);
-		if (!containingScope) return false;
-		const variable = containingScope.variables.find((v) => v.name === bindingName);
-		if (!variable) return false;
-		for (const reference of variable.references) {
-			const parent = reference.identifier.parent;
-			if (!parent || !isNodeOfType(parent, "CallExpression")) continue;
-			const args = parent.arguments ?? [];
-			const refId = reference.identifier;
-			if (!args.includes(refId)) continue;
-			const callee = parent.callee;
-			const calleeName = isNodeOfType(callee, "Identifier") ? callee.name : isNodeOfType(callee, "CallExpression") && isNodeOfType(callee.callee, "Identifier") ? callee.callee.name : null;
-			if (calleeName != null && !KNOWN_PURE_HOC_NAMES.has(calleeName)) return true;
-		}
-		return false;
+const classifyBarrelModule = (sourceText) => {
+	const strippedSource = stripJsComments(sourceText).trim();
+	if (!strippedSource) return createNonBarrelInfo();
+	const importedBindings = /* @__PURE__ */ new Map();
+	const exportsByName = /* @__PURE__ */ new Map();
+	const starExportSources = [];
+	if (replaceKnownDeclarations(strippedSource, importedBindings, exportsByName, starExportSources).trim() || hasUnexportedRuntimeImport(importedBindings)) return createNonBarrelInfo();
+	return {
+		isBarrel: exportsByName.size > 0 || starExportSources.length > 0,
+		exportsByName,
+		starExportSources
 	};
-	return isWrappedInline() || isWrappedSeparately();
 };
-const isCustomHook = (node) => {
-	if (!node) return false;
-	if (isNodeOfType(node, "FunctionDeclaration")) {
-		const name = node.id?.name;
-		if (!name) return false;
-		return name.startsWith("use") && name.length > 3 && name[3] >= "A" && name[3] <= "Z";
+const getBarrelIndexModuleInfo = (filePath) => {
+	if (!isIndexModuleFilePath(filePath)) return createNonBarrelInfo();
+	const cachedResult = barrelIndexModuleInfoCache.get(filePath);
+	if (cachedResult !== void 0) return cachedResult;
+	let moduleInfo = createNonBarrelInfo();
+	try {
+		moduleInfo = classifyBarrelModule(fs.readFileSync(filePath, "utf8"));
+	} catch {
+		moduleInfo = createNonBarrelInfo();
 	}
-	if (isNodeOfType(node, "VariableDeclarator")) {
-		if (!isNodeOfType(node.id, "Identifier")) return false;
-		const name = node.id.name;
-		const init = node.init;
-		if (!init) return false;
-		if (!isNodeOfType(init, "ArrowFunctionExpression") && !isNodeOfType(init, "FunctionExpression")) return false;
-		return name.startsWith("use") && name.length > 3 && name[3] >= "A" && name[3] <= "Z";
+	barrelIndexModuleInfoCache.set(filePath, moduleInfo);
+	return moduleInfo;
+};
+const isBarrelIndexModule = (filePath) => getBarrelIndexModuleInfo(filePath).isBarrel;
+//#endregion
+//#region src/plugin/utils/resolve-relative-import-path.ts
+const MODULE_FILE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".mts",
+	".cts"
+];
+const PACKAGE_EXPORT_CONDITIONS = [
+	"import",
+	"default",
+	"module",
+	"browser",
+	"require"
+];
+const PACKAGE_ENTRY_FIELDS = [
+	"module",
+	"main",
+	"browser"
+];
+const getExistingFilePath = (filePath) => {
+	try {
+		return fs.statSync(filePath).isFile() ? filePath : null;
+	} catch {
+		return null;
 	}
-	return false;
 };
-const isReactNamedImportReference = (ref, importedName) => Boolean(ref?.resolved?.defs.some((def) => {
-	if (def.type !== "ImportBinding") return false;
-	const declarationNode = def.node;
-	if (!isNodeOfType(declarationNode, "ImportSpecifier")) return false;
-	const imported = declarationNode.imported;
-	if (!isNodeOfType(imported, "Identifier")) return false;
-	if (imported.name !== importedName) return false;
-	const importDeclaration = declarationNode.parent;
-	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && isNodeOfType(importDeclaration.source, "Literal") && importDeclaration.source.value === "react");
-}));
-const isHookCallee = (analysis, node, hookName) => {
-	if (!node) return false;
-	if (isNodeOfType(node, "Identifier")) {
-		if (node.name === hookName) return true;
-		if (isReactNamedImportReference(getRef(analysis, node), hookName)) return true;
-		const parent = node.parent;
-		if (parent && isNodeOfType(parent, "MemberExpression") && isNodeOfType(parent.object, "Identifier") && parent.object.name === "React" && isNodeOfType(parent.property, "Identifier") && parent.property.name === hookName) return true;
-		return false;
+const getExistingDirectoryPath = (directoryPath) => {
+	try {
+		return fs.statSync(directoryPath).isDirectory() ? directoryPath : null;
+	} catch {
+		return null;
 	}
-	if (isNodeOfType(node, "MemberExpression")) return isNodeOfType(node.object, "Identifier") && node.object.name === "React" && isNodeOfType(node.property, "Identifier") && node.property.name === hookName;
-	return false;
 };
-const isUseEffect = (node) => {
-	if (!node || !isNodeOfType(node, "CallExpression")) return false;
-	const callee = node.callee;
-	if (isNodeOfType(callee, "Identifier") && callee.name === "useEffect") return true;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && callee.object.name === "React" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "useEffect") return true;
-	return false;
+const getModuleFilePathCandidates = (modulePath) => {
+	const extension = path.extname(modulePath);
+	if (!extension) return MODULE_FILE_EXTENSIONS.map((moduleExtension) => `${modulePath}${moduleExtension}`);
+	const modulePathWithoutExtension = modulePath.slice(0, -extension.length);
+	if (extension === ".js") return [
+		modulePath,
+		`${modulePathWithoutExtension}.ts`,
+		`${modulePathWithoutExtension}.tsx`,
+		`${modulePathWithoutExtension}.jsx`
+	];
+	if (extension === ".jsx") return [modulePath, `${modulePathWithoutExtension}.tsx`];
+	if (extension === ".mjs") return [modulePath, `${modulePathWithoutExtension}.mts`];
+	if (extension === ".cjs") return [modulePath, `${modulePathWithoutExtension}.cts`];
+	return [modulePath];
 };
-const getEffectFn = (analysis, node) => {
-	if (!isNodeOfType(node, "CallExpression")) return null;
-	const fn = node.arguments?.[0];
-	if (!fn) return null;
-	if (isNodeOfType(fn, "ArrowFunctionExpression") || isNodeOfType(fn, "FunctionExpression")) return fn;
-	if (isNodeOfType(fn, "Identifier")) {
-		const definitionNode = getRef(analysis, fn)?.resolved?.defs[0]?.node;
-		if (definitionNode && isFunctionLike$2(definitionNode)) return definitionNode;
-		if (definitionNode && isNodeOfType(definitionNode, "VariableDeclarator")) {
-			const initializer = definitionNode.init;
-			if (isNodeOfType(initializer, "ArrowFunctionExpression") || isNodeOfType(initializer, "FunctionExpression")) return initializer;
+const isObjectRecord$1 = (value) => typeof value === "object" && value !== null;
+const getConditionalExportEntry = (exportEntry) => {
+	if (typeof exportEntry === "string") return exportEntry;
+	if (Array.isArray(exportEntry)) {
+		for (const fallbackEntry of exportEntry) {
+			const resolvedFallbackEntry = getConditionalExportEntry(fallbackEntry);
+			if (resolvedFallbackEntry) return resolvedFallbackEntry;
 		}
+		return null;
+	}
+	if (!isObjectRecord$1(exportEntry)) return null;
+	for (const condition of PACKAGE_EXPORT_CONDITIONS) {
+		const nestedEntry = getConditionalExportEntry(exportEntry[condition]);
+		if (nestedEntry) return nestedEntry;
 	}
 	return null;
 };
-const getEffectFnRefs = (analysis, node) => {
-	const fn = getEffectFn(analysis, node);
-	if (!fn) return null;
-	return getDownstreamRefs(analysis, fn);
+const getPackageExportEntry = (packageJson) => {
+	const exportsField = packageJson.exports;
+	if (!exportsField) return null;
+	const directExportEntry = getConditionalExportEntry(exportsField);
+	if (directExportEntry) return directExportEntry;
+	if (!isObjectRecord$1(exportsField)) return null;
+	return getConditionalExportEntry(exportsField["."]);
 };
-const getEffectDepsRefs = (analysis, node) => {
-	if (!isNodeOfType(node, "CallExpression")) return null;
-	const deps = node.arguments?.[1];
-	if (!deps || !isNodeOfType(deps, "ArrayExpression")) return null;
-	return getDownstreamRefs(analysis, deps);
+const resolveModulePathWithIndexFallback = (modulePath) => {
+	const filePath = resolveModuleFilePath(modulePath);
+	if (filePath) return filePath;
+	return resolveModuleFilePath(path.join(modulePath, "index"));
 };
-const isState = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
-	const node = def.node;
-	if (!isNodeOfType(node, "VariableDeclarator")) return false;
-	if (!isNodeOfType(node.init, "CallExpression")) return false;
-	if (!isHookCallee(analysis, node.init.callee, "useState")) return false;
-	if (!isNodeOfType(node.id, "ArrayPattern")) return false;
-	const elements = node.id.elements ?? [];
-	if (elements.length !== 1 && elements.length !== 2) return false;
-	const first = elements[0];
-	return Boolean(first && isNodeOfType(first, "Identifier") && first.name === ref.identifier.name);
-}));
-const isStateSetter = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
-	const node = def.node;
-	if (!isNodeOfType(node, "VariableDeclarator")) return false;
-	if (!isNodeOfType(node.init, "CallExpression")) return false;
-	if (!isHookCallee(analysis, node.init.callee, "useState")) return false;
-	if (!isNodeOfType(node.id, "ArrayPattern")) return false;
-	const elements = node.id.elements ?? [];
-	if (elements.length !== 2) return false;
-	const second = elements[1];
-	return Boolean(second && isNodeOfType(second, "Identifier") && second.name === ref.identifier.name);
-}));
-const isProp = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
-	if (def.type !== "Parameter") return false;
-	const defNode = def.node;
-	let declaringNode = defNode;
-	if (isNodeOfType(defNode, "ArrowFunctionExpression")) {
-		const parent = defNode.parent;
-		if (parent && isNodeOfType(parent, "CallExpression")) declaringNode = parent.parent;
-		else declaringNode = parent;
+const resolvePackageDirectoryEntry = (directoryPath) => {
+	const existingDirectoryPath = getExistingDirectoryPath(directoryPath);
+	if (!existingDirectoryPath) return null;
+	const packageJsonPath = path.join(existingDirectoryPath, "package.json");
+	try {
+		const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+		const packageEntry = getPackageExportEntry(packageJson) ?? PACKAGE_ENTRY_FIELDS.map((fieldName) => packageJson[fieldName]).find((value) => typeof value === "string");
+		if (!packageEntry) return null;
+		return resolveModulePathWithIndexFallback(path.resolve(existingDirectoryPath, packageEntry));
+	} catch {
+		return null;
 	}
-	if (!declaringNode) return false;
-	return isReactFunctionalComponent(declaringNode) && !isReactFunctionalHOC(analysis, declaringNode) || isCustomHook(declaringNode);
-}));
-const isIdentifierOrMemberExpression = (node) => isNodeOfType(node, "Identifier") || isNodeOfType(node, "MemberExpression");
-const isPropAlias = (analysis, ref) => {
-	if (isProp(analysis, ref)) return true;
-	return Boolean(ref.resolved?.defs.some((def) => {
-		const node = def.node;
-		if (!isNodeOfType(node, "VariableDeclarator")) return false;
-		const initializer = node.init;
-		if (!initializer) return false;
-		if (!isNodeOfType(node.id, "ObjectPattern") && !isIdentifierOrMemberExpression(initializer)) return false;
-		return getDownstreamRefs(analysis, initializer).some((initializerRef) => getUpstreamRefs(analysis, initializerRef).some((upstreamRef) => isProp(analysis, upstreamRef)));
-	}));
 };
-const isConstant = (ref) => Boolean((ref.resolved?.defs ?? []).some((def) => {
-	const node = def.node;
-	if (!isNodeOfType(node, "VariableDeclarator")) return false;
-	const init = node.init;
-	if (!init) return false;
-	return isNodeOfType(init, "Literal") || isNodeOfType(init, "TemplateLiteral") || isNodeOfType(init, "ArrayExpression") || isNodeOfType(init, "ObjectExpression");
-}));
-const isRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
-	const node = def.node;
-	if (!isNodeOfType(node, "VariableDeclarator")) return false;
-	if (!isNodeOfType(node.init, "CallExpression")) return false;
-	return isHookCallee(analysis, node.init.callee, "useRef");
-}));
-const isRefCurrent = (ref) => {
-	const parent = ref.identifier.parent;
-	if (!parent || !isNodeOfType(parent, "MemberExpression")) return false;
-	if (!isNodeOfType(parent.property, "Identifier")) return false;
-	return parent.property.name === "current";
+const resolveModuleFilePath = (modulePath) => {
+	const exactFilePath = getExistingFilePath(modulePath);
+	if (exactFilePath) return exactFilePath;
+	for (const candidateFilePath of getModuleFilePathCandidates(modulePath)) {
+		const filePath = getExistingFilePath(candidateFilePath);
+		if (filePath) return filePath;
+	}
+	return null;
 };
-const isStateSetterCall = (analysis, ref) => isEventualCallTo(analysis, ref, (innerRef) => isStateSetter(analysis, innerRef));
-const isPropCall = (analysis, ref) => isEventualCallTo(analysis, ref, (innerRef) => isPropAlias(analysis, innerRef));
-const isRefCall = (analysis, ref) => isEventualCallTo(analysis, ref, (innerRef) => isRefCurrent(innerRef) || isRef(analysis, innerRef));
-const getUseStateDecl = (analysis, ref) => {
-	let node = getUpstreamRefs(analysis, ref).find((upRef) => isHookCallee(analysis, upRef.identifier, "useState"))?.identifier;
-	while (node && !isNodeOfType(node, "VariableDeclarator")) node = node.parent;
-	return node ?? null;
+const resolveModuleFileFromAbsolutePath = (importPath) => {
+	const directFilePath = resolveModuleFilePath(importPath);
+	if (directFilePath) return directFilePath;
+	const packageEntryFilePath = resolvePackageDirectoryEntry(importPath);
+	if (packageEntryFilePath) return packageEntryFilePath;
+	return resolveModuleFilePath(path.join(importPath, "index"));
 };
-const isCleanupReturnArgument = (analysis, node) => {
-	if (isFunctionLike$2(node)) return true;
-	if (isNodeOfType(node, "MemberExpression")) return true;
-	if (isNodeOfType(node, "Identifier")) {
-		const definitionNode = getRef(analysis, node)?.resolved?.defs[0]?.node;
-		if (definitionNode && isFunctionLike$2(definitionNode)) return true;
-		if (definitionNode && isNodeOfType(definitionNode, "VariableDeclarator")) {
-			const initializer = definitionNode.init;
-			return isFunctionLike$2(initializer);
+const resolveRelativeImportPath = (filename, source) => resolveModuleFileFromAbsolutePath(path.resolve(path.dirname(filename), source));
+//#endregion
+//#region src/plugin/utils/resolve-barrel-export-file-path.ts
+const getUniqueFilePath = (filePaths) => {
+	const uniqueFilePaths = new Set(filePaths);
+	if (uniqueFilePaths.size !== 1) return null;
+	const [filePath] = uniqueFilePaths;
+	return filePath ?? null;
+};
+const resolveStarExportFilePath = (barrelFilePath, exportedName, source, visitedFilePaths) => {
+	const resolvedTargetPath = resolveRelativeImportPath(barrelFilePath, source);
+	if (!resolvedTargetPath) return null;
+	const nestedTargetPath = resolveBarrelExportFilePath(resolvedTargetPath, exportedName, new Set(visitedFilePaths));
+	if (nestedTargetPath) return nestedTargetPath;
+	return doesModuleExportName(resolvedTargetPath, exportedName) ? resolvedTargetPath : null;
+};
+const resolveBarrelExportFilePath = (barrelFilePath, exportedName, visitedFilePaths = /* @__PURE__ */ new Set()) => {
+	if (visitedFilePaths.has(barrelFilePath)) return null;
+	visitedFilePaths.add(barrelFilePath);
+	const moduleInfo = getBarrelIndexModuleInfo(barrelFilePath);
+	if (!moduleInfo.isBarrel) return null;
+	const target = moduleInfo.exportsByName.get(exportedName);
+	if (target) {
+		const resolvedTargetPath = resolveRelativeImportPath(barrelFilePath, target.source);
+		if (!resolvedTargetPath) return null;
+		return resolveBarrelExportFilePath(resolvedTargetPath, target.importedName, visitedFilePaths) ?? resolvedTargetPath;
+	}
+	if (exportedName === "default") return null;
+	return getUniqueFilePath(moduleInfo.starExportSources.map((source) => resolveStarExportFilePath(barrelFilePath, exportedName, source, visitedFilePaths)).filter((filePath) => Boolean(filePath)));
+};
+//#endregion
+//#region src/plugin/utils/resolve-tsconfig-alias.ts
+const TSCONFIG_FILE_NAMES = ["tsconfig.json", "jsconfig.json"];
+const isObjectRecord = (value) => typeof value === "object" && value !== null;
+const stripJsonComments = (text) => {
+	let output = "";
+	let inString = false;
+	let inLineComment = false;
+	let inBlockComment = false;
+	for (let index = 0; index < text.length; index++) {
+		const character = text[index];
+		const nextCharacter = text[index + 1];
+		if (inLineComment) {
+			if (character === "\n") {
+				inLineComment = false;
+				output += character;
+			}
+			continue;
+		}
+		if (inBlockComment) {
+			if (character === "*" && nextCharacter === "/") {
+				inBlockComment = false;
+				index++;
+			}
+			continue;
+		}
+		if (inString) {
+			output += character;
+			if (character === "\\") {
+				output += nextCharacter ?? "";
+				index++;
+			} else if (character === "\"") inString = false;
+			continue;
+		}
+		if (character === "\"") {
+			inString = true;
+			output += character;
+			continue;
 		}
+		if (character === "/" && nextCharacter === "/") {
+			inLineComment = true;
+			index++;
+			continue;
+		}
+		if (character === "/" && nextCharacter === "*") {
+			inBlockComment = true;
+			index++;
+			continue;
+		}
+		output += character;
 	}
-	if (isNodeOfType(node, "ConditionalExpression")) return isCleanupReturnArgument(analysis, node.consequent) || isCleanupReturnArgument(analysis, node.alternate);
-	return false;
+	return output.replace(/,(\s*[}\]])/g, "$1");
 };
-const hasCleanupReturn = (analysis, node, visited = /* @__PURE__ */ new WeakSet()) => {
-	if (visited.has(node)) return false;
-	visited.add(node);
-	if (isNodeOfType(node, "ReturnStatement") && node.argument != null) return isCleanupReturnArgument(analysis, node.argument);
-	if (!isNodeOfType(node, "BlockStatement") && isFunctionLike$2(node)) return false;
-	const record = node;
-	for (const [key, value] of Object.entries(record)) {
-		if (key === "parent") continue;
-		if (Array.isArray(value)) {
-			if (value.some((item) => isAstNode(item) && hasCleanupReturn(analysis, item, visited))) return true;
-		} else if (isAstNode(value) && hasCleanupReturn(analysis, value, visited)) return true;
+const parseTsconfigFile = (configFilePath) => {
+	let sourceText;
+	try {
+		sourceText = fs.readFileSync(configFilePath, "utf8");
+	} catch {
+		return null;
+	}
+	try {
+		const parsed = JSON.parse(stripJsonComments(sourceText));
+		return isObjectRecord(parsed) ? parsed : null;
+	} catch {
+		return null;
 	}
-	return false;
 };
-const hasCleanup = (analysis, node) => {
-	const fn = getEffectFn(analysis, node);
-	if (!isFunctionLike$2(fn)) return false;
-	if (!isNodeOfType(fn.body, "BlockStatement")) return false;
-	return hasCleanupReturn(analysis, fn.body);
+const resolveExtendsPath = (extendsValue, fromConfigDirectory) => {
+	const withExtension = extendsValue.endsWith(".json") ? extendsValue : `${extendsValue}.json`;
+	if (extendsValue.startsWith("./") || extendsValue.startsWith("../")) return path.resolve(fromConfigDirectory, withExtension);
+	return path.join(fromConfigDirectory, "node_modules", withExtension);
+};
+const parsePathsField = (pathsField) => {
+	const paths = /* @__PURE__ */ new Map();
+	if (!isObjectRecord(pathsField)) return paths;
+	for (const [pattern, targets] of Object.entries(pathsField)) {
+		if (!Array.isArray(targets)) continue;
+		const stringTargets = targets.filter((target) => typeof target === "string");
+		if (stringTargets.length > 0) paths.set(pattern, stringTargets);
+	}
+	return paths;
+};
+const readResolvedTsconfig = (configFilePath, extendsDepth) => {
+	const parsed = parseTsconfigFile(configFilePath);
+	if (!parsed) return null;
+	const configDirectory = path.dirname(configFilePath);
+	const compilerOptions = isObjectRecord(parsed.compilerOptions) ? parsed.compilerOptions : {};
+	const baseUrlValue = typeof compilerOptions.baseUrl === "string" ? compilerOptions.baseUrl : null;
+	const hasExplicitBaseUrl = baseUrlValue !== null;
+	const baseAbsolutePath = baseUrlValue !== null ? path.resolve(configDirectory, baseUrlValue) : configDirectory;
+	if (isObjectRecord(compilerOptions.paths)) return {
+		baseAbsolutePath,
+		hasExplicitBaseUrl,
+		paths: parsePathsField(compilerOptions.paths)
+	};
+	if (typeof parsed.extends === "string" && extendsDepth < 8) {
+		const parentPath = resolveExtendsPath(parsed.extends, configDirectory);
+		const inherited = parentPath ? readResolvedTsconfig(parentPath, extendsDepth + 1) : null;
+		if (inherited) return inherited;
+	}
+	return hasExplicitBaseUrl ? {
+		baseAbsolutePath,
+		hasExplicitBaseUrl,
+		paths: /* @__PURE__ */ new Map()
+	} : null;
+};
+const configByFilePath = /* @__PURE__ */ new Map();
+const loadTsconfigCached = (configFilePath) => {
+	let fileStat;
+	try {
+		fileStat = fs.statSync(configFilePath);
+	} catch {
+		return null;
+	}
+	const cached = configByFilePath.get(configFilePath);
+	if (cached && cached.mtimeMs === fileStat.mtimeMs) return cached.config;
+	const config = readResolvedTsconfig(configFilePath, 0);
+	configByFilePath.set(configFilePath, {
+		mtimeMs: fileStat.mtimeMs,
+		config
+	});
+	return config;
 };
-const findContainingNode = (analysis, node) => {
-	if (!node) return null;
-	if (isReactFunctionalComponent(node) || isReactFunctionalHOC(analysis, node) || isCustomHook(node)) return node;
-	const parent = node.parent;
-	return findContainingNode(analysis, parent);
+const findNearestTsconfig = (fromDirectory) => {
+	let currentDirectory = fromDirectory;
+	for (let level = 0; level < 30; level++) {
+		for (const fileName of TSCONFIG_FILE_NAMES) {
+			const candidate = loadTsconfigCached(path.join(currentDirectory, fileName));
+			if (candidate) return candidate;
+		}
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) break;
+		currentDirectory = parentDirectory;
+	}
+	return null;
+};
+const matchPathPattern = (source, pattern) => {
+	const starIndex = pattern.indexOf("*");
+	if (starIndex === -1) return source === pattern ? "" : null;
+	const prefix = pattern.slice(0, starIndex);
+	const suffix = pattern.slice(starIndex + 1);
+	if (source.length >= prefix.length + suffix.length && source.startsWith(prefix) && source.endsWith(suffix)) return source.slice(prefix.length, source.length - suffix.length);
+	return null;
+};
+const resolveTsconfigAliasPath = (fromFilename, source) => {
+	const config = findNearestTsconfig(path.dirname(fromFilename));
+	if (!config) return null;
+	let bestPattern = null;
+	let bestCapture = "";
+	let bestPrefixLength = -1;
+	for (const pattern of config.paths.keys()) {
+		const capture = matchPathPattern(source, pattern);
+		if (capture === null) continue;
+		const starIndex = pattern.indexOf("*");
+		const prefixLength = starIndex === -1 ? pattern.length : starIndex;
+		if (prefixLength > bestPrefixLength) {
+			bestPattern = pattern;
+			bestCapture = capture;
+			bestPrefixLength = prefixLength;
+		}
+	}
+	if (bestPattern) for (const target of config.paths.get(bestPattern) ?? []) {
+		const substituted = target.replaceAll("*", bestCapture);
+		const resolved = resolveModuleFileFromAbsolutePath(path.resolve(config.baseAbsolutePath, substituted));
+		if (resolved) return resolved;
+	}
+	if (config.hasExplicitBaseUrl) return resolveModuleFileFromAbsolutePath(path.resolve(config.baseAbsolutePath, source));
+	return null;
 };
 //#endregion
-//#region src/plugin/rules/state-and-effects/no-adjust-state-on-prop-change.ts
-const noAdjustStateOnPropChange = defineRule({
-	id: "no-adjust-state-on-prop-change",
-	title: "State synced to a prop inside an effect",
-	severity: "error",
-	tags: ["test-noise"],
-	recommendation: "Adjust the state inline during render with a `prev`-prop comparison (`if (prop !== prevProp) { setPrevProp(prop); setX(...); }`), or refactor to remove the duplicated state. Routing the adjustment through a useEffect forces an extra render with a stale UI between the two commits. See https://react.dev/learn/you-might-not-need-an-effect#adjusting-some-state-when-a-prop-changes",
-	create: (context) => ({ CallExpression(node) {
-		if (!isUseEffect(node)) return;
-		const analysis = getProgramAnalysis(node);
-		if (!analysis) return;
-		const effectFnRefs = getEffectFnRefs(analysis, node);
-		const depsRefs = getEffectDepsRefs(analysis, node);
-		if (!effectFnRefs || !depsRefs) return;
-		const effectFn = getEffectFn(analysis, node);
-		if (!effectFn) return;
-		if (!depsRefs.flatMap((ref) => getUpstreamRefs(analysis, ref)).some((ref) => isProp(analysis, ref))) return;
-		for (const ref of effectFnRefs) {
-			if (!isStateSetterCall(analysis, ref)) continue;
-			if (!isSynchronous(ref.identifier, effectFn)) continue;
-			const callExpr = getCallExpr(ref);
-			if (!callExpr) continue;
-			if (getArgsUpstreamRefs(analysis, ref).some((argRef) => isProp(analysis, argRef))) continue;
-			context.report({
-				node: callExpr,
-				message: "Your users briefly see the wrong value when the prop changes."
-			});
-		}
-	} })
-});
+//#region src/plugin/utils/resolve-module-path.ts
+const resolveModulePath = (fromFilename, source) => resolveRelativeImportPath(fromFilename, source) ?? resolveTsconfigAliasPath(fromFilename, source);
 //#endregion
-//#region src/plugin/rules/a11y/no-aria-hidden-on-focusable.ts
-const MESSAGE$30 = "Screen reader users tab to this focusable element but hear nothing because `aria-hidden` skips it, so remove `aria-hidden` or stop it being focusable.";
-const noAriaHiddenOnFocusable = defineRule({
-	id: "no-aria-hidden-on-focusable",
-	title: "aria-hidden on focusable element",
-	tags: ["react-jsx-only"],
-	severity: "warn",
-	recommendation: "Remove `aria-hidden` from focusable elements, or stop them being focusable.",
-	category: "Accessibility",
-	create: (context) => ({ JSXOpeningElement(node) {
-		const ariaHidden = hasJsxPropIgnoreCase(node.attributes, "aria-hidden");
-		if (!ariaHidden) return;
-		const value = ariaHidden.value;
-		if (value) {
-			if (isNodeOfType(value, "Literal") && value.value !== "true") return;
-			if (isNodeOfType(value, "JSXExpressionContainer")) {
-				const expression = value.expression;
-				if (isNodeOfType(expression, "Literal") && !expression.value) return;
-			}
+//#region src/plugin/utils/resolve-cross-file-function-export.ts
+const resolveFunctionExportInFile = (filePath, exportedName, visitedFilePaths) => {
+	if (visitedFilePaths.size >= 4) return null;
+	if (visitedFilePaths.has(filePath)) return null;
+	visitedFilePaths.add(filePath);
+	const actualFilePath = resolveBarrelExportFilePath(filePath, exportedName) ?? filePath;
+	const programRoot = parseSourceFile(actualFilePath);
+	if (!programRoot) return null;
+	const exported = findExportedFunctionBody(programRoot, exportedName);
+	if (exported) return exported;
+	for (const reExportSource of findReExportSourcesForName(programRoot, exportedName)) {
+		const nextFilePath = resolveModulePath(actualFilePath, reExportSource);
+		if (!nextFilePath) continue;
+		const resolved = resolveFunctionExportInFile(nextFilePath, exportedName, visitedFilePaths);
+		if (resolved) return resolved;
+	}
+	return null;
+};
+const resolveCrossFileFunctionExport = (fromFilename, source, exportedName) => {
+	const resolvedFilePath = resolveModulePath(fromFilename, source);
+	if (!resolvedFilePath) return null;
+	return resolveFunctionExportInFile(resolvedFilePath, exportedName, /* @__PURE__ */ new Set());
+};
+//#endregion
+//#region src/plugin/utils/ast-mentions-suspense.ts
+const isSuspenseJsxOpeningName = (name) => {
+	if (isNodeOfType(name, "JSXIdentifier")) return name.name === "Suspense";
+	return isNodeOfType(name, "JSXMemberExpression") && isNodeOfType(name.property, "JSXIdentifier") && name.property.name === "Suspense";
+};
+const astMentionsSuspense = (programNode) => {
+	let didDetect = false;
+	walkAst(programNode, (child) => {
+		if (didDetect) return false;
+		if (isNodeOfType(child, "JSXOpeningElement") && isSuspenseJsxOpeningName(child.name)) {
+			didDetect = true;
+			return false;
 		}
-		const tag = getElementType(node, context.settings);
-		const tabIndex = hasJsxPropIgnoreCase(node.attributes, "tabIndex");
-		const tabIndexValue = tabIndex ? parseJsxValue(tabIndex.value ?? null) : null;
-		if (tabIndexValue !== null && tabIndexValue < 0) return;
-		const isExplicitlyFocusable = tabIndexValue !== null && tabIndexValue >= 0;
-		const isImplicitlyFocusable = isInteractiveElement(tag, node);
-		if (isExplicitlyFocusable || isImplicitlyFocusable) context.report({
-			node: ariaHidden,
-			message: MESSAGE$30
-		});
-	} })
-});
-//#endregion
-//#region src/plugin/utils/is-all-literal-array-expression.ts
-/**
-* True when the node is an `ArrayExpression` whose elements are all
-* primitive literals (string / number / boolean). Used by the two
-* "no array-index key" rule variants to detect a `keys={[1, 2, 3]}`
-* style stable-id array.
-*/
-const isAllLiteralArrayExpression = (node) => {
-	if (!isNodeOfType(node, "ArrayExpression")) return false;
-	const elements = node.elements ?? [];
-	if (elements.length < 1) return false;
-	for (const element of elements) {
-		if (!element) return false;
-		if (!isNodeOfType(element, "Literal")) return false;
-		const value = element.value;
-		if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") return false;
-	}
-	return true;
-};
-//#endregion
-//#region src/plugin/utils/jsx-stateless-leaf.ts
-const PURE_SVG_PRIMITIVE_TAGS = new Set([
-	"circle",
-	"ellipse",
-	"g",
-	"line",
-	"path",
-	"polygon",
-	"polyline",
-	"rect",
-	"stop",
-	"text",
-	"tspan",
-	"defs",
-	"use",
-	"mask",
-	"marker",
-	"linearGradient",
-	"radialGradient",
-	"clipPath",
-	"filter",
-	"feGaussianBlur",
-	"feOffset",
-	"feMerge",
-	"feMergeNode",
-	"feColorMatrix",
-	"feFlood",
-	"feComposite",
-	"title",
-	"desc"
-]);
-const STATELESS_HTML_LEAF_TAGS = new Set([
-	"div",
-	"span",
-	"p",
-	"h1",
-	"h2",
-	"h3",
-	"h4",
-	"h5",
-	"h6",
-	"header",
-	"footer",
-	"section",
-	"article",
-	"aside",
-	"main",
-	"nav",
-	"li",
-	"ul",
-	"ol",
-	"dl",
-	"dt",
-	"dd",
-	"tr",
-	"td",
-	"th",
-	"tbody",
-	"thead",
-	"tfoot",
-	"table",
-	"caption",
-	"colgroup",
-	"col",
-	"strong",
-	"em",
-	"small",
-	"b",
-	"i",
-	"u",
-	"s",
-	"mark",
-	"del",
-	"ins",
-	"sub",
-	"sup",
-	"abbr",
-	"cite",
-	"code",
-	"kbd",
-	"samp",
-	"pre",
-	"blockquote",
-	"q",
-	"br",
-	"hr",
-	"wbr",
-	"img",
-	"picture",
-	"figure",
-	"figcaption",
-	"label",
-	"legend",
-	"fieldset",
-	"address",
-	"time",
-	"data",
-	"var",
-	"ruby",
-	"rt",
-	"rp",
-	"bdi",
-	"bdo"
-]);
-const STATEFUL_HTML_DESCENDANT_TAGS = new Set([
-	"input",
-	"textarea",
-	"select",
-	"option",
-	"optgroup",
-	"button",
-	"form",
-	"output",
-	"progress",
-	"meter",
-	"video",
-	"audio",
-	"source",
-	"track",
-	"iframe",
-	"embed",
-	"object",
-	"a",
-	"details",
-	"summary",
-	"dialog",
-	"canvas"
-]);
-const STATEFUL_DESCENDANT_SCAN_BUDGET = 200;
-const containsStatefulDescendant = (jsxElement) => {
-	let budget = STATEFUL_DESCENDANT_SCAN_BUDGET;
-	const stack = [jsxElement];
-	while (stack.length > 0) {
-		if (budget <= 0) return true;
-		budget -= 1;
-		const node = stack.pop();
-		if (isNodeOfType(node, "JSXElement")) {
-			const name = node.openingElement.name;
-			if (name && isNodeOfType(name, "JSXIdentifier")) {
-				const tagName = name.name;
-				const firstChar = tagName.charCodeAt(0);
-				if (firstChar >= 65 && firstChar <= 90) return true;
-				if (STATEFUL_HTML_DESCENDANT_TAGS.has(tagName)) return true;
+		if (isNodeOfType(child, "ImportDeclaration") && child.source?.value === "react") {
+			if ((child.specifiers ?? []).some((specifier) => isNodeOfType(specifier, "ImportSpecifier") && getImportedName$1(specifier) === "Suspense")) {
+				didDetect = true;
+				return false;
 			}
-			if (name && isNodeOfType(name, "JSXMemberExpression")) return true;
-			const children = node.children ?? [];
-			for (const child of children) stack.push(child);
-			continue;
-		}
-		if (isNodeOfType(node, "JSXFragment")) {
-			const children = node.children ?? [];
-			for (const child of children) stack.push(child);
-			continue;
-		}
-		if (isNodeOfType(node, "JSXExpressionContainer")) {
-			const expression = node.expression;
-			if (isNodeOfType(expression, "CallExpression") || isNodeOfType(expression, "Identifier") || isNodeOfType(expression, "MemberExpression")) return true;
-			stack.push(expression);
-			continue;
-		}
-		if (isNodeOfType(node, "ConditionalExpression")) {
-			stack.push(node.consequent, node.alternate);
-			continue;
-		}
-		if (isNodeOfType(node, "LogicalExpression")) {
-			stack.push(node.left, node.right);
-			continue;
 		}
+	});
+	return didDetect;
+};
+//#endregion
+//#region src/plugin/utils/find-ancestor-suspense-layout.ts
+const LAYOUT_FILE_NAMES = [
+	"layout.tsx",
+	"layout.jsx",
+	"layout.ts",
+	"layout.js"
+];
+const hasAncestorSuspenseLayout = (pageFilename) => {
+	const normalizedPage = pageFilename.replaceAll("\\", "/");
+	let currentDirectory = path.dirname(normalizedPage);
+	for (let level = 0; level < 30; level++) {
+		for (const layoutFileName of LAYOUT_FILE_NAMES) {
+			const layoutPath = path.join(currentDirectory, layoutFileName);
+			if (layoutPath.replaceAll("\\", "/") === normalizedPage) continue;
+			const programRoot = parseSourceFile(layoutPath);
+			if (programRoot && astMentionsSuspense(programRoot)) return true;
+		}
+		if (path.basename(currentDirectory) === "app") break;
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) break;
+		currentDirectory = parentDirectory;
 	}
 	return false;
 };
 //#endregion
-//#region src/plugin/rules/correctness/no-array-index-as-key.ts
-const STRING_COERCION_FUNCTIONS = new Set(["String", "Number"]);
-const extractIndexName = (node) => {
-	if (isNodeOfType(node, "Identifier") && INDEX_PARAMETER_NAMES.has(node.name)) return node.name;
-	if (isNodeOfType(node, "TemplateLiteral")) {
-		for (const expression of node.expressions ?? []) if (isNodeOfType(expression, "Identifier") && INDEX_PARAMETER_NAMES.has(expression.name)) return expression.name;
-	}
-	if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.object, "Identifier") && INDEX_PARAMETER_NAMES.has(node.callee.object.name) && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "toString") return node.callee.object.name;
-	if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && STRING_COERCION_FUNCTIONS.has(node.callee.name) && isNodeOfType(node.arguments?.[0], "Identifier") && INDEX_PARAMETER_NAMES.has(node.arguments[0].name)) return node.arguments[0].name;
-	if (isNodeOfType(node, "BinaryExpression") && node.operator === "+" && (isNodeOfType(node.left, "Identifier") && INDEX_PARAMETER_NAMES.has(node.left.name) && isNodeOfType(node.right, "Literal") && node.right.value === "" || isNodeOfType(node.right, "Identifier") && INDEX_PARAMETER_NAMES.has(node.right.name) && isNodeOfType(node.left, "Literal") && node.left.value === "")) {
-		if (isNodeOfType(node.left, "Identifier")) return node.left.name;
-		if (isNodeOfType(node.right, "Identifier")) return node.right.name;
-		return null;
-	}
-	return null;
+//#region src/plugin/rules/nextjs/nextjs-no-use-search-params-without-suspense.ts
+const astContainsUseSearchParams = (root) => {
+	let didFind = false;
+	walkAst(root, (child) => {
+		if (didFind) return false;
+		if (isHookCall$1(child, "useSearchParams")) {
+			didFind = true;
+			return false;
+		}
+	});
+	return didFind;
 };
-const isNumericLiteralOrUndefined = (node) => {
-	if (!node) return false;
-	if (isNodeOfType(node, "Literal") && typeof node.value === "number") return true;
-	if (isNodeOfType(node, "Identifier") && node.name === "undefined") return true;
-	return false;
+const isSuspenseJsxName = (name, suspenseLocalNames) => {
+	if (isNodeOfType(name, "JSXIdentifier")) return name.name === "Suspense" || suspenseLocalNames.has(name.name);
+	return isNodeOfType(name, "JSXMemberExpression") && isNodeOfType(name.property, "JSXIdentifier") && name.property.name === "Suspense";
 };
-const isArrayConstructorCallWithNumericLength = (node) => {
-	if (!node) return false;
-	if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "Array" && isNumericLiteralOrUndefined(node.arguments?.[0])) return true;
-	if (isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "Array" && isNumericLiteralOrUndefined(node.arguments?.[0])) return true;
+const isInsideSuspenseBoundary = (node, suspenseLocalNames) => {
+	let ancestor = node.parent;
+	while (ancestor) {
+		if (isNodeOfType(ancestor, "JSXElement") && isSuspenseJsxName(ancestor.openingElement?.name, suspenseLocalNames)) return true;
+		ancestor = ancestor.parent ?? null;
+	}
 	return false;
 };
-const isArrayFromCall = (node) => {
-	if (!node) return false;
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	const callee = node.callee;
-	return Boolean(isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "from");
+const collectSuspenseLocalNames = (programNode) => {
+	const names = /* @__PURE__ */ new Set();
+	for (const statement of programNode.body ?? []) {
+		if (!isNodeOfType(statement, "ImportDeclaration")) continue;
+		if (statement.source?.value !== "react") continue;
+		for (const specifier of statement.specifiers ?? []) if (isNodeOfType(specifier, "ImportSpecifier") && getImportedName$1(specifier) === "Suspense" && specifier.local?.name) names.add(specifier.local.name);
+	}
+	return names;
 };
-/**
-* True if every element of an ArrayExpression is a primitive constant
-* (number/string/boolean literal) — `[1, 2, 3]`, `['a', 'b']`. Such arrays
-* have a fixed order at every render, so an index key is stable.
-*/
-/**
-* True if the call expression looks like a placeholder constructor whose
-* elements have no identity beyond their position — i.e. `Array.from(...)`,
-* `Array(N)`, `new Array(N)`, `Array(N).fill(...)`, `[...Array(N)]`, or
-* a literal-only array `[1, 2, 3]` / `['a', 'b']`.
-*
-* Used both for `<receiver>.map(...)` and for `Array.from(<length>, fn)`.
-*/
-const isStaticPlaceholderReceiver = (receiver) => {
-	if (isArrayFromCall(receiver)) return true;
-	if (isArrayConstructorCallWithNumericLength(receiver)) return true;
-	if (isAllLiteralArrayExpression(receiver)) return true;
-	if (isNodeOfType(receiver, "CallExpression")) {
-		const callee = receiver.callee;
-		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "fill" && isArrayConstructorCallWithNumericLength(callee.object)) return true;
-	}
-	if (isNodeOfType(receiver, "ArrayExpression") && receiver.elements?.length === 1) {
-		const only = receiver.elements[0];
-		if (only && isNodeOfType(only, "SpreadElement")) {
-			const arg = only.argument;
-			if (isArrayConstructorCallWithNumericLength(arg)) return true;
-			if (isArrayFromCall(arg)) return true;
-		}
-	}
-	return false;
-};
-const isArrayFromLengthObjectCall = (node) => {
-	if (!isArrayFromCall(node)) return false;
-	if (!isNodeOfType(node, "CallExpression")) return false;
-	const first = node.arguments?.[0];
-	if (!first || !isNodeOfType(first, "ObjectExpression")) return false;
-	for (const prop of first.properties ?? []) {
-		if (!isNodeOfType(prop, "Property")) continue;
-		const key = prop.key;
-		if (!(isNodeOfType(key, "Identifier") && key.name === "length" || isNodeOfType(key, "Literal") && key.value === "length")) continue;
-		if (isNumericLiteralOrUndefined(prop.value)) return true;
-		if (isNodeOfType(prop.value, "Identifier")) return true;
-	}
-	return false;
-};
-const isInsideStaticPlaceholderMap = (node) => {
-	let current = node;
-	while (current.parent) {
-		const parent = current.parent;
-		if (isFunctionLike$2(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
-			const callee = parent.callee;
-			if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && (callee.property.name === "map" || callee.property.name === "flatMap" || callee.property.name === "forEach")) return isStaticPlaceholderReceiver(callee.object);
-			if (isArrayFromCall(parent) && parent.arguments.length >= 2 && parent.arguments[1] === current) return isArrayFromLengthObjectCall(parent);
+const collectImportedComponents = (programNode) => {
+	const entries = /* @__PURE__ */ new Map();
+	for (const statement of programNode.body ?? []) {
+		if (!isNodeOfType(statement, "ImportDeclaration")) continue;
+		if (typeof statement.source?.value !== "string") continue;
+		const source = statement.source.value;
+		for (const specifier of statement.specifiers ?? []) {
+			const localName = specifier.local?.name;
+			if (!localName) continue;
+			const exportedName = resolveImportedExportName(specifier);
+			if (!exportedName) continue;
+			entries.set(localName, {
+				source,
+				exportedName
+			});
 		}
-		current = parent;
 	}
-	return false;
+	return entries;
 };
-/**
-* Walk up from a JSXAttribute node looking for the enclosing iterator
-* callback (`.map(cb)`, `.flatMap(cb)`, `.forEach(cb)`, `Array.from(_, cb)`)
-* and return the first parameter's name. The first param is the per-item
-* value, e.g. `item` in `arr.map((item, index) => …)`.
-*/
-const findIteratorItemName$1 = (node) => {
-	let current = node;
-	while (current.parent) {
-		const parent = current.parent;
-		if (isFunctionLike$2(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
-			const callee = parent.callee;
-			const isIteratorMethodCall = isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && (callee.property.name === "map" || callee.property.name === "flatMap" || callee.property.name === "forEach");
-			const isArrayFromCallback = isArrayFromCall(parent) && parent.arguments.length >= 2 && parent.arguments[1] === current;
-			if (isIteratorMethodCall || isArrayFromCallback) {
-				const first = (current.params ?? [])[0];
-				if (first && isNodeOfType(first, "Identifier")) return first.name;
-				return null;
+const nextjsNoUseSearchParamsWithoutSuspense = defineRule({
+	id: "nextjs-no-use-search-params-without-suspense",
+	title: "useSearchParams without Suspense",
+	tags: ["test-noise"],
+	requires: ["nextjs"],
+	severity: "warn",
+	recommendation: "Wrap the component using useSearchParams: `<Suspense fallback={<Skeleton />}><SearchComponent /></Suspense>`",
+	create: (context) => {
+		let isPageOrLayoutFile = false;
+		let hasAncestorLayoutSuspense = false;
+		let hasSuspenseInFile = false;
+		let importedComponents = /* @__PURE__ */ new Map();
+		let suspenseLocalNames = /* @__PURE__ */ new Set();
+		return {
+			Program(programNode) {
+				const filename = normalizeFilename$1(context.filename ?? "");
+				isPageOrLayoutFile = PAGE_OR_LAYOUT_FILE_PATTERN.test(filename);
+				if (!isPageOrLayoutFile) return;
+				hasAncestorLayoutSuspense = hasAncestorSuspenseLayout(context.filename ?? "");
+				if (hasAncestorLayoutSuspense) return;
+				hasSuspenseInFile = astMentionsSuspense(programNode);
+				importedComponents = collectImportedComponents(programNode);
+				suspenseLocalNames = collectSuspenseLocalNames(programNode);
+			},
+			CallExpression(node) {
+				if (!isPageOrLayoutFile || hasAncestorLayoutSuspense || hasSuspenseInFile) return;
+				if (!isHookCall$1(node, "useSearchParams")) return;
+				context.report({
+					node,
+					message: "useSearchParams() without a <Suspense> boundary forces the whole page into client-side rendering."
+				});
+			},
+			JSXOpeningElement(node) {
+				if (!isPageOrLayoutFile || hasAncestorLayoutSuspense) return;
+				if (!isNodeOfType(node.name, "JSXIdentifier")) return;
+				const importEntry = importedComponents.get(node.name.name);
+				if (!importEntry) return;
+				const jsxElement = node.parent;
+				if (!jsxElement) return;
+				if (isInsideSuspenseBoundary(jsxElement, suspenseLocalNames)) return;
+				const componentBody = resolveCrossFileFunctionExport(context.filename ?? "", importEntry.source, importEntry.exportedName);
+				if (!componentBody || !astContainsUseSearchParams(componentBody)) return;
+				context.report({
+					node,
+					message: `<${node.name.name}> uses useSearchParams() but is not wrapped in a <Suspense> boundary.`
+				});
 			}
-		}
-		current = parent;
-	}
-	return null;
-};
-const templateLiteralHasIteratorIdentity = (template, itemName) => {
-	for (const expression of template.expressions ?? []) {
-		if (isNodeOfType(expression, "Identifier") && expression.name === itemName) return true;
-		if (isNodeOfType(expression, "MemberExpression") && isNodeOfType(expression.object, "Identifier") && expression.object.name === itemName) return true;
+		};
 	}
-	return false;
-};
-/**
-* True when the JSX key value is a template literal mixing an index with at
-* least one stable per-item identifier (e.g. `${item.id}-${index}`). Common
-* defensive pattern in user code — the index is just a uniqueness fallback,
-* the real identity is `item.id`.
-*/
-const isCompositeKeyWithIteratorIdentity = (keyExpression, attributeNode) => {
-	if (!isNodeOfType(keyExpression, "TemplateLiteral")) return false;
-	if ((keyExpression.expressions ?? []).length < 2) return false;
-	const itemName = findIteratorItemName$1(attributeNode);
-	if (!itemName) return false;
-	return templateLiteralHasIteratorIdentity(keyExpression, itemName);
-};
-const noArrayIndexAsKey = defineRule({
-	id: "no-array-index-as-key",
-	title: "Array index used as a key",
+});
+//#endregion
+//#region src/plugin/rules/nextjs/nextjs-no-vercel-og-import.ts
+const nextjsNoVercelOgImport = defineRule({
+	id: "nextjs-no-vercel-og-import",
+	title: "@vercel/og import instead of next/og",
+	tags: ["test-noise"],
+	requires: ["nextjs"],
 	severity: "warn",
-	recommendation: "Use a stable id from the item, like `key={item.id}` or `key={item.slug}`. Index keys break when the list reorders or filters.",
-	create: (context) => ({ JSXAttribute(node) {
-		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "key") return;
-		if (!node.value || !isNodeOfType(node.value, "JSXExpressionContainer")) return;
-		const indexName = extractIndexName(node.value.expression);
-		if (!indexName) return;
-		if (isInsideStaticPlaceholderMap(node)) return;
-		if (isCompositeKeyWithIteratorIdentity(node.value.expression, node)) return;
-		const openingElement = node.parent;
-		if (openingElement && isNodeOfType(openingElement, "JSXOpeningElement")) {
-			const elementName = openingElement.name;
-			if (isNodeOfType(elementName, "JSXIdentifier")) {
-				if (elementName.name === "Fragment") return;
-				if (PURE_SVG_PRIMITIVE_TAGS.has(elementName.name)) return;
-				if (STATELESS_HTML_LEAF_TAGS.has(elementName.name)) {
-					const jsxElement = openingElement.parent;
-					if (jsxElement && isNodeOfType(jsxElement, "JSXElement")) {
-						if (!containsStatefulDescendant(jsxElement)) return;
-					}
-				}
-			}
-			if (isNodeOfType(elementName, "JSXMemberExpression") && isNodeOfType(elementName.object, "JSXIdentifier") && isNodeOfType(elementName.property, "JSXIdentifier") && elementName.object.name === "React" && elementName.property.name === "Fragment") return;
-		}
+	recommendation: "Use `import { ImageResponse } from \"next/og\"`. The `@vercel/og` package is built into Next.js and should not be imported directly",
+	create: (context) => ({ ImportDeclaration(node) {
+		if (node.source?.value !== "@vercel/og") return;
 		context.report({
 			node,
-			message: `Your users can see & submit the wrong data when this list reorders or filters, so use a stable id like \`key={item.id}\`, not the array index "${indexName}".`
+			message: "@vercel/og is bundled into Next.js. Import from \"next/og\" instead to avoid duplicate code and version mismatch."
 		});
 	} })
 });
 //#endregion
-//#region src/plugin/rules/react-builtins/no-array-index-key.ts
-const MESSAGE$29 = "Your users can see & submit the wrong data when this list reorders.";
-const SECOND_INDEX_METHODS = new Set([
-	"every",
-	"filter",
-	"find",
-	"findIndex",
-	"flatMap",
-	"forEach",
-	"map",
-	"some"
-]);
-const THIRD_INDEX_METHODS = new Set(["reduce", "reduceRight"]);
-const isPositionallyStableIterationReceiver = (receiver) => {
-	if (isAllLiteralArrayExpression(receiver)) return true;
-	if (isNodeOfType(receiver, "ArrayExpression") && receiver.elements?.length === 1) {
-		const only = receiver.elements[0];
-		if (only && isNodeOfType(only, "SpreadElement")) {
-			const arg = only.argument;
-			if (arg && isPositionallyStableIterationReceiver(arg)) return true;
+//#region src/plugin/rules/a11y/no-access-key.ts
+const MESSAGE$31 = "Screen reader users can lose their shortcuts because `accessKey` clashes with them, so remove it.";
+const isUndefinedIdentifier = (expression) => isNodeOfType(expression, "Identifier") && expression.name === "undefined";
+const noAccessKey = defineRule({
+	id: "no-access-key",
+	title: "accessKey attribute used",
+	tags: ["react-jsx-only"],
+	severity: "warn",
+	recommendation: "Do not use `accessKey`. It conflicts with assistive tech shortcuts.",
+	category: "Accessibility",
+	create: (context) => ({ JSXOpeningElement(node) {
+		const accessKey = hasJsxPropIgnoreCase(node.attributes, "accessKey");
+		if (!accessKey) return;
+		const attributeValue = accessKey.value;
+		if (!attributeValue) return;
+		if (isNodeOfType(attributeValue, "Literal") && typeof attributeValue.value === "string") {
+			context.report({
+				node: accessKey,
+				message: MESSAGE$31
+			});
+			return;
 		}
-	}
-	if (!isNodeOfType(receiver, "CallExpression")) return false;
-	const callee = receiver.callee;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "from" && receiver.arguments.length >= 1 && isNodeOfType(receiver.arguments[0], "ObjectExpression")) return true;
-	if (isNodeOfType(callee, "Identifier") && callee.name === "Array") return true;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "split") return true;
-	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && (callee.property.name === "fill" || callee.property.name === "flat")) return isPositionallyStableIterationReceiver(callee.object);
-	return false;
-};
-const templateHasIteratorMember = (templateLiteral, iteratorName) => {
-	for (const expression of templateLiteral.expressions ?? []) {
-		if (isNodeOfType(expression, "Identifier") && expression.name === iteratorName) return true;
-		if (isNodeOfType(expression, "MemberExpression") && isNodeOfType(expression.object, "Identifier") && expression.object.name === iteratorName) return true;
-	}
-	return false;
-};
-const isArrayFromMapperCallback = (parentCall, callback) => {
-	if (parentCall.arguments[1] !== callback) return false;
-	const callee = parentCall.callee;
-	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "from";
-};
-const isArrayFromSourcePositionallyStable = (source) => {
-	if (isNodeOfType(source, "ObjectExpression")) {
-		for (const property of source.properties ?? []) {
-			if (!isNodeOfType(property, "Property")) continue;
-			const key = property.key;
-			if (isNodeOfType(key, "Identifier") && key.name === "length" || isNodeOfType(key, "Literal") && key.value === "length") return true;
+		if (isNodeOfType(attributeValue, "JSXExpressionContainer")) {
+			const expression = attributeValue.expression;
+			if (!expression || expression.type === "JSXEmptyExpression") return;
+			if (isUndefinedIdentifier(expression)) return;
+			context.report({
+				node: accessKey,
+				message: MESSAGE$31
+			});
 		}
-		return false;
-	}
-	return isPositionallyStableIterationReceiver(source);
+	} })
+});
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/effect/constants.ts
+const TYPESCRIPT_VISITOR_KEYS = {
+	TSAsExpression: ["expression", "typeAnnotation"],
+	TSNonNullExpression: ["expression"],
+	TSSatisfiesExpression: ["expression", "typeAnnotation"],
+	TSTypeAssertion: ["typeAnnotation", "expression"],
+	TSInstantiationExpression: ["expression", "typeArguments"]
 };
-const findIteratorItemName = (node) => {
-	let current = node;
-	while (current) {
-		if (isNodeOfType(current, "ArrowFunctionExpression") || isNodeOfType(current, "FunctionExpression")) {
-			const parent = current.parent;
-			const callbackItemName = readIteratorItemFromCallback(current, parent);
-			if (callbackItemName !== void 0) return callbackItemName;
-			if (current.params.length > 0) return null;
+const VISITOR_KEYS = {
+	...eslintVisitorKeys.KEYS,
+	...TYPESCRIPT_VISITOR_KEYS
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/effect/get-program-analysis.ts
+const programToAnalysis = /* @__PURE__ */ new WeakMap();
+const stripAndRecordParents = (root) => {
+	const restorations = [];
+	const seen = /* @__PURE__ */ new WeakSet();
+	const visit = (value) => {
+		if (!value || typeof value !== "object") return;
+		if (seen.has(value)) return;
+		seen.add(value);
+		if (Array.isArray(value)) {
+			for (const item of value) visit(item);
+			return;
 		}
-		current = current.parent ?? null;
+		const record = value;
+		if (!("type" in record)) return;
+		if ("parent" in record) {
+			restorations.push({
+				node: record,
+				originalParent: record.parent
+			});
+			record.parent = null;
+		}
+		for (const key of Object.keys(record)) {
+			if (key === "parent") continue;
+			visit(record[key]);
+		}
+	};
+	visit(root);
+	return restorations;
+};
+const restoreParents = (restorations) => {
+	for (const restoration of restorations) restoration.node.parent = restoration.originalParent;
+};
+const getProgramAnalysis = (anyNode) => {
+	const programNode = findProgramRoot(anyNode);
+	if (!programNode) return null;
+	const cached = programToAnalysis.get(programNode);
+	if (cached) return cached;
+	const restorations = stripAndRecordParents(programNode);
+	let scopeManager;
+	try {
+		scopeManager = analyze(programNode, {
+			ecmaVersion: 2024,
+			sourceType: "module",
+			childVisitorKeys: VISITOR_KEYS,
+			fallback: "iteration"
+		});
+	} finally {
+		restoreParents(restorations);
 	}
-	return null;
+	const analysis = {
+		programNode,
+		scopeManager
+	};
+	programToAnalysis.set(programNode, analysis);
+	return analysis;
 };
-const readIteratorItemFromCallback = (callback, parent) => {
-	if (!parent || !isNodeOfType(parent, "CallExpression")) return void 0;
-	const callee = parent.callee;
-	if (parent.arguments[0] === callback && isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
-		const methodName = callee.property.name;
-		if (SECOND_INDEX_METHODS.has(methodName)) {
-			const item = callback.params[0];
-			return item && isNodeOfType(item, "Identifier") ? item.name : null;
-		}
-		if (THIRD_INDEX_METHODS.has(methodName)) {
-			const item = callback.params[1];
-			return item && isNodeOfType(item, "Identifier") ? item.name : null;
+const getScopeForNode = (node, manager) => {
+	if (!node.range) return null;
+	let bestScope = null;
+	let bestSize = Infinity;
+	for (const scope of manager.scopes) {
+		const block = scope.block;
+		if (!block?.range) continue;
+		if (node.range[0] < block.range[0] || node.range[1] > block.range[1]) continue;
+		const size = block.range[1] - block.range[0];
+		if (size <= bestSize) {
+			bestSize = size;
+			bestScope = scope;
 		}
 	}
-	if (isArrayFromMapperCallback(parent, callback)) {
-		const item = callback.params[0];
-		return item && isNodeOfType(item, "Identifier") ? item.name : null;
+	return bestScope;
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/effect/ast.ts
+const getChildKeys = (node) => VISITOR_KEYS[node.type] ?? Object.keys(node).filter((key) => key !== "parent");
+const ascend = (analysis, ref, visit, visited = /* @__PURE__ */ new Set()) => {
+	if (visited.has(ref)) return;
+	const result = visit(ref);
+	visited.add(ref);
+	if (result === false) return;
+	const defs = ref.resolved?.defs ?? [];
+	for (const def of defs) {
+		if (def.type === "ImportBinding") continue;
+		if (def.type === "Parameter") continue;
+		const defNode = def.node;
+		const next = defNode.init ?? defNode.body;
+		if (!next) continue;
+		for (const innerRef of getDownstreamRefs(analysis, next)) ascend(analysis, innerRef, visit, visited);
 	}
 };
-const findIndexParameterBinding = (node) => {
-	let current = node.parent;
-	while (current) {
-		if (isNodeOfType(current, "ArrowFunctionExpression") || isNodeOfType(current, "FunctionExpression")) {
-			const indexParam = readIteratorIndexFromCallback(current, current.parent);
-			if (indexParam !== void 0) return indexParam;
-			if (current.params.length > 0) return null;
-		}
-		current = current.parent ?? null;
+const descend = (node, visit, visited = /* @__PURE__ */ new Set()) => {
+	if (visited.has(node)) return;
+	visit(node);
+	visited.add(node);
+	const keys = getChildKeys(node);
+	const record = node;
+	for (const key of keys) {
+		const child = record[key];
+		if (!child) continue;
+		if (Array.isArray(child)) {
+			for (const item of child) if (item && isAstNode(item)) descend(item, visit, visited);
+		} else if (isAstNode(child)) descend(child, visit, visited);
 	}
+};
+const getUpstreamRefs = (analysis, ref) => {
+	const refs = [];
+	ascend(analysis, ref, (upRef) => {
+		refs.push(upRef);
+	});
+	return refs;
+};
+const findDownstreamNodes = (topNode, type) => {
+	const nodes = [];
+	descend(topNode, (node) => {
+		if (node.type === type) nodes.push(node);
+	});
+	return nodes;
+};
+const getRef = (analysis, identifier) => {
+	const scope = getScopeForNode(identifier, analysis.scopeManager);
+	if (!scope) return null;
+	for (const reference of scope.references) if (reference.identifier === identifier) return reference;
 	return null;
 };
-const readIteratorIndexFromCallback = (callback, parent) => {
-	if (!parent || !isNodeOfType(parent, "CallExpression")) return void 0;
-	const callee = parent.callee;
-	if (parent.arguments[0] === callback && isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
-		const methodName = callee.property.name;
-		let indexParamPosition = null;
-		if (SECOND_INDEX_METHODS.has(methodName)) indexParamPosition = 1;
-		else if (THIRD_INDEX_METHODS.has(methodName)) indexParamPosition = 2;
-		if (indexParamPosition !== null) {
-			const receiver = callee.object;
-			if (isPositionallyStableIterationReceiver(receiver)) return null;
-			const indexParam = callback.params[indexParamPosition];
-			return indexParam && isNodeOfType(indexParam, "Identifier") ? indexParam : null;
-		}
+const downstreamRefsCache = /* @__PURE__ */ new WeakMap();
+const getDownstreamRefs = (analysis, node) => {
+	let perNode = downstreamRefsCache.get(analysis);
+	if (!perNode) {
+		perNode = /* @__PURE__ */ new WeakMap();
+		downstreamRefsCache.set(analysis, perNode);
 	}
-	if (isArrayFromMapperCallback(parent, callback)) {
-		const source = parent.arguments[0];
-		if (source && isArrayFromSourcePositionallyStable(source)) return null;
-		const indexParam = callback.params[1];
-		return indexParam && isNodeOfType(indexParam, "Identifier") ? indexParam : null;
+	const cached = perNode.get(node);
+	if (cached) return cached;
+	const refs = [];
+	for (const identifier of findDownstreamNodes(node, "Identifier")) {
+		const ref = getRef(analysis, identifier);
+		if (ref) refs.push(ref);
 	}
+	perNode.set(node, refs);
+	return refs;
 };
-const isIndexReference = (expression, paramName) => isNodeOfType(expression, "Identifier") && expression.name === paramName;
-const expressionUsesIndex = (expression, paramName) => {
-	if (isIndexReference(expression, paramName)) return true;
-	if (isNodeOfType(expression, "TemplateLiteral")) return expression.expressions.some((innerExpression) => isIndexReference(innerExpression, paramName));
-	if (isNodeOfType(expression, "BinaryExpression")) {
-		const usesInLeft = isIndexReference(expression.left, paramName);
-		const usesInRight = isIndexReference(expression.right, paramName);
-		if (usesInLeft || usesInRight) return true;
-		if (isNodeOfType(expression.left, "BinaryExpression") && expressionUsesIndex(expression.left, paramName)) return true;
-		if (isNodeOfType(expression.right, "BinaryExpression") && expressionUsesIndex(expression.right, paramName)) return true;
-		return false;
+const getCallExpr = (ref, current = ref.identifier.parent) => {
+	if (!current) return null;
+	if (isNodeOfType(current, "CallExpression")) {
+		let node = ref.identifier;
+		let parent = node.parent;
+		while (parent && isNodeOfType(parent, "MemberExpression")) {
+			node = parent;
+			parent = node.parent;
+		}
+		if (current.callee === node) return current;
 	}
-	if (isNodeOfType(expression, "CallExpression")) {
-		if (isNodeOfType(expression.callee, "MemberExpression") && isNodeOfType(expression.callee.property, "Identifier") && expression.callee.property.name === "toString" && isIndexReference(expression.callee.object, paramName)) return true;
-		if (isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "String" && expression.arguments.length > 0 && isIndexReference(expression.arguments[0], paramName)) return true;
+	if (isNodeOfType(current, "MemberExpression")) return getCallExpr(ref, current.parent);
+	return null;
+};
+const getArgsUpstreamRefs = (analysis, ref) => {
+	const result = [];
+	for (const upRef of getUpstreamRefs(analysis, ref)) {
+		const callExpr = getCallExpr(upRef);
+		if (!callExpr || !isNodeOfType(callExpr, "CallExpression")) continue;
+		for (const argument of callExpr.arguments ?? []) for (const argRef of getDownstreamRefs(analysis, argument)) for (const innerRef of getUpstreamRefs(analysis, argRef)) result.push(innerRef);
 	}
-	return false;
+	return result;
 };
-const isReactCloneElement = (callExpression) => {
-	const callee = callExpression.callee;
-	if (!isNodeOfType(callee, "MemberExpression")) return false;
-	if (!isNodeOfType(callee.property, "Identifier")) return false;
-	if (callee.property.name !== "cloneElement") return false;
-	return isNodeOfType(callee.object, "Identifier") && callee.object.name === "React";
+const isSynchronous = (node, within) => {
+	if (!node) return false;
+	if (node === within) return true;
+	if (node.async === true) return false;
+	if (isNodeOfType(node, "AwaitExpression") || isNodeOfType(node, "UnaryExpression") && node.operator === "void" || isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression")) return false;
+	return isSynchronous(node.parent, within);
 };
-const isPureSvgPrimitiveJsxName = (jsxOpeningName) => isNodeOfType(jsxOpeningName, "JSXIdentifier") && PURE_SVG_PRIMITIVE_TAGS.has(jsxOpeningName.name);
-const isStatelessLeafJsxName = (jsxOpeningName) => isNodeOfType(jsxOpeningName, "JSXIdentifier") && STATELESS_HTML_LEAF_TAGS.has(jsxOpeningName.name);
-const isFragmentJsxName = (jsxOpeningName) => {
-	if (isNodeOfType(jsxOpeningName, "JSXIdentifier")) return jsxOpeningName.name === "Fragment";
-	if (isNodeOfType(jsxOpeningName, "JSXMemberExpression") && isNodeOfType(jsxOpeningName.object, "JSXIdentifier") && isNodeOfType(jsxOpeningName.property, "JSXIdentifier") && jsxOpeningName.object.name === "React" && jsxOpeningName.property.name === "Fragment") return true;
-	return false;
+const isEventualCallTo = (analysis, ref, predicate) => {
+	const callExprRefs = [];
+	ascend(analysis, ref, (upRef) => {
+		if (getCallExpr(upRef)) callExprRefs.push(upRef);
+		else return false;
+	});
+	return callExprRefs.some(predicate);
 };
-const noArrayIndexKey = defineRule({
-	id: "no-array-index-key",
-	title: "Array index used as a key",
-	severity: "warn",
-	defaultEnabled: false,
-	recommendation: "Use a stable `key` from your data instead of the array index.",
-	category: "Performance",
-	create: (context) => ({
-		JSXOpeningElement(node) {
-			const keyAttribute = hasJsxPropIgnoreCase(node.attributes, "key");
-			if (!keyAttribute) return;
-			if (!keyAttribute.value || !isNodeOfType(keyAttribute.value, "JSXExpressionContainer")) return;
-			const expression = keyAttribute.value.expression;
-			if (expression.type === "JSXEmptyExpression") return;
-			if (isFragmentJsxName(node.name)) return;
-			if (isPureSvgPrimitiveJsxName(node.name)) return;
-			const indexBinding = findIndexParameterBinding(node);
-			if (!indexBinding) return;
-			if (!expressionUsesIndex(expression, indexBinding.name)) return;
-			if (isNodeOfType(expression, "TemplateLiteral")) {
-				const itemName = findIteratorItemName(node);
-				if (itemName && templateHasIteratorMember(expression, itemName)) return;
-				const interpolations = expression.expressions ?? [];
-				let interpolationsBeyondIndex = 0;
-				for (const interpolation of interpolations) {
-					if (isIndexReference(interpolation, indexBinding.name)) continue;
-					interpolationsBeyondIndex += 1;
-					if (interpolationsBeyondIndex >= 1) break;
-				}
-				if (interpolationsBeyondIndex >= 1) return;
-			}
-			if (isNodeOfType(expression, "BinaryExpression") && expression.operator === "+") {
-				let interpolationsBeyondIndex = 0;
-				const walkOperand = (operand) => {
-					if (isNodeOfType(operand, "BinaryExpression") && operand.operator === "+") {
-						walkOperand(operand.left);
-						walkOperand(operand.right);
-						return;
-					}
-					if (isIndexReference(operand, indexBinding.name)) return;
-					if (isNodeOfType(operand, "Literal") && typeof operand.value === "string") return;
-					interpolationsBeyondIndex += 1;
-				};
-				walkOperand(expression);
-				if (interpolationsBeyondIndex >= 1) return;
-			}
-			if (isStatelessLeafJsxName(node.name)) {
-				const jsxElement = node.parent;
-				if (jsxElement && isNodeOfType(jsxElement, "JSXElement")) {
-					if (!containsStatefulDescendant(jsxElement)) return;
-				}
-			}
+//#endregion
+//#region src/plugin/rules/state-and-effects/utils/effect/react.ts
+const getOuterScopeContaining = (analysis, node) => {
+	if (!node.range) return null;
+	let best = null;
+	let bestSize = Infinity;
+	for (const scope of analysis.scopeManager.scopes) {
+		const block = scope.block;
+		if (!block?.range) continue;
+		if (node.range[0] < block.range[0] || node.range[1] > block.range[1]) continue;
+		const size = block.range[1] - block.range[0];
+		if (size <= bestSize) {
+			bestSize = size;
+			best = scope;
+		}
+	}
+	return best;
+};
+const KNOWN_PURE_HOC_NAMES = new Set(["memo", "forwardRef"]);
+const startsWithUppercase = (name) => Boolean(name && name.length > 0 && name[0] >= "A" && name[0] <= "Z");
+const isReactFunctionalComponent = (node) => {
+	if (!node) return false;
+	if (isNodeOfType(node, "FunctionDeclaration")) return Boolean(node.id && startsWithUppercase(node.id.name));
+	if (isNodeOfType(node, "VariableDeclarator")) {
+		if (!isNodeOfType(node.id, "Identifier")) return false;
+		if (!startsWithUppercase(node.id.name)) return false;
+		const init = node.init;
+		if (!init) return false;
+		return isNodeOfType(init, "ArrowFunctionExpression") || isNodeOfType(init, "CallExpression");
+	}
+	return false;
+};
+const isReactFunctionalHOC = (analysis, node) => {
+	if (!isReactFunctionalComponent(node)) return false;
+	if (!isNodeOfType(node, "VariableDeclarator")) return false;
+	const init = node.init;
+	if (!init) return false;
+	const isWrappedInline = () => {
+		if (!isNodeOfType(init, "CallExpression")) return false;
+		if (!isNodeOfType(init.callee, "Identifier")) return false;
+		if (KNOWN_PURE_HOC_NAMES.has(init.callee.name)) return false;
+		const firstArg = init.arguments?.[0];
+		if (!firstArg) return false;
+		return isNodeOfType(firstArg, "ArrowFunctionExpression") || isNodeOfType(firstArg, "FunctionExpression");
+	};
+	const isWrappedSeparately = () => {
+		if (!isNodeOfType(node.id, "Identifier")) return false;
+		const bindingName = node.id.name;
+		const containingScope = getOuterScopeContaining(analysis, node);
+		if (!containingScope) return false;
+		const variable = containingScope.variables.find((v) => v.name === bindingName);
+		if (!variable) return false;
+		for (const reference of variable.references) {
+			const parent = reference.identifier.parent;
+			if (!parent || !isNodeOfType(parent, "CallExpression")) continue;
+			const args = parent.arguments ?? [];
+			const refId = reference.identifier;
+			if (!args.includes(refId)) continue;
+			const callee = parent.callee;
+			const calleeName = isNodeOfType(callee, "Identifier") ? callee.name : isNodeOfType(callee, "CallExpression") && isNodeOfType(callee.callee, "Identifier") ? callee.callee.name : null;
+			if (calleeName != null && !KNOWN_PURE_HOC_NAMES.has(calleeName)) return true;
+		}
+		return false;
+	};
+	return isWrappedInline() || isWrappedSeparately();
+};
+const isCustomHook = (node) => {
+	if (!node) return false;
+	if (isNodeOfType(node, "FunctionDeclaration")) {
+		const name = node.id?.name;
+		if (!name) return false;
+		return name.startsWith("use") && name.length > 3 && name[3] >= "A" && name[3] <= "Z";
+	}
+	if (isNodeOfType(node, "VariableDeclarator")) {
+		if (!isNodeOfType(node.id, "Identifier")) return false;
+		const name = node.id.name;
+		const init = node.init;
+		if (!init) return false;
+		if (!isNodeOfType(init, "ArrowFunctionExpression") && !isNodeOfType(init, "FunctionExpression")) return false;
+		return name.startsWith("use") && name.length > 3 && name[3] >= "A" && name[3] <= "Z";
+	}
+	return false;
+};
+const isReactNamedImportReference = (ref, importedName) => Boolean(ref?.resolved?.defs.some((def) => {
+	if (def.type !== "ImportBinding") return false;
+	const declarationNode = def.node;
+	if (!isNodeOfType(declarationNode, "ImportSpecifier")) return false;
+	const imported = declarationNode.imported;
+	if (!isNodeOfType(imported, "Identifier")) return false;
+	if (imported.name !== importedName) return false;
+	const importDeclaration = declarationNode.parent;
+	return Boolean(importDeclaration && isNodeOfType(importDeclaration, "ImportDeclaration") && isNodeOfType(importDeclaration.source, "Literal") && importDeclaration.source.value === "react");
+}));
+const isHookCallee = (analysis, node, hookName) => {
+	if (!node) return false;
+	if (isNodeOfType(node, "Identifier")) {
+		if (node.name === hookName) return true;
+		if (isReactNamedImportReference(getRef(analysis, node), hookName)) return true;
+		const parent = node.parent;
+		if (parent && isNodeOfType(parent, "MemberExpression") && isNodeOfType(parent.object, "Identifier") && parent.object.name === "React" && isNodeOfType(parent.property, "Identifier") && parent.property.name === hookName) return true;
+		return false;
+	}
+	if (isNodeOfType(node, "MemberExpression")) return isNodeOfType(node.object, "Identifier") && node.object.name === "React" && isNodeOfType(node.property, "Identifier") && node.property.name === hookName;
+	return false;
+};
+const isUseEffect = (node) => {
+	if (!node || !isNodeOfType(node, "CallExpression")) return false;
+	const callee = node.callee;
+	if (isNodeOfType(callee, "Identifier") && callee.name === "useEffect") return true;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && callee.object.name === "React" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "useEffect") return true;
+	return false;
+};
+const getEffectFn = (analysis, node) => {
+	if (!isNodeOfType(node, "CallExpression")) return null;
+	const fn = node.arguments?.[0];
+	if (!fn) return null;
+	if (isNodeOfType(fn, "ArrowFunctionExpression") || isNodeOfType(fn, "FunctionExpression")) return fn;
+	if (isNodeOfType(fn, "Identifier")) {
+		const definitionNode = getRef(analysis, fn)?.resolved?.defs[0]?.node;
+		if (definitionNode && isFunctionLike$2(definitionNode)) return definitionNode;
+		if (definitionNode && isNodeOfType(definitionNode, "VariableDeclarator")) {
+			const initializer = definitionNode.init;
+			if (isNodeOfType(initializer, "ArrowFunctionExpression") || isNodeOfType(initializer, "FunctionExpression")) return initializer;
+		}
+	}
+	return null;
+};
+const getEffectFnRefs = (analysis, node) => {
+	const fn = getEffectFn(analysis, node);
+	if (!fn) return null;
+	return getDownstreamRefs(analysis, fn);
+};
+const getEffectDepsRefs = (analysis, node) => {
+	if (!isNodeOfType(node, "CallExpression")) return null;
+	const deps = node.arguments?.[1];
+	if (!deps || !isNodeOfType(deps, "ArrayExpression")) return null;
+	return getDownstreamRefs(analysis, deps);
+};
+const isState = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
+	const node = def.node;
+	if (!isNodeOfType(node, "VariableDeclarator")) return false;
+	if (!isNodeOfType(node.init, "CallExpression")) return false;
+	if (!isHookCallee(analysis, node.init.callee, "useState")) return false;
+	if (!isNodeOfType(node.id, "ArrayPattern")) return false;
+	const elements = node.id.elements ?? [];
+	if (elements.length !== 1 && elements.length !== 2) return false;
+	const first = elements[0];
+	return Boolean(first && isNodeOfType(first, "Identifier") && first.name === ref.identifier.name);
+}));
+const isStateSetter = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
+	const node = def.node;
+	if (!isNodeOfType(node, "VariableDeclarator")) return false;
+	if (!isNodeOfType(node.init, "CallExpression")) return false;
+	if (!isHookCallee(analysis, node.init.callee, "useState")) return false;
+	if (!isNodeOfType(node.id, "ArrayPattern")) return false;
+	const elements = node.id.elements ?? [];
+	if (elements.length !== 2) return false;
+	const second = elements[1];
+	return Boolean(second && isNodeOfType(second, "Identifier") && second.name === ref.identifier.name);
+}));
+const isProp = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
+	if (def.type !== "Parameter") return false;
+	const defNode = def.node;
+	let declaringNode = defNode;
+	if (isNodeOfType(defNode, "ArrowFunctionExpression")) {
+		const parent = defNode.parent;
+		if (parent && isNodeOfType(parent, "CallExpression")) declaringNode = parent.parent;
+		else declaringNode = parent;
+	}
+	if (!declaringNode) return false;
+	return isReactFunctionalComponent(declaringNode) && !isReactFunctionalHOC(analysis, declaringNode) || isCustomHook(declaringNode);
+}));
+const isIdentifierOrMemberExpression = (node) => isNodeOfType(node, "Identifier") || isNodeOfType(node, "MemberExpression");
+const isPropAlias = (analysis, ref) => {
+	if (isProp(analysis, ref)) return true;
+	return Boolean(ref.resolved?.defs.some((def) => {
+		const node = def.node;
+		if (!isNodeOfType(node, "VariableDeclarator")) return false;
+		const initializer = node.init;
+		if (!initializer) return false;
+		if (!isNodeOfType(node.id, "ObjectPattern") && !isIdentifierOrMemberExpression(initializer)) return false;
+		return getDownstreamRefs(analysis, initializer).some((initializerRef) => getUpstreamRefs(analysis, initializerRef).some((upstreamRef) => isProp(analysis, upstreamRef)));
+	}));
+};
+const isConstant = (ref) => Boolean((ref.resolved?.defs ?? []).some((def) => {
+	const node = def.node;
+	if (!isNodeOfType(node, "VariableDeclarator")) return false;
+	const init = node.init;
+	if (!init) return false;
+	return isNodeOfType(init, "Literal") || isNodeOfType(init, "TemplateLiteral") || isNodeOfType(init, "ArrayExpression") || isNodeOfType(init, "ObjectExpression");
+}));
+const isRef = (analysis, ref) => Boolean(ref.resolved?.defs.some((def) => {
+	const node = def.node;
+	if (!isNodeOfType(node, "VariableDeclarator")) return false;
+	if (!isNodeOfType(node.init, "CallExpression")) return false;
+	return isHookCallee(analysis, node.init.callee, "useRef");
+}));
+const isRefCurrent = (ref) => {
+	const parent = ref.identifier.parent;
+	if (!parent || !isNodeOfType(parent, "MemberExpression")) return false;
+	if (!isNodeOfType(parent.property, "Identifier")) return false;
+	return parent.property.name === "current";
+};
+const isStateSetterCall = (analysis, ref) => isEventualCallTo(analysis, ref, (innerRef) => isStateSetter(analysis, innerRef));
+const isPropCall = (analysis, ref) => isEventualCallTo(analysis, ref, (innerRef) => isPropAlias(analysis, innerRef));
+const isRefCall = (analysis, ref) => isEventualCallTo(analysis, ref, (innerRef) => isRefCurrent(innerRef) || isRef(analysis, innerRef));
+const getUseStateDecl = (analysis, ref) => {
+	let node = getUpstreamRefs(analysis, ref).find((upRef) => isHookCallee(analysis, upRef.identifier, "useState"))?.identifier;
+	while (node && !isNodeOfType(node, "VariableDeclarator")) node = node.parent;
+	return node ?? null;
+};
+const isCleanupReturnArgument = (analysis, node) => {
+	if (isFunctionLike$2(node)) return true;
+	if (isNodeOfType(node, "MemberExpression")) return true;
+	if (isNodeOfType(node, "Identifier")) {
+		const definitionNode = getRef(analysis, node)?.resolved?.defs[0]?.node;
+		if (definitionNode && isFunctionLike$2(definitionNode)) return true;
+		if (definitionNode && isNodeOfType(definitionNode, "VariableDeclarator")) {
+			const initializer = definitionNode.init;
+			return isFunctionLike$2(initializer);
+		}
+	}
+	if (isNodeOfType(node, "ConditionalExpression")) return isCleanupReturnArgument(analysis, node.consequent) || isCleanupReturnArgument(analysis, node.alternate);
+	return false;
+};
+const hasCleanupReturn = (analysis, node, visited = /* @__PURE__ */ new WeakSet()) => {
+	if (visited.has(node)) return false;
+	visited.add(node);
+	if (isNodeOfType(node, "ReturnStatement") && node.argument != null) return isCleanupReturnArgument(analysis, node.argument);
+	if (!isNodeOfType(node, "BlockStatement") && isFunctionLike$2(node)) return false;
+	const record = node;
+	for (const [key, value] of Object.entries(record)) {
+		if (key === "parent") continue;
+		if (Array.isArray(value)) {
+			if (value.some((item) => isAstNode(item) && hasCleanupReturn(analysis, item, visited))) return true;
+		} else if (isAstNode(value) && hasCleanupReturn(analysis, value, visited)) return true;
+	}
+	return false;
+};
+const hasCleanup = (analysis, node) => {
+	const fn = getEffectFn(analysis, node);
+	if (!isFunctionLike$2(fn)) return false;
+	if (!isNodeOfType(fn.body, "BlockStatement")) return false;
+	return hasCleanupReturn(analysis, fn.body);
+};
+const findContainingNode = (analysis, node) => {
+	if (!node) return null;
+	if (isReactFunctionalComponent(node) || isReactFunctionalHOC(analysis, node) || isCustomHook(node)) return node;
+	const parent = node.parent;
+	return findContainingNode(analysis, parent);
+};
+//#endregion
+//#region src/plugin/rules/state-and-effects/no-adjust-state-on-prop-change.ts
+const noAdjustStateOnPropChange = defineRule({
+	id: "no-adjust-state-on-prop-change",
+	title: "State synced to a prop inside an effect",
+	severity: "error",
+	tags: ["test-noise"],
+	recommendation: "Adjust the state inline during render with a `prev`-prop comparison (`if (prop !== prevProp) { setPrevProp(prop); setX(...); }`), or refactor to remove the duplicated state. Routing the adjustment through a useEffect forces an extra render with a stale UI between the two commits. See https://react.dev/learn/you-might-not-need-an-effect#adjusting-some-state-when-a-prop-changes",
+	create: (context) => ({ CallExpression(node) {
+		if (!isUseEffect(node)) return;
+		const analysis = getProgramAnalysis(node);
+		if (!analysis) return;
+		const effectFnRefs = getEffectFnRefs(analysis, node);
+		const depsRefs = getEffectDepsRefs(analysis, node);
+		if (!effectFnRefs || !depsRefs) return;
+		const effectFn = getEffectFn(analysis, node);
+		if (!effectFn) return;
+		if (!depsRefs.flatMap((ref) => getUpstreamRefs(analysis, ref)).some((ref) => isProp(analysis, ref))) return;
+		for (const ref of effectFnRefs) {
+			if (!isStateSetterCall(analysis, ref)) continue;
+			if (!isSynchronous(ref.identifier, effectFn)) continue;
+			const callExpr = getCallExpr(ref);
+			if (!callExpr) continue;
+			if (getArgsUpstreamRefs(analysis, ref).some((argRef) => isProp(analysis, argRef))) continue;
 			context.report({
-				node: keyAttribute,
-				message: MESSAGE$29
+				node: callExpr,
+				message: "Your users briefly see the wrong value when the prop changes."
 			});
-		},
-		CallExpression(node) {
-			if (!isReactCloneElement(node)) return;
-			if (node.arguments.length < 2 || node.arguments.length > 3) return;
-			const propsArgument = node.arguments[1];
-			if (!isNodeOfType(propsArgument, "ObjectExpression")) return;
-			const indexBinding = findIndexParameterBinding(node);
-			if (!indexBinding) return;
-			for (const property of propsArgument.properties) {
-				if (!isNodeOfType(property, "Property")) continue;
-				if (property.computed) continue;
-				const propKey = property.key;
-				let propName = null;
-				if (isNodeOfType(propKey, "Identifier")) propName = propKey.name;
-				else if (isNodeOfType(propKey, "Literal") && typeof propKey.value === "string") propName = propKey.value;
-				if (propName !== "key") continue;
-				if (expressionUsesIndex(property.value, indexBinding.name)) context.report({
-					node: property,
-					message: MESSAGE$29
-				});
+		}
+	} })
+});
+//#endregion
+//#region src/plugin/rules/a11y/no-aria-hidden-on-focusable.ts
+const MESSAGE$30 = "Screen reader users tab to this focusable element but hear nothing because `aria-hidden` skips it, so remove `aria-hidden` or stop it being focusable.";
+const noAriaHiddenOnFocusable = defineRule({
+	id: "no-aria-hidden-on-focusable",
+	title: "aria-hidden on focusable element",
+	tags: ["react-jsx-only"],
+	severity: "warn",
+	recommendation: "Remove `aria-hidden` from focusable elements, or stop them being focusable.",
+	category: "Accessibility",
+	create: (context) => ({ JSXOpeningElement(node) {
+		const ariaHidden = hasJsxPropIgnoreCase(node.attributes, "aria-hidden");
+		if (!ariaHidden) return;
+		const value = ariaHidden.value;
+		if (value) {
+			if (isNodeOfType(value, "Literal") && value.value !== "true") return;
+			if (isNodeOfType(value, "JSXExpressionContainer")) {
+				const expression = value.expression;
+				if (isNodeOfType(expression, "Literal") && !expression.value) return;
+			}
+		}
+		const tag = getElementType(node, context.settings);
+		const tabIndex = hasJsxPropIgnoreCase(node.attributes, "tabIndex");
+		const tabIndexValue = tabIndex ? parseJsxValue(tabIndex.value ?? null) : null;
+		if (tabIndexValue !== null && tabIndexValue < 0) return;
+		const isExplicitlyFocusable = tabIndexValue !== null && tabIndexValue >= 0;
+		const isImplicitlyFocusable = isInteractiveElement(tag, node);
+		if (isExplicitlyFocusable || isImplicitlyFocusable) context.report({
+			node: ariaHidden,
+			message: MESSAGE$30
+		});
+	} })
+});
+//#endregion
+//#region src/plugin/utils/is-all-literal-array-expression.ts
+/**
+* True when the node is an `ArrayExpression` whose elements are all
+* primitive literals (string / number / boolean). Used by the two
+* "no array-index key" rule variants to detect a `keys={[1, 2, 3]}`
+* style stable-id array.
+*/
+const isAllLiteralArrayExpression = (node) => {
+	if (!isNodeOfType(node, "ArrayExpression")) return false;
+	const elements = node.elements ?? [];
+	if (elements.length < 1) return false;
+	for (const element of elements) {
+		if (!element) return false;
+		if (!isNodeOfType(element, "Literal")) return false;
+		const value = element.value;
+		if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") return false;
+	}
+	return true;
+};
+//#endregion
+//#region src/plugin/utils/jsx-stateless-leaf.ts
+const PURE_SVG_PRIMITIVE_TAGS = new Set([
+	"circle",
+	"ellipse",
+	"g",
+	"line",
+	"path",
+	"polygon",
+	"polyline",
+	"rect",
+	"stop",
+	"text",
+	"tspan",
+	"defs",
+	"use",
+	"mask",
+	"marker",
+	"linearGradient",
+	"radialGradient",
+	"clipPath",
+	"filter",
+	"feGaussianBlur",
+	"feOffset",
+	"feMerge",
+	"feMergeNode",
+	"feColorMatrix",
+	"feFlood",
+	"feComposite",
+	"title",
+	"desc"
+]);
+const STATELESS_HTML_LEAF_TAGS = new Set([
+	"div",
+	"span",
+	"p",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"footer",
+	"section",
+	"article",
+	"aside",
+	"main",
+	"nav",
+	"li",
+	"ul",
+	"ol",
+	"dl",
+	"dt",
+	"dd",
+	"tr",
+	"td",
+	"th",
+	"tbody",
+	"thead",
+	"tfoot",
+	"table",
+	"caption",
+	"colgroup",
+	"col",
+	"strong",
+	"em",
+	"small",
+	"b",
+	"i",
+	"u",
+	"s",
+	"mark",
+	"del",
+	"ins",
+	"sub",
+	"sup",
+	"abbr",
+	"cite",
+	"code",
+	"kbd",
+	"samp",
+	"pre",
+	"blockquote",
+	"q",
+	"br",
+	"hr",
+	"wbr",
+	"img",
+	"picture",
+	"figure",
+	"figcaption",
+	"label",
+	"legend",
+	"fieldset",
+	"address",
+	"time",
+	"data",
+	"var",
+	"ruby",
+	"rt",
+	"rp",
+	"bdi",
+	"bdo"
+]);
+const STATEFUL_HTML_DESCENDANT_TAGS = new Set([
+	"input",
+	"textarea",
+	"select",
+	"option",
+	"optgroup",
+	"button",
+	"form",
+	"output",
+	"progress",
+	"meter",
+	"video",
+	"audio",
+	"source",
+	"track",
+	"iframe",
+	"embed",
+	"object",
+	"a",
+	"details",
+	"summary",
+	"dialog",
+	"canvas"
+]);
+const STATEFUL_DESCENDANT_SCAN_BUDGET = 200;
+const containsStatefulDescendant = (jsxElement) => {
+	let budget = STATEFUL_DESCENDANT_SCAN_BUDGET;
+	const stack = [jsxElement];
+	while (stack.length > 0) {
+		if (budget <= 0) return true;
+		budget -= 1;
+		const node = stack.pop();
+		if (isNodeOfType(node, "JSXElement")) {
+			const name = node.openingElement.name;
+			if (name && isNodeOfType(name, "JSXIdentifier")) {
+				const tagName = name.name;
+				const firstChar = tagName.charCodeAt(0);
+				if (firstChar >= 65 && firstChar <= 90) return true;
+				if (STATEFUL_HTML_DESCENDANT_TAGS.has(tagName)) return true;
 			}
+			if (name && isNodeOfType(name, "JSXMemberExpression")) return true;
+			const children = node.children ?? [];
+			for (const child of children) stack.push(child);
+			continue;
 		}
-	})
-});
-//#endregion
-//#region src/plugin/rules/a11y/no-autofocus.ts
-const MESSAGE$28 = "Screen reader & keyboard users get disoriented because `autoFocus` jumps focus on load, so remove it and let people choose where to focus.";
-const resolveSettings$21 = (settings) => {
-	const reactDoctor = settings?.["react-doctor"];
-	return { ignoreNonDOM: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noAutofocus ?? {} : {}).ignoreNonDOM ?? true };
-};
-const innerExpression = (expression) => {
-	if (expression.type === "ParenthesizedExpression" && "expression" in expression) return innerExpression(expression.expression);
-	return expression;
-};
-const isSameNameIdentifierForward = (attributeName, value) => {
-	if (!value || !isNodeOfType(value, "JSXExpressionContainer")) return false;
-	const expression = innerExpression(value.expression);
-	if (isNodeOfType(expression, "Identifier") && expression.name === attributeName) return true;
-	if (isNodeOfType(expression, "MemberExpression") && !expression.computed && isNodeOfType(expression.property, "Identifier") && expression.property.name === attributeName) return true;
-	return false;
-};
-const isFalseAttributeValue = (value) => {
-	if (isNodeOfType(value, "Literal")) return typeof value.value === "string" ? value.value === "false" : value.value === false;
-	if (isNodeOfType(value, "JSXExpressionContainer")) {
-		const expression = innerExpression(value.expression);
-		if (isNodeOfType(expression, "Literal")) {
-			if (typeof expression.value === "boolean") return !expression.value;
-			if (typeof expression.value === "string") return expression.value === "false";
-			return false;
+		if (isNodeOfType(node, "JSXFragment")) {
+			const children = node.children ?? [];
+			for (const child of children) stack.push(child);
+			continue;
+		}
+		if (isNodeOfType(node, "JSXExpressionContainer")) {
+			const expression = node.expression;
+			if (isNodeOfType(expression, "CallExpression") || isNodeOfType(expression, "Identifier") || isNodeOfType(expression, "MemberExpression")) return true;
+			stack.push(expression);
+			continue;
+		}
+		if (isNodeOfType(node, "ConditionalExpression")) {
+			stack.push(node.consequent, node.alternate);
+			continue;
+		}
+		if (isNodeOfType(node, "LogicalExpression")) {
+			stack.push(node.left, node.right);
+			continue;
 		}
-		if (isNodeOfType(expression, "TemplateLiteral")) return getStaticTemplateLiteralValue(expression) === "false";
 	}
 	return false;
 };
-const noAutofocus = defineRule({
-	id: "no-autofocus",
-	title: "Autofocus on an element",
-	tags: ["react-jsx-only"],
-	severity: "warn",
-	recommendation: "Do not use `autoFocus`. It disorients users on load.",
-	category: "Accessibility",
-	create: (context) => {
-		const settings = resolveSettings$21(context.settings);
-		const isTestlikeFile = isTestlikeFilename(context.filename);
-		return { JSXOpeningElement(node) {
-			if (isTestlikeFile) return;
-			const autoFocusAttribute = node.attributes.find((attribute) => {
-				if (!isNodeOfType(attribute, "JSXAttribute")) return false;
-				const attributeName = attribute.name;
-				return isNodeOfType(attributeName, "JSXIdentifier") && attributeName.name === "autoFocus";
-			});
-			if (!autoFocusAttribute) return;
-			const attributeValue = autoFocusAttribute.value;
-			if (attributeValue && isFalseAttributeValue(attributeValue)) return;
-			if (isSameNameIdentifierForward("autoFocus", attributeValue)) return;
-			if (settings.ignoreNonDOM) {
-				const tag = getElementType(node, context.settings);
-				if (!HTML_TAGS.has(tag)) return;
-			}
-			context.report({
-				node: autoFocusAttribute,
-				message: MESSAGE$28
-			});
-		} };
-	}
-});
 //#endregion
-//#region src/plugin/utils/create-relative-import-source.ts
-const createRelativeImportSource = (filename, targetFilePath) => {
-	const targetPathWithoutExtension = targetFilePath.slice(0, targetFilePath.length - path.extname(targetFilePath).length);
-	const targetModulePath = path.basename(targetPathWithoutExtension) === "index" ? path.dirname(targetPathWithoutExtension) : targetPathWithoutExtension;
-	const relativePath = path.relative(path.dirname(filename), targetModulePath).split(path.sep).join("/");
-	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+//#region src/plugin/rules/correctness/no-array-index-as-key.ts
+const STRING_COERCION_FUNCTIONS = new Set(["String", "Number"]);
+const extractIndexName = (node) => {
+	if (isNodeOfType(node, "Identifier") && INDEX_PARAMETER_NAMES.has(node.name)) return node.name;
+	if (isNodeOfType(node, "TemplateLiteral")) {
+		for (const expression of node.expressions ?? []) if (isNodeOfType(expression, "Identifier") && INDEX_PARAMETER_NAMES.has(expression.name)) return expression.name;
+	}
+	if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "MemberExpression") && isNodeOfType(node.callee.object, "Identifier") && INDEX_PARAMETER_NAMES.has(node.callee.object.name) && isNodeOfType(node.callee.property, "Identifier") && node.callee.property.name === "toString") return node.callee.object.name;
+	if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && STRING_COERCION_FUNCTIONS.has(node.callee.name) && isNodeOfType(node.arguments?.[0], "Identifier") && INDEX_PARAMETER_NAMES.has(node.arguments[0].name)) return node.arguments[0].name;
+	if (isNodeOfType(node, "BinaryExpression") && node.operator === "+" && (isNodeOfType(node.left, "Identifier") && INDEX_PARAMETER_NAMES.has(node.left.name) && isNodeOfType(node.right, "Literal") && node.right.value === "" || isNodeOfType(node.right, "Identifier") && INDEX_PARAMETER_NAMES.has(node.right.name) && isNodeOfType(node.left, "Literal") && node.left.value === "")) {
+		if (isNodeOfType(node.left, "Identifier")) return node.left.name;
+		if (isNodeOfType(node.right, "Identifier")) return node.right.name;
+		return null;
+	}
+	return null;
 };
-//#endregion
-//#region src/plugin/utils/parse-export-specifiers.ts
-const getSpecifierName = (rawName) => rawName.replace(/^type\s+/, "").trim();
-const parseExportSpecifiers = (specifiersText, declarationIsTypeOnly) => specifiersText.split(",").map((specifierText) => specifierText.trim()).filter(Boolean).map((specifierText) => {
-	const isTypeOnly = declarationIsTypeOnly || specifierText.startsWith("type ");
-	const [rawLocalName, rawExportedName] = specifierText.split(/\s+as\s+/);
-	const localName = getSpecifierName(rawLocalName ?? "");
-	return {
-		localName,
-		exportedName: getSpecifierName(rawExportedName ?? localName),
-		isTypeOnly
-	};
-});
-//#endregion
-//#region src/plugin/utils/strip-js-comments.ts
-const BLOCK_COMMENT_PATTERN = /\/\*[\s\S]*?\*\//g;
-const LINE_COMMENT_PATTERN = /^\s*\/\/.*$/gm;
-const stripJsComments = (sourceText) => sourceText.replace(BLOCK_COMMENT_PATTERN, "").replace(LINE_COMMENT_PATTERN, "");
-//#endregion
-//#region src/plugin/utils/is-barrel-index-module.ts
-const INDEX_MODULE_FILE_PATTERN = /^index\.(?:[cm]?[jt]sx?|mjs)$/;
-const BINDING_IMPORT_DECLARATION_PATTERN = /^\s*import\s+(type\s+)?(?!["'])([^;]*?)\s+from\s+["']([^"']+)["']\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
-const BARREL_REEXPORT_DECLARATION_PATTERN = /^\s*export\s+(type\s+)?(?:\*(?:\s+as\s+([\w$]+))?|\{([\s\S]*?)\})\s+from\s+["']([^"']+)["']\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
-const LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN$1 = /^\s*export\s+(type\s+)?\{([\s\S]*?)\}\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
-const barrelIndexModuleInfoCache = /* @__PURE__ */ new Map();
-const isIndexModuleFilePath = (filePath) => INDEX_MODULE_FILE_PATTERN.test(path.basename(filePath));
-const createNonBarrelInfo = () => ({
-	isBarrel: false,
-	exportsByName: /* @__PURE__ */ new Map(),
-	starExportSources: []
-});
-const addImportedBinding = (importedBindings, binding) => {
-	importedBindings.set(binding.localName, {
-		...binding,
-		didExport: false
-	});
+const isNumericLiteralOrUndefined = (node) => {
+	if (!node) return false;
+	if (isNodeOfType(node, "Literal") && typeof node.value === "number") return true;
+	if (isNodeOfType(node, "Identifier") && node.name === "undefined") return true;
+	return false;
 };
-const collectNamedImportBindings = (namedSpecifiersText, source, declarationIsTypeOnly, importedBindings) => {
-	for (const specifier of parseExportSpecifiers(namedSpecifiersText, declarationIsTypeOnly)) addImportedBinding(importedBindings, {
-		localName: specifier.exportedName,
-		importedName: specifier.localName,
-		source,
-		isTypeOnly: specifier.isTypeOnly
-	});
+const isArrayConstructorCallWithNumericLength = (node) => {
+	if (!node) return false;
+	if (isNodeOfType(node, "CallExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "Array" && isNumericLiteralOrUndefined(node.arguments?.[0])) return true;
+	if (isNodeOfType(node, "NewExpression") && isNodeOfType(node.callee, "Identifier") && node.callee.name === "Array" && isNumericLiteralOrUndefined(node.arguments?.[0])) return true;
+	return false;
 };
-const collectImportBindings = (importClause, source, declarationIsTypeOnly, importedBindings) => {
-	const trimmedImportClause = importClause.trim();
-	const namespaceMatch = trimmedImportClause.match(/(?:^|,\s*)\*\s+as\s+([\w$]+)/);
-	if (namespaceMatch?.[1]) addImportedBinding(importedBindings, {
-		localName: namespaceMatch[1],
-		importedName: "*",
-		source,
-		isTypeOnly: declarationIsTypeOnly
-	});
-	const namedImportMatch = trimmedImportClause.match(/\{([\s\S]*?)\}/);
-	if (namedImportMatch?.[1]) collectNamedImportBindings(namedImportMatch[1], source, declarationIsTypeOnly, importedBindings);
-	const defaultImportName = trimmedImportClause.split(",")[0]?.trim();
-	if (defaultImportName && !defaultImportName.startsWith("{") && !defaultImportName.startsWith("*")) addImportedBinding(importedBindings, {
-		localName: defaultImportName,
-		importedName: "default",
-		source,
-		isTypeOnly: declarationIsTypeOnly
-	});
+const isArrayFromCall = (node) => {
+	if (!node) return false;
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const callee = node.callee;
+	return Boolean(isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "from");
 };
-const replaceKnownDeclarations = (sourceText, importedBindings, exportsByName, starExportSources) => {
-	let withoutKnownDeclarations = sourceText.replace(BINDING_IMPORT_DECLARATION_PATTERN, (_match, typeKeyword, importClause, source) => {
-		collectImportBindings(importClause, source, Boolean(typeKeyword), importedBindings);
-		return "";
-	});
-	withoutKnownDeclarations = withoutKnownDeclarations.replace(BARREL_REEXPORT_DECLARATION_PATTERN, (_match, typeKeyword, namespaceExportName, specifiersText, source) => {
-		const isTypeOnly = Boolean(typeKeyword);
-		if (namespaceExportName) {
-			exportsByName.set(namespaceExportName, {
-				exportedName: namespaceExportName,
-				importedName: "*",
-				source,
-				isTypeOnly
-			});
-			return "";
-		}
-		if (specifiersText) {
-			for (const specifier of parseExportSpecifiers(specifiersText, isTypeOnly)) exportsByName.set(specifier.exportedName, {
-				exportedName: specifier.exportedName,
-				importedName: specifier.localName,
-				source,
-				isTypeOnly: specifier.isTypeOnly
-			});
-			return "";
-		}
-		starExportSources.push(source);
-		return "";
-	});
-	withoutKnownDeclarations = withoutKnownDeclarations.replace(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN$1, (_match, typeKeyword, specifiersText) => {
-		for (const specifier of parseExportSpecifiers(specifiersText, Boolean(typeKeyword))) {
-			const importedBinding = importedBindings.get(specifier.localName);
-			if (!importedBinding) return _match;
-			importedBinding.didExport = true;
-			exportsByName.set(specifier.exportedName, {
-				exportedName: specifier.exportedName,
-				importedName: importedBinding.importedName,
-				source: importedBinding.source,
-				isTypeOnly: specifier.isTypeOnly || importedBinding.isTypeOnly
-			});
+/**
+* True if every element of an ArrayExpression is a primitive constant
+* (number/string/boolean literal) — `[1, 2, 3]`, `['a', 'b']`. Such arrays
+* have a fixed order at every render, so an index key is stable.
+*/
+/**
+* True if the call expression looks like a placeholder constructor whose
+* elements have no identity beyond their position — i.e. `Array.from(...)`,
+* `Array(N)`, `new Array(N)`, `Array(N).fill(...)`, `[...Array(N)]`, or
+* a literal-only array `[1, 2, 3]` / `['a', 'b']`.
+*
+* Used both for `<receiver>.map(...)` and for `Array.from(<length>, fn)`.
+*/
+const isStaticPlaceholderReceiver = (receiver) => {
+	if (isArrayFromCall(receiver)) return true;
+	if (isArrayConstructorCallWithNumericLength(receiver)) return true;
+	if (isAllLiteralArrayExpression(receiver)) return true;
+	if (isNodeOfType(receiver, "CallExpression")) {
+		const callee = receiver.callee;
+		if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "fill" && isArrayConstructorCallWithNumericLength(callee.object)) return true;
+	}
+	if (isNodeOfType(receiver, "ArrayExpression") && receiver.elements?.length === 1) {
+		const only = receiver.elements[0];
+		if (only && isNodeOfType(only, "SpreadElement")) {
+			const arg = only.argument;
+			if (isArrayConstructorCallWithNumericLength(arg)) return true;
+			if (isArrayFromCall(arg)) return true;
 		}
-		return "";
-	});
-	return withoutKnownDeclarations;
+	}
+	return false;
 };
-const hasUnexportedRuntimeImport = (importedBindings) => {
-	for (const binding of importedBindings.values()) if (!binding.isTypeOnly && !binding.didExport) return true;
+const isArrayFromLengthObjectCall = (node) => {
+	if (!isArrayFromCall(node)) return false;
+	if (!isNodeOfType(node, "CallExpression")) return false;
+	const first = node.arguments?.[0];
+	if (!first || !isNodeOfType(first, "ObjectExpression")) return false;
+	for (const prop of first.properties ?? []) {
+		if (!isNodeOfType(prop, "Property")) continue;
+		const key = prop.key;
+		if (!(isNodeOfType(key, "Identifier") && key.name === "length" || isNodeOfType(key, "Literal") && key.value === "length")) continue;
+		if (isNumericLiteralOrUndefined(prop.value)) return true;
+		if (isNodeOfType(prop.value, "Identifier")) return true;
+	}
 	return false;
 };
-const classifyBarrelModule = (sourceText) => {
-	const strippedSource = stripJsComments(sourceText).trim();
-	if (!strippedSource) return createNonBarrelInfo();
-	const importedBindings = /* @__PURE__ */ new Map();
-	const exportsByName = /* @__PURE__ */ new Map();
-	const starExportSources = [];
-	if (replaceKnownDeclarations(strippedSource, importedBindings, exportsByName, starExportSources).trim() || hasUnexportedRuntimeImport(importedBindings)) return createNonBarrelInfo();
-	return {
-		isBarrel: exportsByName.size > 0 || starExportSources.length > 0,
-		exportsByName,
-		starExportSources
-	};
+const isInsideStaticPlaceholderMap = (node) => {
+	let current = node;
+	while (current.parent) {
+		const parent = current.parent;
+		if (isFunctionLike$2(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
+			const callee = parent.callee;
+			if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && (callee.property.name === "map" || callee.property.name === "flatMap" || callee.property.name === "forEach")) return isStaticPlaceholderReceiver(callee.object);
+			if (isArrayFromCall(parent) && parent.arguments.length >= 2 && parent.arguments[1] === current) return isArrayFromLengthObjectCall(parent);
+		}
+		current = parent;
+	}
+	return false;
 };
-const getBarrelIndexModuleInfo = (filePath) => {
-	if (!isIndexModuleFilePath(filePath)) return createNonBarrelInfo();
-	const cachedResult = barrelIndexModuleInfoCache.get(filePath);
-	if (cachedResult !== void 0) return cachedResult;
-	let moduleInfo = createNonBarrelInfo();
-	try {
-		moduleInfo = classifyBarrelModule(fs.readFileSync(filePath, "utf8"));
-	} catch {
-		moduleInfo = createNonBarrelInfo();
+/**
+* Walk up from a JSXAttribute node looking for the enclosing iterator
+* callback (`.map(cb)`, `.flatMap(cb)`, `.forEach(cb)`, `Array.from(_, cb)`)
+* and return the first parameter's name. The first param is the per-item
+* value, e.g. `item` in `arr.map((item, index) => …)`.
+*/
+const findIteratorItemName$1 = (node) => {
+	let current = node;
+	while (current.parent) {
+		const parent = current.parent;
+		if (isFunctionLike$2(current) && isNodeOfType(parent, "CallExpression") && parent.arguments.includes(current)) {
+			const callee = parent.callee;
+			const isIteratorMethodCall = isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && (callee.property.name === "map" || callee.property.name === "flatMap" || callee.property.name === "forEach");
+			const isArrayFromCallback = isArrayFromCall(parent) && parent.arguments.length >= 2 && parent.arguments[1] === current;
+			if (isIteratorMethodCall || isArrayFromCallback) {
+				const first = (current.params ?? [])[0];
+				if (first && isNodeOfType(first, "Identifier")) return first.name;
+				return null;
+			}
+		}
+		current = parent;
 	}
-	barrelIndexModuleInfoCache.set(filePath, moduleInfo);
-	return moduleInfo;
+	return null;
 };
-const isBarrelIndexModule = (filePath) => getBarrelIndexModuleInfo(filePath).isBarrel;
+const templateLiteralHasIteratorIdentity = (template, itemName) => {
+	for (const expression of template.expressions ?? []) {
+		if (isNodeOfType(expression, "Identifier") && expression.name === itemName) return true;
+		if (isNodeOfType(expression, "MemberExpression") && isNodeOfType(expression.object, "Identifier") && expression.object.name === itemName) return true;
+	}
+	return false;
+};
+/**
+* True when the JSX key value is a template literal mixing an index with at
+* least one stable per-item identifier (e.g. `${item.id}-${index}`). Common
+* defensive pattern in user code — the index is just a uniqueness fallback,
+* the real identity is `item.id`.
+*/
+const isCompositeKeyWithIteratorIdentity = (keyExpression, attributeNode) => {
+	if (!isNodeOfType(keyExpression, "TemplateLiteral")) return false;
+	if ((keyExpression.expressions ?? []).length < 2) return false;
+	const itemName = findIteratorItemName$1(attributeNode);
+	if (!itemName) return false;
+	return templateLiteralHasIteratorIdentity(keyExpression, itemName);
+};
+const noArrayIndexAsKey = defineRule({
+	id: "no-array-index-as-key",
+	title: "Array index used as a key",
+	severity: "warn",
+	recommendation: "Use a stable id from the item, like `key={item.id}` or `key={item.slug}`. Index keys break when the list reorders or filters.",
+	create: (context) => ({ JSXAttribute(node) {
+		if (!isNodeOfType(node.name, "JSXIdentifier") || node.name.name !== "key") return;
+		if (!node.value || !isNodeOfType(node.value, "JSXExpressionContainer")) return;
+		const indexName = extractIndexName(node.value.expression);
+		if (!indexName) return;
+		if (isInsideStaticPlaceholderMap(node)) return;
+		if (isCompositeKeyWithIteratorIdentity(node.value.expression, node)) return;
+		const openingElement = node.parent;
+		if (openingElement && isNodeOfType(openingElement, "JSXOpeningElement")) {
+			const elementName = openingElement.name;
+			if (isNodeOfType(elementName, "JSXIdentifier")) {
+				if (elementName.name === "Fragment") return;
+				if (PURE_SVG_PRIMITIVE_TAGS.has(elementName.name)) return;
+				if (STATELESS_HTML_LEAF_TAGS.has(elementName.name)) {
+					const jsxElement = openingElement.parent;
+					if (jsxElement && isNodeOfType(jsxElement, "JSXElement")) {
+						if (!containsStatefulDescendant(jsxElement)) return;
+					}
+				}
+			}
+			if (isNodeOfType(elementName, "JSXMemberExpression") && isNodeOfType(elementName.object, "JSXIdentifier") && isNodeOfType(elementName.property, "JSXIdentifier") && elementName.object.name === "React" && elementName.property.name === "Fragment") return;
+		}
+		context.report({
+			node,
+			message: `Your users can see & submit the wrong data when this list reorders or filters, so use a stable id like \`key={item.id}\`, not the array index "${indexName}".`
+		});
+	} })
+});
 //#endregion
-//#region src/plugin/utils/does-module-export-name.ts
-const DEFAULT_EXPORT_DECLARATION_PATTERN = /^\s*export\s+default\b/m;
-const NAMED_EXPORT_DECLARATION_PATTERN = /^\s*export\s+(?:declare\s+)?(?:(?:async\s+)?function|(?:abstract\s+)?class|const|let|var|enum|interface|type)\s+([\w$]+)/gm;
-const LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN = /^\s*export\s+(?:type\s+)?\{([\s\S]*?)\}(?:\s+from\s+["'][^"']+["'])?\s*;?\s*(?:(?:\/\/[^\n]*)?\s*)/gm;
-const doesSourceTextExportName = (sourceText, exportedName) => {
-	const strippedSource = stripJsComments(sourceText);
-	if (exportedName === "default" && DEFAULT_EXPORT_DECLARATION_PATTERN.test(strippedSource)) return true;
-	for (const match of strippedSource.matchAll(NAMED_EXPORT_DECLARATION_PATTERN)) if (match[1] === exportedName) return true;
-	for (const match of strippedSource.matchAll(LOCAL_EXPORT_SPECIFIER_DECLARATION_PATTERN)) if (parseExportSpecifiers(match[1] ?? "", false).map((specifier) => specifier.exportedName).includes(exportedName)) return true;
+//#region src/plugin/rules/react-builtins/no-array-index-key.ts
+const MESSAGE$29 = "Your users can see & submit the wrong data when this list reorders.";
+const SECOND_INDEX_METHODS = new Set([
+	"every",
+	"filter",
+	"find",
+	"findIndex",
+	"flatMap",
+	"forEach",
+	"map",
+	"some"
+]);
+const THIRD_INDEX_METHODS = new Set(["reduce", "reduceRight"]);
+const isPositionallyStableIterationReceiver = (receiver) => {
+	if (isAllLiteralArrayExpression(receiver)) return true;
+	if (isNodeOfType(receiver, "ArrayExpression") && receiver.elements?.length === 1) {
+		const only = receiver.elements[0];
+		if (only && isNodeOfType(only, "SpreadElement")) {
+			const arg = only.argument;
+			if (arg && isPositionallyStableIterationReceiver(arg)) return true;
+		}
+	}
+	if (!isNodeOfType(receiver, "CallExpression")) return false;
+	const callee = receiver.callee;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "from" && receiver.arguments.length >= 1 && isNodeOfType(receiver.arguments[0], "ObjectExpression")) return true;
+	if (isNodeOfType(callee, "Identifier") && callee.name === "Array") return true;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && callee.property.name === "split") return true;
+	if (isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier") && (callee.property.name === "fill" || callee.property.name === "flat")) return isPositionallyStableIterationReceiver(callee.object);
 	return false;
 };
-const doesModuleExportName = (filePath, exportedName) => {
-	try {
-		return doesSourceTextExportName(fs.readFileSync(filePath, "utf8"), exportedName);
-	} catch {
+const templateHasIteratorMember = (templateLiteral, iteratorName) => {
+	for (const expression of templateLiteral.expressions ?? []) {
+		if (isNodeOfType(expression, "Identifier") && expression.name === iteratorName) return true;
+		if (isNodeOfType(expression, "MemberExpression") && isNodeOfType(expression.object, "Identifier") && expression.object.name === iteratorName) return true;
+	}
+	return false;
+};
+const isArrayFromMapperCallback = (parentCall, callback) => {
+	if (parentCall.arguments[1] !== callback) return false;
+	const callee = parentCall.callee;
+	return isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.object, "Identifier") && callee.object.name === "Array" && isNodeOfType(callee.property, "Identifier") && callee.property.name === "from";
+};
+const isArrayFromSourcePositionallyStable = (source) => {
+	if (isNodeOfType(source, "ObjectExpression")) {
+		for (const property of source.properties ?? []) {
+			if (!isNodeOfType(property, "Property")) continue;
+			const key = property.key;
+			if (isNodeOfType(key, "Identifier") && key.name === "length" || isNodeOfType(key, "Literal") && key.value === "length") return true;
+		}
 		return false;
 	}
+	return isPositionallyStableIterationReceiver(source);
 };
-//#endregion
-//#region src/plugin/utils/resolve-relative-import-path.ts
-const MODULE_FILE_EXTENSIONS = [
-	".ts",
-	".tsx",
-	".js",
-	".jsx",
-	".mjs",
-	".cjs",
-	".mts",
-	".cts"
-];
-const PACKAGE_EXPORT_CONDITIONS = [
-	"import",
-	"default",
-	"module",
-	"browser",
-	"require"
-];
-const PACKAGE_ENTRY_FIELDS = [
-	"module",
-	"main",
-	"browser"
-];
-const getExistingFilePath = (filePath) => {
-	try {
-		return fs.statSync(filePath).isFile() ? filePath : null;
-	} catch {
-		return null;
+const findIteratorItemName = (node) => {
+	let current = node;
+	while (current) {
+		if (isNodeOfType(current, "ArrowFunctionExpression") || isNodeOfType(current, "FunctionExpression")) {
+			const parent = current.parent;
+			const callbackItemName = readIteratorItemFromCallback(current, parent);
+			if (callbackItemName !== void 0) return callbackItemName;
+			if (current.params.length > 0) return null;
+		}
+		current = current.parent ?? null;
+	}
+	return null;
+};
+const readIteratorItemFromCallback = (callback, parent) => {
+	if (!parent || !isNodeOfType(parent, "CallExpression")) return void 0;
+	const callee = parent.callee;
+	if (parent.arguments[0] === callback && isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
+		const methodName = callee.property.name;
+		if (SECOND_INDEX_METHODS.has(methodName)) {
+			const item = callback.params[0];
+			return item && isNodeOfType(item, "Identifier") ? item.name : null;
+		}
+		if (THIRD_INDEX_METHODS.has(methodName)) {
+			const item = callback.params[1];
+			return item && isNodeOfType(item, "Identifier") ? item.name : null;
+		}
+	}
+	if (isArrayFromMapperCallback(parent, callback)) {
+		const item = callback.params[0];
+		return item && isNodeOfType(item, "Identifier") ? item.name : null;
 	}
 };
-const getExistingDirectoryPath = (directoryPath) => {
-	try {
-		return fs.statSync(directoryPath).isDirectory() ? directoryPath : null;
-	} catch {
-		return null;
+const findIndexParameterBinding = (node) => {
+	let current = node.parent;
+	while (current) {
+		if (isNodeOfType(current, "ArrowFunctionExpression") || isNodeOfType(current, "FunctionExpression")) {
+			const indexParam = readIteratorIndexFromCallback(current, current.parent);
+			if (indexParam !== void 0) return indexParam;
+			if (current.params.length > 0) return null;
+		}
+		current = current.parent ?? null;
 	}
+	return null;
 };
-const getModuleFilePathCandidates = (modulePath) => {
-	const extension = path.extname(modulePath);
-	if (!extension) return MODULE_FILE_EXTENSIONS.map((moduleExtension) => `${modulePath}${moduleExtension}`);
-	const modulePathWithoutExtension = modulePath.slice(0, -extension.length);
-	if (extension === ".js") return [
-		modulePath,
-		`${modulePathWithoutExtension}.ts`,
-		`${modulePathWithoutExtension}.tsx`,
-		`${modulePathWithoutExtension}.jsx`
-	];
-	if (extension === ".jsx") return [modulePath, `${modulePathWithoutExtension}.tsx`];
-	if (extension === ".mjs") return [modulePath, `${modulePathWithoutExtension}.mts`];
-	if (extension === ".cjs") return [modulePath, `${modulePathWithoutExtension}.cts`];
-	return [modulePath];
-};
-const isObjectRecord = (value) => typeof value === "object" && value !== null;
-const getConditionalExportEntry = (exportEntry) => {
-	if (typeof exportEntry === "string") return exportEntry;
-	if (Array.isArray(exportEntry)) {
-		for (const fallbackEntry of exportEntry) {
-			const resolvedFallbackEntry = getConditionalExportEntry(fallbackEntry);
-			if (resolvedFallbackEntry) return resolvedFallbackEntry;
+const readIteratorIndexFromCallback = (callback, parent) => {
+	if (!parent || !isNodeOfType(parent, "CallExpression")) return void 0;
+	const callee = parent.callee;
+	if (parent.arguments[0] === callback && isNodeOfType(callee, "MemberExpression") && isNodeOfType(callee.property, "Identifier")) {
+		const methodName = callee.property.name;
+		let indexParamPosition = null;
+		if (SECOND_INDEX_METHODS.has(methodName)) indexParamPosition = 1;
+		else if (THIRD_INDEX_METHODS.has(methodName)) indexParamPosition = 2;
+		if (indexParamPosition !== null) {
+			const receiver = callee.object;
+			if (isPositionallyStableIterationReceiver(receiver)) return null;
+			const indexParam = callback.params[indexParamPosition];
+			return indexParam && isNodeOfType(indexParam, "Identifier") ? indexParam : null;
 		}
-		return null;
 	}
-	if (!isObjectRecord(exportEntry)) return null;
-	for (const condition of PACKAGE_EXPORT_CONDITIONS) {
-		const nestedEntry = getConditionalExportEntry(exportEntry[condition]);
-		if (nestedEntry) return nestedEntry;
+	if (isArrayFromMapperCallback(parent, callback)) {
+		const source = parent.arguments[0];
+		if (source && isArrayFromSourcePositionallyStable(source)) return null;
+		const indexParam = callback.params[1];
+		return indexParam && isNodeOfType(indexParam, "Identifier") ? indexParam : null;
 	}
-	return null;
-};
-const getPackageExportEntry = (packageJson) => {
-	const exportsField = packageJson.exports;
-	if (!exportsField) return null;
-	const directExportEntry = getConditionalExportEntry(exportsField);
-	if (directExportEntry) return directExportEntry;
-	if (!isObjectRecord(exportsField)) return null;
-	return getConditionalExportEntry(exportsField["."]);
-};
-const resolveModulePathWithIndexFallback = (modulePath) => {
-	const filePath = resolveModuleFilePath(modulePath);
-	if (filePath) return filePath;
-	return resolveModuleFilePath(path.join(modulePath, "index"));
 };
-const resolvePackageDirectoryEntry = (directoryPath) => {
-	const existingDirectoryPath = getExistingDirectoryPath(directoryPath);
-	if (!existingDirectoryPath) return null;
-	const packageJsonPath = path.join(existingDirectoryPath, "package.json");
-	try {
-		const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-		const packageEntry = getPackageExportEntry(packageJson) ?? PACKAGE_ENTRY_FIELDS.map((fieldName) => packageJson[fieldName]).find((value) => typeof value === "string");
-		if (!packageEntry) return null;
-		return resolveModulePathWithIndexFallback(path.resolve(existingDirectoryPath, packageEntry));
-	} catch {
-		return null;
+const isIndexReference = (expression, paramName) => isNodeOfType(expression, "Identifier") && expression.name === paramName;
+const expressionUsesIndex = (expression, paramName) => {
+	if (isIndexReference(expression, paramName)) return true;
+	if (isNodeOfType(expression, "TemplateLiteral")) return expression.expressions.some((innerExpression) => isIndexReference(innerExpression, paramName));
+	if (isNodeOfType(expression, "BinaryExpression")) {
+		const usesInLeft = isIndexReference(expression.left, paramName);
+		const usesInRight = isIndexReference(expression.right, paramName);
+		if (usesInLeft || usesInRight) return true;
+		if (isNodeOfType(expression.left, "BinaryExpression") && expressionUsesIndex(expression.left, paramName)) return true;
+		if (isNodeOfType(expression.right, "BinaryExpression") && expressionUsesIndex(expression.right, paramName)) return true;
+		return false;
 	}
-};
-const resolveModuleFilePath = (modulePath) => {
-	const exactFilePath = getExistingFilePath(modulePath);
-	if (exactFilePath) return exactFilePath;
-	for (const candidateFilePath of getModuleFilePathCandidates(modulePath)) {
-		const filePath = getExistingFilePath(candidateFilePath);
-		if (filePath) return filePath;
+	if (isNodeOfType(expression, "CallExpression")) {
+		if (isNodeOfType(expression.callee, "MemberExpression") && isNodeOfType(expression.callee.property, "Identifier") && expression.callee.property.name === "toString" && isIndexReference(expression.callee.object, paramName)) return true;
+		if (isNodeOfType(expression.callee, "Identifier") && expression.callee.name === "String" && expression.arguments.length > 0 && isIndexReference(expression.arguments[0], paramName)) return true;
 	}
-	return null;
+	return false;
 };
-const resolveRelativeImportPath = (filename, source) => {
-	const importPath = path.resolve(path.dirname(filename), source);
-	const directFilePath = resolveModuleFilePath(importPath);
-	if (directFilePath) return directFilePath;
-	const packageEntryFilePath = resolvePackageDirectoryEntry(importPath);
-	if (packageEntryFilePath) return packageEntryFilePath;
-	return resolveModuleFilePath(path.join(importPath, "index"));
+const isReactCloneElement = (callExpression) => {
+	const callee = callExpression.callee;
+	if (!isNodeOfType(callee, "MemberExpression")) return false;
+	if (!isNodeOfType(callee.property, "Identifier")) return false;
+	if (callee.property.name !== "cloneElement") return false;
+	return isNodeOfType(callee.object, "Identifier") && callee.object.name === "React";
 };
+const isPureSvgPrimitiveJsxName = (jsxOpeningName) => isNodeOfType(jsxOpeningName, "JSXIdentifier") && PURE_SVG_PRIMITIVE_TAGS.has(jsxOpeningName.name);
+const isStatelessLeafJsxName = (jsxOpeningName) => isNodeOfType(jsxOpeningName, "JSXIdentifier") && STATELESS_HTML_LEAF_TAGS.has(jsxOpeningName.name);
+const isFragmentJsxName = (jsxOpeningName) => {
+	if (isNodeOfType(jsxOpeningName, "JSXIdentifier")) return jsxOpeningName.name === "Fragment";
+	if (isNodeOfType(jsxOpeningName, "JSXMemberExpression") && isNodeOfType(jsxOpeningName.object, "JSXIdentifier") && isNodeOfType(jsxOpeningName.property, "JSXIdentifier") && jsxOpeningName.object.name === "React" && jsxOpeningName.property.name === "Fragment") return true;
+	return false;
+};
+const noArrayIndexKey = defineRule({
+	id: "no-array-index-key",
+	title: "Array index used as a key",
+	severity: "warn",
+	defaultEnabled: false,
+	recommendation: "Use a stable `key` from your data instead of the array index.",
+	category: "Performance",
+	create: (context) => ({
+		JSXOpeningElement(node) {
+			const keyAttribute = hasJsxPropIgnoreCase(node.attributes, "key");
+			if (!keyAttribute) return;
+			if (!keyAttribute.value || !isNodeOfType(keyAttribute.value, "JSXExpressionContainer")) return;
+			const expression = keyAttribute.value.expression;
+			if (expression.type === "JSXEmptyExpression") return;
+			if (isFragmentJsxName(node.name)) return;
+			if (isPureSvgPrimitiveJsxName(node.name)) return;
+			const indexBinding = findIndexParameterBinding(node);
+			if (!indexBinding) return;
+			if (!expressionUsesIndex(expression, indexBinding.name)) return;
+			if (isNodeOfType(expression, "TemplateLiteral")) {
+				const itemName = findIteratorItemName(node);
+				if (itemName && templateHasIteratorMember(expression, itemName)) return;
+				const interpolations = expression.expressions ?? [];
+				let interpolationsBeyondIndex = 0;
+				for (const interpolation of interpolations) {
+					if (isIndexReference(interpolation, indexBinding.name)) continue;
+					interpolationsBeyondIndex += 1;
+					if (interpolationsBeyondIndex >= 1) break;
+				}
+				if (interpolationsBeyondIndex >= 1) return;
+			}
+			if (isNodeOfType(expression, "BinaryExpression") && expression.operator === "+") {
+				let interpolationsBeyondIndex = 0;
+				const walkOperand = (operand) => {
+					if (isNodeOfType(operand, "BinaryExpression") && operand.operator === "+") {
+						walkOperand(operand.left);
+						walkOperand(operand.right);
+						return;
+					}
+					if (isIndexReference(operand, indexBinding.name)) return;
+					if (isNodeOfType(operand, "Literal") && typeof operand.value === "string") return;
+					interpolationsBeyondIndex += 1;
+				};
+				walkOperand(expression);
+				if (interpolationsBeyondIndex >= 1) return;
+			}
+			if (isStatelessLeafJsxName(node.name)) {
+				const jsxElement = node.parent;
+				if (jsxElement && isNodeOfType(jsxElement, "JSXElement")) {
+					if (!containsStatefulDescendant(jsxElement)) return;
+				}
+			}
+			context.report({
+				node: keyAttribute,
+				message: MESSAGE$29
+			});
+		},
+		CallExpression(node) {
+			if (!isReactCloneElement(node)) return;
+			if (node.arguments.length < 2 || node.arguments.length > 3) return;
+			const propsArgument = node.arguments[1];
+			if (!isNodeOfType(propsArgument, "ObjectExpression")) return;
+			const indexBinding = findIndexParameterBinding(node);
+			if (!indexBinding) return;
+			for (const property of propsArgument.properties) {
+				if (!isNodeOfType(property, "Property")) continue;
+				if (property.computed) continue;
+				const propKey = property.key;
+				let propName = null;
+				if (isNodeOfType(propKey, "Identifier")) propName = propKey.name;
+				else if (isNodeOfType(propKey, "Literal") && typeof propKey.value === "string") propName = propKey.value;
+				if (propName !== "key") continue;
+				if (expressionUsesIndex(property.value, indexBinding.name)) context.report({
+					node: property,
+					message: MESSAGE$29
+				});
+			}
+		}
+	})
+});
 //#endregion
-//#region src/plugin/utils/resolve-barrel-export-file-path.ts
-const getUniqueFilePath = (filePaths) => {
-	const uniqueFilePaths = new Set(filePaths);
-	if (uniqueFilePaths.size !== 1) return null;
-	const [filePath] = uniqueFilePaths;
-	return filePath ?? null;
+//#region src/plugin/rules/a11y/no-autofocus.ts
+const MESSAGE$28 = "Screen reader & keyboard users get disoriented because `autoFocus` jumps focus on load, so remove it and let people choose where to focus.";
+const resolveSettings$21 = (settings) => {
+	const reactDoctor = settings?.["react-doctor"];
+	return { ignoreNonDOM: (typeof reactDoctor === "object" && reactDoctor !== null ? reactDoctor.noAutofocus ?? {} : {}).ignoreNonDOM ?? true };
 };
-const resolveStarExportFilePath = (barrelFilePath, exportedName, source, visitedFilePaths) => {
-	const resolvedTargetPath = resolveRelativeImportPath(barrelFilePath, source);
-	if (!resolvedTargetPath) return null;
-	const nestedTargetPath = resolveBarrelExportFilePath(resolvedTargetPath, exportedName, new Set(visitedFilePaths));
-	if (nestedTargetPath) return nestedTargetPath;
-	return doesModuleExportName(resolvedTargetPath, exportedName) ? resolvedTargetPath : null;
+const innerExpression = (expression) => {
+	if (expression.type === "ParenthesizedExpression" && "expression" in expression) return innerExpression(expression.expression);
+	return expression;
 };
-const resolveBarrelExportFilePath = (barrelFilePath, exportedName, visitedFilePaths = /* @__PURE__ */ new Set()) => {
-	if (visitedFilePaths.has(barrelFilePath)) return null;
-	visitedFilePaths.add(barrelFilePath);
-	const moduleInfo = getBarrelIndexModuleInfo(barrelFilePath);
-	if (!moduleInfo.isBarrel) return null;
-	const target = moduleInfo.exportsByName.get(exportedName);
-	if (target) {
-		const resolvedTargetPath = resolveRelativeImportPath(barrelFilePath, target.source);
-		if (!resolvedTargetPath) return null;
-		return resolveBarrelExportFilePath(resolvedTargetPath, target.importedName, visitedFilePaths) ?? resolvedTargetPath;
+const isSameNameIdentifierForward = (attributeName, value) => {
+	if (!value || !isNodeOfType(value, "JSXExpressionContainer")) return false;
+	const expression = innerExpression(value.expression);
+	if (isNodeOfType(expression, "Identifier") && expression.name === attributeName) return true;
+	if (isNodeOfType(expression, "MemberExpression") && !expression.computed && isNodeOfType(expression.property, "Identifier") && expression.property.name === attributeName) return true;
+	return false;
+};
+const isFalseAttributeValue = (value) => {
+	if (isNodeOfType(value, "Literal")) return typeof value.value === "string" ? value.value === "false" : value.value === false;
+	if (isNodeOfType(value, "JSXExpressionContainer")) {
+		const expression = innerExpression(value.expression);
+		if (isNodeOfType(expression, "Literal")) {
+			if (typeof expression.value === "boolean") return !expression.value;
+			if (typeof expression.value === "string") return expression.value === "false";
+			return false;
+		}
+		if (isNodeOfType(expression, "TemplateLiteral")) return getStaticTemplateLiteralValue(expression) === "false";
+	}
+	return false;
+};
+const noAutofocus = defineRule({
+	id: "no-autofocus",
+	title: "Autofocus on an element",
+	tags: ["react-jsx-only"],
+	severity: "warn",
+	recommendation: "Do not use `autoFocus`. It disorients users on load.",
+	category: "Accessibility",
+	create: (context) => {
+		const settings = resolveSettings$21(context.settings);
+		const isTestlikeFile = isTestlikeFilename(context.filename);
+		return { JSXOpeningElement(node) {
+			if (isTestlikeFile) return;
+			const autoFocusAttribute = node.attributes.find((attribute) => {
+				if (!isNodeOfType(attribute, "JSXAttribute")) return false;
+				const attributeName = attribute.name;
+				return isNodeOfType(attributeName, "JSXIdentifier") && attributeName.name === "autoFocus";
+			});
+			if (!autoFocusAttribute) return;
+			const attributeValue = autoFocusAttribute.value;
+			if (attributeValue && isFalseAttributeValue(attributeValue)) return;
+			if (isSameNameIdentifierForward("autoFocus", attributeValue)) return;
+			if (settings.ignoreNonDOM) {
+				const tag = getElementType(node, context.settings);
+				if (!HTML_TAGS.has(tag)) return;
+			}
+			context.report({
+				node: autoFocusAttribute,
+				message: MESSAGE$28
+			});
+		} };
 	}
-	if (exportedName === "default") return null;
-	return getUniqueFilePath(moduleInfo.starExportSources.map((source) => resolveStarExportFilePath(barrelFilePath, exportedName, source, visitedFilePaths)).filter((filePath) => Boolean(filePath)));
+});
+//#endregion
+//#region src/plugin/utils/create-relative-import-source.ts
+const createRelativeImportSource = (filename, targetFilePath) => {
+	const targetPathWithoutExtension = targetFilePath.slice(0, targetFilePath.length - path.extname(targetFilePath).length);
+	const targetModulePath = path.basename(targetPathWithoutExtension) === "index" ? path.dirname(targetPathWithoutExtension) : targetPathWithoutExtension;
+	const relativePath = path.relative(path.dirname(filename), targetModulePath).split(path.sep).join("/");
+	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
 };
 //#endregion
 //#region src/plugin/rules/bundle-size/no-barrel-import.ts
@@ -19279,224 +19778,7 @@ const isLodashMutatorCall = (callExpression) => {
 	return false;
 };
 //#endregion
-//#region src/plugin/utils/find-exported-function-body.ts
-const isFunctionLike = (node) => {
-	if (!node) return false;
-	return isNodeOfType(node, "FunctionDeclaration") || isNodeOfType(node, "FunctionExpression") || isNodeOfType(node, "ArrowFunctionExpression");
-};
-const findExportedFunctionBody = (programRoot, exportedName) => {
-	if (!isNodeOfType(programRoot, "Program")) return null;
-	const localBindings = /* @__PURE__ */ new Map();
-	const namedExports = /* @__PURE__ */ new Map();
-	let defaultExport = null;
-	let defaultExportIdentifierName = null;
-	const recordVariableDeclaration = (declaration) => {
-		for (const declarator of declaration.declarations ?? []) {
-			if (!isNodeOfType(declarator, "VariableDeclarator")) continue;
-			if (!isNodeOfType(declarator.id, "Identifier")) continue;
-			const initializer = declarator.init ? stripParenExpression(declarator.init) : null;
-			if (initializer && isFunctionLike(initializer)) localBindings.set(declarator.id.name, initializer);
-		}
-	};
-	for (const statement of programRoot.body ?? []) {
-		if (isNodeOfType(statement, "VariableDeclaration")) {
-			recordVariableDeclaration(statement);
-			continue;
-		}
-		if (isNodeOfType(statement, "FunctionDeclaration") && statement.id) {
-			localBindings.set(statement.id.name, statement);
-			continue;
-		}
-		if (isNodeOfType(statement, "ExportNamedDeclaration")) {
-			const declaration = statement.declaration;
-			if (declaration && isNodeOfType(declaration, "VariableDeclaration")) {
-				recordVariableDeclaration(declaration);
-				for (const declarator of declaration.declarations ?? []) {
-					if (!isNodeOfType(declarator, "VariableDeclarator")) continue;
-					if (!isNodeOfType(declarator.id, "Identifier")) continue;
-					namedExports.set(declarator.id.name, declarator.id.name);
-				}
-			} else if (declaration && isNodeOfType(declaration, "FunctionDeclaration") && declaration.id) {
-				localBindings.set(declaration.id.name, declaration);
-				namedExports.set(declaration.id.name, declaration.id.name);
-			}
-			for (const specifier of statement.specifiers ?? []) {
-				if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
-				const local = specifier.local;
-				const exported = specifier.exported;
-				if (!isNodeOfType(local, "Identifier")) continue;
-				const exportedNameSpec = isNodeOfType(exported, "Identifier") ? exported.name : isNodeOfType(exported, "Literal") && typeof exported.value === "string" ? exported.value : null;
-				if (!exportedNameSpec) continue;
-				namedExports.set(exportedNameSpec, local.name);
-			}
-			continue;
-		}
-		if (isNodeOfType(statement, "ExportDefaultDeclaration")) {
-			const declaration = statement.declaration;
-			if (!declaration) continue;
-			if (isNodeOfType(declaration, "FunctionDeclaration") && declaration.id) {
-				localBindings.set(declaration.id.name, declaration);
-				defaultExport = declaration;
-				continue;
-			}
-			if (isFunctionLike(declaration)) {
-				defaultExport = declaration;
-				continue;
-			}
-			if (isNodeOfType(declaration, "Identifier")) {
-				defaultExportIdentifierName = declaration.name;
-				continue;
-			}
-		}
-	}
-	if (exportedName === "default") {
-		if (defaultExport) return defaultExport;
-		if (defaultExportIdentifierName) {
-			const binding = localBindings.get(defaultExportIdentifierName);
-			if (binding) return binding;
-		}
-	}
-	const localName = namedExports.get(exportedName);
-	if (!localName) return null;
-	return localBindings.get(localName) ?? null;
-};
-const resolveImportedExportName = (importSpecifier) => {
-	if (isNodeOfType(importSpecifier, "ImportSpecifier")) {
-		const imported = importSpecifier.imported;
-		if (isNodeOfType(imported, "Identifier")) return imported.name;
-		if (isNodeOfType(imported, "Literal") && typeof imported.value === "string") return imported.value;
-		return null;
-	}
-	if (isNodeOfType(importSpecifier, "ImportDefaultSpecifier")) return "default";
-	return null;
-};
-const findReExportSourcesForName = (programRoot, exportedName) => {
-	if (!isNodeOfType(programRoot, "Program")) return [];
-	const exportAllSources = [];
-	for (const statement of programRoot.body ?? []) {
-		if (isNodeOfType(statement, "ExportNamedDeclaration") && statement.source) {
-			const sourceValue = statement.source.value;
-			if (typeof sourceValue !== "string") continue;
-			for (const specifier of statement.specifiers ?? []) {
-				if (!isNodeOfType(specifier, "ExportSpecifier")) continue;
-				const exported = specifier.exported;
-				if ((isNodeOfType(exported, "Identifier") ? exported.name : isNodeOfType(exported, "Literal") && typeof exported.value === "string" ? exported.value : null) === exportedName) return [sourceValue];
-			}
-		}
-		if (isNodeOfType(statement, "ExportAllDeclaration") && statement.source) {
-			const sourceValue = statement.source.value;
-			if (typeof sourceValue === "string") exportAllSources.push(sourceValue);
-		}
-	}
-	return exportAllSources;
-};
-//#endregion
-//#region src/plugin/utils/attach-parent-references.ts
-const attachParentReferences = (root) => {
-	const visit = (node, parent) => {
-		const writableNode = node;
-		writableNode.parent = parent;
-		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, node);
-			} else if (isAstNode(child)) visit(child, node);
-		}
-	};
-	visit(root, null);
-};
-//#endregion
-//#region src/plugin/utils/parse-source-file.ts
-const FILENAME_TO_LANG = {
-	".ts": "ts",
-	".tsx": "tsx",
-	".js": "js",
-	".jsx": "jsx",
-	".mjs": "js",
-	".cjs": "js",
-	".mts": "ts",
-	".cts": "ts"
-};
-const resolveLang = (filename) => {
-	return FILENAME_TO_LANG[path.extname(filename).toLowerCase()] ?? "tsx";
-};
-const parseCache = /* @__PURE__ */ new Map();
-const parseSourceFile = (absoluteFilePath) => {
-	let fileStat;
-	try {
-		fileStat = fs.statSync(absoluteFilePath);
-	} catch {
-		return null;
-	}
-	if (!fileStat.isFile()) return null;
-	if (fileStat.size > 2e6) return null;
-	const cached = parseCache.get(absoluteFilePath);
-	if (cached && cached.mtimeMs === fileStat.mtimeMs && cached.size === fileStat.size) return cached.program;
-	if (absoluteFilePath.endsWith(".d.ts") || absoluteFilePath.endsWith(".d.mts") || absoluteFilePath.endsWith(".d.cts")) {
-		parseCache.set(absoluteFilePath, {
-			mtimeMs: fileStat.mtimeMs,
-			size: fileStat.size,
-			program: null
-		});
-		return null;
-	}
-	let sourceText;
-	try {
-		sourceText = fs.readFileSync(absoluteFilePath, "utf8");
-	} catch {
-		parseCache.set(absoluteFilePath, {
-			mtimeMs: fileStat.mtimeMs,
-			size: fileStat.size,
-			program: null
-		});
-		return null;
-	}
-	let parsedProgram = null;
-	try {
-		const result = parseSync(absoluteFilePath, sourceText, {
-			astType: "ts",
-			lang: resolveLang(absoluteFilePath)
-		});
-		if (!result.errors.some((parseError) => parseError.severity === "Error")) {
-			parsedProgram = result.program;
-			attachParentReferences(parsedProgram);
-		}
-	} catch {
-		parsedProgram = null;
-	}
-	parseCache.set(absoluteFilePath, {
-		mtimeMs: fileStat.mtimeMs,
-		size: fileStat.size,
-		program: parsedProgram
-	});
-	return parsedProgram;
-};
-//#endregion
 //#region src/plugin/rules/state-and-effects/utils/resolve-reducer-function.ts
-const resolveFunctionExportInFile = (filePath, exportedName, visitedFilePaths) => {
-	if (visitedFilePaths.size >= 4) return null;
-	if (visitedFilePaths.has(filePath)) return null;
-	visitedFilePaths.add(filePath);
-	const actualFilePath = resolveBarrelExportFilePath(filePath, exportedName) ?? filePath;
-	const programRoot = parseSourceFile(actualFilePath);
-	if (!programRoot) return null;
-	const exported = findExportedFunctionBody(programRoot, exportedName);
-	if (exported) return exported;
-	for (const reExportSource of findReExportSourcesForName(programRoot, exportedName)) {
-		const nextFilePath = resolveRelativeImportPath(actualFilePath, reExportSource);
-		if (!nextFilePath) continue;
-		const resolved = resolveFunctionExportInFile(nextFilePath, exportedName, visitedFilePaths);
-		if (resolved) return resolved;
-	}
-	return null;
-};
-const resolveCrossFileFunctionExport = (fromFilename, source, exportedName) => {
-	const resolvedFilePath = resolveRelativeImportPath(fromFilename, source);
-	if (!resolvedFilePath) return null;
-	return resolveFunctionExportInFile(resolvedFilePath, exportedName, /* @__PURE__ */ new Set());
-};
 const resolveReducerFunction = (node, currentFilename) => {
 	if (!node) return null;
 	const unwrappedNode = stripParenExpression(node);
@@ -19518,7 +19800,6 @@ const resolveReducerFunction = (node, currentFilename) => {
 		if (!importDeclaration || !isNodeOfType(importDeclaration, "ImportDeclaration")) return null;
 		const sourceValue = importDeclaration.source?.value;
 		if (typeof sourceValue !== "string") return null;
-		if (!sourceValue.startsWith(".") && !sourceValue.startsWith("/")) return null;
 		const exportedName = resolveImportedExportName(initializer);
 		if (!exportedName) return null;
 		const crossFileFunction = resolveCrossFileFunctionExport(currentFilename, sourceValue, exportedName);