@typescript-deploys/pr-build 4.8.0-pr-48997-21 → 4.8.0-pr-49285-5

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.20220525";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220601";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -3499,16 +3499,34 @@ var ts;
 /** Performance measurements for the compiler. */
 var ts;
 (function (ts) {
-    var performance;
-    (function (performance) {
+    var nullTimer = { enter: ts.noop, exit: ts.noop };
+    ts.performance = createPerformanceTracker();
+    ts.solutionPerformance = createPerformanceTracker();
+    function createPerformanceTracker() {
         var perfHooks;
         // when set, indicates the implementation of `Performance` to use for user timing.
         // when unset, indicates user timing is unavailable or disabled.
         var performanceImpl;
+        var enabled = false;
+        var timeorigin = ts.timestamp();
+        var marks = new ts.Map();
+        var counts = new ts.Map();
+        var durations = new ts.Map();
+        return {
+            createTimerIf: createTimerIf,
+            createTimer: createTimer,
+            mark: mark,
+            measure: measure,
+            getCount: getCount,
+            getDuration: getDuration,
+            forEachMeasure: forEachMeasure,
+            isEnabled: isEnabled,
+            enable: enable,
+            disable: disable,
+        };
         function createTimerIf(condition, measureName, startMarkName, endMarkName) {
-            return condition ? createTimer(measureName, startMarkName, endMarkName) : performance.nullTimer;
+            return condition ? createTimer(measureName, startMarkName, endMarkName) : nullTimer;
         }
-        performance.createTimerIf = createTimerIf;
         function createTimer(measureName, startMarkName, endMarkName) {
             var enterCount = 0;
             return {
@@ -3530,13 +3548,6 @@ var ts;
                 }
             }
         }
-        performance.createTimer = createTimer;
-        performance.nullTimer = { enter: ts.noop, exit: ts.noop };
-        var enabled = false;
-        var timeorigin = ts.timestamp();
-        var marks = new ts.Map();
-        var counts = new ts.Map();
-        var durations = new ts.Map();
         /**
          * Marks a performance event.
          *
@@ -3551,7 +3562,6 @@ var ts;
                 performanceImpl === null || performanceImpl === void 0 ? void 0 : performanceImpl.mark(markName);
             }
         }
-        performance.mark = mark;
         /**
          * Adds a performance measurement with the specified name.
          *
@@ -3564,14 +3574,13 @@ var ts;
         function measure(measureName, startMarkName, endMarkName) {
             var _a, _b;
             if (enabled) {
-                var end = (_a = (endMarkName !== undefined ? marks.get(endMarkName) : undefined)) !== null && _a !== void 0 ? _a : ts.timestamp();
-                var start = (_b = (startMarkName !== undefined ? marks.get(startMarkName) : undefined)) !== null && _b !== void 0 ? _b : timeorigin;
+                var end = (_a = marks.get(endMarkName)) !== null && _a !== void 0 ? _a : ts.timestamp();
+                var start = (_b = marks.get(startMarkName)) !== null && _b !== void 0 ? _b : timeorigin;
                 var previousDuration = durations.get(measureName) || 0;
                 durations.set(measureName, previousDuration + (end - start));
                 performanceImpl === null || performanceImpl === void 0 ? void 0 : performanceImpl.measure(measureName, startMarkName, endMarkName);
             }
         }
-        performance.measure = measure;
         /**
          * Gets the number of times a marker was encountered.
          *
@@ -3580,7 +3589,6 @@ var ts;
         function getCount(markName) {
             return counts.get(markName) || 0;
         }
-        performance.getCount = getCount;
         /**
          * Gets the total duration of all measurements with the supplied name.
          *
@@ -3589,7 +3597,6 @@ var ts;
         function getDuration(measureName) {
             return durations.get(measureName) || 0;
         }
-        performance.getDuration = getDuration;
         /**
          * Iterate over each measure, performing some action
          *
@@ -3598,14 +3605,12 @@ var ts;
         function forEachMeasure(cb) {
             durations.forEach(function (duration, measureName) { return cb(measureName, duration); });
         }
-        performance.forEachMeasure = forEachMeasure;
         /**
          * Indicates whether the performance API is enabled.
          */
         function isEnabled() {
             return enabled;
         }
-        performance.isEnabled = isEnabled;
         /** Enables (and resets) performance measurements for the compiler. */
         function enable(system) {
             var _a;
@@ -3626,7 +3631,6 @@ var ts;
             }
             return true;
         }
-        performance.enable = enable;
         /** Disables performance measurements for the compiler. */
         function disable() {
             if (enabled) {
@@ -3637,8 +3641,7 @@ var ts;
                 enabled = false;
             }
         }
-        performance.disable = disable;
-    })(performance = ts.performance || (ts.performance = {}));
+    }
 })(ts || (ts = {}));
 /* @internal */
 var ts;
@@ -5090,6 +5093,11 @@ 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";
@@ -6308,7 +6316,7 @@ var ts;
      */
     /*@internal*/
     function createDirectoryWatcherSupportingRecursive(_a) {
-        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 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 cache = new ts.Map();
         var callbackCache = ts.createMultiMap();
         var cacheToUpdateChildWatches = new ts.Map();
@@ -6408,7 +6416,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 && fileSystemEntryExists(dirName, 1 /* Directory */)) {
+            if (parentWatcher && directoryExists(dirName)) {
                 // Schedule the update and postpone invoke for callbacks
                 scheduleUpdateChildWatches(dirName, dirPath, fileName, options);
                 return;
@@ -6481,7 +6489,7 @@ var ts;
             if (!parentWatcher)
                 return false;
             var newChildWatches;
-            var hasChanges = ts.enumerateInsertsAndDeletes(fileSystemEntryExists(parentDir, 1 /* Directory */) ? ts.mapDefined(getAccessibleSortedChildDirectories(parentDir), function (child) {
+            var hasChanges = ts.enumerateInsertsAndDeletes(directoryExists(parentDir) ? 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
@@ -6527,10 +6535,10 @@ var ts;
         return function (_fileName, eventKind) { return callback(eventKind === FileWatcherEventKind.Changed ? "change" : "rename", ""); };
     }
     ts.createFileWatcherCallback = createFileWatcherCallback;
-    function createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileSystemEntryExists) {
+    function createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileExists) {
         return function (eventName) {
             if (eventName === "rename") {
-                callback(fileName, fileSystemEntryExists(fileName, 0 /* File */) ? FileWatcherEventKind.Created : FileWatcherEventKind.Deleted);
+                callback(fileName, fileExists(fileName) ? FileWatcherEventKind.Created : FileWatcherEventKind.Deleted);
             }
             else {
                 // Change
@@ -6558,12 +6566,11 @@ var ts;
     }
     /*@internal*/
     function createSystemWatchFunctions(_a) {
-        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 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 dynamicPollingWatchFile;
         var fixedChunkSizePollingWatchFile;
         var nonPollingWatchFile;
         var hostRecursiveDirectoryWatcher;
-        var hitSystemWatcherLimit = false;
         return {
             watchFile: watchFile,
             watchDirectory: watchDirectory
@@ -6581,7 +6588,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, fileSystemEntryExists), 
+                    return fsWatch(fileName, 0 /* File */, createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileExists), 
                     /*recursive*/ false, pollingInterval, ts.getFallbackOptions(options));
                 case ts.WatchFileKind.UseFsEventsOnParentDirectory:
                     if (!nonPollingWatchFile) {
@@ -6642,7 +6649,7 @@ var ts;
                 hostRecursiveDirectoryWatcher = createDirectoryWatcherSupportingRecursive({
                     useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                     getCurrentDirectory: getCurrentDirectory,
-                    fileSystemEntryExists: fileSystemEntryExists,
+                    directoryExists: directoryExists,
                     getAccessibleSortedChildDirectories: getAccessibleSortedChildDirectories,
                     watchDirectory: nonRecursiveWatchDirectory,
                     realpath: realpath,
@@ -6693,114 +6700,6 @@ 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;
     /**
@@ -6853,6 +6752,7 @@ var ts;
             }
             var activeSession;
             var profilePath = "./profile.cpuprofile";
+            var hitSystemWatcherLimit = false;
             var Buffer = require("buffer").Buffer;
             var nodeVersion = getNodeMajorVersion();
             var isNode4OrLater = nodeVersion >= 4;
@@ -6867,21 +6767,20 @@ var ts;
                 getModifiedTime: getModifiedTime,
                 setTimeout: setTimeout,
                 clearTimeout: clearTimeout,
-                fsWatchWorker: fsWatchWorker,
+                fsWatch: fsWatch,
                 useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                 getCurrentDirectory: getCurrentDirectory,
-                fileSystemEntryExists: fileSystemEntryExists,
+                fileExists: fileExists,
                 // 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),
@@ -7134,11 +7033,107 @@ var ts;
                     callback(fileName, eventKind);
                 }
             }
-            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 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 readFileWorker(fileName, _encoding) {
                 var buffer;
@@ -8416,6 +8411,7 @@ var ts;
         Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, ts.DiagnosticCategory.Error, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
         The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: diag(2206, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement_2206", "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."),
         The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement: diag(2207, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement_2207", "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."),
+        This_type_parameter_probably_needs_an_extends_object_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_probably_needs_an_extends_object_constraint_2208", "This type parameter probably needs an `extends object` constraint."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2209, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_roo_2209", "The project root is ambiguous, but is required to resolve export map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2210, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_roo_2210", "The project root is ambiguous, but is required to resolve import map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
         Duplicate_identifier_0: diag(2300, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."),
@@ -8901,6 +8897,7 @@ var ts;
         Import_assertion_values_must_be_string_literal_expressions: diag(2837, ts.DiagnosticCategory.Error, "Import_assertion_values_must_be_string_literal_expressions_2837", "Import assertion values must be string literal expressions."),
         All_declarations_of_0_must_have_identical_constraints: diag(2838, ts.DiagnosticCategory.Error, "All_declarations_of_0_must_have_identical_constraints_2838", "All declarations of '{0}' must have identical constraints."),
         This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value: diag(2839, ts.DiagnosticCategory.Error, "This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value_2839", "This condition will always return '{0}' since JavaScript compares objects by reference, not value."),
+        An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_classes: diag(2840, ts.DiagnosticCategory.Error, "An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_clas_2840", "An interface cannot extend a primitive type like '{0}'; an interface can only extend named types and classes"),
         Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -16220,9 +16217,6 @@ var ts;
     }
     ts.isVariableDeclarationInitializedToBareOrAccessedRequire = isVariableDeclarationInitializedToBareOrAccessedRequire;
     function isVariableDeclarationInitializedWithRequireHelper(node, allowAccessedRequire) {
-        if (node.kind === 203 /* BindingElement */) {
-            node = node.parent.parent;
-        }
         return ts.isVariableDeclaration(node) &&
             !!node.initializer &&
             isRequireCall(allowAccessedRequire ? getLeftmostAccessExpression(node.initializer) : node.initializer, /*requireStringLiteralLikeArgument*/ true);
@@ -20034,8 +20028,9 @@ var ts;
      */
     function isFileForcedToBeModuleByFormat(file) {
         // Excludes declaration files - they still require an explicit `export {}` or the like
-        // for back compat purposes.
-        return file.impliedNodeFormat === ts.ModuleKind.ESNext && !file.isDeclarationFile ? true : undefined;
+        // for back compat purposes. The only non-declaration files _not_ forced to be a module are `.js` files
+        // that aren't esm-mode (meaning not in a `type: module` scope).
+        return (file.impliedNodeFormat === ts.ModuleKind.ESNext || (ts.fileExtensionIsOneOf(file.fileName, [".cjs" /* Cjs */, ".cts" /* Cts */]))) && !file.isDeclarationFile ? true : undefined;
     }
     function getSetExternalModuleIndicator(options) {
         // TODO: Should this callback be cached?
@@ -20043,7 +20038,7 @@ var ts;
             case ts.ModuleDetectionKind.Force:
                 // All non-declaration files are modules, declaration files still do the usual isFileProbablyExternalModule
                 return function (file) {
-                    file.externalModuleIndicator = !file.isDeclarationFile || ts.isFileProbablyExternalModule(file);
+                    file.externalModuleIndicator = ts.isFileProbablyExternalModule(file) || !file.isDeclarationFile || undefined;
                 };
             case ts.ModuleDetectionKind.Legacy:
                 // Files are modules if they have imports, exports, or import.meta
@@ -20103,7 +20098,8 @@ var ts;
     }
     ts.getEmitModuleResolutionKind = getEmitModuleResolutionKind;
     function getEmitModuleDetectionKind(options) {
-        return options.moduleDetection || ts.ModuleDetectionKind.Auto;
+        return options.moduleDetection ||
+            (getEmitModuleKind(options) === ts.ModuleKind.Node16 || getEmitModuleKind(options) === ts.ModuleKind.NodeNext ? ts.ModuleDetectionKind.Force : ts.ModuleDetectionKind.Auto);
     }
     ts.getEmitModuleDetectionKind = getEmitModuleDetectionKind;
     function hasJsonModuleEmitEnabled(options) {
@@ -43150,16 +43146,20 @@ var ts;
     function nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
         return nodeNextModuleNameResolverWorker(NodeResolutionFeatures.NodeNextDefault, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
     }
+    var jsOnlyExtensions = [Extensions.JavaScript];
+    var tsExtensions = [Extensions.TypeScript, Extensions.JavaScript];
+    var tsPlusJsonExtensions = __spreadArray(__spreadArray([], tsExtensions, true), [Extensions.Json], false);
+    var tsconfigExtensions = [Extensions.TSConfig];
     function nodeNextModuleNameResolverWorker(features, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
         var containingDirectory = ts.getDirectoryPath(containingFile);
         // es module file or cjs-like input file, use a variant of the legacy cjs resolver that supports the selected modern features
         var esmMode = resolutionMode === ts.ModuleKind.ESNext ? NodeResolutionFeatures.EsmMode : 0;
-        return nodeModuleNameResolverWorker(features | esmMode, moduleName, containingDirectory, compilerOptions, host, cache, compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions, redirectedReference);
+        var extensions = compilerOptions.noDtsResolution ? [Extensions.TsOnly, Extensions.JavaScript] : tsExtensions;
+        if (compilerOptions.resolveJsonModule) {
+            extensions = __spreadArray(__spreadArray([], extensions, true), [Extensions.Json], false);
+        }
+        return nodeModuleNameResolverWorker(features | esmMode, moduleName, containingDirectory, compilerOptions, host, cache, extensions, redirectedReference);
     }
-    var jsOnlyExtensions = [Extensions.JavaScript];
-    var tsExtensions = [Extensions.TypeScript, Extensions.JavaScript];
-    var tsPlusJsonExtensions = __spreadArray(__spreadArray([], tsExtensions, true), [Extensions.Json], false);
-    var tsconfigExtensions = [Extensions.TSConfig];
     function tryResolveJSModuleWorker(moduleName, initialDir, host) {
         return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, initialDir, { moduleResolution: ts.ModuleResolutionKind.NodeJs, allowJs: true }, host, /*cache*/ undefined, jsOnlyExtensions, /*redirectedReferences*/ undefined);
     }
@@ -44167,8 +44167,8 @@ var ts;
             var pathAndExtension = loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) ||
                 loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageInfo && packageInfo.packageJsonContent, packageInfo && packageInfo.versionPaths);
             if (!pathAndExtension && packageInfo
-                && packageInfo.packageJsonContent.exports === undefined
-                && packageInfo.packageJsonContent.main === undefined
+                // eslint-disable-next-line no-null/no-null
+                && (packageInfo.packageJsonContent.exports === undefined || packageInfo.packageJsonContent.exports === null)
                 && state.features & NodeResolutionFeatures.EsmMode) {
                 // EsmMode disables index lookup in `loadNodeModuleFromDirectoryWorker` generally, however non-relative package resolutions still assume
                 // a default `index.js` entrypoint if no `main` or `exports` are present
@@ -46944,12 +46944,14 @@ var ts;
             }
         }
         function setCommonJsModuleIndicator(node) {
-            if (file.externalModuleIndicator) {
+            if (file.externalModuleIndicator && file.externalModuleIndicator !== true) {
                 return false;
             }
             if (!file.commonJsModuleIndicator) {
                 file.commonJsModuleIndicator = node;
-                bindSourceFileAsExternalModule();
+                if (!file.externalModuleIndicator) {
+                    bindSourceFileAsExternalModule();
+                }
             }
             return true;
         }
@@ -47363,7 +47365,11 @@ var ts;
                 checkStrictModeEvalOrArguments(node, node.name);
             }
             if (!ts.isBindingPattern(node.name)) {
-                if (ts.isInJSFile(node) && ts.isVariableDeclarationInitializedToBareOrAccessedRequire(node) && !ts.getJSDocTypeTag(node) && !(ts.getCombinedModifierFlags(node) & 1 /* Export */)) {
+                var possibleVariableDecl = node.kind === 254 /* VariableDeclaration */ ? node : node.parent.parent;
+                if (ts.isInJSFile(node) &&
+                    ts.isVariableDeclarationInitializedToBareOrAccessedRequire(possibleVariableDecl) &&
+                    !ts.getJSDocTypeTag(node) &&
+                    !(ts.getCombinedModifierFlags(node) & 1 /* Export */)) {
                     declareSymbolAndAddToSymbolTable(node, 2097152 /* Alias */, 2097152 /* AliasExcludes */);
                 }
                 else if (ts.isBlockOrCatchScoped(node)) {
@@ -47827,7 +47833,10 @@ var ts;
         TypeFacts[TypeFacts["NEUndefinedOrNull"] = 2097152] = "NEUndefinedOrNull";
         TypeFacts[TypeFacts["Truthy"] = 4194304] = "Truthy";
         TypeFacts[TypeFacts["Falsy"] = 8388608] = "Falsy";
-        TypeFacts[TypeFacts["All"] = 16777215] = "All";
+        TypeFacts[TypeFacts["IsUndefined"] = 16777216] = "IsUndefined";
+        TypeFacts[TypeFacts["IsNull"] = 33554432] = "IsNull";
+        TypeFacts[TypeFacts["IsUndefinedOrNull"] = 50331648] = "IsUndefinedOrNull";
+        TypeFacts[TypeFacts["All"] = 134217727] = "All";
         // The following members encode facts about particular kinds of types for use in the getTypeFacts function.
         // The presence of a particular fact means that the given test is true for some (and possibly all) values
         // of that kind of type.
@@ -47869,14 +47878,16 @@ var ts;
         TypeFacts[TypeFacts["ObjectFacts"] = 16736160] = "ObjectFacts";
         TypeFacts[TypeFacts["FunctionStrictFacts"] = 7880640] = "FunctionStrictFacts";
         TypeFacts[TypeFacts["FunctionFacts"] = 16728000] = "FunctionFacts";
-        TypeFacts[TypeFacts["UndefinedFacts"] = 9830144] = "UndefinedFacts";
-        TypeFacts[TypeFacts["NullFacts"] = 9363232] = "NullFacts";
-        TypeFacts[TypeFacts["EmptyObjectStrictFacts"] = 16318463] = "EmptyObjectStrictFacts";
+        TypeFacts[TypeFacts["VoidFacts"] = 9830144] = "VoidFacts";
+        TypeFacts[TypeFacts["UndefinedFacts"] = 26607360] = "UndefinedFacts";
+        TypeFacts[TypeFacts["NullFacts"] = 42917664] = "NullFacts";
+        TypeFacts[TypeFacts["EmptyObjectStrictFacts"] = 83427327] = "EmptyObjectStrictFacts";
+        TypeFacts[TypeFacts["EmptyObjectFacts"] = 83886079] = "EmptyObjectFacts";
+        TypeFacts[TypeFacts["UnknownFacts"] = 83886079] = "UnknownFacts";
         TypeFacts[TypeFacts["AllTypeofNE"] = 556800] = "AllTypeofNE";
-        TypeFacts[TypeFacts["EmptyObjectFacts"] = 16777215] = "EmptyObjectFacts";
         // Masks
         TypeFacts[TypeFacts["OrFactsMask"] = 8256] = "OrFactsMask";
-        TypeFacts[TypeFacts["AndFactsMask"] = 16768959] = "AndFactsMask";
+        TypeFacts[TypeFacts["AndFactsMask"] = 134209471] = "AndFactsMask";
     })(TypeFacts || (TypeFacts = {}));
     var typeofEQFacts = new ts.Map(ts.getEntries({
         string: 1 /* TypeofEQString */,
@@ -48540,6 +48551,7 @@ 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);
@@ -50039,7 +50051,12 @@ var ts;
         function checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) {
             if (meaning & (111551 /* Value */ & ~1024 /* NamespaceModule */)) {
                 if (isPrimitiveTypeName(name)) {
-                    error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, ts.unescapeLeadingUnderscores(name));
+                    if (isExtendedByInterface(errorLocation)) {
+                        error(errorLocation, ts.Diagnostics.An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_classes, ts.unescapeLeadingUnderscores(name));
+                    }
+                    else {
+                        error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, ts.unescapeLeadingUnderscores(name));
+                    }
                     return true;
                 }
                 var symbol = resolveSymbol(resolveName(errorLocation, name, 788968 /* Type */ & ~111551 /* Value */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
@@ -50059,6 +50076,16 @@ var ts;
             }
             return false;
         }
+        function isExtendedByInterface(node) {
+            var grandparent = node.parent.parent;
+            var parentOfGrandparent = grandparent.parent;
+            if (grandparent && parentOfGrandparent) {
+                var isExtending = ts.isHeritageClause(grandparent) && grandparent.token === 94 /* ExtendsKeyword */;
+                var isInterface = ts.isInterfaceDeclaration(parentOfGrandparent);
+                return isExtending && isInterface;
+            }
+            return false;
+        }
         function maybeMappedType(node, symbol) {
             var container = ts.findAncestor(node.parent, function (n) {
                 return ts.isComputedPropertyName(n) || ts.isPropertySignature(n) ? false : ts.isTypeLiteralNode(n) || "quit";
@@ -50190,7 +50217,8 @@ var ts;
                     && isAliasableOrJsExpression(node.parent.right)
                 || node.kind === 297 /* ShorthandPropertyAssignment */
                 || node.kind === 296 /* PropertyAssignment */ && isAliasableOrJsExpression(node.initializer)
-                || ts.isVariableDeclarationInitializedToBareOrAccessedRequire(node);
+                || node.kind === 254 /* VariableDeclaration */ && ts.isVariableDeclarationInitializedToBareOrAccessedRequire(node)
+                || node.kind === 203 /* BindingElement */ && ts.isVariableDeclarationInitializedToBareOrAccessedRequire(node.parent.parent);
         }
         function isAliasableOrJsExpression(e) {
             return ts.isAliasableExpression(e) || ts.isFunctionExpression(e) && isJSConstructor(e);
@@ -50283,7 +50311,7 @@ var ts;
                 return hasExportAssignmentSymbol(moduleSymbol);
             }
             // JS files have a synthetic default if they do not contain ES2015+ module syntax (export = is not valid in js) _and_ do not have an __esModule marker
-            return !file.externalModuleIndicator && !resolveExportByName(moduleSymbol, ts.escapeLeadingUnderscores("__esModule"), /*sourceNode*/ undefined, dontResolveAlias);
+            return typeof file.externalModuleIndicator !== "object" && !resolveExportByName(moduleSymbol, ts.escapeLeadingUnderscores("__esModule"), /*sourceNode*/ undefined, dontResolveAlias);
         }
         function getTargetOfImportClause(node, dontResolveAlias) {
             var _a;
@@ -52898,7 +52926,7 @@ var ts;
                     anyType : getNonMissingTypeOfSymbol(propertySymbol);
                 var saveEnclosingDeclaration = context.enclosingDeclaration;
                 context.enclosingDeclaration = undefined;
-                if (context.tracker.trackSymbol && ts.getCheckFlags(propertySymbol) & 4096 /* Late */ && isLateBoundName(propertySymbol.escapedName)) {
+                if (context.tracker.trackSymbol && isLateBoundName(propertySymbol.escapedName)) {
                     if (propertySymbol.declarations) {
                         var decl = ts.first(propertySymbol.declarations);
                         if (hasLateBindableName(decl)) {
@@ -54582,7 +54610,7 @@ var ts;
                         ? getBaseConstructorTypeOfClass(staticType)
                         : anyType;
                     var heritageClauses = __spreadArray(__spreadArray([], !ts.length(baseTypes) ? [] : [ts.factory.createHeritageClause(94 /* ExtendsKeyword */, ts.map(baseTypes, function (b) { return serializeBaseType(b, staticBaseType, localName); }))], true), !ts.length(implementsExpressions) ? [] : [ts.factory.createHeritageClause(117 /* ImplementsKeyword */, implementsExpressions)], true);
-                    var symbolProps = getNonInterhitedProperties(classType, baseTypes, getPropertiesOfType(classType));
+                    var symbolProps = getNonInheritedProperties(classType, baseTypes, getPropertiesOfType(classType));
                     var publicSymbolProps = ts.filter(symbolProps, function (s) {
                         // `valueDeclaration` could be undefined if inherited from
                         // a union/intersection base type, but inherited properties
@@ -55720,7 +55748,7 @@ var ts;
             if (ts.getEffectiveTypeAnnotationNode(ts.walkUpBindingElementsAndPatterns(declaration))) {
                 // In strict null checking mode, if a default value of a non-undefined type is specified, remove
                 // undefined from the final type.
-                return strictNullChecks && !(getFalsyFlags(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 32768 /* Undefined */) ? getNonUndefinedType(type) : type;
+                return strictNullChecks && !(getTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 16777216 /* IsUndefined */) ? getNonUndefinedType(type) : type;
             }
             return widenTypeInferredFromInitializer(declaration, getUnionType([getNonUndefinedType(type), checkDeclarationInitializer(declaration, 0 /* Normal */)], 2 /* Subtype */));
         }
@@ -58709,7 +58737,7 @@ var ts;
                         }
                     }
                 }
-                else if (t.flags & 469892092 /* DisjointDomains */) {
+                else if (t.flags & 469892092 /* DisjointDomains */ || isEmptyAnonymousObjectType(t)) {
                     hasDisjointDomainType = true;
                 }
             }
@@ -58721,7 +58749,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 */) {
+                        if (t.flags & 469892092 /* DisjointDomains */ || isEmptyAnonymousObjectType(t)) {
                             constraints = ts.append(constraints, t);
                         }
                     }
@@ -58923,7 +58951,7 @@ var ts;
             var objectType;
             return !!(type.flags & 8388608 /* IndexedAccess */ && ts.getObjectFlags(objectType = type.objectType) & 32 /* Mapped */ &&
                 !isGenericMappedType(objectType) && isGenericIndexType(type.indexType) &&
-                !objectType.declaration.questionToken && !objectType.declaration.nameType);
+                !(getMappedTypeModifiers(objectType) & 8 /* ExcludeOptional */) && !objectType.declaration.nameType);
         }
         /**
          * For a type parameter, return the base constraint of the type parameter. For the string, number,
@@ -61270,7 +61298,7 @@ var ts;
             }
             return includes;
         }
-        function removeRedundantPrimitiveTypes(types, includes) {
+        function removeRedundantSupertypes(types, includes) {
             var i = types.length;
             while (i > 0) {
                 i--;
@@ -61278,7 +61306,9 @@ 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 & 4096 /* ESSymbol */ && includes & 8192 /* UniqueESSymbol */ ||
+                    t.flags & 16384 /* Void */ && includes & 32768 /* Undefined */ ||
+                    isEmptyAnonymousObjectType(t) && includes & 470302716 /* DefinitelyNonNullable */;
                 if (remove) {
                     ts.orderedRemoveItemAt(types, i);
                 }
@@ -61400,7 +61430,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) {
+        function getIntersectionType(types, aliasSymbol, aliasTypeArguments, noSupertypeReduction) {
             var typeMembershipMap = new ts.Map();
             var includes = addTypesToIntersection(typeMembershipMap, 0, types);
             var typeSet = ts.arrayFrom(typeMembershipMap.values());
@@ -61437,11 +61467,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 */) {
-                removeRedundantPrimitiveTypes(typeSet, includes);
-            }
-            if (includes & 16777216 /* IncludesEmptyObject */ && includes & 524288 /* Object */) {
-                ts.orderedRemoveItemAt(typeSet, ts.findIndex(typeSet, isEmptyAnonymousObjectType));
+                includes & 4096 /* ESSymbol */ && includes & 8192 /* UniqueESSymbol */ ||
+                includes & 16384 /* Void */ && includes & 32768 /* Undefined */ ||
+                includes & 16777216 /* IncludesEmptyObject */ && includes & 470302716 /* DefinitelyNonNullable */) {
+                if (!noSupertypeReduction)
+                    removeRedundantSupertypes(typeSet, includes);
             }
             if (includes & 262144 /* IncludesMissingType */) {
                 typeSet[typeSet.indexOf(undefinedType)] = missingType;
@@ -61480,8 +61510,9 @@ 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).
-                        var origin = ts.some(constituents, function (t) { return !!(t.flags & 2097152 /* Intersection */); }) ? createOriginUnionOrIntersectionType(2097152 /* Intersection */, typeSet) : undefined;
+                        // 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;
                         result = getUnionType(constituents, 1 /* Literal */, aliasSymbol, aliasTypeArguments, origin);
                     }
                 }
@@ -61524,11 +61555,21 @@ 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);
-                links.resolvedType = getIntersectionType(ts.map(node.types, getTypeFromTypeNode), aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol));
+                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);
             }
             return links.resolvedType;
         }
@@ -64202,7 +64243,7 @@ var ts;
                     var sourceSig = checkMode & 3 /* Callback */ ? undefined : getSingleCallSignature(getNonNullableType(sourceType));
                     var targetSig = checkMode & 3 /* Callback */ ? undefined : getSingleCallSignature(getNonNullableType(targetType));
                     var callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) &&
-                        (getFalsyFlags(sourceType) & 98304 /* Nullable */) === (getFalsyFlags(targetType) & 98304 /* Nullable */);
+                        (getTypeFacts(sourceType) & 50331648 /* IsUndefinedOrNull */) === (getTypeFacts(targetType) & 50331648 /* IsUndefinedOrNull */);
                     var related = callbacks ?
                         compareSignaturesRelated(targetSig, sourceSig, (checkMode & 8 /* StrictArity */) | (strictVariance ? 2 /* StrictCallback */ : 1 /* BivariantCallback */), reportErrors, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) :
                         !(checkMode & 3 /* Callback */) && !strictVariance && compareTypes(sourceType, targetType, /*reportErrors*/ false) || compareTypes(targetType, sourceType, reportErrors);
@@ -64314,6 +64355,17 @@ 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) ||
@@ -64393,7 +64445,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 */)
+            if (s & 524288 /* Object */ && t & 67108864 /* NonPrimitive */ && !(relation === strictSubtypeRelation && isEmptyAnonymousObjectType(source)))
                 return true;
             if (relation === assignableRelation || relation === comparableRelation) {
                 if (s & 1 /* Any */)
@@ -64403,6 +64455,9 @@ 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;
         }
@@ -64445,16 +64500,27 @@ 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)) :
-                        type.flags & 3145728 /* UnionOrIntersection */ ? getReducedType(type) :
+                    ts.getObjectFlags(type) & 4 /* Reference */ ? type.node ? createTypeReference(type.target, getTypeArguments(type)) : getSingleBaseForNonAugmentingSubtype(type) || type :
+                        type.flags & 3145728 /* UnionOrIntersection */ ? getNormalizedUnionOrIntersectionType(type, writing) :
                             type.flags & 33554432 /* Substitution */ ? writing ? type.baseType : type.substitute :
                                 type.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(type, writing) :
                                     type;
-                t = getSingleBaseForNonAugmentingSubtype(t) || t;
                 if (t === type)
-                    break;
+                    return t;
                 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;
         }
         /**
@@ -64901,6 +64967,7 @@ var ts;
                 return 0 /* False */;
             }
             function reportErrorResults(originalSource, originalTarget, source, target, headMessage) {
+                var _a, _b;
                 var sourceHasBase = !!getSingleBaseForNonAugmentingSubtype(originalSource);
                 var targetHasBase = !!getSingleBaseForNonAugmentingSubtype(originalTarget);
                 source = (originalSource.aliasSymbol || sourceHasBase) ? originalSource : source;
@@ -64941,6 +65008,9 @@ var ts;
                     return;
                 }
                 reportRelationError(headMessage, source, target);
+                if (strictNullChecks && source.flags & 8650752 /* TypeVariable */ && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source) && isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864 /* NonPrimitive */))) {
+                    associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_probably_needs_an_extends_object_constraint));
+                }
             }
             function traceUnionsOrIntersectionsTooLarge(source, target) {
                 if (!ts.tracing) {
@@ -65727,13 +65797,6 @@ var ts;
                     // IndexedAccess comparisons are handled above in the `targetFlags & TypeFlage.IndexedAccess` branch
                     if (!(sourceFlags & 8388608 /* IndexedAccess */ && targetFlags & 8388608 /* IndexedAccess */)) {
                         var constraint = getConstraintOfType(source) || unknownType;
-                        if (!getConstraintOfType(source) || (sourceFlags & 262144 /* TypeParameter */ && constraint.flags & 1 /* Any */)) {
-                            // A type variable with no constraint is not related to the non-primitive object type.
-                            if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864 /* NonPrimitive */), 3 /* Both */)) {
-                                resetErrorInfo(saveErrorInfo);
-                                return result;
-                            }
-                        }
                         // hi-speed no-this-instantiation check (less accurate, but avoids costly `this`-instantiation when the constraint will suffice), see #28231 for report on why this is needed
                         if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
                             resetErrorInfo(saveErrorInfo);
@@ -67207,9 +67270,11 @@ var ts;
                 return getSupertypeOrUnion(types);
             }
             var primaryTypes = ts.filter(types, function (t) { return !(t.flags & 98304 /* Nullable */); });
-            return primaryTypes.length ?
-                getNullableType(getSupertypeOrUnion(primaryTypes), getFalsyFlagsOfTypes(types) & 98304 /* Nullable */) :
-                getUnionType(types, 2 /* Subtype */);
+            if (primaryTypes.length) {
+                var supertypeOrUnion = getSupertypeOrUnion(primaryTypes);
+                return primaryTypes === types ? supertypeOrUnion : getUnionType(__spreadArray([supertypeOrUnion], ts.filter(types, function (t) { return !!(t.flags & 98304 /* Nullable */); }), true));
+            }
+            return getUnionType(types, 2 /* Subtype */);
         }
         // Return the leftmost type for which no type to the right is a subtype.
         function getCommonSubtype(types) {
@@ -67396,29 +67461,8 @@ var ts;
             var value = _a.value;
             return value.base10Value === "0";
         }
-        function getFalsyFlagsOfTypes(types) {
-            var result = 0;
-            for (var _i = 0, types_14 = types; _i < types_14.length; _i++) {
-                var t = types_14[_i];
-                result |= getFalsyFlags(t);
-            }
-            return result;
-        }
-        // Returns the String, Number, Boolean, StringLiteral, NumberLiteral, BooleanLiteral, Void, Undefined, or Null
-        // flags for the string, number, boolean, "", 0, false, void, undefined, or null types respectively. Returns
-        // no flags for all other types (including non-falsy literal types).
-        function getFalsyFlags(type) {
-            return type.flags & 1048576 /* Union */ ? getFalsyFlagsOfTypes(type.types) :
-                type.flags & 128 /* StringLiteral */ ? type.value === "" ? 128 /* StringLiteral */ : 0 :
-                    type.flags & 256 /* NumberLiteral */ ? type.value === 0 ? 256 /* NumberLiteral */ : 0 :
-                        type.flags & 2048 /* BigIntLiteral */ ? isZeroBigInt(type) ? 2048 /* BigIntLiteral */ : 0 :
-                            type.flags & 512 /* BooleanLiteral */ ? (type === falseType || type === regularFalseType) ? 512 /* BooleanLiteral */ : 0 :
-                                type.flags & 117724 /* PossiblyFalsy */;
-        }
         function removeDefinitelyFalsyTypes(type) {
-            return getFalsyFlags(type) & 117632 /* DefinitelyFalsy */ ?
-                filterType(type, function (t) { return !(getFalsyFlags(t) & 117632 /* DefinitelyFalsy */); }) :
-                type;
+            return filterType(type, function (t) { return !!(getTypeFacts(t) & 4194304 /* Truthy */); });
         }
         function extractDefinitelyFalsyTypes(type) {
             return mapType(type, getDefinitelyFalsyPartOfType);
@@ -67453,20 +67497,15 @@ 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, [reducedType]) :
-                reducedType;
+                getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [type]) :
+                getIntersectionType([type, emptyObjectType]);
         }
         function getNonNullableType(type) {
-            return strictNullChecks ? getGlobalNonNullableTypeInstantiation(type) : type;
+            return strictNullChecks ? getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type;
         }
         function addOptionalTypeMarker(type) {
             return strictNullChecks ? getUnionType([type, optionalType]) : type;
@@ -68147,13 +68186,40 @@ var ts;
             return sourceStart.slice(0, startLen) !== targetStart.slice(0, startLen) ||
                 sourceEnd.slice(sourceEnd.length - endLen) !== targetEnd.slice(targetEnd.length - endLen);
         }
-        function isValidBigIntString(s) {
+        /**
+         * Tests whether the provided string can be parsed as a number.
+         * @param s The string to test.
+         * @param roundTripOnly Indicates the resulting number matches the input when converted back to a string.
+         */
+        function isValidNumberString(s, roundTripOnly) {
+            if (s === "")
+                return false;
+            var n = +s;
+            return isFinite(n) && (!roundTripOnly || "" + n === s);
+        }
+        /**
+         * @param text a valid bigint string excluding a trailing `n`, but including a possible prefix `-`. Use `isValidBigIntString(text, roundTripOnly)` before calling this function.
+         */
+        function parseBigIntLiteralType(text) {
+            var negative = text.startsWith("-");
+            var base10Value = ts.parsePseudoBigInt((negative ? text.slice(1) : text) + "n");
+            return getBigIntLiteralType({ negative: negative, base10Value: base10Value });
+        }
+        /**
+         * Tests whether the provided string can be parsed as a bigint.
+         * @param s The string to test.
+         * @param roundTripOnly Indicates the resulting bigint matches the input when converted back to a string.
+         */
+        function isValidBigIntString(s, roundTripOnly) {
+            if (s === "")
+                return false;
             var scanner = ts.createScanner(99 /* ESNext */, /*skipTrivia*/ false);
             var success = true;
             scanner.setOnError(function () { return success = false; });
             scanner.setText(s + "n");
             var result = scanner.scan();
-            if (result === 40 /* MinusToken */) {
+            var negative = result === 40 /* MinusToken */;
+            if (negative) {
                 result = scanner.scan();
             }
             var flags = scanner.getTokenFlags();
@@ -68162,7 +68228,8 @@ var ts;
             // * a bigint can be scanned, and that when it is scanned, it is
             // * the full length of the input string (so the scanner is one character beyond the augmented input length)
             // * it does not contain a numeric seperator (the `BigInt` constructor does not accept a numeric seperator in its input)
-            return success && result === 9 /* BigIntLiteral */ && scanner.getTextPos() === (s.length + 1) && !(flags & 512 /* ContainsSeparator */);
+            return success && result === 9 /* BigIntLiteral */ && scanner.getTextPos() === (s.length + 1) && !(flags & 512 /* ContainsSeparator */)
+                && (!roundTripOnly || s === ts.pseudoBigIntToString({ negative: negative, base10Value: ts.parsePseudoBigInt(scanner.getTokenValue()) }));
         }
         function isValidTypeForTemplateLiteralPlaceholder(source, target) {
             if (source === target || target.flags & (1 /* Any */ | 4 /* String */)) {
@@ -68170,8 +68237,8 @@ var ts;
             }
             if (source.flags & 128 /* StringLiteral */) {
                 var value = source.value;
-                return !!(target.flags & 8 /* Number */ && value !== "" && isFinite(+value) ||
-                    target.flags & 64 /* BigInt */ && value !== "" && isValidBigIntString(value) ||
+                return !!(target.flags & 8 /* Number */ && isValidNumberString(value, /*roundTripOnly*/ false) ||
+                    target.flags & 64 /* BigInt */ && isValidBigIntString(value, /*roundTripOnly*/ false) ||
                     target.flags & (512 /* BooleanLiteral */ | 98304 /* Nullable */) && value === target.intrinsicName);
             }
             if (source.flags & 134217728 /* TemplateLiteral */) {
@@ -68582,8 +68649,8 @@ var ts;
             }
             function getSingleTypeVariableFromIntersectionTypes(types) {
                 var typeVariable;
-                for (var _i = 0, types_15 = types; _i < types_15.length; _i++) {
-                    var type = types_15[_i];
+                for (var _i = 0, types_14 = types; _i < types_14.length; _i++) {
+                    var type = types_14[_i];
                     var t = type.flags & 2097152 /* Intersection */ && ts.find(type.types, function (t) { return !!getInferenceInfoForType(t); });
                     if (!t || typeVariable && t !== typeVariable) {
                         return undefined;
@@ -68744,8 +68811,57 @@ var ts;
                 // upon instantiation, would collapse all the placeholders to just 'string', and an assignment check might
                 // succeed. That would be a pointless and confusing outcome.
                 if (matches || ts.every(target.texts, function (s) { return s.length === 0; })) {
+                    var _loop_23 = function (i) {
+                        var source_1 = matches ? matches[i] : neverType;
+                        var target_3 = types[i];
+                        // If we are inferring from a string literal type to a type variable whose constraint includes one of the
+                        // allowed template literal placeholder types, infer from a literal type corresponding to the constraint.
+                        if (source_1.flags & 128 /* StringLiteral */ && target_3.flags & 8650752 /* TypeVariable */) {
+                            var inferenceContext = getInferenceInfoForType(target_3);
+                            var constraint = inferenceContext ? getBaseConstraintOfType(inferenceContext.typeParameter) : undefined;
+                            if (constraint && !isTypeAny(constraint)) {
+                                var constraintTypes = constraint.flags & 1048576 /* Union */ ? constraint.types : [constraint];
+                                var allTypeFlags_1 = ts.reduceLeft(constraintTypes, function (flags, t) { return flags | t.flags; }, 0);
+                                // If the constraint contains `string`, we don't need to look for a more preferred type
+                                if (!(allTypeFlags_1 & 4 /* String */)) {
+                                    var str_1 = source_1.value;
+                                    // If the type contains `number` or a number literal and the string isn't a valid number, exclude numbers
+                                    if (allTypeFlags_1 & 296 /* NumberLike */ && !isValidNumberString(str_1, /*roundTripOnly*/ true)) {
+                                        allTypeFlags_1 &= ~296 /* NumberLike */;
+                                    }
+                                    // If the type contains `bigint` or a bigint literal and the string isn't a valid bigint, exclude bigints
+                                    if (allTypeFlags_1 & 2112 /* BigIntLike */ && !isValidBigIntString(str_1, /*roundTripOnly*/ true)) {
+                                        allTypeFlags_1 &= ~2112 /* BigIntLike */;
+                                    }
+                                    // for each type in the constraint, find the highest priority matching type
+                                    var matchingType = ts.reduceLeft(constraintTypes, function (left, right) {
+                                        return !(right.flags & allTypeFlags_1) ? left :
+                                            left.flags & 4 /* String */ ? left : right.flags & 4 /* String */ ? source_1 :
+                                                left.flags & 134217728 /* TemplateLiteral */ ? left : right.flags & 134217728 /* TemplateLiteral */ && isTypeMatchedByTemplateLiteralType(source_1, right) ? source_1 :
+                                                    left.flags & 268435456 /* StringMapping */ ? left : right.flags & 268435456 /* StringMapping */ && str_1 === applyStringMapping(right.symbol, str_1) ? source_1 :
+                                                        left.flags & 128 /* StringLiteral */ ? left : right.flags & 128 /* StringLiteral */ && right.value === str_1 ? right :
+                                                            left.flags & 8 /* Number */ ? left : right.flags & 8 /* Number */ ? getNumberLiteralType(+str_1) :
+                                                                left.flags & 32 /* Enum */ ? left : right.flags & 32 /* Enum */ ? getNumberLiteralType(+str_1) :
+                                                                    left.flags & 256 /* NumberLiteral */ ? left : right.flags & 256 /* NumberLiteral */ && right.value === +str_1 ? right :
+                                                                        left.flags & 64 /* BigInt */ ? left : right.flags & 64 /* BigInt */ ? parseBigIntLiteralType(str_1) :
+                                                                            left.flags & 2048 /* BigIntLiteral */ ? left : right.flags & 2048 /* BigIntLiteral */ && ts.pseudoBigIntToString(right.value) === str_1 ? right :
+                                                                                left.flags & 16 /* Boolean */ ? left : right.flags & 16 /* Boolean */ ? str_1 === "true" ? trueType : str_1 === "false" ? falseType : booleanType :
+                                                                                    left.flags & 512 /* BooleanLiteral */ ? left : right.flags & 512 /* BooleanLiteral */ && right.intrinsicName === str_1 ? right :
+                                                                                        left.flags & 32768 /* Undefined */ ? left : right.flags & 32768 /* Undefined */ && right.intrinsicName === str_1 ? right :
+                                                                                            left.flags & 65536 /* Null */ ? left : right.flags & 65536 /* Null */ && right.intrinsicName === str_1 ? right :
+                                                                                                left;
+                                    }, neverType);
+                                    if (!(matchingType.flags & 131072 /* Never */)) {
+                                        inferFromTypes(matchingType, target_3);
+                                        return "continue";
+                                    }
+                                }
+                            }
+                        }
+                        inferFromTypes(source_1, target_3);
+                    };
                     for (var i = 0; i < types.length; i++) {
-                        inferFromTypes(matches ? matches[i] : neverType, types[i]);
+                        _loop_23(i);
                     }
                 }
             }
@@ -69263,7 +69379,7 @@ var ts;
         function mapTypesByKeyProperty(types, name) {
             var map = new ts.Map();
             var count = 0;
-            var _loop_23 = function (type) {
+            var _loop_24 = function (type) {
                 if (type.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 58982400 /* InstantiableNonPrimitive */)) {
                     var discriminant = getTypeOfPropertyOfType(type, name);
                     if (discriminant) {
@@ -69287,9 +69403,9 @@ var ts;
                     }
                 }
             };
-            for (var _i = 0, types_16 = types; _i < types_16.length; _i++) {
-                var type = types_16[_i];
-                var state_9 = _loop_23(type);
+            for (var _i = 0, types_15 = types; _i < types_15.length; _i++) {
+                var type = types_15[_i];
+                var state_9 = _loop_24(type);
                 if (typeof state_9 === "object")
                     return state_9.value;
             }
@@ -69403,14 +69519,16 @@ var ts;
             return !!(resolved.callSignatures.length || resolved.constructSignatures.length ||
                 resolved.members.get("bind") && isTypeSubtypeOf(type, globalFunctionType));
         }
-        function getTypeFacts(type, ignoreObjects) {
-            if (ignoreObjects === void 0) { ignoreObjects = false; }
+        function getTypeFacts(type) {
+            if (type.flags & (2097152 /* Intersection */ | 465829888 /* Instantiable */)) {
+                type = getBaseConstraintOfType(type) || unknownType;
+            }
             var flags = type.flags;
-            if (flags & 4 /* String */) {
+            if (flags & (4 /* String */ | 268435456 /* StringMapping */)) {
                 return strictNullChecks ? 16317953 /* StringStrictFacts */ : 16776705 /* StringFacts */;
             }
-            if (flags & 128 /* StringLiteral */) {
-                var isEmpty = type.value === "";
+            if (flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */)) {
+                var isEmpty = flags & 128 /* StringLiteral */ && type.value === "";
                 return strictNullChecks ?
                     isEmpty ? 12123649 /* EmptyStringStrictFacts */ : 7929345 /* NonEmptyStringStrictFacts */ :
                     isEmpty ? 12582401 /* EmptyStringFacts */ : 16776705 /* NonEmptyStringFacts */;
@@ -69442,20 +69560,20 @@ var ts;
                     (type === falseType || type === regularFalseType) ? 12580616 /* FalseFacts */ : 16774920 /* TrueFacts */;
             }
             if (flags & 524288 /* Object */) {
-                if (ignoreObjects) {
-                    return 16768959 /* AndFactsMask */; // This is the identity element for computing type facts of intersection.
-                }
                 return ts.getObjectFlags(type) & 16 /* Anonymous */ && isEmptyObjectType(type) ?
-                    strictNullChecks ? 16318463 /* EmptyObjectStrictFacts */ : 16777215 /* EmptyObjectFacts */ :
+                    strictNullChecks ? 83427327 /* EmptyObjectStrictFacts */ : 83886079 /* EmptyObjectFacts */ :
                     isFunctionObjectType(type) ?
                         strictNullChecks ? 7880640 /* FunctionStrictFacts */ : 16728000 /* FunctionFacts */ :
                         strictNullChecks ? 7888800 /* ObjectStrictFacts */ : 16736160 /* ObjectFacts */;
             }
-            if (flags & (16384 /* Void */ | 32768 /* Undefined */)) {
-                return 9830144 /* UndefinedFacts */;
+            if (flags & 16384 /* Void */) {
+                return 9830144 /* VoidFacts */;
+            }
+            if (flags & 32768 /* Undefined */) {
+                return 26607360 /* UndefinedFacts */;
             }
             if (flags & 65536 /* Null */) {
-                return 9363232 /* NullFacts */;
+                return 42917664 /* NullFacts */;
             }
             if (flags & 12288 /* ESSymbolLike */) {
                 return strictNullChecks ? 7925520 /* SymbolStrictFacts */ : 16772880 /* SymbolFacts */;
@@ -69466,37 +69584,56 @@ var ts;
             if (flags & 131072 /* Never */) {
                 return 0 /* None */;
             }
-            if (flags & 465829888 /* Instantiable */) {
-                return !isPatternLiteralType(type) ? getTypeFacts(getBaseConstraintOfType(type) || unknownType, ignoreObjects) :
-                    strictNullChecks ? 7929345 /* NonEmptyStringStrictFacts */ : 16776705 /* NonEmptyStringFacts */;
-            }
             if (flags & 1048576 /* Union */) {
-                return ts.reduceLeft(type.types, function (facts, t) { return facts | getTypeFacts(t, ignoreObjects); }, 0 /* None */);
+                return ts.reduceLeft(type.types, function (facts, t) { return facts | getTypeFacts(t); }, 0 /* None */);
             }
             if (flags & 2097152 /* Intersection */) {
-                // When an intersection contains a primitive type we ignore object type constituents as they are
-                // presumably type tags. For example, in string & { __kind__: "name" } we ignore the object type.
-                ignoreObjects || (ignoreObjects = maybeTypeOfKind(type, 131068 /* Primitive */));
-                return getIntersectionTypeFacts(type, ignoreObjects);
+                return getIntersectionTypeFacts(type);
             }
-            return 16777215 /* All */;
+            return 83886079 /* UnknownFacts */;
         }
-        function getIntersectionTypeFacts(type, ignoreObjects) {
+        function getIntersectionTypeFacts(type) {
+            // When an intersection contains a primitive type we ignore object type constituents as they are
+            // presumably type tags. For example, in string & { __kind__: "name" } we ignore the object type.
+            var ignoreObjects = maybeTypeOfKind(type, 131068 /* Primitive */);
             // When computing the type facts of an intersection type, certain type facts are computed as `and`
             // and others are computed as `or`.
             var oredFacts = 0 /* None */;
-            var andedFacts = 16777215 /* All */;
+            var andedFacts = 134217727 /* All */;
             for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
                 var t = _a[_i];
-                var f = getTypeFacts(t, ignoreObjects);
-                oredFacts |= f;
-                andedFacts &= f;
+                if (!(ignoreObjects && t.flags & 524288 /* Object */)) {
+                    var f = getTypeFacts(t);
+                    oredFacts |= f;
+                    andedFacts &= f;
+                }
             }
-            return oredFacts & 8256 /* OrFactsMask */ | andedFacts & 16768959 /* AndFactsMask */;
+            return oredFacts & 8256 /* OrFactsMask */ | andedFacts & 134209471 /* AndFactsMask */;
         }
         function getTypeWithFacts(type, include) {
             return filterType(type, function (t) { return (getTypeFacts(t) & include) !== 0; });
         }
+        // This function is similar to getTypeWithFacts, except that in strictNullChecks mode it replaces type
+        // unknown with the union {} | null | undefined (and reduces that accordingly), and it intersects remaining
+        // instantiable types with {}, {} | null, or {} | undefined in order to remove null and/or undefined.
+        function getAdjustedTypeWithFacts(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)]) :
@@ -69745,8 +69882,8 @@ var ts;
             var types = origin && origin.flags & 1048576 /* Union */ ? origin.types : type.types;
             var mappedTypes;
             var changed = false;
-            for (var _i = 0, types_17 = types; _i < types_17.length; _i++) {
-                var t = types_17[_i];
+            for (var _i = 0, types_16 = types; _i < types_16.length; _i++) {
+                var t = types_16[_i];
                 var mapped = t.flags & 1048576 /* Union */ ? mapType(t, mapper, noReductions) : mapper(t);
                 changed || (changed = t !== mapped);
                 if (mapped) {
@@ -69832,8 +69969,8 @@ var ts;
         }
         function isEvolvingArrayTypeList(types) {
             var hasEvolvingArrayType = false;
-            for (var _i = 0, types_18 = types; _i < types_18.length; _i++) {
-                var t = types_18[_i];
+            for (var _i = 0, types_17 = types; _i < types_17.length; _i++) {
+                var t = types_17[_i];
                 if (!(t.flags & 131072 /* Never */)) {
                     if (!(ts.getObjectFlags(t) & 256 /* EvolvingArray */)) {
                         return false;
@@ -70554,7 +70691,7 @@ var ts;
                 if (isEvolvingArrayTypeList(types)) {
                     return getEvolvingArrayType(getUnionType(ts.map(types, getElementTypeOfEvolvingArrayType)));
                 }
-                var result = getUnionType(ts.sameMap(types, finalizeEvolvingArrayType), subtypeReduction);
+                var result = recombineUnknownType(getUnionType(ts.sameMap(types, finalizeEvolvingArrayType), subtypeReduction));
                 if (result !== declaredType && result.flags & declaredType.flags & 1048576 /* Union */ && ts.arraysEqual(result.types, declaredType.types)) {
                     return declaredType;
                 }
@@ -70656,11 +70793,10 @@ var ts;
             }
             function narrowTypeByTruthiness(type, expr, assumeTrue) {
                 if (isMatchingReference(reference, expr)) {
-                    return type.flags & 2 /* Unknown */ && assumeTrue ? nonNullUnknownType :
-                        getTypeWithFacts(type, assumeTrue ? 4194304 /* Truthy */ : 8388608 /* Falsy */);
+                    return getAdjustedTypeWithFacts(type, assumeTrue ? 4194304 /* Truthy */ : 8388608 /* Falsy */);
                 }
                 if (strictNullChecks && assumeTrue && optionalChainContainsReference(expr, reference)) {
-                    type = getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
+                    type = getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
                 }
                 var access = getDiscriminantPropertyAccess(expr, type);
                 if (access) {
@@ -70800,7 +70936,7 @@ var ts;
                 // Note that we include any and unknown in the exclusion test because their domain includes null and undefined.
                 var removeNullable = equalsOperator !== assumeTrue && everyType(valueType, function (t) { return !!(t.flags & nullableFlags); }) ||
                     equalsOperator === assumeTrue && everyType(valueType, function (t) { return !(t.flags & (3 /* AnyOrUnknown */ | nullableFlags)); });
-                return removeNullable ? getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type;
+                return removeNullable ? getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type;
             }
             function narrowTypeByEquality(type, operator, value, assumeTrue) {
                 if (type.flags & 1 /* Any */) {
@@ -70810,9 +70946,6 @@ 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;
@@ -70832,7 +70965,7 @@ var ts;
                         valueType.flags & 65536 /* Null */ ?
                             assumeTrue ? 131072 /* EQNull */ : 1048576 /* NENull */ :
                             assumeTrue ? 65536 /* EQUndefined */ : 524288 /* NEUndefined */;
-                    return type.flags & 2 /* Unknown */ && facts & (1048576 /* NENull */ | 2097152 /* NEUndefinedOrNull */) ? nonNullUnknownType : getTypeWithFacts(type, facts);
+                    return getAdjustedTypeWithFacts(type, facts);
                 }
                 if (assumeTrue) {
                     var filterFn = operator === 34 /* EqualsEqualsToken */ ?
@@ -70853,24 +70986,18 @@ var ts;
                 var target = getReferenceCandidate(typeOfExpr.expression);
                 if (!isMatchingReference(reference, target)) {
                     if (strictNullChecks && optionalChainContainsReference(target, reference) && assumeTrue === (literal.text !== "undefined")) {
-                        return getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
+                        return getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
                     }
                     return type;
                 }
                 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 ? mapType(type, narrowUnionMemberByTypeof(impliedType)) : type, facts);
+                return getTypeWithFacts(assumeTrue && impliedType ? narrowTypeByImpliedType(type, impliedType) : type, facts);
             }
             function narrowTypeBySwitchOptionalChainContainment(type, switchStatement, clauseStart, clauseEnd, clauseCheck) {
                 var everyClauseChecks = clauseStart !== clauseEnd && ts.every(getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd), clauseCheck);
@@ -70919,10 +71046,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);
                 }
@@ -70933,22 +71060,27 @@ 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 narrowUnionMemberByTypeof(candidate) {
-                return function (type) {
-                    if (isTypeSubtypeOf(type, candidate)) {
-                        return type;
-                    }
-                    if (isTypeSubtypeOf(candidate, type)) {
-                        return candidate;
+            function narrowTypeByImpliedType(type, candidate) {
+                if (type.flags & 3 /* AnyOrUnknown */) {
+                    return candidate;
+                }
+                return mapType(type, function (t) {
+                    if (isTypeRelatedTo(t, candidate, strictSubtypeRelation)) {
+                        return t;
                     }
-                    if (type.flags & 465829888 /* Instantiable */) {
-                        var constraint = getBaseConstraintOfType(type) || anyType;
-                        if (isTypeSubtypeOf(candidate, constraint)) {
-                            return getIntersectionType([type, candidate]);
+                    return mapType(candidate, function (c) {
+                        if (!areTypesComparable(t, c)) {
+                            return neverType;
                         }
-                    }
-                    return type;
-                };
+                        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]);
+                    });
+                });
             }
             function narrowBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) {
                 var switchWitnesses = getSwitchClauseTypeOfWitnesses(switchStatement, /*retainDefault*/ true);
@@ -71007,7 +71139,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(mapType(type, narrowUnionMemberByTypeof(impliedType)), switchFacts);
+                return getTypeWithFacts(narrowTypeByImpliedType(type, impliedType), switchFacts);
             }
             function isMatchingConstructorReference(expr) {
                 return (ts.isPropertyAccessExpression(expr) && ts.idText(expr.name) === "constructor" ||
@@ -71058,7 +71190,7 @@ var ts;
                 var left = getReferenceCandidate(expr.left);
                 if (!isMatchingReference(reference, left)) {
                     if (assumeTrue && strictNullChecks && optionalChainContainsReference(left, reference)) {
-                        return getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
+                        return getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
                     }
                     return type;
                 }
@@ -71146,7 +71278,7 @@ var ts;
                         }
                         if (strictNullChecks && assumeTrue && optionalChainContainsReference(predicateArgument, reference) &&
                             !(getTypeFacts(predicate.type) & 65536 /* EQUndefined */)) {
-                            type = getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
+                            type = getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
                         }
                         var access = getDiscriminantPropertyAccess(predicateArgument, type);
                         if (access) {
@@ -71203,7 +71335,7 @@ var ts;
             }
             function narrowTypeByOptionality(type, expr, assumePresent) {
                 if (isMatchingReference(reference, expr)) {
-                    return getTypeWithFacts(type, assumePresent ? 2097152 /* NEUndefinedOrNull */ : 262144 /* EQUndefinedOrNull */);
+                    return getAdjustedTypeWithFacts(type, assumePresent ? 2097152 /* NEUndefinedOrNull */ : 262144 /* EQUndefinedOrNull */);
                 }
                 var access = getDiscriminantPropertyAccess(expr, type);
                 if (access) {
@@ -71289,8 +71421,8 @@ var ts;
                 var annotationIncludesUndefined = strictNullChecks &&
                     declaration.kind === 164 /* Parameter */ &&
                     declaration.initializer &&
-                    getFalsyFlags(declaredType) & 32768 /* Undefined */ &&
-                    !(getFalsyFlags(checkExpression(declaration.initializer)) & 32768 /* Undefined */);
+                    getTypeFacts(declaredType) & 16777216 /* IsUndefined */ &&
+                    !(getTypeFacts(checkExpression(declaration.initializer)) & 16777216 /* IsUndefined */);
                 popTypeResolution();
                 return annotationIncludesUndefined ? getTypeWithFacts(declaredType, 524288 /* NEUndefined */) : declaredType;
             }
@@ -71311,7 +71443,9 @@ var ts;
                     !(someType(type, isGenericTypeWithoutNullableConstraint) && isGenericIndexType(getTypeOfExpression(parent.argumentExpression)));
         }
         function isGenericTypeWithUnionConstraint(type) {
-            return !!(type.flags & 465829888 /* Instantiable */ && getBaseConstraintOrType(type).flags & (98304 /* Nullable */ | 1048576 /* Union */));
+            return type.flags & 2097152 /* Intersection */ ?
+                ts.some(type.types, isGenericTypeWithUnionConstraint) :
+                !!(type.flags & 465829888 /* Instantiable */ && getBaseConstraintOrType(type).flags & (98304 /* Nullable */ | 1048576 /* Union */));
         }
         function isGenericTypeWithoutNullableConstraint(type) {
             return !!(type.flags & 465829888 /* Instantiable */ && !maybeTypeOfKind(getBaseConstraintOrType(type), 98304 /* Nullable */));
@@ -71339,7 +71473,7 @@ var ts;
             var substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) &&
                 someType(type, isGenericTypeWithUnionConstraint) &&
                 (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
-            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ ? getBaseConstraintOrType(t) : t; }) : type;
+            return substituteConstraints ? mapType(type, getBaseConstraintOrType) : type;
         }
         function isExportOrExportExpression(location) {
             return !!ts.findAncestor(location, function (n) {
@@ -71616,7 +71750,7 @@ var ts;
                     return convertAutoToAny(flowType);
                 }
             }
-            else if (!assumeInitialized && !(getFalsyFlags(type) & 32768 /* Undefined */) && getFalsyFlags(flowType) & 32768 /* Undefined */) {
+            else if (!assumeInitialized && !(getTypeFacts(type) & 16777216 /* IsUndefined */) && getTypeFacts(flowType) & 16777216 /* IsUndefined */) {
                 error(node, ts.Diagnostics.Variable_0_is_used_before_being_assigned, symbolToString(symbol));
                 // Return the declared type to reduce follow-on errors
                 return type;
@@ -73145,8 +73279,8 @@ var ts;
             }
             var signatureList;
             var types = type.types;
-            for (var _i = 0, types_19 = types; _i < types_19.length; _i++) {
-                var current = types_19[_i];
+            for (var _i = 0, types_18 = types; _i < types_18.length; _i++) {
+                var current = types_18[_i];
                 var signature = getContextualCallSignature(current, node);
                 if (signature) {
                     if (!signatureList) {
@@ -74308,19 +74442,19 @@ var ts;
             return checkNonNullType(checkExpression(node), node);
         }
         function isNullableType(type) {
-            return !!((strictNullChecks ? getFalsyFlags(type) : type.flags) & 98304 /* Nullable */);
+            return !!(getTypeFacts(type) & 50331648 /* IsUndefinedOrNull */);
         }
         function getNonNullableTypeIfNeeded(type) {
             return isNullableType(type) ? getNonNullableType(type) : type;
         }
-        function reportObjectPossiblyNullOrUndefinedError(node, flags) {
-            error(node, flags & 32768 /* Undefined */ ? flags & 65536 /* Null */ ?
+        function reportObjectPossiblyNullOrUndefinedError(node, facts) {
+            error(node, facts & 16777216 /* IsUndefined */ ? facts & 33554432 /* IsNull */ ?
                 ts.Diagnostics.Object_is_possibly_null_or_undefined :
                 ts.Diagnostics.Object_is_possibly_undefined :
                 ts.Diagnostics.Object_is_possibly_null);
         }
-        function reportCannotInvokePossiblyNullOrUndefinedError(node, flags) {
-            error(node, flags & 32768 /* Undefined */ ? flags & 65536 /* Null */ ?
+        function reportCannotInvokePossiblyNullOrUndefinedError(node, facts) {
+            error(node, facts & 16777216 /* IsUndefined */ ? facts & 33554432 /* IsNull */ ?
                 ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_null_or_undefined :
                 ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_undefined :
                 ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_null);
@@ -74330,9 +74464,9 @@ var ts;
                 error(node, ts.Diagnostics.Object_is_of_type_unknown);
                 return errorType;
             }
-            var kind = (strictNullChecks ? getFalsyFlags(type) : type.flags) & 98304 /* Nullable */;
-            if (kind) {
-                reportError(node, kind);
+            var facts = getTypeFacts(type);
+            if (facts & 50331648 /* IsUndefinedOrNull */) {
+                reportError(node, facts);
                 var t = getNonNullableType(type);
                 return t.flags & (98304 /* Nullable */ | 131072 /* Never */) ? errorType : t;
             }
@@ -74627,7 +74761,7 @@ var ts;
                 assumeUninitialized = true;
             }
             var flowType = getFlowTypeOfReference(node, propType, assumeUninitialized ? getOptionalType(propType) : propType);
-            if (assumeUninitialized && !(getFalsyFlags(propType) & 32768 /* Undefined */) && getFalsyFlags(flowType) & 32768 /* Undefined */) {
+            if (assumeUninitialized && !(getTypeFacts(propType) & 16777216 /* IsUndefined */) && getTypeFacts(flowType) & 16777216 /* IsUndefined */) {
                 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;
@@ -75677,7 +75811,7 @@ var ts;
             if (spreadIndex >= 0) {
                 // Create synthetic arguments from spreads of tuple types.
                 var effectiveArgs_1 = args.slice(0, spreadIndex);
-                var _loop_24 = function (i) {
+                var _loop_25 = function (i) {
                     var arg = args[i];
                     // We can call checkExpressionCached because spread expressions never have a contextual type.
                     var spreadType = arg.kind === 225 /* SpreadElement */ && (flowLoopCount ? checkExpression(arg.expression) : checkExpressionCached(arg.expression));
@@ -75694,7 +75828,7 @@ var ts;
                     }
                 };
                 for (var i = spreadIndex; i < args.length; i++) {
-                    _loop_24(i);
+                    _loop_25(i);
                 }
                 return effectiveArgs_1;
             }
@@ -76014,7 +76148,7 @@ var ts;
                         var min_3 = Number.MAX_VALUE;
                         var minIndex = 0;
                         var i_1 = 0;
-                        var _loop_25 = function (c) {
+                        var _loop_26 = function (c) {
                             var chain_2 = function () { return ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Overload_0_of_1_2_gave_the_following_error, i_1 + 1, candidates.length, signatureToString(c)); };
                             var diags_2 = getSignatureApplicabilityError(node, args, c, assignableRelation, 0 /* Normal */, /*reportErrors*/ true, chain_2);
                             if (diags_2) {
@@ -76032,7 +76166,7 @@ var ts;
                         };
                         for (var _a = 0, candidatesForArgumentError_1 = candidatesForArgumentError; _a < candidatesForArgumentError_1.length; _a++) {
                             var c = candidatesForArgumentError_1[_a];
-                            _loop_25(c);
+                            _loop_26(c);
                         }
                         var diags_3 = max > 1 ? allDiagnostics[minIndex] : ts.flatten(allDiagnostics);
                         ts.Debug.assert(diags_3.length > 0, "No errors reported for 3 or fewer overload signatures");
@@ -76190,7 +76324,7 @@ var ts;
             }
             var _a = ts.minAndMax(candidates, getNumNonRestParameters), minArgumentCount = _a.min, maxNonRestParam = _a.max;
             var parameters = [];
-            var _loop_26 = function (i) {
+            var _loop_27 = function (i) {
                 var symbols = ts.mapDefined(candidates, function (s) { return signatureHasRestParameter(s) ?
                     i < s.parameters.length - 1 ? s.parameters[i] : ts.last(s.parameters) :
                     i < s.parameters.length ? s.parameters[i] : undefined; });
@@ -76198,7 +76332,7 @@ var ts;
                 parameters.push(createCombinedSymbolFromTypes(symbols, ts.mapDefined(candidates, function (candidate) { return tryGetTypeAtPosition(candidate, i); })));
             };
             for (var i = 0; i < maxNonRestParam; i++) {
-                _loop_26(i);
+                _loop_27(i);
             }
             var restParameterSymbols = ts.mapDefined(candidates, function (c) { return signatureHasRestParameter(c) ? ts.last(c.parameters) : undefined; });
             var flags = 0 /* None */;
@@ -76543,8 +76677,8 @@ var ts;
             if (apparentType.flags & 1048576 /* Union */) {
                 var types = apparentType.types;
                 var hasSignatures = false;
-                for (var _i = 0, types_20 = types; _i < types_20.length; _i++) {
-                    var constituent = types_20[_i];
+                for (var _i = 0, types_19 = types; _i < types_19.length; _i++) {
+                    var constituent = types_19[_i];
                     var signatures = getSignaturesOfType(constituent, kind);
                     if (signatures.length !== 0) {
                         hasSignatures = true;
@@ -78235,7 +78369,7 @@ var ts;
             var type = getTypeOfSymbol(symbol);
             if (strictNullChecks &&
                 !(type.flags & (3 /* AnyOrUnknown */ | 131072 /* Never */)) &&
-                !(exactOptionalPropertyTypes ? symbol.flags & 16777216 /* Optional */ : getFalsyFlags(type) & 32768 /* Undefined */)) {
+                !(exactOptionalPropertyTypes ? symbol.flags & 16777216 /* Optional */ : getTypeFacts(type) & 16777216 /* IsUndefined */)) {
                 error(expr, ts.Diagnostics.The_operand_of_a_delete_operator_must_be_optional);
             }
         }
@@ -78403,8 +78537,8 @@ var ts;
             }
             if (type.flags & 3145728 /* UnionOrIntersection */) {
                 var types = type.types;
-                for (var _i = 0, types_21 = types; _i < types_21.length; _i++) {
-                    var t = types_21[_i];
+                for (var _i = 0, types_20 = types; _i < types_20.length; _i++) {
+                    var t = types_20[_i];
                     if (maybeTypeOfKind(t, kind)) {
                         return true;
                     }
@@ -78631,7 +78765,7 @@ var ts;
                     // In strict null checking mode, if a default value of a non-undefined type is specified, remove
                     // undefined from the final type.
                     if (strictNullChecks &&
-                        !(getFalsyFlags(checkExpression(prop.objectAssignmentInitializer)) & 32768 /* Undefined */)) {
+                        !(getTypeFacts(checkExpression(prop.objectAssignmentInitializer)) & 16777216 /* IsUndefined */)) {
                         sourceType = getTypeWithFacts(sourceType, 524288 /* NEUndefined */);
                     }
                     checkBinaryLikeExpression(prop.name, prop.equalsToken, prop.objectAssignmentInitializer, checkMode);
@@ -79031,7 +79165,7 @@ var ts;
                 case 56 /* BarBarToken */:
                 case 75 /* BarBarEqualsToken */: {
                     var resultType_3 = getTypeFacts(leftType) & 8388608 /* Falsy */ ?
-                        getUnionType([removeDefinitelyFalsyTypes(leftType), rightType], 2 /* Subtype */) :
+                        getUnionType([getNonNullableType(removeDefinitelyFalsyTypes(leftType)), rightType], 2 /* Subtype */) :
                         leftType;
                     if (operator === 75 /* BarBarEqualsToken */) {
                         checkAssignmentOperator(rightType);
@@ -80255,7 +80389,7 @@ var ts;
             var indexSymbol = getIndexSymbol(getSymbolOfNode(node));
             if (indexSymbol === null || indexSymbol === void 0 ? void 0 : indexSymbol.declarations) {
                 var indexSignatureMap_1 = new ts.Map();
-                var _loop_27 = function (declaration) {
+                var _loop_28 = function (declaration) {
                     if (declaration.parameters.length === 1 && declaration.parameters[0].type) {
                         forEachType(getTypeFromTypeNode(declaration.parameters[0].type), function (type) {
                             var entry = indexSignatureMap_1.get(getTypeId(type));
@@ -80270,7 +80404,7 @@ var ts;
                 };
                 for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) {
                     var declaration = _a[_i];
-                    _loop_27(declaration);
+                    _loop_28(declaration);
                 }
                 indexSignatureMap_1.forEach(function (entry) {
                     if (entry.declarations.length > 1) {
@@ -81572,8 +81706,8 @@ var ts;
         }
         function getEntityNameForDecoratorMetadataFromTypeList(types) {
             var commonEntityName;
-            for (var _i = 0, types_22 = types; _i < types_22.length; _i++) {
-                var typeNode = types_22[_i];
+            for (var _i = 0, types_21 = types; _i < types_21.length; _i++) {
+                var typeNode = types_21[_i];
                 while (typeNode.kind === 191 /* ParenthesizedType */ || typeNode.kind === 197 /* NamedTupleMember */) {
                     typeNode = typeNode.type; // Skip parens if need be
                 }
@@ -82439,7 +82573,7 @@ var ts;
             // For a binding pattern, validate the initializer and exit
             if (ts.isBindingPattern(node.name)) {
                 var needCheckInitializer = node.initializer && node.parent.parent.kind !== 243 /* ForInStatement */;
-                var needCheckWidenedType = node.name.elements.length === 0;
+                var needCheckWidenedType = !ts.some(node.name.elements, ts.not(ts.isOmittedExpression));
                 if (needCheckInitializer || needCheckWidenedType) {
                     // Don't validate for-in initializer as it is already an error
                     var widenedType = getWidenedTypeForVariableLikeDeclaration(node);
@@ -82466,7 +82600,7 @@ var ts;
             }
             // For a commonjs `const x = require`, validate the alias and exit
             var symbol = getSymbolOfNode(node);
-            if (symbol.flags & 2097152 /* Alias */ && ts.isVariableDeclarationInitializedToBareOrAccessedRequire(node)) {
+            if (symbol.flags & 2097152 /* Alias */ && ts.isVariableDeclarationInitializedToBareOrAccessedRequire(node.kind === 203 /* BindingElement */ ? node.parent.parent : node)) {
                 checkAliasSymbol(node);
                 return;
             }
@@ -82592,7 +82726,7 @@ var ts;
                     return;
                 var type = checkTruthinessExpression(location);
                 var isPropertyExpressionCast = ts.isPropertyAccessExpression(location) && isTypeAssertion(location.expression);
-                if (getFalsyFlags(type) || isPropertyExpressionCast)
+                if (!(getTypeFacts(type) & 4194304 /* Truthy */) || isPropertyExpressionCast)
                     return;
                 // While it technically should be invalid for any known-truthy value
                 // to be tested, we de-scope to functions and Promises unreferenced in
@@ -83731,7 +83865,7 @@ var ts;
             var interfaceDeclaration = ts.getObjectFlags(type) & 2 /* Interface */ ? ts.getDeclarationOfKind(type.symbol, 258 /* InterfaceDeclaration */) : undefined;
             var localPropDeclaration = declaration && declaration.kind === 221 /* BinaryExpression */ ||
                 name && name.kind === 162 /* ComputedPropertyName */ || getParentOfSymbol(prop) === type.symbol ? declaration : undefined;
-            var _loop_28 = function (info) {
+            var _loop_29 = function (info) {
                 var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined;
                 // We check only when (a) the property is declared in the containing type, or (b) the applicable index signature is declared
                 // in the containing type, or (c) the containing type is an interface and no base interface contains both the property and
@@ -83744,7 +83878,7 @@ var ts;
             };
             for (var _i = 0, indexInfos_9 = indexInfos; _i < indexInfos_9.length; _i++) {
                 var info = indexInfos_9[_i];
-                _loop_28(info);
+                _loop_29(info);
             }
         }
         function checkIndexConstraintForIndexSignature(type, checkInfo) {
@@ -83752,7 +83886,7 @@ var ts;
             var indexInfos = getApplicableIndexInfos(type, checkInfo.keyType);
             var interfaceDeclaration = ts.getObjectFlags(type) & 2 /* Interface */ ? ts.getDeclarationOfKind(type.symbol, 258 /* InterfaceDeclaration */) : undefined;
             var localCheckDeclaration = declaration && getParentOfSymbol(getSymbolOfNode(declaration)) === type.symbol ? declaration : undefined;
-            var _loop_29 = function (info) {
+            var _loop_30 = function (info) {
                 if (info === checkInfo)
                     return "continue";
                 var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined;
@@ -83767,7 +83901,7 @@ var ts;
             };
             for (var _i = 0, indexInfos_10 = indexInfos; _i < indexInfos_10.length; _i++) {
                 var info = indexInfos_10[_i];
-                _loop_29(info);
+                _loop_30(info);
             }
         }
         function checkTypeNameIsReserved(name, message) {
@@ -84086,7 +84220,7 @@ var ts;
             var baseTypes = baseTypeNode && getBaseTypes(type);
             var baseWithThis = (baseTypes === null || baseTypes === void 0 ? void 0 : baseTypes.length) ? getTypeWithThisArgument(ts.first(baseTypes), type.thisType) : undefined;
             var baseStaticType = getBaseConstructorTypeOfClass(type);
-            var _loop_30 = function (member) {
+            var _loop_31 = function (member) {
                 if (ts.hasAmbientModifier(member)) {
                     return "continue";
                 }
@@ -84103,7 +84237,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_30(member);
+                _loop_31(member);
             }
         }
         /**
@@ -84191,7 +84325,7 @@ var ts;
         function issueMemberSpecificError(node, typeWithThis, baseWithThis, broadDiag) {
             // iterate over all implemented properties and issue errors on each one which isn't compatible, rather than the class as a whole, if possible
             var issuedMemberError = false;
-            var _loop_31 = function (member) {
+            var _loop_32 = function (member) {
                 if (ts.isStatic(member)) {
                     return "continue";
                 }
@@ -84210,7 +84344,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_31(member);
+                _loop_32(member);
             }
             if (!issuedMemberError) {
                 // check again with diagnostics to generate a less-specific error
@@ -84278,18 +84412,17 @@ var ts;
             // but not by other kinds of members.
             // Base class instance member variables and accessors can be overridden by
             // derived class instance member variables and accessors, but not by other kinds of members.
-            var _a, _b;
+            var _a, _b, _c, _d;
             // NOTE: assignability is checked in checkClassDeclaration
             var baseProperties = getPropertiesOfType(baseType);
-            basePropertyCheck: for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) {
-                var baseProperty = baseProperties_1[_i];
+            var _loop_33 = function (baseProperty) {
                 var base = getTargetSymbol(baseProperty);
                 if (base.flags & 4194304 /* Prototype */) {
-                    continue;
+                    return "continue";
                 }
                 var baseSymbol = getPropertyOfObjectType(type, base.escapedName);
                 if (!baseSymbol) {
-                    continue;
+                    return "continue";
                 }
                 var derived = getTargetSymbol(baseSymbol);
                 var baseDeclarationFlags = ts.getDeclarationModifierFlagsFromSymbol(base);
@@ -84307,14 +84440,14 @@ var ts;
                         // Searches other base types for a declaration that would satisfy the inherited abstract member.
                         // (The class may have more than one base type via declaration merging with an interface with the
                         // same name.)
-                        for (var _c = 0, _d = getBaseTypes(type); _c < _d.length; _c++) {
-                            var otherBaseType = _d[_c];
+                        for (var _e = 0, _f = getBaseTypes(type); _e < _f.length; _e++) {
+                            var otherBaseType = _f[_e];
                             if (otherBaseType === baseType)
                                 continue;
                             var baseSymbol_1 = getPropertyOfObjectType(otherBaseType, base.escapedName);
                             var derivedElsewhere = baseSymbol_1 && getTargetSymbol(baseSymbol_1);
                             if (derivedElsewhere && derivedElsewhere !== base) {
-                                continue basePropertyCheck;
+                                return "continue-basePropertyCheck";
                             }
                         }
                         if (derivedClassDecl.kind === 226 /* ClassExpression */) {
@@ -84329,20 +84462,19 @@ var ts;
                     // derived overrides base.
                     var derivedDeclarationFlags = ts.getDeclarationModifierFlagsFromSymbol(derived);
                     if (baseDeclarationFlags & 8 /* Private */ || derivedDeclarationFlags & 8 /* Private */) {
-                        // either base or derived property is private - not override, skip it
-                        continue;
+                        return "continue";
                     }
                     var errorMessage = void 0;
                     var basePropertyFlags = base.flags & 98308 /* PropertyOrAccessor */;
                     var derivedPropertyFlags = derived.flags & 98308 /* PropertyOrAccessor */;
                     if (basePropertyFlags && derivedPropertyFlags) {
                         // property/accessor is overridden with property/accessor
-                        if (baseDeclarationFlags & 128 /* Abstract */ && !(base.valueDeclaration && ts.isPropertyDeclaration(base.valueDeclaration) && base.valueDeclaration.initializer)
-                            || base.valueDeclaration && base.valueDeclaration.parent.kind === 258 /* InterfaceDeclaration */
+                        if ((ts.getCheckFlags(base) & 6 /* Synthetic */
+                            ? (_a = base.declarations) === null || _a === void 0 ? void 0 : _a.some(function (d) { return isPropertyAbstractOrInterface(d, baseDeclarationFlags); })
+                            : (_b = base.declarations) === null || _b === void 0 ? void 0 : _b.every(function (d) { return isPropertyAbstractOrInterface(d, baseDeclarationFlags); }))
+                            || ts.getCheckFlags(base) & 262144 /* Mapped */
                             || derived.valueDeclaration && ts.isBinaryExpression(derived.valueDeclaration)) {
-                            // when the base property is abstract or from an interface, base/derived flags don't need to match
-                            // same when the derived property is from an assignment
-                            continue;
+                            return "continue";
                         }
                         var overriddenInstanceProperty = basePropertyFlags !== 4 /* Property */ && derivedPropertyFlags === 4 /* Property */;
                         var overriddenInstanceAccessor = basePropertyFlags === 4 /* Property */ && derivedPropertyFlags !== 4 /* Property */;
@@ -84353,12 +84485,12 @@ var ts;
                             error(ts.getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage_1, symbolToString(base), typeToString(baseType), typeToString(type));
                         }
                         else if (useDefineForClassFields) {
-                            var uninitialized = (_a = derived.declarations) === null || _a === void 0 ? void 0 : _a.find(function (d) { return d.kind === 167 /* PropertyDeclaration */ && !d.initializer; });
+                            var uninitialized = (_c = derived.declarations) === null || _c === void 0 ? void 0 : _c.find(function (d) { return d.kind === 167 /* PropertyDeclaration */ && !d.initializer; });
                             if (uninitialized
                                 && !(derived.flags & 33554432 /* Transient */)
                                 && !(baseDeclarationFlags & 128 /* Abstract */)
                                 && !(derivedDeclarationFlags & 128 /* Abstract */)
-                                && !((_b = derived.declarations) === null || _b === void 0 ? void 0 : _b.some(function (d) { return !!(d.flags & 16777216 /* Ambient */); }))) {
+                                && !((_d = derived.declarations) === null || _d === void 0 ? void 0 : _d.some(function (d) { return !!(d.flags & 16777216 /* Ambient */); }))) {
                                 var constructor = findConstructorDeclaration(ts.getClassLikeDeclarationOfSymbol(type.symbol));
                                 var propName = uninitialized.name;
                                 if (uninitialized.exclamationToken
@@ -84371,13 +84503,11 @@ var ts;
                                 }
                             }
                         }
-                        // correct case
-                        continue;
+                        return "continue";
                     }
                     else if (isPrototypeProperty(base)) {
                         if (isPrototypeProperty(derived) || derived.flags & 4 /* Property */) {
-                            // method is overridden with method or property -- correct case
-                            continue;
+                            return "continue";
                         }
                         else {
                             ts.Debug.assert(!!(derived.flags & 98304 /* Accessor */));
@@ -84392,9 +84522,20 @@ var ts;
                     }
                     error(ts.getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage, typeToString(baseType), symbolToString(base), typeToString(type));
                 }
+            };
+            basePropertyCheck: for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) {
+                var baseProperty = baseProperties_1[_i];
+                var state_10 = _loop_33(baseProperty);
+                switch (state_10) {
+                    case "continue-basePropertyCheck": continue basePropertyCheck;
+                }
             }
         }
-        function getNonInterhitedProperties(type, baseTypes, properties) {
+        function isPropertyAbstractOrInterface(declaration, baseDeclarationFlags) {
+            return baseDeclarationFlags & 128 /* Abstract */ && (!ts.isPropertyDeclaration(declaration) || !declaration.initializer)
+                || ts.isInterfaceDeclaration(declaration.parent);
+        }
+        function getNonInheritedProperties(type, baseTypes, properties) {
             if (!ts.length(baseTypes)) {
                 return properties;
             }
@@ -84463,7 +84604,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 */ || getFalsyFlags(type) & 32768 /* Undefined */)) {
+                        if (!(type.flags & 3 /* AnyOrUnknown */ || getTypeFacts(type) & 16777216 /* IsUndefined */)) {
                             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));
                             }
@@ -84488,7 +84629,7 @@ var ts;
                     ts.setParent(reference, staticBlock);
                     reference.flowNode = staticBlock.returnFlowNode;
                     var flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType));
-                    if (!(getFalsyFlags(flowType) & 32768 /* Undefined */)) {
+                    if (!(getTypeFacts(flowType) & 16777216 /* IsUndefined */)) {
                         return true;
                     }
                 }
@@ -84503,7 +84644,7 @@ var ts;
             ts.setParent(reference, constructor);
             reference.flowNode = constructor.returnFlowNode;
             var flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType));
-            return !(getFalsyFlags(flowType) & 32768 /* Undefined */);
+            return !(getTypeFacts(flowType) & 16777216 /* IsUndefined */);
         }
         function checkInterfaceDeclaration(node) {
             // Grammar checking
@@ -89870,9 +90011,7 @@ var ts;
 var ts;
 (function (ts) {
     function createSourceMapGenerator(host, file, sourceRoot, sourcesDirectoryPath, generatorOptions) {
-        var _a = generatorOptions.extendedDiagnostics
-            ? ts.performance.createTimer("Source Map", "beforeSourcemap", "afterSourcemap")
-            : ts.performance.nullTimer, enter = _a.enter, exit = _a.exit;
+        var _a = ts.performance.createTimerIf(!!generatorOptions.extendedDiagnostics, "Source Map", "beforeSourcemap", "afterSourcemap"), enter = _a.enter, exit = _a.exit;
         // Current source map file and its index in the sources list
         var rawSources = [];
         var sources = [];
@@ -92793,8 +92932,8 @@ var ts;
             // Note when updating logic here also update getEntityNameForDecoratorMetadata
             // so that aliases can be marked as referenced
             var serializedUnion;
-            for (var _i = 0, types_23 = types; _i < types_23.length; _i++) {
-                var typeNode = types_23[_i];
+            for (var _i = 0, types_22 = types; _i < types_22.length; _i++) {
+                var typeNode = types_22[_i];
                 while (typeNode.kind === 191 /* ParenthesizedType */) {
                     typeNode = typeNode.type; // Skip parens if need be
                 }
@@ -113409,8 +113548,8 @@ var ts;
                     bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "reference" /* Reference */, data: directive.fileName });
                 writeLine();
             }
-            for (var _d = 0, types_24 = types; _d < types_24.length; _d++) {
-                var directive = types_24[_d];
+            for (var _d = 0, types_23 = types; _d < types_23.length; _d++) {
+                var directive = types_23[_d];
                 var pos = writer.getTextPos();
                 var resolutionMode = directive.resolutionMode && directive.resolutionMode !== (currentSourceFile === null || currentSourceFile === void 0 ? void 0 : currentSourceFile.impliedNodeFormat)
                     ? "resolution-mode=\"" + (directive.resolutionMode === ts.ModuleKind.ESNext ? "import" : "require") + "\""
@@ -122178,7 +122317,7 @@ var ts;
             });
             // Sort by paths closest to importing file Name directory
             var sortedPaths = [];
-            var _loop_32 = function (directory) {
+            var _loop_34 = function (directory) {
                 var directoryStart = ts.ensureTrailingDirectorySeparator(directory);
                 var pathsInDirectory;
                 allFileNames.forEach(function (_a, fileName) {
@@ -122202,9 +122341,9 @@ var ts;
             };
             var out_directory_1;
             for (var directory = ts.getDirectoryPath(importingFileName); allFileNames.size !== 0;) {
-                var state_10 = _loop_32(directory);
+                var state_11 = _loop_34(directory);
                 directory = out_directory_1;
-                if (state_10 === "break")
+                if (state_11 === "break")
                     break;
             }
             if (allFileNames.size) {
@@ -124148,6 +124287,7 @@ var ts;
         if (value) {
             return isParsedCommandLine(value) ? value : undefined;
         }
+        ts.solutionPerformance.mark("beforeParseConfigFile");
         var diagnostic;
         var parseConfigFileHost = state.parseConfigFileHost, baseCompilerOptions = state.baseCompilerOptions, baseWatchOptions = state.baseWatchOptions, extendedConfigCache = state.extendedConfigCache, host = state.host;
         var parsed;
@@ -124162,6 +124302,8 @@ var ts;
             parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = ts.noop;
         }
         configFileCache.set(configFilePath, parsed || diagnostic);
+        ts.solutionPerformance.mark("afterParseConfigFile");
+        ts.solutionPerformance.measure("ParseConfigFile", "beforeParseConfigFile", "afterParseConfigFile");
         return parsed;
     }
     function resolveProjectName(state, name) {
@@ -124211,6 +124353,7 @@ var ts;
         return state.buildOrder || createStateBuildOrder(state);
     }
     function createStateBuildOrder(state) {
+        ts.solutionPerformance.mark("beforeCreateBuildOrder");
         var buildOrder = createBuildOrder(state, state.rootNames.map(function (f) { return resolveProjectName(state, f); }));
         // Clear all to ResolvedConfigFilePaths cache to start fresh
         state.resolvedConfigFilePaths.clear();
@@ -124240,6 +124383,8 @@ var ts;
             ts.mutateMapSkippingNewValues(state.allWatchedInputFiles, currentProjects, { onDeleteValue: function (existingMap) { return existingMap.forEach(ts.closeFileWatcher); } });
             ts.mutateMapSkippingNewValues(state.allWatchedPackageJsonFiles, currentProjects, { onDeleteValue: function (existingMap) { return existingMap.forEach(ts.closeFileWatcher); } });
         }
+        ts.solutionPerformance.mark("afterCreateBuildOrder");
+        ts.solutionPerformance.measure("CreateBuildOrder", "beforeCreateBuildOrder", "afterCreateBuildOrder");
         return state.buildOrder = buildOrder;
     }
     function getBuildOrderFor(state, project, onlyReferences) {
@@ -124360,6 +124505,7 @@ var ts;
                 if (updateOutputFileStampsPending) {
                     updateOutputTimestamps(state, config, projectPath);
                 }
+                ts.solutionPerformance.mark("timestampUpdated");
                 return doneInvalidatedProject(state, projectPath);
             }
         };
@@ -124453,6 +124599,10 @@ var ts;
             };
         function done(cancellationToken, writeFile, customTransformers) {
             executeSteps(BuildStep.Done, cancellationToken, writeFile, customTransformers);
+            if (kind === InvalidatedProjectKind.Build)
+                ts.solutionPerformance.mark("projectsBuilt");
+            else
+                ts.solutionPerformance.mark("bundlesUpdated");
             return doneInvalidatedProject(state, projectPath);
         }
         function withProgramOrUndefined(action) {
@@ -124542,6 +124692,7 @@ var ts;
             var anyDtsChanged = false;
             var emitterDiagnostics = ts.createDiagnosticCollection();
             var emittedOutputs = new ts.Map();
+            ts.solutionPerformance.mark("beforeOutputFilesWrite");
             outputFiles.forEach(function (_a) {
                 var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark;
                 var priorChangeTime;
@@ -124561,6 +124712,8 @@ var ts;
                     newestDeclarationFileContentChangedTime = newer(priorChangeTime, newestDeclarationFileContentChangedTime);
                 }
             });
+            ts.solutionPerformance.mark("afterOutputFilesWrite");
+            ts.solutionPerformance.measure("OutputFilesWrite", "beforeOutputFilesWrite", "afterOutputFilesWrite");
             finishEmit(emitterDiagnostics, emittedOutputs, newestDeclarationFileContentChangedTime, 
             /*newestDeclarationFileContentChangedTimeIsMaximumDate*/ anyDtsChanged, outputFiles.length ? outputFiles[0].name : ts.getFirstProjectOutput(config, !host.useCaseSensitiveFileNames()), resultFlags);
             return emitResult;
@@ -124690,6 +124843,13 @@ var ts;
             !ts.isIncrementalCompilation(config.options);
     }
     function getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue) {
+        ts.solutionPerformance.mark("beforeGetNextInvalidatedProjectCreateInfo");
+        var result = getNextInvalidatedProjectCreateInfoWorker(state, buildOrder, reportQueue);
+        ts.solutionPerformance.mark("afterGetNextInvalidatedProjectCreateInfo");
+        ts.solutionPerformance.measure("GetNextInvalidatedProjectCreateInfo", "beforeGetNextInvalidatedProjectCreateInfo", "afterGetNextInvalidatedProjectCreateInfo");
+        return result;
+    }
+    function getNextInvalidatedProjectCreateInfoWorker(state, buildOrder, reportQueue) {
         if (!state.projectPendingBuild.size)
             return undefined;
         if (isCircularBuildOrder(buildOrder))
@@ -124789,9 +124949,7 @@ var ts;
     }
     function getNextInvalidatedProject(state, buildOrder, reportQueue) {
         var info = getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue);
-        if (!info)
-            return info;
-        return createInvalidatedProjectWithInfo(state, info, buildOrder);
+        return info && createInvalidatedProjectWithInfo(state, info, buildOrder);
     }
     function listEmittedFile(_a, proj, file) {
         var write = _a.write;
@@ -124799,14 +124957,17 @@ var ts;
             write("TSFILE: " + file);
         }
     }
-    function getOldProgram(_a, proj, parsed) {
-        var options = _a.options, builderPrograms = _a.builderPrograms, compilerHost = _a.compilerHost;
-        if (options.force)
+    function getOldProgram(state, proj, parsed) {
+        if (state.options.force)
             return undefined;
-        var value = builderPrograms.get(proj);
+        var value = state.builderPrograms.get(proj);
         if (value)
             return value;
-        return ts.readBuilderProgram(parsed.options, compilerHost);
+        ts.solutionPerformance.mark("beforeReadBuilderProgram");
+        var program = ts.readBuilderProgram(parsed.options, state.compilerHost);
+        ts.solutionPerformance.mark("afterReadBuilderProgram");
+        ts.solutionPerformance.measure("ReadBuilderProgram", "beforeReadBuilderProgram", "afterReadBuilderProgram");
+        return program;
     }
     function afterProgramDone(state, program, config) {
         if (program) {
@@ -125005,7 +125166,10 @@ var ts;
             state.buildInfoChecked.set(resolvedPath, true);
             var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(project.options);
             if (buildInfoPath) {
+                ts.solutionPerformance.mark("beforeBuildInfoRead");
                 var value = state.readFileWithCache(buildInfoPath);
+                ts.solutionPerformance.mark("afterBuildInfoRead");
+                ts.solutionPerformance.measure("BuildInfoRead", "beforeBuildInfoRead", "afterBuildInfoRead");
                 var buildInfo = value && ts.getBuildInfo(value);
                 if (buildInfo && (buildInfo.bundle || buildInfo.program) && buildInfo.version !== ts.version) {
                     return {
@@ -125041,13 +125205,17 @@ var ts;
         if (prior !== undefined) {
             return prior;
         }
+        ts.solutionPerformance.mark("beforeGetUpToDateStatus");
         var actual = getUpToDateStatusWorker(state, project, resolvedPath);
+        ts.solutionPerformance.mark("afterGetUpToDateStatus");
+        ts.solutionPerformance.measure("GetUpToDateStatus", "beforeGetUpToDateStatus", "afterGetUpToDateStatus");
         state.projectStatus.set(resolvedPath, actual);
         return actual;
     }
     function updateOutputTimestampsWorker(state, proj, priorNewestUpdateTime, verboseMessage, skipOutputs) {
         if (proj.options.noEmit)
             return priorNewestUpdateTime;
+        ts.solutionPerformance.mark("beforeUpdateOutputTimestamps");
         var host = state.host;
         var outputs = ts.getAllProjectOutputs(proj, !host.useCaseSensitiveFileNames());
         if (!skipOutputs || outputs.length !== skipOutputs.size) {
@@ -125068,6 +125236,8 @@ var ts;
                 host.setModifiedTime(file, now);
             }
         }
+        ts.solutionPerformance.mark("afterUpdateOutputTimestamps");
+        ts.solutionPerformance.measure("UpdateOutputTimestamps", "beforeUpdateOutputTimestamps", "afterUpdateOutputTimestamps");
         return priorNewestUpdateTime;
     }
     function updateOutputTimestamps(state, proj, resolvedPath) {
@@ -125146,6 +125316,13 @@ var ts;
         }
     }
     function build(state, project, cancellationToken, writeFile, getCustomTransformers, onlyReferences) {
+        ts.solutionPerformance.mark("beforeBuild");
+        var result = buildWorker(state, project, cancellationToken, writeFile, getCustomTransformers, onlyReferences);
+        ts.solutionPerformance.mark("afterBuild");
+        ts.solutionPerformance.measure("Build", "beforeBuild", "afterBuild");
+        return result;
+    }
+    function buildWorker(state, project, cancellationToken, writeFile, getCustomTransformers, onlyReferences) {
         var buildOrder = getBuildOrderFor(state, project, onlyReferences);
         if (!buildOrder)
             return ts.ExitStatus.InvalidProject_OutputsSkipped;
@@ -125157,7 +125334,10 @@ var ts;
             if (!invalidatedProject)
                 break;
             reportQueue = false;
+            ts.solutionPerformance.mark("beforeInvalidatedProjectBuild");
             invalidatedProject.done(cancellationToken, writeFile, getCustomTransformers === null || getCustomTransformers === void 0 ? void 0 : getCustomTransformers(invalidatedProject.project));
+            ts.solutionPerformance.mark("afterInvalidatedProjectBuild");
+            ts.solutionPerformance.measure("InvalidatedProjectBuild", "beforeInvalidatedProjectBuild", "afterInvalidatedProjectBuild");
             if (!state.diagnostics.has(invalidatedProject.projectPath))
                 successfulProjects++;
         }
@@ -125246,6 +125426,14 @@ var ts;
         state.timerToBuildInvalidatedProject = hostWithWatch.setTimeout(buildNextInvalidatedProject, time, state, changeDetected);
     }
     function buildNextInvalidatedProject(state, changeDetected) {
+        ts.solutionPerformance.mark("beforeBuild");
+        var buildOrder = buildNextInvalidatedProjectWorker(state, changeDetected);
+        ts.solutionPerformance.mark("afterBuild");
+        ts.solutionPerformance.measure("Build", "beforeBuild", "afterBuild");
+        if (buildOrder)
+            reportErrorSummary(state, buildOrder);
+    }
+    function buildNextInvalidatedProjectWorker(state, changeDetected) {
         state.timerToBuildInvalidatedProject = undefined;
         if (state.reportFileChangeDetected) {
             state.reportFileChangeDetected = false;
@@ -125256,7 +125444,10 @@ var ts;
         var buildOrder = getBuildOrder(state);
         var invalidatedProject = getNextInvalidatedProject(state, buildOrder, /*reportQueue*/ false);
         if (invalidatedProject) {
+            ts.solutionPerformance.mark("beforeInvalidatedProjectBuild");
             invalidatedProject.done();
+            ts.solutionPerformance.mark("afterInvalidatedProjectBuild");
+            ts.solutionPerformance.measure("InvalidatedProjectBuild", "beforeInvalidatedProjectBuild", "afterInvalidatedProjectBuild");
             projectsBuilt++;
             while (state.projectPendingBuild.size) {
                 // If already scheduled, skip
@@ -125272,13 +125463,16 @@ var ts;
                     return;
                 }
                 var project = createInvalidatedProjectWithInfo(state, info, buildOrder);
+                ts.solutionPerformance.mark("beforeInvalidatedProjectBuild");
                 project.done();
+                ts.solutionPerformance.mark("afterInvalidatedProjectBuild");
+                ts.solutionPerformance.measure("InvalidatedProjectBuild", "beforeInvalidatedProjectBuild", "afterInvalidatedProjectBuild");
                 if (info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps)
                     projectsBuilt++;
             }
         }
         disableCache(state);
-        reportErrorSummary(state, buildOrder);
+        return buildOrder;
     }
     function watchConfigFile(state, resolved, resolvedPath, parsed) {
         if (!state.watch || state.allWatchedConfigFiles.has(resolvedPath))
@@ -125335,6 +125529,7 @@ var ts;
     function startWatching(state, buildOrder) {
         if (!state.watchAllProjectsPending)
             return;
+        ts.solutionPerformance.mark("beforeStartWatching");
         state.watchAllProjectsPending = false;
         for (var _i = 0, _a = getBuildOrderFromAnyBuildOrder(buildOrder); _i < _a.length; _i++) {
             var resolved = _a[_i];
@@ -125352,6 +125547,8 @@ var ts;
                 watchPackageJsonFiles(state, resolved, resolvedPath, cfg);
             }
         }
+        ts.solutionPerformance.mark("afterStartWatching");
+        ts.solutionPerformance.measure("StartWatching", "beforeStartWatching", "afterStartWatching");
     }
     function stopWatching(state) {
         ts.clearMap(state.allWatchedConfigFiles, ts.closeFileWatcher);