typescript 4.9.1-beta → 5.0.0-dev.20221101

package/lib/typingsInstaller.js

@@ -85,11 +85,11 @@ var ts;
 (function (ts) {
     // WARNING: The script `configurePrerelease.ts` uses a regexp to parse out these values.
     // If changing the text in this section, be sure to test `configurePrerelease` too.
-    ts.versionMajorMinor = "4.9";
+    ts.versionMajorMinor = "5.0";
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = "".concat(ts.versionMajorMinor, ".1-beta");
+    ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221101");
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -1881,8 +1881,8 @@ var ts;
         return compareValues(a === null || a === void 0 ? void 0 : a.start, b === null || b === void 0 ? void 0 : b.start) || compareValues(a === null || a === void 0 ? void 0 : a.length, b === null || b === void 0 ? void 0 : b.length);
     }
     ts.compareTextSpans = compareTextSpans;
-    function min(a, b, compare) {
-        return compare(a, b) === -1 /* Comparison.LessThan */ ? a : b;
+    function min(items, compare) {
+        return reduceLeft(items, function (x, y) { return compare(x, y) === -1 /* Comparison.LessThan */ ? x : y; });
     }
     ts.min = min;
     /**
@@ -3195,11 +3195,13 @@ var ts;
     // > alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty. Numeric identifiers
     // > MUST NOT include leading zeroes.
     var prereleaseRegExp = /^(?:0|[1-9]\d*|[a-z-][a-z0-9-]*)(?:\.(?:0|[1-9]\d*|[a-z-][a-z0-9-]*))*$/i;
+    var prereleasePartRegExp = /^(?:0|[1-9]\d*|[a-z-][a-z0-9-]*)$/i;
     // https://semver.org/#spec-item-10
     // > Build metadata MAY be denoted by appending a plus sign and a series of dot separated
     // > identifiers immediately following the patch or pre-release version. Identifiers MUST
     // > comprise only ASCII alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty.
     var buildRegExp = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*$/i;
+    var buildPartRegExp = /^[a-z0-9-]+$/i;
     // https://semver.org/#spec-item-9
     // > Numeric identifiers MUST NOT include leading zeroes.
     var numericIdentifierRegExp = /^(0|[1-9]\d*)$/;
@@ -3219,13 +3221,15 @@ var ts;
             ts.Debug.assert(major >= 0, "Invalid argument: major");
             ts.Debug.assert(minor >= 0, "Invalid argument: minor");
             ts.Debug.assert(patch >= 0, "Invalid argument: patch");
-            ts.Debug.assert(!prerelease || prereleaseRegExp.test(prerelease), "Invalid argument: prerelease");
-            ts.Debug.assert(!build || buildRegExp.test(build), "Invalid argument: build");
+            var prereleaseArray = prerelease ? ts.isArray(prerelease) ? prerelease : prerelease.split(".") : ts.emptyArray;
+            var buildArray = build ? ts.isArray(build) ? build : build.split(".") : ts.emptyArray;
+            ts.Debug.assert(ts.every(prereleaseArray, function (s) { return prereleasePartRegExp.test(s); }), "Invalid argument: prerelease");
+            ts.Debug.assert(ts.every(buildArray, function (s) { return buildPartRegExp.test(s); }), "Invalid argument: build");
             this.major = major;
             this.minor = minor;
             this.patch = patch;
-            this.prerelease = prerelease ? prerelease.split(".") : ts.emptyArray;
-            this.build = build ? build.split(".") : ts.emptyArray;
+            this.prerelease = prereleaseArray;
+            this.build = buildArray;
         }
         Version.tryParse = function (text) {
             var result = tryParseComponents(text);
@@ -3264,6 +3268,10 @@ var ts;
                 default: return ts.Debug.assertNever(field);
             }
         };
+        Version.prototype.with = function (fields) {
+            var _a = fields.major, major = _a === void 0 ? this.major : _a, _b = fields.minor, minor = _b === void 0 ? this.minor : _b, _c = fields.patch, patch = _c === void 0 ? this.patch : _c, _d = fields.prerelease, prerelease = _d === void 0 ? this.prerelease : _d, _e = fields.build, build = _e === void 0 ? this.build : _e;
+            return new Version(major, minor, patch, prerelease, build);
+        };
         Version.prototype.toString = function () {
             var result = "".concat(this.major, ".").concat(this.minor, ".").concat(this.patch);
             if (ts.some(this.prerelease))
@@ -3272,7 +3280,7 @@ var ts;
                 result += "+".concat(this.build.join("."));
             return result;
         };
-        Version.zero = new Version(0, 0, 0);
+        Version.zero = new Version(0, 0, 0, ["0"]);
         return Version;
     }());
     ts.Version = Version;
@@ -3355,6 +3363,10 @@ var ts;
             }
             return undefined;
         };
+        /**
+         * Tests whether a version matches the range. This is equivalent to `satisfies(version, range, { includePrerelease: true })`.
+         * in `node-semver`.
+         */
         VersionRange.prototype.test = function (version) {
             if (typeof version === "string")
                 version = new Version(version);
@@ -3465,19 +3477,20 @@ var ts;
                     break;
                 case "<":
                 case ">=":
-                    comparators.push(createComparator(operator, version));
+                    comparators.push(isWildcard(minor) || isWildcard(patch) ? createComparator(operator, version.with({ prerelease: "0" })) :
+                        createComparator(operator, version));
                     break;
                 case "<=":
                 case ">":
-                    comparators.push(isWildcard(minor) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("major")) :
-                        isWildcard(patch) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("minor")) :
+                    comparators.push(isWildcard(minor) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("major").with({ prerelease: "0" })) :
+                        isWildcard(patch) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("minor").with({ prerelease: "0" })) :
                             createComparator(operator, version));
                     break;
                 case "=":
                 case undefined:
                     if (isWildcard(minor) || isWildcard(patch)) {
-                        comparators.push(createComparator(">=", version));
-                        comparators.push(createComparator("<", version.increment(isWildcard(minor) ? "major" : "minor")));
+                        comparators.push(createComparator(">=", version.with({ prerelease: "0" })));
+                        comparators.push(createComparator("<", version.increment(isWildcard(minor) ? "major" : "minor").with({ prerelease: "0" })));
                     }
                     else {
                         comparators.push(createComparator("=", version));
@@ -5086,8 +5099,8 @@ var ts;
         NodeCheckFlags[NodeCheckFlags["SuperInstance"] = 256] = "SuperInstance";
         NodeCheckFlags[NodeCheckFlags["SuperStatic"] = 512] = "SuperStatic";
         NodeCheckFlags[NodeCheckFlags["ContextChecked"] = 1024] = "ContextChecked";
-        NodeCheckFlags[NodeCheckFlags["AsyncMethodWithSuper"] = 2048] = "AsyncMethodWithSuper";
-        NodeCheckFlags[NodeCheckFlags["AsyncMethodWithSuperBinding"] = 4096] = "AsyncMethodWithSuperBinding";
+        NodeCheckFlags[NodeCheckFlags["MethodWithSuperPropertyAccessInAsync"] = 2048] = "MethodWithSuperPropertyAccessInAsync";
+        NodeCheckFlags[NodeCheckFlags["MethodWithSuperPropertyAssignmentInAsync"] = 4096] = "MethodWithSuperPropertyAssignmentInAsync";
         NodeCheckFlags[NodeCheckFlags["CaptureArguments"] = 8192] = "CaptureArguments";
         NodeCheckFlags[NodeCheckFlags["EnumValuesComputed"] = 16384] = "EnumValuesComputed";
         NodeCheckFlags[NodeCheckFlags["LexicalModuleMergesWithClass"] = 32768] = "LexicalModuleMergesWithClass";
@@ -6722,7 +6735,7 @@ var ts;
     }
     /*@internal*/
     function createSystemWatchFunctions(_a) {
-        var pollingWatchFileWorker = _a.pollingWatchFileWorker, 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 pollingWatchFileWorker = _a.pollingWatchFileWorker, 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, inodeWatching = _a.inodeWatching, sysLog = _a.sysLog;
         var pollingWatches = new ts.Map();
         var fsWatches = new ts.Map();
         var fsWatchesRecursive = new ts.Map();
@@ -6788,8 +6801,8 @@ var ts;
                     return useNonPollingWatchers ?
                         // Use notifications from FS to watch with falling back to fs.watchFile
                         generateWatchFileOptions(ts.WatchFileKind.UseFsEventsOnParentDirectory, ts.PollingWatchKind.PriorityInterval, options) :
-                        // Default to do not use fixed polling interval
-                        { watchFile: (defaultWatchFileKind === null || defaultWatchFileKind === void 0 ? void 0 : defaultWatchFileKind()) || ts.WatchFileKind.UseFsEvents };
+                        // Default to using fs events
+                        { watchFile: ts.WatchFileKind.UseFsEvents };
             }
         }
         function generateWatchFileOptions(watchFile, fallbackPolling, options) {
@@ -7061,7 +7074,6 @@ var ts;
                 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 = _b.watchFile, watchDirectory = _b.watchDirectory;
@@ -9572,6 +9584,10 @@ var ts;
         Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_were_not_emitted: diag(6399, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_were_not_emitte_6399", "Project '{0}' is out of date because buildinfo file '{1}' indicates that some of the changes were not emitted"),
         Project_0_is_up_to_date_but_needs_to_update_timestamps_of_output_files_that_are_older_than_input_files: diag(6400, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_but_needs_to_update_timestamps_of_output_files_that_are_older_than_input_fil_6400", "Project '{0}' is up to date but needs to update timestamps of output files that are older than input files"),
         Project_0_is_out_of_date_because_there_was_error_reading_file_1: diag(6401, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_there_was_error_reading_file_1_6401", "Project '{0}' is out of date because there was error reading file '{1}'"),
+        Resolving_in_0_mode_with_conditions_1: diag(6402, ts.DiagnosticCategory.Message, "Resolving_in_0_mode_with_conditions_1_6402", "Resolving in {0} mode with conditions {1}."),
+        Matched_0_condition_1: diag(6403, ts.DiagnosticCategory.Message, "Matched_0_condition_1_6403", "Matched '{0}' condition '{1}'."),
+        Using_0_subpath_1_with_target_2: diag(6404, ts.DiagnosticCategory.Message, "Using_0_subpath_1_with_target_2_6404", "Using '{0}' subpath '{1}' with target '{2}'."),
+        Saw_non_matching_condition_0: diag(6405, ts.DiagnosticCategory.Message, "Saw_non_matching_condition_0_6405", "Saw non-matching condition '{0}'."),
         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."),
@@ -9888,6 +9904,8 @@ var ts;
         Remove_type_from_import_of_0_from_1: diag(90056, ts.DiagnosticCategory.Message, "Remove_type_from_import_of_0_from_1_90056", "Remove 'type' from import of '{0}' from \"{1}\""),
         Add_import_from_0: diag(90057, ts.DiagnosticCategory.Message, "Add_import_from_0_90057", "Add import from \"{0}\""),
         Update_import_from_0: diag(90058, ts.DiagnosticCategory.Message, "Update_import_from_0_90058", "Update import from \"{0}\""),
+        Export_0_from_module_1: diag(90059, ts.DiagnosticCategory.Message, "Export_0_from_module_1_90059", "Export '{0}' from module '{1}'"),
+        Export_all_referenced_locals: diag(90060, ts.DiagnosticCategory.Message, "Export_all_referenced_locals_90060", "Export all referenced locals"),
         Convert_function_to_an_ES2015_class: diag(95001, ts.DiagnosticCategory.Message, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"),
         Convert_0_to_1_in_0: diag(95003, ts.DiagnosticCategory.Message, "Convert_0_to_1_in_0_95003", "Convert '{0}' to '{1} in {0}'"),
         Extract_to_0_in_1: diag(95004, ts.DiagnosticCategory.Message, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"),
@@ -11345,7 +11363,7 @@ var ts;
             return -1;
         }
         function peekExtendedUnicodeEscape() {
-            if (languageVersion >= 2 /* ScriptTarget.ES2015 */ && codePointAt(text, pos + 1) === 117 /* CharacterCodes.u */ && codePointAt(text, pos + 2) === 123 /* CharacterCodes.openBrace */) {
+            if (codePointAt(text, pos + 1) === 117 /* CharacterCodes.u */ && codePointAt(text, pos + 2) === 123 /* CharacterCodes.openBrace */) {
                 var start_2 = pos;
                 pos += 3;
                 var escapedValueString = scanMinimumNumberOfHexDigits(1, /*canHaveSeparators*/ false);
@@ -21648,6 +21666,32 @@ var ts;
         return parameter.kind === 343 /* SyntaxKind.JSDocParameterTag */ ? (_a = parameter.typeExpression) === null || _a === void 0 ? void 0 : _a.type : parameter.type;
     }
     ts.getParameterTypeNode = getParameterTypeNode;
+    function isTypeDeclaration(node) {
+        switch (node.kind) {
+            case 165 /* SyntaxKind.TypeParameter */:
+            case 260 /* SyntaxKind.ClassDeclaration */:
+            case 261 /* SyntaxKind.InterfaceDeclaration */:
+            case 262 /* SyntaxKind.TypeAliasDeclaration */:
+            case 263 /* SyntaxKind.EnumDeclaration */:
+            case 348 /* SyntaxKind.JSDocTypedefTag */:
+            case 341 /* SyntaxKind.JSDocCallbackTag */:
+            case 342 /* SyntaxKind.JSDocEnumTag */:
+                return true;
+            case 270 /* SyntaxKind.ImportClause */:
+                return node.isTypeOnly;
+            case 273 /* SyntaxKind.ImportSpecifier */:
+            case 278 /* SyntaxKind.ExportSpecifier */:
+                return node.parent.parent.isTypeOnly;
+            default:
+                return false;
+        }
+    }
+    ts.isTypeDeclaration = isTypeDeclaration;
+    function canHaveExportModifier(node) {
+        return ts.isEnumDeclaration(node) || ts.isVariableStatement(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)
+            || ts.isInterfaceDeclaration(node) || isTypeDeclaration(node) || (ts.isModuleDeclaration(node) && !isExternalModuleAugmentation(node) && !isGlobalScopeAugmentation(node));
+    }
+    ts.canHaveExportModifier = canHaveExportModifier;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
@@ -21656,13 +21700,11 @@ var ts;
      * Creates a `BaseNodeFactory` which can be used to create `Node` instances from the constructors provided by the object allocator.
      */
     function createBaseNodeFactory() {
-        // tslint:disable variable-name
         var NodeConstructor;
         var TokenConstructor;
         var IdentifierConstructor;
         var PrivateIdentifierConstructor;
         var SourceFileConstructor;
-        // tslint:enable variable-name
         return {
             createBaseSourceFileNode: createBaseSourceFileNode,
             createBaseIdentifierNode: createBaseIdentifierNode,
@@ -23126,7 +23168,7 @@ var ts;
             return node;
         }
         // @api
-        function createIdentifier(text, typeArguments, originalKeywordKind) {
+        function createIdentifier(text, typeArguments, originalKeywordKind, hasExtendedUnicodeEscape) {
             var node = createBaseIdentifier(text, originalKeywordKind);
             if (typeArguments) {
                 // NOTE: we do not use `setChildren` here because typeArguments in an identifier do not contribute to transformations
@@ -23135,6 +23177,10 @@ var ts;
             if (node.originalKeywordKind === 133 /* SyntaxKind.AwaitKeyword */) {
                 node.transformFlags |= 67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */;
             }
+            if (hasExtendedUnicodeEscape) {
+                node.hasExtendedUnicodeEscape = hasExtendedUnicodeEscape;
+                node.transformFlags |= 1024 /* TransformFlags.ContainsES2015 */;
+            }
             return node;
         }
         // @api
@@ -27590,11 +27636,9 @@ var ts;
                 rawTextScanner.setText("`" + rawText + "`");
                 break;
             case 15 /* SyntaxKind.TemplateHead */:
-                // tslint:disable-next-line no-invalid-template-strings
                 rawTextScanner.setText("`" + rawText + "${");
                 break;
             case 16 /* SyntaxKind.TemplateMiddle */:
-                // tslint:disable-next-line no-invalid-template-strings
                 rawTextScanner.setText("}" + rawText + "${");
                 break;
             case 17 /* SyntaxKind.TemplateTail */:
@@ -27953,7 +27997,6 @@ var ts;
         return node;
     }
     ts.createInputFiles = createInputFiles;
-    // tslint:disable-next-line variable-name
     var SourceMapSource;
     /**
      * Create an external source map source file reference
@@ -28745,6 +28788,8 @@ var ts;
     //          - The verb (`next`, `throw`, or `return` method) to delegate to the expression
     //            of a `yield*`.
     //          - The result of evaluating the verb delegated to the expression of a `yield*`.
+    //  g       A temporary variable that holds onto the generator object until the generator
+    //          is started, allowing it to also act as the `suspendedStart` state.
     //
     // functions:
     //  verb(n)     Creates a bound callback to the `step` function for opcode `n`.
@@ -28783,7 +28828,7 @@ var ts;
         importName: "__generator",
         scoped: false,
         priority: 6,
-        text: "\n            var __generator = (this && this.__generator) || function (thisArg, body) {\n                var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n                return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n                function verb(n) { return function (v) { return step([n, v]); }; }\n                function step(op) {\n                    if (f) throw new TypeError(\"Generator is already executing.\");\n                    while (_) try {\n                        if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n                        if (y = 0, t) op = [op[0] & 2, t.value];\n                        switch (op[0]) {\n                            case 0: case 1: t = op; break;\n                            case 4: _.label++; return { value: op[1], done: false };\n                            case 5: _.label++; y = op[1]; op = [0]; continue;\n                            case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                            default:\n                                if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                                if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                                if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                                if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                                if (t[2]) _.ops.pop();\n                                _.trys.pop(); continue;\n                        }\n                        op = body.call(thisArg, _);\n                    } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n                    if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n                }\n            };"
+        text: "\n            var __generator = (this && this.__generator) || function (thisArg, body) {\n                var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n                return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n                function verb(n) { return function (v) { return step([n, v]); }; }\n                function step(op) {\n                    if (f) throw new TypeError(\"Generator is already executing.\");\n                    while (g && (g = 0, op[0] && (_ = 0)), _) try {\n                        if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n                        if (y = 0, t) op = [op[0] & 2, t.value];\n                        switch (op[0]) {\n                            case 0: case 1: t = op; break;\n                            case 4: _.label++; return { value: op[1], done: false };\n                            case 5: _.label++; y = op[1]; op = [0]; continue;\n                            case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                            default:\n                                if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                                if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                                if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                                if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                                if (t[2]) _.ops.pop();\n                                _.trys.pop(); continue;\n                        }\n                        op = body.call(thisArg, _);\n                    } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n                    if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n                }\n            };"
     };
     // ES Module Helpers
     ts.createBindingHelper = {
@@ -32087,13 +32132,11 @@ var ts;
         var scanner = ts.createScanner(99 /* ScriptTarget.Latest */, /*skipTrivia*/ true);
         var disallowInAndDecoratorContext = 4096 /* NodeFlags.DisallowInContext */ | 16384 /* NodeFlags.DecoratorContext */;
         // capture constructors in 'initializeState' to avoid null checks
-        // tslint:disable variable-name
         var NodeConstructor;
         var TokenConstructor;
         var IdentifierConstructor;
         var PrivateIdentifierConstructor;
         var SourceFileConstructor;
-        // tslint:enable variable-name
         function countNode(node) {
             nodeCount++;
             return node;
@@ -33069,8 +33112,9 @@ var ts;
                 // Store original token kind if it is not just an Identifier so we can report appropriate error later in type checker
                 var originalKeywordKind = token();
                 var text = internIdentifier(scanner.getTokenValue());
+                var hasExtendedUnicodeEscape = scanner.hasExtendedUnicodeEscape();
                 nextTokenWithoutCheck();
-                return finishNode(factory.createIdentifier(text, /*typeArguments*/ undefined, originalKeywordKind), pos);
+                return finishNode(factory.createIdentifier(text, /*typeArguments*/ undefined, originalKeywordKind, hasExtendedUnicodeEscape), pos);
             }
             if (token() === 80 /* SyntaxKind.PrivateIdentifier */) {
                 parseErrorAtCurrentToken(privateIdentifierDiagnosticMessage || ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
@@ -40319,9 +40363,6 @@ var ts;
             name: "listFilesOnly",
             type: "boolean",
             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,
@@ -42049,12 +42090,14 @@ var ts;
         return config;
     }
     ts.convertToTSConfig = convertToTSConfig;
+    /*@internal*/
     function optionMapToObject(optionMap) {
         return __assign({}, ts.arrayFrom(optionMap.entries()).reduce(function (prev, cur) {
             var _a;
             return (__assign(__assign({}, prev), (_a = {}, _a[cur[0]] = cur[1], _a)));
         }, {}));
     }
+    ts.optionMapToObject = optionMapToObject;
     function filterSameAsDefaultInclude(specs) {
         if (!ts.length(specs))
             return undefined;
@@ -42103,9 +42146,11 @@ var ts;
         });
     }
     ts.getNameOfCompilerOptionValue = getNameOfCompilerOptionValue;
+    /* @internal */
     function serializeCompilerOptions(options, pathOptions) {
         return serializeOptionBaseObject(options, getOptionsNameMap(), pathOptions);
     }
+    ts.serializeCompilerOptions = serializeCompilerOptions;
     function serializeWatchOptions(options) {
         return serializeOptionBaseObject(options, getWatchOptionsNameMap());
     }
@@ -42209,12 +42254,23 @@ var ts;
         }
         function writeConfigurations() {
             // Filter applicable options to place in the file
-            var categorizedOptions = ts.createMultiMap();
+            var categorizedOptions = new ts.Map();
+            // Set allowed categories in order
+            categorizedOptions.set(ts.Diagnostics.Projects, []);
+            categorizedOptions.set(ts.Diagnostics.Language_and_Environment, []);
+            categorizedOptions.set(ts.Diagnostics.Modules, []);
+            categorizedOptions.set(ts.Diagnostics.JavaScript_Support, []);
+            categorizedOptions.set(ts.Diagnostics.Emit, []);
+            categorizedOptions.set(ts.Diagnostics.Interop_Constraints, []);
+            categorizedOptions.set(ts.Diagnostics.Type_Checking, []);
+            categorizedOptions.set(ts.Diagnostics.Completeness, []);
             for (var _i = 0, optionDeclarations_1 = ts.optionDeclarations; _i < optionDeclarations_1.length; _i++) {
                 var option = optionDeclarations_1[_i];
-                var category = option.category;
                 if (isAllowedOptionForOutput(option)) {
-                    categorizedOptions.add(ts.getLocaleSpecificMessage(category), option);
+                    var listForCategory = categorizedOptions.get(option.category);
+                    if (!listForCategory)
+                        categorizedOptions.set(option.category, listForCategory = []);
+                    listForCategory.push(option);
                 }
             }
             // Serialize all options and their descriptions
@@ -42225,7 +42281,7 @@ var ts;
                 if (entries.length !== 0) {
                     entries.push({ value: "" });
                 }
-                entries.push({ value: "/* ".concat(category, " */") });
+                entries.push({ value: "/* ".concat(ts.getLocaleSpecificMessage(category), " */") });
                 for (var _i = 0, options_1 = options; _i < options_1.length; _i++) {
                     var option = options_1[_i];
                     var optionName = void 0;
@@ -44267,6 +44323,9 @@ var ts;
             requestContainingDirectory: containingDirectory,
             reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
         };
+        if (traceEnabled && ts.getEmitModuleResolutionKind(compilerOptions) >= ts.ModuleResolutionKind.Node16 && ts.getEmitModuleResolutionKind(compilerOptions) <= ts.ModuleResolutionKind.NodeNext) {
+            trace(host, ts.Diagnostics.Resolving_in_0_mode_with_conditions_1, features & NodeResolutionFeatures.EsmMode ? "ESM" : "CJS", conditions.map(function (c) { return "'".concat(c, "'"); }).join(", "));
+        }
         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, affectingLocations, diagnostics, state.resultFromCache);
         function tryResolve(extensions) {
@@ -44856,7 +44915,7 @@ var ts;
             }
             if (mainExport) {
                 var loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, subpath, scope, /*isImports*/ false);
-                return loadModuleFromTargetImportOrExport(mainExport, "", /*pattern*/ false);
+                return loadModuleFromTargetImportOrExport(mainExport, "", /*pattern*/ false, ".");
             }
         }
         else if (allKeysStartWithDot(scope.contents.packageJsonContent.exports)) {
@@ -44936,7 +44995,7 @@ var ts;
         var loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports);
         if (!ts.endsWith(moduleName, ts.directorySeparator) && moduleName.indexOf("*") === -1 && ts.hasProperty(lookupTable, moduleName)) {
             var target = lookupTable[moduleName];
-            return loadModuleFromTargetImportOrExport(target, /*subpath*/ "", /*pattern*/ false);
+            return loadModuleFromTargetImportOrExport(target, /*subpath*/ "", /*pattern*/ false, moduleName);
         }
         var expandingKeys = ts.sort(ts.filter(ts.getOwnKeys(lookupTable), function (k) { return k.indexOf("*") !== -1 || ts.endsWith(k, "/"); }), comparePatternKeys);
         for (var _i = 0, expandingKeys_1 = expandingKeys; _i < expandingKeys_1.length; _i++) {
@@ -44945,17 +45004,17 @@ var ts;
                 var target = lookupTable[potentialTarget];
                 var starPos = potentialTarget.indexOf("*");
                 var subpath = moduleName.substring(potentialTarget.substring(0, starPos).length, moduleName.length - (potentialTarget.length - 1 - starPos));
-                return loadModuleFromTargetImportOrExport(target, subpath, /*pattern*/ true);
+                return loadModuleFromTargetImportOrExport(target, subpath, /*pattern*/ true, potentialTarget);
             }
             else if (ts.endsWith(potentialTarget, "*") && ts.startsWith(moduleName, potentialTarget.substring(0, potentialTarget.length - 1))) {
                 var target = lookupTable[potentialTarget];
                 var subpath = moduleName.substring(potentialTarget.length - 1);
-                return loadModuleFromTargetImportOrExport(target, subpath, /*pattern*/ true);
+                return loadModuleFromTargetImportOrExport(target, subpath, /*pattern*/ true, potentialTarget);
             }
             else if (ts.startsWith(moduleName, potentialTarget)) {
                 var target = lookupTable[potentialTarget];
                 var subpath = moduleName.substring(potentialTarget.length);
-                return loadModuleFromTargetImportOrExport(target, subpath, /*pattern*/ false);
+                return loadModuleFromTargetImportOrExport(target, subpath, /*pattern*/ false, potentialTarget);
             }
         }
         function matchesPatternWithTrailer(target, name) {
@@ -44972,7 +45031,7 @@ var ts;
      */
     function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports) {
         return loadModuleFromTargetImportOrExport;
-        function loadModuleFromTargetImportOrExport(target, subpath, pattern) {
+        function loadModuleFromTargetImportOrExport(target, subpath, pattern, key) {
             if (typeof target === "string") {
                 if (!pattern && subpath.length > 0 && !ts.endsWith(target, "/")) {
                     if (state.traceEnabled) {
@@ -44983,6 +45042,8 @@ var ts;
                 if (!ts.startsWith(target, "./")) {
                     if (isImports && !ts.startsWith(target, "../") && !ts.startsWith(target, "/") && !ts.isRootedDiskPath(target)) {
                         var combinedLookup = pattern ? target.replace(/\*/g, subpath) : target + subpath;
+                        traceIfEnabled(state, ts.Diagnostics.Using_0_subpath_1_with_target_2, "imports", key, combinedLookup);
+                        traceIfEnabled(state, ts.Diagnostics.Resolving_module_0_from_1, combinedLookup, scope.packageDirectory + "/");
                         var result = nodeModuleNameResolverWorker(state.features, combinedLookup, scope.packageDirectory + "/", state.compilerOptions, state.host, cache, [extensions], redirectedReference);
                         return toSearchResult(result.resolvedModule ? { path: result.resolvedModule.resolvedFileName, extension: result.resolvedModule.extension, packageId: result.resolvedModule.packageId, originalPath: result.resolvedModule.originalPath } : undefined);
                     }
@@ -45009,6 +45070,9 @@ var ts;
                     }
                     return toSearchResult(/*value*/ undefined);
                 }
+                if (state.traceEnabled) {
+                    trace(state.host, ts.Diagnostics.Using_0_subpath_1_with_target_2, isImports ? "imports" : "exports", key, pattern ? target.replace(/\*/g, subpath) : target + subpath);
+                }
                 var finalPath = toAbsolutePath(pattern ? resolvedTarget.replace(/\*/g, subpath) : resolvedTarget + subpath);
                 var inputLink = tryLoadInputFileForPath(finalPath, subpath, ts.combinePaths(scope.packageDirectory, "package.json"), isImports);
                 if (inputLink)
@@ -45018,14 +45082,18 @@ var ts;
             else if (typeof target === "object" && target !== null) { // eslint-disable-line no-null/no-null
                 if (!Array.isArray(target)) {
                     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);
+                        var condition = _a[_i];
+                        if (condition === "default" || state.conditions.indexOf(condition) >= 0 || isApplicableVersionedTypesKey(state.conditions, condition)) {
+                            traceIfEnabled(state, ts.Diagnostics.Matched_0_condition_1, isImports ? "imports" : "exports", condition);
+                            var subTarget = target[condition];
+                            var result = loadModuleFromTargetImportOrExport(subTarget, subpath, pattern, key);
                             if (result) {
                                 return result;
                             }
                         }
+                        else {
+                            traceIfEnabled(state, ts.Diagnostics.Saw_non_matching_condition_0, condition);
+                        }
                     }
                     return undefined;
                 }
@@ -45038,7 +45106,7 @@ var ts;
                     }
                     for (var _b = 0, target_2 = target; _b < target_2.length; _b++) {
                         var elem = target_2[_b];
-                        var result = loadModuleFromTargetImportOrExport(elem, subpath, pattern);
+                        var result = loadModuleFromTargetImportOrExport(elem, subpath, pattern, key);
                         if (result) {
                             return result;
                         }
@@ -45454,6 +45522,15 @@ var ts;
     function toSearchResult(value) {
         return value !== undefined ? { value: value } : undefined;
     }
+    function traceIfEnabled(state, diagnostic) {
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+        }
+        if (state.traceEnabled) {
+            trace.apply(void 0, __spreadArray([state.host, diagnostic], args, false));
+        }
+    }
 })(ts || (ts = {}));
 /* @internal */
 var ts;
@@ -49045,8 +49122,6 @@ var ts;
         IntersectionState[IntersectionState["None"] = 0] = "None";
         IntersectionState[IntersectionState["Source"] = 1] = "Source";
         IntersectionState[IntersectionState["Target"] = 2] = "Target";
-        IntersectionState[IntersectionState["PropertyCheck"] = 4] = "PropertyCheck";
-        IntersectionState[IntersectionState["InPropertyCheck"] = 8] = "InPropertyCheck";
     })(IntersectionState || (IntersectionState = {}));
     var RecursionFlags;
     (function (RecursionFlags) {
@@ -49465,6 +49540,12 @@ var ts;
             getOptionalType: function () { return optionalType; },
             getPromiseType: function () { return getGlobalPromiseType(/*reportErrors*/ false); },
             getPromiseLikeType: function () { return getGlobalPromiseLikeType(/*reportErrors*/ false); },
+            getAsyncIterableType: function () {
+                var type = getGlobalAsyncIterableType(/*reportErrors*/ false);
+                if (type === emptyGenericType)
+                    return undefined;
+                return type;
+            },
             isSymbolAccessible: isSymbolAccessible,
             isArrayType: isArrayType,
             isTupleType: isTupleType,
@@ -50302,9 +50383,9 @@ var ts;
                         return symbol;
                     }
                     if (symbol.flags & 2097152 /* SymbolFlags.Alias */) {
-                        var target = resolveAlias(symbol);
-                        // Unknown symbol means an error occurred in alias resolution, treat it as positive answer to avoid cascading errors
-                        if (target === unknownSymbol || target.flags & meaning) {
+                        var targetFlags = getAllSymbolFlags(symbol);
+                        // `targetFlags` will be `SymbolFlags.All` if an error occurred in alias resolution; this avoids cascading errors
+                        if (targetFlags & meaning) {
                             return symbol;
                         }
                     }
@@ -50937,8 +51018,8 @@ var ts;
                                 !checkAndReportErrorForExtendingInterface(errorLocation) &&
                                 !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) &&
                                 !checkAndReportErrorForExportingPrimitiveType(errorLocation, name) &&
+                                !checkAndReportErrorForUsingNamespaceAsTypeOrValue(errorLocation, name, meaning) &&
                                 !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) &&
-                                !checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) &&
                                 !checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) {
                             var suggestion = void 0;
                             var suggestedLib = void 0;
@@ -51025,7 +51106,7 @@ var ts;
                         }
                     }
                     if (result && errorLocation && meaning & 111551 /* SymbolFlags.Value */ && result.flags & 2097152 /* SymbolFlags.Alias */ && !(result.flags & 111551 /* SymbolFlags.Value */) && !ts.isValidTypeOnlyAliasUseSite(errorLocation)) {
-                        var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(result);
+                        var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(result, 111551 /* SymbolFlags.Value */);
                         if (typeOnlyDeclaration) {
                             var message = typeOnlyDeclaration.kind === 278 /* SyntaxKind.ExportSpecifier */
                                 ? ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type
@@ -51188,7 +51269,7 @@ var ts;
             return false;
         }
         function checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) {
-            if (meaning & (111551 /* SymbolFlags.Value */ & ~1024 /* SymbolFlags.NamespaceModule */)) {
+            if (meaning & 111551 /* SymbolFlags.Value */) {
                 if (isPrimitiveTypeName(name)) {
                     if (isExtendedByInterface(errorLocation)) {
                         error(errorLocation, ts.Diagnostics.An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_classes, ts.unescapeLeadingUnderscores(name));
@@ -51199,7 +51280,8 @@ var ts;
                     return true;
                 }
                 var symbol = resolveSymbol(resolveName(errorLocation, name, 788968 /* SymbolFlags.Type */ & ~111551 /* SymbolFlags.Value */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
-                if (symbol && !(symbol.flags & 1024 /* SymbolFlags.NamespaceModule */)) {
+                var allFlags = symbol && getAllSymbolFlags(symbol);
+                if (symbol && allFlags !== undefined && !(allFlags & 111551 /* SymbolFlags.Value */)) {
                     var rawName = ts.unescapeLeadingUnderscores(name);
                     if (isES2015OrLaterConstructorName(name)) {
                         error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later, rawName);
@@ -51247,16 +51329,16 @@ var ts;
             }
             return false;
         }
-        function checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) {
-            if (meaning & (111551 /* SymbolFlags.Value */ & ~1024 /* SymbolFlags.NamespaceModule */ & ~788968 /* SymbolFlags.Type */)) {
-                var symbol = resolveSymbol(resolveName(errorLocation, name, 1024 /* SymbolFlags.NamespaceModule */ & ~111551 /* SymbolFlags.Value */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
+        function checkAndReportErrorForUsingNamespaceAsTypeOrValue(errorLocation, name, meaning) {
+            if (meaning & (111551 /* SymbolFlags.Value */ & ~788968 /* SymbolFlags.Type */)) {
+                var symbol = resolveSymbol(resolveName(errorLocation, name, 1024 /* SymbolFlags.NamespaceModule */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
                 if (symbol) {
                     error(errorLocation, ts.Diagnostics.Cannot_use_namespace_0_as_a_value, ts.unescapeLeadingUnderscores(name));
                     return true;
                 }
             }
-            else if (meaning & (788968 /* SymbolFlags.Type */ & ~1024 /* SymbolFlags.NamespaceModule */ & ~111551 /* SymbolFlags.Value */)) {
-                var symbol = resolveSymbol(resolveName(errorLocation, name, (512 /* SymbolFlags.ValueModule */ | 1024 /* SymbolFlags.NamespaceModule */) & ~788968 /* SymbolFlags.Type */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
+            else if (meaning & (788968 /* SymbolFlags.Type */ & ~111551 /* SymbolFlags.Value */)) {
+                var symbol = resolveSymbol(resolveName(errorLocation, name, 1536 /* SymbolFlags.Module */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false));
                 if (symbol) {
                     error(errorLocation, ts.Diagnostics.Cannot_use_namespace_0_as_a_type, ts.unescapeLeadingUnderscores(name));
                     return true;
@@ -51846,6 +51928,52 @@ var ts;
             }
             return undefined;
         }
+        /**
+         * Gets combined flags of a `symbol` and all alias targets it resolves to. `resolveAlias`
+         * is typically recursive over chains of aliases, but stops mid-chain if an alias is merged
+         * with another exported symbol, e.g.
+         * ```ts
+         * // a.ts
+         * export const a = 0;
+         * // b.ts
+         * export { a } from "./a";
+         * export type a = number;
+         * // c.ts
+         * import { a } from "./b";
+         * ```
+         * Calling `resolveAlias` on the `a` in c.ts would stop at the merged symbol exported
+         * from b.ts, even though there is still more alias to resolve. Consequently, if we were
+         * trying to determine if the `a` in c.ts has a value meaning, looking at the flags on
+         * the local symbol and on the symbol returned by `resolveAlias` is not enough.
+         * @returns SymbolFlags.All if `symbol` is an alias that ultimately resolves to `unknown`;
+         * combined flags of all alias targets otherwise.
+         */
+        function getAllSymbolFlags(symbol) {
+            var flags = symbol.flags;
+            var seenSymbols;
+            while (symbol.flags & 2097152 /* SymbolFlags.Alias */) {
+                var target = resolveAlias(symbol);
+                if (target === unknownSymbol) {
+                    return 67108863 /* SymbolFlags.All */;
+                }
+                // Optimizations - try to avoid creating or adding to
+                // `seenSymbols` if possible
+                if (target === symbol || (seenSymbols === null || seenSymbols === void 0 ? void 0 : seenSymbols.has(target))) {
+                    break;
+                }
+                if (target.flags & 2097152 /* SymbolFlags.Alias */) {
+                    if (seenSymbols) {
+                        seenSymbols.add(target);
+                    }
+                    else {
+                        seenSymbols = new ts.Set([symbol, target]);
+                    }
+                }
+                flags |= target.flags;
+                symbol = target;
+            }
+            return flags;
+        }
         /**
          * Marks a symbol as type-only if its declaration is syntactically type-only.
          * If it is not itself marked type-only, but resolves to a type-only alias
@@ -51891,19 +52019,25 @@ var ts;
             return !!aliasDeclarationLinks.typeOnlyDeclaration;
         }
         /** Indicates that a symbol directly or indirectly resolves to a type-only import or export. */
-        function getTypeOnlyAliasDeclaration(symbol) {
+        function getTypeOnlyAliasDeclaration(symbol, include) {
             if (!(symbol.flags & 2097152 /* SymbolFlags.Alias */)) {
                 return undefined;
             }
             var links = getSymbolLinks(symbol);
-            return links.typeOnlyDeclaration || undefined;
+            if (include === undefined) {
+                return links.typeOnlyDeclaration || undefined;
+            }
+            if (links.typeOnlyDeclaration) {
+                return getAllSymbolFlags(resolveAlias(links.typeOnlyDeclaration.symbol)) & include ? links.typeOnlyDeclaration : undefined;
+            }
+            return undefined;
         }
         function markExportAsReferenced(node) {
             var symbol = getSymbolOfNode(node);
             var target = resolveAlias(symbol);
             if (target) {
                 var markAlias = target === unknownSymbol ||
-                    ((target.flags & 111551 /* SymbolFlags.Value */) && !isConstEnumOrConstEnumOnlyModule(target) && !getTypeOnlyAliasDeclaration(symbol));
+                    ((getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */) && !isConstEnumOrConstEnumOnlyModule(target) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* SymbolFlags.Value */));
                 if (markAlias) {
                     markAliasSymbolAsReferenced(symbol);
                 }
@@ -51923,8 +52057,7 @@ var ts;
                 // This way a chain of imports can be elided if ultimately the final input is only used in a type
                 // position.
                 if (ts.isInternalModuleImportEqualsDeclaration(node)) {
-                    var target = resolveSymbol(symbol);
-                    if (target === unknownSymbol || target.flags & 111551 /* SymbolFlags.Value */) {
+                    if (getAllSymbolFlags(resolveSymbol(symbol)) & 111551 /* SymbolFlags.Value */) {
                         // import foo = <symbol>
                         checkExpressionCached(node.moduleReference);
                     }
@@ -52746,7 +52879,7 @@ var ts;
         }
         function symbolIsValue(symbol, includeTypeOnlyMembers) {
             return !!(symbol.flags & 111551 /* SymbolFlags.Value */ ||
-                symbol.flags & 2097152 /* SymbolFlags.Alias */ && resolveAlias(symbol).flags & 111551 /* SymbolFlags.Value */ && (includeTypeOnlyMembers || !getTypeOnlyAliasDeclaration(symbol)));
+                symbol.flags & 2097152 /* SymbolFlags.Alias */ && getAllSymbolFlags(symbol) & 111551 /* SymbolFlags.Value */ && (includeTypeOnlyMembers || !getTypeOnlyAliasDeclaration(symbol)));
         }
         function findConstructorDeclaration(node) {
             var members = node.members;
@@ -53015,8 +53148,10 @@ var ts;
                     return true;
                 }
                 // Qualify if the symbol from symbol table has same meaning as expected
-                symbolFromSymbolTable = (symbolFromSymbolTable.flags & 2097152 /* SymbolFlags.Alias */ && !ts.getDeclarationOfKind(symbolFromSymbolTable, 278 /* SyntaxKind.ExportSpecifier */)) ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable;
-                if (symbolFromSymbolTable.flags & meaning) {
+                var shouldResolveAlias = (symbolFromSymbolTable.flags & 2097152 /* SymbolFlags.Alias */ && !ts.getDeclarationOfKind(symbolFromSymbolTable, 278 /* SyntaxKind.ExportSpecifier */));
+                symbolFromSymbolTable = shouldResolveAlias ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable;
+                var flags = shouldResolveAlias ? getAllSymbolFlags(symbolFromSymbolTable) : symbolFromSymbolTable.flags;
+                if (flags & meaning) {
                     qualify = true;
                     return true;
                 }
@@ -55328,7 +55463,7 @@ var ts;
                                 // export {name} - look thru `statements` for `name`, and if all results can take an `export` modifier, do so and filter it
                                 var indices = ts.indicesOf(statements);
                                 var associatedIndices = ts.filter(indices, function (i) { return ts.nodeHasName(statements[i], e.name); });
-                                if (ts.length(associatedIndices) && ts.every(associatedIndices, function (i) { return canHaveExportModifier(statements[i]); })) {
+                                if (ts.length(associatedIndices) && ts.every(associatedIndices, function (i) { return ts.canHaveExportModifier(statements[i]); })) {
                                     for (var _i = 0, associatedIndices_1 = associatedIndices; _i < associatedIndices_1.length; _i++) {
                                         var index_1 = associatedIndices_1[_i];
                                         statements[index_1] = addExportModifier(statements[index_1]);
@@ -55362,15 +55497,6 @@ var ts;
                     }
                     return statements;
                 }
-                function canHaveExportModifier(node) {
-                    return ts.isEnumDeclaration(node) ||
-                        ts.isVariableStatement(node) ||
-                        ts.isFunctionDeclaration(node) ||
-                        ts.isClassDeclaration(node) ||
-                        (ts.isModuleDeclaration(node) && !ts.isExternalModuleAugmentation(node) && !ts.isGlobalScopeAugmentation(node)) ||
-                        ts.isInterfaceDeclaration(node) ||
-                        isTypeDeclaration(node);
-                }
                 function addExportModifier(node) {
                     var flags = (ts.getEffectiveModifierFlags(node) | 1 /* ModifierFlags.Export */) & ~2 /* ModifierFlags.Ambient */;
                     return ts.factory.updateModifiers(node, flags);
@@ -55617,7 +55743,7 @@ var ts;
                             (ts.isJSDocTypeAlias(context.enclosingDeclaration) ? ts.getSourceFileOfNode(context.enclosingDeclaration) : context.enclosingDeclaration);
                         if (additionalModifierFlags & 1 /* ModifierFlags.Export */ &&
                             enclosingDeclaration_1 && (isExportingScope(enclosingDeclaration_1) || ts.isModuleDeclaration(enclosingDeclaration_1)) &&
-                            canHaveExportModifier(node)) {
+                            ts.canHaveExportModifier(node)) {
                             // Classes, namespaces, variables, functions, interfaces, and types should all be `export`ed in a module context if not private
                             newModifierFlags |= 1 /* ModifierFlags.Export */;
                         }
@@ -55673,7 +55799,7 @@ var ts;
                     return !symbol.exports ? [] : ts.filter(ts.arrayFrom(symbol.exports.values()), isNamespaceMember);
                 }
                 function isTypeOnlyNamespace(symbol) {
-                    return ts.every(getNamespaceMembersForSerialization(symbol), function (m) { return !(resolveSymbol(m).flags & 111551 /* SymbolFlags.Value */); });
+                    return ts.every(getNamespaceMembersForSerialization(symbol), function (m) { return !(getAllSymbolFlags(resolveSymbol(m)) & 111551 /* SymbolFlags.Value */); });
                 }
                 function serializeModule(symbol, symbolName, modifierFlags) {
                     var members = getNamespaceMembersForSerialization(symbol);
@@ -57587,16 +57713,32 @@ var ts;
                 return getTypeFromTypeNode(typeNode);
             }
         }
+        function isParameterOfContextSensitiveSignature(symbol) {
+            var decl = symbol.valueDeclaration;
+            if (!decl) {
+                return false;
+            }
+            if (ts.isBindingElement(decl)) {
+                decl = ts.walkUpBindingElementsAndPatterns(decl);
+            }
+            if (ts.isParameter(decl)) {
+                return isContextSensitiveFunctionOrObjectLiteralMethod(decl.parent);
+            }
+            return false;
+        }
         function getTypeOfVariableOrParameterOrProperty(symbol) {
             var links = getSymbolLinks(symbol);
             if (!links.type) {
                 var type = getTypeOfVariableOrParameterOrPropertyWorker(symbol);
                 // For a contextually typed parameter it is possible that a type has already
                 // been assigned (in assignTypeToParameterAndFixTypeParameters), and we want
-                // to preserve this type.
-                if (!links.type) {
+                // to preserve this type. In fact, we need to _prefer_ that type, but it won't
+                // be assigned until contextual typing is complete, so we need to defer in
+                // cases where contextual typing may take place.
+                if (!links.type && !isParameterOfContextSensitiveSignature(symbol)) {
                     links.type = type;
                 }
+                return type;
             }
             return links.type;
         }
@@ -57893,7 +58035,7 @@ var ts;
                 links.type = (exportSymbol === null || exportSymbol === void 0 ? void 0 : exportSymbol.declarations) && isDuplicatedCommonJSExport(exportSymbol.declarations) && symbol.declarations.length ? getFlowTypeFromCommonJSExport(exportSymbol)
                     : isDuplicatedCommonJSExport(symbol.declarations) ? autoType
                         : declaredType ? declaredType
-                            : targetSymbol.flags & 111551 /* SymbolFlags.Value */ ? getTypeOfSymbol(targetSymbol)
+                            : getAllSymbolFlags(targetSymbol) & 111551 /* SymbolFlags.Value */ ? getTypeOfSymbol(targetSymbol)
                                 : errorType;
             }
             return links.type;
@@ -59776,7 +59918,20 @@ var ts;
             return !!(ts.getObjectFlags(type) & 32 /* ObjectFlags.Mapped */ && getMappedTypeModifiers(type) & 4 /* MappedTypeModifiers.IncludeOptional */);
         }
         function isGenericMappedType(type) {
-            return !!(ts.getObjectFlags(type) & 32 /* ObjectFlags.Mapped */) && isGenericIndexType(getConstraintTypeFromMappedType(type));
+            if (ts.getObjectFlags(type) & 32 /* ObjectFlags.Mapped */) {
+                var constraint = getConstraintTypeFromMappedType(type);
+                if (isGenericIndexType(constraint)) {
+                    return true;
+                }
+                // A mapped type is generic if the 'as' clause references generic types other than the iteration type.
+                // To determine this, we substitute the constraint type (that we now know isn't generic) for the iteration
+                // type and check whether the resulting type is generic.
+                var nameType = getNameTypeFromMappedType(type);
+                if (nameType && isGenericIndexType(instantiateType(nameType, makeUnaryTypeMapper(getTypeParameterFromMappedType(type), constraint)))) {
+                    return true;
+                }
+            }
+            return false;
         }
         function resolveStructuredTypeMembers(type) {
             if (!type.members) {
@@ -60246,7 +60401,7 @@ var ts;
             var indexTypes;
             var isUnion = containingType.flags & 1048576 /* TypeFlags.Union */;
             // Flags we want to propagate to the result if they exist in all source symbols
-            var optionalFlag = isUnion ? 0 /* SymbolFlags.None */ : 16777216 /* SymbolFlags.Optional */;
+            var optionalFlag;
             var syntheticFlag = 4 /* CheckFlags.SyntheticMethod */;
             var checkFlags = isUnion ? 0 : 8 /* CheckFlags.Readonly */;
             var mergedInstantiations = false;
@@ -60257,11 +60412,14 @@ var ts;
                     var prop = getPropertyOfType(type, name, skipObjectFunctionPropertyAugment);
                     var modifiers = prop ? ts.getDeclarationModifierFlagsFromSymbol(prop) : 0;
                     if (prop) {
-                        if (isUnion) {
-                            optionalFlag |= (prop.flags & 16777216 /* SymbolFlags.Optional */);
-                        }
-                        else {
-                            optionalFlag &= prop.flags;
+                        if (prop.flags & 106500 /* SymbolFlags.ClassMember */) {
+                            optionalFlag !== null && optionalFlag !== void 0 ? optionalFlag : (optionalFlag = isUnion ? 0 /* SymbolFlags.None */ : 16777216 /* SymbolFlags.Optional */);
+                            if (isUnion) {
+                                optionalFlag |= (prop.flags & 16777216 /* SymbolFlags.Optional */);
+                            }
+                            else {
+                                optionalFlag &= prop.flags;
+                            }
                         }
                         if (!singleProp) {
                             singleProp = prop;
@@ -60380,7 +60538,7 @@ var ts;
                 propTypes.push(type);
             }
             ts.addRange(propTypes, indexTypes);
-            var result = createSymbol(4 /* SymbolFlags.Property */ | optionalFlag, name, syntheticFlag | checkFlags);
+            var result = createSymbol(4 /* SymbolFlags.Property */ | (optionalFlag !== null && optionalFlag !== void 0 ? optionalFlag : 0), name, syntheticFlag | checkFlags);
             result.containingType = containingType;
             if (!hasNonUniformValueDeclaration && firstValueDeclaration) {
                 result.valueDeclaration = firstValueDeclaration;
@@ -63093,8 +63251,14 @@ var ts;
                 return getStringLiteralType(text);
             }
             newTexts.push(text);
-            if (ts.every(newTexts, function (t) { return t === ""; }) && ts.every(newTypes, function (t) { return !!(t.flags & 4 /* TypeFlags.String */); })) {
-                return stringType;
+            if (ts.every(newTexts, function (t) { return t === ""; })) {
+                if (ts.every(newTypes, function (t) { return !!(t.flags & 4 /* TypeFlags.String */); })) {
+                    return stringType;
+                }
+                // Normalize `${Mapping<xxx>}` into Mapping<xxx>
+                if (newTypes.length === 1 && isPatternLiteralType(newTypes[0])) {
+                    return newTypes[0];
+                }
             }
             var id = "".concat(getTypeListId(newTypes), "|").concat(ts.map(newTexts, function (t) { return t.length; }).join(","), "|").concat(newTexts.join(""));
             var type = templateLiteralTypes.get(id);
@@ -63153,12 +63317,14 @@ var ts;
         }
         function getStringMappingType(symbol, type) {
             return type.flags & (1048576 /* TypeFlags.Union */ | 131072 /* TypeFlags.Never */) ? mapType(type, function (t) { return getStringMappingType(symbol, t); }) :
-                // Mapping<Mapping<T>> === Mapping<T>
-                type.flags & 268435456 /* TypeFlags.StringMapping */ && symbol === type.symbol ? type :
-                    isGenericIndexType(type) || isPatternLiteralPlaceholderType(type) ? getStringMappingTypeForGenericType(symbol, isPatternLiteralPlaceholderType(type) && !(type.flags & 268435456 /* TypeFlags.StringMapping */) ? getTemplateLiteralType(["", ""], [type]) : type) :
-                        type.flags & 128 /* TypeFlags.StringLiteral */ ? getStringLiteralType(applyStringMapping(symbol, type.value)) :
-                            type.flags & 134217728 /* TypeFlags.TemplateLiteral */ ? getTemplateLiteralType.apply(void 0, applyTemplateStringMapping(symbol, type.texts, type.types)) :
-                                type;
+                type.flags & 128 /* TypeFlags.StringLiteral */ ? getStringLiteralType(applyStringMapping(symbol, type.value)) :
+                    type.flags & 134217728 /* TypeFlags.TemplateLiteral */ ? getTemplateLiteralType.apply(void 0, applyTemplateStringMapping(symbol, type.texts, type.types)) :
+                        // Mapping<Mapping<T>> === Mapping<T>
+                        type.flags & 268435456 /* TypeFlags.StringMapping */ && symbol === type.symbol ? type :
+                            type.flags & (1 /* TypeFlags.Any */ | 4 /* TypeFlags.String */ | 268435456 /* TypeFlags.StringMapping */) || isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) :
+                                // This handles Mapping<`${number}`> and Mapping<`${bigint}`>
+                                isPatternLiteralPlaceholderType(type) ? getStringMappingTypeForGenericType(symbol, getTemplateLiteralType(["", ""], [type])) :
+                                    type;
         }
         function applyStringMapping(symbol, str) {
             switch (intrinsicTypeKinds.get(symbol.escapedName)) {
@@ -63323,7 +63489,18 @@ var ts;
                         return accessFlags & 1 /* AccessFlags.IncludeUndefined */ ? getUnionType([indexInfo.type, undefinedType]) : indexInfo.type;
                     }
                     errorIfWritingToReadonlyIndex(indexInfo);
-                    return accessFlags & 1 /* AccessFlags.IncludeUndefined */ ? getUnionType([indexInfo.type, undefinedType]) : indexInfo.type;
+                    // When accessing an enum object with its own type,
+                    // e.g. E[E.A] for enum E { A }, undefined shouldn't
+                    // be included in the result type
+                    if ((accessFlags & 1 /* AccessFlags.IncludeUndefined */) &&
+                        !(objectType.symbol &&
+                            objectType.symbol.flags & (256 /* SymbolFlags.RegularEnum */ | 128 /* SymbolFlags.ConstEnum */) &&
+                            (indexType.symbol &&
+                                indexType.flags & 1024 /* TypeFlags.EnumLiteral */ &&
+                                getParentOfSymbol(indexType.symbol) === objectType.symbol))) {
+                        return getUnionType([indexInfo.type, undefinedType]);
+                    }
+                    return indexInfo.type;
                 }
                 if (indexType.flags & 131072 /* TypeFlags.Never */) {
                     return neverType;
@@ -63426,10 +63603,11 @@ var ts;
                         accessNode;
         }
         function isPatternLiteralPlaceholderType(type) {
-            return !!(type.flags & (1 /* TypeFlags.Any */ | 4 /* TypeFlags.String */ | 8 /* TypeFlags.Number */ | 64 /* TypeFlags.BigInt */)) || !!(type.flags & 268435456 /* TypeFlags.StringMapping */ && isPatternLiteralPlaceholderType(type.type));
+            return !!(type.flags & (1 /* TypeFlags.Any */ | 4 /* TypeFlags.String */ | 8 /* TypeFlags.Number */ | 64 /* TypeFlags.BigInt */)) || isPatternLiteralType(type);
         }
         function isPatternLiteralType(type) {
-            return !!(type.flags & 134217728 /* TypeFlags.TemplateLiteral */) && ts.every(type.types, isPatternLiteralPlaceholderType);
+            return !!(type.flags & 134217728 /* TypeFlags.TemplateLiteral */) && ts.every(type.types, isPatternLiteralPlaceholderType) ||
+                !!(type.flags & 268435456 /* TypeFlags.StringMapping */) && isPatternLiteralPlaceholderType(type.type);
         }
         function isGenericType(type) {
             return !!getGenericObjectFlags(type);
@@ -63708,18 +63886,23 @@ var ts;
             var result;
             var extraTypes;
             var tailCount = 0;
-            var _loop_20 = function () {
+            // We loop here for an immediately nested conditional type in the false position, effectively treating
+            // types of the form 'A extends B ? X : C extends D ? Y : E extends F ? Z : ...' as a single construct for
+            // purposes of resolution. We also loop here when resolution of a conditional type ends in resolution of
+            // another (or, through recursion, possibly the same) conditional type. In the potentially tail-recursive
+            // cases we increment the tail recursion counter and stop after 1000 iterations.
+            while (true) {
                 if (tailCount === 1000) {
                     error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
                     result = errorType;
-                    return "break";
+                    break;
                 }
                 var isUnwrapped = isTypicalNondistributiveConditional(root);
                 var checkType = instantiateType(unwrapNondistributiveConditionalTuple(root, getActualTypeVariable(root.checkType)), mapper);
                 var checkTypeInstantiable = isGenericType(checkType);
                 var extendsType = instantiateType(unwrapNondistributiveConditionalTuple(root, root.extendsType), mapper);
                 if (checkType === wildcardType || extendsType === wildcardType) {
-                    return { value: wildcardType };
+                    return wildcardType;
                 }
                 var combinedMapper = void 0;
                 if (root.inferTypeParameters) {
@@ -63752,11 +63935,7 @@ var ts;
                             }
                         }
                     }
-                    // We skip inference of the possible `infer` types unles the `extendsType` _is_ an infer type
-                    // if it was, it's trivial to say that extendsType = checkType, however such a pattern is used to
-                    // "reset" the type being build up during constraint calculation and avoid making an apparently "infinite" constraint
-                    // so in those cases we refain from performing inference and retain the uninfered type parameter
-                    if (!checkTypeInstantiable || !ts.some(root.inferTypeParameters, function (t) { return t === extendsType; })) {
+                    if (!checkTypeInstantiable) {
                         // We don't want inferences from constraints as they may cause us to eagerly resolve the
                         // conditional type instead of deferring resolution. Also, we always want strict function
                         // types rules (i.e. proper contravariance) for inferences.
@@ -63788,14 +63967,14 @@ var ts;
                             var newRoot = falseType_1.root;
                             if (newRoot.node.parent === root.node && (!newRoot.isDistributive || newRoot.checkType === root.checkType)) {
                                 root = newRoot;
-                                return "continue";
+                                continue;
                             }
                             if (canTailRecurse(falseType_1, mapper)) {
-                                return "continue";
+                                continue;
                             }
                         }
                         result = instantiateType(falseType_1, mapper);
-                        return "break";
+                        break;
                     }
                     // Return trueType for a definitely true extends check. We check instantiations of the two
                     // types with type parameters mapped to their restrictive form, i.e. a form of the type parameter
@@ -63806,10 +63985,10 @@ var ts;
                         var trueType_1 = getTypeFromTypeNode(root.node.trueType);
                         var trueMapper = combinedMapper || mapper;
                         if (canTailRecurse(trueType_1, trueMapper)) {
-                            return "continue";
+                            continue;
                         }
                         result = instantiateType(trueType_1, trueMapper);
-                        return "break";
+                        break;
                     }
                 }
                 // Return a deferred type for a check that is neither definitely true nor definitely false
@@ -63821,19 +64000,7 @@ var ts;
                 result.combinedMapper = combinedMapper;
                 result.aliasSymbol = aliasSymbol || root.aliasSymbol;
                 result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(root.aliasTypeArguments, mapper); // TODO: GH#18217
-                return "break";
-            };
-            // We loop here for an immediately nested conditional type in the false position, effectively treating
-            // types of the form 'A extends B ? X : C extends D ? Y : E extends F ? Z : ...' as a single construct for
-            // purposes of resolution. We also loop here when resolution of a conditional type ends in resolution of
-            // another (or, through recursion, possibly the same) conditional type. In the potentially tail-recursive
-            // cases we increment the tail recursion counter and stop after 1000 iterations.
-            while (true) {
-                var state_6 = _loop_20();
-                if (typeof state_6 === "object")
-                    return state_6.value;
-                if (state_6 === "break")
-                    break;
+                break;
             }
             return extraTypes ? getUnionType(ts.append(extraTypes, result)) : result;
             // We tail-recurse for generic conditional types that (a) have not already been evaluated and cached, and
@@ -66287,7 +66454,7 @@ var ts;
                             return 0 /* Ternary.False */;
                         }
                     }
-                    var isPerformingCommonPropertyChecks = (relation !== comparableRelation || !(source.flags & 1048576 /* TypeFlags.Union */) && isLiteralType(source)) &&
+                    var isPerformingCommonPropertyChecks = (relation !== comparableRelation || isUnitType(source)) &&
                         !(intersectionState & 2 /* IntersectionState.Target */) &&
                         source.flags & (131068 /* TypeFlags.Primitive */ | 524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */) && source !== globalObjectType &&
                         target.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */) && isWeakType(target) &&
@@ -66315,27 +66482,6 @@ var ts;
                     var result_7 = skipCaching ?
                         unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState) :
                         recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags);
-                    // For certain combinations involving intersections and optional, excess, or mismatched properties we need
-                    // an extra property check where the intersection is viewed as a single object. The following are motivating
-                    // examples that all should be errors, but aren't without this extra property check:
-                    //
-                    //   let obj: { a: { x: string } } & { c: number } = { a: { x: 'hello', y: 2 }, c: 5 };  // Nested excess property
-                    //
-                    //   declare let wrong: { a: { y: string } };
-                    //   let weak: { a?: { x?: number } } & { c?: string } = wrong;  // Nested weak object type
-                    //
-                    //   function foo<T extends object>(x: { a?: string }, y: T & { a: boolean }) {
-                    //     x = y;  // Mismatched property in source intersection
-                    //   }
-                    //
-                    // We suppress recursive intersection property checks because they can generate lots of work when relating
-                    // recursive intersections that are structurally similar but not exactly identical. See #37854.
-                    if (result_7 && !inPropertyCheck && (target.flags & 2097152 /* TypeFlags.Intersection */ && (isPerformingExcessPropertyChecks || isPerformingCommonPropertyChecks) ||
-                        isNonGenericObjectType(target) && !isArrayOrTupleType(target) && source.flags & 2097152 /* TypeFlags.Intersection */ && getApparentType(source).flags & 3670016 /* TypeFlags.StructuredType */ && !ts.some(source.types, function (t) { return !!(ts.getObjectFlags(t) & 262144 /* ObjectFlags.NonInferrableType */); }))) {
-                        inPropertyCheck = true;
-                        result_7 &= recursiveTypeRelatedTo(source, target, reportErrors, 4 /* IntersectionState.PropertyCheck */, recursionFlags);
-                        inPropertyCheck = false;
-                    }
                     if (result_7) {
                         return result_7;
                     }
@@ -66447,7 +66593,7 @@ var ts;
                     reducedTarget = findMatchingDiscriminantType(source, target, isRelatedTo) || filterPrimitivesIfContainsNonPrimitive(target);
                     checkTypes = reducedTarget.flags & 1048576 /* TypeFlags.Union */ ? reducedTarget.types : [reducedTarget];
                 }
-                var _loop_21 = function (prop) {
+                var _loop_20 = function (prop) {
                     if (shouldCheckAsExcessProperty(prop, source.symbol) && !isIgnoredJsxProperty(source, prop)) {
                         if (!isKnownProperty(reducedTarget, prop.escapedName, isComparingJsxAttributes)) {
                             if (reportErrors) {
@@ -66510,9 +66656,9 @@ var ts;
                 };
                 for (var _i = 0, _b = getPropertiesOfType(source); _i < _b.length; _i++) {
                     var prop = _b[_i];
-                    var state_7 = _loop_21(prop);
-                    if (typeof state_7 === "object")
-                        return state_7.value;
+                    var state_6 = _loop_20(prop);
+                    if (typeof state_6 === "object")
+                        return state_6.value;
                 }
                 return false;
             }
@@ -66733,8 +66879,7 @@ var ts;
                 if (overflow) {
                     return 0 /* Ternary.False */;
                 }
-                var keyIntersectionState = intersectionState | (inPropertyCheck ? 8 /* IntersectionState.InPropertyCheck */ : 0);
-                var id = getRelationKey(source, target, keyIntersectionState, relation, /*ingnoreConstraints*/ false);
+                var id = getRelationKey(source, target, intersectionState, relation, /*ingnoreConstraints*/ false);
                 var entry = relation.get(id);
                 if (entry !== undefined) {
                     if (reportErrors && entry & 2 /* RelationComparisonResult.Failed */ && !(entry & 4 /* RelationComparisonResult.Reported */)) {
@@ -66764,7 +66909,7 @@ var ts;
                     // A key that starts with "*" is an indication that we have type references that reference constrained
                     // type parameters. For such keys we also check against the key we would have gotten if all type parameters
                     // were unconstrained.
-                    var broadestEquivalentId = id.startsWith("*") ? getRelationKey(source, target, keyIntersectionState, relation, /*ignoreConstraints*/ true) : undefined;
+                    var broadestEquivalentId = id.startsWith("*") ? getRelationKey(source, target, intersectionState, relation, /*ignoreConstraints*/ true) : undefined;
                     for (var i = 0; i < maybeCount; i++) {
                         // If source and target are already being compared, consider them related with assumptions
                         if (id === maybeKeys[i] || broadestEquivalentId && broadestEquivalentId === maybeKeys[i]) {
@@ -66851,7 +66996,7 @@ var ts;
             function structuredTypeRelatedTo(source, target, reportErrors, intersectionState) {
                 var saveErrorInfo = captureErrorCalculationState();
                 var result = structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState, saveErrorInfo);
-                if (!result && (source.flags & 2097152 /* TypeFlags.Intersection */ || source.flags & 262144 /* TypeFlags.TypeParameter */ && target.flags & 1048576 /* TypeFlags.Union */)) {
+                if (relation !== identityRelation) {
                     // The combined constraint of an intersection type is the intersection of the constraints of
                     // the constituents. When an intersection type contains instantiable types with union type
                     // constraints, there are situations where we need to examine the combined constraint. One is
@@ -66865,10 +67010,33 @@ var ts;
                     // needs to have its constraint hoisted into an intersection with said type parameter, this way
                     // the type param can be compared with itself in the target (with the influence of its constraint to match other parts)
                     // For example, if `T extends 1 | 2` and `U extends 2 | 3` and we compare `T & U` to `T & U & (1 | 2 | 3)`
-                    var constraint = getEffectiveConstraintOfIntersection(source.flags & 2097152 /* TypeFlags.Intersection */ ? source.types : [source], !!(target.flags & 1048576 /* TypeFlags.Union */));
-                    if (constraint && !(constraint.flags & 131072 /* TypeFlags.Never */) && everyType(constraint, function (c) { return c !== source; })) { // Skip comparison if expansion contains the source itself
-                        // TODO: Stack errors so we get a pyramid for the "normal" comparison above, _and_ a second for this
-                        result = isRelatedTo(constraint, target, 1 /* RecursionFlags.Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState);
+                    if (!result && (source.flags & 2097152 /* TypeFlags.Intersection */ || source.flags & 262144 /* TypeFlags.TypeParameter */ && target.flags & 1048576 /* TypeFlags.Union */)) {
+                        var constraint = getEffectiveConstraintOfIntersection(source.flags & 2097152 /* TypeFlags.Intersection */ ? source.types : [source], !!(target.flags & 1048576 /* TypeFlags.Union */));
+                        if (constraint && everyType(constraint, function (c) { return c !== source; })) { // Skip comparison if expansion contains the source itself
+                            // TODO: Stack errors so we get a pyramid for the "normal" comparison above, _and_ a second for this
+                            result = isRelatedTo(constraint, target, 1 /* RecursionFlags.Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState);
+                        }
+                    }
+                    // For certain combinations involving intersections and optional, excess, or mismatched properties we need
+                    // an extra property check where the intersection is viewed as a single object. The following are motivating
+                    // examples that all should be errors, but aren't without this extra property check:
+                    //
+                    //   let obj: { a: { x: string } } & { c: number } = { a: { x: 'hello', y: 2 }, c: 5 };  // Nested excess property
+                    //
+                    //   declare let wrong: { a: { y: string } };
+                    //   let weak: { a?: { x?: number } } & { c?: string } = wrong;  // Nested weak object type
+                    //
+                    //   function foo<T extends object>(x: { a?: string }, y: T & { a: boolean }) {
+                    //     x = y;  // Mismatched property in source intersection
+                    //   }
+                    //
+                    // We suppress recursive intersection property checks because they can generate lots of work when relating
+                    // recursive intersections that are structurally similar but not exactly identical. See #37854.
+                    if (result && !inPropertyCheck && (target.flags & 2097152 /* TypeFlags.Intersection */ && !isGenericObjectType(target) && source.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */) ||
+                        isNonGenericObjectType(target) && !isArrayOrTupleType(target) && source.flags & 2097152 /* TypeFlags.Intersection */ && getApparentType(source).flags & 3670016 /* TypeFlags.StructuredType */ && !ts.some(source.types, function (t) { return !!(ts.getObjectFlags(t) & 262144 /* ObjectFlags.NonInferrableType */); }))) {
+                        inPropertyCheck = true;
+                        result &= propertiesRelatedTo(source, target, reportErrors, /*excludedProperties*/ undefined, 0 /* IntersectionState.None */);
+                        inPropertyCheck = false;
                     }
                 }
                 if (result) {
@@ -66877,9 +67045,6 @@ var ts;
                 return result;
             }
             function structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState, saveErrorInfo) {
-                if (intersectionState & 4 /* IntersectionState.PropertyCheck */) {
-                    return propertiesRelatedTo(source, target, reportErrors, /*excludedProperties*/ undefined, 0 /* IntersectionState.None */);
-                }
                 var result;
                 var originalErrorInfo;
                 var varianceCheckFailed = false;
@@ -66980,7 +67145,7 @@ var ts;
                         // with another type parameter unless one extends the other. (Remember: comparability is mostly bidirectional!)
                         var constraint = getConstraintOfTypeParameter(source);
                         if (constraint && hasNonCircularBaseConstraint(source)) {
-                            while (constraint && constraint.flags & 262144 /* TypeFlags.TypeParameter */) {
+                            while (constraint && someType(constraint, function (c) { return !!(c.flags & 262144 /* TypeFlags.TypeParameter */); })) {
                                 if (result = isRelatedTo(constraint, target, 1 /* RecursionFlags.Source */, /*reportErrors*/ false)) {
                                     return result;
                                 }
@@ -67503,11 +67668,11 @@ var ts;
                 // constituents of 'target'. If any combination does not have a match then 'source' is not relatable.
                 var discriminantCombinations = ts.cartesianProduct(sourceDiscriminantTypes);
                 var matchingTypes = [];
-                var _loop_22 = function (combination) {
+                var _loop_21 = function (combination) {
                     var hasMatch = false;
                     outer: for (var _c = 0, _d = target.types; _c < _d.length; _c++) {
                         var type = _d[_c];
-                        var _loop_23 = function (i) {
+                        var _loop_22 = function (i) {
                             var sourceProperty = sourcePropertiesFiltered[i];
                             var targetProperty = getPropertyOfType(type, sourceProperty.escapedName);
                             if (!targetProperty)
@@ -67523,8 +67688,8 @@ var ts;
                             }
                         };
                         for (var i = 0; i < sourcePropertiesFiltered.length; i++) {
-                            var state_9 = _loop_23(i);
-                            switch (state_9) {
+                            var state_8 = _loop_22(i);
+                            switch (state_8) {
                                 case "continue-outer": continue outer;
                             }
                         }
@@ -67537,9 +67702,9 @@ var ts;
                 };
                 for (var _a = 0, discriminantCombinations_1 = discriminantCombinations; _a < discriminantCombinations_1.length; _a++) {
                     var combination = discriminantCombinations_1[_a];
-                    var state_8 = _loop_22(combination);
-                    if (typeof state_8 === "object")
-                        return state_8.value;
+                    var state_7 = _loop_21(combination);
+                    if (typeof state_7 === "object")
+                        return state_7.value;
                 }
                 // Compare the remaining non-discriminant properties of each match.
                 var result = -1 /* Ternary.True */;
@@ -67636,7 +67801,7 @@ var ts;
                     return 0 /* Ternary.False */;
                 }
                 // When checking for comparability, be more lenient with optional properties.
-                if (!skipOptional && sourceProp.flags & 16777216 /* SymbolFlags.Optional */ && !(targetProp.flags & 16777216 /* SymbolFlags.Optional */)) {
+                if (!skipOptional && sourceProp.flags & 16777216 /* SymbolFlags.Optional */ && targetProp.flags & 106500 /* SymbolFlags.ClassMember */ && !(targetProp.flags & 16777216 /* SymbolFlags.Optional */)) {
                     // TypeScript 1.0 spec (April 2014): 3.8.3
                     // S is a subtype of a type T, and T is a supertype of S if ...
                     // S' and T are object types and, for each member M in T..
@@ -68244,7 +68409,7 @@ var ts;
                 ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("checkTypes" /* tracing.Phase.CheckTypes */, "getVariancesWorker", { arity: typeParameters.length, id: getTypeId(getDeclaredTypeOfSymbol(symbol)) });
                 links.variances = ts.emptyArray;
                 var variances = [];
-                var _loop_24 = function (tp) {
+                var _loop_23 = function (tp) {
                     var modifiers = getVarianceModifiers(tp);
                     var variance = modifiers & 65536 /* ModifierFlags.Out */ ?
                         modifiers & 32768 /* ModifierFlags.In */ ? 0 /* VarianceFlags.Invariant */ : 1 /* VarianceFlags.Covariant */ :
@@ -68282,7 +68447,7 @@ var ts;
                 };
                 for (var _i = 0, typeParameters_2 = typeParameters; _i < typeParameters_2.length; _i++) {
                     var tp = typeParameters_2[_i];
-                    _loop_24(tp);
+                    _loop_23(tp);
                 }
                 links.variances = variances;
                 ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop({ variances: variances.map(ts.Debug.formatVariance) });
@@ -68736,8 +68901,7 @@ var ts;
             return !!(type.flags & 109440 /* TypeFlags.Unit */);
         }
         function isUnitLikeType(type) {
-            return type.flags & 2097152 /* TypeFlags.Intersection */ ? ts.some(type.types, isUnitType) :
-                !!(type.flags & 109440 /* TypeFlags.Unit */);
+            return isUnitType(getBaseConstraintOrType(type));
         }
         function extractUnitType(type) {
             return type.flags & 2097152 /* TypeFlags.Intersection */ ? ts.find(type.types, isUnitType) || type : type;
@@ -69616,7 +69780,7 @@ var ts;
                 && (!roundTripOnly || s === ts.pseudoBigIntToString({ negative: negative, base10Value: ts.parsePseudoBigInt(scanner.getTokenValue()) }));
         }
         function isMemberOfStringMapping(source, target) {
-            if (target.flags & (4 /* TypeFlags.String */ | 3 /* TypeFlags.AnyOrUnknown */)) {
+            if (target.flags & (4 /* TypeFlags.String */ | 1 /* TypeFlags.Any */)) {
                 return true;
             }
             if (target.flags & 134217728 /* TypeFlags.TemplateLiteral */) {
@@ -70240,7 +70404,7 @@ var ts;
                 // upon instantiation, would collapse all the placeholders to just 'string', and an assignment check might
                 // succeed. That would be a pointless and confusing outcome.
                 if (matches || ts.every(target.texts, function (s) { return s.length === 0; })) {
-                    var _loop_25 = function (i) {
+                    var _loop_24 = function (i) {
                         var source_1 = matches ? matches[i] : neverType;
                         var target_3 = types[i];
                         // If we are inferring from a string literal type to a type variable whose constraint includes one of the
@@ -70290,7 +70454,7 @@ var ts;
                         inferFromTypes(source_1, target_3);
                     };
                     for (var i = 0; i < types.length; i++) {
-                        _loop_25(i);
+                        _loop_24(i);
                     }
                 }
             }
@@ -70742,7 +70906,7 @@ var ts;
             }
             if (ts.isEntityNameExpression(node.argumentExpression)) {
                 var symbol = resolveEntityName(node.argumentExpression, 111551 /* SymbolFlags.Value */, /*ignoreErrors*/ true);
-                if (!symbol || !isConstVariable(symbol))
+                if (!symbol || !(isConstVariable(symbol) || (symbol.flags & 8 /* SymbolFlags.EnumMember */)))
                     return undefined;
                 var declaration = symbol.valueDeclaration;
                 if (declaration === undefined)
@@ -70756,7 +70920,12 @@ var ts;
                 }
                 if (ts.hasOnlyExpressionInitializer(declaration) && isBlockScopedNameDeclaredBeforeUse(declaration, node.argumentExpression)) {
                     var initializer = ts.getEffectiveInitializer(declaration);
-                    return initializer && tryGetNameFromType(getTypeOfExpression(initializer));
+                    if (initializer) {
+                        return tryGetNameFromType(getTypeOfExpression(initializer));
+                    }
+                    if (ts.isEnumMember(declaration)) {
+                        return ts.getTextOfPropertyName(declaration.name);
+                    }
                 }
             }
             return undefined;
@@ -70814,7 +70983,7 @@ var ts;
         function mapTypesByKeyProperty(types, name) {
             var map = new ts.Map();
             var count = 0;
-            var _loop_26 = function (type) {
+            var _loop_25 = function (type) {
                 if (type.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */ | 58982400 /* TypeFlags.InstantiableNonPrimitive */)) {
                     var discriminant = getTypeOfPropertyOfType(type, name);
                     if (discriminant) {
@@ -70840,9 +71009,9 @@ var ts;
             };
             for (var _i = 0, types_15 = types; _i < types_15.length; _i++) {
                 var type = types_15[_i];
-                var state_10 = _loop_26(type);
-                if (typeof state_10 === "object")
-                    return state_10.value;
+                var state_9 = _loop_25(type);
+                if (typeof state_9 === "object")
+                    return state_9.value;
             }
             return count >= 10 && count * 2 >= types.length ? map : undefined;
         }
@@ -71439,6 +71608,7 @@ var ts;
                     ts.isInJSFile(node) && ts.hasInitializer(node) && node.initializer && ts.isFunctionExpressionOrArrowFunction(node.initializer) && ts.getEffectiveReturnTypeNode(node.initializer));
         }
         function getExplicitTypeOfSymbol(symbol, diagnostic) {
+            symbol = resolveSymbol(symbol);
             if (symbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */ | 32 /* SymbolFlags.Class */ | 512 /* SymbolFlags.ValueModule */)) {
                 return getTypeOfSymbol(symbol);
             }
@@ -71477,7 +71647,7 @@ var ts;
                 switch (node.kind) {
                     case 79 /* SyntaxKind.Identifier */:
                         var symbol = getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(node));
-                        return getExplicitTypeOfSymbol(symbol.flags & 2097152 /* SymbolFlags.Alias */ ? resolveAlias(symbol) : symbol, diagnostic);
+                        return getExplicitTypeOfSymbol(symbol, diagnostic);
                     case 108 /* SyntaxKind.ThisKeyword */:
                         return getExplicitThisType(node);
                     case 106 /* SyntaxKind.SuperKeyword */:
@@ -71964,7 +72134,7 @@ var ts;
                     type = narrowTypeBySwitchOnDiscriminant(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
                 }
                 else if (expr.kind === 218 /* SyntaxKind.TypeOfExpression */ && isMatchingReference(reference, expr.expression)) {
-                    type = narrowBySwitchOnTypeOf(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
+                    type = narrowTypeBySwitchOnTypeOf(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
                 }
                 else {
                     if (strictNullChecks) {
@@ -72245,7 +72415,7 @@ var ts;
                     !!(prop.flags & 16777216 /* SymbolFlags.Optional */) || assumeTrue :
                     !!getApplicableIndexInfoForName(type, propName) || !assumeTrue;
             }
-            function narrowByInKeyword(type, nameType, assumeTrue) {
+            function narrowTypeByInKeyword(type, nameType, assumeTrue) {
                 var name = getPropertyNameFromType(nameType);
                 var isKnownProperty = someType(type, function (t) { return isTypePresencePossible(t, name, /*assumeTrue*/ true); });
                 if (isKnownProperty) {
@@ -72326,7 +72496,7 @@ var ts;
                                 return getTypeWithFacts(type, assumeTrue ? 524288 /* TypeFacts.NEUndefined */ : 65536 /* TypeFacts.EQUndefined */);
                             }
                             if (isMatchingReference(reference, target)) {
-                                return narrowByInKeyword(type, leftType, assumeTrue);
+                                return narrowTypeByInKeyword(type, leftType, assumeTrue);
                             }
                         }
                         break;
@@ -72515,7 +72685,7 @@ var ts;
                                 neverType;
                 });
             }
-            function narrowBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) {
+            function narrowTypeBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) {
                 var witnesses = getSwitchClauseTypeOfWitnesses(switchStatement);
                 if (!witnesses) {
                     return type;
@@ -72903,15 +73073,15 @@ var ts;
             });
         }
         function markAliasReferenced(symbol, location) {
-            if (isNonLocalAlias(symbol, /*excludes*/ 111551 /* SymbolFlags.Value */) && !isInTypeQuery(location) && !getTypeOnlyAliasDeclaration(symbol)) {
+            if (isNonLocalAlias(symbol, /*excludes*/ 111551 /* SymbolFlags.Value */) && !isInTypeQuery(location) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* SymbolFlags.Value */)) {
                 var target = resolveAlias(symbol);
-                if (target.flags & 111551 /* SymbolFlags.Value */) {
+                if (getAllSymbolFlags(target) & (111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */)) {
                     // An alias resolving to a const enum cannot be elided if (1) 'isolatedModules' is enabled
                     // (because the const enum value will not be inlined), or if (2) the alias is an export
                     // of a const enum declaration that will be preserved.
                     if (compilerOptions.isolatedModules ||
                         ts.shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(location) ||
-                        !isConstEnumOrConstEnumOnlyModule(target)) {
+                        !isConstEnumOrConstEnumOnlyModule(getExportSymbolOfValueSymbolIfExported(target))) {
                         markAliasSymbolAsReferenced(symbol);
                     }
                     else {
@@ -73139,7 +73309,7 @@ var ts;
             // We only look for uninitialized variables in strict null checking mode, and only when we can analyze
             // the entire control flow graph from the variable's declaration (i.e. when the flow container and
             // declaration container are the same).
-            var assumeInitialized = isParameter || isAlias || isOuterVariable || isSpreadDestructuringAssignmentTarget || isModuleExports || ts.isBindingElement(declaration) ||
+            var assumeInitialized = isParameter || isAlias || isOuterVariable || isSpreadDestructuringAssignmentTarget || isModuleExports || isSameScopedBindingElement(node, declaration) ||
                 type !== autoType && type !== autoArrayType && (!strictNullChecks || (type.flags & (3 /* TypeFlags.AnyOrUnknown */ | 16384 /* TypeFlags.Void */)) !== 0 ||
                     isInTypeQuery(node) || node.parent.kind === 278 /* SyntaxKind.ExportSpecifier */) ||
                 node.parent.kind === 232 /* SyntaxKind.NonNullExpression */ ||
@@ -73168,6 +73338,12 @@ var ts;
             }
             return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType;
         }
+        function isSameScopedBindingElement(node, declaration) {
+            if (ts.isBindingElement(declaration)) {
+                var bindingElement = ts.findAncestor(node, ts.isBindingElement);
+                return bindingElement && ts.getRootDeclaration(bindingElement) === ts.getRootDeclaration(declaration);
+            }
+        }
         function shouldMarkIdentifierAliasReferenced(node) {
             var _a;
             var parent = node.parent;
@@ -73509,12 +73685,17 @@ var ts;
             var immediateContainer = ts.getSuperContainer(node, /*stopOnFunctions*/ true);
             var container = immediateContainer;
             var needToCaptureLexicalThis = false;
+            var inAsyncFunction = false;
             // adjust the container reference in case if super is used inside arrow functions with arbitrarily deep nesting
             if (!isCallExpression) {
                 while (container && container.kind === 216 /* SyntaxKind.ArrowFunction */) {
+                    if (ts.hasSyntacticModifier(container, 512 /* ModifierFlags.Async */))
+                        inAsyncFunction = true;
                     container = ts.getSuperContainer(container, /*stopOnFunctions*/ true);
                     needToCaptureLexicalThis = languageVersion < 2 /* ScriptTarget.ES2015 */;
                 }
+                if (container && ts.hasSyntacticModifier(container, 512 /* ModifierFlags.Async */))
+                    inAsyncFunction = true;
             }
             var canUseSuperExpression = isLegalUsageOfSuperExpression(container);
             var nodeCheckFlag = 0;
@@ -73620,12 +73801,12 @@ var ts;
             // as a call expression cannot be used as the target of a destructuring assignment while a property access can.
             //
             // For element access expressions (`super[x]`), we emit a generic helper that forwards the element access in both situations.
-            if (container.kind === 171 /* SyntaxKind.MethodDeclaration */ && ts.hasSyntacticModifier(container, 512 /* ModifierFlags.Async */)) {
+            if (container.kind === 171 /* SyntaxKind.MethodDeclaration */ && inAsyncFunction) {
                 if (ts.isSuperProperty(node.parent) && ts.isAssignmentTarget(node.parent)) {
-                    getNodeLinks(container).flags |= 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */;
+                    getNodeLinks(container).flags |= 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */;
                 }
                 else {
-                    getNodeLinks(container).flags |= 2048 /* NodeCheckFlags.AsyncMethodWithSuper */;
+                    getNodeLinks(container).flags |= 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */;
                 }
             }
             if (needToCaptureLexicalThis) {
@@ -74321,9 +74502,10 @@ var ts;
         function instantiateContextualType(contextualType, node, contextFlags) {
             if (contextualType && maybeTypeOfKind(contextualType, 465829888 /* TypeFlags.Instantiable */)) {
                 var inferenceContext = getInferenceContext(node);
-                // If no inferences have been made, nothing is gained from instantiating as type parameters
-                // would just be replaced with their defaults similar to the apparent type.
-                if (inferenceContext && contextFlags & 1 /* ContextFlags.Signature */ && ts.some(inferenceContext.inferences, hasInferenceCandidates)) {
+                // If no inferences have been made, and none of the type parameters for which we are inferring
+                // specify default types, nothing is gained from instantiating as type parameters would just be
+                // replaced with their constraints similar to the apparent type.
+                if (inferenceContext && contextFlags & 1 /* ContextFlags.Signature */ && ts.some(inferenceContext.inferences, hasInferenceCandidatesOrDefault)) {
                     // For contextual signatures we incorporate all inferences made so far, e.g. from return
                     // types as well as arguments to the left in a function call.
                     return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
@@ -77297,7 +77479,7 @@ var ts;
             if (spreadIndex >= 0) {
                 // Create synthetic arguments from spreads of tuple types.
                 var effectiveArgs_1 = args.slice(0, spreadIndex);
-                var _loop_27 = function (i) {
+                var _loop_26 = function (i) {
                     var arg = args[i];
                     // We can call checkExpressionCached because spread expressions never have a contextual type.
                     var spreadType = arg.kind === 227 /* SyntaxKind.SpreadElement */ && (flowLoopCount ? checkExpression(arg.expression) : checkExpressionCached(arg.expression));
@@ -77314,7 +77496,7 @@ var ts;
                     }
                 };
                 for (var i = spreadIndex; i < args.length; i++) {
-                    _loop_27(i);
+                    _loop_26(i);
                 }
                 return effectiveArgs_1;
             }
@@ -77643,7 +77825,7 @@ var ts;
                         var min_3 = Number.MAX_VALUE;
                         var minIndex = 0;
                         var i_1 = 0;
-                        var _loop_28 = function (c) {
+                        var _loop_27 = function (c) {
                             var chain_2 = function () { return ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Overload_0_of_1_2_gave_the_following_error, i_1 + 1, candidates.length, signatureToString(c)); };
                             var diags_2 = getSignatureApplicabilityError(node, args, c, assignableRelation, 0 /* CheckMode.Normal */, /*reportErrors*/ true, chain_2);
                             if (diags_2) {
@@ -77661,7 +77843,7 @@ var ts;
                         };
                         for (var _a = 0, candidatesForArgumentError_1 = candidatesForArgumentError; _a < candidatesForArgumentError_1.length; _a++) {
                             var c = candidatesForArgumentError_1[_a];
-                            _loop_28(c);
+                            _loop_27(c);
                         }
                         var diags_3 = max > 1 ? allDiagnostics[minIndex] : ts.flatten(allDiagnostics);
                         ts.Debug.assert(diags_3.length > 0, "No errors reported for 3 or fewer overload signatures");
@@ -77819,7 +78001,7 @@ var ts;
             }
             var _a = ts.minAndMax(candidates, getNumNonRestParameters), minArgumentCount = _a.min, maxNonRestParam = _a.max;
             var parameters = [];
-            var _loop_29 = function (i) {
+            var _loop_28 = function (i) {
                 var symbols = ts.mapDefined(candidates, function (s) { return signatureHasRestParameter(s) ?
                     i < s.parameters.length - 1 ? s.parameters[i] : ts.last(s.parameters) :
                     i < s.parameters.length ? s.parameters[i] : undefined; });
@@ -77827,7 +78009,7 @@ var ts;
                 parameters.push(createCombinedSymbolFromTypes(symbols, ts.mapDefined(candidates, function (candidate) { return tryGetTypeAtPosition(candidate, i); })));
             };
             for (var i = 0; i < maxNonRestParam; i++) {
-                _loop_29(i);
+                _loop_28(i);
             }
             var restParameterSymbols = ts.mapDefined(candidates, function (c) { return signatureHasRestParameter(c) ? ts.last(c.parameters) : undefined; });
             var flags = 0 /* SignatureFlags.None */;
@@ -78797,7 +78979,7 @@ var ts;
                     if (symbol && symbol.flags & 2097152 /* SymbolFlags.Alias */) {
                         symbol = resolveAlias(symbol);
                     }
-                    return !!(symbol && (symbol.flags & 384 /* SymbolFlags.Enum */) && getEnumKind(symbol) === 1 /* EnumKind.Literal */);
+                    return !!(symbol && (getAllSymbolFlags(symbol) & 384 /* SymbolFlags.Enum */) && getEnumKind(symbol) === 1 /* EnumKind.Literal */);
             }
             return false;
         }
@@ -79459,7 +79641,17 @@ var ts;
         }
         function isExhaustiveSwitchStatement(node) {
             var links = getNodeLinks(node);
-            return links.isExhaustive !== undefined ? links.isExhaustive : (links.isExhaustive = computeExhaustiveSwitchStatement(node));
+            if (links.isExhaustive === undefined) {
+                links.isExhaustive = 0; // Indicate resolution is in process
+                var exhaustive = computeExhaustiveSwitchStatement(node);
+                if (links.isExhaustive === 0) {
+                    links.isExhaustive = exhaustive;
+                }
+            }
+            else if (links.isExhaustive === 0) {
+                links.isExhaustive = false; // Resolve circularity to false
+            }
+            return links.isExhaustive;
         }
         function computeExhaustiveSwitchStatement(node) {
             if (node.expression.kind === 218 /* SyntaxKind.TypeOfExpression */) {
@@ -79467,7 +79659,7 @@ var ts;
                 if (!witnesses) {
                     return false;
                 }
-                var operandConstraint = getBaseConstraintOrType(getTypeOfExpression(node.expression.expression));
+                var operandConstraint = getBaseConstraintOrType(checkExpressionCached(node.expression.expression));
                 // Get the not-equal flags for all handled cases.
                 var notEqualFacts_2 = getNotEqualFactsFromTypeofSwitch(0, 0, witnesses);
                 if (operandConstraint.flags & 3 /* TypeFlags.AnyOrUnknown */) {
@@ -79477,7 +79669,7 @@ var ts;
                 // A missing not-equal flag indicates that the type wasn't handled by some case.
                 return !someType(operandConstraint, function (t) { return (getTypeFacts(t) & notEqualFacts_2) === notEqualFacts_2; });
             }
-            var type = getTypeOfExpression(node.expression);
+            var type = checkExpressionCached(node.expression);
             if (!isLiteralType(type)) {
                 return false;
             }
@@ -81171,6 +81363,9 @@ var ts;
         function hasInferenceCandidates(info) {
             return !!(info.candidates || info.contraCandidates);
         }
+        function hasInferenceCandidatesOrDefault(info) {
+            return !!(info.candidates || info.contraCandidates || hasTypeParameterDefault(info.typeParameter));
+        }
         function hasOverlappingInferences(a, b) {
             for (var i = 0; i < a.length; i++) {
                 if (hasInferenceCandidates(a[i]) && hasInferenceCandidates(b[i])) {
@@ -81872,7 +82067,7 @@ var ts;
             var indexSymbol = getIndexSymbol(getSymbolOfNode(node));
             if (indexSymbol === null || indexSymbol === void 0 ? void 0 : indexSymbol.declarations) {
                 var indexSignatureMap_1 = new ts.Map();
-                var _loop_30 = function (declaration) {
+                var _loop_29 = function (declaration) {
                     if (declaration.parameters.length === 1 && declaration.parameters[0].type) {
                         forEachType(getTypeFromTypeNode(declaration.parameters[0].type), function (type) {
                             var entry = indexSignatureMap_1.get(getTypeId(type));
@@ -81887,7 +82082,7 @@ var ts;
                 };
                 for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) {
                     var declaration = _a[_i];
-                    _loop_30(declaration);
+                    _loop_29(declaration);
                 }
                 indexSignatureMap_1.forEach(function (entry) {
                     if (entry.declarations.length > 1) {
@@ -82164,7 +82359,7 @@ var ts;
                 }
                 var symbol = getNodeLinks(node).resolvedSymbol;
                 if (symbol) {
-                    if (ts.some(symbol.declarations, function (d) { return isTypeDeclaration(d) && !!(d.flags & 268435456 /* NodeFlags.Deprecated */); })) {
+                    if (ts.some(symbol.declarations, function (d) { return ts.isTypeDeclaration(d) && !!(d.flags & 268435456 /* NodeFlags.Deprecated */); })) {
                         addDeprecatedSuggestion(getDeprecatedSuggestionNode(node), symbol.declarations, symbol.escapedName);
                     }
                     if (type.flags & 32 /* TypeFlags.Enum */ && symbol.flags & 8 /* SymbolFlags.EnumMember */) {
@@ -82767,7 +82962,7 @@ var ts;
                 return typeAsPromise.promisedTypeOfPromise = getTypeArguments(type)[0];
             }
             // primitives with a `{ then() }` won't be unwrapped/adopted.
-            if (allTypesAssignableToKind(type, 131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */)) {
+            if (allTypesAssignableToKind(getBaseConstraintOrType(type), 131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */)) {
                 return undefined;
             }
             var thenFunction = getTypeOfPropertyOfType(type, "then"); // TODO: GH#18217
@@ -82834,7 +83029,7 @@ var ts;
          * Determines whether a type is an object with a callable `then` member.
          */
         function isThenableType(type) {
-            if (allTypesAssignableToKind(type, 131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */)) {
+            if (allTypesAssignableToKind(getBaseConstraintOrType(type), 131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */)) {
                 // primitive types cannot be considered "thenable" since they are not objects.
                 return false;
             }
@@ -82868,7 +83063,7 @@ var ts;
                 // We only need `Awaited<T>` if `T` is a type variable that has no base constraint, or the base constraint of `T` is `any`, `unknown`, `{}`, `object`,
                 // or is promise-like.
                 if (baseConstraint ?
-                    baseConstraint.flags & 3 /* TypeFlags.AnyOrUnknown */ || isEmptyObjectType(baseConstraint) || isThenableType(baseConstraint) :
+                    baseConstraint.flags & 3 /* TypeFlags.AnyOrUnknown */ || isEmptyObjectType(baseConstraint) || someType(baseConstraint, isThenableType) :
                     maybeTypeOfKind(type, 8650752 /* TypeFlags.TypeVariable */)) {
                     return true;
                 }
@@ -83542,7 +83737,7 @@ var ts;
         }
         function errorUnusedLocal(declaration, name, addDiagnostic) {
             var node = ts.getNameOfDeclaration(declaration) || declaration;
-            var message = isTypeDeclaration(declaration) ? ts.Diagnostics._0_is_declared_but_never_used : ts.Diagnostics._0_is_declared_but_its_value_is_never_read;
+            var message = ts.isTypeDeclaration(declaration) ? ts.Diagnostics._0_is_declared_but_never_used : ts.Diagnostics._0_is_declared_but_its_value_is_never_read;
             addDiagnostic(declaration, 0 /* UnusedKind.Local */, ts.createDiagnosticForNode(node, message, name));
         }
         function isIdentifierThatStartsWithUnderscore(node) {
@@ -84972,7 +85167,16 @@ var ts;
             var message = allowAsyncIterables
                 ? ts.Diagnostics.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator
                 : ts.Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator;
-            return errorAndMaybeSuggestAwait(errorNode, !!getAwaitedTypeOfPromise(type), message, typeToString(type));
+            var suggestAwait = 
+            // for (const x of Promise<...>) or [...Promise<...>]
+            !!getAwaitedTypeOfPromise(type)
+                // for (const x of AsyncIterable<...>)
+                || (!allowAsyncIterables &&
+                    ts.isForOfStatement(errorNode.parent) &&
+                    errorNode.parent.expression === errorNode &&
+                    getGlobalAsyncIterableType(/** reportErrors */ false) !== emptyGenericType &&
+                    isTypeAssignableTo(type, getGlobalAsyncIterableType(/** reportErrors */ false)));
+            return errorAndMaybeSuggestAwait(errorNode, suggestAwait, message, typeToString(type));
         }
         /**
          * Gets the *yield*, *return*, and *next* types from an `Iterator`-like or `AsyncIterator`-like type.
@@ -85487,7 +85691,7 @@ var ts;
             var propDeclaration = declaration && declaration.kind === 223 /* SyntaxKind.BinaryExpression */ ||
                 name && name.kind === 164 /* SyntaxKind.ComputedPropertyName */ ? declaration : undefined;
             var localPropDeclaration = getParentOfSymbol(prop) === type.symbol ? declaration : undefined;
-            var _loop_31 = function (info) {
+            var _loop_30 = function (info) {
                 var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined;
                 // We check only when (a) the property is declared in the containing type, or (b) the applicable index signature is declared
                 // in the containing type, or (c) the containing type is an interface and no base interface contains both the property and
@@ -85504,7 +85708,7 @@ var ts;
             };
             for (var _i = 0, indexInfos_9 = indexInfos; _i < indexInfos_9.length; _i++) {
                 var info = indexInfos_9[_i];
-                _loop_31(info);
+                _loop_30(info);
             }
         }
         function checkIndexConstraintForIndexSignature(type, checkInfo) {
@@ -85512,7 +85716,7 @@ var ts;
             var indexInfos = getApplicableIndexInfos(type, checkInfo.keyType);
             var interfaceDeclaration = ts.getObjectFlags(type) & 2 /* ObjectFlags.Interface */ ? ts.getDeclarationOfKind(type.symbol, 261 /* SyntaxKind.InterfaceDeclaration */) : undefined;
             var localCheckDeclaration = declaration && getParentOfSymbol(getSymbolOfNode(declaration)) === type.symbol ? declaration : undefined;
-            var _loop_32 = function (info) {
+            var _loop_31 = function (info) {
                 if (info === checkInfo)
                     return "continue";
                 var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined;
@@ -85527,7 +85731,7 @@ var ts;
             };
             for (var _i = 0, indexInfos_10 = indexInfos; _i < indexInfos_10.length; _i++) {
                 var info = indexInfos_10[_i];
-                _loop_32(info);
+                _loop_31(info);
             }
         }
         function checkTypeNameIsReserved(name, message) {
@@ -85582,7 +85786,7 @@ var ts;
             }
             else {
                 ts.forEach(jsdocParameters, function (_a, index) {
-                    var name = _a.name;
+                    var name = _a.name, isNameFirst = _a.isNameFirst;
                     if (excludedParameters.has(index) || ts.isIdentifier(name) && parameters.has(name.escapedText)) {
                         return;
                     }
@@ -85592,7 +85796,9 @@ var ts;
                         }
                     }
                     else {
-                        errorOrSuggestion(isJs, name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name, ts.idText(name));
+                        if (!isNameFirst) {
+                            errorOrSuggestion(isJs, name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name, ts.idText(name));
+                        }
                     }
                 });
             }
@@ -85847,7 +86053,7 @@ var ts;
             var baseTypes = baseTypeNode && getBaseTypes(type);
             var baseWithThis = (baseTypes === null || baseTypes === void 0 ? void 0 : baseTypes.length) ? getTypeWithThisArgument(ts.first(baseTypes), type.thisType) : undefined;
             var baseStaticType = getBaseConstructorTypeOfClass(type);
-            var _loop_33 = function (member) {
+            var _loop_32 = function (member) {
                 if (ts.hasAmbientModifier(member)) {
                     return "continue";
                 }
@@ -85864,7 +86070,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_33(member);
+                _loop_32(member);
             }
         }
         /**
@@ -85952,7 +86158,7 @@ var ts;
         function issueMemberSpecificError(node, typeWithThis, baseWithThis, broadDiag) {
             // iterate over all implemented properties and issue errors on each one which isn't compatible, rather than the class as a whole, if possible
             var issuedMemberError = false;
-            var _loop_34 = function (member) {
+            var _loop_33 = function (member) {
                 if (ts.isStatic(member)) {
                     return "continue";
                 }
@@ -85971,7 +86177,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_34(member);
+                _loop_33(member);
             }
             if (!issuedMemberError) {
                 // check again with diagnostics to generate a less-specific error
@@ -86042,7 +86248,7 @@ var ts;
             var _a, _b, _c, _d;
             // NOTE: assignability is checked in checkClassDeclaration
             var baseProperties = getPropertiesOfType(baseType);
-            var _loop_35 = function (baseProperty) {
+            var _loop_34 = function (baseProperty) {
                 var base = getTargetSymbol(baseProperty);
                 if (base.flags & 4194304 /* SymbolFlags.Prototype */) {
                     return "continue";
@@ -86152,8 +86358,8 @@ var ts;
             };
             basePropertyCheck: for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) {
                 var baseProperty = baseProperties_1[_i];
-                var state_11 = _loop_35(baseProperty);
-                switch (state_11) {
+                var state_10 = _loop_34(baseProperty);
+                switch (state_10) {
                     case "continue-basePropertyCheck": continue basePropertyCheck;
                 }
             }
@@ -86672,12 +86878,11 @@ var ts;
             }
         }
         function checkModuleAugmentationElement(node, isGlobalAugmentation) {
-            var _a;
             switch (node.kind) {
                 case 240 /* SyntaxKind.VariableStatement */:
                     // error each individual name in variable statement instead of marking the entire variable statement
-                    for (var _i = 0, _b = node.declarationList.declarations; _i < _b.length; _i++) {
-                        var decl = _b[_i];
+                    for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) {
+                        var decl = _a[_i];
                         checkModuleAugmentationElement(decl, isGlobalAugmentation);
                     }
                     break;
@@ -86693,8 +86898,8 @@ var ts;
                 case 257 /* SyntaxKind.VariableDeclaration */:
                     var name = node.name;
                     if (ts.isBindingPattern(name)) {
-                        for (var _c = 0, _d = name.elements; _c < _d.length; _c++) {
-                            var el = _d[_c];
+                        for (var _b = 0, _c = name.elements; _b < _c.length; _b++) {
+                            var el = _c[_b];
                             // mark individual names in binding pattern
                             checkModuleAugmentationElement(el, isGlobalAugmentation);
                         }
@@ -86710,18 +86915,6 @@ var ts;
                     if (isGlobalAugmentation) {
                         return;
                     }
-                    var symbol = getSymbolOfNode(node);
-                    if (symbol) {
-                        // module augmentations cannot introduce new names on the top level scope of the module
-                        // this is done it two steps
-                        // 1. quick check - if symbol for node is not merged - this is local symbol to this augmentation - report error
-                        // 2. main check - report error if value declaration of the parent symbol is module augmentation)
-                        var reportError = !(symbol.flags & 33554432 /* SymbolFlags.Transient */);
-                        if (!reportError) {
-                            // symbol should not originate in augmentation
-                            reportError = !!((_a = symbol.parent) === null || _a === void 0 ? void 0 : _a.declarations) && ts.isExternalModuleAugmentation(symbol.parent.declarations[0]);
-                        }
-                    }
                     break;
             }
         }
@@ -86823,10 +87016,11 @@ var ts;
                     }
                     return;
                 }
+                var targetFlags = getAllSymbolFlags(target);
                 var excludedMeanings = (symbol.flags & (111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */) ? 111551 /* SymbolFlags.Value */ : 0) |
                     (symbol.flags & 788968 /* SymbolFlags.Type */ ? 788968 /* SymbolFlags.Type */ : 0) |
                     (symbol.flags & 1920 /* SymbolFlags.Namespace */ ? 1920 /* SymbolFlags.Namespace */ : 0);
-                if (target.flags & excludedMeanings) {
+                if (targetFlags & excludedMeanings) {
                     var message = node.kind === 278 /* SyntaxKind.ExportSpecifier */ ?
                         ts.Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 :
                         ts.Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0;
@@ -86836,7 +87030,7 @@ var ts;
                     && !ts.isTypeOnlyImportOrExportDeclaration(node)
                     && !(node.flags & 16777216 /* NodeFlags.Ambient */)) {
                     var typeOnlyAlias = getTypeOnlyAliasDeclaration(symbol);
-                    var isType = !(target.flags & 111551 /* SymbolFlags.Value */);
+                    var isType = !(targetFlags & 111551 /* SymbolFlags.Value */);
                     if (isType || typeOnlyAlias) {
                         switch (node.kind) {
                             case 270 /* SyntaxKind.ImportClause */:
@@ -86996,14 +87190,15 @@ var ts;
                 if (node.moduleReference.kind !== 280 /* SyntaxKind.ExternalModuleReference */) {
                     var target = resolveAlias(getSymbolOfNode(node));
                     if (target !== unknownSymbol) {
-                        if (target.flags & 111551 /* SymbolFlags.Value */) {
+                        var targetFlags = getAllSymbolFlags(target);
+                        if (targetFlags & 111551 /* SymbolFlags.Value */) {
                             // Target is a value symbol, check that it is not hidden by a local declaration with the same name
                             var moduleName = ts.getFirstIdentifier(node.moduleReference);
                             if (!(resolveEntityName(moduleName, 111551 /* SymbolFlags.Value */ | 1920 /* SymbolFlags.Namespace */).flags & 1920 /* SymbolFlags.Namespace */)) {
                                 error(moduleName, ts.Diagnostics.Module_0_is_hidden_by_a_local_declaration_with_the_same_name, ts.declarationNameToString(moduleName));
                             }
                         }
-                        if (target.flags & 788968 /* SymbolFlags.Type */) {
+                        if (targetFlags & 788968 /* SymbolFlags.Type */) {
                             checkTypeNameIsReserved(node.name, ts.Diagnostics.Import_name_cannot_be_0);
                         }
                     }
@@ -87142,7 +87337,7 @@ var ts;
                         markExportAsReferenced(node);
                     }
                     var target = symbol && (symbol.flags & 2097152 /* SymbolFlags.Alias */ ? resolveAlias(symbol) : symbol);
-                    if (!target || target === unknownSymbol || target.flags & 111551 /* SymbolFlags.Value */) {
+                    if (!target || getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */) {
                         checkExpressionCached(node.propertyName || node.name);
                     }
                 }
@@ -87189,7 +87384,7 @@ var ts;
                     markAliasReferenced(sym, id);
                     // If not a value, we're interpreting the identifier as a type export, along the lines of (`export { Id as default }`)
                     var target = sym.flags & 2097152 /* SymbolFlags.Alias */ ? resolveAlias(sym) : sym;
-                    if (target === unknownSymbol || target.flags & 111551 /* SymbolFlags.Value */) {
+                    if (getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */) {
                         // However if it is a value, we need to check it's being used correctly
                         checkExpressionCached(node.expression);
                     }
@@ -87861,29 +88056,9 @@ var ts;
         }
         function isTypeDeclarationName(name) {
             return name.kind === 79 /* SyntaxKind.Identifier */ &&
-                isTypeDeclaration(name.parent) &&
+                ts.isTypeDeclaration(name.parent) &&
                 ts.getNameOfDeclaration(name.parent) === name;
         }
-        function isTypeDeclaration(node) {
-            switch (node.kind) {
-                case 165 /* SyntaxKind.TypeParameter */:
-                case 260 /* SyntaxKind.ClassDeclaration */:
-                case 261 /* SyntaxKind.InterfaceDeclaration */:
-                case 262 /* SyntaxKind.TypeAliasDeclaration */:
-                case 263 /* SyntaxKind.EnumDeclaration */:
-                case 348 /* SyntaxKind.JSDocTypedefTag */:
-                case 341 /* SyntaxKind.JSDocCallbackTag */:
-                case 342 /* SyntaxKind.JSDocEnumTag */:
-                    return true;
-                case 270 /* SyntaxKind.ImportClause */:
-                    return node.isTypeOnly;
-                case 273 /* SyntaxKind.ImportSpecifier */:
-                case 278 /* SyntaxKind.ExportSpecifier */:
-                    return node.parent.parent.isTypeOnly;
-                default:
-                    return false;
-            }
-        }
         // True if the given identifier is part of a type reference
         function isTypeReferenceIdentifier(node) {
             while (node.parent.kind === 163 /* SyntaxKind.QualifiedName */) {
@@ -88316,7 +88491,7 @@ var ts;
                 var baseType = ts.firstOrUndefined(getBaseTypes(classType));
                 return baseType ? getTypeWithThisArgument(baseType, classType.thisType) : errorType;
             }
-            if (isTypeDeclaration(node)) {
+            if (ts.isTypeDeclaration(node)) {
                 // In this case, we call getSymbolOfNode instead of getSymbolAtLocation because it is a declaration
                 var symbol = getSymbolOfNode(node);
                 return getDeclaredTypeOfSymbol(symbol);
@@ -88511,7 +88686,7 @@ var ts;
             return symbolLinks.exportsSomeValue;
             function isValue(s) {
                 s = resolveSymbol(s);
-                return s && !!(s.flags & 111551 /* SymbolFlags.Value */);
+                return s && !!(getAllSymbolFlags(s) & 111551 /* SymbolFlags.Value */);
             }
         }
         function isNameOfModuleOrEnumDeclaration(node) {
@@ -88564,7 +88739,7 @@ var ts;
                 var symbol = getReferencedValueOrAliasSymbol(node);
                 // We should only get the declaration of an alias if there isn't a local value
                 // declaration for the symbol
-                if (isNonLocalAlias(symbol, /*excludes*/ 111551 /* SymbolFlags.Value */) && !getTypeOnlyAliasDeclaration(symbol)) {
+                if (isNonLocalAlias(symbol, /*excludes*/ 111551 /* SymbolFlags.Value */) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* SymbolFlags.Value */)) {
                     return getDeclarationOfAliasSymbol(symbol);
                 }
             }
@@ -88652,7 +88827,7 @@ var ts;
                 case 273 /* SyntaxKind.ImportSpecifier */:
                 case 278 /* SyntaxKind.ExportSpecifier */:
                     var symbol = getSymbolOfNode(node);
-                    return !!symbol && isAliasResolvedToValue(symbol) && !getTypeOnlyAliasDeclaration(symbol);
+                    return !!symbol && isAliasResolvedToValue(symbol) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* SymbolFlags.Value */);
                 case 275 /* SyntaxKind.ExportDeclaration */:
                     var exportClause = node.exportClause;
                     return !!exportClause && (ts.isNamespaceExport(exportClause) ||
@@ -88674,6 +88849,7 @@ var ts;
             return isValue && node.moduleReference && !ts.nodeIsMissing(node.moduleReference);
         }
         function isAliasResolvedToValue(symbol) {
+            var _a;
             if (!symbol) {
                 return false;
             }
@@ -88683,7 +88859,7 @@ var ts;
             }
             // const enums and modules that contain only const enums are not considered values from the emit perspective
             // unless 'preserveConstEnums' option is set to true
-            return !!(target.flags & 111551 /* SymbolFlags.Value */) &&
+            return !!(((_a = getAllSymbolFlags(target)) !== null && _a !== void 0 ? _a : -1) & 111551 /* SymbolFlags.Value */) &&
                 (ts.shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target));
         }
         function isConstEnumOrConstEnumOnlyModule(s) {
@@ -88698,7 +88874,7 @@ var ts;
                 }
                 var target = getSymbolLinks(symbol).aliasTarget; // TODO: GH#18217
                 if (target && ts.getEffectiveModifierFlags(node) & 1 /* ModifierFlags.Export */ &&
-                    target.flags & 111551 /* SymbolFlags.Value */ &&
+                    getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */ &&
                     (ts.shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target))) {
                     // An `export import ... =` of a value symbol is always considered referenced
                     return true;
@@ -98352,8 +98528,11 @@ var ts;
                     }
                     return ts.visitEachChild(node, visitor, context);
                 case 174 /* SyntaxKind.GetAccessor */:
+                    return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitGetAccessorDeclaration, node);
                 case 175 /* SyntaxKind.SetAccessor */:
+                    return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitSetAccessorDeclaration, node);
                 case 173 /* SyntaxKind.Constructor */:
+                    return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitConstructorDeclaration, node);
                 case 260 /* SyntaxKind.ClassDeclaration */:
                 case 228 /* SyntaxKind.ClassExpression */:
                     return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitDefault, node);
@@ -98454,6 +98633,9 @@ var ts;
             return ts.setOriginalNode(ts.setTextRange(factory.createYieldExpression(
             /*asteriskToken*/ undefined, ts.visitNode(node.expression, visitor, ts.isExpression)), node), node);
         }
+        function visitConstructorDeclaration(node) {
+            return factory.updateConstructorDeclaration(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), ts.visitParameterList(node.parameters, visitor, context), transformMethodBody(node));
+        }
         /**
          * Visits a MethodDeclaration node.
          *
@@ -98468,7 +98650,14 @@ var ts;
             /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), 
             /*type*/ undefined, ts.getFunctionFlags(node) & 2 /* FunctionFlags.Async */
                 ? transformAsyncFunctionBody(node)
-                : ts.visitFunctionBody(node.body, visitor, context));
+                : transformMethodBody(node));
+        }
+        function visitGetAccessorDeclaration(node) {
+            return factory.updateGetAccessorDeclaration(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), node.name, ts.visitParameterList(node.parameters, visitor, context), 
+            /*type*/ undefined, transformMethodBody(node));
+        }
+        function visitSetAccessorDeclaration(node) {
+            return factory.updateSetAccessorDeclaration(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), node.name, ts.visitParameterList(node.parameters, visitor, context), transformMethodBody(node));
         }
         /**
          * Visits a FunctionDeclaration node.
@@ -98582,6 +98771,42 @@ var ts;
             }
             return false;
         }
+        function transformMethodBody(node) {
+            ts.Debug.assertIsDefined(node.body);
+            var savedCapturedSuperProperties = capturedSuperProperties;
+            var savedHasSuperElementAccess = hasSuperElementAccess;
+            capturedSuperProperties = new ts.Set();
+            hasSuperElementAccess = false;
+            var updated = ts.visitFunctionBody(node.body, visitor, context);
+            // Minor optimization, emit `_super` helper to capture `super` access in an arrow.
+            // This step isn't needed if we eventually transform this to ES5.
+            var originalMethod = ts.getOriginalNode(node, ts.isFunctionLikeDeclaration);
+            var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ &&
+                resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */) &&
+                (ts.getFunctionFlags(originalMethod) & 3 /* FunctionFlags.AsyncGenerator */) !== 3 /* FunctionFlags.AsyncGenerator */;
+            if (emitSuperHelpers) {
+                enableSubstitutionForAsyncMethodsWithSuper();
+                if (capturedSuperProperties.size) {
+                    var variableStatement = createSuperAccessVariableStatement(factory, resolver, node, capturedSuperProperties);
+                    substitutedSuperAccessors[ts.getNodeId(variableStatement)] = true;
+                    var statements = updated.statements.slice();
+                    ts.insertStatementsAfterStandardPrologue(statements, [variableStatement]);
+                    updated = factory.updateBlock(updated, statements);
+                }
+                if (hasSuperElementAccess) {
+                    // Emit helpers for super element access expressions (`super[x]`).
+                    if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) {
+                        ts.addEmitHelper(updated, ts.advancedAsyncSuperHelper);
+                    }
+                    else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */) {
+                        ts.addEmitHelper(updated, ts.asyncSuperHelper);
+                    }
+                }
+            }
+            capturedSuperProperties = savedCapturedSuperProperties;
+            hasSuperElementAccess = savedHasSuperElementAccess;
+            return updated;
+        }
         function transformAsyncFunctionBody(node) {
             resumeLexicalEnvironment();
             var original = ts.getOriginalNode(node, ts.isFunctionLike);
@@ -98614,7 +98839,7 @@ var ts;
                 ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
                 // Minor optimization, emit `_super` helper to capture `super` access in an arrow.
                 // This step isn't needed if we eventually transform this to ES5.
-                var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */ | 2048 /* NodeCheckFlags.AsyncMethodWithSuper */);
+                var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */);
                 if (emitSuperHelpers) {
                     enableSubstitutionForAsyncMethodsWithSuper();
                     if (capturedSuperProperties.size) {
@@ -98627,10 +98852,10 @@ var ts;
                 ts.setTextRange(block, node.body);
                 if (emitSuperHelpers && hasSuperElementAccess) {
                     // Emit helpers for super element access expressions (`super[x]`).
-                    if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */) {
+                    if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) {
                         ts.addEmitHelper(block, ts.advancedAsyncSuperHelper);
                     }
-                    else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.AsyncMethodWithSuper */) {
+                    else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */) {
                         ts.addEmitHelper(block, ts.asyncSuperHelper);
                     }
                 }
@@ -98702,7 +98927,7 @@ var ts;
             // If we need to support substitutions for `super` in an async method,
             // we should track it here.
             if (enabledSubstitutions & 1 /* ES2017SubstitutionFlags.AsyncMethodsWithSuper */ && isSuperContainer(node)) {
-                var superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* NodeCheckFlags.AsyncMethodWithSuper */ | 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */);
+                var superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */ | 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */);
                 if (superContainerFlags !== enclosingSuperContainerFlags) {
                     var savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
                     enclosingSuperContainerFlags = superContainerFlags;
@@ -98779,7 +99004,7 @@ var ts;
                 || kind === 175 /* SyntaxKind.SetAccessor */;
         }
         function createSuperElementAccessInAsyncMethod(argumentExpression, location) {
-            if (enclosingSuperContainerFlags & 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */) {
+            if (enclosingSuperContainerFlags & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) {
                 return ts.setTextRange(factory.createPropertyAccessExpression(factory.createCallExpression(factory.createUniqueName("_superIndex", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */), 
                 /*typeArguments*/ undefined, [argumentExpression]), "value"), location);
             }
@@ -98794,7 +99019,7 @@ var ts;
     function createSuperAccessVariableStatement(factory, resolver, node, names) {
         // Create a variable declaration with a getter/setter (if binding) definition for each name:
         //   const _super = Object.create(null, { x: { get: () => super.x, set: (v) => super.x = v }, ... });
-        var hasBinding = (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */) !== 0;
+        var hasBinding = (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) !== 0;
         var accessors = [];
         names.forEach(function (_, key) {
             var name = ts.unescapeLeadingUnderscores(key);
@@ -99287,11 +99512,22 @@ var ts;
             }
             return node;
         }
-        function convertForOfStatementHead(node, boundValue) {
-            var binding = ts.createForOfBindingStatement(factory, node.initializer, boundValue);
+        function convertForOfStatementHead(node, boundValue, nonUserCode) {
+            var value = factory.createTempVariable(hoistVariableDeclaration);
+            var iteratorValueExpression = factory.createAssignment(value, boundValue);
+            var iteratorValueStatement = factory.createExpressionStatement(iteratorValueExpression);
+            ts.setSourceMapRange(iteratorValueStatement, node.expression);
+            var exitNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createFalse());
+            var exitNonUserCodeStatement = factory.createExpressionStatement(exitNonUserCodeExpression);
+            ts.setSourceMapRange(exitNonUserCodeStatement, node.expression);
+            var enterNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createTrue());
+            var enterNonUserCodeStatement = factory.createExpressionStatement(enterNonUserCodeExpression);
+            ts.setSourceMapRange(exitNonUserCodeStatement, node.expression);
+            var statements = [];
+            var binding = ts.createForOfBindingStatement(factory, node.initializer, value);
+            statements.push(ts.visitNode(binding, visitor, ts.isStatement));
             var bodyLocation;
             var statementsLocation;
-            var statements = [ts.visitNode(binding, visitor, ts.isStatement)];
             var statement = ts.visitIterationBody(node.statement, visitor, context);
             if (ts.isBlock(statement)) {
                 ts.addRange(statements, statement.statements);
@@ -99301,8 +99537,16 @@ var ts;
             else {
                 statements.push(statement);
             }
-            return ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation), 
+            var body = ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation), 
             /*multiLine*/ true), bodyLocation), 48 /* EmitFlags.NoSourceMap */ | 384 /* EmitFlags.NoTokenSourceMaps */);
+            return factory.createBlock([
+                iteratorValueStatement,
+                exitNonUserCodeStatement,
+                factory.createTryStatement(body, 
+                /*catchClause*/ undefined, factory.createBlock([
+                    enterNonUserCodeStatement
+                ]))
+            ]);
         }
         function createDownlevelAwait(expression) {
             return enclosingFunctionFlags & 1 /* FunctionFlags.Generator */
@@ -99313,6 +99557,8 @@ var ts;
             var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
             var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(/*recordTempVariable*/ undefined);
             var result = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(iterator) : factory.createTempVariable(/*recordTempVariable*/ undefined);
+            var nonUserCode = factory.createTempVariable(/*recordTempVariable*/ undefined);
+            var done = factory.createTempVariable(hoistVariableDeclaration);
             var errorRecord = factory.createUniqueName("e");
             var catchVariable = factory.getGeneratedNameForNode(errorRecord);
             var returnMethod = factory.createTempVariable(/*recordTempVariable*/ undefined);
@@ -99329,12 +99575,17 @@ var ts;
                 callValues;
             var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement(
             /*initializer*/ ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([
+                factory.createVariableDeclaration(nonUserCode, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createTrue()),
                 ts.setTextRange(factory.createVariableDeclaration(iterator, /*exclamationToken*/ undefined, /*type*/ undefined, initializer), node.expression),
                 factory.createVariableDeclaration(result)
             ]), node.expression), 2097152 /* EmitFlags.NoHoisting */), 
-            /*condition*/ factory.createComma(factory.createAssignment(result, createDownlevelAwait(callNext)), factory.createLogicalNot(getDone)), 
+            /*condition*/ factory.inlineExpressions([
+                factory.createAssignment(result, createDownlevelAwait(callNext)),
+                factory.createAssignment(done, getDone),
+                factory.createLogicalNot(done)
+            ]), 
             /*incrementor*/ undefined, 
-            /*statement*/ convertForOfStatementHead(node, getValue)), 
+            /*statement*/ convertForOfStatementHead(node, getValue, nonUserCode)), 
             /*location*/ node), 256 /* EmitFlags.NoTokenTrailingSourceMaps */);
             ts.setOriginalNode(forStatement, node);
             return factory.createTryStatement(factory.createBlock([
@@ -99346,7 +99597,7 @@ var ts;
             ]), 1 /* EmitFlags.SingleLine */)), factory.createBlock([
                 factory.createTryStatement(
                 /*tryBlock*/ factory.createBlock([
-                    ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(result, factory.createLogicalNot(getDone)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1 /* EmitFlags.SingleLine */)
+                    ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(factory.createLogicalNot(nonUserCode), factory.createLogicalNot(done)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1 /* EmitFlags.SingleLine */)
                 ]), 
                 /*catchClause*/ undefined, 
                 /*finallyBlock*/ ts.setEmitFlags(factory.createBlock([
@@ -99502,7 +99753,7 @@ var ts;
             /*type*/ undefined, factory.updateBlock(node.body, ts.visitLexicalEnvironment(node.body.statements, visitor, context, statementOffset))), !!(hierarchyFacts & 1 /* HierarchyFacts.HasLexicalThis */)));
             // Minor optimization, emit `_super` helper to capture `super` access in an arrow.
             // This step isn't needed if we eventually transform this to ES5.
-            var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */ | 2048 /* NodeCheckFlags.AsyncMethodWithSuper */);
+            var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */);
             if (emitSuperHelpers) {
                 enableSubstitutionForAsyncMethodsWithSuper();
                 var variableStatement = ts.createSuperAccessVariableStatement(factory, resolver, node, capturedSuperProperties);
@@ -99513,10 +99764,10 @@ var ts;
             ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
             var block = factory.updateBlock(node.body, statements);
             if (emitSuperHelpers && hasSuperElementAccess) {
-                if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */) {
+                if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) {
                     ts.addEmitHelper(block, ts.advancedAsyncSuperHelper);
                 }
-                else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.AsyncMethodWithSuper */) {
+                else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */) {
                     ts.addEmitHelper(block, ts.asyncSuperHelper);
                 }
             }
@@ -99645,7 +99896,7 @@ var ts;
             // If we need to support substitutions for `super` in an async method,
             // we should track it here.
             if (enabledSubstitutions & 1 /* ESNextSubstitutionFlags.AsyncMethodsWithSuper */ && isSuperContainer(node)) {
-                var superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* NodeCheckFlags.AsyncMethodWithSuper */ | 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */);
+                var superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */ | 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */);
                 if (superContainerFlags !== enclosingSuperContainerFlags) {
                     var savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
                     enclosingSuperContainerFlags = superContainerFlags;
@@ -99722,7 +99973,7 @@ var ts;
                 || kind === 175 /* SyntaxKind.SetAccessor */;
         }
         function createSuperElementAccessInAsyncMethod(argumentExpression, location) {
-            if (enclosingSuperContainerFlags & 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */) {
+            if (enclosingSuperContainerFlags & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) {
                 return ts.setTextRange(factory.createPropertyAccessExpression(factory.createCallExpression(factory.createIdentifier("_superIndex"), 
                 /*typeArguments*/ undefined, [argumentExpression]), "value"), location);
             }
@@ -101191,11 +101442,13 @@ var ts;
             return ts.visitEachChild(node, visitorWithUnusedExpressionResult, context);
         }
         function visitIdentifier(node) {
-            if (!convertedLoopState) {
-                return node;
+            if (convertedLoopState) {
+                if (resolver.isArgumentsLocalBinding(node)) {
+                    return convertedLoopState.argumentsName || (convertedLoopState.argumentsName = factory.createUniqueName("arguments"));
+                }
             }
-            if (resolver.isArgumentsLocalBinding(node)) {
-                return convertedLoopState.argumentsName || (convertedLoopState.argumentsName = factory.createUniqueName("arguments"));
+            if (node.hasExtendedUnicodeEscape) {
+                return ts.setOriginalNode(ts.setTextRange(factory.createIdentifier(ts.unescapeLeadingUnderscores(node.escapedText)), node), node);
             }
             return node;
         }
@@ -105342,7 +105595,6 @@ var ts;
             return node;
         }
         function transformAndEmitForInStatement(node) {
-            // TODO(rbuckton): Source map locations
             if (containsYield(node)) {
                 // [source]
                 //      for (var p in o) {
@@ -105350,34 +105602,41 @@ var ts;
                 //      }
                 //
                 // [intermediate]
-                //  .local _a, _b, _i
-                //      _a = [];
-                //      for (_b in o) _a.push(_b);
+                //  .local _b, _a, _c, _i
+                //      _b = [];
+                //      _a = o;
+                //      for (_c in _a) _b.push(_c);
                 //      _i = 0;
                 //  .loop incrementLabel, endLoopLabel
                 //  .mark conditionLabel
-                //  .brfalse endLoopLabel, (_i < _a.length)
-                //      p = _a[_i];
+                //  .brfalse endLoopLabel, (_i < _b.length)
+                //      _c = _b[_i];
+                //  .brfalse incrementLabel, (_c in _a)
+                //      p = _c;
                 //      /*body*/
                 //  .mark incrementLabel
-                //      _b++;
+                //      _c++;
                 //  .br conditionLabel
                 //  .endloop
                 //  .mark endLoopLabel
-                var keysArray = declareLocal(); // _a
-                var key = declareLocal(); // _b
+                var obj = declareLocal(); // _a
+                var keysArray = declareLocal(); // _b
+                var key = declareLocal(); // _c
                 var keysIndex = factory.createLoopVariable(); // _i
                 var initializer = node.initializer;
                 hoistVariableDeclaration(keysIndex);
+                emitAssignment(obj, ts.visitNode(node.expression, visitor, ts.isExpression));
                 emitAssignment(keysArray, factory.createArrayLiteralExpression());
-                emitStatement(factory.createForInStatement(key, ts.visitNode(node.expression, visitor, ts.isExpression), factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"), 
+                emitStatement(factory.createForInStatement(key, obj, factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"), 
                 /*typeArguments*/ undefined, [key]))));
                 emitAssignment(keysIndex, factory.createNumericLiteral(0));
                 var conditionLabel = defineLabel();
                 var incrementLabel = defineLabel();
-                var endLabel = beginLoopBlock(incrementLabel);
+                var endLoopLabel = beginLoopBlock(incrementLabel);
                 markLabel(conditionLabel);
-                emitBreakWhenFalse(endLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
+                emitBreakWhenFalse(endLoopLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length")));
+                emitAssignment(key, factory.createElementAccessExpression(keysArray, keysIndex));
+                emitBreakWhenFalse(incrementLabel, factory.createBinaryExpression(key, 101 /* SyntaxKind.InKeyword */, obj));
                 var variable = void 0;
                 if (ts.isVariableDeclarationList(initializer)) {
                     for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) {
@@ -105390,7 +105649,7 @@ var ts;
                     variable = ts.visitNode(initializer, visitor, ts.isExpression);
                     ts.Debug.assert(ts.isLeftHandSideExpression(variable));
                 }
-                emitAssignment(variable, factory.createElementAccessExpression(keysArray, keysIndex));
+                emitAssignment(variable, key);
                 transformAndEmitEmbeddedStatement(node.statement);
                 markLabel(incrementLabel);
                 emitStatement(factory.createExpressionStatement(factory.createPostfixIncrement(keysIndex)));
@@ -107231,7 +107490,7 @@ var ts;
                     return createImportCallExpressionUMD(argument !== null && argument !== void 0 ? argument : factory.createVoidZero(), containsLexicalThis);
                 case ts.ModuleKind.CommonJS:
                 default:
-                    return createImportCallExpressionCommonJS(argument, containsLexicalThis);
+                    return createImportCallExpressionCommonJS(argument);
             }
         }
         function createImportCallExpressionUMD(arg, containsLexicalThis) {
@@ -107254,7 +107513,7 @@ var ts;
                 return factory.createConditionalExpression(
                 /*condition*/ factory.createIdentifier("__syncRequire"), 
                 /*questionToken*/ undefined, 
-                /*whenTrue*/ createImportCallExpressionCommonJS(arg, containsLexicalThis), 
+                /*whenTrue*/ createImportCallExpressionCommonJS(arg), 
                 /*colonToken*/ undefined, 
                 /*whenFalse*/ createImportCallExpressionAMD(argClone, containsLexicalThis));
             }
@@ -107263,7 +107522,7 @@ var ts;
                 return factory.createComma(factory.createAssignment(temp, arg), factory.createConditionalExpression(
                 /*condition*/ factory.createIdentifier("__syncRequire"), 
                 /*questionToken*/ undefined, 
-                /*whenTrue*/ createImportCallExpressionCommonJS(temp, containsLexicalThis), 
+                /*whenTrue*/ createImportCallExpressionCommonJS(temp, /* isInlineable */ true), 
                 /*colonToken*/ undefined, 
                 /*whenFalse*/ createImportCallExpressionAMD(temp, containsLexicalThis)));
             }
@@ -107313,14 +107572,20 @@ var ts;
             }
             return promise;
         }
-        function createImportCallExpressionCommonJS(arg, containsLexicalThis) {
-            // import("./blah")
+        function createImportCallExpressionCommonJS(arg, isInlineable) {
+            // import(x)
             // emit as
-            // Promise.resolve().then(function () { return require(x); }) /*CommonJs Require*/
+            // var _a;
+            // (_a = x, Promise.resolve().then(() => require(_a)) /*CommonJs Require*/
             // We have to wrap require in then callback so that require is done in asynchronously
             // if we simply do require in resolve callback in Promise constructor. We will execute the loading immediately
-            var promiseResolveCall = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Promise"), "resolve"), /*typeArguments*/ undefined, /*argumentsArray*/ []);
-            var requireCall = factory.createCallExpression(factory.createIdentifier("require"), /*typeArguments*/ undefined, arg ? [arg] : []);
+            // If the arg is not inlineable, we have to evaluate it in the current scope with a temp var
+            var temp = arg && !ts.isSimpleInlineableExpression(arg) && !isInlineable ? factory.createTempVariable(hoistVariableDeclaration) : undefined;
+            var promiseResolveCall = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Promise"), "resolve"), 
+            /*typeArguments*/ undefined, 
+            /*argumentsArray*/ []);
+            var requireCall = factory.createCallExpression(factory.createIdentifier("require"), 
+            /*typeArguments*/ undefined, temp ? [temp] : arg ? [arg] : []);
             if (ts.getESModuleInterop(compilerOptions)) {
                 requireCall = emitHelpers().createImportStarHelper(requireCall);
             }
@@ -107341,14 +107606,9 @@ var ts;
                 /*typeParameters*/ undefined, 
                 /*parameters*/ [], 
                 /*type*/ undefined, factory.createBlock([factory.createReturnStatement(requireCall)]));
-                // if there is a lexical 'this' in the import call arguments, ensure we indicate
-                // that this new function expression indicates it captures 'this' so that the
-                // es2015 transformer will properly substitute 'this' with '_this'.
-                if (containsLexicalThis) {
-                    ts.setEmitFlags(func, 8 /* EmitFlags.CapturesThis */);
-                }
             }
-            return factory.createCallExpression(factory.createPropertyAccessExpression(promiseResolveCall, "then"), /*typeArguments*/ undefined, [func]);
+            var downleveledImport = factory.createCallExpression(factory.createPropertyAccessExpression(promiseResolveCall, "then"), /*typeArguments*/ undefined, [func]);
+            return temp === undefined ? downleveledImport : factory.createCommaListExpression([factory.createAssignment(temp, arg), downleveledImport]);
         }
         function getHelperExpressionForExport(node, innerExpr) {
             if (!ts.getESModuleInterop(compilerOptions) || ts.getEmitFlags(node) & 67108864 /* EmitFlags.NeverApplyImportHelper */) {
@@ -118341,14 +118601,16 @@ var ts;
             }
             return setReadFileCache(key, fileName);
         };
-        var getSourceFileWithCache = getSourceFile ? function (fileName, languageVersion, onError, shouldCreateNewSourceFile) {
+        var getSourceFileWithCache = getSourceFile ? function (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
             var key = toPath(fileName);
-            var value = sourceFileCache.get(key);
+            var impliedNodeFormat = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions.impliedNodeFormat : undefined;
+            var forImpliedNodeFormat = sourceFileCache.get(impliedNodeFormat);
+            var value = forImpliedNodeFormat === null || forImpliedNodeFormat === void 0 ? void 0 : forImpliedNodeFormat.get(key);
             if (value)
                 return value;
-            var sourceFile = getSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+            var sourceFile = getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
             if (sourceFile && (ts.isDeclarationFileName(fileName) || ts.fileExtensionIs(fileName, ".json" /* Extension.Json */))) {
-                sourceFileCache.set(key, sourceFile);
+                sourceFileCache.set(impliedNodeFormat, (forImpliedNodeFormat || new ts.Map()).set(key, sourceFile));
             }
             return sourceFile;
         } : undefined;
@@ -118373,13 +118635,15 @@ var ts;
                 var value = readFileCache.get(key);
                 if (value !== undefined && value !== data) {
                     readFileCache.delete(key);
-                    sourceFileCache.delete(key);
+                    sourceFileCache.forEach(function (map) { return map.delete(key); });
                 }
                 else if (getSourceFileWithCache) {
-                    var sourceFile = sourceFileCache.get(key);
-                    if (sourceFile && sourceFile.text !== data) {
-                        sourceFileCache.delete(key);
-                    }
+                    sourceFileCache.forEach(function (map) {
+                        var sourceFile = map.get(key);
+                        if (sourceFile && sourceFile.text !== data) {
+                            map.delete(key);
+                        }
+                    });
                 }
                 originalWriteFile.call.apply(originalWriteFile, __spreadArray([host, fileName, data], rest, false));
             };
@@ -122521,10 +122785,16 @@ var ts;
         var oldCompilerOptions = useOldState ? oldState.compilerOptions : undefined;
         var canCopySemanticDiagnostics = useOldState && oldState.semanticDiagnosticsPerFile && !!state.semanticDiagnosticsPerFile &&
             !ts.compilerOptionsAffectSemanticDiagnostics(compilerOptions, oldCompilerOptions);
+        // We can only reuse emit signatures (i.e. .d.ts signatures) if the .d.ts file is unchanged,
+        // which will eg be depedent on change in options like declarationDir and outDir options are unchanged.
+        // We need to look in oldState.compilerOptions, rather than oldCompilerOptions (i.e.we need to disregard useOldState) because
+        // oldCompilerOptions can be undefined if there was change in say module from None to some other option
+        // which would make useOldState as false since we can now use reference maps that are needed to track what to emit, what to check etc
+        // but that option change does not affect d.ts file name so emitSignatures should still be reused.
         var canCopyEmitSignatures = compilerOptions.composite &&
             (oldState === null || oldState === void 0 ? void 0 : oldState.emitSignatures) &&
             !outFilePath &&
-            !ts.compilerOptionsAffectDeclarationPath(compilerOptions, oldCompilerOptions);
+            !ts.compilerOptionsAffectDeclarationPath(compilerOptions, oldState.compilerOptions);
         if (useOldState) {
             // Copy old state's changed files set
             (_a = oldState.changedFilesSet) === null || _a === void 0 ? void 0 : _a.forEach(function (value) { return state.changedFilesSet.add(value); });
@@ -123070,7 +123340,8 @@ var ts;
             for (var _b = 0, _c = state.affectedFilesPendingEmit.slice(state.affectedFilesPendingEmitIndex).sort(ts.compareStringsCaseSensitive); _b < _c.length; _b++) {
                 var path = _c[_b];
                 if (ts.tryAddToSet(seenFiles, path)) {
-                    (affectedFilesPendingEmit || (affectedFilesPendingEmit = [])).push([toFileId(path), state.affectedFilesPendingEmitKind.get(path)]);
+                    var fileId = toFileId(path), emitKind = state.affectedFilesPendingEmitKind.get(path);
+                    (affectedFilesPendingEmit || (affectedFilesPendingEmit = [])).push(emitKind === 1 /* BuilderFileEmit.Full */ ? fileId : [fileId]);
                 }
             }
         }
@@ -123549,6 +123820,10 @@ var ts;
                 { version: fileInfo.version, signature: fileInfo.signature === false ? undefined : fileInfo.version, affectsGlobalScope: fileInfo.affectsGlobalScope, impliedFormat: fileInfo.impliedFormat };
     }
     ts.toBuilderStateFileInfo = toBuilderStateFileInfo;
+    function toBuilderFileEmit(value) {
+        return ts.isNumber(value) ? 1 /* BuilderFileEmit.Full */ : 0 /* BuilderFileEmit.DtsOnly */;
+    }
+    ts.toBuilderFileEmit = toBuilderFileEmit;
     function createBuilderProgramUsingProgramBuildInfo(program, buildInfoPath, host) {
         var _a, _b, _c, _d;
         var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
@@ -123590,8 +123865,8 @@ var ts;
                 exportedModulesMap: toManyToManyPathMap(program.exportedModulesMap),
                 semanticDiagnosticsPerFile: program.semanticDiagnosticsPerFile && ts.arrayToMap(program.semanticDiagnosticsPerFile, function (value) { return toFilePath(ts.isNumber(value) ? value : value[0]); }, function (value) { return ts.isNumber(value) ? ts.emptyArray : value[1]; }),
                 hasReusableDiagnostic: true,
-                affectedFilesPendingEmit: ts.map(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }),
-                affectedFilesPendingEmitKind: program.affectedFilesPendingEmit && ts.arrayToMap(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }, function (value) { return value[1]; }),
+                affectedFilesPendingEmit: ts.map(program.affectedFilesPendingEmit, function (value) { return toFilePath(ts.isNumber(value) ? value : value[0]); }),
+                affectedFilesPendingEmitKind: program.affectedFilesPendingEmit && ts.arrayToMap(program.affectedFilesPendingEmit, function (value) { return toFilePath(ts.isNumber(value) ? value : value[0]); }, toBuilderFileEmit),
                 affectedFilesPendingEmitIndex: program.affectedFilesPendingEmit && 0,
                 changedFilesSet: new ts.Set(ts.map(program.changeFileSet, toFilePath)),
                 latestChangedDtsFile: latestChangedDtsFile,
@@ -123739,7 +124014,7 @@ var ts;
         var isNonDirectorySeparatorRoot = rootLength > 1 || dirPath.charCodeAt(0) !== 47 /* CharacterCodes.slash */;
         if (isNonDirectorySeparatorRoot &&
             dirPath.search(/[a-zA-Z]:/) !== 0 && // Non dos style paths
-            pathPartForUserCheck.search(/[a-zA-z]\$\//) === 0) { // Dos style nextPart
+            pathPartForUserCheck.search(/[a-zA-Z]\$\//) === 0) { // Dos style nextPart
             nextDirectorySeparator = dirPath.indexOf(ts.directorySeparator, nextDirectorySeparator + 1);
             if (nextDirectorySeparator === -1) {
                 // ignore "//vda1cs4850/c$/folderAtRoot"
@@ -124993,7 +125268,7 @@ var ts;
             });
             // Sort by paths closest to importing file Name directory
             var sortedPaths = [];
-            var _loop_36 = function (directory) {
+            var _loop_35 = function (directory) {
                 var directoryStart = ts.ensureTrailingDirectorySeparator(directory);
                 var pathsInDirectory;
                 allFileNames.forEach(function (_a, fileName) {
@@ -125017,9 +125292,9 @@ var ts;
             };
             var out_directory_1;
             for (var directory = ts.getDirectoryPath(importingFileName); allFileNames.size !== 0;) {
-                var state_12 = _loop_36(directory);
+                var state_11 = _loop_35(directory);
                 directory = out_directory_1;
-                if (state_12 === "break")
+                if (state_11 === "break")
                     break;
             }
             if (allFileNames.size) {
@@ -125088,7 +125363,7 @@ var ts;
         }
         function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions) {
             for (var key in paths) {
-                var _loop_37 = function (patternText_1) {
+                var _loop_36 = function (patternText_1) {
                     var pattern = ts.normalizePath(patternText_1);
                     var indexOfStar = pattern.indexOf("*");
                     // In module resolution, if `pattern` itself has an extension, a file with that extension is looked up directly,
@@ -125155,9 +125430,9 @@ var ts;
                 };
                 for (var _i = 0, _a = paths[key]; _i < _a.length; _i++) {
                     var patternText_1 = _a[_i];
-                    var state_13 = _loop_37(patternText_1);
-                    if (typeof state_13 === "object")
-                        return state_13.value;
+                    var state_12 = _loop_36(patternText_1);
+                    if (typeof state_12 === "object")
+                        return state_12.value;
                 }
             }
             function validateEnding(_a) {
@@ -125245,15 +125520,21 @@ var ts;
             return undefined;
         }
         function tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, ending, compilerOptions) {
-            var normalizedTargetPath = getPathRelativeToRootDirs(moduleFileName, rootDirs, getCanonicalFileName);
-            if (normalizedTargetPath === undefined) {
+            var normalizedTargetPaths = getPathsRelativeToRootDirs(moduleFileName, rootDirs, getCanonicalFileName);
+            if (normalizedTargetPaths === undefined) {
+                return undefined;
+            }
+            var normalizedSourcePaths = getPathsRelativeToRootDirs(sourceDirectory, rootDirs, getCanonicalFileName);
+            var relativePaths = ts.flatMap(normalizedSourcePaths, function (sourcePath) {
+                return ts.map(normalizedTargetPaths, function (targetPath) { return ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(sourcePath, targetPath, getCanonicalFileName)); });
+            });
+            var shortest = ts.min(relativePaths, ts.compareNumberOfDirectorySeparators);
+            if (!shortest) {
                 return undefined;
             }
-            var normalizedSourcePath = getPathRelativeToRootDirs(sourceDirectory, rootDirs, getCanonicalFileName);
-            var relativePath = normalizedSourcePath !== undefined ? ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(normalizedSourcePath, normalizedTargetPath, getCanonicalFileName)) : normalizedTargetPath;
             return ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs
-                ? removeExtensionAndIndexPostFix(relativePath, ending, compilerOptions)
-                : ts.removeFileExtension(relativePath);
+                ? removeExtensionAndIndexPostFix(shortest, ending, compilerOptions)
+                : ts.removeFileExtension(shortest);
         }
         function tryGetModuleNameAsNodeModule(_a, _b, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
             var path = _a.path, isRedirect = _a.isRedirect;
@@ -125390,8 +125671,8 @@ var ts;
                 }
             }
         }
-        function getPathRelativeToRootDirs(path, rootDirs, getCanonicalFileName) {
-            return ts.firstDefined(rootDirs, function (rootDir) {
+        function getPathsRelativeToRootDirs(path, rootDirs, getCanonicalFileName) {
+            return ts.mapDefined(rootDirs, function (rootDir) {
                 var relativePath = getRelativePathIfInDirectory(path, rootDir, getCanonicalFileName);
                 return relativePath !== undefined && isPathRelativeToParent(relativePath) ? undefined : relativePath;
             });
@@ -127959,8 +128240,15 @@ var ts;
             }
             if (buildInfo.program) {
                 // If there are pending changes that are not emitted, project is out of date
+                // When there are syntax errors, changeFileSet will have list of files changed (irrespective of noEmit)
+                // But in case of semantic error we need special treatment.
+                // Checking presence of affectedFilesPendingEmit list is fast and good way to tell if there were semantic errors and file emit was blocked
+                // But if noEmit is true, affectedFilesPendingEmit will have file list even if there are no semantic errors to preserve list of files to be emitted when running with noEmit false
+                // So with noEmit set to true, check on semantic diagnostics needs to be explicit as oppose to when it is false when only files pending emit is sufficient
                 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))) {
+                    (!project.options.noEmit ?
+                        (_b = buildInfo.program.affectedFilesPendingEmit) === null || _b === void 0 ? void 0 : _b.length :
+                        ts.some(buildInfo.program.semanticDiagnosticsPerFile, ts.isArray))) {
                     return {
                         type: ts.UpToDateStatusType.OutOfDateBuildInfo,
                         buildInfoFile: buildInfoPath