deslop-js 0.0.2

package/dist/src-BIp8ek0h.mjs

@@ -0,0 +1,4922 @@
+import path, { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import fg from "fast-glob";
+import { readFile } from "node:fs/promises";
+import { parseSync } from "oxc-parser";
+import { ResolverFactory } from "oxc-resolver";
+import { minimatch } from "minimatch";
+
+//#region src/constants.ts
+const DEFAULT_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mts",
+	".mjs",
+	".cts",
+	".cjs",
+	".mdx",
+	".astro",
+	".graphql",
+	".gql",
+	".css",
+	".scss",
+	".vue",
+	".svelte"
+];
+const HIDDEN_DIRECTORY_ALLOWLIST = [
+	".storybook",
+	".vitepress",
+	".well-known",
+	".changeset",
+	".github",
+	".client",
+	".server"
+];
+const OUTPUT_DIRECTORIES = [
+	"dist",
+	"build",
+	"out",
+	"esm",
+	"cjs"
+];
+const SOURCE_EXTENSIONS$3 = [
+	"ts",
+	"tsx",
+	"mts",
+	"cts",
+	"js",
+	"jsx",
+	"mjs",
+	"cjs"
+];
+const DEFAULT_IGNORE_PATTERNS = [
+	"**/node_modules/**",
+	"**/.git/**",
+	"**/coverage/**",
+	"**/*.min.js",
+	"**/*.min.mjs",
+	"**/mockServiceWorker.js"
+];
+const SCRIPT_FILE_PATTERN = /(?:^|\s)(?:node|tsx|ts-node|tsc|npx|bun|esr|esno|jiti|babel-node|zx)\s+(?:(?:-[\w-]+(?:[=\s][\w./@=-]+)?\s+)|(?:[\w/-]+\s+))*([\w./@-]+\.(?:ts|tsx|js|jsx|mts|mjs|cts|cjs))(?:\s|$)/;
+const SCRIPT_EXTENSIONLESS_FILE_PATTERN = /(?:^|\s)(?:node|tsx|ts-node|bun|esr|esno|jiti|babel-node|zx)\s+(?:(?:-[\w-]+(?:[=\s][\w./@=-]+)?\s+))*((?:[./]|[\w@][\w@-]*\/)[\w./@-]+)(?:\s|$)/;
+const SCRIPT_CONFIG_FILE_PATTERN = /--config\s+([\w./@-]+\.(?:ts|tsx|js|jsx|mts|mjs|cts|cjs))/;
+const SCRIPT_ENTRY_PATTERNS = [];
+const DEFAULT_ENTRY_PATTERNS = [
+	"src/index.{ts,tsx,js,jsx}",
+	"src/main.{ts,tsx,js,jsx}",
+	"index.{ts,tsx,js,jsx}",
+	"main.{ts,tsx,js,jsx}"
+];
+const CONFIG_FILE_PREFIXES = [
+	"babel.config.",
+	"rollup.config.",
+	"webpack.config.",
+	"postcss.config.",
+	"stencil.config.",
+	"remotion.config.",
+	"metro.config.",
+	"tsup.config.",
+	"tsdown.config.",
+	"unbuild.config.",
+	"esbuild.config.",
+	"swc.config.",
+	"turbo.",
+	"jest.config.",
+	"jest.setup.",
+	"vitest.config.",
+	"vitest.ci.config.",
+	"vitest.setup.",
+	"vitest.workspace.",
+	"playwright.config.",
+	"cypress.config.",
+	"karma.conf.",
+	"eslint.config.",
+	"prettier.config.",
+	"stylelint.config.",
+	"lint-staged.config.",
+	"commitlint.config.",
+	"next.config.",
+	"next-sitemap.config.",
+	"nuxt.config.",
+	"astro.config.",
+	"sanity.config.",
+	"vite.config.",
+	"tailwind.config.",
+	"drizzle.config.",
+	"knexfile.",
+	"sentry.client.config.",
+	"sentry.server.config.",
+	"sentry.edge.config.",
+	"react-router.config.",
+	"typedoc.",
+	"deslop.config.",
+	"i18next-parser.config.",
+	"codegen.config.",
+	"graphql.config.",
+	"npmpackagejsonlint.config.",
+	"release-it.",
+	"release.config.",
+	"contentlayer.config.",
+	"rspack.config.",
+	"rsbuild.config.",
+	"module-federation.config.",
+	"next-env.d.",
+	"env.d.",
+	"vite-env.d."
+];
+const ALWAYS_USED_PACKAGES = new Set([
+	"typescript",
+	"@types/node",
+	"@types/react",
+	"@types/react-dom",
+	"eslint",
+	"prettier",
+	"husky",
+	"lint-staged",
+	"tslib"
+]);
+const BUILTIN_MODULES = new Set([
+	"assert",
+	"async_hooks",
+	"buffer",
+	"child_process",
+	"cluster",
+	"console",
+	"constants",
+	"crypto",
+	"dgram",
+	"diagnostics_channel",
+	"dns",
+	"domain",
+	"events",
+	"fs",
+	"http",
+	"http2",
+	"https",
+	"inspector",
+	"module",
+	"net",
+	"os",
+	"path",
+	"perf_hooks",
+	"process",
+	"punycode",
+	"querystring",
+	"readline",
+	"repl",
+	"stream",
+	"string_decoder",
+	"sys",
+	"timers",
+	"tls",
+	"trace_events",
+	"tty",
+	"url",
+	"util",
+	"v8",
+	"vm",
+	"wasi",
+	"worker_threads",
+	"zlib"
+]);
+const PLATFORM_SUFFIXES = [
+	".web",
+	".native",
+	".ios",
+	".android",
+	".desktop",
+	".windows",
+	".macos",
+	".any"
+];
+const REACT_NATIVE_PLATFORM_EXTENSIONS = [
+	".web.ts",
+	".web.tsx",
+	".web.js",
+	".web.jsx",
+	".native.ts",
+	".native.tsx",
+	".native.js",
+	".native.jsx",
+	".ios.ts",
+	".ios.tsx",
+	".ios.js",
+	".ios.jsx",
+	".android.ts",
+	".android.tsx",
+	".android.js",
+	".android.jsx"
+];
+const RESOLVER_EXTENSIONS = [
+	...DEFAULT_EXTENSIONS,
+	".d.ts",
+	".d.mts",
+	".d.cts",
+	".json",
+	".node",
+	".css",
+	".scss",
+	".less",
+	".svg",
+	".png",
+	".jpg",
+	".graphql",
+	".gql"
+];
+
+//#endregion
+//#region src/utils/line-column.ts
+const getLineFromOffset = (source, offset) => {
+	let line = 1;
+	for (let charIndex = 0; charIndex < offset && charIndex < source.length; charIndex++) if (source[charIndex] === "\n") line++;
+	return line;
+};
+const getColumnFromOffset = (source, offset) => {
+	let column = 0;
+	for (let charIndex = offset - 1; charIndex >= 0; charIndex--) {
+		if (source[charIndex] === "\n") break;
+		column++;
+	}
+	return column;
+};
+
+//#endregion
+//#region src/scanner/parse.ts
+const extractMdxImportsExports = (sourceText) => {
+	const statements = [];
+	let isInMultiline = false;
+	let braceDepth = 0;
+	for (const line of sourceText.split("\n")) {
+		const trimmedLine = line.trim();
+		if (isInMultiline) {
+			statements.push(line);
+			for (const character of trimmedLine) {
+				if (character === "{") braceDepth++;
+				if (character === "}") braceDepth--;
+			}
+			const hasFromClause = trimmedLine.includes(" from ") || trimmedLine.includes(" from'") || trimmedLine.includes(" from\"");
+			if (braceDepth <= 0 || trimmedLine.endsWith(";") || hasFromClause) {
+				isInMultiline = false;
+				braceDepth = 0;
+			}
+		} else if (trimmedLine.startsWith("import ") || trimmedLine.startsWith("import{") || trimmedLine.startsWith("export ") || trimmedLine.startsWith("export{")) {
+			statements.push(line);
+			for (const character of trimmedLine) {
+				if (character === "{") braceDepth++;
+				if (character === "}") braceDepth--;
+			}
+			if (braceDepth > 0 && !trimmedLine.includes(" from ")) isInMultiline = true;
+		}
+	}
+	return statements.join("\n");
+};
+const ASTRO_FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---/;
+const extractAstroFrontmatter = (sourceText) => {
+	const frontmatterMatch = sourceText.match(ASTRO_FRONTMATTER_PATTERN);
+	if (!frontmatterMatch) return "";
+	return frontmatterMatch[1];
+};
+const VUE_SCRIPT_PATTERN = /<script[^>]*(?:lang=["'](?:ts|tsx)["'][^>]*)?>([\s\S]*?)<\/script>/gi;
+const extractVueScriptContent = (sourceText) => {
+	const scriptBlocks = [];
+	let scriptMatch;
+	VUE_SCRIPT_PATTERN.lastIndex = 0;
+	while ((scriptMatch = VUE_SCRIPT_PATTERN.exec(sourceText)) !== null) if (scriptMatch[1]) scriptBlocks.push(scriptMatch[1]);
+	return scriptBlocks.join("\n");
+};
+const SVELTE_SCRIPT_PATTERN = /<script[^>]*>([\s\S]*?)<\/script>/gi;
+const extractSvelteScriptContent = (sourceText) => {
+	const scriptBlocks = [];
+	let scriptMatch;
+	SVELTE_SCRIPT_PATTERN.lastIndex = 0;
+	while ((scriptMatch = SVELTE_SCRIPT_PATTERN.exec(sourceText)) !== null) if (scriptMatch[1]) scriptBlocks.push(scriptMatch[1]);
+	return scriptBlocks.join("\n");
+};
+const getModuleExportNameValue = (exportName) => {
+	if (exportName.type === "Identifier") return exportName.name;
+	if (exportName.type === "Literal") return exportName.value;
+	return "default";
+};
+const CSS_EXTENSIONS = [
+	".css",
+	".scss",
+	".less",
+	".sass"
+];
+const CSS_IMPORT_PATTERN = /@import\s+(?:url\()?['"]([^'"]+)['"]\)?/g;
+const SCSS_USE_FORWARD_PATTERN = /@(?:use|forward)\s+['"]([^'"]+)['"]/g;
+const parseCssImports = (filePath) => {
+	const sourceText = readFileSync(filePath, "utf-8");
+	const imports = [];
+	const patterns = [CSS_IMPORT_PATTERN, SCSS_USE_FORWARD_PATTERN];
+	for (const pattern of patterns) {
+		let match;
+		pattern.lastIndex = 0;
+		while ((match = pattern.exec(sourceText)) !== null) {
+			const specifier = match[1];
+			if (specifier && !specifier.startsWith("http")) imports.push({
+				specifier,
+				importedNames: [],
+				isTypeOnly: false,
+				isDynamic: false,
+				isSideEffect: true,
+				line: sourceText.substring(0, match.index).split("\n").length,
+				column: 0
+			});
+		}
+	}
+	return {
+		imports,
+		exports: [],
+		memberAccesses: [],
+		wholeObjectUses: []
+	};
+};
+const NON_JS_EXTENSIONS = [".graphql", ".gql"];
+const parseModule = (filePath) => {
+	if (CSS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) return parseCssImports(filePath);
+	if (NON_JS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) return {
+		imports: [],
+		exports: [],
+		memberAccesses: [],
+		wholeObjectUses: []
+	};
+	const sourceText = readFileSync(filePath, "utf-8");
+	const imports = [];
+	const exports = [];
+	const isMdx = filePath.endsWith(".mdx");
+	const isAstro = filePath.endsWith(".astro");
+	const isVue = filePath.endsWith(".vue");
+	const isSvelte = filePath.endsWith(".svelte");
+	const textToParse = isMdx ? extractMdxImportsExports(sourceText) : isAstro ? extractAstroFrontmatter(sourceText) : isVue ? extractVueScriptContent(sourceText) : isSvelte ? extractSvelteScriptContent(sourceText) : sourceText;
+	const parseFileName = isMdx || isAstro || isVue || isSvelte ? filePath.replace(/\.(mdx|astro|vue|svelte)$/, ".tsx") : filePath;
+	let result = parseSync(parseFileName, textToParse);
+	const isPlainJsFile = parseFileName.endsWith(".js") || parseFileName.endsWith(".mjs") || parseFileName.endsWith(".cjs");
+	if (result.errors.length > 0 && isPlainJsFile && result.errors.some((parseError) => {
+		const errorMessage = String(parseError.message ?? "");
+		return errorMessage.includes("JSX") || errorMessage.includes("Unexpected token");
+	})) result = parseSync(parseFileName.replace(/\.(m?js|cjs)$/, ".jsx"), textToParse);
+	if (result.errors.length > 0) return {
+		imports,
+		exports,
+		memberAccesses: [],
+		wholeObjectUses: []
+	};
+	const program = result.program;
+	if (!program?.body) return {
+		imports,
+		exports,
+		memberAccesses: [],
+		wholeObjectUses: []
+	};
+	for (const node of program.body) switch (node.type) {
+		case "ImportDeclaration":
+			extractImportDeclaration(node, sourceText, imports);
+			break;
+		case "ExportNamedDeclaration":
+			extractNamedExportDeclaration(node, sourceText, exports);
+			break;
+		case "ExportDefaultDeclaration":
+			extractDefaultExportDeclaration(node, sourceText, exports);
+			break;
+		case "ExportAllDeclaration":
+			extractExportAllDeclaration(node, sourceText, exports);
+			break;
+	}
+	collectDynamicImports(program.body, sourceText, imports);
+	const namespaceLocalNames = collectNamespaceLocalNames(imports);
+	const memberAccesses = [];
+	const wholeObjectUses = [];
+	if (namespaceLocalNames.size > 0) collectMemberAccesses(program.body, namespaceLocalNames, memberAccesses, wholeObjectUses);
+	return {
+		imports,
+		exports,
+		memberAccesses,
+		wholeObjectUses
+	};
+};
+const WHOLE_OBJECT_FUNCTION_NAMES = new Set([
+	"keys",
+	"values",
+	"entries",
+	"assign",
+	"freeze",
+	"getOwnPropertyNames",
+	"getOwnPropertyDescriptors"
+]);
+const collectNamespaceLocalNames = (imports) => {
+	const namespaceNames = /* @__PURE__ */ new Set();
+	for (const importInfo of imports) for (const importedName of importInfo.importedNames) if (importedName.isNamespace && importedName.alias) namespaceNames.add(importedName.alias);
+	return namespaceNames;
+};
+const collectMemberAccesses = (bodyNodes, namespaceLocalNames, memberAccesses, wholeObjectUses) => {
+	const walkForMemberAccesses = (node) => {
+		if (node.type === "MemberExpression" && !node.computed) {
+			const memberExpression = node;
+			if (memberExpression.object.type === "Identifier" && namespaceLocalNames.has(memberExpression.object.name)) {
+				const objectName = memberExpression.object.name;
+				const memberName = memberExpression.property.name;
+				if (memberName) memberAccesses.push({
+					objectName,
+					memberName
+				});
+			}
+		}
+		if (node.type === "MemberExpression" && Boolean(node.computed)) {
+			const computedExpression = node;
+			if (computedExpression.object.type === "Identifier" && namespaceLocalNames.has(computedExpression.object.name)) {
+				const objectName = computedExpression.object.name;
+				const expressionNode = node.expression;
+				if (expressionNode?.type === "Literal") {
+					const literalValue = expressionNode.value;
+					if (typeof literalValue === "string") memberAccesses.push({
+						objectName,
+						memberName: literalValue
+					});
+					else wholeObjectUses.push(objectName);
+				} else wholeObjectUses.push(objectName);
+			}
+		}
+		if (node.type === "SpreadElement") {
+			const spreadArgument = node.argument;
+			if (spreadArgument?.type === "Identifier" && namespaceLocalNames.has(spreadArgument.name)) wholeObjectUses.push(spreadArgument.name);
+		}
+		if (node.type === "ForInStatement") {
+			const forInRight = node.right;
+			if (forInRight?.type === "Identifier" && namespaceLocalNames.has(forInRight.name)) wholeObjectUses.push(forInRight.name);
+		}
+		if (node.type === "CallExpression") {
+			const callExpression = node;
+			if (callExpression.callee.type === "MemberExpression" && !callExpression.callee.computed) {
+				const calleeMember = callExpression.callee;
+				if (calleeMember.object.type === "Identifier" && calleeMember.object.name === "Object" && WHOLE_OBJECT_FUNCTION_NAMES.has(calleeMember.property.name)) {
+					const firstArgument = callExpression.arguments[0];
+					if (firstArgument && firstArgument.type !== "SpreadElement" && firstArgument.type === "Identifier" && namespaceLocalNames.has(firstArgument.name)) wholeObjectUses.push(firstArgument.name);
+				}
+			}
+		}
+		for (const value of Object.values(node)) if (Array.isArray(value)) {
+			for (const element of value) if (isWalkableNode(element)) walkForMemberAccesses(element);
+		} else if (isWalkableNode(value)) walkForMemberAccesses(value);
+	};
+	for (const topLevelNode of bodyNodes) if (isWalkableNode(topLevelNode)) walkForMemberAccesses(topLevelNode);
+};
+const extractImportDeclaration = (node, sourceText, imports) => {
+	const specifier = node.source.value;
+	if (!specifier) return;
+	const isTypeOnly = node.importKind === "type";
+	const importedNames = [];
+	for (const specifierNode of node.specifiers) switch (specifierNode.type) {
+		case "ImportDefaultSpecifier":
+			importedNames.push({
+				name: "default",
+				alias: specifierNode.local.name,
+				isNamespace: false,
+				isDefault: true,
+				isTypeOnly
+			});
+			break;
+		case "ImportNamespaceSpecifier":
+			importedNames.push({
+				name: "*",
+				alias: specifierNode.local.name,
+				isNamespace: true,
+				isDefault: false,
+				isTypeOnly
+			});
+			break;
+		case "ImportSpecifier": {
+			const importedName = getModuleExportNameValue(specifierNode.imported);
+			const localName = specifierNode.local.name;
+			importedNames.push({
+				name: importedName,
+				alias: localName !== importedName ? localName : void 0,
+				isNamespace: false,
+				isDefault: importedName === "default",
+				isTypeOnly: isTypeOnly || specifierNode.importKind === "type"
+			});
+			break;
+		}
+	}
+	const isSideEffectImport = importedNames.length === 0;
+	if (isSideEffectImport) importedNames.push({
+		name: "*",
+		alias: void 0,
+		isNamespace: false,
+		isDefault: false,
+		isTypeOnly: false
+	});
+	imports.push({
+		specifier,
+		importedNames,
+		isTypeOnly,
+		isDynamic: false,
+		isSideEffect: isSideEffectImport,
+		line: getLineFromOffset(sourceText, node.start),
+		column: getColumnFromOffset(sourceText, node.start)
+	});
+};
+const extractNamedExportDeclaration = (node, sourceText, exports) => {
+	const isTypeOnly = node.exportKind === "type";
+	const reExportSource = node.source?.value ?? void 0;
+	if (node.declaration) extractDeclarationNames(node.declaration, isTypeOnly, sourceText, exports, node.start);
+	for (const specifierNode of node.specifiers) {
+		const exportedName = getModuleExportNameValue(specifierNode.exported);
+		const localName = getModuleExportNameValue(specifierNode.local);
+		exports.push({
+			name: exportedName,
+			isDefault: exportedName === "default",
+			isTypeOnly: isTypeOnly || specifierNode.exportKind === "type",
+			isReExport: reExportSource !== void 0,
+			isSynthetic: false,
+			reExportSource,
+			reExportOriginalName: reExportSource !== void 0 ? localName : void 0,
+			isNamespaceReExport: false,
+			line: getLineFromOffset(sourceText, specifierNode.start ?? node.start),
+			column: getColumnFromOffset(sourceText, specifierNode.start ?? node.start)
+		});
+	}
+};
+const extractDefaultExportDeclaration = (node, sourceText, exports) => {
+	exports.push({
+		name: "default",
+		isDefault: true,
+		isTypeOnly: false,
+		isReExport: false,
+		isSynthetic: false,
+		reExportSource: void 0,
+		reExportOriginalName: void 0,
+		isNamespaceReExport: false,
+		line: getLineFromOffset(sourceText, node.start),
+		column: getColumnFromOffset(sourceText, node.start)
+	});
+};
+const extractExportAllDeclaration = (node, sourceText, exports) => {
+	const reExportSource = node.source.value;
+	if (!reExportSource) return;
+	const exportedName = node.exported ? getModuleExportNameValue(node.exported) : void 0;
+	exports.push({
+		name: exportedName ?? "*",
+		isDefault: false,
+		isTypeOnly: node.exportKind === "type",
+		isReExport: true,
+		isSynthetic: false,
+		reExportSource,
+		reExportOriginalName: "*",
+		isNamespaceReExport: !exportedName,
+		line: getLineFromOffset(sourceText, node.start),
+		column: getColumnFromOffset(sourceText, node.start)
+	});
+};
+const extractDeclarationNames = (declaration, isTypeOnly, sourceText, exports, fallbackStart) => {
+	const declarationType = declaration.type;
+	if (declarationType === "FunctionDeclaration" || declarationType === "ClassDeclaration" || declarationType === "TSEnumDeclaration") {
+		const declarationName = declaration.id?.name;
+		if (declarationName) exports.push({
+			name: declarationName,
+			isDefault: false,
+			isTypeOnly,
+			isReExport: false,
+			isSynthetic: false,
+			reExportSource: void 0,
+			reExportOriginalName: void 0,
+			isNamespaceReExport: false,
+			line: getLineFromOffset(sourceText, declaration.start ?? fallbackStart),
+			column: getColumnFromOffset(sourceText, declaration.start ?? fallbackStart)
+		});
+		return;
+	}
+	if (declarationType === "TSTypeAliasDeclaration" || declarationType === "TSInterfaceDeclaration") {
+		const declarationName = declaration.id.name;
+		if (declarationName) exports.push({
+			name: declarationName,
+			isDefault: false,
+			isTypeOnly: true,
+			isReExport: false,
+			isSynthetic: false,
+			reExportSource: void 0,
+			reExportOriginalName: void 0,
+			isNamespaceReExport: false,
+			line: getLineFromOffset(sourceText, declaration.start ?? fallbackStart),
+			column: getColumnFromOffset(sourceText, declaration.start ?? fallbackStart)
+		});
+		return;
+	}
+	if (declarationType === "VariableDeclaration") {
+		const variableDeclaration = declaration;
+		for (const declarator of variableDeclaration.declarations) {
+			const bindingNames = extractBindingPatternNames(declarator.id);
+			for (const bindingName of bindingNames) exports.push({
+				name: bindingName,
+				isDefault: false,
+				isTypeOnly,
+				isReExport: false,
+				isSynthetic: false,
+				reExportSource: void 0,
+				reExportOriginalName: void 0,
+				isNamespaceReExport: false,
+				line: getLineFromOffset(sourceText, declarator.start ?? fallbackStart),
+				column: getColumnFromOffset(sourceText, declarator.start ?? fallbackStart)
+			});
+		}
+	}
+};
+const extractBindingPatternNames = (pattern) => {
+	if (!pattern) return [];
+	if (pattern.type === "Identifier") return pattern.name ? [pattern.name] : [];
+	if (pattern.type === "ObjectPattern") {
+		const names = [];
+		for (const property of pattern.properties) if (property.type === "RestElement") names.push(...extractBindingPatternNames(property.argument));
+		else names.push(...extractBindingPatternNames(property.value));
+		return names;
+	}
+	if (pattern.type === "ArrayPattern") {
+		const names = [];
+		for (const element of pattern.elements) {
+			if (!element) continue;
+			if (element.type === "RestElement") names.push(...extractBindingPatternNames(element.argument));
+			else names.push(...extractBindingPatternNames(element));
+		}
+		return names;
+	}
+	if (pattern.type === "AssignmentPattern") return extractBindingPatternNames(pattern.left);
+	return [];
+};
+const createNamespaceImportedName = () => ({
+	name: "*",
+	alias: void 0,
+	isNamespace: true,
+	isDefault: false,
+	isTypeOnly: false
+});
+const isWalkableNode = (value) => Boolean(value) && typeof value === "object" && typeof value.type === "string";
+const extractStringLiteralFromArgument = (callArguments) => {
+	const firstArgument = callArguments[0];
+	if (!firstArgument) return void 0;
+	if (firstArgument.type === "SpreadElement") return void 0;
+	if (firstArgument.type !== "Literal") return void 0;
+	const literalValue = firstArgument.value;
+	return typeof literalValue === "string" ? literalValue : void 0;
+};
+const extractGlobPatterns = (callArguments) => {
+	const firstArgument = callArguments[0];
+	if (!firstArgument || firstArgument.type === "SpreadElement") return [];
+	if (firstArgument.type === "Literal") {
+		const literalValue = firstArgument.value;
+		if (typeof literalValue === "string" && (literalValue.startsWith("./") || literalValue.startsWith("../"))) return [literalValue];
+		return [];
+	}
+	if (firstArgument.type === "ArrayExpression") return firstArgument.elements.filter((element) => element.type === "Literal" && typeof element.value === "string" && (element.value.startsWith("./") || element.value.startsWith("../"))).map((element) => element.value);
+	return [];
+};
+const extractRegexGlobSuffix = (callArguments) => {
+	const thirdArgument = callArguments[2];
+	if (!thirdArgument || thirdArgument.type === "SpreadElement") return void 0;
+	if (thirdArgument.type !== "Literal") return void 0;
+	const regExpValue = thirdArgument.regex;
+	if (!regExpValue) return void 0;
+	const extensionMatch = regExpValue.pattern.match(/^\\\.([\w|]+)\$$/);
+	if (extensionMatch) {
+		const extensions = extensionMatch[1].split("|");
+		if (extensions.length === 1) return `*.${extensions[0]}`;
+		return `*.{${extensions.join(",")}}`;
+	}
+};
+const hasMockFactoryArgument = (callExpression) => {
+	const secondArgument = callExpression.arguments[1];
+	if (!secondArgument) return false;
+	if (secondArgument.type === "SpreadElement") return false;
+	return secondArgument.type === "ArrowFunctionExpression" || secondArgument.type === "FunctionExpression";
+};
+const synthesizeAutoMockSibling = (mockSource) => {
+	if (!mockSource || mockSource.includes("://") || mockSource.startsWith("data:") || mockSource.split("/").some((segment) => segment === "__mocks__")) return;
+	const lastSlashIndex = mockSource.lastIndexOf("/");
+	if (lastSlashIndex === -1) return void 0;
+	const directory = mockSource.slice(0, lastSlashIndex);
+	const fileName = mockSource.slice(lastSlashIndex + 1);
+	if (!fileName) return void 0;
+	return `${directory}/__mocks__/${fileName}`;
+};
+const collectDynamicImports = (bodyNodes, sourceText, imports) => {
+	const walkNode = (node) => {
+		if (node.type === "ImportExpression") {
+			const importExpression = node;
+			const sourceExpression = importExpression.source;
+			if (sourceExpression.type === "Literal") {
+				const specifierValue = sourceExpression.value;
+				if (specifierValue) imports.push({
+					specifier: specifierValue,
+					importedNames: [createNamespaceImportedName()],
+					isTypeOnly: false,
+					isDynamic: true,
+					isSideEffect: false,
+					line: getLineFromOffset(sourceText, importExpression.start),
+					column: getColumnFromOffset(sourceText, importExpression.start)
+				});
+			} else if (sourceExpression.type === "TemplateLiteral") {
+				const templateLiteral = sourceExpression;
+				if (templateLiteral.quasis.length >= 2) {
+					const globPattern = templateLiteral.quasis.map((quasi) => quasi.value.cooked).join("*");
+					if (globPattern.startsWith("./") || globPattern.startsWith("../")) imports.push({
+						specifier: globPattern,
+						importedNames: [createNamespaceImportedName()],
+						isTypeOnly: false,
+						isDynamic: true,
+						isSideEffect: false,
+						isGlob: true,
+						line: getLineFromOffset(sourceText, importExpression.start),
+						column: getColumnFromOffset(sourceText, importExpression.start)
+					});
+				}
+			}
+			return;
+		}
+		if (node.type === "CallExpression") {
+			const callExpression = node;
+			if (callExpression.callee.type === "Identifier" && callExpression.callee.name === "require") {
+				const requireSpecifier = extractStringLiteralFromArgument(callExpression.arguments);
+				if (requireSpecifier) imports.push({
+					specifier: requireSpecifier,
+					importedNames: [createNamespaceImportedName()],
+					isTypeOnly: false,
+					isDynamic: true,
+					isSideEffect: false,
+					line: getLineFromOffset(sourceText, callExpression.start),
+					column: getColumnFromOffset(sourceText, callExpression.start)
+				});
+			}
+			if (callExpression.callee.type === "MemberExpression" && !callExpression.callee.computed) {
+				const memberExpression = callExpression.callee;
+				if (memberExpression.object.type === "Identifier" && memberExpression.object.name === "require" && memberExpression.property.name === "resolve") {
+					const resolveSpecifier = extractStringLiteralFromArgument(callExpression.arguments);
+					if (resolveSpecifier) imports.push({
+						specifier: resolveSpecifier,
+						importedNames: [createNamespaceImportedName()],
+						isTypeOnly: false,
+						isDynamic: true,
+						isSideEffect: false,
+						line: getLineFromOffset(sourceText, callExpression.start),
+						column: getColumnFromOffset(sourceText, callExpression.start)
+					});
+				}
+				if (memberExpression.object.type === "Identifier" && (memberExpression.object.name === "vi" || memberExpression.object.name === "jest") && memberExpression.property.name === "mock") {
+					const mockSpecifier = extractStringLiteralFromArgument(callExpression.arguments);
+					if (mockSpecifier) {
+						imports.push({
+							specifier: mockSpecifier,
+							importedNames: [createNamespaceImportedName()],
+							isTypeOnly: false,
+							isDynamic: true,
+							isSideEffect: true,
+							line: getLineFromOffset(sourceText, callExpression.start),
+							column: getColumnFromOffset(sourceText, callExpression.start)
+						});
+						const hasFactoryArgument = hasMockFactoryArgument(callExpression);
+						const autoMockSibling = synthesizeAutoMockSibling(mockSpecifier);
+						if (!hasFactoryArgument && autoMockSibling) imports.push({
+							specifier: autoMockSibling,
+							importedNames: [createNamespaceImportedName()],
+							isTypeOnly: false,
+							isDynamic: true,
+							isSideEffect: true,
+							line: getLineFromOffset(sourceText, callExpression.start),
+							column: getColumnFromOffset(sourceText, callExpression.start)
+						});
+					}
+				}
+				if (memberExpression.object.type === "MetaProperty" && memberExpression.property.name === "glob") {
+					const globPatterns = extractGlobPatterns(callExpression.arguments);
+					for (const globPattern of globPatterns) imports.push({
+						specifier: globPattern,
+						importedNames: [createNamespaceImportedName()],
+						isTypeOnly: false,
+						isDynamic: true,
+						isSideEffect: false,
+						isGlob: true,
+						line: getLineFromOffset(sourceText, callExpression.start),
+						column: getColumnFromOffset(sourceText, callExpression.start)
+					});
+				}
+				if (memberExpression.object.type === "Identifier" && memberExpression.object.name === "require" && memberExpression.property.name === "context") {
+					const directoryArgument = extractStringLiteralFromArgument(callExpression.arguments);
+					if (directoryArgument && (directoryArgument.startsWith("./") || directoryArgument.startsWith("../"))) {
+						const hasRegexArgument = callExpression.arguments.length >= 3 && callExpression.arguments[2].type !== "SpreadElement";
+						const regexSuffix = extractRegexGlobSuffix(callExpression.arguments);
+						if (!hasRegexArgument || Boolean(regexSuffix)) {
+							const contextGlobPrefix = callExpression.arguments[1]?.type === "Literal" && callExpression.arguments[1].value === true ? `${directoryArgument}/**/` : `${directoryArgument}/`;
+							const contextGlobPattern = regexSuffix ? `${contextGlobPrefix}${regexSuffix}` : `${contextGlobPrefix}*`;
+							imports.push({
+								specifier: contextGlobPattern,
+								importedNames: [createNamespaceImportedName()],
+								isTypeOnly: false,
+								isDynamic: true,
+								isSideEffect: false,
+								isGlob: true,
+								line: getLineFromOffset(sourceText, callExpression.start),
+								column: getColumnFromOffset(sourceText, callExpression.start)
+							});
+						}
+					}
+				}
+			}
+		}
+		if (node.type === "NewExpression") {
+			const newExpression = node;
+			if (newExpression.callee.type === "Identifier" && newExpression.callee.name === "URL" && newExpression.arguments.length >= 2) {
+				const secondArgument = newExpression.arguments[1];
+				if (secondArgument.type === "MemberExpression" && secondArgument.object.type === "MetaProperty" && secondArgument.property.name === "url") {
+					const urlSpecifier = extractStringLiteralFromArgument(newExpression.arguments);
+					if (urlSpecifier) imports.push({
+						specifier: urlSpecifier,
+						importedNames: [createNamespaceImportedName()],
+						isTypeOnly: false,
+						isDynamic: true,
+						isSideEffect: true,
+						line: getLineFromOffset(sourceText, newExpression.start),
+						column: getColumnFromOffset(sourceText, newExpression.start)
+					});
+				}
+			}
+		}
+		if (node.type === "Decorator") {
+			const expression = node.expression;
+			if (expression?.type === "CallExpression") {
+				const callNode = expression;
+				const callee = callNode.callee;
+				if (callee.type === "Identifier" && callee.name === "Component") {
+					const objectArgument = callNode.arguments[0];
+					if (objectArgument?.type === "ObjectExpression") {
+						const objectProperties = objectArgument.properties;
+						for (const property of objectProperties) {
+							if (property.type !== "ObjectProperty" && property.type !== "Property") continue;
+							const propertyKey = property.key;
+							const propertyName = propertyKey?.name ?? propertyKey?.value;
+							const propertyValue = property.value;
+							if (propertyName === "templateUrl" && propertyValue?.type === "Literal") {
+								const templatePath = propertyValue.value;
+								if (templatePath) imports.push({
+									specifier: templatePath.startsWith(".") ? templatePath : `./${templatePath}`,
+									importedNames: [],
+									isTypeOnly: false,
+									isDynamic: false,
+									isSideEffect: true,
+									line: getLineFromOffset(sourceText, property.start),
+									column: getColumnFromOffset(sourceText, property.start)
+								});
+							}
+							if ((propertyName === "styleUrl" || propertyName === "styleUrls") && propertyValue) {
+								const styleUrlValues = [];
+								if (propertyValue.type === "Literal") {
+									const singleValue = propertyValue.value;
+									if (singleValue) styleUrlValues.push(singleValue);
+								} else if (propertyValue.type === "ArrayExpression") {
+									const arrayElements = propertyValue.elements;
+									for (const element of arrayElements) if (element?.type === "Literal") {
+										const elementValue = element.value;
+										if (elementValue) styleUrlValues.push(elementValue);
+									}
+								}
+								for (const styleUrl of styleUrlValues) imports.push({
+									specifier: styleUrl.startsWith(".") ? styleUrl : `./${styleUrl}`,
+									importedNames: [],
+									isTypeOnly: false,
+									isDynamic: false,
+									isSideEffect: true,
+									line: getLineFromOffset(sourceText, property.start),
+									column: getColumnFromOffset(sourceText, property.start)
+								});
+							}
+						}
+					}
+				}
+			}
+		}
+		for (const value of Object.values(node)) if (Array.isArray(value)) {
+			for (const element of value) if (isWalkableNode(element)) walkNode(element);
+		} else if (isWalkableNode(value)) walkNode(value);
+	};
+	for (const topLevelNode of bodyNodes) if (isWalkableNode(topLevelNode)) walkNode(topLevelNode);
+};
+const ROUTE_CALL_FILE_ARG_INDEX = {
+	route: 1,
+	layout: 0,
+	index: 0
+};
+const extractStringFromExpression = (expression) => {
+	if (expression.type === "Literal") {
+		const literalValue = expression.value;
+		return typeof literalValue === "string" ? literalValue : void 0;
+	}
+	if (expression.type === "TemplateLiteral") {
+		const templateLiteral = expression;
+		if (templateLiteral.expressions.length === 0 && templateLiteral.quasis.length === 1) return templateLiteral.quasis[0]?.value.cooked;
+	}
+};
+const extractReactRouterRouteModuleEntries = (routesFilePath) => {
+	const result = parseSync(routesFilePath, readFileSync(routesFilePath, "utf-8"));
+	if (result.errors.length > 0 || !result.program?.body) return [];
+	const modulePaths = [];
+	const walkForRouteCalls = (node) => {
+		if (node.type === "CallExpression") {
+			const callExpression = node;
+			const callee = callExpression.callee;
+			if (callee.type === "Identifier") {
+				const fileArgumentIndex = ROUTE_CALL_FILE_ARG_INDEX[callee.name];
+				if (fileArgumentIndex !== void 0) {
+					const fileArgument = callExpression.arguments[fileArgumentIndex];
+					if (fileArgument && fileArgument.type !== "SpreadElement") {
+						const filePath = extractStringFromExpression(fileArgument);
+						if (filePath) modulePaths.push(filePath);
+					}
+				}
+			}
+		}
+		for (const value of Object.values(node)) if (Array.isArray(value)) {
+			for (const element of value) if (isWalkableNode(element)) walkForRouteCalls(element);
+		} else if (isWalkableNode(value)) walkForRouteCalls(value);
+	};
+	for (const topLevelNode of result.program.body) if (isWalkableNode(topLevelNode)) walkForRouteCalls(topLevelNode);
+	return modulePaths;
+};
+
+//#endregion
+//#region src/scanner/workspaces.ts
+const discoverWorkspacePackagesWithExclusions = (rootDir) => {
+	const rootPatterns = collectWorkspacePatterns(rootDir);
+	const hasRootLevelWorkspacePatterns = rootPatterns.length > 0;
+	let expandedDirectories = hasRootLevelWorkspacePatterns ? expandWorkspaceGlobs(rootPatterns, rootDir) : [];
+	const implicitSubProjects = discoverImplicitSubProjects(rootDir, expandedDirectories);
+	if (expandedDirectories.length === 0 && implicitSubProjects.length > 0) for (const subProjectDirectory of implicitSubProjects) {
+		const subPatterns = collectWorkspacePatterns(subProjectDirectory);
+		if (subPatterns.length > 0) {
+			const subExpanded = expandWorkspaceGlobs(subPatterns, subProjectDirectory);
+			expandedDirectories.push(subProjectDirectory, ...subExpanded);
+		}
+	}
+	const declaredDirectorySet = new Set(expandedDirectories);
+	const excludedDirectories = [];
+	const filteredImplicitSubProjects = implicitSubProjects;
+	const allDirectories = [...new Set([...expandedDirectories, ...filteredImplicitSubProjects])];
+	const workspacePackages = [];
+	for (const directory of allDirectories) {
+		const packageJsonPath = join(directory, "package.json");
+		if (!existsSync(packageJsonPath)) continue;
+		try {
+			const packageContent = readFileSync(packageJsonPath, "utf-8");
+			const packageJson = JSON.parse(packageContent);
+			const packageName = packageJson.name || relative(rootDir, directory);
+			const entryFiles = extractWorkspaceEntries(packageJson, directory);
+			const depthFromRoot = relative(rootDir, directory).split("/").filter(Boolean).length;
+			workspacePackages.push({
+				name: packageName,
+				directory,
+				entryFiles,
+				isDeclaredWorkspace: declaredDirectorySet.has(directory),
+				depthFromRoot
+			});
+		} catch {}
+	}
+	return {
+		packages: workspacePackages,
+		excludedDirectories,
+		hasRootLevelWorkspacePatterns
+	};
+};
+const IMPLICIT_SUB_PROJECT_SEARCH_DEPTH = 3;
+const STANDALONE_PROJECT_LOCKFILES = [
+	"package-lock.json",
+	"yarn.lock",
+	"pnpm-lock.yaml",
+	"bun.lockb"
+];
+const isStandaloneProject = (directory) => STANDALONE_PROJECT_LOCKFILES.some((lockfile) => existsSync(join(directory, lockfile)));
+const discoverImplicitSubProjects = (rootDir, alreadyDiscoveredDirectories) => {
+	const knownDirectories = new Set(alreadyDiscoveredDirectories);
+	const hasDeclaredWorkspaces = alreadyDiscoveredDirectories.length > 0;
+	const subProjectDirectories = [];
+	const subPackageJsonPaths = fg.sync("**/package.json", {
+		cwd: rootDir,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**",
+			"**/.git/**"
+		],
+		deep: IMPLICIT_SUB_PROJECT_SEARCH_DEPTH + 1
+	});
+	for (const packageJsonPath of subPackageJsonPaths) {
+		const directory = packageJsonPath.replace(/\/package\.json$/, "");
+		if (directory === rootDir) continue;
+		if (knownDirectories.has(directory)) continue;
+		if (hasDeclaredWorkspaces && isStandaloneProject(directory)) continue;
+		subProjectDirectories.push(directory);
+	}
+	return subProjectDirectories;
+};
+const collectWorkspacePatterns = (rootDir) => {
+	const patterns = [];
+	const packageJsonPath = join(rootDir, "package.json");
+	if (existsSync(packageJsonPath)) try {
+		const content = readFileSync(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(content);
+		if (Array.isArray(packageJson.workspaces)) patterns.push(...packageJson.workspaces);
+		else if (packageJson.workspaces?.packages) patterns.push(...packageJson.workspaces.packages);
+	} catch {}
+	const pnpmWorkspacePath = join(rootDir, "pnpm-workspace.yaml");
+	if (existsSync(pnpmWorkspacePath)) try {
+		const packageLines = extractPnpmWorkspacePackages(readFileSync(pnpmWorkspacePath, "utf-8"));
+		patterns.push(...packageLines);
+	} catch {}
+	return patterns;
+};
+const extractPnpmWorkspacePackages = (yamlContent) => {
+	const packages = [];
+	let inPackagesSection = false;
+	for (const line of yamlContent.split("\n")) {
+		const trimmedLine = line.trim();
+		if (trimmedLine === "packages:") {
+			inPackagesSection = true;
+			continue;
+		}
+		if (inPackagesSection) {
+			if (trimmedLine.startsWith("- ")) {
+				const pattern = trimmedLine.slice(2).trim().replace(/^["']|["']$/g, "");
+				if (pattern && !pattern.startsWith("!")) packages.push(pattern);
+			} else if (trimmedLine && !trimmedLine.startsWith("#")) break;
+		}
+	}
+	return packages;
+};
+const expandWorkspaceGlobs = (patterns, rootDir) => {
+	const directories = [];
+	for (const pattern of patterns) if (pattern.includes("*")) {
+		const globPattern = pattern.endsWith("/") ? `${pattern}package.json` : `${pattern}/package.json`;
+		try {
+			const matchedFiles = fg.sync(globPattern, {
+				cwd: rootDir,
+				absolute: true,
+				onlyFiles: true
+			});
+			for (const matchedPath of matchedFiles) directories.push(matchedPath.replace(/\/package\.json$/, ""));
+		} catch {}
+	} else {
+		const absoluteDirectory = resolve(rootDir, pattern);
+		if (existsSync(join(absoluteDirectory, "package.json"))) directories.push(absoluteDirectory);
+	}
+	return [...new Set(directories)];
+};
+const SOURCE_EXTENSIONS$2 = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mts",
+	".mjs",
+	".cts",
+	".cjs"
+];
+const OUTPUT_DIR_PREFIXES$1 = [
+	"dist/",
+	"build/",
+	"lib/",
+	"lib-dist/",
+	"esm/",
+	"cjs/",
+	"out/",
+	"./dist/",
+	"./lib-dist/"
+];
+const SOURCE_INDEX_FALLBACK_STEMS$1 = [
+	"src/index",
+	"src/main",
+	"index",
+	"main"
+];
+const resolveSourcePath$1 = (distPath, directory) => {
+	const relativeToDist = relative(directory, distPath);
+	if (OUTPUT_DIR_PREFIXES$1.some((prefix) => relativeToDist.startsWith(prefix))) {
+		const sourceVariants = OUTPUT_DIR_PREFIXES$1.map((prefix) => relativeToDist.replace(new RegExp(`^${prefix.replace(".", "\\.")}`), "src/")).filter((variant) => variant !== relativeToDist);
+		for (const variant of sourceVariants) {
+			const withoutExtension = variant.replace(/\.[^.]+$/, "");
+			for (const sourceExtension of SOURCE_EXTENSIONS$2) {
+				const sourceCandidate = resolve(directory, withoutExtension + sourceExtension);
+				if (existsSync(sourceCandidate)) return [sourceCandidate];
+			}
+		}
+		for (const stem of SOURCE_INDEX_FALLBACK_STEMS$1) for (const sourceExtension of SOURCE_EXTENSIONS$2) {
+			const fallbackCandidate = resolve(directory, stem + sourceExtension);
+			if (existsSync(fallbackCandidate)) return [fallbackCandidate];
+		}
+		return [];
+	}
+	const resolvedDistPath = resolve(directory, relativeToDist);
+	const candidates = [];
+	const withoutJsExtension = relativeToDist.replace(/\.[cm]?js$/, "");
+	if (withoutJsExtension !== relativeToDist) {
+		for (const sourceExtension of SOURCE_EXTENSIONS$2) {
+			const directSourceCandidate = resolve(directory, withoutJsExtension + sourceExtension);
+			if (existsSync(directSourceCandidate)) candidates.push(directSourceCandidate);
+		}
+		const indexCandidate = resolve(directory, withoutJsExtension, "index.ts");
+		if (existsSync(indexCandidate) && !candidates.includes(indexCandidate)) candidates.push(indexCandidate);
+	}
+	const withoutTsExtension = relativeToDist.replace(/\.ts$/, "");
+	if (withoutTsExtension !== relativeToDist && !existsSync(resolvedDistPath)) {
+		const tsxCandidate = resolve(directory, withoutTsExtension + ".tsx");
+		if (existsSync(tsxCandidate) && !candidates.includes(tsxCandidate)) candidates.push(tsxCandidate);
+	}
+	if (candidates.length === 0 && existsSync(resolvedDistPath)) candidates.push(resolvedDistPath);
+	return candidates;
+};
+const extractWorkspaceEntries = (packageJson, directory) => {
+	const entries = [];
+	const addWithSourceResolution = (filePath) => {
+		const resolved = resolve(directory, filePath);
+		const sourceVariants = resolveSourcePath$1(resolved, directory);
+		if (sourceVariants.length > 0) entries.push(...sourceVariants);
+		else entries.push(resolved);
+	};
+	for (const field of [
+		"main",
+		"module",
+		"browser",
+		"types",
+		"typings",
+		"source"
+	]) {
+		const fieldValue = packageJson[field];
+		if (typeof fieldValue === "string") addWithSourceResolution(fieldValue);
+	}
+	if (packageJson.exports) {
+		const exportPaths = [];
+		collectExportPaths$1(packageJson.exports, directory, exportPaths);
+		for (const exportPath of exportPaths) {
+			const sourceVariants = resolveSourcePath$1(exportPath, directory);
+			if (sourceVariants.length > 0) entries.push(...sourceVariants);
+			else entries.push(exportPath);
+		}
+	}
+	if (packageJson.bin) {
+		if (typeof packageJson.bin === "string") addWithSourceResolution(packageJson.bin);
+		else if (typeof packageJson.bin === "object" && packageJson.bin !== null) {
+			for (const binPath of Object.values(packageJson.bin)) if (typeof binPath === "string") addWithSourceResolution(binPath);
+		}
+	}
+	return [...new Set(entries)];
+};
+const collectExportPaths$1 = (exportValue, rootDir, entries) => {
+	if (typeof exportValue === "string") {
+		if (exportValue.startsWith(".")) if (exportValue.includes("*")) {
+			const globPattern = exportValue.replace(/^\.\/?/, "");
+			try {
+				const expandedFiles = fg.sync(globPattern, {
+					cwd: rootDir,
+					absolute: true,
+					onlyFiles: true,
+					ignore: ["**/node_modules/**"]
+				});
+				entries.push(...expandedFiles);
+			} catch {}
+		} else entries.push(resolve(rootDir, exportValue));
+		return;
+	}
+	if (typeof exportValue !== "object" || exportValue === null) return;
+	for (const nestedValue of Object.values(exportValue)) collectExportPaths$1(nestedValue, rootDir, entries);
+};
+const NEXTJS_APP_ROUTER_CONVENTIONS = [
+	"page",
+	"layout",
+	"loading",
+	"error",
+	"not-found",
+	"template",
+	"default",
+	"route",
+	"global-error",
+	"forbidden",
+	"unauthorized",
+	"middleware",
+	"instrumentation",
+	"manifest",
+	"robots",
+	"sitemap",
+	"opengraph-image",
+	"twitter-image",
+	"icon",
+	"apple-icon",
+	"actions"
+];
+const FRAMEWORK_FILE_GLOB = "**/*.{ts,tsx,js,jsx,mjs,cjs}";
+const FRAMEWORK_FILE_GLOB_WITH_MDX = "**/*.{ts,tsx,js,jsx,mdx,md,mjs,cjs}";
+const NEXTJS_ENABLERS = ["next"];
+const REACT_ROUTER_ENABLERS = ["@react-router/dev"];
+const REMIX_ENABLERS = [
+	"@remix-run/node",
+	"@remix-run/react",
+	"@remix-run/cloudflare",
+	"@remix-run/cloudflare-pages",
+	"@remix-run/deno"
+];
+const NUXT_ENABLERS = ["nuxt"];
+const SVELTEKIT_ENABLERS = ["@sveltejs/kit"];
+const ASTRO_ENABLERS = ["astro"];
+const GATSBY_ENABLERS = ["gatsby"];
+const readDependencies = (directory) => {
+	const packageJsonPath = join(directory, "package.json");
+	if (!existsSync(packageJsonPath)) return {};
+	try {
+		const content = readFileSync(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(content);
+		return {
+			...packageJson.dependencies,
+			...packageJson.devDependencies,
+			...packageJson.optionalDependencies
+		};
+	} catch {
+		return {};
+	}
+};
+const hasAnyEnabler = (dependencies, enablers) => enablers.some((enabler) => enabler in dependencies);
+const extractReactRouterAppDirectory = (directory) => {
+	for (const configFile of [
+		"react-router.config.ts",
+		"react-router.config.js",
+		"react-router.config.mjs",
+		"react-router.config.cjs"
+	]) {
+		const configPath = join(directory, configFile);
+		if (!existsSync(configPath)) continue;
+		try {
+			const appDirectoryMatch = readFileSync(configPath, "utf-8").match(/appDirectory\s*:\s*['"`]([^'"`]+)['"`]/);
+			if (appDirectoryMatch) return appDirectoryMatch[1].replace(/^\.\//, "");
+		} catch {}
+	}
+	return "app";
+};
+const ROUTE_FILE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx"
+];
+const resolveRouteModulePath = (modulePath, routesFileDirectory) => {
+	const normalizedPath = modulePath.startsWith("./") ? modulePath.slice(2) : modulePath;
+	if (ROUTE_FILE_EXTENSIONS.some((extension) => normalizedPath.endsWith(extension))) {
+		const absolutePath = resolve(routesFileDirectory, normalizedPath);
+		if (existsSync(absolutePath)) return absolutePath;
+		return;
+	}
+	for (const extension of ROUTE_FILE_EXTENSIONS) {
+		const absolutePath = resolve(routesFileDirectory, normalizedPath + extension);
+		if (existsSync(absolutePath)) return absolutePath;
+	}
+	for (const extension of ROUTE_FILE_EXTENSIONS) {
+		const absolutePath = resolve(routesFileDirectory, normalizedPath, `index${extension}`);
+		if (existsSync(absolutePath)) return absolutePath;
+	}
+};
+const extractRouteModuleEntriesFromRoutesFiles = (rootDir, appDirectory) => {
+	const routesFileCandidates = fg.sync([
+		`${appDirectory}/routes.{ts,js,mts,mjs}`,
+		`${appDirectory}/routes/**/*.{ts,js,mts,mjs}`,
+		`src/routes.{ts,js,mts,mjs}`
+	], {
+		cwd: rootDir,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"]
+	});
+	const resolvedEntries = [];
+	for (const routesFilePath of routesFileCandidates) {
+		const routesFileDirectory = dirname(routesFilePath);
+		const modulePaths = extractReactRouterRouteModuleEntries(routesFilePath);
+		for (const modulePath of modulePaths) {
+			const resolvedPath = resolveRouteModulePath(modulePath, routesFileDirectory);
+			if (resolvedPath) resolvedEntries.push(resolvedPath);
+		}
+	}
+	return resolvedEntries;
+};
+const discoverFrameworkEntryPoints = (rootDir) => {
+	const entryPoints = [];
+	const dependencies = readDependencies(rootDir);
+	const isNextjs = hasAnyEnabler(dependencies, NEXTJS_ENABLERS);
+	const isReactRouter = hasAnyEnabler(dependencies, REACT_ROUTER_ENABLERS);
+	const isRemix = hasAnyEnabler(dependencies, REMIX_ENABLERS);
+	const isNuxt = hasAnyEnabler(dependencies, NUXT_ENABLERS);
+	const isSvelteKit = hasAnyEnabler(dependencies, SVELTEKIT_ENABLERS);
+	const isAstro = hasAnyEnabler(dependencies, ASTRO_ENABLERS);
+	const isGatsby = hasAnyEnabler(dependencies, GATSBY_ENABLERS);
+	if (isNextjs) {
+		const appRouterConventionGlob = NEXTJS_APP_ROUTER_CONVENTIONS.map((convention) => `**/${convention}.{ts,tsx,js,jsx,mdx}`).join(",");
+		const appDirs = [join(rootDir, "app"), join(rootDir, "src", "app")];
+		for (const appDir of appDirs) if (existsSync(appDir) && statSync(appDir).isDirectory()) entryPoints.push(...fg.sync(`{${appRouterConventionGlob}}`, {
+			cwd: appDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		}));
+		const pagesDirs = [join(rootDir, "pages"), join(rootDir, "src", "pages")];
+		for (const pagesDir of pagesDirs) if (existsSync(pagesDir) && statSync(pagesDir).isDirectory()) entryPoints.push(...fg.sync(FRAMEWORK_FILE_GLOB, {
+			cwd: pagesDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		}));
+		entryPoints.push(...fg.sync([
+			"middleware.{ts,js}",
+			"src/middleware.{ts,js}",
+			"instrumentation.{ts,js}",
+			"instrumentation-client.{ts,js}",
+			"src/instrumentation.{ts,js}",
+			"src/instrumentation-client.{ts,js}",
+			"mdx-components.{ts,tsx,js,jsx}",
+			"src/mdx-components.{ts,tsx,js,jsx}"
+		], {
+			cwd: rootDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		}));
+	}
+	if (isReactRouter || isRemix) {
+		const reactRouterAppDirectory = extractReactRouterAppDirectory(rootDir);
+		entryPoints.push(...fg.sync([
+			`${reactRouterAppDirectory}/routes/**/*.{ts,tsx,js,jsx}`,
+			`${reactRouterAppDirectory}/root.{ts,tsx,js,jsx}`,
+			`${reactRouterAppDirectory}/entry.client.{ts,tsx,js,jsx}`,
+			`${reactRouterAppDirectory}/entry.server.{ts,tsx,js,jsx}`,
+			`${reactRouterAppDirectory}/routes.{ts,js,mts,mjs}`
+		], {
+			cwd: rootDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		}));
+		const routeModuleEntries = extractRouteModuleEntriesFromRoutesFiles(rootDir, reactRouterAppDirectory);
+		entryPoints.push(...routeModuleEntries);
+	}
+	if (isNuxt) for (const nuxtDir of [
+		"pages",
+		"layouts",
+		"middleware",
+		"server",
+		"composables",
+		"plugins"
+	]) {
+		const dirPath = join(rootDir, nuxtDir);
+		if (existsSync(dirPath) && statSync(dirPath).isDirectory()) entryPoints.push(...fg.sync("**/*.{ts,tsx,js,jsx,vue}", {
+			cwd: dirPath,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		}));
+	}
+	if (isSvelteKit) {
+		const svelteDirs = [
+			join(rootDir, "src", "routes"),
+			join(rootDir, "src", "lib"),
+			join(rootDir, "src", "params")
+		];
+		for (const svelteDir of svelteDirs) if (existsSync(svelteDir) && statSync(svelteDir).isDirectory()) entryPoints.push(...fg.sync("**/*.{ts,tsx,js,jsx,svelte}", {
+			cwd: svelteDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		}));
+	}
+	if (isAstro) {
+		const astroDirs = [
+			join(rootDir, "src", "pages"),
+			join(rootDir, "src", "layouts"),
+			join(rootDir, "src", "content")
+		];
+		for (const astroDir of astroDirs) if (existsSync(astroDir) && statSync(astroDir).isDirectory()) entryPoints.push(...fg.sync(FRAMEWORK_FILE_GLOB_WITH_MDX, {
+			cwd: astroDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		}));
+	}
+	if (isGatsby) {
+		const gatsbyDirs = [join(rootDir, "src", "pages"), join(rootDir, "src", "templates")];
+		for (const gatsbyDir of gatsbyDirs) if (existsSync(gatsbyDir) && statSync(gatsbyDir).isDirectory()) entryPoints.push(...fg.sync(FRAMEWORK_FILE_GLOB, {
+			cwd: gatsbyDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		}));
+	}
+	entryPoints.push(...fg.sync([
+		"**/*.stories.{ts,tsx,js,jsx,mts,mjs}",
+		"**/*.story.{ts,tsx,js,jsx,mts,mjs}",
+		".storybook/**/*.{ts,tsx,js,jsx,mts,mjs}"
+	], {
+		cwd: rootDir,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"],
+		dot: true
+	}));
+	entryPoints.push(...fg.sync([
+		"env.{ts,js,mjs}",
+		"src/env.{ts,js,mjs}",
+		"src/routeTree.gen.{ts,tsx}",
+		"src/router.{ts,tsx}"
+	], {
+		cwd: rootDir,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"],
+		dot: true
+	}));
+	for (const entryDir of ["e2e", "cypress"]) {
+		const dirPath = join(rootDir, entryDir);
+		if (existsSync(dirPath) && statSync(dirPath).isDirectory()) entryPoints.push(...fg.sync(FRAMEWORK_FILE_GLOB, {
+			cwd: dirPath,
+			absolute: true,
+			onlyFiles: true,
+			dot: entryDir.startsWith(".")
+		}));
+	}
+	entryPoints.push(...discoverElectronEntryPoints(rootDir));
+	entryPoints.push(...discoverMobileEntryPoints(rootDir));
+	return [...new Set(entryPoints)];
+};
+const ELECTRON_ENABLERS = [
+	"electron",
+	"electron-builder",
+	"@electron-forge/cli",
+	"electron-vite"
+];
+const ELECTRON_ENTRY_PATTERNS = [
+	"src/main/**/*.{ts,js}",
+	"src/preload/**/*.{ts,js}",
+	"electron/main.{ts,js}",
+	"electron.vite.config.{ts,js,mjs}",
+	"forge.config.{ts,js,cjs}",
+	"electron-builder.{yml,yaml,json,json5,toml}"
+];
+const discoverElectronEntryPoints = (rootDir) => {
+	const packageJsonPath = join(rootDir, "package.json");
+	if (!existsSync(packageJsonPath)) return [];
+	try {
+		const content = readFileSync(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(content);
+		const allDependencies = {
+			...packageJson.dependencies,
+			...packageJson.devDependencies,
+			...packageJson.optionalDependencies
+		};
+		if (!ELECTRON_ENABLERS.some((enabler) => enabler in allDependencies)) return [];
+		return fg.sync(ELECTRON_ENTRY_PATTERNS, {
+			cwd: rootDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		});
+	} catch {
+		return [];
+	}
+};
+const EXPO_ENABLERS = ["expo"];
+const EXPO_ROUTER_ENABLERS = ["expo-router"];
+const EXPO_ENTRY_PATTERNS = [
+	"App.{ts,tsx,js,jsx}",
+	"src/App.{ts,tsx,js,jsx}",
+	"app.config.{ts,js,mjs,cjs}",
+	"metro.config.{ts,js,mjs,cjs}",
+	"babel.config.{ts,js,mjs,cjs}"
+];
+const EXPO_ROUTER_ENTRY_PATTERNS = [
+	"app/**/*.{ts,tsx,js,jsx}",
+	"app.config.{ts,js,mjs,cjs}",
+	"metro.config.{ts,js,mjs,cjs}",
+	"babel.config.{ts,js,mjs,cjs}"
+];
+const REACT_NATIVE_ENABLERS$1 = ["react-native"];
+const REACT_NATIVE_ENTRY_PATTERNS = [
+	"index.{ts,tsx,js,jsx}",
+	"index.android.{ts,tsx,js,jsx}",
+	"index.ios.{ts,tsx,js,jsx}",
+	"index.native.{ts,tsx,js,jsx}",
+	"App.{ts,tsx,js,jsx}",
+	"src/App.{ts,tsx,js,jsx}",
+	"metro.config.{ts,js}",
+	"react-native.config.{ts,js}"
+];
+const discoverMobileEntryPoints = (directory) => {
+	const packageJsonPath = join(directory, "package.json");
+	if (!existsSync(packageJsonPath)) return [];
+	try {
+		const content = readFileSync(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(content);
+		const allDependencies = {
+			...packageJson.dependencies,
+			...packageJson.devDependencies,
+			...packageJson.optionalDependencies
+		};
+		const detectedPatterns = [];
+		if (EXPO_ROUTER_ENABLERS.some((enabler) => enabler in allDependencies)) detectedPatterns.push(...EXPO_ROUTER_ENTRY_PATTERNS);
+		else if (EXPO_ENABLERS.some((enabler) => enabler in allDependencies)) detectedPatterns.push(...EXPO_ENTRY_PATTERNS);
+		if (REACT_NATIVE_ENABLERS$1.some((enabler) => enabler in allDependencies)) detectedPatterns.push(...REACT_NATIVE_ENTRY_PATTERNS);
+		if (detectedPatterns.length === 0) return [];
+		return fg.sync(detectedPatterns, {
+			cwd: directory,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"]
+		});
+	} catch {
+		return [];
+	}
+};
+
+//#endregion
+//#region src/resolver/source-path.ts
+const SOURCE_EXTENSIONS$1 = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mts",
+	".mjs"
+];
+const OUTPUT_DIR_PREFIXES = [
+	"dist/esm/",
+	"dist/cjs/",
+	"dist/es/",
+	"dist/lib/",
+	"dist/",
+	"build/",
+	"lib/",
+	"lib-dist/",
+	"esm/",
+	"cjs/",
+	"out/"
+];
+const DIST_WILDCARD_PATTERN = /^dist-[^/]+\//;
+const SOURCE_INDEX_FALLBACK_STEMS = ["src/index", "src/main"];
+const matchesOutputDirectory = (relativePath) => OUTPUT_DIR_PREFIXES.some((prefix) => relativePath.startsWith(prefix)) || DIST_WILDCARD_PATTERN.test(relativePath);
+const resolveSourcePath = (distPath, directory) => {
+	if (existsSync(distPath)) return distPath;
+	const relativeToDist = relative(directory, distPath);
+	const sourceReplacements = ["src/"];
+	const allPrefixes = [...OUTPUT_DIR_PREFIXES];
+	const wildcardMatch = DIST_WILDCARD_PATTERN.exec(relativeToDist);
+	if (wildcardMatch) allPrefixes.push(wildcardMatch[0]);
+	const sourceVariants = allPrefixes.flatMap((prefix) => sourceReplacements.map((replacement) => relativeToDist.replace(new RegExp(`^${prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`), replacement))).filter((variant) => variant !== relativeToDist);
+	for (const variant of sourceVariants) {
+		const withoutExtension = variant.replace(/\.[^.]+$/, "");
+		for (const sourceExtension of SOURCE_EXTENSIONS$1) {
+			const sourceCandidate = resolve(directory, withoutExtension + sourceExtension);
+			if (existsSync(sourceCandidate)) return sourceCandidate;
+		}
+	}
+	if (matchesOutputDirectory(relativeToDist)) for (const stem of SOURCE_INDEX_FALLBACK_STEMS) for (const sourceExtension of SOURCE_EXTENSIONS$1) {
+		const fallbackCandidate = resolve(directory, stem + sourceExtension);
+		if (existsSync(fallbackCandidate)) return fallbackCandidate;
+	}
+	const withoutExtension = relativeToDist.replace(/\.[cm]?js$/, "");
+	if (withoutExtension !== relativeToDist) {
+		for (const sourceExtension of SOURCE_EXTENSIONS$1) {
+			const directSourceCandidate = resolve(directory, withoutExtension + sourceExtension);
+			if (existsSync(directSourceCandidate)) return directSourceCandidate;
+		}
+		const indexCandidate = resolve(directory, withoutExtension, "index.ts");
+		if (existsSync(indexCandidate)) return indexCandidate;
+	}
+};
+
+//#endregion
+//#region src/scanner/discover.ts
+const discoverFiles = async (config) => {
+	const extensions = config.includeExtensions.length > 0 ? config.includeExtensions : DEFAULT_EXTENSIONS;
+	const extensionGlob = extensions.length === 1 ? `**/*${extensions[0]}` : `**/*{${extensions.join(",")}}`;
+	const ignorePatterns = [...DEFAULT_IGNORE_PATTERNS, ...config.ignorePatterns];
+	const absoluteRoot = resolve(config.rootDir);
+	const mainFiles = await fg(extensionGlob, {
+		cwd: absoluteRoot,
+		absolute: true,
+		ignore: ignorePatterns,
+		dot: false,
+		onlyFiles: true
+	});
+	const allowedHiddenGlobs = HIDDEN_DIRECTORY_ALLOWLIST.flatMap((directory) => [`${directory}/**/*{${extensions.join(",")}}`, `**/${directory}/**/*{${extensions.join(",")}}`]);
+	const hiddenFiles = allowedHiddenGlobs.length > 0 ? await fg(allowedHiddenGlobs, {
+		cwd: absoluteRoot,
+		absolute: true,
+		ignore: ignorePatterns,
+		dot: true,
+		onlyFiles: true
+	}) : [];
+	return [...mainFiles, ...hiddenFiles].sort().map((filePath, fileIndex) => ({
+		index: fileIndex,
+		path: filePath
+	}));
+};
+const discoverFrameworkIgnorePatterns = (rootDir) => {
+	const absoluteRoot = resolve(rootDir);
+	const directoriesToCheck = [absoluteRoot, ...discoverWorkspacePackagesWithExclusions(absoluteRoot).packages.map((workspacePackage) => workspacePackage.directory)];
+	const ignorePatterns = [];
+	for (const directory of directoriesToCheck) {
+		const packageJsonPath = join(directory, "package.json");
+		if (!existsSync(packageJsonPath)) continue;
+		let allDependencies = {};
+		try {
+			const content = readFileSync(packageJsonPath, "utf-8");
+			const packageJson = JSON.parse(content);
+			allDependencies = {
+				...packageJson.dependencies,
+				...packageJson.devDependencies,
+				...packageJson.optionalDependencies
+			};
+		} catch {
+			continue;
+		}
+		for (const plugin of TOOLING_PLUGIN_DEFINITIONS) if (plugin.contentIgnorePatterns && isToolingPluginEnabled(plugin, allDependencies)) for (const pattern of plugin.contentIgnorePatterns) {
+			const absolutePattern = join(directory, pattern);
+			ignorePatterns.push(absolutePattern);
+		}
+	}
+	return ignorePatterns;
+};
+const discoverEntryPoints = async (config) => {
+	const absoluteRoot = resolve(config.rootDir);
+	const entryFiles = config.entryPatterns.length > 0 ? await fg(config.entryPatterns, {
+		cwd: absoluteRoot,
+		absolute: true,
+		onlyFiles: true
+	}) : [];
+	const packageJsonEntries = await extractPackageJsonEntries(resolve(absoluteRoot, "package.json"));
+	const workspaceDiscovery = discoverWorkspacePackagesWithExclusions(absoluteRoot);
+	const workspacePackages = workspaceDiscovery.packages;
+	const isEntryEligible = (workspacePackage) => {
+		if (workspaceDiscovery.hasRootLevelWorkspacePatterns) return true;
+		return workspacePackage.depthFromRoot <= 2;
+	};
+	const hasDeclaredWorkspaces = workspacePackages.some((workspacePackage) => workspacePackage.isDeclaredWorkspace);
+	const workspaceEntries = [];
+	for (const workspacePackage of workspacePackages) {
+		const isEligible = isEntryEligible(workspacePackage);
+		if (workspaceDiscovery.hasRootLevelWorkspacePatterns && hasDeclaredWorkspaces ? workspacePackage.isDeclaredWorkspace && isEligible : isEligible) {
+			const workspaceFrameworkEntries = discoverFrameworkEntryPoints(workspacePackage.directory);
+			workspaceEntries.push(...workspaceFrameworkEntries);
+		}
+		if (isEligible && (workspacePackage.isDeclaredWorkspace || !workspaceDiscovery.hasRootLevelWorkspacePatterns)) {
+			const workspacePackageJsonEntries = await extractPackageJsonEntries(resolve(workspacePackage.directory, "package.json"));
+			if (workspacePackageJsonEntries.some((entryPath) => existsSync(entryPath))) workspaceEntries.push(...workspacePackageJsonEntries);
+			else {
+				const defaultFallback = findDefaultIndexEntry(workspacePackage.directory);
+				if (defaultFallback) workspaceEntries.push(defaultFallback);
+			}
+		}
+	}
+	const frameworkEntries = discoverFrameworkEntryPoints(absoluteRoot);
+	const entryEligiblePackages = workspacePackages.filter(isEntryEligible);
+	const scriptEntries = extractScriptEntries(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) scriptEntries.push(...extractScriptEntries(workspacePackage.directory));
+	const webpackEntries = extractWebpackEntryPoints(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) webpackEntries.push(...extractWebpackEntryPoints(workspacePackage.directory));
+	const viteEntries = extractViteEntryPoints(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) viteEntries.push(...extractViteEntryPoints(workspacePackage.directory));
+	const bundlerConfigEntries = extractBundlerConfigEntryPoints(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) bundlerConfigEntries.push(...extractBundlerConfigEntryPoints(workspacePackage.directory));
+	const htmlScriptEntries = extractHtmlScriptEntries(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) htmlScriptEntries.push(...extractHtmlScriptEntries(workspacePackage.directory));
+	const allDiscoveredEntries = [
+		...scriptEntries,
+		...webpackEntries,
+		...viteEntries,
+		...bundlerConfigEntries
+	];
+	for (const entryPath of allDiscoveredEntries) if (entryPath.endsWith(".html") && existsSync(entryPath)) htmlScriptEntries.push(...extractScriptTagsFromHtmlFile(entryPath));
+	const angularEntries = extractAngularEntryPoints(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) angularEntries.push(...extractAngularEntryPoints(workspacePackage.directory));
+	const testSetupEntries = extractTestSetupFiles(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) testSetupEntries.push(...extractTestSetupFiles(workspacePackage.directory));
+	const pluginFileEntries = extractNextConfigPluginFiles(absoluteRoot);
+	for (const workspacePackage of entryEligiblePackages) pluginFileEntries.push(...extractNextConfigPluginFiles(workspacePackage.directory));
+	const testRunnerDiscovery = discoverTestRunnerEntryPoints(absoluteRoot, entryEligiblePackages);
+	const toolingDiscovery = discoverToolingEntryPoints(absoluteRoot, entryEligiblePackages);
+	const ciEntries = extractCiWorkflowEntries(absoluteRoot);
+	const testEntries = [...new Set([...testRunnerDiscovery.entryFiles, ...testSetupEntries])];
+	const testEntryPathSet = new Set(testEntries);
+	return {
+		productionEntries: [...new Set([
+			...entryFiles,
+			...packageJsonEntries,
+			...workspaceEntries,
+			...frameworkEntries,
+			...scriptEntries,
+			...webpackEntries,
+			...viteEntries,
+			...bundlerConfigEntries,
+			...htmlScriptEntries,
+			...angularEntries,
+			...pluginFileEntries,
+			...toolingDiscovery.entryFiles,
+			...ciEntries
+		])].filter((entryPath) => !testEntryPathSet.has(entryPath)),
+		testEntries,
+		alwaysUsedFiles: [...new Set([...toolingDiscovery.alwaysUsedFiles, ...testRunnerDiscovery.alwaysUsedFiles])]
+	};
+};
+const DEFAULT_INDEX_PATTERNS = [
+	"src/index.ts",
+	"src/index.tsx",
+	"src/index.js",
+	"src/index.jsx",
+	"src/main.ts",
+	"src/main.tsx",
+	"src/main.js",
+	"src/main.jsx",
+	"index.ts",
+	"index.tsx",
+	"index.js",
+	"index.jsx",
+	"main.ts",
+	"main.tsx",
+	"main.js",
+	"main.jsx"
+];
+const findDefaultIndexEntry = (directory) => {
+	for (const pattern of DEFAULT_INDEX_PATTERNS) {
+		const candidatePath = resolve(directory, pattern);
+		if (existsSync(candidatePath)) return candidatePath;
+	}
+};
+const SOURCE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts",
+	".cts"
+];
+const COMMON_SOURCE_DIRECTORIES = [
+	"src",
+	"lib",
+	"main",
+	"app",
+	"source"
+];
+const BUILD_OUTPUT_DIRECTORY_PATTERN = /^(?:\.\/)?(?:dist(?:-[a-z]+)?|build|out|esm|cjs)\/(?:(?:esm|cjs|es|lib|commonjs|module)\/)?/;
+const findSourceFile = (baseDir, relativePath) => {
+	const pathWithoutExtension = join(baseDir, relativePath).replace(/\.[cm]?js(x?)$/, "");
+	for (const sourceExtension of SOURCE_EXTENSIONS) {
+		const candidatePath = pathWithoutExtension + sourceExtension;
+		if (existsSync(candidatePath)) return candidatePath;
+	}
+	const indexCandidate = join(pathWithoutExtension, "index.ts");
+	if (existsSync(indexCandidate)) return indexCandidate;
+};
+const findSourceFileStrict = (baseDir, relativePath) => {
+	const pathWithoutExtension = join(baseDir, relativePath).replace(/\.[cm]?js(x?)$/, "");
+	for (const sourceExtension of SOURCE_EXTENSIONS) {
+		const candidatePath = pathWithoutExtension + sourceExtension;
+		if (existsSync(candidatePath)) return candidatePath;
+	}
+	const exactPath = join(baseDir, relativePath);
+	if (existsSync(exactPath)) return exactPath;
+};
+const resolveBuiltPathToSource = (builtAbsolutePath, rootDir) => {
+	if (existsSync(builtAbsolutePath)) return void 0;
+	try {
+		const tsconfigPath = join(rootDir, "tsconfig.json");
+		if (!existsSync(tsconfigPath)) return void 0;
+		const tsconfigContent = readFileSync(tsconfigPath, "utf-8").replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+		const tsconfig = JSON.parse(tsconfigContent);
+		const outDir = tsconfig?.compilerOptions?.outDir;
+		if (!outDir) return void 0;
+		const absoluteOutDir = resolve(rootDir, outDir);
+		const relativeToBuild = builtAbsolutePath.startsWith(absoluteOutDir) ? builtAbsolutePath.slice(absoluteOutDir.length) : void 0;
+		if (!relativeToBuild) return void 0;
+		const rootDirOption = tsconfig?.compilerOptions?.rootDir;
+		const sourceRoot = rootDirOption ? resolve(rootDir, rootDirOption) : rootDir;
+		const sourceFileMatch = findSourceFile(sourceRoot, relativeToBuild);
+		if (sourceFileMatch) return sourceFileMatch;
+		const directCandidate = join(sourceRoot, relativeToBuild);
+		if (existsSync(directCandidate)) return directCandidate;
+		if (!rootDirOption) for (const sourceDir of COMMON_SOURCE_DIRECTORIES) {
+			const candidate = findSourceFile(resolve(rootDir, sourceDir), relativeToBuild);
+			if (candidate) return candidate;
+		}
+	} catch {}
+};
+const resolveEntryPathViaHeuristic = (entryPath, rootDir) => {
+	if (!BUILD_OUTPUT_DIRECTORY_PATTERN.test(entryPath)) return void 0;
+	const buildDirMatch = entryPath.match(BUILD_OUTPUT_DIRECTORY_PATTERN);
+	if (!buildDirMatch) return void 0;
+	const relativeToBuildDir = entryPath.slice(buildDirMatch[0].length);
+	for (const sourceDir of COMMON_SOURCE_DIRECTORIES) {
+		const sourceBaseDir = resolve(rootDir, sourceDir);
+		if (!existsSync(sourceBaseDir)) continue;
+		const sourceFileMatch = findSourceFileStrict(sourceBaseDir, relativeToBuildDir);
+		if (sourceFileMatch) return sourceFileMatch;
+	}
+};
+const resolveEntryPath = (entryPath, rootDir) => {
+	const absolutePath = resolve(rootDir, entryPath);
+	const normalizedEntry = entryPath.replace(/^\.\//, "");
+	if (BUILD_OUTPUT_DIRECTORY_PATTERN.test(normalizedEntry)) {
+		const sourcePath = resolveBuiltPathToSource(absolutePath, rootDir);
+		if (sourcePath) return sourcePath;
+		const heuristicMatch = resolveEntryPathViaHeuristic(normalizedEntry, rootDir);
+		if (heuristicMatch) return heuristicMatch;
+	}
+	if (existsSync(absolutePath)) return absolutePath;
+	const sourcePath = resolveBuiltPathToSource(absolutePath, rootDir);
+	if (sourcePath) return sourcePath;
+	const directSourceMatch = findSourceFile(rootDir, normalizedEntry);
+	if (directSourceMatch) return directSourceMatch;
+	const heuristicMatch = resolveEntryPathViaHeuristic(normalizedEntry, rootDir);
+	if (heuristicMatch) return heuristicMatch;
+	return absolutePath;
+};
+const extractPackageJsonEntries = async (packageJsonPath) => {
+	const entries = [];
+	try {
+		const content = await readFile(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(content);
+		const rootDir = packageJsonPath.replace(/\/package\.json$/, "");
+		for (const field of [
+			"main",
+			"module",
+			"browser",
+			"types",
+			"typings"
+		]) if (typeof packageJson[field] === "string") entries.push(resolveEntryPath(packageJson[field], rootDir));
+		if (packageJson.exports) {
+			const exportEntries = [];
+			collectExportPaths(packageJson.exports, rootDir, exportEntries);
+			for (const exportEntry of exportEntries) if (existsSync(exportEntry)) entries.push(exportEntry);
+			else {
+				const sourcePath = resolveSourcePath(exportEntry, rootDir);
+				if (sourcePath) entries.push(sourcePath);
+				else if (exportEntry.endsWith(".ts")) {
+					const tsxFallback = exportEntry.replace(/\.ts$/, ".tsx");
+					if (existsSync(tsxFallback)) entries.push(tsxFallback);
+					else entries.push(exportEntry);
+				} else entries.push(resolveEntryPath(exportEntry, rootDir));
+			}
+		}
+		if (packageJson.bin) {
+			if (typeof packageJson.bin === "string") entries.push(resolveEntryPath(packageJson.bin, rootDir));
+			else if (typeof packageJson.bin === "object") {
+				for (const binPath of Object.values(packageJson.bin)) if (typeof binPath === "string") entries.push(resolveEntryPath(binPath, rootDir));
+			}
+		}
+	} catch {}
+	return entries;
+};
+const SHELL_OPERATORS_PATTERN = /\s*(?:&&|\|\||[;&|])\s*/;
+const SCRIPT_MULTIPLEXERS = new Set([
+	"concurrently",
+	"run-s",
+	"run-p",
+	"npm-run-all",
+	"npm-run-all2",
+	"wireit",
+	"turbo",
+	"lerna",
+	"ultra"
+]);
+const CONFIG_LIKE_FLAGS = new Set([
+	"--config",
+	"-c",
+	"--format",
+	"--formatter",
+	"--tsconfig",
+	"--project",
+	"-p",
+	"--setup",
+	"--global-setup"
+]);
+const ENV_WRAPPER_BINARIES = new Set([
+	"cross-env",
+	"dotenv",
+	"dotenv-flow",
+	"env-cmd"
+]);
+const NON_ENTRY_BINARIES = new Set([
+	"prettier",
+	"eslint",
+	"tslint",
+	"stylelint",
+	"biome",
+	"oxlint",
+	"oxfmt",
+	"tsc",
+	"tsup",
+	"tsdown",
+	"rollup",
+	"webpack",
+	"rimraf",
+	"del-cli",
+	"shx",
+	"cpy-cli",
+	"cpx",
+	"echo",
+	"cat",
+	"mkdir",
+	"rm",
+	"cp",
+	"mv",
+	"ls",
+	"pwd",
+	"test",
+	"husky",
+	"lint-staged",
+	"commitlint",
+	"changeset",
+	"changesets",
+	"typedoc",
+	"api-extractor",
+	"madge",
+	"depcheck",
+	"deslop",
+	"sort-package-json",
+	"pnpm",
+	"npm",
+	"yarn",
+	"ni",
+	"nr",
+	"nun",
+	"next",
+	"nuxt",
+	"astro",
+	"vite",
+	"svelte-kit",
+	"prisma",
+	"drizzle-kit",
+	"formatjs",
+	"i18next",
+	"i18next-parser",
+	"lingui",
+	"storybook",
+	"chromatic",
+	"msw",
+	"patch-package",
+	"syncpack",
+	"manypkg",
+	"jest",
+	"vitest",
+	"mocha",
+	"ava",
+	"tap",
+	"c8",
+	"nyc",
+	"playwright",
+	"cypress",
+	"puppeteer",
+	"webdriver",
+	"sequelize",
+	"typeorm",
+	"mikro-orm",
+	"wait-on",
+	"start-server-and-test",
+	"remark",
+	"markdownlint",
+	"markdownlint-cli2",
+	"textlint",
+	"alex",
+	"cspell",
+	"ncu",
+	"npm-check-updates",
+	"size-limit",
+	"bundlewatch",
+	"dbdocs",
+	"lobe-i18n",
+	"lobe-seo"
+]);
+const looksLikeFilePath = (token) => {
+	if (token.startsWith("-") || token.includes("${{") || token.includes("://")) return false;
+	if (token.includes("}}") && !token.includes("{{")) return false;
+	if (/\.(?:[cm]?[jt]sx?|css|scss|json|yaml|yml|toml|html|mjs|cjs|mts|cts|graphql|gql|mdx|astro|vue|svelte)$/.test(token)) return true;
+	if (/\.\{[^}]+\}$/.test(token)) return true;
+	if (token.startsWith("./") || token.startsWith("../")) return true;
+	return token.includes("/") && !token.startsWith("@");
+};
+const isGlobPattern = (token) => {
+	return token.includes("*") || token.includes("{") || token.includes("?");
+};
+const extractScriptFileArguments = (scriptCommand, directory) => {
+	const entries = [];
+	const segments = scriptCommand.split(SHELL_OPERATORS_PATTERN);
+	for (const segment of segments) {
+		const trimmedSegment = segment.trim();
+		if (!trimmedSegment) continue;
+		const tokens = trimmedSegment.split(/\s+/);
+		if (tokens.length === 0) continue;
+		let startIndex = 0;
+		const firstBinary = tokens[0].replace(/^.*\//, "");
+		if (ENV_WRAPPER_BINARIES.has(firstBinary)) {
+			startIndex = 1;
+			while (startIndex < tokens.length && /^[A-Z_][A-Z0-9_]*=/.test(tokens[startIndex])) startIndex++;
+			if (startIndex >= tokens.length) continue;
+		}
+		const binaryName = tokens[startIndex].replace(/^.*\//, "");
+		if (SCRIPT_MULTIPLEXERS.has(binaryName)) continue;
+		const effectiveBinaryName = binaryName === "npx" || binaryName === "pnpx" || binaryName === "bunx" ? tokens[startIndex + 1]?.replace(/^.*\//, "") ?? "" : binaryName;
+		const isNonEntryBinary = NON_ENTRY_BINARIES.has(binaryName) || effectiveBinaryName !== "" && NON_ENTRY_BINARIES.has(effectiveBinaryName);
+		for (let tokenIndex = startIndex + 1; tokenIndex < tokens.length; tokenIndex++) {
+			const token = tokens[tokenIndex].replace(/^['"]|['"]$/g, "");
+			if (CONFIG_LIKE_FLAGS.has(token)) {
+				if (tokenIndex + 1 < tokens.length && !tokens[tokenIndex + 1].startsWith("-")) {
+					const configPath = tokens[tokenIndex + 1].replace(/^['"]|['"]$/g, "");
+					if (looksLikeFilePath(configPath)) {
+						const absoluteConfigPath = resolve(directory, configPath);
+						if (existsSync(absoluteConfigPath)) entries.push(absoluteConfigPath);
+					}
+					tokenIndex++;
+				}
+				continue;
+			}
+			const equalsIndex = token.indexOf("=");
+			if (equalsIndex > 0 && CONFIG_LIKE_FLAGS.has(token.slice(0, equalsIndex))) {
+				const configValue = token.slice(equalsIndex + 1);
+				if (configValue && looksLikeFilePath(configValue)) {
+					const absoluteConfigPath = resolve(directory, configValue);
+					if (existsSync(absoluteConfigPath)) entries.push(absoluteConfigPath);
+				}
+				continue;
+			}
+			if (token.startsWith("-")) continue;
+			if (isNonEntryBinary) continue;
+			if (!looksLikeFilePath(token)) continue;
+			if (isGlobPattern(token)) {
+				const expandedFiles = fg.sync(token, {
+					cwd: directory,
+					absolute: true,
+					onlyFiles: true,
+					ignore: ["**/node_modules/**"]
+				});
+				entries.push(...expandedFiles);
+			} else {
+				const absoluteFilePath = resolve(directory, token);
+				if (existsSync(absoluteFilePath)) entries.push(absoluteFilePath);
+				else {
+					const sourcePath = resolveSourcePath(absoluteFilePath, directory);
+					if (sourcePath) entries.push(sourcePath);
+				}
+			}
+		}
+	}
+	return entries;
+};
+const EXTENSIONLESS_SCRIPT_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mts",
+	".mjs",
+	".cjs"
+];
+const resolveExtensionlessScriptPath = (basePath) => {
+	for (const extension of EXTENSIONLESS_SCRIPT_EXTENSIONS) {
+		const candidate = basePath + extension;
+		if (existsSync(candidate)) return candidate;
+	}
+	const indexCandidate = resolve(basePath, "index.ts");
+	if (existsSync(indexCandidate)) return indexCandidate;
+};
+const extractScriptEntries = (directory) => {
+	const packageJsonPath = resolve(directory, "package.json");
+	if (!existsSync(packageJsonPath)) return [];
+	const entries = [];
+	try {
+		const content = readFileSync(packageJsonPath, "utf-8");
+		const scripts = JSON.parse(content).scripts;
+		if (scripts && typeof scripts === "object") for (const scriptCommand of Object.values(scripts)) {
+			if (typeof scriptCommand !== "string") continue;
+			const match = scriptCommand.match(SCRIPT_FILE_PATTERN);
+			if (match?.[1]) {
+				const scriptFilePath = resolve(directory, match[1]);
+				if (existsSync(scriptFilePath)) entries.push(scriptFilePath);
+				else {
+					const sourcePath = resolveSourcePath(scriptFilePath, directory);
+					if (sourcePath) entries.push(sourcePath);
+				}
+			} else {
+				const extensionlessMatch = scriptCommand.match(SCRIPT_EXTENSIONLESS_FILE_PATTERN);
+				if (extensionlessMatch?.[1]) {
+					const extensionlessPath = extensionlessMatch[1];
+					const resolved = resolveExtensionlessScriptPath(resolve(directory, extensionlessPath));
+					if (resolved) entries.push(resolved);
+				}
+			}
+			const configMatch = scriptCommand.match(SCRIPT_CONFIG_FILE_PATTERN);
+			if (configMatch?.[1]) {
+				const configFilePath = resolve(directory, configMatch[1]);
+				if (existsSync(configFilePath)) entries.push(configFilePath);
+				else {
+					const sourcePath = resolveSourcePath(configFilePath, directory);
+					if (sourcePath) entries.push(sourcePath);
+				}
+			}
+			entries.push(...extractScriptFileArguments(scriptCommand, directory));
+		}
+	} catch {}
+	const scriptDirectoryFiles = fg.sync(SCRIPT_ENTRY_PATTERNS, {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"]
+	});
+	entries.push(...scriptDirectoryFiles);
+	return entries;
+};
+const isYamlMapping = (line) => {
+	const firstWord = line.split(/\s/)[0];
+	if (!firstWord) return false;
+	return firstWord.endsWith(":") && !firstWord.startsWith("http") && !firstWord.startsWith("ftp");
+};
+const extractCiRunCommands = (content) => {
+	const commands = [];
+	let inMultilineRun = false;
+	let multilineIndent = 0;
+	for (const line of content.split("\n")) {
+		const trimmedLine = line.trim();
+		if (trimmedLine === "" || trimmedLine.startsWith("#")) continue;
+		if (inMultilineRun) {
+			if (line.length - line.trimStart().length > multilineIndent && trimmedLine !== "") {
+				commands.push(trimmedLine);
+				continue;
+			}
+			inMultilineRun = false;
+		}
+		const runMatch = trimmedLine.match(/^(?:-\s+)?run:\s*(.*)$/);
+		if (runMatch) {
+			const runValue = runMatch[1].trim();
+			if (runValue === "|" || runValue === "|-" || runValue === "|+") {
+				inMultilineRun = true;
+				multilineIndent = line.length - line.trimStart().length;
+			} else if (runValue !== "") commands.push(runValue);
+			continue;
+		}
+		if (trimmedLine.startsWith("- ")) {
+			const listItem = trimmedLine.slice(2).trim();
+			if (listItem !== "" && !listItem.startsWith("{") && !listItem.startsWith("[") && !isYamlMapping(listItem)) commands.push(listItem);
+		}
+	}
+	return commands;
+};
+const extractCiWorkflowEntries = (rootDir) => {
+	const entries = [];
+	const workflowsDir = join(rootDir, ".github", "workflows");
+	if (!existsSync(workflowsDir)) return entries;
+	const workflowFiles = fg.sync("*.{yml,yaml}", {
+		cwd: workflowsDir,
+		absolute: true,
+		onlyFiles: true
+	});
+	for (const workflowFile of workflowFiles) try {
+		const runCommands = extractCiRunCommands(readFileSync(workflowFile, "utf-8"));
+		for (const command of runCommands) {
+			const scriptMatch = command.match(SCRIPT_FILE_PATTERN);
+			if (scriptMatch?.[1]) {
+				const scriptFilePath = resolve(rootDir, scriptMatch[1]);
+				if (existsSync(scriptFilePath)) entries.push(scriptFilePath);
+			}
+			const configMatch = command.match(SCRIPT_CONFIG_FILE_PATTERN);
+			if (configMatch?.[1]) {
+				const configFilePath = resolve(rootDir, configMatch[1]);
+				if (existsSync(configFilePath)) entries.push(configFilePath);
+			}
+		}
+	} catch {}
+	return entries;
+};
+const VITE_INPUT_BLOCK_PATTERN = /input\s*:\s*(?:\{[^}]*\}|\[[^\]]*\]|['"][^'"]+['"])/gs;
+const BUNDLER_ENTRY_FILE_PATTERN = /['"]([^'"]+\.(?:js|ts|tsx|jsx|mjs|mts|less|scss|css|sass|html))['"]/g;
+const extractViteEntryPoints = (directory) => {
+	const entries = [];
+	const viteConfigPaths = fg.sync("vite.config.{js,ts,mjs,mts}", {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true
+	});
+	for (const configPath of viteConfigPaths) try {
+		const content = readFileSync(configPath, "utf-8");
+		let inputMatch;
+		VITE_INPUT_BLOCK_PATTERN.lastIndex = 0;
+		while ((inputMatch = VITE_INPUT_BLOCK_PATTERN.exec(content)) !== null) {
+			const inputBlock = inputMatch[0];
+			let valueMatch;
+			BUNDLER_ENTRY_FILE_PATTERN.lastIndex = 0;
+			while ((valueMatch = BUNDLER_ENTRY_FILE_PATTERN.exec(inputBlock)) !== null) {
+				const entryPath = valueMatch[1];
+				if (entryPath.startsWith("./") || entryPath.startsWith("../") || !entryPath.startsWith("/")) {
+					const absoluteEntryPath = resolve(directory, entryPath);
+					if (existsSync(absoluteEntryPath)) entries.push(absoluteEntryPath);
+				}
+			}
+		}
+	} catch {}
+	return entries;
+};
+const BUNDLER_CONFIG_ENTRY_BLOCK_PATTERN = /entry\s*:\s*\[([^\]]*)\]/gs;
+const BUNDLER_CONFIG_ENTRY_STRING_PATTERN = /['"]([^'"]+)['"]/g;
+const extractBundlerConfigEntryPoints = (directory) => {
+	const entries = [];
+	const configPaths = fg.sync(["tsdown.config.{ts,js,cjs,mjs}", "tsup.config.{ts,js,cjs,mjs}"], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true
+	});
+	for (const configPath of configPaths) try {
+		const content = readFileSync(configPath, "utf-8");
+		let blockMatch;
+		BUNDLER_CONFIG_ENTRY_BLOCK_PATTERN.lastIndex = 0;
+		while ((blockMatch = BUNDLER_CONFIG_ENTRY_BLOCK_PATTERN.exec(content)) !== null) {
+			const arrayContent = blockMatch[1];
+			let stringMatch;
+			BUNDLER_CONFIG_ENTRY_STRING_PATTERN.lastIndex = 0;
+			while ((stringMatch = BUNDLER_CONFIG_ENTRY_STRING_PATTERN.exec(arrayContent)) !== null) {
+				const entryPath = stringMatch[1];
+				const resolvedPath = resolveEntryWithExtensions(resolve(directory, entryPath));
+				if (resolvedPath) entries.push(resolvedPath);
+			}
+		}
+	} catch {}
+	return entries;
+};
+const WEBPACK_ENTRY_BLOCK_PATTERN = /entry\s*:\s*(?:\{[^}]*\}|\[[^\]]*\]|['"][^'"]+['"]|path\.(?:join|resolve)\([^)]*\))/gs;
+const WEBPACK_ENTRY_FILE_PATTERN = /['"]([^'"]+)['"]/g;
+const WEBPACK_PATH_JOIN_PATTERN = /path\.(?:join|resolve)\(\s*__dirname\s*,\s*((?:['"][^'"]*['"]\s*,?\s*)+)\)/g;
+const REQUIRE_RESOLVE_PATTERN = /require\.resolve\(\s*['"]([^'"]+)['"]\s*\)/g;
+const RESOLVABLE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".mts"
+];
+const resolveEntryWithExtensions = (basePath) => {
+	if (existsSync(basePath)) return basePath;
+	for (const extension of RESOLVABLE_EXTENSIONS) {
+		const withExtension = basePath + extension;
+		if (existsSync(withExtension)) return withExtension;
+	}
+	const indexCandidates = RESOLVABLE_EXTENSIONS.map((extension) => resolve(basePath, `index${extension}`));
+	for (const candidate of indexCandidates) if (existsSync(candidate)) return candidate;
+};
+const extractWebpackEntryPoints = (directory) => {
+	const entries = [];
+	const webpackConfigPaths = fg.sync([
+		"webpack.config.{js,ts,mjs,cjs}",
+		"**/webpack*.config.{js,ts,mjs,cjs}",
+		"**/webpack.config*.{js,ts,mjs,cjs}",
+		"**/webpack*.config*.babel.{js,ts}"
+	], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"],
+		deep: 3
+	});
+	for (const configPath of webpackConfigPaths) try {
+		const content = readFileSync(configPath, "utf-8");
+		const configDirectory = dirname(configPath);
+		let pathJoinMatch;
+		WEBPACK_PATH_JOIN_PATTERN.lastIndex = 0;
+		while ((pathJoinMatch = WEBPACK_PATH_JOIN_PATTERN.exec(content)) !== null) {
+			const segments = [...pathJoinMatch[1].matchAll(/['"]([^'"]*)['"]/g)].map((match) => match[1]);
+			if (segments.length > 0) {
+				const resolvedEntry = resolveEntryWithExtensions(resolve(configDirectory, ...segments));
+				if (resolvedEntry) entries.push(resolvedEntry);
+			}
+		}
+		let requireResolveMatch;
+		REQUIRE_RESOLVE_PATTERN.lastIndex = 0;
+		while ((requireResolveMatch = REQUIRE_RESOLVE_PATTERN.exec(content)) !== null) {
+			const requirePath = requireResolveMatch[1];
+			if (requirePath.startsWith("./") || requirePath.startsWith("../")) {
+				const resolvedEntry = resolveEntryWithExtensions(resolve(configDirectory, requirePath));
+				if (resolvedEntry) entries.push(resolvedEntry);
+			}
+		}
+		let entryMatch;
+		WEBPACK_ENTRY_BLOCK_PATTERN.lastIndex = 0;
+		while ((entryMatch = WEBPACK_ENTRY_BLOCK_PATTERN.exec(content)) !== null) {
+			const entryBlock = entryMatch[0];
+			if (entryBlock.includes("path.join") || entryBlock.includes("path.resolve")) continue;
+			let valueMatch;
+			WEBPACK_ENTRY_FILE_PATTERN.lastIndex = 0;
+			while ((valueMatch = WEBPACK_ENTRY_FILE_PATTERN.exec(entryBlock)) !== null) {
+				const entryPath = valueMatch[1];
+				if (entryPath.startsWith("./") || entryPath.startsWith("../") || !entryPath.startsWith("/")) {
+					const resolvedEntry = resolveEntryWithExtensions(resolve(directory, entryPath));
+					if (resolvedEntry) entries.push(resolvedEntry);
+				}
+			}
+		}
+	} catch {}
+	return entries;
+};
+const HTML_SCRIPT_SRC_PATTERN = /<script[^>]+src=["']([^"']+\.(?:ts|tsx|js|jsx|mts|mjs))["'][^>]*>/gi;
+const extractHtmlScriptEntries = (directory) => {
+	const entries = [];
+	const htmlFiles = fg.sync(["index.html", "*.html"], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**"
+		],
+		deep: 1
+	});
+	for (const htmlPath of htmlFiles) try {
+		const content = readFileSync(htmlPath, "utf-8");
+		let scriptMatch;
+		HTML_SCRIPT_SRC_PATTERN.lastIndex = 0;
+		while ((scriptMatch = HTML_SCRIPT_SRC_PATTERN.exec(content)) !== null) {
+			const scriptSrc = scriptMatch[1].replace(/^\//, "");
+			const absoluteScriptPath = resolve(htmlPath.replace(/\/[^/]+$/, ""), scriptSrc);
+			if (existsSync(absoluteScriptPath)) entries.push(absoluteScriptPath);
+		}
+	} catch {}
+	return entries;
+};
+const extractScriptTagsFromHtmlFile = (htmlFilePath) => {
+	const entries = [];
+	try {
+		const content = readFileSync(htmlFilePath, "utf-8");
+		let scriptMatch;
+		HTML_SCRIPT_SRC_PATTERN.lastIndex = 0;
+		while ((scriptMatch = HTML_SCRIPT_SRC_PATTERN.exec(content)) !== null) {
+			const scriptSrc = scriptMatch[1].replace(/^\//, "");
+			const absoluteScriptPath = resolve(dirname(htmlFilePath), scriptSrc);
+			if (existsSync(absoluteScriptPath)) entries.push(absoluteScriptPath);
+		}
+	} catch {}
+	return entries;
+};
+const ANGULAR_ENTRY_KEYS = [
+	"main",
+	"polyfills",
+	"styles"
+];
+const extractAngularEntryPoints = (directory) => {
+	const entries = [];
+	const angularJsonPaths = fg.sync(["angular.json", ".angular-cli.json"], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true
+	});
+	for (const angularJsonPath of angularJsonPaths) try {
+		const content = readFileSync(angularJsonPath, "utf-8");
+		const projects = JSON.parse(content).projects ?? {};
+		const angularDir = angularJsonPath.replace(/\/[^/]+$/, "");
+		for (const projectConfig of Object.values(projects)) {
+			const projectRecord = projectConfig;
+			const architect = projectRecord.architect;
+			if (architect) for (const targetConfig of Object.values(architect)) {
+				const options = targetConfig.options;
+				if (!options) continue;
+				for (const entryKey of ANGULAR_ENTRY_KEYS) {
+					const entryValue = options[entryKey];
+					if (typeof entryValue === "string") {
+						const absolutePath = resolve(angularDir, entryValue);
+						if (existsSync(absolutePath)) entries.push(absolutePath);
+					}
+					if (Array.isArray(entryValue)) {
+						for (const entryItem of entryValue) if (typeof entryItem === "string") {
+							const absolutePath = resolve(angularDir, entryItem);
+							if (existsSync(absolutePath)) entries.push(absolutePath);
+						}
+					}
+				}
+			}
+			const projectDir = resolve(angularDir, typeof projectRecord.root === "string" ? projectRecord.root : "");
+			const ngPackagePaths = fg.sync(["ng-package.json", "**/ng-package.json"], {
+				cwd: projectDir,
+				absolute: true,
+				onlyFiles: true,
+				deep: 2,
+				ignore: ["**/node_modules/**"]
+			});
+			for (const ngPackagePath of ngPackagePaths) try {
+				const ngContent = readFileSync(ngPackagePath, "utf-8");
+				const ngPackage = JSON.parse(ngContent);
+				const ngDir = ngPackagePath.replace(/\/[^/]+$/, "");
+				const libEntry = ngPackage?.lib?.entryFile;
+				if (typeof libEntry === "string") {
+					const absoluteEntry = resolve(ngDir, libEntry);
+					if (existsSync(absoluteEntry)) entries.push(absoluteEntry);
+				}
+			} catch {}
+		}
+	} catch {}
+	return entries;
+};
+const PLUGIN_FILE_ARGUMENT_PATTERN = /(?:createNextIntlPlugin|createMDX|withContentlayer|withPlaiceholder)\s*\(\s*['"]([^'"]+)['"]/g;
+const NEXT_INTL_IMPORT_PATTERN = /createNextIntlPlugin/;
+const NEXT_INTL_DEFAULT_PATHS = [
+	"src/i18n/request.ts",
+	"src/i18n/request.tsx",
+	"src/i18n/request.js",
+	"i18n/request.ts",
+	"i18n/request.tsx",
+	"i18n/request.js",
+	"i18n.ts",
+	"i18n.tsx"
+];
+const extractNextConfigPluginFiles = (directory) => {
+	const entries = [];
+	const nextConfigPaths = fg.sync(["next.config.{ts,js,mjs,mts}"], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"]
+	});
+	for (const configPath of nextConfigPaths) try {
+		const content = readFileSync(configPath, "utf-8");
+		const configDirectory = configPath.replace(/\/[^/]+$/, "");
+		let pluginMatch;
+		PLUGIN_FILE_ARGUMENT_PATTERN.lastIndex = 0;
+		let didMatchNextIntlWithPath = false;
+		while ((pluginMatch = PLUGIN_FILE_ARGUMENT_PATTERN.exec(content)) !== null) {
+			const filePath = pluginMatch[1];
+			const absolutePath = resolve(configDirectory, filePath);
+			if (existsSync(absolutePath)) entries.push(absolutePath);
+			if (pluginMatch[0].includes("createNextIntlPlugin")) didMatchNextIntlWithPath = true;
+		}
+		if (!didMatchNextIntlWithPath && NEXT_INTL_IMPORT_PATTERN.test(content)) for (const defaultPath of NEXT_INTL_DEFAULT_PATHS) {
+			const absolutePath = resolve(configDirectory, defaultPath);
+			if (existsSync(absolutePath)) {
+				entries.push(absolutePath);
+				break;
+			}
+		}
+	} catch {}
+	return entries;
+};
+const VITEST_INCLUDE_ITEM_PATTERN = /['"]([^'"]+)['"]/g;
+const COVERAGE_BLOCK_PATTERN = /coverage\s*:\s*\{/g;
+const TEST_MATCH_ARRAY_PATTERN = /testMatch\s*:\s*\[([^\]]*)\]/;
+const STRING_LITERAL_PATTERN = /['"]([^'"]+)['"]/g;
+const extractJestTestMatchPatterns = (directory) => {
+	const configPaths = fg.sync(["jest.config.{ts,js,mjs,cjs}"], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"]
+	});
+	if (configPaths.length === 0) {
+		try {
+			const packageContent = readFileSync(join(directory, "package.json"), "utf-8");
+			const packageJson = JSON.parse(packageContent);
+			if (packageJson.jest?.testMatch) return convertJestTestMatchToGlobs(packageJson.jest.testMatch);
+		} catch {}
+		return [];
+	}
+	for (const configPath of configPaths) try {
+		const content = readFileSync(configPath, "utf-8");
+		const testMatchMatch = TEST_MATCH_ARRAY_PATTERN.exec(content);
+		if (!testMatchMatch) continue;
+		const arrayContent = testMatchMatch[1];
+		const patterns = [];
+		STRING_LITERAL_PATTERN.lastIndex = 0;
+		let itemMatch;
+		while ((itemMatch = STRING_LITERAL_PATTERN.exec(arrayContent)) !== null) patterns.push(itemMatch[1]);
+		if (patterns.length > 0) return convertJestTestMatchToGlobs(patterns);
+	} catch {}
+	return [];
+};
+const convertJestTestMatchToGlobs = (patterns) => {
+	return patterns.map((pattern) => {
+		let converted = pattern.replace(/<rootDir>\/?/g, "");
+		converted = converted.replace(/\?\(\*\.\)/g, "*.");
+		converted = converted.replace(/\?\(([^)]+)\)/g, (_, group) => {
+			return `{${[...group.includes("|") ? group.split("|") : [group], ""].join(",")}}`;
+		});
+		converted = converted.replace(/\+\(([^)]+)\)/g, (_, group) => {
+			return group.includes("|") ? `{${group.replace(/\|/g, ",")}}` : group;
+		});
+		converted = converted.replace(/\(([^)]+)\)/g, (_, group) => {
+			return group.includes("|") ? `{${group.replace(/\|/g, ",")}}` : group;
+		});
+		return converted;
+	});
+};
+const extractVitestIncludePatterns = (directory) => {
+	const configPaths = fg.sync(["vitest.config.{ts,js,mts,mjs}", "vitest.web.config.{ts,js,mts,mjs}"], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"]
+	});
+	const patterns = [];
+	for (const configPath of configPaths) try {
+		const content = readFileSync(configPath, "utf-8");
+		const coverageBlockRanges = findNestedBlockRanges(content, COVERAGE_BLOCK_PATTERN);
+		const includePattern = /include\s*:\s*\[([^\]]*)\]/g;
+		includePattern.lastIndex = 0;
+		let includeMatch;
+		while ((includeMatch = includePattern.exec(content)) !== null) {
+			const matchStart = includeMatch.index;
+			if (coverageBlockRanges.some(([blockStart, blockEnd]) => matchStart > blockStart && matchStart < blockEnd)) continue;
+			const arrayContent = includeMatch[1];
+			VITEST_INCLUDE_ITEM_PATTERN.lastIndex = 0;
+			let itemMatch;
+			while ((itemMatch = VITEST_INCLUDE_ITEM_PATTERN.exec(arrayContent)) !== null) patterns.push(itemMatch[1]);
+		}
+	} catch {}
+	return patterns;
+};
+const findNestedBlockRanges = (content, blockStartPattern) => {
+	const ranges = [];
+	blockStartPattern.lastIndex = 0;
+	let blockMatch;
+	while ((blockMatch = blockStartPattern.exec(content)) !== null) {
+		const openBraceIndex = content.indexOf("{", blockMatch.index);
+		if (openBraceIndex === -1) continue;
+		let braceDepth = 1;
+		let position = openBraceIndex + 1;
+		while (position < content.length && braceDepth > 0) {
+			if (content[position] === "{") braceDepth++;
+			if (content[position] === "}") braceDepth--;
+			position++;
+		}
+		ranges.push([blockMatch.index, position]);
+	}
+	return ranges;
+};
+const SETUP_FILES_PATTERN = /(?:setupFiles|setupFilesAfterEnv|globalSetup|globalTeardown)\s*:\s*(?:\[([^\]]*)\]|['"]([^'"]+)['"])/gs;
+const SETUP_FILE_PATH_PATTERN = /['"]([^'"]+)['"]/g;
+const extractTestSetupFiles = (directory) => {
+	const entries = [];
+	const configPaths = fg.sync([
+		"vitest.config.{ts,js,mts,mjs}",
+		"vitest.web.config.{ts,js,mts,mjs}",
+		"vite.config.{ts,js,mts,mjs}",
+		"jest.config.{ts,js,mjs,cjs}",
+		"**/vitest.config.{ts,js,mts,mjs}"
+	], {
+		cwd: directory,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"],
+		deep: 3
+	});
+	for (const configPath of configPaths) try {
+		const content = readFileSync(configPath, "utf-8");
+		const configDirectory = configPath.replace(/\/[^/]+$/, "");
+		let setupMatch;
+		SETUP_FILES_PATTERN.lastIndex = 0;
+		while ((setupMatch = SETUP_FILES_PATTERN.exec(content)) !== null) {
+			const arrayContent = setupMatch[1];
+			const singleValue = setupMatch[2];
+			if (singleValue) {
+				const absolutePath = resolve(configDirectory, singleValue);
+				if (existsSync(absolutePath)) entries.push(absolutePath);
+			}
+			if (arrayContent) {
+				let pathMatch;
+				SETUP_FILE_PATH_PATTERN.lastIndex = 0;
+				while ((pathMatch = SETUP_FILE_PATH_PATTERN.exec(arrayContent)) !== null) {
+					const absolutePath = resolve(configDirectory, pathMatch[1]);
+					if (existsSync(absolutePath)) entries.push(absolutePath);
+				}
+			}
+		}
+	} catch {}
+	return entries;
+};
+const IMPORTABLE_EXTENSION_SET = new Set(SOURCE_EXTENSIONS$3.map((extension) => `.${extension}`));
+const isImportableSourceFile = (filePath) => IMPORTABLE_EXTENSION_SET.has(filePath.slice(filePath.lastIndexOf(".")));
+const expandWildcardExportPattern = (pattern, rootDir) => {
+	const normalized = pattern.startsWith("./") ? pattern.slice(2) : pattern;
+	return fg.sync(normalized, {
+		cwd: rootDir,
+		absolute: true,
+		onlyFiles: true,
+		ignore: ["**/node_modules/**"]
+	}).filter(isImportableSourceFile);
+};
+const collectExportPaths = (exportValue, rootDir, entries) => {
+	if (typeof exportValue === "string") {
+		if (exportValue.includes("*")) {
+			const expandedFiles = expandWildcardExportPattern(exportValue, rootDir);
+			entries.push(...expandedFiles);
+			return;
+		}
+		entries.push(resolveEntryPath(exportValue, rootDir));
+		return;
+	}
+	if (typeof exportValue !== "object" || exportValue === null) return;
+	for (const [, nestedValue] of Object.entries(exportValue)) collectExportPaths(nestedValue, rootDir, entries);
+};
+const TEST_RUNNER_DEFINITIONS = [
+	{
+		enablers: [
+			"vitest",
+			"@vitest/runner",
+			"vite-plus"
+		],
+		configFileActivators: [
+			"vitest.config.ts",
+			"vitest.config.js",
+			"vitest.config.mts",
+			"vitest.config.mjs"
+		],
+		entryPatterns: [
+			"**/*.test.{ts,tsx,js,jsx}",
+			"**/*.spec.{ts,tsx,js,jsx}",
+			"**/__tests__/**/*.{ts,tsx,js,jsx}",
+			"**/*.bench.{ts,tsx,js,jsx}"
+		],
+		fixturePatterns: ["**/__fixtures__/**/*.{ts,tsx,js,jsx,json}", "**/fixtures/**/*.{ts,tsx,js,jsx,json}"],
+		alwaysUsed: [
+			"vitest.config.{ts,js,mts,mjs}",
+			"vitest.setup.{ts,js}",
+			"vitest.workspace.{ts,js}",
+			"**/src/setupTests.{ts,tsx,js,jsx}",
+			"**/src/test-setup.{ts,tsx,js,jsx}"
+		]
+	},
+	{
+		enablers: [
+			"jest",
+			"@jest/core",
+			"ts-jest"
+		],
+		configFileActivators: [
+			"jest.config.ts",
+			"jest.config.js",
+			"jest.config.mjs",
+			"jest.config.cjs"
+		],
+		entryPatterns: [
+			"**/*.test.{ts,tsx,js,jsx}",
+			"**/*.spec.{ts,tsx,js,jsx}",
+			"**/__tests__/**/*.{ts,tsx,js,jsx}",
+			"**/__mocks__/**/*.{ts,tsx,js,jsx,mjs,cjs}"
+		],
+		fixturePatterns: ["**/__fixtures__/**/*.{ts,tsx,js,jsx,json}", "**/fixtures/**/*.{ts,tsx,js,jsx,json}"],
+		alwaysUsed: ["jest.config.{ts,js,mjs,cjs}", "jest.setup.{ts,js,tsx,jsx}"]
+	},
+	{
+		enablers: ["@playwright/test", "playwright"],
+		configFileActivators: ["playwright.config.ts", "playwright.config.js"],
+		entryPatterns: [
+			"**/*.spec.{ts,tsx,js,jsx}",
+			"**/*.test.{ts,tsx,js,jsx}",
+			"tests/**/*.{ts,tsx,js,jsx}",
+			"e2e/**/*.{ts,tsx,js,jsx}"
+		],
+		fixturePatterns: ["**/fixtures/**/*.{ts,tsx,js,jsx,json}"],
+		alwaysUsed: ["playwright.config.{ts,js}"]
+	},
+	{
+		enablers: ["mocha"],
+		configFileActivators: [
+			".mocharc.js",
+			".mocharc.yaml",
+			".mocharc.yml",
+			".mocharc.json"
+		],
+		entryPatterns: [
+			"test/**/*.{ts,tsx,js,jsx}",
+			"tests/**/*.{ts,tsx,js,jsx}",
+			"spec/**/*.{ts,tsx,js,jsx}",
+			"**/*.test.{ts,tsx,js,jsx}",
+			"**/*.spec.{ts,tsx,js,jsx}"
+		],
+		fixturePatterns: [],
+		alwaysUsed: [".mocharc.*"]
+	},
+	{
+		enablers: ["ava", "@ava/typescript"],
+		configFileActivators: [
+			"ava.config.js",
+			"ava.config.cjs",
+			"ava.config.mjs"
+		],
+		entryPatterns: [
+			"test/**/*.{ts,tsx,js,jsx}",
+			"tests/**/*.{ts,tsx,js,jsx}",
+			"**/*.test.{ts,tsx,js,jsx}",
+			"**/*.spec.{ts,tsx,js,jsx}"
+		],
+		fixturePatterns: [],
+		alwaysUsed: ["ava.config.{js,cjs,mjs}"]
+	},
+	{
+		enablers: ["cypress"],
+		configFileActivators: ["cypress.config.ts", "cypress.config.js"],
+		entryPatterns: [
+			"**/*.cy.{ts,tsx,js,jsx}",
+			"cypress/**/*.{ts,tsx,js,jsx}",
+			"cypress/support/**/*.{ts,js}"
+		],
+		fixturePatterns: ["**/fixtures/**/*.{ts,tsx,js,jsx,json}"],
+		alwaysUsed: ["cypress.config.{ts,js}", "cypress.config.*.{ts,js}"]
+	}
+];
+const TOOLING_PLUGIN_DEFINITIONS = [
+	{
+		enablers: ["storybook"],
+		enablerPrefixes: ["@storybook/"],
+		entryPatterns: ["**/*.stories.{ts,tsx,js,jsx,mdx}", ".storybook/**/*.{ts,tsx,js,jsx}"],
+		alwaysUsed: [
+			".storybook/main.{ts,js,mjs,cjs}",
+			".storybook/preview.{ts,tsx,js,jsx}",
+			".storybook/manager.{ts,tsx,js,jsx}"
+		]
+	},
+	{
+		enablers: ["msw"],
+		enablerPrefixes: [],
+		entryPatterns: [
+			"mocks/**/*.{ts,tsx,js,jsx}",
+			"src/mocks/**/*.{ts,tsx,js,jsx}",
+			"**/mocks/**/*.{ts,tsx,js,jsx}"
+		],
+		alwaysUsed: []
+	},
+	{
+		enablers: ["typeorm"],
+		enablerPrefixes: [],
+		entryPatterns: [
+			"migrations/**/*.{ts,js}",
+			"src/migrations/**/*.{ts,js}",
+			"src/migration/**/*.{ts,js}",
+			"migration/**/*.{ts,js}",
+			"src/entity/**/*.{ts,js}"
+		],
+		alwaysUsed: ["ormconfig.{ts,js,json}"]
+	},
+	{
+		enablers: ["knex"],
+		enablerPrefixes: [],
+		entryPatterns: ["migrations/**/*.{ts,js}", "seeds/**/*.{ts,js}"],
+		alwaysUsed: ["knexfile.{ts,js}"]
+	},
+	{
+		enablers: ["drizzle-orm"],
+		enablerPrefixes: [],
+		entryPatterns: ["drizzle/**/*.{ts,js}"],
+		alwaysUsed: ["drizzle.config.{ts,js,mjs}"]
+	},
+	{
+		enablers: ["kysely"],
+		enablerPrefixes: [],
+		entryPatterns: ["migrations/**/*.{ts,js}", "src/migrations/**/*.{ts,js}"],
+		alwaysUsed: []
+	},
+	{
+		enablers: ["prisma", "@prisma/client"],
+		enablerPrefixes: [],
+		entryPatterns: ["prisma/**/*.{ts,js}", "prisma/seed.{ts,js}"],
+		alwaysUsed: [
+			"prisma/schema.prisma",
+			"schema.prisma",
+			"prisma/schema/*.prisma",
+			"prisma.config.{ts,mts,cts,js,mjs,cjs}",
+			".config/prisma.{ts,mts,cts,js,mjs,cjs}"
+		]
+	},
+	{
+		enablers: ["@nestjs/core"],
+		enablerPrefixes: ["@nestjs/"],
+		entryPatterns: [
+			"src/main.ts",
+			"src/**/*.module.ts",
+			"src/**/*.controller.ts",
+			"src/**/*.service.ts",
+			"src/**/*.guard.ts",
+			"src/**/*.interceptor.ts",
+			"src/**/*.pipe.ts",
+			"src/**/*.filter.ts",
+			"src/**/*.middleware.ts",
+			"src/**/*.decorator.ts",
+			"src/**/*.gateway.ts",
+			"src/**/*.resolver.ts"
+		],
+		alwaysUsed: ["nest-cli.json"]
+	},
+	{
+		enablers: ["wrangler"],
+		enablerPrefixes: ["@cloudflare/"],
+		entryPatterns: [
+			"src/index.{ts,js}",
+			"src/worker.{ts,js}",
+			"functions/**/*.{ts,js}"
+		],
+		alwaysUsed: []
+	},
+	{
+		enablers: ["gatsby"],
+		enablerPrefixes: ["gatsby-"],
+		entryPatterns: [
+			"src/pages/**/*.{ts,tsx,js,jsx}",
+			"src/templates/**/*.{ts,tsx,js,jsx}",
+			"src/api/**/*.{ts,js}"
+		],
+		alwaysUsed: [
+			"gatsby-config.{ts,js,mjs}",
+			"gatsby-node.{ts,js,mjs}",
+			"gatsby-browser.{ts,tsx,js,jsx}",
+			"gatsby-ssr.{ts,tsx,js,jsx}"
+		]
+	},
+	{
+		enablers: ["@angular/core"],
+		enablerPrefixes: ["@angular/"],
+		entryPatterns: [
+			"src/main.ts",
+			"src/app/**/*.ts",
+			"src/environments/**/*.ts",
+			"src/polyfills.ts",
+			"src/test.ts"
+		],
+		alwaysUsed: ["angular.json", "**/karma.conf.js"]
+	},
+	{
+		enablers: ["react-scripts", "react-app-rewired"],
+		enablerPrefixes: [],
+		entryPatterns: ["src/index.{ts,tsx,js,jsx}"],
+		alwaysUsed: [
+			"src/setupTests.{ts,tsx,js,jsx}",
+			"src/reportWebVitals.{ts,tsx,js,jsx}",
+			"src/react-app-env.d.ts"
+		]
+	},
+	{
+		enablers: [
+			"@remix-run/node",
+			"@remix-run/react",
+			"@remix-run/cloudflare",
+			"@react-router/node",
+			"@react-router/serve",
+			"@react-router/dev"
+		],
+		enablerPrefixes: ["@remix-run/", "@react-router/"],
+		entryPatterns: [
+			"app/routes/**/*.{ts,tsx,js,jsx}",
+			"app/root.{ts,tsx,js,jsx}",
+			"app/entry.client.{ts,tsx,js,jsx}",
+			"app/entry.server.{ts,tsx,js,jsx}",
+			"app/routes.{ts,js,mts,mjs}",
+			"src/routes.{ts,js,mts,mjs}"
+		],
+		alwaysUsed: ["react-router.config.{ts,js,mjs}", "remix.config.{ts,js,mjs}"]
+	},
+	{
+		enablers: ["@docusaurus/core"],
+		enablerPrefixes: ["@docusaurus/"],
+		entryPatterns: [
+			"**/*.{md,mdx}",
+			"src/pages/**/*.{ts,tsx,js,jsx}",
+			"src/theme/**/*.{ts,tsx,js,jsx}",
+			"src/theme/**/index.{ts,tsx,js,jsx}",
+			"plugins/**/*.{ts,js,mjs}"
+		],
+		alwaysUsed: [
+			"docusaurus.config.{ts,js,mjs}",
+			"sidebars.{ts,js,mjs,cjs}",
+			"sidebar*.{ts,js,mjs,cjs}",
+			"*-sidebar.{ts,js,mjs,cjs}",
+			"*-sidebars.{ts,js,mjs,cjs}",
+			"*Sidebar*.{ts,js,mjs,cjs}",
+			"*sidebar*.{ts,js,mjs,cjs}"
+		],
+		contentIgnorePatterns: ["versioned_sidebars/**"]
+	},
+	{
+		enablers: ["eslint", "@eslint/js"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["eslint.config.{js,mjs,cjs,ts,mts,cts}", ".eslintrc.{js,cjs,mjs,json,yaml,yml}"]
+	},
+	{
+		enablers: ["prettier"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [".prettierrc.{js,cjs,mjs,json,yaml,yml}", "prettier.config.{js,mjs,cjs,ts}"]
+	},
+	{
+		enablers: ["tailwindcss", "@tailwindcss/postcss"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["tailwind.config.{ts,js,cjs,mjs}"]
+	},
+	{
+		enablers: ["postcss"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["postcss.config.{ts,js,cjs,mjs}"]
+	},
+	{
+		enablers: ["typescript"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["tsconfig.json", "tsconfig.*.json"]
+	},
+	{
+		enablers: ["lint-staged"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [".lintstagedrc.{js,cjs,mjs,json}", "lint-staged.config.{js,mjs,cjs}"]
+	},
+	{
+		enablers: ["husky"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [".husky/**/*"]
+	},
+	{
+		enablers: ["@biomejs/biome"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["biome.json", "biome.jsonc"]
+	},
+	{
+		enablers: ["@commitlint/cli"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["commitlint.config.{js,cjs,mjs,ts}", ".commitlintrc.{js,cjs,mjs,json,yaml,yml}"]
+	},
+	{
+		enablers: ["semantic-release"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [".releaserc.{js,cjs,mjs,json,yaml,yml}", "release.config.{js,cjs,mjs,ts}"]
+	},
+	{
+		enablers: ["@changesets/cli"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [".changeset/**/*"]
+	},
+	{
+		enablers: ["next"],
+		enablerPrefixes: [],
+		entryPatterns: [
+			"app/**/page.{ts,tsx,js,jsx}",
+			"app/**/layout.{ts,tsx,js,jsx}",
+			"app/**/loading.{ts,tsx,js,jsx}",
+			"app/**/error.{ts,tsx,js,jsx}",
+			"app/**/not-found.{ts,tsx,js,jsx}",
+			"app/**/template.{ts,tsx,js,jsx}",
+			"app/**/default.{ts,tsx,js,jsx}",
+			"app/**/route.{ts,tsx,js,jsx}",
+			"app/**/global-error.{ts,tsx,js,jsx}",
+			"app/**/forbidden.{ts,tsx,js,jsx}",
+			"app/**/unauthorized.{ts,tsx,js,jsx}",
+			"app/global-not-found.{ts,tsx,js,jsx}",
+			"app/**/opengraph-image.{ts,tsx,js,jsx}",
+			"app/**/twitter-image.{ts,tsx,js,jsx}",
+			"app/**/icon.{ts,tsx,js,jsx}",
+			"app/**/apple-icon.{ts,tsx,js,jsx}",
+			"app/**/manifest.{ts,tsx,js,jsx}",
+			"app/**/sitemap.{ts,tsx,js,jsx}",
+			"app/**/robots.{ts,tsx,js,jsx}",
+			"pages/**/*.{ts,tsx,js,jsx}",
+			"src/app/**/page.{ts,tsx,js,jsx}",
+			"src/app/**/layout.{ts,tsx,js,jsx}",
+			"src/app/**/loading.{ts,tsx,js,jsx}",
+			"src/app/**/error.{ts,tsx,js,jsx}",
+			"src/app/**/not-found.{ts,tsx,js,jsx}",
+			"src/app/**/template.{ts,tsx,js,jsx}",
+			"src/app/**/default.{ts,tsx,js,jsx}",
+			"src/app/**/route.{ts,tsx,js,jsx}",
+			"src/app/**/global-error.{ts,tsx,js,jsx}",
+			"src/app/**/forbidden.{ts,tsx,js,jsx}",
+			"src/app/**/unauthorized.{ts,tsx,js,jsx}",
+			"src/app/global-not-found.{ts,tsx,js,jsx}",
+			"src/app/**/opengraph-image.{ts,tsx,js,jsx}",
+			"src/app/**/twitter-image.{ts,tsx,js,jsx}",
+			"src/app/**/icon.{ts,tsx,js,jsx}",
+			"src/app/**/apple-icon.{ts,tsx,js,jsx}",
+			"src/app/**/manifest.{ts,tsx,js,jsx}",
+			"src/app/**/sitemap.{ts,tsx,js,jsx}",
+			"src/app/**/robots.{ts,tsx,js,jsx}",
+			"src/pages/**/*.{ts,tsx,js,jsx}",
+			"middleware.{ts,js}",
+			"src/middleware.{ts,js}",
+			"proxy.{ts,js}",
+			"src/proxy.{ts,js}",
+			"instrumentation.{ts,js}",
+			"instrumentation-client.{ts,js}",
+			"src/instrumentation.{ts,js}",
+			"src/instrumentation-client.{ts,js}"
+		],
+		alwaysUsed: [
+			"next.config.{ts,js,mjs,mts}",
+			"next-env.d.ts",
+			"mdx-components.{ts,tsx,js,jsx}",
+			"src/mdx-components.{ts,tsx,js,jsx}",
+			"src/i18n/request.{ts,js}",
+			"src/i18n/routing.{ts,js}",
+			"i18n/request.{ts,js}",
+			"i18n/routing.{ts,js}"
+		]
+	},
+	{
+		enablers: [
+			"@tanstack/react-router",
+			"@tanstack/react-start",
+			"@tanstack/start",
+			"@tanstack/solid-router",
+			"@tanstack/solid-start"
+		],
+		enablerPrefixes: ["@tanstack/router"],
+		entryPatterns: [
+			"src/routes/**/*.{ts,tsx,js,jsx}",
+			"app/routes/**/*.{ts,tsx,js,jsx}",
+			"src/server.{ts,tsx,js,jsx}",
+			"src/client.{ts,tsx,js,jsx}",
+			"src/router.{ts,tsx,js,jsx}",
+			"src/routeTree.gen.{ts,js}"
+		],
+		alwaysUsed: ["tsr.config.json", "app.config.{ts,js}"]
+	},
+	{
+		enablers: ["vite", "rolldown-vite"],
+		enablerPrefixes: ["@vitejs/"],
+		entryPatterns: [
+			"src/main.{ts,tsx,js,jsx}",
+			"src/index.{ts,tsx,js,jsx}",
+			"index.html"
+		],
+		alwaysUsed: ["vite.config.{ts,js,mts,mjs}"]
+	},
+	{
+		enablers: ["vue", "@vue/cli-service"],
+		enablerPrefixes: ["@vue/"],
+		entryPatterns: ["src/main.{ts,js}", "src/App.vue"],
+		alwaysUsed: ["vue.config.{ts,js,mjs,cjs}"]
+	},
+	{
+		enablers: ["nuxt", "nuxt3"],
+		enablerPrefixes: ["@nuxt/"],
+		entryPatterns: [
+			"pages/**/*.vue",
+			"layouts/**/*.vue",
+			"components/**/*.vue",
+			"composables/**/*.{ts,js}",
+			"plugins/**/*.{ts,js}",
+			"middleware/**/*.{ts,js}",
+			"server/**/*.{ts,js}",
+			"app.vue"
+		],
+		alwaysUsed: ["nuxt.config.{ts,js,mjs}"]
+	},
+	{
+		enablers: ["svelte", "@sveltejs/kit"],
+		enablerPrefixes: ["@sveltejs/"],
+		entryPatterns: [
+			"src/routes/**/*.svelte",
+			"src/lib/**/*.svelte",
+			"src/routes/**/+page.{ts,js,svelte}",
+			"src/routes/**/+layout.{ts,js,svelte}",
+			"src/routes/**/+server.{ts,js}"
+		],
+		alwaysUsed: ["svelte.config.{ts,js,mjs}"]
+	},
+	{
+		enablers: ["webpack", "webpack-cli"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["webpack.config.{ts,js,mjs,cjs}", "webpack.*.config.{ts,js,mjs,cjs}"]
+	},
+	{
+		enablers: ["rollup"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["rollup.config.{ts,js,mjs,cjs}", "rollup.*.config.{ts,js,mjs,cjs}"]
+	},
+	{
+		enablers: ["@rspack/core", "@rspack/cli"],
+		enablerPrefixes: ["@rspack/"],
+		entryPatterns: ["src/index.{ts,tsx,js,jsx}"],
+		alwaysUsed: ["rspack.config.{ts,js,mjs,cjs}", "rspack.*.config.{ts,js,mjs,cjs}"]
+	},
+	{
+		enablers: ["@rsbuild/core"],
+		enablerPrefixes: ["@rsbuild/"],
+		entryPatterns: ["src/index.{ts,tsx,js,jsx}"],
+		alwaysUsed: ["rsbuild.config.{ts,js,mjs,cjs}"]
+	},
+	{
+		enablers: ["tsup"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["tsup.config.{ts,js,cjs,mjs}"]
+	},
+	{
+		enablers: ["tsdown"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["tsdown.config.{ts,js,cjs,mjs}"]
+	},
+	{
+		enablers: ["@trigger.dev/sdk"],
+		enablerPrefixes: ["@trigger.dev/"],
+		entryPatterns: [],
+		alwaysUsed: ["trigger.config.{ts,js,mjs,mts}"]
+	},
+	{
+		enablers: ["@swc/core"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [".swcrc"]
+	},
+	{
+		enablers: ["@babel/core"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["babel.config.{js,cjs,mjs,json}", ".babelrc.{js,cjs,mjs,json}"]
+	},
+	{
+		enablers: ["sanity", "@sanity/cli"],
+		enablerPrefixes: ["@sanity/"],
+		entryPatterns: [],
+		alwaysUsed: ["sanity.config.{ts,js}", "sanity.cli.{ts,js}"]
+	},
+	{
+		enablers: ["astro"],
+		enablerPrefixes: ["@astrojs/"],
+		entryPatterns: [
+			"src/pages/**/*.{astro,ts,tsx,js,jsx,mts,mjs,cts,cjs,md,mdx}",
+			"src/content/**/*.{ts,js,mts,mjs,cts,cjs,md,mdx}",
+			"src/layouts/**/*.astro",
+			"src/middleware.{js,ts,mjs,mts,cjs,cts}",
+			"src/middleware/index.{js,ts,mjs,mts,cjs,cts}",
+			"src/actions/index.{js,ts,mjs,mts,cjs,cts}"
+		],
+		alwaysUsed: [
+			"astro.config.{ts,js,mjs,cjs}",
+			"src/content/config.{js,ts,mjs,mts,cjs,cts}",
+			"src/content.config.{js,ts,mjs,mts,cjs,cts}"
+		]
+	},
+	{
+		enablers: [
+			"i18next",
+			"react-i18next",
+			"vue-i18n",
+			"next-i18next"
+		],
+		enablerPrefixes: [],
+		entryPatterns: [
+			"src/i18n.{ts,js,mjs}",
+			"src/i18n/index.{ts,js}",
+			"i18n.{ts,js,mjs}",
+			"i18n/index.{ts,js}"
+		],
+		alwaysUsed: [
+			"src/i18n.{ts,js,mjs}",
+			"src/i18n/index.{ts,js}",
+			"i18n.{ts,js,mjs}",
+			"i18n/index.{ts,js}",
+			"i18next.config.{js,ts,mjs}",
+			"next-i18next.config.{js,mjs}",
+			"locales/**/*.json",
+			"public/locales/**/*.json",
+			"src/locales/**/*.json"
+		]
+	},
+	{
+		enablers: ["turbo"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: ["turbo.json", "turbo/generators/config.{ts,js}"]
+	},
+	{
+		enablers: [
+			"@sentry/nextjs",
+			"@sentry/react",
+			"@sentry/node",
+			"@sentry/browser"
+		],
+		enablerPrefixes: ["@sentry/"],
+		entryPatterns: [],
+		alwaysUsed: [
+			"sentry.client.config.{ts,js,mjs}",
+			"sentry.server.config.{ts,js,mjs}",
+			"sentry.edge.config.{ts,js,mjs}"
+		]
+	},
+	{
+		enablers: ["nodemon"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [
+			"nodemon.json",
+			".nodemonrc",
+			".nodemonrc.{json,yml,yaml}"
+		]
+	},
+	{
+		enablers: ["nx"],
+		enablerPrefixes: ["@nx/"],
+		entryPatterns: [],
+		alwaysUsed: ["nx.json", "**/project.json"]
+	},
+	{
+		enablers: ["react-native"],
+		enablerPrefixes: ["@react-native/", "@react-native-community/"],
+		entryPatterns: [
+			"index.{ts,tsx,js,jsx}",
+			"App.{ts,tsx,js,jsx}",
+			"src/App.{ts,tsx,js,jsx}"
+		],
+		alwaysUsed: [
+			"metro.config.{ts,js}",
+			"react-native.config.{ts,js}",
+			"app.json"
+		]
+	},
+	{
+		enablers: ["expo"],
+		enablerPrefixes: ["@expo/"],
+		entryPatterns: [
+			"App.{ts,tsx,js,jsx}",
+			"app/_layout.{ts,tsx,js,jsx}",
+			"app/index.{ts,tsx,js,jsx}"
+		],
+		alwaysUsed: ["app.json", "app.config.{ts,js}"]
+	},
+	{
+		enablers: ["wrangler"],
+		enablerPrefixes: ["@cloudflare/"],
+		entryPatterns: [
+			"src/index.{ts,js}",
+			"src/worker.{ts,js}",
+			"functions/**/*.{ts,js}"
+		],
+		alwaysUsed: [
+			"wrangler.toml",
+			"wrangler.json",
+			"wrangler.jsonc"
+		]
+	},
+	{
+		enablers: [
+			"electron",
+			"electron-builder",
+			"@electron-forge/cli",
+			"electron-vite",
+			"electron-webpack"
+		],
+		enablerPrefixes: ["@electron-forge/", "@electron/"],
+		entryPatterns: [
+			"src/main/**/*.{ts,tsx,js,jsx}",
+			"src/preload/**/*.{ts,tsx,js,jsx}",
+			"electron/main.{ts,js}"
+		],
+		alwaysUsed: [
+			"electron-builder.{yml,yaml,json,json5,toml}",
+			"forge.config.{ts,js,cjs}",
+			"electron.vite.config.{ts,js,mjs}"
+		]
+	},
+	{
+		enablers: ["lefthook"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [
+			"lefthook.yml",
+			"lefthook.yaml",
+			".lefthook.yml"
+		]
+	},
+	{
+		enablers: ["syncpack"],
+		enablerPrefixes: [],
+		entryPatterns: [],
+		alwaysUsed: [
+			".syncpackrc",
+			".syncpackrc.{json,yaml,yml}",
+			"syncpack.config.{js,mjs,cjs}"
+		]
+	},
+	{
+		enablers: ["@capacitor/core", "@capacitor/cli"],
+		enablerPrefixes: ["@capacitor/"],
+		entryPatterns: [],
+		alwaysUsed: ["capacitor.config.{ts,js,json}"]
+	}
+];
+const detectNodeTestRunner = (directory) => {
+	try {
+		const packageJsonPath = join(directory, "package.json");
+		if (!existsSync(packageJsonPath)) return false;
+		const content = readFileSync(packageJsonPath, "utf-8");
+		const scripts = JSON.parse(content).scripts ?? {};
+		return Object.values(scripts).some((scriptValue) => typeof scriptValue === "string" && /\bnode\b.*\s--test\b/.test(scriptValue));
+	} catch {
+		return false;
+	}
+};
+const detectBunTestRunner = (directory) => {
+	try {
+		const packageJsonPath = join(directory, "package.json");
+		if (!existsSync(packageJsonPath)) return false;
+		const content = readFileSync(packageJsonPath, "utf-8");
+		const scripts = JSON.parse(content).scripts ?? {};
+		return Object.values(scripts).some((scriptValue) => typeof scriptValue === "string" && /\bbun\s+test\b/.test(scriptValue));
+	} catch {
+		return false;
+	}
+};
+const discoverTestRunnerEntryPoints = (rootDir, workspacePackages) => {
+	const allEntries = [];
+	const allAlwaysUsed = [];
+	const directoriesToCheck = [rootDir, ...workspacePackages.map((workspacePackage) => workspacePackage.directory)];
+	for (const directory of directoriesToCheck) {
+		const packageJsonPath = join(directory, "package.json");
+		if (!existsSync(packageJsonPath)) continue;
+		let allDependencies = {};
+		try {
+			const content = readFileSync(packageJsonPath, "utf-8");
+			const packageJson = JSON.parse(content);
+			allDependencies = {
+				...packageJson.dependencies,
+				...packageJson.devDependencies,
+				...packageJson.optionalDependencies
+			};
+		} catch {
+			continue;
+		}
+		const activatedPatterns = [];
+		const activatedFixturePatterns = [];
+		const activatedAlwaysUsed = [];
+		const isRunnerEnabled = (runner, dependencies, checkDirectory) => {
+			if (runner.enablers.some((enabler) => {
+				return enabler in dependencies;
+			})) return true;
+			return runner.configFileActivators.some((configFile) => existsSync(join(checkDirectory, configFile)));
+		};
+		for (const runner of TEST_RUNNER_DEFINITIONS) if (isRunnerEnabled(runner, allDependencies, directory)) {
+			const isVitestRunner = runner.enablers.includes("vitest");
+			const isJestRunner = runner.enablers.includes("jest");
+			let customPatterns = [];
+			if (isVitestRunner) customPatterns = extractVitestIncludePatterns(directory);
+			else if (isJestRunner) customPatterns = extractJestTestMatchPatterns(directory);
+			if (customPatterns.length > 0) activatedPatterns.push(...customPatterns);
+			else activatedPatterns.push(...runner.entryPatterns);
+			activatedFixturePatterns.push(...runner.fixturePatterns);
+			activatedAlwaysUsed.push(...runner.alwaysUsed);
+		}
+		if (activatedPatterns.length === 0 && directory !== rootDir) {
+			const rootPackageJsonPath = join(rootDir, "package.json");
+			if (existsSync(rootPackageJsonPath)) try {
+				const rootContent = readFileSync(rootPackageJsonPath, "utf-8");
+				const rootPackageJson = JSON.parse(rootContent);
+				const rootDeps = {
+					...rootPackageJson.dependencies,
+					...rootPackageJson.devDependencies,
+					...rootPackageJson.optionalDependencies
+				};
+				for (const runner of TEST_RUNNER_DEFINITIONS) if (isRunnerEnabled(runner, rootDeps, rootDir)) {
+					activatedPatterns.push(...runner.entryPatterns);
+					activatedFixturePatterns.push(...runner.fixturePatterns);
+					activatedAlwaysUsed.push(...runner.alwaysUsed);
+				}
+			} catch {}
+		}
+		if (detectNodeTestRunner(directory) || detectNodeTestRunner(rootDir)) activatedPatterns.push("**/*.test.{ts,tsx,js,jsx,mts,mjs,cts,cjs}", "**/*.spec.{ts,tsx,js,jsx,mts,mjs,cts,cjs}", "**/__tests__/**/*.{ts,tsx,js,jsx,mts,mjs,cts,cjs}");
+		if (detectBunTestRunner(directory) || detectBunTestRunner(rootDir)) activatedPatterns.push("**/*.test.{ts,tsx,js,jsx,mts,mjs}", "**/*.spec.{ts,tsx,js,jsx,mts,mjs}", "**/*_test.{ts,tsx,js,jsx,mts,mjs}", "**/*_spec.{ts,tsx,js,jsx,mts,mjs}", "**/__tests__/**/*.{ts,tsx,js,jsx,mts,mjs}");
+		if (activatedPatterns.length === 0) continue;
+		const uniquePatterns = [...new Set(activatedPatterns)];
+		const testFiles = fg.sync(uniquePatterns, {
+			cwd: directory,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**", "**/*.gen.{ts,tsx,js,jsx}"]
+		});
+		allEntries.push(...testFiles);
+		const uniqueFixturePatterns = [...new Set(activatedFixturePatterns)];
+		if (uniqueFixturePatterns.length > 0) {
+			const fixtureFiles = fg.sync(uniqueFixturePatterns, {
+				cwd: directory,
+				absolute: true,
+				onlyFiles: true,
+				ignore: ["**/node_modules/**"]
+			});
+			allEntries.push(...fixtureFiles);
+		}
+		const uniqueAlwaysUsed = [...new Set(activatedAlwaysUsed)];
+		if (uniqueAlwaysUsed.length > 0) {
+			const alwaysUsedFiles = fg.sync(uniqueAlwaysUsed, {
+				cwd: directory,
+				absolute: true,
+				onlyFiles: true,
+				ignore: ["**/node_modules/**"],
+				dot: true
+			});
+			allAlwaysUsed.push(...alwaysUsedFiles);
+		}
+	}
+	return {
+		entryFiles: allEntries,
+		alwaysUsedFiles: allAlwaysUsed
+	};
+};
+const isToolingPluginEnabled = (plugin, dependencies) => {
+	if (plugin.enablers.some((enabler) => enabler in dependencies)) return true;
+	if (plugin.enablerPrefixes.length > 0) {
+		const depNames = Object.keys(dependencies);
+		return plugin.enablerPrefixes.some((prefix) => depNames.some((depName) => depName.startsWith(prefix)));
+	}
+	return false;
+};
+const discoverToolingEntryPoints = (rootDir, workspacePackages) => {
+	const allEntries = [];
+	const allAlwaysUsed = [];
+	const directoriesToCheck = [rootDir, ...workspacePackages.map((workspacePackage) => workspacePackage.directory)];
+	let rootDependencies = {};
+	const rootPackageJsonPath = join(rootDir, "package.json");
+	if (existsSync(rootPackageJsonPath)) try {
+		const rootContent = readFileSync(rootPackageJsonPath, "utf-8");
+		const rootPackageJson = JSON.parse(rootContent);
+		rootDependencies = {
+			...rootPackageJson.dependencies,
+			...rootPackageJson.devDependencies,
+			...rootPackageJson.optionalDependencies
+		};
+	} catch {}
+	for (const directory of directoriesToCheck) {
+		const packageJsonPath = join(directory, "package.json");
+		if (!existsSync(packageJsonPath)) continue;
+		let workspaceDependencies = {};
+		try {
+			const content = readFileSync(packageJsonPath, "utf-8");
+			const packageJson = JSON.parse(content);
+			workspaceDependencies = {
+				...packageJson.dependencies,
+				...packageJson.devDependencies,
+				...packageJson.optionalDependencies
+			};
+		} catch {
+			continue;
+		}
+		const mergedDependencies = directory === rootDir ? rootDependencies : workspaceDependencies;
+		const activatedPatterns = [];
+		const activatedAlwaysUsed = [];
+		for (const plugin of TOOLING_PLUGIN_DEFINITIONS) if (isToolingPluginEnabled(plugin, mergedDependencies)) {
+			activatedPatterns.push(...plugin.entryPatterns);
+			activatedAlwaysUsed.push(...plugin.alwaysUsed);
+		}
+		if (activatedPatterns.length === 0 && activatedAlwaysUsed.length === 0) continue;
+		const uniquePatterns = [...new Set(activatedPatterns)];
+		const toolingFiles = fg.sync(uniquePatterns, {
+			cwd: directory,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"],
+			dot: true
+		});
+		allEntries.push(...toolingFiles);
+		const uniqueAlwaysUsed = [...new Set(activatedAlwaysUsed)];
+		if (uniqueAlwaysUsed.length > 0) {
+			const alwaysUsedFiles = fg.sync(uniqueAlwaysUsed, {
+				cwd: directory,
+				absolute: true,
+				onlyFiles: true,
+				ignore: ["**/node_modules/**"],
+				dot: true
+			});
+			allAlwaysUsed.push(...alwaysUsedFiles);
+		}
+	}
+	const rootActivatedGlobalPatterns = [];
+	for (const plugin of TOOLING_PLUGIN_DEFINITIONS) if (isToolingPluginEnabled(plugin, rootDependencies)) {
+		for (const pattern of plugin.alwaysUsed) if (!pattern.startsWith("**/")) rootActivatedGlobalPatterns.push(`**/${pattern}`);
+	}
+	if (rootActivatedGlobalPatterns.length > 0) {
+		const globalAlwaysUsedFiles = fg.sync([...new Set(rootActivatedGlobalPatterns)], {
+			cwd: rootDir,
+			absolute: true,
+			onlyFiles: true,
+			ignore: ["**/node_modules/**"],
+			dot: true
+		});
+		allAlwaysUsed.push(...globalAlwaysUsedFiles);
+	}
+	return {
+		entryFiles: allEntries,
+		alwaysUsedFiles: allAlwaysUsed
+	};
+};
+
+//#endregion
+//#region src/resolver/resolve.ts
+const fileExistsCache = /* @__PURE__ */ new Map();
+const pathExistsCache = /* @__PURE__ */ new Map();
+const fileContentCache = /* @__PURE__ */ new Map();
+const cachedReadFileSync = (filePath) => {
+	const cached = fileContentCache.get(filePath);
+	if (cached !== void 0) return cached;
+	const content = readFileSync(filePath, "utf-8");
+	fileContentCache.set(filePath, content);
+	return content;
+};
+const cachedExistsSync = (targetPath) => {
+	const cached = pathExistsCache.get(targetPath);
+	if (cached !== void 0) return cached;
+	const result = existsSync(targetPath);
+	pathExistsCache.set(targetPath, result);
+	return result;
+};
+const existsAsFile = (filePath) => {
+	const cached = fileExistsCache.get(filePath);
+	if (cached !== void 0) return cached;
+	try {
+		const result = cachedExistsSync(filePath) && statSync(filePath).isFile();
+		fileExistsCache.set(filePath, result);
+		return result;
+	} catch {
+		fileExistsCache.set(filePath, false);
+		return false;
+	}
+};
+const trySourceFallback = (resolvedPath) => {
+	const segments = resolvedPath.split(sep);
+	const isOutputDirectory = (segment) => OUTPUT_DIRECTORIES.some((outputDirectory) => segment === outputDirectory || segment.startsWith(`${outputDirectory}-`));
+	let lastOutputPosition = -1;
+	for (let index = segments.length - 1; index >= 0; index--) if (isOutputDirectory(segments[index])) {
+		lastOutputPosition = index;
+		break;
+	}
+	if (lastOutputPosition === -1) return void 0;
+	let firstOutputPosition = lastOutputPosition;
+	while (firstOutputPosition > 0 && isOutputDirectory(segments[firstOutputPosition - 1])) firstOutputPosition--;
+	const prefix = segments.slice(0, firstOutputPosition).join(sep);
+	const suffix = segments.slice(lastOutputPosition + 1).join(sep);
+	if (!suffix) return void 0;
+	const fileExtension = extname(basename(suffix));
+	const stemmedSuffix = fileExtension ? suffix.slice(0, suffix.length - fileExtension.length) : suffix;
+	for (const sourceExtension of SOURCE_EXTENSIONS$3) {
+		const sourceCandidate = join(prefix, "src", `${stemmedSuffix}.${sourceExtension}`);
+		if (existsAsFile(sourceCandidate)) return sourceCandidate;
+	}
+};
+const resolvePathWithExtensionFallback = (candidatePath) => {
+	if (existsAsFile(candidatePath)) return candidatePath;
+	for (const extension of RESOLVER_EXTENSIONS) {
+		const withExtension = candidatePath + extension;
+		if (existsAsFile(withExtension)) return withExtension;
+	}
+	for (const extension of RESOLVER_EXTENSIONS) {
+		const indexCandidate = join(candidatePath, `index${extension}`);
+		if (existsAsFile(indexCandidate)) return indexCandidate;
+	}
+	return candidatePath;
+};
+const COMMON_RESOLVER_OPTIONS = {
+	conditionNames: [
+		"import",
+		"require",
+		"node",
+		"default"
+	],
+	extensions: RESOLVER_EXTENSIONS,
+	mainFields: [
+		"module",
+		"main",
+		"browser"
+	],
+	extensionAlias: {
+		".js": [
+			".ts",
+			".tsx",
+			".js",
+			".jsx"
+		],
+		".jsx": [".tsx", ".jsx"],
+		".mjs": [".mts", ".mjs"],
+		".cjs": [".cts", ".cjs"]
+	}
+};
+const TSCONFIG_FILENAMES = [
+	"tsconfig.json",
+	"tsconfig.web.json",
+	"tsconfig.app.json",
+	"tsconfig.base.json"
+];
+const findNearestTsconfig = (fromDir, rootDir) => {
+	let currentDirectory = fromDir;
+	const normalizedRoot = resolve(rootDir);
+	while (currentDirectory.length >= normalizedRoot.length) {
+		for (const tsconfigFilename of TSCONFIG_FILENAMES) {
+			const tsconfigCandidate = join(currentDirectory, tsconfigFilename);
+			if (cachedExistsSync(tsconfigCandidate)) return tsconfigCandidate;
+		}
+		const parentDirectory = dirname(currentDirectory);
+		if (parentDirectory === currentDirectory) break;
+		currentDirectory = parentDirectory;
+	}
+};
+const STYLE_FILE_EXTENSIONS = [
+	".css",
+	".scss",
+	".less",
+	".sass"
+];
+const SCSS_PARTIAL_EXTENSIONS = [
+	".scss",
+	".sass",
+	".css"
+];
+const resolveScssPartial = (specifier, fromDirectory) => {
+	const basePath = resolve(fromDirectory, specifier);
+	const baseDirectory = dirname(basePath);
+	const baseFileName = basePath.split("/").pop() ?? "";
+	const candidates = [];
+	for (const extension of SCSS_PARTIAL_EXTENSIONS) if (!basePath.endsWith(extension)) {
+		candidates.push(`${basePath}${extension}`);
+		candidates.push(join(baseDirectory, `_${baseFileName}${extension}`));
+	} else {
+		candidates.push(basePath);
+		candidates.push(join(baseDirectory, `_${baseFileName}`));
+	}
+	candidates.push(join(basePath, `index.scss`));
+	candidates.push(join(basePath, `_index.scss`));
+	candidates.push(join(basePath, `index.sass`));
+	candidates.push(join(basePath, `_index.sass`));
+	for (const candidate of candidates) if (cachedExistsSync(candidate)) return candidate;
+};
+const createModuleResolver = (config, workspacePackages = [], options = {}) => {
+	const resolverCache = /* @__PURE__ */ new Map();
+	const resolveResultCache = /* @__PURE__ */ new Map();
+	const failedTsconfigPaths = /* @__PURE__ */ new Set();
+	const resolverExtensions = options.hasReactNative ? [...REACT_NATIVE_PLATFORM_EXTENSIONS, ...RESOLVER_EXTENSIONS] : RESOLVER_EXTENSIONS;
+	const resolverOptions = {
+		...COMMON_RESOLVER_OPTIONS,
+		extensions: resolverExtensions
+	};
+	const getOrCreateResolver = (tsconfigPath) => {
+		const effectivePath = tsconfigPath && !failedTsconfigPaths.has(tsconfigPath) ? tsconfigPath : void 0;
+		const cacheKey = effectivePath ?? "__no_tsconfig__";
+		const existingResolver = resolverCache.get(cacheKey);
+		if (existingResolver) return existingResolver;
+		try {
+			const newResolver = new ResolverFactory({
+				...resolverOptions,
+				tsconfig: effectivePath ? {
+					configFile: effectivePath,
+					references: "auto"
+				} : void 0
+			});
+			resolverCache.set(cacheKey, newResolver);
+			return newResolver;
+		} catch {
+			if (effectivePath) {
+				failedTsconfigPaths.add(effectivePath);
+				return getOrCreateResolver(void 0);
+			}
+			const fallbackResolver = new ResolverFactory(COMMON_RESOLVER_OPTIONS);
+			resolverCache.set(cacheKey, fallbackResolver);
+			return fallbackResolver;
+		}
+	};
+	const workspaceNameToDirectory = /* @__PURE__ */ new Map();
+	for (const workspacePackage of workspacePackages) workspaceNameToDirectory.set(workspacePackage.name, workspacePackage.directory);
+	let rootTsconfigPath;
+	if (config.tsConfigPath) rootTsconfigPath = resolve(config.rootDir, config.tsConfigPath);
+	else for (const candidate of [
+		"tsconfig.json",
+		"tsconfig.web.json",
+		"tsconfig.app.json",
+		"tsconfig.base.json"
+	]) {
+		const candidatePath = resolve(config.rootDir, candidate);
+		if (cachedExistsSync(candidatePath)) {
+			rootTsconfigPath = candidatePath;
+			break;
+		}
+	}
+	const tsconfigPathCache = /* @__PURE__ */ new Map();
+	const tsconfigPathAliasCache = /* @__PURE__ */ new Map();
+	const findTsconfigForFile = (filePath) => {
+		const fileDir = dirname(filePath);
+		const cached = tsconfigPathCache.get(fileDir);
+		if (cached !== void 0) return cached;
+		const tsconfigResult = findNearestTsconfig(fileDir, config.rootDir) ?? rootTsconfigPath;
+		tsconfigPathCache.set(fileDir, tsconfigResult);
+		return tsconfigResult;
+	};
+	const tsconfigBaseUrlCache = /* @__PURE__ */ new Map();
+	const getBaseUrlDirectory = (tsconfigFile) => {
+		const cached = tsconfigBaseUrlCache.get(tsconfigFile);
+		if (cached !== void 0) return cached;
+		try {
+			const cleanedContent = stripJsonComments(cachedReadFileSync(tsconfigFile));
+			const baseUrl = JSON.parse(cleanedContent).compilerOptions?.baseUrl;
+			if (baseUrl) {
+				const absoluteBaseUrl = resolve(dirname(tsconfigFile), baseUrl);
+				tsconfigBaseUrlCache.set(tsconfigFile, absoluteBaseUrl);
+				return absoluteBaseUrl;
+			}
+		} catch {}
+		tsconfigBaseUrlCache.set(tsconfigFile, void 0);
+	};
+	const hasNextJsDependency = (() => {
+		try {
+			const rootPackageJson = JSON.parse(cachedReadFileSync(resolve(config.rootDir, "package.json")));
+			return "next" in {
+				...rootPackageJson.dependencies,
+				...rootPackageJson.devDependencies
+			};
+		} catch {
+			return false;
+		}
+	})();
+	const getPathAliases = (tsconfigFile) => {
+		const cached = tsconfigPathAliasCache.get(tsconfigFile);
+		if (cached) return cached;
+		const aliasMap = /* @__PURE__ */ new Map();
+		const tsconfigDir = dirname(tsconfigFile);
+		try {
+			const tsconfigContent = cachedReadFileSync(tsconfigFile).trim();
+			if (tsconfigContent.length > 0) {
+				const cleanedContent = stripJsonComments(tsconfigContent);
+				const tsconfigJson = JSON.parse(cleanedContent);
+				const paths = tsconfigJson.compilerOptions?.paths;
+				const baseUrl = tsconfigJson.compilerOptions?.baseUrl ?? ".";
+				if (paths && typeof paths === "object") {
+					for (const [pattern, targets] of Object.entries(paths)) if (Array.isArray(targets)) aliasMap.set(pattern, targets.map((target) => resolve(tsconfigDir, baseUrl, target)));
+				}
+			}
+		} catch {}
+		if (aliasMap.size === 0 && hasNextJsDependency) if (cachedExistsSync(resolve(tsconfigDir, "src"))) aliasMap.set("@/*", [resolve(tsconfigDir, "src/*")]);
+		else aliasMap.set("@/*", [resolve(tsconfigDir, "*")]);
+		tsconfigPathAliasCache.set(tsconfigFile, aliasMap);
+		return aliasMap;
+	};
+	const tryResolveViaPathAlias = (specifier, fromFile) => {
+		const tsconfigFile = findTsconfigForFile(fromFile);
+		if (!tsconfigFile) return void 0;
+		const aliases = getPathAliases(tsconfigFile);
+		for (const [pattern, targetPatterns] of aliases) {
+			const wildcardIndex = pattern.indexOf("*");
+			if (wildcardIndex === -1) {
+				if (specifier === pattern) for (const targetPattern of targetPatterns) {
+					const candidate = targetPattern.replace("*", "");
+					if (existsAsFile(candidate)) return candidate;
+					for (const ext of RESOLVER_EXTENSIONS) if (cachedExistsSync(candidate + ext)) return candidate + ext;
+					const indexCandidate = join(candidate, "index");
+					for (const ext of RESOLVER_EXTENSIONS) if (cachedExistsSync(indexCandidate + ext)) return indexCandidate + ext;
+				}
+				continue;
+			}
+			const prefix = pattern.slice(0, wildcardIndex);
+			const suffix = pattern.slice(wildcardIndex + 1);
+			if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix)) continue;
+			const matchedWildcard = specifier.slice(prefix.length, specifier.length - suffix.length);
+			for (const targetPattern of targetPatterns) {
+				const resolvedTarget = targetPattern.replace("*", matchedWildcard);
+				if (existsAsFile(resolvedTarget)) return resolvedTarget;
+				for (const ext of RESOLVER_EXTENSIONS) if (cachedExistsSync(resolvedTarget + ext)) return resolvedTarget + ext;
+				const strippedTarget = resolvedTarget.replace(/\.[cm]?js$/, "");
+				if (strippedTarget !== resolvedTarget) {
+					for (const ext of RESOLVER_EXTENSIONS) if (cachedExistsSync(strippedTarget + ext)) return strippedTarget + ext;
+				}
+				const indexCandidate = join(resolvedTarget, "index");
+				for (const ext of RESOLVER_EXTENSIONS) if (cachedExistsSync(indexCandidate + ext)) return indexCandidate + ext;
+			}
+		}
+	};
+	const resolveModule = (specifier, fromFile) => {
+		const queryIndex = specifier.indexOf("?");
+		const cleanedSpecifier = queryIndex !== -1 ? specifier.slice(0, queryIndex) : specifier;
+		const fromDir = dirname(fromFile);
+		const cacheKey = `${fromDir}::${cleanedSpecifier}`;
+		const cached = resolveResultCache.get(cacheKey);
+		if (cached) return cached;
+		if (isBuiltinModule(cleanedSpecifier)) {
+			const resolvedResult = {
+				resolvedPath: void 0,
+				isExternal: true,
+				packageName: cleanedSpecifier.startsWith("node:") ? cleanedSpecifier.slice(5) : cleanedSpecifier
+			};
+			resolveResultCache.set(cacheKey, resolvedResult);
+			return resolvedResult;
+		}
+		if (STYLE_FILE_EXTENSIONS.some((extension) => fromFile.endsWith(extension)) && isBareSpecifier(cleanedSpecifier)) {
+			const scssResolved = resolveScssPartial(cleanedSpecifier, fromDir);
+			if (scssResolved) {
+				const resolvedResult = {
+					resolvedPath: scssResolved,
+					isExternal: false,
+					packageName: void 0
+				};
+				resolveResultCache.set(cacheKey, resolvedResult);
+				return resolvedResult;
+			}
+		}
+		if (isBareSpecifier(cleanedSpecifier) && workspaceNameToDirectory.size > 0) {
+			const packageName = extractPackageNameFromSpecifier(cleanedSpecifier);
+			const workspaceDirectory = workspaceNameToDirectory.get(packageName);
+			if (workspaceDirectory) {
+				const subpath = cleanedSpecifier.slice(packageName.length + 1);
+				const workspacePackageJsonPath = join(workspaceDirectory, "package.json");
+				try {
+					const workspacePackageContent = cachedReadFileSync(workspacePackageJsonPath);
+					const workspacePackageJson = JSON.parse(workspacePackageContent);
+					let resolvedEntryPath;
+					if (subpath && workspacePackageJson.exports) {
+						const exportKey = `./${subpath}`;
+						const exportValue = workspacePackageJson.exports[exportKey];
+						if (typeof exportValue === "string") {
+							const candidatePath = resolvePathWithExtensionFallback(resolve(workspaceDirectory, exportValue));
+							resolvedEntryPath = existsAsFile(candidatePath) ? candidatePath : trySourceFallback(candidatePath);
+						} else if (typeof exportValue === "object" && exportValue !== null) {
+							const conditionValue = exportValue.import ?? exportValue.require ?? exportValue.default ?? exportValue.types;
+							if (typeof conditionValue === "string") {
+								const candidatePath = resolvePathWithExtensionFallback(resolve(workspaceDirectory, conditionValue));
+								resolvedEntryPath = existsAsFile(candidatePath) ? candidatePath : trySourceFallback(candidatePath);
+							}
+						}
+						if (!resolvedEntryPath) for (const [wildcardPattern, wildcardTarget] of Object.entries(workspacePackageJson.exports)) {
+							if (typeof wildcardPattern !== "string" || !wildcardPattern.includes("*")) continue;
+							const wildcardTargetRecord = typeof wildcardTarget === "object" && wildcardTarget !== null ? wildcardTarget : void 0;
+							const wildcardTargetValue = typeof wildcardTarget === "string" ? wildcardTarget : wildcardTargetRecord ? String(wildcardTargetRecord["import"] ?? wildcardTargetRecord["require"] ?? wildcardTargetRecord["default"] ?? wildcardTargetRecord["types"] ?? "") : void 0;
+							if (typeof wildcardTargetValue !== "string") continue;
+							const wildcardPrefix = wildcardPattern.slice(0, wildcardPattern.indexOf("*"));
+							const wildcardSuffix = wildcardPattern.slice(wildcardPattern.indexOf("*") + 1);
+							if (exportKey.startsWith(wildcardPrefix) && exportKey.endsWith(wildcardSuffix)) {
+								const matchedSegment = exportKey.slice(wildcardPrefix.length, exportKey.length - wildcardSuffix.length || void 0);
+								const candidatePath = resolvePathWithExtensionFallback(resolve(workspaceDirectory, wildcardTargetValue.replace("*", matchedSegment)));
+								resolvedEntryPath = existsAsFile(candidatePath) ? candidatePath : trySourceFallback(candidatePath);
+								break;
+							}
+						}
+					}
+					if (subpath && !resolvedEntryPath) {
+						const subpathCandidates = [resolve(workspaceDirectory, subpath), resolve(workspaceDirectory, "src", subpath)];
+						for (const directSubpath of subpathCandidates) {
+							for (const candidateExtension of RESOLVER_EXTENSIONS) {
+								const candidate = directSubpath + candidateExtension;
+								if (cachedExistsSync(candidate)) {
+									resolvedEntryPath = candidate;
+									break;
+								}
+							}
+							if (resolvedEntryPath) break;
+							for (const candidateExtension of RESOLVER_EXTENSIONS) {
+								const indexCandidate = join(directSubpath, `index${candidateExtension}`);
+								if (cachedExistsSync(indexCandidate)) {
+									resolvedEntryPath = indexCandidate;
+									break;
+								}
+							}
+							if (resolvedEntryPath) break;
+						}
+					}
+					if (!subpath) {
+						const mainField = workspacePackageJson.main ?? workspacePackageJson.module;
+						if (typeof mainField === "string") resolvedEntryPath = resolve(workspaceDirectory, mainField);
+						if (!resolvedEntryPath && workspacePackageJson.exports?.["."]) {
+							const dotExport = workspacePackageJson.exports["."];
+							if (typeof dotExport === "string") resolvedEntryPath = resolve(workspaceDirectory, dotExport);
+							else if (typeof dotExport === "object" && dotExport !== null) {
+								const conditionValue = dotExport.import ?? dotExport.require ?? dotExport.default ?? dotExport.types;
+								if (typeof conditionValue === "string") resolvedEntryPath = resolve(workspaceDirectory, conditionValue);
+							}
+						}
+					}
+					if (resolvedEntryPath) {
+						const finalPath = resolveSourcePath(resolvedEntryPath, workspaceDirectory) ?? resolvedEntryPath;
+						if (cachedExistsSync(finalPath)) {
+							const resolvedResult = {
+								resolvedPath: finalPath,
+								isExternal: false,
+								packageName: void 0
+							};
+							resolveResultCache.set(cacheKey, resolvedResult);
+							return resolvedResult;
+						}
+						const sourceFallbackPath = trySourceFallback(resolvedEntryPath);
+						if (sourceFallbackPath) {
+							const resolvedResult = {
+								resolvedPath: sourceFallbackPath,
+								isExternal: false,
+								packageName: void 0
+							};
+							resolveResultCache.set(cacheKey, resolvedResult);
+							return resolvedResult;
+						}
+					}
+				} catch {}
+			}
+		}
+		const tsconfigForFile = findTsconfigForFile(fromFile);
+		const resolver = getOrCreateResolver(tsconfigForFile);
+		const tryResolve = (activeResolver) => {
+			try {
+				const resolverResult = activeResolver.sync(fromDir, cleanedSpecifier);
+				if (resolverResult.path) {
+					const isInsideNodeModules = resolverResult.path.includes("/node_modules/");
+					return {
+						resolvedPath: isInsideNodeModules ? void 0 : resolverResult.path,
+						isExternal: isInsideNodeModules,
+						packageName: isInsideNodeModules ? extractPackageNameFromSpecifier(cleanedSpecifier) : void 0
+					};
+				}
+			} catch {
+				return;
+			}
+		};
+		const resolversToAttempt = [
+			resolver,
+			...tsconfigForFile !== rootTsconfigPath && rootTsconfigPath ? [getOrCreateResolver(rootTsconfigPath)] : [],
+			...tsconfigForFile ? [getOrCreateResolver(void 0)] : []
+		];
+		for (const activeResolver of resolversToAttempt) {
+			const resolvedResult = tryResolve(activeResolver);
+			if (resolvedResult) {
+				resolveResultCache.set(cacheKey, resolvedResult);
+				return resolvedResult;
+			}
+		}
+		const pathAliasResolved = tryResolveViaPathAlias(cleanedSpecifier, fromFile);
+		if (pathAliasResolved) {
+			const resolvedResult = {
+				resolvedPath: pathAliasResolved,
+				isExternal: false,
+				packageName: void 0
+			};
+			resolveResultCache.set(cacheKey, resolvedResult);
+			return resolvedResult;
+		}
+		if (isBareSpecifier(cleanedSpecifier)) {
+			const tsconfigFile = findTsconfigForFile(fromFile);
+			if (tsconfigFile) {
+				const baseUrlDirectory = getBaseUrlDirectory(tsconfigFile);
+				if (baseUrlDirectory) {
+					const baseUrlCandidate = resolve(baseUrlDirectory, cleanedSpecifier);
+					for (const candidateExtension of RESOLVER_EXTENSIONS) {
+						const fullCandidate = baseUrlCandidate + candidateExtension;
+						if (cachedExistsSync(fullCandidate)) {
+							const resolvedResult = {
+								resolvedPath: fullCandidate,
+								isExternal: false,
+								packageName: void 0
+							};
+							resolveResultCache.set(cacheKey, resolvedResult);
+							return resolvedResult;
+						}
+					}
+					const indexCandidate = join(baseUrlCandidate, "index");
+					for (const candidateExtension of RESOLVER_EXTENSIONS) {
+						const fullCandidate = indexCandidate + candidateExtension;
+						if (cachedExistsSync(fullCandidate)) {
+							const resolvedResult = {
+								resolvedPath: fullCandidate,
+								isExternal: false,
+								packageName: void 0
+							};
+							resolveResultCache.set(cacheKey, resolvedResult);
+							return resolvedResult;
+						}
+					}
+				}
+			}
+			const resolvedResult = {
+				resolvedPath: void 0,
+				isExternal: true,
+				packageName: extractPackageNameFromSpecifier(cleanedSpecifier)
+			};
+			resolveResultCache.set(cacheKey, resolvedResult);
+			return resolvedResult;
+		}
+		const unresolvedResult = {
+			resolvedPath: void 0,
+			isExternal: false,
+			packageName: void 0
+		};
+		resolveResultCache.set(cacheKey, unresolvedResult);
+		return unresolvedResult;
+	};
+	return { resolveModule };
+};
+const stripJsonComments = (content) => {
+	let result = "";
+	let insideString = false;
+	let index = 0;
+	while (index < content.length) {
+		if (insideString) {
+			if (content[index] === "\\" && index + 1 < content.length) {
+				result += content[index] + content[index + 1];
+				index += 2;
+				continue;
+			}
+			if (content[index] === "\"") insideString = false;
+			result += content[index];
+			index++;
+			continue;
+		}
+		if (content[index] === "\"") {
+			insideString = true;
+			result += content[index];
+			index++;
+			continue;
+		}
+		if (content[index] === "/" && index + 1 < content.length) {
+			if (content[index + 1] === "/") {
+				while (index < content.length && content[index] !== "\n") index++;
+				continue;
+			}
+			if (content[index + 1] === "*") {
+				index += 2;
+				while (index + 1 < content.length && !(content[index] === "*" && content[index + 1] === "/")) index++;
+				index += 2;
+				continue;
+			}
+		}
+		result += content[index];
+		index++;
+	}
+	return result.replace(/,(\s*[}\]])/g, "$1");
+};
+const BUILTIN_SUBPATH_MODULES = new Set([
+	"fs",
+	"dns",
+	"stream",
+	"readline",
+	"timers",
+	"util"
+]);
+const isBuiltinModule = (specifier) => {
+	if (specifier.startsWith("node:")) return true;
+	const baseName = specifier.split("/")[0];
+	if (!BUILTIN_MODULES.has(baseName)) return false;
+	if (!specifier.includes("/")) return true;
+	return BUILTIN_SUBPATH_MODULES.has(baseName);
+};
+const isBareSpecifier = (specifier) => !specifier.startsWith(".") && !specifier.startsWith("/");
+const extractPackageNameFromSpecifier = (specifier) => {
+	if (specifier.startsWith("node:")) return specifier.slice(5).split("/")[0];
+	if (specifier.startsWith("@")) {
+		const parts = specifier.split("/");
+		return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : specifier;
+	}
+	return specifier.split("/")[0];
+};
+
+//#endregion
+//#region src/utils/is-config-file.ts
+const isConfigFile = (filePath) => {
+	const fileName = filePath.split("/").pop() ?? "";
+	if (fileName.startsWith(".") && !fileName.startsWith("..")) {
+		if (fileName.toLowerCase().includes("rc.")) return true;
+	}
+	return CONFIG_FILE_PREFIXES.some((prefix) => fileName.startsWith(prefix));
+};
+
+//#endregion
+//#region src/graph/build.ts
+const buildModuleGraph = (inputs) => {
+	const fileIdMap = /* @__PURE__ */ new Map();
+	for (const input of inputs) fileIdMap.set(input.fileId.path, input.fileId.index);
+	const modules = inputs.map((input) => ({
+		fileId: input.fileId,
+		imports: input.parsed.imports,
+		exports: input.parsed.exports,
+		memberAccesses: input.parsed.memberAccesses,
+		wholeObjectUses: input.parsed.wholeObjectUses,
+		isEntryPoint: input.isEntryPoint,
+		isTestEntry: input.isTestEntry,
+		isReachable: false,
+		isDeclarationFile: input.fileId.path.endsWith(".d.ts") || input.fileId.path.endsWith(".d.mts") || input.fileId.path.endsWith(".d.cts"),
+		isConfigFile: isConfigFile(input.fileId.path)
+	}));
+	const edges = [];
+	const reverseEdges = /* @__PURE__ */ new Map();
+	const addEdge = (sourceIndex, targetIndex, symbols, isReExportEdge = false, reExportedNames = [], reExportMappings = []) => {
+		edges.push({
+			source: sourceIndex,
+			target: targetIndex,
+			importedSymbols: symbols,
+			isReExportEdge,
+			reExportedNames,
+			reExportMappings
+		});
+		const existingReverseEdges = reverseEdges.get(targetIndex);
+		if (existingReverseEdges) {
+			if (!existingReverseEdges.includes(sourceIndex)) existingReverseEdges.push(sourceIndex);
+		} else reverseEdges.set(targetIndex, [sourceIndex]);
+	};
+	for (const input of inputs) {
+		const sourceIndex = input.fileId.index;
+		for (const importInfo of input.parsed.imports) {
+			if (importInfo.isGlob) {
+				const sourceDir = path.dirname(input.fileId.path);
+				const globPattern = importInfo.specifier;
+				for (const [filePath] of fileIdMap) {
+					const relativePath = path.relative(sourceDir, filePath);
+					if (minimatch(relativePath.startsWith(".") ? relativePath : `./${relativePath}`, globPattern)) {
+						const targetIndex = fileIdMap.get(filePath);
+						if (targetIndex !== void 0) addEdge(sourceIndex, targetIndex, []);
+					}
+				}
+				continue;
+			}
+			const resolved = input.resolvedImports.get(importInfo.specifier);
+			if (!resolved?.resolvedPath) continue;
+			const targetIndex = fileIdMap.get(resolved.resolvedPath);
+			if (targetIndex === void 0) continue;
+			addEdge(sourceIndex, targetIndex, importInfo.importedNames.map((importedName) => ({
+				importedName: importedName.name,
+				localName: importedName.alias ?? importedName.name,
+				isTypeOnly: importedName.isTypeOnly,
+				isNamespace: importedName.isNamespace,
+				isDefault: importedName.isDefault
+			})));
+		}
+		const reExportsByTarget = /* @__PURE__ */ new Map();
+		for (const exportInfo of input.parsed.exports) {
+			if (!exportInfo.isReExport || !exportInfo.reExportSource) continue;
+			const resolved = input.resolvedImports.get(exportInfo.reExportSource);
+			if (!resolved?.resolvedPath) continue;
+			const targetIndex = fileIdMap.get(resolved.resolvedPath);
+			if (targetIndex === void 0) continue;
+			const exportedName = exportInfo.isNamespaceReExport ? "*" : exportInfo.name;
+			const originalName = exportInfo.isNamespaceReExport ? "*" : exportInfo.reExportOriginalName ?? exportInfo.name;
+			const existing = reExportsByTarget.get(targetIndex);
+			if (existing) {
+				existing.names.push(exportedName);
+				existing.mappings.push({
+					exportedName,
+					originalName
+				});
+			} else reExportsByTarget.set(targetIndex, {
+				names: [exportedName],
+				mappings: [{
+					exportedName,
+					originalName
+				}]
+			});
+		}
+		for (const [targetIndex, { names: reExportedNames, mappings: reExportMappings }] of reExportsByTarget) addEdge(sourceIndex, targetIndex, [], true, reExportedNames, reExportMappings);
+	}
+	return {
+		modules,
+		edges,
+		reverseEdges,
+		fileIdMap
+	};
+};
+
+//#endregion
+//#region src/graph/reachability.ts
+const PLATFORM_DIRECTORY_NAMES = new Set([
+	"web",
+	"native",
+	"ios",
+	"android",
+	"desktop",
+	"windows",
+	"macos"
+]);
+const stripPlatformSuffix = (filePath) => {
+	for (const suffix of PLATFORM_SUFFIXES) {
+		const extensionIndex = filePath.lastIndexOf(".");
+		if (extensionIndex === -1) continue;
+		const withoutExtension = filePath.slice(0, extensionIndex);
+		if (withoutExtension.endsWith(suffix)) return withoutExtension.slice(0, -suffix.length) + filePath.slice(extensionIndex);
+	}
+};
+const stripPlatformDirectory = (filePath) => {
+	const segments = filePath.split("/");
+	for (let segmentIndex = segments.length - 2; segmentIndex >= 0; segmentIndex--) if (PLATFORM_DIRECTORY_NAMES.has(segments[segmentIndex])) return [...segments.slice(0, segmentIndex), ...segments.slice(segmentIndex + 1)].join("/");
+};
+const markReachable = (graph) => {
+	const totalModules = graph.modules.length;
+	const visited = new Uint8Array(totalModules);
+	const consumedExportsPerModule = /* @__PURE__ */ new Map();
+	const queue = [];
+	const outgoingEdgesMap = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges) {
+		const existing = outgoingEdgesMap.get(edge.source);
+		if (existing) existing.push(edge);
+		else outgoingEdgesMap.set(edge.source, [edge]);
+	}
+	for (const module of graph.modules) if (module.isEntryPoint) {
+		const moduleIndex = module.fileId.index;
+		if (moduleIndex < totalModules) {
+			visited[moduleIndex] = 1;
+			queue.push({
+				moduleIndex,
+				demandedSymbols: "all"
+			});
+		}
+	}
+	const markConsumedExports = (targetModuleIndex, symbols) => {
+		if (symbols === "all") {
+			consumedExportsPerModule.set(targetModuleIndex, new Set(["*"]));
+			return;
+		}
+		const existing = consumedExportsPerModule.get(targetModuleIndex);
+		if (existing && existing.has("*")) return;
+		if (existing) for (const symbol of symbols) existing.add(symbol);
+		else consumedExportsPerModule.set(targetModuleIndex, new Set(symbols));
+	};
+	let headPointer = 0;
+	while (headPointer < queue.length) {
+		const { moduleIndex: currentIndex } = queue[headPointer++];
+		const outgoingEdges = outgoingEdgesMap.get(currentIndex);
+		if (!outgoingEdges) continue;
+		for (const edge of outgoingEdges) {
+			const targetIndex = edge.target;
+			if (targetIndex >= totalModules) continue;
+			if (edge.isReExportEdge) {
+				if (!visited[targetIndex]) {
+					visited[targetIndex] = 1;
+					markConsumedExports(targetIndex, "all");
+					queue.push({
+						moduleIndex: targetIndex,
+						demandedSymbols: "all"
+					});
+				}
+			} else {
+				const importSymbolNames = /* @__PURE__ */ new Set();
+				let isNamespaceOrSideEffect = edge.importedSymbols.length === 0;
+				for (const symbol of edge.importedSymbols) {
+					if (symbol.isNamespace) {
+						isNamespaceOrSideEffect = true;
+						break;
+					}
+					importSymbolNames.add(symbol.importedName);
+					if (symbol.isDefault) importSymbolNames.add("default");
+				}
+				const symbolDemand = isNamespaceOrSideEffect ? "all" : importSymbolNames;
+				if (!visited[targetIndex]) {
+					visited[targetIndex] = 1;
+					markConsumedExports(targetIndex, symbolDemand);
+					queue.push({
+						moduleIndex: targetIndex,
+						demandedSymbols: symbolDemand
+					});
+				} else {
+					const existingConsumed = consumedExportsPerModule.get(targetIndex);
+					if (symbolDemand !== "all" && existingConsumed && !existingConsumed.has("*")) {
+						let hasNewSymbols = false;
+						for (const symbol of symbolDemand) if (!existingConsumed.has(symbol)) {
+							hasNewSymbols = true;
+							break;
+						}
+						if (hasNewSymbols) {
+							markConsumedExports(targetIndex, symbolDemand);
+							queue.push({
+								moduleIndex: targetIndex,
+								demandedSymbols: symbolDemand
+							});
+						}
+					} else if (symbolDemand === "all" && (!existingConsumed || !existingConsumed.has("*"))) {
+						markConsumedExports(targetIndex, "all");
+						queue.push({
+							moduleIndex: targetIndex,
+							demandedSymbols: "all"
+						});
+					}
+				}
+			}
+		}
+	}
+	const platformSiblingGroups = /* @__PURE__ */ new Map();
+	const addToSiblingGroup = (groupKey, moduleIndex) => {
+		const existingSiblings = platformSiblingGroups.get(groupKey);
+		if (existingSiblings) existingSiblings.push(moduleIndex);
+		else platformSiblingGroups.set(groupKey, [moduleIndex]);
+	};
+	for (let moduleIndex = 0; moduleIndex < totalModules; moduleIndex++) {
+		const modulePath = graph.modules[moduleIndex].fileId.path;
+		const basePathFromSuffix = stripPlatformSuffix(modulePath);
+		if (basePathFromSuffix) addToSiblingGroup(basePathFromSuffix, moduleIndex);
+		const basePathFromDirectory = stripPlatformDirectory(modulePath);
+		if (basePathFromDirectory) addToSiblingGroup("dir:" + basePathFromDirectory, moduleIndex);
+	}
+	for (let moduleIndex = 0; moduleIndex < totalModules; moduleIndex++) {
+		const modulePath = graph.modules[moduleIndex].fileId.path;
+		if (platformSiblingGroups.has(modulePath)) platformSiblingGroups.get(modulePath).push(moduleIndex);
+	}
+	const platformQueue = [];
+	for (const siblingIndices of platformSiblingGroups.values()) if (siblingIndices.some((index) => Boolean(visited[index]))) {
+		for (const siblingIndex of siblingIndices) if (!visited[siblingIndex]) {
+			visited[siblingIndex] = 1;
+			platformQueue.push({
+				moduleIndex: siblingIndex,
+				demandedSymbols: "all"
+			});
+		}
+	}
+	let platformHeadPointer = 0;
+	while (platformHeadPointer < platformQueue.length) {
+		const { moduleIndex: currentIndex } = platformQueue[platformHeadPointer++];
+		const outgoingEdges = outgoingEdgesMap.get(currentIndex);
+		if (!outgoingEdges) continue;
+		for (const edge of outgoingEdges) if (edge.target < totalModules && !visited[edge.target]) {
+			visited[edge.target] = 1;
+			platformQueue.push({
+				moduleIndex: edge.target,
+				demandedSymbols: "all"
+			});
+		}
+	}
+	for (let moduleIndex = 0; moduleIndex < totalModules; moduleIndex++) graph.modules[moduleIndex].isReachable = Boolean(visited[moduleIndex]);
+};
+
+//#endregion
+//#region src/graph/re-exports.ts
+const propagateReExports = (graph) => {
+	const sourceToTargets = buildSourceTargetMap(graph);
+	const maxIterations = graph.modules.length * 2 + 1;
+	let didChange = true;
+	let iterationCount = 0;
+	while (didChange && iterationCount < maxIterations) {
+		didChange = false;
+		iterationCount++;
+		for (const module of graph.modules) {
+			const originalExportCount = module.exports.length;
+			for (let exportIndex = 0; exportIndex < originalExportCount; exportIndex++) {
+				const exportInfo = module.exports[exportIndex];
+				if (!exportInfo.isReExport || !exportInfo.reExportSource) continue;
+				if (!exportInfo.isNamespaceReExport) continue;
+				const targetIndices = sourceToTargets.get(module.fileId.index);
+				if (!targetIndices) continue;
+				for (const targetIndex of targetIndices) {
+					const targetModule = graph.modules[targetIndex];
+					if (!targetModule) continue;
+					for (const targetExport of targetModule.exports) {
+						if (targetExport.name === "*" && targetExport.isNamespaceReExport) continue;
+						if (!module.exports.some((existingExport) => existingExport.name === targetExport.name && !existingExport.isNamespaceReExport)) {
+							module.exports.push({
+								name: targetExport.name,
+								isDefault: targetExport.isDefault,
+								isTypeOnly: targetExport.isTypeOnly || exportInfo.isTypeOnly,
+								isReExport: true,
+								isSynthetic: true,
+								reExportSource: exportInfo.reExportSource,
+								reExportOriginalName: targetExport.name,
+								isNamespaceReExport: false,
+								line: exportInfo.line,
+								column: exportInfo.column
+							});
+							didChange = true;
+						}
+					}
+				}
+			}
+		}
+	}
+};
+const buildSourceTargetMap = (graph) => {
+	const sourceTargets = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges) {
+		const existing = sourceTargets.get(edge.source);
+		if (existing) {
+			if (!existing.includes(edge.target)) existing.push(edge.target);
+		} else sourceTargets.set(edge.source, [edge.target]);
+	}
+	return sourceTargets;
+};
+
+//#endregion
+//#region src/analyzer/unused-files.ts
+const isHtmlFile = (filePath) => {
+	return filePath.endsWith(".html");
+};
+const findUnusedFiles = (graph) => {
+	const unusedFiles = [];
+	for (const module of graph.modules) {
+		if (module.isReachable) continue;
+		if (module.isEntryPoint) continue;
+		if (module.isDeclarationFile) continue;
+		if (module.isConfigFile) continue;
+		if (isHtmlFile(module.fileId.path)) continue;
+		if (isBarrelWithReachableSources(module, graph)) continue;
+		if (hasReachableDirectImporter(module.fileId.index, graph)) continue;
+		unusedFiles.push({ path: module.fileId.path });
+	}
+	return unusedFiles;
+};
+const isBarrelWithReachableSources = (module, graph) => {
+	if (module.exports.length === 0) return false;
+	if (!module.exports.every((exportInfo) => exportInfo.isNamespaceReExport || exportInfo.isSynthetic)) return false;
+	for (const edge of graph.edges) if (edge.source === module.fileId.index) {
+		if (graph.modules[edge.target]?.isReachable) return true;
+	}
+	return false;
+};
+const hasReachableDirectImporter = (targetModuleIndex, graph) => {
+	for (const edge of graph.edges) {
+		if (edge.target !== targetModuleIndex) continue;
+		if (edge.isReExportEdge) continue;
+		if (graph.modules[edge.source]?.isReachable) return true;
+	}
+	return false;
+};
+
+//#endregion
+//#region src/analyzer/unused-exports.ts
+const findUnusedExports = (graph, config) => {
+	const usageMap = buildUsageMap(graph);
+	const unusedExports = [];
+	for (const module of graph.modules) {
+		if (!module.isReachable) continue;
+		if (module.isDeclarationFile) continue;
+		if (module.isEntryPoint && !config.includeEntryExports) continue;
+		for (const exportInfo of module.exports) {
+			if (exportInfo.name === "*" && exportInfo.isNamespaceReExport) continue;
+			if (exportInfo.isReExport && exportInfo.reExportOriginalName) continue;
+			if (!config.reportTypes && exportInfo.isTypeOnly) continue;
+			const usageKey = `${module.fileId.path}::${exportInfo.name}`;
+			if (!usageMap.has(usageKey)) unusedExports.push({
+				path: module.fileId.path,
+				name: exportInfo.name,
+				line: exportInfo.line,
+				column: exportInfo.column,
+				isTypeOnly: exportInfo.isTypeOnly
+			});
+		}
+	}
+	return unusedExports;
+};
+const buildUsageMap = (graph) => {
+	const usedExportKeys = /* @__PURE__ */ new Set();
+	const sourceToTargetMap = buildSourceToTargetsMap(graph);
+	for (const edge of graph.edges) {
+		const targetModule = graph.modules[edge.target];
+		if (!targetModule) continue;
+		const sourceModule = graph.modules[edge.source];
+		for (const symbol of edge.importedSymbols) if (symbol.isNamespace) handleNamespaceImport(sourceModule, targetModule, symbol.localName, graph, sourceToTargetMap, usedExportKeys);
+		else {
+			const importName = symbol.isDefault ? "default" : symbol.importedName;
+			markExportUsedRecursive(targetModule.fileId.path, importName, graph, sourceToTargetMap, usedExportKeys, /* @__PURE__ */ new Set());
+		}
+	}
+	return usedExportKeys;
+};
+const handleNamespaceImport = (sourceModule, targetModule, namespaceLocalName, graph, sourceToTargets, usedKeys) => {
+	if (!sourceModule) {
+		markAllExportsUsedRecursive(targetModule, graph, sourceToTargets, usedKeys, /* @__PURE__ */ new Set());
+		return;
+	}
+	if (sourceModule.wholeObjectUses.includes(namespaceLocalName)) {
+		markAllExportsUsedRecursive(targetModule, graph, sourceToTargets, usedKeys, /* @__PURE__ */ new Set());
+		return;
+	}
+	const accessedMemberNames = extractAccessedMemberNames(sourceModule.memberAccesses, namespaceLocalName);
+	const isNamespaceReExported = sourceModule.exports.some((exportInfo) => exportInfo.reExportOriginalName === namespaceLocalName || !exportInfo.isReExport && exportInfo.name === namespaceLocalName);
+	if (accessedMemberNames.length === 0 && !isNamespaceReExported) {
+		markAllExportsUsedRecursive(targetModule, graph, sourceToTargets, usedKeys, /* @__PURE__ */ new Set());
+		return;
+	}
+	if (isNamespaceReExported && !sourceModule.isEntryPoint) {
+		markAllExportsUsedRecursive(targetModule, graph, sourceToTargets, usedKeys, /* @__PURE__ */ new Set());
+		return;
+	}
+	for (const memberName of accessedMemberNames) markExportUsedRecursive(targetModule.fileId.path, memberName, graph, sourceToTargets, usedKeys, /* @__PURE__ */ new Set());
+};
+const extractAccessedMemberNames = (memberAccesses, objectName) => {
+	const memberNames = [];
+	const seenNames = /* @__PURE__ */ new Set();
+	for (const access of memberAccesses) if (access.objectName === objectName && !seenNames.has(access.memberName)) {
+		seenNames.add(access.memberName);
+		memberNames.push(access.memberName);
+	}
+	return memberNames;
+};
+const buildSourceToTargetsMap = (graph) => {
+	const sourceToTargets = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges) {
+		const existing = sourceToTargets.get(edge.source);
+		if (existing) {
+			if (!existing.includes(edge.target)) existing.push(edge.target);
+		} else sourceToTargets.set(edge.source, [edge.target]);
+	}
+	return sourceToTargets;
+};
+const markAllExportsUsedRecursive = (module, graph, sourceToTargets, usedKeys, visited) => {
+	const visitKey = `all::${module.fileId.path}`;
+	if (visited.has(visitKey)) return;
+	visited.add(visitKey);
+	for (const exportInfo of module.exports) {
+		if (exportInfo.name === "*" && exportInfo.isNamespaceReExport) continue;
+		const usageKey = `${module.fileId.path}::${exportInfo.name}`;
+		usedKeys.add(usageKey);
+		if (exportInfo.isReExport && exportInfo.reExportSource) followReExportChain(module.fileId.index, exportInfo, graph, sourceToTargets, usedKeys, visited);
+	}
+};
+const markExportUsedRecursive = (filePath, exportName, graph, sourceToTargets, usedKeys, visited) => {
+	const visitKey = `${filePath}::${exportName}`;
+	if (visited.has(visitKey)) return;
+	visited.add(visitKey);
+	usedKeys.add(visitKey);
+	const moduleIndex = graph.fileIdMap.get(filePath);
+	if (moduleIndex === void 0) return;
+	const module = graph.modules[moduleIndex];
+	if (!module) return;
+	for (const exportInfo of module.exports) {
+		if (exportInfo.name !== exportName) continue;
+		if (exportInfo.isReExport && exportInfo.reExportSource) followReExportChain(moduleIndex, exportInfo, graph, sourceToTargets, usedKeys, visited);
+	}
+};
+const followReExportChain = (reExporterModuleIndex, exportInfo, graph, sourceToTargets, usedKeys, visited) => {
+	const targetIndices = sourceToTargets.get(reExporterModuleIndex);
+	if (!targetIndices) return;
+	const originalName = exportInfo.reExportOriginalName ?? exportInfo.name;
+	for (const targetIndex of targetIndices) {
+		const targetModule = graph.modules[targetIndex];
+		if (!targetModule) continue;
+		if (originalName === "*" || exportInfo.isNamespaceReExport) markExportUsedRecursive(targetModule.fileId.path, exportInfo.name, graph, sourceToTargets, usedKeys, visited);
+		else if (targetModule.exports.some((targetExport) => targetExport.name === originalName || targetExport.isNamespaceReExport && targetExport.name === "*")) markExportUsedRecursive(targetModule.fileId.path, originalName, graph, sourceToTargets, usedKeys, visited);
+	}
+};
+
+//#endregion
+//#region src/utils/package-name.ts
+const extractPackageName = (specifier) => {
+	if (specifier.startsWith(".") || specifier.startsWith("/")) return void 0;
+	if (specifier.startsWith("node:")) return void 0;
+	if (specifier.startsWith("@")) {
+		const parts = specifier.split("/");
+		return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : void 0;
+	}
+	return specifier.split("/")[0];
+};
+
+//#endregion
+//#region src/analyzer/unused-dependencies.ts
+const findUnusedDependencies = (graph, config) => {
+	const packageJsonPath = resolve(config.rootDir, "package.json");
+	let packageJson;
+	try {
+		const content = readFileSync(packageJsonPath, "utf-8");
+		packageJson = JSON.parse(content);
+	} catch {
+		return [];
+	}
+	const dependencies = packageJson.dependencies ?? {};
+	const devDependencies = packageJson.devDependencies ?? {};
+	const declaredDependencies = /* @__PURE__ */ new Map();
+	for (const dependencyName of Object.keys(dependencies)) declaredDependencies.set(dependencyName, false);
+	for (const dependencyName of Object.keys(devDependencies)) declaredDependencies.set(dependencyName, true);
+	const usedPackageNames = collectUsedPackages(graph);
+	const unusedDependencies = [];
+	for (const [dependencyName, isDevDependency] of declaredDependencies) {
+		if (isAlwaysConsideredUsed(dependencyName)) continue;
+		if (!usedPackageNames.has(dependencyName)) unusedDependencies.push({
+			name: dependencyName,
+			isDevDependency
+		});
+	}
+	return unusedDependencies;
+};
+const collectUsedPackages = (graph) => {
+	const usedPackages = /* @__PURE__ */ new Set();
+	for (const module of graph.modules) for (const importInfo of module.imports) {
+		const packageName = extractPackageName(importInfo.specifier);
+		if (packageName) usedPackages.add(packageName);
+	}
+	return usedPackages;
+};
+const isAlwaysConsideredUsed = (dependencyName) => {
+	if (ALWAYS_USED_PACKAGES.has(dependencyName)) return true;
+	if (dependencyName.startsWith("@types/")) return true;
+	if (dependencyName.startsWith("eslint-config-")) return true;
+	if (dependencyName.startsWith("eslint-plugin-")) return true;
+	if (dependencyName.startsWith("prettier-plugin-")) return true;
+	return false;
+};
+
+//#endregion
+//#region src/analyzer/circular-deps.ts
+const UNDEFINED_INDEX = -1;
+const buildAdjacencyList = (graph) => {
+	const targetSets = Array.from({ length: graph.modules.length }, () => /* @__PURE__ */ new Set());
+	for (const edge of graph.edges) {
+		if (edge.importedSymbols.every((symbol) => symbol.isTypeOnly)) continue;
+		if (edge.target < graph.modules.length) targetSets[edge.source].add(edge.target);
+	}
+	return targetSets.map((targets) => [...targets]);
+};
+const findStronglyConnectedComponents = (adjacencyList) => {
+	const nodeCount = adjacencyList.length;
+	if (nodeCount === 0) return [];
+	const state = {
+		indexCounter: 0,
+		indices: Array(nodeCount).fill(UNDEFINED_INDEX),
+		lowlinks: Array(nodeCount).fill(0),
+		onStack: Array(nodeCount).fill(false),
+		stack: []
+	};
+	const components = [];
+	const dfsStack = [];
+	for (let startNode = 0; startNode < nodeCount; startNode++) {
+		if (state.indices[startNode] !== UNDEFINED_INDEX) continue;
+		state.indices[startNode] = state.indexCounter;
+		state.lowlinks[startNode] = state.indexCounter;
+		state.indexCounter++;
+		state.onStack[startNode] = true;
+		state.stack.push(startNode);
+		dfsStack.push({
+			node: startNode,
+			successorPosition: 0
+		});
+		while (dfsStack.length > 0) {
+			const frame = dfsStack[dfsStack.length - 1];
+			const successors = adjacencyList[frame.node];
+			if (frame.successorPosition < successors.length) {
+				const successor = successors[frame.successorPosition];
+				frame.successorPosition++;
+				if (state.indices[successor] === UNDEFINED_INDEX) {
+					state.indices[successor] = state.indexCounter;
+					state.lowlinks[successor] = state.indexCounter;
+					state.indexCounter++;
+					state.onStack[successor] = true;
+					state.stack.push(successor);
+					dfsStack.push({
+						node: successor,
+						successorPosition: 0
+					});
+				} else if (state.onStack[successor]) state.lowlinks[frame.node] = Math.min(state.lowlinks[frame.node], state.indices[successor]);
+			} else {
+				const currentNode = frame.node;
+				const currentLowlink = state.lowlinks[currentNode];
+				const currentIndex = state.indices[currentNode];
+				dfsStack.pop();
+				if (dfsStack.length > 0) {
+					const parentFrame = dfsStack[dfsStack.length - 1];
+					state.lowlinks[parentFrame.node] = Math.min(state.lowlinks[parentFrame.node], currentLowlink);
+				}
+				if (currentLowlink === currentIndex) {
+					const component = [];
+					let poppedNode;
+					do {
+						poppedNode = state.stack.pop();
+						state.onStack[poppedNode] = false;
+						component.push(poppedNode);
+					} while (poppedNode !== currentNode);
+					if (component.length >= 2) components.push(component);
+				}
+			}
+		}
+	}
+	return components;
+};
+const canonicalizeCycle = (cycle, graph) => {
+	if (cycle.length === 0) return [];
+	let minPosition = 0;
+	let minPath = graph.modules[cycle[0]].fileId.path;
+	for (let position = 1; position < cycle.length; position++) {
+		const currentPath = graph.modules[cycle[position]].fileId.path;
+		if (currentPath < minPath) {
+			minPath = currentPath;
+			minPosition = position;
+		}
+	}
+	return [...cycle.slice(minPosition), ...cycle.slice(0, minPosition)];
+};
+const enumerateElementaryCycles = (componentNodes, adjacencyList, graph) => {
+	if (componentNodes.length === 2) {
+		const [nodeA, nodeB] = componentNodes;
+		return [graph.modules[nodeA].fileId.path <= graph.modules[nodeB].fileId.path ? [nodeA, nodeB] : [nodeB, nodeA]];
+	}
+	const componentSet = new Set(componentNodes);
+	const cycles = [];
+	const seenKeys = /* @__PURE__ */ new Set();
+	for (const startNode of componentNodes) {
+		if (cycles.length >= 20) break;
+		const visitedInThisSearch = /* @__PURE__ */ new Set();
+		visitedInThisSearch.add(startNode);
+		const pathStack = [startNode];
+		const successorPositionStack = [0];
+		while (pathStack.length > 0 && cycles.length < 20) {
+			const currentNode = pathStack[pathStack.length - 1];
+			const currentSuccessorPosition = successorPositionStack[successorPositionStack.length - 1];
+			const successors = adjacencyList[currentNode].filter((successor) => componentSet.has(successor));
+			if (currentSuccessorPosition < successors.length) {
+				successorPositionStack[successorPositionStack.length - 1]++;
+				const successor = successors[currentSuccessorPosition];
+				if (successor === startNode) {
+					const canonical = canonicalizeCycle([...pathStack], graph);
+					const key = canonical.join(",");
+					if (!seenKeys.has(key)) {
+						seenKeys.add(key);
+						cycles.push(canonical);
+					}
+				} else if (!visitedInThisSearch.has(successor)) {
+					visitedInThisSearch.add(successor);
+					pathStack.push(successor);
+					successorPositionStack.push(0);
+				}
+			} else {
+				visitedInThisSearch.delete(pathStack.pop());
+				successorPositionStack.pop();
+			}
+		}
+	}
+	return cycles;
+};
+const findCircularDependencies = (graph) => {
+	const adjacencyList = buildAdjacencyList(graph);
+	const components = findStronglyConnectedComponents(adjacencyList);
+	const allCycles = [];
+	const seenKeys = /* @__PURE__ */ new Set();
+	const sortedComponents = [...components].sort((componentA, componentB) => componentA.length - componentB.length);
+	for (const component of sortedComponents) {
+		if (allCycles.length >= 200) break;
+		if (component.length > 50) continue;
+		const elementaryCycles = enumerateElementaryCycles(component, adjacencyList, graph);
+		for (const cycle of elementaryCycles) {
+			const key = cycle.join(",");
+			if (!seenKeys.has(key)) {
+				seenKeys.add(key);
+				allCycles.push(cycle);
+			}
+			if (allCycles.length >= 200) break;
+		}
+	}
+	allCycles.sort((cycleA, cycleB) => {
+		const lengthDiff = cycleA.length - cycleB.length;
+		if (lengthDiff !== 0) return lengthDiff;
+		return graph.modules[cycleA[0]].fileId.path.localeCompare(graph.modules[cycleB[0]].fileId.path);
+	});
+	return allCycles.map((cycle) => ({ files: cycle.map((nodeIndex) => graph.modules[nodeIndex].fileId.path) }));
+};
+
+//#endregion
+//#region src/analyzer/analyze.ts
+const analyzeGraph = (graph, config) => {
+	const analysisStartTime = performance.now();
+	const unusedFiles = findUnusedFiles(graph);
+	const unusedExports = findUnusedExports(graph, config);
+	const unusedDependencies = findUnusedDependencies(graph, config);
+	const circularDependencies = findCircularDependencies(graph);
+	const totalExports = graph.modules.reduce((exportCount, module) => exportCount + module.exports.filter((exportInfo) => !(exportInfo.name === "*" && exportInfo.isNamespaceReExport)).length, 0);
+	return {
+		unusedFiles,
+		unusedExports,
+		unusedDependencies,
+		circularDependencies,
+		totalFiles: graph.modules.length,
+		totalExports,
+		analysisTimeMs: performance.now() - analysisStartTime
+	};
+};
+
+//#endregion
+//#region src/index.ts
+const STYLE_EXTENSIONS = [".css", ".scss"];
+const REACT_NATIVE_ENABLERS = ["react-native", "expo"];
+const detectReactNative = (rootDir, workspacePackages) => {
+	const directoriesToCheck = [rootDir, ...workspacePackages.map((workspacePackage) => workspacePackage.directory)];
+	for (const directory of directoriesToCheck) {
+		const packageJsonPath = resolve(directory, "package.json");
+		if (!existsSync(packageJsonPath)) continue;
+		try {
+			const content = readFileSync(packageJsonPath, "utf-8");
+			const packageJson = JSON.parse(content);
+			const allDependencies = {
+				...packageJson.dependencies,
+				...packageJson.devDependencies,
+				...packageJson.optionalDependencies
+			};
+			if (REACT_NATIVE_ENABLERS.some((enabler) => enabler in allDependencies)) return true;
+		} catch {
+			continue;
+		}
+	}
+	return false;
+};
+const createConfig = (options) => ({
+	rootDir: resolve(options.rootDir),
+	entryPatterns: options.entryPatterns ?? DEFAULT_ENTRY_PATTERNS,
+	ignorePatterns: options.ignorePatterns ?? [],
+	includeExtensions: options.includeExtensions ?? DEFAULT_EXTENSIONS,
+	tsConfigPath: options.tsConfigPath ?? void 0,
+	reportTypes: options.reportTypes ?? false,
+	includeEntryExports: options.includeEntryExports ?? false
+});
+const analyze = async (config) => {
+	const pipelineStartTime = performance.now();
+	const workspaceDiscovery = discoverWorkspacePackagesWithExclusions(resolve(config.rootDir));
+	const workspacePackages = workspaceDiscovery.packages;
+	const frameworkIgnorePatterns = discoverFrameworkIgnorePatterns(config.rootDir);
+	const absoluteRoot = resolve(config.rootDir);
+	const outputDirectoryExclusions = OUTPUT_DIRECTORIES.flatMap((outputDirectory) => {
+		const exclusions = [`${absoluteRoot}/${outputDirectory}/**`];
+		for (const workspacePackage of workspacePackages) exclusions.push(`${workspacePackage.directory}/${outputDirectory}/**`);
+		return exclusions;
+	});
+	const allExclusionPatterns = [
+		...workspaceDiscovery.excludedDirectories.map((directory) => `${directory}/**`),
+		...frameworkIgnorePatterns,
+		...outputDirectoryExclusions
+	];
+	const configWithExclusions = allExclusionPatterns.length > 0 ? {
+		...config,
+		ignorePatterns: [...config.ignorePatterns, ...allExclusionPatterns]
+	} : config;
+	const files = await discoverFiles(configWithExclusions);
+	const discoveredEntries = await discoverEntryPoints(configWithExclusions);
+	const productionEntrySet = new Set(discoveredEntries.productionEntries);
+	const testEntrySet = new Set(discoveredEntries.testEntries);
+	const alwaysUsedFileSet = new Set(discoveredEntries.alwaysUsedFiles);
+	const hasReactNative = detectReactNative(config.rootDir, workspacePackages);
+	const moduleResolver = createModuleResolver(config, workspacePackages.map((workspacePackage) => ({
+		name: workspacePackage.name,
+		directory: workspacePackage.directory
+	})), { hasReactNative });
+	const graphInputs = [];
+	for (const file of files) {
+		const parsedModule = parseModule(file.path);
+		const resolvedImportMap = /* @__PURE__ */ new Map();
+		for (const importInfo of parsedModule.imports) {
+			if (importInfo.isGlob) {
+				const fileDir = dirname(file.path);
+				const expandedFiles = fg.sync(importInfo.specifier, {
+					cwd: fileDir,
+					absolute: true,
+					onlyFiles: true,
+					ignore: ["**/node_modules/**"]
+				});
+				for (const expandedFile of expandedFiles) resolvedImportMap.set(expandedFile, {
+					resolvedPath: expandedFile,
+					isExternal: false,
+					packageName: void 0
+				});
+				resolvedImportMap.set(importInfo.specifier, {
+					resolvedPath: void 0,
+					isExternal: false,
+					packageName: void 0
+				});
+				continue;
+			}
+			const resolvedImport = moduleResolver.resolveModule(importInfo.specifier, file.path);
+			resolvedImportMap.set(importInfo.specifier, resolvedImport);
+		}
+		for (const exportInfo of parsedModule.exports) if (exportInfo.isReExport && exportInfo.reExportSource) {
+			if (!resolvedImportMap.has(exportInfo.reExportSource)) {
+				const resolvedImport = moduleResolver.resolveModule(exportInfo.reExportSource, file.path);
+				resolvedImportMap.set(exportInfo.reExportSource, resolvedImport);
+			}
+		}
+		const isAlwaysUsed = alwaysUsedFileSet.has(file.path);
+		graphInputs.push({
+			fileId: file,
+			parsed: parsedModule,
+			resolvedImports: resolvedImportMap,
+			isEntryPoint: isAlwaysUsed || productionEntrySet.has(file.path) || testEntrySet.has(file.path),
+			isTestEntry: testEntrySet.has(file.path)
+		});
+	}
+	const discoveredFilePaths = new Set(files.map((file) => file.path));
+	const styleFilesToAdd = /* @__PURE__ */ new Set();
+	for (const input of graphInputs) for (const [, resolvedImport] of input.resolvedImports) {
+		if (!resolvedImport.resolvedPath || resolvedImport.isExternal) continue;
+		if (discoveredFilePaths.has(resolvedImport.resolvedPath)) continue;
+		if (STYLE_EXTENSIONS.some((ext) => resolvedImport.resolvedPath.endsWith(ext)) && existsSync(resolvedImport.resolvedPath)) styleFilesToAdd.add(resolvedImport.resolvedPath);
+	}
+	const sortedStyleFiles = [...styleFilesToAdd].sort();
+	let nextFileIndex = files.length;
+	for (const styleFilePath of sortedStyleFiles) {
+		const styleFileId = {
+			index: nextFileIndex,
+			path: styleFilePath
+		};
+		const parsedStyleModule = parseModule(styleFilePath);
+		const resolvedStyleImportMap = /* @__PURE__ */ new Map();
+		for (const importInfo of parsedStyleModule.imports) {
+			const resolvedImport = moduleResolver.resolveModule(importInfo.specifier, styleFilePath);
+			resolvedStyleImportMap.set(importInfo.specifier, resolvedImport);
+			if (resolvedImport.resolvedPath && !discoveredFilePaths.has(resolvedImport.resolvedPath)) {
+				if (STYLE_EXTENSIONS.some((ext) => resolvedImport.resolvedPath.endsWith(ext)) && existsSync(resolvedImport.resolvedPath)) styleFilesToAdd.add(resolvedImport.resolvedPath);
+			}
+		}
+		graphInputs.push({
+			fileId: styleFileId,
+			parsed: parsedStyleModule,
+			resolvedImports: resolvedStyleImportMap,
+			isEntryPoint: false,
+			isTestEntry: false
+		});
+		discoveredFilePaths.add(styleFilePath);
+		nextFileIndex++;
+	}
+	const moduleGraph = buildModuleGraph(graphInputs);
+	propagateReExports(moduleGraph);
+	markReachable(moduleGraph);
+	const analysisResult = analyzeGraph(moduleGraph, config);
+	analysisResult.analysisTimeMs = performance.now() - pipelineStartTime;
+	return analysisResult;
+};
+
+//#endregion
+export { createConfig as n, analyze as t };