@typescript-deploys/pr-build 4.8.0-pr-49119-45 → 4.8.0-pr-48997-21

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-insiders.20220524";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220525";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -5090,11 +5090,6 @@ var ts;
         // Flags that require TypeFlags.Union
         /* @internal */
         ObjectFlags[ObjectFlags["ContainsIntersections"] = 16777216] = "ContainsIntersections";
-        /* @internal */
-        ObjectFlags[ObjectFlags["IsUnknownLikeUnionComputed"] = 33554432] = "IsUnknownLikeUnionComputed";
-        /* @internal */
-        ObjectFlags[ObjectFlags["IsUnknownLikeUnion"] = 67108864] = "IsUnknownLikeUnion";
-        /* @internal */
         // Flags that require TypeFlags.Intersection
         /* @internal */
         ObjectFlags[ObjectFlags["IsNeverIntersectionComputed"] = 16777216] = "IsNeverIntersectionComputed";
@@ -6313,7 +6308,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();
@@ -6413,7 +6408,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;
@@ -6486,7 +6481,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
@@ -6532,10 +6527,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 /* File */) ? FileWatcherEventKind.Created : FileWatcherEventKind.Deleted);
             }
             else {
                 // Change
@@ -6563,11 +6558,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
@@ -6585,7 +6581,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, fileSystemEntryExists), 
                     /*recursive*/ false, pollingInterval, ts.getFallbackOptions(options));
                 case ts.WatchFileKind.UseFsEventsOnParentDirectory:
                     if (!nonPollingWatchFile) {
@@ -6646,7 +6642,7 @@ var ts;
                 hostRecursiveDirectoryWatcher = createDirectoryWatcherSupportingRecursive({
                     useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                     getCurrentDirectory: getCurrentDirectory,
-                    directoryExists: directoryExists,
+                    fileSystemEntryExists: fileSystemEntryExists,
                     getAccessibleSortedChildDirectories: getAccessibleSortedChildDirectories,
                     watchDirectory: nonRecursiveWatchDirectory,
                     realpath: realpath,
@@ -6697,6 +6693,114 @@ 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 :
+                        function (eventName, relativeFileName) {
+                            sysLog("sysLog:: watchPresentFileSystemEntry:: " + fileOrDirectory + " " + entryKind + " " + eventName + ":: " + relativeFileName);
+                            callback(eventName, relativeFileName);
+                        });
+                    // Watch the missing file or directory or error
+                    presentWatcher.on("error", function () {
+                        sysLog("sysLog:: watchPresentFileSystemEntry:: on Error " + fileOrDirectory + " " + entryKind + " rename, \"\"");
+                        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) {
+                sysLog("sysLog:: callbackChangingToMissingFileSystemEntry:: " + fileOrDirectory + " " + entryKind + " " + event + ":: " + relativeName + " " + inodeWatching + " " + lastDirectoryPart + " " + lastDirectoryPartWithDirectorySeparator);
+                if (relativeName && ts.endsWith(relativeName, "~")) {
+                    relativeName = relativeName.slice(0, relativeName.length - 1);
+                    sysLog("sysLog:: callbackChangingToMissingFileSystemEntry:: changed the relative name to " + relativeName);
+                }
+                callback(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
+                if (event === "rename" &&
+                    (!relativeName ||
+                        relativeName === lastDirectoryPart ||
+                        ts.endsWith(relativeName, lastDirectoryPartWithDirectorySeparator))) {
+                    if (inodeWatching) {
+                        updateWatcher(!fileSystemEntryExists(fileOrDirectory, entryKind) ? watchMissingFileSystemEntry : watchPresentFileSystemEntry);
+                    }
+                    else if (!fileSystemEntryExists(fileOrDirectory, entryKind)) {
+                        updateWatcher(watchMissingFileSystemEntry);
+                    }
+                }
+            }
+            /**
+             * 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(function (eventName, relativeFileName) {
+                    sysLog("sysLog:: watchPresentFileSystemEntryWithFsWatchFile:: " + fileOrDirectory + " " + entryKind + " " + eventName + ":: " + relativeFileName);
+                    callback(eventName, relativeFileName);
+                }), 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) {
+                    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", "");
+                        // 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;
     /**
@@ -6749,7 +6853,6 @@ var ts;
             }
             var activeSession;
             var profilePath = "./profile.cpuprofile";
-            var hitSystemWatcherLimit = false;
             var Buffer = require("buffer").Buffer;
             var nodeVersion = getNodeMajorVersion();
             var isNode4OrLater = nodeVersion >= 4;
@@ -6764,20 +6867,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),
@@ -7030,107 +7134,11 @@ 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);
-                }
-                /** 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;
@@ -42037,7 +42045,7 @@ var ts;
         }
         if (ts.isImplicitGlob(spec.substring(spec.lastIndexOf(ts.directorySeparator) + 1))) {
             return {
-                key: useCaseSensitiveFileNames ? spec : ts.toFileNameLowerCase(spec),
+                key: ts.removeTrailingDirectorySeparator(useCaseSensitiveFileNames ? spec : ts.toFileNameLowerCase(spec)),
                 flags: 1 /* Recursive */
             };
         }
@@ -48532,7 +48540,6 @@ var ts;
         var emptyTypeLiteralSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* Type */);
         emptyTypeLiteralSymbol.members = ts.createSymbolTable();
         var emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
-        var unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray)]) : unknownType;
         var emptyGenericType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
         emptyGenericType.instantiations = new ts.Map();
         var anyFunctionType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
@@ -58702,7 +58709,7 @@ var ts;
                         }
                     }
                 }
-                else if (t.flags & 469892092 /* DisjointDomains */ || isEmptyAnonymousObjectType(t)) {
+                else if (t.flags & 469892092 /* DisjointDomains */) {
                     hasDisjointDomainType = true;
                 }
             }
@@ -58714,7 +58721,7 @@ var ts;
                     // intersection operation to reduce the union constraints.
                     for (var _a = 0, types_6 = types; _a < types_6.length; _a++) {
                         var t = types_6[_a];
-                        if (t.flags & 469892092 /* DisjointDomains */ || isEmptyAnonymousObjectType(t)) {
+                        if (t.flags & 469892092 /* DisjointDomains */) {
                             constraints = ts.append(constraints, t);
                         }
                     }
@@ -61263,7 +61270,7 @@ var ts;
             }
             return includes;
         }
-        function removeRedundantSupertypes(types, includes) {
+        function removeRedundantPrimitiveTypes(types, includes) {
             var i = types.length;
             while (i > 0) {
                 i--;
@@ -61271,9 +61278,7 @@ var ts;
                 var remove = t.flags & 4 /* String */ && includes & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ||
                     t.flags & 8 /* Number */ && includes & 256 /* NumberLiteral */ ||
                     t.flags & 64 /* BigInt */ && includes & 2048 /* BigIntLiteral */ ||
-                    t.flags & 4096 /* ESSymbol */ && includes & 8192 /* UniqueESSymbol */ ||
-                    t.flags & 16384 /* Void */ && includes & 32768 /* Undefined */ ||
-                    isEmptyAnonymousObjectType(t) && includes & 470302716 /* DefinitelyNonNullable */;
+                    t.flags & 4096 /* ESSymbol */ && includes & 8192 /* UniqueESSymbol */;
                 if (remove) {
                     ts.orderedRemoveItemAt(types, i);
                 }
@@ -61395,7 +61400,7 @@ var ts;
         // a type alias of the form "type List<T> = T & { next: List<T> }" cannot be reduced during its declaration.
         // Also, unlike union types, the order of the constituent types is preserved in order that overload resolution
         // for intersections of types with signatures can be deterministic.
-        function getIntersectionType(types, aliasSymbol, aliasTypeArguments, noSupertypeReduction) {
+        function getIntersectionType(types, aliasSymbol, aliasTypeArguments) {
             var typeMembershipMap = new ts.Map();
             var includes = addTypesToIntersection(typeMembershipMap, 0, types);
             var typeSet = ts.arrayFrom(typeMembershipMap.values());
@@ -61432,11 +61437,11 @@ var ts;
             if (includes & 4 /* String */ && includes & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ||
                 includes & 8 /* Number */ && includes & 256 /* NumberLiteral */ ||
                 includes & 64 /* BigInt */ && includes & 2048 /* BigIntLiteral */ ||
-                includes & 4096 /* ESSymbol */ && includes & 8192 /* UniqueESSymbol */ ||
-                includes & 16384 /* Void */ && includes & 32768 /* Undefined */ ||
-                includes & 16777216 /* IncludesEmptyObject */ && includes & 470302716 /* DefinitelyNonNullable */) {
-                if (!noSupertypeReduction)
-                    removeRedundantSupertypes(typeSet, includes);
+                includes & 4096 /* ESSymbol */ && includes & 8192 /* UniqueESSymbol */) {
+                removeRedundantPrimitiveTypes(typeSet, includes);
+            }
+            if (includes & 16777216 /* IncludesEmptyObject */ && includes & 524288 /* Object */) {
+                ts.orderedRemoveItemAt(typeSet, ts.findIndex(typeSet, isEmptyAnonymousObjectType));
             }
             if (includes & 262144 /* IncludesMissingType */) {
                 typeSet[typeSet.indexOf(undefinedType)] = missingType;
@@ -61475,9 +61480,8 @@ var ts;
                         }
                         var constituents = getCrossProductIntersections(typeSet);
                         // We attach a denormalized origin type when at least one constituent of the cross-product union is an
-                        // intersection (i.e. when the intersection didn't just reduce one or more unions to smaller unions) and
-                        // the denormalized origin has fewer constituents than the union itself.
-                        var origin = ts.some(constituents, function (t) { return !!(t.flags & 2097152 /* Intersection */); }) && getConstituentCountOfTypes(constituents) > getConstituentCountOfTypes(typeSet) ? createOriginUnionOrIntersectionType(2097152 /* Intersection */, typeSet) : undefined;
+                        // intersection (i.e. when the intersection didn't just reduce one or more unions to smaller unions).
+                        var origin = ts.some(constituents, function (t) { return !!(t.flags & 2097152 /* Intersection */); }) ? createOriginUnionOrIntersectionType(2097152 /* Intersection */, typeSet) : undefined;
                         result = getUnionType(constituents, 1 /* Literal */, aliasSymbol, aliasTypeArguments, origin);
                     }
                 }
@@ -61520,21 +61524,11 @@ var ts;
             }
             return intersections;
         }
-        function getConstituentCount(type) {
-            return !(type.flags & 3145728 /* UnionOrIntersection */) || type.aliasSymbol ? 1 :
-                type.flags & 1048576 /* Union */ && type.origin ? getConstituentCount(type.origin) :
-                    getConstituentCountOfTypes(type.types);
-        }
-        function getConstituentCountOfTypes(types) {
-            return ts.reduceLeft(types, function (n, t) { return n + getConstituentCount(t); }, 0);
-        }
         function getTypeFromIntersectionTypeNode(node) {
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
                 var aliasSymbol = getAliasSymbolForTypeNode(node);
-                var types = ts.map(node.types, getTypeFromTypeNode);
-                var noSupertypeReduction = types.length === 2 && !!(types[0].flags & (4 /* String */ | 8 /* Number */ | 64 /* BigInt */)) && types[1] === emptyTypeLiteralType;
-                links.resolvedType = getIntersectionType(types, aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol), noSupertypeReduction);
+                links.resolvedType = getIntersectionType(ts.map(node.types, getTypeFromTypeNode), aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol));
             }
             return links.resolvedType;
         }
@@ -64320,17 +64314,6 @@ var ts;
             return !!(ts.getObjectFlags(type) & 16 /* Anonymous */ && (type.members && isEmptyResolvedType(type) ||
                 type.symbol && type.symbol.flags & 2048 /* TypeLiteral */ && getMembersOfSymbol(type.symbol).size === 0));
         }
-        function isUnknownLikeUnionType(type) {
-            if (strictNullChecks && type.flags & 1048576 /* Union */) {
-                if (!(type.objectFlags & 33554432 /* IsUnknownLikeUnionComputed */)) {
-                    var types = type.types;
-                    type.objectFlags |= 33554432 /* IsUnknownLikeUnionComputed */ | (types.length >= 3 && types[0].flags & 32768 /* Undefined */ &&
-                        types[1].flags & 65536 /* Null */ && ts.some(types, isEmptyAnonymousObjectType) ? 67108864 /* IsUnknownLikeUnion */ : 0);
-                }
-                return !!(type.objectFlags & 67108864 /* IsUnknownLikeUnion */);
-            }
-            return false;
-        }
         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) ||
@@ -64410,7 +64393,7 @@ var ts;
                 return true;
             if (s & 65536 /* Null */ && (!strictNullChecks && !(t & 3145728 /* UnionOrIntersection */) || t & 65536 /* Null */))
                 return true;
-            if (s & 524288 /* Object */ && t & 67108864 /* NonPrimitive */ && !(relation === strictSubtypeRelation && isEmptyAnonymousObjectType(source)))
+            if (s & 524288 /* Object */ && t & 67108864 /* NonPrimitive */)
                 return true;
             if (relation === assignableRelation || relation === comparableRelation) {
                 if (s & 1 /* Any */)
@@ -64420,9 +64403,6 @@ var ts;
                 // bit-flag enum types sometimes look like literal enum types with numeric literal values.
                 if (s & (8 /* Number */ | 256 /* NumberLiteral */) && !(s & 1024 /* EnumLiteral */) && (t & 32 /* Enum */ || relation === assignableRelation && t & 256 /* NumberLiteral */ && t & 1024 /* EnumLiteral */))
                     return true;
-                // Anything is assignable to a union containing undefined, null, and {}
-                if (isUnknownLikeUnionType(target))
-                    return true;
             }
             return false;
         }
@@ -64465,27 +64445,16 @@ var ts;
         function getNormalizedType(type, writing) {
             while (true) {
                 var t = isFreshLiteralType(type) ? type.regularType :
-                    ts.getObjectFlags(type) & 4 /* Reference */ ? type.node ? createTypeReference(type.target, getTypeArguments(type)) : getSingleBaseForNonAugmentingSubtype(type) || type :
-                        type.flags & 3145728 /* UnionOrIntersection */ ? getNormalizedUnionOrIntersectionType(type, writing) :
+                    ts.getObjectFlags(type) & 4 /* Reference */ && type.node ? createTypeReference(type.target, getTypeArguments(type)) :
+                        type.flags & 3145728 /* UnionOrIntersection */ ? getReducedType(type) :
                             type.flags & 33554432 /* Substitution */ ? writing ? type.baseType : type.substitute :
                                 type.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(type, writing) :
                                     type;
+                t = getSingleBaseForNonAugmentingSubtype(t) || t;
                 if (t === type)
-                    return t;
+                    break;
                 type = t;
             }
-        }
-        function getNormalizedUnionOrIntersectionType(type, writing) {
-            var reduced = getReducedType(type);
-            if (reduced !== type) {
-                return reduced;
-            }
-            if (type.flags & 2097152 /* Intersection */) {
-                var normalizedTypes = ts.sameMap(type.types, function (t) { return getNormalizedType(t, writing); });
-                if (normalizedTypes !== type.types) {
-                    return getIntersectionType(normalizedTypes);
-                }
-            }
             return type;
         }
         /**
@@ -67484,22 +67453,20 @@ var ts;
             return type.flags & 32768 /* Undefined */ ? type : getUnionType([type, isProperty ? missingType : undefinedType]);
         }
         function getGlobalNonNullableTypeInstantiation(type) {
+            // First reduce away any constituents that are assignable to 'undefined' or 'null'. This not only eliminates
+            // 'undefined' and 'null', but also higher-order types such as a type parameter 'U extends undefined | null'
+            // that isn't eliminated by a NonNullable<T> instantiation.
+            var reducedType = getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
             if (!deferredGlobalNonNullableTypeAlias) {
                 deferredGlobalNonNullableTypeAlias = getGlobalSymbol("NonNullable", 524288 /* TypeAlias */, /*diagnostic*/ undefined) || unknownSymbol;
             }
+            // If the NonNullable<T> type is available, return an instantiation. Otherwise just return the reduced type.
             return deferredGlobalNonNullableTypeAlias !== unknownSymbol ?
-                getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [type]) :
-                getIntersectionType([type, emptyObjectType]);
+                getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [reducedType]) :
+                reducedType;
         }
         function getNonNullableType(type) {
-            if (strictNullChecks) {
-                // First reduce away any constituents that are assignable to 'undefined' or 'null'. This not only eliminates
-                // 'undefined' and 'null', but also higher-order types such as a type parameter 'U extends undefined | null'
-                // that isn't eliminated by a NonNullable<T> instantiation.
-                var reducedType = getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
-                return maybeTypeOfKind(reducedType, 465829888 /* Instantiable */) ? getGlobalNonNullableTypeInstantiation(reducedType) : reducedType;
-            }
-            return type;
+            return strictNullChecks ? getGlobalNonNullableTypeInstantiation(type) : type;
         }
         function addOptionalTypeMarker(type) {
             return strictNullChecks ? getUnionType([type, optionalType]) : type;
@@ -69530,24 +69497,6 @@ var ts;
         function getTypeWithFacts(type, include) {
             return filterType(type, function (t) { return (getTypeFacts(t) & include) !== 0; });
         }
-        function getIntersectionWithFacts(type, facts) {
-            var reduced = recombineUnknownType(getTypeWithFacts(strictNullChecks && type.flags & 2 /* Unknown */ ? unknownUnionType : type, facts));
-            if (strictNullChecks) {
-                switch (facts) {
-                    case 524288 /* NEUndefined */:
-                        return mapType(reduced, function (t) { return getTypeFacts(t) & 65536 /* EQUndefined */ ? getIntersectionType([t, getTypeFacts(t) & 131072 /* EQNull */ && !maybeTypeOfKind(reduced, 65536 /* Null */) ? getUnionType([emptyObjectType, nullType]) : emptyObjectType]) : t; });
-                    case 1048576 /* NENull */:
-                        return mapType(reduced, function (t) { return getTypeFacts(t) & 131072 /* EQNull */ ? getIntersectionType([t, getTypeFacts(t) & 65536 /* EQUndefined */ && !maybeTypeOfKind(reduced, 32768 /* Undefined */) ? getUnionType([emptyObjectType, undefinedType]) : emptyObjectType]) : t; });
-                    case 2097152 /* NEUndefinedOrNull */:
-                    case 4194304 /* Truthy */:
-                        return mapType(reduced, function (t) { return getTypeFacts(t) & 262144 /* EQUndefinedOrNull */ ? getGlobalNonNullableTypeInstantiation(t) : t; });
-                }
-            }
-            return reduced;
-        }
-        function recombineUnknownType(type) {
-            return type === unknownUnionType ? unknownType : type;
-        }
         function getTypeWithDefault(type, defaultExpression) {
             return defaultExpression ?
                 getUnionType([getNonUndefinedType(type), getTypeOfExpression(defaultExpression)]) :
@@ -70605,7 +70554,7 @@ var ts;
                 if (isEvolvingArrayTypeList(types)) {
                     return getEvolvingArrayType(getUnionType(ts.map(types, getElementTypeOfEvolvingArrayType)));
                 }
-                var result = recombineUnknownType(getUnionType(ts.sameMap(types, finalizeEvolvingArrayType), subtypeReduction));
+                var result = getUnionType(ts.sameMap(types, finalizeEvolvingArrayType), subtypeReduction);
                 if (result !== declaredType && result.flags & declaredType.flags & 1048576 /* Union */ && ts.arraysEqual(result.types, declaredType.types)) {
                     return declaredType;
                 }
@@ -70707,7 +70656,8 @@ var ts;
             }
             function narrowTypeByTruthiness(type, expr, assumeTrue) {
                 if (isMatchingReference(reference, expr)) {
-                    return getIntersectionWithFacts(type, assumeTrue ? 4194304 /* Truthy */ : 8388608 /* Falsy */);
+                    return type.flags & 2 /* Unknown */ && assumeTrue ? nonNullUnknownType :
+                        getTypeWithFacts(type, assumeTrue ? 4194304 /* Truthy */ : 8388608 /* Falsy */);
                 }
                 if (strictNullChecks && assumeTrue && optionalChainContainsReference(expr, reference)) {
                     type = getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
@@ -70860,6 +70810,9 @@ var ts;
                     assumeTrue = !assumeTrue;
                 }
                 var valueType = getTypeOfExpression(value);
+                if (assumeTrue && (type.flags & 2 /* Unknown */) && (operator === 34 /* EqualsEqualsToken */ || operator === 35 /* ExclamationEqualsToken */) && (valueType.flags & 65536 /* Null */)) {
+                    return getUnionType([nullType, undefinedType]);
+                }
                 if ((type.flags & 2 /* Unknown */) && assumeTrue && (operator === 36 /* EqualsEqualsEqualsToken */ || operator === 37 /* ExclamationEqualsEqualsToken */)) {
                     if (valueType.flags & (131068 /* Primitive */ | 67108864 /* NonPrimitive */)) {
                         return valueType;
@@ -70879,7 +70832,7 @@ var ts;
                         valueType.flags & 65536 /* Null */ ?
                             assumeTrue ? 131072 /* EQNull */ : 1048576 /* NENull */ :
                             assumeTrue ? 65536 /* EQUndefined */ : 524288 /* NEUndefined */;
-                    return getIntersectionWithFacts(type, facts);
+                    return type.flags & 2 /* Unknown */ && facts & (1048576 /* NENull */ | 2097152 /* NEUndefinedOrNull */) ? nonNullUnknownType : getTypeWithFacts(type, facts);
                 }
                 if (assumeTrue) {
                     var filterFn = operator === 34 /* EqualsEqualsToken */ ?
@@ -70907,11 +70860,17 @@ var ts;
                 if (type.flags & 1 /* Any */ && literal.text === "function") {
                     return type;
                 }
+                if (assumeTrue && type.flags & 2 /* Unknown */ && literal.text === "object") {
+                    // The non-null unknown type is used to track whether a previous narrowing operation has removed the null type
+                    // from the unknown type. For example, the expression `x && typeof x === 'object'` first narrows x to the non-null
+                    // unknown type, and then narrows that to the non-primitive type.
+                    return type === nonNullUnknownType ? nonPrimitiveType : getUnionType([nonPrimitiveType, nullType]);
+                }
                 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 getTypeWithFacts(assumeTrue && impliedType ? mapType(type, narrowUnionMemberByTypeof(impliedType)) : type, facts);
             }
             function narrowTypeBySwitchOptionalChainContainment(type, switchStatement, clauseStart, clauseEnd, clauseCheck) {
                 var everyClauseChecks = clauseStart !== clauseEnd && ts.every(getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd), clauseCheck);
@@ -70960,10 +70919,10 @@ var ts;
             }
             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;
+                    case "object":
+                        return type.flags & 2 /* Unknown */ ? getUnionType([nonPrimitiveType, nullType]) : type;
                     default:
                         return typeofTypesByName.get(text);
                 }
@@ -70974,27 +70933,22 @@ var ts;
             // 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;
-                }
-                return mapType(type, function (t) {
-                    if (isTypeRelatedTo(t, candidate, strictSubtypeRelation)) {
-                        return t;
+            function narrowUnionMemberByTypeof(candidate) {
+                return function (type) {
+                    if (isTypeSubtypeOf(type, candidate)) {
+                        return type;
                     }
-                    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;
+                    if (isTypeSubtypeOf(candidate, type)) {
+                        return candidate;
+                    }
+                    if (type.flags & 465829888 /* Instantiable */) {
+                        var constraint = getBaseConstraintOfType(type) || anyType;
+                        if (isTypeSubtypeOf(candidate, constraint)) {
+                            return getIntersectionType([type, candidate]);
                         }
-                        return getIntersectionType([t, c]);
-                    });
-                });
+                    }
+                    return type;
+                };
             }
             function narrowBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) {
                 var switchWitnesses = getSwitchClauseTypeOfWitnesses(switchStatement, /*retainDefault*/ true);
@@ -71053,7 +71007,7 @@ var ts;
                   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);
+                return getTypeWithFacts(mapType(type, narrowUnionMemberByTypeof(impliedType)), switchFacts);
             }
             function isMatchingConstructorReference(expr) {
                 return (ts.isPropertyAccessExpression(expr) && ts.idText(expr.name) === "constructor" ||
@@ -71357,9 +71311,7 @@ var ts;
                     !(someType(type, isGenericTypeWithoutNullableConstraint) && isGenericIndexType(getTypeOfExpression(parent.argumentExpression)));
         }
         function isGenericTypeWithUnionConstraint(type) {
-            return type.flags & 2097152 /* Intersection */ ?
-                ts.some(type.types, isGenericTypeWithUnionConstraint) :
-                !!(type.flags & 465829888 /* Instantiable */ && getBaseConstraintOrType(type).flags & (98304 /* Nullable */ | 1048576 /* Union */));
+            return !!(type.flags & 465829888 /* Instantiable */ && getBaseConstraintOrType(type).flags & (98304 /* Nullable */ | 1048576 /* Union */));
         }
         function isGenericTypeWithoutNullableConstraint(type) {
             return !!(type.flags & 465829888 /* Instantiable */ && !maybeTypeOfKind(getBaseConstraintOrType(type), 98304 /* Nullable */));
@@ -71387,7 +71339,7 @@ var ts;
             var substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) &&
                 someType(type, isGenericTypeWithUnionConstraint) &&
                 (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
-            return substituteConstraints ? mapType(type, getBaseConstraintOrType) : type;
+            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ ? getBaseConstraintOrType(t) : t; }) : type;
         }
         function isExportOrExportExpression(location) {
             return !!ts.findAncestor(location, function (n) {
@@ -123697,6 +123649,7 @@ var ts;
         }
         function reloadFileNamesFromConfigFile() {
             writeLog("Reloading new file names and options");
+            reloadLevel = ts.ConfigFileProgramReloadLevel.None;
             rootFileNames = ts.getFileNamesFromConfigSpecs(compilerOptions.configFile.configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), compilerOptions, parseConfigFileHost, extraFileExtensions);
             if (ts.updateErrorForNoInputFiles(rootFileNames, ts.getNormalizedAbsolutePath(configFileName, currentDirectory), compilerOptions.configFile.configFileSpecs, configFileParsingDiagnostics, canConfigFileJsonReportNoInputFiles)) {
                 hasChangedConfigFileParsingErrors = true;