foresthouse 1.0.0-dev.6 → 1.0.0-dev.8

package/dist/{tree-Qsy9Nmh9.mjs → react-CWIt8V0Y.mjs}

@@ -1,10 +1,10 @@
 import { builtinModules } from "node:module";
-import fs from "node:fs";
 import path from "node:path";
 import ts from "typescript";
+import fs from "node:fs";
 import { parseSync, visitorKeys } from "oxc-parser";
 import process$1 from "node:process";
-//#region src/config.ts
+//#region src/typescript/config.ts
 function loadCompilerOptions(searchFrom, explicitConfigPath) {
 	const configPath = explicitConfigPath === void 0 ? findNearestConfig(searchFrom) : path.resolve(searchFrom, explicitConfigPath);
 	if (configPath === void 0) return { compilerOptions: defaultCompilerOptions() };
@@ -48,7 +48,18 @@ function formatDiagnostic(diagnostic) {
 	return ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
 }
 //#endregion
-//#region src/path-utils.ts
+//#region src/analyzers/base.ts
+var BaseAnalyzer = class {
+	constructor(entryFile, options) {
+		this.entryFile = entryFile;
+		this.options = options;
+	}
+	analyze() {
+		return this.doAnalyze();
+	}
+};
+//#endregion
+//#region src/utils/is-source-code-file.ts
 const SOURCE_EXTENSIONS = new Set([
 	".js",
 	".jsx",
@@ -59,159 +70,24 @@ const SOURCE_EXTENSIONS = new Set([
 	".mts",
 	".cts"
 ]);
-function normalizeFilePath(filePath) {
-	return path.normalize(filePath);
-}
-function toDisplayPath(filePath, cwd) {
-	const relativePath = path.relative(cwd, filePath);
-	if (relativePath === "") return ".";
-	const normalizedPath = relativePath.split(path.sep).join("/");
-	return normalizedPath.startsWith("..") ? filePath : normalizedPath;
-}
 function isSourceCodeFile(filePath) {
 	return SOURCE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
 }
 //#endregion
-//#region src/analyzer.ts
-const BUILTIN_MODULES = new Set(builtinModules.flatMap((name) => [name, `node:${name}`]));
-function analyzeDependencies(entryFile, options = {}) {
-	const cwd = path.resolve(options.cwd ?? process.cwd());
-	const resolvedEntryPath = resolveExistingPath(cwd, entryFile);
-	const { compilerOptions, path: configPath } = loadCompilerOptions(path.dirname(resolvedEntryPath), options.configPath);
-	const host = {
-		fileExists: ts.sys.fileExists,
-		readFile: ts.sys.readFile,
-		directoryExists: ts.sys.directoryExists,
-		getCurrentDirectory: () => cwd,
-		getDirectories: ts.sys.getDirectories,
-		...ts.sys.realpath === void 0 ? {} : { realpath: ts.sys.realpath }
-	};
-	const nodes = /* @__PURE__ */ new Map();
-	const program = createProgram(resolvedEntryPath, compilerOptions, cwd);
-	visitFile(resolvedEntryPath, compilerOptions, host, program.getTypeChecker(), program, nodes);
-	return {
-		cwd,
-		entryId: resolvedEntryPath,
-		nodes,
-		...configPath === void 0 ? {} : { configPath }
-	};
-}
-function graphToSerializableTree(graph, options = {}) {
-	const visited = /* @__PURE__ */ new Set();
-	return serializeNode(graph.entryId, graph, visited, options.omitUnused ?? false);
-}
-function serializeNode(filePath, graph, visited, omitUnused) {
-	const node = graph.nodes.get(filePath);
-	const displayPath = toDisplayPath(filePath, graph.cwd);
-	if (node === void 0) return {
-		path: displayPath,
-		kind: "missing",
-		dependencies: []
-	};
-	if (visited.has(filePath)) return {
-		path: displayPath,
-		kind: "circular",
-		dependencies: []
-	};
-	visited.add(filePath);
-	const dependencies = node.dependencies.filter((dependency) => !omitUnused || !dependency.unused).map((dependency) => {
-		if (dependency.kind !== "source") return {
-			specifier: dependency.specifier,
-			referenceKind: dependency.referenceKind,
-			isTypeOnly: dependency.isTypeOnly,
-			unused: dependency.unused,
-			kind: dependency.kind,
-			target: dependency.kind === "missing" ? dependency.target : toDisplayPath(dependency.target, graph.cwd)
-		};
-		return {
-			specifier: dependency.specifier,
-			referenceKind: dependency.referenceKind,
-			isTypeOnly: dependency.isTypeOnly,
-			unused: dependency.unused,
-			kind: dependency.kind,
-			target: toDisplayPath(dependency.target, graph.cwd),
-			node: serializeNode(dependency.target, graph, new Set(visited), omitUnused)
-		};
-	});
-	return {
-		path: displayPath,
-		kind: filePath === graph.entryId ? "entry" : "source",
-		dependencies
-	};
-}
-function visitFile(filePath, compilerOptions, host, checker, program, nodes) {
-	const normalizedPath = normalizeFilePath(filePath);
-	if (nodes.has(normalizedPath)) return;
-	const dependencies = collectModuleReferences(program.getSourceFile(normalizedPath) ?? createSourceFile(normalizedPath), checker).map((reference) => resolveDependency(reference, normalizedPath, compilerOptions, host));
-	nodes.set(normalizedPath, {
-		id: normalizedPath,
-		dependencies
-	});
-	for (const dependency of dependencies) if (dependency.kind === "source") visitFile(dependency.target, compilerOptions, host, checker, program, nodes);
-}
-function collectModuleReferences(sourceFile, checker) {
-	const references = /* @__PURE__ */ new Map();
-	const unusedImports = collectUnusedImports(sourceFile, checker);
-	function addReference(specifier, referenceKind, isTypeOnly, unused) {
-		const key = `${referenceKind}:${isTypeOnly ? "type" : "value"}:${specifier}`;
-		const existing = references.get(key);
-		if (existing !== void 0) {
-			if (existing.unused && !unused) references.set(key, {
-				...existing,
-				unused: false
-			});
-			return;
-		}
-		references.set(key, {
-			specifier,
-			referenceKind,
-			isTypeOnly,
-			unused
-		});
-	}
-	function visit(node) {
-		if (ts.isImportDeclaration(node) && ts.isStringLiteralLike(node.moduleSpecifier)) addReference(node.moduleSpecifier.text, "import", node.importClause?.isTypeOnly ?? false, unusedImports.get(node) ?? false);
-		else if (ts.isExportDeclaration(node) && node.moduleSpecifier !== void 0 && ts.isStringLiteralLike(node.moduleSpecifier)) addReference(node.moduleSpecifier.text, "export", node.isTypeOnly ?? false, false);
-		else if (ts.isImportEqualsDeclaration(node)) {
-			const moduleReference = node.moduleReference;
-			if (ts.isExternalModuleReference(moduleReference) && moduleReference.expression !== void 0 && ts.isStringLiteralLike(moduleReference.expression)) addReference(moduleReference.expression.text, "import-equals", false, false);
-		} else if (ts.isCallExpression(node)) {
-			if (node.expression.kind === ts.SyntaxKind.ImportKeyword && node.arguments.length === 1) {
-				const [argument] = node.arguments;
-				if (argument !== void 0 && ts.isStringLiteralLike(argument)) addReference(argument.text, "dynamic-import", false, false);
-			}
-			if (ts.isIdentifier(node.expression) && node.expression.text === "require" && node.arguments.length === 1) {
-				const [argument] = node.arguments;
-				if (argument !== void 0 && ts.isStringLiteralLike(argument)) addReference(argument.text, "require", false, false);
-			}
-		}
-		ts.forEachChild(node, visit);
-	}
-	visit(sourceFile);
-	return [...references.values()];
-}
-function resolveDependency(reference, containingFile, compilerOptions, host) {
-	const specifier = reference.specifier;
-	if (BUILTIN_MODULES.has(specifier)) return createEdge(reference, "builtin", specifier);
-	const resolution = ts.resolveModuleName(specifier, containingFile, compilerOptions, host).resolvedModule;
-	if (resolution !== void 0) {
-		const resolvedPath = normalizeFilePath(resolution.resolvedFileName);
-		if (resolution.isExternalLibraryImport || resolvedPath.includes(`${path.sep}node_modules${path.sep}`)) return createEdge(reference, "external", specifier);
-		if (isSourceCodeFile(resolvedPath) && !resolvedPath.endsWith(".d.ts")) return createEdge(reference, "source", resolvedPath);
-	}
-	if (!specifier.startsWith(".") && !path.isAbsolute(specifier)) return createEdge(reference, "external", specifier);
-	return createEdge(reference, "missing", specifier);
+//#region src/utils/normalize-file-path.ts
+function normalizeFilePath(filePath) {
+	return path.normalize(filePath);
 }
-function createEdge(reference, kind, target) {
-	return {
-		specifier: reference.specifier,
-		referenceKind: reference.referenceKind,
-		isTypeOnly: reference.isTypeOnly,
-		unused: reference.unused,
-		kind,
-		target
-	};
+//#endregion
+//#region src/analyzers/import/entry.ts
+function resolveExistingPath(cwd, entryFile) {
+	const normalizedPath = normalizeFilePath(path.resolve(cwd, entryFile));
+	if (!fs.existsSync(normalizedPath)) throw new Error(`Entry file not found: ${entryFile}`);
+	if (!isSourceCodeFile(normalizedPath)) throw new Error(`Entry file must be a JS/TS source file: ${entryFile}`);
+	return normalizedPath;
 }
+//#endregion
+//#region src/typescript/program.ts
 function createProgram(entryFile, compilerOptions, cwd) {
 	const host = ts.createCompilerHost(compilerOptions, true);
 	host.getCurrentDirectory = () => cwd;
@@ -226,6 +102,29 @@ function createSourceFile(filePath) {
 	const sourceText = fs.readFileSync(filePath, "utf8");
 	return ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, getScriptKind(filePath));
 }
+function createModuleResolutionHost(cwd) {
+	return {
+		fileExists: ts.sys.fileExists,
+		readFile: ts.sys.readFile,
+		directoryExists: ts.sys.directoryExists,
+		getCurrentDirectory: () => cwd,
+		getDirectories: ts.sys.getDirectories,
+		...ts.sys.realpath === void 0 ? {} : { realpath: ts.sys.realpath }
+	};
+}
+function getScriptKind(filePath) {
+	switch (path.extname(filePath).toLowerCase()) {
+		case ".js":
+		case ".mjs":
+		case ".cjs": return ts.ScriptKind.JS;
+		case ".jsx": return ts.ScriptKind.JSX;
+		case ".tsx": return ts.ScriptKind.TSX;
+		case ".json": return ts.ScriptKind.JSON;
+		default: return ts.ScriptKind.TS;
+	}
+}
+//#endregion
+//#region src/analyzers/import/unused.ts
 function collectUnusedImports(sourceFile, checker) {
 	const importUsage = /* @__PURE__ */ new Map();
 	const symbolToImportDeclaration = /* @__PURE__ */ new Map();
@@ -293,296 +192,132 @@ function tryGetSymbolAtLocation(checker, node) {
 		return;
 	}
 }
-function getScriptKind(filePath) {
-	switch (path.extname(filePath).toLowerCase()) {
-		case ".js":
-		case ".mjs":
-		case ".cjs": return ts.ScriptKind.JS;
-		case ".jsx": return ts.ScriptKind.JSX;
-		case ".tsx": return ts.ScriptKind.TSX;
-		case ".json": return ts.ScriptKind.JSON;
-		default: return ts.ScriptKind.TS;
-	}
-}
-function resolveExistingPath(cwd, entryFile) {
-	const normalizedPath = normalizeFilePath(path.resolve(cwd, entryFile));
-	if (!fs.existsSync(normalizedPath)) throw new Error(`Entry file not found: ${entryFile}`);
-	if (!isSourceCodeFile(normalizedPath)) throw new Error(`Entry file must be a JS/TS source file: ${entryFile}`);
-	return normalizedPath;
-}
 //#endregion
-//#region src/react-analyzer.ts
-const FUNCTION_NODE_TYPES = new Set([
-	"FunctionDeclaration",
-	"FunctionExpression",
-	"ArrowFunctionExpression",
-	"TSDeclareFunction",
-	"TSEmptyBodyFunctionExpression"
-]);
-function analyzeReactUsage(entryFile, options = {}) {
-	const dependencyGraph = analyzeDependencies(entryFile, options);
-	const reachableFiles = new Set([dependencyGraph.entryId, ...dependencyGraph.nodes.keys()]);
-	const fileAnalyses = /* @__PURE__ */ new Map();
-	for (const filePath of [...reachableFiles].sort()) {
-		if (!isSourceCodeFile(filePath) || filePath.endsWith(".d.ts")) continue;
-		const sourceText = fs.readFileSync(filePath, "utf8");
-		const parseResult = parseSync(filePath, sourceText, {
-			astType: "ts",
-			sourceType: "unambiguous"
-		});
-		const dependencyNode = dependencyGraph.nodes.get(filePath);
-		const sourceDependencies = /* @__PURE__ */ new Map();
-		dependencyNode?.dependencies.forEach((dependency) => {
-			if (dependency.kind === "source") sourceDependencies.set(dependency.specifier, dependency.target);
-		});
-		fileAnalyses.set(filePath, analyzeReactFile(parseResult.program, filePath, sourceText, filePath === dependencyGraph.entryId, sourceDependencies));
-	}
-	const nodes = /* @__PURE__ */ new Map();
-	for (const fileAnalysis of fileAnalyses.values()) for (const symbol of fileAnalysis.symbolsById.values()) nodes.set(symbol.id, {
-		id: symbol.id,
-		name: symbol.name,
-		kind: symbol.kind,
-		filePath: symbol.filePath,
-		exportNames: [...symbol.exportNames].sort(),
-		usages: []
-	});
-	for (const fileAnalysis of fileAnalyses.values()) fileAnalysis.importsByLocalName.forEach((binding, localName) => {
-		if (binding.sourcePath !== void 0) return;
-		if (!isHookName(localName) && !isHookName(binding.importedName)) return;
-		const externalNode = createExternalHookNode(binding, localName);
-		if (!nodes.has(externalNode.id)) nodes.set(externalNode.id, externalNode);
-	});
-	for (const fileAnalysis of fileAnalyses.values()) for (const symbol of fileAnalysis.symbolsById.values()) {
-		const usages = /* @__PURE__ */ new Map();
-		symbol.componentReferences.forEach((referenceName) => {
-			const targetId = resolveReactReference(fileAnalysis, fileAnalyses, referenceName, "component");
-			if (targetId !== void 0 && targetId !== symbol.id) usages.set(`render:${targetId}`, {
-				kind: "render",
-				target: targetId
-			});
-		});
-		symbol.hookReferences.forEach((referenceName) => {
-			const targetId = resolveReactReference(fileAnalysis, fileAnalyses, referenceName, "hook");
-			if (targetId !== void 0 && targetId !== symbol.id) usages.set(`hook:${targetId}`, {
-				kind: "hook-call",
-				target: targetId
+//#region src/analyzers/import/references.ts
+function collectModuleReferences(sourceFile, checker) {
+	const references = /* @__PURE__ */ new Map();
+	const unusedImports = collectUnusedImports(sourceFile, checker);
+	function addReference(specifier, referenceKind, isTypeOnly, unused) {
+		const key = `${referenceKind}:${isTypeOnly ? "type" : "value"}:${specifier}`;
+		const existing = references.get(key);
+		if (existing !== void 0) {
+			if (existing.unused && !unused) references.set(key, {
+				...existing,
+				unused: false
 			});
-		});
-		const node = nodes.get(symbol.id);
-		if (node === void 0) continue;
-		const sortedUsages = [...usages.values()].sort((left, right) => compareReactNodeIds(left.target, right.target, nodes));
-		nodes.set(symbol.id, {
-			...node,
-			usages: sortedUsages
+			return;
+		}
+		references.set(key, {
+			specifier,
+			referenceKind,
+			isTypeOnly,
+			unused
 		});
 	}
-	const entriesByKey = /* @__PURE__ */ new Map();
-	for (const fileAnalysis of fileAnalyses.values()) for (const entry of fileAnalysis.renderEntries) {
-		const targetId = resolveReactReference(fileAnalysis, fileAnalyses, entry.referenceName, "component");
-		if (targetId === void 0) continue;
-		const key = `${entry.location.filePath}:${entry.location.line}:${entry.location.column}:${targetId}`;
-		entriesByKey.set(key, {
-			target: targetId,
-			location: entry.location
-		});
+	function visit(node) {
+		if (ts.isImportDeclaration(node) && ts.isStringLiteralLike(node.moduleSpecifier)) addReference(node.moduleSpecifier.text, "import", node.importClause?.isTypeOnly ?? false, unusedImports.get(node) ?? false);
+		else if (ts.isExportDeclaration(node) && node.moduleSpecifier !== void 0 && ts.isStringLiteralLike(node.moduleSpecifier)) addReference(node.moduleSpecifier.text, "export", node.isTypeOnly ?? false, false);
+		else if (ts.isImportEqualsDeclaration(node)) {
+			const moduleReference = node.moduleReference;
+			if (ts.isExternalModuleReference(moduleReference) && moduleReference.expression !== void 0 && ts.isStringLiteralLike(moduleReference.expression)) addReference(moduleReference.expression.text, "import-equals", false, false);
+		} else if (ts.isCallExpression(node)) {
+			if (node.expression.kind === ts.SyntaxKind.ImportKeyword && node.arguments.length === 1) {
+				const [argument] = node.arguments;
+				if (argument !== void 0 && ts.isStringLiteralLike(argument)) addReference(argument.text, "dynamic-import", false, false);
+			}
+			if (ts.isIdentifier(node.expression) && node.expression.text === "require" && node.arguments.length === 1) {
+				const [argument] = node.arguments;
+				if (argument !== void 0 && ts.isStringLiteralLike(argument)) addReference(argument.text, "require", false, false);
+			}
+		}
+		ts.forEachChild(node, visit);
 	}
-	const entries = [...entriesByKey.values()].sort((left, right) => compareReactUsageEntries(left, right, nodes));
-	return {
-		cwd: dependencyGraph.cwd,
-		entryId: dependencyGraph.entryId,
-		nodes,
-		entries
-	};
-}
-function graphToSerializableReactTree(graph, options = {}) {
-	const filter = options.filter ?? "all";
-	const entries = getReactUsageEntries(graph, filter);
-	const roots = entries.length > 0 ? entries.map((entry) => serializeReactUsageNode(entry.target, graph, filter, /* @__PURE__ */ new Set())) : getReactUsageRoots(graph, filter).map((rootId) => serializeReactUsageNode(rootId, graph, filter, /* @__PURE__ */ new Set()));
-	return {
-		kind: "react-usage",
-		entries: entries.map((entry) => serializeReactUsageEntry(entry, graph, filter)),
-		roots
-	};
-}
-function getReactUsageEntries(graph, filter = "all") {
-	if (filter === "hook") return [];
-	return graph.entries.filter((entry) => {
-		const targetNode = graph.nodes.get(entry.target);
-		return targetNode !== void 0 && matchesReactFilter(targetNode, filter);
-	});
+	visit(sourceFile);
+	return [...references.values()];
 }
-function getReactUsageRoots(graph, filter = "all") {
-	const entries = getReactUsageEntries(graph, filter);
-	if (entries.length > 0) return [...new Set(entries.map((entry) => entry.target))];
-	const filteredNodes = getFilteredReactUsageNodes(graph, filter);
-	const inboundCounts = /* @__PURE__ */ new Map();
-	filteredNodes.forEach((node) => {
-		inboundCounts.set(node.id, 0);
-	});
-	filteredNodes.forEach((node) => {
-		getFilteredUsages(node, graph, filter).forEach((usage) => {
-			inboundCounts.set(usage.target, (inboundCounts.get(usage.target) ?? 0) + 1);
-		});
-	});
-	const roots = filteredNodes.filter((node) => (inboundCounts.get(node.id) ?? 0) === 0).map((node) => node.id);
-	if (roots.length > 0) return roots.sort((left, right) => compareReactNodeIds(left, right, graph.nodes));
-	return filteredNodes.map((node) => node.id).sort((left, right) => compareReactNodeIds(left, right, graph.nodes));
-}
-function getFilteredUsages(node, graph, filter = "all") {
-	return node.usages.filter((usage) => {
-		const targetNode = graph.nodes.get(usage.target);
-		return targetNode !== void 0 && matchesReactFilter(targetNode, filter);
-	});
+//#endregion
+//#region src/analyzers/import/resolver.ts
+const BUILTIN_MODULES = new Set(builtinModules.flatMap((name) => [name, `node:${name}`]));
+function resolveDependency(reference, containingFile, compilerOptions, host) {
+	const specifier = reference.specifier;
+	if (BUILTIN_MODULES.has(specifier)) return createEdge(reference, "builtin", specifier);
+	const resolution = ts.resolveModuleName(specifier, containingFile, compilerOptions, host).resolvedModule;
+	if (resolution !== void 0) {
+		const resolvedPath = normalizeFilePath(resolution.resolvedFileName);
+		if (resolution.isExternalLibraryImport || resolvedPath.includes(`${path.sep}node_modules${path.sep}`)) return createEdge(reference, "external", specifier);
+		if (isSourceCodeFile(resolvedPath) && !resolvedPath.endsWith(".d.ts")) return createEdge(reference, "source", resolvedPath);
+	}
+	if (!specifier.startsWith(".") && !path.isAbsolute(specifier)) return createEdge(reference, "external", specifier);
+	return createEdge(reference, "missing", specifier);
 }
-function analyzeReactFile(program, filePath, sourceText, includeNestedRenderEntries, sourceDependencies) {
-	const symbolsByName = /* @__PURE__ */ new Map();
-	program.body.forEach((statement) => {
-		collectTopLevelReactSymbols(statement, filePath, symbolsByName);
-	});
-	const importsByLocalName = /* @__PURE__ */ new Map();
-	const exportsByName = /* @__PURE__ */ new Map();
-	const renderEntries = collectRenderEntries(program, filePath, sourceText, includeNestedRenderEntries);
-	program.body.forEach((statement) => {
-		collectImportsAndExports(statement, sourceDependencies, symbolsByName, importsByLocalName, exportsByName);
-	});
-	symbolsByName.forEach((symbol) => {
-		analyzeSymbolUsages(symbol);
-	});
+function createEdge(reference, kind, target) {
 	return {
-		filePath,
-		importsByLocalName,
-		exportsByName,
-		renderEntries,
-		symbolsById: new Map([...symbolsByName.values()].map((symbol) => [symbol.id, symbol])),
-		symbolsByName
+		specifier: reference.specifier,
+		referenceKind: reference.referenceKind,
+		isTypeOnly: reference.isTypeOnly,
+		unused: reference.unused,
+		kind,
+		target
 	};
 }
-function collectRenderEntries(program, filePath, sourceText, includeNestedFunctions) {
-	const entries = /* @__PURE__ */ new Map();
-	program.body.forEach((statement) => {
-		collectStatementRenderEntries(statement, filePath, sourceText, entries, includeNestedFunctions);
-	});
-	return [...entries.values()].sort(comparePendingReactUsageEntries);
-}
-function collectStatementRenderEntries(statement, filePath, sourceText, entries, includeNestedFunctions) {
-	collectNodeRenderEntries(statement, filePath, sourceText, entries, false, includeNestedFunctions);
-}
-function collectNodeRenderEntries(node, filePath, sourceText, entries, hasComponentAncestor, includeNestedFunctions) {
-	if (!includeNestedFunctions && FUNCTION_NODE_TYPES.has(node.type)) return;
-	let nextHasComponentAncestor = hasComponentAncestor;
-	if (node.type === "JSXElement") {
-		const referenceName = getComponentReferenceName(node);
-		if (referenceName !== void 0) {
-			if (!hasComponentAncestor) addPendingRenderEntry(entries, referenceName, createReactUsageLocation(filePath, sourceText, node.start));
-			nextHasComponentAncestor = true;
-		}
-	} else if (node.type === "CallExpression") {
-		const referenceName = getCreateElementComponentReferenceName(node);
-		if (referenceName !== void 0) {
-			if (!hasComponentAncestor) addPendingRenderEntry(entries, referenceName, createReactUsageLocation(filePath, sourceText, node.start));
-			nextHasComponentAncestor = true;
-		}
+//#endregion
+//#region src/analyzers/import/graph.ts
+function buildDependencyGraph(entryPath, compilerOptions, cwd) {
+	return new DependencyGraphBuilder(entryPath, compilerOptions, cwd).build();
+}
+var DependencyGraphBuilder = class {
+	host;
+	nodes = /* @__PURE__ */ new Map();
+	program;
+	checker;
+	constructor(entryPath, compilerOptions, cwd) {
+		this.entryPath = entryPath;
+		this.compilerOptions = compilerOptions;
+		this.host = createModuleResolutionHost(cwd);
+		this.program = createProgram(entryPath, compilerOptions, cwd);
+		this.checker = this.program.getTypeChecker();
 	}
-	const keys = visitorKeys[node.type];
-	if (keys === void 0) return;
-	keys.forEach((key) => {
-		const value = node[key];
-		collectRenderEntryChild(value, filePath, sourceText, entries, nextHasComponentAncestor, includeNestedFunctions);
-	});
-}
-function collectRenderEntryChild(value, filePath, sourceText, entries, hasComponentAncestor, includeNestedFunctions) {
-	if (Array.isArray(value)) {
-		value.forEach((entry) => {
-			collectRenderEntryChild(entry, filePath, sourceText, entries, hasComponentAncestor, includeNestedFunctions);
-		});
-		return;
+	build() {
+		this.visitFile(this.entryPath);
+		return this.nodes;
 	}
-	if (!isNode(value)) return;
-	collectNodeRenderEntries(value, filePath, sourceText, entries, hasComponentAncestor, includeNestedFunctions);
-}
-function addPendingRenderEntry(entries, referenceName, location) {
-	const key = `${location.filePath}:${location.line}:${location.column}:${referenceName}`;
-	entries.set(key, {
-		referenceName,
-		location
-	});
-}
-function createReactUsageLocation(filePath, sourceText, offset) {
-	return {
-		filePath,
-		...offsetToLineAndColumn(sourceText, offset)
-	};
-}
-function offsetToLineAndColumn(sourceText, offset) {
-	let line = 1;
-	let column = 1;
-	for (let index = 0; index < offset && index < sourceText.length; index += 1) {
-		if (sourceText[index] === "\n") {
-			line += 1;
-			column = 1;
-			continue;
-		}
-		column += 1;
+	visitFile(filePath) {
+		const normalizedPath = normalizeFilePath(filePath);
+		if (this.nodes.has(normalizedPath)) return;
+		const dependencies = collectModuleReferences(this.program.getSourceFile(normalizedPath) ?? createSourceFile(normalizedPath), this.checker).map((reference) => resolveDependency(reference, normalizedPath, this.compilerOptions, this.host));
+		this.nodes.set(normalizedPath, {
+			id: normalizedPath,
+			dependencies
+		});
+		for (const dependency of dependencies) if (dependency.kind === "source") this.visitFile(dependency.target);
 	}
-	return {
-		line,
-		column
-	};
-}
-function collectTopLevelReactSymbols(statement, filePath, symbolsByName) {
-	switch (statement.type) {
-		case "FunctionDeclaration":
-			addFunctionSymbol(statement, filePath, symbolsByName);
-			return;
-		case "VariableDeclaration":
-			statement.declarations.forEach((declarator) => {
-				addVariableSymbol(declarator, filePath, symbolsByName);
-			});
-			return;
-		case "ExportNamedDeclaration":
-			if (statement.declaration !== null) collectTopLevelReactSymbols(statement.declaration, filePath, symbolsByName);
-			return;
-		case "ExportDefaultDeclaration":
-			addDefaultExportSymbol(statement, filePath, symbolsByName);
-			return;
-		default: return;
+};
+//#endregion
+//#region src/analyzers/import/index.ts
+function analyzeDependencies(entryFile, options = {}) {
+	return new ImportAnalyzer(entryFile, options).analyze();
+}
+var ImportAnalyzer = class extends BaseAnalyzer {
+	cwd;
+	entryPath;
+	constructor(entryFile, options) {
+		super(entryFile, options);
+		this.cwd = path.resolve(options.cwd ?? process.cwd());
+		this.entryPath = resolveExistingPath(this.cwd, entryFile);
 	}
-}
-function addFunctionSymbol(declaration, filePath, symbolsByName) {
-	const name = declaration.id?.name;
-	if (name === void 0) return;
-	const kind = classifyReactSymbol(name, declaration);
-	if (kind === void 0) return;
-	symbolsByName.set(name, createPendingSymbol(filePath, name, kind, declaration));
-}
-function addVariableSymbol(declarator, filePath, symbolsByName) {
-	if (declarator.id.type !== "Identifier" || declarator.init === null) return;
-	if (declarator.init.type !== "ArrowFunctionExpression" && declarator.init.type !== "FunctionExpression") return;
-	const name = declarator.id.name;
-	const kind = classifyReactSymbol(name, declarator.init);
-	if (kind === void 0) return;
-	symbolsByName.set(name, createPendingSymbol(filePath, name, kind, declarator.init));
-}
-function addDefaultExportSymbol(declaration, filePath, symbolsByName) {
-	if (declaration.declaration.type === "FunctionDeclaration" || declaration.declaration.type === "FunctionExpression") addFunctionSymbol(declaration.declaration, filePath, symbolsByName);
-	else if (declaration.declaration.type === "ArrowFunctionExpression") {
-		const name = "default";
-		const kind = declaration.declaration.body ? classifyReactSymbol(name, declaration.declaration) : void 0;
-		if (kind !== void 0) symbolsByName.set(name, createPendingSymbol(filePath, name, kind, declaration.declaration));
+	doAnalyze() {
+		const { compilerOptions, path: configPath } = loadCompilerOptions(path.dirname(this.entryPath), this.options.configPath);
+		const nodes = buildDependencyGraph(this.entryPath, compilerOptions, this.cwd);
+		return {
+			cwd: this.cwd,
+			entryId: this.entryPath,
+			nodes,
+			...configPath === void 0 ? {} : { configPath }
+		};
 	}
-}
-function createPendingSymbol(filePath, name, kind, declaration) {
-	return {
-		id: `${filePath}#${kind}:${name}`,
-		name,
-		kind,
-		filePath,
-		declaration,
-		exportNames: /* @__PURE__ */ new Set(),
-		componentReferences: /* @__PURE__ */ new Set(),
-		hookReferences: /* @__PURE__ */ new Set()
-	};
-}
+};
+//#endregion
+//#region src/analyzers/react/bindings.ts
 function collectImportsAndExports(statement, sourceDependencies, symbolsByName, importsByLocalName, exportsByName) {
 	switch (statement.type) {
 		case "ImportDeclaration":
@@ -663,38 +398,48 @@ function addExportBinding(localName, exportedName, symbolsByName, exportsByName)
 	symbol.exportNames.add(exportedName);
 	exportsByName.set(exportedName, symbol.id);
 }
-function analyzeSymbolUsages(symbol) {
-	const root = symbol.declaration.type === "ArrowFunctionExpression" ? symbol.declaration.body : symbol.declaration.body;
-	if (root === null) return;
-	walkReactUsageTree(root, (node) => {
-		if (node.type === "JSXElement") {
-			const name = getComponentReferenceName(node);
-			if (name !== void 0) symbol.componentReferences.add(name);
-			return;
-		}
-		if (node.type === "CallExpression") {
-			const hookReference = getHookReferenceName(node);
-			if (hookReference !== void 0) symbol.hookReferences.add(hookReference);
-			const componentReference = getCreateElementComponentReferenceName(node);
-			if (componentReference !== void 0) symbol.componentReferences.add(componentReference);
-		}
+function toModuleExportName(name) {
+	return name.type === "Literal" ? name.value : name.name;
+}
+//#endregion
+//#region src/analyzers/react/walk.ts
+const FUNCTION_NODE_TYPES = new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression",
+	"TSDeclareFunction",
+	"TSEmptyBodyFunctionExpression"
+]);
+function walkReactUsageTree(root, visit) {
+	walkNode(root, visit, true);
+}
+function walkNode(node, visit, allowNestedFunctions = false) {
+	visit(node);
+	const keys = visitorKeys[node.type];
+	if (keys === void 0) return;
+	keys.forEach((key) => {
+		const value = node[key];
+		walkChild(value, visit, allowNestedFunctions);
 	});
 }
+function walkChild(value, visit, allowNestedFunctions) {
+	if (Array.isArray(value)) {
+		value.forEach((entry) => {
+			walkChild(entry, visit, allowNestedFunctions);
+		});
+		return;
+	}
+	if (!isNode(value)) return;
+	if (!allowNestedFunctions && FUNCTION_NODE_TYPES.has(value.type)) return;
+	walkNode(value, visit, false);
+}
+function isNode(value) {
+	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
 function classifyReactSymbol(name, declaration) {
 	if (isHookName(name)) return "hook";
 	if (isComponentName(name) && returnsReactElement(declaration)) return "component";
 }
-function returnsReactElement(declaration) {
-	if (declaration.type === "ArrowFunctionExpression" && declaration.expression) return containsReactElementLikeExpression(declaration.body);
-	const body = declaration.body;
-	if (body === null) return false;
-	let found = false;
-	walkReactUsageTree(body, (node) => {
-		if (node.type !== "ReturnStatement" || node.argument === null) return;
-		if (containsReactElementLikeExpression(node.argument)) found = true;
-	});
-	return found;
-}
 function containsReactElementLikeExpression(expression) {
 	let found = false;
 	walkNode(expression, (node) => {
@@ -716,6 +461,23 @@ function getCreateElementComponentReferenceName(node) {
 	if (firstArgument === void 0 || firstArgument.type !== "Identifier") return;
 	return isComponentName(firstArgument.name) ? firstArgument.name : void 0;
 }
+function isHookName(name) {
+	return /^use[A-Z0-9]/.test(name);
+}
+function isComponentName(name) {
+	return /^[A-Z]/.test(name);
+}
+function returnsReactElement(declaration) {
+	if (declaration.type === "ArrowFunctionExpression" && declaration.expression) return containsReactElementLikeExpression(declaration.body);
+	const body = declaration.body;
+	if (body === null) return false;
+	let found = false;
+	walkReactUsageTree(body, (node) => {
+		if (node.type !== "ReturnStatement" || node.argument === null) return;
+		if (containsReactElementLikeExpression(node.argument)) found = true;
+	});
+	return found;
+}
 function isReactCreateElementCall(node) {
 	const callee = unwrapExpression(node.callee);
 	if (callee.type !== "MemberExpression" || callee.computed) return false;
@@ -738,32 +500,188 @@ function unwrapExpression(expression) {
 		return current;
 	}
 }
-function walkReactUsageTree(root, visit) {
-	walkNode(root, visit, true);
-}
-function walkNode(node, visit, allowNestedFunctions = false) {
-	visit(node);
+//#endregion
+//#region src/analyzers/react/entries.ts
+function collectEntryUsages(program, filePath, sourceText, includeNestedFunctions) {
+	const entries = /* @__PURE__ */ new Map();
+	program.body.forEach((statement) => {
+		collectStatementEntryUsages(statement, filePath, sourceText, entries, includeNestedFunctions);
+	});
+	return [...entries.values()].sort(comparePendingReactUsageEntries);
+}
+function collectStatementEntryUsages(statement, filePath, sourceText, entries, includeNestedFunctions) {
+	collectNodeEntryUsages(statement, filePath, sourceText, entries, false, includeNestedFunctions);
+}
+function collectNodeEntryUsages(node, filePath, sourceText, entries, hasComponentAncestor, includeNestedFunctions) {
+	if (!includeNestedFunctions && FUNCTION_NODE_TYPES.has(node.type)) return;
+	let nextHasComponentAncestor = hasComponentAncestor;
+	if (node.type === "JSXElement") {
+		const referenceName = getComponentReferenceName(node);
+		if (referenceName !== void 0) {
+			if (!hasComponentAncestor) addPendingReactUsageEntry(entries, referenceName, "component", createReactUsageLocation(filePath, sourceText, node.start));
+			nextHasComponentAncestor = true;
+		}
+	} else if (node.type === "CallExpression") {
+		const hookReference = getHookReferenceName(node);
+		if (hookReference !== void 0) addPendingReactUsageEntry(entries, hookReference, "hook", createReactUsageLocation(filePath, sourceText, node.start));
+		const referenceName = getCreateElementComponentReferenceName(node);
+		if (referenceName !== void 0) {
+			if (!hasComponentAncestor) addPendingReactUsageEntry(entries, referenceName, "component", createReactUsageLocation(filePath, sourceText, node.start));
+			nextHasComponentAncestor = true;
+		}
+	}
 	const keys = visitorKeys[node.type];
 	if (keys === void 0) return;
 	keys.forEach((key) => {
 		const value = node[key];
-		walkChild(value, visit, allowNestedFunctions);
+		collectEntryUsageChild(value, filePath, sourceText, entries, nextHasComponentAncestor, includeNestedFunctions);
 	});
 }
-function walkChild(value, visit, allowNestedFunctions) {
+function collectEntryUsageChild(value, filePath, sourceText, entries, hasComponentAncestor, includeNestedFunctions) {
 	if (Array.isArray(value)) {
 		value.forEach((entry) => {
-			walkChild(entry, visit, allowNestedFunctions);
+			collectEntryUsageChild(entry, filePath, sourceText, entries, hasComponentAncestor, includeNestedFunctions);
 		});
 		return;
 	}
 	if (!isNode(value)) return;
-	if (!allowNestedFunctions && FUNCTION_NODE_TYPES.has(value.type)) return;
-	walkNode(value, visit, false);
+	collectNodeEntryUsages(value, filePath, sourceText, entries, hasComponentAncestor, includeNestedFunctions);
 }
-function isNode(value) {
-	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+function addPendingReactUsageEntry(entries, referenceName, kind, location) {
+	const key = `${location.filePath}:${location.line}:${location.column}:${kind}:${referenceName}`;
+	entries.set(key, {
+		referenceName,
+		kind,
+		location
+	});
 }
+function createReactUsageLocation(filePath, sourceText, offset) {
+	return {
+		filePath,
+		...offsetToLineAndColumn(sourceText, offset)
+	};
+}
+function offsetToLineAndColumn(sourceText, offset) {
+	let line = 1;
+	let column = 1;
+	for (let index = 0; index < offset && index < sourceText.length; index += 1) {
+		if (sourceText[index] === "\n") {
+			line += 1;
+			column = 1;
+			continue;
+		}
+		column += 1;
+	}
+	return {
+		line,
+		column
+	};
+}
+function comparePendingReactUsageEntries(left, right) {
+	return left.location.filePath.localeCompare(right.location.filePath) || left.location.line - right.location.line || left.location.column - right.location.column || left.kind.localeCompare(right.kind) || left.referenceName.localeCompare(right.referenceName);
+}
+//#endregion
+//#region src/analyzers/react/symbols.ts
+function collectTopLevelReactSymbols(statement, filePath, symbolsByName) {
+	switch (statement.type) {
+		case "FunctionDeclaration":
+			addFunctionSymbol(statement, filePath, symbolsByName);
+			return;
+		case "VariableDeclaration":
+			statement.declarations.forEach((declarator) => {
+				addVariableSymbol(declarator, filePath, symbolsByName);
+			});
+			return;
+		case "ExportNamedDeclaration":
+			if (statement.declaration !== null) collectTopLevelReactSymbols(statement.declaration, filePath, symbolsByName);
+			return;
+		case "ExportDefaultDeclaration":
+			addDefaultExportSymbol(statement, filePath, symbolsByName);
+			return;
+		default: return;
+	}
+}
+function addFunctionSymbol(declaration, filePath, symbolsByName) {
+	const name = declaration.id?.name;
+	if (name === void 0) return;
+	const kind = classifyReactSymbol(name, declaration);
+	if (kind === void 0) return;
+	symbolsByName.set(name, createPendingSymbol(filePath, name, kind, declaration));
+}
+function addVariableSymbol(declarator, filePath, symbolsByName) {
+	if (declarator.id.type !== "Identifier" || declarator.init === null) return;
+	if (declarator.init.type !== "ArrowFunctionExpression" && declarator.init.type !== "FunctionExpression") return;
+	const name = declarator.id.name;
+	const kind = classifyReactSymbol(name, declarator.init);
+	if (kind === void 0) return;
+	symbolsByName.set(name, createPendingSymbol(filePath, name, kind, declarator.init));
+}
+function addDefaultExportSymbol(declaration, filePath, symbolsByName) {
+	if (declaration.declaration.type === "FunctionDeclaration" || declaration.declaration.type === "FunctionExpression") addFunctionSymbol(declaration.declaration, filePath, symbolsByName);
+	else if (declaration.declaration.type === "ArrowFunctionExpression") {
+		const name = "default";
+		const kind = declaration.declaration.body ? classifyReactSymbol(name, declaration.declaration) : void 0;
+		if (kind !== void 0) symbolsByName.set(name, createPendingSymbol(filePath, name, kind, declaration.declaration));
+	}
+}
+function createPendingSymbol(filePath, name, kind, declaration) {
+	return {
+		id: `${filePath}#${kind}:${name}`,
+		name,
+		kind,
+		filePath,
+		declaration,
+		exportNames: /* @__PURE__ */ new Set(),
+		componentReferences: /* @__PURE__ */ new Set(),
+		hookReferences: /* @__PURE__ */ new Set()
+	};
+}
+//#endregion
+//#region src/analyzers/react/usage.ts
+function analyzeSymbolUsages(symbol) {
+	const root = symbol.declaration.type === "ArrowFunctionExpression" ? symbol.declaration.body : symbol.declaration.body;
+	if (root === null) return;
+	walkReactUsageTree(root, (node) => {
+		if (node.type === "JSXElement") {
+			const name = getComponentReferenceName(node);
+			if (name !== void 0) symbol.componentReferences.add(name);
+			return;
+		}
+		if (node.type === "CallExpression") {
+			const hookReference = getHookReferenceName(node);
+			if (hookReference !== void 0) symbol.hookReferences.add(hookReference);
+			const componentReference = getCreateElementComponentReferenceName(node);
+			if (componentReference !== void 0) symbol.componentReferences.add(componentReference);
+		}
+	});
+}
+//#endregion
+//#region src/analyzers/react/file.ts
+function analyzeReactFile(program, filePath, sourceText, includeNestedRenderEntries, sourceDependencies) {
+	const symbolsByName = /* @__PURE__ */ new Map();
+	program.body.forEach((statement) => {
+		collectTopLevelReactSymbols(statement, filePath, symbolsByName);
+	});
+	const importsByLocalName = /* @__PURE__ */ new Map();
+	const exportsByName = /* @__PURE__ */ new Map();
+	const entryUsages = collectEntryUsages(program, filePath, sourceText, includeNestedRenderEntries);
+	program.body.forEach((statement) => {
+		collectImportsAndExports(statement, sourceDependencies, symbolsByName, importsByLocalName, exportsByName);
+	});
+	symbolsByName.forEach((symbol) => {
+		analyzeSymbolUsages(symbol);
+	});
+	return {
+		filePath,
+		importsByLocalName,
+		exportsByName,
+		entryUsages,
+		symbolsById: new Map([...symbolsByName.values()].map((symbol) => [symbol.id, symbol])),
+		symbolsByName
+	};
+}
+//#endregion
+//#region src/analyzers/react/references.ts
 function resolveReactReference(fileAnalysis, fileAnalyses, name, kind) {
 	const localSymbol = fileAnalysis.symbolsByName.get(name);
 	if (localSymbol !== void 0 && localSymbol.kind === kind) return localSymbol.id;
@@ -776,6 +694,14 @@ function resolveReactReference(fileAnalysis, fileAnalyses, name, kind) {
 	if (targetId === void 0) return;
 	return sourceFileAnalysis.symbolsById.get(targetId)?.kind === kind ? targetId : void 0;
 }
+function addExternalHookNodes(fileAnalyses, nodes) {
+	for (const fileAnalysis of fileAnalyses.values()) fileAnalysis.importsByLocalName.forEach((binding, localName) => {
+		if (binding.sourcePath !== void 0) return;
+		if (!isHookName(localName) && !isHookName(binding.importedName)) return;
+		const externalNode = createExternalHookNode(binding, localName);
+		if (!nodes.has(externalNode.id)) nodes.set(externalNode.id, externalNode);
+	});
+}
 function createExternalHookNode(binding, localName) {
 	const name = getExternalHookName(binding, localName);
 	return {
@@ -793,54 +719,6 @@ function getExternalHookNodeId(binding, localName) {
 function getExternalHookName(binding, localName) {
 	return binding.importedName === "default" ? localName : binding.importedName;
 }
-function getFilteredReactUsageNodes(graph, filter) {
-	return [...graph.nodes.values()].filter((node) => matchesReactFilter(node, filter)).sort((left, right) => compareReactNodes(left, right));
-}
-function matchesReactFilter(node, filter) {
-	return filter === "all" || node.kind === filter;
-}
-function serializeReactUsageNode(nodeId, graph, filter, visited) {
-	const node = graph.nodes.get(nodeId);
-	if (node === void 0) return {
-		id: nodeId,
-		name: nodeId,
-		symbolKind: "circular",
-		filePath: "",
-		exportNames: [],
-		usages: []
-	};
-	if (visited.has(nodeId)) return {
-		id: node.id,
-		name: node.name,
-		symbolKind: "circular",
-		filePath: toDisplayPath(node.filePath, graph.cwd),
-		exportNames: node.exportNames,
-		usages: []
-	};
-	const nextVisited = new Set(visited);
-	nextVisited.add(nodeId);
-	return {
-		id: node.id,
-		name: node.name,
-		symbolKind: node.kind,
-		filePath: toDisplayPath(node.filePath, graph.cwd),
-		exportNames: node.exportNames,
-		usages: getFilteredUsages(node, graph, filter).map((usage) => ({
-			kind: usage.kind,
-			targetId: usage.target,
-			node: serializeReactUsageNode(usage.target, graph, filter, nextVisited)
-		}))
-	};
-}
-function serializeReactUsageEntry(entry, graph, filter) {
-	return {
-		targetId: entry.target,
-		filePath: toDisplayPath(entry.location.filePath, graph.cwd),
-		line: entry.location.line,
-		column: entry.location.column,
-		node: serializeReactUsageNode(entry.target, graph, filter, /* @__PURE__ */ new Set())
-	};
-}
 function compareReactNodeIds(leftId, rightId, nodes) {
 	const left = nodes.get(leftId);
 	const right = nodes.get(rightId);
@@ -850,20 +728,138 @@ function compareReactNodeIds(leftId, rightId, nodes) {
 function compareReactUsageEntries(left, right, nodes) {
 	return left.location.filePath.localeCompare(right.location.filePath) || left.location.line - right.location.line || left.location.column - right.location.column || compareReactNodeIds(left.target, right.target, nodes);
 }
-function comparePendingReactUsageEntries(left, right) {
-	return left.location.filePath.localeCompare(right.location.filePath) || left.location.line - right.location.line || left.location.column - right.location.column || left.referenceName.localeCompare(right.referenceName);
-}
 function compareReactNodes(left, right) {
 	return left.filePath.localeCompare(right.filePath) || left.name.localeCompare(right.name) || left.kind.localeCompare(right.kind);
 }
-function toModuleExportName(name) {
-	return name.type === "Literal" ? name.value : name.name;
+//#endregion
+//#region src/analyzers/react/index.ts
+function analyzeReactUsage(entryFile, options = {}) {
+	return new ReactAnalyzer(entryFile, options).analyze();
+}
+var ReactAnalyzer = class extends BaseAnalyzer {
+	doAnalyze() {
+		const dependencyGraph = analyzeDependencies(this.entryFile, this.options);
+		const fileAnalyses = this.collectFileAnalyses(dependencyGraph);
+		const nodes = this.createNodes(fileAnalyses);
+		this.attachUsages(fileAnalyses, nodes);
+		const entries = this.collectEntries(fileAnalyses, nodes);
+		return {
+			cwd: dependencyGraph.cwd,
+			entryId: dependencyGraph.entryId,
+			nodes,
+			entries
+		};
+	}
+	collectFileAnalyses(dependencyGraph) {
+		const reachableFiles = new Set([dependencyGraph.entryId, ...dependencyGraph.nodes.keys()]);
+		const fileAnalyses = /* @__PURE__ */ new Map();
+		for (const filePath of [...reachableFiles].sort()) {
+			if (!isSourceCodeFile(filePath) || filePath.endsWith(".d.ts")) continue;
+			const sourceText = fs.readFileSync(filePath, "utf8");
+			const parseResult = parseSync(filePath, sourceText, {
+				astType: "ts",
+				sourceType: "unambiguous"
+			});
+			const dependencyNode = dependencyGraph.nodes.get(filePath);
+			const sourceDependencies = /* @__PURE__ */ new Map();
+			dependencyNode?.dependencies.forEach((dependency) => {
+				if (dependency.kind === "source") sourceDependencies.set(dependency.specifier, dependency.target);
+			});
+			fileAnalyses.set(filePath, analyzeReactFile(parseResult.program, filePath, sourceText, filePath === dependencyGraph.entryId, sourceDependencies));
+		}
+		return fileAnalyses;
+	}
+	createNodes(fileAnalyses) {
+		const nodes = /* @__PURE__ */ new Map();
+		for (const fileAnalysis of fileAnalyses.values()) for (const symbol of fileAnalysis.symbolsById.values()) nodes.set(symbol.id, {
+			id: symbol.id,
+			name: symbol.name,
+			kind: symbol.kind,
+			filePath: symbol.filePath,
+			exportNames: [...symbol.exportNames].sort(),
+			usages: []
+		});
+		addExternalHookNodes(fileAnalyses, nodes);
+		return nodes;
+	}
+	attachUsages(fileAnalyses, nodes) {
+		for (const fileAnalysis of fileAnalyses.values()) for (const symbol of fileAnalysis.symbolsById.values()) {
+			const usages = /* @__PURE__ */ new Map();
+			symbol.componentReferences.forEach((referenceName) => {
+				const targetId = resolveReactReference(fileAnalysis, fileAnalyses, referenceName, "component");
+				if (targetId !== void 0 && targetId !== symbol.id) usages.set(`render:${targetId}`, {
+					kind: "render",
+					target: targetId
+				});
+			});
+			symbol.hookReferences.forEach((referenceName) => {
+				const targetId = resolveReactReference(fileAnalysis, fileAnalyses, referenceName, "hook");
+				if (targetId !== void 0 && targetId !== symbol.id) usages.set(`hook:${targetId}`, {
+					kind: "hook-call",
+					target: targetId
+				});
+			});
+			const node = nodes.get(symbol.id);
+			if (node === void 0) continue;
+			const sortedUsages = [...usages.values()].sort((left, right) => compareReactNodeIds(left.target, right.target, nodes));
+			nodes.set(symbol.id, {
+				...node,
+				usages: sortedUsages
+			});
+		}
+	}
+	collectEntries(fileAnalyses, nodes) {
+		const entriesByKey = /* @__PURE__ */ new Map();
+		for (const fileAnalysis of fileAnalyses.values()) for (const entry of fileAnalysis.entryUsages) {
+			const targetId = resolveReactReference(fileAnalysis, fileAnalyses, entry.referenceName, entry.kind);
+			if (targetId === void 0) continue;
+			const key = `${entry.location.filePath}:${entry.location.line}:${entry.location.column}:${targetId}`;
+			entriesByKey.set(key, {
+				target: targetId,
+				location: entry.location
+			});
+		}
+		return [...entriesByKey.values()].sort((left, right) => compareReactUsageEntries(left, right, nodes));
+	}
+};
+//#endregion
+//#region src/analyzers/react/queries.ts
+function getReactUsageEntries(graph, filter = "all") {
+	return graph.entries.filter((entry) => {
+		const targetNode = graph.nodes.get(entry.target);
+		return targetNode !== void 0 && matchesReactFilter(targetNode, filter);
+	});
 }
-function isHookName(name) {
-	return /^use[A-Z0-9]/.test(name);
+function getReactUsageRoots(graph, filter = "all") {
+	const entries = getReactUsageEntries(graph, filter);
+	if (entries.length > 0) return [...new Set(entries.map((entry) => entry.target))];
+	const filteredNodes = getFilteredReactUsageNodes(graph, filter);
+	const inboundCounts = /* @__PURE__ */ new Map();
+	filteredNodes.forEach((node) => {
+		inboundCounts.set(node.id, 0);
+	});
+	filteredNodes.forEach((node) => {
+		getFilteredUsages(node, graph, filter).forEach((usage) => {
+			inboundCounts.set(usage.target, (inboundCounts.get(usage.target) ?? 0) + 1);
+		});
+	});
+	const roots = filteredNodes.filter((node) => (inboundCounts.get(node.id) ?? 0) === 0).map((node) => node.id);
+	if (roots.length > 0) return roots.sort((left, right) => compareReactNodeIds(left, right, graph.nodes));
+	return filteredNodes.map((node) => node.id).sort((left, right) => compareReactNodeIds(left, right, graph.nodes));
 }
-function isComponentName(name) {
-	return /^[A-Z]/.test(name);
+function getFilteredUsages(node, graph, filter = "all") {
+	return node.usages.filter((usage) => {
+		const targetNode = graph.nodes.get(usage.target);
+		return targetNode !== void 0 && matchesReactFilter(targetNode, filter);
+	});
+}
+function getFilteredReactUsageNodes(graph, filter) {
+	return [...graph.nodes.values()].filter((node) => matchesReactFilter(node, filter)).sort((left, right) => {
+		return left.filePath.localeCompare(right.filePath) || left.name.localeCompare(right.name) || left.kind.localeCompare(right.kind);
+	});
+}
+function matchesReactFilter(node, filter) {
+	return filter === "all" || node.kind === filter;
 }
 //#endregion
 //#region src/color.ts
@@ -889,7 +885,72 @@ function formatReactSymbolLabel(name, kind, enabled) {
 	return `${kind === "component" ? ANSI_COMPONENT : ANSI_HOOK}${label}${ANSI_RESET}`;
 }
 //#endregion
-//#region src/react-tree.ts
+//#region src/utils/to-display-path.ts
+function toDisplayPath(filePath, cwd) {
+	const relativePath = path.relative(cwd, filePath);
+	if (relativePath === "") return ".";
+	const normalizedPath = relativePath.split(path.sep).join("/");
+	return normalizedPath.startsWith("..") ? filePath : normalizedPath;
+}
+//#endregion
+//#region src/output/ascii/import.ts
+function printDependencyTree(graph, options = {}) {
+	const cwd = options.cwd ?? graph.cwd;
+	const color = resolveColorSupport(options.color);
+	const includeExternals = options.includeExternals ?? false;
+	const omitUnused = options.omitUnused ?? false;
+	const rootLines = [toDisplayPath(graph.entryId, cwd)];
+	const visited = new Set([graph.entryId]);
+	const entryNode = graph.nodes.get(graph.entryId);
+	if (entryNode === void 0) return rootLines.join("\n");
+	const rootDependencies = filterDependencies(entryNode.dependencies, includeExternals, omitUnused);
+	rootDependencies.forEach((dependency, index) => {
+		rootLines.push(...renderDependency(dependency, graph, visited, "", index === rootDependencies.length - 1, includeExternals, omitUnused, color, cwd));
+	});
+	return rootLines.join("\n");
+}
+function renderDependency(dependency, graph, visited, prefix, isLast, includeExternals, omitUnused, color, cwd) {
+	const branch = `${prefix}${isLast ? "└─ " : "├─ "}`;
+	const label = formatDependencyLabel(dependency, cwd, color);
+	if (dependency.kind !== "source") return [`${branch}${label}`];
+	if (visited.has(dependency.target)) return [`${branch}${label} (circular)`];
+	const childNode = graph.nodes.get(dependency.target);
+	if (childNode === void 0) return [`${branch}${label}`];
+	const nextPrefix = `${prefix}${isLast ? "   " : "│  "}`;
+	const nextVisited = new Set(visited);
+	nextVisited.add(dependency.target);
+	const childLines = [`${branch}${label}`];
+	const childDependencies = filterDependencies(childNode.dependencies, includeExternals, omitUnused);
+	childDependencies.forEach((childDependency, index) => {
+		childLines.push(...renderDependency(childDependency, graph, nextVisited, nextPrefix, index === childDependencies.length - 1, includeExternals, omitUnused, color, cwd));
+	});
+	return childLines;
+}
+function filterDependencies(dependencies, includeExternals, omitUnused) {
+	return dependencies.filter((dependency) => {
+		if (omitUnused && dependency.unused) return false;
+		if (dependency.kind === "source" || dependency.kind === "missing") return true;
+		return includeExternals;
+	});
+}
+function formatDependencyLabel(dependency, cwd, color) {
+	const prefixes = [];
+	if (dependency.isTypeOnly) prefixes.push("type");
+	if (dependency.referenceKind === "require") prefixes.push("require");
+	else if (dependency.referenceKind === "dynamic-import") prefixes.push("dynamic");
+	else if (dependency.referenceKind === "export") prefixes.push("re-export");
+	else if (dependency.referenceKind === "import-equals") prefixes.push("import=");
+	const annotation = prefixes.length > 0 ? `[${prefixes.join(", ")}] ` : "";
+	if (dependency.kind === "source") return colorizeUnusedMarker(withUnusedSuffix(`${annotation}${toDisplayPath(dependency.target, cwd)}`, dependency.unused), color);
+	if (dependency.kind === "missing") return colorizeUnusedMarker(withUnusedSuffix(`${annotation}${dependency.specifier} [missing]`, dependency.unused), color);
+	if (dependency.kind === "builtin") return colorizeUnusedMarker(withUnusedSuffix(`${annotation}${dependency.target} [builtin]`, dependency.unused), color);
+	return colorizeUnusedMarker(withUnusedSuffix(`${annotation}${dependency.target} [external]`, dependency.unused), color);
+}
+function withUnusedSuffix(label, unused) {
+	return unused ? `${label} (unused)` : label;
+}
+//#endregion
+//#region src/output/ascii/react.ts
 function printReactUsageTree(graph, options = {}) {
 	const cwd = options.cwd ?? graph.cwd;
 	const color = resolveColorSupport(options.color);
@@ -948,65 +1009,105 @@ function formatReactEntryLabel(entry, cwd) {
 	return `${toDisplayPath(entry.location.filePath, cwd)}:${entry.location.line}:${entry.location.column}`;
 }
 //#endregion
-//#region src/tree.ts
-function printDependencyTree(graph, options = {}) {
-	const cwd = options.cwd ?? graph.cwd;
-	const color = resolveColorSupport(options.color);
-	const includeExternals = options.includeExternals ?? false;
-	const omitUnused = options.omitUnused ?? false;
-	const rootLines = [toDisplayPath(graph.entryId, cwd)];
-	const visited = new Set([graph.entryId]);
-	const entryNode = graph.nodes.get(graph.entryId);
-	if (entryNode === void 0) return rootLines.join("\n");
-	const rootDependencies = filterDependencies(entryNode.dependencies, includeExternals, omitUnused);
-	rootDependencies.forEach((dependency, index) => {
-		const lines = renderDependency(dependency, graph, visited, "", index === rootDependencies.length - 1, includeExternals, omitUnused, color, cwd);
-		rootLines.push(...lines);
-	});
-	return rootLines.join("\n");
+//#region src/output/json/import.ts
+function graphToSerializableTree(graph, options = {}) {
+	const visited = /* @__PURE__ */ new Set();
+	return serializeNode(graph.entryId, graph, visited, options.omitUnused ?? false);
 }
-function renderDependency(dependency, graph, visited, prefix, isLast, includeExternals, omitUnused, color, cwd) {
-	const branch = `${prefix}${isLast ? "└─ " : "├─ "}`;
-	const label = formatDependencyLabel(dependency, cwd, color);
-	if (dependency.kind !== "source") return [`${branch}${label}`];
-	if (visited.has(dependency.target)) return [`${branch}${label} (circular)`];
-	const childNode = graph.nodes.get(dependency.target);
-	if (childNode === void 0) return [`${branch}${label}`];
-	const nextPrefix = `${prefix}${isLast ? "   " : "│  "}`;
-	const nextVisited = new Set(visited);
-	nextVisited.add(dependency.target);
-	const childLines = [`${branch}${label}`];
-	const childDependencies = filterDependencies(childNode.dependencies, includeExternals, omitUnused);
-	childDependencies.forEach((childDependency, index) => {
-		const isChildLast = index === childDependencies.length - 1;
-		childLines.push(...renderDependency(childDependency, graph, nextVisited, nextPrefix, isChildLast, includeExternals, omitUnused, color, cwd));
+function serializeNode(filePath, graph, visited, omitUnused) {
+	const node = graph.nodes.get(filePath);
+	const displayPath = toDisplayPath(filePath, graph.cwd);
+	if (node === void 0) return {
+		path: displayPath,
+		kind: "missing",
+		dependencies: []
+	};
+	if (visited.has(filePath)) return {
+		path: displayPath,
+		kind: "circular",
+		dependencies: []
+	};
+	visited.add(filePath);
+	const dependencies = node.dependencies.filter((dependency) => !omitUnused || !dependency.unused).map((dependency) => {
+		if (dependency.kind !== "source") return {
+			specifier: dependency.specifier,
+			referenceKind: dependency.referenceKind,
+			isTypeOnly: dependency.isTypeOnly,
+			unused: dependency.unused,
+			kind: dependency.kind,
+			target: dependency.kind === "missing" ? dependency.target : toDisplayPath(dependency.target, graph.cwd)
+		};
+		return {
+			specifier: dependency.specifier,
+			referenceKind: dependency.referenceKind,
+			isTypeOnly: dependency.isTypeOnly,
+			unused: dependency.unused,
+			kind: dependency.kind,
+			target: toDisplayPath(dependency.target, graph.cwd),
+			node: serializeNode(dependency.target, graph, new Set(visited), omitUnused)
+		};
 	});
-	return childLines;
+	return {
+		path: displayPath,
+		kind: filePath === graph.entryId ? "entry" : "source",
+		dependencies
+	};
 }
-function filterDependencies(dependencies, includeExternals, omitUnused) {
-	return dependencies.filter((dependency) => {
-		if (omitUnused && dependency.unused) return false;
-		if (dependency.kind === "source" || dependency.kind === "missing") return true;
-		return includeExternals;
-	});
+//#endregion
+//#region src/output/json/react.ts
+function graphToSerializableReactTree(graph, options = {}) {
+	const filter = options.filter ?? "all";
+	const entries = getReactUsageEntries(graph, filter);
+	const roots = entries.length > 0 ? entries.map((entry) => serializeReactUsageNode(entry.target, graph, filter, /* @__PURE__ */ new Set())) : getReactUsageRoots(graph, filter).map((rootId) => serializeReactUsageNode(rootId, graph, filter, /* @__PURE__ */ new Set()));
+	return {
+		kind: "react-usage",
+		entries: entries.map((entry) => serializeReactUsageEntry(entry, graph, filter)),
+		roots
+	};
 }
-function formatDependencyLabel(dependency, cwd, color) {
-	const prefixes = [];
-	if (dependency.isTypeOnly) prefixes.push("type");
-	if (dependency.referenceKind === "require") prefixes.push("require");
-	else if (dependency.referenceKind === "dynamic-import") prefixes.push("dynamic");
-	else if (dependency.referenceKind === "export") prefixes.push("re-export");
-	else if (dependency.referenceKind === "import-equals") prefixes.push("import=");
-	const annotation = prefixes.length > 0 ? `[${prefixes.join(", ")}] ` : "";
-	if (dependency.kind === "source") return colorizeUnusedMarker(withUnusedSuffix(`${annotation}${toDisplayPath(dependency.target, cwd)}`, dependency.unused), color);
-	if (dependency.kind === "missing") return colorizeUnusedMarker(withUnusedSuffix(`${annotation}${dependency.specifier} [missing]`, dependency.unused), color);
-	if (dependency.kind === "builtin") return colorizeUnusedMarker(withUnusedSuffix(`${annotation}${dependency.target} [builtin]`, dependency.unused), color);
-	return colorizeUnusedMarker(withUnusedSuffix(`${annotation}${dependency.target} [external]`, dependency.unused), color);
+function serializeReactUsageNode(nodeId, graph, filter, visited) {
+	const node = graph.nodes.get(nodeId);
+	if (node === void 0) return {
+		id: nodeId,
+		name: nodeId,
+		symbolKind: "circular",
+		filePath: "",
+		exportNames: [],
+		usages: []
+	};
+	if (visited.has(nodeId)) return {
+		id: node.id,
+		name: node.name,
+		symbolKind: "circular",
+		filePath: toDisplayPath(node.filePath, graph.cwd),
+		exportNames: node.exportNames,
+		usages: []
+	};
+	const nextVisited = new Set(visited);
+	nextVisited.add(nodeId);
+	return {
+		id: node.id,
+		name: node.name,
+		symbolKind: node.kind,
+		filePath: toDisplayPath(node.filePath, graph.cwd),
+		exportNames: node.exportNames,
+		usages: getFilteredUsages(node, graph, filter).map((usage) => ({
+			kind: usage.kind,
+			targetId: usage.target,
+			node: serializeReactUsageNode(usage.target, graph, filter, nextVisited)
+		}))
+	};
 }
-function withUnusedSuffix(label, unused) {
-	return unused ? `${label} (unused)` : label;
+function serializeReactUsageEntry(entry, graph, filter) {
+	return {
+		targetId: entry.target,
+		filePath: toDisplayPath(entry.location.filePath, graph.cwd),
+		line: entry.location.line,
+		column: entry.location.column,
+		node: serializeReactUsageNode(entry.target, graph, filter, /* @__PURE__ */ new Set())
+	};
 }
 //#endregion
-export { graphToSerializableReactTree as a, getReactUsageRoots as i, printReactUsageTree as n, analyzeDependencies as o, analyzeReactUsage as r, graphToSerializableTree as s, printDependencyTree as t };
+export { getFilteredUsages as a, analyzeReactUsage as c, printDependencyTree as i, analyzeDependencies as l, graphToSerializableTree as n, getReactUsageEntries as o, printReactUsageTree as r, getReactUsageRoots as s, graphToSerializableReactTree as t };
 
-//# sourceMappingURL=tree-Qsy9Nmh9.mjs.map
+//# sourceMappingURL=react-CWIt8V0Y.mjs.map