deslop-js 0.9.7 → 0.9.8

package/dist/entries-worker.mjs

@@ -1,11 +1,11 @@
-import { a as OUTPUT_DIRECTORIES, c as SCRIPT_EXTENSIONLESS_FILE_PATTERN, d as STANDALONE_PROJECT_LOCKFILES, i as MONOREPO_ROOT_MARKERS, l as SCRIPT_FILE_PATTERN, o as RESOLVER_EXTENSIONS, r as LOCKFILE_MARKERS, s as SCRIPT_CONFIG_FILE_PATTERN, t as extractReactRouterRouteModuleEntries, u as SOURCE_EXTENSIONS$3 } from "./parse-C6-m3QMJ.mjs";
+import { a as OUTPUT_DIRECTORIES, c as SCRIPT_EXTENSIONLESS_FILE_PATTERN, d as STANDALONE_PROJECT_LOCKFILES, i as MONOREPO_ROOT_MARKERS, l as SCRIPT_FILE_PATTERN, o as RESOLVER_EXTENSIONS, r as LOCKFILE_MARKERS, s as SCRIPT_CONFIG_FILE_PATTERN, t as extractReactRouterRouteModuleEntries, u as SOURCE_EXTENSIONS$3 } from "./parse-C6Iu3cJw.mjs";
 import { parentPort } from "node:worker_threads";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import fg from "fast-glob";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { readFile } from "node:fs/promises";
 import ts from "typescript";
 import "oxc-resolver";
+import { readFile } from "node:fs/promises";
 
 //#region src/collect/workspaces.ts
 const resolveWorkspaces = (rootDir) => {
@@ -1306,6 +1306,246 @@ const extractSiblingWorkspaceImportEntries = (absoluteRoot) => {
 	return [...new Set(importedEntries)];
 };
 
+//#endregion
+//#region src/collect/package-json-entries.ts
+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 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 IMPORTABLE_EXTENSION_SET = new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mts",
+	".mjs",
+	".cts",
+	".cjs",
+	".css",
+	".scss",
+	".less",
+	".sass"
+]);
+const PACKAGE_ENTRY_FIELDS = [
+	"main",
+	"module",
+	"browser",
+	"types",
+	"typings",
+	"style",
+	"source"
+];
+const findDefaultIndexEntry = (directory) => {
+	for (const pattern of DEFAULT_INDEX_PATTERNS) {
+		const candidatePath = resolve(directory, pattern);
+		if (existsSync(candidatePath)) return candidatePath;
+	}
+};
+const findSourceFileWithKnownExtension = (pathWithoutExtension) => {
+	for (const sourceExtension of SOURCE_EXTENSIONS) {
+		const candidatePath = pathWithoutExtension + sourceExtension;
+		if (existsSync(candidatePath)) return candidatePath;
+	}
+};
+const findSourceFile = (baseDirectory, relativePath, shouldResolveDirectoryIndex = true) => {
+	const pathWithoutExtension = join(baseDirectory, relativePath).replace(/\.[cm]?js(x?)$/, "");
+	const sourceFile = findSourceFileWithKnownExtension(pathWithoutExtension);
+	if (sourceFile) return sourceFile;
+	const fallbackPath = shouldResolveDirectoryIndex ? join(pathWithoutExtension, "index.ts") : join(baseDirectory, relativePath);
+	return existsSync(fallbackPath) ? fallbackPath : void 0;
+};
+const findSourceFileStrict = (baseDirectory, relativePath) => findSourceFile(baseDirectory, relativePath, false);
+const readTypeScriptBuildDirectories = (rootDirectory) => {
+	const tsconfigPath = join(rootDirectory, "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 outDirectory = tsconfig?.compilerOptions?.outDir;
+	if (!outDirectory) return void 0;
+	const configuredRootDirectory = tsconfig?.compilerOptions?.rootDir;
+	return {
+		absoluteOutDirectory: resolve(rootDirectory, outDirectory),
+		sourceRoot: configuredRootDirectory ? resolve(rootDirectory, configuredRootDirectory) : rootDirectory,
+		shouldSearchCommonSourceDirectories: !configuredRootDirectory
+	};
+};
+const findRelativeBuildPath = (absoluteOutDirectory, builtAbsolutePath) => {
+	const relativeToBuild = relative(absoluteOutDirectory, builtAbsolutePath);
+	if (relativeToBuild.length === 0 || relativeToBuild === ".." || relativeToBuild.startsWith(`..${sep}`) || isAbsolute(relativeToBuild)) return;
+	return relativeToBuild;
+};
+const findSourcePathForBuildOutput = (buildDirectories, relativeBuildPath, rootDirectory) => {
+	const sourceFileMatch = findSourceFile(buildDirectories.sourceRoot, relativeBuildPath);
+	if (sourceFileMatch) return sourceFileMatch;
+	const directCandidate = join(buildDirectories.sourceRoot, relativeBuildPath);
+	if (existsSync(directCandidate)) return directCandidate;
+	if (!buildDirectories.shouldSearchCommonSourceDirectories) return void 0;
+	for (const sourceDirectory of COMMON_SOURCE_DIRECTORIES) {
+		const candidate = findSourceFile(resolve(rootDirectory, sourceDirectory), relativeBuildPath);
+		if (candidate) return candidate;
+	}
+};
+const resolveBuiltPathToSource = (builtAbsolutePath, rootDirectory) => {
+	if (existsSync(builtAbsolutePath)) return void 0;
+	try {
+		const buildDirectories = readTypeScriptBuildDirectories(rootDirectory);
+		if (!buildDirectories) return void 0;
+		const relativeBuildPath = findRelativeBuildPath(buildDirectories.absoluteOutDirectory, builtAbsolutePath);
+		if (!relativeBuildPath) return void 0;
+		return findSourcePathForBuildOutput(buildDirectories, relativeBuildPath, rootDirectory);
+	} catch {}
+};
+const resolveEntryPathViaHeuristic = (entryPath, rootDirectory) => {
+	const buildDirectoryMatch = entryPath.match(BUILD_OUTPUT_DIRECTORY_PATTERN);
+	if (!buildDirectoryMatch) return void 0;
+	const relativeToBuildDirectory = entryPath.slice(buildDirectoryMatch[0].length);
+	for (const sourceDirectory of COMMON_SOURCE_DIRECTORIES) {
+		const sourceBaseDirectory = resolve(rootDirectory, sourceDirectory);
+		if (!existsSync(sourceBaseDirectory)) continue;
+		const sourceFileMatch = findSourceFileStrict(sourceBaseDirectory, relativeToBuildDirectory);
+		if (sourceFileMatch) return sourceFileMatch;
+	}
+};
+const resolveEntryPath = (entryPath, rootDirectory) => {
+	const absolutePath = resolve(rootDirectory, entryPath);
+	const normalizedEntry = entryPath.replace(/^\.\//, "");
+	if (BUILD_OUTPUT_DIRECTORY_PATTERN.test(normalizedEntry)) {
+		const sourcePath = resolveBuiltPathToSource(absolutePath, rootDirectory);
+		if (sourcePath) return sourcePath;
+		const heuristicMatch = resolveEntryPathViaHeuristic(normalizedEntry, rootDirectory);
+		if (heuristicMatch) return heuristicMatch;
+	}
+	if (existsSync(absolutePath)) return absolutePath;
+	return resolveBuiltPathToSource(absolutePath, rootDirectory) ?? findSourceFile(rootDirectory, normalizedEntry) ?? resolveEntryPathViaHeuristic(normalizedEntry, rootDirectory) ?? absolutePath;
+};
+const collectExportPaths = (exportValue, rootDirectory, entries) => {
+	if (typeof exportValue === "string") {
+		if (exportValue.includes("*")) {
+			const normalizedPattern = exportValue.startsWith("./") ? exportValue.slice(2) : exportValue;
+			entries.push(...findImportableFiles(normalizedPattern, rootDirectory, ["**/node_modules/**"]));
+		} else entries.push(resolveEntryPath(exportValue, rootDirectory));
+		return;
+	}
+	if (!exportValue || typeof exportValue !== "object") return;
+	for (const nestedExportValue of Object.values(exportValue)) collectExportPaths(nestedExportValue, rootDirectory, entries);
+};
+const isImportableSourceFile = (filePath) => IMPORTABLE_EXTENSION_SET.has(filePath.slice(filePath.lastIndexOf(".")));
+const findImportableFiles = (pattern, rootDirectory, ignoredPatterns) => fg.sync(pattern, {
+	cwd: rootDirectory,
+	absolute: true,
+	onlyFiles: true,
+	ignore: ignoredPatterns
+}).filter(isImportableSourceFile);
+const expandSideEffectGlobToSourcePatterns = (pattern) => {
+	const patterns = new Set([pattern]);
+	if (pattern.endsWith(".js")) {
+		patterns.add(pattern.replace(/\.js$/, ".ts"));
+		patterns.add(pattern.replace(/\.js$/, ".tsx"));
+	}
+	if (pattern.includes("/lib/") || pattern.startsWith("lib/")) patterns.add(pattern.replace(/\blib\b/g, "src"));
+	if (pattern.includes("/esm/") || pattern.startsWith("esm/")) patterns.add(pattern.replace(/\besm\b/g, "src"));
+	return [...patterns];
+};
+const collectFieldEntries = (packageJson, rootDirectory, entries) => {
+	for (const field of PACKAGE_ENTRY_FIELDS) {
+		const entryPath = packageJson[field];
+		if (typeof entryPath === "string") entries.push(resolveEntryPath(entryPath, rootDirectory));
+	}
+};
+const resolveExportEntry = (exportEntry, rootDirectory) => {
+	const resolvedExportEntry = resolveEntryWithExtensions(exportEntry) ?? resolveEntryPathWithExtensions(exportEntry, rootDirectory) ?? resolveSourcePath(exportEntry, rootDirectory);
+	if (resolvedExportEntry && existsSync(resolvedExportEntry)) return resolvedExportEntry;
+	const typescriptReactEntry = exportEntry.endsWith(".ts") ? exportEntry.replace(/\.ts$/, ".tsx") : void 0;
+	if (typescriptReactEntry && existsSync(typescriptReactEntry)) return typescriptReactEntry;
+	return existsSync(exportEntry) ? exportEntry : resolveEntryPath(exportEntry, rootDirectory);
+};
+const collectPackageExportEntries = (exportValue, rootDirectory, entries) => {
+	if (!exportValue) return;
+	const exportEntries = [];
+	collectExportPaths(exportValue, rootDirectory, exportEntries);
+	for (const exportEntry of exportEntries) entries.push(resolveExportEntry(exportEntry, rootDirectory));
+};
+const collectPackageBinEntries = (binValue, rootDirectory, entries) => {
+	if (typeof binValue === "string") {
+		entries.push(resolveEntryPath(binValue, rootDirectory));
+		return;
+	}
+	if (!binValue || typeof binValue !== "object") return;
+	for (const binPath of Object.values(binValue)) if (typeof binPath === "string") entries.push(resolveEntryPath(binPath, rootDirectory));
+};
+const collectSideEffectEntries = (sideEffectValue, rootDirectory, entries) => {
+	if (!Array.isArray(sideEffectValue)) return;
+	for (const sideEffectPattern of sideEffectValue) {
+		if (typeof sideEffectPattern !== "string") continue;
+		for (const sourcePattern of expandSideEffectGlobToSourcePatterns(sideEffectPattern)) entries.push(...findImportableFiles(sourcePattern, rootDirectory, [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**"
+		]));
+	}
+};
+const collectBuildEntries = (buildValue, rootDirectory, entries) => {
+	if (typeof buildValue !== "object" || buildValue === null) return;
+	const buildFileEntries = Reflect.get(buildValue, "files");
+	if (!Array.isArray(buildFileEntries)) return;
+	for (const buildFileEntry of buildFileEntries) {
+		if (typeof buildFileEntry !== "string" || buildFileEntry.includes("*")) continue;
+		const resolvedBuildFile = resolveEntryPathWithExtensions(buildFileEntry, rootDirectory);
+		if (resolvedBuildFile && existsSync(resolvedBuildFile)) entries.push(resolvedBuildFile);
+	}
+};
+const collectJestEntries = (jestValue, rootDirectory, entries) => {
+	if (!jestValue || typeof jestValue !== "object") return;
+	const jestConfigContent = JSON.stringify(jestValue);
+	for (const jestRootDirectoryMatch of jestConfigContent.matchAll(/<rootDir>\/([^"\\]+)/g)) {
+		const resolvedJestFile = resolveEntryPathWithExtensions(jestRootDirectoryMatch[1], rootDirectory);
+		if (resolvedJestFile && existsSync(resolvedJestFile)) entries.push(resolvedJestFile);
+	}
+};
+const extractPackageJsonEntries = async (packageJsonPath) => {
+	const entries = [];
+	try {
+		const content = await readFile(packageJsonPath, "utf-8");
+		const packageJson = JSON.parse(content);
+		const rootDirectory = packageJsonPath.replace(/\/package\.json$/, "");
+		collectFieldEntries(packageJson, rootDirectory, entries);
+		collectPackageExportEntries(packageJson.exports, rootDirectory, entries);
+		collectPackageBinEntries(packageJson.bin, rootDirectory, entries);
+		collectSideEffectEntries(packageJson.sideEffects, rootDirectory, entries);
+		collectBuildEntries(packageJson.build, rootDirectory, entries);
+		collectJestEntries(packageJson.jest, rootDirectory, entries);
+	} catch {}
+	return entries;
+};
+
 //#endregion
 //#region src/collect/entries.ts
 const resolveEntries = async (config) => {
@@ -1418,203 +1658,6 @@ const resolveEntries = async (config) => {
 		alwaysUsedFiles: [...new Set([...toolingDiscovery.alwaysUsedFiles, ...testRunnerDiscovery.alwaysUsedFiles].map(toPosixPath))]
 	};
 };
-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",
-			"style",
-			"source"
-		]) 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) {
-				const resolvedExportEntry = resolveEntryWithExtensions(exportEntry) ?? resolveEntryPathWithExtensions(exportEntry, rootDir) ?? resolveSourcePath(exportEntry, rootDir);
-				if (resolvedExportEntry && existsSync(resolvedExportEntry)) {
-					entries.push(resolvedExportEntry);
-					continue;
-				}
-				if (exportEntry.endsWith(".ts")) {
-					const tsxFallback = exportEntry.replace(/\.ts$/, ".tsx");
-					if (existsSync(tsxFallback)) {
-						entries.push(tsxFallback);
-						continue;
-					}
-				}
-				if (existsSync(exportEntry)) 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));
-			}
-		}
-		if (Array.isArray(packageJson.sideEffects)) for (const sideEffectPattern of packageJson.sideEffects) {
-			if (typeof sideEffectPattern !== "string") continue;
-			const sourcePatterns = expandSideEffectGlobToSourcePatterns(sideEffectPattern);
-			for (const sourcePattern of sourcePatterns) {
-				const matchedSideEffectFiles = fg.sync(sourcePattern, {
-					cwd: rootDir,
-					absolute: true,
-					onlyFiles: true,
-					ignore: [
-						"**/node_modules/**",
-						"**/dist/**",
-						"**/build/**"
-					]
-				});
-				for (const matchedSideEffectFile of matchedSideEffectFiles) if (isImportableSourceFile(matchedSideEffectFile)) entries.push(matchedSideEffectFile);
-			}
-		}
-		if (packageJson.build && typeof packageJson.build === "object") {
-			const buildConfig = packageJson.build;
-			if (Array.isArray(buildConfig.files)) for (const buildFileEntry of buildConfig.files) {
-				if (typeof buildFileEntry !== "string") continue;
-				if (buildFileEntry.includes("*")) continue;
-				const resolvedBuildFile = resolveEntryWithExtensions(resolve(rootDir, buildFileEntry)) ?? resolveEntryPathWithExtensions(buildFileEntry, rootDir);
-				if (resolvedBuildFile && existsSync(resolvedBuildFile)) entries.push(resolvedBuildFile);
-			}
-		}
-		if (packageJson.jest && typeof packageJson.jest === "object") {
-			const jestRootDirMatches = JSON.stringify(packageJson.jest).matchAll(/<rootDir>\/([^"\\]+)/g);
-			for (const jestRootDirMatch of jestRootDirMatches) {
-				const resolvedJestFile = resolveEntryPathWithExtensions(jestRootDirMatch[1], rootDir);
-				if (resolvedJestFile && existsSync(resolvedJestFile)) entries.push(resolvedJestFile);
-			}
-		}
-	} catch {}
-	return entries;
-};
-const expandSideEffectGlobToSourcePatterns = (pattern) => {
-	const patterns = new Set([pattern]);
-	if (pattern.endsWith(".js")) {
-		patterns.add(pattern.replace(/\.js$/, ".ts"));
-		patterns.add(pattern.replace(/\.js$/, ".tsx"));
-	}
-	if (pattern.includes("/lib/") || pattern.startsWith("lib/")) patterns.add(pattern.replace(/\blib\b/g, "src"));
-	if (pattern.includes("/esm/") || pattern.startsWith("esm/")) patterns.add(pattern.replace(/\besm\b/g, "src"));
-	return [...patterns];
-};
 const SHELL_OPERATORS_PATTERN = /\s*(?:&&|\|\||[;&|])\s*/;
 const SCRIPT_MULTIPLEXERS = new Set([
 	"concurrently",
@@ -2575,30 +2618,6 @@ const extractTestSetupFiles = (directory) => {
 	} 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_FRAMEWORK_PATTERNS = [
 	{
 		enablers: [