tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/module-resolution.js

@@ -0,0 +1,1598 @@
+/**
+ * Module and type reference resolution for `node16`, `nodenext` and `bundler`.
+ *
+ * ```ts
+ * const resolver = new Resolver(host, options);
+ * const traces: MessageWithArgs[] = [];
+ * const resolved = resolver.resolveModuleName('pkg', '/app/src/index.ts', ModuleKind.ESNext, undefined, traces);
+ * ```
+ */
+import { createDiagnostic, messageWithArgs, } from './diagnostics.js';
+import { ModuleKind, ModuleResolutionKind, comparePatternKeys, getConditions, getEffectiveTypeRoots, inferredTypesContainingFile, mangleScopedPackageName, moduleResolutionKindName, packageIdToString, parseNodeModuleFromPath, parsePackageName, } from './module-resolution-types.js';
+import { PackageJsonInfoCache, isApplicableVersionedTypesKey, isFalsyJson, parsePackageJson, typeScriptVersion, withPackageDirectory, } from './package-json.js';
+import { getAllowJS, getModuleResolutionKind, getResolveJsonModule } from './options.js';
+import { changeExtension, combinePaths, comparePaths, containsPath, ensureTrailingDirectorySeparator, extensionIsTs, fileExtensionIs, getBaseFileName, getDirectoryPath, getNormalizedAbsolutePath, getPathComponents, getPossibleOriginalInputExtensionForExtension, getRelativePathFromDirectory, getRootLength, hasImplementationTSFileExtension, hasTrailingDirectorySeparator, isDeclarationFileName, isExternalModuleNameRelative, isRootedDiskPath, normalizePath, normalizeSlashes, pathIsRelative, removeExtension, removeFileExtension, removeTrailingDirectorySeparator, removeTrailingDirectorySeparators, supportedTSExtensionsWithJsonFlat, tryExtractTSExtension, tryGetExtensionFromPath, } from './path.js';
+export * from './module-resolution-types.js';
+function extensionsToString(extensions) {
+    let result = '';
+    if ((extensions & 1 /* Extensions.TypeScript */) !== 0)
+        result = 'TypeScript';
+    if ((extensions & 2 /* Extensions.JavaScript */) !== 0)
+        result += result === '' ? 'JavaScript' : ', JavaScript';
+    if ((extensions & 4 /* Extensions.Declaration */) !== 0)
+        result += result === '' ? 'Declaration' : ', Declaration';
+    if ((extensions & 8 /* Extensions.Json */) !== 0)
+        result += result === '' ? 'JSON' : ', JSON';
+    return result;
+}
+/** Whether `extension` is one of `extensions`. */
+function extensionIsOk(extensions, extension) {
+    return (((extensions & 2 /* Extensions.JavaScript */) !== 0 &&
+        (extension === '.js' || extension === '.jsx' || extension === '.mjs' || extension === '.cjs')) ||
+        ((extensions & 1 /* Extensions.TypeScript */) !== 0 &&
+            (extension === '.ts' || extension === '.tsx' || extension === '.mts' || extension === '.cts')) ||
+        ((extensions & 4 /* Extensions.Declaration */) !== 0 &&
+            (extension === '.d.ts' || extension === '.d.mts' || extension === '.d.cts')) ||
+        ((extensions & 8 /* Extensions.Json */) !== 0 && extension === '.json'));
+}
+function resolvedFile(path, extension, resolvedUsingTsExtension) {
+    return { path, extension, packageId: undefined, originalPath: '', resolvedUsingTsExtension };
+}
+function unresolved() {
+    return resolvedFile('', '', false);
+}
+export function parsePatterns(paths) {
+    const exact = new Set();
+    const patterns = [];
+    for (const key of paths.keys()) {
+        const star = key.indexOf('*');
+        if (star === -1)
+            exact.add(key);
+        else if (key.indexOf('*', star + 1) === -1)
+            patterns.push({ text: key, starIndex: star });
+    }
+    return { exact, patterns };
+}
+function patternMatches(pattern, candidate) {
+    return (candidate.length >= pattern.text.length - 1 &&
+        candidate.startsWith(pattern.text.slice(0, pattern.starIndex)) &&
+        candidate.endsWith(pattern.text.slice(pattern.starIndex + 1)));
+}
+/** The exact key equal to `candidate`, else the matching pattern with the longest prefix. */
+export function matchPatternOrExact(parsed, candidate) {
+    if (parsed.exact.has(candidate))
+        return { text: candidate, starIndex: -1 };
+    let best;
+    let longestPrefix = -1;
+    for (const pattern of parsed.patterns) {
+        if (pattern.starIndex > longestPrefix && patternMatches(pattern, candidate)) {
+            best = pattern;
+            longestPrefix = pattern.starIndex;
+        }
+    }
+    return best;
+}
+function matchedText(pattern, candidate) {
+    if (pattern.starIndex === -1)
+        return '';
+    return candidate.slice(pattern.starIndex, candidate.length - pattern.text.length + pattern.starIndex + 1);
+}
+function replaceFirstStar(text, replacement) {
+    const star = text.indexOf('*');
+    return star === -1 ? text : text.slice(0, star) + replacement + text.slice(star + 1);
+}
+function replaceAllStars(text, replacement) {
+    let star = text.indexOf('*');
+    if (star === -1)
+        return text;
+    let result = '';
+    let start = 0;
+    while (star !== -1) {
+        result += text.slice(start, star) + replacement;
+        start = star + 1;
+        star = text.indexOf('*', start);
+    }
+    return result + text.slice(start);
+}
+/** Whether a `/`-separated segment of `path` after `start` is `.`, `..` or `node_modules`. */
+function hasInvalidTargetSegment(path, start) {
+    while (start <= path.length) {
+        let end = path.indexOf('/', start);
+        if (end === -1)
+            end = path.length;
+        const length = end - start;
+        if ((length === 1 && path.charCodeAt(start) === 0x2e) ||
+            (length === 2 && path.startsWith('..', start)) ||
+            (length === 12 && path.startsWith('node_modules', start))) {
+            return true;
+        }
+        start = end + 1;
+    }
+    return false;
+}
+function matchesPatternWithTrailer(target, name) {
+    if (target.endsWith('*'))
+        return false;
+    const star = target.indexOf('*');
+    if (star === -1)
+        return false;
+    return name.startsWith(target.slice(0, star)) && name.endsWith(target.slice(star + 1));
+}
+/**
+ * `.` and `..` at the end of a relative name mean a directory, so they normalize to a trailing `/`.
+ */
+function normalizePathForCJSResolution(containingDirectory, moduleName) {
+    const combined = combinePaths(containingDirectory, moduleName);
+    const rootLength = getRootLength(combined);
+    let end = combined.length;
+    if (end > rootLength && combined.charCodeAt(end - 1) === 0x2f)
+        end--;
+    let isDotSegment = false;
+    if (end > rootLength) {
+        const start = Math.max(rootLength, combined.lastIndexOf('/', end - 1) + 1);
+        const length = end - start;
+        isDotSegment = (length === 1 || length === 2) && combined.startsWith(length === 1 ? '.' : '..', start);
+    }
+    return isDotSegment ? ensureTrailingDirectorySeparator(normalizePath(combined)) : normalizePath(combined);
+}
+const RELATIVE_LOADER = { kind: 'relative' };
+const NO_DIAGNOSTICS = [];
+function unresolvedModule(diagnostics) {
+    return {
+        resolvedFileName: '',
+        originalPath: '',
+        extension: '',
+        resolvedUsingTsExtension: false,
+        packageId: undefined,
+        isExternalLibraryImport: false,
+        alternateResult: '',
+        resolutionDiagnostics: diagnostics,
+    };
+}
+// The results each resolver shared with other threads (and so immutable) did not have yet when it was
+// shared, as this thread resolved them.
+const threadModuleCaches = new Map();
+const threadTypeReferenceCaches = new Map();
+export class Resolver {
+    host;
+    options;
+    typingsLocation;
+    projectName;
+    packageJsonInfoCache;
+    moduleCache = new Map();
+    typeReferenceCache = new Map();
+    pathPatterns;
+    shared = false;
+    constructor(host, options, 
+    /** Global typings cache for automatic type acquisition, or `''`. */
+    typingsLocation = '', projectName = '', packageJsonInfoCache) {
+        this.host = host;
+        this.options = options;
+        this.typingsLocation = typingsLocation;
+        this.projectName = projectName;
+        this.packageJsonInfoCache =
+            packageJsonInfoCache ?? new PackageJsonInfoCache(host.getCurrentDirectory(), host.useCaseSensitiveFileNames());
+    }
+    /**
+     * Called before the resolver is shared with other threads, which makes it immutable
+     * (parallel-check.ts): from then on, each thread caches the results and `package.json` lookups the
+     * resolver did not have yet in tables of its own.
+     */
+    prepareForSharing() {
+        this.getPathPatterns();
+        this.packageJsonInfoCache.prepareForSharing();
+        this.shared = true;
+    }
+    cachedModule(key) {
+        const cached = this.moduleCache.get(key);
+        if (cached !== undefined || !this.shared)
+            return cached;
+        return threadModuleCaches.get(this)?.get(key);
+    }
+    cacheModule(key, resolved) {
+        if (this.cachedModule(key) !== undefined)
+            return;
+        if (!this.shared) {
+            this.moduleCache.set(key, resolved);
+            return;
+        }
+        let cache = threadModuleCaches.get(this);
+        if (cache === undefined) {
+            cache = new Map();
+            threadModuleCaches.set(this, cache);
+        }
+        cache.set(key, resolved);
+    }
+    cachedTypeReference(key) {
+        const cached = this.typeReferenceCache.get(key);
+        if (cached !== undefined || !this.shared)
+            return cached;
+        return threadTypeReferenceCaches.get(this)?.get(key);
+    }
+    cacheTypeReference(key, resolved) {
+        if (!this.shared) {
+            this.typeReferenceCache.set(key, resolved);
+            return;
+        }
+        let cache = threadTypeReferenceCaches.get(this);
+        if (cache === undefined) {
+            cache = new Map();
+            threadTypeReferenceCaches.set(this, cache);
+        }
+        cache.set(key, resolved);
+    }
+    /** Parsed `paths` of the resolver's own options. */
+    getPathPatterns() {
+        if (this.pathPatterns === undefined)
+            this.pathPatterns = parsePatterns(this.options.paths ?? new Map());
+        return this.pathPatterns;
+    }
+    /**
+     * Resolves an import specifier. With `traceResolution` set, trace messages are appended to `traces` and the
+     * result cache is bypassed.
+     */
+    resolveModuleName(moduleName, containingFile, mode, redirect, traces) {
+        const containingDirectory = getDirectoryPath(containingFile);
+        const tracer = this.options.traceResolution === true ? (traces ?? []) : undefined;
+        const cacheKey = mode + '|' + (redirect?.configName ?? '') + '|' + containingDirectory + '|' + moduleName;
+        if (tracer === undefined) {
+            const cached = this.cachedModule(cacheKey);
+            if (cached !== undefined)
+                return cached;
+        }
+        const options = optionsWithRedirect(this.options, redirect);
+        tracer?.push(messageWithArgs(1255 /* Diagnostics.Resolving_module_0_from_1 */, moduleName, containingFile));
+        if (tracer !== undefined)
+            traceRedirect(tracer, redirect);
+        const kind = getModuleResolutionKind(options);
+        tracer?.push(options.moduleResolution !== kind
+            ? messageWithArgs(1257 /* Diagnostics.Module_resolution_kind_is_not_specified_using_0 */, moduleResolutionKindName(kind))
+            : messageWithArgs(1256 /* Diagnostics.Explicitly_specified_module_resolution_kind_Colon_0 */, moduleResolutionKindName(kind)));
+        const state = new ResolutionState(this, tracer, moduleName, containingDirectory, false, mode, options);
+        const result = state.resolveNodeLike();
+        if (tracer !== undefined) {
+            if (result.resolvedFileName === '') {
+                tracer.push(messageWithArgs(1259 /* Diagnostics.Module_name_0_was_not_resolved */, moduleName));
+            }
+            else if (result.packageId !== undefined) {
+                tracer.push(messageWithArgs(1371 /* Diagnostics.Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2 */, moduleName, result.resolvedFileName, packageIdToString(result.packageId)));
+            }
+            else {
+                tracer.push(messageWithArgs(1258 /* Diagnostics.Module_name_0_was_successfully_resolved_to_1 */, moduleName, result.resolvedFileName));
+            }
+        }
+        const final = this.tryResolveFromTypingsLocation(moduleName, containingDirectory, result, tracer);
+        this.cacheModule(cacheKey, final);
+        return final;
+    }
+    /** Resolves a `/// <reference types>` directive or an entry of `types`. */
+    resolveTypeReferenceDirective(name, containingFile, mode, redirect, traces) {
+        const containingDirectory = getDirectoryPath(containingFile);
+        const tracer = this.options.traceResolution === true ? (traces ?? []) : undefined;
+        const fromInferredTypes = containingFile.endsWith(inferredTypesContainingFile);
+        const cacheKey = mode +
+            '|' +
+            (fromInferredTypes ? '1' : '0') +
+            (redirect?.configName ?? '') +
+            '|' +
+            containingDirectory +
+            '|' +
+            name;
+        if (tracer === undefined) {
+            const cached = this.cachedTypeReference(cacheKey);
+            if (cached !== undefined)
+                return cached;
+        }
+        const options = optionsWithRedirect(this.options, redirect);
+        const typeRoots = getEffectiveTypeRoots(options, this.host.getCurrentDirectory());
+        const fromConfig = options.typeRoots !== undefined;
+        if (tracer !== undefined) {
+            tracer.push(messageWithArgs(1284 /* Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2 */, name, containingFile, typeRoots.join(',')));
+            traceRedirect(tracer, redirect);
+        }
+        const state = new ResolutionState(this, tracer, name, containingDirectory, true, mode, options);
+        const result = state.resolveTypeReferenceDirective(typeRoots, fromConfig, fromInferredTypes);
+        if (tracer !== undefined) {
+            if (result.resolvedFileName === '') {
+                tracer.push(messageWithArgs(1286 /* Diagnostics.Type_reference_directive_0_was_not_resolved */, name));
+            }
+            else if (result.packageId !== undefined) {
+                tracer.push(messageWithArgs(1372 /* Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3 */, name, result.resolvedFileName, packageIdToString(result.packageId), String(result.primary)));
+            }
+            else {
+                tracer.push(messageWithArgs(1285 /* Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2 */, name, result.resolvedFileName, String(result.primary)));
+            }
+        }
+        this.cacheTypeReference(cacheKey, result);
+        return result;
+    }
+    /** Finds the directory of package `moduleName` in the nearest `node_modules`, without loading files. */
+    resolvePackageDirectory(moduleName, containingFile, mode, redirect) {
+        const options = optionsWithRedirect(this.options, redirect);
+        const state = new ResolutionState(this, undefined, moduleName, getDirectoryPath(containingFile), false, mode, options);
+        state.resolvePackageDirectoryOnly = true;
+        const result = state.loadModuleFromNearestNodeModulesDirectory(false);
+        if (result !== undefined && result.path !== '')
+            return state.createResolvedModuleHandlingSymlink(result);
+        return undefined;
+    }
+    /** The nearest `package.json` at or above `directory`. */
+    getPackageScopeForPath(directory) {
+        const state = new ResolutionState(this, undefined, '', directory, false, ModuleKind.None, this.options);
+        return state.getPackageScopeForPath(directory);
+    }
+    /** Resolves an `extends` specifier of a tsconfig file. */
+    resolveConfig(moduleName, containingFile) {
+        const state = new ResolutionState(this, undefined, moduleName, getDirectoryPath(containingFile), false, ModuleKind.CommonJS, this.options);
+        state.isConfigLookup = true;
+        state.extensions = 8 /* Extensions.Json */;
+        return state.resolveNodeLike();
+    }
+    tryResolveFromTypingsLocation(moduleName, containingDirectory, original, tracer) {
+        if (this.typingsLocation === '' ||
+            isExternalModuleNameRelative(moduleName) ||
+            (original.resolvedFileName !== '' && supportedTSExtensionsWithJsonFlat.includes(original.extension))) {
+            return original;
+        }
+        const state = new ResolutionState(this, tracer, moduleName, containingDirectory, false, ModuleKind.None, this.options);
+        tracer?.push(messageWithArgs(1305 /* Diagnostics.Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2 */, this.projectName, moduleName, this.typingsLocation));
+        const global = state.loadModuleFromImmediateNodeModulesDirectory(4 /* Extensions.Declaration */, this.typingsLocation, false);
+        if (global === undefined)
+            return original;
+        const result = state.createResolvedModule(global, true);
+        result.resolutionDiagnostics = original.resolutionDiagnostics.concat(result.resolutionDiagnostics);
+        return result;
+    }
+}
+function optionsWithRedirect(options, redirect) {
+    return redirect?.options ?? options;
+}
+function traceRedirect(tracer, redirect) {
+    if (redirect !== undefined && redirect.options !== undefined) {
+        tracer.push(messageWithArgs(1368 /* Diagnostics.Using_compiler_options_of_project_reference_redirect_0 */, redirect.configName));
+    }
+}
+/** Resolves an `extends` specifier of a tsconfig file with `nodenext` rules. */
+export function resolveConfig(moduleName, containingFile, host) {
+    return new Resolver(host, { moduleResolution: ModuleResolutionKind.NodeNext }).resolveConfig(moduleName, containingFile);
+}
+/** The `types` entries to include automatically, expanding `*` to every package in the type roots. */
+export function getAutomaticTypeDirectiveNames(options, host) {
+    const types = options.types ?? [];
+    if (!types.includes('*'))
+        return types.slice();
+    const wildcardMatches = [];
+    for (const root of getEffectiveTypeRoots(options, host.getCurrentDirectory())) {
+        if (!host.directoryExists(root))
+            continue;
+        for (const directory of host.getDirectories(root)) {
+            const normalized = normalizePath(directory);
+            const packageJsonPath = combinePaths(combinePaths(root, normalized), 'package.json');
+            // types-publisher writes `"typings": null` for packages that ship their own types.
+            let isNotNeeded = false;
+            if (host.fileExists(packageJsonPath)) {
+                isNotNeeded = parsePackageJson(host.readFile(packageJsonPath) ?? '').typings.isNull;
+            }
+            if (isNotNeeded)
+                continue;
+            const base = getBaseFileName(normalized);
+            if (!base.startsWith('.'))
+                wildcardMatches.push(base);
+        }
+    }
+    const result = [];
+    const seen = new Set();
+    for (const type of types) {
+        if (type === '*') {
+            for (const match of wildcardMatches) {
+                if (!seen.has(match)) {
+                    seen.add(match);
+                    result.push(match);
+                }
+            }
+        }
+        else if (!seen.has(type)) {
+            seen.add(type);
+            result.push(type);
+        }
+    }
+    return result;
+}
+/** One resolution request: the name being resolved plus the knobs that change along the way. */
+class ResolutionState {
+    resolver;
+    traces;
+    name;
+    containingDirectory;
+    options;
+    host;
+    isConfigLookup = false;
+    features = 0 /* Features.None */;
+    esmMode = false;
+    conditions = [];
+    extensions;
+    resolvePackageDirectoryOnly = false;
+    /**
+     * Set while the candidate's extension comes from configuration (package.json, `paths`, wildcard
+     * substitutions) rather than the specifier, which suppresses `resolvedUsingTsExtension`.
+     */
+    candidateEndingIsFromConfig = false;
+    resolvedPackageDirectory = false;
+    diagnostics = [];
+    pathPatterns;
+    constructor(resolver, traces, name, containingDirectory, isTypeReferenceDirective, mode, options) {
+        this.resolver = resolver;
+        this.traces = traces;
+        this.name = name;
+        this.containingDirectory = containingDirectory;
+        this.options = options;
+        this.host = resolver.host;
+        if (isTypeReferenceDirective)
+            this.extensions = 4 /* Extensions.Declaration */;
+        else if (options.noDtsResolution === true)
+            this.extensions = 3 /* Extensions.ImplementationFiles */;
+        else
+            this.extensions = 1 /* Extensions.TypeScript */ | 2 /* Extensions.JavaScript */ | 4 /* Extensions.Declaration */;
+        if (!isTypeReferenceDirective && getResolveJsonModule(options))
+            this.extensions |= 8 /* Extensions.Json */;
+        switch (getModuleResolutionKind(options)) {
+            case ModuleResolutionKind.Node16:
+                this.features = 15 /* Features.Node16Default */;
+                this.esmMode = mode === ModuleKind.ESNext;
+                this.conditions = getConditions(options, mode);
+                break;
+            case ModuleResolutionKind.NodeNext:
+                this.features = 31 /* Features.NodeNextDefault */;
+                this.esmMode = mode === ModuleKind.ESNext;
+                this.conditions = getConditions(options, mode);
+                break;
+            case ModuleResolutionKind.Bundler:
+                this.features = bundlerFeatures(options);
+                this.conditions = getConditions(options, mode);
+                break;
+        }
+    }
+    trace(message, ...args) {
+        this.traces?.push({ message, args });
+    }
+    //// Type reference directives
+    resolveTypeReferenceDirective(typeRoots, fromConfig, fromInferredTypes) {
+        const traces = this.traces;
+        if (typeRoots.length > 0) {
+            if (traces !== undefined)
+                this.trace(1287 /* Diagnostics.Resolving_with_primary_search_path_0 */, typeRoots.join(', '));
+            for (const typeRoot of typeRoots) {
+                const candidate = this.getCandidateFromTypeRoot(typeRoot);
+                if (!this.host.directoryExists(typeRoot)) {
+                    if (traces !== undefined)
+                        this.trace(1311 /* Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it */, typeRoot);
+                    continue;
+                }
+                if (fromConfig) {
+                    // Configured type roots resolve as files or directories, like modules.
+                    const fromFile = this.loadModuleFromFile(4 /* Extensions.Declaration */, candidate);
+                    if (fromFile !== undefined) {
+                        this.setPackageIdFromNodeModulesPath(fromFile);
+                        return this.createResolvedTypeReferenceDirective(fromFile, true);
+                    }
+                }
+                const fromDirectory = this.loadNodeModuleFromDirectory(4 /* Extensions.Declaration */, candidate, true);
+                if (fromDirectory !== undefined)
+                    return this.createResolvedTypeReferenceDirective(fromDirectory, true);
+            }
+        }
+        else if (traces !== undefined) {
+            this.trace(1288 /* Diagnostics.Root_directory_cannot_be_determined_skipping_primary_search_paths */);
+        }
+        let resolved;
+        if (!fromConfig || !fromInferredTypes) {
+            if (traces !== undefined)
+                this.trace(1291 /* Diagnostics.Looking_up_in_node_modules_folder_initial_location_0 */, this.containingDirectory);
+            if (!isExternalModuleNameRelative(this.name)) {
+                resolved = this.loadModuleFromNearestNodeModulesDirectory(false);
+            }
+            else {
+                const candidate = normalizePathForCJSResolution(this.containingDirectory, this.name);
+                resolved = this.nodeLoadModuleByRelativeName(4 /* Extensions.Declaration */, candidate, true);
+            }
+        }
+        else if (traces !== undefined) {
+            this.trace(1417 /* Diagnostics.Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_node_modules_folder */);
+        }
+        return this.createResolvedTypeReferenceDirective(resolved, false);
+    }
+    setPackageIdFromNodeModulesPath(resolved) {
+        const packageDirectory = parseNodeModuleFromPath(resolved.path, false);
+        if (packageDirectory !== '') {
+            resolved.packageId = this.getPackageId(resolved.path, this.getPackageJsonInfo(packageDirectory));
+        }
+    }
+    getCandidateFromTypeRoot(typeRoot) {
+        const name = typeRoot.endsWith('/node_modules/@types') || typeRoot.endsWith('/node_modules/@types/')
+            ? this.mangleScopedPackageName(this.name)
+            : this.name;
+        return combinePaths(typeRoot, name);
+    }
+    mangleScopedPackageName(name) {
+        const mangled = mangleScopedPackageName(name);
+        if (this.traces !== undefined && mangled !== name)
+            this.trace(1337 /* Diagnostics.Scoped_package_detected_looking_in_0 */, mangled);
+        return mangled;
+    }
+    /** Falls back to configured `typeRoots` for declaration lookups of bare names. */
+    resolveFromTypeRoot() {
+        const typeRoots = this.options.typeRoots;
+        if (typeRoots === undefined)
+            return undefined;
+        for (const typeRoot of typeRoots) {
+            const candidate = this.getCandidateFromTypeRoot(typeRoot);
+            if (!this.host.directoryExists(typeRoot)) {
+                if (this.traces !== undefined)
+                    this.trace(1311 /* Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it */, typeRoot);
+                continue;
+            }
+            const fromFile = this.loadModuleFromFile(4 /* Extensions.Declaration */, candidate);
+            if (fromFile !== undefined) {
+                this.setPackageIdFromNodeModulesPath(fromFile);
+                return fromFile;
+            }
+            const fromDirectory = this.loadNodeModuleFromDirectory(4 /* Extensions.Declaration */, candidate, true);
+            if (fromDirectory !== undefined)
+                return fromDirectory;
+        }
+        return undefined;
+    }
+    getPackageScopeForPath(directory) {
+        const stop = this.resolver.typingsLocation;
+        for (;;) {
+            const result = this.getPackageJsonInfo(directory);
+            if (result !== undefined || directory === stop)
+                return result;
+            const parent = getDirectoryPath(directory);
+            if (parent === directory)
+                return undefined;
+            directory = parent;
+        }
+    }
+    //// Module names
+    resolveNodeLike() {
+        if (this.traces !== undefined) {
+            const conditions = this.conditions.map((c) => "'" + c + "'").join(', ');
+            this.trace(1492 /* Diagnostics.Resolving_in_0_mode_with_conditions_1 */, this.esmMode ? 'ESM' : 'CJS', conditions);
+        }
+        const result = this.resolveNodeLikeWorker();
+        if (this.resolvedPackageDirectory &&
+            !this.isConfigLookup &&
+            (this.features & 4 /* Features.Exports */) !== 0 &&
+            (this.extensions & (1 /* Extensions.TypeScript */ | 4 /* Extensions.Declaration */)) !== 0 &&
+            !isExternalModuleNameRelative(this.name) &&
+            result.resolvedFileName !== '' &&
+            result.isExternalLibraryImport &&
+            !extensionIsOk(1 /* Extensions.TypeScript */ | 4 /* Extensions.Declaration */, result.extension) &&
+            this.conditions.includes('import')) {
+            // Find out whether the package would resolve to types without `exports`, to suggest a fix.
+            if (this.traces !== undefined) {
+                this.trace(1426 /* Diagnostics.Resolution_of_non_relative_name_failed_trying_with_modern_Node_resolution_features_disabled_to_see_if_npm_library_needs_configuration_update */);
+            }
+            this.features &= ~4 /* Features.Exports */;
+            this.extensions &= 1 /* Extensions.TypeScript */ | 4 /* Extensions.Declaration */;
+            const diagnosticsCount = this.diagnostics.length;
+            const alternate = this.resolveNodeLikeWorker();
+            if (alternate.resolvedFileName !== '' && alternate.isExternalLibraryImport) {
+                result.alternateResult = alternate.resolvedFileName;
+            }
+            // Results share the array, so truncate a copy.
+            if (this.diagnostics.length !== diagnosticsCount)
+                this.diagnostics = this.diagnostics.slice(0, diagnosticsCount);
+        }
+        return result;
+    }
+    resolveNodeLikeWorker() {
+        const fromSettings = this.tryLoadModuleUsingOptionalResolutionSettings();
+        if (fromSettings !== undefined)
+            return this.createResolvedModuleHandlingSymlink(fromSettings);
+        if (isExternalModuleNameRelative(this.name)) {
+            const candidate = normalizePathForCJSResolution(this.containingDirectory, this.name);
+            const resolved = this.nodeLoadModuleByRelativeName(this.extensions, candidate, true);
+            return this.createResolvedModule(resolved, resolved !== undefined && resolved.path.includes('/node_modules/'));
+        }
+        if ((this.features & 1 /* Features.Imports */) !== 0 && this.name.startsWith('#')) {
+            const resolved = this.loadModuleFromImports();
+            if (resolved !== undefined)
+                return this.createResolvedModuleHandlingSymlink(resolved);
+        }
+        if ((this.features & 2 /* Features.SelfName */) !== 0) {
+            const resolved = this.loadModuleFromSelfNameReference();
+            if (resolved !== undefined)
+                return this.createResolvedModuleHandlingSymlink(resolved);
+        }
+        if (this.name.includes(':')) {
+            if (this.traces !== undefined) {
+                this.trace(1327 /* Diagnostics.Skipping_module_0_that_looks_like_an_absolute_URI_target_file_types_Colon_1 */, this.name, extensionsToString(this.extensions));
+            }
+            return this.createResolvedModule(undefined, false);
+        }
+        if (this.traces !== undefined) {
+            this.trace(1267 /* Diagnostics.Loading_module_0_from_node_modules_folder_target_file_types_Colon_1 */, this.name, extensionsToString(this.extensions));
+        }
+        const fromNodeModules = this.loadModuleFromNearestNodeModulesDirectory(false);
+        if (fromNodeModules !== undefined)
+            return this.createResolvedModuleHandlingSymlink(fromNodeModules);
+        if ((this.extensions & 4 /* Extensions.Declaration */) !== 0) {
+            const fromTypeRoot = this.resolveFromTypeRoot();
+            if (fromTypeRoot !== undefined)
+                return this.createResolvedModuleHandlingSymlink(fromTypeRoot);
+        }
+        return this.createResolvedModule(undefined, false);
+    }
+    loadModuleFromSelfNameReference() {
+        const directory = getNormalizedAbsolutePath(this.containingDirectory, this.host.getCurrentDirectory());
+        const scope = this.getPackageScopeForPath(directory);
+        const contents = scope?.contents;
+        if (scope === undefined || contents === undefined || isFalsyJson(contents.exports))
+            return undefined;
+        const name = contents.name.value;
+        if (name === undefined)
+            return undefined;
+        // Cheap rejection before the component-wise comparison.
+        if (!this.name.includes('\\') &&
+            !name.includes('\\') &&
+            !this.name.startsWith(removeTrailingDirectorySeparators(name))) {
+            return undefined;
+        }
+        const parts = getPathComponents(this.name);
+        const nameParts = getPathComponents(name);
+        if (parts.length < nameParts.length)
+            return undefined;
+        for (let i = 0; i < nameParts.length; i++)
+            if (parts[i] !== nameParts[i])
+                return undefined;
+        let subpath = '.';
+        for (let i = nameParts.length; i < parts.length; i++)
+            subpath = combinePaths(subpath, parts[i]);
+        // Two passes keep @types packages higher in the tree ahead of untyped implementations, as in
+        // node_modules lookups. With allowJs, one pass lets self-names map back to input JS files.
+        if (getAllowJS(this.options) && !this.containingDirectory.includes('/node_modules/')) {
+            return this.loadModuleFromExports(scope, this.extensions, subpath);
+        }
+        const priority = this.extensions & (1 /* Extensions.TypeScript */ | 4 /* Extensions.Declaration */);
+        const secondary = this.extensions & ~(1 /* Extensions.TypeScript */ | 4 /* Extensions.Declaration */);
+        return (this.loadModuleFromExports(scope, priority, subpath) ?? this.loadModuleFromExports(scope, secondary, subpath));
+    }
+    loadModuleFromImports() {
+        if (this.name === '#' || (this.name.startsWith('#/') && (this.features & 16 /* Features.ImportsPatternRoot */) === 0)) {
+            if (this.traces !== undefined)
+                this.trace(1421 /* Diagnostics.Invalid_import_specifier_0_has_no_possible_resolutions */, this.name);
+            return undefined;
+        }
+        const directory = getNormalizedAbsolutePath(this.containingDirectory, this.host.getCurrentDirectory());
+        const scope = this.getPackageScopeForPath(directory);
+        const contents = scope?.contents;
+        if (scope === undefined || contents === undefined) {
+            if (this.traces !== undefined) {
+                this.trace(1419 /* Diagnostics.Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve */, directory);
+            }
+            return undefined;
+        }
+        const imports = contents.imports;
+        if (imports === undefined || imports.type !== 'object') {
+            if (this.traces !== undefined)
+                this.trace(1422 /* Diagnostics.X_package_json_scope_0_has_no_imports_defined */, scope.packageDirectory);
+            return undefined;
+        }
+        const result = this.loadModuleFromExportsOrImports(this.extensions, this.name, imports, scope, true);
+        if (result !== undefined)
+            return result;
+        if (this.traces !== undefined) {
+            this.trace(1420 /* Diagnostics.Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1 */, this.name, scope.packageDirectory);
+        }
+        return undefined;
+    }
+    loadModuleFromExports(scope, extensions, subpath) {
+        const exports = scope.contents?.exports;
+        if (exports === undefined || isFalsyJson(exports))
+            return undefined;
+        if (subpath === '.') {
+            let mainExport;
+            if (exports.type === 'string' || exports.type === 'array')
+                mainExport = exports;
+            else if (exports.type === 'object') {
+                mainExport = exports.kind === 0 /* JsonObjectKind.Conditions */ ? exports : exports.entries.get('.');
+            }
+            if (mainExport !== undefined) {
+                return this.loadModuleFromTargetExportOrImport(extensions, subpath, scope, false, mainExport, '', false, '.');
+            }
+        }
+        else if (exports.type === 'object' && exports.kind === 1 /* JsonObjectKind.Subpaths */) {
+            const result = this.loadModuleFromExportsOrImports(extensions, subpath, exports, scope, false);
+            if (result !== undefined)
+                return result;
+        }
+        if (this.traces !== undefined) {
+            this.trace(1425 /* Diagnostics.Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1 */, subpath, scope.packageDirectory);
+        }
+        return undefined;
+    }
+    loadModuleFromExportsOrImports(extensions, moduleName, lookupTable, scope, isImports) {
+        const entries = lookupTable.entries;
+        if (!moduleName.endsWith('/') && !moduleName.includes('*')) {
+            const target = entries.get(moduleName);
+            if (target !== undefined) {
+                return this.loadModuleFromTargetExportOrImport(extensions, moduleName, scope, isImports, target, '', false, moduleName);
+            }
+        }
+        const expandingKeys = [];
+        for (const key of entries.keys()) {
+            const star = key.indexOf('*');
+            if ((star !== -1 && key.indexOf('*', star + 1) === -1) || key.endsWith('/'))
+                expandingKeys.push(key);
+        }
+        expandingKeys.sort(comparePatternKeys);
+        for (const key of expandingKeys) {
+            const target = entries.get(key);
+            if (target === undefined)
+                continue;
+            if ((this.features & 8 /* Features.ExportsPatternTrailers */) !== 0 && matchesPatternWithTrailer(key, moduleName)) {
+                const star = key.indexOf('*');
+                const subpath = moduleName.slice(star, moduleName.length - (key.length - 1 - star));
+                return this.loadModuleFromTargetExportOrImport(extensions, moduleName, scope, isImports, target, subpath, true, key);
+            }
+            if (key.endsWith('*') && moduleName.startsWith(key.slice(0, -1))) {
+                const subpath = moduleName.slice(key.length - 1);
+                return this.loadModuleFromTargetExportOrImport(extensions, moduleName, scope, isImports, target, subpath, true, key);
+            }
+            if (moduleName.startsWith(key)) {
+                const subpath = moduleName.slice(key.length);
+                return this.loadModuleFromTargetExportOrImport(extensions, moduleName, scope, isImports, target, subpath, false, key);
+            }
+        }
+        return undefined;
+    }
+    invalidTarget(scope, moduleName) {
+        if (this.traces !== undefined) {
+            this.trace(1424 /* Diagnostics.X_package_json_scope_0_has_invalid_type_for_target_of_specifier_1 */, scope.packageDirectory, moduleName);
+        }
+        return undefined;
+    }
+    loadModuleFromTargetExportOrImport(extensions, moduleName, scope, isImports, target, subpath, isPattern, key) {
+        const traces = this.traces;
+        switch (target.type) {
+            case 'string': {
+                const targetString = target.value;
+                const normalizedTarget = normalizeSlashes(targetString);
+                if (!isPattern && subpath.length > 0 && !targetString.endsWith('/'))
+                    return this.invalidTarget(scope, moduleName);
+                if (!targetString.startsWith('./')) {
+                    if (isImports &&
+                        !targetString.startsWith('../') &&
+                        !targetString.startsWith('/') &&
+                        !isRootedDiskPath(targetString)) {
+                        return this.resolveImportsTargetAsModule(targetString, subpath, isPattern, scope, key);
+                    }
+                    return this.invalidTarget(scope, moduleName);
+                }
+                if (hasInvalidTargetSegment(normalizedTarget, 2))
+                    return this.invalidTarget(scope, moduleName);
+                const resolvedTarget = combinePaths(scope.packageDirectory, targetString);
+                const normalizedSubpath = normalizeSlashes(subpath);
+                if (hasInvalidTargetSegment(normalizedSubpath, getRootLength(normalizedSubpath))) {
+                    return this.invalidTarget(scope, moduleName);
+                }
+                if (traces !== undefined) {
+                    this.trace(1494 /* Diagnostics.Using_0_subpath_1_with_target_2 */, isImports ? 'imports' : 'exports', key, isPattern ? replaceAllStars(targetString, subpath) : targetString + subpath);
+                }
+                const finalPath = getNormalizedAbsolutePath(isPattern ? replaceAllStars(resolvedTarget, subpath) : resolvedTarget + subpath, this.host.getCurrentDirectory());
+                const inputLink = this.tryLoadInputFileForPath(finalPath, subpath, combinePaths(scope.packageDirectory, 'package.json'), isImports);
+                if (inputLink !== undefined) {
+                    inputLink.packageId = this.getPackageId(inputLink.path, scope);
+                    return inputLink;
+                }
+                const result = this.loadFileNameFromPackageJsonField(extensions, finalPath, targetString);
+                if (result !== undefined) {
+                    result.packageId = this.getPackageId(result.path, scope);
+                    return result;
+                }
+                return undefined;
+            }
+            case 'object': {
+                if (traces !== undefined)
+                    this.trace(1503 /* Diagnostics.Entering_conditional_exports */);
+                for (const [condition, subTarget] of target.entries) {
+                    if (!this.conditionMatches(condition)) {
+                        if (traces !== undefined)
+                            this.trace(1495 /* Diagnostics.Saw_non_matching_condition_0 */, condition);
+                        continue;
+                    }
+                    if (traces !== undefined)
+                        this.trace(1493 /* Diagnostics.Matched_0_condition_1 */, isImports ? 'imports' : 'exports', condition);
+                    const result = this.loadModuleFromTargetExportOrImport(extensions, moduleName, scope, isImports, subTarget, subpath, isPattern, key);
+                    if (result !== undefined) {
+                        if (traces !== undefined) {
+                            if (result.path !== '')
+                                this.trace(1504 /* Diagnostics.Resolved_under_condition_0 */, condition);
+                            this.trace(1506 /* Diagnostics.Exiting_conditional_exports */);
+                        }
+                        return result;
+                    }
+                    if (traces !== undefined)
+                        this.trace(1505 /* Diagnostics.Failed_to_resolve_under_condition_0 */, condition);
+                }
+                if (traces !== undefined)
+                    this.trace(1506 /* Diagnostics.Exiting_conditional_exports */);
+                return undefined;
+            }
+            case 'array':
+                if (target.items.length === 0)
+                    return this.invalidTarget(scope, moduleName);
+                for (const item of target.items) {
+                    const result = this.loadModuleFromTargetExportOrImport(extensions, moduleName, scope, isImports, item, subpath, isPattern, key);
+                    if (result !== undefined)
+                        return result;
+                }
+                return this.invalidTarget(scope, moduleName);
+            case 'null':
+                if (traces !== undefined) {
+                    this.trace(1423 /* Diagnostics.X_package_json_scope_0_explicitly_maps_specifier_1_to_null */, scope.packageDirectory, moduleName);
+                }
+                return unresolved();
+            default:
+                return this.invalidTarget(scope, moduleName);
+        }
+    }
+    /** An `imports` target naming a package resolves as a module from the scope's directory. */
+    resolveImportsTargetAsModule(targetString, subpath, isPattern, scope, key) {
+        const combinedLookup = isPattern ? replaceAllStars(targetString, subpath) : targetString + subpath;
+        const scopeDirectory = ensureTrailingDirectorySeparator(scope.packageDirectory);
+        if (this.traces !== undefined) {
+            this.trace(1494 /* Diagnostics.Using_0_subpath_1_with_target_2 */, 'imports', key, combinedLookup);
+            this.trace(1255 /* Diagnostics.Resolving_module_0_from_1 */, combinedLookup, scopeDirectory);
+        }
+        const name = this.name;
+        const containingDirectory = this.containingDirectory;
+        this.name = combinedLookup;
+        this.containingDirectory = scopeDirectory;
+        const result = this.resolveNodeLike();
+        this.name = name;
+        this.containingDirectory = containingDirectory;
+        if (result.resolvedFileName === '')
+            return undefined;
+        return {
+            path: result.resolvedFileName,
+            extension: result.extension,
+            packageId: result.packageId,
+            originalPath: result.originalPath,
+            resolvedUsingTsExtension: result.resolvedUsingTsExtension,
+        };
+    }
+    /** Maps a path into `outDir`/`declarationDir` back to the input file, so self-names work before a build. */
+    tryLoadInputFileForPath(finalPath, entry, packagePath, isImports) {
+        const options = this.options;
+        const outDir = options.outDir ?? '';
+        const declarationDir = options.declarationDir ?? '';
+        const configFilePath = options.configFilePath ?? '';
+        const caseSensitive = this.host.useCaseSensitiveFileNames();
+        const currentDirectory = this.host.getCurrentDirectory();
+        if (this.isConfigLookup ||
+            (declarationDir === '' && outDir === '') ||
+            finalPath.includes('/node_modules/') ||
+            (configFilePath !== '' &&
+                !containsPath(getDirectoryPath(packagePath), configFilePath, caseSensitive, currentDirectory))) {
+            return undefined;
+        }
+        // Unlike tsc 5.x, no guessing: the root comes from `rootDir` or the config file location.
+        let rootDir;
+        if (options.rootDir !== undefined && options.rootDir !== '') {
+            rootDir = options.rootDir;
+        }
+        else if (configFilePath !== '') {
+            rootDir = getDirectoryPath(configFilePath);
+        }
+        else {
+            this.diagnostics.push(createDiagnostic(undefined, 0, 0, isImports
+                ? 475 /* Diagnostics.The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate */
+                : 474 /* Diagnostics.The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate */, entry === '' ? '.' : entry, packagePath));
+            return unresolved();
+        }
+        // Output paths in a config are relative to the current directory; otherwise to the root.
+        const base = configFilePath !== '' ? currentDirectory : rootDir;
+        const candidateDirectories = [];
+        if (declarationDir !== '') {
+            candidateDirectories.push(getNormalizedAbsolutePath(combinePaths(base, declarationDir), currentDirectory));
+        }
+        if (outDir !== '' && outDir !== declarationDir) {
+            candidateDirectories.push(getNormalizedAbsolutePath(combinePaths(base, outDir), currentDirectory));
+        }
+        for (const candidateDirectory of candidateDirectories) {
+            if (!containsPath(candidateDirectory, finalPath, caseSensitive, currentDirectory))
+                continue;
+            const fragment = finalPath.length > candidateDirectory.length ? finalPath.slice(candidateDirectory.length + 1) : '';
+            const possibleInputBase = combinePaths(rootDir, fragment);
+            for (const ext of OUTPUT_EXTENSIONS) {
+                if (!fileExtensionIs(possibleInputBase, ext))
+                    continue;
+                for (const inputExt of getPossibleOriginalInputExtensionForExtension(possibleInputBase)) {
+                    if (!extensionIsOk(this.extensions, inputExt))
+                        continue;
+                    const input = changeExtension(possibleInputBase, inputExt);
+                    if (this.host.fileExists(input)) {
+                        const resolved = this.loadFileNameFromPackageJsonField(this.extensions, input, '');
+                        if (resolved !== undefined)
+                            return resolved;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    //// node_modules
+    loadModuleFromNearestNodeModulesDirectory(typesScopeOnly) {
+        // First TS/DTS in implementation packages and @types in every ancestor, then JS in every ancestor.
+        const priority = this.extensions & (1 /* Extensions.TypeScript */ | 4 /* Extensions.Declaration */);
+        const secondary = this.extensions & ~(1 /* Extensions.TypeScript */ | 4 /* Extensions.Declaration */);
+        if (priority !== 0) {
+            if (this.traces !== undefined) {
+                this.trace(1507 /* Diagnostics.Searching_all_ancestor_node_modules_directories_for_preferred_extensions_Colon_0 */, extensionsToString(priority));
+            }
+            const result = this.loadModuleFromAncestorNodeModules(priority, typesScopeOnly);
+            if (result !== undefined)
+                return result;
+        }
+        if (secondary !== 0 && !typesScopeOnly) {
+            if (this.traces !== undefined) {
+                this.trace(1508 /* Diagnostics.Searching_all_ancestor_node_modules_directories_for_fallback_extensions_Colon_0 */, extensionsToString(secondary));
+            }
+            return this.loadModuleFromAncestorNodeModules(secondary, typesScopeOnly);
+        }
+        return undefined;
+    }
+    loadModuleFromAncestorNodeModules(extensions, typesScopeOnly) {
+        let directory = this.containingDirectory;
+        for (;;) {
+            if (getBaseFileName(directory) !== 'node_modules') {
+                const result = this.loadModuleFromImmediateNodeModulesDirectory(extensions, directory, typesScopeOnly);
+                if (result !== undefined)
+                    return result;
+            }
+            const parent = getDirectoryPath(directory);
+            if (parent === directory)
+                return undefined;
+            directory = parent;
+        }
+    }
+    loadModuleFromImmediateNodeModulesDirectory(extensions, directory, typesScopeOnly) {
+        const nodeModules = combinePaths(directory, 'node_modules');
+        if (!this.host.directoryExists(nodeModules)) {
+            if (this.traces !== undefined)
+                this.trace(1311 /* Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it */, nodeModules);
+            return undefined;
+        }
+        if (!typesScopeOnly) {
+            const result = this.loadModuleFromSpecificNodeModulesDirectory(extensions, this.name, nodeModules);
+            if (result !== undefined)
+                return result;
+        }
+        if ((extensions & 4 /* Extensions.Declaration */) !== 0) {
+            const atTypes = combinePaths(nodeModules, '@types');
+            if (!this.host.directoryExists(atTypes)) {
+                if (this.traces !== undefined)
+                    this.trace(1311 /* Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it */, atTypes);
+                return undefined;
+            }
+            return this.loadModuleFromSpecificNodeModulesDirectory(4 /* Extensions.Declaration */, this.mangleScopedPackageName(this.name), atTypes);
+        }
+        return undefined;
+    }
+    loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesDirectory) {
+        // Without the trailing separator, `pkg/` and `pkg` share their candidate and package directory.
+        const candidate = removeTrailingDirectorySeparator(normalizePath(combinePaths(nodeModulesDirectory, moduleName)));
+        const { packageName, rest } = parsePackageName(moduleName);
+        const packageDirectory = packageName === '' ? candidate : combinePaths(nodeModulesDirectory, packageName);
+        if (this.resolvePackageDirectoryOnly) {
+            return this.host.directoryExists(packageDirectory) ? resolvedFile(packageDirectory, '', false) : undefined;
+        }
+        // A nested package.json (`node_modules/foo/bar/package.json`) applies unless the root has `exports`.
+        let rootPackageInfo;
+        let packageInfo = this.getPackageJsonInfo(candidate);
+        if (rest !== '' && packageInfo !== undefined) {
+            if ((this.features & 4 /* Features.Exports */) !== 0)
+                rootPackageInfo = this.getPackageJsonInfo(packageDirectory);
+            if (rootPackageInfo === undefined || rootPackageInfo.contents?.exports === undefined) {
+                const fromFile = this.loadModuleFromFile(extensions, candidate);
+                if (fromFile !== undefined)
+                    return fromFile;
+                const fromDirectory = this.loadNodeModuleFromDirectoryWorker(extensions, candidate, packageInfo);
+                if (fromDirectory !== undefined) {
+                    fromDirectory.packageId = this.getPackageId(fromDirectory.path, packageInfo);
+                    return fromDirectory;
+                }
+            }
+        }
+        if (rest !== '')
+            packageInfo = rootPackageInfo ?? this.getPackageJsonInfo(packageDirectory);
+        const contents = packageInfo?.contents;
+        if (packageInfo !== undefined) {
+            this.resolvedPackageDirectory = true;
+            // `exports` takes priority over files, directories and typesVersions, and blocks them.
+            // A top-level `"exports": null` does not block them.
+            if ((this.features & 4 /* Features.Exports */) !== 0 && contents !== undefined && !isFalsyJson(contents.exports)) {
+                return this.loadModuleFromExports(packageInfo, extensions, combinePaths('.', rest));
+            }
+            if (rest !== '' && contents !== undefined) {
+                const versionPaths = contents.getVersionPaths(this.traces);
+                if (versionPaths !== undefined) {
+                    if (this.traces !== undefined) {
+                        this.trace(1361 /* Diagnostics.X_package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2 */, versionPaths.version, typeScriptVersion, rest);
+                    }
+                    const fromPaths = this.tryLoadModuleUsingPaths(extensions, rest, packageDirectory, versionPaths.paths, parsePatterns(versionPaths.paths), { kind: 'package', rest, packageInfo });
+                    if (fromPaths !== undefined)
+                        return fromPaths;
+                }
+            }
+        }
+        return this.loadFromNodeModulesPackage(extensions, candidate, rest, packageInfo);
+    }
+    /** Loads `candidate` inside a `node_modules` package as a file, then as a directory. */
+    loadFromNodeModulesPackage(extensions, candidate, rest, packageInfo) {
+        if (rest !== '' || !this.esmMode) {
+            const fromFile = this.loadModuleFromFile(extensions, candidate);
+            if (fromFile !== undefined) {
+                fromFile.packageId = this.getPackageId(fromFile.path, packageInfo);
+                return fromFile;
+            }
+        }
+        const fromDirectory = this.loadNodeModuleFromDirectoryWorker(extensions, candidate, packageInfo);
+        if (fromDirectory !== undefined) {
+            fromDirectory.packageId = this.getPackageId(fromDirectory.path, packageInfo);
+            return fromDirectory;
+        }
+        const contents = packageInfo?.contents;
+        if (rest === '' &&
+            contents !== undefined &&
+            (contents.exports === undefined || contents.exports.type === 'null') &&
+            this.esmMode) {
+            // ESM skips index lookups, but a package without `main` or `exports` still defaults to `index.js`.
+            const index = this.loadModuleFromFile(extensions, combinePaths(candidate, 'index.js'));
+            if (index !== undefined) {
+                index.packageId = this.getPackageId(index.path, packageInfo);
+                return index;
+            }
+        }
+        return undefined;
+    }
+    createResolvedModuleHandlingSymlink(resolved) {
+        const isExternalLibraryImport = resolved !== undefined && resolved.path.includes('/node_modules/');
+        if (resolved !== undefined &&
+            this.options.preserveSymlinks !== true &&
+            isExternalLibraryImport &&
+            resolved.originalPath === '' &&
+            !isExternalModuleNameRelative(this.name)) {
+            const real = this.realPathIfDifferent(resolved.path);
+            if (real !== '') {
+                resolved.originalPath = resolved.path;
+                resolved.path = real;
+            }
+        }
+        return this.createResolvedModule(resolved, isExternalLibraryImport);
+    }
+    /** The real path of `path`, or `''` if it is the same path. */
+    realPathIfDifferent(path) {
+        const real = this.realPath(path);
+        // A real path differing only in case keeps the original spelling for forceConsistentCasingInFileNames.
+        const caseSensitive = this.host.useCaseSensitiveFileNames();
+        return comparePaths(path, real, caseSensitive, this.host.getCurrentDirectory()) !== 0 ? real : '';
+    }
+    createResolvedModule(resolved, isExternalLibraryImport) {
+        const diagnostics = this.diagnostics.length === 0 ? NO_DIAGNOSTICS : this.diagnostics;
+        if (resolved === undefined)
+            return unresolvedModule(diagnostics);
+        return {
+            resolvedFileName: resolved.path,
+            originalPath: resolved.originalPath,
+            extension: resolved.extension,
+            resolvedUsingTsExtension: resolved.resolvedUsingTsExtension,
+            packageId: resolved.packageId,
+            isExternalLibraryImport,
+            alternateResult: '',
+            resolutionDiagnostics: diagnostics,
+        };
+    }
+    createResolvedTypeReferenceDirective(resolved, primary) {
+        const result = {
+            resolvedFileName: '',
+            originalPath: '',
+            primary: false,
+            packageId: undefined,
+            isExternalLibraryImport: false,
+            resolutionDiagnostics: this.diagnostics.length === 0 ? NO_DIAGNOSTICS : this.diagnostics,
+        };
+        if (resolved === undefined || resolved.path === '')
+            return result;
+        if (!extensionIsTs(resolved.extension))
+            throw new Error('expected a TypeScript file extension');
+        result.resolvedFileName = resolved.path;
+        result.primary = primary;
+        result.packageId = resolved.packageId;
+        result.isExternalLibraryImport = resolved.path.includes('/node_modules/');
+        if (this.options.preserveSymlinks !== true) {
+            const real = this.realPathIfDifferent(resolved.path);
+            if (real !== '') {
+                result.resolvedFileName = real;
+                result.originalPath = resolved.path;
+            }
+        }
+        return result;
+    }
+    //// paths and rootDirs
+    tryLoadModuleUsingOptionalResolutionSettings() {
+        const fromPaths = this.tryLoadModuleUsingPathsIfEligible();
+        if (fromPaths !== undefined)
+            return fromPaths;
+        // baseUrl lookups were removed; rootDirs only apply to relative names.
+        return isExternalModuleNameRelative(this.name) ? this.tryLoadModuleUsingRootDirs() : undefined;
+    }
+    getPathPatterns() {
+        if (this.options === this.resolver.options)
+            return this.resolver.getPathPatterns();
+        if (this.pathPatterns === undefined)
+            this.pathPatterns = parsePatterns(this.options.paths ?? new Map());
+        return this.pathPatterns;
+    }
+    tryLoadModuleUsingPathsIfEligible() {
+        const paths = this.options.paths;
+        if (paths === undefined || paths.size === 0 || pathIsRelative(this.name))
+            return undefined;
+        if (this.traces !== undefined) {
+            this.trace(1260 /* Diagnostics.X_paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0 */, this.name);
+        }
+        const baseDirectory = this.options.pathsBasePath !== undefined && this.options.pathsBasePath !== ''
+            ? this.options.pathsBasePath
+            : this.host.getCurrentDirectory();
+        return this.tryLoadModuleUsingPaths(this.extensions, this.name, baseDirectory, paths, this.getPathPatterns(), RELATIVE_LOADER);
+    }
+    tryLoadModuleUsingPaths(extensions, moduleName, containingDirectory, paths, patterns, loader) {
+        const pattern = matchPatternOrExact(patterns, moduleName);
+        if (pattern === undefined)
+            return undefined;
+        const star = matchedText(pattern, moduleName);
+        if (this.traces !== undefined)
+            this.trace(1261 /* Diagnostics.Module_name_0_matched_pattern_1 */, moduleName, pattern.text);
+        for (const substitution of paths.get(pattern.text) ?? []) {
+            const path = replaceFirstStar(substitution, star);
+            const candidate = normalizePath(combinePaths(containingDirectory, path));
+            if (this.traces !== undefined) {
+                this.trace(1262 /* Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1 */, substitution, path);
+            }
+            // A substitution may name a file with its extension.
+            const extension = tryGetExtensionFromPath(substitution);
+            if (extension !== '') {
+                const found = this.tryFile(candidate);
+                if (found !== undefined)
+                    return resolvedFile(found, extension, false);
+            }
+            const saved = this.candidateEndingIsFromConfig;
+            if (extension !== '')
+                this.candidateEndingIsFromConfig = true;
+            const resolved = this.runLoader(loader, extensions, candidate);
+            this.candidateEndingIsFromConfig = saved;
+            if (resolved !== undefined)
+                return resolved;
+        }
+        return undefined;
+    }
+    runLoader(loader, extensions, candidate) {
+        switch (loader.kind) {
+            case 'relative':
+                return this.nodeLoadModuleByRelativeName(extensions, candidate, true);
+            case 'package':
+                return this.loadFromNodeModulesPackage(extensions, candidate, loader.rest, loader.packageInfo);
+            case 'directory':
+                return this.loadFromPackageJsonEntry(extensions, candidate, loader.packageFile, loader.packageInfo);
+        }
+    }
+    tryLoadModuleUsingRootDirs() {
+        const rootDirs = this.options.rootDirs;
+        if (rootDirs === undefined || rootDirs.length === 0)
+            return undefined;
+        const traces = this.traces;
+        if (traces !== undefined)
+            this.trace(1275 /* Diagnostics.X_rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0 */, this.name);
+        const candidate = normalizePath(combinePaths(this.containingDirectory, this.name));
+        let matchedRootDir = '';
+        let matchedPrefix = '';
+        for (const rootDir of rootDirs) {
+            const normalizedRoot = ensureTrailingDirectorySeparator(normalizePath(rootDir));
+            const isLongest = candidate.startsWith(normalizedRoot) && (matchedPrefix === '' || matchedPrefix.length < normalizedRoot.length);
+            if (traces !== undefined) {
+                this.trace(1272 /* Diagnostics.Checking_if_0_is_the_longest_matching_prefix_for_1_2 */, normalizedRoot, candidate, String(isLongest));
+            }
+            if (isLongest) {
+                matchedPrefix = normalizedRoot;
+                matchedRootDir = rootDir;
+            }
+        }
+        if (matchedPrefix === '')
+            return undefined;
+        if (traces !== undefined)
+            this.trace(1276 /* Diagnostics.Longest_matching_prefix_for_0_is_1 */, candidate, matchedPrefix);
+        const suffix = candidate.slice(matchedPrefix.length);
+        if (traces !== undefined)
+            this.trace(1277 /* Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2 */, suffix, matchedPrefix, candidate);
+        const initial = this.nodeLoadModuleByRelativeName(this.extensions, candidate, true);
+        if (initial !== undefined)
+            return initial;
+        if (traces !== undefined)
+            this.trace(1278 /* Diagnostics.Trying_other_entries_in_rootDirs */);
+        for (const rootDir of rootDirs) {
+            if (rootDir === matchedRootDir)
+                continue;
+            const other = combinePaths(normalizePath(rootDir), suffix);
+            if (traces !== undefined)
+                this.trace(1277 /* Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2 */, suffix, rootDir, other);
+            const resolved = this.nodeLoadModuleByRelativeName(this.extensions, other, true);
+            if (resolved !== undefined)
+                return resolved;
+        }
+        if (traces !== undefined)
+            this.trace(1279 /* Diagnostics.Module_resolution_using_rootDirs_has_failed */);
+        return undefined;
+    }
+    //// Files and directories
+    nodeLoadModuleByRelativeName(extensions, candidate, considerPackageJson) {
+        if (this.traces !== undefined) {
+            this.trace(1264 /* Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_types_Colon_1 */, candidate, extensionsToString(extensions));
+        }
+        if (!hasTrailingDirectorySeparator(candidate)) {
+            const parent = getDirectoryPath(candidate);
+            if (!this.host.directoryExists(parent)) {
+                if (this.traces !== undefined)
+                    this.trace(1311 /* Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it */, parent);
+                return undefined;
+            }
+            const fromFile = this.loadModuleFromFile(extensions, candidate);
+            if (fromFile !== undefined) {
+                if (considerPackageJson)
+                    this.setPackageIdFromNodeModulesPath(fromFile);
+                return fromFile;
+            }
+        }
+        if (!this.host.directoryExists(candidate)) {
+            if (this.traces !== undefined)
+                this.trace(1311 /* Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it */, candidate);
+            return undefined;
+        }
+        // ESM relative imports do no directory lookups (neither package.json nor index files).
+        return this.esmMode ? undefined : this.loadNodeModuleFromDirectory(extensions, candidate, considerPackageJson);
+    }
+    loadModuleFromFile(extensions, candidate) {
+        // ./foo.js -> ./foo.ts
+        const replaced = this.loadModuleFromFileNoImplicitExtensions(extensions, candidate);
+        if (replaced !== undefined)
+            return replaced;
+        // ./foo -> ./foo.ts
+        return this.esmMode ? undefined : this.tryAddingExtensions(candidate, extensions, '');
+    }
+    loadModuleFromFileNoImplicitExtensions(extensions, candidate) {
+        // Extensionless files are not supported.
+        if (!getBaseFileName(candidate).includes('.'))
+            return undefined;
+        let extensionless = removeFileExtension(candidate);
+        // Unknown extensions map to declaration files such as `.d.css.ts`.
+        if (extensionless === candidate)
+            extensionless = candidate.slice(0, candidate.lastIndexOf('.'));
+        const extension = candidate.slice(extensionless.length);
+        if (this.traces !== undefined)
+            this.trace(1297 /* Diagnostics.File_name_0_has_a_1_extension_stripping_it */, candidate, extension);
+        return this.tryAddingExtensions(extensionless, extensions, extension);
+    }
+    tryAddingExtensions(extensionless, extensions, originalExtension) {
+        const directory = getDirectoryPath(extensionless);
+        if (directory !== '' && !this.host.directoryExists(directory))
+            return undefined;
+        const ts = (extensions & 1 /* Extensions.TypeScript */) !== 0;
+        const dts = (extensions & 4 /* Extensions.Declaration */) !== 0;
+        const js = (extensions & 2 /* Extensions.JavaScript */) !== 0;
+        switch (originalExtension) {
+            case '.mjs':
+            case '.mts':
+            case '.d.mts': {
+                const usingTs = originalExtension === '.mts' || originalExtension === '.d.mts';
+                return ((ts ? this.tryExtension('.mts', extensionless, usingTs) : undefined) ??
+                    (dts ? this.tryExtension('.d.mts', extensionless, usingTs) : undefined) ??
+                    (js ? this.tryExtension('.mjs', extensionless, false) : undefined));
+            }
+            case '.cjs':
+            case '.cts':
+            case '.d.cts': {
+                const usingTs = originalExtension === '.cts' || originalExtension === '.d.cts';
+                return ((ts ? this.tryExtension('.cts', extensionless, usingTs) : undefined) ??
+                    (dts ? this.tryExtension('.d.cts', extensionless, usingTs) : undefined) ??
+                    (js ? this.tryExtension('.cjs', extensionless, false) : undefined));
+            }
+            case '.json':
+                return ((dts ? this.tryExtension('.d.json.ts', extensionless, false) : undefined) ??
+                    ((extensions & 8 /* Extensions.Json */) !== 0 ? this.tryExtension('.json', extensionless, false) : undefined));
+            case '.tsx':
+            case '.jsx': {
+                // Prefer an exact .tsx/.jsx match before the .ts/.js file.
+                const usingTs = originalExtension === '.tsx';
+                return ((ts
+                    ? (this.tryExtension('.tsx', extensionless, usingTs) ?? this.tryExtension('.ts', extensionless, usingTs))
+                    : undefined) ??
+                    (dts ? this.tryExtension('.d.ts', extensionless, usingTs) : undefined) ??
+                    (js
+                        ? (this.tryExtension('.jsx', extensionless, false) ?? this.tryExtension('.js', extensionless, false))
+                        : undefined));
+            }
+            case '.ts':
+            case '.d.ts':
+            case '.js':
+            case '': {
+                const usingTs = originalExtension === '.ts' || originalExtension === '.d.ts';
+                return ((ts
+                    ? (this.tryExtension('.ts', extensionless, usingTs) ?? this.tryExtension('.tsx', extensionless, usingTs))
+                    : undefined) ??
+                    (dts ? this.tryExtension('.d.ts', extensionless, usingTs) : undefined) ??
+                    (js
+                        ? (this.tryExtension('.js', extensionless, false) ?? this.tryExtension('.jsx', extensionless, false))
+                        : undefined) ??
+                    (this.isConfigLookup ? this.tryExtension('.json', extensionless, false) : undefined));
+            }
+            default:
+                if (dts && !isDeclarationFileName(extensionless + originalExtension)) {
+                    return this.tryExtension('.d' + originalExtension + '.ts', extensionless, false);
+                }
+                return undefined;
+        }
+    }
+    tryExtension(extension, extensionless, resolvedUsingTsExtension) {
+        const path = this.tryFile(extensionless + extension);
+        if (path === undefined)
+            return undefined;
+        return resolvedFile(path, extension, !this.candidateEndingIsFromConfig && resolvedUsingTsExtension);
+    }
+    /** The existing file for `fileName`, trying each of `moduleSuffixes`. */
+    tryFile(fileName) {
+        const suffixes = this.options.moduleSuffixes;
+        if (suffixes === undefined || suffixes.length === 0)
+            return this.tryFileLookup(fileName) ? fileName : undefined;
+        const extension = tryGetExtensionFromPath(fileName);
+        const withoutExtension = removeExtension(fileName, extension);
+        for (const suffix of suffixes) {
+            const path = withoutExtension + suffix + extension;
+            if (this.tryFileLookup(path))
+                return path;
+        }
+        return undefined;
+    }
+    tryFileLookup(fileName) {
+        if (this.host.fileExists(fileName)) {
+            if (this.traces !== undefined)
+                this.trace(1266 /* Diagnostics.File_0_exists_use_it_as_a_name_resolution_result */, fileName);
+            return true;
+        }
+        if (this.traces !== undefined)
+            this.trace(1265 /* Diagnostics.File_0_does_not_exist */, fileName);
+        return false;
+    }
+    loadNodeModuleFromDirectory(extensions, candidate, considerPackageJson) {
+        const packageInfo = considerPackageJson ? this.getPackageJsonInfo(candidate) : undefined;
+        return this.loadNodeModuleFromDirectoryWorker(extensions, candidate, packageInfo);
+    }
+    loadNodeModuleFromDirectoryWorker(extensions, candidate, packageInfo) {
+        let packageFile = '';
+        let versionPaths;
+        const contents = packageInfo?.contents;
+        if (packageInfo !== undefined && contents !== undefined) {
+            versionPaths = contents.getVersionPaths(this.traces);
+            if (comparePaths(candidate, packageInfo.packageDirectory, this.host.useCaseSensitiveFileNames()) === 0) {
+                packageFile = this.getPackageFile(extensions, packageInfo);
+            }
+        }
+        const indexPath = combinePaths(candidate, this.isConfigLookup ? 'tsconfig' : 'index');
+        if (versionPaths !== undefined && (packageFile === '' || containsPath(candidate, packageFile, false))) {
+            const moduleName = getRelativePathFromDirectory(candidate, packageFile !== '' ? packageFile : indexPath, false);
+            if (this.traces !== undefined) {
+                this.trace(1361 /* Diagnostics.X_package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2 */, versionPaths.version, typeScriptVersion, moduleName);
+            }
+            const result = this.tryLoadModuleUsingPaths(extensions, moduleName, candidate, versionPaths.paths, parsePatterns(versionPaths.paths), { kind: 'directory', packageFile, packageInfo });
+            if (result !== undefined)
+                return result;
+        }
+        if (packageFile !== '') {
+            const result = this.loadFromPackageJsonEntry(extensions, packageFile, packageFile, packageInfo);
+            if (result !== undefined)
+                return result;
+        }
+        // ESM resolutions do no index lookups.
+        if (this.esmMode || !this.host.directoryExists(candidate))
+            return undefined;
+        return this.loadModuleFromFile(extensions, indexPath);
+    }
+    /** Loads a `main`/`types` entry (or a typesVersions substitution for it). */
+    loadFromPackageJsonEntry(extensions, candidate, packageFile, packageInfo) {
+        const fromFile = this.loadFileNameFromPackageJsonField(extensions, candidate, packageFile);
+        if (fromFile !== undefined)
+            return fromFile;
+        // `types` may point at a .ts file even for declaration-only lookups.
+        const expanded = extensions === 4 /* Extensions.Declaration */ ? 1 /* Extensions.TypeScript */ | 4 /* Extensions.Declaration */ : extensions;
+        // CommonJS packages may omit extensions in `main`, even from ESM importers.
+        const savedEsmMode = this.esmMode;
+        const savedEnding = this.candidateEndingIsFromConfig;
+        this.candidateEndingIsFromConfig = true;
+        if (packageInfo?.contents !== undefined && packageInfo.contents.type.value !== 'module')
+            this.esmMode = false;
+        const result = this.nodeLoadModuleByRelativeName(expanded, candidate, false);
+        this.esmMode = savedEsmMode;
+        this.candidateEndingIsFromConfig = savedEnding;
+        return result;
+    }
+    /**
+     * Loads a path written in package.json. TS extensions are allowed as is; JS extensions are also tried as their
+     * TS counterparts.
+     */
+    loadFileNameFromPackageJsonField(extensions, candidate, packageJsonValue) {
+        if (((extensions & 1 /* Extensions.TypeScript */) !== 0 && hasImplementationTSFileExtension(candidate)) ||
+            ((extensions & 4 /* Extensions.Declaration */) !== 0 && isDeclarationFileName(candidate))) {
+            const path = this.tryFile(candidate);
+            if (path === undefined)
+                return undefined;
+            const extension = tryExtractTSExtension(path);
+            // True when a trailing `*` matched a TS extension written in the specifier.
+            return resolvedFile(path, extension, packageJsonValue.endsWith('*') && extension !== '');
+        }
+        if (this.isConfigLookup && (extensions & 8 /* Extensions.Json */) !== 0 && fileExtensionIs(candidate, '.json')) {
+            const path = this.tryFile(candidate);
+            if (path !== undefined)
+                return resolvedFile(path, '.json', false);
+        }
+        return this.loadModuleFromFileNoImplicitExtensions(extensions, candidate);
+    }
+    getPackageFile(extensions, packageInfo) {
+        const contents = packageInfo.contents;
+        if (contents === undefined)
+            return '';
+        const directory = packageInfo.packageDirectory;
+        if (this.isConfigLookup)
+            return this.getPackageJsonPathField('tsconfig', contents.tsconfig, directory);
+        if ((extensions & 4 /* Extensions.Declaration */) !== 0) {
+            const typings = this.getPackageJsonPathField('typings', contents.typings, directory);
+            if (typings !== '')
+                return typings;
+            const types = this.getPackageJsonPathField('types', contents.types, directory);
+            if (types !== '')
+                return types;
+        }
+        if ((extensions & (3 /* Extensions.ImplementationFiles */ | 4 /* Extensions.Declaration */)) !== 0) {
+            return this.getPackageJsonPathField('main', contents.main, directory);
+        }
+        return '';
+    }
+    //// package.json
+    getPackageJsonInfo(packageDirectory) {
+        const packageJsonPath = combinePaths(packageDirectory, 'package.json');
+        const cache = this.resolver.packageJsonInfoCache;
+        const existing = cache.get(packageJsonPath);
+        if (existing !== undefined) {
+            if (existing.contents !== undefined) {
+                if (this.traces !== undefined)
+                    this.trace(1391 /* Diagnostics.File_0_exists_according_to_earlier_cached_lookups */, packageJsonPath);
+                return withPackageDirectory(existing, packageDirectory);
+            }
+            if (existing.directoryExists && this.traces !== undefined) {
+                this.trace(1392 /* Diagnostics.File_0_does_not_exist_according_to_earlier_cached_lookups */, packageJsonPath);
+            }
+            return undefined;
+        }
+        const directoryExists = this.host.directoryExists(packageDirectory);
+        if (directoryExists && this.host.fileExists(packageJsonPath)) {
+            const contents = parsePackageJson(this.host.readFile(packageJsonPath) ?? '');
+            if (this.traces !== undefined)
+                this.trace(1268 /* Diagnostics.Found_package_json_at_0 */, packageJsonPath);
+            const stored = cache.set(packageJsonPath, { packageDirectory, directoryExists: true, contents });
+            return withPackageDirectory(stored, packageDirectory);
+        }
+        if (directoryExists && this.traces !== undefined)
+            this.trace(1265 /* Diagnostics.File_0_does_not_exist */, packageJsonPath);
+        cache.set(packageJsonPath, { packageDirectory, directoryExists, contents: undefined });
+        return undefined;
+    }
+    getPackageId(resolvedFileName, packageInfo) {
+        const contents = packageInfo?.contents;
+        if (packageInfo === undefined || contents === undefined)
+            return undefined;
+        const name = contents.name.value;
+        const version = contents.version.value;
+        if (name === undefined || version === undefined)
+            return undefined;
+        const directory = packageInfo.packageDirectory;
+        return {
+            name,
+            version,
+            subModuleName: resolvedFileName.length > directory.length ? resolvedFileName.slice(directory.length + 1) : '',
+            peerDependencies: this.readPeerDependencies(packageInfo),
+        };
+    }
+    readPeerDependencies(packageInfo) {
+        const field = packageInfo.contents?.peerDependencies;
+        if (field === undefined || !this.validatePackageJsonField('peerDependencies', field, 'object'))
+            return '';
+        const peers = field.value;
+        if (peers === undefined || peers.size === 0)
+            return '';
+        if (this.traces !== undefined)
+            this.trace(1430 /* Diagnostics.X_package_json_has_a_peerDependencies_field */);
+        const packageDirectory = this.realPath(packageInfo.packageDirectory);
+        const index = packageDirectory.lastIndexOf('/node_modules');
+        if (index === -1)
+            return '';
+        const nodeModules = packageDirectory.slice(0, index + 13) + '/';
+        const names = [...peers.keys()].sort();
+        let result = '';
+        for (const name of names) {
+            const peer = this.getPackageJsonInfo(nodeModules + name);
+            const peerContents = peer?.contents;
+            if (peerContents !== undefined) {
+                const version = peerContents.version.value ?? '';
+                result += '+' + name + '@' + version;
+                if (this.traces !== undefined)
+                    this.trace(1431 /* Diagnostics.Found_peerDependency_0_with_1_version */, name, version);
+            }
+            else if (this.traces !== undefined) {
+                this.trace(1432 /* Diagnostics.Failed_to_find_peerDependency_0 */, name);
+            }
+        }
+        return result;
+    }
+    realPath(path) {
+        const real = normalizePath(this.host.realpath(path));
+        if (this.traces !== undefined)
+            this.trace(1295 /* Diagnostics.Resolving_real_path_for_0_result_1 */, path, real);
+        return real;
+    }
+    validatePackageJsonField(fieldName, field, expectedType) {
+        if (field.actualType !== undefined) {
+            if (field.value !== undefined)
+                return true;
+            if (this.traces !== undefined) {
+                this.trace(1273 /* Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2 */, fieldName, expectedType, field.actualType);
+            }
+        }
+        if (this.traces !== undefined)
+            this.trace(1269 /* Diagnostics.X_package_json_does_not_have_a_0_field */, fieldName);
+        return false;
+    }
+    /** The normalized path a string field points at, or `''`. */
+    getPackageJsonPathField(fieldName, field, directory) {
+        if (!this.validatePackageJsonField(fieldName, field, 'string'))
+            return '';
+        const value = field.value ?? '';
+        if (value === '') {
+            if (this.traces !== undefined)
+                this.trace(1373 /* Diagnostics.X_package_json_had_a_falsy_0_field */, fieldName);
+            return '';
+        }
+        const path = normalizePath(combinePaths(directory, value));
+        if (this.traces !== undefined)
+            this.trace(1270 /* Diagnostics.X_package_json_has_0_field_1_that_references_2 */, fieldName, value, path);
+        return path;
+    }
+    conditionMatches(condition) {
+        if (condition === 'default' || this.conditions.includes(condition))
+            return true;
+        // Versioned types conditions only apply along with `types`.
+        return this.conditions.includes('types') && isApplicableVersionedTypesKey(condition);
+    }
+}
+const OUTPUT_EXTENSIONS = ['.mjs', '.cjs', '.js', '.json', '.d.mts', '.d.cts', '.d.ts'];
+function bundlerFeatures(options) {
+    let features = 31 /* Features.BundlerDefault */;
+    if (options.resolvePackageJsonExports === true)
+        features |= 4 /* Features.Exports */;
+    else if (options.resolvePackageJsonExports === false)
+        features &= ~4 /* Features.Exports */;
+    if (options.resolvePackageJsonImports === true)
+        features |= 1 /* Features.Imports */;
+    else if (options.resolvePackageJsonImports === false)
+        features &= ~1 /* Features.Imports */;
+    return features;
+}