@typescript-deploys/pr-build 4.7.0-pr-48784-4 → 4.7.0-pr-48997-6

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.7";
-    ts.version = ts.versionMajorMinor + ".0-insiders.20220427";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220506";
     var NativeCollections;
     (function (NativeCollections) {
         var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -3405,7 +3405,7 @@ var ts;
     (function (ModuleResolutionKind) {
         ModuleResolutionKind[ModuleResolutionKind["Classic"] = 1] = "Classic";
         ModuleResolutionKind[ModuleResolutionKind["NodeJs"] = 2] = "NodeJs";
-        ModuleResolutionKind[ModuleResolutionKind["Node12"] = 3] = "Node12";
+        ModuleResolutionKind[ModuleResolutionKind["Node16"] = 3] = "Node16";
         ModuleResolutionKind[ModuleResolutionKind["NodeNext"] = 99] = "NodeNext";
     })(ModuleResolutionKind = ts.ModuleResolutionKind || (ts.ModuleResolutionKind = {}));
     var ModuleDetectionKind;
@@ -3448,7 +3448,7 @@ var ts;
         ModuleKind[ModuleKind["ES2020"] = 6] = "ES2020";
         ModuleKind[ModuleKind["ES2022"] = 7] = "ES2022";
         ModuleKind[ModuleKind["ESNext"] = 99] = "ESNext";
-        ModuleKind[ModuleKind["Node12"] = 100] = "Node12";
+        ModuleKind[ModuleKind["Node16"] = 100] = "Node16";
         ModuleKind[ModuleKind["NodeNext"] = 199] = "NodeNext";
     })(ModuleKind = ts.ModuleKind || (ts.ModuleKind = {}));
     ts.commentPragmas = {
@@ -3745,7 +3745,7 @@ var ts;
             };
         }
         function createDirectoryWatcher(dirName, dirPath, fallbackOptions) {
-            var watcher = fsWatch(dirName, 1, function (_eventName, relativeFileName, modifiedTime) {
+            var watcher = fsWatch(dirName, 1, function (_eventName, relativeFileName) {
                 if (!ts.isString(relativeFileName))
                     return;
                 var fileName = ts.getNormalizedAbsolutePath(relativeFileName, dirName);
@@ -3753,7 +3753,7 @@ var ts;
                 if (callbacks) {
                     for (var _i = 0, callbacks_1 = callbacks; _i < callbacks_1.length; _i++) {
                         var fileCallback = callbacks_1[_i];
-                        fileCallback(fileName, FileWatcherEventKind.Changed, modifiedTime);
+                        fileCallback(fileName, FileWatcherEventKind.Changed);
                     }
                 }
             }, false, PollingInterval.Medium, fallbackOptions);
@@ -3805,7 +3805,7 @@ var ts;
             }
             else {
                 cache.set(path, {
-                    watcher: watchFile(fileName, function (fileName, eventKind, modifiedTime) { return ts.forEach(callbacksCache.get(path), function (cb) { return cb(fileName, eventKind, modifiedTime); }); }, pollingInterval, options),
+                    watcher: watchFile(fileName, function (fileName, eventKind) { return ts.forEach(callbacksCache.get(path), function (cb) { return cb(fileName, eventKind); }); }, pollingInterval, options),
                     refCount: 1
                 });
             }
@@ -3829,7 +3829,7 @@ var ts;
         var newTime = modifiedTime.getTime();
         if (oldTime !== newTime) {
             watchedFile.mtime = modifiedTime;
-            watchedFile.callback(watchedFile.fileName, getFileWatcherEventKind(oldTime, newTime), modifiedTime);
+            watchedFile.callback(watchedFile.fileName, getFileWatcherEventKind(oldTime, newTime));
             return true;
         }
         return false;
@@ -3854,7 +3854,7 @@ var ts;
     }
     ts.setSysLog = setSysLog;
     function createDirectoryWatcherSupportingRecursive(_a) {
-        var watchDirectory = _a.watchDirectory, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, directoryExists = _a.directoryExists, realpath = _a.realpath, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout;
+        var watchDirectory = _a.watchDirectory, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, fileSystemEntryExists = _a.fileSystemEntryExists, realpath = _a.realpath, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout;
         var cache = new ts.Map();
         var callbackCache = ts.createMultiMap();
         var cacheToUpdateChildWatches = new ts.Map();
@@ -3947,7 +3947,7 @@ var ts;
         }
         function nonSyncUpdateChildWatches(dirName, dirPath, fileName, options) {
             var parentWatcher = cache.get(dirPath);
-            if (parentWatcher && directoryExists(dirName)) {
+            if (parentWatcher && fileSystemEntryExists(dirName, 1)) {
                 scheduleUpdateChildWatches(dirName, dirPath, fileName, options);
                 return;
             }
@@ -4015,7 +4015,7 @@ var ts;
             if (!parentWatcher)
                 return false;
             var newChildWatches;
-            var hasChanges = ts.enumerateInsertsAndDeletes(directoryExists(parentDir) ? ts.mapDefined(getAccessibleSortedChildDirectories(parentDir), function (child) {
+            var hasChanges = ts.enumerateInsertsAndDeletes(fileSystemEntryExists(parentDir, 1) ? ts.mapDefined(getAccessibleSortedChildDirectories(parentDir), function (child) {
                 var childFullName = ts.getNormalizedAbsolutePath(child, parentDir);
                 return !isIgnoredPath(childFullName, options) && filePathComparer(childFullName, ts.normalizePath(realpath(childFullName))) === 0 ? childFullName : undefined;
             }) : ts.emptyArray, parentWatcher.childWatches, function (child, childWatcher) { return filePathComparer(child, childWatcher.dirName); }, createAndAddChildDirectoryWatcher, ts.closeFileWatcher, addChildDirectoryWatcher);
@@ -4043,17 +4043,16 @@ var ts;
     }
     ts.createDirectoryWatcherSupportingRecursive = createDirectoryWatcherSupportingRecursive;
     function createFileWatcherCallback(callback) {
-        return function (_fileName, eventKind, modifiedTime) { return callback(eventKind === FileWatcherEventKind.Changed ? "change" : "rename", "", modifiedTime); };
+        return function (_fileName, eventKind) { return callback(eventKind === FileWatcherEventKind.Changed ? "change" : "rename", ""); };
     }
     ts.createFileWatcherCallback = createFileWatcherCallback;
-    function createFsWatchCallbackForFileWatcherCallback(fileName, callback, getModifiedTime) {
-        return function (eventName, _relativeFileName, modifiedTime) {
+    function createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileSystemEntryExists) {
+        return function (eventName) {
             if (eventName === "rename") {
-                modifiedTime || (modifiedTime = getModifiedTime(fileName) || ts.missingFileModifiedTime);
-                callback(fileName, modifiedTime !== ts.missingFileModifiedTime ? FileWatcherEventKind.Created : FileWatcherEventKind.Deleted, modifiedTime);
+                callback(fileName, fileSystemEntryExists(fileName, 0) ? FileWatcherEventKind.Created : FileWatcherEventKind.Deleted);
             }
             else {
-                callback(fileName, FileWatcherEventKind.Changed, modifiedTime);
+                callback(fileName, FileWatcherEventKind.Changed);
             }
         };
     }
@@ -4072,11 +4071,12 @@ var ts;
         };
     }
     function createSystemWatchFunctions(_a) {
-        var pollingWatchFile = _a.pollingWatchFile, getModifiedTime = _a.getModifiedTime, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout, fsWatch = _a.fsWatch, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, fsSupportsRecursiveFsWatch = _a.fsSupportsRecursiveFsWatch, directoryExists = _a.directoryExists, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, realpath = _a.realpath, tscWatchFile = _a.tscWatchFile, useNonPollingWatchers = _a.useNonPollingWatchers, tscWatchDirectory = _a.tscWatchDirectory, defaultWatchFileKind = _a.defaultWatchFileKind;
+        var pollingWatchFile = _a.pollingWatchFile, getModifiedTime = _a.getModifiedTime, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout, fsWatchWorker = _a.fsWatchWorker, fileSystemEntryExists = _a.fileSystemEntryExists, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, fsSupportsRecursiveFsWatch = _a.fsSupportsRecursiveFsWatch, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, realpath = _a.realpath, tscWatchFile = _a.tscWatchFile, useNonPollingWatchers = _a.useNonPollingWatchers, tscWatchDirectory = _a.tscWatchDirectory, defaultWatchFileKind = _a.defaultWatchFileKind, inodeWatching = _a.inodeWatching, sysLog = _a.sysLog;
         var dynamicPollingWatchFile;
         var fixedChunkSizePollingWatchFile;
         var nonPollingWatchFile;
         var hostRecursiveDirectoryWatcher;
+        var hitSystemWatcherLimit = false;
         return {
             watchFile: watchFile,
             watchDirectory: watchDirectory
@@ -4094,7 +4094,7 @@ var ts;
                 case ts.WatchFileKind.FixedChunkSizePolling:
                     return ensureFixedChunkSizePollingWatchFile()(fileName, callback, undefined, undefined);
                 case ts.WatchFileKind.UseFsEvents:
-                    return fsWatch(fileName, 0, createFsWatchCallbackForFileWatcherCallback(fileName, callback, getModifiedTime), false, pollingInterval, ts.getFallbackOptions(options));
+                    return fsWatch(fileName, 0, createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileSystemEntryExists), false, pollingInterval, ts.getFallbackOptions(options));
                 case ts.WatchFileKind.UseFsEventsOnParentDirectory:
                     if (!nonPollingWatchFile) {
                         nonPollingWatchFile = createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames);
@@ -4147,7 +4147,7 @@ var ts;
                 hostRecursiveDirectoryWatcher = createDirectoryWatcherSupportingRecursive({
                     useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                     getCurrentDirectory: getCurrentDirectory,
-                    directoryExists: directoryExists,
+                    fileSystemEntryExists: fileSystemEntryExists,
                     getAccessibleSortedChildDirectories: getAccessibleSortedChildDirectories,
                     watchDirectory: nonRecursiveWatchDirectory,
                     realpath: realpath,
@@ -4192,6 +4192,76 @@ var ts;
                     };
             }
         }
+        function fsWatch(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) {
+            var lastDirectoryPartWithDirectorySeparator;
+            var lastDirectoryPart;
+            if (inodeWatching) {
+                lastDirectoryPartWithDirectorySeparator = fileOrDirectory.substr(fileOrDirectory.lastIndexOf(ts.directorySeparator));
+                lastDirectoryPart = lastDirectoryPartWithDirectorySeparator.slice(ts.directorySeparator.length);
+            }
+            var watcher = !fileSystemEntryExists(fileOrDirectory, entryKind) ?
+                watchMissingFileSystemEntry() :
+                watchPresentFileSystemEntry();
+            return {
+                close: function () {
+                    watcher.close();
+                    watcher = undefined;
+                }
+            };
+            function updateWatcher(createWatcher) {
+                if (watcher) {
+                    sysLog("sysLog:: " + fileOrDirectory + ":: Changing watcher to " + (createWatcher === watchPresentFileSystemEntry ? "Present" : "Missing") + "FileSystemEntryWatcher");
+                    watcher.close();
+                    watcher = createWatcher();
+                }
+            }
+            function watchPresentFileSystemEntry() {
+                if (hitSystemWatcherLimit) {
+                    sysLog("sysLog:: " + fileOrDirectory + ":: Defaulting to watchFile");
+                    return watchPresentFileSystemEntryWithFsWatchFile();
+                }
+                try {
+                    var presentWatcher = fsWatchWorker(fileOrDirectory, recursive, inodeWatching ?
+                        callbackChangingToMissingFileSystemEntry :
+                        callback);
+                    presentWatcher.on("error", function () {
+                        callback("rename", "");
+                        updateWatcher(watchMissingFileSystemEntry);
+                    });
+                    return presentWatcher;
+                }
+                catch (e) {
+                    hitSystemWatcherLimit || (hitSystemWatcherLimit = e.code === "ENOSPC");
+                    sysLog("sysLog:: " + fileOrDirectory + ":: Changing to watchFile");
+                    return watchPresentFileSystemEntryWithFsWatchFile();
+                }
+            }
+            function callbackChangingToMissingFileSystemEntry(event, relativeName) {
+                callback(event, relativeName);
+                if (event === "rename" &&
+                    (!relativeName ||
+                        relativeName === lastDirectoryPart ||
+                        (relativeName.lastIndexOf(lastDirectoryPartWithDirectorySeparator) !== -1 && relativeName.lastIndexOf(lastDirectoryPartWithDirectorySeparator) === relativeName.length - lastDirectoryPartWithDirectorySeparator.length))) {
+                    if (inodeWatching) {
+                        updateWatcher(!fileSystemEntryExists(fileOrDirectory, entryKind) ? watchMissingFileSystemEntry : watchPresentFileSystemEntry);
+                    }
+                    else if (!fileSystemEntryExists(fileOrDirectory, entryKind)) {
+                        updateWatcher(watchMissingFileSystemEntry);
+                    }
+                }
+            }
+            function watchPresentFileSystemEntryWithFsWatchFile() {
+                return watchFile(fileOrDirectory, createFileWatcherCallback(callback), fallbackPollingInterval, fallbackOptions);
+            }
+            function watchMissingFileSystemEntry() {
+                return watchFile(fileOrDirectory, function (_fileName, eventKind) {
+                    if (eventKind === FileWatcherEventKind.Created && fileSystemEntryExists(fileOrDirectory, entryKind)) {
+                        callback("rename", "");
+                        updateWatcher(watchPresentFileSystemEntry);
+                    }
+                }, fallbackPollingInterval, fallbackOptions);
+            }
+        }
     }
     ts.createSystemWatchFunctions = createSystemWatchFunctions;
     function patchWriteFileEnsuringDirectory(sys) {
@@ -4233,7 +4303,6 @@ var ts;
             }
             var activeSession;
             var profilePath = "./profile.cpuprofile";
-            var hitSystemWatcherLimit = false;
             var Buffer = require("buffer").Buffer;
             var nodeVersion = getNodeMajorVersion();
             var isNode4OrLater = nodeVersion >= 4;
@@ -4248,17 +4317,19 @@ var ts;
                 getModifiedTime: getModifiedTime,
                 setTimeout: setTimeout,
                 clearTimeout: clearTimeout,
-                fsWatch: fsWatch,
+                fsWatchWorker: fsWatchWorker,
                 useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                 getCurrentDirectory: getCurrentDirectory,
+                fileSystemEntryExists: fileSystemEntryExists,
                 fsSupportsRecursiveFsWatch: fsSupportsRecursiveFsWatch,
-                directoryExists: directoryExists,
                 getAccessibleSortedChildDirectories: function (path) { return getAccessibleFileSystemEntries(path).directories; },
                 realpath: realpath,
                 tscWatchFile: process.env.TSC_WATCHFILE,
                 useNonPollingWatchers: process.env.TSC_NONPOLLING_WATCHER,
                 tscWatchDirectory: process.env.TSC_WATCHDIRECTORY,
                 defaultWatchFileKind: function () { var _a, _b; return (_b = (_a = sys).defaultWatchFileKind) === null || _b === void 0 ? void 0 : _b.call(_a); },
+                inodeWatching: isLinuxOrMacOs,
+                sysLog: sysLog,
             }), watchFile = _c.watchFile, watchDirectory = _c.watchDirectory;
             var nodeSystem = {
                 args: process.argv.slice(2),
@@ -4478,83 +4549,12 @@ var ts;
                     else {
                         eventKind = FileWatcherEventKind.Changed;
                     }
-                    callback(fileName, eventKind, curr.mtime);
+                    callback(fileName, eventKind);
                 }
             }
-            function fsWatch(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) {
-                var options;
-                var lastDirectoryPartWithDirectorySeparator;
-                var lastDirectoryPart;
-                if (isLinuxOrMacOs) {
-                    lastDirectoryPartWithDirectorySeparator = fileOrDirectory.substr(fileOrDirectory.lastIndexOf(ts.directorySeparator));
-                    lastDirectoryPart = lastDirectoryPartWithDirectorySeparator.slice(ts.directorySeparator.length);
-                }
-                var watcher = !fileSystemEntryExists(fileOrDirectory, entryKind) ?
-                    watchMissingFileSystemEntry() :
-                    watchPresentFileSystemEntry();
-                return {
-                    close: function () {
-                        watcher.close();
-                        watcher = undefined;
-                    }
-                };
-                function invokeCallbackAndUpdateWatcher(createWatcher, modifiedTime) {
-                    sysLog("sysLog:: " + fileOrDirectory + ":: Changing watcher to " + (createWatcher === watchPresentFileSystemEntry ? "Present" : "Missing") + "FileSystemEntryWatcher");
-                    callback("rename", "", modifiedTime);
-                    if (watcher) {
-                        watcher.close();
-                        watcher = createWatcher();
-                    }
-                }
-                function watchPresentFileSystemEntry() {
-                    if (options === undefined) {
-                        if (fsSupportsRecursiveFsWatch) {
-                            options = { persistent: true, recursive: !!recursive };
-                        }
-                        else {
-                            options = { persistent: true };
-                        }
-                    }
-                    if (hitSystemWatcherLimit) {
-                        sysLog("sysLog:: " + fileOrDirectory + ":: Defaulting to fsWatchFile");
-                        return watchPresentFileSystemEntryWithFsWatchFile();
-                    }
-                    try {
-                        var presentWatcher = _fs.watch(fileOrDirectory, options, isLinuxOrMacOs ?
-                            callbackChangingToMissingFileSystemEntry :
-                            callback);
-                        presentWatcher.on("error", function () { return invokeCallbackAndUpdateWatcher(watchMissingFileSystemEntry); });
-                        return presentWatcher;
-                    }
-                    catch (e) {
-                        hitSystemWatcherLimit || (hitSystemWatcherLimit = e.code === "ENOSPC");
-                        sysLog("sysLog:: " + fileOrDirectory + ":: Changing to fsWatchFile");
-                        return watchPresentFileSystemEntryWithFsWatchFile();
-                    }
-                }
-                function callbackChangingToMissingFileSystemEntry(event, relativeName) {
-                    var modifiedTime = getModifiedTime(fileOrDirectory) || ts.missingFileModifiedTime;
-                    return event === "rename" &&
-                        (!relativeName ||
-                            relativeName === lastDirectoryPart ||
-                            (relativeName.lastIndexOf(lastDirectoryPartWithDirectorySeparator) !== -1 && relativeName.lastIndexOf(lastDirectoryPartWithDirectorySeparator) === relativeName.length - lastDirectoryPartWithDirectorySeparator.length)) &&
-                        modifiedTime === ts.missingFileModifiedTime ?
-                        invokeCallbackAndUpdateWatcher(watchMissingFileSystemEntry, modifiedTime) :
-                        callback(event, relativeName, modifiedTime);
-                }
-                function watchPresentFileSystemEntryWithFsWatchFile() {
-                    return watchFile(fileOrDirectory, createFileWatcherCallback(callback), fallbackPollingInterval, fallbackOptions);
-                }
-                function watchMissingFileSystemEntry() {
-                    return watchFile(fileOrDirectory, function (_fileName, eventKind, modifiedTime) {
-                        if (eventKind === FileWatcherEventKind.Created) {
-                            modifiedTime || (modifiedTime = getModifiedTime(fileOrDirectory) || ts.missingFileModifiedTime);
-                            if (modifiedTime !== ts.missingFileModifiedTime) {
-                                invokeCallbackAndUpdateWatcher(watchPresentFileSystemEntry, modifiedTime);
-                            }
-                        }
-                    }, fallbackPollingInterval, fallbackOptions);
-                }
+            function fsWatchWorker(fileOrDirectory, recursive, callback) {
+                return _fs.watch(fileOrDirectory, fsSupportsRecursiveFsWatch ?
+                    { persistent: true, recursive: !!recursive } : { persistent: true }, callback);
             }
             function readFileWorker(fileName, _encoding) {
                 var buffer;
@@ -4690,17 +4690,12 @@ var ts;
             }
             function getModifiedTime(path) {
                 var _a;
-                var originalStackTraceLimit = Error.stackTraceLimit;
-                Error.stackTraceLimit = 0;
                 try {
                     return (_a = statSync(path)) === null || _a === void 0 ? void 0 : _a.mtime;
                 }
                 catch (e) {
                     return undefined;
                 }
-                finally {
-                    Error.stackTraceLimit = originalStackTraceLimit;
-                }
             }
             function setModifiedTime(path, time) {
                 try {
@@ -5451,6 +5446,7 @@ var ts;
         _0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias: diag(1274, ts.DiagnosticCategory.Error, "_0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias_1274", "'{0}' modifier can only appear on a type parameter of a class, interface or type alias"),
         with_statements_are_not_allowed_in_an_async_function_block: diag(1300, ts.DiagnosticCategory.Error, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."),
         await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1308, ts.DiagnosticCategory.Error, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."),
+        The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level: diag(1309, ts.DiagnosticCategory.Error, "The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level_1309", "The current file is a CommonJS module and cannot use 'await' at the top level."),
         Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern: diag(1312, ts.DiagnosticCategory.Error, "Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_1312", "Did you mean to use a ':'? An '=' can only follow a property name when the containing object literal is part of a destructuring pattern."),
         The_body_of_an_if_statement_cannot_be_the_empty_statement: diag(1313, ts.DiagnosticCategory.Error, "The_body_of_an_if_statement_cannot_be_the_empty_statement_1313", "The body of an 'if' statement cannot be the empty statement."),
         Global_module_exports_may_only_appear_in_module_files: diag(1314, ts.DiagnosticCategory.Error, "Global_module_exports_may_only_appear_in_module_files_1314", "Global module exports may only appear in module files."),
@@ -5462,10 +5458,10 @@ var ts;
         Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1320, ts.DiagnosticCategory.Error, "Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member_1320", "Type of 'await' operand must either be a valid promise or must not contain a callable 'then' member."),
         Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1321, ts.DiagnosticCategory.Error, "Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_cal_1321", "Type of 'yield' operand in an async generator must either be a valid promise or must not contain a callable 'then' member."),
         Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1322, ts.DiagnosticCategory.Error, "Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_con_1322", "Type of iterated elements of a 'yield*' operand must either be a valid promise or must not contain a callable 'then' member."),
-        Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node12_or_nodenext: diag(1323, ts.DiagnosticCategory.Error, "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd__1323", "Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'es2022', 'esnext', 'commonjs', 'amd', 'system', 'umd', 'node12', or 'nodenext'."),
-        Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext: diag(1324, ts.DiagnosticCategory.Error, "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext_1324", "Dynamic imports only support a second argument when the '--module' option is set to 'esnext' or 'nodenext'."),
+        Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node16_or_nodenext: diag(1323, ts.DiagnosticCategory.Error, "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd__1323", "Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'es2022', 'esnext', 'commonjs', 'amd', 'system', 'umd', 'node16', or 'nodenext'."),
+        Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_or_nodenext: diag(1324, ts.DiagnosticCategory.Error, "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_or_nod_1324", "Dynamic imports only support a second argument when the '--module' option is set to 'esnext', 'node16', or 'nodenext'."),
         Argument_of_dynamic_import_cannot_be_spread_element: diag(1325, ts.DiagnosticCategory.Error, "Argument_of_dynamic_import_cannot_be_spread_element_1325", "Argument of dynamic import cannot be spread element."),
-        Dynamic_import_cannot_have_type_arguments: diag(1326, ts.DiagnosticCategory.Error, "Dynamic_import_cannot_have_type_arguments_1326", "Dynamic import cannot have type arguments."),
+        This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments: diag(1326, ts.DiagnosticCategory.Error, "This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot__1326", "This use of 'import' is invalid. 'import()' calls can be written, but they must have parentheses and cannot have type arguments."),
         String_literal_with_double_quotes_expected: diag(1327, ts.DiagnosticCategory.Error, "String_literal_with_double_quotes_expected_1327", "String literal with double quotes expected."),
         Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal: diag(1328, ts.DiagnosticCategory.Error, "Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_li_1328", "Property value can only be string literal, numeric literal, 'true', 'false', 'null', object literal or array literal."),
         _0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0: diag(1329, ts.DiagnosticCategory.Error, "_0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write__1329", "'{0}' accepts too few arguments to be used as a decorator here. Did you mean to call it first and write '@{0}()'?"),
@@ -5480,7 +5476,7 @@ var ts;
         Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here: diag(1339, ts.DiagnosticCategory.Error, "Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here_1339", "Module '{0}' does not refer to a value, but is used as a value here."),
         Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0: diag(1340, ts.DiagnosticCategory.Error, "Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0_1340", "Module '{0}' does not refer to a type, but is used as a type here. Did you mean 'typeof import('{0}')'?"),
         Type_arguments_cannot_be_used_here: diag(1342, ts.DiagnosticCategory.Error, "Type_arguments_cannot_be_used_here_1342", "Type arguments cannot be used here."),
-        The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node12_or_nodenext: diag(1343, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system__1343", "The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node12', or 'nodenext'."),
+        The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node16_or_nodenext: diag(1343, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system__1343", "The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node16', or 'nodenext'."),
         A_label_is_not_allowed_here: diag(1344, ts.DiagnosticCategory.Error, "A_label_is_not_allowed_here_1344", "'A label is not allowed here."),
         An_expression_of_type_void_cannot_be_tested_for_truthiness: diag(1345, ts.DiagnosticCategory.Error, "An_expression_of_type_void_cannot_be_tested_for_truthiness_1345", "An expression of type 'void' cannot be tested for truthiness."),
         This_parameter_is_not_allowed_with_use_strict_directive: diag(1346, ts.DiagnosticCategory.Error, "This_parameter_is_not_allowed_with_use_strict_directive_1346", "This parameter is not allowed with 'use strict' directive."),
@@ -5511,7 +5507,7 @@ var ts;
         await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module: diag(1375, ts.DiagnosticCategory.Error, "await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_fi_1375", "'await' expressions are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module."),
         _0_was_imported_here: diag(1376, ts.DiagnosticCategory.Message, "_0_was_imported_here_1376", "'{0}' was imported here."),
         _0_was_exported_here: diag(1377, ts.DiagnosticCategory.Message, "_0_was_exported_here_1377", "'{0}' was exported here."),
-        Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher: diag(1378, ts.DiagnosticCategory.Error, "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_o_1378", "Top-level 'await' expressions are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', or 'nodenext', and the 'target' option is set to 'es2017' or higher."),
+        Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher: diag(1378, ts.DiagnosticCategory.Error, "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_n_1378", "Top-level 'await' expressions are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', or 'nodenext', and the 'target' option is set to 'es2017' or higher."),
         An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type: diag(1379, ts.DiagnosticCategory.Error, "An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type_1379", "An import alias cannot reference a declaration that was exported using 'export type'."),
         An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type: diag(1380, ts.DiagnosticCategory.Error, "An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type_1380", "An import alias cannot reference a declaration that was imported using 'import type'."),
         Unexpected_token_Did_you_mean_or_rbrace: diag(1381, ts.DiagnosticCategory.Error, "Unexpected_token_Did_you_mean_or_rbrace_1381", "Unexpected token. Did you mean `{'}'}` or `&rbrace;`?"),
@@ -5563,7 +5559,7 @@ var ts;
         File_redirects_to_file_0: diag(1429, ts.DiagnosticCategory.Message, "File_redirects_to_file_0_1429", "File redirects to file '{0}'"),
         The_file_is_in_the_program_because_Colon: diag(1430, ts.DiagnosticCategory.Message, "The_file_is_in_the_program_because_Colon_1430", "The file is in the program because:"),
         for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module: diag(1431, ts.DiagnosticCategory.Error, "for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_1431", "'for await' loops are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module."),
-        Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher: diag(1432, ts.DiagnosticCategory.Error, "Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_or__1432", "Top-level 'for await' loops are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', or 'nodenext', and the 'target' option is set to 'es2017' or higher."),
+        Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher: diag(1432, ts.DiagnosticCategory.Error, "Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_nod_1432", "Top-level 'for await' loops are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', or 'nodenext', and the 'target' option is set to 'es2017' or higher."),
         Decorators_may_not_be_applied_to_this_parameters: diag(1433, ts.DiagnosticCategory.Error, "Decorators_may_not_be_applied_to_this_parameters_1433", "Decorators may not be applied to 'this' parameters."),
         Unexpected_keyword_or_identifier: diag(1434, ts.DiagnosticCategory.Error, "Unexpected_keyword_or_identifier_1434", "Unexpected keyword or identifier."),
         Unknown_keyword_or_identifier_Did_you_mean_0: diag(1435, ts.DiagnosticCategory.Error, "Unknown_keyword_or_identifier_Did_you_mean_0_1435", "Unknown keyword or identifier. Did you mean '{0}'?"),
@@ -5581,7 +5577,7 @@ var ts;
         Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed: diag(1449, ts.DiagnosticCategory.Message, "Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed_1449", "Preserve unused imported values in the JavaScript output that would otherwise be removed."),
         Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments: diag(1450, ts.DiagnosticCategory.Message, "Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments_1450", "Dynamic imports can only accept a module specifier and an optional assertion as arguments"),
         Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression: diag(1451, ts.DiagnosticCategory.Error, "Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member__1451", "Private identifiers are only allowed in class bodies and may only be used as part of a class member declaration, property access, or on the left-hand-side of an 'in' expression"),
-        Resolution_modes_are_only_supported_when_moduleResolution_is_node12_or_nodenext: diag(1452, ts.DiagnosticCategory.Error, "Resolution_modes_are_only_supported_when_moduleResolution_is_node12_or_nodenext_1452", "Resolution modes are only supported when `moduleResolution` is `node12` or `nodenext`."),
+        Resolution_modes_are_only_supported_when_moduleResolution_is_node16_or_nodenext: diag(1452, ts.DiagnosticCategory.Error, "Resolution_modes_are_only_supported_when_moduleResolution_is_node16_or_nodenext_1452", "Resolution modes are only supported when `moduleResolution` is `node16` or `nodenext`."),
         resolution_mode_should_be_either_require_or_import: diag(1453, ts.DiagnosticCategory.Error, "resolution_mode_should_be_either_require_or_import_1453", "`resolution-mode` should be either `require` or `import`."),
         resolution_mode_can_only_be_set_for_type_only_imports: diag(1454, ts.DiagnosticCategory.Error, "resolution_mode_can_only_be_set_for_type_only_imports_1454", "`resolution-mode` can only be set for type-only imports."),
         resolution_mode_is_the_only_valid_key_for_type_import_assertions: diag(1455, ts.DiagnosticCategory.Error, "resolution_mode_is_the_only_valid_key_for_type_import_assertions_1455", "`resolution-mode` is the only valid key for type import assertions."),
@@ -5592,7 +5588,7 @@ var ts;
         An_import_declaration_can_only_be_used_at_the_top_level_of_a_module: diag(1473, ts.DiagnosticCategory.Error, "An_import_declaration_can_only_be_used_at_the_top_level_of_a_module_1473", "An import declaration can only be used at the top level of a module."),
         An_export_declaration_can_only_be_used_at_the_top_level_of_a_module: diag(1474, ts.DiagnosticCategory.Error, "An_export_declaration_can_only_be_used_at_the_top_level_of_a_module_1474", "An export declaration can only be used at the top level of a module."),
         Control_what_method_is_used_to_detect_module_format_JS_files: diag(1475, ts.DiagnosticCategory.Message, "Control_what_method_is_used_to_detect_module_format_JS_files_1475", "Control what method is used to detect module-format JS files."),
-        auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node12_as_modules: diag(1476, ts.DiagnosticCategory.Message, "auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_w_1476", "\"auto\": Treat files with imports, exports, import.meta, jsx (with jsx: react-jsx), or esm format (with module: node12+) as modules."),
+        auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node16_as_modules: diag(1476, ts.DiagnosticCategory.Message, "auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_w_1476", "\"auto\": Treat files with imports, exports, import.meta, jsx (with jsx: react-jsx), or esm format (with module: node16+) as modules."),
         The_types_of_0_are_incompatible_between_these_types: diag(2200, ts.DiagnosticCategory.Error, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."),
         The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, ts.DiagnosticCategory.Error, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."),
         Call_signature_return_types_0_and_1_are_incompatible: diag(2202, ts.DiagnosticCategory.Error, "Call_signature_return_types_0_and_1_are_incompatible_2202", "Call signature return types '{0}' and '{1}' are incompatible.", undefined, true),
@@ -5601,7 +5597,8 @@ 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}'.", undefined, 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}'."),
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, ts.DiagnosticCategory.Error, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
         Static_members_cannot_reference_class_type_parameters: diag(2302, ts.DiagnosticCategory.Error, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."),
@@ -5852,7 +5849,6 @@ var ts;
         A_rest_element_cannot_have_a_property_name: diag(2566, ts.DiagnosticCategory.Error, "A_rest_element_cannot_have_a_property_name_2566", "A rest element cannot have a property name."),
         Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations: diag(2567, ts.DiagnosticCategory.Error, "Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations_2567", "Enum declarations can only merge with namespace or other enum declarations."),
         Property_0_may_not_exist_on_type_1_Did_you_mean_2: diag(2568, ts.DiagnosticCategory.Error, "Property_0_may_not_exist_on_type_1_Did_you_mean_2_2568", "Property '{0}' may not exist on type '{1}'. Did you mean '{2}'?"),
-        Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators: diag(2569, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterati_2569", "Type '{0}' is not an array type or a string type. Use compiler option '--downlevelIteration' to allow iterating of iterators."),
         Could_not_find_name_0_Did_you_mean_1: diag(2570, ts.DiagnosticCategory.Error, "Could_not_find_name_0_Did_you_mean_1_2570", "Could not find name '{0}'. Did you mean '{1}'?"),
         Object_is_of_type_unknown: diag(2571, ts.DiagnosticCategory.Error, "Object_is_of_type_unknown_2571", "Object is of type 'unknown'."),
         A_rest_element_type_must_be_an_array_type: diag(2574, ts.DiagnosticCategory.Error, "A_rest_element_type_must_be_an_array_type_2574", "A rest element type must be an array type."),
@@ -6080,8 +6076,8 @@ var ts;
         Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext: diag(2821, ts.DiagnosticCategory.Error, "Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext_2821", "Import assertions are only supported when the '--module' option is set to 'esnext' or 'nodenext'."),
         Import_assertions_cannot_be_used_with_type_only_imports_or_exports: diag(2822, ts.DiagnosticCategory.Error, "Import_assertions_cannot_be_used_with_type_only_imports_or_exports_2822", "Import assertions cannot be used with type-only imports or exports."),
         Cannot_find_namespace_0_Did_you_mean_1: diag(2833, ts.DiagnosticCategory.Error, "Cannot_find_namespace_0_Did_you_mean_1_2833", "Cannot find namespace '{0}'. Did you mean '{1}'?"),
-        Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Consider_adding_an_extension_to_the_import_path: diag(2834, ts.DiagnosticCategory.Error, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2834", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node12' or 'nodenext'. Consider adding an extension to the import path."),
-        Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Did_you_mean_0: diag(2835, ts.DiagnosticCategory.Error, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2835", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node12' or 'nodenext'. Did you mean '{0}'?"),
+        Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node16_or_nodenext_Consider_adding_an_extension_to_the_import_path: diag(2834, ts.DiagnosticCategory.Error, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2834", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Consider adding an extension to the import path."),
+        Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node16_or_nodenext_Did_you_mean_0: diag(2835, ts.DiagnosticCategory.Error, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2835", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Did you mean '{0}'?"),
         Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls: diag(2836, ts.DiagnosticCategory.Error, "Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls_2836", "Import assertions are not allowed on statements that transpile to commonjs 'require' calls."),
         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."),
@@ -6494,8 +6490,8 @@ var ts;
         Cannot_prepend_project_0_because_it_does_not_have_outFile_set: diag(6308, ts.DiagnosticCategory.Error, "Cannot_prepend_project_0_because_it_does_not_have_outFile_set_6308", "Cannot prepend project '{0}' because it does not have 'outFile' set"),
         Output_file_0_from_project_1_does_not_exist: diag(6309, ts.DiagnosticCategory.Error, "Output_file_0_from_project_1_does_not_exist_6309", "Output file '{0}' from project '{1}' does not exist"),
         Referenced_project_0_may_not_disable_emit: diag(6310, ts.DiagnosticCategory.Error, "Referenced_project_0_may_not_disable_emit_6310", "Referenced project '{0}' may not disable emit."),
-        Project_0_is_out_of_date_because_output_1_is_older_than_input_2: diag(6350, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_1_is_older_than_input_2_6350", "Project '{0}' is out of date because output '{1}' is older than input '{2}'"),
-        Project_0_is_up_to_date_because_newest_input_1_is_older_than_output_2: diag(6351, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_because_newest_input_1_is_older_than_output_2_6351", "Project '{0}' is up to date because newest input '{1}' is older than output '{2}'"),
+        Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2: diag(6350, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2_6350", "Project '{0}' is out of date because oldest output '{1}' is older than newest input '{2}'"),
+        Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2: diag(6351, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2_6351", "Project '{0}' is up to date because newest input '{1}' is older than oldest output '{2}'"),
         Project_0_is_out_of_date_because_output_file_1_does_not_exist: diag(6352, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_file_1_does_not_exist_6352", "Project '{0}' is out of date because output file '{1}' does not exist"),
         Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date: diag(6353, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date_6353", "Project '{0}' is out of date because its dependency '{1}' is out of date"),
         Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies: diag(6354, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies_6354", "Project '{0}' is up to date with .d.ts files from its dependencies"),
@@ -6539,7 +6535,6 @@ var ts;
         Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3: diag(6396, ts.DiagnosticCategory.Message, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_succes_6396", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}'."),
         Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4: diag(6397, ts.DiagnosticCategory.Message, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_succes_6397", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}' with Package ID '{4}'."),
         Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_not_resolved: diag(6398, ts.DiagnosticCategory.Message, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_not_re_6398", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was not resolved."),
-        Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_are_not_emitted: diag(6399, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_are_not_emitted_6399", "Project '{0}' is out of date because buildinfo file '{1}' indicates that some of the changes are not emitted"),
         The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1: diag(6500, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1_6500", "The expected type comes from property '{0}' which is declared here on type '{1}'"),
         The_expected_type_comes_from_this_index_signature: diag(6501, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_this_index_signature_6501", "The expected type comes from this index signature."),
         The_expected_type_comes_from_the_return_type_of_this_signature: diag(6502, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_the_return_type_of_this_signature_6502", "The expected type comes from the return type of this signature."),
@@ -6748,7 +6743,6 @@ var ts;
         This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead: diag(7059, ts.DiagnosticCategory.Error, "This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead_7059", "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead."),
         This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_constraint: diag(7060, ts.DiagnosticCategory.Error, "This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_cons_7060", "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma or explicit constraint."),
         A_mapped_type_may_not_declare_properties_or_methods: diag(7061, ts.DiagnosticCategory.Error, "A_mapped_type_may_not_declare_properties_or_methods_7061", "A mapped type may not declare properties or methods."),
-        JSON_imports_are_experimental_in_ES_module_mode_imports: diag(7062, ts.DiagnosticCategory.Error, "JSON_imports_are_experimental_in_ES_module_mode_imports_7062", "JSON imports are experimental in ES module mode imports."),
         You_cannot_rename_this_element: diag(8000, ts.DiagnosticCategory.Error, "You_cannot_rename_this_element_8000", "You cannot rename this element."),
         You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: diag(8001, ts.DiagnosticCategory.Error, "You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library_8001", "You cannot rename elements that are defined in the standard TypeScript library."),
         import_can_only_be_used_in_TypeScript_files: diag(8002, ts.DiagnosticCategory.Error, "import_can_only_be_used_in_TypeScript_files_8002", "'import ... =' can only be used in TypeScript files."),
@@ -11346,7 +11340,7 @@ var ts;
     }
     ts.getNonAugmentationDeclaration = getNonAugmentationDeclaration;
     function isCommonJSContainingModuleKind(kind) {
-        return kind === ts.ModuleKind.CommonJS || kind === ts.ModuleKind.Node12 || kind === ts.ModuleKind.NodeNext;
+        return kind === ts.ModuleKind.CommonJS || kind === ts.ModuleKind.Node16 || kind === ts.ModuleKind.NodeNext;
     }
     function isEffectiveExternalModule(node, compilerOptions) {
         return ts.isExternalModule(node) || compilerOptions.isolatedModules || (isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator);
@@ -14288,6 +14282,13 @@ var ts;
                     ".d.ts";
     }
     ts.getDeclarationEmitExtensionForPath = getDeclarationEmitExtensionForPath;
+    function getPossibleOriginalInputExtensionForExtension(path) {
+        return ts.fileExtensionIsOneOf(path, [".d.mts", ".mjs", ".mts"]) ? [".mts", ".mjs"] :
+            ts.fileExtensionIsOneOf(path, [".d.cts", ".cjs", ".cts"]) ? [".cts", ".cjs"] :
+                ts.fileExtensionIsOneOf(path, [".json.d.ts"]) ? [".json"] :
+                    [".tsx", ".ts", ".jsx", ".js"];
+    }
+    ts.getPossibleOriginalInputExtensionForExtension = getPossibleOriginalInputExtensionForExtension;
     function outFile(options) {
         return options.outFile || options.out;
     }
@@ -15859,7 +15860,7 @@ var ts;
                     checks.push(isFileModuleFromUsingJSXTag);
                 }
                 var moduleKind = getEmitModuleKind(options);
-                if (moduleKind === ts.ModuleKind.Node12 || moduleKind === ts.ModuleKind.NodeNext) {
+                if (moduleKind === ts.ModuleKind.Node16 || moduleKind === ts.ModuleKind.NodeNext) {
                     checks.push(isFileForcedToBeModuleByFormat);
                 }
                 var combined_1 = ts.or.apply(void 0, checks);
@@ -15870,7 +15871,7 @@ var ts;
     ts.getSetExternalModuleIndicator = getSetExternalModuleIndicator;
     function getEmitScriptTarget(compilerOptions) {
         return compilerOptions.target ||
-            (compilerOptions.module === ts.ModuleKind.Node12 && 7) ||
+            (compilerOptions.module === ts.ModuleKind.Node16 && 9) ||
             (compilerOptions.module === ts.ModuleKind.NodeNext && 99) ||
             0;
     }
@@ -15888,8 +15889,8 @@ var ts;
                 case ts.ModuleKind.CommonJS:
                     moduleResolution = ts.ModuleResolutionKind.NodeJs;
                     break;
-                case ts.ModuleKind.Node12:
-                    moduleResolution = ts.ModuleResolutionKind.Node12;
+                case ts.ModuleKind.Node16:
+                    moduleResolution = ts.ModuleResolutionKind.Node16;
                     break;
                 case ts.ModuleKind.NodeNext:
                     moduleResolution = ts.ModuleResolutionKind.NodeNext;
@@ -15914,7 +15915,7 @@ var ts;
             case ts.ModuleKind.ES2020:
             case ts.ModuleKind.ES2022:
             case ts.ModuleKind.ESNext:
-            case ts.ModuleKind.Node12:
+            case ts.ModuleKind.Node16:
             case ts.ModuleKind.NodeNext:
                 return true;
             default:
@@ -15939,7 +15940,7 @@ var ts;
             return compilerOptions.esModuleInterop;
         }
         switch (getEmitModuleKind(compilerOptions)) {
-            case ts.ModuleKind.Node12:
+            case ts.ModuleKind.Node16:
             case ts.ModuleKind.NodeNext:
                 return true;
         }
@@ -15986,10 +15987,6 @@ var ts;
         return optionsHaveChanges(oldOptions, newOptions, ts.affectsEmitOptionDeclarations);
     }
     ts.compilerOptionsAffectEmit = compilerOptionsAffectEmit;
-    function compilerOptionsAffectDeclarationPath(newOptions, oldOptions) {
-        return optionsHaveChanges(oldOptions, newOptions, ts.affectsDeclarationPathOptionDeclarations);
-    }
-    ts.compilerOptionsAffectDeclarationPath = compilerOptionsAffectDeclarationPath;
     function getCompilerOptionValue(options, option) {
         return option.strictFlag ? getStrictOptionValue(options, option.name) : options[option.name];
     }
@@ -21078,7 +21075,7 @@ var ts;
             return node;
         }
         function cloneSourceFileWithChanges(source, statements, isDeclarationFile, referencedFiles, typeReferences, hasNoDefaultLib, libReferences) {
-            var node = baseFactory.createBaseSourceFileNode(305);
+            var node = (source.redirectInfo ? Object.create(source.redirectInfo.redirectTarget) : baseFactory.createBaseSourceFileNode(305));
             for (var p in source) {
                 if (p === "emitNode" || ts.hasProperty(node, p) || !ts.hasProperty(source, p))
                     continue;
@@ -25190,7 +25187,7 @@ var ts;
         function parseIsolatedEntityName(content, languageVersion) {
             initializeState("", content, languageVersion, undefined, 1);
             nextToken();
-            var entityName = parseEntityName(true, false);
+            var entityName = parseEntityName(true);
             var isInvalid = token() === 1 && !parseDiagnostics.length;
             clearState();
             return isInvalid ? entityName : undefined;
@@ -26471,6 +26468,7 @@ var ts;
                     var startPos = scanner.getStartPos();
                     var result = parseListElement(kind, parseElement);
                     if (!result) {
+                        parsingContext = saveParsingContext;
                         return undefined;
                     }
                     list.push(result);
@@ -26520,7 +26518,7 @@ var ts;
             }
             return createMissingList();
         }
-        function parseEntityName(allowReservedWords, allowPrivateIdentifiers, diagnosticMessage) {
+        function parseEntityName(allowReservedWords, diagnosticMessage) {
             var pos = getNodePos();
             var entity = allowReservedWords ? parseIdentifierName(diagnosticMessage) : parseIdentifier(diagnosticMessage);
             var dotPos = getNodePos();
@@ -26530,7 +26528,7 @@ var ts;
                     break;
                 }
                 dotPos = getNodePos();
-                entity = finishNode(factory.createQualifiedName(entity, parseRightSideOfDot(allowReservedWords, allowPrivateIdentifiers)), pos);
+                entity = finishNode(factory.createQualifiedName(entity, parseRightSideOfDot(allowReservedWords, false)), pos);
             }
             return entity;
         }
@@ -26633,7 +26631,7 @@ var ts;
             return finishNode(node, pos);
         }
         function parseEntityNameOfTypeReference() {
-            return parseEntityName(true, false, ts.Diagnostics.Type_expected);
+            return parseEntityName(true, ts.Diagnostics.Type_expected);
         }
         function parseTypeArgumentsOfTypeReference() {
             if (!scanner.hasPrecedingLineBreak() && reScanLessThanToken() === 29) {
@@ -26747,7 +26745,7 @@ var ts;
         function parseTypeQuery() {
             var pos = getNodePos();
             parseExpected(112);
-            var entityName = parseEntityName(true, true);
+            var entityName = parseEntityName(true);
             var typeArguments = !scanner.hasPrecedingLineBreak() ? tryParseTypeArguments() : undefined;
             return finishNode(factory.createTypeQueryNode(entityName, typeArguments), pos);
         }
@@ -27582,10 +27580,10 @@ var ts;
                 setDecoratorContext(false);
             }
             var pos = getNodePos();
-            var expr = parseAssignmentExpressionOrHigher(false);
+            var expr = parseAssignmentExpressionOrHigher();
             var operatorToken;
             while ((operatorToken = parseOptionalToken(27))) {
-                expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(false), pos);
+                expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(), pos);
             }
             if (saveDecoratorContext) {
                 setDecoratorContext(true);
@@ -27593,23 +27591,23 @@ var ts;
             return expr;
         }
         function parseInitializer() {
-            return parseOptional(63) ? parseAssignmentExpressionOrHigher(false) : undefined;
+            return parseOptional(63) ? parseAssignmentExpressionOrHigher() : undefined;
         }
-        function parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction) {
+        function parseAssignmentExpressionOrHigher() {
             if (isYieldExpression()) {
                 return parseYieldExpression();
             }
-            var arrowExpression = tryParseParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) || tryParseAsyncSimpleArrowFunctionExpression(disallowReturnTypeInArrowFunction);
+            var arrowExpression = tryParseParenthesizedArrowFunctionExpression() || tryParseAsyncSimpleArrowFunctionExpression();
             if (arrowExpression) {
                 return arrowExpression;
             }
             var pos = getNodePos();
             var expr = parseBinaryExpressionOrHigher(0);
             if (expr.kind === 79 && token() === 38) {
-                return parseSimpleArrowFunctionExpression(pos, expr, disallowReturnTypeInArrowFunction, undefined);
+                return parseSimpleArrowFunctionExpression(pos, expr, undefined);
             }
             if (ts.isLeftHandSideExpression(expr) && ts.isAssignmentOperator(reScanGreaterToken())) {
-                return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction), pos);
+                return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(), pos);
             }
             return parseConditionalExpressionRest(expr, pos);
         }
@@ -27631,30 +27629,30 @@ var ts;
             nextToken();
             if (!scanner.hasPrecedingLineBreak() &&
                 (token() === 41 || isStartOfExpression())) {
-                return finishNode(factory.createYieldExpression(parseOptionalToken(41), parseAssignmentExpressionOrHigher(false)), pos);
+                return finishNode(factory.createYieldExpression(parseOptionalToken(41), parseAssignmentExpressionOrHigher()), pos);
             }
             else {
                 return finishNode(factory.createYieldExpression(undefined, undefined), pos);
             }
         }
-        function parseSimpleArrowFunctionExpression(pos, identifier, disallowReturnTypeInArrowFunction, asyncModifier) {
+        function parseSimpleArrowFunctionExpression(pos, identifier, asyncModifier) {
             ts.Debug.assert(token() === 38, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
             var parameter = factory.createParameterDeclaration(undefined, undefined, undefined, identifier, undefined, undefined, undefined);
             finishNode(parameter, identifier.pos);
             var parameters = createNodeArray([parameter], parameter.pos, parameter.end);
             var equalsGreaterThanToken = parseExpectedToken(38);
-            var body = parseArrowFunctionExpressionBody(!!asyncModifier, disallowReturnTypeInArrowFunction);
+            var body = parseArrowFunctionExpressionBody(!!asyncModifier);
             var node = factory.createArrowFunction(asyncModifier, undefined, parameters, undefined, equalsGreaterThanToken, body);
             return addJSDocComment(finishNode(node, pos));
         }
-        function tryParseParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
+        function tryParseParenthesizedArrowFunctionExpression() {
             var triState = isParenthesizedArrowFunctionExpression();
             if (triState === 0) {
                 return undefined;
             }
             return triState === 1 ?
-                parseParenthesizedArrowFunctionExpression(true, false) :
-                tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction); });
+                parseParenthesizedArrowFunctionExpression(true) :
+                tryParse(parsePossibleParenthesizedArrowFunctionExpression);
         }
         function isParenthesizedArrowFunctionExpression() {
             if (token() === 20 || token() === 29 || token() === 131) {
@@ -27748,24 +27746,24 @@ var ts;
                 return 2;
             }
         }
-        function parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
+        function parsePossibleParenthesizedArrowFunctionExpression() {
             var tokenPos = scanner.getTokenPos();
             if (notParenthesizedArrow === null || notParenthesizedArrow === void 0 ? void 0 : notParenthesizedArrow.has(tokenPos)) {
                 return undefined;
             }
-            var result = parseParenthesizedArrowFunctionExpression(false, disallowReturnTypeInArrowFunction);
+            var result = parseParenthesizedArrowFunctionExpression(false);
             if (!result) {
                 (notParenthesizedArrow || (notParenthesizedArrow = new ts.Set())).add(tokenPos);
             }
             return result;
         }
-        function tryParseAsyncSimpleArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
+        function tryParseAsyncSimpleArrowFunctionExpression() {
             if (token() === 131) {
                 if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === 1) {
                     var pos = getNodePos();
                     var asyncModifier = parseModifiersForArrowFunction();
                     var expr = parseBinaryExpressionOrHigher(0);
-                    return parseSimpleArrowFunctionExpression(pos, expr, disallowReturnTypeInArrowFunction, asyncModifier);
+                    return parseSimpleArrowFunctionExpression(pos, expr, asyncModifier);
                 }
             }
             return undefined;
@@ -27783,7 +27781,7 @@ var ts;
             }
             return 0;
         }
-        function parseParenthesizedArrowFunctionExpression(allowAmbiguity, disallowReturnTypeInArrowFunction) {
+        function parseParenthesizedArrowFunctionExpression(allowAmbiguity) {
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             var modifiers = parseModifiersForArrowFunction();
@@ -27811,9 +27809,6 @@ var ts;
                     return undefined;
                 }
             }
-            if (disallowReturnTypeInArrowFunction && token() === 58) {
-                return undefined;
-            }
             var type = parseReturnType(58, false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -27829,12 +27824,12 @@ var ts;
             var lastToken = token();
             var equalsGreaterThanToken = parseExpectedToken(38);
             var body = (lastToken === 38 || lastToken === 18)
-                ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
+                ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier))
                 : parseIdentifier();
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
-        function parseArrowFunctionExpressionBody(isAsync, disallowReturnTypeInArrowFunction) {
+        function parseArrowFunctionExpressionBody(isAsync) {
             if (token() === 18) {
                 return parseFunctionBlock(isAsync ? 2 : 0);
             }
@@ -27848,8 +27843,8 @@ var ts;
             var savedTopLevel = topLevel;
             topLevel = false;
             var node = isAsync
-                ? doInAwaitContext(function () { return parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction); })
-                : doOutsideOfAwaitContext(function () { return parseAssignmentExpressionOrHigher(disallowReturnTypeInArrowFunction); });
+                ? doInAwaitContext(parseAssignmentExpressionOrHigher)
+                : doOutsideOfAwaitContext(parseAssignmentExpressionOrHigher);
             topLevel = savedTopLevel;
             return node;
         }
@@ -27859,8 +27854,8 @@ var ts;
                 return leftOperand;
             }
             var colonToken;
-            return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, function () { return parseAssignmentExpressionOrHigher(true); }), colonToken = parseExpectedToken(58), ts.nodeIsPresent(colonToken)
-                ? parseAssignmentExpressionOrHigher(true)
+            return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher), colonToken = parseExpectedToken(58), ts.nodeIsPresent(colonToken)
+                ? parseAssignmentExpressionOrHigher()
                 : createMissingNode(79, false, ts.Diagnostics._0_expected, ts.tokenToString(58))), pos);
         }
         function parseBinaryExpressionOrHigher(precedence) {
@@ -28511,13 +28506,13 @@ var ts;
         function parseSpreadElement() {
             var pos = getNodePos();
             parseExpected(25);
-            var expression = parseAssignmentExpressionOrHigher(false);
+            var expression = parseAssignmentExpressionOrHigher();
             return finishNode(factory.createSpreadElement(expression), pos);
         }
         function parseArgumentOrArrayLiteralElement() {
             return token() === 25 ? parseSpreadElement() :
                 token() === 27 ? finishNode(factory.createOmittedExpression(), getNodePos()) :
-                    parseAssignmentExpressionOrHigher(false);
+                    parseAssignmentExpressionOrHigher();
         }
         function parseArgumentExpression() {
             return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement);
@@ -28535,7 +28530,7 @@ var ts;
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             if (parseOptionalToken(25)) {
-                var expression = parseAssignmentExpressionOrHigher(false);
+                var expression = parseAssignmentExpressionOrHigher();
                 return withJSDoc(finishNode(factory.createSpreadAssignment(expression), pos), hasJSDoc);
             }
             var decorators = parseDecorators();
@@ -28558,13 +28553,13 @@ var ts;
             var isShorthandPropertyAssignment = tokenIsIdentifier && (token() !== 58);
             if (isShorthandPropertyAssignment) {
                 var equalsToken = parseOptionalToken(63);
-                var objectAssignmentInitializer = equalsToken ? allowInAnd(function () { return parseAssignmentExpressionOrHigher(false); }) : undefined;
+                var objectAssignmentInitializer = equalsToken ? allowInAnd(parseAssignmentExpressionOrHigher) : undefined;
                 node = factory.createShorthandPropertyAssignment(name, objectAssignmentInitializer);
                 node.equalsToken = equalsToken;
             }
             else {
                 parseExpected(58);
-                var initializer = allowInAnd(function () { return parseAssignmentExpressionOrHigher(false); });
+                var initializer = allowInAnd(parseAssignmentExpressionOrHigher);
                 node = factory.createPropertyAssignment(name, initializer);
             }
             node.decorators = decorators;
@@ -28724,7 +28719,7 @@ var ts;
             }
             var node;
             if (awaitToken ? parseExpected(160) : parseOptional(160)) {
-                var expression = allowInAnd(function () { return parseAssignmentExpressionOrHigher(false); });
+                var expression = allowInAnd(parseAssignmentExpressionOrHigher);
                 parseExpected(21);
                 node = factory.createForOfStatement(awaitToken, initializer, expression, parseStatement());
             }
@@ -29762,7 +29757,7 @@ var ts;
             var pos = getNodePos();
             var name = ts.tokenIsIdentifierOrKeyword(token()) ? parseIdentifierName() : parseLiteralLikeNode(10);
             parseExpected(58);
-            var value = parseAssignmentExpressionOrHigher(false);
+            var value = parseAssignmentExpressionOrHigher();
             return finishNode(factory.createAssertEntry(name, value), pos);
         }
         function parseAssertClause(skipAssertKeyword) {
@@ -29812,7 +29807,7 @@ var ts;
         function parseModuleReference() {
             return isExternalModuleReference()
                 ? parseExternalModuleReference()
-                : parseEntityName(false, false);
+                : parseEntityName(false);
         }
         function parseExternalModuleReference() {
             var pos = getNodePos();
@@ -29956,7 +29951,7 @@ var ts;
             else {
                 parseExpected(88);
             }
-            var expression = parseAssignmentExpressionOrHigher(false);
+            var expression = parseAssignmentExpressionOrHigher();
             parseSemicolon();
             setAwaitContext(savedAwaitContext);
             var node = factory.createExportAssignment(decorators, modifiers, isExportEquals, expression);
@@ -29994,7 +29989,7 @@ var ts;
                 var pos = getNodePos();
                 var hasBrace = parseOptional(18);
                 var p2 = getNodePos();
-                var entityName = parseEntityName(false, false);
+                var entityName = parseEntityName(false);
                 while (token() === 80) {
                     reScanHashToken();
                     nextTokenJSDoc();
@@ -30396,7 +30391,7 @@ var ts;
                     skipWhitespace();
                     var p2 = getNodePos();
                     var name = ts.tokenIsIdentifierOrKeyword(token())
-                        ? parseEntityName(true, false)
+                        ? parseEntityName(true)
                         : undefined;
                     if (name) {
                         while (token() === 80) {
@@ -31484,6 +31479,7 @@ var ts;
         ["es2021.intl", "lib.es2021.intl.d.ts"],
         ["es2022.array", "lib.es2022.array.d.ts"],
         ["es2022.error", "lib.es2022.error.d.ts"],
+        ["es2022.intl", "lib.es2022.intl.d.ts"],
         ["es2022.object", "lib.es2022.object.d.ts"],
         ["es2022.string", "lib.es2022.string.d.ts"],
         ["esnext.array", "lib.es2022.array.d.ts"],
@@ -31684,7 +31680,6 @@ var ts;
             type: "boolean",
             affectsSemanticDiagnostics: true,
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Watch_and_Build_Modes,
             description: ts.Diagnostics.Have_recompiles_in_projects_that_use_incremental_and_watch_mode_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it,
             defaultValueDescription: false,
@@ -31718,39 +31713,12 @@ var ts;
         affectsSourceFile: true,
         affectsModuleResolution: true,
         affectsEmit: true,
-        affectsMultiFileEmitBuildInfo: true,
         paramType: ts.Diagnostics.VERSION,
         showInSimplifiedHelpView: true,
         category: ts.Diagnostics.Language_and_Environment,
         description: ts.Diagnostics.Set_the_JavaScript_language_version_for_emitted_JavaScript_and_include_compatible_library_declarations,
         defaultValueDescription: 0,
     };
-    ts.moduleOptionDeclaration = {
-        name: "module",
-        shortName: "m",
-        type: new ts.Map(ts.getEntries({
-            none: ts.ModuleKind.None,
-            commonjs: ts.ModuleKind.CommonJS,
-            amd: ts.ModuleKind.AMD,
-            system: ts.ModuleKind.System,
-            umd: ts.ModuleKind.UMD,
-            es6: ts.ModuleKind.ES2015,
-            es2015: ts.ModuleKind.ES2015,
-            es2020: ts.ModuleKind.ES2020,
-            es2022: ts.ModuleKind.ES2022,
-            esnext: ts.ModuleKind.ESNext,
-            node12: ts.ModuleKind.Node12,
-            nodenext: ts.ModuleKind.NodeNext,
-        })),
-        affectsModuleResolution: true,
-        affectsEmit: true,
-        affectsMultiFileEmitBuildInfo: true,
-        paramType: ts.Diagnostics.KIND,
-        showInSimplifiedHelpView: true,
-        category: ts.Diagnostics.Modules,
-        description: ts.Diagnostics.Specify_what_module_code_is_generated,
-        defaultValueDescription: undefined,
-    };
     var commandOptionsWithoutBuild = [
         {
             name: "all",
@@ -31811,13 +31779,36 @@ var ts;
             category: ts.Diagnostics.Command_line_Options,
             affectsSemanticDiagnostics: true,
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             isCommandLineOnly: true,
             description: ts.Diagnostics.Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing,
             defaultValueDescription: false,
         },
         ts.targetOptionDeclaration,
-        ts.moduleOptionDeclaration,
+        {
+            name: "module",
+            shortName: "m",
+            type: new ts.Map(ts.getEntries({
+                none: ts.ModuleKind.None,
+                commonjs: ts.ModuleKind.CommonJS,
+                amd: ts.ModuleKind.AMD,
+                system: ts.ModuleKind.System,
+                umd: ts.ModuleKind.UMD,
+                es6: ts.ModuleKind.ES2015,
+                es2015: ts.ModuleKind.ES2015,
+                es2020: ts.ModuleKind.ES2020,
+                es2022: ts.ModuleKind.ES2022,
+                esnext: ts.ModuleKind.ESNext,
+                node16: ts.ModuleKind.Node16,
+                nodenext: ts.ModuleKind.NodeNext,
+            })),
+            affectsModuleResolution: true,
+            affectsEmit: true,
+            paramType: ts.Diagnostics.KIND,
+            showInSimplifiedHelpView: true,
+            category: ts.Diagnostics.Modules,
+            description: ts.Diagnostics.Specify_what_module_code_is_generated,
+            defaultValueDescription: undefined,
+        },
         {
             name: "lib",
             type: "list",
@@ -31854,7 +31845,6 @@ var ts;
             type: jsxOptionMap,
             affectsSourceFile: true,
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             affectsModuleResolution: true,
             paramType: ts.Diagnostics.KIND,
             showInSimplifiedHelpView: true,
@@ -31867,7 +31857,6 @@ var ts;
             shortName: "d",
             type: "boolean",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             showInSimplifiedHelpView: true,
             category: ts.Diagnostics.Emit,
             transpileOptionValue: undefined,
@@ -31878,7 +31867,6 @@ var ts;
             name: "declarationMap",
             type: "boolean",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             showInSimplifiedHelpView: true,
             category: ts.Diagnostics.Emit,
             transpileOptionValue: undefined,
@@ -31889,7 +31877,6 @@ var ts;
             name: "emitDeclarationOnly",
             type: "boolean",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             showInSimplifiedHelpView: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Only_output_d_ts_files_and_not_JavaScript_files,
@@ -31900,7 +31887,6 @@ var ts;
             name: "sourceMap",
             type: "boolean",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             showInSimplifiedHelpView: true,
             category: ts.Diagnostics.Emit,
             defaultValueDescription: false,
@@ -31910,9 +31896,6 @@ var ts;
             name: "outFile",
             type: "string",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
-            affectsDeclarationPath: true,
-            affectsBundleEmitBuildInfo: true,
             isFilePath: true,
             paramType: ts.Diagnostics.FILE,
             showInSimplifiedHelpView: true,
@@ -31924,8 +31907,6 @@ var ts;
             name: "outDir",
             type: "string",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
-            affectsDeclarationPath: true,
             isFilePath: true,
             paramType: ts.Diagnostics.DIRECTORY,
             showInSimplifiedHelpView: true,
@@ -31936,8 +31917,6 @@ var ts;
             name: "rootDir",
             type: "string",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
-            affectsDeclarationPath: true,
             isFilePath: true,
             paramType: ts.Diagnostics.LOCATION,
             category: ts.Diagnostics.Modules,
@@ -31948,8 +31927,6 @@ var ts;
             name: "composite",
             type: "boolean",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
-            affectsBundleEmitBuildInfo: true,
             isTSConfigOnly: true,
             category: ts.Diagnostics.Projects,
             transpileOptionValue: undefined,
@@ -31960,8 +31937,6 @@ var ts;
             name: "tsBuildInfoFile",
             type: "string",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
-            affectsBundleEmitBuildInfo: true,
             isFilePath: true,
             paramType: ts.Diagnostics.FILE,
             category: ts.Diagnostics.Projects,
@@ -31973,7 +31948,6 @@ var ts;
             name: "removeComments",
             type: "boolean",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             showInSimplifiedHelpView: true,
             category: ts.Diagnostics.Emit,
             defaultValueDescription: false,
@@ -31992,7 +31966,6 @@ var ts;
             name: "importHelpers",
             type: "boolean",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Allow_importing_helper_functions_from_tslib_once_per_project_instead_of_including_them_per_file,
             defaultValueDescription: false,
@@ -32006,7 +31979,6 @@ var ts;
             })),
             affectsEmit: true,
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types,
             defaultValueDescription: 0,
@@ -32015,7 +31987,6 @@ var ts;
             name: "downlevelIteration",
             type: "boolean",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Emit_more_compliant_but_verbose_and_less_performant_JavaScript_for_iteration,
             defaultValueDescription: false,
@@ -32031,7 +32002,6 @@ var ts;
         {
             name: "strict",
             type: "boolean",
-            affectsMultiFileEmitBuildInfo: true,
             showInSimplifiedHelpView: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Enable_all_strict_type_checking_options,
@@ -32041,7 +32011,6 @@ var ts;
             name: "noImplicitAny",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             strictFlag: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Enable_error_reporting_for_expressions_and_declarations_with_an_implied_any_type,
@@ -32051,7 +32020,6 @@ var ts;
             name: "strictNullChecks",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             strictFlag: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.When_type_checking_take_into_account_null_and_undefined,
@@ -32060,8 +32028,6 @@ var ts;
         {
             name: "strictFunctionTypes",
             type: "boolean",
-            affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             strictFlag: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.When_assigning_functions_check_to_ensure_parameters_and_the_return_values_are_subtype_compatible,
@@ -32070,8 +32036,6 @@ var ts;
         {
             name: "strictBindCallApply",
             type: "boolean",
-            affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             strictFlag: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Check_that_the_arguments_for_bind_call_and_apply_methods_match_the_original_function,
@@ -32081,7 +32045,6 @@ var ts;
             name: "strictPropertyInitialization",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             strictFlag: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Check_for_class_properties_that_are_declared_but_not_set_in_the_constructor,
@@ -32091,7 +32054,6 @@ var ts;
             name: "noImplicitThis",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             strictFlag: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Enable_error_reporting_when_this_is_given_the_type_any,
@@ -32101,7 +32063,6 @@ var ts;
             name: "useUnknownInCatchVariables",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             strictFlag: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Default_catch_clause_variables_as_unknown_instead_of_any,
@@ -32111,8 +32072,6 @@ var ts;
             name: "alwaysStrict",
             type: "boolean",
             affectsSourceFile: true,
-            affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             strictFlag: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Ensure_use_strict_is_always_emitted,
@@ -32122,7 +32081,6 @@ var ts;
             name: "noUnusedLocals",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Enable_error_reporting_when_local_variables_aren_t_read,
             defaultValueDescription: false,
@@ -32131,7 +32089,6 @@ var ts;
             name: "noUnusedParameters",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Raise_an_error_when_a_function_parameter_isn_t_read,
             defaultValueDescription: false,
@@ -32140,7 +32097,6 @@ var ts;
             name: "exactOptionalPropertyTypes",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Interpret_optional_property_types_as_written_rather_than_adding_undefined,
             defaultValueDescription: false,
@@ -32149,7 +32105,6 @@ var ts;
             name: "noImplicitReturns",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Enable_error_reporting_for_codepaths_that_do_not_explicitly_return_in_a_function,
             defaultValueDescription: false,
@@ -32159,7 +32114,6 @@ var ts;
             type: "boolean",
             affectsBindDiagnostics: true,
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Enable_error_reporting_for_fallthrough_cases_in_switch_statements,
             defaultValueDescription: false,
@@ -32168,7 +32122,6 @@ var ts;
             name: "noUncheckedIndexedAccess",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Add_undefined_to_a_type_when_accessed_using_an_index,
             defaultValueDescription: false,
@@ -32177,7 +32130,6 @@ var ts;
             name: "noImplicitOverride",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Ensure_overriding_members_in_derived_classes_are_marked_with_an_override_modifier,
             defaultValueDescription: false,
@@ -32185,8 +32137,6 @@ var ts;
         {
             name: "noPropertyAccessFromIndexSignature",
             type: "boolean",
-            affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             showInSimplifiedHelpView: false,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Enforces_using_indexed_accessors_for_keys_declared_using_an_indexed_type,
@@ -32197,7 +32147,7 @@ var ts;
             type: new ts.Map(ts.getEntries({
                 node: ts.ModuleResolutionKind.NodeJs,
                 classic: ts.ModuleResolutionKind.Classic,
-                node12: ts.ModuleResolutionKind.Node12,
+                node16: ts.ModuleResolutionKind.Node16,
                 nodenext: ts.ModuleResolutionKind.NodeNext,
             })),
             affectsModuleResolution: true,
@@ -32267,7 +32217,6 @@ var ts;
             name: "allowSyntheticDefaultImports",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Interop_Constraints,
             description: ts.Diagnostics.Allow_import_x_from_y_when_a_module_doesn_t_have_a_default_export,
             defaultValueDescription: ts.Diagnostics.module_system_or_esModuleInterop
@@ -32277,7 +32226,6 @@ var ts;
             type: "boolean",
             affectsSemanticDiagnostics: true,
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             showInSimplifiedHelpView: true,
             category: ts.Diagnostics.Interop_Constraints,
             description: ts.Diagnostics.Emit_additional_JavaScript_to_ease_support_for_importing_CommonJS_modules_This_enables_allowSyntheticDefaultImports_for_type_compatibility,
@@ -32294,7 +32242,6 @@ var ts;
             name: "allowUmdGlobalAccess",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Modules,
             description: ts.Diagnostics.Allow_accessing_UMD_globals_from_modules,
             defaultValueDescription: false,
@@ -32315,7 +32262,6 @@ var ts;
             name: "sourceRoot",
             type: "string",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             paramType: ts.Diagnostics.LOCATION,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Specify_the_root_path_for_debuggers_to_find_the_reference_source_code,
@@ -32324,7 +32270,6 @@ var ts;
             name: "mapRoot",
             type: "string",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             paramType: ts.Diagnostics.LOCATION,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations,
@@ -32333,7 +32278,6 @@ var ts;
             name: "inlineSourceMap",
             type: "boolean",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Include_sourcemap_files_inside_the_emitted_JavaScript,
             defaultValueDescription: false,
@@ -32342,7 +32286,6 @@ var ts;
             name: "inlineSources",
             type: "boolean",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Include_source_code_in_the_sourcemaps_inside_the_emitted_JavaScript,
             defaultValueDescription: false,
@@ -32351,7 +32294,6 @@ var ts;
             name: "experimentalDecorators",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Language_and_Environment,
             description: ts.Diagnostics.Enable_experimental_support_for_TC39_stage_2_draft_decorators,
             defaultValueDescription: false,
@@ -32361,7 +32303,6 @@ var ts;
             type: "boolean",
             affectsSemanticDiagnostics: true,
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Language_and_Environment,
             description: ts.Diagnostics.Emit_design_type_metadata_for_decorated_declarations_in_source_files,
             defaultValueDescription: false,
@@ -32385,7 +32326,6 @@ var ts;
             type: "string",
             affectsSemanticDiagnostics: true,
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             affectsModuleResolution: true,
             category: ts.Diagnostics.Language_and_Environment,
             description: ts.Diagnostics.Specify_module_specifier_used_to_import_the_JSX_factory_functions_when_using_jsx_Colon_react_jsx_Asterisk,
@@ -32403,9 +32343,6 @@ var ts;
             name: "out",
             type: "string",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
-            affectsDeclarationPath: true,
-            affectsBundleEmitBuildInfo: true,
             isFilePath: false,
             category: ts.Diagnostics.Backwards_Compatibility,
             paramType: ts.Diagnostics.FILE,
@@ -32416,7 +32353,6 @@ var ts;
             name: "reactNamespace",
             type: "string",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Language_and_Environment,
             description: ts.Diagnostics.Specify_the_object_invoked_for_createElement_This_only_applies_when_targeting_react_JSX_emit,
             defaultValueDescription: "`React`",
@@ -32424,7 +32360,6 @@ var ts;
         {
             name: "skipDefaultLibCheck",
             type: "boolean",
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Completeness,
             description: ts.Diagnostics.Skip_type_checking_d_ts_files_that_are_included_with_TypeScript,
             defaultValueDescription: false,
@@ -32440,7 +32375,6 @@ var ts;
             name: "emitBOM",
             type: "boolean",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files,
             defaultValueDescription: false,
@@ -32452,7 +32386,6 @@ var ts;
                 lf: 1
             })),
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             paramType: ts.Diagnostics.NEWLINE,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Set_the_newline_character_for_emitting_files,
@@ -32462,7 +32395,6 @@ var ts;
             name: "noErrorTruncation",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Output_Formatting,
             description: ts.Diagnostics.Disable_truncating_types_in_error_messages,
             defaultValueDescription: false,
@@ -32489,7 +32421,6 @@ var ts;
             name: "stripInternal",
             type: "boolean",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Disable_emitting_declarations_that_have_internal_in_their_JSDoc_comments,
             defaultValueDescription: false,
@@ -32530,7 +32461,6 @@ var ts;
             name: "noImplicitUseStrict",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Backwards_Compatibility,
             description: ts.Diagnostics.Disable_adding_use_strict_directives_in_emitted_JavaScript_files,
             defaultValueDescription: false,
@@ -32539,7 +32469,6 @@ var ts;
             name: "noEmitHelpers",
             type: "boolean",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Disable_generating_custom_helper_functions_like_extends_in_compiled_output,
             defaultValueDescription: false,
@@ -32548,7 +32477,6 @@ var ts;
             name: "noEmitOnError",
             type: "boolean",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             transpileOptionValue: undefined,
             description: ts.Diagnostics.Disable_emitting_files_if_any_type_checking_errors_are_reported,
@@ -32558,7 +32486,6 @@ var ts;
             name: "preserveConstEnums",
             type: "boolean",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Disable_erasing_const_enum_declarations_in_generated_code,
             defaultValueDescription: false,
@@ -32567,8 +32494,6 @@ var ts;
             name: "declarationDir",
             type: "string",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
-            affectsDeclarationPath: true,
             isFilePath: true,
             paramType: ts.Diagnostics.DIRECTORY,
             category: ts.Diagnostics.Emit,
@@ -32578,7 +32503,6 @@ var ts;
         {
             name: "skipLibCheck",
             type: "boolean",
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Completeness,
             description: ts.Diagnostics.Skip_type_checking_all_d_ts_files,
             defaultValueDescription: false,
@@ -32588,7 +32512,6 @@ var ts;
             type: "boolean",
             affectsBindDiagnostics: true,
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Disable_error_reporting_for_unused_labels,
             defaultValueDescription: undefined,
@@ -32598,7 +32521,6 @@ var ts;
             type: "boolean",
             affectsBindDiagnostics: true,
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Type_Checking,
             description: ts.Diagnostics.Disable_error_reporting_for_unreachable_code,
             defaultValueDescription: undefined,
@@ -32607,7 +32529,6 @@ var ts;
             name: "suppressExcessPropertyErrors",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Backwards_Compatibility,
             description: ts.Diagnostics.Disable_reporting_of_excess_property_errors_during_the_creation_of_object_literals,
             defaultValueDescription: false,
@@ -32616,7 +32537,6 @@ var ts;
             name: "suppressImplicitAnyIndexErrors",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Backwards_Compatibility,
             description: ts.Diagnostics.Suppress_noImplicitAny_errors_when_indexing_objects_that_lack_index_signatures,
             defaultValueDescription: false,
@@ -32641,7 +32561,6 @@ var ts;
             name: "noStrictGenericChecks",
             type: "boolean",
             affectsSemanticDiagnostics: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Backwards_Compatibility,
             description: ts.Diagnostics.Disable_strict_checking_of_generic_signatures_in_function_types,
             defaultValueDescription: false,
@@ -32651,7 +32570,6 @@ var ts;
             type: "boolean",
             affectsSemanticDiagnostics: true,
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Language_and_Environment,
             description: ts.Diagnostics.Emit_ECMAScript_standard_compliant_class_fields,
             defaultValueDescription: ts.Diagnostics.true_for_ES2022_and_above_including_ESNext
@@ -32660,7 +32578,6 @@ var ts;
             name: "preserveValueImports",
             type: "boolean",
             affectsEmit: true,
-            affectsMultiFileEmitBuildInfo: true,
             category: ts.Diagnostics.Emit,
             description: ts.Diagnostics.Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed,
             defaultValueDescription: false,
@@ -32693,13 +32610,12 @@ var ts;
             affectsModuleResolution: true,
             description: ts.Diagnostics.Control_what_method_is_used_to_detect_module_format_JS_files,
             category: ts.Diagnostics.Language_and_Environment,
-            defaultValueDescription: ts.Diagnostics.auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node12_as_modules,
+            defaultValueDescription: ts.Diagnostics.auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node16_as_modules,
         }
     ];
     ts.optionDeclarations = __spreadArray(__spreadArray([], ts.commonOptionsWithBuild, true), commandOptionsWithoutBuild, true);
     ts.semanticDiagnosticsOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsSemanticDiagnostics; });
     ts.affectsEmitOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsEmit; });
-    ts.affectsDeclarationPathOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsDeclarationPath; });
     ts.moduleResolutionOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsModuleResolution; });
     ts.sourceFileAffectingCompilerOptions = ts.optionDeclarations.filter(function (option) {
         return !!option.affectsSourceFile || !!option.affectsModuleResolution || !!option.affectsBindDiagnostics;
@@ -33479,7 +33395,6 @@ var ts;
             }
         });
     }
-    ts.getNameOfCompilerOptionValue = getNameOfCompilerOptionValue;
     function serializeCompilerOptions(options, pathOptions) {
         return serializeOptionBaseObject(options, getOptionsNameMap(), pathOptions);
     }
@@ -34456,7 +34371,7 @@ var ts;
         ts.Debug.assert(ts.extensionIsTS(resolved.extension));
         return { fileName: resolved.path, packageId: resolved.packageId };
     }
-    function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, resultFromCache) {
+    function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, diagnostics, resultFromCache) {
         var _a;
         if (resultFromCache) {
             (_a = resultFromCache.failedLookupLocations).push.apply(_a, failedLookupLocations);
@@ -34464,7 +34379,8 @@ var ts;
         }
         return {
             resolvedModule: resolved && { resolvedFileName: resolved.path, originalPath: resolved.originalPath === true ? undefined : resolved.originalPath, extension: resolved.extension, isExternalLibraryImport: isExternalLibraryImport, packageId: resolved.packageId },
-            failedLookupLocations: failedLookupLocations
+            failedLookupLocations: failedLookupLocations,
+            resolutionDiagnostics: diagnostics
         };
     }
     function readPackageJsonField(jsonContent, fieldName, typeOfTag, state) {
@@ -34641,11 +34557,22 @@ var ts;
         }
         var failedLookupLocations = [];
         var features = getDefaultNodeResolutionFeatures(options);
-        if (resolutionMode === ts.ModuleKind.ESNext && (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12 || ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext)) {
+        if (resolutionMode === ts.ModuleKind.ESNext && (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node16 || ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext)) {
             features |= NodeResolutionFeatures.EsmMode;
         }
         var conditions = features & NodeResolutionFeatures.Exports ? features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"] : [];
-        var moduleResolutionState = { compilerOptions: options, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: features, conditions: conditions };
+        var diagnostics = [];
+        var moduleResolutionState = {
+            compilerOptions: options,
+            host: host,
+            traceEnabled: traceEnabled,
+            failedLookupLocations: failedLookupLocations,
+            packageJsonInfoCache: cache,
+            features: features,
+            conditions: conditions,
+            requestContainingDirectory: containingDirectory,
+            reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
+        };
         var resolved = primaryLookup();
         var primary = true;
         if (!resolved) {
@@ -34664,7 +34591,7 @@ var ts;
                 isExternalLibraryImport: pathContainsNodeModules(fileName),
             };
         }
-        result = { resolvedTypeReferenceDirective: resolvedTypeReferenceDirective, failedLookupLocations: failedLookupLocations };
+        result = { resolvedTypeReferenceDirective: resolvedTypeReferenceDirective, failedLookupLocations: failedLookupLocations, resolutionDiagnostics: diagnostics };
         perFolderCache === null || perFolderCache === void 0 ? void 0 : perFolderCache.set(typeReferenceDirectiveName, resolutionMode, result);
         if (traceEnabled)
             traceResult(result);
@@ -34728,7 +34655,7 @@ var ts;
     }
     ts.resolveTypeReferenceDirective = resolveTypeReferenceDirective;
     function getDefaultNodeResolutionFeatures(options) {
-        return ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12 ? NodeResolutionFeatures.Node12Default :
+        return ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node16 ? NodeResolutionFeatures.Node16Default :
             ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext ? NodeResolutionFeatures.NodeNextDefault :
                 NodeResolutionFeatures.None;
     }
@@ -34741,6 +34668,8 @@ var ts;
             packageJsonInfoCache: cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(),
             conditions: ts.emptyArray,
             features: NodeResolutionFeatures.None,
+            requestContainingDirectory: containingDirectory,
+            reportDiagnostic: ts.noop
         };
         return ts.forEachAncestorDirectory(containingDirectory, function (ancestorDirectory) {
             if (ts.getBaseFileName(ancestorDirectory) !== "node_modules") {
@@ -35041,8 +34970,8 @@ var ts;
                     case ts.ModuleKind.CommonJS:
                         moduleResolution = ts.ModuleResolutionKind.NodeJs;
                         break;
-                    case ts.ModuleKind.Node12:
-                        moduleResolution = ts.ModuleResolutionKind.Node12;
+                    case ts.ModuleKind.Node16:
+                        moduleResolution = ts.ModuleResolutionKind.Node16;
                         break;
                     case ts.ModuleKind.NodeNext:
                         moduleResolution = ts.ModuleResolutionKind.NodeNext;
@@ -35062,8 +34991,8 @@ var ts;
             }
             ts.perfLogger.logStartResolveModule(moduleName);
             switch (moduleResolution) {
-                case ts.ModuleResolutionKind.Node12:
-                    result = node12ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
+                case ts.ModuleResolutionKind.Node16:
+                    result = node16ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
                     break;
                 case ts.ModuleResolutionKind.NodeNext:
                     result = nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
@@ -35221,12 +35150,12 @@ var ts;
         NodeResolutionFeatures[NodeResolutionFeatures["Exports"] = 8] = "Exports";
         NodeResolutionFeatures[NodeResolutionFeatures["ExportsPatternTrailers"] = 16] = "ExportsPatternTrailers";
         NodeResolutionFeatures[NodeResolutionFeatures["AllFeatures"] = 30] = "AllFeatures";
-        NodeResolutionFeatures[NodeResolutionFeatures["Node12Default"] = 14] = "Node12Default";
+        NodeResolutionFeatures[NodeResolutionFeatures["Node16Default"] = 30] = "Node16Default";
         NodeResolutionFeatures[NodeResolutionFeatures["NodeNextDefault"] = 30] = "NodeNextDefault";
         NodeResolutionFeatures[NodeResolutionFeatures["EsmMode"] = 32] = "EsmMode";
     })(NodeResolutionFeatures || (NodeResolutionFeatures = {}));
-    function node12ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
-        return nodeNextModuleNameResolverWorker(NodeResolutionFeatures.Node12Default, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
+    function node16ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
+        return nodeNextModuleNameResolverWorker(NodeResolutionFeatures.Node16Default, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
     }
     function nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
         return nodeNextModuleNameResolverWorker(NodeResolutionFeatures.NodeNextDefault, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
@@ -35269,6 +35198,7 @@ var ts;
         if (compilerOptions.noDtsResolution) {
             conditions.pop();
         }
+        var diagnostics = [];
         var state = {
             compilerOptions: compilerOptions,
             host: host,
@@ -35277,9 +35207,11 @@ var ts;
             packageJsonInfoCache: cache,
             features: features,
             conditions: conditions,
+            requestContainingDirectory: containingDirectory,
+            reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
         };
         var result = ts.forEach(extensions, function (ext) { return tryResolve(ext); });
-        return createResolvedModuleWithFailedLookupLocations((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, state.resultFromCache);
+        return createResolvedModuleWithFailedLookupLocations((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, diagnostics, state.resultFromCache);
         function tryResolve(extensions) {
             var loader = function (extensions, candidate, onlyRecordFailures, state) { return nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, true); };
             var resolved = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, state);
@@ -35421,9 +35353,9 @@ var ts;
         }
     }
     function loadJSOrExactTSFileName(extensions, candidate, onlyRecordFailures, state) {
-        if ((extensions === Extensions.TypeScript || extensions === Extensions.DtsOnly) && ts.isDeclarationFileName(candidate)) {
+        if ((extensions === Extensions.TypeScript || extensions === Extensions.DtsOnly) && ts.fileExtensionIsOneOf(candidate, ts.supportedTSExtensionsFlat)) {
             var result = tryFile(candidate, onlyRecordFailures, state);
-            return result !== undefined ? { path: candidate, ext: ts.forEach(ts.supportedDeclarationExtensions, function (e) { return ts.fileExtensionIs(candidate, e) ? e : undefined; }) } : undefined;
+            return result !== undefined ? { path: candidate, ext: ts.tryExtractTSExtension(candidate) } : undefined;
         }
         return loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state);
     }
@@ -35540,6 +35472,8 @@ var ts;
             packageJsonInfoCache: cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(),
             conditions: ["node", "require", "types"],
             features: features,
+            requestContainingDirectory: packageJsonInfo.packageDirectory,
+            reportDiagnostic: ts.noop
         };
         var requireResolution = loadNodeModuleFromDirectoryWorker(extensions, packageJsonInfo.packageDirectory, false, requireState, packageJsonInfo.packageJsonContent, packageJsonInfo.versionPaths);
         entrypoints = ts.append(entrypoints, requireResolution === null || requireResolution === void 0 ? void 0 : requireResolution.path);
@@ -35619,6 +35553,8 @@ var ts;
             packageJsonInfoCache: packageJsonInfoCache,
             features: 0,
             conditions: [],
+            requestContainingDirectory: undefined,
+            reportDiagnostic: ts.noop
         };
         var parts = ts.getPathComponents(fileName);
         parts.pop();
@@ -35893,7 +35829,6 @@ var ts;
     function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports) {
         return loadModuleFromTargetImportOrExport;
         function loadModuleFromTargetImportOrExport(target, subpath, pattern) {
-            var _a, _b;
             if (typeof target === "string") {
                 if (!pattern && subpath.length > 0 && !ts.endsWith(target, "/")) {
                     if (state.traceEnabled) {
@@ -35928,13 +35863,16 @@ var ts;
                     }
                     return toSearchResult(undefined);
                 }
-                var finalPath = ts.getNormalizedAbsolutePath(pattern ? resolvedTarget.replace(/\*/g, subpath) : resolvedTarget + subpath, (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a));
+                var finalPath = toAbsolutePath(pattern ? resolvedTarget.replace(/\*/g, subpath) : resolvedTarget + subpath);
+                var inputLink = tryLoadInputFileForPath(finalPath, subpath, ts.combinePaths(scope.packageDirectory, "package.json"), isImports);
+                if (inputLink)
+                    return inputLink;
                 return toSearchResult(withPackageId(scope, loadJSOrExactTSFileName(extensions, finalPath, false, state)));
             }
             else if (typeof target === "object" && target !== null) {
                 if (!Array.isArray(target)) {
-                    for (var _i = 0, _c = ts.getOwnKeys(target); _i < _c.length; _i++) {
-                        var key = _c[_i];
+                    for (var _i = 0, _a = ts.getOwnKeys(target); _i < _a.length; _i++) {
+                        var key = _a[_i];
                         if (key === "default" || state.conditions.indexOf(key) >= 0 || isApplicableVersionedTypesKey(state.conditions, key)) {
                             var subTarget = target[key];
                             var result = loadModuleFromTargetImportOrExport(subTarget, subpath, pattern);
@@ -35952,8 +35890,8 @@ var ts;
                         }
                         return toSearchResult(undefined);
                     }
-                    for (var _d = 0, target_2 = target; _d < target_2.length; _d++) {
-                        var elem = target_2[_d];
+                    for (var _b = 0, target_2 = target; _b < target_2.length; _b++) {
+                        var elem = target_2[_b];
                         var result = loadModuleFromTargetImportOrExport(elem, subpath, pattern);
                         if (result) {
                             return result;
@@ -35971,6 +35909,94 @@ var ts;
                 trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
             }
             return toSearchResult(undefined);
+            function toAbsolutePath(path) {
+                var _a, _b;
+                if (path === undefined)
+                    return path;
+                return ts.hostGetCanonicalFileName({ useCaseSensitiveFileNames: useCaseSensitiveFileNames })(ts.getNormalizedAbsolutePath(path, (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a)));
+            }
+            function combineDirectoryPath(root, dir) {
+                return ts.ensureTrailingDirectorySeparator(ts.combinePaths(root, dir));
+            }
+            function useCaseSensitiveFileNames() {
+                return !state.host.useCaseSensitiveFileNames ? true :
+                    typeof state.host.useCaseSensitiveFileNames === "boolean" ? state.host.useCaseSensitiveFileNames :
+                        state.host.useCaseSensitiveFileNames();
+            }
+            function tryLoadInputFileForPath(finalPath, entry, packagePath, isImports) {
+                var _a, _b, _c, _d;
+                if ((extensions === Extensions.TypeScript || extensions === Extensions.JavaScript || extensions === Extensions.Json)
+                    && (state.compilerOptions.declarationDir || state.compilerOptions.outDir)
+                    && finalPath.indexOf("/node_modules/") === -1
+                    && (state.compilerOptions.configFile ? ts.startsWith(toAbsolutePath(state.compilerOptions.configFile.fileName), scope.packageDirectory) : true)) {
+                    var getCanonicalFileName = ts.hostGetCanonicalFileName({ useCaseSensitiveFileNames: useCaseSensitiveFileNames });
+                    var commonSourceDirGuesses = [];
+                    if (state.compilerOptions.rootDir || (state.compilerOptions.composite && state.compilerOptions.configFilePath)) {
+                        var commonDir = toAbsolutePath(ts.getCommonSourceDirectory(state.compilerOptions, function () { return []; }, ((_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a)) || "", getCanonicalFileName));
+                        commonSourceDirGuesses.push(commonDir);
+                    }
+                    else if (state.requestContainingDirectory) {
+                        var requestingFile_1 = toAbsolutePath(ts.combinePaths(state.requestContainingDirectory, "index.ts"));
+                        var commonDir = toAbsolutePath(ts.getCommonSourceDirectory(state.compilerOptions, function () { return [requestingFile_1, toAbsolutePath(packagePath)]; }, ((_d = (_c = state.host).getCurrentDirectory) === null || _d === void 0 ? void 0 : _d.call(_c)) || "", getCanonicalFileName));
+                        commonSourceDirGuesses.push(commonDir);
+                        var fragment = ts.ensureTrailingDirectorySeparator(commonDir);
+                        while (fragment && fragment.length > 1) {
+                            var parts = ts.getPathComponents(fragment);
+                            parts.pop();
+                            var commonDir_1 = ts.getPathFromPathComponents(parts);
+                            commonSourceDirGuesses.unshift(commonDir_1);
+                            fragment = ts.ensureTrailingDirectorySeparator(commonDir_1);
+                        }
+                    }
+                    if (commonSourceDirGuesses.length > 1) {
+                        state.reportDiagnostic(ts.createCompilerDiagnostic(isImports
+                            ? ts.Diagnostics.The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate
+                            : ts.Diagnostics.The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate, entry === "" ? "." : entry, packagePath));
+                    }
+                    for (var _i = 0, commonSourceDirGuesses_1 = commonSourceDirGuesses; _i < commonSourceDirGuesses_1.length; _i++) {
+                        var commonSourceDirGuess = commonSourceDirGuesses_1[_i];
+                        var candidateDirectories = getOutputDirectoriesForBaseDirectory(commonSourceDirGuess);
+                        for (var _e = 0, candidateDirectories_1 = candidateDirectories; _e < candidateDirectories_1.length; _e++) {
+                            var candidateDir = candidateDirectories_1[_e];
+                            if (ts.startsWith(finalPath, candidateDir)) {
+                                var pathFragment = finalPath.slice(candidateDir.length + 1);
+                                var possibleInputBase = ts.combinePaths(commonSourceDirGuess, pathFragment);
+                                var jsAndDtsExtensions = [".mjs", ".cjs", ".js", ".json", ".d.mts", ".d.cts", ".d.ts"];
+                                for (var _f = 0, jsAndDtsExtensions_1 = jsAndDtsExtensions; _f < jsAndDtsExtensions_1.length; _f++) {
+                                    var ext = jsAndDtsExtensions_1[_f];
+                                    if (ts.fileExtensionIs(possibleInputBase, ext)) {
+                                        var inputExts = ts.getPossibleOriginalInputExtensionForExtension(possibleInputBase);
+                                        for (var _g = 0, inputExts_1 = inputExts; _g < inputExts_1.length; _g++) {
+                                            var possibleExt = inputExts_1[_g];
+                                            var possibleInputWithInputExtension = ts.changeAnyExtension(possibleInputBase, possibleExt, ext, !useCaseSensitiveFileNames());
+                                            if ((extensions === Extensions.TypeScript && ts.hasJSFileExtension(possibleInputWithInputExtension)) ||
+                                                (extensions === Extensions.JavaScript && ts.hasTSFileExtension(possibleInputWithInputExtension))) {
+                                                continue;
+                                            }
+                                            if (state.host.fileExists(possibleInputWithInputExtension)) {
+                                                return toSearchResult(withPackageId(scope, loadJSOrExactTSFileName(extensions, possibleInputWithInputExtension, false, state)));
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                return undefined;
+                function getOutputDirectoriesForBaseDirectory(commonSourceDirGuess) {
+                    var _a, _b;
+                    var currentDir = state.compilerOptions.configFile ? ((_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a)) || "" : commonSourceDirGuess;
+                    var candidateDirectories = [];
+                    if (state.compilerOptions.declarationDir) {
+                        candidateDirectories.push(toAbsolutePath(combineDirectoryPath(currentDir, state.compilerOptions.declarationDir)));
+                    }
+                    if (state.compilerOptions.outDir && state.compilerOptions.outDir !== state.compilerOptions.declarationDir) {
+                        candidateDirectories.push(toAbsolutePath(combineDirectoryPath(currentDir, state.compilerOptions.outDir)));
+                    }
+                    return candidateDirectories;
+                }
+            }
         }
     }
     function isApplicableVersionedTypesKey(conditions, key) {
@@ -36145,10 +36171,11 @@ var ts;
     function classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference) {
         var traceEnabled = isTraceEnabled(compilerOptions, host);
         var failedLookupLocations = [];
-        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: NodeResolutionFeatures.None, conditions: [] };
         var containingDirectory = ts.getDirectoryPath(containingFile);
+        var diagnostics = [];
+        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: NodeResolutionFeatures.None, conditions: [], requestContainingDirectory: containingDirectory, reportDiagnostic: function (diag) { return void diagnostics.push(diag); } };
         var resolved = tryResolve(Extensions.TypeScript) || tryResolve(Extensions.JavaScript);
-        return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, false, failedLookupLocations, state.resultFromCache);
+        return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, false, failedLookupLocations, diagnostics, state.resultFromCache);
         function tryResolve(extensions) {
             var resolvedUsingSettings = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loadModuleFromFileNoPackageId, state);
             if (resolvedUsingSettings) {
@@ -36184,9 +36211,10 @@ var ts;
             trace(host, ts.Diagnostics.Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2, projectName, moduleName, globalCache);
         }
         var failedLookupLocations = [];
-        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: packageJsonInfoCache, features: NodeResolutionFeatures.None, conditions: [] };
+        var diagnostics = [];
+        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: packageJsonInfoCache, features: NodeResolutionFeatures.None, conditions: [], requestContainingDirectory: undefined, reportDiagnostic: function (diag) { return void diagnostics.push(diag); } };
         var resolved = loadModuleFromImmediateNodeModulesDirectory(Extensions.DtsOnly, moduleName, globalCache, state, false, undefined, undefined);
-        return createResolvedModuleWithFailedLookupLocations(resolved, true, failedLookupLocations, state.resultFromCache);
+        return createResolvedModuleWithFailedLookupLocations(resolved, true, failedLookupLocations, diagnostics, state.resultFromCache);
     }
     ts.loadModuleFromGlobalCache = loadModuleFromGlobalCache;
     function toSearchResult(value) {
@@ -41797,16 +41825,13 @@ var ts;
                     if (resolvedModule.isExternalLibraryImport && !ts.resolutionExtensionIsTSOrJson(resolvedModule.extension)) {
                         errorOnImplicitAnyModule(false, errorNode, resolvedModule, moduleReference);
                     }
-                    if (ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Node12 || ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeNext) {
+                    if (ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Node16 || ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeNext) {
                         var isSyncImport = (currentSourceFile.impliedNodeFormat === ts.ModuleKind.CommonJS && !ts.findAncestor(location, ts.isImportCall)) || !!ts.findAncestor(location, ts.isImportEqualsDeclaration);
                         var overrideClauseHost = ts.findAncestor(location, function (l) { return ts.isImportTypeNode(l) || ts.isExportDeclaration(l) || ts.isImportDeclaration(l); });
                         var overrideClause = overrideClauseHost && ts.isImportTypeNode(overrideClauseHost) ? (_g = overrideClauseHost.assertions) === null || _g === void 0 ? void 0 : _g.assertClause : overrideClauseHost === null || overrideClauseHost === void 0 ? void 0 : overrideClauseHost.assertClause;
                         if (isSyncImport && sourceFile.impliedNodeFormat === ts.ModuleKind.ESNext && !ts.getResolutionModeOverrideForClause(overrideClause)) {
                             error(errorNode, ts.Diagnostics.Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_synchronously_Use_dynamic_import_instead, moduleReference);
                         }
-                        if (mode === ts.ModuleKind.ESNext && compilerOptions.resolveJsonModule && resolvedModule.extension === ".json") {
-                            error(errorNode, ts.Diagnostics.JSON_imports_are_experimental_in_ES_module_mode_imports);
-                        }
                     }
                     return getMergedSymbol(sourceFile.symbol);
                 }
@@ -41850,7 +41875,7 @@ var ts;
                     var tsExtension = ts.tryExtractTSExtension(moduleReference);
                     var isExtensionlessRelativePathImport = ts.pathIsRelative(moduleReference) && !ts.hasExtension(moduleReference);
                     var moduleResolutionKind = ts.getEmitModuleResolutionKind(compilerOptions);
-                    var resolutionIsNode12OrNext = moduleResolutionKind === ts.ModuleResolutionKind.Node12 ||
+                    var resolutionIsNode16OrNext = moduleResolutionKind === ts.ModuleResolutionKind.Node16 ||
                         moduleResolutionKind === ts.ModuleResolutionKind.NodeNext;
                     if (tsExtension) {
                         var diag = ts.Diagnostics.An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead;
@@ -41867,17 +41892,17 @@ var ts;
                         ts.hasJsonModuleEmitEnabled(compilerOptions)) {
                         error(errorNode, ts.Diagnostics.Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension, moduleReference);
                     }
-                    else if (mode === ts.ModuleKind.ESNext && resolutionIsNode12OrNext && isExtensionlessRelativePathImport) {
+                    else if (mode === ts.ModuleKind.ESNext && resolutionIsNode16OrNext && isExtensionlessRelativePathImport) {
                         var absoluteRef_1 = ts.getNormalizedAbsolutePath(moduleReference, ts.getDirectoryPath(currentSourceFile.path));
                         var suggestedExt = (_h = suggestedExtensions.find(function (_a) {
                             var actualExt = _a[0], _importExt = _a[1];
                             return host.fileExists(absoluteRef_1 + actualExt);
                         })) === null || _h === void 0 ? void 0 : _h[1];
                         if (suggestedExt) {
-                            error(errorNode, ts.Diagnostics.Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Did_you_mean_0, moduleReference + suggestedExt);
+                            error(errorNode, ts.Diagnostics.Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node16_or_nodenext_Did_you_mean_0, moduleReference + suggestedExt);
                         }
                         else {
-                            error(errorNode, ts.Diagnostics.Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Consider_adding_an_extension_to_the_import_path);
+                            error(errorNode, ts.Diagnostics.Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node16_or_nodenext_Consider_adding_an_extension_to_the_import_path);
                         }
                     }
                     else {
@@ -43974,7 +43999,7 @@ var ts;
                     var targetFile = ts.getSourceFileOfModule(chain[0]);
                     var specifier = void 0;
                     var assertion = void 0;
-                    if (ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Node12 || ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeNext) {
+                    if (ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Node16 || ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeNext) {
                         if ((targetFile === null || targetFile === void 0 ? void 0 : targetFile.impliedNodeFormat) === ts.ModuleKind.ESNext && targetFile.impliedNodeFormat !== (contextFile === null || contextFile === void 0 ? void 0 : contextFile.impliedNodeFormat)) {
                             specifier = getSpecifierForModuleSymbol(chain[0], context, ts.ModuleKind.ESNext);
                             assertion = ts.factory.createImportTypeAssertionContainer(ts.factory.createAssertClause(ts.factory.createNodeArray([
@@ -43987,7 +44012,7 @@ var ts;
                     }
                     if (!(context.flags & 67108864) && ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Classic && specifier.indexOf("/node_modules/") >= 0) {
                         var oldSpecifier = specifier;
-                        if (ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Node12 || ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeNext) {
+                        if (ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Node16 || ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeNext) {
                             var swappedMode = (contextFile === null || contextFile === void 0 ? void 0 : contextFile.impliedNodeFormat) === ts.ModuleKind.ESNext ? ts.ModuleKind.CommonJS : ts.ModuleKind.ESNext;
                             specifier = getSpecifierForModuleSymbol(chain[0], context, swappedMode);
                             if (specifier.indexOf("/node_modules/") >= 0) {
@@ -48031,7 +48056,8 @@ var ts;
                 if (symbol === globalThisSymbol) {
                     var varsOnly_1 = new ts.Map();
                     members.forEach(function (p) {
-                        if (!(p.flags & 418)) {
+                        var _a;
+                        if (!(p.flags & 418) && !(p.flags & 512 && ((_a = p.declarations) === null || _a === void 0 ? void 0 : _a.length) && ts.every(p.declarations, ts.isAmbientModule))) {
                             varsOnly_1.set(p.escapedName, p);
                         }
                     });
@@ -53965,7 +53991,6 @@ var ts;
                 return 0;
             }
             function reportErrorResults(originalSource, originalTarget, source, target, headMessage) {
-                var _a, _b;
                 var sourceHasBase = !!getSingleBaseForNonAugmentingSubtype(originalSource);
                 var targetHasBase = !!getSingleBaseForNonAugmentingSubtype(originalTarget);
                 source = (originalSource.aliasSymbol || sourceHasBase) ? originalSource : source;
@@ -54004,9 +54029,6 @@ var ts;
                     return;
                 }
                 reportRelationError(headMessage, source, target);
-                if (strictNullChecks && source.flags & 8650752 && ((_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))) {
-                    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) {
@@ -54636,17 +54658,17 @@ var ts;
                 if (sourceFlags & 8650752) {
                     if (!(sourceFlags & 8388608 && targetFlags & 8388608)) {
                         var constraint = getConstraintOfType(source);
-                        if (!strictNullChecks && (!constraint || (sourceFlags & 262144 && constraint.flags & 1))) {
+                        if (!constraint || (sourceFlags & 262144 && constraint.flags & 1)) {
                             if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864), 3)) {
                                 resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
-                        else if (constraint && (result = isRelatedTo(constraint, target, 1, false, undefined, intersectionState))) {
+                        else if (result = isRelatedTo(constraint, target, 1, false, undefined, intersectionState)) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
-                        else if (constraint && (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1, reportErrors && !(targetFlags & sourceFlags & 262144), undefined, intersectionState))) {
+                        else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1, reportErrors && !(targetFlags & sourceFlags & 262144), undefined, intersectionState)) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
@@ -59541,7 +59563,7 @@ var ts;
                 if (ts.isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {
                     var parent = declaration.parent.parent;
                     if (parent.kind === 254 && ts.getCombinedNodeFlags(declaration) & 2 || parent.kind === 164) {
-                        var links = getNodeLinks(location);
+                        var links = getNodeLinks(parent);
                         if (!(links.flags & 268435456)) {
                             links.flags |= 268435456;
                             var parentType = getTypeForBindingElementParent(parent, 0);
@@ -64510,13 +64532,13 @@ var ts;
             }
         }
         function checkImportMetaProperty(node) {
-            if (moduleKind === ts.ModuleKind.Node12 || moduleKind === ts.ModuleKind.NodeNext) {
+            if (moduleKind === ts.ModuleKind.Node16 || moduleKind === ts.ModuleKind.NodeNext) {
                 if (ts.getSourceFileOfNode(node).impliedNodeFormat !== ts.ModuleKind.ESNext) {
                     error(node, ts.Diagnostics.The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output);
                 }
             }
             else if (moduleKind < ts.ModuleKind.ES2020 && moduleKind !== ts.ModuleKind.System) {
-                error(node, ts.Diagnostics.The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node12_or_nodenext);
+                error(node, ts.Diagnostics.The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node16_or_nodenext);
             }
             var file = ts.getSourceFileOfNode(node);
             ts.Debug.assert(!!(file.flags & 4194304), "Containing file is missing import meta node flag.");
@@ -65348,15 +65370,28 @@ var ts;
                     if (!hasParseDiagnostics(sourceFile)) {
                         var span = void 0;
                         if (!ts.isEffectiveExternalModule(sourceFile, compilerOptions)) {
-                            if (!span)
-                                span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
+                            span !== null && span !== void 0 ? span : (span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos));
                             var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module);
                             diagnostics.add(diagnostic);
                         }
-                        if ((moduleKind !== ts.ModuleKind.ES2022 && moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System && !(moduleKind === ts.ModuleKind.NodeNext && ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.ESNext)) || languageVersion < 4) {
-                            span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
-                            var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher);
-                            diagnostics.add(diagnostic);
+                        switch (moduleKind) {
+                            case ts.ModuleKind.Node16:
+                            case ts.ModuleKind.NodeNext:
+                                if (sourceFile.impliedNodeFormat === ts.ModuleKind.CommonJS) {
+                                    span !== null && span !== void 0 ? span : (span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos));
+                                    diagnostics.add(ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level));
+                                    break;
+                                }
+                            case ts.ModuleKind.ES2022:
+                            case ts.ModuleKind.ESNext:
+                            case ts.ModuleKind.System:
+                                if (languageVersion >= 4) {
+                                    break;
+                                }
+                            default:
+                                span !== null && span !== void 0 ? span : (span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos));
+                                diagnostics.add(ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher));
+                                break;
                         }
                     }
                 }
@@ -67557,8 +67592,8 @@ var ts;
             if (node.assertions) {
                 var override = ts.getResolutionModeOverrideForClause(node.assertions.assertClause, grammarErrorOnNode);
                 if (override) {
-                    if (ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Node12 && ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeNext) {
-                        grammarErrorOnNode(node.assertions.assertClause, ts.Diagnostics.Resolution_modes_are_only_supported_when_moduleResolution_is_node12_or_nodenext);
+                    if (ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Node16 && ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeNext) {
+                        grammarErrorOnNode(node.assertions.assertClause, ts.Diagnostics.Resolution_modes_are_only_supported_when_moduleResolution_is_node16_or_nodenext);
                     }
                 }
             }
@@ -68727,7 +68762,7 @@ var ts;
             });
         }
         function checkCollisionWithRequireExportsInGeneratedCode(node, name) {
-            if (moduleKind >= ts.ModuleKind.ES2015 && !(moduleKind >= ts.ModuleKind.Node12 && ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.CommonJS)) {
+            if (moduleKind >= ts.ModuleKind.ES2015 && !(moduleKind >= ts.ModuleKind.Node16 && ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.CommonJS)) {
                 return;
             }
             if (!name || !needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) {
@@ -69331,7 +69366,7 @@ var ts;
                 }
                 var yieldType = getIterationTypeOfIterable(use, 0, inputType, undefined);
                 if (yieldType) {
-                    return [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators, false];
+                    return [ts.Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher, false];
                 }
                 if (isES2015OrLaterIterable((_a = inputType.symbol) === null || _a === void 0 ? void 0 : _a.escapedName)) {
                     return [ts.Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher, true];
@@ -71177,8 +71212,8 @@ var ts;
                 var validForTypeAssertions = ts.isExclusivelyTypeOnlyImportOrExport(declaration);
                 var override = ts.getResolutionModeOverrideForClause(declaration.assertClause, validForTypeAssertions ? grammarErrorOnNode : undefined);
                 if (validForTypeAssertions && override) {
-                    if (ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Node12 && ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeNext) {
-                        return grammarErrorOnNode(declaration.assertClause, ts.Diagnostics.Resolution_modes_are_only_supported_when_moduleResolution_is_node12_or_nodenext);
+                    if (ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Node16 && ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeNext) {
+                        return grammarErrorOnNode(declaration.assertClause, ts.Diagnostics.Resolution_modes_are_only_supported_when_moduleResolution_is_node16_or_nodenext);
                     }
                     return;
                 }
@@ -72161,7 +72196,7 @@ var ts;
                         var symbol = getIntrinsicTagSymbol(name.parent);
                         return symbol === unknownSymbol ? undefined : symbol;
                     }
-                    var result = resolveEntityName(name, meaning, false, !isJSDoc_1, ts.getHostSignatureFromJSDoc(name));
+                    var result = resolveEntityName(name, meaning, false, true, ts.getHostSignatureFromJSDoc(name));
                     if (!result && isJSDoc_1) {
                         var container = ts.findAncestor(name, ts.or(ts.isClassLike, ts.isInterfaceDeclaration));
                         if (container) {
@@ -72383,7 +72418,7 @@ var ts;
             }
             if (ts.isDeclaration(node)) {
                 var symbol = getSymbolOfNode(node);
-                return getTypeOfSymbol(symbol);
+                return symbol ? getTypeOfSymbol(symbol) : errorType;
             }
             if (isDeclarationNameOrImportPropertyName(node)) {
                 var symbol = getSymbolAtLocation(node);
@@ -73843,6 +73878,9 @@ var ts;
             return ts.some(types, checkGrammarExpressionWithTypeArguments);
         }
         function checkGrammarExpressionWithTypeArguments(node) {
+            if (ts.isExpressionWithTypeArguments(node) && ts.isImportKeyword(node.expression) && node.typeArguments) {
+                return grammarErrorOnNode(node, ts.Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments);
+            }
             return checkGrammarTypeArguments(node, node.typeArguments);
         }
         function checkGrammarClassDeclarationHeritageClauses(node) {
@@ -74067,8 +74105,22 @@ var ts;
                             if (!ts.isEffectiveExternalModule(sourceFile, compilerOptions)) {
                                 diagnostics.add(ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module));
                             }
-                            if ((moduleKind !== ts.ModuleKind.ES2022 && moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System && !(moduleKind === ts.ModuleKind.NodeNext && ts.getSourceFileOfNode(forInOrOfStatement).impliedNodeFormat === ts.ModuleKind.ESNext)) || languageVersion < 4) {
-                                diagnostics.add(ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher));
+                            switch (moduleKind) {
+                                case ts.ModuleKind.Node16:
+                                case ts.ModuleKind.NodeNext:
+                                    if (sourceFile.impliedNodeFormat === ts.ModuleKind.CommonJS) {
+                                        diagnostics.add(ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level));
+                                        break;
+                                    }
+                                case ts.ModuleKind.ES2022:
+                                case ts.ModuleKind.ESNext:
+                                case ts.ModuleKind.System:
+                                    if (languageVersion >= 4) {
+                                        break;
+                                    }
+                                default:
+                                    diagnostics.add(ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher));
+                                    break;
                             }
                         }
                     }
@@ -74700,17 +74752,17 @@ var ts;
         }
         function checkGrammarImportCallExpression(node) {
             if (moduleKind === ts.ModuleKind.ES2015) {
-                return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node12_or_nodenext);
+                return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node16_or_nodenext);
             }
             if (node.typeArguments) {
-                return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_import_cannot_have_type_arguments);
+                return grammarErrorOnNode(node, ts.Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments);
             }
             var nodeArguments = node.arguments;
             if (moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.NodeNext) {
                 checkGrammarForDisallowedTrailingComma(nodeArguments);
                 if (nodeArguments.length > 1) {
                     var assertionArgument = nodeArguments[1];
-                    return grammarErrorOnNode(assertionArgument, ts.Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext);
+                    return grammarErrorOnNode(assertionArgument, ts.Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_or_nodenext);
                 }
             }
             if (nodeArguments.length === 0 || nodeArguments.length > 2) {
@@ -89057,6 +89109,8 @@ var ts;
                         var varDecl = factory.createVariableDeclaration(newId, undefined, resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, symbolTracker), undefined);
                         errorFallbackNode = undefined;
                         var statement = factory.createVariableStatement(needsDeclare ? [factory.createModifier(135)] : [], factory.createVariableDeclarationList([varDecl], 2));
+                        preserveJsDoc(statement, input);
+                        ts.removeAllComments(input);
                         return [statement, factory.updateExportAssignment(input, input.decorators, input.modifiers, newId)];
                     }
                 }
@@ -89482,7 +89536,7 @@ var ts;
                 return ts.transformECMAScriptModule;
             case ts.ModuleKind.System:
                 return ts.transformSystemModule;
-            case ts.ModuleKind.Node12:
+            case ts.ModuleKind.Node16:
             case ts.ModuleKind.NodeNext:
                 return ts.transformNodeModule;
             default:
@@ -90211,8 +90265,7 @@ var ts;
                 return;
             }
             var version = ts.version;
-            var buildInfo = { bundle: bundle, program: program, version: version };
-            ts.writeFile(host, emitterDiagnostics, buildInfoPath, getBuildInfoText(buildInfo), false, undefined, { buildInfo: buildInfo });
+            ts.writeFile(host, emitterDiagnostics, buildInfoPath, getBuildInfoText({ bundle: bundle, program: program, version: version }), false);
         }
         function emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo) {
             if (!sourceFileOrBundle || emitOnlyDtsFiles || !jsFilePath) {
@@ -90353,17 +90406,12 @@ var ts;
                 if (sourceMapFilePath) {
                     var sourceMap = sourceMapGenerator.toString();
                     ts.writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap, false, sourceFiles);
-                    if (printer.bundleFileInfo)
-                        printer.bundleFileInfo.mapHash = ts.BuilderState.computeSignature(sourceMap, ts.maybeBind(host, host.createHash));
                 }
             }
             else {
                 writer.writeLine();
             }
-            var text = writer.getText();
-            ts.writeFile(host, emitterDiagnostics, jsFilePath, text, !!compilerOptions.emitBOM, sourceFiles, { sourceMapUrlPos: sourceMapUrlPos });
-            if (printer.bundleFileInfo)
-                printer.bundleFileInfo.hash = ts.BuilderState.computeSignature(text, ts.maybeBind(host, host.createHash));
+            ts.writeFile(host, emitterDiagnostics, jsFilePath, writer.getText(), !!compilerOptions.emitBOM, sourceFiles, { sourceMapUrlPos: sourceMapUrlPos });
             writer.clear();
         }
         function shouldEmitSourceMaps(mapOptions, sourceFileOrBundle) {
@@ -90488,50 +90536,30 @@ var ts;
         });
     }
     function emitUsingBuildInfo(config, host, getCommandLine, customTransformers) {
-        var createHash = ts.maybeBind(host, host.createHash);
         var _a = getOutputPathsForBundle(config.options, false), buildInfoPath = _a.buildInfoPath, jsFilePath = _a.jsFilePath, sourceMapFilePath = _a.sourceMapFilePath, declarationFilePath = _a.declarationFilePath, declarationMapPath = _a.declarationMapPath;
-        var buildInfo;
-        if (host.getBuildInfo) {
-            var hostBuildInfo = host.getBuildInfo(buildInfoPath, config.options.configFilePath);
-            if (!hostBuildInfo)
-                return buildInfoPath;
-            buildInfo = hostBuildInfo;
-        }
-        else {
-            var buildInfoText = host.readFile(buildInfoPath);
-            if (!buildInfoText)
-                return buildInfoPath;
-            buildInfo = getBuildInfo(buildInfoText);
-        }
-        if (!buildInfo.bundle || !buildInfo.bundle.js || (declarationFilePath && !buildInfo.bundle.dts))
+        var buildInfoText = host.readFile(ts.Debug.checkDefined(buildInfoPath));
+        if (!buildInfoText)
             return buildInfoPath;
         var jsFileText = host.readFile(ts.Debug.checkDefined(jsFilePath));
         if (!jsFileText)
             return jsFilePath;
-        if (ts.BuilderState.computeSignature(jsFileText, createHash) !== buildInfo.bundle.js.hash)
-            return jsFilePath;
         var sourceMapText = sourceMapFilePath && host.readFile(sourceMapFilePath);
         if ((sourceMapFilePath && !sourceMapText) || config.options.inlineSourceMap)
             return sourceMapFilePath || "inline sourcemap decoding";
-        if (sourceMapFilePath && ts.BuilderState.computeSignature(sourceMapText, createHash) !== buildInfo.bundle.js.mapHash)
-            return sourceMapFilePath;
         var declarationText = declarationFilePath && host.readFile(declarationFilePath);
         if (declarationFilePath && !declarationText)
             return declarationFilePath;
-        if (declarationFilePath && ts.BuilderState.computeSignature(declarationText, createHash) !== buildInfo.bundle.dts.hash)
-            return declarationFilePath;
         var declarationMapText = declarationMapPath && host.readFile(declarationMapPath);
         if ((declarationMapPath && !declarationMapText) || config.options.inlineSourceMap)
             return declarationMapPath || "inline sourcemap decoding";
-        if (declarationMapPath && ts.BuilderState.computeSignature(declarationMapText, createHash) !== buildInfo.bundle.dts.mapHash)
-            return declarationMapPath;
+        var buildInfo = getBuildInfo(buildInfoText);
+        if (!buildInfo.bundle || !buildInfo.bundle.js || (declarationText && !buildInfo.bundle.dts))
+            return buildInfoPath;
         var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
         var ownPrependInput = ts.createInputFiles(jsFileText, declarationText, sourceMapFilePath, sourceMapText, declarationMapPath, declarationMapText, jsFilePath, declarationFilePath, buildInfoPath, buildInfo, true);
         var outputFiles = [];
         var prependNodes = ts.createPrependNodes(config.projectReferences, getCommandLine, function (f) { return host.readFile(f); });
         var sourceFilesForJsEmit = createSourceFilesFromBundleBuildInfo(buildInfo.bundle, buildInfoDirectory, host);
-        var changedDtsText;
-        var changedDtsData;
         var emitHost = {
             getPrependNodes: ts.memoize(function () { return __spreadArray(__spreadArray([], prependNodes, true), [ownPrependInput], false); }),
             getCanonicalFileName: host.getCanonicalFileName,
@@ -90547,7 +90575,7 @@ var ts;
             getResolvedProjectReferenceToRedirect: ts.returnUndefined,
             getProjectReferenceRedirect: ts.returnUndefined,
             isSourceOfProjectReferenceRedirect: ts.returnFalse,
-            writeFile: function (name, text, writeByteOrderMark, _onError, _sourceFiles, data) {
+            writeFile: function (name, text, writeByteOrderMark) {
                 switch (name) {
                     case jsFilePath:
                         if (jsFileText === text)
@@ -90558,25 +90586,19 @@ var ts;
                             return;
                         break;
                     case buildInfoPath:
-                        var newBuildInfo = data.buildInfo;
+                        var newBuildInfo = getBuildInfo(text);
                         newBuildInfo.program = buildInfo.program;
-                        if (newBuildInfo.program && changedDtsText !== undefined && config.options.composite) {
-                            newBuildInfo.program.outSignature = ts.computeSignature(changedDtsText, changedDtsData, createHash);
-                            newBuildInfo.program.dtsChangeTime = ts.getCurrentTime(host).getTime();
-                        }
                         var _a = buildInfo.bundle, js = _a.js, dts = _a.dts, sourceFiles = _a.sourceFiles;
                         newBuildInfo.bundle.js.sources = js.sources;
                         if (dts) {
                             newBuildInfo.bundle.dts.sources = dts.sources;
                         }
                         newBuildInfo.bundle.sourceFiles = sourceFiles;
-                        outputFiles.push({ name: name, text: getBuildInfoText(newBuildInfo), writeByteOrderMark: writeByteOrderMark, buildInfo: newBuildInfo });
+                        outputFiles.push({ name: name, text: getBuildInfoText(newBuildInfo), writeByteOrderMark: writeByteOrderMark });
                         return;
                     case declarationFilePath:
                         if (declarationText === text)
                             return;
-                        changedDtsText = text;
-                        changedDtsData = data;
                         break;
                     case declarationMapPath:
                         if (declarationMapText === text)
@@ -90595,7 +90617,6 @@ var ts;
             getSourceFileFromReference: ts.returnUndefined,
             redirectTargetsMap: ts.createMultiMap(),
             getFileIncludeReasons: ts.notImplemented,
-            createHash: createHash,
         };
         emitFiles(ts.notImplementedResolver, emitHost, undefined, ts.getTransformers(config.options, customTransformers));
         return outputFiles;
@@ -95220,6 +95241,7 @@ var ts;
         if (system === void 0) { system = ts.sys; }
         var existingDirectories = new ts.Map();
         var getCanonicalFileName = ts.createGetCanonicalFileName(system.useCaseSensitiveFileNames);
+        var computeHash = ts.maybeBind(system, system.createHash) || ts.generateDjb2Hash;
         function getSourceFile(fileName, languageVersionOrOptions, onError) {
             var text;
             try {
@@ -95249,7 +95271,7 @@ var ts;
         function writeFile(fileName, data, writeByteOrderMark, onError) {
             try {
                 ts.performance.mark("beforeIOWrite");
-                ts.writeFileEnsuringDirectories(fileName, data, writeByteOrderMark, function (path, data, writeByteOrderMark) { return system.writeFile(path, data, writeByteOrderMark); }, function (path) { return (compilerHost.createDirectory || system.createDirectory)(path); }, function (path) { return directoryExists(path); });
+                ts.writeFileEnsuringDirectories(fileName, data, writeByteOrderMark, function (path, data, writeByteOrderMark) { return writeFileWorker(path, data, writeByteOrderMark); }, function (path) { return (compilerHost.createDirectory || system.createDirectory)(path); }, function (path) { return directoryExists(path); });
                 ts.performance.mark("afterIOWrite");
                 ts.performance.measure("I/O Write", "beforeIOWrite", "afterIOWrite");
             }
@@ -95259,6 +95281,34 @@ var ts;
                 }
             }
         }
+        var outputFingerprints;
+        function writeFileWorker(fileName, data, writeByteOrderMark) {
+            if (!ts.isWatchSet(options) || !system.getModifiedTime) {
+                system.writeFile(fileName, data, writeByteOrderMark);
+                return;
+            }
+            if (!outputFingerprints) {
+                outputFingerprints = new ts.Map();
+            }
+            var hash = computeHash(data);
+            var mtimeBefore = system.getModifiedTime(fileName);
+            if (mtimeBefore) {
+                var fingerprint = outputFingerprints.get(fileName);
+                if (fingerprint &&
+                    fingerprint.byteOrderMark === writeByteOrderMark &&
+                    fingerprint.hash === hash &&
+                    fingerprint.mtime.getTime() === mtimeBefore.getTime()) {
+                    return;
+                }
+            }
+            system.writeFile(fileName, data, writeByteOrderMark);
+            var mtimeAfter = system.getModifiedTime(fileName) || ts.missingFileModifiedTime;
+            outputFingerprints.set(fileName, {
+                hash: hash,
+                byteOrderMark: writeByteOrderMark,
+                mtime: mtimeAfter
+            });
+        }
         function getDefaultLibLocation() {
             return ts.getDirectoryPath(ts.normalizePath(system.getExecutingFilePath()));
         }
@@ -95809,7 +95859,7 @@ var ts;
     ts.getConfigFileParsingDiagnostics = getConfigFileParsingDiagnostics;
     function getImpliedNodeFormatForFile(fileName, packageJsonInfoCache, host, options) {
         switch (ts.getEmitModuleResolutionKind(options)) {
-            case ts.ModuleResolutionKind.Node12:
+            case ts.ModuleResolutionKind.Node16:
             case ts.ModuleResolutionKind.NodeNext:
                 return ts.fileExtensionIsOneOf(fileName, [".d.mts", ".mts", ".mjs"]) ? ts.ModuleKind.ESNext :
                     ts.fileExtensionIsOneOf(fileName, [".d.cts", ".cts", ".cjs"]) ? ts.ModuleKind.CommonJS :
@@ -95860,7 +95910,6 @@ var ts;
         ts.Diagnostics.A_rest_parameter_cannot_have_an_initializer.code,
         ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list.code,
         ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma.code,
-        ts.Diagnostics.A_return_statement_can_only_be_used_within_a_function_body.code,
         ts.Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block.code,
         ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter.code,
         ts.Diagnostics.A_set_accessor_must_have_exactly_one_parameter.code,
@@ -96199,6 +96248,34 @@ var ts;
         ts.performance.measure("Program", "beforeProgram", "afterProgram");
         ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         return program;
+        function addResolutionDiagnostics(list) {
+            if (!list)
+                return;
+            for (var _i = 0, list_3 = list; _i < list_3.length; _i++) {
+                var elem = list_3[_i];
+                programDiagnostics.add(elem);
+            }
+        }
+        function pullDiagnosticsFromCache(names, containingFile) {
+            var _a;
+            if (!moduleResolutionCache)
+                return;
+            var containingFileName = ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
+            var containingFileMode = !ts.isString(containingFile) ? containingFile.impliedNodeFormat : undefined;
+            var containingDir = ts.getDirectoryPath(containingFileName);
+            var redirectedReference = getRedirectReferenceForResolution(containingFile);
+            var i = 0;
+            for (var _i = 0, names_4 = names; _i < names_4.length; _i++) {
+                var n = names_4[_i];
+                var mode = typeof n === "string" ? getModeForResolutionAtIndex(containingFile, i) : getModeForFileReference(n, containingFileMode);
+                var name = typeof n === "string" ? n : n.fileName;
+                i++;
+                if (ts.isExternalModuleNameRelative(name))
+                    continue;
+                var diags = (_a = moduleResolutionCache.getOrCreateCacheForModuleName(name, mode, redirectedReference).get(containingDir)) === null || _a === void 0 ? void 0 : _a.resolutionDiagnostics;
+                addResolutionDiagnostics(diags);
+            }
+        }
         function resolveModuleNamesWorker(moduleNames, containingFile, reusedNames) {
             if (!moduleNames.length)
                 return ts.emptyArray;
@@ -96210,6 +96287,7 @@ var ts;
             ts.performance.mark("afterResolveModule");
             ts.performance.measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
+            pullDiagnosticsFromCache(moduleNames, containingFile);
             return result;
         }
         function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile) {
@@ -96600,7 +96678,6 @@ var ts;
                 getSourceFileFromReference: function (file, ref) { return program.getSourceFileFromReference(file, ref); },
                 redirectTargetsMap: redirectTargetsMap,
                 getFileIncludeReasons: program.getFileIncludeReasons,
-                createHash: ts.maybeBind(host, host.createHash),
             };
         }
         function writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data) {
@@ -97499,8 +97576,8 @@ var ts;
                 var fileName = ts.toFileNameLowerCase(ref.fileName);
                 ts.setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective);
                 var mode = ref.resolutionMode || file.impliedNodeFormat;
-                if (mode && ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.Node12 && ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeNext) {
-                    programDiagnostics.add(ts.createDiagnosticForRange(file, ref, ts.Diagnostics.Resolution_modes_are_only_supported_when_moduleResolution_is_node12_or_nodenext));
+                if (mode && ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.Node16 && ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeNext) {
+                    programDiagnostics.add(ts.createDiagnosticForRange(file, ref, ts.Diagnostics.Resolution_modes_are_only_supported_when_moduleResolution_is_node16_or_nodenext));
                 }
                 processTypeReferenceDirective(fileName, mode, resolvedTypeReferenceDirective, { kind: ts.FileIncludeKind.TypeReferenceDirective, file: file.path, index: index, });
             }
@@ -97833,7 +97910,7 @@ var ts;
             }
             if (options.resolveJsonModule) {
                 if (ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeJs &&
-                    ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.Node12 &&
+                    ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.Node16 &&
                     ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeNext) {
                     createDiagnosticForOptionName(ts.Diagnostics.Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy, "resolveJsonModule");
                 }
@@ -98507,9 +98584,13 @@ var ts;
         function createManyToManyPathMap() {
             function create(forward, reverse, deleted) {
                 var map = {
+                    clone: function () { return create(new ts.Map(forward), new ts.Map(reverse), deleted && new ts.Set(deleted)); },
+                    forEach: function (fn) { return forward.forEach(fn); },
                     getKeys: function (v) { return reverse.get(v); },
                     getValues: function (k) { return forward.get(k); },
+                    hasKey: function (k) { return forward.has(k); },
                     keys: function () { return forward.keys(); },
+                    deletedKeys: function () { return deleted; },
                     deleteKey: function (k) {
                         (deleted || (deleted = new ts.Set())).add(k);
                         var set = forward.get(k);
@@ -98536,6 +98617,11 @@ var ts;
                         });
                         return map;
                     },
+                    clear: function () {
+                        forward.clear();
+                        reverse.clear();
+                        deleted === null || deleted === void 0 ? void 0 : deleted.clear();
+                    }
                 };
                 return map;
             }
@@ -98639,45 +98725,35 @@ var ts;
         }
         BuilderState.canReuseOldState = canReuseOldState;
         function create(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature) {
-            var _a, _b, _c;
             var fileInfos = new ts.Map();
             var referencedMap = newProgram.getCompilerOptions().module !== ts.ModuleKind.None ? createManyToManyPathMap() : undefined;
             var exportedModulesMap = referencedMap ? createManyToManyPathMap() : undefined;
+            var hasCalledUpdateShapeSignature = new ts.Set();
             var useOldState = canReuseOldState(referencedMap, oldState);
             newProgram.getTypeChecker();
-            for (var _i = 0, _d = newProgram.getSourceFiles(); _i < _d.length; _i++) {
-                var sourceFile = _d[_i];
+            for (var _i = 0, _a = newProgram.getSourceFiles(); _i < _a.length; _i++) {
+                var sourceFile = _a[_i];
                 var version_2 = ts.Debug.checkDefined(sourceFile.version, "Program intended to be used with Builder should have source files with versions set");
-                var oldUncommitedSignature = useOldState ? (_a = oldState.oldSignatures) === null || _a === void 0 ? void 0 : _a.get(sourceFile.resolvedPath) : undefined;
-                var signature = oldUncommitedSignature === undefined ?
-                    useOldState ? (_b = oldState.fileInfos.get(sourceFile.resolvedPath)) === null || _b === void 0 ? void 0 : _b.signature : undefined :
-                    oldUncommitedSignature || undefined;
+                var oldInfo = useOldState ? oldState.fileInfos.get(sourceFile.resolvedPath) : undefined;
                 if (referencedMap) {
                     var newReferences = getReferencedFiles(newProgram, sourceFile, getCanonicalFileName);
                     if (newReferences) {
                         referencedMap.set(sourceFile.resolvedPath, newReferences);
                     }
                     if (useOldState) {
-                        var oldUncommitedExportedModules = (_c = oldState.oldExportedModulesMap) === null || _c === void 0 ? void 0 : _c.get(sourceFile.resolvedPath);
-                        var exportedModules = oldUncommitedExportedModules === undefined ?
-                            oldState.exportedModulesMap.getValues(sourceFile.resolvedPath) :
-                            oldUncommitedExportedModules || undefined;
+                        var exportedModules = oldState.exportedModulesMap.getValues(sourceFile.resolvedPath);
                         if (exportedModules) {
                             exportedModulesMap.set(sourceFile.resolvedPath, exportedModules);
                         }
                     }
                 }
-                fileInfos.set(sourceFile.resolvedPath, {
-                    version: version_2,
-                    signature: signature,
-                    affectsGlobalScope: isFileAffectingGlobalScope(sourceFile) || undefined,
-                    impliedFormat: sourceFile.impliedNodeFormat
-                });
+                fileInfos.set(sourceFile.resolvedPath, { version: version_2, signature: oldInfo && oldInfo.signature, affectsGlobalScope: isFileAffectingGlobalScope(sourceFile) || undefined, impliedFormat: sourceFile.impliedNodeFormat });
             }
             return {
                 fileInfos: fileInfos,
                 referencedMap: referencedMap,
                 exportedModulesMap: exportedModulesMap,
+                hasCalledUpdateShapeSignature: hasCalledUpdateShapeSignature,
                 useFileVersionAsSignature: !disableUseFileVersionAsSignature && !useOldState
             };
         }
@@ -98687,36 +98763,52 @@ var ts;
             state.allFileNames = undefined;
         }
         BuilderState.releaseCache = releaseCache;
-        function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, computeHash) {
+        function clone(state) {
             var _a, _b;
-            var result = getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, computeHash);
-            (_a = state.oldSignatures) === null || _a === void 0 ? void 0 : _a.clear();
-            (_b = state.oldExportedModulesMap) === null || _b === void 0 ? void 0 : _b.clear();
-            return result;
+            return {
+                fileInfos: new ts.Map(state.fileInfos),
+                referencedMap: (_a = state.referencedMap) === null || _a === void 0 ? void 0 : _a.clone(),
+                exportedModulesMap: (_b = state.exportedModulesMap) === null || _b === void 0 ? void 0 : _b.clone(),
+                hasCalledUpdateShapeSignature: new ts.Set(state.hasCalledUpdateShapeSignature),
+                useFileVersionAsSignature: state.useFileVersionAsSignature,
+            };
         }
-        BuilderState.getFilesAffectedBy = getFilesAffectedBy;
-        function getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, computeHash) {
+        BuilderState.clone = clone;
+        function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, computeHash, cacheToUpdateSignature, exportedModulesMapCache) {
+            var signatureCache = cacheToUpdateSignature || new ts.Map();
             var sourceFile = programOfThisState.getSourceFileByPath(path);
             if (!sourceFile) {
                 return ts.emptyArray;
             }
-            if (!updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash)) {
+            if (!updateShapeSignature(state, programOfThisState, sourceFile, signatureCache, cancellationToken, computeHash, exportedModulesMapCache)) {
                 return [sourceFile];
             }
-            return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, computeHash);
+            var result = (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, signatureCache, cancellationToken, computeHash, exportedModulesMapCache);
+            if (!cacheToUpdateSignature) {
+                updateSignaturesFromCache(state, signatureCache);
+            }
+            return result;
+        }
+        BuilderState.getFilesAffectedBy = getFilesAffectedBy;
+        function updateSignaturesFromCache(state, signatureCache) {
+            signatureCache.forEach(function (signature, path) { return updateSignatureOfFile(state, signature, path); });
         }
-        BuilderState.getFilesAffectedByWithOldState = getFilesAffectedByWithOldState;
+        BuilderState.updateSignaturesFromCache = updateSignaturesFromCache;
         function updateSignatureOfFile(state, signature, path) {
             state.fileInfos.get(path).signature = signature;
-            (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = new ts.Set())).add(path);
+            state.hasCalledUpdateShapeSignature.add(path);
         }
         BuilderState.updateSignatureOfFile = updateSignatureOfFile;
-        function updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash, useFileVersionAsSignature) {
-            var _a;
+        function updateShapeSignature(state, programOfThisState, sourceFile, cacheToUpdateSignature, cancellationToken, computeHash, exportedModulesMapCache, useFileVersionAsSignature) {
             if (useFileVersionAsSignature === void 0) { useFileVersionAsSignature = state.useFileVersionAsSignature; }
-            if ((_a = state.hasCalledUpdateShapeSignature) === null || _a === void 0 ? void 0 : _a.has(sourceFile.resolvedPath))
+            ts.Debug.assert(!!sourceFile);
+            ts.Debug.assert(!exportedModulesMapCache || !!state.exportedModulesMap, "Compute visible to outside map only if visibleToOutsideReferencedMap present in the state");
+            if (state.hasCalledUpdateShapeSignature.has(sourceFile.resolvedPath) || cacheToUpdateSignature.has(sourceFile.resolvedPath)) {
                 return false;
+            }
             var info = state.fileInfos.get(sourceFile.resolvedPath);
+            if (!info)
+                return ts.Debug.fail();
             var prevSignature = info.signature;
             var latestSignature;
             if (!sourceFile.isDeclarationFile && !useFileVersionAsSignature) {
@@ -98724,50 +98816,40 @@ var ts;
                 var firstDts_1 = ts.firstOrUndefined(emitOutput_1.outputFiles);
                 if (firstDts_1) {
                     ts.Debug.assert(ts.isDeclarationFileName(firstDts_1.name), "File extension for signature expected to be dts", function () { return "Found: " + ts.getAnyExtensionFromPath(firstDts_1.name) + " for " + firstDts_1.name + ":: All output files: " + JSON.stringify(emitOutput_1.outputFiles.map(function (f) { return f.name; })); });
-                    latestSignature = computeSignature(firstDts_1.text, computeHash);
-                    if (latestSignature !== prevSignature) {
-                        updateExportedModules(state, sourceFile, emitOutput_1.exportedModulesFromDeclarationEmit);
+                    latestSignature = (computeHash || ts.generateDjb2Hash)(firstDts_1.text);
+                    if (exportedModulesMapCache && latestSignature !== prevSignature) {
+                        updateExportedModules(sourceFile, emitOutput_1.exportedModulesFromDeclarationEmit, exportedModulesMapCache);
                     }
                 }
             }
             if (latestSignature === undefined) {
                 latestSignature = sourceFile.version;
-                if (state.exportedModulesMap && latestSignature !== prevSignature) {
-                    (state.oldExportedModulesMap || (state.oldExportedModulesMap = new ts.Map())).set(sourceFile.resolvedPath, state.exportedModulesMap.getValues(sourceFile.resolvedPath) || false);
+                if (exportedModulesMapCache && latestSignature !== prevSignature) {
                     var references = state.referencedMap ? state.referencedMap.getValues(sourceFile.resolvedPath) : undefined;
                     if (references) {
-                        state.exportedModulesMap.set(sourceFile.resolvedPath, references);
+                        exportedModulesMapCache.set(sourceFile.resolvedPath, references);
                     }
                     else {
-                        state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
+                        exportedModulesMapCache.deleteKey(sourceFile.resolvedPath);
                     }
                 }
             }
-            (state.oldSignatures || (state.oldSignatures = new ts.Map())).set(sourceFile.resolvedPath, prevSignature || false);
-            (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = new ts.Set())).add(sourceFile.resolvedPath);
-            info.signature = latestSignature;
+            cacheToUpdateSignature.set(sourceFile.resolvedPath, latestSignature);
             return latestSignature !== prevSignature;
         }
         BuilderState.updateShapeSignature = updateShapeSignature;
-        function computeSignature(text, computeHash) {
-            return (computeHash || ts.generateDjb2Hash)(text);
-        }
-        BuilderState.computeSignature = computeSignature;
-        function updateExportedModules(state, sourceFile, exportedModulesFromDeclarationEmit) {
-            if (!state.exportedModulesMap)
-                return;
-            (state.oldExportedModulesMap || (state.oldExportedModulesMap = new ts.Map())).set(sourceFile.resolvedPath, state.exportedModulesMap.getValues(sourceFile.resolvedPath) || false);
+        function updateExportedModules(sourceFile, exportedModulesFromDeclarationEmit, exportedModulesMapCache) {
             if (!exportedModulesFromDeclarationEmit) {
-                state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
+                exportedModulesMapCache.deleteKey(sourceFile.resolvedPath);
                 return;
             }
             var exportedModules;
             exportedModulesFromDeclarationEmit.forEach(function (symbol) { return addExportedModule(getReferencedFilesFromImportedModuleSymbol(symbol)); });
             if (exportedModules) {
-                state.exportedModulesMap.set(sourceFile.resolvedPath, exportedModules);
+                exportedModulesMapCache.set(sourceFile.resolvedPath, exportedModules);
             }
             else {
-                state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
+                exportedModulesMapCache.deleteKey(sourceFile.resolvedPath);
             }
             function addExportedModule(exportedModulePaths) {
                 if (exportedModulePaths === null || exportedModulePaths === void 0 ? void 0 : exportedModulePaths.length) {
@@ -98779,6 +98861,15 @@ var ts;
             }
         }
         BuilderState.updateExportedModules = updateExportedModules;
+        function updateExportedFilesMapFromCache(state, exportedModulesMapCache) {
+            var _a;
+            if (exportedModulesMapCache) {
+                ts.Debug.assert(!!state.exportedModulesMap);
+                (_a = exportedModulesMapCache.deletedKeys()) === null || _a === void 0 ? void 0 : _a.forEach(function (path) { return state.exportedModulesMap.deleteKey(path); });
+                exportedModulesMapCache.forEach(function (exportedModules, path) { return state.exportedModulesMap.set(path, exportedModules); });
+            }
+        }
+        BuilderState.updateExportedFilesMapFromCache = updateExportedFilesMapFromCache;
         function getAllDependencies(state, programOfThisState, sourceFile) {
             var compilerOptions = programOfThisState.getCompilerOptions();
             if (ts.outFile(compilerOptions)) {
@@ -98862,7 +98953,7 @@ var ts;
             }
             return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
         }
-        function getFilesAffectedByUpdatedShapeWhenModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape, cancellationToken, computeHash) {
+        function getFilesAffectedByUpdatedShapeWhenModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape, cacheToUpdateSignature, cancellationToken, computeHash, exportedModulesMapCache) {
             if (isFileAffectingGlobalScope(sourceFileWithUpdatedShape)) {
                 return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
             }
@@ -98878,7 +98969,7 @@ var ts;
                 if (!seenFileNamesMap.has(currentPath)) {
                     var currentSourceFile = programOfThisState.getSourceFileByPath(currentPath);
                     seenFileNamesMap.set(currentPath, currentSourceFile);
-                    if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cancellationToken, computeHash)) {
+                    if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cacheToUpdateSignature, cancellationToken, computeHash, exportedModulesMapCache)) {
                         queue.push.apply(queue, getReferencedByPaths(state, currentSourceFile.resolvedPath));
                     }
                 }
@@ -98893,31 +98984,29 @@ var ts;
         return map1 === map2 || map1 !== undefined && map2 !== undefined && map1.size === map2.size && !ts.forEachKey(map1, function (key) { return !map2.has(key); });
     }
     function createBuilderProgramState(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature) {
-        var _a, _b;
         var state = ts.BuilderState.create(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature);
         state.program = newProgram;
         var compilerOptions = newProgram.getCompilerOptions();
         state.compilerOptions = compilerOptions;
-        var outFilePath = ts.outFile(compilerOptions);
-        if (!outFilePath) {
+        if (!ts.outFile(compilerOptions)) {
             state.semanticDiagnosticsPerFile = new ts.Map();
         }
-        else if (compilerOptions.composite && (oldState === null || oldState === void 0 ? void 0 : oldState.outSignature) && outFilePath === ts.outFile(oldState === null || oldState === void 0 ? void 0 : oldState.compilerOptions)) {
-            state.outSignature = oldState === null || oldState === void 0 ? void 0 : oldState.outSignature;
-        }
         state.changedFilesSet = new ts.Set();
-        state.dtsChangeTime = compilerOptions.composite ? oldState === null || oldState === void 0 ? void 0 : oldState.dtsChangeTime : undefined;
         var useOldState = ts.BuilderState.canReuseOldState(state.referencedMap, oldState);
         var oldCompilerOptions = useOldState ? oldState.compilerOptions : undefined;
         var canCopySemanticDiagnostics = useOldState && oldState.semanticDiagnosticsPerFile && !!state.semanticDiagnosticsPerFile &&
             !ts.compilerOptionsAffectSemanticDiagnostics(compilerOptions, oldCompilerOptions);
-        var canCopyEmitSignatures = compilerOptions.composite &&
-            (oldState === null || oldState === void 0 ? void 0 : oldState.emitSignatures) &&
-            !outFilePath &&
-            !ts.compilerOptionsAffectDeclarationPath(compilerOptions, oldCompilerOptions);
         if (useOldState) {
-            (_a = oldState.changedFilesSet) === null || _a === void 0 ? void 0 : _a.forEach(function (value) { return state.changedFilesSet.add(value); });
-            if (!outFilePath && oldState.affectedFilesPendingEmit) {
+            if (!oldState.currentChangedFilePath) {
+                var affectedSignatures = oldState.currentAffectedFilesSignatures;
+                ts.Debug.assert(!oldState.affectedFiles && (!affectedSignatures || !affectedSignatures.size), "Cannot reuse if only few affected files of currentChangedFile were iterated");
+            }
+            var changedFilesSet = oldState.changedFilesSet;
+            if (canCopySemanticDiagnostics) {
+                ts.Debug.assert(!changedFilesSet || !ts.forEachKey(changedFilesSet, function (path) { return oldState.semanticDiagnosticsPerFile.has(path); }), "Semantic diagnostics shouldnt be available for changed files");
+            }
+            changedFilesSet === null || changedFilesSet === void 0 ? void 0 : changedFilesSet.forEach(function (value) { return state.changedFilesSet.add(value); });
+            if (!ts.outFile(compilerOptions) && oldState.affectedFilesPendingEmit) {
                 state.affectedFilesPendingEmit = oldState.affectedFilesPendingEmit.slice();
                 state.affectedFilesPendingEmitKind = oldState.affectedFilesPendingEmitKind && new ts.Map(oldState.affectedFilesPendingEmitKind);
                 state.affectedFilesPendingEmitIndex = oldState.affectedFilesPendingEmitIndex;
@@ -98934,7 +99023,6 @@ var ts;
             if (!useOldState ||
                 !(oldInfo = oldState.fileInfos.get(sourceFilePath)) ||
                 oldInfo.version !== info.version ||
-                oldInfo.impliedFormat !== info.impliedFormat ||
                 !hasSameKeys(newReferences = referencedMap && referencedMap.getValues(sourceFilePath), oldReferencedMap && oldReferencedMap.getValues(sourceFilePath)) ||
                 newReferences && ts.forEachKey(newReferences, function (path) { return !state.fileInfos.has(path) && oldState.fileInfos.has(path); })) {
                 state.changedFilesSet.add(sourceFilePath);
@@ -98954,22 +99042,24 @@ var ts;
                     state.semanticDiagnosticsFromOldState.add(sourceFilePath);
                 }
             }
-            if (canCopyEmitSignatures) {
-                var oldEmitSignature = oldState.emitSignatures.get(sourceFilePath);
-                if (oldEmitSignature)
-                    (state.emitSignatures || (state.emitSignatures = new ts.Map())).set(sourceFilePath, oldEmitSignature);
-            }
         });
         if (useOldState && ts.forEachEntry(oldState.fileInfos, function (info, sourceFilePath) { return info.affectsGlobalScope && !state.fileInfos.has(sourceFilePath); })) {
             ts.BuilderState.getAllFilesExcludingDefaultLibraryFile(state, newProgram, undefined)
                 .forEach(function (file) { return state.changedFilesSet.add(file.resolvedPath); });
         }
-        else if (oldCompilerOptions && !outFilePath && ts.compilerOptionsAffectEmit(compilerOptions, oldCompilerOptions)) {
+        else if (oldCompilerOptions && !ts.outFile(compilerOptions) && ts.compilerOptionsAffectEmit(compilerOptions, oldCompilerOptions)) {
             newProgram.getSourceFiles().forEach(function (f) { return addToAffectedFilesPendingEmit(state, f.resolvedPath, 1); });
             ts.Debug.assert(!state.seenAffectedFiles || !state.seenAffectedFiles.size);
             state.seenAffectedFiles = state.seenAffectedFiles || new ts.Set();
         }
-        state.buildInfoEmitPending = !useOldState || state.changedFilesSet.size !== (((_b = oldState.changedFilesSet) === null || _b === void 0 ? void 0 : _b.size) || 0);
+        if (useOldState) {
+            ts.forEachEntry(oldState.fileInfos, function (info, sourceFilePath) {
+                if (state.fileInfos.has(sourceFilePath) && state.fileInfos.get(sourceFilePath).impliedFormat !== info.impliedFormat) {
+                    state.changedFilesSet.add(sourceFilePath);
+                }
+            });
+        }
+        state.buildInfoEmitPending = !!state.changedFilesSet.size;
         return state;
     }
     function convertToDiagnostics(diagnostics, newProgram, getCanonicalFileName) {
@@ -99002,40 +99092,33 @@ var ts;
         ts.BuilderState.releaseCache(state);
         state.program = undefined;
     }
-    function backupEmitBuilderProgramState(state) {
-        var outFilePath = ts.outFile(state.compilerOptions);
-        ts.Debug.assert(!state.changedFilesSet.size || outFilePath);
-        return {
-            affectedFilesPendingEmit: state.affectedFilesPendingEmit && state.affectedFilesPendingEmit.slice(),
-            affectedFilesPendingEmitKind: state.affectedFilesPendingEmitKind && new ts.Map(state.affectedFilesPendingEmitKind),
-            affectedFilesPendingEmitIndex: state.affectedFilesPendingEmitIndex,
-            seenEmittedFiles: state.seenEmittedFiles && new ts.Map(state.seenEmittedFiles),
-            programEmitComplete: state.programEmitComplete,
-            emitSignatures: state.emitSignatures && new ts.Map(state.emitSignatures),
-            outSignature: state.outSignature,
-            dtsChangeTime: state.dtsChangeTime,
-            hasChangedEmitSignature: state.hasChangedEmitSignature,
-            changedFilesSet: outFilePath ? new ts.Set(state.changedFilesSet) : undefined,
-        };
-    }
-    function restoreEmitBuilderProgramState(state, backupEmitState) {
-        state.affectedFilesPendingEmit = backupEmitState.affectedFilesPendingEmit;
-        state.affectedFilesPendingEmitKind = backupEmitState.affectedFilesPendingEmitKind;
-        state.affectedFilesPendingEmitIndex = backupEmitState.affectedFilesPendingEmitIndex;
-        state.seenEmittedFiles = backupEmitState.seenEmittedFiles;
-        state.programEmitComplete = backupEmitState.programEmitComplete;
-        state.emitSignatures = backupEmitState.emitSignatures;
-        state.outSignature = backupEmitState.outSignature;
-        state.dtsChangeTime = backupEmitState.dtsChangeTime;
-        state.hasChangedEmitSignature = backupEmitState.hasChangedEmitSignature;
-        if (backupEmitState.changedFilesSet)
-            state.changedFilesSet = backupEmitState.changedFilesSet;
+    function cloneBuilderProgramState(state) {
+        var _a;
+        var newState = ts.BuilderState.clone(state);
+        newState.semanticDiagnosticsPerFile = state.semanticDiagnosticsPerFile && new ts.Map(state.semanticDiagnosticsPerFile);
+        newState.changedFilesSet = new ts.Set(state.changedFilesSet);
+        newState.affectedFiles = state.affectedFiles;
+        newState.affectedFilesIndex = state.affectedFilesIndex;
+        newState.currentChangedFilePath = state.currentChangedFilePath;
+        newState.currentAffectedFilesSignatures = state.currentAffectedFilesSignatures && new ts.Map(state.currentAffectedFilesSignatures);
+        newState.currentAffectedFilesExportedModulesMap = (_a = state.currentAffectedFilesExportedModulesMap) === null || _a === void 0 ? void 0 : _a.clone();
+        newState.seenAffectedFiles = state.seenAffectedFiles && new ts.Set(state.seenAffectedFiles);
+        newState.cleanedDiagnosticsOfLibFiles = state.cleanedDiagnosticsOfLibFiles;
+        newState.semanticDiagnosticsFromOldState = state.semanticDiagnosticsFromOldState && new ts.Set(state.semanticDiagnosticsFromOldState);
+        newState.program = state.program;
+        newState.compilerOptions = state.compilerOptions;
+        newState.affectedFilesPendingEmit = state.affectedFilesPendingEmit && state.affectedFilesPendingEmit.slice();
+        newState.affectedFilesPendingEmitKind = state.affectedFilesPendingEmitKind && new ts.Map(state.affectedFilesPendingEmitKind);
+        newState.affectedFilesPendingEmitIndex = state.affectedFilesPendingEmitIndex;
+        newState.seenEmittedFiles = state.seenEmittedFiles && new ts.Map(state.seenEmittedFiles);
+        newState.programEmitComplete = state.programEmitComplete;
+        return newState;
     }
     function assertSourceFileOkWithoutNextAffectedCall(state, sourceFile) {
         ts.Debug.assert(!sourceFile || !state.affectedFiles || state.affectedFiles[state.affectedFilesIndex - 1] !== sourceFile || !state.semanticDiagnosticsPerFile.has(sourceFile.resolvedPath));
     }
     function getNextAffectedFile(state, cancellationToken, computeHash, host) {
-        var _a, _b;
+        var _a;
         while (true) {
             var affectedFiles = state.affectedFiles;
             if (affectedFiles) {
@@ -99052,8 +99135,10 @@ var ts;
                 }
                 state.changedFilesSet.delete(state.currentChangedFilePath);
                 state.currentChangedFilePath = undefined;
-                (_a = state.oldSignatures) === null || _a === void 0 ? void 0 : _a.clear();
-                (_b = state.oldExportedModulesMap) === null || _b === void 0 ? void 0 : _b.clear();
+                ts.BuilderState.updateSignaturesFromCache(state, state.currentAffectedFilesSignatures);
+                state.currentAffectedFilesSignatures.clear();
+                ts.BuilderState.updateExportedFilesMapFromCache(state, state.currentAffectedFilesExportedModulesMap);
+                (_a = state.currentAffectedFilesExportedModulesMap) === null || _a === void 0 ? void 0 : _a.clear();
                 state.affectedFiles = undefined;
             }
             var nextKey = state.changedFilesSet.keys().next();
@@ -99066,7 +99151,12 @@ var ts;
                 ts.Debug.assert(!state.semanticDiagnosticsPerFile);
                 return program;
             }
-            state.affectedFiles = ts.BuilderState.getFilesAffectedByWithOldState(state, program, nextKey.value, cancellationToken, computeHash);
+            if (!state.currentAffectedFilesSignatures)
+                state.currentAffectedFilesSignatures = new ts.Map();
+            if (state.exportedModulesMap) {
+                state.currentAffectedFilesExportedModulesMap || (state.currentAffectedFilesExportedModulesMap = ts.BuilderState.createManyToManyPathMap());
+            }
+            state.affectedFiles = ts.BuilderState.getFilesAffectedBy(state, program, nextKey.value, cancellationToken, computeHash, state.currentAffectedFilesSignatures, state.currentAffectedFilesExportedModulesMap);
             state.currentChangedFilePath = nextKey.value;
             state.affectedFilesIndex = 0;
             if (!state.seenAffectedFiles)
@@ -99110,12 +99200,14 @@ var ts;
         }
     }
     function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash, host) {
+        var _a;
         removeSemanticDiagnosticsOf(state, affectedFile.resolvedPath);
         if (state.allFilesExcludingDefaultLibraryFile === state.affectedFiles) {
             removeDiagnosticsOfLibraryFiles(state);
-            ts.BuilderState.updateShapeSignature(state, ts.Debug.checkDefined(state.program), affectedFile, cancellationToken, computeHash);
+            ts.BuilderState.updateShapeSignature(state, ts.Debug.checkDefined(state.program), affectedFile, ts.Debug.checkDefined(state.currentAffectedFilesSignatures), cancellationToken, computeHash, state.currentAffectedFilesExportedModulesMap);
             return;
         }
+        ts.Debug.assert(state.hasCalledUpdateShapeSignature.has(affectedFile.resolvedPath) || ((_a = state.currentAffectedFilesSignatures) === null || _a === void 0 ? void 0 : _a.has(affectedFile.resolvedPath)), "Signature not updated for affected file: " + affectedFile.fileName);
         if (state.compilerOptions.assumeChangesOnlyAffectDirectDependencies)
             return;
         handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, host);
@@ -99126,7 +99218,7 @@ var ts;
             var program = ts.Debug.checkDefined(state.program);
             var sourceFile = program.getSourceFileByPath(path);
             if (sourceFile) {
-                ts.BuilderState.updateShapeSignature(state, program, sourceFile, cancellationToken, computeHash, !host.disableUseFileVersionAsSignature);
+                ts.BuilderState.updateShapeSignature(state, program, sourceFile, ts.Debug.checkDefined(state.currentAffectedFilesSignatures), cancellationToken, computeHash, state.currentAffectedFilesExportedModulesMap, !host.disableUseFileVersionAsSignature);
                 if (ts.getEmitDeclarations(state.compilerOptions)) {
                     addToAffectedFilesPendingEmit(state, path, 0);
                 }
@@ -99142,10 +99234,24 @@ var ts;
         return !state.semanticDiagnosticsFromOldState.size;
     }
     function isChangedSignature(state, path) {
-        var oldSignature = ts.Debug.checkDefined(state.oldSignatures).get(path) || undefined;
-        var newSignature = ts.Debug.checkDefined(state.fileInfos.get(path)).signature;
+        var newSignature = ts.Debug.checkDefined(state.currentAffectedFilesSignatures).get(path);
+        var oldSignature = ts.Debug.checkDefined(state.fileInfos.get(path)).signature;
         return newSignature !== oldSignature;
     }
+    function forEachKeyOfExportedModulesMap(state, filePath, fn) {
+        var keys = state.currentAffectedFilesExportedModulesMap.getKeys(filePath);
+        var result = keys && ts.forEachKey(keys, fn);
+        if (result)
+            return result;
+        keys = state.exportedModulesMap.getKeys(filePath);
+        return keys && ts.forEachKey(keys, function (exportedFromPath) {
+            var _a;
+            return !state.currentAffectedFilesExportedModulesMap.hasKey(exportedFromPath) &&
+                !((_a = state.currentAffectedFilesExportedModulesMap.deletedKeys()) === null || _a === void 0 ? void 0 : _a.has(exportedFromPath)) ?
+                fn(exportedFromPath) :
+                undefined;
+        });
+    }
     function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, host) {
         var _a;
         if (!((_a = state.fileInfos.get(filePath)) === null || _a === void 0 ? void 0 : _a.affectsGlobalScope))
@@ -99156,7 +99262,6 @@ var ts;
         return true;
     }
     function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, host) {
-        var _a;
         if (!state.exportedModulesMap || !state.changedFilesSet.has(affectedFile.resolvedPath))
             return;
         if (!isChangedSignature(state, affectedFile.resolvedPath))
@@ -99179,8 +99284,9 @@ var ts;
                 }
             }
         }
+        ts.Debug.assert(!!state.currentAffectedFilesExportedModulesMap);
         var seenFileAndExportsOfFile = new ts.Set();
-        (_a = state.exportedModulesMap.getKeys(affectedFile.resolvedPath)) === null || _a === void 0 ? void 0 : _a.forEach(function (exportedFromPath) {
+        forEachKeyOfExportedModulesMap(state, affectedFile.resolvedPath, function (exportedFromPath) {
             if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, computeHash, host))
                 return true;
             var references = state.referencedMap.getKeys(exportedFromPath);
@@ -99190,16 +99296,17 @@ var ts;
         });
     }
     function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, computeHash, host) {
-        var _a, _b;
+        var _a;
         if (!ts.tryAddToSet(seenFileAndExportsOfFile, filePath))
             return undefined;
         if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, host))
             return true;
         handleDtsMayChangeOf(state, filePath, cancellationToken, computeHash, host);
-        (_a = state.exportedModulesMap.getKeys(filePath)) === null || _a === void 0 ? void 0 : _a.forEach(function (exportedFromPath) {
+        ts.Debug.assert(!!state.currentAffectedFilesExportedModulesMap);
+        forEachKeyOfExportedModulesMap(state, filePath, function (exportedFromPath) {
             return handleDtsMayChangeOfFileAndExportsOfFile(state, exportedFromPath, seenFileAndExportsOfFile, cancellationToken, computeHash, host);
         });
-        (_b = state.referencedMap.getKeys(filePath)) === null || _b === void 0 ? void 0 : _b.forEach(function (referencingFilePath) {
+        (_a = state.referencedMap.getKeys(filePath)) === null || _a === void 0 ? void 0 : _a.forEach(function (referencingFilePath) {
             return !seenFileAndExportsOfFile.has(referencingFilePath) &&
                 handleDtsMayChangeOf(state, referencingFilePath, cancellationToken, computeHash, host);
         });
@@ -99215,12 +99322,12 @@ var ts;
         }
         else {
             state.seenAffectedFiles.add(affected.resolvedPath);
-            state.buildInfoEmitPending = true;
             if (emitKind !== undefined) {
                 (state.seenEmittedFiles || (state.seenEmittedFiles = new ts.Map())).set(affected.resolvedPath, emitKind);
             }
             if (isPendingEmit) {
                 state.affectedFilesPendingEmitIndex++;
+                state.buildInfoEmitPending = true;
             }
             else {
                 state.affectedFilesIndex++;
@@ -99252,50 +99359,29 @@ var ts;
         }
         return ts.filterSemanticDiagnostics(diagnostics, state.compilerOptions);
     }
-    function getProgramBuildInfo(state, getCanonicalFileName, host) {
-        var outFilePath = ts.outFile(state.compilerOptions);
-        if (outFilePath && !state.compilerOptions.composite)
-            return;
+    function getProgramBuildInfo(state, getCanonicalFileName) {
+        if (ts.outFile(state.compilerOptions))
+            return undefined;
         var currentDirectory = ts.Debug.checkDefined(state.program).getCurrentDirectory();
         var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(ts.getTsBuildInfoEmitOutputFilePath(state.compilerOptions), currentDirectory));
-        state.dtsChangeTime = state.hasChangedEmitSignature ? ts.getCurrentTime(host).getTime() : state.dtsChangeTime;
-        if (outFilePath) {
-            var result_15 = {
-                options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsBundleEmitBuildInfo"),
-                outSignature: state.outSignature,
-                dtsChangeTime: state.dtsChangeTime,
-            };
-            return result_15;
-        }
         var fileNames = [];
         var fileNameToFileId = new ts.Map();
         var fileIdsList;
         var fileNamesToFileIdListId;
-        var emitSignatures;
         var fileInfos = ts.arrayFrom(state.fileInfos.entries(), function (_a) {
-            var _b, _c;
             var key = _a[0], value = _a[1];
             var fileId = toFileId(key);
             ts.Debug.assert(fileNames[fileId - 1] === relativeToBuildInfo(key));
-            var oldSignature = (_b = state.oldSignatures) === null || _b === void 0 ? void 0 : _b.get(key);
-            var actualSignature = oldSignature !== undefined ? oldSignature || undefined : value.signature;
-            if (state.compilerOptions.composite) {
-                var file = state.program.getSourceFileByPath(key);
-                if (!ts.isJsonSourceFile(file) && ts.sourceFileMayBeEmitted(file, state.program)) {
-                    var emitSignature = (_c = state.emitSignatures) === null || _c === void 0 ? void 0 : _c.get(key);
-                    if (emitSignature !== actualSignature) {
-                        (emitSignatures || (emitSignatures = [])).push(emitSignature === undefined ? fileId : [fileId, emitSignature]);
-                    }
-                }
-            }
+            var signature = state.currentAffectedFilesSignatures && state.currentAffectedFilesSignatures.get(key);
+            var actualSignature = signature !== null && signature !== void 0 ? signature : value.signature;
             return value.version === actualSignature ?
                 value.affectsGlobalScope || value.impliedFormat ?
                     { version: value.version, signature: undefined, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat } :
                     value.version :
                 actualSignature !== undefined ?
-                    oldSignature === undefined ?
+                    signature === undefined ?
                         value :
-                        { version: value.version, signature: actualSignature, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat } :
+                        { version: value.version, signature: signature, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat } :
                     { version: value.version, signature: false, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat };
         });
         var referencedMap;
@@ -99309,12 +99395,16 @@ var ts;
         if (state.exportedModulesMap) {
             exportedModulesMap = ts.mapDefined(ts.arrayFrom(state.exportedModulesMap.keys()).sort(ts.compareStringsCaseSensitive), function (key) {
                 var _a;
-                var oldValue = (_a = state.oldExportedModulesMap) === null || _a === void 0 ? void 0 : _a.get(key);
-                if (oldValue === undefined)
-                    return [toFileId(key), toFileIdListId(state.exportedModulesMap.getValues(key))];
-                if (oldValue)
-                    return [toFileId(key), toFileIdListId(oldValue)];
-                return undefined;
+                if (state.currentAffectedFilesExportedModulesMap) {
+                    if ((_a = state.currentAffectedFilesExportedModulesMap.deletedKeys()) === null || _a === void 0 ? void 0 : _a.has(key)) {
+                        return undefined;
+                    }
+                    var newValue = state.currentAffectedFilesExportedModulesMap.getValues(key);
+                    if (newValue) {
+                        return [toFileId(key), toFileIdListId(newValue)];
+                    }
+                }
+                return [toFileId(key), toFileIdListId(state.exportedModulesMap.getValues(key))];
             });
         }
         var semanticDiagnosticsPerFile;
@@ -99325,7 +99415,9 @@ var ts;
                 (semanticDiagnosticsPerFile || (semanticDiagnosticsPerFile = [])).push(value.length ?
                     [
                         toFileId(key),
-                        convertToReusableDiagnostics(value, relativeToBuildInfo)
+                        state.hasReusableDiagnostic ?
+                            value :
+                            convertToReusableDiagnostics(value, relativeToBuildInfo)
                     ] :
                     toFileId(key));
             }
@@ -99340,27 +99432,16 @@ var ts;
                 }
             }
         }
-        var changeFileSet;
-        if (state.changedFilesSet.size) {
-            for (var _d = 0, _e = ts.arrayFrom(state.changedFilesSet.keys()).sort(ts.compareStringsCaseSensitive); _d < _e.length; _d++) {
-                var path = _e[_d];
-                (changeFileSet || (changeFileSet = [])).push(toFileId(path));
-            }
-        }
-        var result = {
+        return {
             fileNames: fileNames,
             fileInfos: fileInfos,
-            options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsMultiFileEmitBuildInfo"),
+            options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions, relativeToBuildInfoEnsuringAbsolutePath),
             fileIdsList: fileIdsList,
             referencedMap: referencedMap,
             exportedModulesMap: exportedModulesMap,
             semanticDiagnosticsPerFile: semanticDiagnosticsPerFile,
             affectedFilesPendingEmit: affectedFilesPendingEmit,
-            changeFileSet: changeFileSet,
-            emitSignatures: emitSignatures,
-            dtsChangeTime: state.dtsChangeTime,
         };
-        return result;
         function relativeToBuildInfoEnsuringAbsolutePath(path) {
             return relativeToBuildInfo(ts.getNormalizedAbsolutePath(path, currentDirectory));
         }
@@ -99385,18 +99466,21 @@ var ts;
             }
             return fileIdListId;
         }
-        function convertToProgramBuildInfoCompilerOptions(options, optionKey) {
-            var result;
-            var optionsNameMap = ts.getOptionsNameMap().optionsNameMap;
-            for (var _i = 0, _a = ts.getOwnKeys(options).sort(ts.compareStringsCaseSensitive); _i < _a.length; _i++) {
-                var name = _a[_i];
-                var optionInfo = optionsNameMap.get(name.toLowerCase());
-                if (optionInfo === null || optionInfo === void 0 ? void 0 : optionInfo[optionKey]) {
-                    (result || (result = {}))[name] = convertToReusableCompilerOptionValue(optionInfo, options[name], relativeToBuildInfoEnsuringAbsolutePath);
-                }
+    }
+    function convertToProgramBuildInfoCompilerOptions(options, relativeToBuildInfo) {
+        var result;
+        var optionsNameMap = ts.getOptionsNameMap().optionsNameMap;
+        for (var _i = 0, _a = ts.getOwnKeys(options).sort(ts.compareStringsCaseSensitive); _i < _a.length; _i++) {
+            var name = _a[_i];
+            var optionKey = name.toLowerCase();
+            var optionInfo = optionsNameMap.get(optionKey);
+            if ((optionInfo === null || optionInfo === void 0 ? void 0 : optionInfo.affectsEmit) || (optionInfo === null || optionInfo === void 0 ? void 0 : optionInfo.affectsSemanticDiagnostics) ||
+                optionKey === "strict" ||
+                optionKey === "skiplibcheck" || optionKey === "skipdefaultlibcheck") {
+                (result || (result = {}))[name] = convertToReusableCompilerOptionValue(optionInfo, options[name], relativeToBuildInfo);
             }
-            return result;
         }
+        return result;
     }
     function convertToReusableCompilerOptionValue(option, value, relativeToBuildInfo) {
         if (option) {
@@ -99470,10 +99554,6 @@ var ts;
         return { host: host, newProgram: newProgram, oldProgram: oldProgram, configFileParsingDiagnostics: configFileParsingDiagnostics || ts.emptyArray };
     }
     ts.getBuilderCreationParameters = getBuilderCreationParameters;
-    function computeSignature(text, data, computeHash) {
-        return ts.BuilderState.computeSignature((data === null || data === void 0 ? void 0 : data.sourceMapUrlPos) !== undefined ? text.substring(0, data.sourceMapUrlPos) : text, computeHash);
-    }
-    ts.computeSignature = computeSignature;
     function createBuilderProgram(kind, _a) {
         var newProgram = _a.newProgram, host = _a.host, oldProgram = _a.oldProgram, configFileParsingDiagnostics = _a.configFileParsingDiagnostics;
         var oldState = oldProgram && oldProgram.getState();
@@ -99485,28 +99565,28 @@ var ts;
         var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames());
         var computeHash = ts.maybeBind(host, host.createHash);
         var state = createBuilderProgramState(newProgram, getCanonicalFileName, oldState, host.disableUseFileVersionAsSignature);
-        var backupEmitState;
-        newProgram.getProgramBuildInfo = function () { return getProgramBuildInfo(state, getCanonicalFileName, host); };
+        var backupState;
+        newProgram.getProgramBuildInfo = function () { return getProgramBuildInfo(state, getCanonicalFileName); };
         newProgram = undefined;
         oldProgram = undefined;
         oldState = undefined;
         var getState = function () { return state; };
         var builderProgram = createRedirectedBuilderProgram(getState, configFileParsingDiagnostics);
         builderProgram.getState = getState;
-        builderProgram.backupEmitState = function () {
-            ts.Debug.assert(backupEmitState === undefined);
-            backupEmitState = backupEmitBuilderProgramState(state);
+        builderProgram.backupState = function () {
+            ts.Debug.assert(backupState === undefined);
+            backupState = cloneBuilderProgramState(state);
         };
-        builderProgram.restoreEmitState = function () {
-            restoreEmitBuilderProgramState(state, ts.Debug.checkDefined(backupEmitState));
-            backupEmitState = undefined;
+        builderProgram.restoreState = function () {
+            state = ts.Debug.checkDefined(backupState);
+            backupState = undefined;
         };
         builderProgram.getAllDependencies = function (sourceFile) { return ts.BuilderState.getAllDependencies(state, ts.Debug.checkDefined(state.program), sourceFile); };
         builderProgram.getSemanticDiagnostics = getSemanticDiagnostics;
         builderProgram.emit = emit;
         builderProgram.releaseProgram = function () {
             releaseCache(state);
-            backupEmitState = undefined;
+            backupState = undefined;
         };
         if (kind === BuilderProgramKind.SemanticDiagnosticsBuilderProgram) {
             builderProgram.getSemanticDiagnosticsOfNextAffectedFile = getSemanticDiagnosticsOfNextAffectedFile;
@@ -99552,57 +99632,35 @@ var ts;
                     affected = program;
                 }
             }
-            return toAffectedFileEmitResult(state, ts.Debug.checkDefined(state.program).emit(affected === state.program ? undefined : affected, ts.getEmitDeclarations(state.compilerOptions) ?
-                getWriteFileCallback(writeFile, customTransformers) :
+            return toAffectedFileEmitResult(state, ts.Debug.checkDefined(state.program).emit(affected === state.program ? undefined : affected, affected !== state.program && ts.getEmitDeclarations(state.compilerOptions) && !customTransformers ?
+                getWriteFileUpdatingSignatureCallback(writeFile) :
                 writeFile || ts.maybeBind(host, host.writeFile), cancellationToken, emitOnlyDtsFiles || emitKind === 0, customTransformers), affected, emitKind, isPendingEmitFile);
         }
-        function getWriteFileCallback(writeFile, customTransformers) {
+        function getWriteFileUpdatingSignatureCallback(writeFile) {
             return function (fileName, text, writeByteOrderMark, onError, sourceFiles, data) {
-                var _a, _b, _c;
+                var _a;
                 if (ts.isDeclarationFileName(fileName)) {
-                    if (!ts.outFile(state.compilerOptions)) {
-                        ts.Debug.assert((sourceFiles === null || sourceFiles === void 0 ? void 0 : sourceFiles.length) === 1);
-                        var newSignature = void 0;
-                        if (!customTransformers) {
-                            var file = sourceFiles[0];
-                            var info = state.fileInfos.get(file.resolvedPath);
-                            if (info.signature === file.version) {
-                                newSignature = computeSignature(text, data, computeHash);
-                                if (newSignature !== file.version) {
-                                    if (host.storeFilesChangingSignatureDuringEmit)
-                                        (state.filesChangingSignature || (state.filesChangingSignature = new ts.Set())).add(file.resolvedPath);
-                                    if (state.exportedModulesMap)
-                                        ts.BuilderState.updateExportedModules(state, file, file.exportedModulesFromDeclarationEmit);
-                                    if (state.affectedFiles) {
-                                        var existing = (_a = state.oldSignatures) === null || _a === void 0 ? void 0 : _a.get(file.resolvedPath);
-                                        if (existing === undefined)
-                                            (state.oldSignatures || (state.oldSignatures = new ts.Map())).set(file.resolvedPath, info.signature || false);
-                                        info.signature = newSignature;
-                                    }
-                                    else {
-                                        info.signature = newSignature;
-                                        (_b = state.oldExportedModulesMap) === null || _b === void 0 ? void 0 : _b.clear();
-                                    }
-                                }
+                    ts.Debug.assert((sourceFiles === null || sourceFiles === void 0 ? void 0 : sourceFiles.length) === 1);
+                    var file = sourceFiles[0];
+                    var info = state.fileInfos.get(file.resolvedPath);
+                    var signature = ((_a = state.currentAffectedFilesSignatures) === null || _a === void 0 ? void 0 : _a.get(file.resolvedPath)) || info.signature;
+                    if (signature === file.version) {
+                        var newSignature = (computeHash || ts.generateDjb2Hash)((data === null || data === void 0 ? void 0 : data.sourceMapUrlPos) !== undefined ? text.substring(0, data.sourceMapUrlPos) : text);
+                        if (newSignature !== file.version) {
+                            if (host.storeFilesChangingSignatureDuringEmit)
+                                (state.filesChangingSignature || (state.filesChangingSignature = new ts.Set())).add(file.resolvedPath);
+                            if (state.exportedModulesMap)
+                                ts.BuilderState.updateExportedModules(file, file.exportedModulesFromDeclarationEmit, state.currentAffectedFilesExportedModulesMap || (state.currentAffectedFilesExportedModulesMap = ts.BuilderState.createManyToManyPathMap()));
+                            if (state.affectedFiles && state.affectedFilesIndex < state.affectedFiles.length) {
+                                state.currentAffectedFilesSignatures.set(file.resolvedPath, newSignature);
                             }
-                        }
-                        if (state.compilerOptions.composite) {
-                            var filePath = sourceFiles[0].resolvedPath;
-                            var oldSignature = (_c = state.emitSignatures) === null || _c === void 0 ? void 0 : _c.get(filePath);
-                            newSignature || (newSignature = computeSignature(text, data, computeHash));
-                            if (newSignature !== oldSignature) {
-                                (state.emitSignatures || (state.emitSignatures = new ts.Map())).set(filePath, newSignature);
-                                state.hasChangedEmitSignature = true;
+                            else {
+                                info.signature = newSignature;
+                                if (state.exportedModulesMap)
+                                    ts.BuilderState.updateExportedFilesMapFromCache(state, state.currentAffectedFilesExportedModulesMap);
                             }
                         }
                     }
-                    else if (state.compilerOptions.composite) {
-                        var newSignature = computeSignature(text, data, computeHash);
-                        if (newSignature !== state.outSignature) {
-                            state.outSignature = newSignature;
-                            state.hasChangedEmitSignature = true;
-                        }
-                    }
                 }
                 if (writeFile)
                     writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
@@ -99651,8 +99709,8 @@ var ts;
                     }
                 }
             }
-            return ts.Debug.checkDefined(state.program).emit(targetSourceFile, ts.getEmitDeclarations(state.compilerOptions) ?
-                getWriteFileCallback(writeFile, customTransformers) :
+            return ts.Debug.checkDefined(state.program).emit(targetSourceFile, !ts.outFile(state.compilerOptions) && ts.getEmitDeclarations(state.compilerOptions) && !customTransformers ?
+                getWriteFileUpdatingSignatureCallback(writeFile) :
                 writeFile || ts.maybeBind(host, host.writeFile), cancellationToken, emitOnlyDtsFiles, customTransformers);
         }
         function getSemanticDiagnosticsOfNextAffectedFile(cancellationToken, ignoreSourceFile) {
@@ -99715,28 +99773,14 @@ var ts;
                 { version: fileInfo.version, signature: fileInfo.signature === false ? undefined : fileInfo.version, affectsGlobalScope: fileInfo.affectsGlobalScope, impliedFormat: fileInfo.impliedFormat };
     }
     ts.toBuilderStateFileInfo = toBuilderStateFileInfo;
-    function createBuilderProgramUsingProgramBuildInfo(programFromBuildInfo, buildInfoPath, host) {
-        var _a, _b, _c, _d, _e;
+    function createBuildProgramUsingProgramBuildInfo(program, buildInfoPath, host) {
+        var _a;
         var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
         var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames());
-        var program = programFromBuildInfo;
-        var filePaths = (_a = program.fileNames) === null || _a === void 0 ? void 0 : _a.map(toPath);
-        var filePathsSetList = (_b = program.fileIdsList) === null || _b === void 0 ? void 0 : _b.map(function (fileIds) { return new ts.Set(fileIds.map(toFilePath)); });
+        var filePaths = program.fileNames.map(toPath);
+        var filePathsSetList = (_a = program.fileIdsList) === null || _a === void 0 ? void 0 : _a.map(function (fileIds) { return new ts.Set(fileIds.map(toFilePath)); });
         var fileInfos = new ts.Map();
-        var emitSignatures = ((_c = program.options) === null || _c === void 0 ? void 0 : _c.composite) && !ts.outFile(program.options) ? new ts.Map() : undefined;
-        (_d = program.fileInfos) === null || _d === void 0 ? void 0 : _d.forEach(function (fileInfo, index) {
-            var path = toFilePath(index + 1);
-            var stateFileInfo = toBuilderStateFileInfo(fileInfo);
-            fileInfos.set(path, stateFileInfo);
-            if (emitSignatures && stateFileInfo.signature)
-                emitSignatures.set(path, stateFileInfo.signature);
-        });
-        (_e = program.emitSignatures) === null || _e === void 0 ? void 0 : _e.forEach(function (value) {
-            if (ts.isNumber(value))
-                emitSignatures.delete(toFilePath(value));
-            else
-                emitSignatures.set(toFilePath(value[0]), value[1]);
-        });
+        program.fileInfos.forEach(function (fileInfo, index) { return fileInfos.set(toFilePath(index + 1), toBuilderStateFileInfo(fileInfo)); });
         var state = {
             fileInfos: fileInfos,
             compilerOptions: program.options ? ts.convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
@@ -99747,15 +99791,11 @@ var ts;
             affectedFilesPendingEmit: ts.map(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }),
             affectedFilesPendingEmitKind: program.affectedFilesPendingEmit && ts.arrayToMap(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }, function (value) { return value[1]; }),
             affectedFilesPendingEmitIndex: program.affectedFilesPendingEmit && 0,
-            changedFilesSet: new ts.Set(ts.map(program.changeFileSet, toFilePath)),
-            dtsChangeTime: program.dtsChangeTime,
-            emitSignatures: (emitSignatures === null || emitSignatures === void 0 ? void 0 : emitSignatures.size) ? emitSignatures : undefined,
-            outSignature: program.outSignature,
         };
         return {
             getState: function () { return state; },
-            backupEmitState: ts.noop,
-            restoreEmitState: ts.noop,
+            backupState: ts.noop,
+            restoreState: ts.noop,
             getProgram: ts.notImplemented,
             getProgramOrUndefined: ts.returnUndefined,
             releaseProgram: ts.noop,
@@ -99800,12 +99840,12 @@ var ts;
             return map;
         }
     }
-    ts.createBuilderProgramUsingProgramBuildInfo = createBuilderProgramUsingProgramBuildInfo;
+    ts.createBuildProgramUsingProgramBuildInfo = createBuildProgramUsingProgramBuildInfo;
     function createRedirectedBuilderProgram(getState, configFileParsingDiagnostics) {
         return {
             getState: ts.notImplemented,
-            backupEmitState: ts.noop,
-            restoreEmitState: ts.noop,
+            backupState: ts.noop,
+            restoreState: ts.noop,
             getProgram: getProgram,
             getProgramOrUndefined: function () { return getState().program; },
             releaseProgram: function () { return getState().program = undefined; },
@@ -100050,8 +100090,8 @@ var ts;
                 !!redirectedReference;
             var seenNamesInFile = ts.createModeAwareCache();
             var i = 0;
-            for (var _i = 0, names_4 = names; _i < names_4.length; _i++) {
-                var entry = names_4[_i];
+            for (var _i = 0, names_5 = names; _i < names_5.length; _i++) {
+                var entry = names_5[_i];
                 var name = ts.isString(entry) ? entry : entry.fileName.toLowerCase();
                 var mode = !ts.isString(entry) ? ts.getModeForFileReference(entry, containingSourceFileMode) :
                     containingSourceFile ? ts.getModeForResolutionAtIndex(containingSourceFile, i) : undefined;
@@ -100543,7 +100583,7 @@ var ts;
         }
         function isFormatRequiringExtensions(compilerOptions, importingSourceFileName, host) {
             var _a;
-            if (ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Node12
+            if (ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Node16
                 && ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeNext) {
                 return false;
             }
@@ -100577,14 +100617,14 @@ var ts;
             if (options === void 0) { options = {}; }
             var info = getInfo(importingSourceFile.path, host);
             var modulePaths = getAllModulePaths(importingSourceFile.path, nodeModulesFileName, host, preferences, options);
-            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, true, options.overrideImportMode); });
+            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, preferences, true, options.overrideImportMode); });
         }
         moduleSpecifiers_1.getNodeModulesPackageName = getNodeModulesPackageName;
         function getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, preferences, userPreferences, options) {
             if (options === void 0) { options = {}; }
             var info = getInfo(importingSourceFileName, host);
             var modulePaths = getAllModulePaths(importingSourceFileName, toFileName, host, userPreferences, options);
-            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, undefined, options.overrideImportMode); }) ||
+            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, userPreferences, undefined, options.overrideImportMode); }) ||
                 getLocalModuleSpecifier(toFileName, info, compilerOptions, host, preferences);
         }
         function tryGetModuleSpecifiersFromCache(moduleSymbol, importingSourceFile, host, userPreferences, options) {
@@ -100650,7 +100690,7 @@ var ts;
             var relativeSpecifiers;
             for (var _i = 0, modulePaths_1 = modulePaths; _i < modulePaths_1.length; _i++) {
                 var modulePath = modulePaths_1[_i];
-                var specifier = tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, undefined, options.overrideImportMode);
+                var specifier = tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, userPreferences, undefined, options.overrideImportMode);
                 nodeModulesSpecifiers = ts.append(nodeModulesSpecifiers, specifier);
                 if (specifier && modulePath.isRedirect) {
                     return nodeModulesSpecifiers;
@@ -100756,9 +100796,9 @@ var ts;
             var targets = importedFileNames.map(function (f) { return ts.getNormalizedAbsolutePath(f, cwd); });
             var shouldFilterIgnoredPaths = !ts.every(targets, ts.containsIgnoredPath);
             if (!preferSymlinks) {
-                var result_16 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
-                if (result_16)
-                    return result_16;
+                var result_15 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
+                if (result_15)
+                    return result_15;
             }
             var symlinkedDirectories = (_a = host.getSymlinkCache) === null || _a === void 0 ? void 0 : _a.call(host).getSymlinkedDirectoriesByRealpath();
             var fullImportedFileName = ts.getNormalizedAbsolutePath(importedFileName, cwd);
@@ -100777,10 +100817,10 @@ var ts;
                     for (var _i = 0, symlinkDirectories_1 = symlinkDirectories; _i < symlinkDirectories_1.length; _i++) {
                         var symlinkDirectory = symlinkDirectories_1[_i];
                         var option = ts.resolvePath(symlinkDirectory, relative);
-                        var result_17 = cb(option, target === referenceRedirect);
+                        var result_16 = cb(option, target === referenceRedirect);
                         shouldFilterIgnoredPaths = true;
-                        if (result_17)
-                            return result_17;
+                        if (result_16)
+                            return result_16;
                     }
                 });
             });
@@ -100981,7 +101021,7 @@ var ts;
                 ? removeExtensionAndIndexPostFix(relativePath, ending, compilerOptions)
                 : ts.removeFileExtension(relativePath);
         }
-        function tryGetModuleNameAsNodeModule(_a, _b, importingSourceFile, host, options, packageNameOnly, overrideMode) {
+        function tryGetModuleNameAsNodeModule(_a, _b, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
             var path = _a.path, isRedirect = _a.isRedirect;
             var getCanonicalFileName = _b.getCanonicalFileName, sourceDirectory = _b.sourceDirectory;
             if (!host.fileExists || !host.readFile) {
@@ -100994,8 +101034,9 @@ var ts;
             var moduleSpecifier = path;
             var isPackageRootPath = false;
             if (!packageNameOnly) {
+                var preferences = getPreferences(host, userPreferences, options, importingSourceFile);
                 var packageRootIndex = parts.packageRootIndex;
-                var moduleFileNameForExtensionless = void 0;
+                var moduleFileName = void 0;
                 while (true) {
                     var _c = tryDirectoryWithPackageJson(packageRootIndex), moduleFileToTry = _c.moduleFileToTry, packageRootPath = _c.packageRootPath, blockedByExports = _c.blockedByExports, verbatimFromExports = _c.verbatimFromExports;
                     if (ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.Classic) {
@@ -101011,11 +101052,11 @@ var ts;
                         isPackageRootPath = true;
                         break;
                     }
-                    if (!moduleFileNameForExtensionless)
-                        moduleFileNameForExtensionless = moduleFileToTry;
+                    if (!moduleFileName)
+                        moduleFileName = moduleFileToTry;
                     packageRootIndex = path.indexOf(ts.directorySeparator, packageRootIndex + 1);
                     if (packageRootIndex === -1) {
-                        moduleSpecifier = getExtensionlessFileName(moduleFileNameForExtensionless);
+                        moduleSpecifier = removeExtensionAndIndexPostFix(moduleFileName, preferences.ending, options, host);
                         break;
                     }
                 }
@@ -101039,7 +101080,7 @@ var ts;
                 var cachedPackageJson = (_b = (_a = host.getPackageJsonInfoCache) === null || _a === void 0 ? void 0 : _a.call(host)) === null || _b === void 0 ? void 0 : _b.getPackageJsonInfo(packageJsonPath);
                 if (typeof cachedPackageJson === "object" || cachedPackageJson === undefined && host.fileExists(packageJsonPath)) {
                     var packageJsonContent = (cachedPackageJson === null || cachedPackageJson === void 0 ? void 0 : cachedPackageJson.packageJsonContent) || JSON.parse(host.readFile(packageJsonPath));
-                    if (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12 || ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext) {
+                    if (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node16 || ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext) {
                         var conditions = ["node", overrideMode || importingSourceFile.impliedNodeFormat === ts.ModuleKind.ESNext ? "import" : "require", "types"];
                         var fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string"
                             ? tryGetModuleNameFromExports(options, path, packageRootPath, ts.getPackageNameFromTypesPackageName(packageJsonContent.name), packageJsonContent.exports, conditions)
@@ -101064,7 +101105,7 @@ var ts;
                             moduleFileToTry = ts.combinePaths(packageRootPath, fromPaths);
                         }
                     }
-                    var mainFileRelative = packageJsonContent.typings || packageJsonContent.types || packageJsonContent.main;
+                    var mainFileRelative = packageJsonContent.typings || packageJsonContent.types || packageJsonContent.main || "index.js";
                     if (ts.isString(mainFileRelative)) {
                         var mainExportFile = ts.toPath(mainFileRelative, packageRootPath, getCanonicalFileName);
                         if (ts.removeFileExtension(mainExportFile) === ts.removeFileExtension(getCanonicalFileName(moduleFileToTry))) {
@@ -101072,14 +101113,13 @@ var ts;
                         }
                     }
                 }
-                return { moduleFileToTry: moduleFileToTry };
-            }
-            function getExtensionlessFileName(path) {
-                var fullModulePathWithoutExtension = ts.removeFileExtension(path);
-                if (getCanonicalFileName(fullModulePathWithoutExtension.substring(parts.fileNameIndex)) === "/index" && !tryGetAnyFileFromPath(host, fullModulePathWithoutExtension.substring(0, parts.fileNameIndex))) {
-                    return fullModulePathWithoutExtension.substring(0, parts.fileNameIndex);
+                else {
+                    var fileName = getCanonicalFileName(moduleFileToTry.substring(parts.packageRootIndex + 1));
+                    if (fileName === "index.d.ts" || fileName === "index.js" || fileName === "index.ts" || fileName === "index.tsx") {
+                        return { moduleFileToTry: moduleFileToTry, packageRootPath: packageRootPath };
+                    }
                 }
-                return fullModulePathWithoutExtension;
+                return { moduleFileToTry: moduleFileToTry };
             }
         }
         function tryGetAnyFileFromPath(host, path) {
@@ -101100,7 +101140,7 @@ var ts;
                 return relativePath !== undefined && isPathRelativeToParent(relativePath) ? undefined : relativePath;
             });
         }
-        function removeExtensionAndIndexPostFix(fileName, ending, options) {
+        function removeExtensionAndIndexPostFix(fileName, ending, options, host) {
             if (ts.fileExtensionIsOneOf(fileName, [".json", ".mjs", ".cjs"]))
                 return fileName;
             var noExtension = ts.removeFileExtension(fileName);
@@ -101108,7 +101148,11 @@ var ts;
                 return noExtension + getJSExtensionForFile(fileName, options);
             switch (ending) {
                 case 0:
-                    return ts.removeSuffix(noExtension, "/index");
+                    var withoutIndex = ts.removeSuffix(noExtension, "/index");
+                    if (host && withoutIndex !== noExtension && tryGetAnyFileFromPath(host, withoutIndex)) {
+                        return noExtension;
+                    }
+                    return withoutIndex;
                 case 1:
                     return noExtension;
                 case 2:
@@ -101595,7 +101639,6 @@ var ts;
             readDirectory: ts.maybeBind(host, host.readDirectory),
             disableUseFileVersionAsSignature: host.disableUseFileVersionAsSignature,
             storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit,
-            now: ts.maybeBind(host, host.now),
         };
         function writeFile(fileName, text, writeByteOrderMark, onError) {
             try {
@@ -101650,7 +101693,6 @@ var ts;
             createProgram: createProgram || ts.createEmitAndSemanticDiagnosticsBuilderProgram,
             disableUseFileVersionAsSignature: system.disableUseFileVersionAsSignature,
             storeFilesChangingSignatureDuringEmit: system.storeFilesChangingSignatureDuringEmit,
-            now: ts.maybeBind(system, system.now),
         };
     }
     ts.createProgramHost = createProgramHost;
@@ -101706,26 +101748,20 @@ var ts;
 var ts;
 (function (ts) {
     function readBuilderProgram(compilerOptions, host) {
+        if (ts.outFile(compilerOptions))
+            return undefined;
         var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(compilerOptions);
         if (!buildInfoPath)
             return undefined;
-        var buildInfo;
-        if (host.getBuildInfo) {
-            buildInfo = host.getBuildInfo(buildInfoPath, compilerOptions.configFilePath);
-            if (!buildInfo)
-                return undefined;
-        }
-        else {
-            var content = host.readFile(buildInfoPath);
-            if (!content)
-                return undefined;
-            buildInfo = ts.getBuildInfo(content);
-        }
+        var content = host.readFile(buildInfoPath);
+        if (!content)
+            return undefined;
+        var buildInfo = ts.getBuildInfo(content);
         if (buildInfo.version !== ts.version)
             return undefined;
         if (!buildInfo.program)
             return undefined;
-        return ts.createBuilderProgramUsingProgramBuildInfo(buildInfo.program, buildInfoPath, host);
+        return ts.createBuildProgramUsingProgramBuildInfo(buildInfo.program, buildInfoPath, host);
     }
     ts.readBuilderProgram = readBuilderProgram;
     function createIncrementalCompilerHost(options, system) {
@@ -101734,7 +101770,6 @@ var ts;
         host.createHash = ts.maybeBind(system, system.createHash);
         host.disableUseFileVersionAsSignature = system.disableUseFileVersionAsSignature;
         host.storeFilesChangingSignatureDuringEmit = system.storeFilesChangingSignatureDuringEmit;
-        host.now = ts.maybeBind(system, system.now);
         ts.setGetSourceFileAsHashVersioned(host, system);
         ts.changeCompilerHostLikeToUseCache(host, function (fileName) { return ts.toPath(fileName, host.getCurrentDirectory(), host.getCanonicalFileName); });
         return host;
@@ -102397,13 +102432,11 @@ var ts;
         UpToDateStatusType[UpToDateStatusType["OutputMissing"] = 4] = "OutputMissing";
         UpToDateStatusType[UpToDateStatusType["OutOfDateWithSelf"] = 5] = "OutOfDateWithSelf";
         UpToDateStatusType[UpToDateStatusType["OutOfDateWithUpstream"] = 6] = "OutOfDateWithUpstream";
-        UpToDateStatusType[UpToDateStatusType["OutOfDateBuildInfo"] = 7] = "OutOfDateBuildInfo";
-        UpToDateStatusType[UpToDateStatusType["UpstreamOutOfDate"] = 8] = "UpstreamOutOfDate";
-        UpToDateStatusType[UpToDateStatusType["UpstreamBlocked"] = 9] = "UpstreamBlocked";
-        UpToDateStatusType[UpToDateStatusType["ComputingUpstream"] = 10] = "ComputingUpstream";
-        UpToDateStatusType[UpToDateStatusType["TsVersionOutputOfDate"] = 11] = "TsVersionOutputOfDate";
-        UpToDateStatusType[UpToDateStatusType["ContainerOnly"] = 12] = "ContainerOnly";
-        UpToDateStatusType[UpToDateStatusType["ForceBuild"] = 13] = "ForceBuild";
+        UpToDateStatusType[UpToDateStatusType["UpstreamOutOfDate"] = 7] = "UpstreamOutOfDate";
+        UpToDateStatusType[UpToDateStatusType["UpstreamBlocked"] = 8] = "UpstreamBlocked";
+        UpToDateStatusType[UpToDateStatusType["ComputingUpstream"] = 9] = "ComputingUpstream";
+        UpToDateStatusType[UpToDateStatusType["TsVersionOutputOfDate"] = 10] = "TsVersionOutputOfDate";
+        UpToDateStatusType[UpToDateStatusType["ContainerOnly"] = 11] = "ContainerOnly";
     })(UpToDateStatusType = ts.UpToDateStatusType || (ts.UpToDateStatusType = {}));
     function resolveConfigFileProjectName(project) {
         if (ts.fileExtensionIs(project, ".json")) {
@@ -102441,10 +102474,9 @@ var ts;
     function getOrCreateValueMapFromConfigFileMap(configFileMap, resolved) {
         return getOrCreateValueFromConfigFileMap(configFileMap, resolved, function () { return new ts.Map(); });
     }
-    function getCurrentTime(host) {
-        return host.now ? host.now() : new Date();
+    function newer(date1, date2) {
+        return date2 > date1 ? date2 : date1;
     }
-    ts.getCurrentTime = getCurrentTime;
     function isCircularBuildOrder(buildOrder) {
         return !!buildOrder && !!buildOrder.buildOrder;
     }
@@ -102528,7 +102560,6 @@ var ts;
                 return ts.loadWithTypeDirectiveCache(ts.Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader_4);
             };
         }
-        compilerHost.getBuildInfo = function (fileName, configFilePath) { return getBuildInfo(state, fileName, toResolvedConfigFilePath(state, configFilePath), undefined); };
         var _a = ts.createWatchFactory(hostWithWatch, options), watchFile = _a.watchFile, watchDirectory = _a.watchDirectory, writeLog = _a.writeLog;
         var state = {
             host: host,
@@ -102544,9 +102575,8 @@ var ts;
             resolvedConfigFilePaths: new ts.Map(),
             configFileCache: new ts.Map(),
             projectStatus: new ts.Map(),
+            buildInfoChecked: new ts.Map(),
             extendedConfigCache: new ts.Map(),
-            buildInfoCache: new ts.Map(),
-            outputTimeStamps: new ts.Map(),
             builderPrograms: new ts.Map(),
             diagnostics: new ts.Map(),
             projectPendingBuild: new ts.Map(),
@@ -102568,7 +102598,6 @@ var ts;
             allWatchedConfigFiles: new ts.Map(),
             allWatchedExtendedConfigFiles: new ts.Map(),
             allWatchedPackageJsonFiles: new ts.Map(),
-            filesWatched: new ts.Map(),
             lastCachedPackageJsonLookups: new ts.Map(),
             timerToBuildInvalidatedProject: undefined,
             reportFileChangeDetected: false,
@@ -102670,12 +102699,11 @@ var ts;
         var noopOnDelete = { onDeleteValue: ts.noop };
         ts.mutateMapSkippingNewValues(state.configFileCache, currentProjects, noopOnDelete);
         ts.mutateMapSkippingNewValues(state.projectStatus, currentProjects, noopOnDelete);
+        ts.mutateMapSkippingNewValues(state.buildInfoChecked, currentProjects, noopOnDelete);
         ts.mutateMapSkippingNewValues(state.builderPrograms, currentProjects, noopOnDelete);
         ts.mutateMapSkippingNewValues(state.diagnostics, currentProjects, noopOnDelete);
         ts.mutateMapSkippingNewValues(state.projectPendingBuild, currentProjects, noopOnDelete);
         ts.mutateMapSkippingNewValues(state.projectErrorsReported, currentProjects, noopOnDelete);
-        ts.mutateMapSkippingNewValues(state.buildInfoCache, currentProjects, noopOnDelete);
-        ts.mutateMapSkippingNewValues(state.outputTimeStamps, currentProjects, noopOnDelete);
         if (state.watch) {
             ts.mutateMapSkippingNewValues(state.allWatchedConfigFiles, currentProjects, { onDeleteValue: ts.closeFileWatcher });
             state.allWatchedExtendedConfigFiles.forEach(function (watcher) {
@@ -102961,16 +102989,16 @@ var ts;
         }
         function emit(writeFileCallback, cancellationToken, customTransformers) {
             var _a;
-            var _b, _c, _d;
+            var _b, _c;
             ts.Debug.assertIsDefined(program);
             ts.Debug.assert(step === BuildStep.Emit);
-            program.backupEmitState();
+            program.backupState();
             var declDiagnostics;
             var reportDeclarationDiagnostics = function (d) { return (declDiagnostics || (declDiagnostics = [])).push(d); };
             var outputFiles = [];
-            var emitResult = ts.emitFilesAndReportErrors(program, reportDeclarationDiagnostics, undefined, undefined, function (name, text, writeByteOrderMark, _onError, _sourceFiles, data) { return outputFiles.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark, buildInfo: data === null || data === void 0 ? void 0 : data.buildInfo }); }, cancellationToken, false, customTransformers || ((_c = (_b = state.host).getCustomTransformers) === null || _c === void 0 ? void 0 : _c.call(_b, project))).emitResult;
+            var emitResult = ts.emitFilesAndReportErrors(program, reportDeclarationDiagnostics, undefined, undefined, function (name, text, writeByteOrderMark) { return outputFiles.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark }); }, cancellationToken, false, customTransformers || ((_c = (_b = state.host).getCustomTransformers) === null || _c === void 0 ? void 0 : _c.call(_b, project))).emitResult;
             if (declDiagnostics) {
-                program.restoreEmitState();
+                program.restoreState();
                 (_a = buildErrors(state, projectPath, program, config, declDiagnostics, BuildResultFlags.DeclarationEmitErrors, "Declaration file"), buildResult = _a.buildResult, step = _a.step);
                 return {
                     emitSkipped: true,
@@ -102979,43 +103007,35 @@ var ts;
             }
             var host = state.host, compilerHost = state.compilerHost;
             var resultFlags = BuildResultFlags.DeclarationOutputUnchanged;
-            var existingBuildInfo = ((_d = state.buildInfoCache.get(projectPath)) === null || _d === void 0 ? void 0 : _d.buildInfo) || undefined;
+            var newestDeclarationFileContentChangedTime = minimumDate;
+            var anyDtsChanged = false;
             var emitterDiagnostics = ts.createDiagnosticCollection();
             var emittedOutputs = new ts.Map();
-            var options = program.getCompilerOptions();
-            var isIncremental = ts.isIncrementalCompilation(options);
-            var outputTimeStampMap;
-            var now;
             outputFiles.forEach(function (_a) {
-                var _b, _c;
-                var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark, buildInfo = _a.buildInfo;
-                var path = toPath(state, name);
-                emittedOutputs.set(toPath(state, name), name);
-                if (buildInfo) {
-                    setBuildInfo(state, buildInfo, projectPath, options);
-                    if (((_b = buildInfo.program) === null || _b === void 0 ? void 0 : _b.dtsChangeTime) !== ((_c = existingBuildInfo === null || existingBuildInfo === void 0 ? void 0 : existingBuildInfo.program) === null || _c === void 0 ? void 0 : _c.dtsChangeTime)) {
+                var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark;
+                var priorChangeTime;
+                if (!anyDtsChanged && ts.isDeclarationFileName(name)) {
+                    if (host.fileExists(name) && state.readFileWithCache(name) === text) {
+                        priorChangeTime = host.getModifiedTime(name);
+                    }
+                    else {
                         resultFlags &= ~BuildResultFlags.DeclarationOutputUnchanged;
+                        anyDtsChanged = true;
                     }
                 }
+                emittedOutputs.set(toPath(state, name), name);
                 ts.writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
-                if (!isIncremental && state.watch) {
-                    (outputTimeStampMap || (outputTimeStampMap = getOutputTimeStampMap(state, projectPath))).set(path, now || (now = getCurrentTime(state.host)));
+                if (priorChangeTime !== undefined) {
+                    newestDeclarationFileContentChangedTime = newer(priorChangeTime, newestDeclarationFileContentChangedTime);
                 }
             });
-            finishEmit(emitterDiagnostics, emittedOutputs, outputFiles.length ? outputFiles[0].name : ts.getFirstProjectOutput(config, !host.useCaseSensitiveFileNames()), resultFlags);
+            finishEmit(emitterDiagnostics, emittedOutputs, newestDeclarationFileContentChangedTime, anyDtsChanged, outputFiles.length ? outputFiles[0].name : ts.getFirstProjectOutput(config, !host.useCaseSensitiveFileNames()), resultFlags);
             return emitResult;
         }
         function emitBuildInfo(writeFileCallback, cancellationToken) {
             ts.Debug.assertIsDefined(program);
             ts.Debug.assert(step === BuildStep.EmitBuildInfo);
-            var emitResult = program.emitBuildInfo(function (name, text, writeByteOrderMark, onError, sourceFiles, data) {
-                if (data === null || data === void 0 ? void 0 : data.buildInfo)
-                    setBuildInfo(state, data.buildInfo, projectPath, program.getCompilerOptions());
-                if (writeFileCallback)
-                    writeFileCallback(name, text, writeByteOrderMark, onError, sourceFiles, data);
-                else
-                    state.compilerHost.writeFile(name, text, writeByteOrderMark, onError, sourceFiles, data);
-            }, cancellationToken);
+            var emitResult = program.emitBuildInfo(writeFileCallback, cancellationToken);
             if (emitResult.diagnostics.length) {
                 reportErrors(state, emitResult.diagnostics);
                 state.diagnostics.set(projectPath, __spreadArray(__spreadArray([], state.diagnostics.get(projectPath), true), emitResult.diagnostics, true));
@@ -103028,7 +103048,7 @@ var ts;
             step = BuildStep.QueueReferencingProjects;
             return emitResult;
         }
-        function finishEmit(emitterDiagnostics, emittedOutputs, oldestOutputFileName, resultFlags) {
+        function finishEmit(emitterDiagnostics, emittedOutputs, priorNewestUpdateTime, newestDeclarationFileContentChangedTimeIsMaximumDate, oldestOutputFileName, resultFlags) {
             var _a;
             var emitDiagnostics = emitterDiagnostics.getDiagnostics();
             if (emitDiagnostics.length) {
@@ -103038,11 +103058,13 @@ var ts;
             if (state.write) {
                 emittedOutputs.forEach(function (name) { return listEmittedFile(state, config, name); });
             }
-            updateOutputTimestampsWorker(state, config, projectPath, ts.Diagnostics.Updating_unchanged_output_timestamps_of_project_0, emittedOutputs);
+            var newestDeclarationFileContentChangedTime = updateOutputTimestampsWorker(state, config, priorNewestUpdateTime, ts.Diagnostics.Updating_unchanged_output_timestamps_of_project_0, emittedOutputs);
             state.diagnostics.delete(projectPath);
             state.projectStatus.set(projectPath, {
                 type: ts.UpToDateStatusType.UpToDate,
-                newestDeclarationFileContentChangedTime: getDtsChangeTime(state, config.options, projectPath),
+                newestDeclarationFileContentChangedTime: newestDeclarationFileContentChangedTimeIsMaximumDate ?
+                    maximumDate :
+                    newestDeclarationFileContentChangedTime,
                 oldestOutputFileName: oldestOutputFileName
             });
             afterProgramDone(state, program, config);
@@ -103075,21 +103097,12 @@ var ts;
             ts.Debug.assert(!!outputFiles.length);
             var emitterDiagnostics = ts.createDiagnosticCollection();
             var emittedOutputs = new ts.Map();
-            var resultFlags = BuildResultFlags.DeclarationOutputUnchanged;
-            var existingBuildInfo = state.buildInfoCache.get(projectPath).buildInfo;
             outputFiles.forEach(function (_a) {
-                var _b, _c;
-                var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark, buildInfo = _a.buildInfo;
+                var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark;
                 emittedOutputs.set(toPath(state, name), name);
-                if (buildInfo) {
-                    setBuildInfo(state, buildInfo, projectPath, config.options);
-                    if (((_b = buildInfo.program) === null || _b === void 0 ? void 0 : _b.dtsChangeTime) !== ((_c = existingBuildInfo.program) === null || _c === void 0 ? void 0 : _c.dtsChangeTime)) {
-                        resultFlags &= ~BuildResultFlags.DeclarationOutputUnchanged;
-                    }
-                }
                 ts.writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
             });
-            var emitDiagnostics = finishEmit(emitterDiagnostics, emittedOutputs, outputFiles[0].name, resultFlags);
+            var emitDiagnostics = finishEmit(emitterDiagnostics, emittedOutputs, minimumDate, false, outputFiles[0].name, BuildResultFlags.DeclarationOutputUnchanged);
             return { emitSkipped: false, diagnostics: emitDiagnostics };
         }
         function executeSteps(till, cancellationToken, writeFile, customTransformers) {
@@ -103245,7 +103258,7 @@ var ts;
         state.projectCompilerOptions = state.baseCompilerOptions;
     }
     function buildErrors(state, resolvedPath, program, config, diagnostics, buildResult, errorType) {
-        var canEmitBuildInfo = program && !ts.outFile(program.getCompilerOptions());
+        var canEmitBuildInfo = !(buildResult & BuildResultFlags.SyntaxErrors) && program && !ts.outFile(program.getCompilerOptions());
         reportAndStoreErrors(state, resolvedPath, diagnostics);
         state.projectStatus.set(resolvedPath, { type: ts.UpToDateStatusType.Unbuildable, reason: errorType + " errors" });
         if (canEmitBuildInfo)
@@ -103253,94 +103266,8 @@ var ts;
         afterProgramDone(state, program, config);
         return { buildResult: buildResult, step: BuildStep.QueueReferencingProjects };
     }
-    function isFileWatcherWithModifiedTime(value) {
-        return !!value.watcher;
-    }
-    function getModifiedTime(state, fileName) {
-        var path = toPath(state, fileName);
-        var existing = state.filesWatched.get(path);
-        if (state.watch && !!existing) {
-            if (!isFileWatcherWithModifiedTime(existing))
-                return existing;
-            if (existing.modifiedTime)
-                return existing.modifiedTime;
-        }
-        var result = ts.getModifiedTime(state.host, fileName);
-        if (state.watch) {
-            if (existing)
-                existing.modifiedTime = result;
-            else
-                state.filesWatched.set(path, result);
-        }
-        return result;
-    }
-    function watchFile(state, file, callback, pollingInterval, options, watchType, project) {
-        var path = toPath(state, file);
-        var existing = state.filesWatched.get(path);
-        if (existing && isFileWatcherWithModifiedTime(existing)) {
-            existing.callbacks.push(callback);
-        }
-        else {
-            var watcher = state.watchFile(file, function (fileName, eventKind, modifiedTime) {
-                var existing = ts.Debug.checkDefined(state.filesWatched.get(path));
-                ts.Debug.assert(isFileWatcherWithModifiedTime(existing));
-                existing.modifiedTime = modifiedTime;
-                existing.callbacks.forEach(function (cb) { return cb(fileName, eventKind, modifiedTime); });
-            }, pollingInterval, options, watchType, project);
-            state.filesWatched.set(path, { callbacks: [callback], watcher: watcher, modifiedTime: existing });
-        }
-        return {
-            close: function () {
-                var existing = ts.Debug.checkDefined(state.filesWatched.get(path));
-                ts.Debug.assert(isFileWatcherWithModifiedTime(existing));
-                if (existing.callbacks.length === 1) {
-                    state.filesWatched.delete(path);
-                    ts.closeFileWatcherOf(existing);
-                }
-                else {
-                    ts.unorderedRemoveItem(existing.callbacks, callback);
-                }
-            }
-        };
-    }
-    function getOutputTimeStampMap(state, resolvedConfigFilePath) {
-        if (!state.watch)
-            return undefined;
-        var result = state.outputTimeStamps.get(resolvedConfigFilePath);
-        if (!result)
-            state.outputTimeStamps.set(resolvedConfigFilePath, result = new ts.Map());
-        return result;
-    }
-    function setBuildInfo(state, buildInfo, resolvedConfigPath, options) {
-        var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(options);
-        var existing = getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath);
-        if (existing) {
-            existing.buildInfo = buildInfo;
-            existing.modifiedTime = getCurrentTime(state.host);
-        }
-        else {
-            state.buildInfoCache.set(resolvedConfigPath, { path: toPath(state, buildInfoPath), buildInfo: buildInfo, modifiedTime: getCurrentTime(state.host) });
-        }
-    }
-    function getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath) {
-        var path = toPath(state, buildInfoPath);
-        var existing = state.buildInfoCache.get(resolvedConfigPath);
-        return (existing === null || existing === void 0 ? void 0 : existing.path) === path ? existing : undefined;
-    }
-    function getBuildInfo(state, buildInfoPath, resolvedConfigPath, modifiedTime) {
-        var path = toPath(state, buildInfoPath);
-        var existing = state.buildInfoCache.get(resolvedConfigPath);
-        if (existing !== undefined && existing.path === path) {
-            return existing.buildInfo || undefined;
-        }
-        var value = state.readFileWithCache(buildInfoPath);
-        var buildInfo = value ? ts.getBuildInfo(value) : undefined;
-        ts.Debug.assert(modifiedTime || !buildInfo);
-        state.buildInfoCache.set(resolvedConfigPath, { path: path, buildInfo: buildInfo || false, modifiedTime: modifiedTime || ts.missingFileModifiedTime });
-        return buildInfo;
-    }
     function checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName) {
-        var tsconfigTime = getModifiedTime(state, configFile);
+        var tsconfigTime = ts.getModifiedTime(state.host, configFile);
         if (oldestOutputFileTime < tsconfigTime) {
             return {
                 type: ts.UpToDateStatusType.OutOfDateWithSelf,
@@ -103350,22 +103277,76 @@ var ts;
         }
     }
     function getUpToDateStatusWorker(state, project, resolvedPath) {
-        var _a, _b, _c;
+        var force = !!state.options.force;
+        var newestInputFileName = undefined;
+        var newestInputFileTime = minimumDate;
+        var host = state.host;
+        for (var _i = 0, _a = project.fileNames; _i < _a.length; _i++) {
+            var inputFile = _a[_i];
+            if (!host.fileExists(inputFile)) {
+                return {
+                    type: ts.UpToDateStatusType.Unbuildable,
+                    reason: inputFile + " does not exist"
+                };
+            }
+            if (!force) {
+                var inputTime = ts.getModifiedTime(host, inputFile);
+                if (inputTime > newestInputFileTime) {
+                    newestInputFileName = inputFile;
+                    newestInputFileTime = inputTime;
+                }
+            }
+        }
         if (!project.fileNames.length && !ts.canJsonReportNoInputFiles(project.raw)) {
             return {
                 type: ts.UpToDateStatusType.ContainerOnly
             };
         }
-        var referenceStatuses;
-        var force = !!state.options.force;
+        var outputs = ts.getAllProjectOutputs(project, !host.useCaseSensitiveFileNames());
+        var oldestOutputFileName = "(none)";
+        var oldestOutputFileTime = maximumDate;
+        var newestOutputFileName = "(none)";
+        var newestOutputFileTime = minimumDate;
+        var missingOutputFileName;
+        var newestDeclarationFileContentChangedTime = minimumDate;
+        var isOutOfDateWithInputs = false;
+        if (!force) {
+            for (var _b = 0, outputs_1 = outputs; _b < outputs_1.length; _b++) {
+                var output = outputs_1[_b];
+                if (!host.fileExists(output)) {
+                    missingOutputFileName = output;
+                    break;
+                }
+                var outputTime = ts.getModifiedTime(host, output);
+                if (outputTime < oldestOutputFileTime) {
+                    oldestOutputFileTime = outputTime;
+                    oldestOutputFileName = output;
+                }
+                if (outputTime < newestInputFileTime) {
+                    isOutOfDateWithInputs = true;
+                    break;
+                }
+                if (outputTime > newestOutputFileTime) {
+                    newestOutputFileTime = outputTime;
+                    newestOutputFileName = output;
+                }
+                if (ts.isDeclarationFileName(output)) {
+                    var outputModifiedTime = ts.getModifiedTime(host, output);
+                    newestDeclarationFileContentChangedTime = newer(newestDeclarationFileContentChangedTime, outputModifiedTime);
+                }
+            }
+        }
+        var pseudoUpToDate = false;
+        var usesPrepend = false;
+        var upstreamChangedProject;
         if (project.projectReferences) {
             state.projectStatus.set(resolvedPath, { type: ts.UpToDateStatusType.ComputingUpstream });
-            for (var _i = 0, _d = project.projectReferences; _i < _d.length; _i++) {
-                var ref = _d[_i];
+            for (var _c = 0, _d = project.projectReferences; _c < _d.length; _c++) {
+                var ref = _d[_c];
+                usesPrepend = usesPrepend || !!(ref.prepend);
                 var resolvedRef = ts.resolveProjectReferencePath(ref);
                 var resolvedRefPath = toResolvedConfigFilePath(state, resolvedRef);
-                var resolvedConfig = parseConfigFile(state, resolvedRef, resolvedRefPath);
-                var refStatus = getUpToDateStatus(state, resolvedConfig, resolvedRefPath);
+                var refStatus = getUpToDateStatus(state, parseConfigFile(state, resolvedRef, resolvedRefPath), resolvedRefPath);
                 if (refStatus.type === ts.UpToDateStatusType.ComputingUpstream ||
                     refStatus.type === ts.UpToDateStatusType.ContainerOnly) {
                     continue;
@@ -103384,152 +103365,65 @@ var ts;
                         upstreamProjectName: ref.path
                     };
                 }
-                if (!force)
-                    (referenceStatuses || (referenceStatuses = [])).push({ ref: ref, refStatus: refStatus, resolvedRefPath: resolvedRefPath, resolvedConfig: resolvedConfig });
-            }
-        }
-        if (force)
-            return { type: ts.UpToDateStatusType.ForceBuild };
-        var host = state.host;
-        var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(project.options);
-        var oldestOutputFileName = "(none)";
-        var oldestOutputFileTime = maximumDate;
-        var buildInfoTime;
-        var newestDeclarationFileContentChangedTime;
-        if (buildInfoPath) {
-            var buildInfoCacheEntry_1 = getBuildInfoCacheEntry(state, buildInfoPath, resolvedPath);
-            buildInfoTime = (buildInfoCacheEntry_1 === null || buildInfoCacheEntry_1 === void 0 ? void 0 : buildInfoCacheEntry_1.modifiedTime) || ts.getModifiedTime(host, buildInfoPath);
-            if (buildInfoTime === ts.missingFileModifiedTime) {
-                if (!buildInfoCacheEntry_1) {
-                    state.buildInfoCache.set(resolvedPath, {
-                        path: toPath(state, buildInfoPath),
-                        buildInfo: false,
-                        modifiedTime: buildInfoTime
-                    });
-                }
-                return {
-                    type: ts.UpToDateStatusType.OutputMissing,
-                    missingOutputFileName: buildInfoPath
-                };
-            }
-            var buildInfo = ts.Debug.checkDefined(getBuildInfo(state, buildInfoPath, resolvedPath, buildInfoTime));
-            if ((buildInfo.bundle || buildInfo.program) && buildInfo.version !== ts.version) {
-                return {
-                    type: ts.UpToDateStatusType.TsVersionOutputOfDate,
-                    version: buildInfo.version
-                };
-            }
-            if (buildInfo.program) {
-                if (((_a = buildInfo.program.changeFileSet) === null || _a === void 0 ? void 0 : _a.length) ||
-                    (!project.options.noEmit && ((_b = buildInfo.program.affectedFilesPendingEmit) === null || _b === void 0 ? void 0 : _b.length))) {
+                if (!force && !missingOutputFileName) {
+                    if (refStatus.newestInputFileTime && refStatus.newestInputFileTime <= oldestOutputFileTime) {
+                        continue;
+                    }
+                    if (refStatus.newestDeclarationFileContentChangedTime && refStatus.newestDeclarationFileContentChangedTime <= oldestOutputFileTime) {
+                        pseudoUpToDate = true;
+                        upstreamChangedProject = ref.path;
+                        continue;
+                    }
+                    ts.Debug.assert(oldestOutputFileName !== undefined, "Should have an oldest output filename here");
                     return {
-                        type: ts.UpToDateStatusType.OutOfDateBuildInfo,
-                        buildInfoFile: buildInfoPath
+                        type: ts.UpToDateStatusType.OutOfDateWithUpstream,
+                        outOfDateOutputFileName: oldestOutputFileName,
+                        newerProjectName: ref.path
                     };
                 }
             }
-            oldestOutputFileTime = buildInfoTime;
-            oldestOutputFileName = buildInfoPath;
-            newestDeclarationFileContentChangedTime = ((_c = buildInfo.program) === null || _c === void 0 ? void 0 : _c.dtsChangeTime) ? new Date(buildInfo.program.dtsChangeTime) : undefined;
         }
-        var newestInputFileName = undefined;
-        var newestInputFileTime = minimumDate;
-        for (var _e = 0, _f = project.fileNames; _e < _f.length; _e++) {
-            var inputFile = _f[_e];
-            var inputTime = getModifiedTime(state, inputFile);
-            if (inputTime === ts.missingFileModifiedTime) {
-                return {
-                    type: ts.UpToDateStatusType.Unbuildable,
-                    reason: inputFile + " does not exist"
-                };
-            }
-            if (buildInfoTime && buildInfoTime < inputTime) {
-                return {
-                    type: ts.UpToDateStatusType.OutOfDateWithSelf,
-                    outOfDateOutputFileName: buildInfoPath,
-                    newerInputFileName: inputFile
-                };
-            }
-            if (inputTime > newestInputFileTime) {
-                newestInputFileName = inputFile;
-                newestInputFileTime = inputTime;
-            }
+        if (missingOutputFileName !== undefined) {
+            return {
+                type: ts.UpToDateStatusType.OutputMissing,
+                missingOutputFileName: missingOutputFileName
+            };
         }
-        if (!buildInfoPath) {
-            var outputs = ts.getAllProjectOutputs(project, !host.useCaseSensitiveFileNames());
-            var outputTimeStampMap = getOutputTimeStampMap(state, resolvedPath);
-            for (var _g = 0, outputs_1 = outputs; _g < outputs_1.length; _g++) {
-                var output = outputs_1[_g];
-                var path = toPath(state, output);
-                var outputTime = outputTimeStampMap === null || outputTimeStampMap === void 0 ? void 0 : outputTimeStampMap.get(path);
-                if (!outputTime) {
-                    outputTime = ts.getModifiedTime(state.host, output);
-                    outputTimeStampMap === null || outputTimeStampMap === void 0 ? void 0 : outputTimeStampMap.set(path, outputTime);
-                }
-                if (outputTime === ts.missingFileModifiedTime) {
-                    return {
-                        type: ts.UpToDateStatusType.OutputMissing,
-                        missingOutputFileName: output
-                    };
-                }
-                if (outputTime < oldestOutputFileTime) {
-                    oldestOutputFileTime = outputTime;
-                    oldestOutputFileName = output;
-                }
-                if (outputTime < newestInputFileTime) {
-                    return {
-                        type: ts.UpToDateStatusType.OutOfDateWithSelf,
-                        outOfDateOutputFileName: oldestOutputFileName,
-                        newerInputFileName: newestInputFileName
-                    };
-                }
-            }
+        if (isOutOfDateWithInputs) {
+            return {
+                type: ts.UpToDateStatusType.OutOfDateWithSelf,
+                outOfDateOutputFileName: oldestOutputFileName,
+                newerInputFileName: newestInputFileName
+            };
         }
-        var seenRefs = buildInfoPath ? new ts.Set() : undefined;
-        var buildInfoCacheEntry = state.buildInfoCache.get(resolvedPath);
-        seenRefs === null || seenRefs === void 0 ? void 0 : seenRefs.add(resolvedPath);
-        var pseudoUpToDate = false;
-        var usesPrepend = false;
-        var upstreamChangedProject;
-        if (referenceStatuses) {
-            for (var _h = 0, referenceStatuses_1 = referenceStatuses; _h < referenceStatuses_1.length; _h++) {
-                var _j = referenceStatuses_1[_h], ref = _j.ref, refStatus = _j.refStatus, resolvedConfig = _j.resolvedConfig, resolvedRefPath = _j.resolvedRefPath;
-                usesPrepend = usesPrepend || !!(ref.prepend);
-                if (refStatus.newestInputFileTime && refStatus.newestInputFileTime <= oldestOutputFileTime) {
-                    continue;
-                }
-                if (buildInfoCacheEntry && hasSameBuildInfo(state, buildInfoCacheEntry, seenRefs, resolvedConfig, resolvedRefPath)) {
+        else {
+            var configStatus = checkConfigFileUpToDateStatus(state, project.options.configFilePath, oldestOutputFileTime, oldestOutputFileName);
+            if (configStatus)
+                return configStatus;
+            var extendedConfigStatus = ts.forEach(project.options.configFile.extendedSourceFiles || ts.emptyArray, function (configFile) { return checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName); });
+            if (extendedConfigStatus)
+                return extendedConfigStatus;
+            var dependentPackageFileStatus = ts.forEach(state.lastCachedPackageJsonLookups.get(resolvedPath) || ts.emptyArray, function (_a) {
+                var path = _a[0];
+                return checkConfigFileUpToDateStatus(state, path, oldestOutputFileTime, oldestOutputFileName);
+            });
+            if (dependentPackageFileStatus)
+                return dependentPackageFileStatus;
+        }
+        if (!force && !state.buildInfoChecked.has(resolvedPath)) {
+            state.buildInfoChecked.set(resolvedPath, true);
+            var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(project.options);
+            if (buildInfoPath) {
+                var value = state.readFileWithCache(buildInfoPath);
+                var buildInfo = value && ts.getBuildInfo(value);
+                if (buildInfo && (buildInfo.bundle || buildInfo.program) && buildInfo.version !== ts.version) {
                     return {
-                        type: ts.UpToDateStatusType.OutOfDateWithUpstream,
-                        outOfDateOutputFileName: buildInfoPath,
-                        newerProjectName: ref.path
+                        type: ts.UpToDateStatusType.TsVersionOutputOfDate,
+                        version: buildInfo.version
                     };
                 }
-                if (refStatus.newestDeclarationFileContentChangedTime && refStatus.newestDeclarationFileContentChangedTime <= oldestOutputFileTime) {
-                    pseudoUpToDate = true;
-                    upstreamChangedProject = ref.path;
-                    continue;
-                }
-                ts.Debug.assert(oldestOutputFileName !== undefined, "Should have an oldest output filename here");
-                return {
-                    type: ts.UpToDateStatusType.OutOfDateWithUpstream,
-                    outOfDateOutputFileName: oldestOutputFileName,
-                    newerProjectName: ref.path
-                };
             }
         }
-        var configStatus = checkConfigFileUpToDateStatus(state, project.options.configFilePath, oldestOutputFileTime, oldestOutputFileName);
-        if (configStatus)
-            return configStatus;
-        var extendedConfigStatus = ts.forEach(project.options.configFile.extendedSourceFiles || ts.emptyArray, function (configFile) { return checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName); });
-        if (extendedConfigStatus)
-            return extendedConfigStatus;
-        var dependentPackageFileStatus = ts.forEach(state.lastCachedPackageJsonLookups.get(resolvedPath) || ts.emptyArray, function (_a) {
-            var path = _a[0];
-            return checkConfigFileUpToDateStatus(state, path, oldestOutputFileTime, oldestOutputFileName);
-        });
-        if (dependentPackageFileStatus)
-            return dependentPackageFileStatus;
         if (usesPrepend && pseudoUpToDate) {
             return {
                 type: ts.UpToDateStatusType.OutOfDateWithPrepend,
@@ -103541,29 +103435,12 @@ var ts;
             type: pseudoUpToDate ? ts.UpToDateStatusType.UpToDateWithUpstreamTypes : ts.UpToDateStatusType.UpToDate,
             newestDeclarationFileContentChangedTime: newestDeclarationFileContentChangedTime,
             newestInputFileTime: newestInputFileTime,
+            newestOutputFileTime: newestOutputFileTime,
             newestInputFileName: newestInputFileName,
+            newestOutputFileName: newestOutputFileName,
             oldestOutputFileName: oldestOutputFileName
         };
     }
-    function hasSameBuildInfo(state, buildInfoCacheEntry, seenRefs, resolvedConfig, resolvedRefPath) {
-        if (seenRefs.has(resolvedRefPath))
-            return false;
-        seenRefs.add(resolvedRefPath);
-        var refBuildInfo = state.buildInfoCache.get(resolvedRefPath);
-        if (refBuildInfo.path === buildInfoCacheEntry.path)
-            return true;
-        if (resolvedConfig.projectReferences) {
-            for (var _i = 0, _a = resolvedConfig.projectReferences; _i < _a.length; _i++) {
-                var ref = _a[_i];
-                var resolvedRef = ts.resolveProjectReferencePath(ref);
-                var resolvedRefPath_1 = toResolvedConfigFilePath(state, resolvedRef);
-                var resolvedConfig_1 = parseConfigFile(state, resolvedRef, resolvedRefPath_1);
-                if (hasSameBuildInfo(state, buildInfoCacheEntry, seenRefs, resolvedConfig_1, resolvedRefPath_1))
-                    return true;
-            }
-        }
-        return false;
-    }
     function getUpToDateStatus(state, project, resolvedPath) {
         if (project === undefined) {
             return { type: ts.UpToDateStatusType.Unbuildable, reason: "File deleted mid-build" };
@@ -103576,64 +103453,39 @@ var ts;
         state.projectStatus.set(resolvedPath, actual);
         return actual;
     }
-    function updateOutputTimestampsWorker(state, proj, projectPath, verboseMessage, skipOutputs) {
+    function updateOutputTimestampsWorker(state, proj, priorNewestUpdateTime, verboseMessage, skipOutputs) {
         if (proj.options.noEmit)
-            return;
-        var now;
-        var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(proj.options);
-        if (buildInfoPath) {
-            if (!(skipOutputs === null || skipOutputs === void 0 ? void 0 : skipOutputs.has(toPath(state, buildInfoPath)))) {
-                if (!!state.options.verbose)
-                    reportStatus(state, verboseMessage, proj.options.configFilePath);
-                state.host.setModifiedTime(buildInfoPath, now = getCurrentTime(state.host));
-                getBuildInfoCacheEntry(state, buildInfoPath, projectPath).modifiedTime = now;
-            }
-            state.outputTimeStamps.delete(projectPath);
-            return;
-        }
+            return priorNewestUpdateTime;
         var host = state.host;
         var outputs = ts.getAllProjectOutputs(proj, !host.useCaseSensitiveFileNames());
-        var outputTimeStampMap = getOutputTimeStampMap(state, projectPath);
-        var modifiedOutputs = outputTimeStampMap ? new ts.Set() : undefined;
         if (!skipOutputs || outputs.length !== skipOutputs.size) {
             var reportVerbose = !!state.options.verbose;
+            var now = host.now ? host.now() : new Date();
             for (var _i = 0, outputs_2 = outputs; _i < outputs_2.length; _i++) {
                 var file = outputs_2[_i];
-                var path = toPath(state, file);
-                if (skipOutputs === null || skipOutputs === void 0 ? void 0 : skipOutputs.has(path))
+                if (skipOutputs && skipOutputs.has(toPath(state, file))) {
                     continue;
+                }
                 if (reportVerbose) {
                     reportVerbose = false;
                     reportStatus(state, verboseMessage, proj.options.configFilePath);
                 }
-                host.setModifiedTime(file, now || (now = getCurrentTime(state.host)));
-                if (outputTimeStampMap) {
-                    outputTimeStampMap.set(path, now);
-                    modifiedOutputs.add(path);
+                if (ts.isDeclarationFileName(file)) {
+                    priorNewestUpdateTime = newer(priorNewestUpdateTime, ts.getModifiedTime(host, file));
                 }
+                host.setModifiedTime(file, now);
             }
         }
-        outputTimeStampMap === null || outputTimeStampMap === void 0 ? void 0 : outputTimeStampMap.forEach(function (_value, key) {
-            if (!(skipOutputs === null || skipOutputs === void 0 ? void 0 : skipOutputs.has(key)) && !modifiedOutputs.has(key))
-                outputTimeStampMap.delete(key);
-        });
-    }
-    function getDtsChangeTime(state, options, resolvedConfigPath) {
-        var _a;
-        if (!options.composite)
-            return undefined;
-        var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(options);
-        var buildInfo = getBuildInfo(state, buildInfoPath, resolvedConfigPath, undefined);
-        return ((_a = buildInfo === null || buildInfo === void 0 ? void 0 : buildInfo.program) === null || _a === void 0 ? void 0 : _a.dtsChangeTime) ? new Date(buildInfo.program.dtsChangeTime) : undefined;
+        return priorNewestUpdateTime;
     }
     function updateOutputTimestamps(state, proj, resolvedPath) {
         if (state.options.dry) {
             return reportStatus(state, ts.Diagnostics.A_non_dry_build_would_update_timestamps_for_output_of_project_0, proj.options.configFilePath);
         }
-        updateOutputTimestampsWorker(state, proj, resolvedPath, ts.Diagnostics.Updating_output_timestamps_of_project_0);
+        var priorNewestUpdateTime = updateOutputTimestampsWorker(state, proj, minimumDate, ts.Diagnostics.Updating_output_timestamps_of_project_0);
         state.projectStatus.set(resolvedPath, {
             type: ts.UpToDateStatusType.UpToDate,
-            newestDeclarationFileContentChangedTime: getDtsChangeTime(state, proj.options, resolvedPath),
+            newestDeclarationFileContentChangedTime: priorNewestUpdateTime,
             oldestOutputFileName: ts.getFirstProjectOutput(proj, !state.host.useCaseSensitiveFileNames())
         });
     }
@@ -103815,10 +103667,12 @@ var ts;
     function watchConfigFile(state, resolved, resolvedPath, parsed) {
         if (!state.watch || state.allWatchedConfigFiles.has(resolvedPath))
             return;
-        state.allWatchedConfigFiles.set(resolvedPath, watchFile(state, resolved, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.Full); }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.ConfigFile, resolved));
+        state.allWatchedConfigFiles.set(resolvedPath, state.watchFile(resolved, function () {
+            invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.Full);
+        }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.ConfigFile, resolved));
     }
     function watchExtendedConfigFiles(state, resolvedPath, parsed) {
-        ts.updateSharedExtendedConfigFileWatcher(resolvedPath, parsed === null || parsed === void 0 ? void 0 : parsed.options, state.allWatchedExtendedConfigFiles, function (extendedConfigFileName, extendedConfigFilePath) { return watchFile(state, extendedConfigFileName, function () {
+        ts.updateSharedExtendedConfigFileWatcher(resolvedPath, parsed === null || parsed === void 0 ? void 0 : parsed.options, state.allWatchedExtendedConfigFiles, function (extendedConfigFileName, extendedConfigFilePath) { return state.watchFile(extendedConfigFileName, function () {
             var _a;
             return (_a = state.allWatchedExtendedConfigFiles.get(extendedConfigFilePath)) === null || _a === void 0 ? void 0 : _a.projects.forEach(function (projectConfigFilePath) {
                 return invalidateProjectAndScheduleBuilds(state, projectConfigFilePath, ts.ConfigFileProgramReloadLevel.Full);
@@ -103850,7 +103704,7 @@ var ts;
         if (!state.watch)
             return;
         ts.mutateMap(getOrCreateValueMapFromConfigFileMap(state.allWatchedInputFiles, resolvedPath), ts.arrayToMap(parsed.fileNames, function (fileName) { return toPath(state, fileName); }), {
-            createNewValue: function (_path, input) { return watchFile(state, input, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.None); }, ts.PollingInterval.Low, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.SourceFile, resolved); },
+            createNewValue: function (_path, input) { return state.watchFile(input, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.None); }, ts.PollingInterval.Low, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.SourceFile, resolved); },
             onDeleteValue: ts.closeFileWatcher,
         });
     }
@@ -103858,7 +103712,7 @@ var ts;
         if (!state.watch || !state.lastCachedPackageJsonLookups)
             return;
         ts.mutateMap(getOrCreateValueMapFromConfigFileMap(state.allWatchedPackageJsonFiles, resolvedPath), new ts.Map(state.lastCachedPackageJsonLookups.get(resolvedPath)), {
-            createNewValue: function (path, _input) { return watchFile(state, path, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.Full); }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.PackageJson, resolved); },
+            createNewValue: function (path, _input) { return state.watchFile(path, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.None); }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.PackageJson, resolved); },
             onDeleteValue: ts.closeFileWatcher,
         });
     }
@@ -103982,18 +103836,19 @@ var ts;
         }
     }
     function reportUpToDateStatus(state, configFileName, status) {
+        if (state.options.force && (status.type === ts.UpToDateStatusType.UpToDate || status.type === ts.UpToDateStatusType.UpToDateWithUpstreamTypes)) {
+            return reportStatus(state, ts.Diagnostics.Project_0_is_being_forcibly_rebuilt, relName(state, configFileName));
+        }
         switch (status.type) {
             case ts.UpToDateStatusType.OutOfDateWithSelf:
-                return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_1_is_older_than_input_2, relName(state, configFileName), relName(state, status.outOfDateOutputFileName), relName(state, status.newerInputFileName));
+                return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, relName(state, configFileName), relName(state, status.outOfDateOutputFileName), relName(state, status.newerInputFileName));
             case ts.UpToDateStatusType.OutOfDateWithUpstream:
-                return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_1_is_older_than_input_2, relName(state, configFileName), relName(state, status.outOfDateOutputFileName), relName(state, status.newerProjectName));
+                return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2, relName(state, configFileName), relName(state, status.outOfDateOutputFileName), relName(state, status.newerProjectName));
             case ts.UpToDateStatusType.OutputMissing:
                 return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, relName(state, configFileName), relName(state, status.missingOutputFileName));
-            case ts.UpToDateStatusType.OutOfDateBuildInfo:
-                return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_are_not_emitted, relName(state, configFileName), relName(state, status.buildInfoFile));
             case ts.UpToDateStatusType.UpToDate:
                 if (status.newestInputFileTime !== undefined) {
-                    return reportStatus(state, ts.Diagnostics.Project_0_is_up_to_date_because_newest_input_1_is_older_than_output_2, relName(state, configFileName), relName(state, status.newestInputFileName || ""), relName(state, status.oldestOutputFileName || ""));
+                    return reportStatus(state, ts.Diagnostics.Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2, relName(state, configFileName), relName(state, status.newestInputFileName || ""), relName(state, status.oldestOutputFileName || ""));
                 }
                 break;
             case ts.UpToDateStatusType.OutOfDateWithPrepend:
@@ -104010,8 +103865,6 @@ var ts;
                 return reportStatus(state, ts.Diagnostics.Failed_to_parse_file_0_Colon_1, relName(state, configFileName), status.reason);
             case ts.UpToDateStatusType.TsVersionOutputOfDate:
                 return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_current_version_2, relName(state, configFileName), status.version, ts.version);
-            case ts.UpToDateStatusType.ForceBuild:
-                return reportStatus(state, ts.Diagnostics.Project_0_is_being_forcibly_rebuilt, relName(state, configFileName));
             case ts.UpToDateStatusType.ContainerOnly:
             case ts.UpToDateStatusType.ComputingUpstream:
                 break;