typescript 4.6.0-dev.20220204 → 4.6.0-dev.20220205

package/lib/tsserverlibrary.js

@@ -294,7 +294,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.20220204";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220205";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -1468,11 +1468,11 @@ var ts;
         return result;
     }
     ts.getAllKeys = getAllKeys;
-    function getOwnValues(sparseArray) {
+    function getOwnValues(collection) {
         var values = [];
-        for (var key in sparseArray) {
-            if (hasOwnProperty.call(sparseArray, key)) {
-                values.push(sparseArray[key]);
+        for (var key in collection) {
+            if (hasOwnProperty.call(collection, key)) {
+                values.push(collection[key]);
             }
         }
         return values;
@@ -8875,12 +8875,10 @@ var ts;
         Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher: diag(2802, ts.DiagnosticCategory.Error, "Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es201_2802", "Type '{0}' can only be iterated through when using the '--downlevelIteration' flag or with a '--target' of 'es2015' or higher."),
         Cannot_assign_to_private_method_0_Private_methods_are_not_writable: diag(2803, ts.DiagnosticCategory.Error, "Cannot_assign_to_private_method_0_Private_methods_are_not_writable_2803", "Cannot assign to private method '{0}'. Private methods are not writable."),
         Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name: diag(2804, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name_2804", "Duplicate identifier '{0}'. Static and instance elements cannot share the same private name."),
-        Static_fields_with_private_names_can_t_have_initializers_when_the_useDefineForClassFields_flag_is_not_specified_with_a_target_of_esnext_Consider_adding_the_useDefineForClassFields_flag: diag(2805, ts.DiagnosticCategory.Error, "Static_fields_with_private_names_can_t_have_initializers_when_the_useDefineForClassFields_flag_is_no_2805", "Static fields with private names can't have initializers when the '--useDefineForClassFields' flag is not specified with a '--target' of 'esnext'. Consider adding the '--useDefineForClassFields' flag."),
         Private_accessor_was_defined_without_a_getter: diag(2806, ts.DiagnosticCategory.Error, "Private_accessor_was_defined_without_a_getter_2806", "Private accessor was defined without a getter."),
         This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0: diag(2807, ts.DiagnosticCategory.Error, "This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_o_2807", "This syntax requires an imported helper named '{1}' with {2} parameters, which is not compatible with the one in '{0}'. Consider upgrading your version of '{0}'."),
         A_get_accessor_must_be_at_least_as_accessible_as_the_setter: diag(2808, ts.DiagnosticCategory.Error, "A_get_accessor_must_be_at_least_as_accessible_as_the_setter_2808", "A get accessor must be at least as accessible as the setter"),
         Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_the_whole_assignment_in_parentheses: diag(2809, ts.DiagnosticCategory.Error, "Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_d_2809", "Declaration or statement expected. This '=' follows a block of statements, so if you intended to write a destructuring assignment, you might need to wrap the the whole assignment in parentheses."),
-        Property_0_may_not_be_used_in_a_static_property_s_initializer_in_the_same_class_when_target_is_esnext_and_useDefineForClassFields_is_false: diag(2810, ts.DiagnosticCategory.Error, "Property_0_may_not_be_used_in_a_static_property_s_initializer_in_the_same_class_when_target_is_esnex_2810", "Property '{0}' may not be used in a static property's initializer in the same class when 'target' is 'esnext' and 'useDefineForClassFields' is 'false'."),
         Initializer_for_property_0: diag(2811, ts.DiagnosticCategory.Error, "Initializer_for_property_0_2811", "Initializer for property '{0}'"),
         Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom: diag(2812, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom_2812", "Property '{0}' does not exist on type '{1}'. Try changing the 'lib' compiler option to include 'dom'."),
         Class_declaration_cannot_implement_overload_list_for_0: diag(2813, ts.DiagnosticCategory.Error, "Class_declaration_cannot_implement_overload_list_for_0_2813", "Class declaration cannot implement overload list for '{0}'."),
@@ -9831,6 +9829,7 @@ var ts;
         Add_missing_attributes: diag(95167, ts.DiagnosticCategory.Message, "Add_missing_attributes_95167", "Add missing attributes"),
         Add_all_missing_attributes: diag(95168, ts.DiagnosticCategory.Message, "Add_all_missing_attributes_95168", "Add all missing attributes"),
         Add_undefined_to_optional_property_type: diag(95169, ts.DiagnosticCategory.Message, "Add_undefined_to_optional_property_type_95169", "Add 'undefined' to optional property type"),
+        Convert_named_imports_to_default_import: diag(95170, ts.DiagnosticCategory.Message, "Convert_named_imports_to_default_import_95170", "Convert named imports to default import"),
         No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, ts.DiagnosticCategory.Error, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."),
         Classes_may_not_have_a_field_named_constructor: diag(18006, ts.DiagnosticCategory.Error, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."),
         JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, ts.DiagnosticCategory.Error, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"),
@@ -73146,23 +73145,6 @@ var ts;
                 if (assignmentKind && lexicallyScopedSymbol && lexicallyScopedSymbol.valueDeclaration && ts.isMethodDeclaration(lexicallyScopedSymbol.valueDeclaration)) {
                     grammarErrorOnNode(right, ts.Diagnostics.Cannot_assign_to_private_method_0_Private_methods_are_not_writable, ts.idText(right));
                 }
-                if ((lexicallyScopedSymbol === null || lexicallyScopedSymbol === void 0 ? void 0 : lexicallyScopedSymbol.valueDeclaration) && (ts.getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && !useDefineForClassFields)) {
-                    var lexicalClass_1 = ts.getContainingClass(lexicallyScopedSymbol.valueDeclaration);
-                    var parentStaticFieldInitializer = ts.findAncestor(node, function (n) {
-                        if (n === lexicalClass_1)
-                            return "quit";
-                        if (ts.isPropertyDeclaration(n.parent) && ts.hasStaticModifier(n.parent) && n.parent.initializer === n && n.parent.parent === lexicalClass_1) {
-                            return true;
-                        }
-                        return false;
-                    });
-                    if (parentStaticFieldInitializer) {
-                        var parentStaticFieldInitializerSymbol = getSymbolOfNode(parentStaticFieldInitializer.parent);
-                        ts.Debug.assert(parentStaticFieldInitializerSymbol, "Initializer without declaration symbol");
-                        var diagnostic = error(node, ts.Diagnostics.Property_0_may_not_be_used_in_a_static_property_s_initializer_in_the_same_class_when_target_is_esnext_and_useDefineForClassFields_is_false, ts.symbolName(lexicallyScopedSymbol));
-                        ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(parentStaticFieldInitializer.parent, ts.Diagnostics.Initializer_for_property_0, ts.symbolName(parentStaticFieldInitializerSymbol)));
-                    }
-                }
                 if (isAnyLike) {
                     if (lexicallyScopedSymbol) {
                         return isErrorType(apparentType) ? errorType : apparentType;
@@ -78798,9 +78780,6 @@ var ts;
                 checkGrammarComputedPropertyName(node.name);
             checkVariableLikeDeclaration(node);
             setNodeLinksForPrivateIdentifierScope(node);
-            if (ts.isPrivateIdentifier(node.name) && ts.hasStaticModifier(node) && node.initializer && languageVersion === 99 /* ESNext */ && !compilerOptions.useDefineForClassFields) {
-                error(node.initializer, ts.Diagnostics.Static_fields_with_private_names_can_t_have_initializers_when_the_useDefineForClassFields_flag_is_not_specified_with_a_target_of_esnext_Consider_adding_the_useDefineForClassFields_flag);
-            }
             // property signatures already report "initializer not allowed in ambient context" elsewhere
             if (ts.hasSyntacticModifier(node, 128 /* Abstract */) && node.kind === 166 /* PropertyDeclaration */ && node.initializer) {
                 error(node, ts.Diagnostics.Property_0_cannot_have_an_initializer_because_it_is_marked_abstract, ts.declarationNameToString(node.name));
@@ -92490,10 +92469,12 @@ var ts;
         var languageVersion = ts.getEmitScriptTarget(compilerOptions);
         var useDefineForClassFields = ts.getUseDefineForClassFields(compilerOptions);
         var shouldTransformPrivateElementsOrClassStaticBlocks = languageVersion < 9 /* ES2022 */;
+        // We need to transform `this` in a static initializer into a reference to the class
+        // when targeting < ES2022 since the assignment will be moved outside of the class body.
+        var shouldTransformThisInStaticInitializers = languageVersion < 9 /* ES2022 */;
         // We don't need to transform `super` property access when targeting ES5, ES3 because
         // the es2015 transformation handles those.
-        var shouldTransformSuperInStaticInitializers = (languageVersion <= 8 /* ES2021 */ || !useDefineForClassFields) && languageVersion >= 2 /* ES2015 */;
-        var shouldTransformThisInStaticInitializers = languageVersion <= 8 /* ES2021 */ || !useDefineForClassFields;
+        var shouldTransformSuperInStaticInitializers = shouldTransformThisInStaticInitializers && languageVersion >= 2 /* ES2015 */;
         var previousOnSubstituteNode = context.onSubstituteNode;
         context.onSubstituteNode = onSubstituteNode;
         var previousOnEmitNode = context.onEmitNode;
@@ -92722,6 +92703,10 @@ var ts;
             ts.Debug.assert(!ts.some(node.decorators));
             if (ts.isPrivateIdentifier(node.name)) {
                 if (!shouldTransformPrivateElementsOrClassStaticBlocks) {
+                    if (ts.isStatic(node)) {
+                        // static fields are left as is
+                        return ts.visitEachChild(node, visitor, context);
+                    }
                     // Initializer is elided as the field is initialized in transformConstructor.
                     return factory.updatePropertyDeclaration(node, 
                     /*decorators*/ undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.name, 
@@ -92743,6 +92728,22 @@ var ts;
             if (expr && !ts.isSimpleInlineableExpression(expr)) {
                 getPendingExpressions().push(expr);
             }
+            if (ts.isStatic(node) && !shouldTransformPrivateElementsOrClassStaticBlocks && !useDefineForClassFields) {
+                var initializerStatement = transformPropertyOrClassStaticBlock(node, factory.createThis());
+                if (initializerStatement) {
+                    var staticBlock = factory.createClassStaticBlockDeclaration(
+                    /*decorators*/ undefined, 
+                    /*modifiers*/ undefined, factory.createBlock([initializerStatement]));
+                    ts.setOriginalNode(staticBlock, node);
+                    ts.setCommentRange(staticBlock, node);
+                    // Set the comment range for the statement to an empty synthetic range
+                    // and drop synthetic comments from the statement to avoid printing them twice.
+                    ts.setCommentRange(initializerStatement, { pos: -1, end: -1 });
+                    ts.setSyntheticLeadingComments(initializerStatement, undefined);
+                    ts.setSyntheticTrailingComments(initializerStatement, undefined);
+                    return staticBlock;
+                }
+            }
             return undefined;
         }
         function createPrivateIdentifierAccess(info, receiver) {
@@ -93130,7 +93131,6 @@ var ts;
             if (facts & 8 /* NeedsSubstitutionForThisInClassStaticField */) {
                 enableSubstitutionForClassStaticThisOrSuperReference();
             }
-            var staticProperties = ts.getStaticPropertiesAndClassStaticBlock(node);
             // If a class has private static fields, or a static field has a `this` or `super` reference,
             // then we need to allocate a temp variable to hold on to that reference.
             var pendingClassReferenceAssignment;
@@ -93158,6 +93158,7 @@ var ts;
             // From ES6 specification:
             //      HasLexicalDeclaration (N) : Determines if the argument identifier has a binding in this environment record that was created using
             //                                  a lexical declaration such as a LexicalDeclaration or a ClassDeclaration.
+            var staticProperties = ts.getStaticPropertiesAndClassStaticBlock(node);
             if (ts.some(staticProperties)) {
                 addPropertyOrClassStaticBlockStatements(statements, staticProperties, factory.getInternalName(node));
             }
@@ -93196,7 +93197,7 @@ var ts;
             }
             var classExpression = factory.updateClassExpression(node, ts.visitNodes(node.decorators, visitor, ts.isDecorator), node.modifiers, node.name, 
             /*typeParameters*/ undefined, ts.visitNodes(node.heritageClauses, heritageClauseVisitor, ts.isHeritageClause), transformClassMembers(node, isDerivedClass));
-            var hasTransformableStatics = ts.some(staticPropertiesOrClassStaticBlocks, function (p) { return ts.isClassStaticBlockDeclaration(p) || !!p.initializer || (shouldTransformPrivateElementsOrClassStaticBlocks && ts.isPrivateIdentifier(p.name)); });
+            var hasTransformableStatics = shouldTransformPrivateElementsOrClassStaticBlocks && ts.some(staticPropertiesOrClassStaticBlocks, function (p) { return ts.isClassStaticBlockDeclaration(p) || !!p.initializer || ts.isPrivateIdentifier(p.name); });
             if (hasTransformableStatics || ts.some(pendingExpressions)) {
                 if (isDecoratedClassDeclaration) {
                     ts.Debug.assertIsDefined(pendingStatements, "Decorated classes transformed by TypeScript are expected to be within a variable declaration.");
@@ -93243,6 +93244,7 @@ var ts;
             return undefined;
         }
         function transformClassMembers(node, isDerivedClass) {
+            var members = [];
             if (shouldTransformPrivateElementsOrClassStaticBlocks) {
                 // Declare private names.
                 for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
@@ -93255,12 +93257,20 @@ var ts;
                     createBrandCheckWeakSetForPrivateMethods();
                 }
             }
-            var members = [];
             var constructor = transformConstructor(node, isDerivedClass);
+            var visitedMembers = ts.visitNodes(node.members, classElementVisitor, ts.isClassElement);
             if (constructor) {
                 members.push(constructor);
             }
-            ts.addRange(members, ts.visitNodes(node.members, classElementVisitor, ts.isClassElement));
+            if (!shouldTransformPrivateElementsOrClassStaticBlocks && ts.some(pendingExpressions)) {
+                members.push(factory.createClassStaticBlockDeclaration(
+                /*decorators*/ undefined, 
+                /*modifiers*/ undefined, factory.createBlock([
+                    factory.createExpressionStatement(factory.inlineExpressions(pendingExpressions))
+                ])));
+                pendingExpressions = undefined;
+            }
+            ts.addRange(members, visitedMembers);
             return ts.setTextRange(factory.createNodeArray(members), /*location*/ node.members);
         }
         function createBrandCheckWeakSetForPrivateMethods() {
@@ -93403,24 +93413,34 @@ var ts;
         function addPropertyOrClassStaticBlockStatements(statements, properties, receiver) {
             for (var _i = 0, properties_7 = properties; _i < properties_7.length; _i++) {
                 var property = properties_7[_i];
-                var expression = ts.isClassStaticBlockDeclaration(property) ?
-                    transformClassStaticBlockDeclaration(property) :
-                    transformProperty(property, receiver);
-                if (!expression) {
+                if (ts.isStatic(property) && !shouldTransformPrivateElementsOrClassStaticBlocks && !useDefineForClassFields) {
+                    continue;
+                }
+                var statement = transformPropertyOrClassStaticBlock(property, receiver);
+                if (!statement) {
                     continue;
                 }
-                var statement = factory.createExpressionStatement(expression);
-                ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property));
-                ts.setCommentRange(statement, property);
-                ts.setOriginalNode(statement, property);
-                // `setOriginalNode` *copies* the `emitNode` from `property`, so now both
-                // `statement` and `expression` have a copy of the synthesized comments.
-                // Drop the comments from expression to avoid printing them twice.
-                ts.setSyntheticLeadingComments(expression, undefined);
-                ts.setSyntheticTrailingComments(expression, undefined);
                 statements.push(statement);
             }
         }
+        function transformPropertyOrClassStaticBlock(property, receiver) {
+            var expression = ts.isClassStaticBlockDeclaration(property) ?
+                transformClassStaticBlockDeclaration(property) :
+                transformProperty(property, receiver);
+            if (!expression) {
+                return undefined;
+            }
+            var statement = factory.createExpressionStatement(expression);
+            ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property));
+            ts.setCommentRange(statement, property);
+            ts.setOriginalNode(statement, property);
+            // `setOriginalNode` *copies* the `emitNode` from `property`, so now both
+            // `statement` and `expression` have a copy of the synthesized comments.
+            // Drop the comments from expression to avoid printing them twice.
+            ts.setSyntheticLeadingComments(expression, undefined);
+            ts.setSyntheticTrailingComments(expression, undefined);
+            return statement;
+        }
         /**
          * Generates assignment expressions for property initializers.
          *
@@ -127300,15 +127320,35 @@ var ts;
         return ts.isArray(valueOrArray) ? ts.first(valueOrArray) : valueOrArray;
     }
     ts.firstOrOnly = firstOrOnly;
+    function getNamesForExportedSymbol(symbol, scriptTarget) {
+        if (needsNameFromDeclaration(symbol)) {
+            var fromDeclaration = getDefaultLikeExportNameFromDeclaration(symbol);
+            if (fromDeclaration)
+                return fromDeclaration;
+            var fileNameCase = ts.codefix.moduleSymbolToValidIdentifier(getSymbolParentOrFail(symbol), scriptTarget, /*preferCapitalized*/ false);
+            var capitalized = ts.codefix.moduleSymbolToValidIdentifier(getSymbolParentOrFail(symbol), scriptTarget, /*preferCapitalized*/ true);
+            if (fileNameCase === capitalized)
+                return fileNameCase;
+            return [fileNameCase, capitalized];
+        }
+        return symbol.name;
+    }
+    ts.getNamesForExportedSymbol = getNamesForExportedSymbol;
     function getNameForExportedSymbol(symbol, scriptTarget, preferCapitalized) {
-        if (!(symbol.flags & 33554432 /* Transient */) && (symbol.escapedName === "export=" /* ExportEquals */ || symbol.escapedName === "default" /* Default */)) {
+        if (needsNameFromDeclaration(symbol)) {
             // Name of "export default foo;" is "foo". Name of "export default 0" is the filename converted to camelCase.
-            return ts.firstDefined(symbol.declarations, function (d) { var _a; return ts.isExportAssignment(d) ? (_a = ts.tryCast(ts.skipOuterExpressions(d.expression), ts.isIdentifier)) === null || _a === void 0 ? void 0 : _a.text : undefined; })
+            return getDefaultLikeExportNameFromDeclaration(symbol)
                 || ts.codefix.moduleSymbolToValidIdentifier(getSymbolParentOrFail(symbol), scriptTarget, !!preferCapitalized);
         }
         return symbol.name;
     }
     ts.getNameForExportedSymbol = getNameForExportedSymbol;
+    function needsNameFromDeclaration(symbol) {
+        return !(symbol.flags & 33554432 /* Transient */) && (symbol.escapedName === "export=" /* ExportEquals */ || symbol.escapedName === "default" /* Default */);
+    }
+    function getDefaultLikeExportNameFromDeclaration(symbol) {
+        return ts.firstDefined(symbol.declarations, function (d) { var _a; return ts.isExportAssignment(d) ? (_a = ts.tryCast(ts.skipOuterExpressions(d.expression), ts.isIdentifier)) === null || _a === void 0 ? void 0 : _a.text : undefined; });
+    }
     function getSymbolParentOrFail(symbol) {
         var _a;
         return ts.Debug.checkDefined(symbol.parent, "Symbol parent was undefined. Flags: " + ts.Debug.formatSymbolFlags(symbol.flags) + ". " +
@@ -127478,9 +127518,11 @@ var ts;
                 // 3. Otherwise, we have a default/namespace import that can be imported by any name, and
                 //    `symbolTableKey` will be something undesirable like `export=` or `default`, so we try to
                 //    get a better name.
-                var importedName = exportKind === 0 /* Named */ || ts.isExternalModuleSymbol(namedSymbol)
+                var names = exportKind === 0 /* Named */ || ts.isExternalModuleSymbol(namedSymbol)
                     ? ts.unescapeLeadingUnderscores(symbolTableKey)
-                    : ts.getNameForExportedSymbol(namedSymbol, /*scriptTarget*/ undefined);
+                    : ts.getNamesForExportedSymbol(namedSymbol, /*scriptTarget*/ undefined);
+                var symbolName = typeof names === "string" ? names : names[0];
+                var capitalizedSymbolName = typeof names === "string" ? undefined : names[1];
                 var moduleName = ts.stripQuotes(moduleSymbol.name);
                 var id = exportInfoId++;
                 var target = ts.skipAlias(symbol, checker);
@@ -127488,10 +127530,11 @@ var ts;
                 var storedModuleSymbol = moduleSymbol.flags & 33554432 /* Transient */ ? undefined : moduleSymbol;
                 if (!storedSymbol || !storedModuleSymbol)
                     symbols.set(id, [symbol, moduleSymbol]);
-                exportInfo.add(key(importedName, symbol, ts.isExternalModuleNameRelative(moduleName) ? undefined : moduleName, checker), {
+                exportInfo.add(key(symbolName, symbol, ts.isExternalModuleNameRelative(moduleName) ? undefined : moduleName, checker), {
                     id: id,
                     symbolTableKey: symbolTableKey,
-                    symbolName: importedName,
+                    symbolName: symbolName,
+                    capitalizedSymbolName: capitalizedSymbolName,
                     moduleName: moduleName,
                     moduleFile: moduleFile,
                     moduleFileName: moduleFile === null || moduleFile === void 0 ? void 0 : moduleFile.fileName,
@@ -127509,21 +127552,18 @@ var ts;
                 var result = exportInfo.get(key);
                 return result === null || result === void 0 ? void 0 : result.map(rehydrateCachedInfo);
             },
-            forEach: function (importingFile, action) {
+            search: function (importingFile, preferCapitalized, matches, action) {
                 if (importingFile !== usableByFileName)
                     return;
                 exportInfo.forEach(function (info, key) {
                     var _a = parseKey(key), symbolName = _a.symbolName, ambientModuleName = _a.ambientModuleName;
-                    var rehydrated = info.map(rehydrateCachedInfo);
-                    var filtered = rehydrated.filter(function (r, i) { return isNotShadowedByDeeperNodeModulesPackage(r, info[i].packageName); });
-                    if (filtered.length) {
-                        action(filtered, function (preferCapitalized) {
-                            var _a = rehydrated[0], symbol = _a.symbol, exportKind = _a.exportKind;
-                            var namedSymbol = exportKind === 1 /* Default */ && ts.getLocalSymbolForExportDefault(symbol) || symbol;
-                            return preferCapitalized
-                                ? ts.getNameForExportedSymbol(namedSymbol, /*scriptTarget*/ undefined, /*preferCapitalized*/ true)
-                                : symbolName;
-                        }, !!ambientModuleName, key);
+                    var name = preferCapitalized && info[0].capitalizedSymbolName || symbolName;
+                    if (matches(name, info[0].targetFlags)) {
+                        var rehydrated = info.map(rehydrateCachedInfo);
+                        var filtered = rehydrated.filter(function (r, i) { return isNotShadowedByDeeperNodeModulesPackage(r, info[i].packageName); });
+                        if (filtered.length) {
+                            action(filtered, name, !!ambientModuleName, key);
+                        }
                     }
                 });
             },
@@ -131639,44 +131679,47 @@ var ts;
                 var packageJsonAutoImportProvider = (_b = host.getPackageJsonAutoImportProvider) === null || _b === void 0 ? void 0 : _b.call(host);
                 var packageJsonFilter = detailsEntryId ? undefined : ts.createPackageJsonImportFilter(sourceFile, preferences, host);
                 resolvingModuleSpecifiers("collectAutoImports", host, program, sourceFile, preferences, !!importCompletionNode, function (context) {
-                    exportInfo.forEach(sourceFile.path, function (info, getSymbolName, isFromAmbientModule, exportMapKey) {
-                        var symbolName = getSymbolName(/*preferCapitalized*/ isRightOfOpenTag);
+                    exportInfo.search(sourceFile.path, 
+                    /*preferCapitalized*/ isRightOfOpenTag, function (symbolName, targetFlags) {
                         if (!ts.isIdentifierText(symbolName, ts.getEmitScriptTarget(host.getCompilationSettings())))
-                            return;
+                            return false;
                         if (!detailsEntryId && ts.isStringANonContextualKeyword(symbolName))
-                            return;
-                        // `targetFlags` should be the same for each `info`
-                        if (!isTypeOnlyLocation && !importCompletionNode && !(info[0].targetFlags & 111551 /* Value */))
-                            return;
-                        if (isTypeOnlyLocation && !(info[0].targetFlags & (1536 /* Module */ | 788968 /* Type */)))
-                            return;
+                            return false;
+                        if (!isTypeOnlyLocation && !importCompletionNode && !(targetFlags & 111551 /* Value */))
+                            return false;
+                        if (isTypeOnlyLocation && !(targetFlags & (1536 /* Module */ | 788968 /* Type */)))
+                            return false;
                         // Do not try to auto-import something with a lowercase first letter for a JSX tag
                         var firstChar = symbolName.charCodeAt(0);
                         if (isRightOfOpenTag && (firstChar < 65 /* A */ || firstChar > 90 /* Z */))
+                            return false;
+                        if (detailsEntryId)
+                            return true;
+                        return charactersFuzzyMatchInString(symbolName, lowerCaseTokenText);
+                    }, function (info, symbolName, isFromAmbientModule, exportMapKey) {
+                        if (detailsEntryId && !ts.some(info, function (i) { return detailsEntryId.source === ts.stripQuotes(i.moduleSymbol.name); })) {
                             return;
-                        var isCompletionDetailsMatch = detailsEntryId && ts.some(info, function (i) { return detailsEntryId.source === ts.stripQuotes(i.moduleSymbol.name); });
-                        if (isCompletionDetailsMatch || !detailsEntryId && charactersFuzzyMatchInString(symbolName, lowerCaseTokenText)) {
-                            var defaultExportInfo = ts.find(info, isImportableExportInfo);
-                            if (!defaultExportInfo) {
-                                return;
-                            }
-                            // If we don't need to resolve module specifiers, we can use any re-export that is importable at all
-                            // (We need to ensure that at least one is importable to show a completion.)
-                            var _a = context.tryResolve(info, isFromAmbientModule) || {}, _b = _a.exportInfo, exportInfo_1 = _b === void 0 ? defaultExportInfo : _b, moduleSpecifier = _a.moduleSpecifier;
-                            var isDefaultExport = exportInfo_1.exportKind === 1 /* Default */;
-                            var symbol = isDefaultExport && ts.getLocalSymbolForExportDefault(exportInfo_1.symbol) || exportInfo_1.symbol;
-                            pushAutoImportSymbol(symbol, {
-                                kind: moduleSpecifier ? 32 /* ResolvedExport */ : 4 /* Export */,
-                                moduleSpecifier: moduleSpecifier,
-                                symbolName: symbolName,
-                                exportMapKey: exportMapKey,
-                                exportName: exportInfo_1.exportKind === 2 /* ExportEquals */ ? "export=" /* ExportEquals */ : exportInfo_1.symbol.name,
-                                fileName: exportInfo_1.moduleFileName,
-                                isDefaultExport: isDefaultExport,
-                                moduleSymbol: exportInfo_1.moduleSymbol,
-                                isFromPackageJson: exportInfo_1.isFromPackageJson,
-                            });
                         }
+                        var defaultExportInfo = ts.find(info, isImportableExportInfo);
+                        if (!defaultExportInfo) {
+                            return;
+                        }
+                        // If we don't need to resolve module specifiers, we can use any re-export that is importable at all
+                        // (We need to ensure that at least one is importable to show a completion.)
+                        var _a = context.tryResolve(info, isFromAmbientModule) || {}, _b = _a.exportInfo, exportInfo = _b === void 0 ? defaultExportInfo : _b, moduleSpecifier = _a.moduleSpecifier;
+                        var isDefaultExport = exportInfo.exportKind === 1 /* Default */;
+                        var symbol = isDefaultExport && ts.getLocalSymbolForExportDefault(exportInfo.symbol) || exportInfo.symbol;
+                        pushAutoImportSymbol(symbol, {
+                            kind: moduleSpecifier ? 32 /* ResolvedExport */ : 4 /* Export */,
+                            moduleSpecifier: moduleSpecifier,
+                            symbolName: symbolName,
+                            exportMapKey: exportMapKey,
+                            exportName: exportInfo.exportKind === 2 /* ExportEquals */ ? "export=" /* ExportEquals */ : exportInfo.symbol.name,
+                            fileName: exportInfo.moduleFileName,
+                            isDefaultExport: isDefaultExport,
+                            moduleSymbol: exportInfo.moduleSymbol,
+                            isFromPackageJson: exportInfo.isFromPackageJson,
+                        });
                     });
                     hasUnresolvedAutoImports = context.resolutionLimitExceeded();
                 });
@@ -137615,7 +137658,27 @@ var ts;
                 case 326 /* JSDocAugmentsTag */:
                     return withNode(tag.class);
                 case 342 /* JSDocTemplateTag */:
-                    return addComment(tag.typeParameters.map(function (tp) { return tp.getText(); }).join(", "));
+                    var templateTag = tag;
+                    var displayParts_3 = [];
+                    if (templateTag.constraint) {
+                        displayParts_3.push(ts.textPart(templateTag.constraint.getText()));
+                    }
+                    if (ts.length(templateTag.typeParameters)) {
+                        if (ts.length(displayParts_3)) {
+                            displayParts_3.push(ts.spacePart());
+                        }
+                        var lastTypeParameter_1 = templateTag.typeParameters[templateTag.typeParameters.length - 1];
+                        ts.forEach(templateTag.typeParameters, function (tp) {
+                            displayParts_3.push(namePart(tp.getText()));
+                            if (lastTypeParameter_1 !== tp) {
+                                displayParts_3.push.apply(displayParts_3, [ts.punctuationPart(27 /* CommaToken */), ts.spacePart()]);
+                            }
+                        });
+                    }
+                    if (comment) {
+                        displayParts_3.push.apply(displayParts_3, __spreadArray([ts.spacePart()], getDisplayPartsFromComment(comment, checker), true));
+                    }
+                    return displayParts_3;
                 case 341 /* JSDocTypeTag */:
                     return withNode(tag.typeExpression);
                 case 343 /* JSDocTypedefTag */:
@@ -141041,12 +141104,12 @@ var ts;
                 : { invocation: info.invocation.node, argumentCount: info.argumentCount, argumentIndex: info.argumentIndex };
         }
         SignatureHelp.getArgumentInfoForCompletions = getArgumentInfoForCompletions;
-        function getArgumentOrParameterListInfo(node, sourceFile) {
+        function getArgumentOrParameterListInfo(node, position, sourceFile) {
             var info = getArgumentOrParameterListAndIndex(node, sourceFile);
             if (!info)
                 return undefined;
             var list = info.list, argumentIndex = info.argumentIndex;
-            var argumentCount = getArgumentCount(list);
+            var argumentCount = getArgumentCount(list, /*ignoreTrailingComma*/ ts.isInString(sourceFile, position, node));
             if (argumentIndex !== 0) {
                 ts.Debug.assertLessThan(argumentIndex, argumentCount);
             }
@@ -141092,7 +141155,7 @@ var ts;
                 //    Case 3:
                 //          foo<T#, U#>(a#, #b#) -> The token is buried inside a list, and should give signature help
                 // Find out if 'node' is an argument, a type argument, or neither
-                var info = getArgumentOrParameterListInfo(node, sourceFile);
+                var info = getArgumentOrParameterListInfo(node, position, sourceFile);
                 if (!info)
                     return undefined;
                 var list = info.list, argumentIndex = info.argumentIndex, argumentCount = info.argumentCount, argumentsSpan = info.argumentsSpan;
@@ -141161,8 +141224,8 @@ var ts;
         function countBinaryExpressionParameters(b) {
             return ts.isBinaryExpression(b.left) ? countBinaryExpressionParameters(b.left) + 1 : 2;
         }
-        function tryGetParameterInfo(startingToken, _position, sourceFile, checker) {
-            var info = getContextualSignatureLocationInfo(startingToken, sourceFile, checker);
+        function tryGetParameterInfo(startingToken, position, sourceFile, checker) {
+            var info = getContextualSignatureLocationInfo(startingToken, sourceFile, position, checker);
             if (!info)
                 return undefined;
             var contextualType = info.contextualType, argumentIndex = info.argumentIndex, argumentCount = info.argumentCount, argumentsSpan = info.argumentsSpan;
@@ -141174,7 +141237,7 @@ var ts;
             var invocation = { kind: 2 /* Contextual */, signature: ts.first(signatures), node: startingToken, symbol: chooseBetterSymbol(nonNullableContextualType.symbol) };
             return { isTypeParameterList: false, invocation: invocation, argumentsSpan: argumentsSpan, argumentIndex: argumentIndex, argumentCount: argumentCount };
         }
-        function getContextualSignatureLocationInfo(startingToken, sourceFile, checker) {
+        function getContextualSignatureLocationInfo(startingToken, sourceFile, position, checker) {
             if (startingToken.kind !== 20 /* OpenParenToken */ && startingToken.kind !== 27 /* CommaToken */)
                 return undefined;
             var parent = startingToken.parent;
@@ -141183,7 +141246,7 @@ var ts;
                 case 168 /* MethodDeclaration */:
                 case 212 /* FunctionExpression */:
                 case 213 /* ArrowFunction */:
-                    var info = getArgumentOrParameterListInfo(startingToken, sourceFile);
+                    var info = getArgumentOrParameterListInfo(startingToken, position, sourceFile);
                     if (!info)
                         return undefined;
                     var argumentIndex = info.argumentIndex, argumentCount = info.argumentCount, argumentsSpan = info.argumentsSpan;
@@ -141230,7 +141293,7 @@ var ts;
             }
             return argumentIndex;
         }
-        function getArgumentCount(argumentsList) {
+        function getArgumentCount(argumentsList, ignoreTrailingComma) {
             // The argument count for a list is normally the number of non-comma children it has.
             // For example, if you have "Foo(a,b)" then there will be three children of the arg
             // list 'a' '<comma>' 'b'.  So, in this case the arg count will be 2.  However, there
@@ -141244,7 +141307,7 @@ var ts;
             // arg count of 3.
             var listChildren = argumentsList.getChildren();
             var argumentCount = ts.countWhere(listChildren, function (arg) { return arg.kind !== 27 /* CommaToken */; });
-            if (listChildren.length > 0 && ts.last(listChildren).kind === 27 /* CommaToken */) {
+            if (!ignoreTrailingComma && listChildren.length > 0 && ts.last(listChildren).kind === 27 /* CommaToken */) {
                 argumentCount++;
             }
             return argumentCount;
@@ -156243,51 +156306,53 @@ var ts;
 (function (ts) {
     var refactor;
     (function (refactor) {
+        var _a;
         var refactorName = "Convert import";
-        var namespaceToNamedAction = {
-            name: "Convert namespace import to named imports",
-            description: ts.Diagnostics.Convert_namespace_import_to_named_imports.message,
-            kind: "refactor.rewrite.import.named",
-        };
-        var namedToNamespaceAction = {
-            name: "Convert named imports to namespace import",
-            description: ts.Diagnostics.Convert_named_imports_to_namespace_import.message,
-            kind: "refactor.rewrite.import.namespace",
-        };
+        var actions = (_a = {},
+            _a[0 /* Named */] = {
+                name: "Convert namespace import to named imports",
+                description: ts.Diagnostics.Convert_namespace_import_to_named_imports.message,
+                kind: "refactor.rewrite.import.named",
+            },
+            _a[2 /* Namespace */] = {
+                name: "Convert named imports to namespace import",
+                description: ts.Diagnostics.Convert_named_imports_to_namespace_import.message,
+                kind: "refactor.rewrite.import.namespace",
+            },
+            _a[1 /* Default */] = {
+                name: "Convert named imports to default import",
+                description: ts.Diagnostics.Convert_named_imports_to_default_import.message,
+                kind: "refactor.rewrite.import.default",
+            },
+            _a);
         refactor.registerRefactor(refactorName, {
-            kinds: [
-                namespaceToNamedAction.kind,
-                namedToNamespaceAction.kind
-            ],
+            kinds: ts.getOwnValues(actions).map(function (a) { return a.kind; }),
             getAvailableActions: function getRefactorActionsToConvertBetweenNamedAndNamespacedImports(context) {
-                var info = getImportToConvert(context, context.triggerReason === "invoked");
+                var info = getImportConversionInfo(context, context.triggerReason === "invoked");
                 if (!info)
                     return ts.emptyArray;
                 if (!refactor.isRefactorErrorInfo(info)) {
-                    var namespaceImport = info.kind === 267 /* NamespaceImport */;
-                    var action = namespaceImport ? namespaceToNamedAction : namedToNamespaceAction;
+                    var action = actions[info.convertTo];
                     return [{ name: refactorName, description: action.description, actions: [action] }];
                 }
                 if (context.preferences.provideRefactorNotApplicableReason) {
-                    return [
-                        { name: refactorName, description: namespaceToNamedAction.description,
-                            actions: [__assign(__assign({}, namespaceToNamedAction), { notApplicableReason: info.error })] },
-                        { name: refactorName, description: namedToNamespaceAction.description,
-                            actions: [__assign(__assign({}, namedToNamespaceAction), { notApplicableReason: info.error })] }
-                    ];
+                    return ts.getOwnValues(actions).map(function (action) { return ({
+                        name: refactorName,
+                        description: action.description,
+                        actions: [__assign(__assign({}, action), { notApplicableReason: info.error })]
+                    }); });
                 }
                 return ts.emptyArray;
             },
             getEditsForAction: function getRefactorEditsToConvertBetweenNamedAndNamespacedImports(context, actionName) {
-                ts.Debug.assert(actionName === namespaceToNamedAction.name || actionName === namedToNamespaceAction.name, "Unexpected action name");
-                var info = getImportToConvert(context);
+                ts.Debug.assert(ts.some(ts.getOwnValues(actions), function (action) { return action.name === actionName; }), "Unexpected action name");
+                var info = getImportConversionInfo(context);
                 ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info");
                 var edits = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(context.file, context.program, t, info); });
                 return { edits: edits, renameFilename: undefined, renameLocation: undefined };
             }
         });
-        // Can convert imports of the form `import * as m from "m";` or `import d, { x, y } from "m";`.
-        function getImportToConvert(context, considerPartialSpans) {
+        function getImportConversionInfo(context, considerPartialSpans) {
             if (considerPartialSpans === void 0) { considerPartialSpans = true; }
             var file = context.file;
             var span = ts.getRefactorContextSpan(context);
@@ -156306,15 +156371,23 @@ var ts;
             if (!importClause.namedBindings) {
                 return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_find_namespace_import_or_named_imports) };
             }
-            return importClause.namedBindings;
+            if (importClause.namedBindings.kind === 267 /* NamespaceImport */) {
+                return { convertTo: 0 /* Named */, import: importClause.namedBindings };
+            }
+            var compilerOptions = context.program.getCompilerOptions();
+            var shouldUseDefault = ts.getAllowSyntheticDefaultImports(compilerOptions)
+                && isExportEqualsModule(importClause.parent.moduleSpecifier, context.program.getTypeChecker());
+            return shouldUseDefault
+                ? { convertTo: 1 /* Default */, import: importClause.namedBindings }
+                : { convertTo: 2 /* Namespace */, import: importClause.namedBindings };
         }
-        function doChange(sourceFile, program, changes, toConvert) {
+        function doChange(sourceFile, program, changes, info) {
             var checker = program.getTypeChecker();
-            if (toConvert.kind === 267 /* NamespaceImport */) {
-                doChangeNamespaceToNamed(sourceFile, checker, changes, toConvert, ts.getAllowSyntheticDefaultImports(program.getCompilerOptions()));
+            if (info.convertTo === 0 /* Named */) {
+                doChangeNamespaceToNamed(sourceFile, checker, changes, info.import, ts.getAllowSyntheticDefaultImports(program.getCompilerOptions()));
             }
             else {
-                doChangeNamedToNamespace(sourceFile, checker, changes, toConvert);
+                doChangeNamedToNamespaceOrDefault(sourceFile, checker, changes, info.import, info.convertTo === 1 /* Default */);
             }
         }
         function doChangeNamespaceToNamed(sourceFile, checker, changes, toConvert, allowSyntheticDefaultImports) {
@@ -156364,7 +156437,7 @@ var ts;
         function getLeftOfPropertyAccessOrQualifiedName(propertyAccessOrQualifiedName) {
             return ts.isPropertyAccessExpression(propertyAccessOrQualifiedName) ? propertyAccessOrQualifiedName.expression : propertyAccessOrQualifiedName.left;
         }
-        function doChangeNamedToNamespace(sourceFile, checker, changes, toConvert) {
+        function doChangeNamedToNamespaceOrDefault(sourceFile, checker, changes, toConvert, shouldUseDefault) {
             var importDecl = toConvert.parent.parent;
             var moduleSpecifier = importDecl.moduleSpecifier;
             var toConvertSymbols = new ts.Set();
@@ -156415,7 +156488,9 @@ var ts;
                 var element = _a[_i];
                 _loop_17(element);
             }
-            changes.replaceNode(sourceFile, toConvert, ts.factory.createNamespaceImport(ts.factory.createIdentifier(namespaceImportName)));
+            changes.replaceNode(sourceFile, toConvert, shouldUseDefault
+                ? ts.factory.createIdentifier(namespaceImportName)
+                : ts.factory.createNamespaceImport(ts.factory.createIdentifier(namespaceImportName)));
             if (neededNamedImports.size) {
                 var newNamedImports = ts.arrayFrom(neededNamedImports.values()).map(function (element) {
                     return ts.factory.createImportSpecifier(element.isTypeOnly, element.propertyName && ts.factory.createIdentifier(element.propertyName.text), ts.factory.createIdentifier(element.name.text));
@@ -156423,6 +156498,13 @@ var ts;
                 changes.insertNodeAfter(sourceFile, toConvert.parent.parent, updateImport(importDecl, /*defaultImportName*/ undefined, newNamedImports));
             }
         }
+        function isExportEqualsModule(moduleSpecifier, checker) {
+            var externalModule = checker.resolveExternalModuleName(moduleSpecifier);
+            if (!externalModule)
+                return false;
+            var exportEquals = checker.resolveExternalModuleSymbol(externalModule);
+            return externalModule !== exportEquals;
+        }
         function updateImport(old, defaultImportName, elements) {
             return ts.factory.createImportDeclaration(/*decorators*/ undefined, /*modifiers*/ undefined, ts.factory.createImportClause(/*isTypeOnly*/ false, defaultImportName, elements && elements.length ? ts.factory.createNamedImports(elements) : undefined), old.moduleSpecifier, /*assertClause*/ undefined);
         }