foresthouse 1.0.0-dev.9 → 1.0.1-dev.1

package/dist/react-BHPy_fw5.mjs

@@ -1,1130 +0,0 @@
-import { builtinModules } from "node:module";
-import path from "node:path";
-import ts from "typescript";
-import fs from "node:fs";
-import { parseSync, visitorKeys } from "oxc-parser";
-import process$1 from "node:process";
-//#region src/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) {
-		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");
-}
-//#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/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, cwd) {
-	const host = ts.createCompilerHost(compilerOptions, true);
-	host.getCurrentDirectory = () => cwd;
-	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 createModuleResolutionHost(cwd) {
-	return {
-		fileExists: ts.sys.fileExists,
-		readFile: ts.sys.readFile,
-		directoryExists: ts.sys.directoryExists,
-		getCurrentDirectory: () => cwd,
-		getDirectories: ts.sys.getDirectories,
-		...ts.sys.realpath === void 0 ? {} : { realpath: ts.sys.realpath }
-	};
-}
-function getScriptKind(filePath) {
-	switch (path.extname(filePath).toLowerCase()) {
-		case ".js":
-		case ".mjs":
-		case ".cjs": return ts.ScriptKind.JS;
-		case ".jsx": return ts.ScriptKind.JSX;
-		case ".tsx": return ts.ScriptKind.TSX;
-		case ".json": return ts.ScriptKind.JSON;
-		default: return ts.ScriptKind.TS;
-	}
-}
-//#endregion
-//#region src/analyzers/import/unused.ts
-function collectUnusedImports(sourceFile, checker) {
-	const importUsage = /* @__PURE__ */ new Map();
-	const symbolToImportDeclaration = /* @__PURE__ */ new Map();
-	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, compilerOptions, host) {
-	const specifier = reference.specifier;
-	if (BUILTIN_MODULES.has(specifier)) return createEdge(reference, "builtin", specifier);
-	const resolution = ts.resolveModuleName(specifier, containingFile, compilerOptions, host).resolvedModule;
-	if (resolution !== void 0) {
-		const resolvedPath = normalizeFilePath(resolution.resolvedFileName);
-		if (resolution.isExternalLibraryImport || resolvedPath.includes(`${path.sep}node_modules${path.sep}`)) return createEdge(reference, "external", specifier);
-		if (isSourceCodeFile(resolvedPath) && !resolvedPath.endsWith(".d.ts")) return createEdge(reference, "source", resolvedPath);
-	}
-	if (!specifier.startsWith(".") && !path.isAbsolute(specifier)) return createEdge(reference, "external", specifier);
-	return createEdge(reference, "missing", specifier);
-}
-function createEdge(reference, kind, target) {
-	return {
-		specifier: reference.specifier,
-		referenceKind: reference.referenceKind,
-		isTypeOnly: reference.isTypeOnly,
-		unused: reference.unused,
-		kind,
-		target
-	};
-}
-//#endregion
-//#region src/analyzers/import/graph.ts
-function buildDependencyGraph(entryPath, compilerOptions, cwd) {
-	return new DependencyGraphBuilder(entryPath, compilerOptions, cwd).build();
-}
-var DependencyGraphBuilder = class {
-	host;
-	nodes = /* @__PURE__ */ new Map();
-	program;
-	checker;
-	constructor(entryPath, compilerOptions, cwd) {
-		this.entryPath = entryPath;
-		this.compilerOptions = compilerOptions;
-		this.host = createModuleResolutionHost(cwd);
-		this.program = createProgram(entryPath, compilerOptions, cwd);
-		this.checker = this.program.getTypeChecker();
-	}
-	build() {
-		this.visitFile(this.entryPath);
-		return this.nodes;
-	}
-	visitFile(filePath) {
-		const normalizedPath = normalizeFilePath(filePath);
-		if (this.nodes.has(normalizedPath)) return;
-		const dependencies = collectModuleReferences(this.program.getSourceFile(normalizedPath) ?? createSourceFile(normalizedPath), this.checker).map((reference) => resolveDependency(reference, normalizedPath, this.compilerOptions, this.host));
-		this.nodes.set(normalizedPath, {
-			id: normalizedPath,
-			dependencies
-		});
-		for (const dependency of dependencies) if (dependency.kind === "source") this.visitFile(dependency.target);
-	}
-};
-//#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, compilerOptions, this.cwd);
-		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) {
-	switch (statement.type) {
-		case "ImportDeclaration":
-			collectImportBindings(statement, sourceDependencies, importsByLocalName);
-			return;
-		case "ExportNamedDeclaration":
-			collectNamedExports(statement, symbolsByName, exportsByName);
-			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, symbolsByName, exportsByName) {
-	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) return;
-	declaration.specifiers.forEach((specifier) => {
-		if (specifier.exportKind === "type") return;
-		addExportBinding(toModuleExportName(specifier.local), toModuleExportName(specifier.exported), symbolsByName, exportsByName);
-	});
-}
-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)) return "hook";
-	if (isComponentName(name) && returnsReactElement(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 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 isHookName(name) {
-	return /^use[A-Z0-9]/.test(name);
-}
-function isComponentName(name) {
-	return /^[A-Z]/.test(name);
-}
-function returnsReactElement(declaration) {
-	if (declaration.type === "ArrowFunctionExpression" && declaration.expression) return containsReactElementLikeExpression(declaration.body);
-	const body = declaration.body;
-	if (body === null) return false;
-	let found = false;
-	walkReactUsageTree(body, (node) => {
-		if (node.type !== "ReturnStatement" || node.argument === null) return;
-		if (containsReactElementLikeExpression(node.argument)) found = true;
-	});
-	return found;
-}
-function isReactCreateElementCall(node) {
-	const callee = unwrapExpression(node.callee);
-	if (callee.type !== "MemberExpression" || callee.computed) return false;
-	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, includeNestedFunctions) {
-	const entries = /* @__PURE__ */ new Map();
-	program.body.forEach((statement) => {
-		collectStatementEntryUsages(statement, filePath, sourceText, entries, includeNestedFunctions);
-	});
-	return [...entries.values()].sort(comparePendingReactUsageEntries);
-}
-function collectStatementEntryUsages(statement, filePath, sourceText, entries, includeNestedFunctions) {
-	collectNodeEntryUsages(statement, filePath, sourceText, entries, false, includeNestedFunctions);
-}
-function collectNodeEntryUsages(node, filePath, sourceText, entries, hasComponentAncestor, includeNestedFunctions) {
-	if (!includeNestedFunctions && FUNCTION_NODE_TYPES.has(node.type)) return;
-	let nextHasComponentAncestor = hasComponentAncestor;
-	if (node.type === "JSXElement") {
-		const referenceName = getComponentReferenceName(node);
-		if (referenceName !== void 0) {
-			if (!hasComponentAncestor) addPendingReactUsageEntry(entries, referenceName, "component", createReactUsageLocation(filePath, sourceText, node.start));
-			nextHasComponentAncestor = true;
-		}
-	} else if (node.type === "CallExpression") {
-		const hookReference = getHookReferenceName(node);
-		if (hookReference !== void 0) addPendingReactUsageEntry(entries, hookReference, "hook", createReactUsageLocation(filePath, sourceText, node.start));
-		const referenceName = getCreateElementComponentReferenceName(node);
-		if (referenceName !== void 0) {
-			if (!hasComponentAncestor) addPendingReactUsageEntry(entries, referenceName, "component", createReactUsageLocation(filePath, sourceText, node.start));
-			nextHasComponentAncestor = true;
-		}
-	}
-	const keys = visitorKeys[node.type];
-	if (keys === void 0) return;
-	keys.forEach((key) => {
-		const value = node[key];
-		collectEntryUsageChild(value, filePath, sourceText, entries, nextHasComponentAncestor, includeNestedFunctions);
-	});
-}
-function collectEntryUsageChild(value, filePath, sourceText, entries, hasComponentAncestor, includeNestedFunctions) {
-	if (Array.isArray(value)) {
-		value.forEach((entry) => {
-			collectEntryUsageChild(entry, filePath, sourceText, entries, hasComponentAncestor, includeNestedFunctions);
-		});
-		return;
-	}
-	if (!isNode(value)) return;
-	collectNodeEntryUsages(value, filePath, sourceText, entries, hasComponentAncestor, includeNestedFunctions);
-}
-function addPendingReactUsageEntry(entries, referenceName, kind, location) {
-	const key = `${location.filePath}:${location.line}:${location.column}:${kind}:${referenceName}`;
-	entries.set(key, {
-		referenceName,
-		kind,
-		location
-	});
-}
-function createReactUsageLocation(filePath, sourceText, offset) {
-	return {
-		filePath,
-		...offsetToLineAndColumn(sourceText, offset)
-	};
-}
-function offsetToLineAndColumn(sourceText, offset) {
-	let line = 1;
-	let column = 1;
-	for (let index = 0; index < offset && index < sourceText.length; index += 1) {
-		if (sourceText[index] === "\n") {
-			line += 1;
-			column = 1;
-			continue;
-		}
-		column += 1;
-	}
-	return {
-		line,
-		column
-	};
-}
-function comparePendingReactUsageEntries(left, right) {
-	return left.location.filePath.localeCompare(right.location.filePath) || left.location.line - right.location.line || left.location.column - right.location.column || left.kind.localeCompare(right.kind) || left.referenceName.localeCompare(right.referenceName);
-}
-//#endregion
-//#region src/analyzers/react/symbols.ts
-function collectTopLevelReactSymbols(statement, filePath, symbolsByName) {
-	switch (statement.type) {
-		case "FunctionDeclaration":
-			addFunctionSymbol(statement, filePath, symbolsByName);
-			return;
-		case "VariableDeclaration":
-			statement.declarations.forEach((declarator) => {
-				addVariableSymbol(declarator, filePath, symbolsByName);
-			});
-			return;
-		case "ExportNamedDeclaration":
-			if (statement.declaration !== null) collectTopLevelReactSymbols(statement.declaration, filePath, symbolsByName);
-			return;
-		case "ExportDefaultDeclaration":
-			addDefaultExportSymbol(statement, filePath, symbolsByName);
-			return;
-		default: return;
-	}
-}
-function addFunctionSymbol(declaration, filePath, symbolsByName) {
-	const name = declaration.id?.name;
-	if (name === void 0) return;
-	const kind = classifyReactSymbol(name, declaration);
-	if (kind === void 0) return;
-	symbolsByName.set(name, createPendingSymbol(filePath, name, kind, declaration));
-}
-function addVariableSymbol(declarator, filePath, symbolsByName) {
-	if (declarator.id.type !== "Identifier" || declarator.init === null) return;
-	if (declarator.init.type !== "ArrowFunctionExpression" && declarator.init.type !== "FunctionExpression") return;
-	const name = declarator.id.name;
-	const kind = classifyReactSymbol(name, declarator.init);
-	if (kind === void 0) return;
-	symbolsByName.set(name, createPendingSymbol(filePath, name, kind, declarator.init));
-}
-function addDefaultExportSymbol(declaration, filePath, symbolsByName) {
-	if (declaration.declaration.type === "FunctionDeclaration" || declaration.declaration.type === "FunctionExpression") addFunctionSymbol(declaration.declaration, filePath, symbolsByName);
-	else if (declaration.declaration.type === "ArrowFunctionExpression") {
-		const name = "default";
-		const kind = declaration.declaration.body ? classifyReactSymbol(name, declaration.declaration) : void 0;
-		if (kind !== void 0) symbolsByName.set(name, createPendingSymbol(filePath, name, kind, declaration.declaration));
-	}
-}
-function createPendingSymbol(filePath, name, kind, declaration) {
-	return {
-		id: `${filePath}#${kind}:${name}`,
-		name,
-		kind,
-		filePath,
-		declaration,
-		exportNames: /* @__PURE__ */ new Set(),
-		componentReferences: /* @__PURE__ */ new Set(),
-		hookReferences: /* @__PURE__ */ new Set()
-	};
-}
-//#endregion
-//#region src/analyzers/react/usage.ts
-function analyzeSymbolUsages(symbol) {
-	const root = symbol.declaration.type === "ArrowFunctionExpression" ? symbol.declaration.body : symbol.declaration.body;
-	if (root === null) return;
-	walkReactUsageTree(root, (node) => {
-		if (node.type === "JSXElement") {
-			const name = getComponentReferenceName(node);
-			if (name !== void 0) symbol.componentReferences.add(name);
-			return;
-		}
-		if (node.type === "CallExpression") {
-			const hookReference = getHookReferenceName(node);
-			if (hookReference !== void 0) symbol.hookReferences.add(hookReference);
-			const componentReference = getCreateElementComponentReferenceName(node);
-			if (componentReference !== void 0) symbol.componentReferences.add(componentReference);
-		}
-	});
-}
-//#endregion
-//#region src/analyzers/react/file.ts
-function analyzeReactFile(program, filePath, sourceText, includeNestedRenderEntries, sourceDependencies) {
-	const symbolsByName = /* @__PURE__ */ new Map();
-	program.body.forEach((statement) => {
-		collectTopLevelReactSymbols(statement, filePath, symbolsByName);
-	});
-	const importsByLocalName = /* @__PURE__ */ new Map();
-	const exportsByName = /* @__PURE__ */ new Map();
-	const entryUsages = collectEntryUsages(program, filePath, sourceText, includeNestedRenderEntries);
-	program.body.forEach((statement) => {
-		collectImportsAndExports(statement, sourceDependencies, symbolsByName, importsByLocalName, exportsByName);
-	});
-	symbolsByName.forEach((symbol) => {
-		analyzeSymbolUsages(symbol);
-	});
-	return {
-		filePath,
-		importsByLocalName,
-		exportsByName,
-		entryUsages,
-		symbolsById: new Map([...symbolsByName.values()].map((symbol) => [symbol.id, symbol])),
-		symbolsByName
-	};
-}
-//#endregion
-//#region src/analyzers/react/references.ts
-function resolveReactReference(fileAnalysis, fileAnalyses, name, kind) {
-	const localSymbol = fileAnalysis.symbolsByName.get(name);
-	if (localSymbol !== void 0 && localSymbol.kind === kind) return localSymbol.id;
-	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 = sourceFileAnalysis.exportsByName.get(importBinding.importedName);
-	if (targetId === void 0) return;
-	return sourceFileAnalysis.symbolsById.get(targetId)?.kind === kind ? targetId : void 0;
-}
-function addExternalHookNodes(fileAnalyses, nodes) {
-	for (const fileAnalysis of fileAnalyses.values()) fileAnalysis.importsByLocalName.forEach((binding, localName) => {
-		if (binding.sourcePath !== void 0) return;
-		if (!isHookName(localName) && !isHookName(binding.importedName)) return;
-		const externalNode = createExternalHookNode(binding, localName);
-		if (!nodes.has(externalNode.id)) nodes.set(externalNode.id, externalNode);
-	});
-}
-function createExternalHookNode(binding, localName) {
-	const name = getExternalHookName(binding, localName);
-	return {
-		id: getExternalHookNodeId(binding, localName),
-		name,
-		kind: "hook",
-		filePath: binding.sourceSpecifier,
-		exportNames: [binding.importedName],
-		usages: []
-	};
-}
-function getExternalHookNodeId(binding, localName) {
-	return `external:${binding.sourceSpecifier}#hook:${getExternalHookName(binding, localName)}`;
-}
-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(entryFile, options).analyze();
-}
-var ReactAnalyzer = class extends BaseAnalyzer {
-	doAnalyze() {
-		const dependencyGraph = analyzeDependencies(this.entryFile, this.options);
-		const fileAnalyses = this.collectFileAnalyses(dependencyGraph);
-		const nodes = this.createNodes(fileAnalyses);
-		this.attachUsages(fileAnalyses, nodes);
-		const entries = this.collectEntries(fileAnalyses, nodes);
-		return {
-			cwd: dependencyGraph.cwd,
-			entryId: dependencyGraph.entryId,
-			nodes,
-			entries
-		};
-	}
-	collectFileAnalyses(dependencyGraph) {
-		const reachableFiles = new Set([dependencyGraph.entryId, ...dependencyGraph.nodes.keys()]);
-		const fileAnalyses = /* @__PURE__ */ new Map();
-		for (const filePath of [...reachableFiles].sort()) {
-			if (!isSourceCodeFile(filePath) || filePath.endsWith(".d.ts")) continue;
-			const sourceText = fs.readFileSync(filePath, "utf8");
-			const parseResult = parseSync(filePath, sourceText, {
-				astType: "ts",
-				sourceType: "unambiguous"
-			});
-			const dependencyNode = dependencyGraph.nodes.get(filePath);
-			const sourceDependencies = /* @__PURE__ */ new Map();
-			dependencyNode?.dependencies.forEach((dependency) => {
-				if (dependency.kind === "source") sourceDependencies.set(dependency.specifier, dependency.target);
-			});
-			fileAnalyses.set(filePath, analyzeReactFile(parseResult.program, filePath, sourceText, filePath === dependencyGraph.entryId, sourceDependencies));
-		}
-		return fileAnalyses;
-	}
-	createNodes(fileAnalyses) {
-		const nodes = /* @__PURE__ */ new Map();
-		for (const fileAnalysis of fileAnalyses.values()) for (const symbol of fileAnalysis.symbolsById.values()) nodes.set(symbol.id, {
-			id: symbol.id,
-			name: symbol.name,
-			kind: symbol.kind,
-			filePath: symbol.filePath,
-			exportNames: [...symbol.exportNames].sort(),
-			usages: []
-		});
-		addExternalHookNodes(fileAnalyses, nodes);
-		return nodes;
-	}
-	attachUsages(fileAnalyses, nodes) {
-		for (const fileAnalysis of fileAnalyses.values()) for (const symbol of fileAnalysis.symbolsById.values()) {
-			const usages = /* @__PURE__ */ new Map();
-			symbol.componentReferences.forEach((referenceName) => {
-				const targetId = resolveReactReference(fileAnalysis, fileAnalyses, referenceName, "component");
-				if (targetId !== void 0 && targetId !== symbol.id) usages.set(`render:${targetId}:${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
-				});
-			});
-			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));
-	}
-};
-//#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_MUTED = "\x1B[38;5;244m";
-const ANSI_UNUSED = "\x1B[38;5;214m";
-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 = `${name} [${kind}]`;
-	if (!enabled) return label;
-	return `${getReactSymbolColor(kind)}${label}${ANSI_RESET}`;
-}
-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 getReactSymbolColor(kind) {
-	return kind === "component" ? ANSI_COMPONENT : ANSI_HOOK;
-}
-//#endregion
-//#region src/utils/to-display-path.ts
-function toDisplayPath(filePath, cwd) {
-	const relativePath = path.relative(cwd, filePath);
-	if (relativePath === "") return ".";
-	const normalizedPath = relativePath.split(path.sep).join("/");
-	return normalizedPath.startsWith("..") ? filePath : normalizedPath;
-}
-//#endregion
-//#region src/output/ascii/import.ts
-function printDependencyTree(graph, options = {}) {
-	const cwd = options.cwd ?? graph.cwd;
-	const color = resolveColorSupport(options.color);
-	const includeExternals = options.includeExternals ?? false;
-	const omitUnused = options.omitUnused ?? false;
-	const rootLines = [toDisplayPath(graph.entryId, cwd)];
-	const visited = new Set([graph.entryId]);
-	const entryNode = graph.nodes.get(graph.entryId);
-	if (entryNode === void 0) return rootLines.join("\n");
-	const rootDependencies = filterDependencies(entryNode.dependencies, includeExternals, omitUnused);
-	rootDependencies.forEach((dependency, index) => {
-		rootLines.push(...renderDependency(dependency, graph, visited, "", index === rootDependencies.length - 1, includeExternals, omitUnused, color, cwd));
-	});
-	return rootLines.join("\n");
-}
-function renderDependency(dependency, graph, visited, prefix, isLast, includeExternals, omitUnused, color, cwd) {
-	const branch = `${prefix}${isLast ? "└─ " : "├─ "}`;
-	const label = formatDependencyLabel(dependency, cwd, color);
-	if (dependency.kind !== "source") return [`${branch}${label}`];
-	if (visited.has(dependency.target)) return [`${branch}${label} (circular)`];
-	const childNode = graph.nodes.get(dependency.target);
-	if (childNode === void 0) return [`${branch}${label}`];
-	const nextPrefix = `${prefix}${isLast ? "   " : "│  "}`;
-	const nextVisited = new Set(visited);
-	nextVisited.add(dependency.target);
-	const childLines = [`${branch}${label}`];
-	const childDependencies = filterDependencies(childNode.dependencies, includeExternals, omitUnused);
-	childDependencies.forEach((childDependency, index) => {
-		childLines.push(...renderDependency(childDependency, graph, nextVisited, nextPrefix, index === childDependencies.length - 1, includeExternals, omitUnused, color, cwd));
-	});
-	return childLines;
-}
-function filterDependencies(dependencies, includeExternals, omitUnused) {
-	return dependencies.filter((dependency) => {
-		if (omitUnused && dependency.unused) return false;
-		if (dependency.kind === "source" || dependency.kind === "missing") return true;
-		return includeExternals;
-	});
-}
-function formatDependencyLabel(dependency, cwd, color) {
-	const prefixes = [];
-	if (dependency.isTypeOnly) prefixes.push("type");
-	if (dependency.referenceKind === "require") prefixes.push("require");
-	else if (dependency.referenceKind === "dynamic-import") prefixes.push("dynamic");
-	else if (dependency.referenceKind === "export") prefixes.push("re-export");
-	else if (dependency.referenceKind === "import-equals") prefixes.push("import=");
-	const annotation = prefixes.length > 0 ? `[${prefixes.join(", ")}] ` : "";
-	if (dependency.kind === "source") return colorizeUnusedMarker(withUnusedSuffix(`${annotation}${toDisplayPath(dependency.target, cwd)}`, dependency.unused), color);
-	if (dependency.kind === "missing") return colorizeUnusedMarker(withUnusedSuffix(`${annotation}${dependency.specifier} [missing]`, dependency.unused), color);
-	if (dependency.kind === "builtin") return colorizeUnusedMarker(withUnusedSuffix(`${annotation}${dependency.target} [builtin]`, dependency.unused), color);
-	return colorizeUnusedMarker(withUnusedSuffix(`${annotation}${dependency.target} [external]`, dependency.unused), color);
-}
-function withUnusedSuffix(label, unused) {
-	return unused ? `${label} (unused)` : label;
-}
-//#endregion
-//#region src/output/ascii/react.ts
-function printReactUsageTree(graph, options = {}) {
-	const cwd = options.cwd ?? graph.cwd;
-	const color = resolveColorSupport(options.color);
-	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(node.name, node.kind, color)} ${colorizeMuted(`as ${referenceName}`, color)} ${colorizeReactLabel(`[${node.kind}]`, node.kind, color)}` : formatReactSymbolLabel(node.name, node.kind, color)} (${toDisplayPath(node.filePath, cwd)})`;
-}
-function formatReactEntryLabel(entry, cwd) {
-	return `${toDisplayPath(entry.location.filePath, cwd)}:${entry.location.line}:${entry.location.column}`;
-}
-//#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,
-			target: dependency.kind === "missing" ? dependency.target : toDisplayPath(dependency.target, graph.cwd)
-		};
-		return {
-			specifier: dependency.specifier,
-			referenceKind: dependency.referenceKind,
-			isTypeOnly: dependency.isTypeOnly,
-			unused: dependency.unused,
-			kind: dependency.kind,
-			target: toDisplayPath(dependency.target, graph.cwd),
-			node: serializeNode(dependency.target, graph, new Set(visited), omitUnused)
-		};
-	});
-	return {
-		path: displayPath,
-		kind: filePath === graph.entryId ? "entry" : "source",
-		dependencies
-	};
-}
-//#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: toDisplayPath(node.filePath, graph.cwd),
-		exportNames: node.exportNames,
-		usages: []
-	};
-	const nextVisited = new Set(visited);
-	nextVisited.add(nodeId);
-	return {
-		id: node.id,
-		name: node.name,
-		symbolKind: node.kind,
-		filePath: toDisplayPath(node.filePath, graph.cwd),
-		exportNames: node.exportNames,
-		usages: getFilteredUsages(node, graph, filter).map((usage) => ({
-			kind: usage.kind,
-			targetId: usage.target,
-			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())
-	};
-}
-//#endregion
-export { getFilteredUsages as a, analyzeReactUsage as c, printDependencyTree as i, analyzeDependencies as l, graphToSerializableTree as n, getReactUsageEntries as o, printReactUsageTree as r, getReactUsageRoots as s, graphToSerializableReactTree as t };
-
-//# sourceMappingURL=react-BHPy_fw5.mjs.map