typescript 4.9.1-beta → 5.0.0-dev.20221101

package/lib/tsserver.js

@@ -105,11 +105,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) {
@@ -1901,8 +1901,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;
     /**
@@ -3215,11 +3215,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*)$/;
@@ -3239,13 +3241,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);
@@ -3284,6 +3288,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))
@@ -3292,7 +3300,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;
@@ -3375,6 +3383,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);
@@ -3485,19 +3497,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));
@@ -5106,8 +5119,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";
@@ -6742,7 +6755,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();
@@ -6808,8 +6821,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) {
@@ -7081,7 +7094,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;
@@ -9592,6 +9604,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."),
@@ -9908,6 +9924,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}"),
@@ -11365,7 +11383,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);
@@ -21668,6 +21686,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;
@@ -21676,13 +21720,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,
@@ -23146,7 +23188,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
@@ -23155,6 +23197,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
@@ -27610,11 +27656,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 */:
@@ -27973,7 +28017,6 @@ var ts;
         return node;
     }
     ts.createInputFiles = createInputFiles;
-    // tslint:disable-next-line variable-name
     var SourceMapSource;
     /**
      * Create an external source map source file reference
@@ -28765,6 +28808,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`.
@@ -28803,7 +28848,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 = {
@@ -32107,13 +32152,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;
@@ -33089,8 +33132,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);
@@ -40339,9 +40383,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,
@@ -42069,12 +42110,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;
@@ -42123,9 +42166,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());
     }
@@ -42229,12 +42274,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
@@ -42245,7 +42301,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;
@@ -44287,6 +44343,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) {
@@ -44876,7 +44935,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)) {
@@ -44956,7 +45015,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++) {
@@ -44965,17 +45024,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) {
@@ -44992,7 +45051,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) {
@@ -45003,6 +45062,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);
                     }
@@ -45029,6 +45090,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)
@@ -45038,14 +45102,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;
                 }
@@ -45058,7 +45126,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;
                         }
@@ -45474,6 +45542,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;
@@ -49065,8 +49142,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) {
@@ -49485,6 +49560,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,
@@ -50322,9 +50403,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;
                         }
                     }
@@ -50957,8 +51038,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;
@@ -51045,7 +51126,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
@@ -51208,7 +51289,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));
@@ -51219,7 +51300,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);
@@ -51267,16 +51349,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;
@@ -51866,6 +51948,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
@@ -51911,19 +52039,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);
                 }
@@ -51943,8 +52077,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);
                     }
@@ -52766,7 +52899,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;
@@ -53035,8 +53168,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;
                 }
@@ -55348,7 +55483,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]);
@@ -55382,15 +55517,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);
@@ -55637,7 +55763,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 */;
                         }
@@ -55693,7 +55819,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);
@@ -57607,16 +57733,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;
         }
@@ -57913,7 +58055,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;
@@ -59796,7 +59938,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) {
@@ -60266,7 +60421,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;
@@ -60277,11 +60432,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;
@@ -60400,7 +60558,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;
@@ -63113,8 +63271,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);
@@ -63173,12 +63337,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)) {
@@ -63343,7 +63509,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;
@@ -63446,10 +63623,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);
@@ -63728,18 +63906,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) {
@@ -63772,11 +63955,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.
@@ -63808,14 +63987,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
@@ -63826,10 +64005,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
@@ -63841,19 +64020,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
@@ -66307,7 +66474,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) &&
@@ -66335,27 +66502,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;
                     }
@@ -66467,7 +66613,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) {
@@ -66530,9 +66676,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;
             }
@@ -66753,8 +66899,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 */)) {
@@ -66784,7 +66929,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]) {
@@ -66871,7 +67016,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
@@ -66885,10 +67030,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) {
@@ -66897,9 +67065,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;
@@ -67000,7 +67165,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;
                                 }
@@ -67523,11 +67688,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)
@@ -67543,8 +67708,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;
                             }
                         }
@@ -67557,9 +67722,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 */;
@@ -67656,7 +67821,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..
@@ -68264,7 +68429,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 */ :
@@ -68302,7 +68467,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) });
@@ -68756,8 +68921,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;
@@ -69636,7 +69800,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 */) {
@@ -70260,7 +70424,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
@@ -70310,7 +70474,7 @@ var ts;
                         inferFromTypes(source_1, target_3);
                     };
                     for (var i = 0; i < types.length; i++) {
-                        _loop_25(i);
+                        _loop_24(i);
                     }
                 }
             }
@@ -70762,7 +70926,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)
@@ -70776,7 +70940,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;
@@ -70834,7 +71003,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) {
@@ -70860,9 +71029,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;
         }
@@ -71459,6 +71628,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);
             }
@@ -71497,7 +71667,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 */:
@@ -71984,7 +72154,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) {
@@ -72265,7 +72435,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) {
@@ -72346,7 +72516,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;
@@ -72535,7 +72705,7 @@ var ts;
                                 neverType;
                 });
             }
-            function narrowBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) {
+            function narrowTypeBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) {
                 var witnesses = getSwitchClauseTypeOfWitnesses(switchStatement);
                 if (!witnesses) {
                     return type;
@@ -72923,15 +73093,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 {
@@ -73159,7 +73329,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 */ ||
@@ -73188,6 +73358,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;
@@ -73529,12 +73705,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;
@@ -73640,12 +73821,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) {
@@ -74341,9 +74522,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);
@@ -77317,7 +77499,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));
@@ -77334,7 +77516,7 @@ var ts;
                     }
                 };
                 for (var i = spreadIndex; i < args.length; i++) {
-                    _loop_27(i);
+                    _loop_26(i);
                 }
                 return effectiveArgs_1;
             }
@@ -77663,7 +77845,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) {
@@ -77681,7 +77863,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");
@@ -77839,7 +78021,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; });
@@ -77847,7 +78029,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 */;
@@ -78817,7 +78999,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;
         }
@@ -79479,7 +79661,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 */) {
@@ -79487,7 +79679,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 */) {
@@ -79497,7 +79689,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;
             }
@@ -81191,6 +81383,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])) {
@@ -81892,7 +82087,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));
@@ -81907,7 +82102,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) {
@@ -82184,7 +82379,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 */) {
@@ -82787,7 +82982,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
@@ -82854,7 +83049,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;
             }
@@ -82888,7 +83083,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;
                 }
@@ -83562,7 +83757,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) {
@@ -84992,7 +85187,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.
@@ -85507,7 +85711,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
@@ -85524,7 +85728,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) {
@@ -85532,7 +85736,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;
@@ -85547,7 +85751,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) {
@@ -85602,7 +85806,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;
                     }
@@ -85612,7 +85816,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));
+                        }
                     }
                 });
             }
@@ -85867,7 +86073,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";
                 }
@@ -85884,7 +86090,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_33(member);
+                _loop_32(member);
             }
         }
         /**
@@ -85972,7 +86178,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";
                 }
@@ -85991,7 +86197,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
@@ -86062,7 +86268,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";
@@ -86172,8 +86378,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;
                 }
             }
@@ -86692,12 +86898,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;
@@ -86713,8 +86918,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);
                         }
@@ -86730,18 +86935,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;
             }
         }
@@ -86843,10 +87036,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;
@@ -86856,7 +87050,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 */:
@@ -87016,14 +87210,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);
                         }
                     }
@@ -87162,7 +87357,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);
                     }
                 }
@@ -87209,7 +87404,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);
                     }
@@ -87881,29 +88076,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 */) {
@@ -88336,7 +88511,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);
@@ -88531,7 +88706,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) {
@@ -88584,7 +88759,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);
                 }
             }
@@ -88672,7 +88847,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) ||
@@ -88694,6 +88869,7 @@ var ts;
             return isValue && node.moduleReference && !ts.nodeIsMissing(node.moduleReference);
         }
         function isAliasResolvedToValue(symbol) {
+            var _a;
             if (!symbol) {
                 return false;
             }
@@ -88703,7 +88879,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) {
@@ -88718,7 +88894,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;
@@ -98372,8 +98548,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);
@@ -98474,6 +98653,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.
          *
@@ -98488,7 +98670,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.
@@ -98602,6 +98791,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);
@@ -98634,7 +98859,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) {
@@ -98647,10 +98872,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);
                     }
                 }
@@ -98722,7 +98947,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;
@@ -98799,7 +99024,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);
             }
@@ -98814,7 +99039,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);
@@ -99307,11 +99532,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);
@@ -99321,8 +99557,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 */
@@ -99333,6 +99577,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);
@@ -99349,12 +99595,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([
@@ -99366,7 +99617,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([
@@ -99522,7 +99773,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);
@@ -99533,10 +99784,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);
                 }
             }
@@ -99665,7 +99916,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;
@@ -99742,7 +99993,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);
             }
@@ -101211,11 +101462,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;
         }
@@ -105362,7 +105615,6 @@ var ts;
             return node;
         }
         function transformAndEmitForInStatement(node) {
-            // TODO(rbuckton): Source map locations
             if (containsYield(node)) {
                 // [source]
                 //      for (var p in o) {
@@ -105370,34 +105622,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++) {
@@ -105410,7 +105669,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)));
@@ -107251,7 +107510,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) {
@@ -107274,7 +107533,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));
             }
@@ -107283,7 +107542,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)));
             }
@@ -107333,14 +107592,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);
             }
@@ -107361,14 +107626,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 */) {
@@ -118361,14 +118621,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;
@@ -118393,13 +118655,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));
             };
@@ -122541,10 +122805,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); });
@@ -123090,7 +123360,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]);
                 }
             }
         }
@@ -123569,6 +123840,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()));
@@ -123610,8 +123885,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,
@@ -123759,7 +124034,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"
@@ -125013,7 +125288,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) {
@@ -125037,9 +125312,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) {
@@ -125108,7 +125383,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,
@@ -125175,9 +125450,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) {
@@ -125265,15 +125540,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;
@@ -125410,8 +125691,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;
             });
@@ -127979,8 +128260,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
@@ -128742,6 +129030,12 @@ var ts;
         SemanticClassificationFormat["Original"] = "original";
         SemanticClassificationFormat["TwentyTwenty"] = "2020";
     })(SemanticClassificationFormat = ts.SemanticClassificationFormat || (ts.SemanticClassificationFormat = {}));
+    var OrganizeImportsMode;
+    (function (OrganizeImportsMode) {
+        OrganizeImportsMode["All"] = "All";
+        OrganizeImportsMode["SortAndCombine"] = "SortAndCombine";
+        OrganizeImportsMode["RemoveUnused"] = "RemoveUnused";
+    })(OrganizeImportsMode = ts.OrganizeImportsMode || (ts.OrganizeImportsMode = {}));
     var CompletionTriggerKind;
     (function (CompletionTriggerKind) {
         /** Completion was triggered by typing an identifier, manual invocation (e.g Ctrl+Space) or via API. */
@@ -129787,6 +130081,8 @@ var ts;
         return lastTypeNode;
     }
     function getContextualTypeFromParentOrAncestorTypeNode(node, checker) {
+        if (node.flags & (8388608 /* NodeFlags.JSDoc */ & ~262144 /* NodeFlags.JavaScriptFile */))
+            return undefined;
         var contextualType = getContextualTypeFromParent(node, checker);
         if (contextualType)
             return contextualType;
@@ -132273,6 +132569,10 @@ var ts;
         return jsx === 2 /* JsxEmit.React */ || jsx === 3 /* JsxEmit.ReactNative */;
     }
     ts.jsxModeNeedsExplicitImport = jsxModeNeedsExplicitImport;
+    function isSourceFileFromLibrary(program, node) {
+        return program.isSourceFileFromExternalLibrary(node) || program.isSourceFileDefaultLibrary(node);
+    }
+    ts.isSourceFileFromLibrary = isSourceFileFromLibrary;
     // #endregion
 })(ts || (ts = {}));
 /*@internal*/
@@ -135299,7 +135599,7 @@ var ts;
             if (preferences.includeCompletionsWithClassMemberSnippets &&
                 preferences.includeCompletionsWithInsertText &&
                 completionKind === 3 /* CompletionKind.MemberLike */ &&
-                isClassLikeMemberCompletion(symbol, location)) {
+                isClassLikeMemberCompletion(symbol, location, sourceFile)) {
                 var importAdder = void 0;
                 (_b = getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, contextToken, formatContext), insertText = _b.insertText, isSnippet = _b.isSnippet, importAdder = _b.importAdder, replacementSpan = _b.replacementSpan);
                 sortText = Completions.SortText.ClassMemberSnippets; // sortText has to be lower priority than the sortText for keywords. See #47852.
@@ -135371,7 +135671,7 @@ var ts;
                 data: data,
             };
         }
-        function isClassLikeMemberCompletion(symbol, location) {
+        function isClassLikeMemberCompletion(symbol, location, sourceFile) {
             // TODO: support JS files.
             if (ts.isInJSFile(location)) {
                 return false;
@@ -135405,6 +135705,7 @@ var ts;
                         location.parent.parent &&
                         ts.isClassElement(location.parent) &&
                         location === location.parent.name &&
+                        location.parent.getLastToken(sourceFile) === location.parent.name &&
                         ts.isClassLike(location.parent.parent)) ||
                     (location.parent &&
                         ts.isSyntaxList(location) &&
@@ -142566,6 +142867,12 @@ var ts;
                 var label = ts.getTargetLabel(node.parent, node.text);
                 return label ? [createDefinitionInfoFromName(typeChecker, label, "label" /* ScriptElementKind.label */, node.text, /*containerName*/ undefined)] : undefined; // TODO: GH#18217
             }
+            if (node.kind === 105 /* SyntaxKind.ReturnKeyword */) {
+                var functionDeclaration = ts.findAncestor(node.parent, function (n) {
+                    return ts.isClassStaticBlockDeclaration(n) ? "quit" : ts.isFunctionLikeDeclaration(n);
+                });
+                return functionDeclaration ? [createDefinitionFromSignatureDeclaration(typeChecker, functionDeclaration)] : undefined;
+            }
             if (ts.isStaticModifier(node) && ts.isClassStaticBlockDeclaration(node.parent)) {
                 var classDecl = node.parent.parent;
                 var _c = getSymbol(classDecl, typeChecker, stopAtAlias), symbol_1 = _c.symbol, failedAliasResolution_1 = _c.failedAliasResolution;
@@ -142701,13 +143008,16 @@ var ts;
             if (!baseDeclaration)
                 return;
             var baseTypeNode = ts.getEffectiveBaseTypeNode(baseDeclaration);
-            var baseType = baseTypeNode ? typeChecker.getTypeAtLocation(baseTypeNode) : undefined;
-            if (!baseType)
+            if (!baseTypeNode)
+                return;
+            var expression = ts.skipParentheses(baseTypeNode.expression);
+            var base = ts.isClassExpression(expression) ? expression.symbol : typeChecker.getSymbolAtLocation(expression);
+            if (!base)
                 return;
             var name = ts.unescapeLeadingUnderscores(ts.getTextOfPropertyName(classElement.name));
             var symbol = ts.hasStaticModifier(classElement)
-                ? typeChecker.getPropertyOfType(typeChecker.getTypeOfSymbolAtLocation(baseType.symbol, baseDeclaration), name)
-                : typeChecker.getPropertyOfType(baseType, name);
+                ? typeChecker.getPropertyOfType(typeChecker.getTypeOfSymbol(base), name)
+                : typeChecker.getPropertyOfType(typeChecker.getDeclaredTypeOfSymbol(base), name);
             if (!symbol)
                 return;
             return getDefinitionFromSymbol(typeChecker, symbol, node);
@@ -143414,19 +143724,24 @@ var ts;
                     return getCommentOwnerInfoWorker(commentOwner.initializer, options);
                 case 260 /* SyntaxKind.ClassDeclaration */:
                 case 261 /* SyntaxKind.InterfaceDeclaration */:
-                case 168 /* SyntaxKind.PropertySignature */:
                 case 263 /* SyntaxKind.EnumDeclaration */:
                 case 302 /* SyntaxKind.EnumMember */:
                 case 262 /* SyntaxKind.TypeAliasDeclaration */:
                     return { commentOwner: commentOwner };
+                case 168 /* SyntaxKind.PropertySignature */: {
+                    var host_1 = commentOwner;
+                    return host_1.type && ts.isFunctionTypeNode(host_1.type)
+                        ? { commentOwner: commentOwner, parameters: host_1.type.parameters, hasReturn: hasReturn(host_1.type, options) }
+                        : { commentOwner: commentOwner };
+                }
                 case 240 /* SyntaxKind.VariableStatement */: {
                     var varStatement = commentOwner;
                     var varDeclarations = varStatement.declarationList.declarations;
-                    var host_1 = varDeclarations.length === 1 && varDeclarations[0].initializer
+                    var host_2 = varDeclarations.length === 1 && varDeclarations[0].initializer
                         ? getRightHandSideOfAssignment(varDeclarations[0].initializer)
                         : undefined;
-                    return host_1
-                        ? { commentOwner: commentOwner, parameters: host_1.parameters, hasReturn: hasReturn(host_1, options) }
+                    return host_2
+                        ? { commentOwner: commentOwner, parameters: host_2.parameters, hasReturn: hasReturn(host_2, options) }
                         : { commentOwner: commentOwner };
                 }
                 case 308 /* SyntaxKind.SourceFile */:
@@ -143456,7 +143771,7 @@ var ts;
         }
         function hasReturn(node, options) {
             return !!(options === null || options === void 0 ? void 0 : options.generateReturnInDocTemplate) &&
-                (ts.isArrowFunction(node) && ts.isExpression(node.body)
+                (ts.isFunctionTypeNode(node) || ts.isArrowFunction(node) && ts.isExpression(node.body)
                     || ts.isFunctionLikeDeclaration(node) && node.body && ts.isBlock(node.body) && !!ts.forEachReturnStatement(node.body, function (n) { return n; }));
         }
         function getRightHandSideOfAssignment(rightHandSide) {
@@ -144497,23 +144812,39 @@ var ts;
          *   2) Coalescing imports from the same module
          *   3) Sorting imports
          */
-        function organizeImports(sourceFile, formatContext, host, program, preferences, skipDestructiveCodeActions) {
+        function organizeImports(sourceFile, formatContext, host, program, preferences, mode) {
             var changeTracker = ts.textChanges.ChangeTracker.fromContext({ host: host, formatContext: formatContext, preferences: preferences });
-            var coalesceAndOrganizeImports = function (importGroup) { return ts.stableSort(coalesceImports(removeUnusedImports(importGroup, sourceFile, program, skipDestructiveCodeActions)), function (s1, s2) { return compareImportsOrRequireStatements(s1, s2); }); };
+            var shouldSort = mode === "SortAndCombine" /* OrganizeImportsMode.SortAndCombine */ || mode === "All" /* OrganizeImportsMode.All */;
+            var shouldCombine = shouldSort; // These are currently inseparable, but I draw a distinction for clarity and in case we add modes in the future.
+            var shouldRemove = mode === "RemoveUnused" /* OrganizeImportsMode.RemoveUnused */ || mode === "All" /* OrganizeImportsMode.All */;
+            var maybeRemove = shouldRemove ? removeUnusedImports : ts.identity;
+            var maybeCoalesce = shouldCombine ? coalesceImports : ts.identity;
+            var processImportsOfSameModuleSpecifier = function (importGroup) {
+                var processedDeclarations = maybeCoalesce(maybeRemove(importGroup, sourceFile, program));
+                return shouldSort
+                    ? ts.stableSort(processedDeclarations, function (s1, s2) { return compareImportsOrRequireStatements(s1, s2); })
+                    : processedDeclarations;
+            };
             // All of the old ImportDeclarations in the file, in syntactic order.
             var topLevelImportGroupDecls = groupImportsByNewlineContiguous(sourceFile, sourceFile.statements.filter(ts.isImportDeclaration));
-            topLevelImportGroupDecls.forEach(function (importGroupDecl) { return organizeImportsWorker(importGroupDecl, coalesceAndOrganizeImports); });
-            // All of the old ExportDeclarations in the file, in syntactic order.
-            var topLevelExportDecls = sourceFile.statements.filter(ts.isExportDeclaration);
-            organizeImportsWorker(topLevelExportDecls, coalesceExports);
+            topLevelImportGroupDecls.forEach(function (importGroupDecl) { return organizeImportsWorker(importGroupDecl, processImportsOfSameModuleSpecifier); });
+            // Exports are always used
+            if (mode !== "RemoveUnused" /* OrganizeImportsMode.RemoveUnused */) {
+                // All of the old ExportDeclarations in the file, in syntactic order.
+                var topLevelExportDecls = sourceFile.statements.filter(ts.isExportDeclaration);
+                organizeImportsWorker(topLevelExportDecls, coalesceExports);
+            }
             for (var _i = 0, _a = sourceFile.statements.filter(ts.isAmbientModule); _i < _a.length; _i++) {
                 var ambientModule = _a[_i];
                 if (!ambientModule.body)
                     continue;
                 var ambientModuleImportGroupDecls = groupImportsByNewlineContiguous(sourceFile, ambientModule.body.statements.filter(ts.isImportDeclaration));
-                ambientModuleImportGroupDecls.forEach(function (importGroupDecl) { return organizeImportsWorker(importGroupDecl, coalesceAndOrganizeImports); });
-                var ambientModuleExportDecls = ambientModule.body.statements.filter(ts.isExportDeclaration);
-                organizeImportsWorker(ambientModuleExportDecls, coalesceExports);
+                ambientModuleImportGroupDecls.forEach(function (importGroupDecl) { return organizeImportsWorker(importGroupDecl, processImportsOfSameModuleSpecifier); });
+                // Exports are always used
+                if (mode !== "RemoveUnused" /* OrganizeImportsMode.RemoveUnused */) {
+                    var ambientModuleExportDecls = ambientModule.body.statements.filter(ts.isExportDeclaration);
+                    organizeImportsWorker(ambientModuleExportDecls, coalesceExports);
+                }
             }
             return changeTracker.getChanges();
             function organizeImportsWorker(oldImportDecls, coalesce) {
@@ -144526,8 +144857,12 @@ var ts;
                 // Consider: we could do a more careful check that this trivia is actually a header,
                 // but the consequences of being wrong are very minor.
                 ts.suppressLeadingTrivia(oldImportDecls[0]);
-                var oldImportGroups = ts.group(oldImportDecls, function (importDecl) { return getExternalModuleName(importDecl.moduleSpecifier); });
-                var sortedImportGroups = ts.stableSort(oldImportGroups, function (group1, group2) { return compareModuleSpecifiers(group1[0].moduleSpecifier, group2[0].moduleSpecifier); });
+                var oldImportGroups = shouldCombine
+                    ? ts.group(oldImportDecls, function (importDecl) { return getExternalModuleName(importDecl.moduleSpecifier); })
+                    : [oldImportDecls];
+                var sortedImportGroups = shouldSort
+                    ? ts.stableSort(oldImportGroups, function (group1, group2) { return compareModuleSpecifiers(group1[0].moduleSpecifier, group2[0].moduleSpecifier); })
+                    : oldImportGroups;
                 var newImportDecls = ts.flatMap(sortedImportGroups, function (importGroup) {
                     return getExternalModuleName(importGroup[0].moduleSpecifier)
                         ? coalesce(importGroup)
@@ -144591,11 +144926,7 @@ var ts;
             }
             return false;
         }
-        function removeUnusedImports(oldImports, sourceFile, program, skipDestructiveCodeActions) {
-            // As a precaution, consider unused import detection to be destructive (GH #43051)
-            if (skipDestructiveCodeActions) {
-                return oldImports;
-            }
+        function removeUnusedImports(oldImports, sourceFile, program) {
             var typeChecker = program.getTypeChecker();
             var compilerOptions = program.getCompilerOptions();
             var jsxNamespace = typeChecker.getJsxNamespace(sourceFile);
@@ -145451,7 +145782,7 @@ var ts;
         return bestMatch;
     }
     function betterMatch(a, b) {
-        return ts.min(a, b, compareMatches);
+        return ts.min([a, b], compareMatches);
     }
     function compareMatches(a, b) {
         return a === undefined ? 1 /* Comparison.GreaterThan */ : b === undefined ? -1 /* Comparison.LessThan */
@@ -146060,8 +146391,8 @@ var ts;
                 }
                 if (ts.scanner.getToken() === 15 /* SyntaxKind.TemplateHead */) {
                     var stack = [ts.scanner.getToken()];
-                    var token = ts.scanner.scan();
                     loop: while (ts.length(stack)) {
+                        var token = ts.scanner.scan();
                         switch (token) {
                             case 1 /* SyntaxKind.EndOfFileToken */:
                                 break loop;
@@ -146089,7 +146420,6 @@ var ts;
                                 }
                                 break;
                         }
-                        token = ts.scanner.scan();
                     }
                     nextToken();
                 }
@@ -148568,7 +148898,7 @@ var ts;
                 tags = signature.getJsDocTags();
                 if (allSignatures.length > 1 && documentation.length === 0 && tags.length === 0) {
                     documentation = allSignatures[0].getDocumentationComment(typeChecker);
-                    tags = allSignatures[0].getJsDocTags();
+                    tags = allSignatures[0].getJsDocTags().filter(function (tag) { return tag.name !== "deprecated"; }); // should only include @deprecated JSDoc tag on the first overload (#49368)
                 }
             }
             function writeTypeParametersOfSymbol(symbol, enclosingDeclaration) {
@@ -148911,7 +149241,7 @@ var ts;
                 return false;
             }
             function shouldRescanJsxText(node) {
-                return ts.isJsxText(node);
+                return ts.isJsxText(node) || ts.isJsxElement(node) && (lastTokenInfo === null || lastTokenInfo === void 0 ? void 0 : lastTokenInfo.token.kind) === 11 /* SyntaxKind.JsxText */;
             }
             function shouldRescanSlashToken(container) {
                 return container.kind === 13 /* SyntaxKind.RegularExpressionLiteral */;
@@ -149680,10 +150010,10 @@ var ts;
                 !nodeIsInDecoratorContext(context.nextTokenParent);
         }
         function nodeIsInDecoratorContext(node) {
-            while (ts.isExpressionNode(node)) {
+            while (node && ts.isExpression(node)) {
                 node = node.parent;
             }
-            return node.kind === 167 /* SyntaxKind.Decorator */;
+            return node && node.kind === 167 /* SyntaxKind.Decorator */;
         }
         function isStartOfVariableDeclarationList(context) {
             return context.currentTokenParent.kind === 258 /* SyntaxKind.VariableDeclarationList */ &&
@@ -152601,6 +152931,26 @@ var ts;
         function startPositionToDeleteNodeInList(sourceFile, node) {
             return ts.skipTrivia(sourceFile.text, getAdjustedStartPosition(sourceFile, node, { leadingTriviaOption: LeadingTriviaOption.IncludeAll }), /*stopAfterLineBreak*/ false, /*stopAtComments*/ true);
         }
+        function endPositionToDeleteNodeInList(sourceFile, node, prevNode, nextNode) {
+            var end = startPositionToDeleteNodeInList(sourceFile, nextNode);
+            if (prevNode === undefined || ts.positionsAreOnSameLine(getAdjustedEndPosition(sourceFile, node, {}), end, sourceFile)) {
+                return end;
+            }
+            var token = ts.findPrecedingToken(nextNode.getStart(sourceFile), sourceFile);
+            if (isSeparator(node, token)) {
+                var prevToken = ts.findPrecedingToken(node.getStart(sourceFile), sourceFile);
+                if (isSeparator(prevNode, prevToken)) {
+                    var pos = ts.skipTrivia(sourceFile.text, token.getEnd(), /*stopAfterLineBreak*/ true, /*stopAtComments*/ true);
+                    if (ts.positionsAreOnSameLine(prevToken.getStart(sourceFile), token.getStart(sourceFile), sourceFile)) {
+                        return ts.isLineBreak(sourceFile.text.charCodeAt(pos - 1)) ? pos - 1 : pos;
+                    }
+                    if (ts.isLineBreak(sourceFile.text.charCodeAt(pos))) {
+                        return pos;
+                    }
+                }
+            }
+            return end;
+        }
         function getClassOrObjectBraceEnds(cls, sourceFile) {
             var open = ts.findChildOfKind(cls, 18 /* SyntaxKind.OpenBraceToken */, sourceFile);
             var close = ts.findChildOfKind(cls, 19 /* SyntaxKind.CloseBraceToken */, sourceFile);
@@ -153158,7 +153508,7 @@ var ts;
             deletedNodesInLists.add(node);
             changes.deleteRange(sourceFile, {
                 pos: startPositionToDeleteNodeInList(sourceFile, node),
-                end: index === containingList.length - 1 ? getAdjustedEndPosition(sourceFile, node, {}) : startPositionToDeleteNodeInList(sourceFile, containingList[index + 1]),
+                end: index === containingList.length - 1 ? getAdjustedEndPosition(sourceFile, node, {}) : endPositionToDeleteNodeInList(sourceFile, node, containingList[index - 1], containingList[index + 1]),
             });
         }
     })(textChanges = ts.textChanges || (ts.textChanges = {}));
@@ -153628,6 +153978,15 @@ var ts;
             });
         }
         function makeChange(changeTracker, errorCode, sourceFile, checker, insertionSite, fixedDeclarations) {
+            if (ts.isForOfStatement(insertionSite.parent) && !insertionSite.parent.awaitModifier) {
+                var exprType = checker.getTypeAtLocation(insertionSite);
+                var asyncIter = checker.getAsyncIterableType();
+                if (asyncIter && checker.isTypeAssignableTo(exprType, asyncIter)) {
+                    var forOf = insertionSite.parent;
+                    changeTracker.replaceNode(sourceFile, forOf, ts.factory.updateForOfStatement(forOf, ts.factory.createToken(133 /* SyntaxKind.AwaitKeyword */), forOf.initializer, forOf.expression, forOf.statement));
+                    return;
+                }
+            }
             if (ts.isBinaryExpression(insertionSite)) {
                 for (var _i = 0, _a = [insertionSite.left, insertionSite.right]; _i < _a.length; _i++) {
                     var side = _a[_i];
@@ -157353,6 +157712,143 @@ var ts;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
+(function (ts) {
+    var codefix;
+    (function (codefix) {
+        var fixId = "fixImportNonExportedMember";
+        var errorCodes = [
+            ts.Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported.code,
+        ];
+        codefix.registerCodeFix({
+            errorCodes: errorCodes,
+            fixIds: [fixId],
+            getCodeActions: function (context) {
+                var sourceFile = context.sourceFile, span = context.span, program = context.program;
+                var info = getInfo(sourceFile, span.start, program);
+                if (info === undefined)
+                    return undefined;
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, program, info); });
+                return [codefix.createCodeFixAction(fixId, changes, [ts.Diagnostics.Export_0_from_module_1, info.exportName.node.text, info.moduleSpecifier], fixId, ts.Diagnostics.Export_all_referenced_locals)];
+            },
+            getAllCodeActions: function (context) {
+                var program = context.program;
+                return codefix.createCombinedCodeActions(ts.textChanges.ChangeTracker.with(context, function (changes) {
+                    var exports = new ts.Map();
+                    codefix.eachDiagnostic(context, errorCodes, function (diag) {
+                        var info = getInfo(diag.file, diag.start, program);
+                        if (info === undefined)
+                            return undefined;
+                        var exportName = info.exportName, node = info.node, moduleSourceFile = info.moduleSourceFile;
+                        if (tryGetExportDeclaration(moduleSourceFile, exportName.isTypeOnly) === undefined && ts.canHaveExportModifier(node)) {
+                            changes.insertExportModifier(moduleSourceFile, node);
+                        }
+                        else {
+                            var moduleExports = exports.get(moduleSourceFile) || { typeOnlyExports: [], exports: [] };
+                            if (exportName.isTypeOnly) {
+                                moduleExports.typeOnlyExports.push(exportName);
+                            }
+                            else {
+                                moduleExports.exports.push(exportName);
+                            }
+                            exports.set(moduleSourceFile, moduleExports);
+                        }
+                    });
+                    exports.forEach(function (moduleExports, moduleSourceFile) {
+                        var exportDeclaration = tryGetExportDeclaration(moduleSourceFile, /*isTypeOnly*/ true);
+                        if (exportDeclaration && exportDeclaration.isTypeOnly) {
+                            doChanges(changes, program, moduleSourceFile, moduleExports.typeOnlyExports, exportDeclaration);
+                            doChanges(changes, program, moduleSourceFile, moduleExports.exports, tryGetExportDeclaration(moduleSourceFile, /*isTypeOnly*/ false));
+                        }
+                        else {
+                            doChanges(changes, program, moduleSourceFile, __spreadArray(__spreadArray([], moduleExports.exports, true), moduleExports.typeOnlyExports, true), exportDeclaration);
+                        }
+                    });
+                }));
+            }
+        });
+        function getInfo(sourceFile, pos, program) {
+            var _a;
+            var token = ts.getTokenAtPosition(sourceFile, pos);
+            if (ts.isIdentifier(token)) {
+                var importDeclaration = ts.findAncestor(token, ts.isImportDeclaration);
+                if (importDeclaration === undefined)
+                    return undefined;
+                var moduleSpecifier = ts.isStringLiteral(importDeclaration.moduleSpecifier) ? importDeclaration.moduleSpecifier.text : undefined;
+                if (moduleSpecifier === undefined)
+                    return undefined;
+                var resolvedModule = ts.getResolvedModule(sourceFile, moduleSpecifier, /*mode*/ undefined);
+                if (resolvedModule === undefined)
+                    return undefined;
+                var moduleSourceFile = program.getSourceFile(resolvedModule.resolvedFileName);
+                if (moduleSourceFile === undefined || ts.isSourceFileFromLibrary(program, moduleSourceFile))
+                    return undefined;
+                var moduleSymbol = moduleSourceFile.symbol;
+                var locals = (_a = moduleSymbol.valueDeclaration) === null || _a === void 0 ? void 0 : _a.locals;
+                if (locals === undefined)
+                    return undefined;
+                var localSymbol = locals.get(token.escapedText);
+                if (localSymbol === undefined)
+                    return undefined;
+                var node = getNodeOfSymbol(localSymbol);
+                if (node === undefined)
+                    return undefined;
+                var exportName = { node: token, isTypeOnly: ts.isTypeDeclaration(node) };
+                return { exportName: exportName, node: node, moduleSourceFile: moduleSourceFile, moduleSpecifier: moduleSpecifier };
+            }
+            return undefined;
+        }
+        function doChange(changes, program, _a) {
+            var exportName = _a.exportName, node = _a.node, moduleSourceFile = _a.moduleSourceFile;
+            var exportDeclaration = tryGetExportDeclaration(moduleSourceFile, exportName.isTypeOnly);
+            if (exportDeclaration) {
+                updateExport(changes, program, moduleSourceFile, exportDeclaration, [exportName]);
+            }
+            else if (ts.canHaveExportModifier(node)) {
+                changes.insertExportModifier(moduleSourceFile, node);
+            }
+            else {
+                createExport(changes, program, moduleSourceFile, [exportName]);
+            }
+        }
+        function doChanges(changes, program, sourceFile, moduleExports, node) {
+            if (ts.length(moduleExports)) {
+                if (node) {
+                    updateExport(changes, program, sourceFile, node, moduleExports);
+                }
+                else {
+                    createExport(changes, program, sourceFile, moduleExports);
+                }
+            }
+        }
+        function tryGetExportDeclaration(sourceFile, isTypeOnly) {
+            var predicate = function (node) {
+                return ts.isExportDeclaration(node) && (isTypeOnly && node.isTypeOnly || !node.isTypeOnly);
+            };
+            return ts.findLast(sourceFile.statements, predicate);
+        }
+        function updateExport(changes, program, sourceFile, node, names) {
+            var namedExports = node.exportClause && ts.isNamedExports(node.exportClause) ? node.exportClause.elements : ts.factory.createNodeArray([]);
+            var allowTypeModifier = !node.isTypeOnly && !!(program.getCompilerOptions().isolatedModules || ts.find(namedExports, function (e) { return e.isTypeOnly; }));
+            changes.replaceNode(sourceFile, node, ts.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, ts.factory.createNamedExports(ts.factory.createNodeArray(__spreadArray(__spreadArray([], namedExports, true), createExportSpecifiers(names, allowTypeModifier), true), /*hasTrailingComma*/ namedExports.hasTrailingComma)), node.moduleSpecifier, node.assertClause));
+        }
+        function createExport(changes, program, sourceFile, names) {
+            changes.insertNodeAtEndOfScope(sourceFile, sourceFile, ts.factory.createExportDeclaration(/*modifiers*/ undefined, /*isTypeOnly*/ false, ts.factory.createNamedExports(createExportSpecifiers(names, /*allowTypeModifier*/ !!program.getCompilerOptions().isolatedModules)), /*moduleSpecifier*/ undefined, /*assertClause*/ undefined));
+        }
+        function createExportSpecifiers(names, allowTypeModifier) {
+            return ts.factory.createNodeArray(ts.map(names, function (n) { return ts.factory.createExportSpecifier(allowTypeModifier && n.isTypeOnly, /*propertyName*/ undefined, n.node); }));
+        }
+        function getNodeOfSymbol(symbol) {
+            if (symbol.valueDeclaration === undefined) {
+                return ts.firstOrUndefined(symbol.declarations);
+            }
+            var declaration = symbol.valueDeclaration;
+            var variableStatement = ts.isVariableDeclaration(declaration) ? ts.tryCast(declaration.parent.parent, ts.isVariableStatement) : undefined;
+            return variableStatement && ts.length(variableStatement.declarationList.declarations) === 1 ? variableStatement : declaration;
+        }
+    })(codefix = ts.codefix || (ts.codefix = {}));
+})(ts || (ts = {}));
+/* @internal */
+var ts;
 (function (ts) {
     var codefix;
     (function (codefix) {
@@ -157883,7 +158379,7 @@ var ts;
                 var argIndex = ts.findIndex(parent.parent.arguments, function (arg) { return arg === parent; });
                 if (argIndex < 0)
                     return undefined;
-                var signature = ts.singleOrUndefined(checker.getSignaturesOfType(checker.getTypeAtLocation(parent.parent.expression), 0 /* SignatureKind.Call */));
+                var signature = checker.getResolvedSignature(parent.parent);
                 if (!(signature && signature.declaration && signature.parameters[argIndex]))
                     return undefined;
                 var param = signature.parameters[argIndex].valueDeclaration;
@@ -157930,13 +158426,13 @@ var ts;
             if (ts.isIdentifier(token) && ts.isCallExpression(parent.parent)) {
                 var moduleDeclaration = ts.find(symbol.declarations, ts.isModuleDeclaration);
                 var moduleDeclarationSourceFile = moduleDeclaration === null || moduleDeclaration === void 0 ? void 0 : moduleDeclaration.getSourceFile();
-                if (moduleDeclaration && moduleDeclarationSourceFile && !isSourceFileFromLibrary(program, moduleDeclarationSourceFile)) {
+                if (moduleDeclaration && moduleDeclarationSourceFile && !ts.isSourceFileFromLibrary(program, moduleDeclarationSourceFile)) {
                     return { kind: InfoKind.Function, token: token, call: parent.parent, sourceFile: sourceFile, modifierFlags: 1 /* ModifierFlags.Export */, parentDeclaration: moduleDeclaration };
                 }
                 var moduleSourceFile = ts.find(symbol.declarations, ts.isSourceFile);
                 if (sourceFile.commonJsModuleIndicator)
                     return undefined;
-                if (moduleSourceFile && !isSourceFileFromLibrary(program, moduleSourceFile)) {
+                if (moduleSourceFile && !ts.isSourceFileFromLibrary(program, moduleSourceFile)) {
                     return { kind: InfoKind.Function, token: token, call: parent.parent, sourceFile: moduleSourceFile, modifierFlags: 1 /* ModifierFlags.Export */, parentDeclaration: moduleSourceFile };
                 }
             }
@@ -157946,7 +158442,7 @@ var ts;
                 return undefined;
             // Prefer to change the class instead of the interface if they are merged
             var declaration = classDeclaration || ts.find(symbol.declarations, function (d) { return ts.isInterfaceDeclaration(d) || ts.isTypeLiteralNode(d); });
-            if (declaration && !isSourceFileFromLibrary(program, declaration.getSourceFile())) {
+            if (declaration && !ts.isSourceFileFromLibrary(program, declaration.getSourceFile())) {
                 var makeStatic = !ts.isTypeLiteralNode(declaration) && (leftExpressionType.target || leftExpressionType) !== checker.getDeclaredTypeOfSymbol(symbol);
                 if (makeStatic && (ts.isPrivateIdentifier(token) || ts.isInterfaceDeclaration(declaration)))
                     return undefined;
@@ -157958,14 +158454,11 @@ var ts;
                 return { kind: InfoKind.TypeLikeDeclaration, token: token, call: call, modifierFlags: modifierFlags, parentDeclaration: declaration, declSourceFile: declSourceFile, isJSFile: isJSFile };
             }
             var enumDeclaration = ts.find(symbol.declarations, ts.isEnumDeclaration);
-            if (enumDeclaration && !(leftExpressionType.flags & 1056 /* TypeFlags.EnumLike */) && !ts.isPrivateIdentifier(token) && !isSourceFileFromLibrary(program, enumDeclaration.getSourceFile())) {
+            if (enumDeclaration && !(leftExpressionType.flags & 1056 /* TypeFlags.EnumLike */) && !ts.isPrivateIdentifier(token) && !ts.isSourceFileFromLibrary(program, enumDeclaration.getSourceFile())) {
                 return { kind: InfoKind.Enum, token: token, parentDeclaration: enumDeclaration };
             }
             return undefined;
         }
-        function isSourceFileFromLibrary(program, node) {
-            return program.isSourceFileFromExternalLibrary(node) || program.isSourceFileDefaultLibrary(node);
-        }
         function getActionsForMissingMemberDeclaration(context, info) {
             return info.isJSFile ? ts.singleElementArray(createActionForAddMissingMemberInJavascriptFile(context, info)) :
                 createActionsForAddMissingMemberInTypeScriptFile(context, info);
@@ -163391,8 +163884,8 @@ var ts;
                 var i = 0;
                 for (var _i = 0, extractions_1 = extractions; _i < extractions_1.length; _i++) {
                     var _a = extractions_1[_i], functionExtraction = _a.functionExtraction, constantExtraction = _a.constantExtraction;
-                    var description = functionExtraction.description;
                     if (refactor.refactorKindBeginsWith(extractFunctionAction.kind, requestedRefactor)) {
+                        var description = functionExtraction.description;
                         if (functionExtraction.errors.length === 0) {
                             // Don't issue refactorings with duplicated names.
                             // Scopes come back in "innermost first" order, so extractions will
@@ -163416,15 +163909,15 @@ var ts;
                         }
                     }
                     if (refactor.refactorKindBeginsWith(extractConstantAction.kind, requestedRefactor)) {
+                        var description = constantExtraction.description;
                         if (constantExtraction.errors.length === 0) {
                             // Don't issue refactorings with duplicated names.
                             // Scopes come back in "innermost first" order, so extractions will
                             // preferentially go into nearer scopes
-                            var description_1 = constantExtraction.description;
-                            if (!usedConstantNames.has(description_1)) {
-                                usedConstantNames.set(description_1, true);
+                            if (!usedConstantNames.has(description)) {
+                                usedConstantNames.set(description, true);
                                 constantActions.push({
-                                    description: description_1,
+                                    description: description,
                                     name: "constant_scope_".concat(i),
                                     kind: extractConstantAction.kind
                                 });
@@ -163569,7 +164062,6 @@ var ts;
                 var start = cursorRequest ? getExtractableParent(startToken) : ts.getParentNodeInSpan(startToken, sourceFile, adjustedSpan);
                 // Do the same for the ending position
                 var end = cursorRequest ? start : ts.getParentNodeInSpan(endToken, sourceFile, adjustedSpan);
-                var declarations = [];
                 // We'll modify these flags as we walk the tree to collect data
                 // about what things need to be done as part of the extraction.
                 var rangeFacts = RangeFacts.None;
@@ -163612,7 +164104,7 @@ var ts;
                         // the expression.
                         return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] };
                     }
-                    return { targetRange: { range: statements, facts: rangeFacts, declarations: declarations, thisNode: thisNode } };
+                    return { targetRange: { range: statements, facts: rangeFacts, thisNode: thisNode } };
                 }
                 if (ts.isReturnStatement(start) && !start.expression) {
                     // Makes no sense to extract an expression-less return statement.
@@ -163624,7 +164116,7 @@ var ts;
                 if (errors) {
                     return { errors: errors };
                 }
-                return { targetRange: { range: getStatementOrExpressionRange(node), facts: rangeFacts, declarations: declarations, thisNode: thisNode } }; // TODO: GH#18217
+                return { targetRange: { range: getStatementOrExpressionRange(node), facts: rangeFacts, thisNode: thisNode } }; // TODO: GH#18217
                 /**
                  * Attempt to refine the extraction node (generally, by shrinking it) to produce better results.
                  * @param node The unrefined extraction node.
@@ -163636,10 +164128,10 @@ var ts;
                         }
                     }
                     else if (ts.isVariableStatement(node) || ts.isVariableDeclarationList(node)) {
-                        var declarations_6 = ts.isVariableStatement(node) ? node.declarationList.declarations : node.declarations;
+                        var declarations = ts.isVariableStatement(node) ? node.declarationList.declarations : node.declarations;
                         var numInitializers = 0;
                         var lastInitializer = void 0;
-                        for (var _i = 0, declarations_5 = declarations_6; _i < declarations_5.length; _i++) {
+                        for (var _i = 0, declarations_5 = declarations; _i < declarations_5.length; _i++) {
                             var declaration = declarations_5[_i];
                             if (declaration.initializer) {
                                 numInitializers++;
@@ -163739,7 +164231,6 @@ var ts;
                                 (errors || (errors = [])).push(ts.createDiagnosticForNode(node, Messages.cannotExtractExportedEntity));
                                 return true;
                             }
-                            declarations.push(node.symbol);
                         }
                         // Some things can't be extracted in certain situations
                         switch (node.kind) {
@@ -165464,7 +165955,7 @@ var ts;
         function getNewStatementsAndRemoveFromOldFile(oldFile, usage, changes, toMove, program, newModuleName, preferences) {
             var checker = program.getTypeChecker();
             var prologueDirectives = ts.takeWhile(oldFile.statements, ts.isPrologueDirective);
-            if (!oldFile.externalModuleIndicator && !oldFile.commonJsModuleIndicator) {
+            if (oldFile.externalModuleIndicator === undefined && oldFile.commonJsModuleIndicator === undefined && usage.oldImportsNeededByNewFile.size() === 0) {
                 deleteMovedStatements(oldFile, toMove.ranges, changes);
                 return __spreadArray(__spreadArray([], prologueDirectives, true), toMove.all, true);
             }
@@ -165705,7 +166196,12 @@ var ts;
             switch (name.kind) {
                 case 79 /* SyntaxKind.Identifier */:
                     if (isUnused(name)) {
-                        changes.delete(sourceFile, name);
+                        if (varDecl.initializer && ts.isRequireCall(varDecl.initializer, /*requireStringLiteralLikeArgument*/ true)) {
+                            changes.delete(sourceFile, ts.isVariableDeclarationList(varDecl.parent) && ts.length(varDecl.parent.declarations) === 1 ? varDecl.parent.parent : varDecl);
+                        }
+                        else {
+                            changes.delete(sourceFile, name);
+                        }
                     }
                     break;
                 case 204 /* SyntaxKind.ArrayBindingPattern */:
@@ -165937,6 +166433,9 @@ var ts;
                 ts.copyEntries(this.map, clone.map);
                 return clone;
             };
+            SymbolSet.prototype.size = function () {
+                return this.map.size;
+            };
             return SymbolSet;
         }());
         function isTopLevelDeclaration(node) {
@@ -166025,7 +166524,8 @@ var ts;
             if (useEs6Exports) {
                 return !ts.isExpressionStatement(decl) && ts.hasSyntacticModifier(decl, 1 /* ModifierFlags.Export */) || !!(name && ((_a = sourceFile.symbol.exports) === null || _a === void 0 ? void 0 : _a.has(name.escapedText)));
             }
-            return getNamesToExportInCommonJS(decl).some(function (name) { return sourceFile.symbol.exports.has(ts.escapeLeadingUnderscores(name)); });
+            return !!sourceFile.symbol && !!sourceFile.symbol.exports &&
+                getNamesToExportInCommonJS(decl).some(function (name) { return sourceFile.symbol.exports.has(ts.escapeLeadingUnderscores(name)); });
         }
         function addExport(decl, useEs6Exports) {
             return useEs6Exports ? [addEs6Export(decl)] : addCommonjsExport(decl);
@@ -167785,8 +168285,8 @@ var ts;
                     tags = __spreadArray(__spreadArray([], inheritedTags, true), tags, true);
                 }
             };
-            for (var _i = 0, declarations_7 = declarations; _i < declarations_7.length; _i++) {
-                var declaration = declarations_7[_i];
+            for (var _i = 0, declarations_6 = declarations; _i < declarations_6.length; _i++) {
+                var declaration = declarations_6[_i];
                 _loop_20(declaration);
             }
         }
@@ -167812,8 +168312,8 @@ var ts;
                 if (inheritedDocs)
                     doc = doc.length === 0 ? inheritedDocs.slice() : inheritedDocs.concat(ts.lineBreakPart(), doc);
             };
-            for (var _i = 0, declarations_8 = declarations; _i < declarations_8.length; _i++) {
-                var declaration = declarations_8[_i];
+            for (var _i = 0, declarations_7 = declarations; _i < declarations_7.length; _i++) {
+                var declaration = declarations_7[_i];
                 _loop_21(declaration);
             }
         }
@@ -168983,12 +169483,14 @@ var ts;
             return ts.codefix.getAllFixes({ fixId: fixId, sourceFile: sourceFile, program: program, host: host, cancellationToken: cancellationToken, formatContext: formatContext, preferences: preferences });
         }
         function organizeImports(args, formatOptions, preferences) {
+            var _a;
             if (preferences === void 0) { preferences = ts.emptyOptions; }
             synchronizeHostData();
             ts.Debug.assert(args.type === "file");
             var sourceFile = getValidSourceFile(args.fileName);
             var formatContext = ts.formatting.getFormatContext(formatOptions, host);
-            return ts.OrganizeImports.organizeImports(sourceFile, formatContext, host, program, preferences, args.skipDestructiveCodeActions);
+            var mode = (_a = args.mode) !== null && _a !== void 0 ? _a : (args.skipDestructiveCodeActions ? "SortAndCombine" /* OrganizeImportsMode.SortAndCombine */ : "All" /* OrganizeImportsMode.All */);
+            return ts.OrganizeImports.organizeImports(sourceFile, formatContext, host, program, preferences, mode);
         }
         function getEditsForFileRename(oldFilePath, newFilePath, formatOptions, preferences) {
             if (preferences === void 0) { preferences = ts.emptyOptions; }
@@ -171987,6 +172489,12 @@ var ts;
                 CommandTypes["ProvideInlayHints"] = "provideInlayHints";
                 // NOTE: If updating this, be sure to also update `allCommandNames` in `testRunner/unittests/tsserver/session.ts`.
             })(CommandTypes = protocol.CommandTypes || (protocol.CommandTypes = {}));
+            var OrganizeImportsMode;
+            (function (OrganizeImportsMode) {
+                OrganizeImportsMode["All"] = "All";
+                OrganizeImportsMode["SortAndCombine"] = "SortAndCombine";
+                OrganizeImportsMode["RemoveUnused"] = "RemoveUnused";
+            })(OrganizeImportsMode = protocol.OrganizeImportsMode || (protocol.OrganizeImportsMode = {}));
             var WatchFileKind;
             (function (WatchFileKind) {
                 WatchFileKind["FixedPollingInterval"] = "FixedPollingInterval";
@@ -172873,6 +173381,7 @@ var ts;
                 this.watchOptions = watchOptions;
                 this.rootFiles = [];
                 this.rootFilesMap = new ts.Map();
+                /*@internal*/
                 this.plugins = [];
                 /*@internal*/
                 /**
@@ -173401,6 +173910,7 @@ var ts;
                 this.directoryStructureHost = undefined;
                 this.exportMapCache = undefined;
                 this.projectErrors = undefined;
+                this.plugins.length = 0;
                 // Clean up file watchers waiting for missing files
                 if (this.missingFilesMap) {
                     ts.clearMap(this.missingFilesMap, ts.closeFileWatcher);
@@ -174074,35 +174584,39 @@ var ts;
             Project.prototype.isSourceOfProjectReferenceRedirect = function (fileName) {
                 return !!this.program && this.program.isSourceOfProjectReferenceRedirect(fileName);
             };
+            /*@internal*/
+            Project.prototype.getGlobalPluginSearchPaths = function () {
+                // Search any globally-specified probe paths, then our peer node_modules
+                return __spreadArray(__spreadArray([], this.projectService.pluginProbeLocations, true), [
+                    // ../../.. to walk from X/node_modules/typescript/lib/tsserver.js to X/node_modules/
+                    ts.combinePaths(this.projectService.getExecutingFilePath(), "../../.."),
+                ], false);
+            };
             Project.prototype.enableGlobalPlugins = function (options, pluginConfigOverrides) {
+                if (!this.projectService.globalPlugins.length)
+                    return;
                 var host = this.projectService.host;
                 if (!host.require && !host.importPlugin) {
                     this.projectService.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded");
                     return;
                 }
-                // Search any globally-specified probe paths, then our peer node_modules
-                var searchPaths = __spreadArray(__spreadArray([], this.projectService.pluginProbeLocations, true), [
-                    // ../../.. to walk from X/node_modules/typescript/lib/tsserver.js to X/node_modules/
-                    ts.combinePaths(this.projectService.getExecutingFilePath(), "../../.."),
-                ], false);
-                if (this.projectService.globalPlugins) {
-                    var _loop_1 = function (globalPluginName) {
-                        // Skip empty names from odd commandline parses
-                        if (!globalPluginName)
-                            return "continue";
-                        // Skip already-locally-loaded plugins
-                        if (options.plugins && options.plugins.some(function (p) { return p.name === globalPluginName; }))
-                            return "continue";
-                        // Provide global: true so plugins can detect why they can't find their config
-                        this_1.projectService.logger.info("Loading global plugin ".concat(globalPluginName));
-                        this_1.enablePlugin({ name: globalPluginName, global: true }, searchPaths, pluginConfigOverrides);
-                    };
-                    var this_1 = this;
-                    // Enable global plugins with synthetic configuration entries
-                    for (var _i = 0, _a = this.projectService.globalPlugins; _i < _a.length; _i++) {
-                        var globalPluginName = _a[_i];
-                        _loop_1(globalPluginName);
-                    }
+                // Enable global plugins with synthetic configuration entries
+                var searchPaths = this.getGlobalPluginSearchPaths();
+                var _loop_1 = function (globalPluginName) {
+                    // Skip empty names from odd commandline parses
+                    if (!globalPluginName)
+                        return "continue";
+                    // Skip already-locally-loaded plugins
+                    if (options.plugins && options.plugins.some(function (p) { return p.name === globalPluginName; }))
+                        return "continue";
+                    // Provide global: true so plugins can detect why they can't find their config
+                    this_1.projectService.logger.info("Loading global plugin ".concat(globalPluginName));
+                    this_1.enablePlugin({ name: globalPluginName, global: true }, searchPaths, pluginConfigOverrides);
+                };
+                var this_1 = this;
+                for (var _i = 0, _a = this.projectService.globalPlugins; _i < _a.length; _i++) {
+                    var globalPluginName = _a[_i];
+                    _loop_1(globalPluginName);
                 }
             };
             /**
@@ -174833,14 +175347,16 @@ var ts;
             };
             /*@internal*/
             ConfiguredProject.prototype.enablePluginsWithOptions = function (options, pluginConfigOverrides) {
+                var _a;
+                this.plugins.length = 0;
+                if (!((_a = options.plugins) === null || _a === void 0 ? void 0 : _a.length) && !this.projectService.globalPlugins.length)
+                    return;
                 var host = this.projectService.host;
                 if (!host.require && !host.importPlugin) {
                     this.projectService.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded");
                     return;
                 }
-                // Search our peer node_modules, then any globally-specified probe paths
-                // ../../.. to walk from X/node_modules/typescript/lib/tsserver.js to X/node_modules/
-                var searchPaths = __spreadArray([ts.combinePaths(this.projectService.getExecutingFilePath(), "../../..")], this.projectService.pluginProbeLocations, true);
+                var searchPaths = this.getGlobalPluginSearchPaths();
                 if (this.projectService.allowLocalPluginLoads) {
                     var local = ts.getDirectoryPath(this.canonicalConfigFilePath);
                     this.projectService.logger.info("Local plugin loading enabled; adding ".concat(local, " to search paths"));
@@ -174848,8 +175364,8 @@ var ts;
                 }
                 // Enable tsconfig-specified plugins
                 if (options.plugins) {
-                    for (var _i = 0, _a = options.plugins; _i < _a.length; _i++) {
-                        var pluginConfigEntry = _a[_i];
+                    for (var _i = 0, _b = options.plugins; _i < _b.length; _i++) {
+                        var pluginConfigEntry = _b[_i];
                         this.enablePlugin(pluginConfigEntry, searchPaths, pluginConfigOverrides);
                     }
                 }
@@ -175694,18 +176210,20 @@ var ts;
                 return ensureProject ? this.ensureDefaultProjectForFile(fileName) : this.tryGetDefaultProjectForFile(fileName);
             };
             /* @internal */
-            ProjectService.prototype.tryGetDefaultProjectForFile = function (fileName) {
-                var scriptInfo = this.getScriptInfoForNormalizedPath(fileName);
+            ProjectService.prototype.tryGetDefaultProjectForFile = function (fileNameOrScriptInfo) {
+                var scriptInfo = ts.isString(fileNameOrScriptInfo) ? this.getScriptInfoForNormalizedPath(fileNameOrScriptInfo) : fileNameOrScriptInfo;
                 return scriptInfo && !scriptInfo.isOrphan() ? scriptInfo.getDefaultProject() : undefined;
             };
             /* @internal */
-            ProjectService.prototype.ensureDefaultProjectForFile = function (fileName) {
-                return this.tryGetDefaultProjectForFile(fileName) || this.doEnsureDefaultProjectForFile(fileName);
+            ProjectService.prototype.ensureDefaultProjectForFile = function (fileNameOrScriptInfo) {
+                return this.tryGetDefaultProjectForFile(fileNameOrScriptInfo) || this.doEnsureDefaultProjectForFile(fileNameOrScriptInfo);
             };
-            ProjectService.prototype.doEnsureDefaultProjectForFile = function (fileName) {
+            ProjectService.prototype.doEnsureDefaultProjectForFile = function (fileNameOrScriptInfo) {
                 this.ensureProjectStructuresUptoDate();
-                var scriptInfo = this.getScriptInfoForNormalizedPath(fileName);
-                return scriptInfo ? scriptInfo.getDefaultProject() : (this.logErrorForScriptInfoNotFound(fileName), server.Errors.ThrowNoProject());
+                var scriptInfo = ts.isString(fileNameOrScriptInfo) ? this.getScriptInfoForNormalizedPath(fileNameOrScriptInfo) : fileNameOrScriptInfo;
+                return scriptInfo ?
+                    scriptInfo.getDefaultProject() :
+                    (this.logErrorForScriptInfoNotFound(ts.isString(fileNameOrScriptInfo) ? fileNameOrScriptInfo : fileNameOrScriptInfo.fileName), server.Errors.ThrowNoProject());
             };
             ProjectService.prototype.getScriptInfoEnsuringProjectsUptoDate = function (uncheckedFileName) {
                 this.ensureProjectStructuresUptoDate();
@@ -177877,7 +178395,7 @@ var ts;
                 if (this.serverMode !== ts.LanguageServiceMode.Semantic || !this.eventHandler || !scriptInfo.isJavaScript() || !ts.addToSeen(this.allJsFilesForOpenFileTelemetry, scriptInfo.path)) {
                     return;
                 }
-                var project = scriptInfo.getDefaultProject();
+                var project = this.ensureDefaultProjectForFile(scriptInfo);
                 if (!project.languageServiceEnabled) {
                     return;
                 }
@@ -180477,6 +180995,10 @@ var ts;
                         this.projectService.logErrorForScriptInfoNotFound(args.file);
                         return server.Errors.ThrowNoProject();
                     }
+                    else if (!getScriptInfoEnsuringProjectsUptoDate) {
+                        // Ensure there are containing projects are present
+                        this.projectService.ensureDefaultProjectForFile(scriptInfo);
+                    }
                     projects = scriptInfo.containingProjects;
                     symLinkedProjects = this.projectService.getSymlinkedProjects(scriptInfo);
                 }
@@ -180545,6 +181067,7 @@ var ts;
                 var references = getReferencesWorker(projects, this.getDefaultProject(args), { fileName: args.file, pos: position }, this.logger);
                 if (!simplifiedResult)
                     return references;
+                var preferences = this.getPreferences(file);
                 var defaultProject = this.getDefaultProject(args);
                 var scriptInfo = defaultProject.getScriptInfoForNormalizedPath(file);
                 var nameInfo = defaultProject.getLanguageService().getQuickInfoAtPosition(file, position);
@@ -180553,7 +181076,7 @@ var ts;
                 var symbolStartOffset = nameSpan ? scriptInfo.positionToLineOffset(nameSpan.start).offset : 0;
                 var symbolName = nameSpan ? scriptInfo.getSnapshot().getText(nameSpan.start, ts.textSpanEnd(nameSpan)) : "";
                 var refs = ts.flatMap(references, function (referencedSymbol) {
-                    return referencedSymbol.references.map(function (entry) { return referenceEntryToReferencesResponseItem(_this.projectService, entry); });
+                    return referencedSymbol.references.map(function (entry) { return referenceEntryToReferencesResponseItem(_this.projectService, entry, preferences); });
                 });
                 return { refs: refs, symbolName: symbolName, symbolStartOffset: symbolStartOffset, symbolDisplayString: symbolDisplayString };
             };
@@ -180561,6 +181084,7 @@ var ts;
                 var _this = this;
                 var projects = this.getProjects(args);
                 var fileName = args.file;
+                var preferences = this.getPreferences(server.toNormalizedPath(fileName));
                 var references = [];
                 var seen = createDocumentSpanSet();
                 forEachProjectInProjects(projects, /*path*/ undefined, function (project) {
@@ -180579,7 +181103,7 @@ var ts;
                 });
                 if (!simplifiedResult)
                     return references;
-                var refs = references.map(function (entry) { return referenceEntryToReferencesResponseItem(_this.projectService, entry); });
+                var refs = references.map(function (entry) { return referenceEntryToReferencesResponseItem(_this.projectService, entry, preferences); });
                 return {
                     refs: refs,
                     symbolName: "\"".concat(args.file, "\"")
@@ -180603,13 +181127,7 @@ var ts;
                 return this.getFileAndProjectWorker(args.file, args.projectFileName);
             };
             Session.prototype.getFileAndLanguageServiceForSyntacticOperation = function (args) {
-                // Since this is syntactic operation, there should always be project for the file
-                // throw if we dont get project
-                var file = server.toNormalizedPath(args.file);
-                var project = this.getProject(args.projectFileName) || this.projectService.ensureDefaultProjectForFile(file);
-                if (!project) {
-                    return server.Errors.ThrowNoProject();
-                }
+                var _a = this.getFileAndProject(args), file = _a.file, project = _a.project;
                 return {
                     file: file,
                     languageService: project.getLanguageService(/*ensureSynchronized*/ false)
@@ -181150,11 +181668,12 @@ var ts;
                 }
             };
             Session.prototype.organizeImports = function (args, simplifiedResult) {
+                var _a;
                 ts.Debug.assert(args.scope.type === "file");
-                var _a = this.getFileAndProject(args.scope.args), file = _a.file, project = _a.project;
+                var _b = this.getFileAndProject(args.scope.args), file = _b.file, project = _b.project;
                 var changes = project.getLanguageService().organizeImports({
                     fileName: file,
-                    skipDestructiveCodeActions: args.skipDestructiveCodeActions,
+                    mode: (_a = args.mode) !== null && _a !== void 0 ? _a : (args.skipDestructiveCodeActions ? "SortAndCombine" /* OrganizeImportsMode.SortAndCombine */ : undefined),
                     type: "file",
                 }, this.getFormatOptions(file), this.getPreferences(file));
                 if (simplifiedResult) {
@@ -181648,14 +182167,18 @@ var ts;
             }
             return text;
         }
-        function referenceEntryToReferencesResponseItem(projectService, _a) {
+        function referenceEntryToReferencesResponseItem(projectService, _a, _b) {
             var fileName = _a.fileName, textSpan = _a.textSpan, contextSpan = _a.contextSpan, isWriteAccess = _a.isWriteAccess, isDefinition = _a.isDefinition;
+            var disableLineTextInReferences = _b.disableLineTextInReferences;
             var scriptInfo = ts.Debug.checkDefined(projectService.getScriptInfo(fileName));
             var span = toProtocolTextSpanWithContext(textSpan, contextSpan, scriptInfo);
-            var lineSpan = scriptInfo.lineToTextSpan(span.start.line - 1);
-            var lineText = scriptInfo.getSnapshot().getText(lineSpan.start, ts.textSpanEnd(lineSpan)).replace(/\r|\n/g, "");
+            var lineText = disableLineTextInReferences ? undefined : getLineText(scriptInfo, span);
             return __assign(__assign({ file: fileName }, span), { lineText: lineText, isWriteAccess: isWriteAccess, isDefinition: isDefinition });
         }
+        function getLineText(scriptInfo, span) {
+            var lineSpan = scriptInfo.lineToTextSpan(span.start.line - 1);
+            return scriptInfo.getSnapshot().getText(lineSpan.start, ts.textSpanEnd(lineSpan)).replace(/\r|\n/g, "");
+        }
         function isCompletionEntryData(data) {
             return data === undefined || data && typeof data === "object"
                 && typeof data.exportName === "string"
@@ -185695,6 +186218,9 @@ var ts;
                     process.on("message", function (e) {
                         _this.onMessage(e);
                     });
+                    process.on("disconnect", function () {
+                        _this.exit();
+                    });
                 };
                 return IpcIOSession;
             }(IOSession));