tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/file-loader.js

@@ -0,0 +1,1323 @@
+/**
+ * Finds every file of a program: root files, libraries, references, imports and type directives, in tsgo's order.
+ */
+import { ImportDeclaration, ParseOptions, StringLiteral, getText, } from './ast.js';
+import { FileIncludeReason, IncludeProcessor, ProcessingDiagnostic } from './file-include.js';
+import { ModuleResolutionHost, Resolver, getAutomaticTypeDirectiveNames } from './module-resolution.js';
+import { getResolutionDiagnostic, inferredTypesContainingFile, } from './module-resolution-types.js';
+import { getAllowJS, getIsolatedModules, getModuleResolutionKind, ModuleKind, ModuleResolutionKind, } from './options.js';
+import { isPrepared, preparedLoad, preparedPackageJsonLookups, takePreparedFile, } from './parallel-parse.js';
+import { parseSourceFile } from './parser.js';
+import { mark } from './timeline.js';
+import { combinePaths, fileExtensionIsOneOf, getCanonicalFileName, getDirectoryPath, getNormalizedAbsolutePath, getRootLength, hasJSFileExtension, isRootedDiskPath, normalizePath, normalizeSlashes, removeTrailingDirectorySeparator, supportedTSExtensionsWithJsonFlat, toFileNameLowerCase, toPath, } from './path.js';
+import { getDefaultLibFileName, getDefaultResolutionModeForFile, getExternalModuleIndicatorOptions, getImpliedNodeFormatForFile, getJSXImplicitImportBase, getJSXRuntimeImport, getLibFileName, getModeForUsageLocation, isExternalModule, isSourceFileJS, libFileMetadata, libNames, SourceFileMetadata, } from './program-utilities.js';
+import { hasExtension } from './vfs-match.js';
+import { ConfigParser, flattenExtensions, getSupportedExtensions, getSupportedExtensionsWithJsonIfResolveJsonModule, } from './tsconfig.js';
+/** Files and services the compiler reads through. */
+export class CompilerHost extends ModuleResolutionHost {
+    fs;
+    currentDirectory;
+    defaultLibraryPath;
+    configParser;
+    constructor(fs, currentDirectory, 
+    /** Where bundled `lib.*.d.ts` files are. */
+    defaultLibraryPath) {
+        super();
+        this.fs = fs;
+        this.currentDirectory = currentDirectory;
+        this.defaultLibraryPath = defaultLibraryPath;
+        this.configParser = new ConfigParser(fs, currentDirectory);
+    }
+    useCaseSensitiveFileNames() {
+        return this.fs.useCaseSensitiveFileNames;
+    }
+    getCurrentDirectory() {
+        return this.currentDirectory;
+    }
+    fileExists(path) {
+        return this.fs.fileExists(path);
+    }
+    directoryExists(path) {
+        return this.fs.directoryExists(path);
+    }
+    readFile(path) {
+        return this.fs.readFile(path);
+    }
+    realpath(path) {
+        return this.fs.realpath(path);
+    }
+    getDirectories(path) {
+        return this.fs.getAccessibleEntries(path).directories;
+    }
+    /** Parses a file, or returns `undefined` if it can't be read. */
+    getSourceFile(fileName, path, externalModuleIndicatorOptions) {
+        // A file that parse threads prepared (parallel-parse.ts).
+        const prepared = takePreparedFile(fileName, path, externalModuleIndicatorOptions);
+        if (prepared !== undefined)
+            return prepared;
+        const text = this.fs.readFile(fileName);
+        if (text === undefined)
+            return undefined;
+        return parseSourceFile(fileName, text, new ParseOptions(path, 0 /* ScriptKind.Unknown */, externalModuleIndicatorOptions));
+    }
+    /** The config of a referenced project, or `undefined` if it can't be read. */
+    getResolvedProjectReference(fileName) {
+        return this.configParser.parseConfigFile(fileName, undefined, undefined, []);
+    }
+    /** Called with module resolution traces under `--traceResolution`. */
+    trace(_message) { }
+}
+/** A bundled library file. */
+export class LibFile {
+    name;
+    path;
+    replaced;
+    constructor(name, path, 
+    /** Found through `libReplacement` in `node_modules/@typescript/lib-*`. */
+    replaced) {
+        this.name = name;
+        this.path = path;
+        this.replaced = replaced;
+    }
+}
+/** The JSX runtime import of a file, synthesized for resolution. */
+export class JsxRuntimeImport {
+    moduleReference;
+    specifier;
+    constructor(moduleReference, specifier) {
+        this.moduleReference = moduleReference;
+        this.specifier = specifier;
+    }
+}
+/** A file found through a package installed at several places, kept only once. */
+export class RedirectFile {
+    index;
+    fileName;
+    path;
+    target;
+    constructor(
+    /** Where in `getSourceFiles()` order it is explained. */
+    index, fileName, path, 
+    /** The path of the file it redirects to. */
+    target) {
+        this.index = index;
+        this.fileName = fileName;
+        this.path = path;
+        this.target = target;
+    }
+}
+export function modeAwareKey(name, mode) {
+    return mode + '|' + name;
+}
+/** A file a loaded file adds (`ParseTask.addSubTask`), as a parse thread recorded it (`LoadedFile`). */
+export class LoadedReference {
+    normalizedFilePath;
+    libName;
+    reason;
+    increaseDepth;
+    elideOnDepth;
+    packageId;
+    constructor(normalizedFilePath, 
+    /** The library file's name, or `''`. */
+    libName, reason, increaseDepth, elideOnDepth, packageId) {
+        this.normalizedFilePath = normalizedFilePath;
+        this.libName = libName;
+        this.reason = reason;
+        this.increaseDepth = increaseDepth;
+        this.elideOnDepth = elideOnDepth;
+        this.packageId = packageId;
+    }
+}
+/**
+ * What a parse thread's FileLoader found loading a file it prepared (parallel-parse.ts): the same
+ * as the program's FileLoader finds, since both load with the same options and file system. The
+ * program's FileLoader takes it instead of resolving the file's references, imports and type
+ * directives again, and takes its reasons as they are (they are immutable).
+ */
+export class LoadedFile {
+    file;
+    isLibFile;
+    metadata;
+    references;
+    resolutionsInFile;
+    typeResolutionsInFile;
+    processingDiagnostics;
+    importHelpersImportSpecifier;
+    jsxRuntimeImport;
+    constructor(file, isLibFile, metadata, references, resolutionsInFile, typeResolutionsInFile, processingDiagnostics, importHelpersImportSpecifier, jsxRuntimeImport) {
+        this.file = file;
+        this.isLibFile = isLibFile;
+        this.metadata = metadata;
+        this.references = references;
+        this.resolutionsInFile = resolutionsInFile;
+        this.typeResolutionsInFile = typeResolutionsInFile;
+        this.processingDiagnostics = processingDiagnostics;
+        this.importHelpersImportSpecifier = importHelpersImportSpecifier;
+        this.jsxRuntimeImport = jsxRuntimeImport;
+    }
+}
+/** Sub-tasks of a prepared file built ahead (`FileLoader.takeAhead`), and what they were built from. */
+class SubTasksAhead {
+    loaded;
+    subTasks;
+    constructor(loaded, subTasks) {
+        this.loaded = loaded;
+        this.subTasks = subTasks;
+    }
+}
+class ParseTask {
+    normalizedFilePath;
+    libFile;
+    includeReason;
+    isForAutomaticTypeDirective;
+    increaseDepth;
+    elideOnDepth;
+    packageId;
+    path = '';
+    file = undefined;
+    redirectedParseTask = undefined;
+    subTasks = [];
+    loaded = false;
+    startedSubTasks = false;
+    metadata = libFileMetadata;
+    resolutionsInFile = undefined;
+    resolutionsTrace = [];
+    typeResolutionsInFile = undefined;
+    typeResolutionsTrace = [];
+    processingDiagnostics = [];
+    importHelpersImportSpecifier = undefined;
+    jsxRuntimeImport = undefined;
+    /** The task of the same file name that was loaded instead of this one. */
+    loadedTask = undefined;
+    constructor(normalizedFilePath, libFile, includeReason, isForAutomaticTypeDirective, increaseDepth, 
+    /** A JavaScript file found in `node_modules`, loaded only within `maxNodeModuleJsDepth`. */
+    elideOnDepth, packageId) {
+        this.normalizedFilePath = normalizedFilePath;
+        this.libFile = libFile;
+        this.includeReason = includeReason;
+        this.isForAutomaticTypeDirective = isForAutomaticTypeDirective;
+        this.increaseDepth = increaseDepth;
+        this.elideOnDepth = elideOnDepth;
+        this.packageId = packageId;
+    }
+    addSubTask(fileName, libFile, reason, increaseDepth, elideOnDepth, packageId) {
+        this.subTasks.push(new ParseTask(normalizePath(fileName), libFile, reason, false, increaseDepth, elideOnDepth, packageId));
+    }
+}
+/** The tasks of one path, by file name casing. */
+class ParseTaskData {
+    tasks = new Map();
+    lowestDepth = Number.MAX_SAFE_INTEGER;
+    startedSubTasks = false;
+    packageId = undefined;
+    constructor(task) {
+        this.tasks.set(task.normalizedFilePath, task);
+    }
+}
+/** Pending processing of `tasks[index]`. */
+class ParseWork {
+    tasks;
+    index;
+    data;
+    loaded;
+    depth;
+    constructor(tasks, index, data, loaded, depth) {
+        this.tasks = tasks;
+        this.index = index;
+        this.data = data;
+        this.loaded = loaded;
+        this.depth = depth;
+    }
+}
+/** Referenced projects, and how their sources map to declaration outputs. */
+export class ProjectReferenceMapper {
+    config;
+    configToProjectReference = new Map();
+    referencesInConfigFile = new Map();
+    sourceToProjectReference = new Map();
+    outputDtsToProjectReference = new Map();
+    realpathDtsToSource = new Map();
+    /** Set while loading files, for symlink lookups. */
+    loader = undefined;
+    constructor(config) {
+        this.config = config;
+    }
+    /** The declaration output to load instead of a source of a referenced project, or `''`. */
+    getParseFileRedirect(path) {
+        const output = this.sourceToProjectReference.get(path);
+        return output !== undefined ? output.outputDts : '';
+    }
+    /** The referenced project whose options apply to a file. */
+    getRedirectForResolution(path, fileName) {
+        return (this.sourceToProjectReference.get(path) ??
+            this.outputDtsToProjectReference.get(path) ??
+            this.getSourceToDtsIfSymlink(path, fileName));
+    }
+    getCompilerOptionsForFile(path, fileName) {
+        return this.getRedirectForResolution(path, fileName)?.resolved.options ?? this.config.options;
+    }
+    /** Under `preserveSymlinks`, a symlinked declaration in `node_modules` may be the output of a reference. */
+    getSourceToDtsIfSymlink(path, fileName) {
+        const known = this.realpathDtsToSource.get(path);
+        if (known !== undefined)
+            return known ?? undefined;
+        const loader = this.loader;
+        if (loader === undefined || this.config.options.preserveSymlinks !== true)
+            return undefined;
+        let result;
+        if (fileName.includes('/node_modules/')) {
+            const realPath = loader.toPath(loader.host.realpath(fileName));
+            if (realPath !== path)
+                result = this.outputDtsToProjectReference.get(realPath);
+        }
+        this.realpathDtsToSource.set(path, result ?? null);
+        return result;
+    }
+    /** The configs of the root config's references, `undefined` for those that couldn't be read. */
+    resolvedProjectReferences() {
+        const result = [];
+        const configFile = this.config.configFile;
+        if (configFile === undefined)
+            return result;
+        for (const path of this.referencesInConfigFile.get(configFile.sourceFile.path) ?? []) {
+            result.push(this.configToProjectReference.get(path));
+        }
+        return result;
+    }
+}
+/** A referenced project to read. */
+class ProjectReferenceTask {
+    configName;
+    resolved = undefined;
+    subTasks = [];
+    constructor(configName) {
+        this.configName = configName;
+    }
+}
+class ReferenceDiagnostic {
+    message;
+    args;
+    constructor(message, args) {
+        this.message = message;
+        this.args = args;
+    }
+}
+/** What loading produced. */
+export class ProcessedFiles {
+    resolver;
+    files;
+    filesByPath;
+    missingFiles;
+    resolvedModules;
+    typeResolutionsInFile;
+    sourceFileMetadata;
+    jsxRuntimeImports;
+    importHelpersImportSpecifiers;
+    libFiles;
+    sourceFilesFoundSearchingNodeModules;
+    includeProcessor;
+    outputFileToProjectReferenceSource;
+    redirectTargets;
+    redirectFilesByPath;
+    projectReferenceMapper;
+    preparedPackageJsons;
+    constructor(resolver, 
+    /** Libraries first, sorted, then other files in load order. */
+    files, filesByPath, missingFiles, resolvedModules, typeResolutionsInFile, sourceFileMetadata, jsxRuntimeImports, importHelpersImportSpecifiers, libFiles, 
+    /** Files found while searching `node_modules`. */
+    sourceFilesFoundSearchingNodeModules, includeProcessor, 
+    /** Declaration outputs of referenced projects loaded for their sources, mapped back to the sources. */
+    outputFileToProjectReferenceSource, redirectTargets, redirectFilesByPath, projectReferenceMapper, 
+    /**
+     * The `package.json` lookups made resolving the files whose resolutions were taken from parse
+     * threads (`preparedPackageJsonLookups`); `undefined` where they may miss some.
+     */
+    preparedPackageJsons) {
+        this.resolver = resolver;
+        this.files = files;
+        this.filesByPath = filesByPath;
+        this.missingFiles = missingFiles;
+        this.resolvedModules = resolvedModules;
+        this.typeResolutionsInFile = typeResolutionsInFile;
+        this.sourceFileMetadata = sourceFileMetadata;
+        this.jsxRuntimeImports = jsxRuntimeImports;
+        this.importHelpersImportSpecifiers = importHelpersImportSpecifiers;
+        this.libFiles = libFiles;
+        this.sourceFilesFoundSearchingNodeModules = sourceFilesFoundSearchingNodeModules;
+        this.includeProcessor = includeProcessor;
+        this.outputFileToProjectReferenceSource = outputFileToProjectReferenceSource;
+        this.redirectTargets = redirectTargets;
+        this.redirectFilesByPath = redirectFilesByPath;
+        this.projectReferenceMapper = projectReferenceMapper;
+        this.preparedPackageJsons = preparedPackageJsons;
+    }
+}
+/** The files of `processed` with `file` in place of the file at its path, for `Program.updateFile`. */
+export function withReplacedFile(processed, file) {
+    const files = processed.files.slice();
+    files[files.findIndex((f) => f.path === file.path)] = file;
+    const filesByPath = new Map(processed.filesByPath);
+    filesByPath.set(file.path, file);
+    return new ProcessedFiles(processed.resolver, files, filesByPath, processed.missingFiles, processed.resolvedModules, processed.typeResolutionsInFile, processed.sourceFileMetadata, processed.jsxRuntimeImports, processed.importHelpersImportSpecifiers, processed.libFiles, processed.sourceFilesFoundSearchingNodeModules, processed.includeProcessor.copy(file.path), processed.outputFileToProjectReferenceSource, processed.redirectTargets, processed.redirectFilesByPath, processed.projectReferenceMapper, processed.preparedPackageJsons);
+}
+/** Whether `file` imports the `importHelpers` module (tslib) under `options`. */
+export function needsImportHelpersImportSpecifier(file, options) {
+    if (options.importHelpers !== true)
+        return false;
+    return isSourceFileJS(file) || (!file.isDeclarationFile && (getIsolatedModules(options) || isExternalModule(file)));
+}
+/** The module `file` imports the JSX runtime from under `options`, or '' if it imports none. */
+export function jsxRuntimeImportOf(file, options) {
+    if (file.scriptKind !== 2 /* ScriptKind.JSX */ && file.scriptKind !== 4 /* ScriptKind.TSX */)
+        return '';
+    return getJSXRuntimeImport(getJSXImplicitImportBase(options, file), options);
+}
+/**
+ * Whether `next`, a new version of `file`, can take its place in a program without loading the program again,
+ * as tsgo's canReplaceFileInProgram checks: it has the same script kind, is a module if `file` is one, and has
+ * the same module specifiers with the same resolution modes (`modeOf`), module augmentation names, ambient
+ * modules, file, type and library references, `// @ts-check` directive and node core module style. A CommonJS
+ * module indicator is set when a file is bound, so `next` has none yet; the new program's binder sets it.
+ */
+export function canReplaceFile(file, next, modeOf) {
+    return (file.scriptKind === next.scriptKind &&
+        isExternalModule(file) === isExternalModule(next) &&
+        file.usesUriStyleNodeCoreModules === next.usesUriStyleNodeCoreModules &&
+        sameNodes(file.imports, next.imports, (a, b) => (a.kind !== 10 /* SyntaxKind.StringLiteral */ || getText(a) === getText(b)) && modeOf(file, a) === modeOf(next, b)) &&
+        sameNodes(file.moduleAugmentations, next.moduleAugmentations, (a, b) => getText(a) === getText(b)) &&
+        sameStrings(file.ambientModuleNames, next.ambientModuleNames) &&
+        sameFileReferences(file.referencedFiles, next.referencedFiles) &&
+        sameFileReferences(file.typeReferenceDirectives, next.typeReferenceDirectives) &&
+        sameFileReferences(file.libReferenceDirectives, next.libReferenceDirectives) &&
+        (file.checkJsDirective === undefined
+            ? next.checkJsDirective === undefined
+            : next.checkJsDirective !== undefined && file.checkJsDirective.enabled === next.checkJsDirective.enabled));
+}
+function sameNodes(a, b, same) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i].kind !== b[i].kind || !same(a[i], b[i]))
+            return false;
+    return true;
+}
+function sameStrings(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+function sameFileReferences(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i].fileName !== b[i].fileName ||
+            a[i].resolutionMode !== b[i].resolutionMode ||
+            a[i].preserve !== b[i].preserve)
+            return false;
+    }
+    return true;
+}
+class LibResolution {
+    libraryName;
+    resolution;
+    trace;
+    constructor(libraryName, resolution, trace) {
+        this.libraryName = libraryName;
+        this.resolution = resolution;
+        this.trace = trace;
+    }
+}
+/** Loads files depth-first in tsgo's single-threaded order; the result does not depend on that order. */
+export class FileLoader {
+    host;
+    config;
+    resolver;
+    mapper;
+    options;
+    defaultLibraryPath;
+    supportedExtensions;
+    supportedExtensionsWithJson;
+    maxNodeModuleJsDepth;
+    rootTasks = [];
+    taskDataByPath = new Map();
+    /** Work queued by `start`, run last-in first-out like tsgo's single-threaded work group. */
+    work = [];
+    libFileCache = new Map();
+    libResolutions = new Map();
+    referenceTasks = new Map();
+    /** `toPath` of each file name seen: every reference to a file asks again. */
+    paths = new Map();
+    /** The normalized config file name root files are found from, once computed. */
+    rootContainingFile = undefined;
+    /** Root files whose tasks `addRootFiles` added. */
+    rootFilesAdded = 0;
+    /** The sub-tasks of prepared files, by file name, built ahead by `takeAhead`. */
+    subTasksAhead = new Map();
+    /** Whether the work of the root tasks is queued (`startRootTasks`). */
+    rootTasksStarted = false;
+    /** Set while `walkAhead` runs: the walk stops at work that would parse a file not prepared yet. */
+    walkingAhead = false;
+    /**
+     * Whether a file that parse threads prepared is loaded from what its thread found (its metadata
+     * and resolutions). If not, only the parsed and bound file is taken, and this loader looks up the
+     * file's metadata and resolves its references and imports itself, as without parse threads.
+     */
+    takesPreparedResolutions = true;
+    // Whether a file's resolutions were taken from a parse thread.
+    tookPreparedResolutions = false;
+    constructor(host, config) {
+        this.host = host;
+        this.config = config;
+        const options = config.options;
+        this.options = options;
+        this.defaultLibraryPath = getNormalizedAbsolutePath(host.defaultLibraryPath, host.currentDirectory);
+        this.supportedExtensions = getSupportedExtensions(options);
+        this.supportedExtensionsWithJson = getSupportedExtensionsWithJsonIfResolveJsonModule(options);
+        this.maxNodeModuleJsDepth = options.maxNodeModuleJsDepth ?? 0;
+        this.mapper = new ProjectReferenceMapper(config);
+        this.loadProjectReferences();
+        this.resolver = new Resolver(host, options);
+    }
+    toPath(fileName) {
+        let path = this.paths.get(fileName);
+        if (path === undefined) {
+            path = toPath(fileName, this.host.currentDirectory, this.host.fs.useCaseSensitiveFileNames);
+            this.paths.set(fileName, path);
+        }
+        return path;
+    }
+    /**
+     * Adds the tasks of up to `count` more root files, the first step of `load`: the main thread does
+     * this while parse threads load the files (parallel-parse.ts). Returns whether every root file's
+     * task is added.
+     */
+    addRootFiles(count) {
+        const rootFiles = this.config.fileNames;
+        const end = Math.min(rootFiles.length, this.rootFilesAdded + count);
+        for (let i = this.rootFilesAdded; i < end; i++)
+            this.addRootFileTask(rootFiles[i], FileIncludeReason.rootFile(i));
+        this.rootFilesAdded = end;
+        return end === rootFiles.length;
+    }
+    /** Builds ahead what loading takes from each of `files` (`takeLoadedFile`). */
+    takeAhead(files) {
+        for (const prepared of files) {
+            const loaded = prepared.loaded;
+            if (loaded === undefined)
+                continue;
+            const subTasks = this.subTasksOf(loaded);
+            for (const task of subTasks)
+                task.path = this.toPath(task.normalizedFilePath);
+            this.subTasksAhead.set(prepared.fileName, new SubTasksAhead(loaded, subTasks));
+        }
+    }
+    /**
+     * Loads what it can while parse threads load more files (parallel-parse.ts), the main thread's work
+     * for each batch they return: builds ahead what loading takes from its `files` (`takeAhead`), and once
+     * every root file's task is added, runs the walk `load` would run, in the same order, up to work that
+     * would parse a file the threads have not prepared yet. A later batch, or `load`, goes on from there.
+     * The order decides the program where a file is reached at several depths (the depth it is first
+     * loaded at decides the depths of the files it adds), so the walk keeps it.
+     */
+    walkAhead(files) {
+        this.takeAhead(files);
+        if (!this.rootTasksStarted && this.rootFilesAdded < this.config.fileNames.length)
+            return;
+        this.startRootTasks();
+        this.walkingAhead = true;
+        this.walk();
+        this.walkingAhead = false;
+    }
+    load() {
+        this.addRootFiles(this.config.fileNames.length);
+        this.startRootTasks();
+        mark('loader roots added');
+        this.walk();
+        mark('loader walked');
+        const result = this.collect();
+        mark('loader collected');
+        this.mapper.loader = undefined;
+        return result;
+    }
+    /** Adds the tasks of the libraries and of the automatic type directives, after those of the root files. */
+    addLastRootTasks() {
+        if (this.config.fileNames.length === 0)
+            return;
+        if (this.options.noLib !== true) {
+            const lib = this.options.lib;
+            if (lib === undefined) {
+                const libFile = this.pathForLibFile(getDefaultLibFileName(this.options));
+                this.addRootTask(libFile.path, libFile, FileIncludeReason.libFile(-1));
+            }
+            else {
+                for (let i = 0; i < lib.length; i++) {
+                    const name = getLibFileName(lib[i]);
+                    if (name === '')
+                        continue;
+                    const libFile = this.pathForLibFile(name);
+                    this.addRootTask(libFile.path, libFile, FileIncludeReason.libFile(i));
+                }
+            }
+        }
+        const containingDirectory = this.options.configFilePath !== undefined
+            ? getDirectoryPath(this.options.configFilePath)
+            : this.host.currentDirectory;
+        this.rootTasks.push(new ParseTask(combinePaths(containingDirectory, inferredTypesContainingFile), undefined, undefined, true, false, false, undefined));
+    }
+    /** Adds the last root tasks and queues the work of every root task, once every root file's task is added. */
+    startRootTasks() {
+        if (this.rootTasksStarted)
+            return;
+        this.rootTasksStarted = true;
+        this.addLastRootTasks();
+        this.start(this.rootTasks, 0);
+    }
+    walk() {
+        for (let work = this.work.pop(); work !== undefined; work = this.work.pop()) {
+            if (this.walkingAhead && this.parsesUnprepared(work.tasks[work.index], work.data)) {
+                this.work.push(work);
+                return;
+            }
+            this.run(work);
+        }
+    }
+    /**
+     * Drops the tasks once the program has its files, so that whatever holds the loader after loading
+     * (a parse session's callbacks) no longer keeps every file's task, sub-task list and resolution
+     * traces. Freeing them takes a while on large programs, so the drivers call this once checking
+     * has started (`releaseLater`).
+     */
+    release() {
+        this.rootTasks.length = 0;
+        this.taskDataByPath.clear();
+        this.work.length = 0;
+        this.subTasksAhead.clear();
+        this.referenceTasks.clear();
+        this.paths.clear();
+    }
+    /**
+     * Parse threads (parallel-parse.ts): loads one file as `load` would, parsing it through
+     * `host.getSourceFile`, and adds the files it references, imports and type directives add to `out`
+     * (libraries by name). `depth` is the file's `maxNodeModuleJsDepth` depth.
+     */
+    loadAhead(kind, name, depth, out) {
+        let task;
+        if (kind === 2 /* LoadKind.Library */) {
+            const libFile = this.pathForLibFile(name);
+            task = new ParseTask(getNormalizedAbsolutePath(libFile.path, this.host.currentDirectory), libFile, undefined, false, false, false, undefined);
+        }
+        else if (kind === 3 /* LoadKind.AutomaticTypes */) {
+            const containingDirectory = this.options.configFilePath !== undefined
+                ? getDirectoryPath(this.options.configFilePath)
+                : this.host.currentDirectory;
+            task = new ParseTask(combinePaths(containingDirectory, inferredTypesContainingFile), undefined, undefined, true, false, false, undefined);
+        }
+        else {
+            let fileName = name;
+            if (kind === 0 /* LoadKind.Root */) {
+                const configFile = this.config.configFile;
+                const containingFile = configFile !== undefined
+                    ? getNormalizedAbsolutePath(configFile.sourceFile.fileName, this.host.currentDirectory)
+                    : this.host.currentDirectory;
+                const resolved = this.getSourceFileFromReference(name, name, containingFile, FileIncludeReason.rootFile(0));
+                if (typeof resolved !== 'string')
+                    return undefined;
+                fileName = resolved;
+            }
+            task = new ParseTask(fileName, undefined, undefined, false, false, false, undefined);
+        }
+        task.path = this.toPath(task.normalizedFilePath);
+        this.loadTask(task);
+        const redirected = task.redirectedParseTask;
+        if (redirected !== undefined) {
+            // A source file of a referenced project: queue its output declaration file, which the program
+            // loads in its place. The redirected task has this task's include reason, which is undefined
+            // for a task loaded ahead, so no reference is recorded for it.
+            out.push(1 /* LoadKind.File */, redirected.normalizedFilePath, depth);
+            return undefined;
+        }
+        const references = [];
+        for (const sub of task.subTasks) {
+            references.push(new LoadedReference(sub.normalizedFilePath, sub.libFile !== undefined ? sub.libFile.name : '', sub.includeReason, sub.increaseDepth, sub.elideOnDepth, sub.packageId));
+            const subDepth = sub.increaseDepth ? depth + 1 : depth;
+            // `run` skips these.
+            if (sub.elideOnDepth && subDepth > this.maxNodeModuleJsDepth)
+                continue;
+            if (sub.libFile !== undefined)
+                out.push(2 /* LoadKind.Library */, sub.libFile.name, subDepth);
+            else
+                out.push(1 /* LoadKind.File */, sub.normalizedFilePath, subDepth);
+        }
+        const file = task.file;
+        // Traces are reported in the program's order: such programs resolve on their own.
+        if (file === undefined || this.options.traceResolution === true)
+            return undefined;
+        return new LoadedFile(file, task.libFile !== undefined, task.metadata, references, task.resolutionsInFile, task.typeResolutionsInFile, task.processingDiagnostics, task.importHelpersImportSpecifier, task.jsxRuntimeImport);
+    }
+    // ---- Project references
+    loadProjectReferences() {
+        const references = this.config.resolvedProjectReferencePaths();
+        if (references.length === 0)
+            return;
+        const configFile = this.config.configFile;
+        if (configFile === undefined)
+            return;
+        this.mapper.loader = this;
+        const tasks = createProjectReferenceTasks(references);
+        this.parseProjectReferences(tasks);
+        this.mapper.referencesInConfigFile.set(configFile.sourceFile.path, this.mapProjectReferences(tasks, new Set()));
+    }
+    parseProjectReferences(tasks) {
+        for (let i = 0; i < tasks.length; i++) {
+            const task = tasks[i];
+            const path = this.toPath(task.configName);
+            const existing = this.referenceTasks.get(path);
+            if (existing !== undefined) {
+                tasks[i] = existing;
+                continue;
+            }
+            this.referenceTasks.set(path, task);
+            task.resolved = this.host.getResolvedProjectReference(task.configName);
+            if (task.resolved !== undefined) {
+                const subReferences = task.resolved.resolvedProjectReferencePaths();
+                if (subReferences.length > 0)
+                    task.subTasks = createProjectReferenceTasks(subReferences);
+            }
+            this.parseProjectReferences(task.subTasks);
+        }
+    }
+    mapProjectReferences(tasks, seen) {
+        const results = [];
+        for (const task of tasks) {
+            const path = this.toPath(task.configName);
+            results.push(path);
+            if (seen.has(task))
+                continue;
+            seen.add(task);
+            this.mapper.configToProjectReference.set(path, task.resolved);
+            const resolved = task.resolved;
+            if (resolved !== undefined && resolved.configFile !== this.config.configFile) {
+                // A project's files are mapped before its references', which win for files in both.
+                for (const [source, reference] of resolved.sourceToProjectReference()) {
+                    this.mapper.sourceToProjectReference.set(source, reference);
+                }
+                for (const [output, reference] of resolved.outputDtsToProjectReference()) {
+                    this.mapper.outputDtsToProjectReference.set(output, reference);
+                }
+            }
+            this.mapper.referencesInConfigFile.set(path, this.mapProjectReferences(task.subTasks, seen));
+        }
+        return results;
+    }
+    // ---- Root tasks
+    addRootTask(fileName, libFile, reason) {
+        const absolute = getNormalizedAbsolutePath(fileName, this.host.currentDirectory);
+        if (this.options.allowNonTsExtensions === true || hasExtension(absolute)) {
+            this.rootTasks.push(new ParseTask(absolute, libFile, reason, false, false, false, undefined));
+        }
+    }
+    addRootFileTask(fileName, reason) {
+        const currentDirectory = this.host.currentDirectory;
+        const absolute = getNormalizedAbsolutePath(fileName, currentDirectory);
+        let containingFile = this.rootContainingFile;
+        if (containingFile === undefined) {
+            const configFile = this.config.configFile;
+            containingFile =
+                configFile !== undefined
+                    ? getNormalizedAbsolutePath(configFile.sourceFile.fileName, currentDirectory)
+                    : currentDirectory;
+            this.rootContainingFile = containingFile;
+        }
+        const resolved = this.getSourceFileFromReference(absolute, fileName, containingFile, reason);
+        if (typeof resolved === 'string') {
+            this.rootTasks.push(new ParseTask(resolved, undefined, reason, false, false, false, undefined));
+            return;
+        }
+        const task = new ParseTask(absolute, undefined, reason, false, false, false, undefined);
+        task.processingDiagnostics.push(ProcessingDiagnostic.explainingFileInclude('', reason, resolved.message, resolved.args));
+        this.rootTasks.push(task);
+    }
+    isSupportedExtension(canonicalFileName) {
+        for (const group of this.supportedExtensionsWithJson) {
+            if (fileExtensionIsOneOf(canonicalFileName, group))
+                return true;
+        }
+        return false;
+    }
+    supportedExtensionsList() {
+        return "'" + flattenExtensions(this.supportedExtensions).join("', '") + "'";
+    }
+    /** The file a root file or `/// <reference path>` names, trying extensions, or why there is none. */
+    getSourceFileFromReference(fileName, referenceText, containingFile, reason) {
+        const allowNonTsExtensions = this.options.allowNonTsExtensions === true;
+        const diagnosticFileName = normalizeSlashes(referenceText);
+        const fs = this.host.fs;
+        if (hasExtension(fileName)) {
+            const canonicalFileName = getCanonicalFileName(fileName, fs.useCaseSensitiveFileNames);
+            if (!allowNonTsExtensions && !this.isSupportedExtension(canonicalFileName)) {
+                if (hasJSFileExtension(canonicalFileName)) {
+                    return new ReferenceDiagnostic(1519 /* Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option */, [diagnosticFileName]);
+                }
+                return new ReferenceDiagnostic(1230 /* Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1 */, [diagnosticFileName, this.supportedExtensionsList()]);
+            }
+            if (!fs.fileExists(fileName))
+                return new ReferenceDiagnostic(1229 /* Diagnostics.File_0_not_found */, [diagnosticFileName]);
+            if (reason.isReferencedFile() &&
+                getCanonicalFileName(containingFile, fs.useCaseSensitiveFileNames) === canonicalFileName) {
+                return new ReferenceDiagnostic(3 /* Diagnostics.A_file_cannot_have_a_reference_to_itself */, []);
+            }
+            return fileName;
+        }
+        if (allowNonTsExtensions) {
+            return fs.fileExists(fileName)
+                ? fileName
+                : new ReferenceDiagnostic(1229 /* Diagnostics.File_0_not_found */, [diagnosticFileName]);
+        }
+        for (const extension of this.supportedExtensions[0]) {
+            const candidate = fileName + extension;
+            if (fs.fileExists(candidate))
+                return candidate;
+        }
+        return new ReferenceDiagnostic(1383 /* Diagnostics.Could_not_resolve_the_path_0_with_the_extensions_Colon_1 */, [
+            diagnosticFileName,
+            this.supportedExtensionsList(),
+        ]);
+    }
+    // ---- Libraries
+    /** The normalized file name of the library file `name` (`lib.dom.d.ts`), as `loadAhead` loads it. */
+    libraryFileName(name) {
+        return getNormalizedAbsolutePath(this.pathForLibFile(name).path, this.host.currentDirectory);
+    }
+    pathForLibFile(name) {
+        const cached = this.libFileCache.get(name);
+        if (cached !== undefined)
+            return cached;
+        let path = combinePaths(this.defaultLibraryPath, name);
+        let replaced = false;
+        if (this.options.libReplacement === true && name !== 'lib.d.ts') {
+            const libraryName = getLibraryNameFromLibFileName(name);
+            const containingDirectory = this.options.configFilePath !== undefined
+                ? getDirectoryPath(this.options.configFilePath)
+                : this.host.currentDirectory;
+            const resolveFrom = combinePaths(containingDirectory, '__lib_node_modules_lookup_' + name + '__.ts');
+            const trace = [];
+            const resolution = this.resolver.resolveModuleName(libraryName, resolveFrom, ModuleKind.CommonJS, undefined, trace);
+            if (resolution.resolvedFileName !== '') {
+                path = resolution.resolvedFileName;
+                replaced = true;
+            }
+            const key = this.toPath(resolveFrom);
+            if (!this.libResolutions.has(key))
+                this.libResolutions.set(key, new LibResolution(libraryName, resolution, trace));
+        }
+        const libFile = new LibFile(name, path, replaced);
+        this.libFileCache.set(name, libFile);
+        return libFile;
+    }
+    libFilePriority(file) {
+        const directory = removeTrailingDirectorySeparator(this.defaultLibraryPath);
+        const fileName = file.fileName;
+        if (fileName.startsWith(directory) &&
+            fileName.length > directory.length &&
+            fileName.charCodeAt(directory.length) === 0x2f) {
+            const baseName = fileName.slice(fileName.lastIndexOf('/') + 1);
+            if (baseName === 'lib.d.ts' || baseName === 'lib.es6.d.ts')
+                return 0;
+            let name = baseName.startsWith('lib.') ? baseName.slice(4) : baseName;
+            if (name.endsWith('.d.ts'))
+                name = name.slice(0, -5);
+            const index = libNames.indexOf(name);
+            if (index !== -1)
+                return index + 1;
+        }
+        return libNames.length + 2;
+    }
+    // ---- Loading
+    start(tasks, depth) {
+        for (let i = 0; i < tasks.length; i++) {
+            const task = tasks[i];
+            // Sub-tasks built ahead have their paths.
+            if (task.path === '')
+                task.path = this.toPath(task.normalizedFilePath);
+            let data = this.taskDataByPath.get(task.path);
+            const loaded = data !== undefined;
+            if (data === undefined) {
+                data = new ParseTaskData(task);
+                this.taskDataByPath.set(task.path, data);
+            }
+            this.work.push(new ParseWork(tasks, i, data, loaded, depth));
+        }
+    }
+    run(work) {
+        const task = work.tasks[work.index];
+        const data = work.data;
+        let startSubTasks = false;
+        if (work.loaded) {
+            const existing = data.tasks.get(task.normalizedFilePath);
+            if (existing !== undefined) {
+                task.loadedTask = existing;
+            }
+            else {
+                data.tasks.set(task.normalizedFilePath, task);
+                // A new casing of a file: load its references if another casing's were.
+                startSubTasks = data.startedSubTasks;
+            }
+        }
+        if (data.packageId === undefined && task.packageId !== undefined)
+            data.packageId = task.packageId;
+        const depth = task.increaseDepth ? work.depth + 1 : work.depth;
+        if (depth < data.lowestDepth) {
+            // Reached at a lower depth than before: load references again.
+            data.lowestDepth = depth;
+            startSubTasks = true;
+            data.startedSubTasks = true;
+        }
+        if (task.elideOnDepth && depth > this.maxNodeModuleJsDepth)
+            return;
+        for (const taskByFileName of data.tasks.values()) {
+            let loadSubTasks = startSubTasks;
+            if (!taskByFileName.loaded) {
+                this.loadTask(taskByFileName);
+                if (taskByFileName.redirectedParseTask !== undefined) {
+                    loadSubTasks = true;
+                    data.startedSubTasks = true;
+                }
+            }
+            if (!taskByFileName.startedSubTasks && loadSubTasks) {
+                taskByFileName.startedSubTasks = true;
+                this.start(taskByFileName.subTasks, data.lowestDepth);
+            }
+        }
+    }
+    /**
+     * Whether running the work of `task` (of `data`'s path) may parse a file that parse threads have not
+     * prepared yet: a task of the path not loaded yet, or `task`, a new casing.
+     */
+    parsesUnprepared(task, data) {
+        if (!data.tasks.has(task.normalizedFilePath) && !isPrepared(task.normalizedFilePath))
+            return true;
+        for (const other of data.tasks.values())
+            if (!other.loaded && !other.isForAutomaticTypeDirective && !isPrepared(other.normalizedFilePath))
+                return true;
+        return false;
+    }
+    loadTask(task) {
+        task.loaded = true;
+        if (task.isForAutomaticTypeDirective) {
+            this.loadAutomaticTypeDirectives(task);
+            return;
+        }
+        const redirect = this.mapper.getParseFileRedirect(task.path);
+        if (redirect !== '') {
+            const redirected = new ParseTask(normalizePath(redirect), task.libFile, task.includeReason, false, false, false, undefined);
+            task.redirectedParseTask = redirected;
+            task.subTasks = [redirected];
+            return;
+        }
+        const fs = this.host.fs;
+        if (hasExtension(task.normalizedFilePath) && this.options.allowNonTsExtensions !== true) {
+            const canonicalFileName = getCanonicalFileName(task.normalizedFilePath, fs.useCaseSensitiveFileNames);
+            if (!this.isSupportedExtension(canonicalFileName)) {
+                task.processingDiagnostics.push(hasJSFileExtension(canonicalFileName)
+                    ? ProcessingDiagnostic.explainingFileInclude('', task.includeReason, 1519 /* Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option */, [task.normalizedFilePath])
+                    : ProcessingDiagnostic.explainingFileInclude('', task.includeReason, 1230 /* Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1 */, [task.normalizedFilePath, this.supportedExtensionsList()]));
+                return;
+            }
+        }
+        // What a parse thread found loading this file, if it prepared it as the same kind of file.
+        let loaded = this.takesPreparedResolutions ? preparedLoad(task.normalizedFilePath) : undefined;
+        if (loaded !== undefined && loaded.isLibFile !== (task.libFile !== undefined))
+            loaded = undefined;
+        // Default libraries are scripts: skip looking up their package.json.
+        task.metadata =
+            task.libFile !== undefined
+                ? libFileMetadata
+                : (loaded?.metadata ?? this.loadSourceFileMetadata(task.normalizedFilePath));
+        const options = this.mapper.getCompilerOptionsForFile(task.path, task.normalizedFilePath);
+        const file = this.host.getSourceFile(task.normalizedFilePath, task.path, getExternalModuleIndicatorOptions(task.normalizedFilePath, options, task.metadata));
+        if (file === undefined)
+            return;
+        task.file = file;
+        if (loaded !== undefined && loaded.file === file) {
+            this.takeLoadedFile(task, loaded);
+            return;
+        }
+        if (this.options.noResolve !== true) {
+            for (let i = 0; i < file.referencedFiles.length; i++)
+                this.resolveTripleSlashPathReference(task, file, i);
+            this.resolveTypeReferenceDirectives(task, file);
+        }
+        if (this.options.noLib !== true) {
+            for (let i = 0; i < file.libReferenceDirectives.length; i++) {
+                const reason = FileIncludeReason.reference(3 /* FileIncludeKind.LibReferenceDirective */, task.path, i, undefined);
+                const name = getLibFileName(file.libReferenceDirectives[i].fileName);
+                if (name === '') {
+                    task.processingDiagnostics.push(ProcessingDiagnostic.unknownReference(reason));
+                    continue;
+                }
+                const libFile = this.pathForLibFile(name);
+                task.addSubTask(libFile.path, libFile, reason, false, false, undefined);
+            }
+        }
+        this.resolveImportsAndModuleAugmentations(task, file);
+    }
+    /** Loads `task` from what a parse thread found loading the same file (`LoadedFile`). */
+    takeLoadedFile(task, loaded) {
+        this.tookPreparedResolutions = true;
+        const ahead = this.subTasksAhead.get(task.normalizedFilePath);
+        if (ahead !== undefined && ahead.loaded === loaded) {
+            this.subTasksAhead.delete(task.normalizedFilePath);
+            task.subTasks = ahead.subTasks;
+        }
+        else
+            task.subTasks = this.subTasksOf(loaded);
+        for (const diagnostic of loaded.processingDiagnostics)
+            task.processingDiagnostics.push(diagnostic.copy());
+        task.resolutionsInFile = loaded.resolutionsInFile;
+        task.typeResolutionsInFile = loaded.typeResolutionsInFile;
+        task.importHelpersImportSpecifier = loaded.importHelpersImportSpecifier;
+        task.jsxRuntimeImport = loaded.jsxRuntimeImport;
+    }
+    /** New tasks of the references a parse thread found loading a file. */
+    subTasksOf(loaded) {
+        const subTasks = [];
+        for (const reference of loaded.references) {
+            const libFile = reference.libName !== '' ? this.pathForLibFile(reference.libName) : undefined;
+            subTasks.push(new ParseTask(reference.normalizedFilePath, libFile, reference.reason, false, reference.increaseDepth, reference.elideOnDepth, reference.packageId));
+        }
+        return subTasks;
+    }
+    loadSourceFileMetadata(fileName) {
+        return sourceFileMetadataOf(this.resolver, this.options, fileName);
+    }
+    resolveTripleSlashPathReference(task, file, index) {
+        const moduleName = file.referencedFiles[index].fileName;
+        const containingFile = file.fileName;
+        const referencedFileName = isRootedDiskPath(moduleName)
+            ? moduleName
+            : combinePaths(getDirectoryPath(containingFile), moduleName);
+        const reason = FileIncludeReason.reference(1 /* FileIncludeKind.ReferenceFile */, this.toPath(containingFile), index, undefined);
+        const resolved = this.getSourceFileFromReference(normalizePath(referencedFileName), moduleName, containingFile, reason);
+        if (typeof resolved !== 'string') {
+            task.processingDiagnostics.push(ProcessingDiagnostic.explainingFileInclude('', reason, resolved.message, resolved.args));
+            return;
+        }
+        task.addSubTask(resolved, undefined, reason, false, false, undefined);
+    }
+    resolveTypeReferenceDirectives(task, file) {
+        const references = file.typeReferenceDirectives;
+        if (references.length === 0)
+            return;
+        const resolutions = new Map();
+        for (let i = 0; i < references.length; i++) {
+            const reference = references[i];
+            const redirect = this.mapper.getRedirectForResolution(file.path, file.fileName);
+            const containingFile = redirect !== undefined ? redirect.source : file.fileName;
+            const options = redirect !== undefined ? redirect.resolved.options : this.options;
+            const mode = reference.resolutionMode !== ModuleKind.None
+                ? reference.resolutionMode
+                : getDefaultResolutionModeForFile(file.fileName, task.metadata, options);
+            const resolved = this.resolver.resolveTypeReferenceDirective(reference.fileName, containingFile, mode, redirect?.resolved, task.typeResolutionsTrace);
+            resolutions.set(modeAwareKey(reference.fileName, mode), resolved);
+            const reason = FileIncludeReason.reference(2 /* FileIncludeKind.TypeReferenceDirective */, task.path, i, undefined);
+            if (resolved.resolvedFileName !== '') {
+                task.addSubTask(resolved.resolvedFileName, undefined, reason, resolved.isExternalLibraryImport, false, resolved.packageId);
+            }
+            else {
+                task.processingDiagnostics.push(ProcessingDiagnostic.unknownReference(reason));
+            }
+        }
+        task.typeResolutionsInFile = resolutions;
+    }
+    loadAutomaticTypeDirectives(task) {
+        const names = getAutomaticTypeDirectiveNames(this.options, this.host);
+        if (names.length === 0)
+            return;
+        const resolutions = new Map();
+        for (const name of names) {
+            // Resolved without a mode: CommonJS under node16/nodenext, `import` conditions under bundler.
+            const resolved = this.resolver.resolveTypeReferenceDirective(name, task.normalizedFilePath, ModuleKind.None, undefined, task.typeResolutionsTrace);
+            resolutions.set(modeAwareKey(name, ModuleKind.None), resolved);
+            if (resolved.resolvedFileName !== '') {
+                task.addSubTask(resolved.resolvedFileName, undefined, FileIncludeReason.automaticTypeDirective(name, resolved.packageId), resolved.isExternalLibraryImport, false, resolved.packageId);
+            }
+            else {
+                task.processingDiagnostics.push(ProcessingDiagnostic.explainingFileInclude('', FileIncludeReason.automaticTypeDirective(name, undefined), 821 /* Diagnostics.Cannot_find_type_definition_file_for_0 */, [name]));
+            }
+        }
+        task.typeResolutionsInFile = resolutions;
+    }
+    resolveImportsAndModuleAugmentations(task, file) {
+        const moduleNames = [];
+        const redirect = this.mapper.getRedirectForResolution(file.path, file.fileName);
+        const containingFile = redirect !== undefined ? redirect.source : file.fileName;
+        const options = redirect !== undefined ? redirect.resolved.options : this.options;
+        if (needsImportHelpersImportSpecifier(file, options)) {
+            const specifier = createSyntheticImport('tslib', file);
+            moduleNames.push(specifier);
+            task.importHelpersImportSpecifier = specifier;
+        }
+        const jsxImport = jsxRuntimeImportOf(file, options);
+        if (jsxImport !== '') {
+            const specifier = createSyntheticImport(jsxImport, file);
+            moduleNames.push(specifier);
+            task.jsxRuntimeImport = new JsxRuntimeImport(jsxImport, specifier);
+        }
+        const importsStart = moduleNames.length;
+        for (const specifier of file.imports)
+            moduleNames.push(specifier);
+        for (const augmentation of file.moduleAugmentations) {
+            // `declare global` needs no resolution.
+            if (augmentation.kind === 10 /* SyntaxKind.StringLiteral */)
+                moduleNames.push(augmentation);
+        }
+        if (moduleNames.length === 0)
+            return;
+        const resolutions = new Map();
+        for (let index = 0; index < moduleNames.length; index++) {
+            const entry = moduleNames[index];
+            const moduleName = getText(entry);
+            if (moduleName === '')
+                continue;
+            const mode = getModeForUsageLocation(file.fileName, task.metadata, entry, options);
+            const resolved = this.resolver.resolveModuleName(moduleName, containingFile, mode, redirect?.resolved, task.resolutionsTrace);
+            resolutions.set(modeAwareKey(moduleName, mode), resolved);
+            const resolvedFileName = resolved.resolvedFileName;
+            if (resolvedFileName === '')
+                continue;
+            // Redirected files are not JavaScript files.
+            const isJsFile = !fileExtensionIsOneOf(resolvedFileName, supportedTSExtensionsWithJsonFlat) &&
+                this.mapper.getRedirectForResolution(this.toPath(resolvedFileName), resolvedFileName) === undefined;
+            const isJsFileFromNodeModules = resolved.isExternalLibraryImport && isJsFile && resolvedFileName.includes('/node_modules/');
+            const importIndex = index - importsStart;
+            const imports = file.imports;
+            // Imports from JSDoc of TypeScript files only resolve; module augmentations aren't added either.
+            const shouldAddFile = getResolutionDiagnostic(options, resolved, file.isDeclarationFile) === undefined &&
+                options.noResolve !== true &&
+                !(isJsFile && !getAllowJS(options)) &&
+                (importIndex < 0 ||
+                    (importIndex < imports.length &&
+                        ((imports[importIndex].flags & 65536 /* NodeFlags.JavaScriptFile */) !== 0 ||
+                            (imports[importIndex].flags & 4194304 /* NodeFlags.JSDoc */) === 0)));
+            if (!shouldAddFile)
+                continue;
+            // `as`: scriptc loses instanceof narrowing here.
+            const specifier = importIndex < 0 && entry instanceof StringLiteral ? entry : undefined;
+            task.addSubTask(resolvedFileName, undefined, FileIncludeReason.reference(0 /* FileIncludeKind.Import */, task.path, importIndex, specifier), resolved.isExternalLibraryImport, isJsFileFromNodeModules, resolved.packageId);
+        }
+        task.resolutionsInFile = resolutions;
+    }
+    // ---- Collecting
+    collect() {
+        const host = this.host;
+        const cs = host.fs.useCaseSensitiveFileNames;
+        const missingFiles = [];
+        const files = [];
+        const libFiles = [];
+        const filesByPath = new Map();
+        const tasksSeenByNameIgnoreCase = cs ? new Map() : undefined;
+        const includeProcessor = new IncludeProcessor();
+        const outputFileToProjectReferenceSource = new Map();
+        const resolvedModules = new Map();
+        const typeResolutionsInFile = new Map();
+        const sourceFileMetadata = new Map();
+        const jsxRuntimeImports = new Map();
+        const importHelpersImportSpecifiers = new Map();
+        const sourceFilesFoundSearchingNodeModules = new Set();
+        const libFilesByPath = new Map();
+        const deduplicatePackages = this.options.deduplicatePackages !== false;
+        const redirectTargets = new Map();
+        const redirectFilesByPath = new Map();
+        const packageIdToSourceFile = new Map();
+        const checkCasing = this.options.forceConsistentCasingInFileNames !== false;
+        const seen = new Map();
+        const collectFiles = (tasks) => {
+            for (let task of tasks) {
+                const includeReason = task.includeReason;
+                // Automatic type directive tasks are an implementation detail, not a reason.
+                if (task.redirectedParseTask === undefined && !task.isForAutomaticTypeDirective) {
+                    if (task.loadedTask !== undefined)
+                        task = task.loadedTask;
+                    if (includeReason !== undefined)
+                        addIncludeReason(includeProcessor, task, includeReason);
+                }
+                const data = this.taskDataByPath.get(task.path);
+                if (!task.loaded || data === undefined)
+                    continue;
+                const checkedName = seen.get(data);
+                if (checkedName !== undefined) {
+                    // The same name normalizes the same: only another spelling needs comparing.
+                    if (checkCasing &&
+                        checkedName !== task.normalizedFilePath &&
+                        withoutRoot(getNormalizedAbsolutePath(checkedName, host.currentDirectory)) !==
+                            withoutRoot(getNormalizedAbsolutePath(task.normalizedFilePath, host.currentDirectory))) {
+                        includeProcessor.addCasingDiagnostic(task.path, checkedName, task.normalizedFilePath, includeReason);
+                    }
+                    continue;
+                }
+                seen.set(data, task.normalizedFilePath);
+                if (tasksSeenByNameIgnoreCase !== undefined) {
+                    const lowerCasePath = toFileNameLowerCase(task.path);
+                    const existing = tasksSeenByNameIgnoreCase.get(lowerCasePath);
+                    if (existing !== undefined) {
+                        includeProcessor.addCasingDiagnostic(existing.path, existing.normalizedFilePath, task.normalizedFilePath, includeReason);
+                    }
+                    else {
+                        tasksSeenByNameIgnoreCase.set(lowerCasePath, task);
+                    }
+                }
+                for (const trace of task.typeResolutionsTrace)
+                    host.trace(trace);
+                for (const trace of task.resolutionsTrace)
+                    host.trace(trace);
+                const file = task.file;
+                const packageId = data.packageId;
+                if (deduplicatePackages && packageId !== undefined && packageId.name !== '') {
+                    const key = packageIdKey(packageId);
+                    const packageIdFile = packageIdToSourceFile.get(key);
+                    if (packageIdFile !== undefined) {
+                        const targets = redirectTargets.get(packageIdFile.path);
+                        if (targets === undefined)
+                            redirectTargets.set(packageIdFile.path, [task.normalizedFilePath]);
+                        else
+                            targets.push(task.normalizedFilePath);
+                        redirectFilesByPath.set(task.path, new RedirectFile(files.length + redirectFilesByPath.size, task.normalizedFilePath, task.path, packageIdFile.path));
+                        filesByPath.set(task.path, packageIdFile);
+                        if (data.lowestDepth > 0)
+                            sourceFilesFoundSearchingNodeModules.add(task.path);
+                        continue;
+                    }
+                    if (file !== undefined)
+                        packageIdToSourceFile.set(key, file);
+                }
+                if (task.subTasks.length > 0)
+                    collectFiles(task.subTasks);
+                const redirected = task.redirectedParseTask;
+                if (redirected !== undefined) {
+                    outputFileToProjectReferenceSource.set(redirected.path, task.normalizedFilePath);
+                    continue;
+                }
+                if (task.isForAutomaticTypeDirective) {
+                    typeResolutionsInFile.set(task.path, task.typeResolutionsInFile);
+                    for (const diagnostic of task.processingDiagnostics)
+                        includeProcessor.addProcessingDiagnostic(diagnostic);
+                    continue;
+                }
+                const path = task.path;
+                for (const diagnostic of task.processingDiagnostics)
+                    includeProcessor.addProcessingDiagnostic(diagnostic);
+                if (file === undefined) {
+                    missingFiles.push(task.normalizedFilePath);
+                    continue;
+                }
+                if (task.libFile !== undefined) {
+                    libFiles.push(file);
+                    libFilesByPath.set(path, task.libFile);
+                }
+                else {
+                    files.push(file);
+                }
+                filesByPath.set(path, file);
+                resolvedModules.set(path, task.resolutionsInFile);
+                typeResolutionsInFile.set(path, task.typeResolutionsInFile);
+                sourceFileMetadata.set(path, task.metadata);
+                if (task.jsxRuntimeImport !== undefined)
+                    jsxRuntimeImports.set(path, task.jsxRuntimeImport);
+                if (task.importHelpersImportSpecifier !== undefined) {
+                    importHelpersImportSpecifiers.set(path, task.importHelpersImportSpecifier);
+                }
+                if (data.lowestDepth > 0)
+                    sourceFilesFoundSearchingNodeModules.add(path);
+            }
+        };
+        collectFiles(this.rootTasks);
+        const priorities = new Map();
+        for (const file of libFiles)
+            priorities.set(file, this.libFilePriority(file));
+        libFiles.sort((a, b) => (priorities.get(a) ?? 0) - (priorities.get(b) ?? 0));
+        const allFiles = [...libFiles, ...files];
+        for (const redirect of redirectFilesByPath.values())
+            redirect.index += libFiles.length;
+        const keys = [...this.libResolutions.keys()].sort();
+        for (const key of keys) {
+            const resolution = this.libResolutions.get(key);
+            if (resolution === undefined)
+                continue;
+            const cache = new Map();
+            cache.set(modeAwareKey(resolution.libraryName, ModuleKind.CommonJS), resolution.resolution);
+            resolvedModules.set(key, cache);
+            for (const trace of resolution.trace)
+                host.trace(trace);
+        }
+        return new ProcessedFiles(this.resolver, allFiles, filesByPath, missingFiles, resolvedModules, typeResolutionsInFile, sourceFileMetadata, jsxRuntimeImports, importHelpersImportSpecifiers, libFilesByPath, sourceFilesFoundSearchingNodeModules, includeProcessor, outputFileToProjectReferenceSource, redirectTargets, redirectFilesByPath, this.mapper, this.tookPreparedResolutions ? preparedPackageJsonLookups() : noPackageJsonLookups);
+    }
+}
+const noPackageJsonLookups = [];
+/** Releases `loader` (`FileLoader.release`) on a later turn of the event loop, while checking runs. */
+export function releaseLater(loader) {
+    setImmediate(() => loader.release());
+}
+function addIncludeReason(processor, task, reason) {
+    const redirected = task.redirectedParseTask;
+    if (redirected !== undefined)
+        addIncludeReason(processor, redirected, reason);
+    else if (task.loaded)
+        processor.addReason(task.path, reason);
+}
+function createProjectReferenceTasks(paths) {
+    const tasks = [];
+    for (const path of paths)
+        tasks.push(new ProjectReferenceTask(path));
+    return tasks;
+}
+function packageIdKey(id) {
+    return id.name + '\0' + id.subModuleName + '\0' + id.version + '\0' + id.peerDependencies;
+}
+function withoutRoot(path) {
+    return path.slice(getRootLength(path));
+}
+/** A specifier of an import the compiler adds, such as `tslib` for `importHelpers`. */
+function createSyntheticImport(text, file) {
+    const specifier = new StringLiteral(text, 0 /* TokenFlags.None */);
+    const declaration = new ImportDeclaration(273 /* SyntaxKind.ImportDeclaration */, undefined, undefined, specifier, undefined);
+    specifier.parent = declaration;
+    declaration.parent = file;
+    return specifier;
+}
+/** `lib.dom.iterable.d.ts` to `@typescript/lib-dom/iterable`, `lib.es2015.symbol.wellknown.d.ts` to `@typescript/lib-es2015/symbol-wellknown`. */
+function getLibraryNameFromLibFileName(libFileName) {
+    const components = libFileName.split('.');
+    let path = '@typescript/lib-';
+    if (components.length > 1)
+        path += components[1];
+    for (let i = 2; i < components.length && components[i] !== '' && components[i] !== 'd'; i++) {
+        path += (i === 2 ? '/' : '-') + components[i];
+    }
+    return path;
+}
+/**
+ * The metadata of `fileName` in a program with `options`: the `type` and directory of its nearest
+ * package.json (`resolver`), where they apply, and its implied module format.
+ */
+export function sourceFileMetadataOf(resolver, options, fileName) {
+    const scope = resolver.getPackageScopeForPath(getDirectoryPath(fileName));
+    const kind = getModuleResolutionKind(options);
+    let packageJsonType = '';
+    let packageJsonDirectory = '';
+    const contents = scope?.contents;
+    if (scope !== undefined && contents !== undefined) {
+        packageJsonDirectory = scope.packageDirectory;
+        const type = contents.type.value;
+        if (type !== undefined &&
+            ((!fileExtensionIsOneOf(fileName, ['.mts', '.cts', '.mjs', '.cjs']) &&
+                ModuleResolutionKind.Node16 <= kind &&
+                kind <= ModuleResolutionKind.NodeNext) ||
+                fileName.includes('/node_modules/'))) {
+            packageJsonType = type;
+        }
+    }
+    return new SourceFileMetadata(packageJsonType, packageJsonDirectory, getImpliedNodeFormatForFile(fileName, packageJsonType));
+}