typescript 4.8.0-dev.20220705 → 4.8.0-dev.20220708

package/lib/tsserverlibrary.js

@@ -303,7 +303,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220705";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220708";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -2259,7 +2259,7 @@ var ts;
      *         and 1 insertion/deletion at 3 characters)
      */
     function getSpellingSuggestion(name, candidates, getName) {
-        var maximumLengthDifference = Math.min(2, Math.floor(name.length * 0.34));
+        var maximumLengthDifference = Math.max(2, Math.floor(name.length * 0.34));
         var bestDistance = Math.floor(name.length * 0.4) + 1; // If the best result is worse than this, don't bother.
         var bestCandidate;
         for (var _i = 0, candidates_2 = candidates; _i < candidates_2.length; _i++) {
@@ -2988,6 +2988,22 @@ var ts;
             return formatEnum(flags, ts.FlowFlags, /*isFlags*/ true);
         }
         Debug.formatFlowFlags = formatFlowFlags;
+        function formatRelationComparisonResult(result) {
+            return formatEnum(result, ts.RelationComparisonResult, /*isFlags*/ true);
+        }
+        Debug.formatRelationComparisonResult = formatRelationComparisonResult;
+        function formatCheckMode(mode) {
+            return formatEnum(mode, ts.CheckMode, /*isFlags*/ true);
+        }
+        Debug.formatCheckMode = formatCheckMode;
+        function formatSignatureCheckMode(mode) {
+            return formatEnum(mode, ts.SignatureCheckMode, /*isFlags*/ true);
+        }
+        Debug.formatSignatureCheckMode = formatSignatureCheckMode;
+        function formatTypeFacts(facts) {
+            return formatEnum(facts, ts.TypeFacts, /*isFlags*/ true);
+        }
+        Debug.formatTypeFacts = formatTypeFacts;
         var isDebugInfoEnabled = false;
         var extendedDebugModule;
         function extendedDebug() {
@@ -4940,6 +4956,7 @@ var ts;
         NodeBuilderFlags[NodeBuilderFlags["UseAliasDefinedOutsideCurrentScope"] = 16384] = "UseAliasDefinedOutsideCurrentScope";
         NodeBuilderFlags[NodeBuilderFlags["UseSingleQuotesForStringLiteralType"] = 268435456] = "UseSingleQuotesForStringLiteralType";
         NodeBuilderFlags[NodeBuilderFlags["NoTypeReduction"] = 536870912] = "NoTypeReduction";
+        NodeBuilderFlags[NodeBuilderFlags["OmitThisParameter"] = 33554432] = "OmitThisParameter";
         // Error handling
         NodeBuilderFlags[NodeBuilderFlags["AllowThisInObjectLiteral"] = 32768] = "AllowThisInObjectLiteral";
         NodeBuilderFlags[NodeBuilderFlags["AllowQualifiedNameInPlaceOfIdentifier"] = 65536] = "AllowQualifiedNameInPlaceOfIdentifier";
@@ -4980,6 +4997,7 @@ var ts;
         TypeFormatFlags[TypeFormatFlags["UseAliasDefinedOutsideCurrentScope"] = 16384] = "UseAliasDefinedOutsideCurrentScope";
         TypeFormatFlags[TypeFormatFlags["UseSingleQuotesForStringLiteralType"] = 268435456] = "UseSingleQuotesForStringLiteralType";
         TypeFormatFlags[TypeFormatFlags["NoTypeReduction"] = 536870912] = "NoTypeReduction";
+        TypeFormatFlags[TypeFormatFlags["OmitThisParameter"] = 33554432] = "OmitThisParameter";
         // Error Handling
         TypeFormatFlags[TypeFormatFlags["AllowUniqueESSymbolType"] = 1048576] = "AllowUniqueESSymbolType";
         // TypeFormatFlags exclusive
@@ -4991,7 +5009,7 @@ var ts;
         TypeFormatFlags[TypeFormatFlags["InFirstTypeArgument"] = 4194304] = "InFirstTypeArgument";
         TypeFormatFlags[TypeFormatFlags["InTypeAlias"] = 8388608] = "InTypeAlias";
         /** @deprecated */ TypeFormatFlags[TypeFormatFlags["WriteOwnNameForAnyLike"] = 0] = "WriteOwnNameForAnyLike";
-        TypeFormatFlags[TypeFormatFlags["NodeBuilderFlagsMask"] = 814775659] = "NodeBuilderFlagsMask";
+        TypeFormatFlags[TypeFormatFlags["NodeBuilderFlagsMask"] = 848330091] = "NodeBuilderFlagsMask";
     })(TypeFormatFlags = ts.TypeFormatFlags || (ts.TypeFormatFlags = {}));
     var SymbolFormatFlags;
     (function (SymbolFormatFlags) {
@@ -9225,6 +9243,7 @@ var ts;
         The_type_of_this_expression_cannot_be_named_without_a_resolution_mode_assertion_which_is_an_unstable_feature_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next: diag(2841, ts.DiagnosticCategory.Error, "The_type_of_this_expression_cannot_be_named_without_a_resolution_mode_assertion_which_is_an_unstable_2841", "The type of this expression cannot be named without a 'resolution-mode' assertion, which is an unstable feature. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'."),
         _0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation: diag(2842, ts.DiagnosticCategory.Error, "_0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation_2842", "'{0}' is an unused renaming of '{1}'. Did you intend to use it as a type annotation?"),
         We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here: diag(2843, ts.DiagnosticCategory.Error, "We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here_2843", "We can only write a type for '{0}' by adding a type for the entire parameter here."),
+        Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2844, ts.DiagnosticCategory.Error, "Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2844", "Type of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
         Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -19723,7 +19742,8 @@ var ts;
     function getDeclarationModifierFlagsFromSymbol(s, isWrite) {
         if (isWrite === void 0) { isWrite = false; }
         if (s.valueDeclaration) {
-            var declaration = (isWrite && s.declarations && ts.find(s.declarations, function (d) { return d.kind === 173 /* SetAccessor */; })) || s.valueDeclaration;
+            var declaration = (isWrite && s.declarations && ts.find(s.declarations, ts.isSetAccessorDeclaration))
+                || (s.flags & 32768 /* GetAccessor */ && ts.find(s.declarations, ts.isGetAccessorDeclaration)) || s.valueDeclaration;
             var flags = ts.getCombinedModifierFlags(declaration);
             return s.parent && s.parent.flags & 32 /* Class */ ? flags : flags & ~28 /* AccessibilityModifier */;
         }
@@ -20398,7 +20418,7 @@ var ts;
         // Excludes declaration files - they still require an explicit `export {}` or the like
         // for back compat purposes. The only non-declaration files _not_ forced to be a module are `.js` files
         // that aren't esm-mode (meaning not in a `type: module` scope).
-        return (file.impliedNodeFormat === ts.ModuleKind.ESNext || (ts.fileExtensionIsOneOf(file.fileName, [".cjs" /* Cjs */, ".cts" /* Cts */]))) && !file.isDeclarationFile ? true : undefined;
+        return (file.impliedNodeFormat === ts.ModuleKind.ESNext || (ts.fileExtensionIsOneOf(file.fileName, [".cjs" /* Cjs */, ".cts" /* Cts */, ".mjs" /* Mjs */, ".mts" /* Mts */]))) && !file.isDeclarationFile ? true : undefined;
     }
     function getSetExternalModuleIndicator(options) {
         // TODO: Should this callback be cached?
@@ -20421,10 +20441,7 @@ var ts;
                 if (options.jsx === 4 /* ReactJSX */ || options.jsx === 5 /* ReactJSXDev */) {
                     checks.push(isFileModuleFromUsingJSXTag);
                 }
-                var moduleKind = getEmitModuleKind(options);
-                if (moduleKind === ts.ModuleKind.Node16 || moduleKind === ts.ModuleKind.NodeNext) {
-                    checks.push(isFileForcedToBeModuleByFormat);
-                }
+                checks.push(isFileForcedToBeModuleByFormat);
                 var combined_1 = ts.or.apply(void 0, checks);
                 var callback = function (file) { return void (file.externalModuleIndicator = combined_1(file)); };
                 return callback;
@@ -34144,10 +34161,10 @@ var ts;
             var hasJSDoc = hasPrecedingJSDocComment();
             var modifiers = parseModifiers();
             if (parseContextualModifier(136 /* GetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers, 172 /* GetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers, 172 /* GetAccessor */, 4 /* Type */);
             }
             if (parseContextualModifier(149 /* SetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers, 173 /* SetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers, 173 /* SetAccessor */, 4 /* Type */);
             }
             if (isIndexSignature()) {
                 return parseIndexSignatureDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers);
@@ -36193,10 +36210,10 @@ var ts;
             var decorators = parseDecorators();
             var modifiers = parseModifiers();
             if (parseContextualModifier(136 /* GetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 172 /* GetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 172 /* GetAccessor */, 0 /* None */);
             }
             if (parseContextualModifier(149 /* SetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 173 /* SetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 173 /* SetAccessor */, 0 /* None */);
             }
             var asteriskToken = parseOptionalToken(41 /* AsteriskToken */);
             var tokenIsIdentifier = isIdentifier();
@@ -36888,9 +36905,15 @@ var ts;
             return !scanner.hasPrecedingLineBreak() && (isIdentifier() || token() === 10 /* StringLiteral */);
         }
         function parseFunctionBlockOrSemicolon(flags, diagnosticMessage) {
-            if (token() !== 18 /* OpenBraceToken */ && canParseSemicolon()) {
-                parseSemicolon();
-                return;
+            if (token() !== 18 /* OpenBraceToken */) {
+                if (flags & 4 /* Type */) {
+                    parseTypeMemberSemicolon();
+                    return;
+                }
+                if (canParseSemicolon()) {
+                    parseSemicolon();
+                    return;
+                }
             }
             return parseFunctionBlock(flags, diagnosticMessage);
         }
@@ -37094,12 +37117,12 @@ var ts;
             }
             return parsePropertyDeclaration(pos, hasJSDoc, decorators, modifiers, name, questionToken);
         }
-        function parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, kind) {
+        function parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, kind, flags) {
             var name = parsePropertyName();
             var typeParameters = parseTypeParameters();
             var parameters = parseParameters(0 /* None */);
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
-            var body = parseFunctionBlockOrSemicolon(0 /* None */);
+            var body = parseFunctionBlockOrSemicolon(flags);
             var node = kind === 172 /* GetAccessor */
                 ? factory.createGetAccessorDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), name, parameters, type, body)
                 : factory.createSetAccessorDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), name, parameters, body);
@@ -37286,10 +37309,10 @@ var ts;
                 return parseClassStaticBlockDeclaration(pos, hasJSDoc, decorators, modifiers);
             }
             if (parseContextualModifier(136 /* GetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 172 /* GetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 172 /* GetAccessor */, 0 /* None */);
             }
             if (parseContextualModifier(149 /* SetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 173 /* SetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 173 /* SetAccessor */, 0 /* None */);
             }
             if (token() === 134 /* ConstructorKeyword */ || token() === 10 /* StringLiteral */) {
                 var constructorDeclaration = tryParseConstructorDeclaration(pos, hasJSDoc, decorators, modifiers);
@@ -44600,6 +44623,7 @@ var ts;
         return toSearchResult(/*value*/ undefined);
     }
     /**
+     * @internal
      * From https://github.com/nodejs/node/blob/8f39f51cbbd3b2de14b9ee896e26421cc5b20121/lib/internal/modules/esm/resolve.js#L722 -
      * "longest" has some nuance as to what "longest" means in the presence of pattern trailers
      */
@@ -44622,6 +44646,7 @@ var ts;
             return 1;
         return 0;
     }
+    ts.comparePatternKeys = comparePatternKeys;
     function loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, moduleName, lookupTable, scope, isImports) {
         var loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports);
         if (!ts.endsWith(moduleName, ts.directorySeparator) && moduleName.indexOf("*") === -1 && ts.hasProperty(lookupTable, moduleName)) {
@@ -48693,7 +48718,7 @@ var ts;
         // Masks
         TypeFacts[TypeFacts["OrFactsMask"] = 8256] = "OrFactsMask";
         TypeFacts[TypeFacts["AndFactsMask"] = 134209471] = "AndFactsMask";
-    })(TypeFacts || (TypeFacts = {}));
+    })(TypeFacts = ts.TypeFacts || (ts.TypeFacts = {}));
     var typeofNEFacts = new ts.Map(ts.getEntries({
         string: 256 /* TypeofNEString */,
         number: 512 /* TypeofNENumber */,
@@ -48728,7 +48753,7 @@ var ts;
         CheckMode[CheckMode["RestBindingElement"] = 64] = "RestBindingElement";
         //   e.g. in `const { a, ...rest } = foo`, when checking the type of `foo` to determine the type of `rest`,
         //   we need to preserve generic types instead of substituting them for constraints
-    })(CheckMode || (CheckMode = {}));
+    })(CheckMode = ts.CheckMode || (ts.CheckMode = {}));
     var SignatureCheckMode;
     (function (SignatureCheckMode) {
         SignatureCheckMode[SignatureCheckMode["BivariantCallback"] = 1] = "BivariantCallback";
@@ -48736,7 +48761,7 @@ var ts;
         SignatureCheckMode[SignatureCheckMode["IgnoreReturnTypes"] = 4] = "IgnoreReturnTypes";
         SignatureCheckMode[SignatureCheckMode["StrictArity"] = 8] = "StrictArity";
         SignatureCheckMode[SignatureCheckMode["Callback"] = 3] = "Callback";
-    })(SignatureCheckMode || (SignatureCheckMode = {}));
+    })(SignatureCheckMode = ts.SignatureCheckMode || (ts.SignatureCheckMode = {}));
     var IntersectionState;
     (function (IntersectionState) {
         IntersectionState[IntersectionState["None"] = 0] = "None";
@@ -49088,7 +49113,7 @@ var ts;
             },
             getContextualTypeForObjectLiteralElement: function (nodeIn) {
                 var node = ts.getParseTreeNode(nodeIn, ts.isObjectLiteralElementLike);
-                return node ? getContextualTypeForObjectLiteralElement(node) : undefined;
+                return node ? getContextualTypeForObjectLiteralElement(node, /*contextFlags*/ undefined) : undefined;
             },
             getContextualTypeForArgumentAtIndex: function (nodeIn, argIndex) {
                 var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression);
@@ -49096,7 +49121,7 @@ var ts;
             },
             getContextualTypeForJsxAttribute: function (nodeIn) {
                 var node = ts.getParseTreeNode(nodeIn, ts.isJsxAttributeLike);
-                return node && getContextualTypeForJsxAttribute(node);
+                return node && getContextualTypeForJsxAttribute(node, /*contextFlags*/ undefined);
             },
             isContextSensitive: isContextSensitive,
             getTypeOfPropertyOfContextualType: getTypeOfPropertyOfContextualType,
@@ -49302,6 +49327,7 @@ var ts;
         var stringMappingTypes = new ts.Map();
         var substitutionTypes = new ts.Map();
         var subtypeReductionCache = new ts.Map();
+        var cachedTypes = new ts.Map();
         var evolvingArrayTypes = [];
         var undefinedProperties = new ts.Map();
         var markerTypes = new ts.Set();
@@ -49555,6 +49581,14 @@ var ts;
         ];
         initializeTypeChecker();
         return checker;
+        function getCachedType(key) {
+            return key ? cachedTypes.get(key) : undefined;
+        }
+        function setCachedType(key, type) {
+            if (key)
+                cachedTypes.set(key, type);
+            return type;
+        }
         function getJsxNamespace(location) {
             if (location) {
                 var file = ts.getSourceFileOfNode(location);
@@ -50419,6 +50453,7 @@ var ts;
                             if (ctor && ctor.locals) {
                                 if (lookup(ctor.locals, name, meaning & 111551 /* Value */)) {
                                     // Remember the property node, it will be used later to report appropriate error
+                                    ts.Debug.assertNode(location, ts.isPropertyDeclaration);
                                     propertyWithInvalidInitializer = location;
                                 }
                             }
@@ -50608,11 +50643,27 @@ var ts;
                     }
                 }
             }
+            // The invalid initializer error is needed in two situation:
+            // 1. When result is undefined, after checking for a missing "this."
+            // 2. When result is defined
+            function checkAndReportErrorForInvalidInitializer() {
+                if (propertyWithInvalidInitializer && !(ts.getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields)) {
+                    // We have a match, but the reference occurred within a property initializer and the identifier also binds
+                    // to a local variable in the constructor where the code will be emitted. Note that this is actually allowed
+                    // with ESNext+useDefineForClassFields because the scope semantics are different.
+                    error(errorLocation, errorLocation && propertyWithInvalidInitializer.type && ts.textRangeContainsPositionInclusive(propertyWithInvalidInitializer.type, errorLocation.pos)
+                        ? ts.Diagnostics.Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor
+                        : ts.Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, ts.declarationNameToString(propertyWithInvalidInitializer.name), diagnosticName(nameArg));
+                    return true;
+                }
+                return false;
+            }
             if (!result) {
                 if (nameNotFoundMessage) {
                     addLazyDiagnostic(function () {
                         if (!errorLocation ||
                             !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) && // TODO: GH#18217
+                                !checkAndReportErrorForInvalidInitializer() &&
                                 !checkAndReportErrorForExtendingInterface(errorLocation) &&
                                 !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) &&
                                 !checkAndReportErrorForExportingPrimitiveType(errorLocation, name) &&
@@ -50620,7 +50671,16 @@ var ts;
                                 !checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) &&
                                 !checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) {
                             var suggestion = void 0;
-                            if (getSpellingSuggestions && suggestionCount < maximumSuggestionCount) {
+                            var suggestedLib = void 0;
+                            // Report missing lib first
+                            if (nameArg) {
+                                suggestedLib = getSuggestedLibForNonExistentName(nameArg);
+                                if (suggestedLib) {
+                                    error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg), suggestedLib);
+                                }
+                            }
+                            // then spelling suggestions
+                            if (!suggestedLib && getSpellingSuggestions && suggestionCount < maximumSuggestionCount) {
                                 suggestion = getSuggestedSymbolForNonexistentSymbol(originalLocation, name, meaning);
                                 var isGlobalScopeAugmentationDeclaration = (suggestion === null || suggestion === void 0 ? void 0 : suggestion.valueDeclaration) && ts.isAmbientModule(suggestion.valueDeclaration) && ts.isGlobalScopeAugmentation(suggestion.valueDeclaration);
                                 if (isGlobalScopeAugmentationDeclaration) {
@@ -50639,16 +50699,9 @@ var ts;
                                     }
                                 }
                             }
-                            if (!suggestion) {
-                                if (nameArg) {
-                                    var lib = getSuggestedLibForNonExistentName(nameArg);
-                                    if (lib) {
-                                        error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg), lib);
-                                    }
-                                    else {
-                                        error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg));
-                                    }
-                                }
+                            // And then fall back to unspecified "not found"
+                            if (!suggestion && !suggestedLib && nameArg) {
+                                error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg));
                             }
                             suggestionCount++;
                         }
@@ -50656,12 +50709,7 @@ var ts;
                 }
                 return undefined;
             }
-            if (propertyWithInvalidInitializer && !(ts.getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields)) {
-                // We have a match, but the reference occurred within a property initializer and the identifier also binds
-                // to a local variable in the constructor where the code will be emitted. Note that this is actually allowed
-                // with ESNext+useDefineForClassFields because the scope semantics are different.
-                var propertyName = propertyWithInvalidInitializer.name;
-                error(errorLocation, ts.Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, ts.declarationNameToString(propertyName), diagnosticName(nameArg));
+            else if (checkAndReportErrorForInvalidInitializer()) {
                 return undefined;
             }
             // Perform extra checks only if error reporting was requested
@@ -52810,13 +52858,25 @@ var ts;
                         && isDeclarationVisible(declaration.parent)) {
                         return addVisibleAlias(declaration, declaration);
                     }
-                    else if (symbol.flags & 2097152 /* Alias */ && ts.isBindingElement(declaration) && ts.isInJSFile(declaration) && ((_a = declaration.parent) === null || _a === void 0 ? void 0 : _a.parent) // exported import-like top-level JS require statement
-                        && ts.isVariableDeclaration(declaration.parent.parent)
-                        && ((_b = declaration.parent.parent.parent) === null || _b === void 0 ? void 0 : _b.parent) && ts.isVariableStatement(declaration.parent.parent.parent.parent)
-                        && !ts.hasSyntacticModifier(declaration.parent.parent.parent.parent, 1 /* Export */)
-                        && declaration.parent.parent.parent.parent.parent // check if the thing containing the variable statement is visible (ie, the file)
-                        && isDeclarationVisible(declaration.parent.parent.parent.parent.parent)) {
-                        return addVisibleAlias(declaration, declaration.parent.parent.parent.parent);
+                    else if (ts.isBindingElement(declaration)) {
+                        if (symbol.flags & 2097152 /* Alias */ && ts.isInJSFile(declaration) && ((_a = declaration.parent) === null || _a === void 0 ? void 0 : _a.parent) // exported import-like top-level JS require statement
+                            && ts.isVariableDeclaration(declaration.parent.parent)
+                            && ((_b = declaration.parent.parent.parent) === null || _b === void 0 ? void 0 : _b.parent) && ts.isVariableStatement(declaration.parent.parent.parent.parent)
+                            && !ts.hasSyntacticModifier(declaration.parent.parent.parent.parent, 1 /* Export */)
+                            && declaration.parent.parent.parent.parent.parent // check if the thing containing the variable statement is visible (ie, the file)
+                            && isDeclarationVisible(declaration.parent.parent.parent.parent.parent)) {
+                            return addVisibleAlias(declaration, declaration.parent.parent.parent.parent);
+                        }
+                        else if (symbol.flags & 2 /* BlockScopedVariable */) {
+                            var variableStatement = ts.findAncestor(declaration, ts.isVariableStatement);
+                            if (ts.hasSyntacticModifier(variableStatement, 1 /* Export */)) {
+                                return true;
+                            }
+                            if (!isDeclarationVisible(variableStatement.parent)) {
+                                return false;
+                            }
+                            return addVisibleAlias(declaration, variableStatement);
+                        }
                     }
                     // Declaration is not visible
                     return false;
@@ -52949,7 +53009,7 @@ var ts;
         }
         function toNodeBuilderFlags(flags) {
             if (flags === void 0) { flags = 0 /* None */; }
-            return flags & 814775659 /* NodeBuilderFlagsMask */;
+            return flags & 848330091 /* NodeBuilderFlagsMask */;
         }
         function isClassInstanceSide(type) {
             return !!type.symbol && !!(type.symbol.flags & 32 /* Class */) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || (!!(type.flags & 524288 /* Object */) && !!(ts.getObjectFlags(type) & 16777216 /* IsClassInstanceClone */)));
@@ -53337,6 +53397,10 @@ var ts;
                     }
                     return typeToTypeNodeHelper(type, context);
                 }
+                function isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type) {
+                    return isMappedTypeWithKeyofConstraintDeclaration(type)
+                        && !(getModifiersTypeFromMappedType(type).flags & 262144 /* TypeParameter */);
+                }
                 function createMappedTypeNodeFromType(type) {
                     ts.Debug.assert(!!(type.flags & 524288 /* Object */));
                     var readonlyToken = type.declaration.readonlyToken ? ts.factory.createToken(type.declaration.readonlyToken.kind) : undefined;
@@ -53346,7 +53410,7 @@ var ts;
                     if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
                         // We have a { [P in keyof T]: X }
                         // We do this to ensure we retain the toplevel keyof-ness of the type which may be lost due to keyof distribution during `getConstraintTypeFromMappedType`
-                        if (!(getModifiersTypeFromMappedType(type).flags & 262144 /* TypeParameter */) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
+                        if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
                             var newParam = createTypeParameter(createSymbol(262144 /* TypeParameter */, "T"));
                             var name = typeParameterToName(newParam, context);
                             newTypeVariable = ts.factory.createTypeReferenceNode(name);
@@ -53362,11 +53426,12 @@ var ts;
                     var mappedTypeNode = ts.factory.createMappedTypeNode(readonlyToken, typeParameterNode, nameTypeNode, questionToken, templateTypeNode, /*members*/ undefined);
                     context.approximateLength += 10;
                     var result = ts.setEmitFlags(mappedTypeNode, 1 /* SingleLine */);
-                    if (isMappedTypeWithKeyofConstraintDeclaration(type) && !(getModifiersTypeFromMappedType(type).flags & 262144 /* TypeParameter */) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
+                    if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
                         // homomorphic mapped type with a non-homomorphic naive inlining
                         // wrap it with a conditional like `SomeModifiersType extends infer U ? {..the mapped type...} : never` to ensure the resulting
                         // type stays homomorphic
-                        return ts.factory.createConditionalTypeNode(typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context), ts.factory.createInferTypeNode(ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, ts.factory.cloneNode(newTypeVariable.typeName))), result, ts.factory.createKeywordTypeNode(143 /* NeverKeyword */));
+                        var originalConstraint = instantiateType(getConstraintOfTypeParameter(getTypeFromTypeNode(type.declaration.typeParameter.constraint.type)) || unknownType, type.mapper);
+                        return ts.factory.createConditionalTypeNode(typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context), ts.factory.createInferTypeNode(ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, ts.factory.cloneNode(newTypeVariable.typeName), originalConstraint.flags & 2 /* Unknown */ ? undefined : typeToTypeNodeHelper(originalConstraint, context))), result, ts.factory.createKeywordTypeNode(143 /* NeverKeyword */));
                     }
                     return result;
                 }
@@ -53928,7 +53993,7 @@ var ts;
                 var expandedParams = getExpandedParameters(signature, /*skipUnionExpanding*/ true)[0];
                 // If the expanded parameter list had a variadic in a non-trailing position, don't expand it
                 var parameters = (ts.some(expandedParams, function (p) { return p !== expandedParams[expandedParams.length - 1] && !!(ts.getCheckFlags(p) & 32768 /* RestParameter */); }) ? signature.parameters : expandedParams).map(function (parameter) { return symbolToParameterDeclaration(parameter, context, kind === 171 /* Constructor */, options === null || options === void 0 ? void 0 : options.privateSymbolVisitor, options === null || options === void 0 ? void 0 : options.bundledImports); });
-                var thisParameter = tryGetThisParameterDeclaration(signature, context);
+                var thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? undefined : tryGetThisParameterDeclaration(signature, context);
                 if (thisParameter) {
                     parameters.unshift(thisParameter);
                 }
@@ -54987,12 +55052,11 @@ var ts;
                     if (skipMembershipCheck || (!!ts.length(symbol.declarations) && ts.some(symbol.declarations, function (d) { return !!ts.findAncestor(d, function (n) { return n === enclosingDeclaration; }); }))) {
                         var oldContext = context;
                         context = cloneNodeBuilderContext(context);
-                        var result = serializeSymbolWorker(symbol, isPrivate, propertyAsAlias);
+                        serializeSymbolWorker(symbol, isPrivate, propertyAsAlias);
                         if (context.reportedDiagnostic) {
                             oldcontext.reportedDiagnostic = context.reportedDiagnostic; // hoist diagnostic result into outer context
                         }
                         context = oldContext;
-                        return result;
                     }
                 }
                 // Synthesize declarations for a symbol - might be an Interface, a Class, a Namespace, a Type, a Variable (const, let, or var), an Alias
@@ -58049,7 +58113,7 @@ var ts;
                         error(declaration.typeExpression.type, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
                     }
                     else {
-                        error(ts.isNamedDeclaration(declaration) ? declaration.name : declaration || declaration, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
+                        error(ts.isNamedDeclaration(declaration) ? declaration.name || declaration : declaration, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
                     }
                 }
                 links.declaredType = type;
@@ -62512,19 +62576,22 @@ var ts;
          * to reduce the resulting type if possible (since only intersections with conflicting literal-typed properties are reducible).
          */
         function isPossiblyReducibleByInstantiation(type) {
-            return ts.some(type.types, function (t) {
-                var uniqueFilled = getUniqueLiteralFilledInstantiation(t);
-                return getReducedType(uniqueFilled) !== uniqueFilled;
-            });
+            var uniqueFilled = getUniqueLiteralFilledInstantiation(type);
+            return getReducedType(uniqueFilled) !== uniqueFilled;
+        }
+        function shouldDeferIndexType(type) {
+            return !!(type.flags & 58982400 /* InstantiableNonPrimitive */ ||
+                isGenericTupleType(type) ||
+                isGenericMappedType(type) && !hasDistributiveNameType(type) ||
+                type.flags & 1048576 /* Union */ && ts.some(type.types, isPossiblyReducibleByInstantiation) ||
+                type.flags & 2097152 /* Intersection */ && maybeTypeOfKind(type, 465829888 /* Instantiable */) && ts.some(type.types, isEmptyAnonymousObjectType));
         }
         function getIndexType(type, stringsOnly, noIndexSignatures) {
             if (stringsOnly === void 0) { stringsOnly = keyofStringsOnly; }
             type = getReducedType(type);
-            return type.flags & 1048576 /* Union */ ? isPossiblyReducibleByInstantiation(type)
-                ? getIndexTypeForGenericType(type, stringsOnly)
-                : getIntersectionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
-                type.flags & 2097152 /* Intersection */ ? getUnionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
-                    type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && !hasDistributiveNameType(type) ? getIndexTypeForGenericType(type, stringsOnly) :
+            return shouldDeferIndexType(type) ? getIndexTypeForGenericType(type, stringsOnly) :
+                type.flags & 1048576 /* Union */ ? getIntersectionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
+                    type.flags & 2097152 /* Intersection */ ? getUnionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
                         ts.getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) :
                             type === wildcardType ? wildcardType :
                                 type.flags & 2 /* Unknown */ ? neverType :
@@ -66317,13 +66384,20 @@ var ts;
                 return result;
             }
             function structuredTypeRelatedTo(source, target, reportErrors, intersectionState) {
+                var saveErrorInfo = captureErrorCalculationState();
+                var result = structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState, saveErrorInfo);
+                if (result) {
+                    resetErrorInfo(saveErrorInfo);
+                }
+                return result;
+            }
+            function structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState, saveErrorInfo) {
                 if (intersectionState & 4 /* PropertyCheck */) {
                     return propertiesRelatedTo(source, target, reportErrors, /*excludedProperties*/ undefined, 0 /* None */);
                 }
                 var result;
                 var originalErrorInfo;
                 var varianceCheckFailed = false;
-                var saveErrorInfo = captureErrorCalculationState();
                 var sourceFlags = source.flags;
                 var targetFlags = target.flags;
                 if (relation === identityRelation) {
@@ -66387,7 +66461,6 @@ var ts;
                         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
                             if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
-                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -66512,7 +66585,6 @@ var ts;
                             result &= isRelatedTo(source.indexType, target.indexType, 3 /* Both */, reportErrors);
                         }
                         if (result) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                         if (reportErrors) {
@@ -66615,7 +66687,6 @@ var ts;
                     // If we reach 10 levels of nesting for the same conditional type, assume it is an infinitely expanding recursive
                     // conditional type and bail out with a Ternary.Maybe result.
                     if (isDeeplyNestedType(target, targetStack, targetDepth, 10)) {
-                        resetErrorInfo(saveErrorInfo);
                         return 3 /* Maybe */;
                     }
                     var c = target;
@@ -66630,7 +66701,6 @@ var ts;
                         if (result = skipTrue ? -1 /* True */ : isRelatedTo(source, getTrueTypeFromConditionalType(c), 2 /* Target */, /*reportErrors*/ false)) {
                             result &= skipFalse ? -1 /* True */ : isRelatedTo(source, getFalseTypeFromConditionalType(c), 2 /* Target */, /*reportErrors*/ false);
                             if (result) {
-                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -66662,12 +66732,10 @@ var ts;
                         var constraint = getConstraintOfType(source) || unknownType;
                         // hi-speed no-this-instantiation check (less accurate, but avoids costly `this`-instantiation when the constraint will suffice), see #28231 for report on why this is needed
                         if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                         // slower, fuller, this-instantiated check (necessary when comparing raw `this` types from base classes), see `subclassWithPolymorphicThisIsAssignable.ts` test for example
                         else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1 /* Source */, reportErrors && constraint !== unknownType && !(targetFlags & sourceFlags & 262144 /* TypeParameter */), /*headMessage*/ undefined, intersectionState)) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                         if (isMappedTypeGenericIndexedAccess(source)) {
@@ -66676,7 +66744,6 @@ var ts;
                             var indexConstraint = getConstraintOfType(source.indexType);
                             if (indexConstraint) {
                                 if (result = isRelatedTo(getIndexedAccessType(source.objectType, indexConstraint), target, 1 /* Source */, reportErrors)) {
-                                    resetErrorInfo(saveErrorInfo);
                                     return result;
                                 }
                             }
@@ -66685,7 +66752,6 @@ var ts;
                 }
                 else if (sourceFlags & 4194304 /* Index */) {
                     if (result = isRelatedTo(keyofConstraintType, target, 1 /* Source */, reportErrors)) {
-                        resetErrorInfo(saveErrorInfo);
                         return result;
                     }
                 }
@@ -66693,7 +66759,6 @@ var ts;
                     if (!(targetFlags & 134217728 /* TemplateLiteral */)) {
                         var constraint = getBaseConstraintOfType(source);
                         if (constraint && constraint !== source && (result = isRelatedTo(constraint, target, 1 /* Source */, reportErrors))) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
@@ -66704,14 +66769,12 @@ var ts;
                             return 0 /* False */;
                         }
                         if (result = isRelatedTo(source.type, target.type, 3 /* Both */, reportErrors)) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
                     else {
                         var constraint = getBaseConstraintOfType(source);
                         if (constraint && (result = isRelatedTo(constraint, target, 1 /* Source */, reportErrors))) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
@@ -66720,7 +66783,6 @@ var ts;
                     // If we reach 10 levels of nesting for the same conditional type, assume it is an infinitely expanding recursive
                     // conditional type and bail out with a Ternary.Maybe result.
                     if (isDeeplyNestedType(source, sourceStack, sourceDepth, 10)) {
-                        resetErrorInfo(saveErrorInfo);
                         return 3 /* Maybe */;
                     }
                     if (targetFlags & 16777216 /* Conditional */) {
@@ -66743,7 +66805,6 @@ var ts;
                                 result &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), 3 /* Both */, reportErrors);
                             }
                             if (result) {
-                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -66754,7 +66815,6 @@ var ts;
                         var distributiveConstraint = hasNonCircularBaseConstraint(source) ? getConstraintOfDistributiveConditionalType(source) : undefined;
                         if (distributiveConstraint) {
                             if (result = isRelatedTo(distributiveConstraint, target, 1 /* Source */, reportErrors)) {
-                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -66764,7 +66824,6 @@ var ts;
                     var defaultConstraint = getDefaultConstraintOfConditionalType(source);
                     if (defaultConstraint) {
                         if (result = isRelatedTo(defaultConstraint, target, 1 /* Source */, reportErrors)) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
@@ -66777,7 +66836,6 @@ var ts;
                     if (isGenericMappedType(target)) {
                         if (isGenericMappedType(source)) {
                             if (result = mappedTypeRelatedTo(source, target, reportErrors)) {
-                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -68232,9 +68290,14 @@ var ts;
                     type.flags & 256 /* NumberLiteral */ ? numberType :
                         type.flags & 2048 /* BigIntLiteral */ ? bigintType :
                             type.flags & 512 /* BooleanLiteral */ ? booleanType :
-                                type.flags & 1048576 /* Union */ ? mapType(type, getBaseTypeOfLiteralType) :
+                                type.flags & 1048576 /* Union */ ? getBaseTypeOfLiteralTypeUnion(type) :
                                     type;
         }
+        function getBaseTypeOfLiteralTypeUnion(type) {
+            var _a;
+            var key = "B" + getTypeId(type);
+            return (_a = getCachedType(key)) !== null && _a !== void 0 ? _a : setCachedType(key, mapType(type, getBaseTypeOfLiteralType));
+        }
         function getWidenedLiteralType(type) {
             return type.flags & 1024 /* EnumLiteral */ && isFreshLiteralType(type) ? getBaseTypeOfEnumLiteralType(type) :
                 type.flags & 128 /* StringLiteral */ && isFreshLiteralType(type) ? stringType :
@@ -70118,6 +70181,15 @@ var ts;
                         var key = getFlowCacheKey(node.expression, declaredType, initialType, flowContainer);
                         return key && key + "." + propName;
                     }
+                    break;
+                case 201 /* ObjectBindingPattern */:
+                case 202 /* ArrayBindingPattern */:
+                case 256 /* FunctionDeclaration */:
+                case 213 /* FunctionExpression */:
+                case 214 /* ArrowFunction */:
+                case 169 /* MethodDeclaration */:
+                    // Handle pseudo-references originating in getNarrowedTypeOfSymbol.
+                    return getNodeId(node) + "#" + getTypeId(declaredType);
             }
             return undefined;
         }
@@ -70377,23 +70449,25 @@ var ts;
         // For example, when a variable of type number | string | boolean is assigned a value of type number | boolean,
         // we remove type string.
         function getAssignmentReducedType(declaredType, assignedType) {
-            if (declaredType !== assignedType) {
-                if (assignedType.flags & 131072 /* Never */) {
-                    return assignedType;
-                }
-                var reducedType = filterType(declaredType, function (t) { return typeMaybeAssignableTo(assignedType, t); });
-                if (assignedType.flags & 512 /* BooleanLiteral */ && isFreshLiteralType(assignedType)) {
-                    reducedType = mapType(reducedType, getFreshTypeOfLiteralType); // Ensure that if the assignment is a fresh type, that we narrow to fresh types
-                }
-                // Our crude heuristic produces an invalid result in some cases: see GH#26130.
-                // For now, when that happens, we give up and don't narrow at all.  (This also
-                // means we'll never narrow for erroneous assignments where the assigned type
-                // is not assignable to the declared type.)
-                if (isTypeAssignableTo(assignedType, reducedType)) {
-                    return reducedType;
-                }
+            var _a;
+            if (declaredType === assignedType) {
+                return declaredType;
             }
-            return declaredType;
+            if (assignedType.flags & 131072 /* Never */) {
+                return assignedType;
+            }
+            var key = "A" + getTypeId(declaredType) + "," + getTypeId(assignedType);
+            return (_a = getCachedType(key)) !== null && _a !== void 0 ? _a : setCachedType(key, getAssignmentReducedTypeWorker(declaredType, assignedType));
+        }
+        function getAssignmentReducedTypeWorker(declaredType, assignedType) {
+            var filteredType = filterType(declaredType, function (t) { return typeMaybeAssignableTo(assignedType, t); });
+            // Ensure that we narrow to fresh types if the assignment is a fresh boolean literal type.
+            var reducedType = assignedType.flags & 512 /* BooleanLiteral */ && isFreshLiteralType(assignedType) ? mapType(filteredType, getFreshTypeOfLiteralType) : filteredType;
+            // Our crude heuristic produces an invalid result in some cases: see GH#26130.
+            // For now, when that happens, we give up and don't narrow at all.  (This also
+            // means we'll never narrow for erroneous assignments where the assigned type
+            // is not assignable to the declared type.)
+            return isTypeAssignableTo(assignedType, reducedType) ? reducedType : declaredType;
         }
         function isFunctionObjectType(type) {
             // We do a quick check for a "bind" property before performing the more expensive subtype
@@ -71799,7 +71873,7 @@ var ts;
                 var targetType = ts.hasStaticModifier(ts.Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration"))
                     ? getTypeOfSymbol(classSymbol)
                     : getDeclaredTypeOfSymbol(classSymbol);
-                return getNarrowedType(type, targetType, assumeTrue, isTypeDerivedFrom);
+                return getNarrowedType(type, targetType, assumeTrue, /*checkDerived*/ true);
             }
             function narrowTypeByOptionalChainContainment(type, operator, value, assumeTrue) {
                 // We are in a branch of obj?.foo === value (or any one of the other equality operators). We narrow obj as follows:
@@ -72050,9 +72124,15 @@ var ts;
                     if (!nonConstructorTypeInUnion)
                         return type;
                 }
-                return getNarrowedType(type, targetType, assumeTrue, isTypeDerivedFrom);
+                return getNarrowedType(type, targetType, assumeTrue, /*checkDerived*/ true);
+            }
+            function getNarrowedType(type, candidate, assumeTrue, checkDerived) {
+                var _a;
+                var key = type.flags & 1048576 /* Union */ ? "N" + getTypeId(type) + "," + getTypeId(candidate) + "," + ((assumeTrue ? 1 : 0) | (checkDerived ? 2 : 0)) : undefined;
+                return (_a = getCachedType(key)) !== null && _a !== void 0 ? _a : setCachedType(key, getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived));
             }
-            function getNarrowedType(type, candidate, assumeTrue, isRelated) {
+            function getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived) {
+                var isRelated = checkDerived ? isTypeDerivedFrom : isTypeSubtypeOf;
                 if (!assumeTrue) {
                     return filterType(type, function (t) { return !isRelated(t, candidate); });
                 }
@@ -72100,7 +72180,7 @@ var ts;
                     var predicateArgument = getTypePredicateArgument(predicate, callExpression);
                     if (predicateArgument) {
                         if (isMatchingReference(reference, predicateArgument)) {
-                            return getNarrowedType(type, predicate.type, assumeTrue, isTypeSubtypeOf);
+                            return getNarrowedType(type, predicate.type, assumeTrue, /*checkDerived*/ false);
                         }
                         if (strictNullChecks && assumeTrue && optionalChainContainsReference(predicateArgument, reference) &&
                             !(getTypeFacts(predicate.type) & 65536 /* EQUndefined */)) {
@@ -72108,7 +72188,7 @@ var ts;
                         }
                         var access = getDiscriminantPropertyAccess(predicateArgument, type);
                         if (access) {
-                            return narrowTypeByDiscriminant(type, access, function (t) { return getNarrowedType(t, predicate.type, assumeTrue, isTypeSubtypeOf); });
+                            return narrowTypeByDiscriminant(type, access, function (t) { return getNarrowedType(t, predicate.type, assumeTrue, /*checkDerived*/ false); });
                         }
                     }
                 }
@@ -72285,7 +72365,7 @@ var ts;
                 !((ts.isJsxOpeningElement(node.parent) || ts.isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) &&
                 (checkMode && checkMode & 64 /* RestBindingElement */ ?
                     getContextualType(node, 8 /* SkipBindingPatterns */)
-                    : getContextualType(node));
+                    : getContextualType(node, /*contextFlags*/ undefined));
             return contextualType && !isGenericType(contextualType);
         }
         function getNarrowableTypeForReference(type, reference, checkMode) {
@@ -72447,9 +72527,7 @@ var ts;
                 getNodeLinks(container).flags |= 8192 /* CaptureArguments */;
                 return getTypeOfSymbol(symbol);
             }
-            // We should only mark aliases as referenced if there isn't a local value declaration
-            // for the symbol. Also, don't mark any property access expression LHS - checkPropertyAccessExpression will handle that
-            if (!(node.parent && ts.isPropertyAccessExpression(node.parent) && node.parent.expression === node)) {
+            if (shouldMarkIdentifierAliasReferenced(node)) {
                 markAliasReferenced(symbol, node);
             }
             var localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol);
@@ -72583,6 +72661,25 @@ var ts;
             }
             return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType;
         }
+        function shouldMarkIdentifierAliasReferenced(node) {
+            var _a;
+            var parent = node.parent;
+            if (parent) {
+                // A property access expression LHS? checkPropertyAccessExpression will handle that.
+                if (ts.isPropertyAccessExpression(parent) && parent.expression === node) {
+                    return false;
+                }
+                // Next two check for an identifier inside a type only export.
+                if (ts.isExportSpecifier(parent) && parent.isTypeOnly) {
+                    return false;
+                }
+                var greatGrandparent = (_a = parent.parent) === null || _a === void 0 ? void 0 : _a.parent;
+                if (greatGrandparent && ts.isExportDeclaration(greatGrandparent) && greatGrandparent.isTypeOnly) {
+                    return false;
+                }
+            }
+            return true;
+        }
         function isInsideFunctionOrInstancePropertyInitializer(node, threshold) {
             return !!ts.findAncestor(node, function (n) { return n === threshold ? "quit" : ts.isFunctionLike(n) || (n.parent && ts.isPropertyDeclaration(n.parent) && !ts.hasStaticModifier(n.parent) && n.parent.initializer === n); });
         }
@@ -73132,7 +73229,7 @@ var ts;
                     // We have an object literal method. Check if the containing object literal has a contextual type
                     // that includes a ThisType<T>. If so, T is the contextual type for 'this'. We continue looking in
                     // any directly enclosing object literals.
-                    var contextualType = getApparentTypeOfContextualType(containingLiteral);
+                    var contextualType = getApparentTypeOfContextualType(containingLiteral, /*contextFlags*/ undefined);
                     var literal = containingLiteral;
                     var type = contextualType;
                     while (type) {
@@ -73144,7 +73241,7 @@ var ts;
                             break;
                         }
                         literal = literal.parent.parent;
-                        type = getApparentTypeOfContextualType(literal);
+                        type = getApparentTypeOfContextualType(literal, /*contextFlags*/ undefined);
                     }
                     // There was no contextual ThisType<T> for the containing object literal, so the contextual type
                     // for 'this' is the non-null form of the contextual type for the containing object literal or
@@ -73201,7 +73298,7 @@ var ts;
                     tryGetTypeAtPosition(contextualSignature, index);
             }
         }
-        function getContextualTypeForVariableLikeDeclaration(declaration) {
+        function getContextualTypeForVariableLikeDeclaration(declaration, contextFlags) {
             var typeNode = ts.getEffectiveTypeAnnotationNode(declaration);
             if (typeNode) {
                 return getTypeFromTypeNode(typeNode);
@@ -73210,18 +73307,18 @@ var ts;
                 case 164 /* Parameter */:
                     return getContextuallyTypedParameterType(declaration);
                 case 203 /* BindingElement */:
-                    return getContextualTypeForBindingElement(declaration);
+                    return getContextualTypeForBindingElement(declaration, contextFlags);
                 case 167 /* PropertyDeclaration */:
                     if (ts.isStatic(declaration)) {
-                        return getContextualTypeForStaticPropertyDeclaration(declaration);
+                        return getContextualTypeForStaticPropertyDeclaration(declaration, contextFlags);
                     }
                 // By default, do nothing and return undefined - only the above cases have context implied by a parent
             }
         }
-        function getContextualTypeForBindingElement(declaration) {
+        function getContextualTypeForBindingElement(declaration, contextFlags) {
             var parent = declaration.parent.parent;
             var name = declaration.propertyName || declaration.name;
-            var parentType = getContextualTypeForVariableLikeDeclaration(parent) ||
+            var parentType = getContextualTypeForVariableLikeDeclaration(parent, contextFlags) ||
                 parent.kind !== 203 /* BindingElement */ && parent.initializer && checkDeclarationInitializer(parent, declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */);
             if (!parentType || ts.isBindingPattern(name) || ts.isComputedNonLiteralName(name))
                 return undefined;
@@ -73237,8 +73334,8 @@ var ts;
                 return getTypeOfPropertyOfType(parentType, text);
             }
         }
-        function getContextualTypeForStaticPropertyDeclaration(declaration) {
-            var parentType = ts.isExpression(declaration.parent) && getContextualType(declaration.parent);
+        function getContextualTypeForStaticPropertyDeclaration(declaration, contextFlags) {
+            var parentType = ts.isExpression(declaration.parent) && getContextualType(declaration.parent, contextFlags);
             if (!parentType)
                 return undefined;
             return getTypeOfPropertyOfContextualType(parentType, getSymbolOfNode(declaration).escapedName);
@@ -73254,7 +73351,7 @@ var ts;
         function getContextualTypeForInitializerExpression(node, contextFlags) {
             var declaration = node.parent;
             if (ts.hasInitializer(declaration) && node === declaration.initializer) {
-                var result = getContextualTypeForVariableLikeDeclaration(declaration);
+                var result = getContextualTypeForVariableLikeDeclaration(declaration, contextFlags);
                 if (result) {
                     return result;
                 }
@@ -73264,10 +73361,10 @@ var ts;
             }
             return undefined;
         }
-        function getContextualTypeForReturnExpression(node) {
+        function getContextualTypeForReturnExpression(node, contextFlags) {
             var func = ts.getContainingFunction(node);
             if (func) {
-                var contextualReturnType = getContextualReturnType(func);
+                var contextualReturnType = getContextualReturnType(func, contextFlags);
                 if (contextualReturnType) {
                     var functionFlags = ts.getFunctionFlags(func);
                     if (functionFlags & 1 /* Generator */) { // Generator or AsyncGenerator function
@@ -73297,11 +73394,11 @@ var ts;
             }
             return undefined;
         }
-        function getContextualTypeForYieldOperand(node) {
+        function getContextualTypeForYieldOperand(node, contextFlags) {
             var func = ts.getContainingFunction(node);
             if (func) {
                 var functionFlags = ts.getFunctionFlags(func);
-                var contextualReturnType = getContextualReturnType(func);
+                var contextualReturnType = getContextualReturnType(func, contextFlags);
                 if (contextualReturnType) {
                     return node.asteriskToken
                         ? contextualReturnType
@@ -73325,14 +73422,14 @@ var ts;
         }
         function getContextualIterationType(kind, functionDecl) {
             var isAsync = !!(ts.getFunctionFlags(functionDecl) & 2 /* Async */);
-            var contextualReturnType = getContextualReturnType(functionDecl);
+            var contextualReturnType = getContextualReturnType(functionDecl, /*contextFlags*/ undefined);
             if (contextualReturnType) {
                 return getIterationTypeOfGeneratorFunctionReturnType(kind, contextualReturnType, isAsync)
                     || undefined;
             }
             return undefined;
         }
-        function getContextualReturnType(functionDecl) {
+        function getContextualReturnType(functionDecl, contextFlags) {
             // If the containing function has a return type annotation, is a constructor, or is a get accessor whose
             // corresponding set accessor has a type annotation, return statements in the function are contextually typed
             var returnType = getReturnTypeFromAnnotation(functionDecl);
@@ -73347,7 +73444,7 @@ var ts;
             }
             var iife = ts.getImmediatelyInvokedFunctionExpression(functionDecl);
             if (iife) {
-                return getContextualType(iife);
+                return getContextualType(iife, contextFlags);
             }
             return undefined;
         }
@@ -73600,7 +73697,7 @@ var ts;
         }
         function getContextualTypeForObjectLiteralElement(element, contextFlags) {
             var objectLiteral = element.parent;
-            var propertyAssignmentType = ts.isPropertyAssignment(element) && getContextualTypeForVariableLikeDeclaration(element);
+            var propertyAssignmentType = ts.isPropertyAssignment(element) && getContextualTypeForVariableLikeDeclaration(element, contextFlags);
             if (propertyAssignmentType) {
                 return propertyAssignmentType;
             }
@@ -73795,9 +73892,9 @@ var ts;
                     return getContextualTypeForInitializerExpression(node, contextFlags);
                 case 214 /* ArrowFunction */:
                 case 247 /* ReturnStatement */:
-                    return getContextualTypeForReturnExpression(node);
+                    return getContextualTypeForReturnExpression(node, contextFlags);
                 case 224 /* YieldExpression */:
-                    return getContextualTypeForYieldOperand(parent);
+                    return getContextualTypeForYieldOperand(parent, contextFlags);
                 case 218 /* AwaitExpression */:
                     return getContextualTypeForAwaitOperand(parent, contextFlags);
                 case 208 /* CallExpression */:
@@ -73845,7 +73942,7 @@ var ts;
             }
             return undefined;
             function tryFindWhenConstTypeReference(node) {
-                return getContextualType(node);
+                return getContextualType(node, contextFlags);
             }
         }
         function getInferenceContext(node) {
@@ -74147,7 +74244,7 @@ var ts;
             var elementCount = elements.length;
             var elementTypes = [];
             var elementFlags = [];
-            var contextualType = getApparentTypeOfContextualType(node);
+            var contextualType = getApparentTypeOfContextualType(node, /*contextFlags*/ undefined);
             var inDestructuringPattern = ts.isAssignmentTarget(node);
             var inConstContext = isConstContext(node);
             var hasOmittedExpression = false;
@@ -74318,7 +74415,7 @@ var ts;
             var propertiesTable = ts.createSymbolTable();
             var propertiesArray = [];
             var spread = emptyObjectType;
-            var contextualType = getApparentTypeOfContextualType(node);
+            var contextualType = getApparentTypeOfContextualType(node, /*contextFlags*/ undefined);
             var contextualTypeHasPattern = contextualType && contextualType.pattern &&
                 (contextualType.pattern.kind === 201 /* ObjectBindingPattern */ || contextualType.pattern.kind === 205 /* ObjectLiteralExpression */);
             var inConstContext = isConstContext(node);
@@ -74657,7 +74754,7 @@ var ts;
                     if (explicitlySpecifyChildrenAttribute) {
                         error(attributes, ts.Diagnostics._0_are_specified_twice_The_attribute_named_0_will_be_overwritten, ts.unescapeLeadingUnderscores(jsxChildrenPropertyName));
                     }
-                    var contextualType = getApparentTypeOfContextualType(openingLikeElement.attributes);
+                    var contextualType = getApparentTypeOfContextualType(openingLikeElement.attributes, /*contextFlags*/ undefined);
                     var childrenContextualType = contextualType && getTypeOfPropertyOfContextualType(contextualType, jsxChildrenPropertyName);
                     // If there are children in the body of JSX element, create dummy attribute "children" with the union of children types so that it will pass the attribute checking process
                     var childrenPropSymbol = createSymbol(4 /* Property */, jsxChildrenPropertyName);
@@ -77120,7 +77217,7 @@ var ts;
                         argCheckMode = checkMode & 32 /* IsForStringLiteralArgumentCompletions */;
                         if (inferenceContext) {
                             var typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
-                            checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, ts.isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
+                            checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, ts.isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
                             // If the original signature has a generic rest type, instantiation may produce a
                             // signature with different arity and we need to perform another arity check.
                             if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma)) {
@@ -78497,17 +78594,6 @@ var ts;
                     }
                 }
             }
-            var restType = getEffectiveRestType(context);
-            if (restType && restType.flags & 262144 /* TypeParameter */) {
-                // The contextual signature has a generic rest parameter. We first instantiate the contextual
-                // signature (without fixing type parameters) and assign types to contextually typed parameters.
-                var instantiatedContext = instantiateSignature(context, inferenceContext.nonFixingMapper);
-                assignContextualParameterTypes(signature, instantiatedContext);
-                // We then infer from a tuple type representing the parameters that correspond to the contextual
-                // rest parameter.
-                var restPos = getParameterCount(context) - 1;
-                inferTypes(inferenceContext.inferences, getRestTypeAtPosition(signature, restPos), restType);
-            }
         }
         function assignContextualParameterTypes(signature, context) {
             if (context.typeParameters) {
@@ -78700,7 +78786,7 @@ var ts;
                     var contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func);
                     var contextualType = !contextualSignature ? undefined :
                         contextualSignature === getSignatureFromDeclaration(func) ? isGenerator ? undefined : returnType :
-                            instantiateContextualType(getReturnTypeOfSignature(contextualSignature), func);
+                            instantiateContextualType(getReturnTypeOfSignature(contextualSignature), func, /*contextFlags*/ undefined);
                     if (isGenerator) {
                         yieldType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(yieldType, contextualType, 0 /* Yield */, isAsync);
                         returnType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(returnType, contextualType, 1 /* Return */, isAsync);
@@ -78771,7 +78857,7 @@ var ts;
                     nextType = iterationTypes && iterationTypes.nextType;
                 }
                 else {
-                    nextType = getContextualType(yieldExpression);
+                    nextType = getContextualType(yieldExpression, /*contextFlags*/ undefined);
                 }
                 if (nextType)
                     ts.pushIfUnique(nextTypes, nextType);
@@ -78980,11 +79066,16 @@ var ts;
                     if (isContextSensitive(node)) {
                         if (contextualSignature) {
                             var inferenceContext = getInferenceContext(node);
+                            var instantiatedContextualSignature = void 0;
                             if (checkMode && checkMode & 2 /* Inferential */) {
                                 inferFromAnnotatedParameters(signature, contextualSignature, inferenceContext);
+                                var restType = getEffectiveRestType(contextualSignature);
+                                if (restType && restType.flags & 262144 /* TypeParameter */) {
+                                    instantiatedContextualSignature = instantiateSignature(contextualSignature, inferenceContext.nonFixingMapper);
+                                }
                             }
-                            var instantiatedContextualSignature = inferenceContext ?
-                                instantiateSignature(contextualSignature, inferenceContext.mapper) : contextualSignature;
+                            instantiatedContextualSignature || (instantiatedContextualSignature = inferenceContext ?
+                                instantiateSignature(contextualSignature, inferenceContext.mapper) : contextualSignature);
                             assignContextualParameterTypes(signature, instantiatedContextualSignature);
                         }
                         else {
@@ -80226,7 +80317,7 @@ var ts;
                 type = anyType;
                 addLazyDiagnostic(function () {
                     if (noImplicitAny && !ts.expressionResultIsUnused(node)) {
-                        var contextualType = getContextualType(node);
+                        var contextualType = getContextualType(node, /*contextFlags*/ undefined);
                         if (!contextualType || isTypeAny(contextualType)) {
                             error(node, ts.Diagnostics.yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_type_annotation);
                         }
@@ -80267,7 +80358,7 @@ var ts;
                 texts.push(span.literal.text);
                 types.push(isTypeAssignableTo(type, templateConstraintType) ? type : stringType);
             }
-            return isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType(node) || unknownType, isTemplateLiteralContextualType) ? getTemplateLiteralType(texts, types) : stringType;
+            return isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType(node, /*contextFlags*/ undefined) || unknownType, isTemplateLiteralContextualType) ? getTemplateLiteralType(texts, types) : stringType;
         }
         function isTemplateLiteralContextualType(type) {
             return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) ||
@@ -80295,7 +80386,7 @@ var ts;
                 // We strip literal freshness when an appropriate contextual type is present such that contextually typed
                 // literals always preserve their literal types (otherwise they might widen during type inference). An alternative
                 // here would be to not mark contextually typed literals as fresh in the first place.
-                var result = maybeTypeOfKind(type, 2944 /* Literal */) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node)) ?
+                var result = maybeTypeOfKind(type, 2944 /* Literal */) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, /*contextFlags*/ undefined)) ?
                     getRegularTypeOfLiteralType(type) : type;
                 return result;
             }
@@ -80410,7 +80501,7 @@ var ts;
             var type = checkExpression(node, checkMode, forceTuple);
             return isConstContext(node) || ts.isCommonJsExportedExpression(node) ? getRegularTypeOfLiteralType(type) :
                 isTypeAssertion(node) ? type :
-                    getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType(node) : contextualType, node));
+                    getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType(node, /*contextFlags*/ undefined) : contextualType, node, /*contextFlags*/ undefined));
         }
         function checkPropertyAssignment(node, checkMode) {
             // Do not use hasDynamicName here, because that returns false for well known symbols.
@@ -86392,7 +86483,9 @@ var ts;
                     error(exportedName, ts.Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, ts.idText(exportedName));
                 }
                 else {
-                    markExportAsReferenced(node);
+                    if (!node.isTypeOnly && !node.parent.parent.isTypeOnly) {
+                        markExportAsReferenced(node);
+                    }
                     var target = symbol && (symbol.flags & 2097152 /* Alias */ ? resolveAlias(symbol) : symbol);
                     if (!target || target === unknownSymbol || target.flags & 111551 /* Value */) {
                         checkExpressionCached(node.propertyName || node.name);
@@ -89753,9 +89846,6 @@ var ts;
                 else {
                     return grammarErrorOnNode(initializer, ts.Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
                 }
-                if (!isConstOrReadonly || isInvalidInitializer) {
-                    return grammarErrorOnNode(initializer, ts.Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
-                }
             }
         }
         function checkGrammarVariableDeclaration(node) {
@@ -111540,7 +111630,7 @@ var ts;
                 return;
             }
             // Make sure not to write js file and source map file if any of them cannot be written
-            if ((jsFilePath && host.isEmitBlocked(jsFilePath)) || compilerOptions.noEmit) {
+            if (host.isEmitBlocked(jsFilePath) || compilerOptions.noEmit) {
                 emitSkipped = true;
                 return;
             }
@@ -124802,7 +124892,6 @@ var ts;
         var parsedConfigs; // Parsed commandline and watching cached for referenced projects
         var sharedExtendedConfigFileWatchers; // Map of file watchers for extended files, shared between different referenced projects
         var extendedConfigCache = host.extendedConfigCache; // Cache for extended config evaluation
-        var changesAffectResolution = false; // Flag for indicating non-config changes affect module resolution
         var reportFileChangeDetectedOnCreateProgram = false; // True if synchronizeProgram should report "File change detected..." when a new program is created
         var sourceFilesCache = new ts.Map(); // Cache that stores the source file and version info
         var missingFilePathsRequestedForRelease; // These paths are held temporarily so that we can remove the entry from source file cache if the file is not tracked by missing files
@@ -124955,12 +125044,12 @@ var ts;
             var program = getCurrentBuilderProgram();
             if (hasChangedCompilerOptions) {
                 newLine = updateNewLine();
-                if (program && (changesAffectResolution || ts.changesAffectModuleResolution(program.getCompilerOptions(), compilerOptions))) {
+                if (program && ts.changesAffectModuleResolution(program.getCompilerOptions(), compilerOptions)) {
                     resolutionCache.clear();
                 }
             }
             // All resolutions are invalid if user provided resolutions
-            var hasInvalidatedResolution = resolutionCache.createHasInvalidatedResolution(userProvidedResolution || changesAffectResolution);
+            var hasInvalidatedResolution = resolutionCache.createHasInvalidatedResolution(userProvidedResolution);
             if (ts.isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, getSourceVersion, fileExists, hasInvalidatedResolution, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
                 if (hasChangedConfigFileParsingErrors) {
                     if (reportFileChangeDetectedOnCreateProgram) {
@@ -124976,7 +125065,6 @@ var ts;
                 }
                 createNewProgram(hasInvalidatedResolution);
             }
-            changesAffectResolution = false; // reset for next sync
             reportFileChangeDetectedOnCreateProgram = false;
             if (host.afterProgramCreate && program !== builderProgram) {
                 host.afterProgramCreate(builderProgram);
@@ -126357,7 +126445,7 @@ var ts;
     }
     function afterProgramDone(state, program, config) {
         if (program) {
-            if (program && state.write)
+            if (state.write)
                 ts.listFiles(program, state.write);
             if (state.host.afterProgramEmitAndDiagnostics) {
                 state.host.afterProgramEmitAndDiagnostics(program);
@@ -132934,6 +133022,26 @@ var ts;
     (function (Completions) {
         var StringCompletions;
         (function (StringCompletions) {
+            var _a;
+            var kindPrecedence = (_a = {},
+                _a["directory" /* directory */] = 0,
+                _a["script" /* scriptElement */] = 1,
+                _a["external module name" /* externalModuleName */] = 2,
+                _a);
+            function createNameAndKindSet() {
+                var map = new ts.Map();
+                function add(value) {
+                    var existing = map.get(value.name);
+                    if (!existing || kindPrecedence[existing.kind] < kindPrecedence[value.kind]) {
+                        map.set(value.name, value);
+                    }
+                }
+                return {
+                    add: add,
+                    has: map.has.bind(map),
+                    values: map.values.bind(map),
+                };
+            }
             function getStringLiteralCompletions(sourceFile, position, contextToken, options, host, program, log, preferences) {
                 if (ts.isInReferenceComment(sourceFile, position)) {
                     var entries = getTripleSlashReferenceCompletion(sourceFile, position, options, host);
@@ -133215,11 +133323,12 @@ var ts;
             }
             function getStringLiteralCompletionsFromModuleNamesWorker(sourceFile, node, compilerOptions, host, typeChecker, preferences) {
                 var literalValue = ts.normalizeSlashes(node.text);
+                var mode = ts.isStringLiteralLike(node) ? ts.getModeForUsageLocation(sourceFile, node) : undefined;
                 var scriptPath = sourceFile.path;
                 var scriptDirectory = ts.getDirectoryPath(scriptPath);
                 return isPathRelativeToScript(literalValue) || !compilerOptions.baseUrl && (ts.isRootedDiskPath(literalValue) || ts.isUrl(literalValue))
                     ? getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, compilerOptions, host, scriptPath, getIncludeExtensionOption())
-                    : getCompletionEntriesForNonRelativeModules(literalValue, scriptDirectory, compilerOptions, host, typeChecker);
+                    : getCompletionEntriesForNonRelativeModules(literalValue, scriptDirectory, mode, compilerOptions, host, getIncludeExtensionOption(), typeChecker);
                 function getIncludeExtensionOption() {
                     var mode = ts.isStringLiteralLike(node) ? ts.getModeForUsageLocation(sourceFile, node) : undefined;
                     return preferences.importModuleSpecifierEnding === "js" || mode === ts.ModuleKind.ESNext ? 2 /* ModuleSpecifierCompletion */ : 0 /* Exclude */;
@@ -133235,7 +133344,7 @@ var ts;
                     return getCompletionEntriesForDirectoryFragmentWithRootDirs(compilerOptions.rootDirs, literalValue, scriptDirectory, extensionOptions, compilerOptions, host, scriptPath);
                 }
                 else {
-                    return getCompletionEntriesForDirectoryFragment(literalValue, scriptDirectory, extensionOptions, host, scriptPath);
+                    return ts.arrayFrom(getCompletionEntriesForDirectoryFragment(literalValue, scriptDirectory, extensionOptions, host, scriptPath).values());
                 }
             }
             function isEmitResolutionKindUsingNodeModules(compilerOptions) {
@@ -133271,7 +133380,7 @@ var ts;
                 var basePath = compilerOptions.project || host.getCurrentDirectory();
                 var ignoreCase = !(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames());
                 var baseDirectories = getBaseDirectoriesFromRootDirs(rootDirs, basePath, scriptDirectory, ignoreCase);
-                return ts.flatMap(baseDirectories, function (baseDirectory) { return getCompletionEntriesForDirectoryFragment(fragment, baseDirectory, extensionOptions, host, exclude); });
+                return ts.flatMap(baseDirectories, function (baseDirectory) { return ts.arrayFrom(getCompletionEntriesForDirectoryFragment(fragment, baseDirectory, extensionOptions, host, exclude).values()); });
             }
             var IncludeExtensionsOption;
             (function (IncludeExtensionsOption) {
@@ -133282,10 +133391,9 @@ var ts;
             /**
              * Given a path ending at a directory, gets the completions for the path, and filters for those entries containing the basename.
              */
-            function getCompletionEntriesForDirectoryFragment(fragment, scriptPath, _a, host, exclude, result) {
-                var _b;
-                var extensions = _a.extensions, includeExtensionsOption = _a.includeExtensionsOption;
-                if (result === void 0) { result = []; }
+            function getCompletionEntriesForDirectoryFragment(fragment, scriptPath, extensionOptions, host, exclude, result) {
+                var _a;
+                if (result === void 0) { result = createNameAndKindSet(); }
                 if (fragment === undefined) {
                     fragment = "";
                 }
@@ -133309,11 +133417,11 @@ var ts;
                     var packageJson = ts.readJson(packageJsonPath, host);
                     var typesVersions = packageJson.typesVersions;
                     if (typeof typesVersions === "object") {
-                        var versionPaths = (_b = ts.getPackageJsonTypesVersionsPaths(typesVersions)) === null || _b === void 0 ? void 0 : _b.paths;
+                        var versionPaths = (_a = ts.getPackageJsonTypesVersionsPaths(typesVersions)) === null || _a === void 0 ? void 0 : _a.paths;
                         if (versionPaths) {
                             var packageDirectory = ts.getDirectoryPath(packageJsonPath);
                             var pathInPackage = absolutePath.slice(ts.ensureTrailingDirectorySeparator(packageDirectory).length);
-                            if (addCompletionEntriesFromPaths(result, pathInPackage, packageDirectory, extensions, versionPaths, host)) {
+                            if (addCompletionEntriesFromPaths(result, pathInPackage, packageDirectory, extensionOptions, host, versionPaths)) {
                                 // A true result means one of the `versionPaths` was matched, which will block relative resolution
                                 // to files and folders from here. All reachable paths given the pattern match are already added.
                                 return result;
@@ -133325,39 +133433,17 @@ var ts;
                 if (!ts.tryDirectoryExists(host, baseDirectory))
                     return result;
                 // Enumerate the available files if possible
-                var files = ts.tryReadDirectory(host, baseDirectory, extensions, /*exclude*/ undefined, /*include*/ ["./*"]);
+                var files = ts.tryReadDirectory(host, baseDirectory, extensionOptions.extensions, /*exclude*/ undefined, /*include*/ ["./*"]);
                 if (files) {
-                    /**
-                     * Multiple file entries might map to the same truncated name once we remove extensions
-                     * (happens iff includeExtensionsOption === includeExtensionsOption.Exclude) so we use a set-like data structure. Eg:
-                     *
-                     * both foo.ts and foo.tsx become foo
-                     */
-                    var foundFiles = new ts.Map(); // maps file to its extension
                     for (var _i = 0, files_1 = files; _i < files_1.length; _i++) {
                         var filePath = files_1[_i];
                         filePath = ts.normalizePath(filePath);
                         if (exclude && ts.comparePaths(filePath, exclude, scriptPath, ignoreCase) === 0 /* EqualTo */) {
                             continue;
                         }
-                        var foundFileName = void 0;
-                        var outputExtension = ts.moduleSpecifiers.tryGetJSExtensionForFile(filePath, host.getCompilationSettings());
-                        if (includeExtensionsOption === 0 /* Exclude */ && !ts.fileExtensionIsOneOf(filePath, [".json" /* Json */, ".mts" /* Mts */, ".cts" /* Cts */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */, ".mjs" /* Mjs */, ".cjs" /* Cjs */])) {
-                            foundFileName = ts.removeFileExtension(ts.getBaseFileName(filePath));
-                            foundFiles.set(foundFileName, ts.tryGetExtensionFromPath(filePath));
-                        }
-                        else if ((ts.fileExtensionIsOneOf(filePath, [".mts" /* Mts */, ".cts" /* Cts */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */, ".mjs" /* Mjs */, ".cjs" /* Cjs */]) || includeExtensionsOption === 2 /* ModuleSpecifierCompletion */) && outputExtension) {
-                            foundFileName = ts.changeExtension(ts.getBaseFileName(filePath), outputExtension);
-                            foundFiles.set(foundFileName, outputExtension);
-                        }
-                        else {
-                            foundFileName = ts.getBaseFileName(filePath);
-                            foundFiles.set(foundFileName, ts.tryGetExtensionFromPath(filePath));
-                        }
+                        var _b = getFilenameWithExtensionOption(ts.getBaseFileName(filePath), host.getCompilationSettings(), extensionOptions.includeExtensionsOption), name = _b.name, extension = _b.extension;
+                        result.add(nameAndKind(name, "script" /* scriptElement */, extension));
                     }
-                    foundFiles.forEach(function (ext, foundFile) {
-                        result.push(nameAndKind(foundFile, "script" /* scriptElement */, ext));
-                    });
                 }
                 // If possible, get folder completion as well
                 var directories = ts.tryGetDirectories(host, baseDirectory);
@@ -133366,27 +133452,52 @@ var ts;
                         var directory = directories_1[_c];
                         var directoryName = ts.getBaseFileName(ts.normalizePath(directory));
                         if (directoryName !== "@types") {
-                            result.push(directoryResult(directoryName));
+                            result.add(directoryResult(directoryName));
                         }
                     }
                 }
                 return result;
             }
+            function getFilenameWithExtensionOption(name, compilerOptions, includeExtensionsOption) {
+                var outputExtension = ts.moduleSpecifiers.tryGetJSExtensionForFile(name, compilerOptions);
+                if (includeExtensionsOption === 0 /* Exclude */ && !ts.fileExtensionIsOneOf(name, [".json" /* Json */, ".mts" /* Mts */, ".cts" /* Cts */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */, ".mjs" /* Mjs */, ".cjs" /* Cjs */])) {
+                    return { name: ts.removeFileExtension(name), extension: ts.tryGetExtensionFromPath(name) };
+                }
+                else if ((ts.fileExtensionIsOneOf(name, [".mts" /* Mts */, ".cts" /* Cts */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */, ".mjs" /* Mjs */, ".cjs" /* Cjs */]) || includeExtensionsOption === 2 /* ModuleSpecifierCompletion */) && outputExtension) {
+                    return { name: ts.changeExtension(name, outputExtension), extension: outputExtension };
+                }
+                else {
+                    return { name: name, extension: ts.tryGetExtensionFromPath(name) };
+                }
+            }
             /** @returns whether `fragment` was a match for any `paths` (which should indicate whether any other path completions should be offered) */
-            function addCompletionEntriesFromPaths(result, fragment, baseDirectory, fileExtensions, paths, host) {
-                var _a;
+            function addCompletionEntriesFromPaths(result, fragment, baseDirectory, extensionOptions, host, paths) {
+                var getPatternsForKey = function (key) { return paths[key]; };
+                var comparePaths = function (a, b) {
+                    var patternA = ts.tryParsePattern(a);
+                    var patternB = ts.tryParsePattern(b);
+                    var lengthA = typeof patternA === "object" ? patternA.prefix.length : a.length;
+                    var lengthB = typeof patternB === "object" ? patternB.prefix.length : b.length;
+                    return ts.compareValues(lengthB, lengthA);
+                };
+                return addCompletionEntriesFromPathsOrExports(result, fragment, baseDirectory, extensionOptions, host, ts.getOwnKeys(paths), getPatternsForKey, comparePaths);
+            }
+            /** @returns whether `fragment` was a match for any `paths` (which should indicate whether any other path completions should be offered) */
+            function addCompletionEntriesFromPathsOrExports(result, fragment, baseDirectory, extensionOptions, host, keys, getPatternsForKey, comparePaths) {
                 var pathResults = [];
-                var matchedPathPrefixLength = -1;
-                for (var path in paths) {
-                    if (!ts.hasProperty(paths, path))
+                var matchedPath;
+                for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+                    var key = keys_1[_i];
+                    if (key === ".")
                         continue;
-                    var patterns = paths[path];
+                    var keyWithoutLeadingDotSlash = key.replace(/^\.\//, ""); // remove leading "./"
+                    var patterns = getPatternsForKey(key);
                     if (patterns) {
-                        var pathPattern = ts.tryParsePattern(path);
+                        var pathPattern = ts.tryParsePattern(keyWithoutLeadingDotSlash);
                         if (!pathPattern)
                             continue;
                         var isMatch = typeof pathPattern === "object" && ts.isPatternMatch(pathPattern, fragment);
-                        var isLongestMatch = isMatch && (matchedPathPrefixLength === undefined || pathPattern.prefix.length > matchedPathPrefixLength);
+                        var isLongestMatch = isMatch && (matchedPath === undefined || comparePaths(key, matchedPath) === -1 /* LessThan */);
                         if (isLongestMatch) {
                             // If this is a higher priority match than anything we've seen so far, previous results from matches are invalid, e.g.
                             // for `import {} from "some-package/|"` with a typesVersions:
@@ -133399,13 +133510,13 @@ var ts;
                             //                                 added by the '*' match, after typing `"some-package/foo/|"` we would get file results from both
                             //                                 ./dist/foo and ./foo, when only the latter will actually be resolvable.
                             //                                 See pathCompletionsTypesVersionsWildcard6.ts.
-                            matchedPathPrefixLength = pathPattern.prefix.length;
+                            matchedPath = key;
                             pathResults = pathResults.filter(function (r) { return !r.matchedPattern; });
                         }
-                        if (typeof pathPattern === "string" || matchedPathPrefixLength === undefined || pathPattern.prefix.length >= matchedPathPrefixLength) {
+                        if (typeof pathPattern === "string" || matchedPath === undefined || comparePaths(key, matchedPath) !== 1 /* GreaterThan */) {
                             pathResults.push({
                                 matchedPattern: isMatch,
-                                results: getCompletionsForPathMapping(path, patterns, fragment, baseDirectory, fileExtensions, host)
+                                results: getCompletionsForPathMapping(keyWithoutLeadingDotSlash, patterns, fragment, baseDirectory, extensionOptions, host)
                                     .map(function (_a) {
                                     var name = _a.name, kind = _a.kind, extension = _a.extension;
                                     return nameAndKind(name, kind, extension);
@@ -133414,10 +133525,8 @@ var ts;
                         }
                     }
                 }
-                var equatePaths = ((_a = host.useCaseSensitiveFileNames) === null || _a === void 0 ? void 0 : _a.call(host)) ? ts.equateStringsCaseSensitive : ts.equateStringsCaseInsensitive;
-                var equateResults = function (a, b) { return equatePaths(a.name, b.name); };
-                pathResults.forEach(function (pathResult) { return pathResult.results.forEach(function (pathResult) { return ts.pushIfUnique(result, pathResult, equateResults); }); });
-                return matchedPathPrefixLength > -1;
+                pathResults.forEach(function (pathResult) { return pathResult.results.forEach(function (r) { return result.add(r); }); });
+                return matchedPath !== undefined;
             }
             /**
              * Check all of the declared modules and those in node modules. Possible sources of modules:
@@ -133426,22 +133535,22 @@ var ts;
              *      Modules from node_modules (i.e. those listed in package.json)
              *          This includes all files that are found in node_modules/moduleName/ with acceptable file extensions
              */
-            function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, compilerOptions, host, typeChecker) {
+            function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, compilerOptions, host, includeExtensionsOption, typeChecker) {
                 var baseUrl = compilerOptions.baseUrl, paths = compilerOptions.paths;
-                var result = [];
-                var extensionOptions = getExtensionOptions(compilerOptions);
+                var result = createNameAndKindSet();
+                var extensionOptions = getExtensionOptions(compilerOptions, includeExtensionsOption);
                 if (baseUrl) {
                     var projectDir = compilerOptions.project || host.getCurrentDirectory();
                     var absolute = ts.normalizePath(ts.combinePaths(projectDir, baseUrl));
                     getCompletionEntriesForDirectoryFragment(fragment, absolute, extensionOptions, host, /*exclude*/ undefined, result);
                     if (paths) {
-                        addCompletionEntriesFromPaths(result, fragment, absolute, extensionOptions.extensions, paths, host);
+                        addCompletionEntriesFromPaths(result, fragment, absolute, extensionOptions, host, paths);
                     }
                 }
                 var fragmentDirectory = getFragmentDirectory(fragment);
                 for (var _i = 0, _a = getAmbientModuleCompletions(fragment, fragmentDirectory, typeChecker); _i < _a.length; _i++) {
                     var ambientName = _a[_i];
-                    result.push(nameAndKind(ambientName, "external module name" /* externalModuleName */, /*extension*/ undefined));
+                    result.add(nameAndKind(ambientName, "external module name" /* externalModuleName */, /*extension*/ undefined));
                 }
                 getCompletionEntriesFromTypings(host, compilerOptions, scriptPath, fragmentDirectory, extensionOptions, result);
                 if (isEmitResolutionKindUsingNodeModules(compilerOptions)) {
@@ -133449,15 +133558,13 @@ var ts;
                     // (But do if we didn't find anything, e.g. 'package.json' missing.)
                     var foundGlobal = false;
                     if (fragmentDirectory === undefined) {
-                        var _loop_3 = function (moduleName) {
-                            if (!result.some(function (entry) { return entry.name === moduleName; })) {
-                                foundGlobal = true;
-                                result.push(nameAndKind(moduleName, "external module name" /* externalModuleName */, /*extension*/ undefined));
-                            }
-                        };
                         for (var _b = 0, _c = enumerateNodeModulesVisibleToScript(host, scriptPath); _b < _c.length; _b++) {
                             var moduleName = _c[_b];
-                            _loop_3(moduleName);
+                            var moduleResult = nameAndKind(moduleName, "external module name" /* externalModuleName */, /*extension*/ undefined);
+                            if (!result.has(moduleResult.name)) {
+                                foundGlobal = true;
+                                result.add(moduleResult);
+                            }
                         }
                     }
                     if (!foundGlobal) {
@@ -133483,39 +133590,19 @@ var ts;
                                     }
                                     packagePath = ts.combinePaths(packagePath, subName);
                                 }
-                                var packageFile = ts.combinePaths(ancestor, "node_modules", packagePath, "package.json");
+                                var packageDirectory = ts.combinePaths(ancestor, "node_modules", packagePath);
+                                var packageFile = ts.combinePaths(packageDirectory, "package.json");
                                 if (ts.tryFileExists(host, packageFile)) {
                                     var packageJson = ts.readJson(packageFile, host);
-                                    var exports = packageJson.exports;
-                                    if (exports) {
-                                        if (typeof exports !== "object" || exports === null) { // eslint-disable-line no-null/no-null
+                                    var exports_1 = packageJson.exports;
+                                    if (exports_1) {
+                                        if (typeof exports_1 !== "object" || exports_1 === null) { // eslint-disable-line no-null/no-null
                                             return; // null exports or entrypoint only, no sub-modules available
                                         }
-                                        var keys = ts.getOwnKeys(exports);
-                                        var fragmentSubpath_1 = components.join("/");
-                                        var processedKeys = ts.mapDefined(keys, function (k) {
-                                            if (k === ".")
-                                                return undefined;
-                                            if (!ts.startsWith(k, "./"))
-                                                return undefined;
-                                            var subpath = k.substring(2);
-                                            if (!ts.startsWith(subpath, fragmentSubpath_1))
-                                                return undefined;
-                                            // subpath is a valid export (barring conditions, which we don't currently check here)
-                                            if (!ts.stringContains(subpath, "*")) {
-                                                return subpath;
-                                            }
-                                            // pattern export - only return everything up to the `*`, so the user can autocomplete, then
-                                            // keep filling in the pattern (we could speculatively return a list of options by hitting disk,
-                                            // but conditions will make that somewhat awkward, as each condition may have a different set of possible
-                                            // options for the `*`.
-                                            return subpath.slice(0, subpath.indexOf("*"));
-                                        });
-                                        ts.forEach(processedKeys, function (k) {
-                                            if (k) {
-                                                result.push(nameAndKind(k, "external module name" /* externalModuleName */, /*extension*/ undefined));
-                                            }
-                                        });
+                                        var keys = ts.getOwnKeys(exports_1);
+                                        var fragmentSubpath = components.join("/") + (components.length && ts.hasTrailingDirectorySeparator(fragment) ? "/" : "");
+                                        var conditions_1 = mode === ts.ModuleKind.ESNext ? ["node", "import", "types"] : ["node", "require", "types"];
+                                        addCompletionEntriesFromPathsOrExports(result, fragmentSubpath, packageDirectory, extensionOptions, host, keys, function (key) { return ts.singleElementArray(getPatternFromFirstMatchingCondition(exports_1[key], conditions_1)); }, ts.comparePatternKeys);
                                         return;
                                     }
                                 }
@@ -133525,31 +133612,44 @@ var ts;
                         ts.forEachAncestorDirectory(scriptPath, ancestorLookup);
                     }
                 }
-                return result;
+                return ts.arrayFrom(result.values());
+            }
+            function getPatternFromFirstMatchingCondition(target, conditions) {
+                if (typeof target === "string") {
+                    return target;
+                }
+                if (target && typeof target === "object" && !ts.isArray(target)) {
+                    for (var condition in target) {
+                        if (condition === "default" || conditions.indexOf(condition) > -1 || ts.isApplicableVersionedTypesKey(conditions, condition)) {
+                            var pattern = target[condition];
+                            return getPatternFromFirstMatchingCondition(pattern, conditions);
+                        }
+                    }
+                }
             }
             function getFragmentDirectory(fragment) {
                 return containsSlash(fragment) ? ts.hasTrailingDirectorySeparator(fragment) ? fragment : ts.getDirectoryPath(fragment) : undefined;
             }
-            function getCompletionsForPathMapping(path, patterns, fragment, baseUrl, fileExtensions, host) {
+            function getCompletionsForPathMapping(path, patterns, fragment, packageDirectory, extensionOptions, host) {
                 if (!ts.endsWith(path, "*")) {
                     // For a path mapping "foo": ["/x/y/z.ts"], add "foo" itself as a completion.
-                    return !ts.stringContains(path, "*") ? justPathMappingName(path) : ts.emptyArray;
+                    return !ts.stringContains(path, "*") ? justPathMappingName(path, "script" /* scriptElement */) : ts.emptyArray;
                 }
                 var pathPrefix = path.slice(0, path.length - 1);
                 var remainingFragment = ts.tryRemovePrefix(fragment, pathPrefix);
                 if (remainingFragment === undefined) {
                     var starIsFullPathComponent = path[path.length - 2] === "/";
-                    return starIsFullPathComponent ? justPathMappingName(pathPrefix) : ts.flatMap(patterns, function (pattern) { var _a; return (_a = getModulesForPathsPattern("", baseUrl, pattern, fileExtensions, host)) === null || _a === void 0 ? void 0 : _a.map(function (_a) {
+                    return starIsFullPathComponent ? justPathMappingName(pathPrefix, "directory" /* directory */) : ts.flatMap(patterns, function (pattern) { var _a; return (_a = getModulesForPathsPattern("", packageDirectory, pattern, extensionOptions, host)) === null || _a === void 0 ? void 0 : _a.map(function (_a) {
                         var name = _a.name, rest = __rest(_a, ["name"]);
                         return (__assign({ name: pathPrefix + name }, rest));
                     }); });
                 }
-                return ts.flatMap(patterns, function (pattern) { return getModulesForPathsPattern(remainingFragment, baseUrl, pattern, fileExtensions, host); });
-                function justPathMappingName(name) {
-                    return ts.startsWith(name, fragment) ? [directoryResult(ts.removeTrailingDirectorySeparator(name))] : ts.emptyArray;
+                return ts.flatMap(patterns, function (pattern) { return getModulesForPathsPattern(remainingFragment, packageDirectory, pattern, extensionOptions, host); });
+                function justPathMappingName(name, kind) {
+                    return ts.startsWith(name, fragment) ? [{ name: ts.removeTrailingDirectorySeparator(name), kind: kind, extension: undefined }] : ts.emptyArray;
                 }
             }
-            function getModulesForPathsPattern(fragment, baseUrl, pattern, fileExtensions, host) {
+            function getModulesForPathsPattern(fragment, packageDirectory, pattern, extensionOptions, host) {
                 if (!host.readDirectory) {
                     return undefined;
                 }
@@ -133568,21 +133668,33 @@ var ts;
                 var expandedPrefixDirectory = fragmentHasPath ? ts.combinePaths(normalizedPrefixDirectory, normalizedPrefixBase + fragmentDirectory) : normalizedPrefixDirectory;
                 var normalizedSuffix = ts.normalizePath(parsed.suffix);
                 // Need to normalize after combining: If we combinePaths("a", "../b"), we want "b" and not "a/../b".
-                var baseDirectory = ts.normalizePath(ts.combinePaths(baseUrl, expandedPrefixDirectory));
+                var baseDirectory = ts.normalizePath(ts.combinePaths(packageDirectory, expandedPrefixDirectory));
                 var completePrefix = fragmentHasPath ? baseDirectory : ts.ensureTrailingDirectorySeparator(baseDirectory) + normalizedPrefixBase;
-                // If we have a suffix, then we need to read the directory all the way down. We could create a glob
-                // that encodes the suffix, but we would have to escape the character "?" which readDirectory
-                // doesn't support. For now, this is safer but slower
-                var includeGlob = normalizedSuffix ? "**/*" : "./*";
-                var matches = ts.mapDefined(ts.tryReadDirectory(host, baseDirectory, fileExtensions, /*exclude*/ undefined, [includeGlob]), function (match) {
-                    var extension = ts.tryGetExtensionFromPath(match);
-                    var name = trimPrefixAndSuffix(match);
-                    return name === undefined ? undefined : nameAndKind(ts.removeFileExtension(name), "script" /* scriptElement */, extension);
-                });
-                var directories = ts.mapDefined(ts.tryGetDirectories(host, baseDirectory).map(function (d) { return ts.combinePaths(baseDirectory, d); }), function (dir) {
-                    var name = trimPrefixAndSuffix(dir);
-                    return name === undefined ? undefined : directoryResult(name);
+                // If we have a suffix, then we read the directory all the way down to avoid returning completions for
+                // directories that don't contain files that would match the suffix. A previous comment here was concerned
+                // about the case where `normalizedSuffix` includes a `?` character, which should be interpreted literally,
+                // but will match any single character as part of the `include` pattern in `tryReadDirectory`. This is not
+                // a problem, because (in the extremely unusual circumstance where the suffix has a `?` in it) a `?`
+                // interpreted as "any character" can only return *too many* results as compared to the literal
+                // interpretation, so we can filter those superfluous results out via `trimPrefixAndSuffix` as we've always
+                // done.
+                var includeGlob = normalizedSuffix ? "**/*" + normalizedSuffix : "./*";
+                var matches = ts.mapDefined(ts.tryReadDirectory(host, baseDirectory, extensionOptions.extensions, /*exclude*/ undefined, [includeGlob]), function (match) {
+                    var trimmedWithPattern = trimPrefixAndSuffix(match);
+                    if (trimmedWithPattern) {
+                        if (containsSlash(trimmedWithPattern)) {
+                            return directoryResult(ts.getPathComponents(removeLeadingDirectorySeparator(trimmedWithPattern))[1]);
+                        }
+                        var _a = getFilenameWithExtensionOption(trimmedWithPattern, host.getCompilationSettings(), extensionOptions.includeExtensionsOption), name = _a.name, extension = _a.extension;
+                        return nameAndKind(name, "script" /* scriptElement */, extension);
+                    }
                 });
+                // If we had a suffix, we already recursively searched for all possible files that could match
+                // it and returned the directories leading to those files. Otherwise, assume any directory could
+                // have something valid to import.
+                var directories = normalizedSuffix
+                    ? ts.emptyArray
+                    : ts.mapDefined(ts.tryGetDirectories(host, baseDirectory), function (dir) { return dir === "node_modules" ? undefined : directoryResult(dir); });
                 return __spreadArray(__spreadArray([], matches, true), directories, true);
                 function trimPrefixAndSuffix(path) {
                     var inner = withoutStartAndEnd(ts.normalizePath(path), completePrefix, normalizedSuffix);
@@ -133625,10 +133737,10 @@ var ts;
                 var names = kind === "path" ? getCompletionEntriesForDirectoryFragment(toComplete, scriptPath, getExtensionOptions(compilerOptions, 1 /* Include */), host, sourceFile.path)
                     : kind === "types" ? getCompletionEntriesFromTypings(host, compilerOptions, scriptPath, getFragmentDirectory(toComplete), getExtensionOptions(compilerOptions))
                         : ts.Debug.fail();
-                return addReplacementSpans(toComplete, range.pos + prefix.length, names);
+                return addReplacementSpans(toComplete, range.pos + prefix.length, ts.arrayFrom(names.values()));
             }
             function getCompletionEntriesFromTypings(host, options, scriptPath, fragmentDirectory, extensionOptions, result) {
-                if (result === void 0) { result = []; }
+                if (result === void 0) { result = createNameAndKindSet(); }
                 // Check for typings specified in compiler options
                 var seen = new ts.Map();
                 var typeRoots = ts.tryAndIgnoreErrors(function () { return ts.getEffectiveTypeRoots(options, host); }) || ts.emptyArray;
@@ -133653,7 +133765,7 @@ var ts;
                             continue;
                         if (fragmentDirectory === undefined) {
                             if (!seen.has(packageName)) {
-                                result.push(nameAndKind(packageName, "external module name" /* externalModuleName */, /*extension*/ undefined));
+                                result.add(nameAndKind(packageName, "external module name" /* externalModuleName */, /*extension*/ undefined));
                                 seen.set(packageName, true);
                             }
                         }
@@ -134545,7 +134657,7 @@ var ts;
             var name = ts.getSynthesizedDeepClone(ts.getNameOfDeclaration(declaration), /*includeTrivia*/ false);
             var type = checker.getWidenedType(checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration));
             var quotePreference = ts.getQuotePreference(sourceFile, preferences);
-            var builderFlags = quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : undefined;
+            var builderFlags = 33554432 /* OmitThisParameter */ | (quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0 /* None */);
             switch (declaration.kind) {
                 case 166 /* PropertySignature */:
                 case 167 /* PropertyDeclaration */:
@@ -139254,7 +139366,7 @@ var ts;
                         result = references;
                         continue;
                     }
-                    var _loop_4 = function (entry) {
+                    var _loop_3 = function (entry) {
                         if (!entry.definition || entry.definition.type !== 0 /* Symbol */) {
                             result.push(entry);
                             return "continue";
@@ -139286,7 +139398,7 @@ var ts;
                     };
                     for (var _b = 0, references_2 = references; _b < references_2.length; _b++) {
                         var entry = references_2[_b];
-                        _loop_4(entry);
+                        _loop_3(entry);
                     }
                 }
                 return result;
@@ -140867,8 +140979,8 @@ var ts;
             var declarations;
             if (symbol && symbol.declarations) {
                 var indices = ts.indicesOf(symbol.declarations);
-                var keys_1 = ts.map(symbol.declarations, function (decl) { return ({ file: decl.getSourceFile().fileName, pos: decl.pos }); });
-                indices.sort(function (a, b) { return ts.compareStringsCaseSensitive(keys_1[a].file, keys_1[b].file) || keys_1[a].pos - keys_1[b].pos; });
+                var keys_2 = ts.map(symbol.declarations, function (decl) { return ({ file: decl.getSourceFile().fileName, pos: decl.pos }); });
+                indices.sort(function (a, b) { return ts.compareStringsCaseSensitive(keys_2[a].file, keys_2[b].file) || keys_2[a].pos - keys_2[b].pos; });
                 var sortedDeclarations = ts.map(indices, function (i) { return symbol.declarations[i]; });
                 var lastDecl = void 0;
                 for (var _i = 0, sortedDeclarations_1 = sortedDeclarations; _i < sortedDeclarations_1.length; _i++) {
@@ -141316,7 +141428,7 @@ var ts;
     }
     function updateImports(program, changeTracker, oldToNew, newToOld, host, getCanonicalFileName) {
         var allFiles = program.getSourceFiles();
-        var _loop_5 = function (sourceFile) {
+        var _loop_4 = function (sourceFile) {
             var newFromOld = oldToNew(sourceFile.fileName);
             var newImportFromPath = newFromOld !== null && newFromOld !== void 0 ? newFromOld : sourceFile.fileName;
             var newImportFromDirectory = ts.getDirectoryPath(newImportFromPath);
@@ -141348,7 +141460,7 @@ var ts;
         };
         for (var _i = 0, allFiles_1 = allFiles; _i < allFiles_1.length; _i++) {
             var sourceFile = allFiles_1[_i];
-            _loop_5(sourceFile);
+            _loop_4(sourceFile);
         }
     }
     function combineNormal(pathA, pathB) {
@@ -142372,7 +142484,7 @@ var ts;
             if (!patternMatcher)
                 return ts.emptyArray;
             var rawItems = [];
-            var _loop_6 = function (sourceFile) {
+            var _loop_5 = function (sourceFile) {
                 cancellationToken.throwIfCancellationRequested();
                 if (excludeDtsFiles && sourceFile.isDeclarationFile) {
                     return "continue";
@@ -142384,7 +142496,7 @@ var ts;
             // Search the declarations in all files and output matched NavigateToItem into array of NavigateToItem[]
             for (var _i = 0, sourceFiles_4 = sourceFiles; _i < sourceFiles_4.length; _i++) {
                 var sourceFile = sourceFiles_4[_i];
-                _loop_6(sourceFile);
+                _loop_5(sourceFile);
             }
             rawItems.sort(compareNavigateToItems);
             return (maxResultCount === undefined ? rawItems : rawItems.slice(0, maxResultCount)).map(createNavigateToItem);
@@ -144447,13 +144559,13 @@ var ts;
     // Assumes 'value' is already lowercase.
     function indexOfIgnoringCase(str, value) {
         var n = str.length - value.length;
-        var _loop_7 = function (start) {
+        var _loop_6 = function (start) {
             if (every(value, function (valueChar, i) { return toLowerCase(str.charCodeAt(i + start)) === valueChar; })) {
                 return { value: start };
             }
         };
         for (var start = 0; start <= n; start++) {
-            var state_3 = _loop_7(start);
+            var state_3 = _loop_6(start);
             if (typeof state_3 === "object")
                 return state_3.value;
         }
@@ -145920,7 +146032,7 @@ var ts;
             return ts.createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart);
         }
         function getContainingArgumentInfo(node, position, sourceFile, checker, isManuallyInvoked) {
-            var _loop_8 = function (n) {
+            var _loop_7 = function (n) {
                 // If the node is not a subspan of its parent, this is a big problem.
                 // There have been crashes that might be caused by this violation.
                 ts.Debug.assert(ts.rangeContainsRange(n.parent, n), "Not a subspan", function () { return "Child: " + ts.Debug.formatSyntaxKind(n.kind) + ", parent: " + ts.Debug.formatSyntaxKind(n.parent.kind); });
@@ -145930,7 +146042,7 @@ var ts;
                 }
             };
             for (var n = node; !ts.isSourceFile(n) && (isManuallyInvoked || !ts.isBlock(n)); n = n.parent) {
-                var state_4 = _loop_8(n);
+                var state_4 = _loop_7(n);
                 if (typeof state_4 === "object")
                     return state_4.value;
             }
@@ -147543,7 +147655,7 @@ var ts;
         commandLineOptionsStringToEnum = commandLineOptionsStringToEnum ||
             ts.filter(ts.optionDeclarations, function (o) { return typeof o.type === "object" && !ts.forEachEntry(o.type, function (v) { return typeof v !== "number"; }); });
         options = ts.cloneCompilerOptions(options);
-        var _loop_9 = function (opt) {
+        var _loop_8 = function (opt) {
             if (!ts.hasProperty(options, opt.name)) {
                 return "continue";
             }
@@ -147562,7 +147674,7 @@ var ts;
         };
         for (var _i = 0, commandLineOptionsStringToEnum_1 = commandLineOptionsStringToEnum; _i < commandLineOptionsStringToEnum_1.length; _i++) {
             var opt = commandLineOptionsStringToEnum_1[_i];
-            _loop_9(opt);
+            _loop_8(opt);
         }
         return options;
     }
@@ -151327,7 +151439,7 @@ var ts;
             ChangeTracker.prototype.finishDeleteDeclarations = function () {
                 var _this = this;
                 var deletedNodesInLists = new ts.Set(); // Stores nodes in lists that we already deleted. Used to avoid deleting `, ` twice in `a, b`.
-                var _loop_10 = function (sourceFile, node) {
+                var _loop_9 = function (sourceFile, node) {
                     if (!this_1.deletedNodes.some(function (d) { return d.sourceFile === sourceFile && ts.rangeContainsRangeExclusive(d.node, node); })) {
                         if (ts.isArray(node)) {
                             this_1.deleteRange(sourceFile, ts.rangeOfTypeParameters(sourceFile, node));
@@ -151340,7 +151452,7 @@ var ts;
                 var this_1 = this;
                 for (var _i = 0, _a = this.deletedNodes; _i < _a.length; _i++) {
                     var _b = _a[_i], sourceFile = _b.sourceFile, node = _b.node;
-                    _loop_10(sourceFile, node);
+                    _loop_9(sourceFile, node);
                 }
                 deletedNodesInLists.forEach(function (node) {
                     var sourceFile = node.getSourceFile();
@@ -151428,14 +151540,14 @@ var ts;
                     // order changes by start position
                     // If the start position is the same, put the shorter range first, since an empty range (x, x) may precede (x, y) but not vice-versa.
                     var normalized = ts.stableSort(changesInFile, function (a, b) { return (a.range.pos - b.range.pos) || (a.range.end - b.range.end); });
-                    var _loop_11 = function (i) {
+                    var _loop_10 = function (i) {
                         ts.Debug.assert(normalized[i].range.end <= normalized[i + 1].range.pos, "Changes overlap", function () {
                             return JSON.stringify(normalized[i].range) + " and " + JSON.stringify(normalized[i + 1].range);
                         });
                     };
                     // verify that change intervals do not overlap, except possibly at end points.
                     for (var i = 0; i < normalized.length - 1; i++) {
-                        _loop_11(i);
+                        _loop_10(i);
                     }
                     var textChanges = ts.mapDefined(normalized, function (c) {
                         var span = ts.createTextSpanFromRange(c.range);
@@ -152343,7 +152455,7 @@ var ts;
             }
             var isCompleteFix = identifiers.isCompleteFix;
             var initializers;
-            var _loop_12 = function (identifier) {
+            var _loop_11 = function (identifier) {
                 var symbol = checker.getSymbolAtLocation(identifier);
                 if (!symbol) {
                     return "continue";
@@ -152376,7 +152488,7 @@ var ts;
             };
             for (var _i = 0, _a = identifiers.identifiers; _i < _a.length; _i++) {
                 var identifier = _a[_i];
-                _loop_12(identifier);
+                _loop_11(identifier);
             }
             return initializers && {
                 initializers: initializers,
@@ -153261,7 +153373,7 @@ var ts;
             }
             var pos = ts.skipTrivia(sourceFile.text, ts.moveRangePastModifiers(functionToConvert).pos);
             changes.insertModifierAt(sourceFile, pos, 131 /* AsyncKeyword */, { suffix: " " });
-            var _loop_13 = function (returnStatement) {
+            var _loop_12 = function (returnStatement) {
                 ts.forEachChild(returnStatement, function visit(node) {
                     if (ts.isCallExpression(node)) {
                         var newNodes = transformExpression(node, node, transformer, /*hasContinuation*/ false);
@@ -153283,7 +153395,7 @@ var ts;
             };
             for (var _i = 0, returnStatements_1 = returnStatements; _i < returnStatements_1.length; _i++) {
                 var returnStatement = returnStatements_1[_i];
-                var state_5 = _loop_13(returnStatement);
+                var state_5 = _loop_12(returnStatement);
                 if (typeof state_5 === "object")
                     return state_5.value;
             }
@@ -156618,7 +156730,7 @@ var ts;
                     });
                     typeDeclToMembers.forEach(function (infos, declaration) {
                         var supers = ts.isTypeLiteralNode(declaration) ? undefined : codefix.getAllSupers(declaration, checker);
-                        var _loop_14 = function (info) {
+                        var _loop_13 = function (info) {
                             // If some superclass added this property, don't add it again.
                             if (supers === null || supers === void 0 ? void 0 : supers.some(function (superClassOrInterface) {
                                 var superInfos = typeDeclToMembers.get(superClassOrInterface);
@@ -156645,7 +156757,7 @@ var ts;
                         };
                         for (var _i = 0, infos_1 = infos; _i < infos_1.length; _i++) {
                             var info = infos_1[_i];
-                            _loop_14(info);
+                            _loop_13(info);
                         }
                     });
                 }));
@@ -159419,7 +159531,7 @@ var ts;
             function getSignatureFromCalls(calls) {
                 var parameters = [];
                 var length = Math.max.apply(Math, calls.map(function (c) { return c.argumentTypes.length; }));
-                var _loop_15 = function (i) {
+                var _loop_14 = function (i) {
                     var symbol = checker.createSymbol(1 /* FunctionScopedVariable */, ts.escapeLeadingUnderscores("arg" + i));
                     symbol.type = combineTypes(calls.map(function (call) { return call.argumentTypes[i] || checker.getUndefinedType(); }));
                     if (calls.some(function (call) { return call.argumentTypes[i] === undefined; })) {
@@ -159428,7 +159540,7 @@ var ts;
                     parameters.push(symbol);
                 };
                 for (var i = 0; i < length; i++) {
-                    _loop_15(i);
+                    _loop_14(i);
                 }
                 var returnType = combineFromUsage(combineUsages(calls.map(function (call) { return call.return_; })));
                 return checker.createSignature(/*declaration*/ undefined, /*typeParameters*/ undefined, /*thisParameter*/ undefined, parameters, returnType, /*typePredicate*/ undefined, length, 0 /* None */);
@@ -161404,7 +161516,7 @@ var ts;
             // Imports that need to be kept as named imports in the refactored code, to avoid changing the semantics.
             // More specifically, those are named imports that appear in named exports in the original code, e.g. `a` in `import { a } from "m"; export { a }`.
             var neededNamedImports = new ts.Set();
-            var _loop_16 = function (element) {
+            var _loop_15 = function (element) {
                 var propertyName = (element.propertyName || element.name).text;
                 ts.FindAllReferences.Core.eachSymbolReferenceInFile(element.name, checker, sourceFile, function (id) {
                     var access = ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(namespaceImportName), propertyName);
@@ -161421,7 +161533,7 @@ var ts;
             };
             for (var _i = 0, _a = toConvert.elements; _i < _a.length; _i++) {
                 var element = _a[_i];
-                _loop_16(element);
+                _loop_15(element);
             }
             changes.replaceNode(sourceFile, toConvert, shouldUseDefault
                 ? ts.factory.createIdentifier(namespaceImportName)
@@ -163312,7 +163424,7 @@ var ts;
                         : ts.getEnclosingBlockScopeContainer(scopes[0]);
                     ts.forEachChild(containingLexicalScopeOfExtraction, checkForUsedDeclarations);
                 }
-                var _loop_17 = function (i) {
+                var _loop_16 = function (i) {
                     var scopeUsages = usagesPerScope[i];
                     // Special case: in the innermost scope, all usages are available.
                     // (The computed value reflects the value at the top-level of the scope, but the
@@ -163355,7 +163467,7 @@ var ts;
                     }
                 };
                 for (var i = 0; i < scopes.length; i++) {
-                    _loop_17(i);
+                    _loop_16(i);
                 }
                 return { target: target, usagesPerScope: usagesPerScope, functionErrorsPerScope: functionErrorsPerScope, constantErrorsPerScope: constantErrorsPerScope, exposedVariableDeclarations: exposedVariableDeclarations };
                 function isInGenericContext(node) {
@@ -164056,10 +164168,10 @@ var ts;
         }
         function updateImportsInOtherFiles(changes, program, oldFile, movedSymbols, newModuleName) {
             var checker = program.getTypeChecker();
-            var _loop_18 = function (sourceFile) {
+            var _loop_17 = function (sourceFile) {
                 if (sourceFile === oldFile)
                     return "continue";
-                var _loop_19 = function (statement) {
+                var _loop_18 = function (statement) {
                     forEachImportInStatement(statement, function (importNode) {
                         if (checker.getSymbolAtLocation(moduleSpecifierFromImport(importNode)) !== oldFile.symbol)
                             return;
@@ -164081,12 +164193,12 @@ var ts;
                 };
                 for (var _b = 0, _c = sourceFile.statements; _b < _c.length; _b++) {
                     var statement = _c[_b];
-                    _loop_19(statement);
+                    _loop_18(statement);
                 }
             };
             for (var _i = 0, _a = program.getSourceFiles(); _i < _a.length; _i++) {
                 var sourceFile = _a[_i];
-                _loop_18(sourceFile);
+                _loop_17(sourceFile);
             }
         }
         function getNamespaceLikeImport(node) {
@@ -165449,7 +165561,7 @@ var ts;
                 var templateSpans = [];
                 var templateHead = ts.factory.createTemplateHead(headText, rawHeadText);
                 copyCommentFromStringLiterals(headIndexes, templateHead);
-                var _loop_20 = function (i) {
+                var _loop_19 = function (i) {
                     var currentNode = getExpressionFromParenthesesOrExpression(nodes[i]);
                     copyOperatorComments(i, currentNode);
                     var _c = concatConsecutiveString(i + 1, nodes), newIndex = _c[0], subsequentText = _c[1], rawSubsequentText = _c[2], stringIndexes = _c[3];
@@ -165478,7 +165590,7 @@ var ts;
                 };
                 var out_i_1;
                 for (var i = begin; i < nodes.length; i++) {
-                    _loop_20(i);
+                    _loop_19(i);
                     i = out_i_1;
                 }
                 return ts.factory.createTemplateExpression(templateHead, templateSpans);
@@ -166090,20 +166202,25 @@ var ts;
             return this.documentationComment;
         };
         SymbolObject.prototype.getContextualDocumentationComment = function (context, checker) {
-            switch (context === null || context === void 0 ? void 0 : context.kind) {
-                case 172 /* GetAccessor */:
+            if (context) {
+                if (ts.isGetAccessor(context)) {
                     if (!this.contextualGetAccessorDocumentationComment) {
                         this.contextualGetAccessorDocumentationComment = getDocumentationComment(ts.filter(this.declarations, ts.isGetAccessor), checker);
                     }
-                    return this.contextualGetAccessorDocumentationComment;
-                case 173 /* SetAccessor */:
+                    if (ts.length(this.contextualGetAccessorDocumentationComment)) {
+                        return this.contextualGetAccessorDocumentationComment;
+                    }
+                }
+                if (ts.isSetAccessor(context)) {
                     if (!this.contextualSetAccessorDocumentationComment) {
                         this.contextualSetAccessorDocumentationComment = getDocumentationComment(ts.filter(this.declarations, ts.isSetAccessor), checker);
                     }
-                    return this.contextualSetAccessorDocumentationComment;
-                default:
-                    return this.getDocumentationComment(checker);
+                    if (ts.length(this.contextualSetAccessorDocumentationComment)) {
+                        return this.contextualSetAccessorDocumentationComment;
+                    }
+                }
             }
+            return this.getDocumentationComment(checker);
         };
         SymbolObject.prototype.getJsDocTags = function (checker) {
             if (this.tags === undefined) {
@@ -166112,20 +166229,25 @@ var ts;
             return this.tags;
         };
         SymbolObject.prototype.getContextualJsDocTags = function (context, checker) {
-            switch (context === null || context === void 0 ? void 0 : context.kind) {
-                case 172 /* GetAccessor */:
+            if (context) {
+                if (ts.isGetAccessor(context)) {
                     if (!this.contextualGetAccessorTags) {
                         this.contextualGetAccessorTags = getJsDocTagsOfDeclarations(ts.filter(this.declarations, ts.isGetAccessor), checker);
                     }
-                    return this.contextualGetAccessorTags;
-                case 173 /* SetAccessor */:
+                    if (ts.length(this.contextualGetAccessorTags)) {
+                        return this.contextualGetAccessorTags;
+                    }
+                }
+                if (ts.isSetAccessor(context)) {
                     if (!this.contextualSetAccessorTags) {
                         this.contextualSetAccessorTags = getJsDocTagsOfDeclarations(ts.filter(this.declarations, ts.isSetAccessor), checker);
                     }
-                    return this.contextualSetAccessorTags;
-                default:
-                    return this.getJsDocTags(checker);
+                    if (ts.length(this.contextualSetAccessorTags)) {
+                        return this.contextualSetAccessorTags;
+                    }
+                }
             }
+            return this.getJsDocTags(checker);
         };
         return SymbolObject;
     }());
@@ -166314,7 +166436,7 @@ var ts;
         var tags = ts.JsDoc.getJsDocTagsFromDeclarations(declarations, checker);
         if (checker && (tags.length === 0 || declarations.some(hasJSDocInheritDocTag))) {
             var seenSymbols_1 = new ts.Set();
-            var _loop_21 = function (declaration) {
+            var _loop_20 = function (declaration) {
                 var inheritedTags = findBaseOfDeclaration(checker, declaration, function (symbol) {
                     var _a;
                     if (!seenSymbols_1.has(symbol)) {
@@ -166331,7 +166453,7 @@ var ts;
             };
             for (var _i = 0, declarations_7 = declarations; _i < declarations_7.length; _i++) {
                 var declaration = declarations_7[_i];
-                _loop_21(declaration);
+                _loop_20(declaration);
             }
         }
         return tags;
@@ -166342,7 +166464,7 @@ var ts;
         var doc = ts.JsDoc.getJsDocCommentsFromDeclarations(declarations, checker);
         if (checker && (doc.length === 0 || declarations.some(hasJSDocInheritDocTag))) {
             var seenSymbols_2 = new ts.Set();
-            var _loop_22 = function (declaration) {
+            var _loop_21 = function (declaration) {
                 var inheritedDocs = findBaseOfDeclaration(checker, declaration, function (symbol) {
                     if (!seenSymbols_2.has(symbol)) {
                         seenSymbols_2.add(symbol);
@@ -166358,7 +166480,7 @@ var ts;
             };
             for (var _i = 0, declarations_8 = declarations; _i < declarations_8.length; _i++) {
                 var declaration = declarations_8[_i];
-                _loop_22(declaration);
+                _loop_21(declaration);
             }
         }
         return doc;
@@ -166876,7 +166998,10 @@ var ts;
                 program = undefined; // TODO: GH#18217
                 lastTypesRootVersion = typeRootsVersion;
             }
-            var rootFileNames = host.getScriptFileNames();
+            // This array is retained by the program and will be used to determine if the program is up to date,
+            // so we need to make a copy in case the host mutates the underlying array - otherwise it would look
+            // like every program always has the host's current list of root files.
+            var rootFileNames = host.getScriptFileNames().slice();
             // Get a fresh cache of the host information
             var newSettings = host.getCompilationSettings() || getDefaultCompilerOptions();
             var hasInvalidatedResolution = host.hasInvalidatedResolution || ts.returnFalse;