deslop-js 0.0.19 → 0.0.20-dev.867c5c6

package/dist/index.cjs

@@ -41,6 +41,7 @@ let node_os = require("node:os");
 node_os = __toESM(node_os, 1);
 let oxc_resolver = require("oxc-resolver");
 let minimatch = require("minimatch");
+let node_child_process = require("node:child_process");
 
 //#region src/constants.ts
 const DEFAULT_EXTENSIONS = [
@@ -348,6 +349,7 @@ const DEFAULT_SEMANTIC_TSCONFIG_NAMES = [
 	"tsconfig.src.json",
 	"jsconfig.json"
 ];
+const GIT_CHECK_IGNORE_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
 
 //#endregion
 //#region src/errors.ts
@@ -4881,7 +4883,7 @@ const extractNextConfigPluginFiles = (directory) => {
 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 STRING_LITERAL_PATTERN$1 = /['"]([^'"]+)['"]/g;
 const extractJestTestMatchPatterns = (directory) => {
 	const configPaths = fast_glob.default.sync(["jest.config.{ts,js,mjs,cjs}"], {
 		cwd: directory,
@@ -4903,9 +4905,9 @@ const extractJestTestMatchPatterns = (directory) => {
 		if (!testMatchMatch) continue;
 		const arrayContent = testMatchMatch[1];
 		const patterns = [];
-		STRING_LITERAL_PATTERN.lastIndex = 0;
+		STRING_LITERAL_PATTERN$1.lastIndex = 0;
 		let itemMatch;
-		while ((itemMatch = STRING_LITERAL_PATTERN.exec(arrayContent)) !== null) patterns.push(itemMatch[1]);
+		while ((itemMatch = STRING_LITERAL_PATTERN$1.exec(arrayContent)) !== null) patterns.push(itemMatch[1]);
 		if (patterns.length > 0) return convertJestTestMatchToGlobs(patterns);
 	} catch {}
 	return [];
@@ -6322,6 +6324,19 @@ const isPlatformBuiltinOrVirtualSpecifier = (specifier) => {
 	return BUILTIN_SUBPATH_NODE_MODULES.has(baseName);
 };
 
+//#endregion
+//#region src/utils/sanitize-import-specifier.ts
+const sanitizeImportSpecifier = (specifier) => {
+	if (specifier.startsWith("node:") || specifier.startsWith("data:") || specifier.includes("://")) return specifier;
+	const lastLoaderSeparator = specifier.lastIndexOf("!");
+	let cleaned = lastLoaderSeparator === -1 ? specifier : specifier.slice(lastLoaderSeparator + 1);
+	const queryIndex = cleaned.indexOf("?");
+	if (queryIndex !== -1) cleaned = cleaned.slice(0, queryIndex);
+	const fragmentIndex = cleaned.indexOf("#", 1);
+	if (fragmentIndex !== -1) cleaned = cleaned.slice(0, fragmentIndex);
+	return cleaned || specifier;
+};
+
 //#endregion
 //#region src/resolver/resolve.ts
 const fileExistsCache = /* @__PURE__ */ new Map();
@@ -6386,6 +6401,50 @@ const resolvePathWithExtensionFallback = (candidatePath) => {
 	}
 	return candidatePath;
 };
+const resolveAliasTarget = (target) => {
+	if (existsAsFile(target)) return target;
+	for (const extension of RESOLVER_EXTENSIONS) if (cachedExistsSync(target + extension)) return target + extension;
+	const sourceTarget = target.replace(/\.[cm]?js$/, "");
+	if (sourceTarget !== target) {
+		for (const extension of RESOLVER_EXTENSIONS) if (cachedExistsSync(sourceTarget + extension)) return sourceTarget + extension;
+	}
+	const indexCandidate = (0, node_path.join)(target, "index");
+	for (const extension of RESOLVER_EXTENSIONS) if (cachedExistsSync(indexCandidate + extension)) return indexCandidate + extension;
+};
+const pathMappingSpecificity = (mapping) => mapping.isWildcard ? mapping.prefix.length + mapping.suffix.length : Number.MAX_SAFE_INTEGER;
+const compilePathMappings = (entries) => {
+	const compiled = [];
+	for (const [pattern, targets] of entries) {
+		const wildcardIndex = pattern.indexOf("*");
+		if (wildcardIndex === -1) compiled.push({
+			prefix: pattern,
+			suffix: "",
+			isWildcard: false,
+			targets
+		});
+		else compiled.push({
+			prefix: pattern.slice(0, wildcardIndex),
+			suffix: pattern.slice(wildcardIndex + 1),
+			isWildcard: true,
+			targets
+		});
+	}
+	compiled.sort((left, right) => pathMappingSpecificity(right) - pathMappingSpecificity(left));
+	return compiled;
+};
+const matchCompiledMapping = (specifier, mappings) => {
+	for (const mapping of mappings) {
+		let matchedWildcard = "";
+		if (mapping.isWildcard) {
+			if (!specifier.startsWith(mapping.prefix) || !specifier.endsWith(mapping.suffix)) continue;
+			matchedWildcard = specifier.slice(mapping.prefix.length, specifier.length - mapping.suffix.length);
+		} else if (specifier !== mapping.prefix) continue;
+		for (const target of mapping.targets) {
+			const resolved = resolveAliasTarget(target.replace("*", matchedWildcard));
+			if (resolved) return resolved;
+		}
+	}
+};
 const COMMON_RESOLVER_OPTIONS = {
 	conditionNames: [
 		"import",
@@ -6417,11 +6476,26 @@ const WEBPACK_CONFIG_GLOBS = [
 	"**/webpack.config*.{js,ts,mjs,cjs}",
 	"**/webpack*.config*.babel.{js,ts}"
 ];
-const WEBPACK_ALIAS_BLOCK_PATTERN = /alias\s*:\s*\{([\s\S]*?)\}/g;
-const WEBPACK_ALIAS_ENTRY_PATTERN = /["']?([@\w$./-]+)["']?\s*:\s*(?:path\.(?:resolve|join)\(\s*__dirname\s*,\s*((?:["'][^"']+["']\s*,?\s*)+)\)|["']([^"']+)["'])/g;
+const VITE_CONFIG_GLOBS = [
+	"vite.config.{js,ts,mjs,cjs,mts,cts}",
+	"vitest.config.{js,ts,mjs,cjs,mts,cts}",
+	"**/vite.config.{js,ts,mjs,cjs,mts,cts}",
+	"**/vitest.config.{js,ts,mjs,cjs,mts,cts}"
+];
+const BABEL_CONFIG_GLOBS = [
+	"babel.config.{js,cjs,mjs,json}",
+	".babelrc",
+	".babelrc.{js,cjs,mjs,json}",
+	"**/babel.config.{js,cjs,mjs,json}"
+];
+const JEST_CONFIG_GLOBS = ["jest.config.{js,ts,mjs,cjs,json}", "**/jest.config.{js,ts,mjs,cjs,json}"];
+const ALIAS_BLOCK_PATTERN = /alias\s*:\s*\{([\s\S]*?)\}/g;
+const ALIAS_ENTRY_PATTERN = /["']?([@\w$./-]+)["']?\s*:\s*(?:path\.(?:resolve|join)\(\s*__dirname\s*,\s*((?:["'][^"']+["']\s*,?\s*)+)\)|fileURLToPath\(\s*new URL\(\s*["']([^"']+)["']\s*,\s*import\.meta\.url\s*\)\s*\)|["']([^"']+)["'])/g;
+const JEST_MODULE_NAME_MAPPER_BLOCK_PATTERN = /moduleNameMapper\s*:\s*\{([\s\S]*?)\}/g;
+const JEST_MODULE_NAME_MAPPER_ENTRY_PATTERN = /["']([^"']+)["']\s*:\s*["']([^"']+)["']/g;
 const WEBPACK_MODULES_BLOCK_PATTERN = /modules\s*:\s*\[([\s\S]*?)\]/g;
 const WEBPACK_PATH_CALL_PATTERN = /path\.(?:resolve|join)\(\s*__dirname\s*,\s*((?:["'][^"']+["']\s*,?\s*)+)\)/g;
-const WEBPACK_STRING_LITERAL_PATTERN = /["']([^"']+)["']/g;
+const STRING_LITERAL_PATTERN = /["']([^"']+)["']/g;
 const TSCONFIG_FILENAMES = [
 	"tsconfig.json",
 	"tsconfig.web.json",
@@ -6478,15 +6552,15 @@ const isInsideDirectory = (filePath, directory) => {
 const extractQuotedSegments = (value) => {
 	const segments = [];
 	let segmentMatch;
-	WEBPACK_STRING_LITERAL_PATTERN.lastIndex = 0;
-	while ((segmentMatch = WEBPACK_STRING_LITERAL_PATTERN.exec(value)) !== null) segments.push(segmentMatch[1]);
+	STRING_LITERAL_PATTERN.lastIndex = 0;
+	while ((segmentMatch = STRING_LITERAL_PATTERN.exec(value)) !== null) segments.push(segmentMatch[1]);
 	return segments;
 };
-const resolveWebpackPathValue = (value, configDirectory) => {
+const resolveConfigPathValue = (value, configDirectory) => {
 	if ((0, node_path.isAbsolute)(value)) return value;
 	return (0, node_path.resolve)(configDirectory, value);
 };
-const findWebpackConfigScope = (configPath, rootDir) => {
+const findConfigScope = (configPath, rootDir) => {
 	let currentDirectory = (0, node_path.dirname)(configPath);
 	const absoluteRoot = (0, node_path.resolve)(rootDir);
 	while (currentDirectory.length >= absoluteRoot.length) {
@@ -6497,24 +6571,25 @@ const findWebpackConfigScope = (configPath, rootDir) => {
 	}
 	return absoluteRoot;
 };
-const extractWebpackAliases = (content, configDirectory) => {
+const extractBundlerAliases = (content, configDirectory) => {
 	const aliases = [];
 	let aliasBlockMatch;
-	WEBPACK_ALIAS_BLOCK_PATTERN.lastIndex = 0;
-	while ((aliasBlockMatch = WEBPACK_ALIAS_BLOCK_PATTERN.exec(content)) !== null) {
+	ALIAS_BLOCK_PATTERN.lastIndex = 0;
+	while ((aliasBlockMatch = ALIAS_BLOCK_PATTERN.exec(content)) !== null) {
 		const aliasBlock = aliasBlockMatch[1];
 		let aliasEntryMatch;
-		WEBPACK_ALIAS_ENTRY_PATTERN.lastIndex = 0;
-		while ((aliasEntryMatch = WEBPACK_ALIAS_ENTRY_PATTERN.exec(aliasBlock)) !== null) {
+		ALIAS_ENTRY_PATTERN.lastIndex = 0;
+		while ((aliasEntryMatch = ALIAS_ENTRY_PATTERN.exec(aliasBlock)) !== null) {
 			const rawName = aliasEntryMatch[1];
 			const pathCallSegments = aliasEntryMatch[2];
-			const stringTarget = aliasEntryMatch[3];
-			if (!pathCallSegments && !stringTarget) continue;
+			const fileUrlTarget = aliasEntryMatch[3];
+			const stringTarget = aliasEntryMatch[4];
 			const isExact = rawName.endsWith("$");
 			const name = isExact ? rawName.slice(0, -1) : rawName.replace(/\/$/, "");
 			let targetDirectory;
 			if (pathCallSegments) targetDirectory = (0, node_path.resolve)(configDirectory, ...extractQuotedSegments(pathCallSegments));
-			else if (stringTarget) targetDirectory = resolveWebpackPathValue(stringTarget, configDirectory);
+			else if (fileUrlTarget) targetDirectory = (0, node_path.resolve)(configDirectory, fileUrlTarget);
+			else if (stringTarget) targetDirectory = resolveConfigPathValue(stringTarget, configDirectory);
 			else continue;
 			aliases.push({
 				name,
@@ -6525,6 +6600,32 @@ const extractWebpackAliases = (content, configDirectory) => {
 	}
 	return aliases;
 };
+const compileJestModuleNameMapperAlias = (pattern, target, configDirectory) => {
+	if (!target.includes("<rootDir>")) return void 0;
+	const isWildcard = pattern.includes("(.*)") || pattern.includes("(.+)");
+	const aliasName = pattern.replace(/^\^/, "").replace(/\$$/, "").replace(/\\(.)/g, "$1").replace(/\/?\((?:\.\*|\.\+)\)$/, "").replace(/\/$/, "");
+	if (!aliasName) return void 0;
+	return {
+		name: aliasName,
+		targetDirectory: (0, node_path.resolve)(target.replace(/<rootDir>/g, configDirectory).replace(/\/?\$\d+$/, "")),
+		isExact: !isWildcard
+	};
+};
+const extractJestModuleNameMapperAliases = (content, configDirectory) => {
+	const aliases = [];
+	let blockMatch;
+	JEST_MODULE_NAME_MAPPER_BLOCK_PATTERN.lastIndex = 0;
+	while ((blockMatch = JEST_MODULE_NAME_MAPPER_BLOCK_PATTERN.exec(content)) !== null) {
+		const block = blockMatch[1];
+		let entryMatch;
+		JEST_MODULE_NAME_MAPPER_ENTRY_PATTERN.lastIndex = 0;
+		while ((entryMatch = JEST_MODULE_NAME_MAPPER_ENTRY_PATTERN.exec(block)) !== null) {
+			const alias = compileJestModuleNameMapperAlias(entryMatch[1], entryMatch[2], configDirectory);
+			if (alias) aliases.push(alias);
+		}
+	}
+	return aliases;
+};
 const extractWebpackModuleDirectories = (content, configDirectory) => {
 	const moduleDirectories = [];
 	let modulesBlockMatch;
@@ -6535,17 +6636,39 @@ const extractWebpackModuleDirectories = (content, configDirectory) => {
 		WEBPACK_PATH_CALL_PATTERN.lastIndex = 0;
 		while ((pathCallMatch = WEBPACK_PATH_CALL_PATTERN.exec(modulesBlock)) !== null) moduleDirectories.push((0, node_path.resolve)(configDirectory, ...extractQuotedSegments(pathCallMatch[1])));
 		let stringMatch;
-		WEBPACK_STRING_LITERAL_PATTERN.lastIndex = 0;
-		while ((stringMatch = WEBPACK_STRING_LITERAL_PATTERN.exec(modulesBlock)) !== null) {
+		STRING_LITERAL_PATTERN.lastIndex = 0;
+		while ((stringMatch = STRING_LITERAL_PATTERN.exec(modulesBlock)) !== null) {
 			const moduleDirectory = stringMatch[1];
 			if (moduleDirectory === "node_modules") continue;
-			moduleDirectories.push(resolveWebpackPathValue(moduleDirectory, configDirectory));
+			moduleDirectories.push(resolveConfigPathValue(moduleDirectory, configDirectory));
 		}
 	}
 	return [...new Set(moduleDirectories)];
 };
-const loadWebpackResolverConfigs = (rootDir) => {
-	const configPaths = fast_glob.default.sync(WEBPACK_CONFIG_GLOBS, {
+const isJestConfigPath = (configPath) => /(?:^|[\\/])jest\.config\.[^\\/]+$/.test(configPath);
+const isWebpackConfigPath = (configPath) => /webpack/.test(configPath);
+const extractPackageJsonJestAliases = (rootDir) => {
+	try {
+		const moduleNameMapper = JSON.parse(cachedReadFileSync((0, node_path.join)(rootDir, "package.json")))?.jest?.moduleNameMapper;
+		if (!moduleNameMapper || typeof moduleNameMapper !== "object") return [];
+		const aliases = [];
+		for (const [pattern, target] of Object.entries(moduleNameMapper)) {
+			if (typeof target !== "string") continue;
+			const alias = compileJestModuleNameMapperAlias(pattern, target, rootDir);
+			if (alias) aliases.push(alias);
+		}
+		return aliases;
+	} catch {
+		return [];
+	}
+};
+const loadBundlerAliasConfigs = (rootDir) => {
+	const configPaths = fast_glob.default.sync([
+		...WEBPACK_CONFIG_GLOBS,
+		...VITE_CONFIG_GLOBS,
+		...BABEL_CONFIG_GLOBS,
+		...JEST_CONFIG_GLOBS
+	], {
 		cwd: rootDir,
 		absolute: true,
 		onlyFiles: true,
@@ -6560,17 +6683,24 @@ const loadWebpackResolverConfigs = (rootDir) => {
 	for (const configPath of configPaths) try {
 		const content = cachedReadFileSync(configPath);
 		const configDirectory = (0, node_path.dirname)(configPath);
-		const aliases = extractWebpackAliases(content, configDirectory);
-		const moduleDirectories = extractWebpackModuleDirectories(content, configDirectory);
+		const aliases = extractBundlerAliases(content, configDirectory);
+		if (isJestConfigPath(configPath)) aliases.push(...extractJestModuleNameMapperAliases(content, configDirectory));
+		const moduleDirectories = isWebpackConfigPath(configPath) ? extractWebpackModuleDirectories(content, configDirectory) : [];
 		if (aliases.length === 0 && moduleDirectories.length === 0) continue;
 		configs.push({
-			scopeDirectory: findWebpackConfigScope(configPath, rootDir),
+			scopeDirectory: findConfigScope(configPath, rootDir),
 			aliases,
 			moduleDirectories
 		});
 	} catch {
 		continue;
 	}
+	const packageJsonJestAliases = extractPackageJsonJestAliases(rootDir);
+	if (packageJsonJestAliases.length > 0) configs.push({
+		scopeDirectory: (0, node_path.resolve)(rootDir),
+		aliases: packageJsonJestAliases,
+		moduleDirectories: []
+	});
 	return configs;
 };
 const createResolver = (config, workspacePackages = [], options = {}) => {
@@ -6609,7 +6739,36 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 	};
 	const workspaceNameToDirectory = /* @__PURE__ */ new Map();
 	for (const workspacePackage of workspacePackages) workspaceNameToDirectory.set(workspacePackage.name, workspacePackage.directory);
-	const webpackResolverConfigs = (options.monorepoRoot && options.monorepoRoot !== config.rootDir ? [config.rootDir, options.monorepoRoot] : [config.rootDir]).flatMap(loadWebpackResolverConfigs).sort((leftConfig, rightConfig) => rightConfig.scopeDirectory.length - leftConfig.scopeDirectory.length);
+	const structuralAliasToDirectory = /* @__PURE__ */ new Map();
+	const workspaceScopes = /* @__PURE__ */ new Set();
+	for (const workspacePackage of workspacePackages) {
+		if (!workspacePackage.name.startsWith("@")) continue;
+		const slashIndex = workspacePackage.name.indexOf("/");
+		if (slashIndex !== -1) workspaceScopes.add(workspacePackage.name.slice(0, slashIndex));
+	}
+	if (workspaceScopes.size > 0) {
+		const ambiguousStructuralKeys = /* @__PURE__ */ new Set();
+		const registerStructuralAlias = (aliasKey, directory) => {
+			if (workspaceNameToDirectory.has(aliasKey)) return;
+			const existing = structuralAliasToDirectory.get(aliasKey);
+			if (existing !== void 0 && existing !== directory) {
+				ambiguousStructuralKeys.add(aliasKey);
+				return;
+			}
+			structuralAliasToDirectory.set(aliasKey, directory);
+		};
+		for (const workspacePackage of workspacePackages) {
+			const directoryBasename = (0, node_path.basename)(workspacePackage.directory);
+			const slashIndex = workspacePackage.name.indexOf("/");
+			const unscopedName = workspacePackage.name.startsWith("@") && slashIndex !== -1 ? workspacePackage.name.slice(slashIndex + 1) : workspacePackage.name;
+			for (const scope of workspaceScopes) {
+				registerStructuralAlias(`${scope}/${directoryBasename}`, workspacePackage.directory);
+				if (unscopedName && unscopedName !== directoryBasename) registerStructuralAlias(`${scope}/${unscopedName}`, workspacePackage.directory);
+			}
+		}
+		for (const ambiguousKey of ambiguousStructuralKeys) structuralAliasToDirectory.delete(ambiguousKey);
+	}
+	const bundlerAliasConfigs = (options.monorepoRoot && options.monorepoRoot !== config.rootDir ? [config.rootDir, options.monorepoRoot] : [config.rootDir]).flatMap(loadBundlerAliasConfigs).sort((leftConfig, rightConfig) => rightConfig.scopeDirectory.length - leftConfig.scopeDirectory.length);
 	let rootTsconfigPath;
 	if (config.tsConfigPath) rootTsconfigPath = (0, node_path.resolve)(config.rootDir, config.tsConfigPath);
 	else {
@@ -6627,6 +6786,7 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 	}
 	const tsconfigPathCache = /* @__PURE__ */ new Map();
 	const tsconfigPathAliasCache = /* @__PURE__ */ new Map();
+	const tsconfigCompiledAliasCache = /* @__PURE__ */ new Map();
 	const findTsconfigForFile = (filePath) => {
 		const fileDir = (0, node_path.dirname)(filePath);
 		const cached = tsconfigPathCache.get(fileDir);
@@ -6773,64 +6933,127 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 		tsconfigPathAliasCache.set(tsconfigFile, aliasMap);
 		return aliasMap;
 	};
+	const getCompiledPathAliases = (tsconfigFile) => {
+		const cached = tsconfigCompiledAliasCache.get(tsconfigFile);
+		if (cached) return cached;
+		const compiled = compilePathMappings(getPathAliases(tsconfigFile));
+		tsconfigCompiledAliasCache.set(tsconfigFile, compiled);
+		return compiled;
+	};
 	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 = (0, node_path.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 = (0, node_path.join)(resolvedTarget, "index");
-				for (const ext of RESOLVER_EXTENSIONS) if (cachedExistsSync(indexCandidate + ext)) return indexCandidate + ext;
-			}
-		}
+		return matchCompiledMapping(specifier, getCompiledPathAliases(tsconfigFile));
 	};
 	const tryResolveFromDirectory = (directory, specifier) => {
 		const candidatePath = resolvePathWithExtensionFallback((0, node_path.resolve)(directory, specifier));
 		if (existsAsFile(candidatePath)) return candidatePath;
 	};
-	const tryResolveViaWebpackConfig = (specifier, fromFile) => {
-		if (webpackResolverConfigs.length === 0) return void 0;
+	const tryResolveViaBundlerAlias = (specifier, fromFile) => {
+		if (bundlerAliasConfigs.length === 0) return void 0;
 		if (!isBareSpecifier(specifier)) return void 0;
-		for (const webpackConfig of webpackResolverConfigs) {
-			if (!isInsideDirectory(fromFile, webpackConfig.scopeDirectory)) continue;
-			for (const alias of webpackConfig.aliases) {
+		for (const bundlerConfig of bundlerAliasConfigs) {
+			if (!isInsideDirectory(fromFile, bundlerConfig.scopeDirectory)) continue;
+			for (const alias of bundlerConfig.aliases) {
 				if (alias.isExact && specifier !== alias.name) continue;
 				const suffix = specifier === alias.name ? "" : specifier.startsWith(`${alias.name}/`) ? specifier.slice(alias.name.length + 1) : void 0;
 				if (suffix === void 0) continue;
 				const aliasCandidate = tryResolveFromDirectory(alias.targetDirectory, suffix);
 				if (aliasCandidate) return aliasCandidate;
 			}
-			for (const moduleDirectory of webpackConfig.moduleDirectories) {
+			for (const moduleDirectory of bundlerConfig.moduleDirectories) {
 				const moduleCandidate = tryResolveFromDirectory(moduleDirectory, specifier);
 				if (moduleCandidate) return moduleCandidate;
 			}
 		}
 	};
+	const compiledConfigPaths = config.paths ? compilePathMappings(Object.entries(config.paths).map(([pattern, targets]) => [pattern, targets.map((target) => (0, node_path.resolve)(config.rootDir, target))])) : [];
+	const tryResolveViaConfigPaths = (specifier) => compiledConfigPaths.length === 0 ? void 0 : matchCompiledMapping(specifier, compiledConfigPaths);
+	const resolveWorkspaceSubpath = (workspaceDirectory, subpath) => {
+		const workspacePackageJsonPath = (0, node_path.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((0, node_path.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((0, node_path.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((0, node_path.resolve)(workspaceDirectory, wildcardTargetValue.replace("*", matchedSegment)));
+						resolvedEntryPath = existsAsFile(candidatePath) ? candidatePath : trySourceFallback(candidatePath);
+						break;
+					}
+				}
+			}
+			if (subpath && !resolvedEntryPath) {
+				const subpathCandidates = [(0, node_path.resolve)(workspaceDirectory, subpath), (0, node_path.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 = (0, node_path.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 = (0, node_path.resolve)(workspaceDirectory, mainField);
+				if (!resolvedEntryPath && workspacePackageJson.exports?.["."]) {
+					const dotExport = workspacePackageJson.exports["."];
+					if (typeof dotExport === "string") resolvedEntryPath = (0, node_path.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 = (0, node_path.resolve)(workspaceDirectory, conditionValue);
+					}
+				}
+			}
+			if (resolvedEntryPath) {
+				const finalPath = resolveSourcePath(resolvedEntryPath, workspaceDirectory) ?? resolvedEntryPath;
+				if (cachedExistsSync(finalPath)) return finalPath;
+				const sourceFallbackPath = trySourceFallback(resolvedEntryPath);
+				if (sourceFallbackPath) return sourceFallbackPath;
+			}
+		} catch {}
+	};
+	const tryResolveViaWorkspaceStructure = (specifier) => {
+		if (structuralAliasToDirectory.size === 0) return void 0;
+		if (!isBareSpecifier(specifier)) return void 0;
+		const packageKey = extractPackageNameFromSpecifier(specifier);
+		const directory = structuralAliasToDirectory.get(packageKey);
+		if (!directory) return void 0;
+		return resolveWorkspaceSubpath(directory, specifier.length > packageKey.length ? specifier.slice(packageKey.length + 1) : "");
+	};
 	const resolveModule = (specifier, fromFile) => {
-		const queryIndex = specifier.indexOf("?");
-		const cleanedSpecifier = queryIndex !== -1 ? specifier.slice(0, queryIndex) : specifier;
+		const cleanedSpecifier = sanitizeImportSpecifier(specifier);
 		const fromDir = (0, node_path.dirname)(fromFile);
 		const cacheKey = `${fromDir}::${cleanedSpecifier}`;
 		const cached = resolveResultCache.get(cacheKey);
@@ -6860,96 +7083,16 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 			const packageName = extractPackageNameFromSpecifier(cleanedSpecifier);
 			const workspaceDirectory = workspaceNameToDirectory.get(packageName);
 			if (workspaceDirectory) {
-				const subpath = cleanedSpecifier.slice(packageName.length + 1);
-				const workspacePackageJsonPath = (0, node_path.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((0, node_path.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((0, node_path.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((0, node_path.resolve)(workspaceDirectory, wildcardTargetValue.replace("*", matchedSegment)));
-								resolvedEntryPath = existsAsFile(candidatePath) ? candidatePath : trySourceFallback(candidatePath);
-								break;
-							}
-						}
-					}
-					if (subpath && !resolvedEntryPath) {
-						const subpathCandidates = [(0, node_path.resolve)(workspaceDirectory, subpath), (0, node_path.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 = (0, node_path.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 = (0, node_path.resolve)(workspaceDirectory, mainField);
-						if (!resolvedEntryPath && workspacePackageJson.exports?.["."]) {
-							const dotExport = workspacePackageJson.exports["."];
-							if (typeof dotExport === "string") resolvedEntryPath = (0, node_path.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 = (0, node_path.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 resolvedWorkspacePath = resolveWorkspaceSubpath(workspaceDirectory, cleanedSpecifier.slice(packageName.length + 1));
+				if (resolvedWorkspacePath) {
+					const resolvedResult = {
+						resolvedPath: resolvedWorkspacePath,
+						isExternal: false,
+						packageName: void 0
+					};
+					resolveResultCache.set(cacheKey, resolvedResult);
+					return resolvedResult;
+				}
 			}
 		}
 		const tsconfigForFile = findTsconfigForFile(fromFile);
@@ -6992,10 +7135,30 @@ const createResolver = (config, workspacePackages = [], options = {}) => {
 			resolveResultCache.set(cacheKey, resolvedResult);
 			return resolvedResult;
 		}
-		const webpackResolved = tryResolveViaWebpackConfig(cleanedSpecifier, fromFile);
-		if (webpackResolved) {
+		const configPathResolved = tryResolveViaConfigPaths(cleanedSpecifier);
+		if (configPathResolved) {
+			const resolvedResult = {
+				resolvedPath: configPathResolved,
+				isExternal: false,
+				packageName: void 0
+			};
+			resolveResultCache.set(cacheKey, resolvedResult);
+			return resolvedResult;
+		}
+		const bundlerAliasResolved = tryResolveViaBundlerAlias(cleanedSpecifier, fromFile);
+		if (bundlerAliasResolved) {
 			const resolvedResult = {
-				resolvedPath: webpackResolved,
+				resolvedPath: bundlerAliasResolved,
+				isExternal: false,
+				packageName: void 0
+			};
+			resolveResultCache.set(cacheKey, resolvedResult);
+			return resolvedResult;
+		}
+		const structuralResolved = tryResolveViaWorkspaceStructure(cleanedSpecifier);
+		if (structuralResolved) {
+			const resolvedResult = {
+				resolvedPath: structuralResolved,
 				isExternal: false,
 				packageName: void 0
 			};
@@ -7177,7 +7340,8 @@ const buildDependencyGraph = (inputs) => {
 		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)
+		isConfigFile: isConfigFile(input.fileId.path),
+		isGitIgnored: input.isGitIgnored
 	}));
 	const edges = [];
 	const reverseEdges = /* @__PURE__ */ new Map();
@@ -7514,6 +7678,7 @@ const detectOrphanFiles = (graph) => {
 		if (module.isEntryPoint) continue;
 		if (module.isDeclarationFile) continue;
 		if (module.isConfigFile) continue;
+		if (module.isGitIgnored) continue;
 		if (hasExcludedExtension(module.fileId.path)) continue;
 		if (isExcludedByPattern(module.fileId.path)) continue;
 		if (isOpaqueToAnalysis(module)) continue;
@@ -7548,6 +7713,7 @@ const detectDeadExports = (graph, config) => {
 	for (const module of graph.modules) {
 		if (!module.isReachable) continue;
 		if (module.isDeclarationFile) continue;
+		if (module.isGitIgnored) continue;
 		if (module.isEntryPoint && !config.includeEntryExports) continue;
 		const defaultExportLinkedNames = /* @__PURE__ */ new Set();
 		for (const exportInfo of module.exports) if (exportInfo.isDefault && exportInfo.defaultExportLocalName && usageMap.has(`${module.fileId.path}::default`)) defaultExportLinkedNames.add(exportInfo.defaultExportLocalName);
@@ -12482,6 +12648,64 @@ const generateReport = (graph, config) => {
 	};
 };
 
+//#endregion
+//#region src/utils/collect-git-ignored-paths.ts
+/**
+* Returns the subset of `candidatePaths` that git considers ignored.
+*
+* `--no-index` is load-bearing: without it `git check-ignore` stays silent for
+* any path already tracked in the index, so generated files that were committed
+* once (then later gitignored) would not be reported. We want the ignore *rules*
+* to decide, independent of tracking state.
+*
+* `core.excludesFile=<devNull>` scopes the result to the analyzed project's own
+* ignore rules: a developer's personal global gitignore must not change which
+* files deslop reports, otherwise the same project yields different findings on
+* different machines.
+*
+* `gitUnavailable` is true only when the `git` binary could not be launched
+* (e.g. not installed → `ENOENT`). A non-git directory is normal: git exits 128
+* and often closes stdin before reading it, which surfaces as an `EPIPE` on the
+* input write — that is reported as available-but-empty, not a failure. Every
+* failure still degrades to an empty set so callers never crash. Exit status 1
+* means "no matches", not an error.
+*/
+const collectGitIgnoredPaths = (rootDirectory, candidatePaths) => {
+	if (candidatePaths.length === 0) return {
+		ignoredPaths: /* @__PURE__ */ new Set(),
+		gitUnavailable: false
+	};
+	const result = (0, node_child_process.spawnSync)("git", [
+		"-c",
+		`core.excludesFile=${node_os.devNull}`,
+		"check-ignore",
+		"--no-index",
+		"--stdin",
+		"-z"
+	], {
+		cwd: rootDirectory,
+		input: candidatePaths.join("\0"),
+		encoding: "utf-8",
+		maxBuffer: GIT_CHECK_IGNORE_MAX_BUFFER_BYTES
+	});
+	if (result.error) {
+		const gitBinaryMissing = "code" in result.error && result.error.code === "ENOENT";
+		return {
+			ignoredPaths: /* @__PURE__ */ new Set(),
+			gitUnavailable: gitBinaryMissing
+		};
+	}
+	if (result.status === null || result.status > 1) return {
+		ignoredPaths: /* @__PURE__ */ new Set(),
+		gitUnavailable: false
+	};
+	const ignoredPaths = result.stdout.split("\0").filter((entry) => entry.length > 0);
+	return {
+		ignoredPaths: new Set(ignoredPaths),
+		gitUnavailable: false
+	};
+};
+
 //#endregion
 //#region src/index.ts
 const STYLE_EXTENSIONS = [".css", ".scss"];
@@ -12617,6 +12841,7 @@ const defineConfig = (options) => ({
 	ignorePatterns: options.ignorePatterns ?? [],
 	includeExtensions: options.includeExtensions ?? DEFAULT_EXTENSIONS,
 	tsConfigPath: options.tsConfigPath,
+	paths: options.paths,
 	reportTypes: options.reportTypes ?? false,
 	includeEntryExports: options.includeEntryExports ?? false,
 	reportRedundancy: options.reportRedundancy ?? true,
@@ -12767,6 +12992,14 @@ const analyze = async (config) => {
 	const productionEntrySet = new Set(discoveredEntries.productionEntries);
 	const testEntrySet = new Set(discoveredEntries.testEntries);
 	const alwaysUsedFileSet = new Set(discoveredEntries.alwaysUsedFiles);
+	const gitIgnoreResult = collectGitIgnoredPaths((0, node_path.resolve)(config.rootDir), files.map((file) => file.path));
+	const gitIgnoredFileSet = gitIgnoreResult.ignoredPaths;
+	if (gitIgnoreResult.gitUnavailable) setupErrors.push(new WorkspaceError({
+		code: "gitignore-check-failed",
+		severity: "info",
+		message: "git unavailable — .gitignore filtering skipped",
+		path: config.rootDir
+	}));
 	let hasReactNative = false;
 	try {
 		hasReactNative = detectReactNative(config.rootDir, workspacePackages);
@@ -12855,7 +13088,8 @@ const analyze = async (config) => {
 			parsed: parsedModule,
 			resolvedImports: resolvedImportMap,
 			isEntryPoint: isAlwaysUsed || productionEntrySet.has(file.path) || testEntrySet.has(file.path),
-			isTestEntry: testEntrySet.has(file.path)
+			isTestEntry: testEntrySet.has(file.path),
+			isGitIgnored: gitIgnoredFileSet.has(file.path)
 		});
 	}
 	const discoveredFilePaths = new Set(files.map((file) => file.path));
@@ -12901,7 +13135,8 @@ const analyze = async (config) => {
 			parsed: parsedStyleModule,
 			resolvedImports: resolvedStyleImportMap,
 			isEntryPoint: false,
-			isTestEntry: false
+			isTestEntry: false,
+			isGitIgnored: gitIgnoredFileSet.has(styleFilePath)
 		});
 		discoveredFilePaths.add(styleFilePath);
 		nextFileIndex++;