@typescript-deploys/pr-build 4.8.0-pr-49157-6 → 4.8.0-pr-48997-18

package/lib/lib.es2020.intl.d.ts

@@ -18,6 +18,7 @@ and limitations under the License.
 /// <reference no-default-lib="true"/>
 
 
+/// <reference lib="es2018.intl" />
 declare namespace Intl {
 
     /**

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.8";
-    ts.version = ts.versionMajorMinor + ".0-insiders.20220518";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220523";
     var NativeCollections;
     (function (NativeCollections) {
         var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -1862,6 +1862,7 @@ var ts;
             startsWith(candidate, prefix) &&
             endsWith(candidate, suffix);
     }
+    ts.isPatternMatch = isPatternMatch;
     function and(f, g) {
         return function (arg) { return f(arg) && g(arg); };
     }
@@ -3854,7 +3855,7 @@ var ts;
     }
     ts.setSysLog = setSysLog;
     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();
@@ -3947,7 +3948,7 @@ var ts;
         }
         function nonSyncUpdateChildWatches(dirName, dirPath, fileName, options) {
             var parentWatcher = cache.get(dirPath);
-            if (parentWatcher && directoryExists(dirName)) {
+            if (parentWatcher && fileSystemEntryExists(dirName, 1)) {
                 scheduleUpdateChildWatches(dirName, dirPath, fileName, options);
                 return;
             }
@@ -4015,7 +4016,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) ? ts.mapDefined(getAccessibleSortedChildDirectories(parentDir), function (child) {
                 var childFullName = ts.getNormalizedAbsolutePath(child, parentDir);
                 return !isIgnoredPath(childFullName, options) && filePathComparer(childFullName, ts.normalizePath(realpath(childFullName))) === 0 ? childFullName : undefined;
             }) : ts.emptyArray, parentWatcher.childWatches, function (child, childWatcher) { return filePathComparer(child, childWatcher.dirName); }, createAndAddChildDirectoryWatcher, ts.closeFileWatcher, addChildDirectoryWatcher);
@@ -4046,10 +4047,10 @@ var ts;
         return function (_fileName, eventKind) { return callback(eventKind === FileWatcherEventKind.Changed ? "change" : "rename", ""); };
     }
     ts.createFileWatcherCallback = createFileWatcherCallback;
-    function createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileExists) {
+    function createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileSystemEntryExists) {
         return function (eventName) {
             if (eventName === "rename") {
-                callback(fileName, fileExists(fileName) ? FileWatcherEventKind.Created : FileWatcherEventKind.Deleted);
+                callback(fileName, fileSystemEntryExists(fileName, 0) ? FileWatcherEventKind.Created : FileWatcherEventKind.Deleted);
             }
             else {
                 callback(fileName, FileWatcherEventKind.Changed);
@@ -4071,11 +4072,12 @@ var ts;
         };
     }
     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
@@ -4093,7 +4095,7 @@ var ts;
                 case ts.WatchFileKind.FixedChunkSizePolling:
                     return ensureFixedChunkSizePollingWatchFile()(fileName, callback, undefined, undefined);
                 case ts.WatchFileKind.UseFsEvents:
-                    return fsWatch(fileName, 0, createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileExists), false, pollingInterval, ts.getFallbackOptions(options));
+                    return fsWatch(fileName, 0, createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileSystemEntryExists), false, pollingInterval, ts.getFallbackOptions(options));
                 case ts.WatchFileKind.UseFsEventsOnParentDirectory:
                     if (!nonPollingWatchFile) {
                         nonPollingWatchFile = createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames);
@@ -4146,7 +4148,7 @@ var ts;
                 hostRecursiveDirectoryWatcher = createDirectoryWatcherSupportingRecursive({
                     useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                     getCurrentDirectory: getCurrentDirectory,
-                    directoryExists: directoryExists,
+                    fileSystemEntryExists: fileSystemEntryExists,
                     getAccessibleSortedChildDirectories: getAccessibleSortedChildDirectories,
                     watchDirectory: nonRecursiveWatchDirectory,
                     realpath: realpath,
@@ -4191,6 +4193,86 @@ var ts;
                     };
             }
         }
+        function fsWatch(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) {
+            var lastDirectoryPartWithDirectorySeparator;
+            var lastDirectoryPart;
+            if (inodeWatching) {
+                lastDirectoryPartWithDirectorySeparator = fileOrDirectory.substr(fileOrDirectory.lastIndexOf(ts.directorySeparator));
+                lastDirectoryPart = lastDirectoryPartWithDirectorySeparator.slice(ts.directorySeparator.length);
+            }
+            var watcher = !fileSystemEntryExists(fileOrDirectory, entryKind) ?
+                watchMissingFileSystemEntry() :
+                watchPresentFileSystemEntry();
+            return {
+                close: function () {
+                    watcher.close();
+                    watcher = undefined;
+                }
+            };
+            function updateWatcher(createWatcher) {
+                if (watcher) {
+                    sysLog("sysLog:: " + fileOrDirectory + ":: Changing watcher to " + (createWatcher === watchPresentFileSystemEntry ? "Present" : "Missing") + "FileSystemEntryWatcher");
+                    watcher.close();
+                    watcher = createWatcher();
+                }
+            }
+            function watchPresentFileSystemEntry() {
+                if (hitSystemWatcherLimit) {
+                    sysLog("sysLog:: " + fileOrDirectory + ":: Defaulting to watchFile");
+                    return watchPresentFileSystemEntryWithFsWatchFile();
+                }
+                try {
+                    var presentWatcher = fsWatchWorker(fileOrDirectory, recursive, inodeWatching ?
+                        callbackChangingToMissingFileSystemEntry :
+                        function (eventName, relativeFileName) {
+                            sysLog("sysLog:: watchPresentFileSystemEntry:: " + fileOrDirectory + " " + entryKind + " " + eventName + ":: " + relativeFileName);
+                            callback(eventName, relativeFileName);
+                        });
+                    presentWatcher.on("error", function () {
+                        sysLog("sysLog:: watchPresentFileSystemEntry:: on Error " + fileOrDirectory + " " + entryKind + " rename, \"\"");
+                        callback("rename", "");
+                        updateWatcher(watchMissingFileSystemEntry);
+                    });
+                    return presentWatcher;
+                }
+                catch (e) {
+                    hitSystemWatcherLimit || (hitSystemWatcherLimit = e.code === "ENOSPC");
+                    sysLog("sysLog:: " + fileOrDirectory + ":: Changing to watchFile");
+                    return watchPresentFileSystemEntryWithFsWatchFile();
+                }
+            }
+            function callbackChangingToMissingFileSystemEntry(event, relativeName) {
+                sysLog("sysLog:: callbackChangingToMissingFileSystemEntry:: " + fileOrDirectory + " " + entryKind + " " + event + ":: " + relativeName + " " + inodeWatching + " " + lastDirectoryPart + " " + lastDirectoryPartWithDirectorySeparator);
+                callback(event, relativeName);
+                if (event === "rename" &&
+                    (!relativeName ||
+                        relativeName === lastDirectoryPart ||
+                        (relativeName.lastIndexOf(lastDirectoryPartWithDirectorySeparator) !== -1 && relativeName.lastIndexOf(lastDirectoryPartWithDirectorySeparator) === relativeName.length - lastDirectoryPartWithDirectorySeparator.length))) {
+                    if (inodeWatching) {
+                        updateWatcher(!fileSystemEntryExists(fileOrDirectory, entryKind) ? watchMissingFileSystemEntry : watchPresentFileSystemEntry);
+                    }
+                    else if (!fileSystemEntryExists(fileOrDirectory, entryKind)) {
+                        updateWatcher(watchMissingFileSystemEntry);
+                    }
+                }
+            }
+            function watchPresentFileSystemEntryWithFsWatchFile() {
+                return watchFile(fileOrDirectory, createFileWatcherCallback(function (eventName, relativeFileName) {
+                    sysLog("sysLog:: watchPresentFileSystemEntryWithFsWatchFile:: " + fileOrDirectory + " " + entryKind + " " + eventName + ":: " + relativeFileName);
+                    callback(eventName, relativeFileName);
+                }), fallbackPollingInterval, fallbackOptions);
+            }
+            function watchMissingFileSystemEntry() {
+                return watchFile(fileOrDirectory, function (_fileName, eventKind) {
+                    sysLog("sysLog:: watchMissingFileSystemEntry:: " + fileOrDirectory + " " + entryKind + " " + _fileName + ":: " + eventKind);
+                    if (eventKind === FileWatcherEventKind.Created && fileSystemEntryExists(fileOrDirectory, entryKind)) {
+                        sysLog("sysLog:: watchMissingFileSystemEntry::  Callback :: rename, \"\" and will update the watcher");
+                        callback("rename", "");
+                        updateWatcher(watchPresentFileSystemEntry);
+                    }
+                }, fallbackPollingInterval, fallbackOptions);
+            }
+        }
     }
     ts.createSystemWatchFunctions = createSystemWatchFunctions;
     function patchWriteFileEnsuringDirectory(sys) {
@@ -4232,7 +4314,6 @@ var ts;
             }
             var activeSession;
             var profilePath = "./profile.cpuprofile";
-            var hitSystemWatcherLimit = false;
             var Buffer = require("buffer").Buffer;
             var nodeVersion = getNodeMajorVersion();
             var isNode4OrLater = nodeVersion >= 4;
@@ -4247,18 +4328,19 @@ var ts;
                 getModifiedTime: getModifiedTime,
                 setTimeout: setTimeout,
                 clearTimeout: clearTimeout,
-                fsWatch: fsWatch,
+                fsWatchWorker: fsWatchWorker,
                 useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                 getCurrentDirectory: getCurrentDirectory,
-                fileExists: fileExists,
+                fileSystemEntryExists: fileSystemEntryExists,
                 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),
@@ -4481,76 +4563,9 @@ var ts;
                     callback(fileName, eventKind);
                 }
             }
-            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);
-                }
-                var watcher = !fileSystemEntryExists(fileOrDirectory, entryKind) ?
-                    watchMissingFileSystemEntry() :
-                    watchPresentFileSystemEntry();
-                return {
-                    close: function () {
-                        watcher.close();
-                        watcher = undefined;
-                    }
-                };
-                function invokeCallbackAndUpdateWatcher(createWatcher) {
-                    sysLog("sysLog:: " + fileOrDirectory + ":: Changing watcher to " + (createWatcher === watchPresentFileSystemEntry ? "Present" : "Missing") + "FileSystemEntryWatcher");
-                    callback("rename", "");
-                    if (watcher) {
-                        watcher.close();
-                        watcher = createWatcher();
-                    }
-                }
-                function watchPresentFileSystemEntry() {
-                    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);
-                        presentWatcher.on("error", function () { return invokeCallbackAndUpdateWatcher(watchMissingFileSystemEntry); });
-                        return presentWatcher;
-                    }
-                    catch (e) {
-                        hitSystemWatcherLimit || (hitSystemWatcherLimit = e.code === "ENOSPC");
-                        sysLog("sysLog:: " + fileOrDirectory + ":: Changing to fsWatchFile");
-                        return watchPresentFileSystemEntryWithFsWatchFile();
-                    }
-                }
-                function callbackChangingToMissingFileSystemEntry(event, relativeName) {
-                    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);
-                }
-                function watchPresentFileSystemEntryWithFsWatchFile() {
-                    return watchFile(fileOrDirectory, createFileWatcherCallback(callback), fallbackPollingInterval, fallbackOptions);
-                }
-                function watchMissingFileSystemEntry() {
-                    return watchFile(fileOrDirectory, function (_fileName, eventKind) {
-                        if (eventKind === FileWatcherEventKind.Created && fileSystemEntryExists(fileOrDirectory, entryKind)) {
-                            invokeCallbackAndUpdateWatcher(watchPresentFileSystemEntry);
-                        }
-                    }, fallbackPollingInterval, fallbackOptions);
-                }
+            function fsWatchWorker(fileOrDirectory, recursive, callback) {
+                return _fs.watch(fileOrDirectory, fsSupportsRecursiveFsWatch ?
+                    { persistent: true, recursive: !!recursive } : { persistent: true }, callback);
             }
             function readFileWorker(fileName, _encoding) {
                 var buffer;
@@ -51630,7 +51645,7 @@ var ts;
         function substituteIndexedMappedType(objectType, index) {
             var mapper = createTypeMapper([getTypeParameterFromMappedType(objectType)], [index]);
             var templateMapper = combineTypeMappers(objectType.mapper, mapper);
-            return instantiateType(getTemplateTypeFromMappedType(objectType), templateMapper);
+            return instantiateType(getTemplateTypeFromMappedType(objectType.target || objectType), templateMapper);
         }
         function getIndexedAccessType(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) {
             if (accessFlags === void 0) { accessFlags = 0; }
@@ -95544,7 +95559,7 @@ var ts;
                 originalWriteFile.call.apply(originalWriteFile, __spreadArray([host, fileName, data], rest, false));
             };
         }
-        if (originalDirectoryExists && originalCreateDirectory) {
+        if (originalDirectoryExists) {
             host.directoryExists = function (directory) {
                 var key = toPath(directory);
                 var value = directoryExistsCache.get(key);
@@ -95554,11 +95569,13 @@ var ts;
                 directoryExistsCache.set(key, !!newValue);
                 return newValue;
             };
-            host.createDirectory = function (directory) {
-                var key = toPath(directory);
-                directoryExistsCache.delete(key);
-                originalCreateDirectory.call(host, directory);
-            };
+            if (originalCreateDirectory) {
+                host.createDirectory = function (directory) {
+                    var key = toPath(directory);
+                    directoryExistsCache.delete(key);
+                    originalCreateDirectory.call(host, directory);
+                };
+            }
         }
         return {
             originalReadFile: originalReadFile,
@@ -102739,7 +102756,6 @@ var ts;
             allProjectBuildPending: true,
             needsSummary: true,
             watchAllProjectsPending: watch,
-            currentInvalidatedProject: undefined,
             watch: watch,
             allWatchedWildcardDirectories: new ts.Map(),
             allWatchedInputFiles: new ts.Map(),
@@ -102964,7 +102980,6 @@ var ts;
     })(InvalidatedProjectKind = ts.InvalidatedProjectKind || (ts.InvalidatedProjectKind = {}));
     function doneInvalidatedProject(state, projectPath) {
         state.projectPendingBuild.delete(projectPath);
-        state.currentInvalidatedProject = undefined;
         return state.diagnostics.has(projectPath) ?
             ts.ExitStatus.DiagnosticsPresent_OutputsSkipped :
             ts.ExitStatus.Success;
@@ -103299,16 +103314,11 @@ var ts;
             !!ts.getConfigFileParsingDiagnostics(config).length ||
             !ts.isIncrementalCompilation(config.options);
     }
-    function getNextInvalidatedProject(state, buildOrder, reportQueue) {
+    function getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue) {
         if (!state.projectPendingBuild.size)
             return undefined;
         if (isCircularBuildOrder(buildOrder))
             return undefined;
-        if (state.currentInvalidatedProject) {
-            return ts.arrayIsEqualTo(state.currentInvalidatedProject.buildOrder, buildOrder) ?
-                state.currentInvalidatedProject :
-                undefined;
-        }
         var options = state.options, projectPendingBuild = state.projectPendingBuild;
         for (var projectIndex = 0; projectIndex < buildOrder.length; projectIndex++) {
             var project = buildOrder[projectIndex];
@@ -103340,9 +103350,9 @@ var ts;
                 watchPackageJsonFiles(state, project, projectPath, config);
             }
             var status = getUpToDateStatus(state, config, projectPath);
-            verboseReportProjectStatus(state, project, status);
             if (!options.force) {
                 if (status.type === ts.UpToDateStatusType.UpToDate) {
+                    verboseReportProjectStatus(state, project, status);
                     reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                     projectPendingBuild.delete(projectPath);
                     if (options.dry) {
@@ -103352,10 +103362,18 @@ var ts;
                 }
                 if (status.type === ts.UpToDateStatusType.UpToDateWithUpstreamTypes) {
                     reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
-                    return createUpdateOutputFileStampsProject(state, project, projectPath, config, buildOrder);
+                    return {
+                        kind: InvalidatedProjectKind.UpdateOutputFileStamps,
+                        status: status,
+                        project: project,
+                        projectPath: projectPath,
+                        projectIndex: projectIndex,
+                        config: config
+                    };
                 }
             }
             if (status.type === ts.UpToDateStatusType.UpstreamBlocked) {
+                verboseReportProjectStatus(state, project, status);
                 reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                 projectPendingBuild.delete(projectPath);
                 if (options.verbose) {
@@ -103366,16 +103384,36 @@ var ts;
                 continue;
             }
             if (status.type === ts.UpToDateStatusType.ContainerOnly) {
+                verboseReportProjectStatus(state, project, status);
                 reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config));
                 projectPendingBuild.delete(projectPath);
                 continue;
             }
-            return createBuildOrUpdateInvalidedProject(needsBuild(state, status, config) ?
-                InvalidatedProjectKind.Build :
-                InvalidatedProjectKind.UpdateBundle, state, project, projectPath, projectIndex, config, buildOrder);
+            return {
+                kind: needsBuild(state, status, config) ?
+                    InvalidatedProjectKind.Build :
+                    InvalidatedProjectKind.UpdateBundle,
+                status: status,
+                project: project,
+                projectPath: projectPath,
+                projectIndex: projectIndex,
+                config: config,
+            };
         }
         return undefined;
     }
+    function createInvalidatedProjectWithInfo(state, info, buildOrder) {
+        verboseReportProjectStatus(state, info.project, info.status);
+        return info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps ?
+            createBuildOrUpdateInvalidedProject(info.kind, state, info.project, info.projectPath, info.projectIndex, info.config, buildOrder) :
+            createUpdateOutputFileStampsProject(state, info.project, info.projectPath, info.config, buildOrder);
+    }
+    function getNextInvalidatedProject(state, buildOrder, reportQueue) {
+        var info = getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue);
+        if (!info)
+            return info;
+        return createInvalidatedProjectWithInfo(state, info, buildOrder);
+    }
     function listEmittedFile(_a, proj, file) {
         var write = _a.write;
         if (write && proj.options.listEmittedFiles) {
@@ -103779,9 +103817,9 @@ var ts;
     function invalidateProjectAndScheduleBuilds(state, resolvedPath, reloadLevel) {
         state.reportFileChangeDetected = true;
         invalidateProject(state, resolvedPath, reloadLevel);
-        scheduleBuildInvalidatedProject(state);
+        scheduleBuildInvalidatedProject(state, 250, true);
     }
-    function scheduleBuildInvalidatedProject(state) {
+    function scheduleBuildInvalidatedProject(state, time, changeDetected) {
         var hostWithWatch = state.hostWithWatch;
         if (!hostWithWatch.setTimeout || !hostWithWatch.clearTimeout) {
             return;
@@ -103789,24 +103827,35 @@ var ts;
         if (state.timerToBuildInvalidatedProject) {
             hostWithWatch.clearTimeout(state.timerToBuildInvalidatedProject);
         }
-        state.timerToBuildInvalidatedProject = hostWithWatch.setTimeout(buildNextInvalidatedProject, 250, state);
+        state.timerToBuildInvalidatedProject = hostWithWatch.setTimeout(buildNextInvalidatedProject, time, state, changeDetected);
     }
-    function buildNextInvalidatedProject(state) {
+    function buildNextInvalidatedProject(state, changeDetected) {
         state.timerToBuildInvalidatedProject = undefined;
         if (state.reportFileChangeDetected) {
             state.reportFileChangeDetected = false;
             state.projectErrorsReported.clear();
             reportWatchStatus(state, ts.Diagnostics.File_change_detected_Starting_incremental_compilation);
         }
+        var projectsBuilt = 0;
         var buildOrder = getBuildOrder(state);
         var invalidatedProject = getNextInvalidatedProject(state, buildOrder, false);
         if (invalidatedProject) {
             invalidatedProject.done();
-            if (state.projectPendingBuild.size) {
-                if (state.watch && !state.timerToBuildInvalidatedProject) {
-                    scheduleBuildInvalidatedProject(state);
+            projectsBuilt++;
+            while (state.projectPendingBuild.size) {
+                if (state.timerToBuildInvalidatedProject)
+                    return;
+                var info = getNextInvalidatedProjectCreateInfo(state, buildOrder, false);
+                if (!info)
+                    break;
+                if (info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps && (changeDetected || projectsBuilt === 5)) {
+                    scheduleBuildInvalidatedProject(state, 100, false);
+                    return;
                 }
-                return;
+                var project = createInvalidatedProjectWithInfo(state, info, buildOrder);
+                project.done();
+                if (info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps)
+                    projectsBuilt++;
             }
         }
         disableCache(state);
@@ -103906,8 +103955,6 @@ var ts;
                 return getUpToDateStatus(state, parseConfigFile(state, configFileName, configFilePath), configFilePath);
             },
             invalidateProject: function (configFilePath, reloadLevel) { return invalidateProject(state, configFilePath, reloadLevel || ts.ConfigFileProgramReloadLevel.None); },
-            buildNextInvalidatedProject: function () { return buildNextInvalidatedProject(state); },
-            getAllParsedConfigs: function () { return ts.arrayFrom(ts.mapDefinedIterator(state.configFileCache.values(), function (config) { return isParsedCommandLine(config) ? config : undefined; })); },
             close: function () { return stopWatching(state); },
         };
     }