deslop-js 0.0.20-dev.9342b67 → 0.0.21-dev.3d2e8a1

package/dist/index.d.mts

@@ -47,6 +47,7 @@ interface UnusedExport {
 interface UnusedDependency {
   name: string;
   isDevDependency: boolean;
+  reason: string;
 }
 interface CircularDependency {
   files: string[];
@@ -416,6 +417,7 @@ interface DeslopConfig {
   ignorePatterns: string[];
   includeExtensions: string[];
   tsConfigPath: string | undefined;
+  paths: Record<string, string[]> | undefined;
   reportTypes: boolean;
   includeEntryExports: boolean;
   reportRedundancy: boolean;

package/dist/index.mjs

@@ -4851,7 +4851,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 = fg.sync(["jest.config.{ts,js,mjs,cjs}"], {
 		cwd: directory,
@@ -4873,9 +4873,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 [];
@@ -6292,6 +6292,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();
@@ -6356,6 +6369,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 = 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",
@@ -6387,11 +6444,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",
@@ -6448,15 +6520,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 (isAbsolute(value)) return value;
 	return resolve(configDirectory, value);
 };
-const findWebpackConfigScope = (configPath, rootDir) => {
+const findConfigScope = (configPath, rootDir) => {
 	let currentDirectory = dirname(configPath);
 	const absoluteRoot = resolve(rootDir);
 	while (currentDirectory.length >= absoluteRoot.length) {
@@ -6467,24 +6539,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 = resolve(configDirectory, ...extractQuotedSegments(pathCallSegments));
-			else if (stringTarget) targetDirectory = resolveWebpackPathValue(stringTarget, configDirectory);
+			else if (fileUrlTarget) targetDirectory = resolve(configDirectory, fileUrlTarget);
+			else if (stringTarget) targetDirectory = resolveConfigPathValue(stringTarget, configDirectory);
 			else continue;
 			aliases.push({
 				name,
@@ -6495,6 +6568,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: 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;
@@ -6505,17 +6604,39 @@ const extractWebpackModuleDirectories = (content, configDirectory) => {
 		WEBPACK_PATH_CALL_PATTERN.lastIndex = 0;
 		while ((pathCallMatch = WEBPACK_PATH_CALL_PATTERN.exec(modulesBlock)) !== null) moduleDirectories.push(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 = fg.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(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 = fg.sync([
+		...WEBPACK_CONFIG_GLOBS,
+		...VITE_CONFIG_GLOBS,
+		...BABEL_CONFIG_GLOBS,
+		...JEST_CONFIG_GLOBS
+	], {
 		cwd: rootDir,
 		absolute: true,
 		onlyFiles: true,
@@ -6530,17 +6651,24 @@ const loadWebpackResolverConfigs = (rootDir) => {
 	for (const configPath of configPaths) try {
 		const content = cachedReadFileSync(configPath);
 		const configDirectory = 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: resolve(rootDir),
+		aliases: packageJsonJestAliases,
+		moduleDirectories: []
+	});
 	return configs;
 };
 const createResolver = (config, workspacePackages = [], options = {}) => {
@@ -6579,7 +6707,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 = 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 = resolve(config.rootDir, config.tsConfigPath);
 	else {
@@ -6597,6 +6754,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 = dirname(filePath);
 		const cached = tsconfigPathCache.get(fileDir);
@@ -6743,64 +6901,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 = 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;
-			}
-		}
+		return matchCompiledMapping(specifier, getCompiledPathAliases(tsconfigFile));
 	};
 	const tryResolveFromDirectory = (directory, specifier) => {
 		const candidatePath = resolvePathWithExtensionFallback(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) => resolve(config.rootDir, target))])) : [];
+	const tryResolveViaConfigPaths = (specifier) => compiledConfigPaths.length === 0 ? void 0 : matchCompiledMapping(specifier, compiledConfigPaths);
+	const resolveWorkspaceSubpath = (workspaceDirectory, subpath) => {
+		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)) 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 = dirname(fromFile);
 		const cacheKey = `${fromDir}::${cleanedSpecifier}`;
 		const cached = resolveResultCache.get(cacheKey);
@@ -6830,96 +7051,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 = 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 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);
@@ -6962,10 +7103,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: bundlerAliasResolved,
+				isExternal: false,
+				packageName: void 0
+			};
+			resolveResultCache.set(cacheKey, resolvedResult);
+			return resolvedResult;
+		}
+		const structuralResolved = tryResolveViaWorkspaceStructure(cleanedSpecifier);
+		if (structuralResolved) {
 			const resolvedResult = {
-				resolvedPath: webpackResolved,
+				resolvedPath: structuralResolved,
 				isExternal: false,
 				packageName: void 0
 			};
@@ -7909,9 +8070,11 @@ const detectStalePackages = (graph, config) => {
 	const unusedDependencies = [];
 	for (const dependencyName of candidateUnused) {
 		const isDevDependency = declaredDependencies.get(dependencyName) ?? false;
+		const dependencySection = isDevDependency ? "devDependencies" : "dependencies";
 		unusedDependencies.push({
 			name: dependencyName,
-			isDevDependency
+			isDevDependency,
+			reason: `"${dependencyName}" is declared in ${dependencySection} but is never imported or referenced by any source file, script, or config — remove it from package.json if it is genuinely unused`
 		});
 	}
 	return unusedDependencies;
@@ -12648,6 +12811,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,