foresthouse 1.0.0-dev.2 → 1.0.0-dev.21

package/dist/react-DWxB8qZ6.mjs

@@ -0,0 +1,2484 @@
+import { builtinModules } from "node:module";
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import ts from "typescript";
+import { ResolverFactory } from "oxc-resolver";
+import { parseSync, visitorKeys } from "oxc-parser";
+import process$1 from "node:process";
+//#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/analyzers/base.ts
+var BaseAnalyzer = class {
+	constructor(entryFile, options) {
+		this.entryFile = entryFile;
+		this.options = options;
+	}
+	analyze() {
+		return this.doAnalyze();
+	}
+};
+//#endregion
+//#region src/analyzers/deps/index.ts
+const PNPM_WORKSPACE_FILE$1 = "pnpm-workspace.yaml";
+function analyzePackageDependencies(directory) {
+	return new PackageDependencyAnalyzer(directory).analyze();
+}
+var PackageDependencyAnalyzer = class extends BaseAnalyzer {
+	inputPath;
+	constructor(directory) {
+		super(directory, {});
+		this.inputPath = path.resolve(process.cwd(), directory);
+	}
+	doAnalyze() {
+		const rootPackageDir = findNearestPackageDirectory(resolveInputDirectory(this.inputPath));
+		const workspaceRootDir = findWorkspaceRoot(rootPackageDir) ?? rootPackageDir;
+		const workspacePackages = discoverWorkspacePackages(workspaceRootDir);
+		const nodes = /* @__PURE__ */ new Map();
+		visitPackage(rootPackageDir, workspaceRootDir, workspacePackages, nodes);
+		return {
+			repositoryRoot: workspaceRootDir,
+			rootId: rootPackageDir,
+			nodes
+		};
+	}
+};
+function visitPackage(packageDir, repositoryRoot, workspacePackages, nodes) {
+	if (nodes.has(packageDir)) return;
+	const manifest = readPackageManifest(packageDir);
+	const packageName = resolvePackageName(manifest, packageDir);
+	const dependencies = packageDir === repositoryRoot && workspacePackages.size > 0 ? collectRepositoryRootDependencies(manifest, workspacePackages, repositoryRoot) : collectManifestDependencies(manifest, workspacePackages, repositoryRoot);
+	nodes.set(packageDir, {
+		packageDir,
+		packageName,
+		dependencies
+	});
+	dependencies.forEach((dependency) => {
+		if (dependency.kind === "workspace") visitPackage(dependency.target, repositoryRoot, workspacePackages, nodes);
+	});
+}
+function resolveInputDirectory(resolvedPath) {
+	const stats = fs.existsSync(resolvedPath) ? fs.statSync(resolvedPath) : null;
+	if (stats === null) throw new Error(`Directory does not exist: ${resolvedPath}`);
+	if (stats.isDirectory()) return resolvedPath;
+	if (stats.isFile() && path.basename(resolvedPath) === "package.json") return path.dirname(resolvedPath);
+	throw new Error(`Expected a package directory: ${resolvedPath}`);
+}
+function findNearestPackageDirectory(startDirectory) {
+	let currentDirectory = startDirectory;
+	while (true) {
+		const packageJsonPath = path.join(currentDirectory, "package.json");
+		if (fs.existsSync(packageJsonPath)) return currentDirectory;
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) break;
+		currentDirectory = parentDirectory;
+	}
+	throw new Error(`No package.json found from ${startDirectory}`);
+}
+function findWorkspaceRoot(packageDir) {
+	let currentDirectory = packageDir;
+	while (true) {
+		const packageJsonPath = path.join(currentDirectory, "package.json");
+		if (fs.existsSync(packageJsonPath)) {
+			const manifest = readPackageManifest(currentDirectory);
+			const workspacePatterns = resolveWorkspacePatterns(currentDirectory, manifest);
+			if (workspacePatterns.length > 0 && currentDirectory === packageDir) return currentDirectory;
+			if (workspacePatterns.length > 0 && isWorkspaceMatch(currentDirectory, workspacePatterns, packageDir)) return currentDirectory;
+		}
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) return;
+		currentDirectory = parentDirectory;
+	}
+}
+function discoverWorkspacePackages(repositoryRoot) {
+	const workspacePatterns = resolveWorkspacePatterns(repositoryRoot, readPackageManifest(repositoryRoot));
+	if (workspacePatterns.length === 0) return /* @__PURE__ */ new Map();
+	const workspacePackageDirs = /* @__PURE__ */ new Set();
+	workspacePatterns.forEach((pattern) => {
+		expandWorkspacePattern(repositoryRoot, pattern).forEach((packageDir) => {
+			workspacePackageDirs.add(packageDir);
+		});
+	});
+	const workspacePackages = /* @__PURE__ */ new Map();
+	Array.from(workspacePackageDirs).sort((left, right) => left.localeCompare(right)).forEach((packageDir) => {
+		const workspaceName = resolvePackageName(readPackageManifest(packageDir), packageDir);
+		if (workspacePackages.has(workspaceName)) throw new Error(`Duplicate workspace package name: ${workspaceName}`);
+		workspacePackages.set(workspaceName, {
+			name: workspaceName,
+			packageDir,
+			label: toDisplayPath(packageDir, repositoryRoot)
+		});
+	});
+	return workspacePackages;
+}
+function collectManifestDependencies(manifest, workspacePackages, repositoryRoot) {
+	const dependencyEntries = Object.entries(manifest.dependencies ?? {});
+	const workspaceDependencies = [];
+	const externalDependencies = [];
+	dependencyEntries.forEach(([dependencyName, specifier]) => {
+		const workspacePackage = workspacePackages.get(dependencyName);
+		if (workspacePackage !== void 0) {
+			workspaceDependencies.push({
+				kind: "workspace",
+				name: dependencyName,
+				specifier,
+				target: workspacePackage.packageDir
+			});
+			return;
+		}
+		externalDependencies.push({
+			kind: "external",
+			name: dependencyName,
+			specifier
+		});
+	});
+	workspaceDependencies.sort((left, right) => {
+		const leftLabel = toDisplayPath(left.target, repositoryRoot);
+		const rightLabel = toDisplayPath(right.target, repositoryRoot);
+		return leftLabel.localeCompare(rightLabel);
+	});
+	externalDependencies.sort((left, right) => left.name.localeCompare(right.name));
+	return [...workspaceDependencies, ...externalDependencies];
+}
+function collectRepositoryRootDependencies(manifest, workspacePackages, _repositoryRoot) {
+	const topLevelWorkspaceDependencies = Array.from(workspacePackages.values()).sort((left, right) => left.label.localeCompare(right.label)).map((workspacePackage) => ({
+		kind: "workspace",
+		name: workspacePackage.name,
+		target: workspacePackage.packageDir
+	}));
+	const externalDependencies = Object.entries(manifest.dependencies ?? {}).filter(([dependencyName]) => !workspacePackages.has(dependencyName)).map(([dependencyName, specifier]) => ({
+		kind: "external",
+		name: dependencyName,
+		specifier
+	})).sort((left, right) => left.name.localeCompare(right.name));
+	return [...topLevelWorkspaceDependencies, ...externalDependencies];
+}
+function readPackageManifest(packageDir) {
+	const packageJsonPath = path.join(packageDir, "package.json");
+	if (!fs.existsSync(packageJsonPath)) throw new Error(`Missing package.json in ${packageDir}`);
+	const manifestText = fs.readFileSync(packageJsonPath, "utf8");
+	try {
+		const parsed = JSON.parse(manifestText);
+		if (!isRecord(parsed)) throw new Error("package.json must contain an object");
+		return parsed;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown JSON parse error";
+		throw new Error(`Failed to read ${packageJsonPath}: ${message}`);
+	}
+}
+function resolvePackageName(manifest, packageDir) {
+	if (typeof manifest.name === "string" && manifest.name.trim().length > 0) return manifest.name;
+	throw new Error(`Package at ${packageDir} is missing a valid name`);
+}
+function getWorkspacePatterns(manifest) {
+	if (Array.isArray(manifest.workspaces)) return manifest.workspaces.filter((pattern) => typeof pattern === "string" && pattern.length > 0);
+	if (isRecord(manifest.workspaces) && Array.isArray(manifest.workspaces.packages)) return manifest.workspaces.packages.filter((pattern) => typeof pattern === "string" && pattern.length > 0);
+	return [];
+}
+function resolveWorkspacePatterns(repositoryRoot, manifest) {
+	const manifestPatterns = getWorkspacePatterns(manifest);
+	if (manifestPatterns.length > 0) return manifestPatterns;
+	return readPnpmWorkspacePatterns(repositoryRoot);
+}
+function readPnpmWorkspacePatterns(repositoryRoot) {
+	const pnpmWorkspacePath = path.join(repositoryRoot, PNPM_WORKSPACE_FILE$1);
+	if (!fs.existsSync(pnpmWorkspacePath)) return [];
+	const lines = fs.readFileSync(pnpmWorkspacePath, "utf8").split(/\r?\n/);
+	const patterns = [];
+	let inPackagesBlock = false;
+	for (const line of lines) {
+		const trimmedLine = line.trim();
+		if (trimmedLine.length === 0 || trimmedLine.startsWith("#")) continue;
+		if (!inPackagesBlock) {
+			if (trimmedLine === "packages:") inPackagesBlock = true;
+			continue;
+		}
+		if (!line.startsWith(" ") && !line.startsWith("	")) break;
+		if (!trimmedLine.startsWith("- ")) continue;
+		const pattern = unquoteWorkspacePattern(trimmedLine.slice(2).trim());
+		if (pattern.length > 0) patterns.push(pattern);
+	}
+	return patterns;
+}
+function unquoteWorkspacePattern(pattern) {
+	if (pattern.startsWith("\"") && pattern.endsWith("\"") || pattern.startsWith("'") && pattern.endsWith("'")) return pattern.slice(1, -1);
+	return pattern;
+}
+function isWorkspaceMatch(repositoryRoot, patterns, packageDir) {
+	return patterns.some((pattern) => expandWorkspacePattern(repositoryRoot, pattern).includes(packageDir));
+}
+function expandWorkspacePattern(repositoryRoot, pattern) {
+	return matchWorkspaceSegments(repositoryRoot, normalizeWorkspacePattern(pattern), 0).filter((packageDir) => fs.existsSync(path.join(packageDir, "package.json")));
+}
+function normalizeWorkspacePattern(pattern) {
+	return pattern.split(/[\\/]+/).filter((segment) => segment.length > 0 && segment !== ".");
+}
+function matchWorkspaceSegments(currentDirectory, segments, index) {
+	if (index >= segments.length) return [currentDirectory];
+	const segment = segments[index];
+	if (segment === void 0) return [currentDirectory];
+	if (segment === "**") {
+		const results = new Set(matchWorkspaceSegments(currentDirectory, segments, index + 1));
+		listSubdirectories(currentDirectory).forEach((subdirectory) => {
+			matchWorkspaceSegments(subdirectory, segments, index).forEach((match) => {
+				results.add(match);
+			});
+		});
+		return [...results];
+	}
+	const matcher = createWorkspaceSegmentMatcher(segment);
+	const results = [];
+	listSubdirectories(currentDirectory).forEach((subdirectory) => {
+		if (!matcher(path.basename(subdirectory))) return;
+		results.push(...matchWorkspaceSegments(subdirectory, segments, index + 1));
+	});
+	return results;
+}
+function listSubdirectories(directory) {
+	return fs.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name !== "node_modules" && entry.name !== ".git").map((entry) => path.join(directory, entry.name));
+}
+function createWorkspaceSegmentMatcher(segment) {
+	if (!segment.includes("*")) return (name) => name === segment;
+	const escapedSegment = escapeRegExp(segment).replaceAll("*", "[^/]*");
+	const pattern = new RegExp(`^${escapedSegment}$`);
+	return (name) => pattern.test(name);
+}
+function escapeRegExp(value) {
+	return value.replaceAll(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+//#region src/analyzers/deps/pnpm-lock.ts
+const PNPM_LOCKFILE$1 = "pnpm-lock.yaml";
+const DEPENDENCY_SECTIONS = new Set(["dependencies", "optionalDependencies"]);
+function loadPnpmLockImporterResolutions(repositoryRoot) {
+	const lockfilePath = path.join(repositoryRoot, PNPM_LOCKFILE$1);
+	if (!fs.existsSync(lockfilePath)) return;
+	return parsePnpmLockImporterResolutions(fs.readFileSync(lockfilePath, "utf8"));
+}
+function parsePnpmLockImporterResolutions(source) {
+	const importers = /* @__PURE__ */ new Map();
+	const lines = source.split(/\r?\n/u);
+	let inImporters = false;
+	let currentImporter;
+	let currentSection;
+	let currentDependencyName;
+	lines.forEach((line) => {
+		const trimmedLine = line.trim();
+		if (trimmedLine.length === 0 || trimmedLine.startsWith("#")) return;
+		const indentation = line.length - line.trimStart().length;
+		if (indentation === 0) {
+			if (trimmedLine === "importers:") {
+				inImporters = true;
+				currentImporter = void 0;
+				currentSection = void 0;
+				currentDependencyName = void 0;
+				return;
+			}
+			inImporters = false;
+			return;
+		}
+		if (!inImporters) return;
+		if (indentation === 2 && trimmedLine.endsWith(":")) {
+			currentImporter = parseYamlScalar(trimmedLine.slice(0, -1));
+			currentSection = void 0;
+			currentDependencyName = void 0;
+			if (!importers.has(currentImporter)) importers.set(currentImporter, /* @__PURE__ */ new Map());
+			return;
+		}
+		if (currentImporter === void 0) return;
+		if (indentation === 4 && trimmedLine.endsWith(":")) {
+			const sectionName = parseYamlScalar(trimmedLine.slice(0, -1));
+			currentSection = DEPENDENCY_SECTIONS.has(sectionName) ? sectionName : void 0;
+			currentDependencyName = void 0;
+			return;
+		}
+		if (currentSection === void 0) return;
+		if (indentation === 6) {
+			if (trimmedLine.endsWith(":")) {
+				currentDependencyName = parseYamlScalar(trimmedLine.slice(0, -1));
+				upsertDependency(importers, currentImporter, currentDependencyName, {});
+				return;
+			}
+			const pair = splitYamlKeyValue(trimmedLine);
+			if (pair === void 0) return;
+			currentDependencyName = void 0;
+			upsertDependency(importers, currentImporter, parseYamlScalar(pair.key), { ...parsePnpmVersion(parseYamlScalar(pair.value)) });
+			return;
+		}
+		if (indentation === 8 && currentDependencyName !== void 0) {
+			const pair = splitYamlKeyValue(trimmedLine);
+			if (pair === void 0) return;
+			if (pair.key === "specifier") {
+				upsertDependency(importers, currentImporter, currentDependencyName, { specifier: parseYamlScalar(pair.value) });
+				return;
+			}
+			if (pair.key === "version") upsertDependency(importers, currentImporter, currentDependencyName, { ...parsePnpmVersion(parseYamlScalar(pair.value)) });
+		}
+	});
+	return importers;
+}
+function upsertDependency(importers, importerPath, dependencyName, nextValue) {
+	const importer = importers.get(importerPath);
+	if (importer === void 0) return;
+	importer.set(dependencyName, {
+		...importer.get(dependencyName),
+		...nextValue
+	});
+}
+function splitYamlKeyValue(line) {
+	const separatorIndex = line.indexOf(":");
+	if (separatorIndex <= 0) return;
+	return {
+		key: line.slice(0, separatorIndex).trim(),
+		value: line.slice(separatorIndex + 1).trim()
+	};
+}
+function parseYamlScalar(value) {
+	if (value.length >= 2) {
+		const firstCharacter = value[0];
+		const lastCharacter = value[value.length - 1];
+		if (firstCharacter === "\"" && lastCharacter === "\"" || firstCharacter === "'" && lastCharacter === "'") return value.slice(1, -1);
+	}
+	return value;
+}
+function parsePnpmVersion(value) {
+	const firstParenthesisIndex = value.indexOf("(");
+	if (firstParenthesisIndex < 0) return { version: value };
+	return {
+		version: value.slice(0, firstParenthesisIndex),
+		peerSuffix: value.slice(firstParenthesisIndex)
+	};
+}
+//#endregion
+//#region src/analyzers/deps/diff.ts
+const PNPM_LOCKFILE = "pnpm-lock.yaml";
+const PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
+function analyzePackageDependencyDiff(directory, diff) {
+	const resolvedInputPath = path.resolve(process.cwd(), directory);
+	const repositoryRoot = findGitRepositoryRoot(resolvedInputPath);
+	const inputPathWithinRepository = resolveRepositoryInputPath(resolvedInputPath, repositoryRoot);
+	const comparison = resolveGitDiffComparison(repositoryRoot, diff);
+	const beforeGraph = loadGitTreeGraph(repositoryRoot, comparison.beforeTree, inputPathWithinRepository);
+	const afterGraph = comparison.afterTree === void 0 ? loadWorkingTreeGraph(repositoryRoot, inputPathWithinRepository) : loadGitTreeGraph(repositoryRoot, comparison.afterTree, inputPathWithinRepository);
+	if (beforeGraph === void 0 && afterGraph === void 0) throw new Error(`No package.json found from ${resolvedInputPath}`);
+	const changedPackagePaths = collectChangedPackagePaths(repositoryRoot, comparison, beforeGraph, afterGraph);
+	return {
+		repositoryRoot,
+		root: diffPackageNode({
+			beforePath: beforeGraph?.rootPath,
+			afterPath: afterGraph?.rootPath,
+			kind: "root"
+		}, beforeGraph, afterGraph, changedPackagePaths, /* @__PURE__ */ new Set())
+	};
+}
+function resolveRepositoryInputPath(resolvedInputPath, repositoryRoot) {
+	const existingPath = findNearestExistingPath(resolvedInputPath);
+	const existingRealPath = fs.realpathSync.native(existingPath);
+	const repositoryRealPath = fs.realpathSync.native(repositoryRoot);
+	const relativeFromExistingPath = path.relative(existingPath, resolvedInputPath);
+	const relativeToRepository = path.relative(repositoryRealPath, existingRealPath);
+	const normalizedPath = path.normalize(path.join(relativeToRepository, relativeFromExistingPath));
+	return normalizedPath === "." ? "" : normalizedPath;
+}
+function findGitRepositoryRoot(resolvedInputPath) {
+	const searchPath = findNearestExistingPath(resolvedInputPath);
+	try {
+		return runGit(searchPath, ["rev-parse", "--show-toplevel"]).trim();
+	} catch (error) {
+		throw new Error(`Git diff mode requires a Git repository: ${getCommandErrorMessage(error)}`);
+	}
+}
+function findNearestExistingPath(resolvedInputPath) {
+	let currentPath = resolvedInputPath;
+	while (!fs.existsSync(currentPath)) {
+		const parentPath = path.dirname(currentPath);
+		if (parentPath === currentPath) return resolvedInputPath;
+		currentPath = parentPath;
+	}
+	if (fs.statSync(currentPath).isFile()) return path.dirname(currentPath);
+	return currentPath;
+}
+function resolveGitDiffComparison(repositoryRoot, diff) {
+	if (diff.includes("...")) {
+		const [baseRef, headRef] = splitDiffRange(diff, "...");
+		try {
+			return {
+				beforeTree: resolveGitTree(repositoryRoot, runGit(repositoryRoot, [
+					"merge-base",
+					baseRef,
+					headRef
+				]).trim()),
+				afterTree: resolveGitTree(repositoryRoot, headRef)
+			};
+		} catch (error) {
+			throw new Error(`Failed to resolve Git diff spec \`${diff}\`: ${getCommandErrorMessage(error)}`);
+		}
+	}
+	if (diff.includes("..")) {
+		const [beforeRef, afterRef] = splitDiffRange(diff, "..");
+		try {
+			return {
+				beforeTree: resolveGitTree(repositoryRoot, beforeRef),
+				afterTree: resolveGitTree(repositoryRoot, afterRef)
+			};
+		} catch (error) {
+			throw new Error(`Failed to resolve Git diff spec \`${diff}\`: ${getCommandErrorMessage(error)}`);
+		}
+	}
+	try {
+		return {
+			beforeTree: resolveGitTree(repositoryRoot, diff),
+			afterTree: void 0
+		};
+	} catch (error) {
+		throw new Error(`Failed to resolve Git diff spec \`${diff}\`: ${getCommandErrorMessage(error)}`);
+	}
+}
+function splitDiffRange(diff, separator) {
+	const [left, right, ...extra] = diff.split(separator);
+	if (left === void 0 || right === void 0 || left.length === 0 || right.length === 0 || extra.length > 0) throw new Error(`Invalid Git diff spec \`${diff}\``);
+	return [left, right];
+}
+function resolveGitTree(repositoryRoot, reference) {
+	return runGit(repositoryRoot, [
+		"rev-parse",
+		"--verify",
+		`${reference}^{tree}`
+	]).trim();
+}
+function loadWorkingTreeGraph(repositoryRoot, inputPathWithinRepository) {
+	const packageGraph = tryAnalyzePackageGraph(resolveSnapshotInputPath(repositoryRoot, inputPathWithinRepository));
+	return packageGraph === void 0 ? void 0 : toComparableGraph(packageGraph);
+}
+function loadGitTreeGraph(repositoryRoot, tree, inputPathWithinRepository) {
+	const snapshotRoot = materializeGitTreeSnapshot(repositoryRoot, tree);
+	try {
+		const packageGraph = tryAnalyzePackageGraph(resolveSnapshotInputPath(snapshotRoot, inputPathWithinRepository));
+		return packageGraph === void 0 ? void 0 : toComparableGraph(packageGraph);
+	} finally {
+		fs.rmSync(snapshotRoot, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function materializeGitTreeSnapshot(repositoryRoot, tree) {
+	const snapshotRoot = fs.mkdtempSync(path.join(os.tmpdir(), "foresthouse-deps-diff-"));
+	const trackedFiles = runGit(repositoryRoot, [
+		"ls-tree",
+		"-r",
+		"-z",
+		"--name-only",
+		tree
+	]).split("\0").filter((filePath) => filePath.length > 0);
+	trackedFiles.forEach((filePath) => {
+		ensureSnapshotDirectory(snapshotRoot, filePath);
+	});
+	trackedFiles.filter(isManifestSnapshotFile).forEach((filePath) => {
+		const fileContent = runGit(repositoryRoot, [
+			"cat-file",
+			"-p",
+			`${tree}:${filePath}`
+		], { trim: false });
+		const absolutePath = path.join(snapshotRoot, ...filePath.split("/"));
+		fs.writeFileSync(absolutePath, fileContent);
+	});
+	return snapshotRoot;
+}
+function ensureSnapshotDirectory(snapshotRoot, filePath) {
+	const parentDirectory = path.dirname(filePath);
+	if (parentDirectory === ".") return;
+	fs.mkdirSync(path.join(snapshotRoot, ...parentDirectory.split("/")), { recursive: true });
+}
+function isManifestSnapshotFile(filePath) {
+	const fileName = path.posix.basename(filePath);
+	return fileName === "package.json" || fileName === PNPM_LOCKFILE || fileName === PNPM_WORKSPACE_FILE;
+}
+function resolveSnapshotInputPath(snapshotRoot, inputPathWithinRepository) {
+	if (inputPathWithinRepository === "") return snapshotRoot;
+	return path.join(snapshotRoot, inputPathWithinRepository);
+}
+function tryAnalyzePackageGraph(inputPath) {
+	if (!fs.existsSync(inputPath)) return;
+	try {
+		return analyzePackageDependencies(inputPath);
+	} catch (error) {
+		if (error instanceof Error && error.message.startsWith("No package.json found from ")) return;
+		throw error;
+	}
+}
+function toComparableGraph(graph) {
+	const pnpmLockResolutions = loadPnpmLockImporterResolutions(graph.repositoryRoot);
+	const nodes = /* @__PURE__ */ new Map();
+	graph.nodes.forEach((node, packageDir) => {
+		const packagePath = toDisplayPath(packageDir, graph.repositoryRoot);
+		const packageLockResolutions = pnpmLockResolutions?.get(packagePath);
+		const dependenciesByKey = /* @__PURE__ */ new Map();
+		node.dependencies.forEach((dependency) => {
+			dependenciesByKey.set(createDependencyKey(dependency), toComparableDependency(dependency, graph.repositoryRoot, packageLockResolutions?.get(dependency.name)));
+		});
+		nodes.set(packagePath, {
+			path: packagePath,
+			packageName: node.packageName,
+			dependenciesByKey
+		});
+	});
+	return {
+		rootPath: toDisplayPath(graph.rootId, graph.repositoryRoot),
+		nodes
+	};
+}
+function createDependencyKey(dependency) {
+	return `${dependency.kind}:${dependency.name}`;
+}
+function toComparableDependency(dependency, repositoryRoot, lockResolution) {
+	if (dependency.kind === "external") {
+		const resolvedVersion = resolveResolvedVersion(lockResolution);
+		const peerContext = resolvePeerContext(lockResolution);
+		return {
+			kind: "external",
+			key: createDependencyKey(dependency),
+			name: dependency.name,
+			specifier: dependency.specifier,
+			...resolvedVersion === void 0 ? {} : { resolvedVersion },
+			...peerContext === void 0 ? {} : { peerContext }
+		};
+	}
+	return {
+		kind: "workspace",
+		key: createDependencyKey(dependency),
+		name: dependency.name,
+		specifier: dependency.specifier,
+		targetPath: toDisplayPath(dependency.target, repositoryRoot)
+	};
+}
+function resolveResolvedVersion(lockResolution) {
+	if (lockResolution === void 0) return;
+	const version = lockResolution.version?.trim();
+	if (version === void 0 || version.length === 0 || version.startsWith("link:") || version.startsWith("file:") || version.startsWith("workspace:")) return;
+	return version;
+}
+function resolvePeerContext(lockResolution) {
+	const peerSuffix = lockResolution?.peerSuffix?.trim();
+	return peerSuffix === void 0 || peerSuffix.length === 0 ? void 0 : peerSuffix;
+}
+function diffPackageNode(location, beforeGraph, afterGraph, changedPackagePaths, ancestry) {
+	const nodeKey = `${location.beforePath ?? ""}->${location.afterPath ?? ""}`;
+	const beforeNode = location.beforePath === void 0 ? void 0 : beforeGraph?.nodes.get(location.beforePath);
+	const afterNode = location.afterPath === void 0 ? void 0 : afterGraph?.nodes.get(location.afterPath);
+	if (beforeNode === void 0 && afterNode === void 0) throw new Error("Unable to resolve package diff node.");
+	const packageName = afterNode?.packageName ?? beforeNode?.packageName ?? location.afterPath ?? location.beforePath ?? ".";
+	const packagePath = location.afterPath ?? location.beforePath ?? ".";
+	if (ancestry.has(nodeKey)) return {
+		kind: "circular",
+		label: location.kind === "root" ? packageName : packagePath,
+		packageName,
+		path: packagePath,
+		change: "unchanged",
+		dependencies: []
+	};
+	const nextAncestry = new Set(ancestry);
+	nextAncestry.add(nodeKey);
+	const dependencies = collectDependencyDiffs(beforeNode, afterNode, beforeGraph, afterGraph, changedPackagePaths, nextAncestry);
+	const change = resolveNodeChange(location, beforeNode, afterNode, dependencies, changedPackagePaths);
+	return {
+		kind: location.kind,
+		label: location.kind === "root" ? packageName : packagePath,
+		packageName,
+		path: packagePath,
+		change,
+		...beforeNode !== void 0 && afterNode !== void 0 && beforeNode.packageName !== afterNode.packageName ? {
+			beforePackageName: beforeNode.packageName,
+			afterPackageName: afterNode.packageName
+		} : {},
+		dependencies
+	};
+}
+function collectDependencyDiffs(beforeNode, afterNode, beforeGraph, afterGraph, changedPackagePaths, ancestry) {
+	const dependencyKeys = new Set([...Array.from(beforeNode?.dependenciesByKey.keys() ?? []), ...Array.from(afterNode?.dependenciesByKey.keys() ?? [])]);
+	return Array.from(dependencyKeys).sort((left, right) => compareDependencyLabels(beforeNode?.dependenciesByKey.get(left) ?? afterNode?.dependenciesByKey.get(left), beforeNode?.dependenciesByKey.get(right) ?? afterNode?.dependenciesByKey.get(right))).flatMap((dependencyKey) => {
+		const dependency = diffDependency(beforeNode?.dependenciesByKey.get(dependencyKey), afterNode?.dependenciesByKey.get(dependencyKey), beforeGraph, afterGraph, changedPackagePaths, ancestry);
+		return dependency === void 0 ? [] : [dependency];
+	});
+}
+function compareDependencyLabels(left, right) {
+	const leftLabel = left === void 0 ? "" : getDependencySortLabel(left);
+	const rightLabel = right === void 0 ? "" : getDependencySortLabel(right);
+	return leftLabel.localeCompare(rightLabel);
+}
+function getDependencySortLabel(dependency) {
+	if (dependency.kind === "external") return `${dependency.name}@${dependency.specifier}`;
+	return dependency.targetPath;
+}
+function diffDependency(beforeDependency, afterDependency, beforeGraph, afterGraph, changedPackagePaths, ancestry) {
+	const change = resolveDependencyChange(beforeDependency, afterDependency);
+	if (beforeDependency?.kind === "workspace" || afterDependency?.kind === "workspace") {
+		const workspaceDependency = afterDependency?.kind === "workspace" ? afterDependency : beforeDependency?.kind === "workspace" ? beforeDependency : void 0;
+		if (workspaceDependency === void 0) return;
+		const node = diffPackageNode({
+			beforePath: beforeDependency?.kind === "workspace" ? beforeDependency.targetPath : void 0,
+			afterPath: afterDependency?.kind === "workspace" ? afterDependency.targetPath : void 0,
+			kind: "workspace"
+		}, beforeGraph, afterGraph, changedPackagePaths, ancestry);
+		if (change === "unchanged" && !hasVisibleChanges(node)) return;
+		return {
+			kind: "workspace",
+			name: workspaceDependency.name,
+			change,
+			...beforeDependency === void 0 ? {} : { before: toDiffState(beforeDependency) },
+			...afterDependency === void 0 ? {} : { after: toDiffState(afterDependency) },
+			node
+		};
+	}
+	if (change === "unchanged") return;
+	const dependency = afterDependency ?? beforeDependency;
+	if (dependency === void 0 || dependency.kind !== "external") return;
+	return {
+		kind: "external",
+		name: dependency.name,
+		change,
+		specifierChanged: didExternalSpecifierChange(beforeDependency, afterDependency),
+		resolvedVersionChanged: didExternalResolvedVersionChange(beforeDependency, afterDependency),
+		peerContextChanged: didExternalPeerContextChange(beforeDependency, afterDependency),
+		...beforeDependency === void 0 ? {} : { before: toDiffState(beforeDependency) },
+		...afterDependency === void 0 ? {} : { after: toDiffState(afterDependency) }
+	};
+}
+function didExternalSpecifierChange(beforeDependency, afterDependency) {
+	return beforeDependency?.kind === "external" && afterDependency?.kind === "external" && beforeDependency.specifier !== afterDependency.specifier;
+}
+function didExternalResolvedVersionChange(beforeDependency, afterDependency) {
+	return beforeDependency?.kind === "external" && afterDependency?.kind === "external" && beforeDependency.resolvedVersion !== afterDependency.resolvedVersion;
+}
+function didExternalPeerContextChange(beforeDependency, afterDependency) {
+	return beforeDependency?.kind === "external" && afterDependency?.kind === "external" && beforeDependency.peerContext !== afterDependency.peerContext;
+}
+function resolveDependencyChange(beforeDependency, afterDependency) {
+	if (beforeDependency === void 0 && afterDependency !== void 0) return "added";
+	if (beforeDependency !== void 0 && afterDependency === void 0) return "removed";
+	if (beforeDependency === void 0 || afterDependency === void 0) return "unchanged";
+	if (beforeDependency.kind !== afterDependency.kind) return "changed";
+	if (beforeDependency.kind === "external" && afterDependency.kind === "external") return beforeDependency.specifier === afterDependency.specifier && beforeDependency.resolvedVersion === afterDependency.resolvedVersion && beforeDependency.peerContext === afterDependency.peerContext ? "unchanged" : "changed";
+	if (beforeDependency.kind === "workspace" && afterDependency.kind === "workspace") return beforeDependency.specifier === afterDependency.specifier && beforeDependency.targetPath === afterDependency.targetPath ? "unchanged" : "changed";
+	return "changed";
+}
+function toDiffState(dependency) {
+	if (dependency.kind === "external") return {
+		target: `${dependency.name}@${dependency.specifier}`,
+		specifier: dependency.specifier,
+		...dependency.resolvedVersion === void 0 ? {} : { resolvedVersion: dependency.resolvedVersion },
+		...dependency.peerContext === void 0 ? {} : { peerContext: dependency.peerContext }
+	};
+	return dependency.specifier === void 0 ? { target: dependency.targetPath } : {
+		target: dependency.targetPath,
+		specifier: dependency.specifier
+	};
+}
+function hasVisibleChanges(node) {
+	return node.change !== "unchanged" || node.dependencies.length > 0;
+}
+function resolveNodeChange(location, beforeNode, afterNode, dependencies, changedPackagePaths) {
+	if (beforeNode === void 0 && afterNode !== void 0) return "added";
+	if (beforeNode !== void 0 && afterNode === void 0) return "removed";
+	if (beforeNode === void 0 || afterNode === void 0) return "unchanged";
+	if (location.beforePath !== location.afterPath) return "changed";
+	if (beforeNode.packageName !== afterNode.packageName) return "changed";
+	const packagePath = location.afterPath ?? location.beforePath;
+	if (packagePath !== void 0 && changedPackagePaths.has(packagePath)) return "changed";
+	return dependencies.length > 0 ? "changed" : "unchanged";
+}
+function collectChangedPackagePaths(repositoryRoot, comparison, beforeGraph, afterGraph) {
+	const changedFiles = listChangedRepositoryPaths(repositoryRoot, comparison);
+	const packagePaths = Array.from(new Set([...Array.from(beforeGraph?.nodes.keys() ?? []), ...Array.from(afterGraph?.nodes.keys() ?? [])])).sort((left, right) => right.length - left.length);
+	const changedPackagePaths = /* @__PURE__ */ new Set();
+	changedFiles.forEach((filePath) => {
+		const ownerPackagePath = packagePaths.find((packagePath) => isFileInPackage(filePath, packagePath));
+		if (ownerPackagePath !== void 0) changedPackagePaths.add(ownerPackagePath);
+	});
+	return changedPackagePaths;
+}
+function listChangedRepositoryPaths(repositoryRoot, comparison) {
+	const trackedChanges = comparison.afterTree === void 0 ? runGit(repositoryRoot, [
+		"diff",
+		"--name-only",
+		"-z",
+		comparison.beforeTree,
+		"--"
+	]) : runGit(repositoryRoot, [
+		"diff",
+		"--name-only",
+		"-z",
+		comparison.beforeTree,
+		comparison.afterTree
+	]);
+	const changedPaths = new Set(trackedChanges.split("\0").filter((filePath) => filePath.length > 0));
+	if (comparison.afterTree === void 0) runGit(repositoryRoot, [
+		"ls-files",
+		"--others",
+		"--exclude-standard",
+		"-z"
+	]).split("\0").filter((filePath) => filePath.length > 0).forEach((filePath) => {
+		changedPaths.add(filePath);
+	});
+	return Array.from(changedPaths);
+}
+function isFileInPackage(filePath, packagePath) {
+	if (packagePath === ".") return true;
+	return filePath === packagePath || filePath.startsWith(`${packagePath}/`);
+}
+function runGit(repositoryRoot, args, options = {}) {
+	const output = execFileSync("git", [
+		"-C",
+		repositoryRoot,
+		...args
+	], { encoding: "utf8" });
+	return options.trim === false ? output : output.trimEnd();
+}
+function getCommandErrorMessage(error) {
+	if (!(error instanceof Error)) return "Unknown Git error";
+	const stderr = Reflect.get(error, "stderr");
+	if (typeof stderr === "string" && stderr.trim().length > 0) return stderr.trim();
+	if (Buffer.isBuffer(stderr) && stderr.byteLength > 0) return stderr.toString("utf8").trim();
+	return error.message;
+}
+//#endregion
+//#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() };
+	const readResult = ts.readConfigFile(configPath, ts.sys.readFile);
+	if (readResult.error !== void 0) throw new Error(`Failed to read TypeScript config at ${configPath}: ${formatDiagnostic(readResult.error)}`);
+	const parsed = ts.parseJsonConfigFileContent(readResult.config, ts.sys, path.dirname(configPath), defaultCompilerOptions(), configPath);
+	if (parsed.errors.length > 0) {
+		const [firstError] = parsed.errors;
+		if (firstError === void 0) throw new Error(`Failed to parse TypeScript config at ${configPath}.`);
+		throw new Error(`Failed to parse TypeScript config at ${configPath}: ${formatDiagnostic(firstError)}`);
+	}
+	return {
+		path: configPath,
+		compilerOptions: parsed.options
+	};
+}
+function findNearestConfig(searchFrom) {
+	let currentDirectory = path.resolve(searchFrom);
+	while (true) {
+		if (!isInsideNodeModules$1(currentDirectory)) {
+			const tsconfigPath = path.join(currentDirectory, "tsconfig.json");
+			if (ts.sys.fileExists(tsconfigPath)) return tsconfigPath;
+			const jsconfigPath = path.join(currentDirectory, "jsconfig.json");
+			if (ts.sys.fileExists(jsconfigPath)) return jsconfigPath;
+		}
+		const parentDirectory = path.dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) return;
+		currentDirectory = parentDirectory;
+	}
+}
+function defaultCompilerOptions() {
+	return {
+		allowJs: true,
+		jsx: ts.JsxEmit.ReactJSX,
+		module: ts.ModuleKind.NodeNext,
+		moduleResolution: ts.ModuleResolutionKind.NodeNext,
+		target: ts.ScriptTarget.ESNext,
+		resolveJsonModule: true,
+		esModuleInterop: true
+	};
+}
+function formatDiagnostic(diagnostic) {
+	return ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+}
+function isInsideNodeModules$1(filePath) {
+	return filePath.includes(`${path.sep}node_modules${path.sep}`);
+}
+//#endregion
+//#region src/utils/is-source-code-file.ts
+const SOURCE_EXTENSIONS = new Set([
+	".js",
+	".jsx",
+	".ts",
+	".tsx",
+	".mjs",
+	".cjs",
+	".mts",
+	".cts"
+]);
+function isSourceCodeFile(filePath) {
+	return SOURCE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+//#endregion
+//#region src/utils/normalize-file-path.ts
+function normalizeFilePath(filePath) {
+	return path.normalize(filePath);
+}
+//#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, currentDirectory) {
+	const host = ts.createCompilerHost(compilerOptions, true);
+	host.getCurrentDirectory = () => currentDirectory;
+	if (ts.sys.realpath !== void 0) host.realpath = ts.sys.realpath;
+	return ts.createProgram({
+		rootNames: [entryFile],
+		options: compilerOptions,
+		host
+	});
+}
+function createSourceFile(filePath) {
+	const sourceText = fs.readFileSync(filePath, "utf8");
+	return ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, getScriptKind(filePath));
+}
+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();
+	const importedLocalNames = /* @__PURE__ */ new Set();
+	sourceFile.statements.forEach((statement) => {
+		if (!ts.isImportDeclaration(statement) || statement.importClause === void 0) return;
+		const identifiers = getImportBindingIdentifiers(statement.importClause);
+		if (identifiers.length === 0) return;
+		importUsage.set(statement, {
+			canTrack: false,
+			used: false
+		});
+		identifiers.forEach((identifier) => {
+			importedLocalNames.add(identifier.text);
+			const symbol = tryGetSymbolAtLocation(checker, identifier);
+			if (symbol === void 0) return;
+			symbolToImportDeclaration.set(symbol, statement);
+			const state = importUsage.get(statement);
+			if (state !== void 0) state.canTrack = true;
+		});
+	});
+	function visit(node) {
+		if (ts.isImportDeclaration(node)) return;
+		if (ts.isIdentifier(node) && importedLocalNames.has(node.text) && isReferenceIdentifier(node)) {
+			const symbol = tryGetSymbolAtLocation(checker, node);
+			const declaration = symbol === void 0 ? void 0 : symbolToImportDeclaration.get(symbol);
+			if (declaration !== void 0) {
+				const state = importUsage.get(declaration);
+				if (state !== void 0) state.used = true;
+			}
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(sourceFile);
+	return new Map([...importUsage.entries()].map(([declaration, state]) => [declaration, state.canTrack && !state.used]));
+}
+function getImportBindingIdentifiers(importClause) {
+	const identifiers = [];
+	if (importClause.name !== void 0) identifiers.push(importClause.name);
+	const namedBindings = importClause.namedBindings;
+	if (namedBindings === void 0) return identifiers;
+	if (ts.isNamespaceImport(namedBindings)) {
+		identifiers.push(namedBindings.name);
+		return identifiers;
+	}
+	namedBindings.elements.forEach((element) => {
+		identifiers.push(element.name);
+	});
+	return identifiers;
+}
+function isReferenceIdentifier(node) {
+	const parent = node.parent;
+	if (ts.isPropertyAccessExpression(parent) && parent.name === node) return false;
+	if (ts.isQualifiedName(parent) && parent.right === node) return false;
+	if (ts.isPropertyAssignment(parent) && parent.name === node) return false;
+	if (ts.isBindingElement(parent) && parent.propertyName === node) return false;
+	if (ts.isJsxAttribute(parent) && parent.name === node) return false;
+	if (ts.isExportSpecifier(parent)) return parent.propertyName === node || parent.propertyName === void 0;
+	return true;
+}
+function tryGetSymbolAtLocation(checker, node) {
+	try {
+		return checker.getSymbolAtLocation(node);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#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
+			});
+			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()];
+}
+//#endregion
+//#region src/analyzers/import/resolver.ts
+const BUILTIN_MODULES = new Set(builtinModules.flatMap((name) => [name, `node:${name}`]));
+function resolveDependency(reference, containingFile, options) {
+	const specifier = reference.specifier;
+	if (BUILTIN_MODULES.has(specifier)) return createEdge(reference, "builtin", specifier);
+	const containingConfig = options.getConfigForFile(containingFile);
+	const oxcResolution = resolveWithOxc(reference, specifier, containingFile, options);
+	if (oxcResolution !== void 0) return oxcResolution;
+	const host = createResolutionHost(containingConfig, options.cwd);
+	const resolution = ts.resolveModuleName(specifier, containingFile, containingConfig.compilerOptions, host).resolvedModule;
+	if (resolution !== void 0) {
+		const resolvedPath = normalizeFilePath(resolution.resolvedFileName);
+		const realPath = resolveRealPath(resolvedPath);
+		const sourcePath = pickSourcePath(resolvedPath, realPath);
+		if (sourcePath !== void 0) {
+			const boundary = classifyBoundary(specifier, sourcePath, options);
+			if (boundary !== void 0) return createEdge(reference, "boundary", sourcePath, boundary);
+			if (!resolution.isExternalLibraryImport || !isInsideNodeModules(sourcePath) || realPath !== void 0 && !isInsideNodeModules(realPath)) return createEdge(reference, "source", sourcePath);
+		}
+		if (resolution.isExternalLibraryImport || isInsideNodeModules(resolvedPath) || realPath !== void 0 && isInsideNodeModules(realPath)) return createEdge(reference, "external", specifier);
+	}
+	if (!specifier.startsWith(".") && !path.isAbsolute(specifier)) return createEdge(reference, "external", specifier);
+	return createEdge(reference, "missing", specifier);
+}
+function resolveWithOxc(reference, specifier, containingFile, options) {
+	try {
+		const result = options.getResolverForFile(containingFile).resolveFileSync(containingFile, specifier);
+		if (result.builtin !== void 0) return createEdge(reference, "builtin", result.builtin.resolved);
+		if (result.path !== void 0) return classifyResolvedPath(reference, specifier, result.path, options);
+	} catch {
+		return;
+	}
+}
+function createEdge(reference, kind, target, boundary) {
+	return {
+		specifier: reference.specifier,
+		referenceKind: reference.referenceKind,
+		isTypeOnly: reference.isTypeOnly,
+		unused: reference.unused,
+		kind,
+		target,
+		...boundary === void 0 ? {} : { boundary }
+	};
+}
+function createResolutionHost(config, cwd) {
+	return {
+		fileExists: ts.sys.fileExists,
+		readFile: ts.sys.readFile,
+		directoryExists: ts.sys.directoryExists,
+		getCurrentDirectory: () => config.path === void 0 ? cwd : path.dirname(config.path),
+		getDirectories: ts.sys.getDirectories,
+		...ts.sys.realpath === void 0 ? {} : { realpath: ts.sys.realpath }
+	};
+}
+function resolveRealPath(resolvedPath) {
+	if (ts.sys.realpath === void 0) return;
+	try {
+		return normalizeFilePath(ts.sys.realpath(resolvedPath));
+	} catch {
+		return;
+	}
+}
+function classifyResolvedPath(reference, specifier, resolvedPathValue, options) {
+	const resolvedPath = normalizeFilePath(resolvedPathValue);
+	const realPath = resolveRealPath(resolvedPath);
+	const sourcePath = pickSourcePath(resolvedPath, realPath);
+	if (sourcePath !== void 0) {
+		const boundary = classifyBoundary(specifier, sourcePath, options);
+		if (boundary !== void 0) return createEdge(reference, "boundary", sourcePath, boundary);
+		if (!isInsideNodeModules(sourcePath) || realPath !== void 0 && !isInsideNodeModules(realPath)) return createEdge(reference, "source", sourcePath);
+	}
+	return createEdge(reference, "external", specifier);
+}
+function pickSourcePath(resolvedPath, realPath) {
+	const candidates = [realPath, resolvedPath];
+	for (const candidate of candidates) if (candidate !== void 0 && isSourceCodeFile(candidate) && !candidate.endsWith(".d.ts")) return candidate;
+}
+function classifyBoundary(specifier, sourcePath, options) {
+	const targetConfigPath = options.getConfigForFile(sourcePath).path;
+	const entryConfigPath = options.entryConfigPath;
+	if (options.projectOnly && entryConfigPath !== void 0 && targetConfigPath !== entryConfigPath) return "project";
+	if (!options.expandWorkspaces && isWorkspaceLikeImport(specifier) && entryConfigPath !== void 0 && targetConfigPath !== entryConfigPath) return "workspace";
+}
+function isWorkspaceLikeImport(specifier) {
+	return !specifier.startsWith(".") && !path.isAbsolute(specifier);
+}
+function isInsideNodeModules(filePath) {
+	return filePath.includes(`${path.sep}node_modules${path.sep}`);
+}
+//#endregion
+//#region src/analyzers/import/graph.ts
+function buildDependencyGraph(entryPath, options) {
+	return new DependencyGraphBuilder(entryPath, options).build();
+}
+var DependencyGraphBuilder = class {
+	nodes = /* @__PURE__ */ new Map();
+	configCache = /* @__PURE__ */ new Map();
+	programCache = /* @__PURE__ */ new Map();
+	checkerCache = /* @__PURE__ */ new Map();
+	resolverCache = /* @__PURE__ */ new Map();
+	constructor(entryPath, options) {
+		this.entryPath = entryPath;
+		this.options = options;
+		const entryConfig = {
+			compilerOptions: options.entryCompilerOptions,
+			...options.entryConfigPath === void 0 ? {} : { path: options.entryConfigPath }
+		};
+		this.configCache.set(path.dirname(this.entryPath), entryConfig);
+	}
+	build() {
+		this.visitFile(this.entryPath);
+		return this.nodes;
+	}
+	visitFile(filePath) {
+		const normalizedPath = normalizeFilePath(filePath);
+		if (this.nodes.has(normalizedPath)) return;
+		const config = this.getConfigForFile(normalizedPath);
+		const program = this.getProgramForFile(normalizedPath, config);
+		const checker = this.getCheckerForFile(normalizedPath, config);
+		const dependencies = collectModuleReferences(program.getSourceFile(normalizedPath) ?? createSourceFile(normalizedPath), checker).map((reference) => resolveDependency(reference, normalizedPath, {
+			cwd: this.options.cwd,
+			expandWorkspaces: this.options.expandWorkspaces,
+			projectOnly: this.options.projectOnly,
+			getConfigForFile: (targetPath) => this.getConfigForFile(targetPath),
+			getResolverForFile: (targetPath) => this.getResolverForFile(targetPath),
+			...this.options.entryConfigPath === void 0 ? {} : { entryConfigPath: this.options.entryConfigPath }
+		}));
+		this.nodes.set(normalizedPath, {
+			id: normalizedPath,
+			dependencies
+		});
+		for (const dependency of dependencies) if (dependency.kind === "source") this.visitFile(dependency.target);
+	}
+	getConfigForFile(filePath) {
+		const directory = path.dirname(filePath);
+		const cached = this.configCache.get(directory);
+		if (cached !== void 0) return cached;
+		const loaded = loadCompilerOptions(directory);
+		this.configCache.set(directory, loaded);
+		return loaded;
+	}
+	getProgramForFile(filePath, config) {
+		const cacheKey = this.getProgramCacheKey(filePath, config);
+		const cached = this.programCache.get(cacheKey);
+		if (cached !== void 0) return cached;
+		const currentDirectory = config.path === void 0 ? path.dirname(filePath) : path.dirname(config.path);
+		const program = createProgram(filePath, config.compilerOptions, currentDirectory);
+		this.programCache.set(cacheKey, program);
+		return program;
+	}
+	getCheckerForFile(filePath, config) {
+		const cacheKey = this.getProgramCacheKey(filePath, config);
+		const cached = this.checkerCache.get(cacheKey);
+		if (cached !== void 0) return cached;
+		const checker = this.getProgramForFile(filePath, config).getTypeChecker();
+		this.checkerCache.set(cacheKey, checker);
+		return checker;
+	}
+	getProgramCacheKey(filePath, config) {
+		return config.path ?? `default:${path.dirname(filePath)}`;
+	}
+	getResolverForFile(filePath) {
+		const config = this.getConfigForFile(filePath);
+		const cacheKey = this.getProgramCacheKey(filePath, config);
+		const cached = this.resolverCache.get(cacheKey);
+		if (cached !== void 0) return cached;
+		const resolver = new ResolverFactory({
+			builtinModules: true,
+			conditionNames: [
+				"import",
+				"require",
+				"default"
+			],
+			extensions: [
+				".ts",
+				".tsx",
+				".js",
+				".jsx",
+				".mts",
+				".cts",
+				".mjs",
+				".cjs",
+				".json"
+			],
+			mainFields: [
+				"types",
+				"module",
+				"main"
+			],
+			tsconfig: config.path === void 0 ? "auto" : { configFile: config.path }
+		});
+		this.resolverCache.set(cacheKey, resolver);
+		return resolver;
+	}
+};
+//#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);
+	}
+	doAnalyze() {
+		const { compilerOptions, path: configPath } = loadCompilerOptions(path.dirname(this.entryPath), this.options.configPath);
+		const nodes = buildDependencyGraph(this.entryPath, {
+			cwd: this.cwd,
+			entryCompilerOptions: compilerOptions,
+			expandWorkspaces: this.options.expandWorkspaces ?? true,
+			projectOnly: this.options.projectOnly ?? false,
+			...configPath === void 0 ? {} : { entryConfigPath: configPath }
+		});
+		return {
+			cwd: this.cwd,
+			entryId: this.entryPath,
+			nodes,
+			...configPath === void 0 ? {} : { configPath }
+		};
+	}
+};
+//#endregion
+//#region src/analyzers/react/bindings.ts
+function collectImportsAndExports(statement, sourceDependencies, symbolsByName, importsByLocalName, exportsByName, reExportBindingsByName, exportAllBindings) {
+	switch (statement.type) {
+		case "ImportDeclaration":
+			collectImportBindings(statement, sourceDependencies, importsByLocalName);
+			return;
+		case "ExportNamedDeclaration":
+			collectNamedExports(statement, sourceDependencies, symbolsByName, exportsByName, reExportBindingsByName);
+			return;
+		case "ExportAllDeclaration":
+			collectExportAllBindings(statement, sourceDependencies, exportAllBindings);
+			return;
+		case "ExportDefaultDeclaration":
+			collectDefaultExport(statement, symbolsByName, exportsByName);
+			return;
+		default: return;
+	}
+}
+function collectImportBindings(declaration, sourceDependencies, importsByLocalName) {
+	if (declaration.importKind === "type") return;
+	const sourceSpecifier = declaration.source.value;
+	const sourcePath = sourceDependencies.get(declaration.source.value);
+	declaration.specifiers.forEach((specifier) => {
+		const binding = getImportBinding(specifier, sourceSpecifier, sourcePath);
+		if (binding === void 0) return;
+		importsByLocalName.set(binding.localName, {
+			importedName: binding.importedName,
+			sourceSpecifier: binding.sourceSpecifier,
+			...binding.sourcePath === void 0 ? {} : { sourcePath: binding.sourcePath }
+		});
+	});
+}
+function getImportBinding(specifier, sourceSpecifier, sourcePath) {
+	if (specifier.type === "ImportSpecifier") {
+		if (specifier.importKind === "type") return;
+		return {
+			localName: specifier.local.name,
+			importedName: toModuleExportName(specifier.imported),
+			sourceSpecifier,
+			...sourcePath === void 0 ? {} : { sourcePath }
+		};
+	}
+	if (specifier.type === "ImportDefaultSpecifier") return {
+		localName: specifier.local.name,
+		importedName: "default",
+		sourceSpecifier,
+		...sourcePath === void 0 ? {} : { sourcePath }
+	};
+}
+function collectNamedExports(declaration, sourceDependencies, symbolsByName, exportsByName, reExportBindingsByName) {
+	if (declaration.exportKind === "type") return;
+	if (declaration.declaration !== null) {
+		if (declaration.declaration.type === "FunctionDeclaration") {
+			const name = declaration.declaration.id?.name;
+			if (name !== void 0) addExportBinding(name, name, symbolsByName, exportsByName);
+		} else if (declaration.declaration.type === "VariableDeclaration") declaration.declaration.declarations.forEach((declarator) => {
+			if (declarator.id.type === "Identifier") addExportBinding(declarator.id.name, declarator.id.name, symbolsByName, exportsByName);
+		});
+		return;
+	}
+	if (declaration.source !== null) {
+		const sourceSpecifier = declaration.source.value;
+		const sourcePath = sourceDependencies.get(sourceSpecifier);
+		declaration.specifiers.forEach((specifier) => {
+			if (specifier.exportKind === "type") return;
+			reExportBindingsByName.set(toModuleExportName(specifier.exported), {
+				importedName: toModuleExportName(specifier.local),
+				sourceSpecifier,
+				...sourcePath === void 0 ? {} : { sourcePath }
+			});
+		});
+		return;
+	}
+	declaration.specifiers.forEach((specifier) => {
+		if (specifier.exportKind === "type") return;
+		addExportBinding(toModuleExportName(specifier.local), toModuleExportName(specifier.exported), symbolsByName, exportsByName);
+	});
+}
+function collectExportAllBindings(declaration, sourceDependencies, exportAllBindings) {
+	if (declaration.exportKind === "type") return;
+	const sourceSpecifier = declaration.source.value;
+	const sourcePath = sourceDependencies.get(sourceSpecifier);
+	exportAllBindings.push({
+		importedName: "*",
+		sourceSpecifier,
+		...sourcePath === void 0 ? {} : { sourcePath }
+	});
+}
+function collectDefaultExport(declaration, symbolsByName, exportsByName) {
+	if (declaration.declaration.type === "FunctionDeclaration" || declaration.declaration.type === "FunctionExpression") {
+		const localName = declaration.declaration.id?.name;
+		if (localName !== void 0) addExportBinding(localName, "default", symbolsByName, exportsByName);
+		return;
+	}
+	if (declaration.declaration.type === "Identifier") {
+		addExportBinding(declaration.declaration.name, "default", symbolsByName, exportsByName);
+		return;
+	}
+	if (declaration.declaration.type === "ArrowFunctionExpression") addExportBinding("default", "default", symbolsByName, exportsByName);
+}
+function addExportBinding(localName, exportedName, symbolsByName, exportsByName) {
+	const symbol = symbolsByName.get(localName);
+	if (symbol === void 0) return;
+	symbol.exportNames.add(exportedName);
+	exportsByName.set(exportedName, symbol.id);
+}
+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) && isFunctionLikeDeclaration(declaration)) return "hook";
+	if (isComponentName(name) && (isFunctionLikeDeclaration(declaration) && returnsReactElement(declaration) || isStyledComponentDeclaration(declaration))) return "component";
+}
+function containsReactElementLikeExpression(expression) {
+	let found = false;
+	walkNode(expression, (node) => {
+		if (node.type === "JSXElement" || node.type === "JSXFragment" || node.type === "CallExpression" && isReactCreateElementCall(node)) found = true;
+	});
+	return found;
+}
+function getComponentReferenceName(node) {
+	const name = getJsxName(node.openingElement.name);
+	return name !== void 0 && isComponentName(name) ? name : void 0;
+}
+function getBuiltinReferenceName(node) {
+	const name = getJsxName(node.openingElement.name);
+	return name !== void 0 && isIntrinsicElementName(name) ? name : void 0;
+}
+function getHookReferenceName(node) {
+	const calleeName = getIdentifierName(node.callee);
+	return calleeName !== void 0 && isHookName(calleeName) ? calleeName : void 0;
+}
+function getCreateElementComponentReferenceName(node) {
+	if (!isReactCreateElementCall(node)) return;
+	const [firstArgument] = node.arguments;
+	if (firstArgument === void 0 || firstArgument.type !== "Identifier") return;
+	return isComponentName(firstArgument.name) ? firstArgument.name : void 0;
+}
+function getStyledComponentReferenceName(node) {
+	const reference = getStyledFactoryReference(node.type === "CallExpression" ? node.callee : node.tag);
+	return reference?.kind === "component" ? reference.name : void 0;
+}
+function getStyledBuiltinReferenceName(node) {
+	const reference = getStyledFactoryReference(node.type === "CallExpression" ? node.callee : node.tag);
+	return reference?.kind === "builtin" ? reference.name : void 0;
+}
+function isHookName(name) {
+	return /^use[A-Z0-9]/.test(name);
+}
+function isComponentName(name) {
+	return /^[A-Z]/.test(name);
+}
+function isIntrinsicElementName(name) {
+	return /^[a-z]/.test(name);
+}
+function isFunctionLikeDeclaration(declaration) {
+	return declaration.type === "ArrowFunctionExpression" || declaration.type === "FunctionDeclaration" || declaration.type === "FunctionExpression";
+}
+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 isStyledComponentDeclaration(expression) {
+	if (expression.type === "CallExpression") return getStyledFactoryReference(expression.callee) !== void 0;
+	if (expression.type === "TaggedTemplateExpression") return getStyledFactoryReference(expression.tag) !== void 0;
+	return false;
+}
+function getStyledFactoryReference(expression) {
+	const unwrapped = unwrapExpression(expression);
+	if (unwrapped.type === "MemberExpression" && !unwrapped.computed) {
+		if (unwrapped.object.type !== "Identifier" || unwrapped.object.name !== "styled" || unwrapped.property.type !== "Identifier") return;
+		const name = unwrapped.property.name;
+		if (isIntrinsicElementName(name)) return {
+			kind: "builtin",
+			name
+		};
+		if (isComponentName(name)) return {
+			kind: "component",
+			name
+		};
+		return;
+	}
+	if (unwrapped.type !== "CallExpression") return;
+	const callee = unwrapExpression(unwrapped.callee);
+	if (callee.type !== "Identifier" || callee.name !== "styled") return;
+	const [firstArgument] = unwrapped.arguments;
+	if (firstArgument?.type !== "Identifier") return;
+	return isComponentName(firstArgument.name) ? {
+		kind: "component",
+		name: firstArgument.name
+	} : void 0;
+}
+function isReactCreateElementCall(node) {
+	const callee = unwrapExpression(node.callee);
+	if (callee.type !== "MemberExpression" || callee.computed) return false;
+	return callee.object.type === "Identifier" && callee.object.name === "React" && callee.property.name === "createElement";
+}
+function getJsxName(name) {
+	if (name.type === "JSXIdentifier") return name.name;
+}
+function getIdentifierName(expression) {
+	const unwrapped = unwrapExpression(expression);
+	return unwrapped.type === "Identifier" ? unwrapped.name : void 0;
+}
+function unwrapExpression(expression) {
+	let current = expression;
+	while (true) {
+		if (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression") {
+			current = current.expression;
+			continue;
+		}
+		return current;
+	}
+}
+//#endregion
+//#region src/analyzers/react/entries.ts
+function collectEntryUsages(program, filePath, sourceText, includeBuiltins) {
+	const entries = /* @__PURE__ */ new Map();
+	program.body.forEach((statement) => {
+		collectStatementEntryUsages(statement, filePath, sourceText, entries, includeBuiltins);
+	});
+	return [...entries.values()].sort(comparePendingReactUsageEntries);
+}
+function collectStatementEntryUsages(statement, filePath, sourceText, entries, includeBuiltins) {
+	collectNodeEntryUsages(statement, filePath, sourceText, entries, includeBuiltins, false);
+}
+function collectNodeEntryUsages(node, filePath, sourceText, entries, includeBuiltins, hasComponentAncestor) {
+	if (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 (includeBuiltins) {
+			const builtinName = getBuiltinReferenceName(node);
+			if (builtinName !== void 0) {
+				if (!hasComponentAncestor) addPendingReactUsageEntry(entries, builtinName, "builtin", 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];
+		collectEntryUsageChild(value, filePath, sourceText, entries, includeBuiltins, nextHasComponentAncestor);
+	});
+}
+function collectEntryUsageChild(value, filePath, sourceText, entries, includeBuiltins, hasComponentAncestor) {
+	if (Array.isArray(value)) {
+		value.forEach((entry) => {
+			collectEntryUsageChild(entry, filePath, sourceText, entries, includeBuiltins, hasComponentAncestor);
+		});
+		return;
+	}
+	if (!isNode(value)) return;
+	collectNodeEntryUsages(value, filePath, sourceText, entries, includeBuiltins, hasComponentAncestor);
+}
+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 collectTopLevelDynamicComponentCandidates(statement, filePath, symbolsByName, dynamicComponentCandidatesByName) {
+	switch (statement.type) {
+		case "VariableDeclaration":
+			statement.declarations.forEach((declarator) => {
+				addDynamicComponentCandidate(declarator, filePath, symbolsByName, dynamicComponentCandidatesByName);
+			});
+			return;
+		case "ExportNamedDeclaration":
+			if (statement.declaration !== null) collectTopLevelDynamicComponentCandidates(statement.declaration, filePath, symbolsByName, dynamicComponentCandidatesByName);
+			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.id?.start ?? declaration.start, getAnalysisRoot(declaration)));
+}
+function addVariableSymbol(declarator, filePath, symbolsByName) {
+	if (declarator.id.type !== "Identifier" || declarator.init === null) 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.start, getAnalysisRoot(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.start, getAnalysisRoot(declaration.declaration)));
+	}
+}
+function addDynamicComponentCandidate(declarator, filePath, symbolsByName, dynamicComponentCandidatesByName) {
+	if (declarator.id.type !== "Identifier" || declarator.init === null) return;
+	const name = declarator.id.name;
+	if (!isPotentialDynamicComponentName(name) || symbolsByName.has(name) || !isDynamicComponentInitializer(declarator.init)) return;
+	dynamicComponentCandidatesByName.set(name, createPendingSymbol(filePath, name, "component", declarator.init.start, getAnalysisRoot(declarator.init)));
+}
+function createPendingSymbol(filePath, name, kind, declarationOffset, analysisRoot) {
+	return {
+		id: `${filePath}#${kind}:${name}`,
+		name,
+		kind,
+		filePath,
+		declarationOffset,
+		analysisRoot,
+		exportNames: /* @__PURE__ */ new Set(),
+		componentReferences: /* @__PURE__ */ new Set(),
+		hookReferences: /* @__PURE__ */ new Set(),
+		builtinReferences: /* @__PURE__ */ new Set()
+	};
+}
+function getAnalysisRoot(declaration) {
+	if (declaration.type === "FunctionDeclaration" || declaration.type === "FunctionExpression") {
+		if (declaration.body === null) throw new Error(`Expected React symbol "${declaration.id?.name ?? "anonymous"}" to have a body.`);
+		return declaration.body;
+	}
+	if (declaration.type === "ArrowFunctionExpression") return declaration.body;
+	return declaration;
+}
+function isDynamicComponentInitializer(expression) {
+	return expression.type === "CallExpression" || expression.type === "TaggedTemplateExpression";
+}
+function isPotentialDynamicComponentName(name) {
+	return /^[A-Z][A-Za-z0-9]*$/.test(name);
+}
+//#endregion
+//#region src/analyzers/react/usage.ts
+function analyzeSymbolUsages(symbol, includeBuiltins) {
+	walkReactUsageTree(symbol.analysisRoot, (node) => {
+		if (node.type === "JSXElement") {
+			const name = getComponentReferenceName(node);
+			if (name !== void 0) symbol.componentReferences.add(name);
+			if (includeBuiltins) {
+				const builtinName = getBuiltinReferenceName(node);
+				if (builtinName !== void 0) symbol.builtinReferences.add(builtinName);
+			}
+			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);
+			const styledComponentReference = getStyledComponentReferenceName(node);
+			if (styledComponentReference !== void 0) symbol.componentReferences.add(styledComponentReference);
+			if (includeBuiltins) {
+				const styledBuiltinReference = getStyledBuiltinReferenceName(node);
+				if (styledBuiltinReference !== void 0) symbol.builtinReferences.add(styledBuiltinReference);
+			}
+		}
+		if (node.type === "TaggedTemplateExpression") {
+			const styledComponentReference = getStyledComponentReferenceName(node);
+			if (styledComponentReference !== void 0) symbol.componentReferences.add(styledComponentReference);
+			if (includeBuiltins) {
+				const styledBuiltinReference = getStyledBuiltinReferenceName(node);
+				if (styledBuiltinReference !== void 0) symbol.builtinReferences.add(styledBuiltinReference);
+			}
+		}
+	});
+}
+//#endregion
+//#region src/analyzers/react/file.ts
+function analyzeReactFile(program, filePath, sourceText, includeNestedRenderEntries, sourceDependencies, includeBuiltins) {
+	const symbolsByName = /* @__PURE__ */ new Map();
+	const dynamicComponentCandidatesByName = /* @__PURE__ */ new Map();
+	program.body.forEach((statement) => {
+		collectTopLevelReactSymbols(statement, filePath, symbolsByName);
+	});
+	program.body.forEach((statement) => {
+		collectTopLevelDynamicComponentCandidates(statement, filePath, symbolsByName, dynamicComponentCandidatesByName);
+	});
+	const allSymbolsByName = new Map([...dynamicComponentCandidatesByName, ...symbolsByName]);
+	const importsByLocalName = /* @__PURE__ */ new Map();
+	const exportsByName = /* @__PURE__ */ new Map();
+	const reExportBindingsByName = /* @__PURE__ */ new Map();
+	const exportAllBindings = [];
+	const directEntryUsages = includeNestedRenderEntries ? collectEntryUsages(program, filePath, sourceText, includeBuiltins) : [];
+	program.body.forEach((statement) => {
+		collectImportsAndExports(statement, sourceDependencies, allSymbolsByName, importsByLocalName, exportsByName, reExportBindingsByName, exportAllBindings);
+	});
+	allSymbolsByName.forEach((symbol) => {
+		analyzeSymbolUsages(symbol, includeBuiltins);
+	});
+	const allSymbolsById = new Map([...allSymbolsByName.values()].map((symbol) => [symbol.id, symbol]));
+	return {
+		filePath,
+		importsByLocalName,
+		exportsByName,
+		reExportBindingsByName,
+		exportAllBindings,
+		entryUsages: directEntryUsages.length > 0 ? directEntryUsages : includeNestedRenderEntries ? collectComponentDeclarationEntryUsages(symbolsByName, sourceText) : [],
+		allSymbolsById,
+		allSymbolsByName,
+		symbolsById: new Map([...symbolsByName.values()].map((symbol) => [symbol.id, symbol])),
+		symbolsByName
+	};
+}
+function collectComponentDeclarationEntryUsages(symbolsByName, sourceText) {
+	const componentSymbols = [...symbolsByName.values()].filter((symbol) => symbol.kind === "component");
+	if (componentSymbols.length === 0) return [];
+	const exportedComponentSymbols = componentSymbols.filter((symbol) => symbol.exportNames.size > 0);
+	return (exportedComponentSymbols.length > 0 ? exportedComponentSymbols : componentSymbols).sort((left, right) => {
+		return left.declarationOffset - right.declarationOffset || left.name.localeCompare(right.name);
+	}).map((symbol) => ({
+		referenceName: symbol.name,
+		kind: "component",
+		location: createReactUsageLocation(symbol.filePath, sourceText, symbol.declarationOffset)
+	}));
+}
+//#endregion
+//#region src/analyzers/react/references.ts
+function resolveReactReference(fileAnalysis, fileAnalyses, name, kind) {
+	if (kind === "builtin") return getBuiltinNodeId(name);
+	const localSymbol = fileAnalysis.allSymbolsByName.get(name);
+	if (localSymbol !== void 0 && localSymbol.kind === kind) return localSymbol.id;
+	const importBinding = fileAnalysis.importsByLocalName.get(name);
+	if (importBinding === void 0) return;
+	if (importBinding.sourcePath === void 0) return kind === "hook" ? getExternalHookNodeId(importBinding, name) : void 0;
+	const sourceFileAnalysis = fileAnalyses.get(importBinding.sourcePath);
+	if (sourceFileAnalysis === void 0) return;
+	const targetId = resolveExportedSymbol(sourceFileAnalysis, importBinding.importedName, kind, fileAnalyses, /* @__PURE__ */ new Set());
+	if (targetId === void 0) return;
+	return targetId;
+}
+function resolveExportedSymbol(fileAnalysis, exportName, kind, fileAnalyses, visited) {
+	const visitKey = `${fileAnalysis.filePath}:${exportName}:${kind}`;
+	if (visited.has(visitKey)) return;
+	visited.add(visitKey);
+	const directTargetId = fileAnalysis.exportsByName.get(exportName);
+	if (directTargetId !== void 0) {
+		if (fileAnalysis.allSymbolsById.get(directTargetId)?.kind === kind) return directTargetId;
+	}
+	const reExportBinding = fileAnalysis.reExportBindingsByName.get(exportName);
+	if (reExportBinding?.sourcePath !== void 0) {
+		const reExportSourceAnalysis = fileAnalyses.get(reExportBinding.sourcePath);
+		if (reExportSourceAnalysis !== void 0) {
+			const reExportTargetId = resolveExportedSymbol(reExportSourceAnalysis, reExportBinding.importedName, kind, fileAnalyses, visited);
+			if (reExportTargetId !== void 0) return reExportTargetId;
+		}
+	}
+	for (const exportAllBinding of fileAnalysis.exportAllBindings) {
+		if (exportAllBinding.sourcePath === void 0) continue;
+		const exportAllSourceAnalysis = fileAnalyses.get(exportAllBinding.sourcePath);
+		if (exportAllSourceAnalysis === void 0) continue;
+		const exportAllTargetId = resolveExportedSymbol(exportAllSourceAnalysis, exportName, kind, fileAnalyses, visited);
+		if (exportAllTargetId !== void 0) return exportAllTargetId;
+	}
+}
+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 addBuiltinNodes(fileAnalyses, nodes) {
+	for (const fileAnalysis of fileAnalyses.values()) {
+		fileAnalysis.entryUsages.forEach((entry) => {
+			if (entry.kind !== "builtin") return;
+			const builtinNode = createBuiltinNode(entry.referenceName);
+			if (!nodes.has(builtinNode.id)) nodes.set(builtinNode.id, builtinNode);
+		});
+		fileAnalysis.allSymbolsById.forEach((symbol) => {
+			symbol.builtinReferences.forEach((name) => {
+				const builtinNode = createBuiltinNode(name);
+				if (!nodes.has(builtinNode.id)) nodes.set(builtinNode.id, builtinNode);
+			});
+		});
+	}
+}
+function createExternalHookNode(binding, localName) {
+	const name = getExternalHookName(binding, localName);
+	return {
+		id: getExternalHookNodeId(binding, localName),
+		name,
+		kind: "hook",
+		filePath: binding.sourceSpecifier,
+		exportNames: [binding.importedName],
+		usages: []
+	};
+}
+function createBuiltinNode(name) {
+	return {
+		id: getBuiltinNodeId(name),
+		name,
+		kind: "builtin",
+		filePath: "html",
+		exportNames: [],
+		usages: []
+	};
+}
+function getExternalHookNodeId(binding, localName) {
+	return `external:${binding.sourceSpecifier}#hook:${getExternalHookName(binding, localName)}`;
+}
+function getBuiltinNodeId(name) {
+	return `builtin:${name}`;
+}
+function getExternalHookName(binding, localName) {
+	return binding.importedName === "default" ? localName : binding.importedName;
+}
+function compareReactNodeIds(leftId, rightId, nodes) {
+	const left = nodes.get(leftId);
+	const right = nodes.get(rightId);
+	if (left === void 0 || right === void 0) return leftId.localeCompare(rightId);
+	return compareReactNodes(left, right);
+}
+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 || left.referenceName.localeCompare(right.referenceName) || compareReactNodeIds(left.target, right.target, nodes);
+}
+function compareReactNodes(left, right) {
+	return left.filePath.localeCompare(right.filePath) || left.name.localeCompare(right.name) || left.kind.localeCompare(right.kind);
+}
+//#endregion
+//#region src/analyzers/react/index.ts
+function analyzeReactUsage(entryFile, options = {}) {
+	return new ReactAnalyzer(normalizeEntryFiles(entryFile), options).analyze();
+}
+var ReactAnalyzer = class extends BaseAnalyzer {
+	constructor(entryFiles, options) {
+		const [firstEntryFile] = entryFiles;
+		if (firstEntryFile === void 0) throw new Error("At least one React entry file is required.");
+		super(firstEntryFile, options);
+		this.entryFiles = entryFiles;
+	}
+	doAnalyze() {
+		const dependencyGraphs = this.entryFiles.map((entryFile) => analyzeDependencies(entryFile, this.options));
+		const dependencyGraph = mergeDependencyGraphs(dependencyGraphs);
+		const entryIds = dependencyGraphs.map((graph) => graph.entryId);
+		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,
+			entryIds,
+			nodes,
+			entries
+		};
+	}
+	collectFileAnalyses(dependencyGraph) {
+		const reachableFiles = new Set([...dependencyGraph.entryIds, ...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, dependencyGraph.entryIds.includes(filePath), sourceDependencies, this.options.includeBuiltins === true));
+		}
+		return fileAnalyses;
+	}
+	createNodes(fileAnalyses) {
+		const nodes = /* @__PURE__ */ new Map();
+		for (const fileAnalysis of fileAnalyses.values()) for (const symbol of fileAnalysis.allSymbolsById.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);
+		if (this.options.includeBuiltins === true) addBuiltinNodes(fileAnalyses, nodes);
+		return nodes;
+	}
+	attachUsages(fileAnalyses, nodes) {
+		for (const fileAnalysis of fileAnalyses.values()) for (const symbol of fileAnalysis.allSymbolsById.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}:${referenceName}`, {
+					kind: "render",
+					target: targetId,
+					referenceName
+				});
+			});
+			symbol.hookReferences.forEach((referenceName) => {
+				const targetId = resolveReactReference(fileAnalysis, fileAnalyses, referenceName, "hook");
+				if (targetId !== void 0 && targetId !== symbol.id) usages.set(`hook:${targetId}:${referenceName}`, {
+					kind: "hook-call",
+					target: targetId,
+					referenceName
+				});
+			});
+			if (this.options.includeBuiltins === true) symbol.builtinReferences.forEach((referenceName) => {
+				const targetId = getBuiltinNodeId(referenceName);
+				usages.set(`render:${targetId}:${referenceName}`, {
+					kind: "render",
+					target: targetId,
+					referenceName
+				});
+			});
+			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,
+				referenceName: entry.referenceName,
+				location: entry.location
+			});
+		}
+		return [...entriesByKey.values()].sort((left, right) => compareReactUsageEntries(left, right, nodes));
+	}
+};
+function normalizeEntryFiles(entryFile) {
+	const entryFiles = Array.isArray(entryFile) ? entryFile : [entryFile];
+	const dedupedEntryFiles = [...new Set(entryFiles)];
+	if (dedupedEntryFiles.length === 0) throw new Error("At least one React entry file is required.");
+	return dedupedEntryFiles;
+}
+function mergeDependencyGraphs(graphs) {
+	const firstGraph = graphs[0];
+	if (firstGraph === void 0) throw new Error("At least one dependency graph is required.");
+	const nodes = /* @__PURE__ */ new Map();
+	for (const graph of graphs) for (const [nodeId, node] of graph.nodes) if (!nodes.has(nodeId)) nodes.set(nodeId, node);
+	const uniqueConfigPaths = [...new Set(graphs.map((graph) => graph.configPath))];
+	const configPath = uniqueConfigPaths.length === 1 ? uniqueConfigPaths[0] : void 0;
+	return {
+		cwd: firstGraph.cwd,
+		entryId: firstGraph.entryId,
+		entryIds: graphs.map((graph) => graph.entryId),
+		nodes,
+		...configPath === void 0 ? {} : { configPath }
+	};
+}
+//#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 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);
+	});
+}
+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
+const ANSI_RESET = "\x1B[0m";
+const ANSI_COMPONENT = "\x1B[36m";
+const ANSI_HOOK = "\x1B[35m";
+const ANSI_BUILTIN = "\x1B[34m";
+const ANSI_MUTED = "\x1B[38;5;244m";
+const ANSI_UNUSED = "\x1B[38;5;214m";
+const ANSI_DIFF_ADDED = "\x1B[32m";
+const ANSI_DIFF_REMOVED = "\x1B[31m";
+const ANSI_DIFF_CHANGED = "\x1B[33m";
+function resolveColorSupport(mode = "auto", options = {}) {
+	if (mode === true) return true;
+	if (mode === false) return false;
+	const forceColor = "forceColor" in options ? options.forceColor : process$1.env.FORCE_COLOR;
+	if (forceColor !== void 0) return forceColor !== "0";
+	if (("noColor" in options ? options.noColor : process$1.env.NO_COLOR) !== void 0) return false;
+	return ("isTTY" in options ? options.isTTY : process$1.stdout.isTTY) === true;
+}
+function colorizeUnusedMarker(text, enabled) {
+	if (!enabled) return text;
+	return text.replaceAll("(unused)", `${ANSI_UNUSED}(unused)${ANSI_RESET}`);
+}
+function formatReactSymbolLabel(name, kind, enabled) {
+	const label = `${formatReactSymbolName(name, kind)} [${kind}]`;
+	if (!enabled) return label;
+	return `${getReactSymbolColor(kind)}${label}${ANSI_RESET}`;
+}
+function formatReactSymbolName(name, kind) {
+	if (kind === "component") return `<${name} />`;
+	if (kind === "hook") return `${name}()`;
+	return `<${name}>`;
+}
+function colorizeReactLabel(text, kind, enabled) {
+	if (!enabled) return text;
+	return `${getReactSymbolColor(kind)}${text}${ANSI_RESET}`;
+}
+function colorizeMuted(text, enabled) {
+	if (!enabled) return text;
+	return `${ANSI_MUTED}${text}${ANSI_RESET}`;
+}
+function colorizePackageDiff(text, change, enabled) {
+	if (!enabled) return text;
+	return `${getPackageDiffColor(change)}${text}${ANSI_RESET}`;
+}
+function getReactSymbolColor(kind) {
+	if (kind === "component") return ANSI_COMPONENT;
+	if (kind === "hook") return ANSI_HOOK;
+	return ANSI_BUILTIN;
+}
+function getPackageDiffColor(change) {
+	if (change === "added") return ANSI_DIFF_ADDED;
+	if (change === "removed") return ANSI_DIFF_REMOVED;
+	return ANSI_DIFF_CHANGED;
+}
+//#endregion
+//#region src/output/ascii/deps.ts
+function printPackageDependencyTree(graph, _options = {}) {
+	const rootNode = graph.nodes.get(graph.rootId);
+	if (rootNode === void 0) return toDisplayPath(graph.rootId, graph.repositoryRoot);
+	const lines = [rootNode.packageName];
+	const visited = new Set([graph.rootId]);
+	rootNode.dependencies.forEach((dependency, index) => {
+		lines.push(...renderDependency$1(dependency, graph, visited, "", index === rootNode.dependencies.length - 1));
+	});
+	return lines.join("\n");
+}
+function printPackageDependencyDiffTree(graph, options = {}) {
+	const color = resolveColorSupport(options.color);
+	const lines = [formatDiffRootLabel(graph.root, color)];
+	graph.root.dependencies.forEach((dependency, index) => {
+		lines.push(...renderDiffDependency(dependency, "", index === graph.root.dependencies.length - 1, color));
+	});
+	return lines.join("\n");
+}
+function renderDependency$1(dependency, graph, visited, prefix, isLast) {
+	const branch = `${prefix}${isLast ? "└─ " : "├─ "}`;
+	const label = formatDependencyLabel$1(dependency, graph.repositoryRoot);
+	if (dependency.kind === "external") 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 childLines = [`${branch}${label}`];
+	const nextPrefix = `${prefix}${isLast ? "   " : "│  "}`;
+	const nextVisited = new Set(visited);
+	nextVisited.add(dependency.target);
+	childNode.dependencies.forEach((childDependency, index) => {
+		childLines.push(...renderDependency$1(childDependency, graph, nextVisited, nextPrefix, index === childNode.dependencies.length - 1));
+	});
+	return childLines;
+}
+function formatDependencyLabel$1(dependency, repositoryRoot) {
+	if (dependency.kind === "external") return `${dependency.name}@${dependency.specifier}`;
+	const workspaceLabel = toDisplayPath(dependency.target, repositoryRoot);
+	if (dependency.specifier === void 0) return workspaceLabel;
+	return `${workspaceLabel} (${dependency.specifier})`;
+}
+function renderDiffDependency(dependency, prefix, isLast, color) {
+	const line = `${`${prefix}${isLast ? "└─ " : "├─ "}`}${formatDiffDependencyLine(dependency, color)}`;
+	if (dependency.kind === "external") return [line];
+	if (dependency.node.kind === "circular") return [`${line} (circular)`];
+	const childLines = [line];
+	const nextPrefix = `${prefix}${isLast ? "   " : "│  "}`;
+	dependency.node.dependencies.forEach((childDependency, index) => {
+		childLines.push(...renderDiffDependency(childDependency, nextPrefix, index === dependency.node.dependencies.length - 1, color));
+	});
+	return childLines;
+}
+function formatDiffRootLabel(node, color) {
+	if (node.change === "changed" && node.beforePackageName !== void 0 && node.afterPackageName !== void 0) return colorizeDiffText(`${toMarker(node.change)} ${node.beforePackageName} -> ${node.afterPackageName}`, node.change, color);
+	if (node.change === "unchanged") return node.packageName;
+	return colorizeDiffText(`${toMarker(node.change)} ${node.packageName}`, node.change, color);
+}
+function formatDiffDependencyLine(dependency, color) {
+	const marker = resolveVisibleDependencyMarker(dependency);
+	const label = formatDiffDependencyLabel(dependency);
+	if (marker === "unchanged") return label;
+	return colorizeDiffText(`${toMarker(marker)} ${label}`, marker, color);
+}
+function resolveVisibleDependencyMarker(dependency) {
+	if (dependency.change !== "unchanged") return dependency.change;
+	if (dependency.kind === "workspace" && dependency.node.change !== "unchanged") return dependency.node.change;
+	return "unchanged";
+}
+function formatDiffDependencyLabel(dependency) {
+	if (dependency.kind === "external") return formatExternalDiffLabel(dependency);
+	return formatWorkspaceDiffLabel(dependency);
+}
+function formatExternalDiffLabel(dependency) {
+	const beforeResolution = dependency.before?.resolvedVersion;
+	const afterResolution = dependency.after?.resolvedVersion;
+	if (dependency.change !== "changed") return dependency.after?.target ?? dependency.before?.target ?? dependency.name;
+	const previousSpecifier = dependency.before?.specifier ?? "none";
+	const nextSpecifier = dependency.after?.specifier ?? "none";
+	if (dependency.resolvedVersionChanged) {
+		const resolutionLabel = formatVersionChange(beforeResolution, afterResolution);
+		return previousSpecifier === nextSpecifier ? `${dependency.name}@${nextSpecifier} (${resolutionLabel})` : `${dependency.name}@${previousSpecifier} -> ${nextSpecifier} (${resolutionLabel})`;
+	}
+	if (previousSpecifier === nextSpecifier) return `${dependency.name}@${nextSpecifier}`;
+	return `${dependency.name}@${previousSpecifier} -> ${nextSpecifier}`;
+}
+function formatWorkspaceDiffLabel(dependency) {
+	if (dependency.change !== "changed") return formatWorkspaceState(dependency.after ?? dependency.before, dependency.node.path);
+	const previousTarget = dependency.before?.target ?? dependency.node.path;
+	const nextTarget = dependency.after?.target ?? dependency.node.path;
+	const targetLabel = previousTarget === nextTarget ? nextTarget : `${previousTarget} -> ${nextTarget}`;
+	const previousSpecifier = dependency.before?.specifier;
+	const nextSpecifier = dependency.after?.specifier;
+	if (previousSpecifier === nextSpecifier) return formatWorkspaceState({
+		target: targetLabel,
+		...nextSpecifier === void 0 ? {} : { specifier: nextSpecifier }
+	}, dependency.node.path);
+	return formatWorkspaceState({
+		target: targetLabel,
+		specifier: `${previousSpecifier ?? "none"} -> ${nextSpecifier ?? "none"}`
+	}, dependency.node.path);
+}
+function formatWorkspaceState(state, fallbackTarget) {
+	const target = state?.target ?? fallbackTarget;
+	if (state?.specifier === void 0) return target;
+	return `${target} (${state.specifier})`;
+}
+function formatVersionChange(beforeResolvedVersion, afterResolvedVersion) {
+	return `${beforeResolvedVersion ?? "none"} -> ${afterResolvedVersion ?? "none"}`;
+}
+function toMarker(change) {
+	if (change === "added") return "+";
+	if (change === "removed") return "-";
+	return "~";
+}
+function colorizeDiffText(text, change, color) {
+	if (change === "unchanged") return text;
+	return colorizePackageDiff(text, change, color);
+}
+//#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" || dependency.kind === "boundary") 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 === "boundary") return colorizeUnusedMarker(withUnusedSuffix(`${annotation}${toDisplayPath(dependency.target, cwd)} [${dependency.boundary === "project" ? "project boundary" : "workspace boundary"}]`, 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);
+	const filter = options.filter ?? "all";
+	const entries = getReactUsageEntries(graph, filter);
+	if (entries.length > 0) return renderReactUsageEntries(graph, entries, cwd, filter, color);
+	const roots = getReactUsageRoots(graph, filter);
+	if (roots.length === 0) return "No React symbols found.";
+	const lines = [];
+	roots.forEach((rootId, index) => {
+		const root = graph.nodes.get(rootId);
+		if (root === void 0) return;
+		lines.push(formatReactNodeLabel(root, cwd, color));
+		const usages = getFilteredUsages(root, graph, filter);
+		usages.forEach((usage, usageIndex) => {
+			lines.push(...renderUsage(usage, graph, cwd, filter, color, new Set([root.id]), "", usageIndex === usages.length - 1));
+		});
+		if (index < roots.length - 1) lines.push("");
+	});
+	return lines.join("\n");
+}
+function renderReactUsageEntries(graph, entries, cwd, filter, color) {
+	const lines = [];
+	entries.forEach((entry, index) => {
+		const root = graph.nodes.get(entry.target);
+		if (root === void 0) return;
+		lines.push(formatReactEntryLabel(entry, cwd));
+		lines.push(formatReactNodeLabel(root, cwd, color, entry.referenceName));
+		const usages = getFilteredUsages(root, graph, filter);
+		usages.forEach((usage, usageIndex) => {
+			lines.push(...renderUsage(usage, graph, cwd, filter, color, new Set([root.id]), "", usageIndex === usages.length - 1));
+		});
+		if (index < entries.length - 1) lines.push("");
+	});
+	return lines.join("\n");
+}
+function renderUsage(usage, graph, cwd, filter, color, visited, prefix, isLast) {
+	const branch = `${prefix}${isLast ? "└─ " : "├─ "}`;
+	const target = graph.nodes.get(usage.target);
+	if (target === void 0) return [`${branch}${usage.target}`];
+	if (visited.has(target.id)) return [`${branch}${formatReactNodeLabel(target, cwd, color, usage.referenceName)} (circular)`];
+	const childLines = [`${branch}${formatReactNodeLabel(target, cwd, color, usage.referenceName)}`];
+	const nextVisited = new Set(visited);
+	nextVisited.add(target.id);
+	const nextPrefix = `${prefix}${isLast ? "   " : "│  "}`;
+	const childUsages = getFilteredUsages(target, graph, filter);
+	childUsages.forEach((childUsage, index) => {
+		childLines.push(...renderUsage(childUsage, graph, cwd, filter, color, nextVisited, nextPrefix, index === childUsages.length - 1));
+	});
+	return childLines;
+}
+function formatReactNodeLabel(node, cwd, color, referenceName) {
+	return `${referenceName !== void 0 && referenceName !== node.name ? `${colorizeReactLabel(formatReactSymbolName(node.name, node.kind), node.kind, color)} ${colorizeMuted(`as ${referenceName}`, color)} ${colorizeReactLabel(`[${node.kind}]`, node.kind, color)}` : formatReactSymbolLabel(node.name, node.kind, color)} (${formatReactNodeFilePath$1(node, cwd)})`;
+}
+function formatReactEntryLabel(entry, cwd) {
+	return `${toDisplayPath(entry.location.filePath, cwd)}:${entry.location.line}:${entry.location.column}`;
+}
+function formatReactNodeFilePath$1(node, cwd) {
+	return node.kind === "builtin" ? "html" : toDisplayPath(node.filePath, cwd);
+}
+//#endregion
+//#region src/output/json/deps.ts
+function graphToSerializablePackageTree(graph) {
+	return serializePackageNode(graph.rootId, graph, /* @__PURE__ */ new Set());
+}
+function diffGraphToSerializablePackageTree(graph) {
+	return serializePackageDiffNode(graph.root);
+}
+function serializePackageNode(packageDir, graph, visited) {
+	const packageNode = graph.nodes.get(packageDir);
+	const packagePath = toDisplayPath(packageDir, graph.repositoryRoot);
+	if (packageNode === void 0) return {
+		kind: "missing",
+		label: packagePath,
+		path: packagePath,
+		dependencies: []
+	};
+	if (visited.has(packageDir)) return {
+		kind: "circular",
+		label: packageNode.packageName,
+		packageName: packageNode.packageName,
+		path: packagePath,
+		dependencies: []
+	};
+	visited.add(packageDir);
+	return {
+		kind: packageDir === graph.rootId ? "root" : "workspace",
+		label: packageDir === graph.rootId ? packageNode.packageName : packagePath,
+		packageName: packageNode.packageName,
+		path: packagePath,
+		dependencies: packageNode.dependencies.map((dependency) => serializeDependency(dependency, graph, new Set(visited)))
+	};
+}
+function serializeDependency(dependency, graph, visited) {
+	if (dependency.kind === "external") return {
+		kind: "external",
+		name: dependency.name,
+		specifier: dependency.specifier,
+		target: `${dependency.name}@${dependency.specifier}`
+	};
+	return {
+		kind: "workspace",
+		name: dependency.name,
+		...dependency.specifier === void 0 ? {} : { specifier: dependency.specifier },
+		target: toDisplayPath(dependency.target, graph.repositoryRoot),
+		node: serializePackageNode(dependency.target, graph, visited)
+	};
+}
+function serializePackageDiffNode(node) {
+	return {
+		kind: node.kind,
+		label: node.label,
+		packageName: node.packageName,
+		path: node.path,
+		change: node.change,
+		...node.beforePackageName === void 0 ? {} : { beforePackageName: node.beforePackageName },
+		...node.afterPackageName === void 0 ? {} : { afterPackageName: node.afterPackageName },
+		dependencies: node.dependencies.map((dependency) => serializePackageDiffDependency(dependency))
+	};
+}
+function serializePackageDiffDependency(dependency) {
+	return {
+		kind: dependency.kind,
+		name: dependency.name,
+		change: dependency.change,
+		...dependency.kind === "external" ? {
+			specifierChanged: dependency.specifierChanged,
+			resolvedVersionChanged: dependency.resolvedVersionChanged,
+			peerContextChanged: dependency.peerContextChanged
+		} : {},
+		...dependency.before === void 0 ? {} : {
+			beforeTarget: dependency.before.target,
+			...dependency.before.specifier === void 0 ? {} : { beforeSpecifier: dependency.before.specifier },
+			...dependency.before.resolvedVersion === void 0 ? {} : { beforeResolvedVersion: dependency.before.resolvedVersion },
+			...dependency.before.peerContext === void 0 ? {} : { beforePeerContext: dependency.before.peerContext }
+		},
+		...dependency.after === void 0 ? {} : {
+			afterTarget: dependency.after.target,
+			...dependency.after.specifier === void 0 ? {} : { afterSpecifier: dependency.after.specifier },
+			...dependency.after.resolvedVersion === void 0 ? {} : { afterResolvedVersion: dependency.after.resolvedVersion },
+			...dependency.after.peerContext === void 0 ? {} : { afterPeerContext: dependency.after.peerContext }
+		},
+		...dependency.before === void 0 ? {} : { before: dependency.before },
+		...dependency.after === void 0 ? {} : { after: dependency.after },
+		...dependency.after === void 0 ? dependency.before === void 0 ? {} : { target: dependency.before.target } : { target: dependency.after.target },
+		...dependency.kind === "workspace" ? { node: serializePackageDiffNode(dependency.node) } : {}
+	};
+}
+//#endregion
+//#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 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,
+			...dependency.boundary === void 0 ? {} : { boundary: dependency.boundary },
+			target: serializeDependencyTarget(dependency, 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 serializeDependencyTarget(dependency, cwd) {
+	if (dependency.kind === "missing" || dependency.kind === "external") return dependency.target;
+	if (dependency.kind === "builtin") return dependency.target;
+	return toDisplayPath(dependency.target, cwd);
+}
+//#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 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: formatReactNodeFilePath(node.filePath, node.kind, 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: formatReactNodeFilePath(node.filePath, node.kind, graph.cwd),
+		exportNames: node.exportNames,
+		usages: getFilteredUsages(node, graph, filter).map((usage) => ({
+			kind: usage.kind,
+			targetId: usage.target,
+			referenceName: usage.referenceName,
+			node: serializeReactUsageNode(usage.target, graph, filter, nextVisited)
+		}))
+	};
+}
+function serializeReactUsageEntry(entry, graph, filter) {
+	return {
+		targetId: entry.target,
+		referenceName: entry.referenceName,
+		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 formatReactNodeFilePath(filePath, kind, cwd) {
+	return kind === "builtin" ? "html" : toDisplayPath(filePath, cwd);
+}
+//#endregion
+export { printReactUsageTree as a, printPackageDependencyTree as c, getReactUsageRoots as d, analyzeReactUsage as f, analyzePackageDependencies as g, analyzePackageDependencyDiff as h, graphToSerializablePackageTree as i, getFilteredUsages as l, isSourceCodeFile as m, graphToSerializableTree as n, printDependencyTree as o, analyzeDependencies as p, diffGraphToSerializablePackageTree as r, printPackageDependencyDiffTree as s, graphToSerializableReactTree as t, getReactUsageEntries as u };
+
+//# sourceMappingURL=react-DWxB8qZ6.mjs.map