typescript 4.8.0-dev.20220605 → 4.8.0-dev.20220609

package/lib/typingsInstaller.js

@@ -89,7 +89,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220605";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220609";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -6187,7 +6187,7 @@ var ts;
             };
         }
         function createDirectoryWatcher(dirName, dirPath, fallbackOptions) {
-            var watcher = fsWatch(dirName, 1 /* Directory */, function (_eventName, relativeFileName) {
+            var watcher = fsWatch(dirName, 1 /* Directory */, function (_eventName, relativeFileName, modifiedTime) {
                 // When files are deleted from disk, the triggered "rename" event would have a relativefileName of "undefined"
                 if (!ts.isString(relativeFileName))
                     return;
@@ -6197,7 +6197,7 @@ var ts;
                 if (callbacks) {
                     for (var _i = 0, callbacks_1 = callbacks; _i < callbacks_1.length; _i++) {
                         var fileCallback = callbacks_1[_i];
-                        fileCallback(fileName, FileWatcherEventKind.Changed);
+                        fileCallback(fileName, FileWatcherEventKind.Changed, modifiedTime);
                     }
                 }
             }, 
@@ -6251,7 +6251,7 @@ var ts;
             }
             else {
                 cache.set(path, {
-                    watcher: watchFile(fileName, function (fileName, eventKind) { return ts.forEach(callbacksCache.get(path), function (cb) { return cb(fileName, eventKind); }); }, pollingInterval, options),
+                    watcher: watchFile(fileName, function (fileName, eventKind, modifiedTime) { return ts.forEach(callbacksCache.get(path), function (cb) { return cb(fileName, eventKind, modifiedTime); }); }, pollingInterval, options),
                     refCount: 1
                 });
             }
@@ -6279,7 +6279,8 @@ var ts;
         var newTime = modifiedTime.getTime();
         if (oldTime !== newTime) {
             watchedFile.mtime = modifiedTime;
-            watchedFile.callback(watchedFile.fileName, getFileWatcherEventKind(oldTime, newTime));
+            // Pass modified times so tsc --build can use it
+            watchedFile.callback(watchedFile.fileName, getFileWatcherEventKind(oldTime, newTime), modifiedTime);
             return true;
         }
         return false;
@@ -6314,7 +6315,7 @@ var ts;
      */
     /*@internal*/
     function createDirectoryWatcherSupportingRecursive(_a) {
-        var watchDirectory = _a.watchDirectory, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, directoryExists = _a.directoryExists, realpath = _a.realpath, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout;
+        var watchDirectory = _a.watchDirectory, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, fileSystemEntryExists = _a.fileSystemEntryExists, realpath = _a.realpath, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout;
         var cache = new ts.Map();
         var callbackCache = ts.createMultiMap();
         var cacheToUpdateChildWatches = new ts.Map();
@@ -6414,7 +6415,7 @@ var ts;
         function nonSyncUpdateChildWatches(dirName, dirPath, fileName, options) {
             // Iterate through existing children and update the watches if needed
             var parentWatcher = cache.get(dirPath);
-            if (parentWatcher && directoryExists(dirName)) {
+            if (parentWatcher && fileSystemEntryExists(dirName, 1 /* Directory */)) {
                 // Schedule the update and postpone invoke for callbacks
                 scheduleUpdateChildWatches(dirName, dirPath, fileName, options);
                 return;
@@ -6487,7 +6488,7 @@ var ts;
             if (!parentWatcher)
                 return false;
             var newChildWatches;
-            var hasChanges = ts.enumerateInsertsAndDeletes(directoryExists(parentDir) ? ts.mapDefined(getAccessibleSortedChildDirectories(parentDir), function (child) {
+            var hasChanges = ts.enumerateInsertsAndDeletes(fileSystemEntryExists(parentDir, 1 /* Directory */) ? ts.mapDefined(getAccessibleSortedChildDirectories(parentDir), function (child) {
                 var childFullName = ts.getNormalizedAbsolutePath(child, parentDir);
                 // Filter our the symbolic link directories since those arent included in recursive watch
                 // which is same behaviour when recursive: true is passed to fs.watch
@@ -6530,17 +6531,19 @@ var ts;
     })(FileSystemEntryKind = ts.FileSystemEntryKind || (ts.FileSystemEntryKind = {}));
     /*@internal*/
     function createFileWatcherCallback(callback) {
-        return function (_fileName, eventKind) { return callback(eventKind === FileWatcherEventKind.Changed ? "change" : "rename", ""); };
+        return function (_fileName, eventKind, modifiedTime) { return callback(eventKind === FileWatcherEventKind.Changed ? "change" : "rename", "", modifiedTime); };
     }
     ts.createFileWatcherCallback = createFileWatcherCallback;
-    function createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileExists) {
-        return function (eventName) {
+    function createFsWatchCallbackForFileWatcherCallback(fileName, callback, getModifiedTime) {
+        return function (eventName, _relativeFileName, modifiedTime) {
             if (eventName === "rename") {
-                callback(fileName, fileExists(fileName) ? FileWatcherEventKind.Created : FileWatcherEventKind.Deleted);
+                // Check time stamps rather than file system entry checks
+                modifiedTime || (modifiedTime = getModifiedTime(fileName) || ts.missingFileModifiedTime);
+                callback(fileName, modifiedTime !== ts.missingFileModifiedTime ? FileWatcherEventKind.Created : FileWatcherEventKind.Deleted, modifiedTime);
             }
             else {
                 // Change
-                callback(fileName, FileWatcherEventKind.Changed);
+                callback(fileName, FileWatcherEventKind.Changed, modifiedTime);
             }
         };
     }
@@ -6564,11 +6567,12 @@ var ts;
     }
     /*@internal*/
     function createSystemWatchFunctions(_a) {
-        var pollingWatchFile = _a.pollingWatchFile, getModifiedTime = _a.getModifiedTime, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout, fsWatch = _a.fsWatch, fileExists = _a.fileExists, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, fsSupportsRecursiveFsWatch = _a.fsSupportsRecursiveFsWatch, directoryExists = _a.directoryExists, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, realpath = _a.realpath, tscWatchFile = _a.tscWatchFile, useNonPollingWatchers = _a.useNonPollingWatchers, tscWatchDirectory = _a.tscWatchDirectory, defaultWatchFileKind = _a.defaultWatchFileKind;
+        var pollingWatchFile = _a.pollingWatchFile, getModifiedTime = _a.getModifiedTime, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout, fsWatchWorker = _a.fsWatchWorker, fileSystemEntryExists = _a.fileSystemEntryExists, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, fsSupportsRecursiveFsWatch = _a.fsSupportsRecursiveFsWatch, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, realpath = _a.realpath, tscWatchFile = _a.tscWatchFile, useNonPollingWatchers = _a.useNonPollingWatchers, tscWatchDirectory = _a.tscWatchDirectory, defaultWatchFileKind = _a.defaultWatchFileKind, inodeWatching = _a.inodeWatching, sysLog = _a.sysLog;
         var dynamicPollingWatchFile;
         var fixedChunkSizePollingWatchFile;
         var nonPollingWatchFile;
         var hostRecursiveDirectoryWatcher;
+        var hitSystemWatcherLimit = false;
         return {
             watchFile: watchFile,
             watchDirectory: watchDirectory
@@ -6586,7 +6590,7 @@ var ts;
                 case ts.WatchFileKind.FixedChunkSizePolling:
                     return ensureFixedChunkSizePollingWatchFile()(fileName, callback, /* pollingInterval */ undefined, /*options*/ undefined);
                 case ts.WatchFileKind.UseFsEvents:
-                    return fsWatch(fileName, 0 /* File */, createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileExists), 
+                    return fsWatch(fileName, 0 /* File */, createFsWatchCallbackForFileWatcherCallback(fileName, callback, getModifiedTime), 
                     /*recursive*/ false, pollingInterval, ts.getFallbackOptions(options));
                 case ts.WatchFileKind.UseFsEventsOnParentDirectory:
                     if (!nonPollingWatchFile) {
@@ -6647,7 +6651,7 @@ var ts;
                 hostRecursiveDirectoryWatcher = createDirectoryWatcherSupportingRecursive({
                     useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                     getCurrentDirectory: getCurrentDirectory,
-                    directoryExists: directoryExists,
+                    fileSystemEntryExists: fileSystemEntryExists,
                     getAccessibleSortedChildDirectories: getAccessibleSortedChildDirectories,
                     watchDirectory: nonRecursiveWatchDirectory,
                     realpath: realpath,
@@ -6698,6 +6702,122 @@ var ts;
                     };
             }
         }
+        function fsWatch(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) {
+            var lastDirectoryPartWithDirectorySeparator;
+            var lastDirectoryPart;
+            if (inodeWatching) {
+                lastDirectoryPartWithDirectorySeparator = fileOrDirectory.substring(fileOrDirectory.lastIndexOf(ts.directorySeparator));
+                lastDirectoryPart = lastDirectoryPartWithDirectorySeparator.slice(ts.directorySeparator.length);
+            }
+            /** Watcher for the file system entry depending on whether it is missing or present */
+            var watcher = !fileSystemEntryExists(fileOrDirectory, entryKind) ?
+                watchMissingFileSystemEntry() :
+                watchPresentFileSystemEntry();
+            return {
+                close: function () {
+                    // Close the watcher (either existing file system entry watcher or missing file system entry watcher)
+                    watcher.close();
+                    watcher = undefined;
+                }
+            };
+            function updateWatcher(createWatcher) {
+                // If watcher is not closed, update it
+                if (watcher) {
+                    sysLog("sysLog:: " + fileOrDirectory + ":: Changing watcher to " + (createWatcher === watchPresentFileSystemEntry ? "Present" : "Missing") + "FileSystemEntryWatcher");
+                    watcher.close();
+                    watcher = createWatcher();
+                }
+            }
+            /**
+             * Watch the file or directory that is currently present
+             * and when the watched file or directory is deleted, switch to missing file system entry watcher
+             */
+            function watchPresentFileSystemEntry() {
+                if (hitSystemWatcherLimit) {
+                    sysLog("sysLog:: " + fileOrDirectory + ":: Defaulting to watchFile");
+                    return watchPresentFileSystemEntryWithFsWatchFile();
+                }
+                try {
+                    var presentWatcher = fsWatchWorker(fileOrDirectory, recursive, inodeWatching ?
+                        callbackChangingToMissingFileSystemEntry :
+                        callback);
+                    // Watch the missing file or directory or error
+                    presentWatcher.on("error", function () {
+                        callback("rename", "");
+                        updateWatcher(watchMissingFileSystemEntry);
+                    });
+                    return presentWatcher;
+                }
+                catch (e) {
+                    // Catch the exception and use polling instead
+                    // Eg. on linux the number of watches are limited and one could easily exhaust watches and the exception ENOSPC is thrown when creating watcher at that point
+                    // so instead of throwing error, use fs.watchFile
+                    hitSystemWatcherLimit || (hitSystemWatcherLimit = e.code === "ENOSPC");
+                    sysLog("sysLog:: " + fileOrDirectory + ":: Changing to watchFile");
+                    return watchPresentFileSystemEntryWithFsWatchFile();
+                }
+            }
+            function callbackChangingToMissingFileSystemEntry(event, relativeName) {
+                // In some scenarios, file save operation fires event with fileName.ext~ instead of fileName.ext
+                // To ensure we see the file going missing and coming back up (file delete and then recreated)
+                // and watches being updated correctly we are calling back with fileName.ext as well as fileName.ext~
+                // The worst is we have fired event that was not needed but we wont miss any changes
+                // especially in cases where file goes missing and watches wrong inode
+                var originalRelativeName;
+                if (relativeName && ts.endsWith(relativeName, "~")) {
+                    originalRelativeName = relativeName;
+                    relativeName = relativeName.slice(0, relativeName.length - 1);
+                }
+                // because relativeName is not guaranteed to be correct we need to check on each rename with few combinations
+                // Eg on ubuntu while watching app/node_modules the relativeName is "node_modules" which is neither relative nor full path
+                if (event === "rename" &&
+                    (!relativeName ||
+                        relativeName === lastDirectoryPart ||
+                        ts.endsWith(relativeName, lastDirectoryPartWithDirectorySeparator))) {
+                    var modifiedTime = getModifiedTime(fileOrDirectory) || ts.missingFileModifiedTime;
+                    if (originalRelativeName)
+                        callback(event, originalRelativeName, modifiedTime);
+                    callback(event, relativeName, modifiedTime);
+                    if (inodeWatching) {
+                        // If this was rename event, inode has changed means we need to update watcher
+                        updateWatcher(modifiedTime === ts.missingFileModifiedTime ? watchMissingFileSystemEntry : watchPresentFileSystemEntry);
+                    }
+                    else if (modifiedTime === ts.missingFileModifiedTime) {
+                        updateWatcher(watchMissingFileSystemEntry);
+                    }
+                }
+                else {
+                    if (originalRelativeName)
+                        callback(event, originalRelativeName);
+                    callback(event, relativeName);
+                }
+            }
+            /**
+             * Watch the file or directory using fs.watchFile since fs.watch threw exception
+             * Eg. on linux the number of watches are limited and one could easily exhaust watches and the exception ENOSPC is thrown when creating watcher at that point
+             */
+            function watchPresentFileSystemEntryWithFsWatchFile() {
+                return watchFile(fileOrDirectory, createFileWatcherCallback(callback), fallbackPollingInterval, fallbackOptions);
+            }
+            /**
+             * Watch the file or directory that is missing
+             * and switch to existing file or directory when the missing filesystem entry is created
+             */
+            function watchMissingFileSystemEntry() {
+                return watchFile(fileOrDirectory, function (_fileName, eventKind, modifiedTime) {
+                    if (eventKind === FileWatcherEventKind.Created) {
+                        modifiedTime || (modifiedTime = getModifiedTime(fileOrDirectory) || ts.missingFileModifiedTime);
+                        if (modifiedTime !== ts.missingFileModifiedTime) {
+                            callback("rename", "", modifiedTime);
+                            // Call the callback for current file or directory
+                            // For now it could be callback for the inner directory creation,
+                            // but just return current directory, better than current no-op
+                            updateWatcher(watchPresentFileSystemEntry);
+                        }
+                    }
+                }, fallbackPollingInterval, fallbackOptions);
+            }
+        }
     }
     ts.createSystemWatchFunctions = createSystemWatchFunctions;
     /**
@@ -6750,7 +6870,6 @@ var ts;
             }
             var activeSession;
             var profilePath = "./profile.cpuprofile";
-            var hitSystemWatcherLimit = false;
             var Buffer = require("buffer").Buffer;
             var nodeVersion = getNodeMajorVersion();
             var isNode4OrLater = nodeVersion >= 4;
@@ -6765,20 +6884,21 @@ var ts;
                 getModifiedTime: getModifiedTime,
                 setTimeout: setTimeout,
                 clearTimeout: clearTimeout,
-                fsWatch: fsWatch,
+                fsWatchWorker: fsWatchWorker,
                 useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                 getCurrentDirectory: getCurrentDirectory,
-                fileExists: fileExists,
+                fileSystemEntryExists: fileSystemEntryExists,
                 // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows
                 // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
                 fsSupportsRecursiveFsWatch: fsSupportsRecursiveFsWatch,
-                directoryExists: directoryExists,
                 getAccessibleSortedChildDirectories: function (path) { return getAccessibleFileSystemEntries(path).directories; },
                 realpath: realpath,
                 tscWatchFile: process.env.TSC_WATCHFILE,
                 useNonPollingWatchers: process.env.TSC_NONPOLLING_WATCHER,
                 tscWatchDirectory: process.env.TSC_WATCHDIRECTORY,
                 defaultWatchFileKind: function () { var _a, _b; return (_b = (_a = sys).defaultWatchFileKind) === null || _b === void 0 ? void 0 : _b.call(_a); },
+                inodeWatching: isLinuxOrMacOs,
+                sysLog: sysLog,
             }), watchFile = _c.watchFile, watchDirectory = _c.watchDirectory;
             var nodeSystem = {
                 args: process.argv.slice(2),
@@ -7028,110 +7148,14 @@ var ts;
                         // File changed
                         eventKind = FileWatcherEventKind.Changed;
                     }
-                    callback(fileName, eventKind);
+                    callback(fileName, eventKind, curr.mtime);
                 }
             }
-            function fsWatch(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) {
-                var options;
-                var lastDirectoryPartWithDirectorySeparator;
-                var lastDirectoryPart;
-                if (isLinuxOrMacOs) {
-                    lastDirectoryPartWithDirectorySeparator = fileOrDirectory.substr(fileOrDirectory.lastIndexOf(ts.directorySeparator));
-                    lastDirectoryPart = lastDirectoryPartWithDirectorySeparator.slice(ts.directorySeparator.length);
-                }
-                /** Watcher for the file system entry depending on whether it is missing or present */
-                var watcher = !fileSystemEntryExists(fileOrDirectory, entryKind) ?
-                    watchMissingFileSystemEntry() :
-                    watchPresentFileSystemEntry();
-                return {
-                    close: function () {
-                        // Close the watcher (either existing file system entry watcher or missing file system entry watcher)
-                        watcher.close();
-                        watcher = undefined;
-                    }
-                };
-                /**
-                 * Invoke the callback with rename and update the watcher if not closed
-                 * @param createWatcher
-                 */
-                function invokeCallbackAndUpdateWatcher(createWatcher) {
-                    sysLog("sysLog:: " + fileOrDirectory + ":: Changing watcher to " + (createWatcher === watchPresentFileSystemEntry ? "Present" : "Missing") + "FileSystemEntryWatcher");
-                    // Call the callback for current directory
-                    callback("rename", "");
-                    // If watcher is not closed, update it
-                    if (watcher) {
-                        watcher.close();
-                        watcher = createWatcher();
-                    }
-                }
-                /**
-                 * Watch the file or directory that is currently present
-                 * and when the watched file or directory is deleted, switch to missing file system entry watcher
-                 */
-                function watchPresentFileSystemEntry() {
-                    // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows
-                    // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
-                    if (options === undefined) {
-                        if (fsSupportsRecursiveFsWatch) {
-                            options = { persistent: true, recursive: !!recursive };
-                        }
-                        else {
-                            options = { persistent: true };
-                        }
-                    }
-                    if (hitSystemWatcherLimit) {
-                        sysLog("sysLog:: " + fileOrDirectory + ":: Defaulting to fsWatchFile");
-                        return watchPresentFileSystemEntryWithFsWatchFile();
-                    }
-                    try {
-                        var presentWatcher = _fs.watch(fileOrDirectory, options, isLinuxOrMacOs ?
-                            callbackChangingToMissingFileSystemEntry :
-                            callback);
-                        // Watch the missing file or directory or error
-                        presentWatcher.on("error", function () { return invokeCallbackAndUpdateWatcher(watchMissingFileSystemEntry); });
-                        return presentWatcher;
-                    }
-                    catch (e) {
-                        // Catch the exception and use polling instead
-                        // Eg. on linux the number of watches are limited and one could easily exhaust watches and the exception ENOSPC is thrown when creating watcher at that point
-                        // so instead of throwing error, use fs.watchFile
-                        hitSystemWatcherLimit || (hitSystemWatcherLimit = e.code === "ENOSPC");
-                        sysLog("sysLog:: " + fileOrDirectory + ":: Changing to fsWatchFile");
-                        return watchPresentFileSystemEntryWithFsWatchFile();
-                    }
-                }
-                function callbackChangingToMissingFileSystemEntry(event, relativeName) {
-                    // because relativeName is not guaranteed to be correct we need to check on each rename with few combinations
-                    // Eg on ubuntu while watching app/node_modules the relativeName is "node_modules" which is neither relative nor full path
-                    return event === "rename" &&
-                        (!relativeName ||
-                            relativeName === lastDirectoryPart ||
-                            (relativeName.lastIndexOf(lastDirectoryPartWithDirectorySeparator) !== -1 && relativeName.lastIndexOf(lastDirectoryPartWithDirectorySeparator) === relativeName.length - lastDirectoryPartWithDirectorySeparator.length)) &&
-                        !fileSystemEntryExists(fileOrDirectory, entryKind) ?
-                        invokeCallbackAndUpdateWatcher(watchMissingFileSystemEntry) :
-                        callback(event, relativeName);
-                }
-                /**
-                 * Watch the file or directory using fs.watchFile since fs.watch threw exception
-                 * Eg. on linux the number of watches are limited and one could easily exhaust watches and the exception ENOSPC is thrown when creating watcher at that point
-                 */
-                function watchPresentFileSystemEntryWithFsWatchFile() {
-                    return watchFile(fileOrDirectory, createFileWatcherCallback(callback), fallbackPollingInterval, fallbackOptions);
-                }
-                /**
-                 * Watch the file or directory that is missing
-                 * and switch to existing file or directory when the missing filesystem entry is created
-                 */
-                function watchMissingFileSystemEntry() {
-                    return watchFile(fileOrDirectory, function (_fileName, eventKind) {
-                        if (eventKind === FileWatcherEventKind.Created && fileSystemEntryExists(fileOrDirectory, entryKind)) {
-                            // Call the callback for current file or directory
-                            // For now it could be callback for the inner directory creation,
-                            // but just return current directory, better than current no-op
-                            invokeCallbackAndUpdateWatcher(watchPresentFileSystemEntry);
-                        }
-                    }, fallbackPollingInterval, fallbackOptions);
-                }
+            function fsWatchWorker(fileOrDirectory, recursive, callback) {
+                // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows
+                // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
+                return _fs.watch(fileOrDirectory, fsSupportsRecursiveFsWatch ?
+                    { persistent: true, recursive: !!recursive } : { persistent: true }, callback);
             }
             function readFileWorker(fileName, _encoding) {
                 var buffer;
@@ -7278,12 +7302,19 @@ var ts;
             }
             function getModifiedTime(path) {
                 var _a;
+                // Since the error thrown by fs.statSync isn't used, we can avoid collecting a stack trace to improve
+                // the CPU time performance.
+                var originalStackTraceLimit = Error.stackTraceLimit;
+                Error.stackTraceLimit = 0;
                 try {
                     return (_a = statSync(path)) === null || _a === void 0 ? void 0 : _a.mtime;
                 }
                 catch (e) {
                     return undefined;
                 }
+                finally {
+                    Error.stackTraceLimit = originalStackTraceLimit;
+                }
             }
             function setModifiedTime(path, time) {
                 try {
@@ -9308,8 +9339,8 @@ var ts;
         Cannot_prepend_project_0_because_it_does_not_have_outFile_set: diag(6308, ts.DiagnosticCategory.Error, "Cannot_prepend_project_0_because_it_does_not_have_outFile_set_6308", "Cannot prepend project '{0}' because it does not have 'outFile' set"),
         Output_file_0_from_project_1_does_not_exist: diag(6309, ts.DiagnosticCategory.Error, "Output_file_0_from_project_1_does_not_exist_6309", "Output file '{0}' from project '{1}' does not exist"),
         Referenced_project_0_may_not_disable_emit: diag(6310, ts.DiagnosticCategory.Error, "Referenced_project_0_may_not_disable_emit_6310", "Referenced project '{0}' may not disable emit."),
-        Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2: diag(6350, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2_6350", "Project '{0}' is out of date because oldest output '{1}' is older than newest input '{2}'"),
-        Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2: diag(6351, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2_6351", "Project '{0}' is up to date because newest input '{1}' is older than oldest output '{2}'"),
+        Project_0_is_out_of_date_because_output_1_is_older_than_input_2: diag(6350, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_1_is_older_than_input_2_6350", "Project '{0}' is out of date because output '{1}' is older than input '{2}'"),
+        Project_0_is_up_to_date_because_newest_input_1_is_older_than_output_2: diag(6351, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_because_newest_input_1_is_older_than_output_2_6351", "Project '{0}' is up to date because newest input '{1}' is older than output '{2}'"),
         Project_0_is_out_of_date_because_output_file_1_does_not_exist: diag(6352, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_file_1_does_not_exist_6352", "Project '{0}' is out of date because output file '{1}' does not exist"),
         Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date: diag(6353, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date_6353", "Project '{0}' is out of date because its dependency '{1}' is out of date"),
         Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies: diag(6354, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies_6354", "Project '{0}' is up to date with .d.ts files from its dependencies"),
@@ -9353,6 +9384,8 @@ var ts;
         Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3: diag(6396, ts.DiagnosticCategory.Message, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_succes_6396", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}'."),
         Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4: diag(6397, ts.DiagnosticCategory.Message, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_succes_6397", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}' with Package ID '{4}'."),
         Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_not_resolved: diag(6398, ts.DiagnosticCategory.Message, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_not_re_6398", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was not resolved."),
+        Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_were_not_emitted: diag(6399, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_were_not_emitte_6399", "Project '{0}' is out of date because buildinfo file '{1}' indicates that some of the changes were not emitted"),
+        Project_0_is_up_to_date_but_needs_to_update_timestamps_of_output_files_that_are_older_than_input_files: diag(6400, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_but_needs_to_update_timestamps_of_output_files_that_are_older_than_input_fil_6400", "Project '{0}' is up to date but needs to update timestamps of output files that are older than input files"),
         The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1: diag(6500, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1_6500", "The expected type comes from property '{0}' which is declared here on type '{1}'"),
         The_expected_type_comes_from_this_index_signature: diag(6501, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_this_index_signature_6501", "The expected type comes from this index signature."),
         The_expected_type_comes_from_the_return_type_of_this_signature: diag(6502, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_the_return_type_of_this_signature_6502", "The expected type comes from the return type of this signature."),
@@ -20190,6 +20223,10 @@ var ts;
         return optionsHaveChanges(oldOptions, newOptions, ts.affectsEmitOptionDeclarations);
     }
     ts.compilerOptionsAffectEmit = compilerOptionsAffectEmit;
+    function compilerOptionsAffectDeclarationPath(newOptions, oldOptions) {
+        return optionsHaveChanges(oldOptions, newOptions, ts.affectsDeclarationPathOptionDeclarations);
+    }
+    ts.compilerOptionsAffectDeclarationPath = compilerOptionsAffectDeclarationPath;
     function getCompilerOptionValue(options, option) {
         return option.strictFlag ? getStrictOptionValue(options, option.name) : options[option.name];
     }
@@ -39033,6 +39070,7 @@ var ts;
         ["es2022.error", "lib.es2022.error.d.ts"],
         ["es2022.intl", "lib.es2022.intl.d.ts"],
         ["es2022.object", "lib.es2022.object.d.ts"],
+        ["es2022.sharedmemory", "lib.es2022.sharedmemory.d.ts"],
         ["es2022.string", "lib.es2022.string.d.ts"],
         ["esnext.array", "lib.es2022.array.d.ts"],
         ["esnext.symbol", "lib.es2019.symbol.d.ts"],
@@ -39246,6 +39284,7 @@ var ts;
             type: "boolean",
             affectsSemanticDiagnostics: true,
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Watch_and_Build_Modes,
             description: ts.Diagnostics.Have_recompiles_in_projects_that_use_incremental_and_watch_mode_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it,
             defaultValueDescription: false,
@@ -39280,12 +39319,40 @@ var ts;
         affectsSourceFile: true,
         affectsModuleResolution: true,
         affectsEmit: true,
+        affectsMultiFileEmitBuildInfo: true,
         paramType: ts.Diagnostics.VERSION,
         showInSimplifiedHelpView: true,
         category: ts.Diagnostics.Language_and_Environment,
         description: ts.Diagnostics.Set_the_JavaScript_language_version_for_emitted_JavaScript_and_include_compatible_library_declarations,
         defaultValueDescription: 0 /* ES3 */,
     };
+    /*@internal*/
+    ts.moduleOptionDeclaration = {
+        name: "module",
+        shortName: "m",
+        type: new ts.Map(ts.getEntries({
+            none: ts.ModuleKind.None,
+            commonjs: ts.ModuleKind.CommonJS,
+            amd: ts.ModuleKind.AMD,
+            system: ts.ModuleKind.System,
+            umd: ts.ModuleKind.UMD,
+            es6: ts.ModuleKind.ES2015,
+            es2015: ts.ModuleKind.ES2015,
+            es2020: ts.ModuleKind.ES2020,
+            es2022: ts.ModuleKind.ES2022,
+            esnext: ts.ModuleKind.ESNext,
+            node16: ts.ModuleKind.Node16,
+            nodenext: ts.ModuleKind.NodeNext,
+        })),
+        affectsModuleResolution: true,
+        affectsEmit: true,
+        affectsMultiFileEmitBuildInfo: true,
+        paramType: ts.Diagnostics.KIND,
+        showInSimplifiedHelpView: true,
+        category: ts.Diagnostics.Modules,
+        description: ts.Diagnostics.Specify_what_module_code_is_generated,
+        defaultValueDescription: undefined,
+    };
     var commandOptionsWithoutBuild = [
         // CommandLine only options
         {
@@ -39347,37 +39414,14 @@ var ts;
             category: ts.Diagnostics.Command_line_Options,
             affectsSemanticDiagnostics: true,
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             isCommandLineOnly: true,
             description: ts.Diagnostics.Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing,
             defaultValueDescription: false,
         },
         // Basic
         ts.targetOptionDeclaration,
-        {
-            name: "module",
-            shortName: "m",
-            type: new ts.Map(ts.getEntries({
-                none: ts.ModuleKind.None,
-                commonjs: ts.ModuleKind.CommonJS,
-                amd: ts.ModuleKind.AMD,
-                system: ts.ModuleKind.System,
-                umd: ts.ModuleKind.UMD,
-                es6: ts.ModuleKind.ES2015,
-                es2015: ts.ModuleKind.ES2015,
-                es2020: ts.ModuleKind.ES2020,
-                es2022: ts.ModuleKind.ES2022,
-                esnext: ts.ModuleKind.ESNext,
-                node16: ts.ModuleKind.Node16,
-                nodenext: ts.ModuleKind.NodeNext,
-            })),
-            affectsModuleResolution: true,
-            affectsEmit: true,
-            paramType: ts.Diagnostics.KIND,
-            showInSimplifiedHelpView: true,
-            category: ts.Diagnostics.Modules,
-            description: ts.Diagnostics.Specify_what_module_code_is_generated,
-            defaultValueDescription: undefined,
-        },
+        ts.moduleOptionDeclaration,
         {
             name: "lib",
             type: "list",
@@ -39414,6 +39458,7 @@ var ts;
             type: jsxOptionMap,
             affectsSourceFile: true,
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             affectsModuleResolution: true,
             paramType: ts.Diagnostics.KIND,
             showInSimplifiedHelpView: true,
@@ -39426,6 +39471,7 @@ var ts;
             shortName: "d",
             type: "boolean",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             showInSimplifiedHelpView: true,
             category: ts.Diagnostics.Emit,
             transpileOptionValue: undefined,
@@ -39436,6 +39482,7 @@ var ts;
             name: "declarationMap",
             type: "boolean",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             showInSimplifiedHelpView: true,
             category: ts.Diagnostics.Emit,
             transpileOptionValue: undefined,
@@ -39446,6 +39493,7 @@ var ts;
             name: "emitDeclarationOnly",
             type: "boolean",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             showInSimplifiedHelpView: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Only_output_d_ts_files_and_not_JavaScript_files,
@@ -39456,6 +39504,7 @@ var ts;
             name: "sourceMap",
             type: "boolean",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             showInSimplifiedHelpView: true,
             category: ts.Diagnostics.Emit,
             defaultValueDescription: false,
@@ -39465,6 +39514,9 @@ var ts;
             name: "outFile",
             type: "string",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
+            affectsDeclarationPath: true,
+            affectsBundleEmitBuildInfo: true,
             isFilePath: true,
             paramType: ts.Diagnostics.FILE,
             showInSimplifiedHelpView: true,
@@ -39476,6 +39528,8 @@ var ts;
             name: "outDir",
             type: "string",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
+            affectsDeclarationPath: true,
             isFilePath: true,
             paramType: ts.Diagnostics.DIRECTORY,
             showInSimplifiedHelpView: true,
@@ -39486,6 +39540,8 @@ var ts;
             name: "rootDir",
             type: "string",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
+            affectsDeclarationPath: true,
             isFilePath: true,
             paramType: ts.Diagnostics.LOCATION,
             category: ts.Diagnostics.Modules,
@@ -39496,6 +39552,8 @@ var ts;
             name: "composite",
             type: "boolean",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
+            affectsBundleEmitBuildInfo: true,
             isTSConfigOnly: true,
             category: ts.Diagnostics.Projects,
             transpileOptionValue: undefined,
@@ -39506,6 +39564,8 @@ var ts;
             name: "tsBuildInfoFile",
             type: "string",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
+            affectsBundleEmitBuildInfo: true,
             isFilePath: true,
             paramType: ts.Diagnostics.FILE,
             category: ts.Diagnostics.Projects,
@@ -39517,6 +39577,7 @@ var ts;
             name: "removeComments",
             type: "boolean",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             showInSimplifiedHelpView: true,
             category: ts.Diagnostics.Emit,
             defaultValueDescription: false,
@@ -39535,6 +39596,7 @@ var ts;
             name: "importHelpers",
             type: "boolean",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Allow_importing_helper_functions_from_tslib_once_per_project_instead_of_including_them_per_file,
             defaultValueDescription: false,
@@ -39548,6 +39610,7 @@ var ts;
             })),
             affectsEmit: true,
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types,
             defaultValueDescription: 0 /* Remove */,
@@ -39556,6 +39619,7 @@ var ts;
             name: "downlevelIteration",
             type: "boolean",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Emit_more_compliant_but_verbose_and_less_performant_JavaScript_for_iteration,
             defaultValueDescription: false,
@@ -39574,6 +39638,9 @@ var ts;
             type: "boolean",
             // Though this affects semantic diagnostics, affectsSemanticDiagnostics is not set here
             // The value of each strictFlag depends on own strictFlag value or this and never accessed directly.
+            // But we need to store `strict` in builf info, even though it won't be examined directly, so that the
+            // flags it controls (e.g. `strictNullChecks`) will be retrieved correctly
+            affectsMultiFileEmitBuildInfo: true,
             showInSimplifiedHelpView: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Enable_all_strict_type_checking_options,
@@ -39583,6 +39650,7 @@ var ts;
             name: "noImplicitAny",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             strictFlag: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Enable_error_reporting_for_expressions_and_declarations_with_an_implied_any_type,
@@ -39592,6 +39660,7 @@ var ts;
             name: "strictNullChecks",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             strictFlag: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.When_type_checking_take_into_account_null_and_undefined,
@@ -39600,6 +39669,8 @@ var ts;
         {
             name: "strictFunctionTypes",
             type: "boolean",
+            affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             strictFlag: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.When_assigning_functions_check_to_ensure_parameters_and_the_return_values_are_subtype_compatible,
@@ -39608,6 +39679,8 @@ var ts;
         {
             name: "strictBindCallApply",
             type: "boolean",
+            affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             strictFlag: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Check_that_the_arguments_for_bind_call_and_apply_methods_match_the_original_function,
@@ -39617,6 +39690,7 @@ var ts;
             name: "strictPropertyInitialization",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             strictFlag: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Check_for_class_properties_that_are_declared_but_not_set_in_the_constructor,
@@ -39626,6 +39700,7 @@ var ts;
             name: "noImplicitThis",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             strictFlag: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Enable_error_reporting_when_this_is_given_the_type_any,
@@ -39635,6 +39710,7 @@ var ts;
             name: "useUnknownInCatchVariables",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             strictFlag: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Default_catch_clause_variables_as_unknown_instead_of_any,
@@ -39644,6 +39720,8 @@ var ts;
             name: "alwaysStrict",
             type: "boolean",
             affectsSourceFile: true,
+            affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             strictFlag: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Ensure_use_strict_is_always_emitted,
@@ -39654,6 +39732,7 @@ var ts;
             name: "noUnusedLocals",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Enable_error_reporting_when_local_variables_aren_t_read,
             defaultValueDescription: false,
@@ -39662,6 +39741,7 @@ var ts;
             name: "noUnusedParameters",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Raise_an_error_when_a_function_parameter_isn_t_read,
             defaultValueDescription: false,
@@ -39670,6 +39750,7 @@ var ts;
             name: "exactOptionalPropertyTypes",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Interpret_optional_property_types_as_written_rather_than_adding_undefined,
             defaultValueDescription: false,
@@ -39678,6 +39759,7 @@ var ts;
             name: "noImplicitReturns",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Enable_error_reporting_for_codepaths_that_do_not_explicitly_return_in_a_function,
             defaultValueDescription: false,
@@ -39687,6 +39769,7 @@ var ts;
             type: "boolean",
             affectsBindDiagnostics: true,
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Enable_error_reporting_for_fallthrough_cases_in_switch_statements,
             defaultValueDescription: false,
@@ -39695,6 +39778,7 @@ var ts;
             name: "noUncheckedIndexedAccess",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Add_undefined_to_a_type_when_accessed_using_an_index,
             defaultValueDescription: false,
@@ -39703,6 +39787,7 @@ var ts;
             name: "noImplicitOverride",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Ensure_overriding_members_in_derived_classes_are_marked_with_an_override_modifier,
             defaultValueDescription: false,
@@ -39710,6 +39795,8 @@ var ts;
         {
             name: "noPropertyAccessFromIndexSignature",
             type: "boolean",
+            affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             showInSimplifiedHelpView: false,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Enforces_using_indexed_accessors_for_keys_declared_using_an_indexed_type,
@@ -39795,6 +39882,7 @@ var ts;
             name: "allowSyntheticDefaultImports",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Interop_Constraints,
             description: ts.Diagnostics.Allow_import_x_from_y_when_a_module_doesn_t_have_a_default_export,
             defaultValueDescription: ts.Diagnostics.module_system_or_esModuleInterop
@@ -39804,6 +39892,7 @@ var ts;
             type: "boolean",
             affectsSemanticDiagnostics: true,
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             showInSimplifiedHelpView: true,
             category: ts.Diagnostics.Interop_Constraints,
             description: ts.Diagnostics.Emit_additional_JavaScript_to_ease_support_for_importing_CommonJS_modules_This_enables_allowSyntheticDefaultImports_for_type_compatibility,
@@ -39820,6 +39909,7 @@ var ts;
             name: "allowUmdGlobalAccess",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Modules,
             description: ts.Diagnostics.Allow_accessing_UMD_globals_from_modules,
             defaultValueDescription: false,
@@ -39841,6 +39931,7 @@ var ts;
             name: "sourceRoot",
             type: "string",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             paramType: ts.Diagnostics.LOCATION,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Specify_the_root_path_for_debuggers_to_find_the_reference_source_code,
@@ -39849,6 +39940,7 @@ var ts;
             name: "mapRoot",
             type: "string",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             paramType: ts.Diagnostics.LOCATION,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations,
@@ -39857,6 +39949,7 @@ var ts;
             name: "inlineSourceMap",
             type: "boolean",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Include_sourcemap_files_inside_the_emitted_JavaScript,
             defaultValueDescription: false,
@@ -39865,6 +39958,7 @@ var ts;
             name: "inlineSources",
             type: "boolean",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Include_source_code_in_the_sourcemaps_inside_the_emitted_JavaScript,
             defaultValueDescription: false,
@@ -39874,6 +39968,7 @@ var ts;
             name: "experimentalDecorators",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Language_and_Environment,
             description: ts.Diagnostics.Enable_experimental_support_for_TC39_stage_2_draft_decorators,
             defaultValueDescription: false,
@@ -39883,6 +39978,7 @@ var ts;
             type: "boolean",
             affectsSemanticDiagnostics: true,
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Language_and_Environment,
             description: ts.Diagnostics.Emit_design_type_metadata_for_decorated_declarations_in_source_files,
             defaultValueDescription: false,
@@ -39907,6 +40003,7 @@ var ts;
             type: "string",
             affectsSemanticDiagnostics: true,
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             affectsModuleResolution: true,
             category: ts.Diagnostics.Language_and_Environment,
             description: ts.Diagnostics.Specify_module_specifier_used_to_import_the_JSX_factory_functions_when_using_jsx_Colon_react_jsx_Asterisk,
@@ -39924,6 +40021,9 @@ var ts;
             name: "out",
             type: "string",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
+            affectsDeclarationPath: true,
+            affectsBundleEmitBuildInfo: true,
             isFilePath: false,
             // for correct behaviour, please use outFile
             category: ts.Diagnostics.Backwards_Compatibility,
@@ -39935,6 +40035,7 @@ var ts;
             name: "reactNamespace",
             type: "string",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Language_and_Environment,
             description: ts.Diagnostics.Specify_the_object_invoked_for_createElement_This_only_applies_when_targeting_react_JSX_emit,
             defaultValueDescription: "`React`",
@@ -39942,6 +40043,8 @@ var ts;
         {
             name: "skipDefaultLibCheck",
             type: "boolean",
+            // We need to store these to determine whether `lib` files need to be rechecked
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Completeness,
             description: ts.Diagnostics.Skip_type_checking_d_ts_files_that_are_included_with_TypeScript,
             defaultValueDescription: false,
@@ -39957,6 +40060,7 @@ var ts;
             name: "emitBOM",
             type: "boolean",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files,
             defaultValueDescription: false,
@@ -39968,6 +40072,7 @@ var ts;
                 lf: 1 /* LineFeed */
             })),
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             paramType: ts.Diagnostics.NEWLINE,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Set_the_newline_character_for_emitting_files,
@@ -39977,6 +40082,7 @@ var ts;
             name: "noErrorTruncation",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Output_Formatting,
             description: ts.Diagnostics.Disable_truncating_types_in_error_messages,
             defaultValueDescription: false,
@@ -40007,6 +40113,7 @@ var ts;
             name: "stripInternal",
             type: "boolean",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Disable_emitting_declarations_that_have_internal_in_their_JSDoc_comments,
             defaultValueDescription: false,
@@ -40047,6 +40154,7 @@ var ts;
             name: "noImplicitUseStrict",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Backwards_Compatibility,
             description: ts.Diagnostics.Disable_adding_use_strict_directives_in_emitted_JavaScript_files,
             defaultValueDescription: false,
@@ -40055,6 +40163,7 @@ var ts;
             name: "noEmitHelpers",
             type: "boolean",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Disable_generating_custom_helper_functions_like_extends_in_compiled_output,
             defaultValueDescription: false,
@@ -40063,6 +40172,7 @@ var ts;
             name: "noEmitOnError",
             type: "boolean",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             transpileOptionValue: undefined,
             description: ts.Diagnostics.Disable_emitting_files_if_any_type_checking_errors_are_reported,
@@ -40072,6 +40182,7 @@ var ts;
             name: "preserveConstEnums",
             type: "boolean",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Disable_erasing_const_enum_declarations_in_generated_code,
             defaultValueDescription: false,
@@ -40080,6 +40191,8 @@ var ts;
             name: "declarationDir",
             type: "string",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
+            affectsDeclarationPath: true,
             isFilePath: true,
             paramType: ts.Diagnostics.DIRECTORY,
             category: ts.Diagnostics.Emit,
@@ -40089,6 +40202,8 @@ var ts;
         {
             name: "skipLibCheck",
             type: "boolean",
+            // We need to store these to determine whether `lib` files need to be rechecked
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Completeness,
             description: ts.Diagnostics.Skip_type_checking_all_d_ts_files,
             defaultValueDescription: false,
@@ -40098,6 +40213,7 @@ var ts;
             type: "boolean",
             affectsBindDiagnostics: true,
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Disable_error_reporting_for_unused_labels,
             defaultValueDescription: undefined,
@@ -40107,6 +40223,7 @@ var ts;
             type: "boolean",
             affectsBindDiagnostics: true,
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Disable_error_reporting_for_unreachable_code,
             defaultValueDescription: undefined,
@@ -40115,6 +40232,7 @@ var ts;
             name: "suppressExcessPropertyErrors",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Backwards_Compatibility,
             description: ts.Diagnostics.Disable_reporting_of_excess_property_errors_during_the_creation_of_object_literals,
             defaultValueDescription: false,
@@ -40123,6 +40241,7 @@ var ts;
             name: "suppressImplicitAnyIndexErrors",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Backwards_Compatibility,
             description: ts.Diagnostics.Suppress_noImplicitAny_errors_when_indexing_objects_that_lack_index_signatures,
             defaultValueDescription: false,
@@ -40147,6 +40266,7 @@ var ts;
             name: "noStrictGenericChecks",
             type: "boolean",
             affectsSemanticDiagnostics: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Backwards_Compatibility,
             description: ts.Diagnostics.Disable_strict_checking_of_generic_signatures_in_function_types,
             defaultValueDescription: false,
@@ -40156,6 +40276,7 @@ var ts;
             type: "boolean",
             affectsSemanticDiagnostics: true,
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Language_and_Environment,
             description: ts.Diagnostics.Emit_ECMAScript_standard_compliant_class_fields,
             defaultValueDescription: ts.Diagnostics.true_for_ES2022_and_above_including_ESNext
@@ -40164,6 +40285,7 @@ var ts;
             name: "preserveValueImports",
             type: "boolean",
             affectsEmit: true,
+            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed,
             defaultValueDescription: false,
@@ -40207,6 +40329,8 @@ var ts;
     /* @internal */
     ts.affectsEmitOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsEmit; });
     /* @internal */
+    ts.affectsDeclarationPathOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsDeclarationPath; });
+    /* @internal */
     ts.moduleResolutionOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsModuleResolution; });
     /* @internal */
     ts.sourceFileAffectingCompilerOptions = ts.optionDeclarations.filter(function (option) {
@@ -41062,6 +41186,7 @@ var ts;
             return optionDefinition.type;
         }
     }
+    /* @internal */
     function getNameOfCompilerOptionValue(value, customTypeMap) {
         // There is a typeMap associated with this command-line option so use it to map value back to its name
         return ts.forEachEntry(customTypeMap, function (mapValue, key) {
@@ -41070,6 +41195,7 @@ var ts;
             }
         });
     }
+    ts.getNameOfCompilerOptionValue = getNameOfCompilerOptionValue;
     function serializeCompilerOptions(options, pathOptions) {
         return serializeOptionBaseObject(options, getOptionsNameMap(), pathOptions);
     }
@@ -42235,16 +42361,18 @@ var ts;
         ts.Debug.assert(ts.extensionIsTS(resolved.extension));
         return { fileName: resolved.path, packageId: resolved.packageId };
     }
-    function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, diagnostics, resultFromCache) {
-        var _a;
+    function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, resultFromCache) {
+        var _a, _b;
         if (resultFromCache) {
             (_a = resultFromCache.failedLookupLocations).push.apply(_a, failedLookupLocations);
+            (_b = resultFromCache.affectingLocations).push.apply(_b, affectingLocations);
             return resultFromCache;
         }
         return {
             resolvedModule: resolved && { resolvedFileName: resolved.path, originalPath: resolved.originalPath === true ? undefined : resolved.originalPath, extension: resolved.extension, isExternalLibraryImport: isExternalLibraryImport, packageId: resolved.packageId },
             failedLookupLocations: failedLookupLocations,
-            resolutionDiagnostics: diagnostics
+            affectingLocations: affectingLocations,
+            resolutionDiagnostics: diagnostics,
         };
     }
     function readPackageJsonField(jsonContent, fieldName, typeOfTag, state) {
@@ -42433,6 +42561,7 @@ var ts;
             }
         }
         var failedLookupLocations = [];
+        var affectingLocations = [];
         var features = getDefaultNodeResolutionFeatures(options);
         // Unlike `import` statements, whose mode-calculating APIs are all guaranteed to return `undefined` if we're in an un-mode-ed module resolution
         // setting, type references will return their target mode regardless of options because of how the parser works, so we guard against the mode being
@@ -42451,6 +42580,7 @@ var ts;
             host: host,
             traceEnabled: traceEnabled,
             failedLookupLocations: failedLookupLocations,
+            affectingLocations: affectingLocations,
             packageJsonInfoCache: cache,
             features: features,
             conditions: conditions,
@@ -42475,7 +42605,7 @@ var ts;
                 isExternalLibraryImport: pathContainsNodeModules(fileName),
             };
         }
-        result = { resolvedTypeReferenceDirective: resolvedTypeReferenceDirective, failedLookupLocations: failedLookupLocations, resolutionDiagnostics: diagnostics };
+        result = { resolvedTypeReferenceDirective: resolvedTypeReferenceDirective, failedLookupLocations: failedLookupLocations, affectingLocations: affectingLocations, resolutionDiagnostics: diagnostics };
         perFolderCache === null || perFolderCache === void 0 ? void 0 : perFolderCache.set(typeReferenceDirectiveName, /*mode*/ resolutionMode, result);
         if (traceEnabled)
             traceResult(result);
@@ -42555,6 +42685,7 @@ var ts;
             host: host,
             traceEnabled: isTraceEnabled(options, host),
             failedLookupLocations: [],
+            affectingLocations: [],
             packageJsonInfoCache: cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(),
             conditions: ts.emptyArray,
             features: NodeResolutionFeatures.None,
@@ -43209,6 +43340,7 @@ var ts;
         var _a, _b;
         var traceEnabled = isTraceEnabled(compilerOptions, host);
         var failedLookupLocations = [];
+        var affectingLocations = [];
         // conditions are only used by the node16/nodenext resolver - there's no priority order in the list,
         //it's essentially a set (priority is determined by object insertion order in the object we look at).
         var conditions = features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"];
@@ -43221,6 +43353,7 @@ var ts;
             host: host,
             traceEnabled: traceEnabled,
             failedLookupLocations: failedLookupLocations,
+            affectingLocations: affectingLocations,
             packageJsonInfoCache: cache,
             features: features,
             conditions: conditions,
@@ -43228,7 +43361,7 @@ var ts;
             reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
         };
         var result = ts.forEach(extensions, function (ext) { return tryResolve(ext); });
-        return createResolvedModuleWithFailedLookupLocations((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, diagnostics, state.resultFromCache);
+        return createResolvedModuleWithFailedLookupLocations((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, state.resultFromCache);
         function tryResolve(extensions) {
             var loader = function (extensions, candidate, onlyRecordFailures, state) { return nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, /*considerPackageJson*/ true); };
             var resolved = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, state);
@@ -43523,6 +43656,7 @@ var ts;
             host: host,
             traceEnabled: isTraceEnabled(options, host),
             failedLookupLocations: [],
+            affectingLocations: [],
             packageJsonInfoCache: cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(),
             conditions: ["node", "require", "types"],
             features: features,
@@ -43611,6 +43745,7 @@ var ts;
             compilerOptions: options,
             traceEnabled: isTraceEnabled(options, host),
             failedLookupLocations: [],
+            affectingLocations: [],
             packageJsonInfoCache: packageJsonInfoCache,
             features: 0,
             conditions: [],
@@ -43643,6 +43778,7 @@ var ts;
             if (typeof existing !== "boolean") {
                 if (traceEnabled)
                     trace(host, ts.Diagnostics.File_0_exists_according_to_earlier_cached_lookups, packageJsonPath);
+                state.affectingLocations.push(packageJsonPath);
                 return existing;
             }
             else {
@@ -43661,6 +43797,7 @@ var ts;
             var versionPaths = readPackageJsonTypesVersionPaths(packageJsonContent, state);
             var result = { packageDirectory: packageDirectory, packageJsonContent: packageJsonContent, versionPaths: versionPaths, resolvedEntrypoints: undefined };
             (_b = state.packageJsonInfoCache) === null || _b === void 0 ? void 0 : _b.setPackageJsonInfo(packageJsonPath, result);
+            state.affectingLocations.push(packageJsonPath);
             return result;
         }
         else {
@@ -44324,12 +44461,25 @@ var ts;
     function classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference) {
         var traceEnabled = isTraceEnabled(compilerOptions, host);
         var failedLookupLocations = [];
+        var affectingLocations = [];
         var containingDirectory = ts.getDirectoryPath(containingFile);
         var diagnostics = [];
-        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: NodeResolutionFeatures.None, conditions: [], requestContainingDirectory: containingDirectory, reportDiagnostic: function (diag) { return void diagnostics.push(diag); } };
+        var state = {
+            compilerOptions: compilerOptions,
+            host: host,
+            traceEnabled: traceEnabled,
+            failedLookupLocations: failedLookupLocations,
+            affectingLocations: affectingLocations,
+            packageJsonInfoCache: cache,
+            features: NodeResolutionFeatures.None,
+            conditions: [],
+            requestContainingDirectory: containingDirectory,
+            reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
+        };
         var resolved = tryResolve(Extensions.TypeScript) || tryResolve(Extensions.JavaScript);
         // No originalPath because classic resolution doesn't resolve realPath
-        return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, /*isExternalLibraryImport*/ false, failedLookupLocations, diagnostics, state.resultFromCache);
+        return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, 
+        /*isExternalLibraryImport*/ false, failedLookupLocations, affectingLocations, diagnostics, state.resultFromCache);
         function tryResolve(extensions) {
             var resolvedUsingSettings = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loadModuleFromFileNoPackageId, state);
             if (resolvedUsingSettings) {
@@ -44372,10 +44522,23 @@ var ts;
             trace(host, ts.Diagnostics.Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2, projectName, moduleName, globalCache);
         }
         var failedLookupLocations = [];
+        var affectingLocations = [];
         var diagnostics = [];
-        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: packageJsonInfoCache, features: NodeResolutionFeatures.None, conditions: [], requestContainingDirectory: undefined, reportDiagnostic: function (diag) { return void diagnostics.push(diag); } };
+        var state = {
+            compilerOptions: compilerOptions,
+            host: host,
+            traceEnabled: traceEnabled,
+            failedLookupLocations: failedLookupLocations,
+            affectingLocations: affectingLocations,
+            packageJsonInfoCache: packageJsonInfoCache,
+            features: NodeResolutionFeatures.None,
+            conditions: [],
+            requestContainingDirectory: undefined,
+            reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
+        };
         var resolved = loadModuleFromImmediateNodeModulesDirectory(Extensions.DtsOnly, moduleName, globalCache, state, /*typesScopeOnly*/ false, /*cache*/ undefined, /*redirectedReference*/ undefined);
-        return createResolvedModuleWithFailedLookupLocations(resolved, /*isExternalLibraryImport*/ true, failedLookupLocations, diagnostics, state.resultFromCache);
+        return createResolvedModuleWithFailedLookupLocations(resolved, 
+        /*isExternalLibraryImport*/ true, failedLookupLocations, affectingLocations, diagnostics, state.resultFromCache);
     }
     ts.loadModuleFromGlobalCache = loadModuleFromGlobalCache;
     /**
@@ -47936,16 +48099,6 @@ var ts;
         TypeFacts[TypeFacts["OrFactsMask"] = 8256] = "OrFactsMask";
         TypeFacts[TypeFacts["AndFactsMask"] = 134209471] = "AndFactsMask";
     })(TypeFacts || (TypeFacts = {}));
-    var typeofEQFacts = new ts.Map(ts.getEntries({
-        string: 1 /* TypeofEQString */,
-        number: 2 /* TypeofEQNumber */,
-        bigint: 4 /* TypeofEQBigInt */,
-        boolean: 8 /* TypeofEQBoolean */,
-        symbol: 16 /* TypeofEQSymbol */,
-        undefined: 65536 /* EQUndefined */,
-        object: 32 /* TypeofEQObject */,
-        function: 64 /* TypeofEQFunction */
-    }));
     var typeofNEFacts = new ts.Map(ts.getEntries({
         string: 256 /* TypeofNEString */,
         number: 512 /* TypeofNENumber */,
@@ -48744,14 +48897,6 @@ var ts;
         var awaitedTypeStack = [];
         var diagnostics = ts.createDiagnosticCollection();
         var suggestionDiagnostics = ts.createDiagnosticCollection();
-        var typeofTypesByName = new ts.Map(ts.getEntries({
-            string: stringType,
-            number: numberType,
-            bigint: bigintType,
-            boolean: booleanType,
-            symbol: esSymbolType,
-            undefined: undefinedType
-        }));
         var typeofType = createTypeofType();
         var _jsxNamespace;
         var _jsxFactoryEntity;
@@ -51627,7 +51772,7 @@ var ts;
             return type;
         }
         function createTypeofType() {
-            return getUnionType(ts.arrayFrom(typeofEQFacts.keys(), getStringLiteralType));
+            return getUnionType(ts.arrayFrom(typeofNEFacts.keys(), getStringLiteralType));
         }
         function createTypeParameter(symbol) {
             var type = createType(262144 /* TypeParameter */);
@@ -52413,6 +52558,9 @@ var ts;
                     var typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context);
                     if (isReservedMemberName(type.aliasSymbol.escapedName) && !(type.aliasSymbol.flags & 32 /* Class */))
                         return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(""), typeArgumentNodes);
+                    if (ts.length(typeArgumentNodes) === 1 && type.aliasSymbol === globalArrayType.symbol) {
+                        return ts.factory.createArrayTypeNode(typeArgumentNodes[0]);
+                    }
                     return symbolToTypeNode(type.aliasSymbol, context, 788968 /* Type */, typeArgumentNodes);
                 }
                 var objectFlags = ts.getObjectFlags(type);
@@ -52603,7 +52751,7 @@ var ts;
                         // Always use 'typeof T' for type of class, enum, and module objects
                         else if (symbol.flags & 32 /* Class */
                             && !getBaseTypeVariableOfClass(symbol)
-                            && !(symbol.valueDeclaration && symbol.valueDeclaration.kind === 226 /* ClassExpression */ && context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */) ||
+                            && !(symbol.valueDeclaration && ts.isClassLike(symbol.valueDeclaration) && context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ && (!ts.isClassDeclaration(symbol.valueDeclaration) || isSymbolAccessible(symbol, context.enclosingDeclaration, isInstanceType, /*computeAliases*/ false).accessibility !== 0 /* Accessible */)) ||
                             symbol.flags & (384 /* Enum */ | 512 /* ValueModule */) ||
                             shouldWriteTypeOfFunctionSymbol()) {
                             return symbolToTypeNode(symbol, context, isInstanceType);
@@ -56233,6 +56381,17 @@ var ts;
                 });
                 var result = createAnonymousType(initialSize !== members_4.size ? undefined : exportedType.symbol, // Only set the type's symbol if it looks to be the same as the original type
                 members_4, exportedType.callSignatures, exportedType.constructSignatures, exportedType.indexInfos);
+                if (initialSize === members_4.size) {
+                    if (type.aliasSymbol) {
+                        result.aliasSymbol = type.aliasSymbol;
+                        result.aliasTypeArguments = type.aliasTypeArguments;
+                    }
+                    if (ts.getObjectFlags(type) & 4 /* Reference */) {
+                        result.aliasSymbol = type.symbol;
+                        var args = getTypeArguments(type);
+                        result.aliasTypeArguments = ts.length(args) ? args : undefined;
+                    }
+                }
                 result.objectFlags |= (ts.getObjectFlags(type) & 4096 /* JSLiteral */); // Propagate JSLiteral flag
                 if (result.symbol && result.symbol.flags & 32 /* Class */ && type === getDeclaredTypeOfClassOrInterface(result.symbol)) {
                     result.objectFlags |= 16777216 /* IsClassInstanceClone */; // Propagate the knowledge that this type is equivalent to the symbol's class instance type
@@ -64416,6 +64575,9 @@ var ts;
             }
             return false;
         }
+        function containsUndefinedType(type) {
+            return !!((type.flags & 1048576 /* Union */ ? type.types[0] : type).flags & 32768 /* Undefined */);
+        }
         function isStringIndexSignatureOnlyType(type) {
             return type.flags & 524288 /* Object */ && !isGenericMappedType(type) && getPropertiesOfType(type).length === 0 && getIndexInfosOfType(type).length === 1 && !!getIndexInfoOfType(type, stringType) ||
                 type.flags & 3145728 /* UnionOrIntersection */ && ts.every(type.types, isStringIndexSignatureOnlyType) ||
@@ -69838,19 +70000,17 @@ var ts;
             }
             return links.switchTypes;
         }
-        function getSwitchClauseTypeOfWitnesses(switchStatement, retainDefault) {
+        // Get the type names from all cases in a switch on `typeof`. The default clause and/or duplicate type names are
+        // represented as undefined. Return undefined if one or more case clause expressions are not string literals.
+        function getSwitchClauseTypeOfWitnesses(switchStatement) {
+            if (ts.some(switchStatement.caseBlock.clauses, function (clause) { return clause.kind === 289 /* CaseClause */ && !ts.isStringLiteralLike(clause.expression); })) {
+                return undefined;
+            }
             var witnesses = [];
             for (var _i = 0, _a = switchStatement.caseBlock.clauses; _i < _a.length; _i++) {
                 var clause = _a[_i];
-                if (clause.kind === 289 /* CaseClause */) {
-                    if (ts.isStringLiteralLike(clause.expression)) {
-                        witnesses.push(clause.expression.text);
-                        continue;
-                    }
-                    return ts.emptyArray;
-                }
-                if (retainDefault)
-                    witnesses.push(/*explicitDefaultStatement*/ undefined);
+                var text = clause.kind === 289 /* CaseClause */ ? clause.expression.text : undefined;
+                witnesses.push(text && !ts.contains(witnesses, text) ? text : undefined);
             }
             return witnesses;
         }
@@ -71040,14 +71200,9 @@ var ts;
                     }
                     return type;
                 }
-                if (type.flags & 1 /* Any */ && literal.text === "function") {
-                    return type;
-                }
-                var facts = assumeTrue ?
-                    typeofEQFacts.get(literal.text) || 128 /* TypeofEQHostObject */ :
-                    typeofNEFacts.get(literal.text) || 32768 /* TypeofNEHostObject */;
-                var impliedType = getImpliedTypeFromTypeofGuard(type, literal.text);
-                return getTypeWithFacts(assumeTrue && impliedType ? narrowTypeByImpliedType(type, impliedType) : type, facts);
+                return assumeTrue ?
+                    narrowTypeByTypeName(type, literal.text) :
+                    getTypeWithFacts(type, typeofNEFacts.get(literal.text) || 32768 /* TypeofNEHostObject */);
             }
             function narrowTypeBySwitchOptionalChainContainment(type, switchStatement, clauseStart, clauseEnd, clauseCheck) {
                 var everyClauseChecks = clauseStart !== clauseEnd && ts.every(getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd), clauseCheck);
@@ -71094,102 +71249,52 @@ var ts;
                 var defaultType = filterType(type, function (t) { return !(isUnitLikeType(t) && ts.contains(switchTypes, getRegularTypeOfLiteralType(extractUnitType(t)))); });
                 return caseType.flags & 131072 /* Never */ ? defaultType : getUnionType([caseType, defaultType]);
             }
-            function getImpliedTypeFromTypeofGuard(type, text) {
-                switch (text) {
-                    case "object":
-                        return type.flags & 1 /* Any */ ? type : getUnionType([nullType, nonPrimitiveType]);
-                    case "function":
-                        return type.flags & 1 /* Any */ ? type : globalFunctionType;
-                    default:
-                        return typeofTypesByName.get(text);
+            function narrowTypeByTypeName(type, typeName) {
+                switch (typeName) {
+                    case "string": return narrowTypeByTypeFacts(type, stringType, 1 /* TypeofEQString */);
+                    case "number": return narrowTypeByTypeFacts(type, numberType, 2 /* TypeofEQNumber */);
+                    case "bigint": return narrowTypeByTypeFacts(type, bigintType, 4 /* TypeofEQBigInt */);
+                    case "boolean": return narrowTypeByTypeFacts(type, booleanType, 8 /* TypeofEQBoolean */);
+                    case "symbol": return narrowTypeByTypeFacts(type, esSymbolType, 16 /* TypeofEQSymbol */);
+                    case "object": return type.flags & 1 /* Any */ ? type : getUnionType([narrowTypeByTypeFacts(type, nonPrimitiveType, 32 /* TypeofEQObject */), narrowTypeByTypeFacts(type, nullType, 131072 /* EQNull */)]);
+                    case "function": return type.flags & 1 /* Any */ ? type : narrowTypeByTypeFacts(type, globalFunctionType, 64 /* TypeofEQFunction */);
+                    case "undefined": return narrowTypeByTypeFacts(type, undefinedType, 65536 /* EQUndefined */);
                 }
+                return narrowTypeByTypeFacts(type, nonPrimitiveType, 128 /* TypeofEQHostObject */);
             }
-            // When narrowing a union type by a `typeof` guard using type-facts alone, constituent types that are
-            // super-types of the implied guard will be retained in the final type: this is because type-facts only
-            // filter. Instead, we would like to replace those union constituents with the more precise type implied by
-            // the guard. For example: narrowing `{} | undefined` by `"boolean"` should produce the type `boolean`, not
-            // the filtered type `{}`. For this reason we narrow constituents of the union individually, in addition to
-            // filtering by type-facts.
-            function narrowTypeByImpliedType(type, candidate) {
-                if (type.flags & 3 /* AnyOrUnknown */) {
-                    return candidate;
-                }
+            function narrowTypeByTypeFacts(type, impliedType, facts) {
                 return mapType(type, function (t) {
-                    if (isTypeRelatedTo(t, candidate, strictSubtypeRelation)) {
-                        return t;
-                    }
-                    return mapType(candidate, function (c) {
-                        if (!areTypesComparable(t, c)) {
-                            return neverType;
-                        }
-                        if (c.flags & 131068 /* Primitive */ && t.flags & 524288 /* Object */ && !isEmptyAnonymousObjectType(t)) {
-                            return isTypeSubtypeOf(c, t) ? c : neverType;
-                        }
-                        if (c === globalFunctionType && isTypeSubtypeOf(c, t)) {
-                            return c;
-                        }
-                        return getIntersectionType([t, c]);
-                    });
+                    // We first check if a constituent is a subtype of the implied type. If so, we either keep or eliminate
+                    // the constituent based on its type facts. We use the strict subtype relation because it treats `object`
+                    // as a subtype of `{}`, and we need the type facts check because function types are subtypes of `object`,
+                    // but are classified as "function" according to `typeof`.
+                    return isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? getTypeFacts(t) & facts ? t : neverType :
+                        // We next check if the consituent is a supertype of the implied type. If so, we substitute the implied
+                        // type. This handles top types like `unknown` and `{}`, and supertypes like `{ toString(): string }`.
+                        isTypeSubtypeOf(impliedType, t) ? impliedType :
+                            // Neither the constituent nor the implied type is a subtype of the other, however their domains may still
+                            // overlap. For example, an unconstrained type parameter and type `string`. If the type facts indicate
+                            // possible overlap, we form an intersection. Otherwise, we eliminate the constituent.
+                            getTypeFacts(t) & facts ? getIntersectionType([t, impliedType]) :
+                                neverType;
                 });
             }
             function narrowBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) {
-                var switchWitnesses = getSwitchClauseTypeOfWitnesses(switchStatement, /*retainDefault*/ true);
-                if (!switchWitnesses.length) {
+                var witnesses = getSwitchClauseTypeOfWitnesses(switchStatement);
+                if (!witnesses) {
                     return type;
                 }
-                //  Equal start and end denotes implicit fallthrough; undefined marks explicit default clause
-                var defaultCaseLocation = ts.findIndex(switchWitnesses, function (elem) { return elem === undefined; });
-                var hasDefaultClause = clauseStart === clauseEnd || (defaultCaseLocation >= clauseStart && defaultCaseLocation < clauseEnd);
-                var clauseWitnesses;
-                var switchFacts;
-                if (defaultCaseLocation > -1) {
-                    // We no longer need the undefined denoting an explicit default case. Remove the undefined and
-                    // fix-up clauseStart and clauseEnd.  This means that we don't have to worry about undefined in the
-                    // witness array.
-                    var witnesses = switchWitnesses.filter(function (witness) { return witness !== undefined; });
-                    // The adjusted clause start and end after removing the `default` statement.
-                    var fixedClauseStart = defaultCaseLocation < clauseStart ? clauseStart - 1 : clauseStart;
-                    var fixedClauseEnd = defaultCaseLocation < clauseEnd ? clauseEnd - 1 : clauseEnd;
-                    clauseWitnesses = witnesses.slice(fixedClauseStart, fixedClauseEnd);
-                    switchFacts = getFactsFromTypeofSwitch(fixedClauseStart, fixedClauseEnd, witnesses, hasDefaultClause);
-                }
-                else {
-                    clauseWitnesses = switchWitnesses.slice(clauseStart, clauseEnd);
-                    switchFacts = getFactsFromTypeofSwitch(clauseStart, clauseEnd, switchWitnesses, hasDefaultClause);
-                }
+                // Equal start and end denotes implicit fallthrough; undefined marks explicit default clause.
+                var defaultIndex = ts.findIndex(switchStatement.caseBlock.clauses, function (clause) { return clause.kind === 290 /* DefaultClause */; });
+                var hasDefaultClause = clauseStart === clauseEnd || (defaultIndex >= clauseStart && defaultIndex < clauseEnd);
                 if (hasDefaultClause) {
-                    return filterType(type, function (t) { return (getTypeFacts(t) & switchFacts) === switchFacts; });
+                    // In the default clause we filter constituents down to those that are not-equal to all handled cases.
+                    var notEqualFacts_1 = getNotEqualFactsFromTypeofSwitch(clauseStart, clauseEnd, witnesses);
+                    return filterType(type, function (t) { return (getTypeFacts(t) & notEqualFacts_1) === notEqualFacts_1; });
                 }
-                /*
-                  The implied type is the raw type suggested by a
-                  value being caught in this clause.
-
-                  When the clause contains a default case we ignore
-                  the implied type and try to narrow using any facts
-                  we can learn: see `switchFacts`.
-
-                  Example:
-                  switch (typeof x) {
-                      case 'number':
-                      case 'string': break;
-                      default: break;
-                      case 'number':
-                      case 'boolean': break
-                  }
-
-                  In the first clause (case `number` and `string`) the
-                  implied type is number | string.
-
-                  In the default clause we de not compute an implied type.
-
-                  In the third clause (case `number` and `boolean`)
-                  the naive implied type is number | boolean, however
-                  we use the type facts to narrow the implied type to
-                  boolean. We know that number cannot be selected
-                  because it is caught in the first clause.
-                */
-                var impliedType = getTypeWithFacts(getUnionType(clauseWitnesses.map(function (text) { return getImpliedTypeFromTypeofGuard(type, text) || type; })), switchFacts);
-                return getTypeWithFacts(narrowTypeByImpliedType(type, impliedType), switchFacts);
+                // In the non-default cause we create a union of the type narrowed by each of the listed cases.
+                var clauseWitnesses = witnesses.slice(clauseStart, clauseEnd);
+                return getUnionType(ts.map(clauseWitnesses, function (text) { return text ? narrowTypeByTypeName(type, text) : neverType; }));
             }
             function isMatchingConstructorReference(expr) {
                 return (ts.isPropertyAccessExpression(expr) && ts.idText(expr.name) === "constructor" ||
@@ -71800,7 +71905,7 @@ var ts;
                     return convertAutoToAny(flowType);
                 }
             }
-            else if (!assumeInitialized && !(getTypeFacts(type) & 16777216 /* IsUndefined */) && getTypeFacts(flowType) & 16777216 /* IsUndefined */) {
+            else if (!assumeInitialized && !containsUndefinedType(type) && containsUndefinedType(flowType)) {
                 error(node, ts.Diagnostics.Variable_0_is_used_before_being_assigned, symbolToString(symbol));
                 // Return the declared type to reduce follow-on errors
                 return type;
@@ -74811,7 +74916,7 @@ var ts;
                 assumeUninitialized = true;
             }
             var flowType = getFlowTypeOfReference(node, propType, assumeUninitialized ? getOptionalType(propType) : propType);
-            if (assumeUninitialized && !(getTypeFacts(propType) & 16777216 /* IsUndefined */) && getTypeFacts(flowType) & 16777216 /* IsUndefined */) {
+            if (assumeUninitialized && !containsUndefinedType(propType) && containsUndefinedType(flowType)) {
                 error(errorNode, ts.Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(prop)); // TODO: GH#18217
                 // Return the declared type to reduce follow-on errors
                 return propType;
@@ -78001,45 +78106,12 @@ var ts;
                 ? ts.Diagnostics.Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
                 : ts.Diagnostics.Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
         }
-        /**
-         * Collect the TypeFacts learned from a typeof switch with
-         * total clauses `witnesses`, and the active clause ranging
-         * from `start` to `end`. Parameter `hasDefault` denotes
-         * whether the active clause contains a default clause.
-         */
-        function getFactsFromTypeofSwitch(start, end, witnesses, hasDefault) {
+        // Return the combined not-equal type facts for all cases except those between the start and end indices.
+        function getNotEqualFactsFromTypeofSwitch(start, end, witnesses) {
             var facts = 0 /* None */;
-            // When in the default we only collect inequality facts
-            // because default is 'in theory' a set of infinite
-            // equalities.
-            if (hasDefault) {
-                // Value is not equal to any types after the active clause.
-                for (var i = end; i < witnesses.length; i++) {
-                    facts |= typeofNEFacts.get(witnesses[i]) || 32768 /* TypeofNEHostObject */;
-                }
-                // Remove inequalities for types that appear in the
-                // active clause because they appear before other
-                // types collected so far.
-                for (var i = start; i < end; i++) {
-                    facts &= ~(typeofNEFacts.get(witnesses[i]) || 0);
-                }
-                // Add inequalities for types before the active clause unconditionally.
-                for (var i = 0; i < start; i++) {
-                    facts |= typeofNEFacts.get(witnesses[i]) || 32768 /* TypeofNEHostObject */;
-                }
-            }
-            // When in an active clause without default the set of
-            // equalities is finite.
-            else {
-                // Add equalities for all types in the active clause.
-                for (var i = start; i < end; i++) {
-                    facts |= typeofEQFacts.get(witnesses[i]) || 128 /* TypeofEQHostObject */;
-                }
-                // Remove equalities for types that appear before the
-                // active clause.
-                for (var i = 0; i < start; i++) {
-                    facts &= ~(typeofEQFacts.get(witnesses[i]) || 0);
-                }
+            for (var i = 0; i < witnesses.length; i++) {
+                var witness = i < start || i >= end ? witnesses[i] : undefined;
+                facts |= witness !== undefined ? typeofNEFacts.get(witness) || 32768 /* TypeofNEHostObject */ : 0;
             }
             return facts;
         }
@@ -78049,16 +78121,19 @@ var ts;
         }
         function computeExhaustiveSwitchStatement(node) {
             if (node.expression.kind === 216 /* TypeOfExpression */) {
-                var operandType = getTypeOfExpression(node.expression.expression);
-                var witnesses = getSwitchClauseTypeOfWitnesses(node, /*retainDefault*/ false);
-                // notEqualFacts states that the type of the switched value is not equal to every type in the switch.
-                var notEqualFacts_1 = getFactsFromTypeofSwitch(0, 0, witnesses, /*hasDefault*/ true);
-                var type_6 = getBaseConstraintOfType(operandType) || operandType;
-                // Take any/unknown as a special condition. Or maybe we could change `type` to a union containing all primitive types.
-                if (type_6.flags & 3 /* AnyOrUnknown */) {
-                    return (556800 /* AllTypeofNE */ & notEqualFacts_1) === 556800 /* AllTypeofNE */;
+                var witnesses = getSwitchClauseTypeOfWitnesses(node);
+                if (!witnesses) {
+                    return false;
+                }
+                var operandConstraint = getBaseConstraintOrType(getTypeOfExpression(node.expression.expression));
+                // Get the not-equal flags for all handled cases.
+                var notEqualFacts_2 = getNotEqualFactsFromTypeofSwitch(0, 0, witnesses);
+                if (operandConstraint.flags & 3 /* AnyOrUnknown */) {
+                    // We special case the top types to be exhaustive when all cases are handled.
+                    return (556800 /* AllTypeofNE */ & notEqualFacts_2) === 556800 /* AllTypeofNE */;
                 }
-                return !!(filterType(type_6, function (t) { return (getTypeFacts(t) & notEqualFacts_1) === notEqualFacts_1; }).flags & 131072 /* Never */);
+                // A missing not-equal flag indicates that the type wasn't handled by some case.
+                return !someType(operandConstraint, function (t) { return (getTypeFacts(t) & notEqualFacts_2) === notEqualFacts_2; });
             }
             var type = getTypeOfExpression(node.expression);
             if (!isLiteralType(type)) {
@@ -81890,6 +81965,11 @@ var ts;
         function checkJSDocTypeTag(node) {
             checkSourceElement(node.typeExpression);
         }
+        function checkJSDocLinkLikeTag(node) {
+            if (node.name) {
+                resolveJSDocMemberName(node.name, /*ignoreErrors*/ true);
+            }
+        }
         function checkJSDocParameterTag(node) {
             checkSourceElement(node.typeExpression);
         }
@@ -84661,7 +84741,7 @@ var ts;
                     var propName = member.name;
                     if (ts.isIdentifier(propName) || ts.isPrivateIdentifier(propName) || ts.isComputedPropertyName(propName)) {
                         var type = getTypeOfSymbol(getSymbolOfNode(member));
-                        if (!(type.flags & 3 /* AnyOrUnknown */ || getTypeFacts(type) & 16777216 /* IsUndefined */)) {
+                        if (!(type.flags & 3 /* AnyOrUnknown */ || containsUndefinedType(type))) {
                             if (!constructor || !isPropertyInitializedInConstructor(propName, type, constructor)) {
                                 error(member.name, ts.Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor, ts.declarationNameToString(propName));
                             }
@@ -84686,7 +84766,7 @@ var ts;
                     ts.setParent(reference, staticBlock);
                     reference.flowNode = staticBlock.returnFlowNode;
                     var flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType));
-                    if (!(getTypeFacts(flowType) & 16777216 /* IsUndefined */)) {
+                    if (!containsUndefinedType(flowType)) {
                         return true;
                     }
                 }
@@ -84701,7 +84781,7 @@ var ts;
             ts.setParent(reference, constructor);
             reference.flowNode = constructor.returnFlowNode;
             var flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType));
-            return !(getTypeFacts(flowType) & 16777216 /* IsUndefined */);
+            return !containsUndefinedType(flowType);
         }
         function checkInterfaceDeclaration(node) {
             // Grammar checking
@@ -85684,12 +85764,16 @@ var ts;
             }
         }
         function checkSourceElementWorker(node) {
-            if (ts.isInJSFile(node)) {
-                ts.forEach(node.jsDoc, function (_a) {
-                    var tags = _a.tags;
-                    return ts.forEach(tags, checkSourceElement);
+            ts.forEach(node.jsDoc, function (_a) {
+                var comment = _a.comment, tags = _a.tags;
+                checkJSDocCommentWorker(comment);
+                ts.forEach(tags, function (tag) {
+                    checkJSDocCommentWorker(tag.comment);
+                    if (ts.isInJSFile(node)) {
+                        checkSourceElement(tag);
+                    }
                 });
-            }
+            });
             var kind = node.kind;
             if (cancellationToken) {
                 // Only bother checking on a few construct kinds.  We don't want to be excessively
@@ -85775,6 +85859,10 @@ var ts;
                     return checkJSDocTemplateTag(node);
                 case 343 /* JSDocTypeTag */:
                     return checkJSDocTypeTag(node);
+                case 324 /* JSDocLink */:
+                case 325 /* JSDocLinkCode */:
+                case 326 /* JSDocLinkPlain */:
+                    return checkJSDocLinkLikeTag(node);
                 case 340 /* JSDocParameterTag */:
                     return checkJSDocParameterTag(node);
                 case 347 /* JSDocPropertyTag */:
@@ -85869,6 +85957,15 @@ var ts;
                     return checkMissingDeclaration(node);
             }
         }
+        function checkJSDocCommentWorker(node) {
+            if (ts.isArray(node)) {
+                ts.forEach(node, function (tag) {
+                    if (ts.isJSDocLinkLike(tag)) {
+                        checkSourceElement(tag);
+                    }
+                });
+            }
+        }
         function checkJSDocTypeIsInJsFile(node) {
             if (!ts.isInJSFile(node)) {
                 grammarErrorOnNode(node, ts.Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments);
@@ -86424,7 +86521,7 @@ var ts;
                     if (!result && isJSDoc_1) {
                         var container = ts.findAncestor(name, ts.or(ts.isClassLike, ts.isInterfaceDeclaration));
                         if (container) {
-                            return resolveJSDocMemberName(name, getSymbolOfNode(container));
+                            return resolveJSDocMemberName(name, /*ignoreErrors*/ false, getSymbolOfNode(container));
                         }
                     }
                     return result;
@@ -86470,11 +86567,11 @@ var ts;
          *
          * For unqualified names, a container K may be provided as a second argument.
          */
-        function resolveJSDocMemberName(name, container) {
+        function resolveJSDocMemberName(name, ignoreErrors, container) {
             if (ts.isEntityName(name)) {
                 // resolve static values first
                 var meaning = 788968 /* Type */ | 1920 /* Namespace */ | 111551 /* Value */;
-                var symbol = resolveEntityName(name, meaning, /*ignoreErrors*/ false, /*dontResolveAlias*/ true, ts.getHostSignatureFromJSDoc(name));
+                var symbol = resolveEntityName(name, meaning, ignoreErrors, /*dontResolveAlias*/ true, ts.getHostSignatureFromJSDoc(name));
                 if (!symbol && ts.isIdentifier(name) && container) {
                     symbol = getMergedSymbol(getSymbol(getExportsOfSymbol(container), name.escapedText, meaning));
                 }
@@ -86482,7 +86579,7 @@ var ts;
                     return symbol;
                 }
             }
-            var left = ts.isIdentifier(name) ? container : resolveJSDocMemberName(name.left);
+            var left = ts.isIdentifier(name) ? container : resolveJSDocMemberName(name.left, ignoreErrors, container);
             var right = ts.isIdentifier(name) ? name.escapedText : name.right.escapedText;
             if (left) {
                 var proto = left.flags & 111551 /* Value */ && getPropertyOfType(getTypeOfSymbol(left), "prototype");
@@ -110771,7 +110868,9 @@ var ts;
                 return;
             }
             var version = ts.version; // Extracted into a const so the form is stable between namespace and module
-            ts.writeFile(host, emitterDiagnostics, buildInfoPath, getBuildInfoText({ bundle: bundle, program: program, version: version }), /*writeByteOrderMark*/ false);
+            var buildInfo = { bundle: bundle, program: program, version: version };
+            // Pass buildinfo as additional data to avoid having to reparse
+            ts.writeFile(host, emitterDiagnostics, buildInfoPath, getBuildInfoText(buildInfo), /*writeByteOrderMark*/ false, /*sourceFiles*/ undefined, { buildInfo: buildInfo });
         }
         function emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo) {
             if (!sourceFileOrBundle || emitOnlyDtsFiles || !jsFilePath) {
@@ -110925,13 +111024,20 @@ var ts;
                 if (sourceMapFilePath) {
                     var sourceMap = sourceMapGenerator.toString();
                     ts.writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap, /*writeByteOrderMark*/ false, sourceFiles);
+                    if (printer.bundleFileInfo)
+                        printer.bundleFileInfo.mapHash = ts.BuilderState.computeSignature(sourceMap, ts.maybeBind(host, host.createHash));
                 }
             }
             else {
                 writer.writeLine();
             }
             // Write the output file
-            ts.writeFile(host, emitterDiagnostics, jsFilePath, writer.getText(), !!compilerOptions.emitBOM, sourceFiles, { sourceMapUrlPos: sourceMapUrlPos });
+            var text = writer.getText();
+            ts.writeFile(host, emitterDiagnostics, jsFilePath, text, !!compilerOptions.emitBOM, sourceFiles, { sourceMapUrlPos: sourceMapUrlPos });
+            // We store the hash of the text written in the buildinfo to ensure that text of the referenced d.ts file is same as whats in the buildinfo
+            // This is needed because incremental can be toggled between two runs and we might use stale file text to do text manipulation in prepend mode
+            if (printer.bundleFileInfo)
+                printer.bundleFileInfo.hash = ts.BuilderState.computeSignature(text, ts.maybeBind(host, host.createHash));
             // Reset state
             writer.clear();
         }
@@ -111074,34 +111180,56 @@ var ts;
     }
     /*@internal*/
     function emitUsingBuildInfo(config, host, getCommandLine, customTransformers) {
+        var createHash = ts.maybeBind(host, host.createHash);
         var _a = getOutputPathsForBundle(config.options, /*forceDtsPaths*/ false), buildInfoPath = _a.buildInfoPath, jsFilePath = _a.jsFilePath, sourceMapFilePath = _a.sourceMapFilePath, declarationFilePath = _a.declarationFilePath, declarationMapPath = _a.declarationMapPath;
-        var buildInfoText = host.readFile(ts.Debug.checkDefined(buildInfoPath));
-        if (!buildInfoText)
+        var buildInfo;
+        if (host.getBuildInfo) {
+            // If host directly provides buildinfo we can get it directly. This allows host to cache the buildinfo
+            var hostBuildInfo = host.getBuildInfo(buildInfoPath, config.options.configFilePath);
+            if (!hostBuildInfo)
+                return buildInfoPath;
+            buildInfo = hostBuildInfo;
+        }
+        else {
+            var buildInfoText = host.readFile(buildInfoPath);
+            if (!buildInfoText)
+                return buildInfoPath;
+            buildInfo = getBuildInfo(buildInfoText);
+        }
+        if (!buildInfo.bundle || !buildInfo.bundle.js || (declarationFilePath && !buildInfo.bundle.dts))
             return buildInfoPath;
         var jsFileText = host.readFile(ts.Debug.checkDefined(jsFilePath));
         if (!jsFileText)
             return jsFilePath;
+        // If the jsFileText is not same has what it was created with, tsbuildinfo is stale so dont use it
+        if (ts.BuilderState.computeSignature(jsFileText, createHash) !== buildInfo.bundle.js.hash)
+            return jsFilePath;
         var sourceMapText = sourceMapFilePath && host.readFile(sourceMapFilePath);
         // error if no source map or for now if inline sourcemap
         if ((sourceMapFilePath && !sourceMapText) || config.options.inlineSourceMap)
             return sourceMapFilePath || "inline sourcemap decoding";
+        if (sourceMapFilePath && ts.BuilderState.computeSignature(sourceMapText, createHash) !== buildInfo.bundle.js.mapHash)
+            return sourceMapFilePath;
         // read declaration text
         var declarationText = declarationFilePath && host.readFile(declarationFilePath);
         if (declarationFilePath && !declarationText)
             return declarationFilePath;
+        if (declarationFilePath && ts.BuilderState.computeSignature(declarationText, createHash) !== buildInfo.bundle.dts.hash)
+            return declarationFilePath;
         var declarationMapText = declarationMapPath && host.readFile(declarationMapPath);
         // error if no source map or for now if inline sourcemap
         if ((declarationMapPath && !declarationMapText) || config.options.inlineSourceMap)
             return declarationMapPath || "inline sourcemap decoding";
-        var buildInfo = getBuildInfo(buildInfoText);
-        if (!buildInfo.bundle || !buildInfo.bundle.js || (declarationText && !buildInfo.bundle.dts))
-            return buildInfoPath;
+        if (declarationMapPath && ts.BuilderState.computeSignature(declarationMapText, createHash) !== buildInfo.bundle.dts.mapHash)
+            return declarationMapPath;
         var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
         var ownPrependInput = ts.createInputFiles(jsFileText, declarationText, sourceMapFilePath, sourceMapText, declarationMapPath, declarationMapText, jsFilePath, declarationFilePath, buildInfoPath, buildInfo, 
         /*onlyOwnText*/ true);
         var outputFiles = [];
         var prependNodes = ts.createPrependNodes(config.projectReferences, getCommandLine, function (f) { return host.readFile(f); });
         var sourceFilesForJsEmit = createSourceFilesFromBundleBuildInfo(buildInfo.bundle, buildInfoDirectory, host);
+        var changedDtsText;
+        var changedDtsData;
         var emitHost = {
             getPrependNodes: ts.memoize(function () { return __spreadArray(__spreadArray([], prependNodes, true), [ownPrependInput], false); }),
             getCanonicalFileName: host.getCanonicalFileName,
@@ -111117,7 +111245,7 @@ var ts;
             getResolvedProjectReferenceToRedirect: ts.returnUndefined,
             getProjectReferenceRedirect: ts.returnUndefined,
             isSourceOfProjectReferenceRedirect: ts.returnFalse,
-            writeFile: function (name, text, writeByteOrderMark) {
+            writeFile: function (name, text, writeByteOrderMark, _onError, _sourceFiles, data) {
                 switch (name) {
                     case jsFilePath:
                         if (jsFileText === text)
@@ -111128,8 +111256,13 @@ var ts;
                             return;
                         break;
                     case buildInfoPath:
-                        var newBuildInfo = getBuildInfo(text);
+                        var newBuildInfo = data.buildInfo;
                         newBuildInfo.program = buildInfo.program;
+                        if (newBuildInfo.program && changedDtsText !== undefined && config.options.composite) {
+                            // Update the output signature
+                            newBuildInfo.program.outSignature = ts.computeSignature(changedDtsText, changedDtsData, createHash);
+                            newBuildInfo.program.dtsChangeTime = ts.getCurrentTime(host).getTime();
+                        }
                         // Update sourceFileInfo
                         var _a = buildInfo.bundle, js = _a.js, dts = _a.dts, sourceFiles = _a.sourceFiles;
                         newBuildInfo.bundle.js.sources = js.sources;
@@ -111137,11 +111270,13 @@ var ts;
                             newBuildInfo.bundle.dts.sources = dts.sources;
                         }
                         newBuildInfo.bundle.sourceFiles = sourceFiles;
-                        outputFiles.push({ name: name, text: getBuildInfoText(newBuildInfo), writeByteOrderMark: writeByteOrderMark });
+                        outputFiles.push({ name: name, text: getBuildInfoText(newBuildInfo), writeByteOrderMark: writeByteOrderMark, buildInfo: newBuildInfo });
                         return;
                     case declarationFilePath:
                         if (declarationText === text)
                             return;
+                        changedDtsText = text;
+                        changedDtsData = data;
                         break;
                     case declarationMapPath:
                         if (declarationMapText === text)
@@ -111160,6 +111295,7 @@ var ts;
             getSourceFileFromReference: ts.returnUndefined,
             redirectTargetsMap: ts.createMultiMap(),
             getFileIncludeReasons: ts.notImplemented,
+            createHash: createHash,
         };
         emitFiles(ts.notImplementedResolver, emitHost, 
         /*targetSourceFile*/ undefined, ts.getTransformers(config.options, customTransformers));
@@ -116244,12 +116380,10 @@ var ts;
     }
     ts.createCompilerHost = createCompilerHost;
     /*@internal*/
-    // TODO(shkamat): update this after reworking ts build API
     function createCompilerHostWorker(options, setParentNodes, system) {
         if (system === void 0) { system = ts.sys; }
         var existingDirectories = new ts.Map();
         var getCanonicalFileName = ts.createGetCanonicalFileName(system.useCaseSensitiveFileNames);
-        var computeHash = ts.maybeBind(system, system.createHash) || ts.generateDjb2Hash;
         function getSourceFile(fileName, languageVersionOrOptions, onError) {
             var text;
             try {
@@ -116282,7 +116416,7 @@ var ts;
                 // NOTE: If patchWriteFileEnsuringDirectory has been called,
                 // the system.writeFile will do its own directory creation and
                 // the ensureDirectoriesExist call will always be redundant.
-                ts.writeFileEnsuringDirectories(fileName, data, writeByteOrderMark, function (path, data, writeByteOrderMark) { return writeFileWorker(path, data, writeByteOrderMark); }, function (path) { return (compilerHost.createDirectory || system.createDirectory)(path); }, function (path) { return directoryExists(path); });
+                ts.writeFileEnsuringDirectories(fileName, data, writeByteOrderMark, function (path, data, writeByteOrderMark) { return system.writeFile(path, data, writeByteOrderMark); }, function (path) { return (compilerHost.createDirectory || system.createDirectory)(path); }, function (path) { return directoryExists(path); });
                 ts.performance.mark("afterIOWrite");
                 ts.performance.measure("I/O Write", "beforeIOWrite", "afterIOWrite");
             }
@@ -116292,35 +116426,6 @@ var ts;
                 }
             }
         }
-        var outputFingerprints;
-        function writeFileWorker(fileName, data, writeByteOrderMark) {
-            if (!ts.isWatchSet(options) || !system.getModifiedTime) {
-                system.writeFile(fileName, data, writeByteOrderMark);
-                return;
-            }
-            if (!outputFingerprints) {
-                outputFingerprints = new ts.Map();
-            }
-            var hash = computeHash(data);
-            var mtimeBefore = system.getModifiedTime(fileName);
-            if (mtimeBefore) {
-                var fingerprint = outputFingerprints.get(fileName);
-                // If output has not been changed, and the file has no external modification
-                if (fingerprint &&
-                    fingerprint.byteOrderMark === writeByteOrderMark &&
-                    fingerprint.hash === hash &&
-                    fingerprint.mtime.getTime() === mtimeBefore.getTime()) {
-                    return;
-                }
-            }
-            system.writeFile(fileName, data, writeByteOrderMark);
-            var mtimeAfter = system.getModifiedTime(fileName) || ts.missingFileModifiedTime;
-            outputFingerprints.set(fileName, {
-                hash: hash,
-                byteOrderMark: writeByteOrderMark,
-                mtime: mtimeAfter
-            });
-        }
         function getDefaultLibLocation() {
             return ts.getDirectoryPath(ts.normalizePath(system.getExecutingFilePath()));
         }
@@ -117920,6 +118025,7 @@ var ts;
                 getSourceFileFromReference: function (file, ref) { return program.getSourceFileFromReference(file, ref); },
                 redirectTargetsMap: redirectTargetsMap,
                 getFileIncludeReasons: program.getFileIncludeReasons,
+                createHash: ts.maybeBind(host, host.createHash),
             };
         }
         function writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data) {
@@ -120033,13 +120139,9 @@ var ts;
         function createManyToManyPathMap() {
             function create(forward, reverse, deleted) {
                 var map = {
-                    clone: function () { return create(new ts.Map(forward), new ts.Map(reverse), deleted && new ts.Set(deleted)); },
-                    forEach: function (fn) { return forward.forEach(fn); },
                     getKeys: function (v) { return reverse.get(v); },
                     getValues: function (k) { return forward.get(k); },
-                    hasKey: function (k) { return forward.has(k); },
                     keys: function () { return forward.keys(); },
-                    deletedKeys: function () { return deleted; },
                     deleteKey: function (k) {
                         (deleted || (deleted = new ts.Set())).add(k);
                         var set = forward.get(k);
@@ -120066,11 +120168,6 @@ var ts;
                         });
                         return map;
                     },
-                    clear: function () {
-                        forward.clear();
-                        reverse.clear();
-                        deleted === null || deleted === void 0 ? void 0 : deleted.clear();
-                    }
                 };
                 return map;
             }
@@ -120198,18 +120295,21 @@ var ts;
          * Creates the state of file references and signature for the new program from oldState if it is safe
          */
         function create(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature) {
+            var _a, _b, _c;
             var fileInfos = new ts.Map();
             var referencedMap = newProgram.getCompilerOptions().module !== ts.ModuleKind.None ? createManyToManyPathMap() : undefined;
             var exportedModulesMap = referencedMap ? createManyToManyPathMap() : undefined;
-            var hasCalledUpdateShapeSignature = new ts.Set();
             var useOldState = canReuseOldState(referencedMap, oldState);
             // Ensure source files have parent pointers set
             newProgram.getTypeChecker();
             // Create the reference map, and set the file infos
-            for (var _i = 0, _a = newProgram.getSourceFiles(); _i < _a.length; _i++) {
-                var sourceFile = _a[_i];
+            for (var _i = 0, _d = newProgram.getSourceFiles(); _i < _d.length; _i++) {
+                var sourceFile = _d[_i];
                 var version_2 = ts.Debug.checkDefined(sourceFile.version, "Program intended to be used with Builder should have source files with versions set");
-                var oldInfo = useOldState ? oldState.fileInfos.get(sourceFile.resolvedPath) : undefined;
+                var oldUncommittedSignature = useOldState ? (_a = oldState.oldSignatures) === null || _a === void 0 ? void 0 : _a.get(sourceFile.resolvedPath) : undefined;
+                var signature = oldUncommittedSignature === undefined ?
+                    useOldState ? (_b = oldState.fileInfos.get(sourceFile.resolvedPath)) === null || _b === void 0 ? void 0 : _b.signature : undefined :
+                    oldUncommittedSignature || undefined;
                 if (referencedMap) {
                     var newReferences = getReferencedFiles(newProgram, sourceFile, getCanonicalFileName);
                     if (newReferences) {
@@ -120217,19 +120317,26 @@ var ts;
                     }
                     // Copy old visible to outside files map
                     if (useOldState) {
-                        var exportedModules = oldState.exportedModulesMap.getValues(sourceFile.resolvedPath);
+                        var oldUncommittedExportedModules = (_c = oldState.oldExportedModulesMap) === null || _c === void 0 ? void 0 : _c.get(sourceFile.resolvedPath);
+                        var exportedModules = oldUncommittedExportedModules === undefined ?
+                            oldState.exportedModulesMap.getValues(sourceFile.resolvedPath) :
+                            oldUncommittedExportedModules || undefined;
                         if (exportedModules) {
                             exportedModulesMap.set(sourceFile.resolvedPath, exportedModules);
                         }
                     }
                 }
-                fileInfos.set(sourceFile.resolvedPath, { version: version_2, signature: oldInfo && oldInfo.signature, affectsGlobalScope: isFileAffectingGlobalScope(sourceFile) || undefined, impliedFormat: sourceFile.impliedNodeFormat });
+                fileInfos.set(sourceFile.resolvedPath, {
+                    version: version_2,
+                    signature: signature,
+                    affectsGlobalScope: isFileAffectingGlobalScope(sourceFile) || undefined,
+                    impliedFormat: sourceFile.impliedNodeFormat
+                });
             }
             return {
                 fileInfos: fileInfos,
                 referencedMap: referencedMap,
                 exportedModulesMap: exportedModulesMap,
-                hasCalledUpdateShapeSignature: hasCalledUpdateShapeSignature,
                 useFileVersionAsSignature: !disableUseFileVersionAsSignature && !useOldState
             };
         }
@@ -120243,71 +120350,42 @@ var ts;
         }
         BuilderState.releaseCache = releaseCache;
         /**
-         * Creates a clone of the state
+         * Gets the files affected by the path from the program
          */
-        function clone(state) {
+        function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, computeHash) {
             var _a, _b;
-            // Dont need to backup allFiles info since its cache anyway
-            return {
-                fileInfos: new ts.Map(state.fileInfos),
-                referencedMap: (_a = state.referencedMap) === null || _a === void 0 ? void 0 : _a.clone(),
-                exportedModulesMap: (_b = state.exportedModulesMap) === null || _b === void 0 ? void 0 : _b.clone(),
-                hasCalledUpdateShapeSignature: new ts.Set(state.hasCalledUpdateShapeSignature),
-                useFileVersionAsSignature: state.useFileVersionAsSignature,
-            };
+            var result = getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, computeHash);
+            (_a = state.oldSignatures) === null || _a === void 0 ? void 0 : _a.clear();
+            (_b = state.oldExportedModulesMap) === null || _b === void 0 ? void 0 : _b.clear();
+            return result;
         }
-        BuilderState.clone = clone;
-        /**
-         * Gets the files affected by the path from the program
-         */
-        function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, computeHash, cacheToUpdateSignature, exportedModulesMapCache) {
-            // Since the operation could be cancelled, the signatures are always stored in the cache
-            // They will be committed once it is safe to use them
-            // eg when calling this api from tsserver, if there is no cancellation of the operation
-            // In the other cases the affected files signatures are committed only after the iteration through the result is complete
-            var signatureCache = cacheToUpdateSignature || new ts.Map();
+        BuilderState.getFilesAffectedBy = getFilesAffectedBy;
+        function getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, computeHash) {
             var sourceFile = programOfThisState.getSourceFileByPath(path);
             if (!sourceFile) {
                 return ts.emptyArray;
             }
-            if (!updateShapeSignature(state, programOfThisState, sourceFile, signatureCache, cancellationToken, computeHash, exportedModulesMapCache)) {
+            if (!updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash)) {
                 return [sourceFile];
             }
-            var result = (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, signatureCache, cancellationToken, computeHash, exportedModulesMapCache);
-            if (!cacheToUpdateSignature) {
-                // Commit all the signatures in the signature cache
-                updateSignaturesFromCache(state, signatureCache);
-            }
-            return result;
-        }
-        BuilderState.getFilesAffectedBy = getFilesAffectedBy;
-        /**
-         * Updates the signatures from the cache into state's fileinfo signatures
-         * This should be called whenever it is safe to commit the state of the builder
-         */
-        function updateSignaturesFromCache(state, signatureCache) {
-            signatureCache.forEach(function (signature, path) { return updateSignatureOfFile(state, signature, path); });
+            return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, computeHash);
         }
-        BuilderState.updateSignaturesFromCache = updateSignaturesFromCache;
+        BuilderState.getFilesAffectedByWithOldState = getFilesAffectedByWithOldState;
         function updateSignatureOfFile(state, signature, path) {
             state.fileInfos.get(path).signature = signature;
-            state.hasCalledUpdateShapeSignature.add(path);
+            (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = new ts.Set())).add(path);
         }
         BuilderState.updateSignatureOfFile = updateSignatureOfFile;
         /**
          * Returns if the shape of the signature has changed since last emit
          */
-        function updateShapeSignature(state, programOfThisState, sourceFile, cacheToUpdateSignature, cancellationToken, computeHash, exportedModulesMapCache, useFileVersionAsSignature) {
+        function updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash, useFileVersionAsSignature) {
+            var _a;
             if (useFileVersionAsSignature === void 0) { useFileVersionAsSignature = state.useFileVersionAsSignature; }
-            ts.Debug.assert(!!sourceFile);
-            ts.Debug.assert(!exportedModulesMapCache || !!state.exportedModulesMap, "Compute visible to outside map only if visibleToOutsideReferencedMap present in the state");
             // If we have cached the result for this file, that means hence forth we should assume file shape is uptodate
-            if (state.hasCalledUpdateShapeSignature.has(sourceFile.resolvedPath) || cacheToUpdateSignature.has(sourceFile.resolvedPath)) {
+            if ((_a = state.hasCalledUpdateShapeSignature) === null || _a === void 0 ? void 0 : _a.has(sourceFile.resolvedPath))
                 return false;
-            }
             var info = state.fileInfos.get(sourceFile.resolvedPath);
-            if (!info)
-                return ts.Debug.fail();
             var prevSignature = info.signature;
             var latestSignature;
             if (!sourceFile.isDeclarationFile && !useFileVersionAsSignature) {
@@ -120318,45 +120396,55 @@ var ts;
                 var firstDts_1 = ts.firstOrUndefined(emitOutput_1.outputFiles);
                 if (firstDts_1) {
                     ts.Debug.assert(ts.isDeclarationFileName(firstDts_1.name), "File extension for signature expected to be dts", function () { return "Found: " + ts.getAnyExtensionFromPath(firstDts_1.name) + " for " + firstDts_1.name + ":: All output files: " + JSON.stringify(emitOutput_1.outputFiles.map(function (f) { return f.name; })); });
-                    latestSignature = (computeHash || ts.generateDjb2Hash)(firstDts_1.text);
-                    if (exportedModulesMapCache && latestSignature !== prevSignature) {
-                        updateExportedModules(sourceFile, emitOutput_1.exportedModulesFromDeclarationEmit, exportedModulesMapCache);
+                    latestSignature = computeSignature(firstDts_1.text, computeHash);
+                    if (latestSignature !== prevSignature) {
+                        updateExportedModules(state, sourceFile, emitOutput_1.exportedModulesFromDeclarationEmit);
                     }
                 }
             }
             // Default is to use file version as signature
             if (latestSignature === undefined) {
                 latestSignature = sourceFile.version;
-                if (exportedModulesMapCache && latestSignature !== prevSignature) {
+                if (state.exportedModulesMap && latestSignature !== prevSignature) {
+                    (state.oldExportedModulesMap || (state.oldExportedModulesMap = new ts.Map())).set(sourceFile.resolvedPath, state.exportedModulesMap.getValues(sourceFile.resolvedPath) || false);
                     // All the references in this file are exported
                     var references = state.referencedMap ? state.referencedMap.getValues(sourceFile.resolvedPath) : undefined;
                     if (references) {
-                        exportedModulesMapCache.set(sourceFile.resolvedPath, references);
+                        state.exportedModulesMap.set(sourceFile.resolvedPath, references);
                     }
                     else {
-                        exportedModulesMapCache.deleteKey(sourceFile.resolvedPath);
+                        state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
                     }
                 }
             }
-            cacheToUpdateSignature.set(sourceFile.resolvedPath, latestSignature);
+            (state.oldSignatures || (state.oldSignatures = new ts.Map())).set(sourceFile.resolvedPath, prevSignature || false);
+            (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = new ts.Set())).add(sourceFile.resolvedPath);
+            info.signature = latestSignature;
             return latestSignature !== prevSignature;
         }
         BuilderState.updateShapeSignature = updateShapeSignature;
+        function computeSignature(text, computeHash) {
+            return (computeHash || ts.generateDjb2Hash)(text);
+        }
+        BuilderState.computeSignature = computeSignature;
         /**
          * Coverts the declaration emit result into exported modules map
          */
-        function updateExportedModules(sourceFile, exportedModulesFromDeclarationEmit, exportedModulesMapCache) {
+        function updateExportedModules(state, sourceFile, exportedModulesFromDeclarationEmit) {
+            if (!state.exportedModulesMap)
+                return;
+            (state.oldExportedModulesMap || (state.oldExportedModulesMap = new ts.Map())).set(sourceFile.resolvedPath, state.exportedModulesMap.getValues(sourceFile.resolvedPath) || false);
             if (!exportedModulesFromDeclarationEmit) {
-                exportedModulesMapCache.deleteKey(sourceFile.resolvedPath);
+                state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
                 return;
             }
             var exportedModules;
             exportedModulesFromDeclarationEmit.forEach(function (symbol) { return addExportedModule(getReferencedFilesFromImportedModuleSymbol(symbol)); });
             if (exportedModules) {
-                exportedModulesMapCache.set(sourceFile.resolvedPath, exportedModules);
+                state.exportedModulesMap.set(sourceFile.resolvedPath, exportedModules);
             }
             else {
-                exportedModulesMapCache.deleteKey(sourceFile.resolvedPath);
+                state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
             }
             function addExportedModule(exportedModulePaths) {
                 if (exportedModulePaths === null || exportedModulePaths === void 0 ? void 0 : exportedModulePaths.length) {
@@ -120368,19 +120456,6 @@ var ts;
             }
         }
         BuilderState.updateExportedModules = updateExportedModules;
-        /**
-         * Updates the exported modules from cache into state's exported modules map
-         * This should be called whenever it is safe to commit the state of the builder
-         */
-        function updateExportedFilesMapFromCache(state, exportedModulesMapCache) {
-            var _a;
-            if (exportedModulesMapCache) {
-                ts.Debug.assert(!!state.exportedModulesMap);
-                (_a = exportedModulesMapCache.deletedKeys()) === null || _a === void 0 ? void 0 : _a.forEach(function (path) { return state.exportedModulesMap.deleteKey(path); });
-                exportedModulesMapCache.forEach(function (exportedModules, path) { return state.exportedModulesMap.set(path, exportedModules); });
-            }
-        }
-        BuilderState.updateExportedFilesMapFromCache = updateExportedFilesMapFromCache;
         /**
          * Get all the dependencies of the sourceFile
          */
@@ -120501,7 +120576,7 @@ var ts;
         /**
          * When program emits modular code, gets the files affected by the sourceFile whose shape has changed
          */
-        function getFilesAffectedByUpdatedShapeWhenModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape, cacheToUpdateSignature, cancellationToken, computeHash, exportedModulesMapCache) {
+        function getFilesAffectedByUpdatedShapeWhenModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape, cancellationToken, computeHash) {
             if (isFileAffectingGlobalScope(sourceFileWithUpdatedShape)) {
                 return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
             }
@@ -120521,7 +120596,7 @@ var ts;
                 if (!seenFileNamesMap.has(currentPath)) {
                     var currentSourceFile = programOfThisState.getSourceFileByPath(currentPath);
                     seenFileNamesMap.set(currentPath, currentSourceFile);
-                    if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cacheToUpdateSignature, cancellationToken, computeHash, exportedModulesMapCache)) {
+                    if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cancellationToken, computeHash)) {
                         queue.push.apply(queue, getReferencedByPaths(state, currentSourceFile.resolvedPath));
                     }
                 }
@@ -120547,32 +120622,33 @@ var ts;
      * Create the state so that we can iterate on changedFiles/affected files
      */
     function createBuilderProgramState(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature) {
+        var _a, _b;
         var state = ts.BuilderState.create(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature);
         state.program = newProgram;
         var compilerOptions = newProgram.getCompilerOptions();
         state.compilerOptions = compilerOptions;
+        var outFilePath = ts.outFile(compilerOptions);
         // With --out or --outFile, any change affects all semantic diagnostics so no need to cache them
-        if (!ts.outFile(compilerOptions)) {
+        if (!outFilePath) {
             state.semanticDiagnosticsPerFile = new ts.Map();
         }
+        else if (compilerOptions.composite && (oldState === null || oldState === void 0 ? void 0 : oldState.outSignature) && outFilePath === ts.outFile(oldState === null || oldState === void 0 ? void 0 : oldState.compilerOptions)) {
+            state.outSignature = oldState === null || oldState === void 0 ? void 0 : oldState.outSignature;
+        }
         state.changedFilesSet = new ts.Set();
+        state.dtsChangeTime = compilerOptions.composite ? oldState === null || oldState === void 0 ? void 0 : oldState.dtsChangeTime : undefined;
         var useOldState = ts.BuilderState.canReuseOldState(state.referencedMap, oldState);
         var oldCompilerOptions = useOldState ? oldState.compilerOptions : undefined;
         var canCopySemanticDiagnostics = useOldState && oldState.semanticDiagnosticsPerFile && !!state.semanticDiagnosticsPerFile &&
             !ts.compilerOptionsAffectSemanticDiagnostics(compilerOptions, oldCompilerOptions);
+        var canCopyEmitSignatures = compilerOptions.composite &&
+            (oldState === null || oldState === void 0 ? void 0 : oldState.emitSignatures) &&
+            !outFilePath &&
+            !ts.compilerOptionsAffectDeclarationPath(compilerOptions, oldCompilerOptions);
         if (useOldState) {
-            // Verify the sanity of old state
-            if (!oldState.currentChangedFilePath) {
-                var affectedSignatures = oldState.currentAffectedFilesSignatures;
-                ts.Debug.assert(!oldState.affectedFiles && (!affectedSignatures || !affectedSignatures.size), "Cannot reuse if only few affected files of currentChangedFile were iterated");
-            }
-            var changedFilesSet = oldState.changedFilesSet;
-            if (canCopySemanticDiagnostics) {
-                ts.Debug.assert(!changedFilesSet || !ts.forEachKey(changedFilesSet, function (path) { return oldState.semanticDiagnosticsPerFile.has(path); }), "Semantic diagnostics shouldnt be available for changed files");
-            }
             // Copy old state's changed files set
-            changedFilesSet === null || changedFilesSet === void 0 ? void 0 : changedFilesSet.forEach(function (value) { return state.changedFilesSet.add(value); });
-            if (!ts.outFile(compilerOptions) && oldState.affectedFilesPendingEmit) {
+            (_a = oldState.changedFilesSet) === null || _a === void 0 ? void 0 : _a.forEach(function (value) { return state.changedFilesSet.add(value); });
+            if (!outFilePath && oldState.affectedFilesPendingEmit) {
                 state.affectedFilesPendingEmit = oldState.affectedFilesPendingEmit.slice();
                 state.affectedFilesPendingEmitKind = oldState.affectedFilesPendingEmitKind && new ts.Map(oldState.affectedFilesPendingEmitKind);
                 state.affectedFilesPendingEmitIndex = oldState.affectedFilesPendingEmitIndex;
@@ -120593,6 +120669,8 @@ var ts;
                 !(oldInfo = oldState.fileInfos.get(sourceFilePath)) ||
                 // versions dont match
                 oldInfo.version !== info.version ||
+                // Implied formats dont match
+                oldInfo.impliedFormat !== info.impliedFormat ||
                 // Referenced files changed
                 !hasSameKeys(newReferences = referencedMap && referencedMap.getValues(sourceFilePath), oldReferencedMap && oldReferencedMap.getValues(sourceFilePath)) ||
                 // Referenced file was deleted in the new program
@@ -120616,27 +120694,25 @@ var ts;
                     state.semanticDiagnosticsFromOldState.add(sourceFilePath);
                 }
             }
+            if (canCopyEmitSignatures) {
+                var oldEmitSignature = oldState.emitSignatures.get(sourceFilePath);
+                if (oldEmitSignature)
+                    (state.emitSignatures || (state.emitSignatures = new ts.Map())).set(sourceFilePath, oldEmitSignature);
+            }
         });
         // If the global file is removed, add all files as changed
         if (useOldState && ts.forEachEntry(oldState.fileInfos, function (info, sourceFilePath) { return info.affectsGlobalScope && !state.fileInfos.has(sourceFilePath); })) {
             ts.BuilderState.getAllFilesExcludingDefaultLibraryFile(state, newProgram, /*firstSourceFile*/ undefined)
                 .forEach(function (file) { return state.changedFilesSet.add(file.resolvedPath); });
         }
-        else if (oldCompilerOptions && !ts.outFile(compilerOptions) && ts.compilerOptionsAffectEmit(compilerOptions, oldCompilerOptions)) {
+        else if (oldCompilerOptions && !outFilePath && ts.compilerOptionsAffectEmit(compilerOptions, oldCompilerOptions)) {
             // Add all files to affectedFilesPendingEmit since emit changed
             newProgram.getSourceFiles().forEach(function (f) { return addToAffectedFilesPendingEmit(state, f.resolvedPath, 1 /* Full */); });
             ts.Debug.assert(!state.seenAffectedFiles || !state.seenAffectedFiles.size);
             state.seenAffectedFiles = state.seenAffectedFiles || new ts.Set();
         }
-        if (useOldState) {
-            // Any time the interpretation of a source file changes, mark it as changed
-            ts.forEachEntry(oldState.fileInfos, function (info, sourceFilePath) {
-                if (state.fileInfos.has(sourceFilePath) && state.fileInfos.get(sourceFilePath).impliedFormat !== info.impliedFormat) {
-                    state.changedFilesSet.add(sourceFilePath);
-                }
-            });
-        }
-        state.buildInfoEmitPending = !!state.changedFilesSet.size;
+        // Since old states change files set is copied, any additional change means we would need to emit build info
+        state.buildInfoEmitPending = !useOldState || state.changedFilesSet.size !== (((_b = oldState.changedFilesSet) === null || _b === void 0 ? void 0 : _b.size) || 0);
         return state;
     }
     function convertToDiagnostics(diagnostics, newProgram, getCanonicalFileName) {
@@ -120672,30 +120748,35 @@ var ts;
         ts.BuilderState.releaseCache(state);
         state.program = undefined;
     }
-    /**
-     * Creates a clone of the state
-     */
-    function cloneBuilderProgramState(state) {
-        var _a;
-        var newState = ts.BuilderState.clone(state);
-        newState.semanticDiagnosticsPerFile = state.semanticDiagnosticsPerFile && new ts.Map(state.semanticDiagnosticsPerFile);
-        newState.changedFilesSet = new ts.Set(state.changedFilesSet);
-        newState.affectedFiles = state.affectedFiles;
-        newState.affectedFilesIndex = state.affectedFilesIndex;
-        newState.currentChangedFilePath = state.currentChangedFilePath;
-        newState.currentAffectedFilesSignatures = state.currentAffectedFilesSignatures && new ts.Map(state.currentAffectedFilesSignatures);
-        newState.currentAffectedFilesExportedModulesMap = (_a = state.currentAffectedFilesExportedModulesMap) === null || _a === void 0 ? void 0 : _a.clone();
-        newState.seenAffectedFiles = state.seenAffectedFiles && new ts.Set(state.seenAffectedFiles);
-        newState.cleanedDiagnosticsOfLibFiles = state.cleanedDiagnosticsOfLibFiles;
-        newState.semanticDiagnosticsFromOldState = state.semanticDiagnosticsFromOldState && new ts.Set(state.semanticDiagnosticsFromOldState);
-        newState.program = state.program;
-        newState.compilerOptions = state.compilerOptions;
-        newState.affectedFilesPendingEmit = state.affectedFilesPendingEmit && state.affectedFilesPendingEmit.slice();
-        newState.affectedFilesPendingEmitKind = state.affectedFilesPendingEmitKind && new ts.Map(state.affectedFilesPendingEmitKind);
-        newState.affectedFilesPendingEmitIndex = state.affectedFilesPendingEmitIndex;
-        newState.seenEmittedFiles = state.seenEmittedFiles && new ts.Map(state.seenEmittedFiles);
-        newState.programEmitComplete = state.programEmitComplete;
-        return newState;
+    function backupBuilderProgramEmitState(state) {
+        var outFilePath = ts.outFile(state.compilerOptions);
+        // Only in --out changeFileSet is kept around till emit
+        ts.Debug.assert(!state.changedFilesSet.size || outFilePath);
+        return {
+            affectedFilesPendingEmit: state.affectedFilesPendingEmit && state.affectedFilesPendingEmit.slice(),
+            affectedFilesPendingEmitKind: state.affectedFilesPendingEmitKind && new ts.Map(state.affectedFilesPendingEmitKind),
+            affectedFilesPendingEmitIndex: state.affectedFilesPendingEmitIndex,
+            seenEmittedFiles: state.seenEmittedFiles && new ts.Map(state.seenEmittedFiles),
+            programEmitComplete: state.programEmitComplete,
+            emitSignatures: state.emitSignatures && new ts.Map(state.emitSignatures),
+            outSignature: state.outSignature,
+            dtsChangeTime: state.dtsChangeTime,
+            hasChangedEmitSignature: state.hasChangedEmitSignature,
+            changedFilesSet: outFilePath ? new ts.Set(state.changedFilesSet) : undefined,
+        };
+    }
+    function restoreBuilderProgramEmitState(state, savedEmitState) {
+        state.affectedFilesPendingEmit = savedEmitState.affectedFilesPendingEmit;
+        state.affectedFilesPendingEmitKind = savedEmitState.affectedFilesPendingEmitKind;
+        state.affectedFilesPendingEmitIndex = savedEmitState.affectedFilesPendingEmitIndex;
+        state.seenEmittedFiles = savedEmitState.seenEmittedFiles;
+        state.programEmitComplete = savedEmitState.programEmitComplete;
+        state.emitSignatures = savedEmitState.emitSignatures;
+        state.outSignature = savedEmitState.outSignature;
+        state.dtsChangeTime = savedEmitState.dtsChangeTime;
+        state.hasChangedEmitSignature = savedEmitState.hasChangedEmitSignature;
+        if (savedEmitState.changedFilesSet)
+            state.changedFilesSet = savedEmitState.changedFilesSet;
     }
     /**
      * Verifies that source file is ok to be used in calls that arent handled by next
@@ -120710,7 +120791,7 @@ var ts;
      * eg. if during diagnostics check cancellation token ends up cancelling the request, the affected file should be retained
      */
     function getNextAffectedFile(state, cancellationToken, computeHash, host) {
-        var _a;
+        var _a, _b;
         while (true) {
             var affectedFiles = state.affectedFiles;
             if (affectedFiles) {
@@ -120730,10 +120811,8 @@ var ts;
                 state.changedFilesSet.delete(state.currentChangedFilePath);
                 state.currentChangedFilePath = undefined;
                 // Commit the changes in file signature
-                ts.BuilderState.updateSignaturesFromCache(state, state.currentAffectedFilesSignatures);
-                state.currentAffectedFilesSignatures.clear();
-                ts.BuilderState.updateExportedFilesMapFromCache(state, state.currentAffectedFilesExportedModulesMap);
-                (_a = state.currentAffectedFilesExportedModulesMap) === null || _a === void 0 ? void 0 : _a.clear();
+                (_a = state.oldSignatures) === null || _a === void 0 ? void 0 : _a.clear();
+                (_b = state.oldExportedModulesMap) === null || _b === void 0 ? void 0 : _b.clear();
                 state.affectedFiles = undefined;
             }
             // Get next changed file
@@ -120751,12 +120830,7 @@ var ts;
                 return program;
             }
             // Get next batch of affected files
-            if (!state.currentAffectedFilesSignatures)
-                state.currentAffectedFilesSignatures = new ts.Map();
-            if (state.exportedModulesMap) {
-                state.currentAffectedFilesExportedModulesMap || (state.currentAffectedFilesExportedModulesMap = ts.BuilderState.createManyToManyPathMap());
-            }
-            state.affectedFiles = ts.BuilderState.getFilesAffectedBy(state, program, nextKey.value, cancellationToken, computeHash, state.currentAffectedFilesSignatures, state.currentAffectedFilesExportedModulesMap);
+            state.affectedFiles = ts.BuilderState.getFilesAffectedByWithOldState(state, program, nextKey.value, cancellationToken, computeHash);
             state.currentChangedFilePath = nextKey.value;
             state.affectedFilesIndex = 0;
             if (!state.seenAffectedFiles)
@@ -120808,7 +120882,6 @@ var ts;
      *  This is because even though js emit doesnt change, dts emit / type used can change resulting in need for dts emit and js change
      */
     function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash, host) {
-        var _a;
         removeSemanticDiagnosticsOf(state, affectedFile.resolvedPath);
         // If affected files is everything except default library, then nothing more to do
         if (state.allFilesExcludingDefaultLibraryFile === state.affectedFiles) {
@@ -120816,10 +120889,9 @@ var ts;
             // When a change affects the global scope, all files are considered to be affected without updating their signature
             // That means when affected file is handled, its signature can be out of date
             // To avoid this, ensure that we update the signature for any affected file in this scenario.
-            ts.BuilderState.updateShapeSignature(state, ts.Debug.checkDefined(state.program), affectedFile, ts.Debug.checkDefined(state.currentAffectedFilesSignatures), cancellationToken, computeHash, state.currentAffectedFilesExportedModulesMap);
+            ts.BuilderState.updateShapeSignature(state, ts.Debug.checkDefined(state.program), affectedFile, cancellationToken, computeHash);
             return;
         }
-        ts.Debug.assert(state.hasCalledUpdateShapeSignature.has(affectedFile.resolvedPath) || ((_a = state.currentAffectedFilesSignatures) === null || _a === void 0 ? void 0 : _a.has(affectedFile.resolvedPath)), "Signature not updated for affected file: " + affectedFile.fileName);
         if (state.compilerOptions.assumeChangesOnlyAffectDirectDependencies)
             return;
         handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, host);
@@ -120839,7 +120911,7 @@ var ts;
                 // This ensures that we dont later during incremental builds considering wrong signature.
                 // Eg where this also is needed to ensure that .tsbuildinfo generated by incremental build should be same as if it was first fresh build
                 // But we avoid expensive full shape computation, as using file version as shape is enough for correctness.
-                ts.BuilderState.updateShapeSignature(state, program, sourceFile, ts.Debug.checkDefined(state.currentAffectedFilesSignatures), cancellationToken, computeHash, state.currentAffectedFilesExportedModulesMap, !host.disableUseFileVersionAsSignature);
+                ts.BuilderState.updateShapeSignature(state, program, sourceFile, cancellationToken, computeHash, !host.disableUseFileVersionAsSignature);
                 // If not dts emit, nothing more to do
                 if (ts.getEmitDeclarations(state.compilerOptions)) {
                     addToAffectedFilesPendingEmit(state, path, 0 /* DtsOnly */);
@@ -120860,27 +120932,10 @@ var ts;
         return !state.semanticDiagnosticsFromOldState.size;
     }
     function isChangedSignature(state, path) {
-        var newSignature = ts.Debug.checkDefined(state.currentAffectedFilesSignatures).get(path);
-        var oldSignature = ts.Debug.checkDefined(state.fileInfos.get(path)).signature;
+        var oldSignature = ts.Debug.checkDefined(state.oldSignatures).get(path) || undefined;
+        var newSignature = ts.Debug.checkDefined(state.fileInfos.get(path)).signature;
         return newSignature !== oldSignature;
     }
-    function forEachKeyOfExportedModulesMap(state, filePath, fn) {
-        // Go through exported modules from cache first
-        var keys = state.currentAffectedFilesExportedModulesMap.getKeys(filePath);
-        var result = keys && ts.forEachKey(keys, fn);
-        if (result)
-            return result;
-        // If exported from path is not from cache and exported modules has path, all files referencing file exported from are affected
-        keys = state.exportedModulesMap.getKeys(filePath);
-        return keys && ts.forEachKey(keys, function (exportedFromPath) {
-            var _a;
-            // If the cache had an updated value, skip
-            return !state.currentAffectedFilesExportedModulesMap.hasKey(exportedFromPath) &&
-                !((_a = state.currentAffectedFilesExportedModulesMap.deletedKeys()) === null || _a === void 0 ? void 0 : _a.has(exportedFromPath)) ?
-                fn(exportedFromPath) :
-                undefined;
-        });
-    }
     function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, host) {
         var _a;
         if (!((_a = state.fileInfos.get(filePath)) === null || _a === void 0 ? void 0 : _a.affectsGlobalScope))
@@ -120895,6 +120950,7 @@ var ts;
      * Iterate on referencing modules that export entities from affected file and delete diagnostics and add pending emit
      */
     function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, host) {
+        var _a;
         // If there was change in signature (dts output) for the changed file,
         // then only we need to handle pending file emit
         if (!state.exportedModulesMap || !state.changedFilesSet.has(affectedFile.resolvedPath))
@@ -120921,11 +120977,10 @@ var ts;
                 }
             }
         }
-        ts.Debug.assert(!!state.currentAffectedFilesExportedModulesMap);
         var seenFileAndExportsOfFile = new ts.Set();
         // Go through exported modules from cache first
         // If exported modules has path, all files referencing file exported from are affected
-        forEachKeyOfExportedModulesMap(state, affectedFile.resolvedPath, function (exportedFromPath) {
+        (_a = state.exportedModulesMap.getKeys(affectedFile.resolvedPath)) === null || _a === void 0 ? void 0 : _a.forEach(function (exportedFromPath) {
             if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, computeHash, host))
                 return true;
             var references = state.referencedMap.getKeys(exportedFromPath);
@@ -120939,19 +120994,18 @@ var ts;
      * return true when all work is done and we can exit handling dts emit and semantic diagnostics
      */
     function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, computeHash, host) {
-        var _a;
+        var _a, _b;
         if (!ts.tryAddToSet(seenFileAndExportsOfFile, filePath))
             return undefined;
         if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, host))
             return true;
         handleDtsMayChangeOf(state, filePath, cancellationToken, computeHash, host);
-        ts.Debug.assert(!!state.currentAffectedFilesExportedModulesMap);
         // If exported modules has path, all files referencing file exported from are affected
-        forEachKeyOfExportedModulesMap(state, filePath, function (exportedFromPath) {
+        (_a = state.exportedModulesMap.getKeys(filePath)) === null || _a === void 0 ? void 0 : _a.forEach(function (exportedFromPath) {
             return handleDtsMayChangeOfFileAndExportsOfFile(state, exportedFromPath, seenFileAndExportsOfFile, cancellationToken, computeHash, host);
         });
         // Remove diagnostics of files that import this file (without going to exports of referencing files)
-        (_a = state.referencedMap.getKeys(filePath)) === null || _a === void 0 ? void 0 : _a.forEach(function (referencingFilePath) {
+        (_b = state.referencedMap.getKeys(filePath)) === null || _b === void 0 ? void 0 : _b.forEach(function (referencingFilePath) {
             return !seenFileAndExportsOfFile.has(referencingFilePath) && // Not already removed diagnostic file
                 handleDtsMayChangeOf(// Dont add to seen since this is not yet done with the export removal
                 state, referencingFilePath, cancellationToken, computeHash, host);
@@ -120972,12 +121026,13 @@ var ts;
         }
         else {
             state.seenAffectedFiles.add(affected.resolvedPath);
+            // Change in changeSet/affectedFilesPendingEmit, buildInfo needs to be emitted
+            state.buildInfoEmitPending = true;
             if (emitKind !== undefined) {
                 (state.seenEmittedFiles || (state.seenEmittedFiles = new ts.Map())).set(affected.resolvedPath, emitKind);
             }
             if (isPendingEmit) {
                 state.affectedFilesPendingEmitIndex++;
-                state.buildInfoEmitPending = true;
             }
             else {
                 state.affectedFilesIndex++;
@@ -121025,25 +121080,62 @@ var ts;
         }
         return ts.filterSemanticDiagnostics(diagnostics, state.compilerOptions);
     }
+    function isProgramBundleEmitBuildInfo(info) {
+        return !!ts.outFile(info.options || {});
+    }
+    ts.isProgramBundleEmitBuildInfo = isProgramBundleEmitBuildInfo;
     /**
      * Gets the program information to be emitted in buildInfo so that we can use it to create new program
      */
-    function getProgramBuildInfo(state, getCanonicalFileName) {
-        if (ts.outFile(state.compilerOptions))
-            return undefined;
+    function getProgramBuildInfo(state, getCanonicalFileName, host) {
+        var outFilePath = ts.outFile(state.compilerOptions);
+        if (outFilePath && !state.compilerOptions.composite)
+            return;
         var currentDirectory = ts.Debug.checkDefined(state.program).getCurrentDirectory();
         var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(ts.getTsBuildInfoEmitOutputFilePath(state.compilerOptions), currentDirectory));
+        // Update the dtsChange time in buildInfo
+        state.dtsChangeTime = state.hasChangedEmitSignature ? ts.getCurrentTime(host).getTime() : state.dtsChangeTime;
+        if (outFilePath) {
+            var fileNames_1 = [];
+            var fileInfos_1 = [];
+            state.program.getRootFileNames().forEach(function (f) {
+                var sourceFile = state.program.getSourceFile(f);
+                if (!sourceFile)
+                    return;
+                fileNames_1.push(relativeToBuildInfo(sourceFile.resolvedPath));
+                fileInfos_1.push(sourceFile.version);
+            });
+            var result_15 = {
+                fileNames: fileNames_1,
+                fileInfos: fileInfos_1,
+                options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsBundleEmitBuildInfo"),
+                outSignature: state.outSignature,
+                dtsChangeTime: state.dtsChangeTime,
+            };
+            return result_15;
+        }
         var fileNames = [];
         var fileNameToFileId = new ts.Map();
         var fileIdsList;
         var fileNamesToFileIdListId;
+        var emitSignatures;
         var fileInfos = ts.arrayFrom(state.fileInfos.entries(), function (_a) {
+            var _b, _c;
             var key = _a[0], value = _a[1];
             // Ensure fileId
             var fileId = toFileId(key);
             ts.Debug.assert(fileNames[fileId - 1] === relativeToBuildInfo(key));
-            var signature = state.currentAffectedFilesSignatures && state.currentAffectedFilesSignatures.get(key);
-            var actualSignature = signature !== null && signature !== void 0 ? signature : value.signature;
+            var oldSignature = (_b = state.oldSignatures) === null || _b === void 0 ? void 0 : _b.get(key);
+            var actualSignature = oldSignature !== undefined ? oldSignature || undefined : value.signature;
+            if (state.compilerOptions.composite) {
+                var file = state.program.getSourceFileByPath(key);
+                if (!ts.isJsonSourceFile(file) && ts.sourceFileMayBeEmitted(file, state.program)) {
+                    var emitSignature = (_c = state.emitSignatures) === null || _c === void 0 ? void 0 : _c.get(key);
+                    if (emitSignature !== actualSignature) {
+                        (emitSignatures || (emitSignatures = [])).push(emitSignature === undefined ? fileId : [fileId, emitSignature]);
+                    }
+                }
+            }
             return value.version === actualSignature ?
                 value.affectsGlobalScope || value.impliedFormat ?
                     // If file version is same as signature, dont serialize signature
@@ -121051,11 +121143,11 @@ var ts;
                     // If file info only contains version and signature and both are same we can just write string
                     value.version :
                 actualSignature !== undefined ? // If signature is not same as version, encode signature in the fileInfo
-                    signature === undefined ?
+                    oldSignature === undefined ?
                         // If we havent computed signature, use fileInfo as is
                         value :
                         // Serialize fileInfo with new updated signature
-                        { version: value.version, signature: signature, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat } :
+                        { version: value.version, signature: actualSignature, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat } :
                     // Signature of the FileInfo is undefined, serialize it as false
                     { version: value.version, signature: false, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat };
         });
@@ -121070,17 +121162,13 @@ var ts;
         if (state.exportedModulesMap) {
             exportedModulesMap = ts.mapDefined(ts.arrayFrom(state.exportedModulesMap.keys()).sort(ts.compareStringsCaseSensitive), function (key) {
                 var _a;
-                if (state.currentAffectedFilesExportedModulesMap) {
-                    if ((_a = state.currentAffectedFilesExportedModulesMap.deletedKeys()) === null || _a === void 0 ? void 0 : _a.has(key)) {
-                        return undefined;
-                    }
-                    var newValue = state.currentAffectedFilesExportedModulesMap.getValues(key);
-                    if (newValue) {
-                        return [toFileId(key), toFileIdListId(newValue)];
-                    }
-                }
+                var oldValue = (_a = state.oldExportedModulesMap) === null || _a === void 0 ? void 0 : _a.get(key);
                 // Not in temporary cache, use existing value
-                return [toFileId(key), toFileIdListId(state.exportedModulesMap.getValues(key))];
+                if (oldValue === undefined)
+                    return [toFileId(key), toFileIdListId(state.exportedModulesMap.getValues(key))];
+                if (oldValue)
+                    return [toFileId(key), toFileIdListId(oldValue)];
+                return undefined;
             });
         }
         var semanticDiagnosticsPerFile;
@@ -121091,9 +121179,7 @@ var ts;
                 (semanticDiagnosticsPerFile || (semanticDiagnosticsPerFile = [])).push(value.length ?
                     [
                         toFileId(key),
-                        state.hasReusableDiagnostic ?
-                            value :
-                            convertToReusableDiagnostics(value, relativeToBuildInfo)
+                        convertToReusableDiagnostics(value, relativeToBuildInfo)
                     ] :
                     toFileId(key));
             }
@@ -121108,16 +121194,27 @@ var ts;
                 }
             }
         }
-        return {
+        var changeFileSet;
+        if (state.changedFilesSet.size) {
+            for (var _d = 0, _e = ts.arrayFrom(state.changedFilesSet.keys()).sort(ts.compareStringsCaseSensitive); _d < _e.length; _d++) {
+                var path = _e[_d];
+                (changeFileSet || (changeFileSet = [])).push(toFileId(path));
+            }
+        }
+        var result = {
             fileNames: fileNames,
             fileInfos: fileInfos,
-            options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions, relativeToBuildInfoEnsuringAbsolutePath),
+            options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsMultiFileEmitBuildInfo"),
             fileIdsList: fileIdsList,
             referencedMap: referencedMap,
             exportedModulesMap: exportedModulesMap,
             semanticDiagnosticsPerFile: semanticDiagnosticsPerFile,
             affectedFilesPendingEmit: affectedFilesPendingEmit,
+            changeFileSet: changeFileSet,
+            emitSignatures: emitSignatures,
+            dtsChangeTime: state.dtsChangeTime,
         };
+        return result;
         function relativeToBuildInfoEnsuringAbsolutePath(path) {
             return relativeToBuildInfo(ts.getNormalizedAbsolutePath(path, currentDirectory));
         }
@@ -121142,24 +121239,21 @@ var ts;
             }
             return fileIdListId;
         }
-    }
-    function convertToProgramBuildInfoCompilerOptions(options, relativeToBuildInfo) {
-        var result;
-        var optionsNameMap = ts.getOptionsNameMap().optionsNameMap;
-        for (var _i = 0, _a = ts.getOwnKeys(options).sort(ts.compareStringsCaseSensitive); _i < _a.length; _i++) {
-            var name = _a[_i];
-            var optionKey = name.toLowerCase();
-            var optionInfo = optionsNameMap.get(optionKey);
-            if ((optionInfo === null || optionInfo === void 0 ? void 0 : optionInfo.affectsEmit) || (optionInfo === null || optionInfo === void 0 ? void 0 : optionInfo.affectsSemanticDiagnostics) ||
-                // We need to store `strict`, even though it won't be examined directly, so that the
-                // flags it controls (e.g. `strictNullChecks`) will be retrieved correctly from the buildinfo
-                optionKey === "strict" ||
-                // We need to store these to determine whether `lib` files need to be rechecked.
-                optionKey === "skiplibcheck" || optionKey === "skipdefaultlibcheck") {
-                (result || (result = {}))[name] = convertToReusableCompilerOptionValue(optionInfo, options[name], relativeToBuildInfo);
+        /**
+         * @param optionKey key of CommandLineOption to use to determine if the option should be serialized in tsbuildinfo
+         */
+        function convertToProgramBuildInfoCompilerOptions(options, optionKey) {
+            var result;
+            var optionsNameMap = ts.getOptionsNameMap().optionsNameMap;
+            for (var _i = 0, _a = ts.getOwnKeys(options).sort(ts.compareStringsCaseSensitive); _i < _a.length; _i++) {
+                var name = _a[_i];
+                var optionInfo = optionsNameMap.get(name.toLowerCase());
+                if (optionInfo === null || optionInfo === void 0 ? void 0 : optionInfo[optionKey]) {
+                    (result || (result = {}))[name] = convertToReusableCompilerOptionValue(optionInfo, options[name], relativeToBuildInfoEnsuringAbsolutePath);
+                }
             }
+            return result;
         }
-        return result;
     }
     function convertToReusableCompilerOptionValue(option, value, relativeToBuildInfo) {
         if (option) {
@@ -121233,6 +121327,10 @@ var ts;
         return { host: host, newProgram: newProgram, oldProgram: oldProgram, configFileParsingDiagnostics: configFileParsingDiagnostics || ts.emptyArray };
     }
     ts.getBuilderCreationParameters = getBuilderCreationParameters;
+    function computeSignature(text, data, computeHash) {
+        return ts.BuilderState.computeSignature((data === null || data === void 0 ? void 0 : data.sourceMapUrlPos) !== undefined ? text.substring(0, data.sourceMapUrlPos) : text, computeHash);
+    }
+    ts.computeSignature = computeSignature;
     function createBuilderProgram(kind, _a) {
         var newProgram = _a.newProgram, host = _a.host, oldProgram = _a.oldProgram, configFileParsingDiagnostics = _a.configFileParsingDiagnostics;
         // Return same program if underlying program doesnt change
@@ -121251,8 +121349,7 @@ var ts;
          */
         var computeHash = ts.maybeBind(host, host.createHash);
         var state = createBuilderProgramState(newProgram, getCanonicalFileName, oldState, host.disableUseFileVersionAsSignature);
-        var backupState;
-        newProgram.getProgramBuildInfo = function () { return getProgramBuildInfo(state, getCanonicalFileName); };
+        newProgram.getProgramBuildInfo = function () { return getProgramBuildInfo(state, getCanonicalFileName, host); };
         // To ensure that we arent storing any references to old program or new program without state
         newProgram = undefined; // TODO: GH#18217
         oldProgram = undefined;
@@ -121260,21 +121357,12 @@ var ts;
         var getState = function () { return state; };
         var builderProgram = createRedirectedBuilderProgram(getState, configFileParsingDiagnostics);
         builderProgram.getState = getState;
-        builderProgram.backupState = function () {
-            ts.Debug.assert(backupState === undefined);
-            backupState = cloneBuilderProgramState(state);
-        };
-        builderProgram.restoreState = function () {
-            state = ts.Debug.checkDefined(backupState);
-            backupState = undefined;
-        };
+        builderProgram.saveEmitState = function () { return backupBuilderProgramEmitState(state); };
+        builderProgram.restoreEmitState = function (saved) { return restoreBuilderProgramEmitState(state, saved); };
         builderProgram.getAllDependencies = function (sourceFile) { return ts.BuilderState.getAllDependencies(state, ts.Debug.checkDefined(state.program), sourceFile); };
         builderProgram.getSemanticDiagnostics = getSemanticDiagnostics;
         builderProgram.emit = emit;
-        builderProgram.releaseProgram = function () {
-            releaseCache(state);
-            backupState = undefined;
-        };
+        builderProgram.releaseProgram = function () { return releaseCache(state); };
         if (kind === BuilderProgramKind.SemanticDiagnosticsBuilderProgram) {
             builderProgram.getSemanticDiagnosticsOfNextAffectedFile = getSemanticDiagnosticsOfNextAffectedFile;
         }
@@ -121332,35 +121420,62 @@ var ts;
             return toAffectedFileEmitResult(state, 
             // When whole program is affected, do emit only once (eg when --out or --outFile is specified)
             // Otherwise just affected file
-            ts.Debug.checkDefined(state.program).emit(affected === state.program ? undefined : affected, affected !== state.program && ts.getEmitDeclarations(state.compilerOptions) && !customTransformers ?
-                getWriteFileUpdatingSignatureCallback(writeFile) :
+            ts.Debug.checkDefined(state.program).emit(affected === state.program ? undefined : affected, ts.getEmitDeclarations(state.compilerOptions) ?
+                getWriteFileCallback(writeFile, customTransformers) :
                 writeFile || ts.maybeBind(host, host.writeFile), cancellationToken, emitOnlyDtsFiles || emitKind === 0 /* DtsOnly */, customTransformers), affected, emitKind, isPendingEmitFile);
         }
-        function getWriteFileUpdatingSignatureCallback(writeFile) {
+        function getWriteFileCallback(writeFile, customTransformers) {
             return function (fileName, text, writeByteOrderMark, onError, sourceFiles, data) {
-                var _a;
+                var _a, _b, _c;
                 if (ts.isDeclarationFileName(fileName)) {
-                    ts.Debug.assert((sourceFiles === null || sourceFiles === void 0 ? void 0 : sourceFiles.length) === 1);
-                    var file = sourceFiles[0];
-                    var info = state.fileInfos.get(file.resolvedPath);
-                    var signature = ((_a = state.currentAffectedFilesSignatures) === null || _a === void 0 ? void 0 : _a.get(file.resolvedPath)) || info.signature;
-                    if (signature === file.version) {
-                        var newSignature = (computeHash || ts.generateDjb2Hash)((data === null || data === void 0 ? void 0 : data.sourceMapUrlPos) !== undefined ? text.substring(0, data.sourceMapUrlPos) : text);
-                        if (newSignature !== file.version) { // Update it
-                            if (host.storeFilesChangingSignatureDuringEmit)
-                                (state.filesChangingSignature || (state.filesChangingSignature = new ts.Set())).add(file.resolvedPath);
-                            if (state.exportedModulesMap)
-                                ts.BuilderState.updateExportedModules(file, file.exportedModulesFromDeclarationEmit, state.currentAffectedFilesExportedModulesMap || (state.currentAffectedFilesExportedModulesMap = ts.BuilderState.createManyToManyPathMap()));
-                            if (state.affectedFiles && state.affectedFilesIndex < state.affectedFiles.length) {
-                                state.currentAffectedFilesSignatures.set(file.resolvedPath, newSignature);
+                    if (!ts.outFile(state.compilerOptions)) {
+                        ts.Debug.assert((sourceFiles === null || sourceFiles === void 0 ? void 0 : sourceFiles.length) === 1);
+                        var newSignature = void 0;
+                        if (!customTransformers) {
+                            var file = sourceFiles[0];
+                            var info = state.fileInfos.get(file.resolvedPath);
+                            if (info.signature === file.version) {
+                                newSignature = computeSignature(text, data, computeHash);
+                                if (newSignature !== file.version) { // Update it
+                                    if (host.storeFilesChangingSignatureDuringEmit)
+                                        (state.filesChangingSignature || (state.filesChangingSignature = new ts.Set())).add(file.resolvedPath);
+                                    if (state.exportedModulesMap)
+                                        ts.BuilderState.updateExportedModules(state, file, file.exportedModulesFromDeclarationEmit);
+                                    if (state.affectedFiles) {
+                                        // Keep old signature so we know what to undo if cancellation happens
+                                        var existing = (_a = state.oldSignatures) === null || _a === void 0 ? void 0 : _a.get(file.resolvedPath);
+                                        if (existing === undefined)
+                                            (state.oldSignatures || (state.oldSignatures = new ts.Map())).set(file.resolvedPath, info.signature || false);
+                                        info.signature = newSignature;
+                                    }
+                                    else {
+                                        // These are directly commited
+                                        info.signature = newSignature;
+                                        (_b = state.oldExportedModulesMap) === null || _b === void 0 ? void 0 : _b.clear();
+                                    }
+                                }
                             }
-                            else {
-                                info.signature = newSignature;
-                                if (state.exportedModulesMap)
-                                    ts.BuilderState.updateExportedFilesMapFromCache(state, state.currentAffectedFilesExportedModulesMap);
+                        }
+                        // Store d.ts emit hash so later can be compared to check if d.ts has changed.
+                        // Currently we do this only for composite projects since these are the only projects that can be referenced by other projects
+                        // and would need their d.ts change time in --build mode
+                        if (state.compilerOptions.composite) {
+                            var filePath = sourceFiles[0].resolvedPath;
+                            var oldSignature = (_c = state.emitSignatures) === null || _c === void 0 ? void 0 : _c.get(filePath);
+                            newSignature || (newSignature = computeSignature(text, data, computeHash));
+                            if (newSignature !== oldSignature) {
+                                (state.emitSignatures || (state.emitSignatures = new ts.Map())).set(filePath, newSignature);
+                                state.hasChangedEmitSignature = true;
                             }
                         }
                     }
+                    else if (state.compilerOptions.composite) {
+                        var newSignature = computeSignature(text, data, computeHash);
+                        if (newSignature !== state.outSignature) {
+                            state.outSignature = newSignature;
+                            state.hasChangedEmitSignature = true;
+                        }
+                    }
                 }
                 if (writeFile)
                     writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
@@ -121425,8 +121540,8 @@ var ts;
                     }
                 }
             }
-            return ts.Debug.checkDefined(state.program).emit(targetSourceFile, !ts.outFile(state.compilerOptions) && ts.getEmitDeclarations(state.compilerOptions) && !customTransformers ?
-                getWriteFileUpdatingSignatureCallback(writeFile) :
+            return ts.Debug.checkDefined(state.program).emit(targetSourceFile, ts.getEmitDeclarations(state.compilerOptions) ?
+                getWriteFileCallback(writeFile, customTransformers) :
                 writeFile || ts.maybeBind(host, host.writeFile), cancellationToken, emitOnlyDtsFiles, customTransformers);
         }
         /**
@@ -121515,29 +121630,58 @@ var ts;
                 { version: fileInfo.version, signature: fileInfo.signature === false ? undefined : fileInfo.version, affectsGlobalScope: fileInfo.affectsGlobalScope, impliedFormat: fileInfo.impliedFormat };
     }
     ts.toBuilderStateFileInfo = toBuilderStateFileInfo;
-    function createBuildProgramUsingProgramBuildInfo(program, buildInfoPath, host) {
-        var _a;
+    function createBuilderProgramUsingProgramBuildInfo(program, buildInfoPath, host) {
+        var _a, _b, _c, _d;
         var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
         var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames());
-        var filePaths = program.fileNames.map(toPath);
-        var filePathsSetList = (_a = program.fileIdsList) === null || _a === void 0 ? void 0 : _a.map(function (fileIds) { return new ts.Set(fileIds.map(toFilePath)); });
-        var fileInfos = new ts.Map();
-        program.fileInfos.forEach(function (fileInfo, index) { return fileInfos.set(toFilePath(index + 1), toBuilderStateFileInfo(fileInfo)); });
-        var state = {
-            fileInfos: fileInfos,
-            compilerOptions: program.options ? ts.convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
-            referencedMap: toManyToManyPathMap(program.referencedMap),
-            exportedModulesMap: toManyToManyPathMap(program.exportedModulesMap),
-            semanticDiagnosticsPerFile: program.semanticDiagnosticsPerFile && ts.arrayToMap(program.semanticDiagnosticsPerFile, function (value) { return toFilePath(ts.isNumber(value) ? value : value[0]); }, function (value) { return ts.isNumber(value) ? ts.emptyArray : value[1]; }),
-            hasReusableDiagnostic: true,
-            affectedFilesPendingEmit: ts.map(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }),
-            affectedFilesPendingEmitKind: program.affectedFilesPendingEmit && ts.arrayToMap(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }, function (value) { return value[1]; }),
-            affectedFilesPendingEmitIndex: program.affectedFilesPendingEmit && 0,
-        };
+        var state;
+        var filePaths;
+        var filePathsSetList;
+        if (isProgramBundleEmitBuildInfo(program)) {
+            state = {
+                fileInfos: new ts.Map(),
+                compilerOptions: program.options ? ts.convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
+                dtsChangeTime: program.dtsChangeTime,
+                outSignature: program.outSignature,
+            };
+        }
+        else {
+            filePaths = (_a = program.fileNames) === null || _a === void 0 ? void 0 : _a.map(toPath);
+            filePathsSetList = (_b = program.fileIdsList) === null || _b === void 0 ? void 0 : _b.map(function (fileIds) { return new ts.Set(fileIds.map(toFilePath)); });
+            var fileInfos_2 = new ts.Map();
+            var emitSignatures_1 = ((_c = program.options) === null || _c === void 0 ? void 0 : _c.composite) && !ts.outFile(program.options) ? new ts.Map() : undefined;
+            program.fileInfos.forEach(function (fileInfo, index) {
+                var path = toFilePath(index + 1);
+                var stateFileInfo = toBuilderStateFileInfo(fileInfo);
+                fileInfos_2.set(path, stateFileInfo);
+                if (emitSignatures_1 && stateFileInfo.signature)
+                    emitSignatures_1.set(path, stateFileInfo.signature);
+            });
+            (_d = program.emitSignatures) === null || _d === void 0 ? void 0 : _d.forEach(function (value) {
+                if (ts.isNumber(value))
+                    emitSignatures_1.delete(toFilePath(value));
+                else
+                    emitSignatures_1.set(toFilePath(value[0]), value[1]);
+            });
+            state = {
+                fileInfos: fileInfos_2,
+                compilerOptions: program.options ? ts.convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
+                referencedMap: toManyToManyPathMap(program.referencedMap),
+                exportedModulesMap: toManyToManyPathMap(program.exportedModulesMap),
+                semanticDiagnosticsPerFile: program.semanticDiagnosticsPerFile && ts.arrayToMap(program.semanticDiagnosticsPerFile, function (value) { return toFilePath(ts.isNumber(value) ? value : value[0]); }, function (value) { return ts.isNumber(value) ? ts.emptyArray : value[1]; }),
+                hasReusableDiagnostic: true,
+                affectedFilesPendingEmit: ts.map(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }),
+                affectedFilesPendingEmitKind: program.affectedFilesPendingEmit && ts.arrayToMap(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }, function (value) { return value[1]; }),
+                affectedFilesPendingEmitIndex: program.affectedFilesPendingEmit && 0,
+                changedFilesSet: new ts.Set(ts.map(program.changeFileSet, toFilePath)),
+                dtsChangeTime: program.dtsChangeTime,
+                emitSignatures: (emitSignatures_1 === null || emitSignatures_1 === void 0 ? void 0 : emitSignatures_1.size) ? emitSignatures_1 : undefined,
+            };
+        }
         return {
             getState: function () { return state; },
-            backupState: ts.noop,
-            restoreState: ts.noop,
+            saveEmitState: ts.noop,
+            restoreEmitState: ts.noop,
             getProgram: ts.notImplemented,
             getProgramOrUndefined: ts.returnUndefined,
             releaseProgram: ts.noop,
@@ -121582,12 +121726,24 @@ var ts;
             return map;
         }
     }
-    ts.createBuildProgramUsingProgramBuildInfo = createBuildProgramUsingProgramBuildInfo;
+    ts.createBuilderProgramUsingProgramBuildInfo = createBuilderProgramUsingProgramBuildInfo;
+    function getBuildInfoFileVersionMap(program, buildInfoPath, host) {
+        var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
+        var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames());
+        var fileInfos = new ts.Map();
+        program.fileInfos.forEach(function (fileInfo, index) {
+            var path = ts.toPath(program.fileNames[index], buildInfoDirectory, getCanonicalFileName);
+            var version = ts.isString(fileInfo) ? fileInfo : fileInfo.version; // eslint-disable-line @typescript-eslint/no-unnecessary-type-assertion
+            fileInfos.set(path, version);
+        });
+        return fileInfos;
+    }
+    ts.getBuildInfoFileVersionMap = getBuildInfoFileVersionMap;
     function createRedirectedBuilderProgram(getState, configFileParsingDiagnostics) {
         return {
             getState: ts.notImplemented,
-            backupState: ts.noop,
-            restoreState: ts.noop,
+            saveEmitState: ts.noop,
+            restoreEmitState: ts.noop,
             getProgram: getProgram,
             getProgramOrUndefined: function () { return getState().program; },
             releaseProgram: function () { return getState().program = undefined; },
@@ -121691,8 +121847,10 @@ var ts;
         var filesWithInvalidatedNonRelativeUnresolvedImports;
         var nonRelativeExternalModuleResolutions = ts.createMultiMap();
         var resolutionsWithFailedLookups = [];
+        var resolutionsWithOnlyAffectingLocations = [];
         var resolvedFileToResolution = ts.createMultiMap();
         var hasChangedAutomaticTypeDirectiveNames = false;
+        var affectingPathChecks;
         var failedLookupChecks;
         var startsWithPathChecks;
         var isInDirectoryChecks;
@@ -121719,6 +121877,7 @@ var ts;
         var failedLookupDefaultExtensions = [".ts" /* Ts */, ".tsx" /* Tsx */, ".js" /* Js */, ".jsx" /* Jsx */, ".json" /* Json */];
         var customFailedLookupPaths = new ts.Map();
         var directoryWatchesOfFailedLookups = new ts.Map();
+        var fileWatchesOfAffectingLocations = new ts.Map();
         var rootDir = rootDirForResolution && ts.removeTrailingDirectorySeparator(ts.getNormalizedAbsolutePath(rootDirForResolution, getCurrentDirectory()));
         var rootPath = (rootDir && resolutionHost.toPath(rootDir)); // TODO: GH#18217
         var rootSplitLength = rootPath !== undefined ? rootPath.split(ts.directorySeparator).length : 0;
@@ -121761,6 +121920,7 @@ var ts;
         }
         function clear() {
             ts.clearMap(directoryWatchesOfFailedLookups, ts.closeFileWatcherOf);
+            ts.clearMap(fileWatchesOfAffectingLocations, ts.closeFileWatcherOf);
             customFailedLookupPaths.clear();
             nonRelativeExternalModuleResolutions.clear();
             closeTypeRootsWatch();
@@ -121768,9 +121928,11 @@ var ts;
             resolvedTypeReferenceDirectives.clear();
             resolvedFileToResolution.clear();
             resolutionsWithFailedLookups.length = 0;
+            resolutionsWithOnlyAffectingLocations.length = 0;
             failedLookupChecks = undefined;
             startsWithPathChecks = undefined;
             isInDirectoryChecks = undefined;
+            affectingPathChecks = undefined;
             // perDirectoryResolvedModuleNames and perDirectoryResolvedTypeReferenceDirectives could be non empty if there was exception during program update
             // (between startCachingPerDirectoryResolution and finishCachingPerDirectoryResolution)
             clearPerDirectoryResolutions();
@@ -121820,10 +121982,18 @@ var ts;
                     watcher.watcher.close();
                 }
             });
+            fileWatchesOfAffectingLocations.forEach(function (watcher, path) {
+                if (watcher.refCount === 0) {
+                    fileWatchesOfAffectingLocations.delete(path);
+                    watcher.watcher.close();
+                    // Ensure when watching symlinked package.json, we can close the actual file watcher only once
+                    watcher.watcher = ts.noopFileWatcher;
+                }
+            });
             hasChangedAutomaticTypeDirectiveNames = false;
         }
         function resolveModuleName(moduleName, containingFile, compilerOptions, host, redirectedReference, _containingSourceFile, mode) {
-            var _a;
+            var _a, _b;
             var primaryResult = ts.resolveModuleName(moduleName, containingFile, compilerOptions, host, moduleResolutionCache, redirectedReference, mode);
             // return result immediately only if global cache support is not enabled or if it is .ts, .tsx or .d.ts
             if (!resolutionHost.getGlobalCache) {
@@ -121834,11 +122004,12 @@ var ts;
             if (globalCache !== undefined && !ts.isExternalModuleNameRelative(moduleName) && !(primaryResult.resolvedModule && ts.extensionIsTS(primaryResult.resolvedModule.extension))) {
                 // create different collection of failed lookup locations for second pass
                 // if it will fail and we've already found something during the first pass - we don't want to pollute its results
-                var _b = ts.loadModuleFromGlobalCache(ts.Debug.checkDefined(resolutionHost.globalCacheResolutionModuleName)(moduleName), resolutionHost.projectName, compilerOptions, host, globalCache, moduleResolutionCache), resolvedModule = _b.resolvedModule, failedLookupLocations = _b.failedLookupLocations;
+                var _c = ts.loadModuleFromGlobalCache(ts.Debug.checkDefined(resolutionHost.globalCacheResolutionModuleName)(moduleName), resolutionHost.projectName, compilerOptions, host, globalCache, moduleResolutionCache), resolvedModule = _c.resolvedModule, failedLookupLocations = _c.failedLookupLocations, affectingLocations = _c.affectingLocations;
                 if (resolvedModule) {
                     // Modify existing resolution so its saved in the directory cache as well
                     primaryResult.resolvedModule = resolvedModule;
                     (_a = primaryResult.failedLookupLocations).push.apply(_a, failedLookupLocations);
+                    (_b = primaryResult.affectingLocations).push.apply(_b, affectingLocations);
                     return primaryResult;
                 }
             }
@@ -122089,10 +122260,11 @@ var ts;
         }
         function watchFailedLookupLocationOfResolution(resolution) {
             ts.Debug.assert(!!resolution.refCount);
-            var failedLookupLocations = resolution.failedLookupLocations;
-            if (!failedLookupLocations.length)
+            var failedLookupLocations = resolution.failedLookupLocations, affectingLocations = resolution.affectingLocations;
+            if (!failedLookupLocations.length && !affectingLocations.length)
                 return;
-            resolutionsWithFailedLookups.push(resolution);
+            if (failedLookupLocations.length)
+                resolutionsWithFailedLookups.push(resolution);
             var setAtRoot = false;
             for (var _i = 0, failedLookupLocations_1 = failedLookupLocations; _i < failedLookupLocations_1.length; _i++) {
                 var failedLookupLocation = failedLookupLocations_1[_i];
@@ -122119,12 +122291,66 @@ var ts;
                 // This is always non recursive
                 setDirectoryWatcher(rootDir, rootPath, /*nonRecursive*/ true); // TODO: GH#18217
             }
+            watchAffectingLocationsOfResolution(resolution, !failedLookupLocations.length);
+        }
+        function watchAffectingLocationsOfResolution(resolution, addToResolutionsWithOnlyAffectingLocations) {
+            ts.Debug.assert(!!resolution.refCount);
+            if (addToResolutionsWithOnlyAffectingLocations)
+                resolutionsWithOnlyAffectingLocations.push(resolution);
+            var affectingLocations = resolution.affectingLocations;
+            // Watch package json
+            for (var _i = 0, affectingLocations_1 = affectingLocations; _i < affectingLocations_1.length; _i++) {
+                var affectingLocation = affectingLocations_1[_i];
+                createFileWatcherOfAffectingLocation(affectingLocation);
+            }
+        }
+        function createFileWatcherOfAffectingLocation(affectingLocation) {
+            var path = resolutionHost.toPath(affectingLocation);
+            var fileWatcher = fileWatchesOfAffectingLocations.get(path);
+            if (fileWatcher) {
+                fileWatcher.refCount++;
+                return;
+            }
+            var locationToWatch = affectingLocation;
+            var locationToWatchPath = path;
+            if (resolutionHost.realpath) {
+                locationToWatch = resolutionHost.realpath(affectingLocation);
+                locationToWatchPath = resolutionHost.toPath(locationToWatch);
+                if (path !== locationToWatchPath) {
+                    var fileWatcher_1 = fileWatchesOfAffectingLocations.get(locationToWatchPath);
+                    if (fileWatcher_1) {
+                        fileWatcher_1.refCount++;
+                        fileWatcher_1.paths.add(path);
+                        fileWatchesOfAffectingLocations.set(path, fileWatcher_1);
+                        return;
+                    }
+                }
+            }
+            var paths = new ts.Set();
+            paths.add(locationToWatchPath);
+            var watcher = {
+                watcher: resolutionHost.watchAffectingFileLocation(locationToWatch, function (fileName, eventKind) {
+                    cachedDirectoryStructureHost === null || cachedDirectoryStructureHost === void 0 ? void 0 : cachedDirectoryStructureHost.addOrDeleteFile(fileName, path, eventKind);
+                    paths.forEach(function (path) { return (affectingPathChecks || (affectingPathChecks = new ts.Set())).add(path); });
+                    resolutionHost.scheduleInvalidateResolutionsOfFailedLookupLocations();
+                }),
+                refCount: 1,
+                paths: paths,
+            };
+            fileWatchesOfAffectingLocations.set(locationToWatchPath, watcher);
+            if (path !== locationToWatchPath) {
+                fileWatchesOfAffectingLocations.set(path, watcher);
+                paths.add(path);
+            }
         }
         function watchFailedLookupLocationOfNonRelativeModuleResolutions(resolutions, name) {
             var program = resolutionHost.getCurrentProgram();
             if (!program || !program.getTypeChecker().tryFindAmbientModuleWithoutAugmentations(name)) {
                 resolutions.forEach(watchFailedLookupLocationOfResolution);
             }
+            else {
+                resolutions.forEach(function (resolution) { return watchAffectingLocationsOfResolution(resolution, /*addToResolutionWithOnlyAffectingLocations*/ true); });
+            }
         }
         function setDirectoryWatcher(dir, dirPath, nonRecursive) {
             var dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
@@ -122146,38 +122372,44 @@ var ts;
             if (resolved && resolved.resolvedFileName) {
                 resolvedFileToResolution.remove(resolutionHost.toPath(resolved.resolvedFileName), resolution);
             }
-            if (!ts.unorderedRemoveItem(resolutionsWithFailedLookups, resolution)) {
-                // If not watching failed lookups, it wont be there in resolutionsWithFailedLookups
-                return;
-            }
-            var failedLookupLocations = resolution.failedLookupLocations;
-            var removeAtRoot = false;
-            for (var _i = 0, failedLookupLocations_2 = failedLookupLocations; _i < failedLookupLocations_2.length; _i++) {
-                var failedLookupLocation = failedLookupLocations_2[_i];
-                var failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
-                var toWatch = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
-                if (toWatch) {
-                    var dirPath = toWatch.dirPath;
-                    var refCount = customFailedLookupPaths.get(failedLookupLocationPath);
-                    if (refCount) {
-                        if (refCount === 1) {
-                            customFailedLookupPaths.delete(failedLookupLocationPath);
+            var failedLookupLocations = resolution.failedLookupLocations, affectingLocations = resolution.affectingLocations;
+            if (ts.unorderedRemoveItem(resolutionsWithFailedLookups, resolution)) {
+                var removeAtRoot = false;
+                for (var _i = 0, failedLookupLocations_2 = failedLookupLocations; _i < failedLookupLocations_2.length; _i++) {
+                    var failedLookupLocation = failedLookupLocations_2[_i];
+                    var failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
+                    var toWatch = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
+                    if (toWatch) {
+                        var dirPath = toWatch.dirPath;
+                        var refCount = customFailedLookupPaths.get(failedLookupLocationPath);
+                        if (refCount) {
+                            if (refCount === 1) {
+                                customFailedLookupPaths.delete(failedLookupLocationPath);
+                            }
+                            else {
+                                ts.Debug.assert(refCount > 1);
+                                customFailedLookupPaths.set(failedLookupLocationPath, refCount - 1);
+                            }
+                        }
+                        if (dirPath === rootPath) {
+                            removeAtRoot = true;
                         }
                         else {
-                            ts.Debug.assert(refCount > 1);
-                            customFailedLookupPaths.set(failedLookupLocationPath, refCount - 1);
+                            removeDirectoryWatcher(dirPath);
                         }
                     }
-                    if (dirPath === rootPath) {
-                        removeAtRoot = true;
-                    }
-                    else {
-                        removeDirectoryWatcher(dirPath);
-                    }
+                }
+                if (removeAtRoot) {
+                    removeDirectoryWatcher(rootPath);
                 }
             }
-            if (removeAtRoot) {
-                removeDirectoryWatcher(rootPath);
+            else if (affectingLocations.length) {
+                ts.unorderedRemoveItem(resolutionsWithOnlyAffectingLocations, resolution);
+            }
+            for (var _a = 0, affectingLocations_2 = affectingLocations; _a < affectingLocations_2.length; _a++) {
+                var affectingLocation = affectingLocations_2[_a];
+                var watcher = fileWatchesOfAffectingLocations.get(resolutionHost.toPath(affectingLocation));
+                watcher.refCount--;
             }
         }
         function removeDirectoryWatcher(dirPath) {
@@ -122256,7 +122488,7 @@ var ts;
             if (isCreatingWatchedDirectory) {
                 // Watching directory is created
                 // Invalidate any resolution has failed lookup in this directory
-                (isInDirectoryChecks || (isInDirectoryChecks = [])).push(fileOrDirectoryPath);
+                (isInDirectoryChecks || (isInDirectoryChecks = new ts.Set())).add(fileOrDirectoryPath);
             }
             else {
                 // If something to do with folder/file starting with "." in node_modules folder, skip it
@@ -122274,7 +122506,7 @@ var ts;
                 if (isNodeModulesAtTypesDirectory(fileOrDirectoryPath) || ts.isNodeModulesDirectory(fileOrDirectoryPath) ||
                     isNodeModulesAtTypesDirectory(dirOfFileOrDirectory) || ts.isNodeModulesDirectory(dirOfFileOrDirectory)) {
                     // Invalidate any resolution from this directory
-                    (failedLookupChecks || (failedLookupChecks = [])).push(fileOrDirectoryPath);
+                    (failedLookupChecks || (failedLookupChecks = new ts.Set())).add(fileOrDirectoryPath);
                     (startsWithPathChecks || (startsWithPathChecks = new ts.Set())).add(fileOrDirectoryPath);
                 }
                 else {
@@ -122286,7 +122518,7 @@ var ts;
                         return false;
                     }
                     // Resolution need to be invalidated if failed lookup location is same as the file or directory getting created
-                    (failedLookupChecks || (failedLookupChecks = [])).push(fileOrDirectoryPath);
+                    (failedLookupChecks || (failedLookupChecks = new ts.Set())).add(fileOrDirectoryPath);
                     // If the invalidated file is from a node_modules package, invalidate everything else
                     // in the package since we might not get notifications for other files in the package.
                     // This hardens our logic against unreliable file watchers.
@@ -122298,21 +122530,32 @@ var ts;
             resolutionHost.scheduleInvalidateResolutionsOfFailedLookupLocations();
         }
         function invalidateResolutionsOfFailedLookupLocations() {
-            if (!failedLookupChecks && !startsWithPathChecks && !isInDirectoryChecks) {
+            if (!failedLookupChecks && !startsWithPathChecks && !isInDirectoryChecks && !affectingPathChecks) {
                 return false;
             }
             var invalidated = invalidateResolutions(resolutionsWithFailedLookups, canInvalidateFailedLookupResolution);
             failedLookupChecks = undefined;
             startsWithPathChecks = undefined;
             isInDirectoryChecks = undefined;
+            invalidated = invalidateResolutions(resolutionsWithOnlyAffectingLocations, canInvalidatedFailedLookupResolutionWithAffectingLocation) || invalidated;
+            affectingPathChecks = undefined;
             return invalidated;
         }
         function canInvalidateFailedLookupResolution(resolution) {
+            if (canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution))
+                return true;
+            if (!failedLookupChecks && !startsWithPathChecks && !isInDirectoryChecks)
+                return false;
             return resolution.failedLookupLocations.some(function (location) {
                 var locationPath = resolutionHost.toPath(location);
-                return ts.contains(failedLookupChecks, locationPath) ||
+                return (failedLookupChecks === null || failedLookupChecks === void 0 ? void 0 : failedLookupChecks.has(locationPath)) ||
                     ts.firstDefinedIterator((startsWithPathChecks === null || startsWithPathChecks === void 0 ? void 0 : startsWithPathChecks.keys()) || ts.emptyIterator, function (fileOrDirectoryPath) { return ts.startsWith(locationPath, fileOrDirectoryPath) ? true : undefined; }) ||
-                    (isInDirectoryChecks === null || isInDirectoryChecks === void 0 ? void 0 : isInDirectoryChecks.some(function (fileOrDirectoryPath) { return isInDirectoryPath(fileOrDirectoryPath, locationPath); }));
+                    ts.firstDefinedIterator((isInDirectoryChecks === null || isInDirectoryChecks === void 0 ? void 0 : isInDirectoryChecks.keys()) || ts.emptyIterator, function (fileOrDirectoryPath) { return isInDirectoryPath(fileOrDirectoryPath, locationPath) ? true : undefined; });
+            });
+        }
+        function canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution) {
+            return !!affectingPathChecks && resolution.affectingLocations.some(function (location) {
+                return affectingPathChecks.has(resolutionHost.toPath(location));
             });
         }
         function closeTypeRootsWatch() {
@@ -122703,9 +122946,9 @@ var ts;
             if (!preferSymlinks) {
                 // Symlinks inside ignored paths are already filtered out of the symlink cache,
                 // so we only need to remove them from the realpath filenames.
-                var result_15 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
-                if (result_15)
-                    return result_15;
+                var result_16 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
+                if (result_16)
+                    return result_16;
             }
             var symlinkedDirectories = (_a = host.getSymlinkCache) === null || _a === void 0 ? void 0 : _a.call(host).getSymlinkedDirectoriesByRealpath();
             var fullImportedFileName = ts.getNormalizedAbsolutePath(importedFileName, cwd);
@@ -122725,10 +122968,10 @@ var ts;
                     for (var _i = 0, symlinkDirectories_1 = symlinkDirectories; _i < symlinkDirectories_1.length; _i++) {
                         var symlinkDirectory = symlinkDirectories_1[_i];
                         var option = ts.resolvePath(symlinkDirectory, relative);
-                        var result_16 = cb(option, target === referenceRedirect);
+                        var result_17 = cb(option, target === referenceRedirect);
                         shouldFilterIgnoredPaths = true; // We found a non-ignored path in symlinks, so we can reject ignored-path realpaths
-                        if (result_16)
-                            return result_16;
+                        if (result_17)
+                            return result_17;
                     }
                 });
             });
@@ -123638,6 +123881,7 @@ var ts;
             readDirectory: ts.maybeBind(host, host.readDirectory),
             disableUseFileVersionAsSignature: host.disableUseFileVersionAsSignature,
             storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit,
+            now: ts.maybeBind(host, host.now),
         };
         function writeFile(fileName, text, writeByteOrderMark, onError) {
             try {
@@ -123698,6 +123942,7 @@ var ts;
             createProgram: createProgram || ts.createEmitAndSemanticDiagnosticsBuilderProgram,
             disableUseFileVersionAsSignature: system.disableUseFileVersionAsSignature,
             storeFilesChangingSignatureDuringEmit: system.storeFilesChangingSignatureDuringEmit,
+            now: ts.maybeBind(system, system.now),
         };
     }
     ts.createProgramHost = createProgramHost;
@@ -123765,20 +124010,27 @@ var ts;
 var ts;
 (function (ts) {
     function readBuilderProgram(compilerOptions, host) {
-        if (ts.outFile(compilerOptions))
-            return undefined;
         var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(compilerOptions);
         if (!buildInfoPath)
             return undefined;
-        var content = host.readFile(buildInfoPath);
-        if (!content)
-            return undefined;
-        var buildInfo = ts.getBuildInfo(content);
+        var buildInfo;
+        if (host.getBuildInfo) {
+            // host provides buildinfo, get it from there. This allows host to cache it
+            buildInfo = host.getBuildInfo(buildInfoPath, compilerOptions.configFilePath);
+            if (!buildInfo)
+                return undefined;
+        }
+        else {
+            var content = host.readFile(buildInfoPath);
+            if (!content)
+                return undefined;
+            buildInfo = ts.getBuildInfo(content);
+        }
         if (buildInfo.version !== ts.version)
             return undefined;
         if (!buildInfo.program)
             return undefined;
-        return ts.createBuildProgramUsingProgramBuildInfo(buildInfo.program, buildInfoPath, host);
+        return ts.createBuilderProgramUsingProgramBuildInfo(buildInfo.program, buildInfoPath, host);
     }
     ts.readBuilderProgram = readBuilderProgram;
     function createIncrementalCompilerHost(options, system) {
@@ -123787,6 +124039,7 @@ var ts;
         host.createHash = ts.maybeBind(system, system.createHash);
         host.disableUseFileVersionAsSignature = system.disableUseFileVersionAsSignature;
         host.storeFilesChangingSignatureDuringEmit = system.storeFilesChangingSignatureDuringEmit;
+        host.now = ts.maybeBind(system, system.now);
         ts.setGetSourceFileAsHashVersioned(host, system);
         ts.changeCompilerHostLikeToUseCache(host, function (fileName) { return ts.toPath(fileName, host.getCurrentDirectory(), host.getCanonicalFileName); });
         return host;
@@ -123831,7 +124084,6 @@ var ts;
         var builderProgram;
         var reloadLevel; // level to indicate if the program needs to be reloaded from config file/just filenames etc
         var missingFilesMap; // Map of file watchers for the missing files
-        var packageJsonMap; // map of watchers for package json files used in module resolution
         var watchedWildcardDirectories; // map of watchers for the wild card directories in the config file
         var timerToUpdateProgram; // timer callback to recompile the program
         var timerToInvalidateFailedLookupResolutions; // timer callback to invalidate resolutions for changes in failed lookup locations
@@ -123895,6 +124147,7 @@ var ts;
         compilerHost.getCompilationSettings = function () { return compilerOptions; };
         compilerHost.useSourceOfProjectReferenceRedirect = ts.maybeBind(host, host.useSourceOfProjectReferenceRedirect);
         compilerHost.watchDirectoryOfFailedLookupLocation = function (dir, cb, flags) { return watchDirectory(dir, cb, flags, watchOptions, ts.WatchType.FailedLookupLocations); };
+        compilerHost.watchAffectingFileLocation = function (file, cb) { return watchFile(file, cb, ts.PollingInterval.High, watchOptions, ts.WatchType.PackageJson); };
         compilerHost.watchTypeRootsDirectory = function (dir, cb, flags) { return watchDirectory(dir, cb, flags, watchOptions, ts.WatchType.TypeRoots); };
         compilerHost.getCachedDirectoryStructureHost = function () { return cachedDirectoryStructureHost; };
         compilerHost.scheduleInvalidateResolutionsOfFailedLookupLocations = scheduleInvalidateResolutionsOfFailedLookupLocations;
@@ -123977,10 +124230,6 @@ var ts;
                 });
                 parsedConfigs = undefined;
             }
-            if (packageJsonMap) {
-                ts.clearMap(packageJsonMap, ts.closeFileWatcher);
-                packageJsonMap = undefined;
-            }
         }
         function getCurrentBuilderProgram() {
             return builderProgram;
@@ -124036,15 +124285,9 @@ var ts;
             compilerHost.hasInvalidatedResolution = hasInvalidatedResolution;
             compilerHost.hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames;
             builderProgram = createProgram(rootFileNames, compilerOptions, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences);
-            // map package json cache entries to their realpaths so we don't try to watch across symlinks
-            var packageCacheEntries = ts.map(resolutionCache.getModuleResolutionCache().getPackageJsonInfoCache().entries(), function (_a) {
-                var path = _a[0], data = _a[1];
-                return [compilerHost.realpath ? toPath(compilerHost.realpath(path)) : path, data];
-            });
             resolutionCache.finishCachingPerDirectoryResolution();
             // Update watches
             ts.updateMissingFilePathsWatch(builderProgram.getProgram(), missingFilesMap || (missingFilesMap = new ts.Map()), watchMissingFilePath);
-            ts.updatePackageJsonWatch(packageCacheEntries, packageJsonMap || (packageJsonMap = new ts.Map()), watchPackageJsonLookupPath);
             if (needsUpdateInTypeRootWatch) {
                 resolutionCache.updateTypeRootsWatch();
             }
@@ -124350,21 +124593,6 @@ var ts;
                 ts.noopFileWatcher :
                 watchFilePath(missingFilePath, missingFilePath, onMissingFileChange, ts.PollingInterval.Medium, watchOptions, ts.WatchType.MissingFile);
         }
-        function watchPackageJsonLookupPath(packageJsonPath) {
-            // If the package.json is pulled into the compilation itself (eg, via json imports), don't add a second watcher here
-            return sourceFilesCache.has(packageJsonPath) ?
-                ts.noopFileWatcher :
-                watchFilePath(packageJsonPath, packageJsonPath, onPackageJsonChange, ts.PollingInterval.High, watchOptions, ts.WatchType.PackageJson);
-        }
-        function onPackageJsonChange(fileName, eventKind, path) {
-            updateCachedSystemWithFile(fileName, path, eventKind);
-            // package.json changes invalidate module resolution and can change the set of loaded files
-            // so if we witness a change to one, we have to do a full reload
-            reloadLevel = ts.ConfigFileProgramReloadLevel.Full;
-            changesAffectResolution = true;
-            // Update the program
-            scheduleProgramUpdate();
-        }
         function onMissingFileChange(fileName, eventKind, missingFilePath) {
             updateCachedSystemWithFile(fileName, missingFilePath, eventKind);
             if (eventKind === ts.FileWatcherEventKind.Created && missingFilesMap.has(missingFilePath)) {
@@ -124522,14 +124750,17 @@ var ts;
         UpToDateStatusType[UpToDateStatusType["OutputMissing"] = 4] = "OutputMissing";
         UpToDateStatusType[UpToDateStatusType["OutOfDateWithSelf"] = 5] = "OutOfDateWithSelf";
         UpToDateStatusType[UpToDateStatusType["OutOfDateWithUpstream"] = 6] = "OutOfDateWithUpstream";
-        UpToDateStatusType[UpToDateStatusType["UpstreamOutOfDate"] = 7] = "UpstreamOutOfDate";
-        UpToDateStatusType[UpToDateStatusType["UpstreamBlocked"] = 8] = "UpstreamBlocked";
-        UpToDateStatusType[UpToDateStatusType["ComputingUpstream"] = 9] = "ComputingUpstream";
-        UpToDateStatusType[UpToDateStatusType["TsVersionOutputOfDate"] = 10] = "TsVersionOutputOfDate";
+        UpToDateStatusType[UpToDateStatusType["OutOfDateBuildInfo"] = 7] = "OutOfDateBuildInfo";
+        UpToDateStatusType[UpToDateStatusType["UpstreamOutOfDate"] = 8] = "UpstreamOutOfDate";
+        UpToDateStatusType[UpToDateStatusType["UpstreamBlocked"] = 9] = "UpstreamBlocked";
+        UpToDateStatusType[UpToDateStatusType["ComputingUpstream"] = 10] = "ComputingUpstream";
+        UpToDateStatusType[UpToDateStatusType["TsVersionOutputOfDate"] = 11] = "TsVersionOutputOfDate";
+        UpToDateStatusType[UpToDateStatusType["UpToDateWithInputFileText"] = 12] = "UpToDateWithInputFileText";
         /**
          * Projects with no outputs (i.e. "solution" files)
          */
-        UpToDateStatusType[UpToDateStatusType["ContainerOnly"] = 11] = "ContainerOnly";
+        UpToDateStatusType[UpToDateStatusType["ContainerOnly"] = 13] = "ContainerOnly";
+        UpToDateStatusType[UpToDateStatusType["ForceBuild"] = 14] = "ForceBuild";
     })(UpToDateStatusType = ts.UpToDateStatusType || (ts.UpToDateStatusType = {}));
     function resolveConfigFileProjectName(project) {
         if (ts.fileExtensionIs(project, ".json" /* Json */)) {
@@ -124574,9 +124805,12 @@ var ts;
     function getOrCreateValueMapFromConfigFileMap(configFileMap, resolved) {
         return getOrCreateValueFromConfigFileMap(configFileMap, resolved, function () { return new ts.Map(); });
     }
-    function newer(date1, date2) {
-        return date2 > date1 ? date2 : date1;
+    /*@internal*/
+    /** Helper to use now method instead of current date for testing purposes to get consistent baselines */
+    function getCurrentTime(host) {
+        return host.now ? host.now() : new Date();
     }
+    ts.getCurrentTime = getCurrentTime;
     /*@internal*/
     function isCircularBuildOrder(buildOrder) {
         return !!buildOrder && !!buildOrder.buildOrder;
@@ -124666,6 +124900,7 @@ var ts;
                 return ts.loadWithTypeDirectiveCache(ts.Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader_4);
             };
         }
+        compilerHost.getBuildInfo = function (fileName, configFilePath) { return getBuildInfo(state, fileName, toResolvedConfigFilePath(state, configFilePath), /*modifiedTime*/ undefined); };
         var _a = ts.createWatchFactory(hostWithWatch, options), watchFile = _a.watchFile, watchDirectory = _a.watchDirectory, writeLog = _a.writeLog;
         var state = {
             host: host,
@@ -124682,8 +124917,9 @@ var ts;
             resolvedConfigFilePaths: new ts.Map(),
             configFileCache: new ts.Map(),
             projectStatus: new ts.Map(),
-            buildInfoChecked: new ts.Map(),
             extendedConfigCache: new ts.Map(),
+            buildInfoCache: new ts.Map(),
+            outputTimeStamps: new ts.Map(),
             builderPrograms: new ts.Map(),
             diagnostics: new ts.Map(),
             projectPendingBuild: new ts.Map(),
@@ -124706,6 +124942,7 @@ var ts;
             allWatchedConfigFiles: new ts.Map(),
             allWatchedExtendedConfigFiles: new ts.Map(),
             allWatchedPackageJsonFiles: new ts.Map(),
+            filesWatched: new ts.Map(),
             lastCachedPackageJsonLookups: new ts.Map(),
             timerToBuildInvalidatedProject: undefined,
             reportFileChangeDetected: false,
@@ -124812,11 +125049,12 @@ var ts;
         // Config file cache
         ts.mutateMapSkippingNewValues(state.configFileCache, currentProjects, noopOnDelete);
         ts.mutateMapSkippingNewValues(state.projectStatus, currentProjects, noopOnDelete);
-        ts.mutateMapSkippingNewValues(state.buildInfoChecked, currentProjects, noopOnDelete);
         ts.mutateMapSkippingNewValues(state.builderPrograms, currentProjects, noopOnDelete);
         ts.mutateMapSkippingNewValues(state.diagnostics, currentProjects, noopOnDelete);
         ts.mutateMapSkippingNewValues(state.projectPendingBuild, currentProjects, noopOnDelete);
         ts.mutateMapSkippingNewValues(state.projectErrorsReported, currentProjects, noopOnDelete);
+        ts.mutateMapSkippingNewValues(state.buildInfoCache, currentProjects, noopOnDelete);
+        ts.mutateMapSkippingNewValues(state.outputTimeStamps, currentProjects, noopOnDelete);
         // Remove watches for the program no longer in the solution
         if (state.watch) {
             ts.mutateMapSkippingNewValues(state.allWatchedConfigFiles, currentProjects, { onDeleteValue: ts.closeFileWatcher });
@@ -125106,21 +125344,21 @@ var ts;
         }
         function emit(writeFileCallback, cancellationToken, customTransformers) {
             var _a;
-            var _b, _c;
+            var _b, _c, _d;
             ts.Debug.assertIsDefined(program);
             ts.Debug.assert(step === BuildStep.Emit);
             // Before emitting lets backup state, so we can revert it back if there are declaration errors to handle emit and declaration errors correctly
-            program.backupState();
+            var saved = program.saveEmitState();
             var declDiagnostics;
             var reportDeclarationDiagnostics = function (d) { return (declDiagnostics || (declDiagnostics = [])).push(d); };
             var outputFiles = [];
             var emitResult = ts.emitFilesAndReportErrors(program, reportDeclarationDiagnostics, 
             /*write*/ undefined, 
-            /*reportSummary*/ undefined, function (name, text, writeByteOrderMark) { return outputFiles.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark }); }, cancellationToken, 
+            /*reportSummary*/ undefined, function (name, text, writeByteOrderMark, _onError, _sourceFiles, data) { return outputFiles.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark, buildInfo: data === null || data === void 0 ? void 0 : data.buildInfo }); }, cancellationToken, 
             /*emitOnlyDts*/ false, customTransformers || ((_c = (_b = state.host).getCustomTransformers) === null || _c === void 0 ? void 0 : _c.call(_b, project))).emitResult;
             // Don't emit .d.ts if there are decl file errors
             if (declDiagnostics) {
-                program.restoreState();
+                program.restoreEmitState(saved);
                 (_a = buildErrors(state, projectPath, program, config, declDiagnostics, BuildResultFlags.DeclarationEmitErrors, "Declaration file"), buildResult = _a.buildResult, step = _a.step);
                 return {
                     emitSkipped: true,
@@ -125130,37 +125368,44 @@ var ts;
             // Actual Emit
             var host = state.host, compilerHost = state.compilerHost;
             var resultFlags = BuildResultFlags.DeclarationOutputUnchanged;
-            var newestDeclarationFileContentChangedTime = minimumDate;
-            var anyDtsChanged = false;
+            var existingBuildInfo = ((_d = state.buildInfoCache.get(projectPath)) === null || _d === void 0 ? void 0 : _d.buildInfo) || undefined;
             var emitterDiagnostics = ts.createDiagnosticCollection();
             var emittedOutputs = new ts.Map();
+            var options = program.getCompilerOptions();
+            var isIncremental = ts.isIncrementalCompilation(options);
+            var outputTimeStampMap;
+            var now;
             outputFiles.forEach(function (_a) {
-                var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark;
-                var priorChangeTime;
-                if (!anyDtsChanged && ts.isDeclarationFileName(name)) {
-                    // Check for unchanged .d.ts files
-                    if (host.fileExists(name) && state.readFileWithCache(name) === text) {
-                        priorChangeTime = host.getModifiedTime(name);
-                    }
-                    else {
+                var _b, _c;
+                var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark, buildInfo = _a.buildInfo;
+                var path = toPath(state, name);
+                emittedOutputs.set(toPath(state, name), name);
+                if (buildInfo) {
+                    setBuildInfo(state, buildInfo, projectPath, options);
+                    // Buildinfo has information on when last dts change time
+                    if (((_b = buildInfo.program) === null || _b === void 0 ? void 0 : _b.dtsChangeTime) !== ((_c = existingBuildInfo === null || existingBuildInfo === void 0 ? void 0 : existingBuildInfo.program) === null || _c === void 0 ? void 0 : _c.dtsChangeTime)) {
                         resultFlags &= ~BuildResultFlags.DeclarationOutputUnchanged;
-                        anyDtsChanged = true;
                     }
                 }
-                emittedOutputs.set(toPath(state, name), name);
                 ts.writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
-                if (priorChangeTime !== undefined) {
-                    newestDeclarationFileContentChangedTime = newer(priorChangeTime, newestDeclarationFileContentChangedTime);
+                if (!isIncremental && state.watch) {
+                    (outputTimeStampMap || (outputTimeStampMap = getOutputTimeStampMap(state, projectPath))).set(path, now || (now = getCurrentTime(state.host)));
                 }
             });
-            finishEmit(emitterDiagnostics, emittedOutputs, newestDeclarationFileContentChangedTime, 
-            /*newestDeclarationFileContentChangedTimeIsMaximumDate*/ anyDtsChanged, outputFiles.length ? outputFiles[0].name : ts.getFirstProjectOutput(config, !host.useCaseSensitiveFileNames()), resultFlags);
+            finishEmit(emitterDiagnostics, emittedOutputs, outputFiles.length ? outputFiles[0].name : ts.getFirstProjectOutput(config, !host.useCaseSensitiveFileNames()), resultFlags);
             return emitResult;
         }
         function emitBuildInfo(writeFileCallback, cancellationToken) {
             ts.Debug.assertIsDefined(program);
             ts.Debug.assert(step === BuildStep.EmitBuildInfo);
-            var emitResult = program.emitBuildInfo(writeFileCallback, cancellationToken);
+            var emitResult = program.emitBuildInfo(function (name, text, writeByteOrderMark, onError, sourceFiles, data) {
+                if (data === null || data === void 0 ? void 0 : data.buildInfo)
+                    setBuildInfo(state, data.buildInfo, projectPath, program.getCompilerOptions());
+                if (writeFileCallback)
+                    writeFileCallback(name, text, writeByteOrderMark, onError, sourceFiles, data);
+                else
+                    state.compilerHost.writeFile(name, text, writeByteOrderMark, onError, sourceFiles, data);
+            }, cancellationToken);
             if (emitResult.diagnostics.length) {
                 reportErrors(state, emitResult.diagnostics);
                 state.diagnostics.set(projectPath, __spreadArray(__spreadArray([], state.diagnostics.get(projectPath), true), emitResult.diagnostics, true));
@@ -125173,7 +125418,7 @@ var ts;
             step = BuildStep.QueueReferencingProjects;
             return emitResult;
         }
-        function finishEmit(emitterDiagnostics, emittedOutputs, priorNewestUpdateTime, newestDeclarationFileContentChangedTimeIsMaximumDate, oldestOutputFileName, resultFlags) {
+        function finishEmit(emitterDiagnostics, emittedOutputs, oldestOutputFileName, resultFlags) {
             var _a;
             var emitDiagnostics = emitterDiagnostics.getDiagnostics();
             if (emitDiagnostics.length) {
@@ -125184,13 +125429,11 @@ var ts;
                 emittedOutputs.forEach(function (name) { return listEmittedFile(state, config, name); });
             }
             // Update time stamps for rest of the outputs
-            var newestDeclarationFileContentChangedTime = updateOutputTimestampsWorker(state, config, priorNewestUpdateTime, ts.Diagnostics.Updating_unchanged_output_timestamps_of_project_0, emittedOutputs);
+            updateOutputTimestampsWorker(state, config, projectPath, ts.Diagnostics.Updating_unchanged_output_timestamps_of_project_0, emittedOutputs);
             state.diagnostics.delete(projectPath);
             state.projectStatus.set(projectPath, {
                 type: ts.UpToDateStatusType.UpToDate,
-                newestDeclarationFileContentChangedTime: newestDeclarationFileContentChangedTimeIsMaximumDate ?
-                    maximumDate :
-                    newestDeclarationFileContentChangedTime,
+                newestDeclarationFileContentChangedTime: getDtsChangeTime(state, config.options, projectPath),
                 oldestOutputFileName: oldestOutputFileName
             });
             afterProgramDone(state, program, config);
@@ -125225,13 +125468,21 @@ var ts;
             ts.Debug.assert(!!outputFiles.length);
             var emitterDiagnostics = ts.createDiagnosticCollection();
             var emittedOutputs = new ts.Map();
+            var resultFlags = BuildResultFlags.DeclarationOutputUnchanged;
+            var existingBuildInfo = state.buildInfoCache.get(projectPath).buildInfo;
             outputFiles.forEach(function (_a) {
-                var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark;
+                var _b, _c;
+                var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark, buildInfo = _a.buildInfo;
                 emittedOutputs.set(toPath(state, name), name);
+                if (buildInfo) {
+                    setBuildInfo(state, buildInfo, projectPath, config.options);
+                    if (((_b = buildInfo.program) === null || _b === void 0 ? void 0 : _b.dtsChangeTime) !== ((_c = existingBuildInfo.program) === null || _c === void 0 ? void 0 : _c.dtsChangeTime)) {
+                        resultFlags &= ~BuildResultFlags.DeclarationOutputUnchanged;
+                    }
+                }
                 ts.writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
             });
-            var emitDiagnostics = finishEmit(emitterDiagnostics, emittedOutputs, minimumDate, 
-            /*newestDeclarationFileContentChangedTimeIsMaximumDate*/ false, outputFiles[0].name, BuildResultFlags.DeclarationOutputUnchanged);
+            var emitDiagnostics = finishEmit(emitterDiagnostics, emittedOutputs, outputFiles[0].name, resultFlags);
             return { emitSkipped: false, diagnostics: emitDiagnostics };
         }
         function executeSteps(till, cancellationToken, writeFile, customTransformers) {
@@ -125330,7 +125581,7 @@ var ts;
                     }
                     continue;
                 }
-                if (status.type === ts.UpToDateStatusType.UpToDateWithUpstreamTypes) {
+                if (status.type === ts.UpToDateStatusType.UpToDateWithUpstreamTypes || status.type === ts.UpToDateStatusType.UpToDateWithInputFileText) {
                     reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                     return {
                         kind: InvalidatedProjectKind.UpdateOutputFileStamps,
@@ -125415,7 +125666,8 @@ var ts;
         state.projectCompilerOptions = state.baseCompilerOptions;
     }
     function buildErrors(state, resolvedPath, program, config, diagnostics, buildResult, errorType) {
-        var canEmitBuildInfo = !(buildResult & BuildResultFlags.SyntaxErrors) && program && !ts.outFile(program.getCompilerOptions());
+        // Since buildinfo has changeset and diagnostics when doing multi file emit, only --out cannot emit buildinfo if it has errors
+        var canEmitBuildInfo = program && !ts.outFile(program.getCompilerOptions());
         reportAndStoreErrors(state, resolvedPath, diagnostics);
         state.projectStatus.set(resolvedPath, { type: ts.UpToDateStatusType.Unbuildable, reason: errorType + " errors" });
         if (canEmitBuildInfo)
@@ -125423,9 +125675,99 @@ var ts;
         afterProgramDone(state, program, config);
         return { buildResult: buildResult, step: BuildStep.QueueReferencingProjects };
     }
+    function isFileWatcherWithModifiedTime(value) {
+        return !!value.watcher;
+    }
+    function getModifiedTime(state, fileName) {
+        var path = toPath(state, fileName);
+        var existing = state.filesWatched.get(path);
+        if (state.watch && !!existing) {
+            if (!isFileWatcherWithModifiedTime(existing))
+                return existing;
+            if (existing.modifiedTime)
+                return existing.modifiedTime;
+        }
+        // In watch mode we store the modified times in the cache
+        // This is either Date | FileWatcherWithModifiedTime because we query modified times first and
+        // then after complete compilation of the project, watch the files so we dont want to loose these modified times.
+        var result = ts.getModifiedTime(state.host, fileName);
+        if (state.watch) {
+            if (existing)
+                existing.modifiedTime = result;
+            else
+                state.filesWatched.set(path, result);
+        }
+        return result;
+    }
+    function watchFile(state, file, callback, pollingInterval, options, watchType, project) {
+        var path = toPath(state, file);
+        var existing = state.filesWatched.get(path);
+        if (existing && isFileWatcherWithModifiedTime(existing)) {
+            existing.callbacks.push(callback);
+        }
+        else {
+            var watcher = state.watchFile(file, function (fileName, eventKind, modifiedTime) {
+                var existing = ts.Debug.checkDefined(state.filesWatched.get(path));
+                ts.Debug.assert(isFileWatcherWithModifiedTime(existing));
+                existing.modifiedTime = modifiedTime;
+                existing.callbacks.forEach(function (cb) { return cb(fileName, eventKind, modifiedTime); });
+            }, pollingInterval, options, watchType, project);
+            state.filesWatched.set(path, { callbacks: [callback], watcher: watcher, modifiedTime: existing });
+        }
+        return {
+            close: function () {
+                var existing = ts.Debug.checkDefined(state.filesWatched.get(path));
+                ts.Debug.assert(isFileWatcherWithModifiedTime(existing));
+                if (existing.callbacks.length === 1) {
+                    state.filesWatched.delete(path);
+                    ts.closeFileWatcherOf(existing);
+                }
+                else {
+                    ts.unorderedRemoveItem(existing.callbacks, callback);
+                }
+            }
+        };
+    }
+    function getOutputTimeStampMap(state, resolvedConfigFilePath) {
+        // Output timestamps are stored only in watch mode
+        if (!state.watch)
+            return undefined;
+        var result = state.outputTimeStamps.get(resolvedConfigFilePath);
+        if (!result)
+            state.outputTimeStamps.set(resolvedConfigFilePath, result = new ts.Map());
+        return result;
+    }
+    function setBuildInfo(state, buildInfo, resolvedConfigPath, options) {
+        var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(options);
+        var existing = getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath);
+        if (existing) {
+            existing.buildInfo = buildInfo;
+            existing.modifiedTime = getCurrentTime(state.host);
+        }
+        else {
+            state.buildInfoCache.set(resolvedConfigPath, { path: toPath(state, buildInfoPath), buildInfo: buildInfo, modifiedTime: getCurrentTime(state.host) });
+        }
+    }
+    function getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath) {
+        var path = toPath(state, buildInfoPath);
+        var existing = state.buildInfoCache.get(resolvedConfigPath);
+        return (existing === null || existing === void 0 ? void 0 : existing.path) === path ? existing : undefined;
+    }
+    function getBuildInfo(state, buildInfoPath, resolvedConfigPath, modifiedTime) {
+        var path = toPath(state, buildInfoPath);
+        var existing = state.buildInfoCache.get(resolvedConfigPath);
+        if (existing !== undefined && existing.path === path) {
+            return existing.buildInfo || undefined;
+        }
+        var value = state.readFileWithCache(buildInfoPath);
+        var buildInfo = value ? ts.getBuildInfo(value) : undefined;
+        ts.Debug.assert(modifiedTime || !buildInfo);
+        state.buildInfoCache.set(resolvedConfigPath, { path: path, buildInfo: buildInfo || false, modifiedTime: modifiedTime || ts.missingFileModifiedTime });
+        return buildInfo;
+    }
     function checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName) {
         // Check tsconfig time
-        var tsconfigTime = ts.getModifiedTime(state.host, configFile);
+        var tsconfigTime = getModifiedTime(state, configFile);
         if (oldestOutputFileTime < tsconfigTime) {
             return {
                 type: ts.UpToDateStatusType.OutOfDateWithSelf,
@@ -125435,88 +125777,24 @@ var ts;
         }
     }
     function getUpToDateStatusWorker(state, project, resolvedPath) {
-        var force = !!state.options.force;
-        var newestInputFileName = undefined;
-        var newestInputFileTime = minimumDate;
-        var host = state.host;
-        // Get timestamps of input files
-        for (var _i = 0, _a = project.fileNames; _i < _a.length; _i++) {
-            var inputFile = _a[_i];
-            if (!host.fileExists(inputFile)) {
-                return {
-                    type: ts.UpToDateStatusType.Unbuildable,
-                    reason: inputFile + " does not exist"
-                };
-            }
-            if (!force) {
-                var inputTime = ts.getModifiedTime(host, inputFile);
-                if (inputTime > newestInputFileTime) {
-                    newestInputFileName = inputFile;
-                    newestInputFileTime = inputTime;
-                }
-            }
-        }
+        var _a, _b, _c;
         // Container if no files are specified in the project
         if (!project.fileNames.length && !ts.canJsonReportNoInputFiles(project.raw)) {
             return {
                 type: ts.UpToDateStatusType.ContainerOnly
             };
         }
-        // Collect the expected outputs of this project
-        var outputs = ts.getAllProjectOutputs(project, !host.useCaseSensitiveFileNames());
-        // Now see if all outputs are newer than the newest input
-        var oldestOutputFileName = "(none)";
-        var oldestOutputFileTime = maximumDate;
-        var newestOutputFileName = "(none)";
-        var newestOutputFileTime = minimumDate;
-        var missingOutputFileName;
-        var newestDeclarationFileContentChangedTime = minimumDate;
-        var isOutOfDateWithInputs = false;
-        if (!force) {
-            for (var _b = 0, outputs_1 = outputs; _b < outputs_1.length; _b++) {
-                var output = outputs_1[_b];
-                // Output is missing; can stop checking
-                // Don't immediately return because we can still be upstream-blocked, which is a higher-priority status
-                if (!host.fileExists(output)) {
-                    missingOutputFileName = output;
-                    break;
-                }
-                var outputTime = ts.getModifiedTime(host, output);
-                if (outputTime < oldestOutputFileTime) {
-                    oldestOutputFileTime = outputTime;
-                    oldestOutputFileName = output;
-                }
-                // If an output is older than the newest input, we can stop checking
-                // Don't immediately return because we can still be upstream-blocked, which is a higher-priority status
-                if (outputTime < newestInputFileTime) {
-                    isOutOfDateWithInputs = true;
-                    break;
-                }
-                if (outputTime > newestOutputFileTime) {
-                    newestOutputFileTime = outputTime;
-                    newestOutputFileName = output;
-                }
-                // Keep track of when the most recent time a .d.ts file was changed.
-                // In addition to file timestamps, we also keep track of when a .d.ts file
-                // had its file touched but not had its contents changed - this allows us
-                // to skip a downstream typecheck
-                if (ts.isDeclarationFileName(output)) {
-                    var outputModifiedTime = ts.getModifiedTime(host, output);
-                    newestDeclarationFileContentChangedTime = newer(newestDeclarationFileContentChangedTime, outputModifiedTime);
-                }
-            }
-        }
-        var pseudoUpToDate = false;
-        var usesPrepend = false;
-        var upstreamChangedProject;
+        // Fast check to see if reference projects are upto date and error free
+        var referenceStatuses;
+        var force = !!state.options.force;
         if (project.projectReferences) {
             state.projectStatus.set(resolvedPath, { type: ts.UpToDateStatusType.ComputingUpstream });
-            for (var _c = 0, _d = project.projectReferences; _c < _d.length; _c++) {
-                var ref = _d[_c];
-                usesPrepend = usesPrepend || !!(ref.prepend);
+            for (var _i = 0, _d = project.projectReferences; _i < _d.length; _i++) {
+                var ref = _d[_i];
                 var resolvedRef = ts.resolveProjectReferencePath(ref);
                 var resolvedRefPath = toResolvedConfigFilePath(state, resolvedRef);
-                var refStatus = getUpToDateStatus(state, parseConfigFile(state, resolvedRef, resolvedRefPath), resolvedRefPath);
+                var resolvedConfig = parseConfigFile(state, resolvedRef, resolvedRefPath);
+                var refStatus = getUpToDateStatus(state, resolvedConfig, resolvedRefPath);
                 // Its a circular reference ignore the status of this project
                 if (refStatus.type === ts.UpToDateStatusType.ComputingUpstream ||
                     refStatus.type === ts.UpToDateStatusType.ContainerOnly) { // Container only ignore this project
@@ -125538,75 +125816,194 @@ var ts;
                         upstreamProjectName: ref.path
                     };
                 }
-                // Check oldest output file name only if there is no missing output file name
-                // (a check we will have skipped if this is a forced build)
-                if (!force && !missingOutputFileName) {
-                    // If the upstream project's newest file is older than our oldest output, we
-                    // can't be out of date because of it
-                    if (refStatus.newestInputFileTime && refStatus.newestInputFileTime <= oldestOutputFileTime) {
-                        continue;
-                    }
-                    // If the upstream project has only change .d.ts files, and we've built
-                    // *after* those files, then we're "psuedo up to date" and eligible for a fast rebuild
-                    if (refStatus.newestDeclarationFileContentChangedTime && refStatus.newestDeclarationFileContentChangedTime <= oldestOutputFileTime) {
-                        pseudoUpToDate = true;
-                        upstreamChangedProject = ref.path;
-                        continue;
-                    }
-                    // We have an output older than an upstream output - we are out of date
-                    ts.Debug.assert(oldestOutputFileName !== undefined, "Should have an oldest output filename here");
+                if (!force)
+                    (referenceStatuses || (referenceStatuses = [])).push({ ref: ref, refStatus: refStatus, resolvedRefPath: resolvedRefPath, resolvedConfig: resolvedConfig });
+            }
+        }
+        if (force)
+            return { type: ts.UpToDateStatusType.ForceBuild };
+        // Check buildinfo first
+        var host = state.host;
+        var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(project.options);
+        var oldestOutputFileName;
+        var oldestOutputFileTime = maximumDate;
+        var buildInfoTime;
+        var buildInfoProgram;
+        var buildInfoVersionMap;
+        var newestDeclarationFileContentChangedTime;
+        if (buildInfoPath) {
+            var buildInfoCacheEntry_1 = getBuildInfoCacheEntry(state, buildInfoPath, resolvedPath);
+            buildInfoTime = (buildInfoCacheEntry_1 === null || buildInfoCacheEntry_1 === void 0 ? void 0 : buildInfoCacheEntry_1.modifiedTime) || ts.getModifiedTime(host, buildInfoPath);
+            if (buildInfoTime === ts.missingFileModifiedTime) {
+                if (!buildInfoCacheEntry_1) {
+                    state.buildInfoCache.set(resolvedPath, {
+                        path: toPath(state, buildInfoPath),
+                        buildInfo: false,
+                        modifiedTime: buildInfoTime
+                    });
+                }
+                return {
+                    type: ts.UpToDateStatusType.OutputMissing,
+                    missingOutputFileName: buildInfoPath
+                };
+            }
+            var buildInfo = ts.Debug.checkDefined(getBuildInfo(state, buildInfoPath, resolvedPath, buildInfoTime));
+            if ((buildInfo.bundle || buildInfo.program) && buildInfo.version !== ts.version) {
+                return {
+                    type: ts.UpToDateStatusType.TsVersionOutputOfDate,
+                    version: buildInfo.version
+                };
+            }
+            if (buildInfo.program) {
+                // If there are pending changes that are not emitted, project is out of date
+                if (((_a = buildInfo.program.changeFileSet) === null || _a === void 0 ? void 0 : _a.length) ||
+                    (!project.options.noEmit && ((_b = buildInfo.program.affectedFilesPendingEmit) === null || _b === void 0 ? void 0 : _b.length))) {
                     return {
-                        type: ts.UpToDateStatusType.OutOfDateWithUpstream,
-                        outOfDateOutputFileName: oldestOutputFileName,
-                        newerProjectName: ref.path
+                        type: ts.UpToDateStatusType.OutOfDateBuildInfo,
+                        buildInfoFile: buildInfoPath
                     };
                 }
+                buildInfoProgram = buildInfo.program;
             }
+            oldestOutputFileTime = buildInfoTime;
+            oldestOutputFileName = buildInfoPath;
+            // Get the last dtsChange time from build info
+            newestDeclarationFileContentChangedTime = ((_c = buildInfo.program) === null || _c === void 0 ? void 0 : _c.dtsChangeTime) ? new Date(buildInfo.program.dtsChangeTime) : undefined;
         }
-        if (missingOutputFileName !== undefined) {
-            return {
-                type: ts.UpToDateStatusType.OutputMissing,
-                missingOutputFileName: missingOutputFileName
-            };
+        // Check input files
+        var newestInputFileName = undefined;
+        var newestInputFileTime = minimumDate;
+        /** True if input file has changed timestamp but text is not changed, we can then do only timestamp updates on output to make it look up-to-date later */
+        var pseudoInputUpToDate = false;
+        // Get timestamps of input files
+        for (var _e = 0, _f = project.fileNames; _e < _f.length; _e++) {
+            var inputFile = _f[_e];
+            var inputTime = getModifiedTime(state, inputFile);
+            if (inputTime === ts.missingFileModifiedTime) {
+                return {
+                    type: ts.UpToDateStatusType.Unbuildable,
+                    reason: inputFile + " does not exist"
+                };
+            }
+            // If an buildInfo is older than the newest input, we can stop checking
+            if (buildInfoTime && buildInfoTime < inputTime) {
+                var version_3 = void 0;
+                var currentVersion = void 0;
+                if (buildInfoProgram) {
+                    // Read files and see if they are same, read is anyways cached
+                    if (!buildInfoVersionMap)
+                        buildInfoVersionMap = ts.getBuildInfoFileVersionMap(buildInfoProgram, buildInfoPath, host);
+                    version_3 = buildInfoVersionMap.get(toPath(state, inputFile));
+                    var text = version_3 ? state.readFileWithCache(inputFile) : undefined;
+                    currentVersion = text && (host.createHash || ts.generateDjb2Hash)(text);
+                    if (version_3 && version_3 === currentVersion)
+                        pseudoInputUpToDate = true;
+                }
+                if (!version_3 || version_3 !== currentVersion) {
+                    return {
+                        type: ts.UpToDateStatusType.OutOfDateWithSelf,
+                        outOfDateOutputFileName: buildInfoPath,
+                        newerInputFileName: inputFile
+                    };
+                }
+            }
+            if (inputTime > newestInputFileTime) {
+                newestInputFileName = inputFile;
+                newestInputFileTime = inputTime;
+            }
         }
-        if (isOutOfDateWithInputs) {
-            return {
-                type: ts.UpToDateStatusType.OutOfDateWithSelf,
-                outOfDateOutputFileName: oldestOutputFileName,
-                newerInputFileName: newestInputFileName
-            };
+        // Now see if all outputs are newer than the newest input
+        // Dont check output timestamps if we have buildinfo telling us output is uptodate
+        if (!buildInfoPath) {
+            // Collect the expected outputs of this project
+            var outputs = ts.getAllProjectOutputs(project, !host.useCaseSensitiveFileNames());
+            var outputTimeStampMap = getOutputTimeStampMap(state, resolvedPath);
+            for (var _g = 0, outputs_1 = outputs; _g < outputs_1.length; _g++) {
+                var output = outputs_1[_g];
+                var path = toPath(state, output);
+                // Output is missing; can stop checking
+                var outputTime = outputTimeStampMap === null || outputTimeStampMap === void 0 ? void 0 : outputTimeStampMap.get(path);
+                if (!outputTime) {
+                    outputTime = ts.getModifiedTime(state.host, output);
+                    outputTimeStampMap === null || outputTimeStampMap === void 0 ? void 0 : outputTimeStampMap.set(path, outputTime);
+                }
+                if (outputTime === ts.missingFileModifiedTime) {
+                    return {
+                        type: ts.UpToDateStatusType.OutputMissing,
+                        missingOutputFileName: output
+                    };
+                }
+                // If an output is older than the newest input, we can stop checking
+                if (outputTime < newestInputFileTime) {
+                    return {
+                        type: ts.UpToDateStatusType.OutOfDateWithSelf,
+                        outOfDateOutputFileName: output,
+                        newerInputFileName: newestInputFileName
+                    };
+                }
+                // No need to get newestDeclarationFileContentChangedTime since thats needed only for composite projects
+                // And composite projects are the only ones that can be referenced
+                if (outputTime < oldestOutputFileTime) {
+                    oldestOutputFileTime = outputTime;
+                    oldestOutputFileName = output;
+                }
+            }
         }
-        else {
-            // Check tsconfig time
-            var configStatus = checkConfigFileUpToDateStatus(state, project.options.configFilePath, oldestOutputFileTime, oldestOutputFileName);
-            if (configStatus)
-                return configStatus;
-            // Check extended config time
-            var extendedConfigStatus = ts.forEach(project.options.configFile.extendedSourceFiles || ts.emptyArray, function (configFile) { return checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName); });
-            if (extendedConfigStatus)
-                return extendedConfigStatus;
-            // Check package file time
-            var dependentPackageFileStatus = ts.forEach(state.lastCachedPackageJsonLookups.get(resolvedPath) || ts.emptyArray, function (_a) {
-                var path = _a[0];
-                return checkConfigFileUpToDateStatus(state, path, oldestOutputFileTime, oldestOutputFileName);
-            });
-            if (dependentPackageFileStatus)
-                return dependentPackageFileStatus;
-        }
-        if (!force && !state.buildInfoChecked.has(resolvedPath)) {
-            state.buildInfoChecked.set(resolvedPath, true);
-            var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(project.options);
-            if (buildInfoPath) {
-                var value = state.readFileWithCache(buildInfoPath);
-                var buildInfo = value && ts.getBuildInfo(value);
-                if (buildInfo && (buildInfo.bundle || buildInfo.program) && buildInfo.version !== ts.version) {
+        var seenRefs = buildInfoPath ? new ts.Set() : undefined;
+        var buildInfoCacheEntry = state.buildInfoCache.get(resolvedPath);
+        seenRefs === null || seenRefs === void 0 ? void 0 : seenRefs.add(resolvedPath);
+        /** Inputs are up-to-date, just need either timestamp update or bundle prepend manipulation to make it look up-to-date */
+        var pseudoUpToDate = false;
+        var usesPrepend = false;
+        var upstreamChangedProject;
+        if (referenceStatuses) {
+            for (var _h = 0, referenceStatuses_1 = referenceStatuses; _h < referenceStatuses_1.length; _h++) {
+                var _j = referenceStatuses_1[_h], ref = _j.ref, refStatus = _j.refStatus, resolvedConfig = _j.resolvedConfig, resolvedRefPath = _j.resolvedRefPath;
+                usesPrepend = usesPrepend || !!(ref.prepend);
+                // If the upstream project's newest file is older than our oldest output, we
+                // can't be out of date because of it
+                if (refStatus.newestInputFileTime && refStatus.newestInputFileTime <= oldestOutputFileTime) {
+                    continue;
+                }
+                // Check if tsbuildinfo path is shared, then we need to rebuild
+                if (buildInfoCacheEntry && hasSameBuildInfo(state, buildInfoCacheEntry, seenRefs, resolvedConfig, resolvedRefPath)) {
                     return {
-                        type: ts.UpToDateStatusType.TsVersionOutputOfDate,
-                        version: buildInfo.version
+                        type: ts.UpToDateStatusType.OutOfDateWithUpstream,
+                        outOfDateOutputFileName: buildInfoPath,
+                        newerProjectName: ref.path
                     };
                 }
+                // If the upstream project has only change .d.ts files, and we've built
+                // *after* those files, then we're "psuedo up to date" and eligible for a fast rebuild
+                if (refStatus.newestDeclarationFileContentChangedTime && refStatus.newestDeclarationFileContentChangedTime <= oldestOutputFileTime) {
+                    pseudoUpToDate = true;
+                    upstreamChangedProject = ref.path;
+                    continue;
+                }
+                // We have an output older than an upstream output - we are out of date
+                ts.Debug.assert(oldestOutputFileName !== undefined, "Should have an oldest output filename here");
+                return {
+                    type: ts.UpToDateStatusType.OutOfDateWithUpstream,
+                    outOfDateOutputFileName: oldestOutputFileName,
+                    newerProjectName: ref.path
+                };
             }
         }
+        // Check tsconfig time
+        var configStatus = checkConfigFileUpToDateStatus(state, project.options.configFilePath, oldestOutputFileTime, oldestOutputFileName);
+        if (configStatus)
+            return configStatus;
+        // Check extended config time
+        var extendedConfigStatus = ts.forEach(project.options.configFile.extendedSourceFiles || ts.emptyArray, function (configFile) { return checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName); });
+        if (extendedConfigStatus)
+            return extendedConfigStatus;
+        // Check package file time
+        var dependentPackageFileStatus = ts.forEach(state.lastCachedPackageJsonLookups.get(resolvedPath) || ts.emptyArray, function (_a) {
+            var path = _a[0];
+            return checkConfigFileUpToDateStatus(state, path, oldestOutputFileTime, oldestOutputFileName);
+        });
+        if (dependentPackageFileStatus)
+            return dependentPackageFileStatus;
         if (usesPrepend && pseudoUpToDate) {
             return {
                 type: ts.UpToDateStatusType.OutOfDateWithPrepend,
@@ -125616,15 +126013,37 @@ var ts;
         }
         // Up to date
         return {
-            type: pseudoUpToDate ? ts.UpToDateStatusType.UpToDateWithUpstreamTypes : ts.UpToDateStatusType.UpToDate,
+            type: pseudoUpToDate ?
+                ts.UpToDateStatusType.UpToDateWithUpstreamTypes :
+                pseudoInputUpToDate ?
+                    ts.UpToDateStatusType.UpToDateWithInputFileText :
+                    ts.UpToDateStatusType.UpToDate,
             newestDeclarationFileContentChangedTime: newestDeclarationFileContentChangedTime,
             newestInputFileTime: newestInputFileTime,
-            newestOutputFileTime: newestOutputFileTime,
             newestInputFileName: newestInputFileName,
-            newestOutputFileName: newestOutputFileName,
             oldestOutputFileName: oldestOutputFileName
         };
     }
+    function hasSameBuildInfo(state, buildInfoCacheEntry, seenRefs, resolvedConfig, resolvedRefPath) {
+        if (seenRefs.has(resolvedRefPath))
+            return false;
+        seenRefs.add(resolvedRefPath);
+        var refBuildInfo = state.buildInfoCache.get(resolvedRefPath);
+        if (refBuildInfo.path === buildInfoCacheEntry.path)
+            return true;
+        if (resolvedConfig.projectReferences) {
+            // Check references
+            for (var _i = 0, _a = resolvedConfig.projectReferences; _i < _a.length; _i++) {
+                var ref = _a[_i];
+                var resolvedRef = ts.resolveProjectReferencePath(ref);
+                var resolvedRefPath_1 = toResolvedConfigFilePath(state, resolvedRef);
+                var resolvedConfig_1 = parseConfigFile(state, resolvedRef, resolvedRefPath_1);
+                if (hasSameBuildInfo(state, buildInfoCacheEntry, seenRefs, resolvedConfig_1, resolvedRefPath_1))
+                    return true;
+            }
+        }
+        return false;
+    }
     function getUpToDateStatus(state, project, resolvedPath) {
         if (project === undefined) {
             return { type: ts.UpToDateStatusType.Unbuildable, reason: "File deleted mid-build" };
@@ -125637,39 +126056,68 @@ var ts;
         state.projectStatus.set(resolvedPath, actual);
         return actual;
     }
-    function updateOutputTimestampsWorker(state, proj, priorNewestUpdateTime, verboseMessage, skipOutputs) {
+    function updateOutputTimestampsWorker(state, proj, projectPath, verboseMessage, skipOutputs) {
         if (proj.options.noEmit)
-            return priorNewestUpdateTime;
+            return;
+        var now;
+        var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(proj.options);
+        if (buildInfoPath) {
+            // For incremental projects, only buildinfo needs to be upto date with timestamp check
+            // as we dont check output files for up-to-date ness
+            if (!(skipOutputs === null || skipOutputs === void 0 ? void 0 : skipOutputs.has(toPath(state, buildInfoPath)))) {
+                if (!!state.options.verbose)
+                    reportStatus(state, verboseMessage, proj.options.configFilePath);
+                state.host.setModifiedTime(buildInfoPath, now = getCurrentTime(state.host));
+                getBuildInfoCacheEntry(state, buildInfoPath, projectPath).modifiedTime = now;
+            }
+            state.outputTimeStamps.delete(projectPath);
+            return;
+        }
         var host = state.host;
         var outputs = ts.getAllProjectOutputs(proj, !host.useCaseSensitiveFileNames());
+        var outputTimeStampMap = getOutputTimeStampMap(state, projectPath);
+        var modifiedOutputs = outputTimeStampMap ? new ts.Set() : undefined;
         if (!skipOutputs || outputs.length !== skipOutputs.size) {
             var reportVerbose = !!state.options.verbose;
-            var now = host.now ? host.now() : new Date();
             for (var _i = 0, outputs_2 = outputs; _i < outputs_2.length; _i++) {
                 var file = outputs_2[_i];
-                if (skipOutputs && skipOutputs.has(toPath(state, file))) {
+                var path = toPath(state, file);
+                if (skipOutputs === null || skipOutputs === void 0 ? void 0 : skipOutputs.has(path))
                     continue;
-                }
                 if (reportVerbose) {
                     reportVerbose = false;
                     reportStatus(state, verboseMessage, proj.options.configFilePath);
                 }
-                if (ts.isDeclarationFileName(file)) {
-                    priorNewestUpdateTime = newer(priorNewestUpdateTime, ts.getModifiedTime(host, file));
+                host.setModifiedTime(file, now || (now = getCurrentTime(state.host)));
+                // Store output timestamps in a map because non incremental build will need to check them to determine up-to-dateness
+                if (outputTimeStampMap) {
+                    outputTimeStampMap.set(path, now);
+                    modifiedOutputs.add(path);
                 }
-                host.setModifiedTime(file, now);
             }
         }
-        return priorNewestUpdateTime;
+        // Clear out timestamps not in output list any more
+        outputTimeStampMap === null || outputTimeStampMap === void 0 ? void 0 : outputTimeStampMap.forEach(function (_value, key) {
+            if (!(skipOutputs === null || skipOutputs === void 0 ? void 0 : skipOutputs.has(key)) && !modifiedOutputs.has(key))
+                outputTimeStampMap.delete(key);
+        });
+    }
+    function getDtsChangeTime(state, options, resolvedConfigPath) {
+        var _a;
+        if (!options.composite)
+            return undefined;
+        var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(options);
+        var buildInfo = getBuildInfo(state, buildInfoPath, resolvedConfigPath, /*modifiedTime*/ undefined);
+        return ((_a = buildInfo === null || buildInfo === void 0 ? void 0 : buildInfo.program) === null || _a === void 0 ? void 0 : _a.dtsChangeTime) ? new Date(buildInfo.program.dtsChangeTime) : undefined;
     }
     function updateOutputTimestamps(state, proj, resolvedPath) {
         if (state.options.dry) {
             return reportStatus(state, ts.Diagnostics.A_non_dry_build_would_update_timestamps_for_output_of_project_0, proj.options.configFilePath);
         }
-        var priorNewestUpdateTime = updateOutputTimestampsWorker(state, proj, minimumDate, ts.Diagnostics.Updating_output_timestamps_of_project_0);
+        updateOutputTimestampsWorker(state, proj, resolvedPath, ts.Diagnostics.Updating_output_timestamps_of_project_0);
         state.projectStatus.set(resolvedPath, {
             type: ts.UpToDateStatusType.UpToDate,
-            newestDeclarationFileContentChangedTime: priorNewestUpdateTime,
+            newestDeclarationFileContentChangedTime: getDtsChangeTime(state, proj.options, resolvedPath),
             oldestOutputFileName: ts.getFirstProjectOutput(proj, !state.host.useCaseSensitiveFileNames())
         });
     }
@@ -125715,6 +126163,7 @@ var ts;
                                 break;
                             }
                         // falls through
+                        case ts.UpToDateStatusType.UpToDateWithInputFileText:
                         case ts.UpToDateStatusType.UpToDateWithUpstreamTypes:
                         case ts.UpToDateStatusType.OutOfDateWithPrepend:
                             if (!(buildResult & BuildResultFlags.DeclarationOutputUnchanged)) {
@@ -125875,12 +126324,10 @@ var ts;
     function watchConfigFile(state, resolved, resolvedPath, parsed) {
         if (!state.watch || state.allWatchedConfigFiles.has(resolvedPath))
             return;
-        state.allWatchedConfigFiles.set(resolvedPath, state.watchFile(resolved, function () {
-            invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.Full);
-        }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.ConfigFile, resolved));
+        state.allWatchedConfigFiles.set(resolvedPath, watchFile(state, resolved, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.Full); }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.ConfigFile, resolved));
     }
     function watchExtendedConfigFiles(state, resolvedPath, parsed) {
-        ts.updateSharedExtendedConfigFileWatcher(resolvedPath, parsed === null || parsed === void 0 ? void 0 : parsed.options, state.allWatchedExtendedConfigFiles, function (extendedConfigFileName, extendedConfigFilePath) { return state.watchFile(extendedConfigFileName, function () {
+        ts.updateSharedExtendedConfigFileWatcher(resolvedPath, parsed === null || parsed === void 0 ? void 0 : parsed.options, state.allWatchedExtendedConfigFiles, function (extendedConfigFileName, extendedConfigFilePath) { return watchFile(state, extendedConfigFileName, function () {
             var _a;
             return (_a = state.allWatchedExtendedConfigFiles.get(extendedConfigFilePath)) === null || _a === void 0 ? void 0 : _a.projects.forEach(function (projectConfigFilePath) {
                 return invalidateProjectAndScheduleBuilds(state, projectConfigFilePath, ts.ConfigFileProgramReloadLevel.Full);
@@ -125912,7 +126359,7 @@ var ts;
         if (!state.watch)
             return;
         ts.mutateMap(getOrCreateValueMapFromConfigFileMap(state.allWatchedInputFiles, resolvedPath), ts.arrayToMap(parsed.fileNames, function (fileName) { return toPath(state, fileName); }), {
-            createNewValue: function (_path, input) { return state.watchFile(input, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.None); }, ts.PollingInterval.Low, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.SourceFile, resolved); },
+            createNewValue: function (_path, input) { return watchFile(state, input, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.None); }, ts.PollingInterval.Low, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.SourceFile, resolved); },
             onDeleteValue: ts.closeFileWatcher,
         });
     }
@@ -125920,7 +126367,7 @@ var ts;
         if (!state.watch || !state.lastCachedPackageJsonLookups)
             return;
         ts.mutateMap(getOrCreateValueMapFromConfigFileMap(state.allWatchedPackageJsonFiles, resolvedPath), new ts.Map(state.lastCachedPackageJsonLookups.get(resolvedPath)), {
-            createNewValue: function (path, _input) { return state.watchFile(path, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.None); }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.PackageJson, resolved); },
+            createNewValue: function (path, _input) { return watchFile(state, path, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.None); }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.PackageJson, resolved); },
             onDeleteValue: ts.closeFileWatcher,
         });
     }
@@ -126050,19 +126497,18 @@ var ts;
         }
     }
     function reportUpToDateStatus(state, configFileName, status) {
-        if (state.options.force && (status.type === ts.UpToDateStatusType.UpToDate || status.type === ts.UpToDateStatusType.UpToDateWithUpstreamTypes)) {
-            return reportStatus(state, ts.Diagnostics.Project_0_is_being_forcibly_rebuilt, relName(state, configFileName));
-        }
         switch (status.type) {
             case ts.UpToDateStatusType.OutOfDateWithSelf:
-                return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, relName(state, configFileName), relName(state, status.outOfDateOutputFileName), relName(state, status.newerInputFileName));
+                return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_1_is_older_than_input_2, relName(state, configFileName), relName(state, status.outOfDateOutputFileName), relName(state, status.newerInputFileName));
             case ts.UpToDateStatusType.OutOfDateWithUpstream:
-                return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, relName(state, configFileName), relName(state, status.outOfDateOutputFileName), relName(state, status.newerProjectName));
+                return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_1_is_older_than_input_2, relName(state, configFileName), relName(state, status.outOfDateOutputFileName), relName(state, status.newerProjectName));
             case ts.UpToDateStatusType.OutputMissing:
                 return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, relName(state, configFileName), relName(state, status.missingOutputFileName));
+            case ts.UpToDateStatusType.OutOfDateBuildInfo:
+                return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_were_not_emitted, relName(state, configFileName), relName(state, status.buildInfoFile));
             case ts.UpToDateStatusType.UpToDate:
                 if (status.newestInputFileTime !== undefined) {
-                    return reportStatus(state, ts.Diagnostics.Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2, relName(state, configFileName), relName(state, status.newestInputFileName || ""), relName(state, status.oldestOutputFileName || ""));
+                    return reportStatus(state, ts.Diagnostics.Project_0_is_up_to_date_because_newest_input_1_is_older_than_output_2, relName(state, configFileName), relName(state, status.newestInputFileName || ""), relName(state, status.oldestOutputFileName || ""));
                 }
                 // Don't report anything for "up to date because it was already built" -- too verbose
                 break;
@@ -126070,6 +126516,8 @@ var ts;
                 return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed, relName(state, configFileName), relName(state, status.newerProjectName));
             case ts.UpToDateStatusType.UpToDateWithUpstreamTypes:
                 return reportStatus(state, ts.Diagnostics.Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies, relName(state, configFileName));
+            case ts.UpToDateStatusType.UpToDateWithInputFileText:
+                return reportStatus(state, ts.Diagnostics.Project_0_is_up_to_date_but_needs_to_update_timestamps_of_output_files_that_are_older_than_input_files, relName(state, configFileName));
             case ts.UpToDateStatusType.UpstreamOutOfDate:
                 return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date, relName(state, configFileName), relName(state, status.upstreamProjectName));
             case ts.UpToDateStatusType.UpstreamBlocked:
@@ -126080,6 +126528,8 @@ var ts;
                 return reportStatus(state, ts.Diagnostics.Failed_to_parse_file_0_Colon_1, relName(state, configFileName), status.reason);
             case ts.UpToDateStatusType.TsVersionOutputOfDate:
                 return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_current_version_2, relName(state, configFileName), status.version, ts.version);
+            case ts.UpToDateStatusType.ForceBuild:
+                return reportStatus(state, ts.Diagnostics.Project_0_is_being_forcibly_rebuilt, relName(state, configFileName));
             case ts.UpToDateStatusType.ContainerOnly:
             // Don't report status on "solution" projects
             // falls through