@monoes/monograph 1.5.6 → 1.5.8

package/src/graph/resolve/dynamic-imports.ts

@@ -1,102 +0,0 @@
-// Resolve import() calls into structured import entries.
-
-export type DynamicImportPattern =
-  | { kind: 'string'; value: string }
-  | { kind: 'template'; prefix: string; suffix: string }
-  | { kind: 'expression' };
-
-export interface DynamicImportInfo {
-  pattern: DynamicImportPattern;
-  importedNames: string[];   // destructured: `const { a } = await import('./x')` → ['a']
-  namespaceLocal?: string;   // `const ns = await import('./x')` → 'ns'
-  isSideEffect: boolean;
-  line: number;
-}
-
-export interface ResolvedDynamicImport {
-  source: DynamicImportInfo;
-  resolvedPaths: string[];   // matched file paths
-  isGlob: boolean;
-}
-
-/** Parse dynamic import calls from source text. */
-export function parseDynamicImports(source: string): DynamicImportInfo[] {
-  const results: DynamicImportInfo[] = [];
-  const lines = source.split('\n');
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (!line.includes('import(')) continue;
-
-    // Template literal: import(`./routes/${name}`)
-    const tmplM = /import\(`([^`]*)\$\{[^}]+\}([^`]*)`\)/.exec(line);
-    if (tmplM) {
-      results.push({
-        pattern: { kind: 'template', prefix: tmplM[1], suffix: tmplM[2] },
-        importedNames: [],
-        isSideEffect: true,
-        line: i + 1,
-      });
-      continue;
-    }
-
-    // String literal: import('./foo')
-    const strM = /import\(\s*['"`]([^'"`]+)['"`]\s*\)/.exec(line);
-    if (!strM) continue;
-
-    const path = strM[1];
-
-    // Destructured await: const { a, b } = await import('./x')
-    const destructM = /const\s+\{([^}]+)\}\s*=\s*await\s+import/.exec(line);
-    if (destructM) {
-      const names = destructM[1].split(',').map(s => s.trim().split(/\s+as\s+/)[0].trim()).filter(Boolean);
-      results.push({ pattern: { kind: 'string', value: path }, importedNames: names, isSideEffect: false, line: i + 1 });
-      continue;
-    }
-
-    // Namespace: const ns = await import('./x')
-    const nsM = /const\s+([a-zA-Z_$][\w$]*)\s*=\s*await\s+import/.exec(line);
-    if (nsM) {
-      results.push({ pattern: { kind: 'string', value: path }, importedNames: [], namespaceLocal: nsM[1], isSideEffect: false, line: i + 1 });
-      continue;
-    }
-
-    // Bare side-effect: await import('./x') or import('./x').then(...)
-    results.push({ pattern: { kind: 'string', value: path }, importedNames: [], isSideEffect: true, line: i + 1 });
-  }
-
-  return results;
-}
-
-/** Expand a template-literal import to a glob pattern. */
-export function templateToGlob(prefix: string, suffix: string): string {
-  return `${prefix}*${suffix}`;
-}
-
-/** Match a glob pattern against a list of file paths (simple prefix+suffix matching). */
-export function matchGlob(pattern: string, files: string[]): string[] {
-  const [pre, suf = ''] = pattern.split('*');
-  return files.filter(f => f.includes(pre) && (suf === '' || f.endsWith(suf)));
-}
-
-/** Resolve a single dynamic import info against a list of known file paths. */
-export function resolveSingleDynamicImport(
-  info: DynamicImportInfo,
-  allFiles: string[],
-  currentDir: string,
-): ResolvedDynamicImport {
-  if (info.pattern.kind === 'expression') {
-    return { source: info, resolvedPaths: [], isGlob: false };
-  }
-  if (info.pattern.kind === 'template') {
-    const glob = templateToGlob(
-      currentDir + '/' + info.pattern.prefix,
-      info.pattern.suffix,
-    );
-    return { source: info, resolvedPaths: matchGlob(glob, allFiles), isGlob: true };
-  }
-  // String literal
-  const target = info.pattern.value;
-  const resolved = allFiles.find(f => f.endsWith(target.replace(/^\.\//, '/'))) ?? target;
-  return { source: info, resolvedPaths: [resolved], isGlob: false };
-}

package/src/graph/resolve/fallbacks.ts

@@ -1,79 +0,0 @@
-import * as path from 'node:path';
-import type { ResolveContext, ResolveResult, FileId, DynamicImportPattern, DiscoveredFile } from './types.js';
-import { OUTPUT_DIRS } from './types.js';
-import { extractPackageNameFromNodeModulesPath } from './path-info.js';
-
-export function trySourceFallback(canonical: string, pathToId: Map<string, FileId>): FileId | null {
-  const normalized = canonical.replace(/\\/g, '/');
-  for (const outDir of OUTPUT_DIRS) {
-    const pattern = `/${outDir}/`;
-    if (normalized.includes(pattern)) {
-      const sourcePath = normalized.replace(pattern, '/src/');
-      const id = pathToId.get(sourcePath);
-      if (id !== undefined) return id;
-    }
-  }
-  return null;
-}
-
-export function tryPnpmWorkspaceFallback(
-  canonical: string,
-  pathToId: Map<string, FileId>,
-  workspaceRoots: Map<string, string>,
-): FileId | null {
-  const normalized = canonical.replace(/\\/g, '/');
-  const pnpmStore = 'node_modules/.pnpm/';
-  const idx = normalized.indexOf(pnpmStore);
-  if (idx === -1) return null;
-  const afterStore = normalized.slice(idx + pnpmStore.length);
-  const nodeModulesIdx = afterStore.indexOf('/node_modules/');
-  if (nodeModulesIdx === -1) return null;
-  const subpath = afterStore.slice(nodeModulesIdx + '/node_modules/'.length);
-  for (const [, wsRoot] of workspaceRoots) {
-    const candidate = path.join(wsRoot, 'node_modules', subpath);
-    const id = pathToId.get(candidate);
-    if (id !== undefined) return id;
-  }
-  return null;
-}
-
-export function tryWorkspacePackageFallback(
-  ctx: ResolveContext,
-  specifier: string,
-): ResolveResult | null {
-  for (const [pkgName, wsRoot] of ctx.workspaceRoots) {
-    if (specifier === pkgName || specifier.startsWith(pkgName + '/')) {
-      const subpath = specifier.slice(pkgName.length);
-      const candidate = path.join(wsRoot, subpath || 'index');
-      const id = ctx.pathToId.get(candidate);
-      if (id !== undefined) return { kind: 'InternalModule', fileId: id };
-    }
-  }
-  return null;
-}
-
-export function makeGlobFromPattern(pattern: DynamicImportPattern): string {
-  return pattern.pattern
-    .replace(/\$\{[^}]+\}/g, '*')
-    .replace(/\+/g, '*')
-    .replace(/\(\?:[^)]+\)/g, '*');
-}
-
-export function tryScssIncludePathFallback(
-  ctx: ResolveContext,
-  _fromFile: string,
-  specifier: string,
-  fromStyle: boolean,
-): ResolveResult | null {
-  if (!fromStyle) return null;
-  for (const includePath of ctx.scssIncludePaths) {
-    const candidate = path.join(includePath, specifier);
-    const id = ctx.pathToId.get(candidate);
-    if (id !== undefined) return { kind: 'InternalModule', fileId: id };
-    for (const ext of ['.scss', '.sass', '.css']) {
-      const withExt = ctx.pathToId.get(candidate + ext);
-      if (withExt !== undefined) return { kind: 'InternalModule', fileId: withExt };
-    }
-  }
-  return null;
-}

package/src/graph/resolve/index.ts

@@ -1,68 +0,0 @@
-import type { ResolveContext, ResolvedModule, DiscoveredFile, WorkspaceInfo, FileId } from './types.js';
-import { makeResolvedModule } from './types.js';
-import { resolveStaticImports } from './static-imports.js';
-import { resolveReExports } from './re-exports.js';
-import { applySpecifierUpgrades } from './upgrades.js';
-import { extractPackageNameFromNodeModulesPath } from './path-info.js';
-
-export * from './types.js';
-export * from './path-info.js';
-export * from './specifier.js';
-export * from './static-imports.js';
-export * from './require-imports.js';
-export * from './re-exports.js';
-export * from './fallbacks.js';
-export * from './react-native.js';
-export * from './upgrades.js';
-
-export interface ModuleInfo {
-  fileId: FileId;
-  path: string;
-  imports: Array<{ specifier: string; isDynamic?: boolean; isTypeOnly?: boolean }>;
-  reExports: Array<{ specifier: string; isTypeOnly?: boolean }>;
-  hasCjsExports?: boolean;
-}
-
-export function resolveAllImports(
-  modules: ModuleInfo[],
-  files: DiscoveredFile[],
-  workspaces: WorkspaceInfo[],
-  activePlugins: string[],
-  pathAliases: Array<[string, string]>,
-  scssIncludePaths: string[],
-  root: string,
-  extraConditions: string[],
-): ResolvedModule[] {
-  const pathToId = new Map<string, FileId>(files.map(f => [f.path, f.fileId]));
-  const rawPathToId = new Map<string, FileId>(
-    files.filter(f => f.canonicalPath).map(f => [f.canonicalPath!, f.fileId])
-  );
-  const workspaceRoots = new Map<string, string>(
-    workspaces.filter(w => w.name).map(w => [w.name!, w.root])
-  );
-
-  const ctx: ResolveContext = {
-    pathToId,
-    rawPathToId,
-    workspaceRoots,
-    pathAliases,
-    scssIncludePaths,
-    root,
-    tsconfigWarned: new Set(),
-    activePlugins,
-    extraConditions,
-  };
-
-  const resolved = modules.map(mod => {
-    const rm = makeResolvedModule(mod.fileId, mod.path);
-    rm.resolvedImports = resolveStaticImports(ctx, mod.path, mod.imports);
-    rm.resolvedReExports = resolveReExports(ctx, mod.path, mod.reExports);
-    rm.hasCjsExports = mod.hasCjsExports ?? false;
-    return rm;
-  });
-
-  applySpecifierUpgrades(resolved);
-  return resolved;
-}
-
-export { extractPackageNameFromNodeModulesPath };

package/src/graph/resolve/path-info.ts

@@ -1,41 +0,0 @@
-const PATH_ALIAS_PREFIXES = ['@/', '~/', '#', '@@/'];
-const PASCAL_SCOPE_RE = /^@[A-Z]/;
-const PACKAGE_NAME_RE = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/i;
-
-export function isPathAlias(specifier: string): boolean {
-  for (const prefix of PATH_ALIAS_PREFIXES) {
-    if (specifier.startsWith(prefix)) return true;
-  }
-  return PASCAL_SCOPE_RE.test(specifier);
-}
-
-export function isBareSpecifier(specifier: string): boolean {
-  if (specifier.startsWith('.') || specifier.startsWith('/')) return false;
-  if (specifier.startsWith('node:') || specifier.startsWith('bun:')) return false;
-  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(specifier)) return false;
-  return true;
-}
-
-export function isValidPackageName(name: string): boolean {
-  return PACKAGE_NAME_RE.test(name);
-}
-
-export function extractPackageName(specifier: string): string {
-  if (specifier.startsWith('@')) {
-    const parts = specifier.split('/');
-    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : specifier;
-  }
-  return specifier.split('/')[0];
-}
-
-export function extractPackageNameFromNodeModulesPath(path: string): string | null {
-  const normalized = path.replace(/\\/g, '/');
-  const idx = normalized.lastIndexOf('node_modules/');
-  if (idx === -1) return null;
-  const after = normalized.slice(idx + 'node_modules/'.length);
-  if (after.startsWith('@')) {
-    const parts = after.split('/');
-    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : null;
-  }
-  return after.split('/')[0] || null;
-}

package/src/graph/resolve/re-exports.ts

@@ -1,14 +0,0 @@
-import type { ResolveContext, ResolvedReExport, ReExportInfo } from './types.js';
-import { resolveSpecifier, isStyleFile } from './specifier.js';
-
-export function resolveReExports(
-  ctx: ResolveContext,
-  filePath: string,
-  reExports: ReExportInfo[],
-): ResolvedReExport[] {
-  const fromStyle = isStyleFile(filePath);
-  return reExports.map(info => ({
-    info,
-    target: resolveSpecifier(ctx, filePath, info.specifier, fromStyle),
-  }));
-}

package/src/graph/resolve/react-native.ts

@@ -1,27 +0,0 @@
-const REACT_NATIVE_PLUGINS = ['react-native', 'expo', '@react-native'];
-const BASE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
-const RN_SUFFIXES = ['.native', '.ios', '.android', '.web'];
-const BASE_CONDITIONS = ['import', 'require', 'default'];
-const RN_CONDITIONS = ['react-native', 'browser', 'module'];
-
-export function hasReactNativePlugin(activePlugins: string[]): boolean {
-  return activePlugins.some(p => REACT_NATIVE_PLUGINS.some(rn => p.includes(rn)));
-}
-
-export function buildExtensions(activePlugins: string[]): string[] {
-  if (!hasReactNativePlugin(activePlugins)) return BASE_EXTENSIONS;
-  const rnExts: string[] = [];
-  for (const suffix of RN_SUFFIXES) {
-    for (const ext of ['.ts', '.tsx', '.js', '.jsx']) {
-      rnExts.push(suffix + ext);
-    }
-  }
-  return [...rnExts, ...BASE_EXTENSIONS];
-}
-
-export function buildConditionNames(activePlugins: string[], extraConditions: string[]): string[] {
-  const conditions = [...BASE_CONDITIONS];
-  if (hasReactNativePlugin(activePlugins)) conditions.unshift(...RN_CONDITIONS);
-  conditions.push(...extraConditions);
-  return [...new Set(conditions)];
-}

package/src/graph/resolve/require-imports.ts

@@ -1,18 +0,0 @@
-import type { ResolveContext, ResolvedImport, ImportInfo } from './types.js';
-import { resolveSpecifier } from './specifier.js';
-
-export interface RequireCallInfo {
-  specifier: string;
-  span?: { start: number; end: number };
-}
-
-export function resolveRequireImports(
-  ctx: ResolveContext,
-  filePath: string,
-  requireCalls: RequireCallInfo[],
-): ResolvedImport[] {
-  return requireCalls.map(req => {
-    const info: ImportInfo = { specifier: req.specifier, isDynamic: true, span: req.span };
-    return { info, target: resolveSpecifier(ctx, filePath, req.specifier, false) };
-  });
-}

package/src/graph/resolve/specifier.ts

@@ -1,120 +0,0 @@
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-import type { ResolveContext, ResolveResult, FileId } from './types.js';
-import { extractPackageNameFromNodeModulesPath } from './path-info.js';
-
-const STYLE_EXTS = new Set(['.css', '.scss', '.sass', '.less', '.styl']);
-const JS_TS_EXTS = new Set(['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs']);
-
-export function isStyleFile(filePath: string): boolean {
-  return STYLE_EXTS.has(path.extname(filePath).toLowerCase());
-}
-
-export function isJsTsExtension(filePath: string): boolean {
-  return JS_TS_EXTS.has(path.extname(filePath).toLowerCase());
-}
-
-export function isPlainCssFile(filePath: string): boolean {
-  return path.extname(filePath).toLowerCase() === '.css';
-}
-
-export function isBareStyleSubpath(specifier: string): boolean {
-  return !specifier.startsWith('.') && STYLE_EXTS.has(path.extname(specifier).toLowerCase());
-}
-
-export function pathAliasPatternMatches(pattern: string, specifier: string): boolean {
-  if (pattern.endsWith('*')) {
-    return specifier.startsWith(pattern.slice(0, -1));
-  }
-  return specifier === pattern;
-}
-
-export function matchesNearestTsconfigPathAlias(root: string, fromFile: string, specifier: string): boolean {
-  const tsconfigPath = nearestTsconfigPath(root, fromFile);
-  if (!tsconfigPath) return false;
-  try {
-    const raw = fs.readFileSync(tsconfigPath, 'utf8');
-    const json = JSON.parse(stripJsonComments(raw));
-    const paths: Record<string, string[]> = json?.compilerOptions?.paths ?? {};
-    return Object.keys(paths).some(p => pathAliasPatternMatches(p, specifier));
-  } catch {
-    return false;
-  }
-}
-
-export function nearestTsconfigPath(root: string, fromFile: string): string | null {
-  let dir = path.dirname(fromFile);
-  while (dir.startsWith(root)) {
-    const candidate = path.join(dir, 'tsconfig.json');
-    if (fs.existsSync(candidate)) return candidate;
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-}
-
-export function resolveSpecifier(
-  ctx: ResolveContext,
-  fromFile: string,
-  specifier: string,
-  fromStyle: boolean,
-): ResolveResult {
-  if (specifier.startsWith('.') || specifier.startsWith('/')) {
-    const resolved = resolveRelative(ctx, fromFile, specifier);
-    if (resolved) return resolved;
-    if (fromStyle) {
-      const scss = tryScssPartialFallback(ctx, fromFile, specifier);
-      if (scss) return scss;
-    }
-    return { kind: 'Unresolvable', specifier };
-  }
-
-  for (const [pattern, target] of ctx.pathAliases) {
-    if (pathAliasPatternMatches(pattern, specifier)) {
-      const mapped = specifier.replace(pattern.replace('*', ''), target.replace('*', ''));
-      const r = resolveRelative(ctx, ctx.root, mapped);
-      if (r) return r;
-    }
-  }
-
-  const pkg = extractPackageNameFromNodeModulesPath(specifier) ?? specifier.split('/')[0];
-  return { kind: 'NpmPackage', name: pkg };
-}
-
-function resolveRelative(ctx: ResolveContext, fromFile: string, specifier: string): ResolveResult | null {
-  const fromDir = path.dirname(fromFile);
-  const base = path.resolve(fromDir, specifier);
-
-  const directId = ctx.pathToId.get(base) ?? ctx.rawPathToId.get(base);
-  if (directId !== undefined) return { kind: 'InternalModule', fileId: directId };
-
-  const exts = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs'];
-  for (const ext of exts) {
-    const id = ctx.pathToId.get(base + ext) ?? ctx.rawPathToId.get(base + ext);
-    if (id !== undefined) return { kind: 'InternalModule', fileId: id };
-  }
-
-  for (const ext of exts) {
-    const id = ctx.pathToId.get(path.join(base, 'index' + ext));
-    if (id !== undefined) return { kind: 'InternalModule', fileId: id };
-  }
-
-  return null;
-}
-
-function tryScssPartialFallback(ctx: ResolveContext, fromFile: string, specifier: string): ResolveResult | null {
-  const fromDir = path.dirname(fromFile);
-  const base = path.resolve(fromDir, specifier);
-  const dir = path.dirname(base);
-  const name = '_' + path.basename(base);
-  for (const ext of ['.scss', '.sass', '.css']) {
-    const id = ctx.pathToId.get(path.join(dir, name + ext));
-    if (id !== undefined) return { kind: 'InternalModule', fileId: id };
-  }
-  return null;
-}
-
-function stripJsonComments(s: string): string {
-  return s.replace(/\/\/[^\n]*/g, '').replace(/\/\*[\s\S]*?\*\//g, '');
-}

package/src/graph/resolve/static-imports.ts

@@ -1,14 +0,0 @@
-import type { ResolveContext, ResolvedImport, ImportInfo } from './types.js';
-import { resolveSpecifier, isStyleFile } from './specifier.js';
-
-export function resolveStaticImports(
-  ctx: ResolveContext,
-  filePath: string,
-  imports: ImportInfo[],
-): ResolvedImport[] {
-  const fromStyle = isStyleFile(filePath);
-  return imports.map(info => ({
-    info,
-    target: resolveSpecifier(ctx, filePath, info.specifier, fromStyle),
-  }));
-}

package/src/graph/resolve/types.ts

@@ -1,108 +0,0 @@
-export type FileId = number;
-
-export type ResolveResult =
-  | { kind: 'InternalModule'; fileId: FileId }
-  | { kind: 'ExternalFile'; path: string }
-  | { kind: 'NpmPackage'; name: string }
-  | { kind: 'Unresolvable'; specifier: string };
-
-export interface ImportInfo {
-  specifier: string;
-  isDynamic?: boolean;
-  isTypeOnly?: boolean;
-  span?: { start: number; end: number };
-}
-
-export interface ReExportInfo {
-  specifier: string;
-  isTypeOnly?: boolean;
-}
-
-export interface ResolvedImport {
-  info: ImportInfo;
-  target: ResolveResult;
-}
-
-export interface ResolvedReExport {
-  info: ReExportInfo;
-  target: ResolveResult;
-}
-
-export interface DynamicImportPattern {
-  pattern: string;
-  fromFile: string;
-}
-
-export interface ResolvedModule {
-  fileId: FileId;
-  path: string;
-  resolvedImports: ResolvedImport[];
-  resolvedReExports: ResolvedReExport[];
-  resolvedDynamicImports: ResolvedImport[];
-  resolvedDynamicPatterns: Array<[DynamicImportPattern, FileId[]]>;
-  unusedImportBindings: Set<string>;
-  typeReferencedImportBindings: string[];
-  valueReferencedImportBindings: string[];
-  hasCjsExports: boolean;
-}
-
-export interface CanonicalFallback {
-  files: DiscoveredFile[];
-  map: Map<string, FileId> | null;
-}
-
-export interface DiscoveredFile {
-  path: string;
-  fileId: FileId;
-  canonicalPath?: string;
-}
-
-export interface WorkspaceInfo {
-  root: string;
-  name?: string;
-}
-
-export interface ResolveContext {
-  pathToId: Map<string, FileId>;
-  rawPathToId: Map<string, FileId>;
-  workspaceRoots: Map<string, string>;
-  pathAliases: Array<[string, string]>;
-  scssIncludePaths: string[];
-  root: string;
-  canonicalFallback?: CanonicalFallback;
-  tsconfigWarned: Set<string>;
-  activePlugins: string[];
-  extraConditions: string[];
-}
-
-export const OUTPUT_DIRS = ['dist', 'build', 'out', 'esm', 'cjs', '.next', '.nuxt', '.svelte-kit'] as const;
-
-export const SOURCE_EXTS = ['ts', 'tsx', 'mts', 'cts', 'js', 'jsx', 'mjs', 'cjs'] as const;
-
-export const RN_PLATFORM_PREFIXES = ['.web', '.ios', '.android', '.native'] as const;
-
-export function getOrBuildCanonicalMap(fallback: CanonicalFallback): Map<string, FileId> {
-  if (!fallback.map) {
-    fallback.map = new Map(
-      fallback.files
-        .filter(f => f.canonicalPath)
-        .map(f => [f.canonicalPath!, f.fileId])
-    );
-  }
-  return fallback.map;
-}
-
-export function makeResolvedModule(fileId: FileId, path: string): ResolvedModule {
-  return {
-    fileId,
-    path,
-    resolvedImports: [],
-    resolvedReExports: [],
-    resolvedDynamicImports: [],
-    resolvedDynamicPatterns: [],
-    unusedImportBindings: new Set(),
-    typeReferencedImportBindings: [],
-    valueReferencedImportBindings: [],
-    hasCjsExports: false,
-  };
-}

package/src/graph/resolve/upgrades.ts

@@ -1,32 +0,0 @@
-import type { ResolvedModule } from './types.js';
-
-export function applySpecifierUpgrades(resolved: ResolvedModule[]): void {
-  const internalBySpecifier = new Map<string, number>();
-
-  for (const mod of resolved) {
-    for (const ri of mod.resolvedImports) {
-      if (ri.target.kind === 'InternalModule') {
-        internalBySpecifier.set(ri.info.specifier, ri.target.fileId);
-      }
-    }
-  }
-
-  for (const mod of resolved) {
-    for (const ri of mod.resolvedImports) {
-      if (ri.target.kind === 'NpmPackage') {
-        const internalId = internalBySpecifier.get(ri.info.specifier);
-        if (internalId !== undefined) {
-          ri.target = { kind: 'InternalModule', fileId: internalId };
-        }
-      }
-    }
-    for (const rr of mod.resolvedReExports) {
-      if (rr.target.kind === 'NpmPackage') {
-        const internalId = internalBySpecifier.get(rr.info.specifier);
-        if (internalId !== undefined) {
-          rr.target = { kind: 'InternalModule', fileId: internalId };
-        }
-      }
-    }
-  }
-}