typescript 4.6.0-dev.20220126 → 4.6.0-dev.20220127

package/lib/typescriptServices.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.20220126";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220127";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -9667,6 +9667,8 @@ var ts;
         Remove_unused_declarations_for_Colon_0: diag(90041, ts.DiagnosticCategory.Message, "Remove_unused_declarations_for_Colon_0_90041", "Remove unused declarations for: '{0}'"),
         Declare_a_private_field_named_0: diag(90053, ts.DiagnosticCategory.Message, "Declare_a_private_field_named_0_90053", "Declare a private field named '{0}'."),
         Includes_imports_of_types_referenced_by_0: diag(90054, ts.DiagnosticCategory.Message, "Includes_imports_of_types_referenced_by_0_90054", "Includes imports of types referenced by '{0}'"),
+        Remove_type_from_import_declaration_from_0: diag(90055, ts.DiagnosticCategory.Message, "Remove_type_from_import_declaration_from_0_90055", "Remove 'type' from import declaration from \"{0}\""),
+        Remove_type_from_import_of_0_from_1: diag(90056, ts.DiagnosticCategory.Message, "Remove_type_from_import_of_0_from_1_90056", "Remove 'type' from import of '{0}' from \"{1}\""),
         Convert_function_to_an_ES2015_class: diag(95001, ts.DiagnosticCategory.Message, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"),
         Convert_0_to_1_in_0: diag(95003, ts.DiagnosticCategory.Message, "Convert_0_to_1_in_0_95003", "Convert '{0}' to '{1} in {0}'"),
         Extract_to_0_in_1: diag(95004, ts.DiagnosticCategory.Message, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"),
@@ -15096,6 +15098,15 @@ var ts;
         };
     }
     ts.createDiagnosticForFileFromMessageChain = createDiagnosticForFileFromMessageChain;
+    function createDiagnosticMessageChainFromDiagnostic(diagnostic) {
+        return typeof diagnostic.messageText === "string" ? {
+            code: diagnostic.code,
+            category: diagnostic.category,
+            messageText: diagnostic.messageText,
+            next: diagnostic.next,
+        } : diagnostic.messageText;
+    }
+    ts.createDiagnosticMessageChainFromDiagnostic = createDiagnosticMessageChainFromDiagnostic;
     function createDiagnosticForRange(sourceFile, range, message) {
         return {
             file: sourceFile,
@@ -52729,7 +52740,8 @@ var ts;
                         includePrivateSymbol === null || includePrivateSymbol === void 0 ? void 0 : includePrivateSymbol(sym);
                     }
                     if (ts.isIdentifier(node)) {
-                        var name = sym.flags & 262144 /* TypeParameter */ ? typeParameterToName(getDeclaredTypeOfSymbol(sym), context) : ts.factory.cloneNode(node);
+                        var type = getDeclaredTypeOfSymbol(sym);
+                        var name = sym.flags & 262144 /* TypeParameter */ && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration) ? typeParameterToName(type, context) : ts.factory.cloneNode(node);
                         name.symbol = sym; // for quickinfo, which uses identifier symbol information
                         return { introducesError: introducesError, node: ts.setEmitFlags(ts.setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */) };
                     }
@@ -74621,7 +74633,7 @@ var ts;
                         }
                         var diags_3 = max > 1 ? allDiagnostics[minIndex] : ts.flatten(allDiagnostics);
                         ts.Debug.assert(diags_3.length > 0, "No errors reported for 3 or fewer overload signatures");
-                        var chain = ts.chainDiagnosticMessages(ts.map(diags_3, function (d) { return typeof d.messageText === "string" ? d : d.messageText; }), ts.Diagnostics.No_overload_matches_this_call);
+                        var chain = ts.chainDiagnosticMessages(ts.map(diags_3, ts.createDiagnosticMessageChainFromDiagnostic), ts.Diagnostics.No_overload_matches_this_call);
                         // The below is a spread to guarantee we get a new (mutable) array - our `flatMap` helper tries to do "smart" optimizations where it reuses input
                         // arrays and the emptyArray singleton where possible, which is decidedly not what we want while we're still constructing this diagnostic
                         var related = __spreadArray([], ts.flatMap(diags_3, function (d) { return d.relatedInformation; }), true);
@@ -83000,16 +83012,15 @@ var ts;
                         return ts.nodeIsMissing(expr) ? 0 : evaluateEnumMember(expr, getSymbolOfNode(member.parent), identifier.escapedText);
                     case 206 /* ElementAccessExpression */:
                     case 205 /* PropertyAccessExpression */:
-                        var ex = expr;
-                        if (isConstantMemberAccess(ex)) {
-                            var type = getTypeOfExpression(ex.expression);
+                        if (isConstantMemberAccess(expr)) {
+                            var type = getTypeOfExpression(expr.expression);
                             if (type.symbol && type.symbol.flags & 384 /* Enum */) {
                                 var name = void 0;
-                                if (ex.kind === 205 /* PropertyAccessExpression */) {
-                                    name = ex.name.escapedText;
+                                if (expr.kind === 205 /* PropertyAccessExpression */) {
+                                    name = expr.name.escapedText;
                                 }
                                 else {
-                                    name = ts.escapeLeadingUnderscores(ts.cast(ex.argumentExpression, ts.isLiteralExpression).text);
+                                    name = ts.escapeLeadingUnderscores(ts.cast(expr.argumentExpression, ts.isLiteralExpression).text);
                                 }
                                 return evaluateEnumMember(expr, type.symbol, name);
                             }
@@ -83037,6 +83048,10 @@ var ts;
             }
         }
         function isConstantMemberAccess(node) {
+            var type = getTypeOfExpression(node);
+            if (type === errorType) {
+                return false;
+            }
             return node.kind === 79 /* Identifier */ ||
                 node.kind === 205 /* PropertyAccessExpression */ && isConstantMemberAccess(node.expression) ||
                 node.kind === 206 /* ElementAccessExpression */ && isConstantMemberAccess(node.expression) &&
@@ -127167,11 +127182,11 @@ var ts;
         return ts.isArray(valueOrArray) ? ts.first(valueOrArray) : valueOrArray;
     }
     ts.firstOrOnly = firstOrOnly;
-    function getNameForExportedSymbol(symbol, scriptTarget) {
+    function getNameForExportedSymbol(symbol, scriptTarget, preferCapitalized) {
         if (!(symbol.flags & 33554432 /* Transient */) && (symbol.escapedName === "export=" /* ExportEquals */ || symbol.escapedName === "default" /* Default */)) {
             // 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; })
-                || ts.codefix.moduleSymbolToValidIdentifier(getSymbolParentOrFail(symbol), scriptTarget);
+                || ts.codefix.moduleSymbolToValidIdentifier(getSymbolParentOrFail(symbol), scriptTarget, !!preferCapitalized);
         }
         return symbol.name;
     }
@@ -127299,7 +127314,7 @@ var ts;
                 symbols.clear();
                 usableByFileName = undefined;
             },
-            add: function (importingFile, symbol, symbolTableKey, moduleSymbol, moduleFile, exportKind, isFromPackageJson, scriptTarget, checker) {
+            add: function (importingFile, symbol, symbolTableKey, moduleSymbol, moduleFile, exportKind, isFromPackageJson, checker) {
                 if (importingFile !== usableByFileName) {
                     cache.clear();
                     usableByFileName = importingFile;
@@ -127315,7 +127330,7 @@ var ts;
                 //    get a better name.
                 var importedName = exportKind === 0 /* Named */ || ts.isExternalModuleSymbol(namedSymbol)
                     ? ts.unescapeLeadingUnderscores(symbolTableKey)
-                    : ts.getNameForExportedSymbol(namedSymbol, scriptTarget);
+                    : ts.getNameForExportedSymbol(namedSymbol, /*scriptTarget*/ undefined);
                 var moduleName = ts.stripQuotes(moduleSymbol.name);
                 var id = exportInfoId++;
                 var target = ts.skipAlias(symbol, checker);
@@ -127348,7 +127363,14 @@ var ts;
                     return;
                 exportInfo.forEach(function (info, key) {
                     var _a = parseKey(key), symbolName = _a.symbolName, ambientModuleName = _a.ambientModuleName;
-                    action(info.map(rehydrateCachedInfo), symbolName, !!ambientModuleName, key);
+                    var rehydrated = info.map(rehydrateCachedInfo);
+                    action(rehydrated, 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);
                 });
             },
             releaseSymbols: function () {
@@ -127530,7 +127552,6 @@ var ts;
         }
         (_d = host.log) === null || _d === void 0 ? void 0 : _d.call(host, "getExportInfoMap: cache miss or empty; calculating new results");
         var compilerOptions = program.getCompilerOptions();
-        var scriptTarget = ts.getEmitScriptTarget(compilerOptions);
         var moduleCount = 0;
         forEachExternalModuleToImportFrom(program, host, /*useAutoImportProvider*/ true, function (moduleSymbol, moduleFile, program, isFromPackageJson) {
             if (++moduleCount % 100 === 0)
@@ -127541,11 +127562,11 @@ var ts;
             // Note: I think we shouldn't actually see resolved module symbols here, but weird merges
             // can cause it to happen: see 'completionsImport_mergedReExport.ts'
             if (defaultInfo && isImportableSymbol(defaultInfo.symbol, checker)) {
-                cache.add(importingFile.path, defaultInfo.symbol, defaultInfo.exportKind === 1 /* Default */ ? "default" /* Default */ : "export=" /* ExportEquals */, moduleSymbol, moduleFile, defaultInfo.exportKind, isFromPackageJson, scriptTarget, checker);
+                cache.add(importingFile.path, defaultInfo.symbol, defaultInfo.exportKind === 1 /* Default */ ? "default" /* Default */ : "export=" /* ExportEquals */, moduleSymbol, moduleFile, defaultInfo.exportKind, isFromPackageJson, checker);
             }
             checker.forEachExportAndPropertyOfModule(moduleSymbol, function (exported, key) {
                 if (exported !== (defaultInfo === null || defaultInfo === void 0 ? void 0 : defaultInfo.symbol) && isImportableSymbol(exported, checker) && ts.addToSeen(seenExports, key)) {
-                    cache.add(importingFile.path, exported, key, moduleSymbol, moduleFile, 0 /* Named */, isFromPackageJson, scriptTarget, checker);
+                    cache.add(importingFile.path, exported, key, moduleSymbol, moduleFile, 0 /* Named */, isFromPackageJson, checker);
                 }
             });
         });
@@ -129619,6 +129640,8 @@ var ts;
             CompletionSource["ThisProperty"] = "ThisProperty/";
             /** Auto-import that comes attached to a class member snippet */
             CompletionSource["ClassMemberSnippet"] = "ClassMemberSnippet/";
+            /** A type-only import that needs to be promoted in order to be used at the completion location */
+            CompletionSource["TypeOnlyAlias"] = "TypeOnlyAlias/";
         })(CompletionSource = Completions.CompletionSource || (Completions.CompletionSource = {}));
         var SymbolOriginInfoKind;
         (function (SymbolOriginInfoKind) {
@@ -129628,6 +129651,7 @@ var ts;
             SymbolOriginInfoKind[SymbolOriginInfoKind["Promise"] = 8] = "Promise";
             SymbolOriginInfoKind[SymbolOriginInfoKind["Nullable"] = 16] = "Nullable";
             SymbolOriginInfoKind[SymbolOriginInfoKind["ResolvedExport"] = 32] = "ResolvedExport";
+            SymbolOriginInfoKind[SymbolOriginInfoKind["TypeOnlyAlias"] = 64] = "TypeOnlyAlias";
             SymbolOriginInfoKind[SymbolOriginInfoKind["SymbolMemberNoExport"] = 2] = "SymbolMemberNoExport";
             SymbolOriginInfoKind[SymbolOriginInfoKind["SymbolMemberExport"] = 6] = "SymbolMemberExport";
         })(SymbolOriginInfoKind || (SymbolOriginInfoKind = {}));
@@ -129655,6 +129679,9 @@ var ts;
         function originIsNullableMember(origin) {
             return !!(origin.kind & 16 /* Nullable */);
         }
+        function originIsTypeOnlyAlias(origin) {
+            return !!(origin && origin.kind & 64 /* TypeOnlyAlias */);
+        }
         var KeywordCompletionFilters;
         (function (KeywordCompletionFilters) {
             KeywordCompletionFilters[KeywordCompletionFilters["None"] = 0] = "None";
@@ -130059,6 +130086,9 @@ var ts;
                     isSnippet = preferences.includeCompletionsWithSnippetText ? true : undefined;
                 }
             }
+            if ((origin === null || origin === void 0 ? void 0 : origin.kind) === 64 /* TypeOnlyAlias */) {
+                hasAction = true;
+            }
             if (preferences.includeCompletionsWithClassMemberSnippets &&
                 preferences.includeCompletionsWithInsertText &&
                 completionKind === 3 /* MemberLike */ &&
@@ -130403,6 +130433,9 @@ var ts;
             if ((origin === null || origin === void 0 ? void 0 : origin.kind) === 1 /* ThisType */) {
                 return CompletionSource.ThisProperty;
             }
+            if ((origin === null || origin === void 0 ? void 0 : origin.kind) === 64 /* TypeOnlyAlias */) {
+                return CompletionSource.TypeOnlyAlias;
+            }
         }
         function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, sourceFile, host, program, target, log, kind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap, isJsxIdentifierExpected, isRightOfOpenTag) {
             var _a;
@@ -130430,7 +130463,7 @@ var ts;
                     continue;
                 }
                 /** True for locals; false for globals, module exports from other files, `this.` completions. */
-                var shouldShadowLaterSymbols = !origin && !(symbol.parent === undefined && !ts.some(symbol.declarations, function (d) { return d.getSourceFile() === location.getSourceFile(); }));
+                var shouldShadowLaterSymbols = (!origin || originIsTypeOnlyAlias(origin)) && !(symbol.parent === undefined && !ts.some(symbol.declarations, function (d) { return d.getSourceFile() === location.getSourceFile(); }));
                 uniques.set(name, shouldShadowLaterSymbols);
                 ts.insertSorted(entries, entry, compareCompletionEntries, /*allowDuplicates*/ true);
             }
@@ -130443,6 +130476,7 @@ var ts;
                 add: function (name) { return uniques.set(name, true); },
             };
             function shouldIncludeSymbol(symbol, symbolToSortTextIdMap) {
+                var allFlags = symbol.flags;
                 if (!ts.isSourceFile(location)) {
                     // export = /**/ here we want to get all meanings, so any symbol is ok
                     if (ts.isExportAssignment(location.parent)) {
@@ -130468,11 +130502,10 @@ var ts;
                             || symbolToSortTextIdMap[ts.getSymbolId(symbolOrigin)] === 11 /* LocationPriority */)) {
                         return false;
                     }
-                    // Continue with origin symbol
-                    symbol = symbolOrigin;
+                    allFlags |= ts.getCombinedLocalAndExportSymbolFlags(symbolOrigin);
                     // import m = /**/ <-- It can only access namespace (if typing import = x. this would get member symbols and not namespace)
                     if (ts.isInRightSideOfInternalImportEqualsDeclaration(location)) {
-                        return !!(symbol.flags & 1920 /* Namespace */);
+                        return !!(allFlags & 1920 /* Namespace */);
                     }
                     if (isTypeOnlyLocation) {
                         // It's a type, but you can reach it by namespace.type as well
@@ -130480,7 +130513,7 @@ var ts;
                     }
                 }
                 // expressions are value space (which includes the value namespaces)
-                return !!(ts.getCombinedLocalAndExportSymbolFlags(symbol) & 111551 /* Value */);
+                return !!(allFlags & 111551 /* Value */);
             }
         }
         Completions.getCompletionEntriesFromSymbols = getCompletionEntriesFromSymbols;
@@ -130614,8 +130647,7 @@ var ts;
         Completions.createCompletionDetails = createCompletionDetails;
         function getCompletionEntryCodeActionsAndSourceDisplay(name, location, contextToken, origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken, formatContext, preferences, data, source) {
             if (data === null || data === void 0 ? void 0 : data.moduleSpecifier) {
-                var _a = getRelevantTokens(position, sourceFile), contextToken_3 = _a.contextToken, previousToken_2 = _a.previousToken;
-                if (previousToken_2 && getImportStatementCompletionInfo(contextToken_3 || previousToken_2).replacementNode) {
+                if (previousToken && getImportStatementCompletionInfo(contextToken || previousToken).replacementNode) {
                     // Import statement completion: 'import c|'
                     return { codeActions: undefined, sourceDisplay: [ts.textPart(data.moduleSpecifier)] };
                 }
@@ -130633,13 +130665,19 @@ var ts;
                     };
                 }
             }
+            if (originIsTypeOnlyAlias(origin)) {
+                var codeAction_1 = ts.codefix.getPromoteTypeOnlyCompletionAction(sourceFile, origin.declaration.name, program, host, formatContext, preferences);
+                ts.Debug.assertIsDefined(codeAction_1, "Expected to have a code action for promoting type-only alias");
+                return { codeActions: [codeAction_1], sourceDisplay: undefined };
+            }
             if (!origin || !(originIsExport(origin) || originIsResolvedExport(origin))) {
                 return { codeActions: undefined, sourceDisplay: undefined };
             }
             var checker = origin.isFromPackageJson ? host.getPackageJsonAutoImportProvider().getTypeChecker() : program.getTypeChecker();
             var moduleSymbol = origin.moduleSymbol;
             var targetSymbol = checker.getMergedSymbol(ts.skipAlias(symbol.exportSymbol || symbol, checker));
-            var _b = ts.codefix.getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, ts.getNameForExportedSymbol(symbol, ts.getEmitScriptTarget(compilerOptions)), host, program, formatContext, previousToken && ts.isIdentifier(previousToken) ? previousToken.getStart(sourceFile) : position, preferences), moduleSpecifier = _b.moduleSpecifier, codeAction = _b.codeAction;
+            var isJsxOpeningTagName = (contextToken === null || contextToken === void 0 ? void 0 : contextToken.kind) === 29 /* LessThanToken */ && ts.isJsxOpeningLikeElement(contextToken.parent);
+            var _a = ts.codefix.getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, ts.getNameForExportedSymbol(symbol, ts.getEmitScriptTarget(compilerOptions), isJsxOpeningTagName), isJsxOpeningTagName, host, program, formatContext, previousToken && ts.isIdentifier(previousToken) ? previousToken.getStart(sourceFile) : position, preferences), moduleSpecifier = _a.moduleSpecifier, codeAction = _a.codeAction;
             ts.Debug.assert(!(data === null || data === void 0 ? void 0 : data.moduleSpecifier) || moduleSpecifier === data.moduleSpecifier);
             return { sourceDisplay: [ts.textPart(moduleSpecifier)], codeActions: [codeAction] };
         }
@@ -131309,21 +131347,29 @@ var ts;
                 var scopeNode = getScopeNode(contextToken, adjustedPosition, sourceFile) || sourceFile;
                 isInSnippetScope = isSnippetScope(scopeNode);
                 var symbolMeanings = (isTypeOnlyLocation ? 0 /* None */ : 111551 /* Value */) | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */;
+                var typeOnlyAliasNeedsPromotion = previousToken && !ts.isValidTypeOnlyAliasUseSite(previousToken);
                 symbols = ts.concatenate(symbols, typeChecker.getSymbolsInScope(scopeNode, symbolMeanings));
                 ts.Debug.assertEachIsDefined(symbols, "getSymbolsInScope() should all be defined");
-                for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {
-                    var symbol = symbols_1[_i];
+                for (var i = 0; i < symbols.length; i++) {
+                    var symbol = symbols[i];
                     if (!typeChecker.isArgumentsSymbol(symbol) &&
                         !ts.some(symbol.declarations, function (d) { return d.getSourceFile() === sourceFile; })) {
                         symbolToSortTextIdMap[ts.getSymbolId(symbol)] = 15 /* GlobalsOrKeywords */;
                     }
+                    if (typeOnlyAliasNeedsPromotion && !(symbol.flags & 111551 /* Value */)) {
+                        var typeOnlyAliasDeclaration = symbol.declarations && ts.find(symbol.declarations, ts.isTypeOnlyImportOrExportDeclaration);
+                        if (typeOnlyAliasDeclaration) {
+                            var origin = { kind: 64 /* TypeOnlyAlias */, declaration: typeOnlyAliasDeclaration };
+                            symbolToOriginInfoMap[i] = origin;
+                        }
+                    }
                 }
                 // Need to insert 'this.' before properties of `this` type, so only do that if `includeInsertTextCompletions`
                 if (preferences.includeCompletionsWithInsertText && scopeNode.kind !== 303 /* SourceFile */) {
                     var thisType = typeChecker.tryGetThisTypeAt(scopeNode, /*includeGlobalThis*/ false);
                     if (thisType && !isProbablyGlobalType(thisType, sourceFile, typeChecker)) {
-                        for (var _a = 0, _b = getPropertiesForCompletion(thisType, typeChecker); _a < _b.length; _a++) {
-                            var symbol = _b[_a];
+                        for (var _i = 0, _a = getPropertiesForCompletion(thisType, typeChecker); _i < _a.length; _i++) {
+                            var symbol = _a[_i];
                             symbolToOriginInfoMap[symbols.length] = { kind: 1 /* ThisType */ };
                             symbols.push(symbol);
                             symbolToSortTextIdMap[ts.getSymbolId(symbol)] = 14 /* SuggestedClassMembers */;
@@ -131426,7 +131472,8 @@ 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, symbolName, isFromAmbientModule, exportMapKey) {
+                    exportInfo.forEach(sourceFile.path, function (info, getSymbolName, isFromAmbientModule, exportMapKey) {
+                        var symbolName = getSymbolName(/*preferCapitalized*/ isRightOfOpenTag);
                         if (!ts.isIdentifierText(symbolName, ts.getEmitScriptTarget(host.getCompilationSettings())))
                             return;
                         if (!detailsEntryId && ts.isStringANonContextualKeyword(symbolName))
@@ -131436,6 +131483,10 @@ var ts;
                             return;
                         if (isTypeOnlyLocation && !(info[0].targetFlags & (1536 /* Module */ | 788968 /* Type */)))
                             return;
+                        // 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;
                         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);
@@ -131512,16 +131563,19 @@ var ts;
                     return true;
                 }
                 if (contextToken.kind === 31 /* GreaterThanToken */ && contextToken.parent) {
+                    // <Component<string> /**/ />
+                    // <Component<string> /**/ ><Component>
+                    // - contextToken: GreaterThanToken (before cursor)
+                    // - location: JsxSelfClosingElement or JsxOpeningElement
+                    // - contextToken.parent === location
+                    if (location === contextToken.parent && (location.kind === 279 /* JsxOpeningElement */ || location.kind === 278 /* JsxSelfClosingElement */)) {
+                        return false;
+                    }
                     if (contextToken.parent.kind === 279 /* JsxOpeningElement */) {
-                        // Two possibilities:
-                        //   1. <div>/**/
-                        //      - contextToken: GreaterThanToken (before cursor)
-                        //      - location: JSXElement
-                        //      - different parents (JSXOpeningElement, JSXElement)
-                        //   2. <Component<string> /**/>
-                        //      - contextToken: GreaterThanToken (before cursor)
-                        //      - location: GreaterThanToken (after cursor)
-                        //      - same parent (JSXOpeningElement)
+                        // <div>/**/
+                        // - contextToken: GreaterThanToken (before cursor)
+                        // - location: JSXElement
+                        // - different parents (JSXOpeningElement, JSXElement)
                         return location.parent.kind !== 279 /* JsxOpeningElement */;
                     }
                     if (contextToken.parent.kind === 280 /* JsxClosingElement */ || contextToken.parent.kind === 278 /* JsxSelfClosingElement */) {
@@ -132722,10 +132776,14 @@ var ts;
         /** True if symbol is a type or a module containing at least one type. */
         function symbolCanBeReferencedAtTypeLocation(symbol, checker, seenModules) {
             if (seenModules === void 0) { seenModules = new ts.Map(); }
-            var sym = ts.skipAlias(symbol.exportSymbol || symbol, checker);
-            return !!(sym.flags & 788968 /* Type */) || checker.isUnknownSymbol(sym) ||
-                !!(sym.flags & 1536 /* Module */) && ts.addToSeen(seenModules, ts.getSymbolId(sym)) &&
-                    checker.getExportsOfModule(sym).some(function (e) { return symbolCanBeReferencedAtTypeLocation(e, checker, seenModules); });
+            // Since an alias can be merged with a local declaration, we need to test both the alias and its target.
+            // This code used to just test the result of `skipAlias`, but that would ignore any locally introduced meanings.
+            return nonAliasCanBeReferencedAtTypeLocation(symbol) || nonAliasCanBeReferencedAtTypeLocation(ts.skipAlias(symbol.exportSymbol || symbol, checker));
+            function nonAliasCanBeReferencedAtTypeLocation(symbol) {
+                return !!(symbol.flags & 788968 /* Type */) || checker.isUnknownSymbol(symbol) ||
+                    !!(symbol.flags & 1536 /* Module */) && ts.addToSeen(seenModules, ts.getSymbolId(symbol)) &&
+                        checker.getExportsOfModule(symbol).some(function (e) { return symbolCanBeReferencedAtTypeLocation(e, checker, seenModules); });
+            }
         }
         function isDeprecated(symbol, checker) {
             var declarations = ts.skipAlias(symbol, checker).declarations;
@@ -134979,8 +135037,8 @@ var ts;
                     var sourceId = ts.getNodeId(sourceFile);
                     var seenSymbols = this.sourceFileToSeenSymbols[sourceId] || (this.sourceFileToSeenSymbols[sourceId] = new ts.Set());
                     var anyNewSymbols = false;
-                    for (var _i = 0, symbols_2 = symbols; _i < symbols_2.length; _i++) {
-                        var sym = symbols_2[_i];
+                    for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {
+                        var sym = symbols_1[_i];
                         anyNewSymbols = ts.tryAddToSet(seenSymbols, ts.getSymbolId(sym)) || anyNewSymbols;
                     }
                     return anyNewSymbols;
@@ -145851,6 +145909,7 @@ var ts;
             ChangeTracker.prototype.delete = function (sourceFile, node) {
                 this.deletedNodes.push({ sourceFile: sourceFile, node: node });
             };
+            /** Stop! Consider using `delete` instead, which has logic for deleting nodes from delimited lists. */
             ChangeTracker.prototype.deleteNode = function (sourceFile, node, options) {
                 if (options === void 0) { options = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }; }
                 this.deleteRange(sourceFile, getAdjustedRange(sourceFile, node, node, options));
@@ -146254,6 +146313,15 @@ var ts;
             ChangeTracker.prototype.insertExportModifier = function (sourceFile, node) {
                 this.insertText(sourceFile, node.getStart(sourceFile), "export ");
             };
+            ChangeTracker.prototype.insertImportSpecifierAtIndex = function (sourceFile, importSpecifier, namedImports, index) {
+                var prevSpecifier = namedImports.elements[index - 1];
+                if (prevSpecifier) {
+                    this.insertNodeInListAfter(sourceFile, prevSpecifier, importSpecifier);
+                }
+                else {
+                    this.insertNodeBefore(sourceFile, namedImports.elements[0], importSpecifier, !ts.positionsAreOnSameLine(namedImports.elements[0].getStart(), namedImports.parent.parent.getStart(), sourceFile));
+                }
+            };
             /**
              * This function should be used to insert nodes in lists when nodes don't carry separators as the part of the node range,
              * i.e. arguments in arguments lists, parameters in parameter lists etc.
@@ -149756,7 +149824,8 @@ var ts;
             ts.Diagnostics.Cannot_find_namespace_0.code,
             ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code,
             ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here.code,
-            ts.Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer.code
+            ts.Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer.code,
+            ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type.code,
         ];
         codefix.registerCodeFix({
             errorCodes: errorCodes,
@@ -149802,7 +149871,7 @@ var ts;
                 var symbolName = ts.getNameForExportedSymbol(exportedSymbol, ts.getEmitScriptTarget(compilerOptions));
                 var checker = program.getTypeChecker();
                 var symbol = checker.getMergedSymbol(ts.skipAlias(exportedSymbol, checker));
-                var exportInfos = getAllReExportingModules(sourceFile, symbol, moduleSymbol, symbolName, host, program, preferences, useAutoImportProvider);
+                var exportInfos = getAllReExportingModules(sourceFile, symbol, moduleSymbol, symbolName, /*isJsxTagName*/ false, host, program, preferences, useAutoImportProvider);
                 var useRequire = shouldUseRequire(sourceFile, program);
                 var fix = getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, /*position*/ undefined, !!isValidTypeOnlyUseSite, useRequire, host, preferences);
                 if (fix) {
@@ -149861,6 +149930,9 @@ var ts;
                         }
                         break;
                     }
+                    case 4 /* PromoteTypeOnly */:
+                        // Excluding from fix-all
+                        break;
                     default:
                         ts.Debug.assertNever(fix, "fix wasn't never - got kind " + fix.kind);
                 }
@@ -149952,6 +150024,7 @@ var ts;
             ImportFixKind[ImportFixKind["JsdocTypeImport"] = 1] = "JsdocTypeImport";
             ImportFixKind[ImportFixKind["AddToExisting"] = 2] = "AddToExisting";
             ImportFixKind[ImportFixKind["AddNew"] = 3] = "AddNew";
+            ImportFixKind[ImportFixKind["PromoteTypeOnly"] = 4] = "PromoteTypeOnly";
         })(ImportFixKind || (ImportFixKind = {}));
         // These should not be combined as bitflags, but are given powers of 2 values to
         // easily detect conflicts between `NotAllowed` and `Required` by giving them a unique sum.
@@ -149963,11 +150036,11 @@ var ts;
             AddAsTypeOnly[AddAsTypeOnly["Required"] = 2] = "Required";
             AddAsTypeOnly[AddAsTypeOnly["NotAllowed"] = 4] = "NotAllowed";
         })(AddAsTypeOnly || (AddAsTypeOnly = {}));
-        function getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, symbolName, host, program, formatContext, position, preferences) {
+        function getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, symbolName, isJsxTagName, host, program, formatContext, position, preferences) {
             var compilerOptions = program.getCompilerOptions();
             var exportInfos = ts.pathIsBareSpecifier(ts.stripQuotes(moduleSymbol.name))
                 ? [getSymbolExportInfoForSymbol(targetSymbol, moduleSymbol, program, host)]
-                : getAllReExportingModules(sourceFile, targetSymbol, moduleSymbol, symbolName, host, program, preferences, /*useAutoImportProvider*/ true);
+                : getAllReExportingModules(sourceFile, targetSymbol, moduleSymbol, symbolName, isJsxTagName, host, program, preferences, /*useAutoImportProvider*/ true);
             var useRequire = shouldUseRequire(sourceFile, program);
             var isValidTypeOnlyUseSite = ts.isValidTypeOnlyAliasUseSite(ts.getTokenAtPosition(sourceFile, position));
             var fix = ts.Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences));
@@ -149977,6 +150050,13 @@ var ts;
             };
         }
         codefix.getImportCompletionAction = getImportCompletionAction;
+        function getPromoteTypeOnlyCompletionAction(sourceFile, symbolToken, program, host, formatContext, preferences) {
+            var compilerOptions = program.getCompilerOptions();
+            var symbolName = getSymbolName(sourceFile, program.getTypeChecker(), symbolToken, compilerOptions);
+            var fix = getTypeOnlyPromotionFix(sourceFile, symbolToken, symbolName, program);
+            return fix && codeFixActionToCodeAction(codeActionForFix({ host: host, formatContext: formatContext, preferences: preferences }, sourceFile, symbolName, fix, 1 /* Double */, compilerOptions));
+        }
+        codefix.getPromoteTypeOnlyCompletionAction = getPromoteTypeOnlyCompletionAction;
         function getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences) {
             ts.Debug.assert(exportInfos.some(function (info) { return info.moduleSymbol === moduleSymbol || info.symbol.parent === moduleSymbol; }), "Some exportInfo should match the specified moduleSymbol");
             var packageJsonImportFilter = ts.createPackageJsonImportFilter(sourceFile, preferences, host);
@@ -150006,7 +150086,7 @@ var ts;
                 }
             }
         }
-        function getAllReExportingModules(importingFile, targetSymbol, exportingModuleSymbol, symbolName, host, program, preferences, useAutoImportProvider) {
+        function getAllReExportingModules(importingFile, targetSymbol, exportingModuleSymbol, symbolName, isJsxTagName, host, program, preferences, useAutoImportProvider) {
             var result = [];
             var compilerOptions = program.getCompilerOptions();
             var getModuleSpecifierResolutionHost = ts.memoizeOne(function (isFromPackageJson) {
@@ -150019,7 +150099,7 @@ var ts;
                     return;
                 }
                 var defaultInfo = ts.getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions);
-                if (defaultInfo && (defaultInfo.name === symbolName || moduleSymbolToValidIdentifier(moduleSymbol, ts.getEmitScriptTarget(compilerOptions)) === symbolName) && ts.skipAlias(defaultInfo.symbol, checker) === targetSymbol && isImportable(program, moduleFile, isFromPackageJson)) {
+                if (defaultInfo && (defaultInfo.name === symbolName || moduleSymbolToValidIdentifier(moduleSymbol, ts.getEmitScriptTarget(compilerOptions), isJsxTagName) === symbolName) && ts.skipAlias(defaultInfo.symbol, checker) === targetSymbol && isImportable(program, moduleFile, isFromPackageJson)) {
                     result.push({ symbol: defaultInfo.symbol, moduleSymbol: moduleSymbol, moduleFileName: moduleFile === null || moduleFile === void 0 ? void 0 : moduleFile.fileName, exportKind: defaultInfo.exportKind, targetFlags: ts.skipAlias(defaultInfo.symbol, checker).flags, isFromPackageJson: isFromPackageJson });
                 }
                 for (var _i = 0, _a = checker.getExportsAndPropertiesOfModule(moduleSymbol); _i < _a.length; _i++) {
@@ -150257,9 +150337,21 @@ var ts;
         }
         function getFixesInfo(context, errorCode, pos, useAutoImportProvider) {
             var symbolToken = ts.getTokenAtPosition(context.sourceFile, pos);
-            var info = errorCode === ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code
-                ? getFixesInfoForUMDImport(context, symbolToken)
-                : ts.isIdentifier(symbolToken) ? getFixesInfoForNonUMDImport(context, symbolToken, useAutoImportProvider) : undefined;
+            var info;
+            if (errorCode === ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code) {
+                info = getFixesInfoForUMDImport(context, symbolToken);
+            }
+            else if (!ts.isIdentifier(symbolToken)) {
+                return undefined;
+            }
+            else if (errorCode === ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type.code) {
+                var symbolName_1 = getSymbolName(context.sourceFile, context.program.getTypeChecker(), symbolToken, context.program.getCompilerOptions());
+                var fix = getTypeOnlyPromotionFix(context.sourceFile, symbolToken, symbolName_1, context.program);
+                return fix && { fixes: [fix], symbolName: symbolName_1 };
+            }
+            else {
+                info = getFixesInfoForNonUMDImport(context, symbolToken, useAutoImportProvider);
+            }
             var packageJsonImportFilter = ts.createPackageJsonImportFilter(context.sourceFile, context.preferences, context.host);
             return info && __assign(__assign({}, info), { fixes: sortFixes(info.fixes, context.sourceFile, context.program, packageJsonImportFilter) });
         }
@@ -150376,13 +150468,23 @@ var ts;
             ts.Debug.assert(symbolName !== "default" /* Default */, "'default' isn't a legal identifier and couldn't occur here");
             var isValidTypeOnlyUseSite = ts.isValidTypeOnlyAliasUseSite(symbolToken);
             var useRequire = shouldUseRequire(sourceFile, program);
-            var exportInfos = getExportInfos(symbolName, ts.getMeaningFromLocation(symbolToken), cancellationToken, sourceFile, program, useAutoImportProvider, host, preferences);
+            var exportInfos = getExportInfos(symbolName, ts.isJSXTagName(symbolToken), ts.getMeaningFromLocation(symbolToken), cancellationToken, sourceFile, program, useAutoImportProvider, host, preferences);
             var fixes = ts.arrayFrom(ts.flatMapIterator(exportInfos.entries(), function (_a) {
                 var _ = _a[0], exportInfos = _a[1];
                 return getImportFixes(exportInfos, symbolName, symbolToken.getStart(sourceFile), isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences);
             }));
             return { fixes: fixes, symbolName: symbolName };
         }
+        function getTypeOnlyPromotionFix(sourceFile, symbolToken, symbolName, program) {
+            var checker = program.getTypeChecker();
+            var symbol = checker.resolveName(symbolName, symbolToken, 111551 /* Value */, /*excludeGlobals*/ true);
+            if (!symbol)
+                return undefined;
+            var typeOnlyAliasDeclaration = checker.getTypeOnlyAliasDeclaration(symbol);
+            if (!typeOnlyAliasDeclaration || ts.getSourceFileOfNode(typeOnlyAliasDeclaration) !== sourceFile)
+                return undefined;
+            return { kind: 4 /* PromoteTypeOnly */, typeOnlyAliasDeclaration: typeOnlyAliasDeclaration };
+        }
         function jsxModeNeedsExplicitImport(jsx) {
             return jsx === 2 /* React */ || jsx === 3 /* ReactNative */;
         }
@@ -150390,14 +150492,20 @@ var ts;
             var parent = symbolToken.parent;
             if ((ts.isJsxOpeningLikeElement(parent) || ts.isJsxClosingElement(parent)) && parent.tagName === symbolToken && jsxModeNeedsExplicitImport(compilerOptions.jsx)) {
                 var jsxNamespace = checker.getJsxNamespace(sourceFile);
-                if (ts.isIntrinsicJsxName(symbolToken.text) || !checker.resolveName(jsxNamespace, parent, 111551 /* Value */, /*excludeGlobals*/ true)) {
+                if (needsJsxNamespaceFix(jsxNamespace, symbolToken, checker)) {
                     return jsxNamespace;
                 }
             }
             return symbolToken.text;
         }
+        function needsJsxNamespaceFix(jsxNamespace, symbolToken, checker) {
+            if (ts.isIntrinsicJsxName(symbolToken.text))
+                return true; // If we were triggered by a matching error code on an intrinsic, the error must have been about missing the JSX factory
+            var namespaceSymbol = checker.resolveName(jsxNamespace, symbolToken, 111551 /* Value */, /*excludeGlobals*/ true);
+            return !namespaceSymbol || ts.some(namespaceSymbol.declarations, ts.isTypeOnlyImportOrExportDeclaration) && !(namespaceSymbol.flags & 111551 /* Value */);
+        }
         // Returns a map from an exported symbol's ID to a list of every way it's (re-)exported.
-        function getExportInfos(symbolName, currentTokenMeaning, cancellationToken, fromFile, program, useAutoImportProvider, host, preferences) {
+        function getExportInfos(symbolName, isJsxTagName, currentTokenMeaning, cancellationToken, fromFile, program, useAutoImportProvider, host, preferences) {
             var _a;
             // For each original symbol, keep all re-exports of that symbol together so we can call `getCodeActionsForImport` on the whole group at once.
             // Maps symbol id to info for modules providing that symbol (original export + re-exports).
@@ -150420,7 +150528,7 @@ var ts;
                 cancellationToken.throwIfCancellationRequested();
                 var compilerOptions = program.getCompilerOptions();
                 var defaultInfo = ts.getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions);
-                if (defaultInfo && (defaultInfo.name === symbolName || moduleSymbolToValidIdentifier(moduleSymbol, ts.getEmitScriptTarget(compilerOptions)) === symbolName) && symbolHasMeaning(defaultInfo.symbolForMeaning, currentTokenMeaning)) {
+                if (defaultInfo && (defaultInfo.name === symbolName || moduleSymbolToValidIdentifier(moduleSymbol, ts.getEmitScriptTarget(compilerOptions), isJsxTagName) === symbolName) && symbolHasMeaning(defaultInfo.symbolForMeaning, currentTokenMeaning)) {
                     addSymbol(moduleSymbol, sourceFile, defaultInfo.symbol, defaultInfo.exportKind, program, isFromPackageJson);
                 }
                 // check exports with the same name
@@ -150494,10 +150602,80 @@ var ts;
                     ts.insertImports(changes, sourceFile, getDeclarations(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport), /*blankLineBetween*/ true);
                     return [importKind === 1 /* Default */ ? ts.Diagnostics.Import_default_0_from_module_1 : ts.Diagnostics.Import_0_from_module_1, symbolName, moduleSpecifier];
                 }
+                case 4 /* PromoteTypeOnly */: {
+                    var typeOnlyAliasDeclaration = fix.typeOnlyAliasDeclaration;
+                    var promotedDeclaration = promoteFromTypeOnly(changes, typeOnlyAliasDeclaration, compilerOptions, sourceFile);
+                    return promotedDeclaration.kind === 269 /* ImportSpecifier */
+                        ? [ts.Diagnostics.Remove_type_from_import_of_0_from_1, symbolName, getModuleSpecifierText(promotedDeclaration.parent.parent)]
+                        : [ts.Diagnostics.Remove_type_from_import_declaration_from_0, getModuleSpecifierText(promotedDeclaration)];
+                }
                 default:
                     return ts.Debug.assertNever(fix, "Unexpected fix kind " + fix.kind);
             }
         }
+        function getModuleSpecifierText(promotedDeclaration) {
+            var _a, _b;
+            return promotedDeclaration.kind === 264 /* ImportEqualsDeclaration */
+                ? ((_b = ts.tryCast((_a = ts.tryCast(promotedDeclaration.moduleReference, ts.isExternalModuleReference)) === null || _a === void 0 ? void 0 : _a.expression, ts.isStringLiteralLike)) === null || _b === void 0 ? void 0 : _b.text) || promotedDeclaration.moduleReference.getText()
+                : ts.cast(promotedDeclaration.parent.moduleSpecifier, ts.isStringLiteral).text;
+        }
+        function promoteFromTypeOnly(changes, aliasDeclaration, compilerOptions, sourceFile) {
+            // See comment in `doAddExistingFix` on constant with the same name.
+            var convertExistingToTypeOnly = compilerOptions.preserveValueImports && compilerOptions.isolatedModules;
+            switch (aliasDeclaration.kind) {
+                case 269 /* ImportSpecifier */:
+                    if (aliasDeclaration.isTypeOnly) {
+                        if (aliasDeclaration.parent.elements.length > 1 && ts.OrganizeImports.importSpecifiersAreSorted(aliasDeclaration.parent.elements)) {
+                            changes.delete(sourceFile, aliasDeclaration);
+                            var newSpecifier = ts.factory.updateImportSpecifier(aliasDeclaration, /*isTypeOnly*/ false, aliasDeclaration.propertyName, aliasDeclaration.name);
+                            var insertionIndex = ts.OrganizeImports.getImportSpecifierInsertionIndex(aliasDeclaration.parent.elements, newSpecifier);
+                            changes.insertImportSpecifierAtIndex(sourceFile, newSpecifier, aliasDeclaration.parent, insertionIndex);
+                        }
+                        else {
+                            changes.deleteRange(sourceFile, aliasDeclaration.getFirstToken());
+                        }
+                        return aliasDeclaration;
+                    }
+                    else {
+                        ts.Debug.assert(aliasDeclaration.parent.parent.isTypeOnly);
+                        promoteImportClause(aliasDeclaration.parent.parent);
+                        return aliasDeclaration.parent.parent;
+                    }
+                case 266 /* ImportClause */:
+                    promoteImportClause(aliasDeclaration);
+                    return aliasDeclaration;
+                case 267 /* NamespaceImport */:
+                    promoteImportClause(aliasDeclaration.parent);
+                    return aliasDeclaration.parent;
+                case 264 /* ImportEqualsDeclaration */:
+                    changes.deleteRange(sourceFile, aliasDeclaration.getChildAt(1));
+                    return aliasDeclaration;
+                default:
+                    ts.Debug.failBadSyntaxKind(aliasDeclaration);
+            }
+            function promoteImportClause(importClause) {
+                changes.delete(sourceFile, ts.getTypeKeywordOfTypeOnlyImport(importClause, sourceFile));
+                if (convertExistingToTypeOnly) {
+                    var namedImports = ts.tryCast(importClause.namedBindings, ts.isNamedImports);
+                    if (namedImports && namedImports.elements.length > 1) {
+                        if (ts.OrganizeImports.importSpecifiersAreSorted(namedImports.elements) &&
+                            aliasDeclaration.kind === 269 /* ImportSpecifier */ &&
+                            namedImports.elements.indexOf(aliasDeclaration) !== 0) {
+                            // The import specifier being promoted will be the only non-type-only,
+                            //  import in the NamedImports, so it should be moved to the front.
+                            changes.delete(sourceFile, aliasDeclaration);
+                            changes.insertImportSpecifierAtIndex(sourceFile, aliasDeclaration, namedImports, 0);
+                        }
+                        for (var _i = 0, _a = namedImports.elements; _i < _a.length; _i++) {
+                            var element = _a[_i];
+                            if (element !== aliasDeclaration && !element.isTypeOnly) {
+                                changes.insertModifierBefore(sourceFile, 151 /* TypeKeyword */, element);
+                            }
+                        }
+                    }
+                }
+            }
+        }
         function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImports, compilerOptions) {
             var _a;
             if (clause.kind === 200 /* ObjectBindingPattern */) {
@@ -150535,13 +150713,7 @@ var ts;
                         var insertionIndex = convertExistingToTypeOnly && !spec.isTypeOnly
                             ? 0
                             : ts.OrganizeImports.getImportSpecifierInsertionIndex(existingSpecifiers, spec);
-                        var prevSpecifier = clause.namedBindings.elements[insertionIndex - 1];
-                        if (prevSpecifier) {
-                            changes.insertNodeInListAfter(sourceFile, prevSpecifier, spec);
-                        }
-                        else {
-                            changes.insertNodeBefore(sourceFile, existingSpecifiers[0], spec, !ts.positionsAreOnSameLine(existingSpecifiers[0].getStart(), clause.parent.getStart(), sourceFile));
-                        }
+                        changes.insertImportSpecifierAtIndex(sourceFile, spec, clause.namedBindings, insertionIndex);
                     }
                 }
                 else if (existingSpecifiers === null || existingSpecifiers === void 0 ? void 0 : existingSpecifiers.length) {
@@ -150656,17 +150828,20 @@ var ts;
             var declarations = _a.declarations;
             return ts.some(declarations, function (decl) { return !!(ts.getMeaningFromDeclaration(decl) & meaning); });
         }
-        function moduleSymbolToValidIdentifier(moduleSymbol, target) {
-            return moduleSpecifierToValidIdentifier(ts.removeFileExtension(ts.stripQuotes(moduleSymbol.name)), target);
+        function moduleSymbolToValidIdentifier(moduleSymbol, target, forceCapitalize) {
+            return moduleSpecifierToValidIdentifier(ts.removeFileExtension(ts.stripQuotes(moduleSymbol.name)), target, forceCapitalize);
         }
         codefix.moduleSymbolToValidIdentifier = moduleSymbolToValidIdentifier;
-        function moduleSpecifierToValidIdentifier(moduleSpecifier, target) {
+        function moduleSpecifierToValidIdentifier(moduleSpecifier, target, forceCapitalize) {
             var baseName = ts.getBaseFileName(ts.removeSuffix(moduleSpecifier, "/index"));
             var res = "";
             var lastCharWasValid = true;
             var firstCharCode = baseName.charCodeAt(0);
             if (ts.isIdentifierStart(firstCharCode, target)) {
                 res += String.fromCharCode(firstCharCode);
+                if (forceCapitalize) {
+                    res = res.toUpperCase();
+                }
             }
             else {
                 lastCharWasValid = false;