typescript 4.5.0-dev.20210927 → 4.5.0-dev.20210928

package/lib/tsserver.js

@@ -100,7 +100,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.20210927";
+    ts.version = ts.versionMajorMinor + ".0-dev.20210928";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8198,6 +8198,8 @@ var ts;
         Construct_signature_return_types_0_and_1_are_incompatible: diag(2203, ts.DiagnosticCategory.Error, "Construct_signature_return_types_0_and_1_are_incompatible_2203", "Construct signature return types '{0}' and '{1}' are incompatible.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
         Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2204, ts.DiagnosticCategory.Error, "Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2204", "Call signatures with no arguments have incompatible return types '{0}' and '{1}'.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
         Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, ts.DiagnosticCategory.Error, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
+        The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: diag(2206, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement_2206", "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."),
+        The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement: diag(2207, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement_2207", "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."),
         Duplicate_identifier_0: diag(2300, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."),
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, ts.DiagnosticCategory.Error, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
         Static_members_cannot_reference_class_type_parameters: diag(2302, ts.DiagnosticCategory.Error, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."),
@@ -12985,7 +12987,7 @@ var ts;
         switch (node.kind) {
             case 269 /* ImportSpecifier */:
             case 274 /* ExportSpecifier */:
-                return node.parent.parent.isTypeOnly;
+                return node.isTypeOnly || node.parent.parent.isTypeOnly;
             case 267 /* NamespaceImport */:
                 return node.parent.isTypeOnly;
             case 266 /* ImportClause */:
@@ -19796,7 +19798,8 @@ var ts;
         var aParts = ts.getPathComponents(ts.getNormalizedAbsolutePath(a, cwd));
         var bParts = ts.getPathComponents(ts.getNormalizedAbsolutePath(b, cwd));
         var isDirectory = false;
-        while (!isNodeModulesOrScopedPackageDirectory(aParts[aParts.length - 2], getCanonicalFileName) &&
+        while (aParts.length >= 2 && bParts.length >= 2 &&
+            !isNodeModulesOrScopedPackageDirectory(aParts[aParts.length - 2], getCanonicalFileName) &&
             !isNodeModulesOrScopedPackageDirectory(bParts[bParts.length - 2], getCanonicalFileName) &&
             getCanonicalFileName(aParts[aParts.length - 1]) === getCanonicalFileName(bParts[bParts.length - 1])) {
             aParts.pop();
@@ -19808,7 +19811,7 @@ var ts;
     // KLUDGE: Don't assume one 'node_modules' links to another. More likely a single directory inside the node_modules is the symlink.
     // ALso, don't assume that an `@foo` directory is linked. More likely the contents of that are linked.
     function isNodeModulesOrScopedPackageDirectory(s, getCanonicalFileName) {
-        return getCanonicalFileName(s) === "node_modules" || ts.startsWith(s, "@");
+        return s !== undefined && (getCanonicalFileName(s) === "node_modules" || ts.startsWith(s, "@"));
     }
     function stripLeadingDirectorySeparator(s) {
         return ts.isAnyDirectorySeparator(s.charCodeAt(0)) ? s.slice(1) : undefined;
@@ -20439,10 +20442,6 @@ var ts;
             || !(isExpressionNode(useSite) || isShorthandPropertyNameUseSite(useSite));
     }
     ts.isValidTypeOnlyAliasUseSite = isValidTypeOnlyAliasUseSite;
-    function typeOnlyDeclarationIsExport(typeOnlyDeclaration) {
-        return typeOnlyDeclaration.kind === 274 /* ExportSpecifier */;
-    }
-    ts.typeOnlyDeclarationIsExport = typeOnlyDeclarationIsExport;
     function isShorthandPropertyNameUseSite(useSite) {
         return ts.isIdentifier(useSite) && ts.isShorthandPropertyAssignment(useSite.parent) && useSite.parent.name === useSite;
     }
@@ -24464,8 +24463,9 @@ var ts;
                 : node;
         }
         // @api
-        function createImportSpecifier(propertyName, name) {
+        function createImportSpecifier(isTypeOnly, propertyName, name) {
             var node = createBaseNode(269 /* ImportSpecifier */);
+            node.isTypeOnly = isTypeOnly;
             node.propertyName = propertyName;
             node.name = name;
             node.transformFlags |=
@@ -24475,10 +24475,11 @@ var ts;
             return node;
         }
         // @api
-        function updateImportSpecifier(node, propertyName, name) {
-            return node.propertyName !== propertyName
+        function updateImportSpecifier(node, isTypeOnly, propertyName, name) {
+            return node.isTypeOnly !== isTypeOnly
+                || node.propertyName !== propertyName
                 || node.name !== name
-                ? update(createImportSpecifier(propertyName, name), node)
+                ? update(createImportSpecifier(isTypeOnly, propertyName, name), node)
                 : node;
         }
         // @api
@@ -24539,8 +24540,9 @@ var ts;
                 : node;
         }
         // @api
-        function createExportSpecifier(propertyName, name) {
+        function createExportSpecifier(isTypeOnly, propertyName, name) {
             var node = createBaseNode(274 /* ExportSpecifier */);
+            node.isTypeOnly = isTypeOnly;
             node.propertyName = asName(propertyName);
             node.name = asName(name);
             node.transformFlags |=
@@ -24550,10 +24552,11 @@ var ts;
             return node;
         }
         // @api
-        function updateExportSpecifier(node, propertyName, name) {
-            return node.propertyName !== propertyName
+        function updateExportSpecifier(node, isTypeOnly, propertyName, name) {
+            return node.isTypeOnly !== isTypeOnly
+                || node.propertyName !== propertyName
                 || node.name !== name
-                ? update(createExportSpecifier(propertyName, name), node)
+                ? update(createExportSpecifier(isTypeOnly, propertyName, name), node)
                 : node;
         }
         // @api
@@ -25661,7 +25664,7 @@ var ts;
             /*decorators*/ undefined, 
             /*modifiers*/ undefined, 
             /*isTypeOnly*/ false, createNamedExports([
-                createExportSpecifier(/*propertyName*/ undefined, exportName)
+                createExportSpecifier(/*isTypeOnly*/ false, /*propertyName*/ undefined, exportName)
             ]));
         }
         //
@@ -28928,8 +28931,8 @@ var ts;
                         // Alias the imports if the names are used somewhere in the file.
                         // NOTE: We don't need to care about global import collisions as this is a module.
                         namedBindings = nodeFactory.createNamedImports(ts.map(helperNames, function (name) { return ts.isFileLevelUniqueName(sourceFile, name)
-                            ? nodeFactory.createImportSpecifier(/*propertyName*/ undefined, nodeFactory.createIdentifier(name))
-                            : nodeFactory.createImportSpecifier(nodeFactory.createIdentifier(name), helperFactory.getUnscopedHelperName(name)); }));
+                            ? nodeFactory.createImportSpecifier(/*isTypeOnly*/ false, /*propertyName*/ undefined, nodeFactory.createIdentifier(name))
+                            : nodeFactory.createImportSpecifier(/*isTypeOnly*/ false, nodeFactory.createIdentifier(name), helperFactory.getUnscopedHelperName(name)); }));
                         var parseNode = ts.getOriginalNode(sourceFile, ts.isSourceFile);
                         var emitNode = ts.getOrCreateEmitNode(parseNode);
                         emitNode.externalHelpers = true;
@@ -36056,27 +36059,74 @@ var ts;
             var checkIdentifierIsKeyword = ts.isKeyword(token()) && !isIdentifier();
             var checkIdentifierStart = scanner.getTokenPos();
             var checkIdentifierEnd = scanner.getTextPos();
-            var identifierName = parseIdentifierName();
+            var isTypeOnly = false;
             var propertyName;
-            var name;
-            if (token() === 127 /* AsKeyword */) {
-                propertyName = identifierName;
-                parseExpected(127 /* AsKeyword */);
-                checkIdentifierIsKeyword = ts.isKeyword(token()) && !isIdentifier();
-                checkIdentifierStart = scanner.getTokenPos();
-                checkIdentifierEnd = scanner.getTextPos();
-                name = parseIdentifierName();
+            var canParseAsKeyword = true;
+            var name = parseIdentifierName();
+            if (name.escapedText === "type") {
+                // If the first token of an import specifier is 'type', there are a lot of possibilities,
+                // especially if we see 'as' afterwards:
+                //
+                // import { type } from "mod";          - isTypeOnly: false,   name: type
+                // import { type as } from "mod";       - isTypeOnly: true,    name: as
+                // import { type as as } from "mod";    - isTypeOnly: false,   name: as,    propertyName: type
+                // import { type as as as } from "mod"; - isTypeOnly: true,    name: as,    propertyName: as
+                if (token() === 127 /* AsKeyword */) {
+                    // { type as ...? }
+                    var firstAs = parseIdentifierName();
+                    if (token() === 127 /* AsKeyword */) {
+                        // { type as as ...? }
+                        var secondAs = parseIdentifierName();
+                        if (ts.tokenIsIdentifierOrKeyword(token())) {
+                            // { type as as something }
+                            isTypeOnly = true;
+                            propertyName = firstAs;
+                            name = parseNameWithKeywordCheck();
+                            canParseAsKeyword = false;
+                        }
+                        else {
+                            // { type as as }
+                            propertyName = name;
+                            name = secondAs;
+                            canParseAsKeyword = false;
+                        }
+                    }
+                    else if (ts.tokenIsIdentifierOrKeyword(token())) {
+                        // { type as something }
+                        propertyName = name;
+                        canParseAsKeyword = false;
+                        name = parseNameWithKeywordCheck();
+                    }
+                    else {
+                        // { type as }
+                        isTypeOnly = true;
+                        name = firstAs;
+                    }
+                }
+                else if (ts.tokenIsIdentifierOrKeyword(token())) {
+                    // { type something ...? }
+                    isTypeOnly = true;
+                    name = parseNameWithKeywordCheck();
+                }
             }
-            else {
-                name = identifierName;
+            if (canParseAsKeyword && token() === 127 /* AsKeyword */) {
+                propertyName = name;
+                parseExpected(127 /* AsKeyword */);
+                name = parseNameWithKeywordCheck();
             }
             if (kind === 269 /* ImportSpecifier */ && checkIdentifierIsKeyword) {
                 parseErrorAt(checkIdentifierStart, checkIdentifierEnd, ts.Diagnostics.Identifier_expected);
             }
             var node = kind === 269 /* ImportSpecifier */
-                ? factory.createImportSpecifier(propertyName, name)
-                : factory.createExportSpecifier(propertyName, name);
+                ? factory.createImportSpecifier(isTypeOnly, propertyName, name)
+                : factory.createExportSpecifier(isTypeOnly, propertyName, name);
             return finishNode(node, pos);
+            function parseNameWithKeywordCheck() {
+                checkIdentifierIsKeyword = ts.isKeyword(token()) && !isIdentifier();
+                checkIdentifierStart = scanner.getTokenPos();
+                checkIdentifierEnd = scanner.getTextPos();
+                return parseIdentifierName();
+            }
         }
         function parseNamespaceExport(pos) {
             return finishNode(factory.createNamespaceExport(parseIdentifierName()), pos);
@@ -46906,6 +46956,7 @@ var ts;
             getLocalTypeParametersOfClassOrInterfaceOrTypeAlias: getLocalTypeParametersOfClassOrInterfaceOrTypeAlias,
             isDeclarationVisible: isDeclarationVisible,
             isPropertyAccessible: isPropertyAccessible,
+            getTypeOnlyAliasDeclaration: getTypeOnlyAliasDeclaration,
         };
         function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode) {
             var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression);
@@ -48282,8 +48333,7 @@ var ts;
             if (!ts.isValidTypeOnlyAliasUseSite(useSite)) {
                 var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(symbol);
                 if (typeOnlyDeclaration) {
-                    var isExport = ts.typeOnlyDeclarationIsExport(typeOnlyDeclaration);
-                    var message = isExport
+                    var message = typeOnlyDeclaration.kind === 274 /* ExportSpecifier */
                         ? ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type
                         : ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type;
                     var unescapedName = ts.unescapeLeadingUnderscores(name);
@@ -48294,7 +48344,7 @@ var ts;
         function addTypeOnlyDeclarationRelatedInfo(diagnostic, typeOnlyDeclaration, unescapedName) {
             if (!typeOnlyDeclaration)
                 return diagnostic;
-            return ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(typeOnlyDeclaration, ts.typeOnlyDeclarationIsExport(typeOnlyDeclaration) ? ts.Diagnostics._0_was_exported_here : ts.Diagnostics._0_was_imported_here, unescapedName));
+            return ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(typeOnlyDeclaration, typeOnlyDeclaration.kind === 274 /* ExportSpecifier */ ? ts.Diagnostics._0_was_exported_here : ts.Diagnostics._0_was_imported_here, unescapedName));
         }
         function getIsDeferredContext(location, lastLocation) {
             if (location.kind !== 213 /* ArrowFunction */ && location.kind !== 212 /* FunctionExpression */) {
@@ -48618,15 +48668,13 @@ var ts;
         function checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(node, resolved) {
             if (markSymbolOfAliasDeclarationIfTypeOnly(node, /*immediateTarget*/ undefined, resolved, /*overwriteEmpty*/ false) && !node.isTypeOnly) {
                 var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(getSymbolOfNode(node));
-                var isExport = ts.typeOnlyDeclarationIsExport(typeOnlyDeclaration);
+                var isExport = typeOnlyDeclaration.kind === 274 /* ExportSpecifier */;
                 var message = isExport
                     ? ts.Diagnostics.An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type
                     : ts.Diagnostics.An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type;
                 var relatedMessage = isExport
                     ? ts.Diagnostics._0_was_exported_here
                     : ts.Diagnostics._0_was_imported_here;
-                // Non-null assertion is safe because the optionality comes from ImportClause,
-                // but if an ImportClause was the typeOnlyDeclaration, it had to have a `name`.
                 var name = ts.unescapeLeadingUnderscores(typeOnlyDeclaration.name.escapedText);
                 ts.addRelatedInfo(error(node.moduleReference, message), ts.createDiagnosticForNode(typeOnlyDeclaration, relatedMessage, name));
             }
@@ -49042,13 +49090,13 @@ var ts;
          * and issue an error if so.
          *
          * @param aliasDeclaration The alias declaration not marked as type-only
+         * @param immediateTarget The symbol to which the alias declaration immediately resolves
+         * @param finalTarget The symbol to which the alias declaration ultimately resolves
+         * @param overwriteEmpty Checks `resolvesToSymbol` for type-only declarations even if `aliasDeclaration`
          * has already been marked as not resolving to a type-only alias. Used when recursively resolving qualified
          * names of import aliases, e.g. `import C = a.b.C`. If namespace `a` is not found to be type-only, the
          * import declaration will initially be marked as not resolving to a type-only symbol. But, namespace `b`
          * must still be checked for a type-only marker, overwriting the previous negative result if found.
-         * @param immediateTarget The symbol to which the alias declaration immediately resolves
-         * @param finalTarget The symbol to which the alias declaration ultimately resolves
-         * @param overwriteEmpty Checks `resolvesToSymbol` for type-only declarations even if `aliasDeclaration`
          */
         function markSymbolOfAliasDeclarationIfTypeOnly(aliasDeclaration, immediateTarget, finalTarget, overwriteEmpty) {
             if (!aliasDeclaration || ts.isPropertyAccessExpression(aliasDeclaration))
@@ -52181,7 +52229,7 @@ var ts;
                             ns = ts.factory.updateModuleDeclaration(ns, ns.decorators, ns.modifiers, ns.name, body = ts.factory.updateModuleBlock(body, ts.factory.createNodeArray(__spreadArray(__spreadArray([], ns.body.statements, true), [ts.factory.createExportDeclaration(
                                 /*decorators*/ undefined, 
                                 /*modifiers*/ undefined, 
-                                /*isTypeOnly*/ false, ts.factory.createNamedExports(ts.map(ts.flatMap(excessExports, function (e) { return getNamesOfDeclaration(e); }), function (id) { return ts.factory.createExportSpecifier(/*alias*/ undefined, id); })), 
+                                /*isTypeOnly*/ false, ts.factory.createNamedExports(ts.map(ts.flatMap(excessExports, function (e) { return getNamesOfDeclaration(e); }), function (id) { return ts.factory.createExportSpecifier(/*isTypeOnly*/ false, /*alias*/ undefined, id); })), 
                                 /*moduleSpecifier*/ undefined)], false))));
                             statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, nsIndex), true), [ns], false), statements.slice(nsIndex + 1), true);
                         }
@@ -52409,7 +52457,7 @@ var ts;
                                     addResult(ts.factory.createExportDeclaration(
                                     /*decorators*/ undefined, 
                                     /*modifiers*/ undefined, 
-                                    /*isTypeOnly*/ false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(alias, localName)])), 0 /* None */);
+                                    /*isTypeOnly*/ false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(/*isTypeOnly*/ false, alias, localName)])), 0 /* None */);
                                     context.tracker.trackSymbol(type.symbol, context.enclosingDeclaration, 111551 /* Value */);
                                 }
                                 else {
@@ -52442,7 +52490,7 @@ var ts;
                                         addResult(ts.factory.createExportDeclaration(
                                         /*decorators*/ undefined, 
                                         /*modifiers*/ undefined, 
-                                        /*isTypeOnly*/ false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(name, localName)])), 0 /* None */);
+                                        /*isTypeOnly*/ false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(/*isTypeOnly*/ false, name, localName)])), 0 /* None */);
                                         needsExportDeclaration = false;
                                         needsPostExportDefault = false;
                                     }
@@ -52500,7 +52548,7 @@ var ts;
                         addResult(ts.factory.createExportDeclaration(
                         /*decorators*/ undefined, 
                         /*modifiers*/ undefined, 
-                        /*isTypeOnly*/ false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(getInternalSymbolName(symbol, symbolName), symbolName)])), 0 /* None */);
+                        /*isTypeOnly*/ false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(/*isTypeOnly*/ false, getInternalSymbolName(symbol, symbolName), symbolName)])), 0 /* None */);
                     }
                 }
                 function includePrivateSymbol(symbol) {
@@ -52622,7 +52670,7 @@ var ts;
                                 var target = aliasDecl && getTargetOfAliasDeclaration(aliasDecl, /*dontRecursivelyResolve*/ true);
                                 includePrivateSymbol(target || s);
                                 var targetName = target ? getInternalSymbolName(target, ts.unescapeLeadingUnderscores(target.escapedName)) : localName;
-                                return ts.factory.createExportSpecifier(name === targetName ? undefined : targetName, name);
+                                return ts.factory.createExportSpecifier(/*isTypeOnly*/ false, name === targetName ? undefined : targetName, name);
                             })))]);
                         addResult(ts.factory.createModuleDeclaration(
                         /*decorators*/ undefined, 
@@ -52713,7 +52761,7 @@ var ts;
                         var defaultReplaced = ts.map(declarations, function (d) { return ts.isExportAssignment(d) && !d.isExportEquals && ts.isIdentifier(d.expression) ? ts.factory.createExportDeclaration(
                         /*decorators*/ undefined, 
                         /*modifiers*/ undefined, 
-                        /*isTypeOnly*/ false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(d.expression, ts.factory.createIdentifier("default" /* Default */))])) : d; });
+                        /*isTypeOnly*/ false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(/*isTypeOnly*/ false, d.expression, ts.factory.createIdentifier("default" /* Default */))])) : d; });
                         var exportModifierStripped = ts.every(defaultReplaced, function (d) { return ts.hasSyntacticModifier(d, 1 /* Export */); }) ? ts.map(defaultReplaced, removeExportModifier) : defaultReplaced;
                         fakespace = ts.factory.updateModuleDeclaration(fakespace, fakespace.decorators, fakespace.modifiers, fakespace.name, ts.factory.createModuleBlock(exportModifierStripped));
                         addResult(fakespace, modifierFlags); // namespaces can never be default exported
@@ -52864,7 +52912,8 @@ var ts;
                                 var propertyName = node.propertyName;
                                 addResult(ts.factory.createImportDeclaration(
                                 /*decorators*/ undefined, 
-                                /*modifiers*/ undefined, ts.factory.createImportClause(/*isTypeOnly*/ false, /*name*/ undefined, ts.factory.createNamedImports([ts.factory.createImportSpecifier(propertyName && ts.isIdentifier(propertyName) ? ts.factory.createIdentifier(ts.idText(propertyName)) : undefined, ts.factory.createIdentifier(localName))])), ts.factory.createStringLiteral(specifier_1), 
+                                /*modifiers*/ undefined, ts.factory.createImportClause(/*isTypeOnly*/ false, /*name*/ undefined, ts.factory.createNamedImports([ts.factory.createImportSpecifier(
+                                    /*isTypeOnly*/ false, propertyName && ts.isIdentifier(propertyName) ? ts.factory.createIdentifier(ts.idText(propertyName)) : undefined, ts.factory.createIdentifier(localName))])), ts.factory.createStringLiteral(specifier_1), 
                                 /*importClause*/ undefined), 0 /* None */);
                                 break;
                             }
@@ -52948,7 +52997,8 @@ var ts;
                             /*modifiers*/ undefined, ts.factory.createImportClause(
                             /*isTypeOnly*/ false, 
                             /*importClause*/ undefined, ts.factory.createNamedImports([
-                                ts.factory.createImportSpecifier(localName !== verbatimTargetName ? ts.factory.createIdentifier(verbatimTargetName) : undefined, ts.factory.createIdentifier(localName))
+                                ts.factory.createImportSpecifier(
+                                /*isTypeOnly*/ false, localName !== verbatimTargetName ? ts.factory.createIdentifier(verbatimTargetName) : undefined, ts.factory.createIdentifier(localName))
                             ])), ts.factory.createStringLiteral(getSpecifierForModuleSymbol(target.parent || target, context)), 
                             /*assertClause*/ undefined), 0 /* None */);
                             break;
@@ -52984,7 +53034,7 @@ var ts;
                     addResult(ts.factory.createExportDeclaration(
                     /*decorators*/ undefined, 
                     /*modifiers*/ undefined, 
-                    /*isTypeOnly*/ false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(localName !== targetName ? targetName : undefined, localName)]), specifier), 0 /* None */);
+                    /*isTypeOnly*/ false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(/*isTypeOnly*/ false, localName !== targetName ? targetName : undefined, localName)]), specifier), 0 /* None */);
                 }
                 /**
                  * Returns `true` if an export assignment or declaration was produced for the symbol
@@ -56479,6 +56529,23 @@ var ts;
         function getIsLateCheckFlag(s) {
             return ts.getCheckFlags(s) & 4096 /* Late */;
         }
+        function forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(type, include, stringsOnly, cb) {
+            for (var _i = 0, _a = getPropertiesOfType(type); _i < _a.length; _i++) {
+                var prop = _a[_i];
+                cb(getLiteralTypeFromProperty(prop, include));
+            }
+            if (type.flags & 1 /* Any */) {
+                cb(stringType);
+            }
+            else {
+                for (var _b = 0, _c = getIndexInfosOfType(type); _b < _c.length; _b++) {
+                    var info = _c[_b];
+                    if (!stringsOnly || info.keyType.flags & (4 /* String */ | 134217728 /* TemplateLiteral */)) {
+                        cb(info.keyType);
+                    }
+                }
+            }
+        }
         /** Resolve the members of a mapped type { [P in K]: T } */
         function resolveMappedTypeMembers(type) {
             var members = ts.createSymbolTable();
@@ -56496,21 +56563,7 @@ var ts;
             var include = keyofStringsOnly ? 128 /* StringLiteral */ : 8576 /* StringOrNumberLiteralOrUnique */;
             if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
                 // We have a { [P in keyof T]: X }
-                for (var _i = 0, _a = getPropertiesOfType(modifiersType); _i < _a.length; _i++) {
-                    var prop = _a[_i];
-                    addMemberForKeyType(getLiteralTypeFromProperty(prop, include));
-                }
-                if (modifiersType.flags & 1 /* Any */) {
-                    addMemberForKeyType(stringType);
-                }
-                else {
-                    for (var _b = 0, _c = getIndexInfosOfType(modifiersType); _b < _c.length; _b++) {
-                        var info = _c[_b];
-                        if (!keyofStringsOnly || info.keyType.flags & (4 /* String */ | 134217728 /* TemplateLiteral */)) {
-                            addMemberForKeyType(info.keyType);
-                        }
-                    }
-                }
+                forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, include, keyofStringsOnly, addMemberForKeyType);
             }
             else {
                 forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
@@ -59627,18 +59680,56 @@ var ts;
                 type.resolvedStringIndexType || (type.resolvedStringIndexType = createIndexType(type, /*stringsOnly*/ true)) :
                 type.resolvedIndexType || (type.resolvedIndexType = createIndexType(type, /*stringsOnly*/ false));
         }
-        function instantiateTypeAsMappedNameType(nameType, type, t) {
-            return instantiateType(nameType, appendTypeMapping(type.mapper, getTypeParameterFromMappedType(type), t));
-        }
-        function getIndexTypeForMappedType(type, noIndexSignatures) {
-            var constraint = filterType(getConstraintTypeFromMappedType(type), function (t) { return !(noIndexSignatures && t.flags & (1 /* Any */ | 4 /* String */)); });
-            var nameType = type.declaration.nameType && getTypeFromTypeNode(type.declaration.nameType);
-            // If the constraint is exclusively string/number/never type(s), we need to pull the property names from the modified type and run them through the `nameType` mapper as well
-            // since they won't appear in the constraint, due to subtype reducing with the string/number index types
-            var properties = nameType && everyType(constraint, function (t) { return !!(t.flags & (4 /* String */ | 8 /* Number */ | 131072 /* Never */)); }) && getPropertiesOfType(getApparentType(getModifiersTypeFromMappedType(type)));
-            return nameType ?
-                getUnionType([mapType(constraint, function (t) { return instantiateTypeAsMappedNameType(nameType, type, t); }), mapType(getUnionType(ts.map(properties || ts.emptyArray, function (p) { return getLiteralTypeFromProperty(p, 8576 /* StringOrNumberLiteralOrUnique */); })), function (t) { return instantiateTypeAsMappedNameType(nameType, type, t); })]) :
-                constraint;
+        /**
+         * This roughly mirrors `resolveMappedTypeMembers` in the nongeneric case, except only reports a union of the keys calculated,
+         * rather than manufacturing the properties. We can't just fetch the `constraintType` since that would ignore mappings
+         * and mapping the `constraintType` directly ignores how mapped types map _properties_ and not keys (thus ignoring subtype
+         * reduction in the constraintType) when possible.
+         * @param noIndexSignatures Indicates if _string_ index signatures should be elided. (other index signatures are always reported)
+         */
+        function getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) {
+            var typeParameter = getTypeParameterFromMappedType(type);
+            var constraintType = getConstraintTypeFromMappedType(type);
+            var nameType = getNameTypeFromMappedType(type.target || type);
+            if (!nameType && !noIndexSignatures) {
+                // no mapping and no filtering required, just quickly bail to returning the constraint in the common case
+                return constraintType;
+            }
+            var keyTypes = [];
+            if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
+                // We have a { [P in keyof T]: X }
+                // `getApparentType` on the T in a generic mapped type can trigger a circularity
+                // (conditionals and `infer` types create a circular dependency in the constraint resolution)
+                // so we only eagerly manifest the keys if the constraint is nongeneric
+                if (!isGenericIndexType(constraintType)) {
+                    var modifiersType = getApparentType(getModifiersTypeFromMappedType(type)); // The 'T' in 'keyof T'
+                    forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, stringsOnly, addMemberForKeyType);
+                }
+                else {
+                    // we have a generic index and a homomorphic mapping (but a distributive key remapping) - we need to defer the whole `keyof whatever` for later
+                    // since it's not safe to resolve the shape of modifier type
+                    return getIndexTypeForGenericType(type, stringsOnly);
+                }
+            }
+            else {
+                forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
+            }
+            if (isGenericIndexType(constraintType)) { // include the generic component in the resulting type
+                forEachType(constraintType, addMemberForKeyType);
+            }
+            // we had to pick apart the constraintType to potentially map/filter it - compare the final resulting list with the original constraintType,
+            // so we can return the union that preserves aliases/origin data if possible
+            var result = noIndexSignatures ? filterType(getUnionType(keyTypes), function (t) { return !(t.flags & (1 /* Any */ | 4 /* String */)); }) : getUnionType(keyTypes);
+            if (result.flags & 1048576 /* Union */ && constraintType.flags & 1048576 /* Union */ && getTypeListId(result.types) === getTypeListId(constraintType.types)) {
+                return constraintType;
+            }
+            return result;
+            function addMemberForKeyType(keyType) {
+                var propNameType = nameType ? instantiateType(nameType, appendTypeMapping(type.mapper, typeParameter, keyType)) : keyType;
+                // `keyof` currently always returns `string | number` for concrete `string` index signatures - the below ternary keeps that behavior for mapped types
+                // See `getLiteralTypeFromProperties` where there's a similar ternary to cause the same behavior.
+                keyTypes.push(propNameType === stringType ? stringOrNumberType : propNameType);
+            }
         }
         // Ordinarily we reduce a keyof M, where M is a mapped type { [P in K as N<P>]: X }, to simply N<K>. This however presumes
         // that N distributes over union types, i.e. that N<A | B | C> is equivalent to N<A> | N<B> | N<C>. Specifically, we only
@@ -59696,7 +59787,7 @@ var ts;
             return type.flags & 1048576 /* Union */ ? getIntersectionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
                 type.flags & 2097152 /* Intersection */ ? getUnionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
                     type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && !hasDistributiveNameType(type) ? getIndexTypeForGenericType(type, stringsOnly) :
-                        ts.getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, noIndexSignatures) :
+                        ts.getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) :
                             type === wildcardType ? wildcardType :
                                 type.flags & 2 /* Unknown */ ? neverType :
                                     type.flags & (1 /* Any */ | 131072 /* Never */) ? keyofConstraintType :
@@ -63455,24 +63546,24 @@ var ts;
                     }
                 }
                 else if (target.flags & 4194304 /* Index */) {
-                    var targetType = target.type;
+                    var targetType_1 = target.type;
                     // A keyof S is related to a keyof T if T is related to S.
                     if (source.flags & 4194304 /* Index */) {
-                        if (result = isRelatedTo(targetType, source.type, /*reportErrors*/ false)) {
+                        if (result = isRelatedTo(targetType_1, source.type, /*reportErrors*/ false)) {
                             return result;
                         }
                     }
-                    if (isTupleType(targetType)) {
+                    if (isTupleType(targetType_1)) {
                         // An index type can have a tuple type target when the tuple type contains variadic elements.
                         // Check if the source is related to the known keys of the tuple type.
-                        if (result = isRelatedTo(source, getKnownKeysOfTupleType(targetType), reportErrors)) {
+                        if (result = isRelatedTo(source, getKnownKeysOfTupleType(targetType_1), reportErrors)) {
                             return result;
                         }
                     }
                     else {
                         // A type S is assignable to keyof T if S is assignable to keyof C, where C is the
                         // simplified form of T or, if T doesn't simplify, the constraint of T.
-                        var constraint = getSimplifiedTypeOrConstraint(targetType);
+                        var constraint = getSimplifiedTypeOrConstraint(targetType_1);
                         if (constraint) {
                             // We require Ternary.True here such that circular constraints don't cause
                             // false positives. For example, given 'T extends { [K in keyof T]: string }',
@@ -63482,6 +63573,30 @@ var ts;
                                 return -1 /* True */;
                             }
                         }
+                        else if (isGenericMappedType(targetType_1)) {
+                            // generic mapped types that don't simplify or have a constraint still have a very simple set of keys we can compare against
+                            // - their nameType or constraintType.
+                            // In many ways, this comparison is a deferred version of what `getIndexTypeForMappedType` does to actually resolve the keys for _non_-generic types
+                            var nameType_1 = getNameTypeFromMappedType(targetType_1);
+                            var constraintType = getConstraintTypeFromMappedType(targetType_1);
+                            var targetKeys = void 0;
+                            if (nameType_1 && isMappedTypeWithKeyofConstraintDeclaration(targetType_1)) {
+                                // we need to get the apparent mappings and union them with the generic mappings, since some properties may be
+                                // missing from the `constraintType` which will otherwise be mapped in the object
+                                var modifiersType = getApparentType(getModifiersTypeFromMappedType(targetType_1));
+                                var mappedKeys_1 = [];
+                                forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, 
+                                /*stringsOnly*/ false, function (t) { return void mappedKeys_1.push(instantiateType(nameType_1, appendTypeMapping(targetType_1.mapper, getTypeParameterFromMappedType(targetType_1), t))); });
+                                // We still need to include the non-apparent (and thus still generic) keys in the target side of the comparison (in case they're in the source side)
+                                targetKeys = getUnionType(__spreadArray(__spreadArray([], mappedKeys_1, true), [nameType_1], false));
+                            }
+                            else {
+                                targetKeys = nameType_1 || constraintType;
+                            }
+                            if (isRelatedTo(source, targetKeys, reportErrors) === -1 /* True */) {
+                                return -1 /* True */;
+                            }
+                        }
                     }
                 }
                 else if (target.flags & 8388608 /* IndexedAccess */) {
@@ -66512,8 +66627,16 @@ var ts;
             function inferToTemplateLiteralType(source, target) {
                 var matches = inferTypesFromTemplateLiteralType(source, target);
                 var types = target.types;
-                for (var i = 0; i < types.length; i++) {
-                    inferFromTypes(matches ? matches[i] : neverType, types[i]);
+                // When the target template literal contains only placeholders (meaning that inference is intended to extract
+                // single characters and remainder strings) and inference fails to produce matches, we want to infer 'never' for
+                // each placeholder such that instantiation with the inferred value(s) produces 'never', a type for which an
+                // assignment check will fail. If we make no inferences, we'll likely end up with the constraint 'string' which,
+                // upon instantiation, would collapse all the placeholders to just 'string', and an assignment check might
+                // succeed. That would be a pointless and confusing outcome.
+                if (matches || ts.every(target.texts, function (s) { return s.length === 0; })) {
+                    for (var i = 0; i < types.length; i++) {
+                        inferFromTypes(matches ? matches[i] : neverType, types[i]);
+                    }
                 }
             }
             function inferFromObjectTypes(source, target) {
@@ -70230,9 +70353,9 @@ var ts;
                     return getTypeOfPropertyOfContextualType(type, getSymbolOfNode(element).escapedName);
                 }
                 if (element.name) {
-                    var nameType_1 = getLiteralTypeFromPropertyName(element.name);
+                    var nameType_2 = getLiteralTypeFromPropertyName(element.name);
                     // We avoid calling getApplicableIndexInfo here because it performs potentially expensive intersection reduction.
-                    return mapType(type, function (t) { var _a; return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType_1)) === null || _a === void 0 ? void 0 : _a.type; }, /*noReductions*/ true);
+                    return mapType(type, function (t) { var _a; return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType_2)) === null || _a === void 0 ? void 0 : _a.type; }, /*noReductions*/ true);
                 }
             }
             return undefined;
@@ -82375,11 +82498,15 @@ var ts;
         }
         function checkGrammarExportDeclaration(node) {
             var _a;
-            var isTypeOnlyExportStar = node.isTypeOnly && ((_a = node.exportClause) === null || _a === void 0 ? void 0 : _a.kind) !== 272 /* NamedExports */;
-            if (isTypeOnlyExportStar) {
-                grammarErrorOnNode(node, ts.Diagnostics.Only_named_exports_may_use_export_type);
+            if (node.isTypeOnly) {
+                if (((_a = node.exportClause) === null || _a === void 0 ? void 0 : _a.kind) === 272 /* NamedExports */) {
+                    return checkGrammarNamedImportsOrExports(node.exportClause);
+                }
+                else {
+                    return grammarErrorOnNode(node, ts.Diagnostics.Only_named_exports_may_use_export_type);
+                }
             }
-            return !isTypeOnlyExportStar;
+            return false;
         }
         function checkGrammarModuleElementContext(node, errorMessage) {
             var isInAppropriateContext = node.parent.kind === 303 /* SourceFile */ || node.parent.kind === 261 /* ModuleBlock */ || node.parent.kind === 260 /* ModuleDeclaration */;
@@ -86054,11 +86181,24 @@ var ts;
             return ambientModulesCache;
         }
         function checkGrammarImportClause(node) {
+            var _a;
             if (node.isTypeOnly && node.name && node.namedBindings) {
                 return grammarErrorOnNode(node, ts.Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both);
             }
+            if (node.isTypeOnly && ((_a = node.namedBindings) === null || _a === void 0 ? void 0 : _a.kind) === 268 /* NamedImports */) {
+                return checkGrammarNamedImportsOrExports(node.namedBindings);
+            }
             return false;
         }
+        function checkGrammarNamedImportsOrExports(namedBindings) {
+            return !!ts.forEach(namedBindings.elements, function (specifier) {
+                if (specifier.isTypeOnly) {
+                    return grammarErrorOnFirstToken(specifier, specifier.kind === 269 /* ImportSpecifier */
+                        ? ts.Diagnostics.The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement
+                        : ts.Diagnostics.The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement);
+                }
+            });
+        }
         function checkGrammarImportCallExpression(node) {
             if (moduleKind === ts.ModuleKind.ES2015) {
                 return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_esnext_commonjs_amd_system_umd_node12_or_nodenext);
@@ -86790,7 +86930,7 @@ var ts;
                 return factory.updateNamedImports(node, nodesVisitor(node.elements, visitor, ts.isImportSpecifier));
             case 269 /* ImportSpecifier */:
                 ts.Debug.type(node);
-                return factory.updateImportSpecifier(node, nodeVisitor(node.propertyName, visitor, ts.isIdentifier), nodeVisitor(node.name, visitor, ts.isIdentifier));
+                return factory.updateImportSpecifier(node, node.isTypeOnly, nodeVisitor(node.propertyName, visitor, ts.isIdentifier), nodeVisitor(node.name, visitor, ts.isIdentifier));
             case 270 /* ExportAssignment */:
                 ts.Debug.type(node);
                 return factory.updateExportAssignment(node, nodesVisitor(node.decorators, visitor, ts.isDecorator), nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.expression, visitor, ts.isExpression));
@@ -86802,7 +86942,7 @@ var ts;
                 return factory.updateNamedExports(node, nodesVisitor(node.elements, visitor, ts.isExportSpecifier));
             case 274 /* ExportSpecifier */:
                 ts.Debug.type(node);
-                return factory.updateExportSpecifier(node, nodeVisitor(node.propertyName, visitor, ts.isIdentifier), nodeVisitor(node.name, visitor, ts.isIdentifier));
+                return factory.updateExportSpecifier(node, node.isTypeOnly, nodeVisitor(node.propertyName, visitor, ts.isIdentifier), nodeVisitor(node.name, visitor, ts.isIdentifier));
             // Module references
             case 276 /* ExternalModuleReference */:
                 ts.Debug.type(node);
@@ -90743,9 +90883,11 @@ var ts;
                 return shouldEmitAliasDeclaration(node) ? node : undefined;
             }
             else {
-                // Elide named imports if all of its import specifiers are elided.
+                // Elide named imports if all of its import specifiers are elided and settings allow.
+                var allowEmpty = compilerOptions.preserveValueImports && (compilerOptions.importsNotUsedAsValues === 1 /* Preserve */ ||
+                    compilerOptions.importsNotUsedAsValues === 2 /* Error */);
                 var elements = ts.visitNodes(node.elements, visitImportSpecifier, ts.isImportSpecifier);
-                return ts.some(elements) ? factory.updateNamedImports(node, elements) : undefined;
+                return allowEmpty || ts.some(elements) ? factory.updateNamedImports(node, elements) : undefined;
             }
         }
         /**
@@ -90754,7 +90896,7 @@ var ts;
          * @param node The import specifier node.
          */
         function visitImportSpecifier(node) {
-            return shouldEmitAliasDeclaration(node) ? node : undefined;
+            return !node.isTypeOnly && shouldEmitAliasDeclaration(node) ? node : undefined;
         }
         /**
          * Visits an export assignment, eliding it if it does not contain a clause that resolves
@@ -90783,12 +90925,10 @@ var ts;
                 // type checker doesn't know about any exports
                 return node;
             }
-            if (!resolver.isValueAliasDeclaration(node)) {
-                // Elide the export declaration if it does not export a value.
-                return undefined;
-            }
             // Elide the export declaration if all of its named exports are elided.
-            var exportClause = ts.visitNode(node.exportClause, visitNamedExportBindings, ts.isNamedExportBindings);
+            var allowEmpty = !!node.moduleSpecifier && (compilerOptions.importsNotUsedAsValues === 1 /* Preserve */ ||
+                compilerOptions.importsNotUsedAsValues === 2 /* Error */);
+            var exportClause = ts.visitNode(node.exportClause, function (bindings) { return visitNamedExportBindings(bindings, allowEmpty); }, ts.isNamedExportBindings);
             return exportClause
                 ? factory.updateExportDeclaration(node, 
                 /*decorators*/ undefined, 
@@ -90801,16 +90941,16 @@ var ts;
          *
          * @param node The named exports node.
          */
-        function visitNamedExports(node) {
+        function visitNamedExports(node, allowEmpty) {
             // Elide the named exports if all of its export specifiers were elided.
             var elements = ts.visitNodes(node.elements, visitExportSpecifier, ts.isExportSpecifier);
-            return ts.some(elements) ? factory.updateNamedExports(node, elements) : undefined;
+            return allowEmpty || ts.some(elements) ? factory.updateNamedExports(node, elements) : undefined;
         }
         function visitNamespaceExports(node) {
             return factory.updateNamespaceExport(node, ts.visitNode(node.name, visitor, ts.isIdentifier));
         }
-        function visitNamedExportBindings(node) {
-            return ts.isNamespaceExport(node) ? visitNamespaceExports(node) : visitNamedExports(node);
+        function visitNamedExportBindings(node, allowEmpty) {
+            return ts.isNamespaceExport(node) ? visitNamespaceExports(node) : visitNamedExports(node, allowEmpty);
         }
         /**
          * Visits an export specifier, eliding it if it does not resolve to a value.
@@ -90819,7 +90959,7 @@ var ts;
          */
         function visitExportSpecifier(node) {
             // Elide an export specifier if it does not reference a value.
-            return resolver.isValueAliasDeclaration(node) ? node : undefined;
+            return !node.isTypeOnly && resolver.isValueAliasDeclaration(node) ? node : undefined;
         }
         /**
          * Determines whether to emit an import equals declaration.
@@ -94420,7 +94560,7 @@ var ts;
                 currentFileState.utilizedImplicitRuntimeImports.set(importSource, specifierSourceImports);
             }
             var generatedName = factory.createUniqueName("_" + name, 16 /* Optimistic */ | 32 /* FileLevel */ | 64 /* AllowNameSubstitution */);
-            var specifier = factory.createImportSpecifier(factory.createIdentifier(name), generatedName);
+            var specifier = factory.createImportSpecifier(/*isTypeOnly*/ false, factory.createIdentifier(name), generatedName);
             generatedName.generatedImportReference = specifier;
             specifierSourceImports.set(name, specifier);
             return generatedName;
@@ -104136,7 +104276,7 @@ var ts;
                 /*modifiers*/ undefined, factory.createImportClause(
                 /*isTypeOnly*/ false, 
                 /*name*/ undefined, factory.createNamedImports([
-                    factory.createImportSpecifier(factory.createIdentifier("createRequire"), createRequireName)
+                    factory.createImportSpecifier(/*isTypeOnly*/ false, factory.createIdentifier("createRequire"), createRequireName)
                 ])), factory.createStringLiteral("module"));
                 var requireHelperName = factory.createUniqueName("__require", 16 /* Optimistic */ | 32 /* FileLevel */);
                 var requireStatement = factory.createVariableStatement(
@@ -104176,7 +104316,7 @@ var ts;
             if (ts.hasSyntacticModifier(node, 1 /* Export */)) {
                 statements = ts.append(statements, factory.createExportDeclaration(
                 /*decorators*/ undefined, 
-                /*modifiers*/ undefined, node.isTypeOnly, factory.createNamedExports([factory.createExportSpecifier(/*propertyName*/ undefined, ts.idText(node.name))])));
+                /*modifiers*/ undefined, node.isTypeOnly, factory.createNamedExports([factory.createExportSpecifier(/*isTypeOnly*/ false, /*propertyName*/ undefined, ts.idText(node.name))])));
             }
             return statements;
         }
@@ -104204,7 +104344,7 @@ var ts;
             var exportDecl = ts.isExportNamespaceAsDefaultDeclaration(node) ? factory.createExportDefault(synthName) : factory.createExportDeclaration(
             /*decorators*/ undefined, 
             /*modifiers*/ undefined, 
-            /*isTypeOnly*/ false, factory.createNamedExports([factory.createExportSpecifier(synthName, oldIdentifier)]));
+            /*isTypeOnly*/ false, factory.createNamedExports([factory.createExportSpecifier(/*isTypeOnly*/ false, synthName, oldIdentifier)]));
             ts.setOriginalNode(exportDecl, node);
             return [importDecl, exportDecl];
         }
@@ -105771,7 +105911,7 @@ var ts;
                             /*modifiers*/ undefined, 
                             /*isTypeOnly*/ false, factory.createNamedExports(ts.map(exportMappings_1, function (_a) {
                                 var gen = _a[0], exp = _a[1];
-                                return factory.createExportSpecifier(gen, exp);
+                                return factory.createExportSpecifier(/*isTypeOnly*/ false, gen, exp);
                             }))));
                         }
                         var namespaceDecl = factory.createModuleDeclaration(/*decorators*/ undefined, ensureModifiers(input), input.name, factory.createModuleBlock(declarations), 16 /* Namespace */);
@@ -109710,6 +109850,10 @@ var ts;
             writePunctuation("}");
         }
         function emitImportOrExportSpecifier(node) {
+            if (node.isTypeOnly) {
+                writeKeyword("type");
+                writeSpace();
+            }
             if (node.propertyName) {
                 emit(node.propertyName);
                 writeSpace();
@@ -123750,6 +123894,10 @@ var ts;
         return node.kind === 151 /* TypeKeyword */;
     }
     ts.isTypeKeywordToken = isTypeKeywordToken;
+    function isTypeKeywordTokenOrIdentifier(node) {
+        return isTypeKeywordToken(node) || ts.isIdentifier(node) && node.text === "type";
+    }
+    ts.isTypeKeywordTokenOrIdentifier = isTypeKeywordTokenOrIdentifier;
     /** True if the symbol is for an external module, as opposed to a namespace. */
     function isExternalModuleSymbol(moduleSymbol) {
         return !!(moduleSymbol.flags & 1536 /* Module */) && moduleSymbol.name.charCodeAt(0) === 34 /* doubleQuote */;
@@ -126714,7 +126862,7 @@ var ts;
                         return convertPathCompletions(completion.paths);
                     case 1 /* Properties */: {
                         var entries = [];
-                        Completions.getCompletionEntriesFromSymbols(completion.symbols, entries, contextToken, sourceFile, sourceFile, checker, 99 /* ESNext */, log, 4 /* String */, preferences, options); // Target will not be used, so arbitrary
+                        Completions.getCompletionEntriesFromSymbols(completion.symbols, entries, contextToken, contextToken, sourceFile, sourceFile, checker, 99 /* ESNext */, log, 4 /* String */, preferences, options); // Target will not be used, so arbitrary
                         return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: completion.hasIndexSignature, optionalReplacementSpan: optionalReplacementSpan, entries: entries };
                     }
                     case 2 /* Types */: {
@@ -127486,6 +127634,7 @@ var ts;
             KeywordCompletionFilters[KeywordCompletionFilters["FunctionLikeBodyKeywords"] = 5] = "FunctionLikeBodyKeywords";
             KeywordCompletionFilters[KeywordCompletionFilters["TypeAssertionKeywords"] = 6] = "TypeAssertionKeywords";
             KeywordCompletionFilters[KeywordCompletionFilters["TypeKeywords"] = 7] = "TypeKeywords";
+            KeywordCompletionFilters[KeywordCompletionFilters["TypeKeyword"] = 8] = "TypeKeyword";
             KeywordCompletionFilters[KeywordCompletionFilters["Last"] = 7] = "Last";
         })(KeywordCompletionFilters || (KeywordCompletionFilters = {}));
         var GlobalsSearch;
@@ -127587,7 +127736,7 @@ var ts;
                 case 3 /* JsDocParameterName */:
                     return jsdocCompletionInfo(ts.JsDoc.getJSDocParameterNameCompletions(completionData.tag));
                 case 4 /* Keywords */:
-                    return specificKeywordCompletionInfo(completionData.keywords);
+                    return specificKeywordCompletionInfo(completionData.keywordCompletions, completionData.isNewIdentifierLocation);
                 default:
                     return ts.Debug.assertNever(completionData);
             }
@@ -127638,25 +127787,41 @@ var ts;
         function jsdocCompletionInfo(entries) {
             return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries: entries };
         }
-        function specificKeywordCompletionInfo(keywords) {
+        function keywordToCompletionEntry(keyword) {
+            return {
+                name: ts.tokenToString(keyword),
+                kind: "keyword" /* keyword */,
+                kindModifiers: "" /* none */,
+                sortText: SortText.GlobalsOrKeywords,
+            };
+        }
+        function specificKeywordCompletionInfo(entries, isNewIdentifierLocation) {
             return {
                 isGlobalCompletion: false,
                 isMemberCompletion: false,
-                isNewIdentifierLocation: false,
-                entries: keywords.map(function (k) { return ({
-                    name: ts.tokenToString(k),
-                    kind: "keyword" /* keyword */,
-                    kindModifiers: "" /* none */,
-                    sortText: SortText.GlobalsOrKeywords,
-                }); }),
+                isNewIdentifierLocation: isNewIdentifierLocation,
+                entries: entries.slice(),
             };
         }
+        function keywordCompletionData(keywordFilters, filterOutTsOnlyKeywords, isNewIdentifierLocation) {
+            return {
+                kind: 4 /* Keywords */,
+                keywordCompletions: getKeywordCompletions(keywordFilters, filterOutTsOnlyKeywords),
+                isNewIdentifierLocation: isNewIdentifierLocation,
+            };
+        }
+        function keywordFiltersFromSyntaxKind(keywordCompletion) {
+            switch (keywordCompletion) {
+                case 151 /* TypeKeyword */: return 8 /* TypeKeyword */;
+                default: ts.Debug.fail("Unknown mapping from SyntaxKind to KeywordCompletionFilters");
+            }
+        }
         function getOptionalReplacementSpan(location) {
             // StringLiteralLike locations are handled separately in stringCompletions.ts
             return (location === null || location === void 0 ? void 0 : location.kind) === 79 /* Identifier */ ? ts.createTextSpanFromNode(location) : undefined;
         }
         function completionInfoFromData(sourceFile, typeChecker, compilerOptions, log, completionData, preferences) {
-            var symbols = completionData.symbols, completionKind = completionData.completionKind, isInSnippetScope = completionData.isInSnippetScope, isNewIdentifierLocation = completionData.isNewIdentifierLocation, location = completionData.location, propertyAccessToConvert = completionData.propertyAccessToConvert, keywordFilters = completionData.keywordFilters, literals = completionData.literals, symbolToOriginInfoMap = completionData.symbolToOriginInfoMap, recommendedCompletion = completionData.recommendedCompletion, isJsxInitializer = completionData.isJsxInitializer, isTypeOnlyLocation = completionData.isTypeOnlyLocation, isJsxIdentifierExpected = completionData.isJsxIdentifierExpected, importCompletionNode = completionData.importCompletionNode, insideJsDocTagTypeExpression = completionData.insideJsDocTagTypeExpression, symbolToSortTextIdMap = completionData.symbolToSortTextIdMap, hasUnresolvedAutoImports = completionData.hasUnresolvedAutoImports;
+            var symbols = completionData.symbols, contextToken = completionData.contextToken, completionKind = completionData.completionKind, isInSnippetScope = completionData.isInSnippetScope, isNewIdentifierLocation = completionData.isNewIdentifierLocation, location = completionData.location, propertyAccessToConvert = completionData.propertyAccessToConvert, keywordFilters = completionData.keywordFilters, literals = completionData.literals, symbolToOriginInfoMap = completionData.symbolToOriginInfoMap, recommendedCompletion = completionData.recommendedCompletion, isJsxInitializer = completionData.isJsxInitializer, isTypeOnlyLocation = completionData.isTypeOnlyLocation, isJsxIdentifierExpected = completionData.isJsxIdentifierExpected, importCompletionNode = completionData.importCompletionNode, insideJsDocTagTypeExpression = completionData.insideJsDocTagTypeExpression, symbolToSortTextIdMap = completionData.symbolToSortTextIdMap, hasUnresolvedAutoImports = completionData.hasUnresolvedAutoImports;
             // Verify if the file is JSX language variant
             if (ts.getLanguageVariant(sourceFile.scriptKind) === 1 /* JSX */) {
                 var completionInfo = getJsxClosingTagCompletion(location, sourceFile);
@@ -127667,7 +127832,7 @@ var ts;
             var entries = [];
             if (isUncheckedFile(sourceFile, compilerOptions)) {
                 var uniqueNames = getCompletionEntriesFromSymbols(symbols, entries, 
-                /* contextToken */ undefined, location, sourceFile, typeChecker, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
+                /*replacementToken*/ undefined, contextToken, location, sourceFile, typeChecker, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
                 getJSCompletionEntries(sourceFile, location.pos, uniqueNames, ts.getEmitScriptTarget(compilerOptions), entries); // TODO: GH#18217
             }
             else {
@@ -127675,7 +127840,7 @@ var ts;
                     return undefined;
                 }
                 getCompletionEntriesFromSymbols(symbols, entries, 
-                /* contextToken */ undefined, location, sourceFile, typeChecker, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
+                /*replacementToken*/ undefined, contextToken, location, sourceFile, typeChecker, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
             }
             if (keywordFilters !== 0 /* None */) {
                 var entryNames = new ts.Set(entries.map(function (e) { return e.name; }));
@@ -127781,10 +127946,10 @@ var ts;
         function createCompletionEntryForLiteral(sourceFile, preferences, literal) {
             return { name: completionNameForLiteral(sourceFile, preferences, literal), kind: "string" /* string */, kindModifiers: "" /* none */, sortText: SortText.LocationPriority };
         }
-        function createCompletionEntry(symbol, sortText, contextToken, location, sourceFile, typeChecker, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, isTypeOnlyImport, useSemicolons, options, preferences) {
+        function createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, typeChecker, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, options, preferences) {
             var _a;
             var insertText;
-            var replacementSpan = ts.getReplacementSpanForContextToken(contextToken);
+            var replacementSpan = ts.getReplacementSpanForContextToken(replacementToken);
             var data;
             var isSnippet;
             var sourceDisplay;
@@ -127835,7 +128000,7 @@ var ts;
             if (originIsResolvedExport(origin)) {
                 sourceDisplay = [ts.textPart(origin.moduleSpecifier)];
                 if (importCompletionNode) {
-                    (_a = getInsertTextAndReplacementSpanForImportCompletion(name, importCompletionNode, isTypeOnlyImport, origin, useSemicolons, options, preferences), insertText = _a.insertText, replacementSpan = _a.replacementSpan);
+                    (_a = getInsertTextAndReplacementSpanForImportCompletion(name, importCompletionNode, contextToken, origin, useSemicolons, options, preferences), insertText = _a.insertText, replacementSpan = _a.replacementSpan);
                     isSnippet = preferences.includeCompletionsWithSnippetText ? true : undefined;
                 }
             }
@@ -127908,22 +128073,26 @@ var ts;
                 moduleSpecifier: originIsResolvedExport(origin) ? origin.moduleSpecifier : undefined,
             };
         }
-        function getInsertTextAndReplacementSpanForImportCompletion(name, importCompletionNode, isTypeOnly, origin, useSemicolons, options, preferences) {
+        function getInsertTextAndReplacementSpanForImportCompletion(name, importCompletionNode, contextToken, origin, useSemicolons, options, preferences) {
+            var _a, _b, _c;
             var sourceFile = importCompletionNode.getSourceFile();
-            var replacementSpan = ts.createTextSpanFromNode(importCompletionNode, sourceFile);
+            var replacementSpan = ts.createTextSpanFromNode(ts.findAncestor(importCompletionNode, ts.or(ts.isImportDeclaration, ts.isImportEqualsDeclaration)) || importCompletionNode, sourceFile);
             var quotedModuleSpecifier = ts.quote(sourceFile, preferences, origin.moduleSpecifier);
             var exportKind = origin.isDefaultExport ? 1 /* Default */ :
                 origin.exportName === "export=" /* ExportEquals */ ? 2 /* ExportEquals */ :
                     0 /* Named */;
             var tabStop = preferences.includeCompletionsWithSnippetText ? "$1" : "";
             var importKind = ts.codefix.getImportKind(sourceFile, exportKind, options, /*forceImportKeyword*/ true);
-            var typeOnlyPrefix = isTypeOnly ? " " + ts.tokenToString(151 /* TypeKeyword */) + " " : " ";
+            var isTopLevelTypeOnly = ((_b = (_a = ts.tryCast(importCompletionNode, ts.isImportDeclaration)) === null || _a === void 0 ? void 0 : _a.importClause) === null || _b === void 0 ? void 0 : _b.isTypeOnly) || ((_c = ts.tryCast(importCompletionNode, ts.isImportEqualsDeclaration)) === null || _c === void 0 ? void 0 : _c.isTypeOnly);
+            var isImportSpecifierTypeOnly = couldBeTypeOnlyImportSpecifier(importCompletionNode, contextToken);
+            var topLevelTypeOnlyText = isTopLevelTypeOnly ? " " + ts.tokenToString(151 /* TypeKeyword */) + " " : " ";
+            var importSpecifierTypeOnlyText = isImportSpecifierTypeOnly ? ts.tokenToString(151 /* TypeKeyword */) + " " : "";
             var suffix = useSemicolons ? ";" : "";
             switch (importKind) {
-                case 3 /* CommonJS */: return { replacementSpan: replacementSpan, insertText: "import" + typeOnlyPrefix + escapeSnippetText(name) + tabStop + " = require(" + quotedModuleSpecifier + ")" + suffix };
-                case 1 /* Default */: return { replacementSpan: replacementSpan, insertText: "import" + typeOnlyPrefix + escapeSnippetText(name) + tabStop + " from " + quotedModuleSpecifier + suffix };
-                case 2 /* Namespace */: return { replacementSpan: replacementSpan, insertText: "import" + typeOnlyPrefix + "* as " + escapeSnippetText(name) + " from " + quotedModuleSpecifier + suffix };
-                case 0 /* Named */: return { replacementSpan: replacementSpan, insertText: "import" + typeOnlyPrefix + "{ " + escapeSnippetText(name) + tabStop + " } from " + quotedModuleSpecifier + suffix };
+                case 3 /* CommonJS */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + escapeSnippetText(name) + tabStop + " = require(" + quotedModuleSpecifier + ")" + suffix };
+                case 1 /* Default */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + escapeSnippetText(name) + tabStop + " from " + quotedModuleSpecifier + suffix };
+                case 2 /* Namespace */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + "* as " + escapeSnippetText(name) + " from " + quotedModuleSpecifier + suffix };
+                case 0 /* Named */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + "{ " + importSpecifierTypeOnlyText + escapeSnippetText(name) + tabStop + " } from " + quotedModuleSpecifier + suffix };
             }
         }
         function quotePropertyName(sourceFile, preferences, name) {
@@ -127947,12 +128116,11 @@ var ts;
                 return CompletionSource.ThisProperty;
             }
         }
-        function getCompletionEntriesFromSymbols(symbols, entries, contextToken, location, sourceFile, typeChecker, target, log, kind, preferences, compilerOptions, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap) {
+        function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, sourceFile, typeChecker, target, log, kind, preferences, compilerOptions, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap) {
             var _a;
             var start = ts.timestamp();
             var variableDeclaration = getVariableDeclaration(location);
             var useSemicolons = ts.probablyUsesSemicolons(sourceFile);
-            var isTypeOnlyImport = !!importCompletionNode && ts.isTypeOnlyImportOrExportDeclaration(location.parent);
             // Tracks unique names.
             // Value is set to false for global variables or completions from external module exports, because we can have multiple of those;
             // true otherwise. Based on the order we add things we will always see locals first, then globals, then module exports.
@@ -127968,7 +128136,7 @@ var ts;
                 var name = info.name, needsConvertPropertyAccess = info.needsConvertPropertyAccess;
                 var sortTextId = (_a = symbolToSortTextIdMap === null || symbolToSortTextIdMap === void 0 ? void 0 : symbolToSortTextIdMap[ts.getSymbolId(symbol)]) !== null && _a !== void 0 ? _a : 11 /* LocationPriority */;
                 var sortText = (isDeprecated(symbol, typeChecker) ? 8 /* DeprecatedOffset */ + sortTextId : sortTextId).toString();
-                var entry = createCompletionEntry(symbol, sortText, contextToken, location, sourceFile, typeChecker, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, isTypeOnlyImport, useSemicolons, compilerOptions, preferences);
+                var entry = createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, typeChecker, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, compilerOptions, preferences);
                 if (!entry) {
                     continue;
                 }
@@ -128117,7 +128285,7 @@ var ts;
                         case 3 /* JsDocParameterName */:
                             return ts.JsDoc.getJSDocParameterNameCompletionDetails(name);
                         case 4 /* Keywords */:
-                            return request.keywords.indexOf(ts.stringToToken(name)) > -1 ? createSimpleDetails(name, "keyword" /* keyword */, ts.SymbolDisplayPartKind.keyword) : undefined;
+                            return ts.some(request.keywordCompletions, function (c) { return c.name === name; }) ? createSimpleDetails(name, "keyword" /* keyword */, ts.SymbolDisplayPartKind.keyword) : undefined;
                         default:
                             return ts.Debug.assertNever(request);
                     }
@@ -128156,7 +128324,7 @@ var ts;
         function getCompletionEntryCodeActionsAndSourceDisplay(origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken, formatContext, preferences, data) {
             if (data === null || data === void 0 ? void 0 : data.moduleSpecifier) {
                 var _a = getRelevantTokens(position, sourceFile), contextToken = _a.contextToken, previousToken_1 = _a.previousToken;
-                if (previousToken_1 && getImportCompletionNode(contextToken || previousToken_1)) {
+                if (previousToken_1 && getImportStatementCompletionInfo(contextToken || previousToken_1).replacementNode) {
                     // Import statement completion: 'import c|'
                     return { codeActions: undefined, sourceDisplay: [ts.textPart(data.moduleSpecifier)] };
                 }
@@ -128319,6 +128487,7 @@ var ts;
             start = ts.timestamp();
             // The decision to provide completion depends on the contextToken, which is determined through the previousToken.
             // Note: 'previousToken' (and thus 'contextToken') can be undefined if we are the beginning of the file
+            var isJsOnlyLocation = !insideJsDocTagTypeExpression && ts.isSourceFileJS(sourceFile);
             var tokens = getRelevantTokens(position, sourceFile);
             var previousToken = tokens.previousToken;
             var contextToken = tokens.contextToken;
@@ -128336,22 +128505,34 @@ var ts;
             var isJsxIdentifierExpected = false;
             var importCompletionNode;
             var location = ts.getTouchingPropertyName(sourceFile, position);
+            var keywordFilters = 0 /* None */;
+            var isNewIdentifierLocation = false;
             if (contextToken) {
-                var importCompletionCandidate = getImportCompletionNode(contextToken);
-                if (importCompletionCandidate === 155 /* FromKeyword */) {
-                    return { kind: 4 /* Keywords */, keywords: [155 /* FromKeyword */] };
+                var importStatementCompletion = getImportStatementCompletionInfo(contextToken);
+                isNewIdentifierLocation = importStatementCompletion.isNewIdentifierLocation;
+                if (importStatementCompletion.keywordCompletion) {
+                    if (importStatementCompletion.isKeywordOnlyCompletion) {
+                        return {
+                            kind: 4 /* Keywords */,
+                            keywordCompletions: [keywordToCompletionEntry(importStatementCompletion.keywordCompletion)],
+                            isNewIdentifierLocation: isNewIdentifierLocation,
+                        };
+                    }
+                    keywordFilters = keywordFiltersFromSyntaxKind(importStatementCompletion.keywordCompletion);
                 }
-                // Import statement completions use `insertText`, and also require the `data` property of `CompletionEntryIdentifier`
-                // added in TypeScript 4.3 to be sent back from the client during `getCompletionEntryDetails`. Since this feature
-                // is not backward compatible with older clients, the language service defaults to disabling it, allowing newer clients
-                // to opt in with the `includeCompletionsForImportStatements` user preference.
-                if (importCompletionCandidate && preferences.includeCompletionsForImportStatements && preferences.includeCompletionsWithInsertText) {
-                    importCompletionNode = importCompletionCandidate;
+                if (importStatementCompletion.replacementNode && preferences.includeCompletionsForImportStatements && preferences.includeCompletionsWithInsertText) {
+                    // Import statement completions use `insertText`, and also require the `data` property of `CompletionEntryIdentifier`
+                    // added in TypeScript 4.3 to be sent back from the client during `getCompletionEntryDetails`. Since this feature
+                    // is not backward compatible with older clients, the language service defaults to disabling it, allowing newer clients
+                    // to opt in with the `includeCompletionsForImportStatements` user preference.
+                    importCompletionNode = importStatementCompletion.replacementNode;
                 }
                 // Bail out if this is a known invalid completion location
                 if (!importCompletionNode && isCompletionListBlocker(contextToken)) {
                     log("Returning an empty list because completion was requested in an invalid position.");
-                    return undefined;
+                    return keywordFilters
+                        ? keywordCompletionData(keywordFilters, isJsOnlyLocation, isNewIdentifierDefinitionLocation())
+                        : undefined;
                 }
                 var parent = contextToken.parent;
                 if (contextToken.kind === 24 /* DotToken */ || contextToken.kind === 28 /* QuestionDotToken */) {
@@ -128471,10 +128652,8 @@ var ts;
             }
             var semanticStart = ts.timestamp();
             var completionKind = 5 /* None */;
-            var isNewIdentifierLocation = false;
             var isNonContextualObjectLiteral = false;
             var hasUnresolvedAutoImports = false;
-            var keywordFilters = 0 /* None */;
             // This also gets mutated in nested-functions after the return
             var symbols = [];
             var symbolToOriginInfoMap = [];
@@ -128508,7 +128687,9 @@ var ts;
                 // global symbols in scope.  These results should be valid for either language as
                 // the set of symbols that can be referenced from this location.
                 if (!tryGetGlobalSymbols()) {
-                    return undefined;
+                    return keywordFilters
+                        ? keywordCompletionData(keywordFilters, isJsOnlyLocation, isNewIdentifierLocation)
+                        : undefined;
                 }
             }
             log("getCompletionData: Semantic work: " + (ts.timestamp() - semanticStart));
@@ -128528,6 +128709,7 @@ var ts;
                 symbolToOriginInfoMap: symbolToOriginInfoMap,
                 recommendedCompletion: recommendedCompletion,
                 previousToken: previousToken,
+                contextToken: contextToken,
                 isJsxInitializer: isJsxInitializer,
                 insideJsDocTagTypeExpression: insideJsDocTagTypeExpression,
                 symbolToSortTextIdMap: symbolToSortTextIdMap,
@@ -128914,8 +129096,14 @@ var ts;
                     // Asking for completion details for an item that is not an auto-import
                     return;
                 }
+                // import { type | -> token text should be blank
+                var isAfterTypeOnlyImportSpecifierModifier = previousToken === contextToken
+                    && importCompletionNode
+                    && couldBeTypeOnlyImportSpecifier(importCompletionNode, contextToken);
+                var lowerCaseTokenText = isAfterTypeOnlyImportSpecifierModifier ? "" :
+                    previousToken && ts.isIdentifier(previousToken) ? previousToken.text.toLowerCase() :
+                        "";
                 var moduleSpecifierCache = (_a = host.getModuleSpecifierCache) === null || _a === void 0 ? void 0 : _a.call(host);
-                var lowerCaseTokenText = previousToken && ts.isIdentifier(previousToken) ? previousToken.text.toLowerCase() : "";
                 var exportInfo = ts.getExportInfoMap(sourceFile, host, program, cancellationToken);
                 var packageJsonAutoImportProvider = (_b = host.getPackageJsonAutoImportProvider) === null || _b === void 0 ? void 0 : _b.call(host);
                 var packageJsonFilter = detailsEntryId ? undefined : ts.createPackageJsonImportFilter(sourceFile, preferences, host);
@@ -129048,6 +129236,7 @@ var ts;
                                 || containingNodeKind === 161 /* ComputedPropertyName */; // [ |    /* this can become an index signature */
                         case 141 /* ModuleKeyword */: // module |
                         case 142 /* NamespaceKeyword */: // namespace |
+                        case 100 /* ImportKeyword */: // import |
                             return true;
                         case 24 /* DotToken */:
                             return containingNodeKind === 260 /* ModuleDeclaration */; // module A.|
@@ -129186,23 +129375,38 @@ var ts;
              * Relevant symbols are stored in the captured 'symbols' variable.
              */
             function tryGetImportOrExportClauseCompletionSymbols() {
-                // `import { |` or `import { a as 0, | }`
-                var namedImportsOrExports = contextToken && (contextToken.kind === 18 /* OpenBraceToken */ || contextToken.kind === 27 /* CommaToken */)
-                    ? ts.tryCast(contextToken.parent, ts.isNamedImportsOrExports) : undefined;
+                if (!contextToken)
+                    return 0 /* Continue */;
+                // `import { |` or `import { a as 0, | }` or `import { type | }`
+                var namedImportsOrExports = contextToken.kind === 18 /* OpenBraceToken */ || contextToken.kind === 27 /* CommaToken */ ? ts.tryCast(contextToken.parent, ts.isNamedImportsOrExports) :
+                    ts.isTypeKeywordTokenOrIdentifier(contextToken) ? ts.tryCast(contextToken.parent.parent, ts.isNamedImportsOrExports) : undefined;
                 if (!namedImportsOrExports)
                     return 0 /* Continue */;
+                // We can at least offer `type` at `import { |`
+                if (!ts.isTypeKeywordTokenOrIdentifier(contextToken)) {
+                    keywordFilters = 8 /* TypeKeyword */;
+                }
                 // try to show exported member for imported/re-exported module
                 var moduleSpecifier = (namedImportsOrExports.kind === 268 /* NamedImports */ ? namedImportsOrExports.parent.parent : namedImportsOrExports.parent).moduleSpecifier;
-                if (!moduleSpecifier)
+                if (!moduleSpecifier) {
+                    isNewIdentifierLocation = true;
                     return namedImportsOrExports.kind === 268 /* NamedImports */ ? 2 /* Fail */ : 0 /* Continue */;
+                }
                 var moduleSpecifierSymbol = typeChecker.getSymbolAtLocation(moduleSpecifier); // TODO: GH#18217
-                if (!moduleSpecifierSymbol)
+                if (!moduleSpecifierSymbol) {
+                    isNewIdentifierLocation = true;
                     return 2 /* Fail */;
+                }
                 completionKind = 3 /* MemberLike */;
                 isNewIdentifierLocation = false;
                 var exports = typeChecker.getExportsAndPropertiesOfModule(moduleSpecifierSymbol);
                 var existing = new ts.Set(namedImportsOrExports.elements.filter(function (n) { return !isCurrentlyEditingNode(n); }).map(function (n) { return (n.propertyName || n.name).escapedText; }));
-                symbols = ts.concatenate(symbols, exports.filter(function (e) { return e.escapedName !== "default" /* Default */ && !existing.has(e.escapedName); }));
+                var uniques = exports.filter(function (e) { return e.escapedName !== "default" /* Default */ && !existing.has(e.escapedName); });
+                symbols = ts.concatenate(symbols, uniques);
+                if (!uniques.length) {
+                    // If there's nothing else to import, don't offer `type` either
+                    keywordFilters = 0 /* None */;
+                }
                 return 1 /* Success */;
             }
             /**
@@ -129463,6 +129667,14 @@ var ts;
                     case 136 /* GetKeyword */:
                     case 148 /* SetKeyword */:
                         return !isFromObjectTypeDeclaration(contextToken);
+                    case 79 /* Identifier */:
+                        if (containingNodeKind === 269 /* ImportSpecifier */ &&
+                            contextToken === parent.name &&
+                            contextToken.text === "type") {
+                            // import { type | }
+                            return false;
+                        }
+                        break;
                     case 84 /* ClassKeyword */:
                     case 92 /* EnumKeyword */:
                     case 118 /* InterfaceKeyword */:
@@ -129472,8 +129684,10 @@ var ts;
                     case 119 /* LetKeyword */:
                     case 85 /* ConstKeyword */:
                     case 137 /* InferKeyword */:
-                    case 151 /* TypeKeyword */: // type htm|
                         return true;
+                    case 151 /* TypeKeyword */:
+                        // import { type foo| }
+                        return containingNodeKind !== 269 /* ImportSpecifier */;
                     case 41 /* AsteriskToken */:
                         return ts.isFunctionLike(contextToken.parent) && !ts.isMethodDeclaration(contextToken.parent);
                 }
@@ -129834,6 +130048,8 @@ var ts;
                         return ts.isTypeKeyword(kind) || kind === 85 /* ConstKeyword */;
                     case 7 /* TypeKeywords */:
                         return ts.isTypeKeyword(kind);
+                    case 8 /* TypeKeyword */:
+                        return kind === 151 /* TypeKeyword */;
                     default:
                         return ts.Debug.assertNever(keywordFilter);
                 }
@@ -130107,34 +130323,67 @@ var ts;
             }
             return undefined;
         }
-        function getImportCompletionNode(contextToken) {
+        function getImportStatementCompletionInfo(contextToken) {
+            var keywordCompletion;
+            var isKeywordOnlyCompletion = false;
             var candidate = getCandidate();
-            return candidate === 155 /* FromKeyword */ || candidate && ts.rangeIsOnSingleLine(candidate, candidate.getSourceFile()) ? candidate : undefined;
+            return {
+                isKeywordOnlyCompletion: isKeywordOnlyCompletion,
+                keywordCompletion: keywordCompletion,
+                isNewIdentifierLocation: !!(candidate || keywordCompletion === 151 /* TypeKeyword */),
+                replacementNode: candidate && ts.rangeIsOnSingleLine(candidate, candidate.getSourceFile())
+                    ? candidate
+                    : undefined
+            };
             function getCandidate() {
                 var parent = contextToken.parent;
                 if (ts.isImportEqualsDeclaration(parent)) {
+                    keywordCompletion = contextToken.kind === 151 /* TypeKeyword */ ? undefined : 151 /* TypeKeyword */;
                     return isModuleSpecifierMissingOrEmpty(parent.moduleReference) ? parent : undefined;
                 }
+                if (couldBeTypeOnlyImportSpecifier(parent, contextToken) && canCompleteFromNamedBindings(parent.parent)) {
+                    return parent;
+                }
                 if (ts.isNamedImports(parent) || ts.isNamespaceImport(parent)) {
-                    if (isModuleSpecifierMissingOrEmpty(parent.parent.parent.moduleSpecifier) && (ts.isNamespaceImport(parent) || parent.elements.length < 2) && !parent.parent.name) {
+                    if (!parent.parent.isTypeOnly && (contextToken.kind === 18 /* OpenBraceToken */ ||
+                        contextToken.kind === 100 /* ImportKeyword */ ||
+                        contextToken.kind === 27 /* CommaToken */)) {
+                        keywordCompletion = 151 /* TypeKeyword */;
+                    }
+                    if (canCompleteFromNamedBindings(parent)) {
                         // At `import { ... } |` or `import * as Foo |`, the only possible completion is `from`
-                        return contextToken.kind === 19 /* CloseBraceToken */ || contextToken.kind === 79 /* Identifier */
-                            ? 155 /* FromKeyword */
-                            : parent.parent.parent;
+                        if (contextToken.kind === 19 /* CloseBraceToken */ || contextToken.kind === 79 /* Identifier */) {
+                            isKeywordOnlyCompletion = true;
+                            keywordCompletion = 155 /* FromKeyword */;
+                        }
+                        else {
+                            return parent.parent.parent;
+                        }
                     }
                     return undefined;
                 }
                 if (ts.isImportKeyword(contextToken) && ts.isSourceFile(parent)) {
                     // A lone import keyword with nothing following it does not parse as a statement at all
+                    keywordCompletion = 151 /* TypeKeyword */;
                     return contextToken;
                 }
                 if (ts.isImportKeyword(contextToken) && ts.isImportDeclaration(parent)) {
                     // `import s| from`
+                    keywordCompletion = 151 /* TypeKeyword */;
                     return isModuleSpecifierMissingOrEmpty(parent.moduleSpecifier) ? parent : undefined;
                 }
                 return undefined;
             }
         }
+        function couldBeTypeOnlyImportSpecifier(importSpecifier, contextToken) {
+            return ts.isImportSpecifier(importSpecifier)
+                && (importSpecifier.isTypeOnly || contextToken === importSpecifier.name && ts.isTypeKeywordTokenOrIdentifier(contextToken));
+        }
+        function canCompleteFromNamedBindings(namedBindings) {
+            return isModuleSpecifierMissingOrEmpty(namedBindings.parent.parent.moduleSpecifier)
+                && (ts.isNamespaceImport(namedBindings) || namedBindings.elements.length < 2)
+                && !namedBindings.parent.name;
+        }
         function isModuleSpecifierMissingOrEmpty(specifier) {
             var _a;
             if (ts.nodeIsMissing(specifier))
@@ -136274,7 +136523,7 @@ var ts;
                 else {
                     for (var _e = 0, defaultImports_1 = defaultImports; _e < defaultImports_1.length; _e++) {
                         var defaultImport = defaultImports_1[_e];
-                        newImportSpecifiers.push(ts.factory.createImportSpecifier(ts.factory.createIdentifier("default"), defaultImport.importClause.name)); // TODO: GH#18217
+                        newImportSpecifiers.push(ts.factory.createImportSpecifier(/*isTypeOnly*/ false, ts.factory.createIdentifier("default"), defaultImport.importClause.name)); // TODO: GH#18217
                     }
                 }
                 newImportSpecifiers.push.apply(newImportSpecifiers, ts.flatMap(namedImports, function (i) { return i.importClause.namedBindings.elements; })); // TODO: GH#18217
@@ -136408,7 +136657,8 @@ var ts;
             return ts.stableSort(specifiers, compareImportOrExportSpecifiers);
         }
         function compareImportOrExportSpecifiers(s1, s2) {
-            return compareIdentifiers(s1.propertyName || s1.name, s2.propertyName || s2.name)
+            return ts.compareBooleans(s1.isTypeOnly, s2.isTypeOnly)
+                || compareIdentifiers(s1.propertyName || s1.name, s2.propertyName || s2.name)
                 || compareIdentifiers(s1.name, s2.name);
         }
         OrganizeImports.compareImportOrExportSpecifiers = compareImportOrExportSpecifiers;
@@ -146566,7 +146816,7 @@ var ts;
                 */
                 var newNodes = [
                     makeConst(/*modifiers*/ undefined, rename, assignment.right),
-                    makeExportDeclaration([ts.factory.createExportSpecifier(rename, text)]),
+                    makeExportDeclaration([ts.factory.createExportSpecifier(/*isTypeOnly*/ false, rename, text)]),
                 ];
                 changes.replaceNodeWithNodes(sourceFile, assignment.parent, newNodes);
             }
@@ -146588,7 +146838,7 @@ var ts;
             return makeExportDeclaration(/*exportClause*/ undefined, moduleSpecifier);
         }
         function reExportDefault(moduleSpecifier) {
-            return makeExportDeclaration([ts.factory.createExportSpecifier(/*propertyName*/ undefined, "default")], moduleSpecifier);
+            return makeExportDeclaration([ts.factory.createExportSpecifier(/*isTypeOnly*/ false, /*propertyName*/ undefined, "default")], moduleSpecifier);
         }
         function convertExportsPropertyAssignment(_a, sourceFile, changes) {
             var left = _a.left, right = _a.right, parent = _a.parent;
@@ -146730,7 +146980,7 @@ var ts;
             }
             var namedBindings = namedBindingsNames.size === 0 ? undefined : ts.arrayFrom(ts.mapIterator(namedBindingsNames.entries(), function (_a) {
                 var propertyName = _a[0], idName = _a[1];
-                return ts.factory.createImportSpecifier(propertyName === idName ? undefined : ts.factory.createIdentifier(propertyName), ts.factory.createIdentifier(idName));
+                return ts.factory.createImportSpecifier(/*isTypeOnly*/ false, propertyName === idName ? undefined : ts.factory.createIdentifier(propertyName), ts.factory.createIdentifier(idName));
             }));
             if (!namedBindings) {
                 // If it was unused, ensure that we at least import *something*.
@@ -146788,7 +147038,7 @@ var ts;
                 : ts.makeImport(/*name*/ undefined, [makeImportSpecifier(propertyName, localName)], moduleSpecifier, quotePreference);
         }
         function makeImportSpecifier(propertyName, name) {
-            return ts.factory.createImportSpecifier(propertyName !== undefined && propertyName !== name ? ts.factory.createIdentifier(propertyName) : undefined, ts.factory.createIdentifier(name));
+            return ts.factory.createImportSpecifier(/*isTypeOnly*/ false, propertyName !== undefined && propertyName !== name ? ts.factory.createIdentifier(propertyName) : undefined, ts.factory.createIdentifier(name));
         }
         function makeConst(modifiers, name, init) {
             return ts.factory.createVariableStatement(modifiers, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(name, /*exclamationToken*/ undefined, /*type*/ undefined, init)], 2 /* Const */));
@@ -147113,13 +147363,13 @@ var ts;
         codefix.registerCodeFix({
             errorCodes: errorCodes,
             getCodeActions: function (context) {
-                var errorCode = context.errorCode, preferences = context.preferences, sourceFile = context.sourceFile, span = context.span;
+                var errorCode = context.errorCode, preferences = context.preferences, sourceFile = context.sourceFile, span = context.span, program = context.program;
                 var info = getFixesInfo(context, errorCode, span.start, /*useAutoImportProvider*/ true);
                 if (!info)
                     return undefined;
                 var fixes = info.fixes, symbolName = info.symbolName;
                 var quotePreference = ts.getQuotePreference(sourceFile, preferences);
-                return fixes.map(function (fix) { return codeActionForFix(context, sourceFile, symbolName, fix, quotePreference); });
+                return fixes.map(function (fix) { return codeActionForFix(context, sourceFile, symbolName, fix, quotePreference, program.getCompilerOptions()); });
             },
             fixIds: [importFixId],
             getAllCodeActions: function (context) {
@@ -147138,8 +147388,9 @@ var ts;
             // Namespace fixes don't conflict, so just build a list.
             var addToNamespace = [];
             var importType = [];
-            // Keys are import clause node IDs.
+            /** Keys are import clause node IDs. */
             var addToExisting = new ts.Map();
+            /** Use `getNewImportEntry` for access */
             var newImports = new ts.Map();
             return { addImportFromDiagnostic: addImportFromDiagnostic, addImportFromExportedSymbol: addImportFromExportedSymbol, writeFixes: writeFixes };
             function addImportFromDiagnostic(diagnostic, context) {
@@ -147148,67 +147399,66 @@ var ts;
                     return;
                 addImport(info);
             }
-            function addImportFromExportedSymbol(exportedSymbol, usageIsTypeOnly) {
+            function addImportFromExportedSymbol(exportedSymbol, isValidTypeOnlyUseSite) {
                 var moduleSymbol = ts.Debug.checkDefined(exportedSymbol.parent);
                 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 preferTypeOnlyImport = !!usageIsTypeOnly && compilerOptions.importsNotUsedAsValues === 2 /* Error */;
                 var useRequire = shouldUseRequire(sourceFile, program);
-                var fix = getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, /*position*/ undefined, preferTypeOnlyImport, useRequire, host, preferences);
+                var fix = getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, /*position*/ undefined, !!isValidTypeOnlyUseSite, useRequire, host, preferences);
                 if (fix) {
                     addImport({ fixes: [fix], symbolName: symbolName });
                 }
             }
             function addImport(info) {
+                var _a, _b;
                 var fixes = info.fixes, symbolName = info.symbolName;
                 var fix = ts.first(fixes);
                 switch (fix.kind) {
                     case 0 /* UseNamespace */:
                         addToNamespace.push(fix);
                         break;
-                    case 1 /* ImportType */:
+                    case 1 /* JsdocTypeImport */:
                         importType.push(fix);
                         break;
                     case 2 /* AddToExisting */: {
-                        var importClauseOrBindingPattern = fix.importClauseOrBindingPattern, importKind = fix.importKind, canUseTypeOnlyImport = fix.canUseTypeOnlyImport;
+                        var importClauseOrBindingPattern = fix.importClauseOrBindingPattern, importKind = fix.importKind, addAsTypeOnly = fix.addAsTypeOnly;
                         var key = String(ts.getNodeId(importClauseOrBindingPattern));
                         var entry = addToExisting.get(key);
                         if (!entry) {
-                            addToExisting.set(key, entry = { importClauseOrBindingPattern: importClauseOrBindingPattern, defaultImport: undefined, namedImports: [], canUseTypeOnlyImport: canUseTypeOnlyImport });
+                            addToExisting.set(key, entry = { importClauseOrBindingPattern: importClauseOrBindingPattern, defaultImport: undefined, namedImports: new ts.Map() });
                         }
                         if (importKind === 0 /* Named */) {
-                            ts.pushIfUnique(entry.namedImports, symbolName);
+                            var prevValue = entry === null || entry === void 0 ? void 0 : entry.namedImports.get(symbolName);
+                            entry.namedImports.set(symbolName, reduceAddAsTypeOnlyValues(prevValue, addAsTypeOnly));
                         }
                         else {
-                            ts.Debug.assert(entry.defaultImport === undefined || entry.defaultImport === symbolName, "(Add to Existing) Default import should be missing or match symbolName");
-                            entry.defaultImport = symbolName;
+                            ts.Debug.assert(entry.defaultImport === undefined || entry.defaultImport.name === symbolName, "(Add to Existing) Default import should be missing or match symbolName");
+                            entry.defaultImport = {
+                                name: symbolName,
+                                addAsTypeOnly: reduceAddAsTypeOnlyValues((_a = entry.defaultImport) === null || _a === void 0 ? void 0 : _a.addAsTypeOnly, addAsTypeOnly),
+                            };
                         }
                         break;
                     }
                     case 3 /* AddNew */: {
-                        var moduleSpecifier = fix.moduleSpecifier, importKind = fix.importKind, useRequire = fix.useRequire, typeOnly = fix.typeOnly;
-                        var entry = newImports.get(moduleSpecifier);
-                        if (!entry) {
-                            newImports.set(moduleSpecifier, entry = { namedImports: [], namespaceLikeImport: undefined, typeOnly: typeOnly, useRequire: useRequire });
-                        }
-                        else {
-                            // An import clause can only be type-only if every import fix contributing to it can be type-only.
-                            entry.typeOnly = entry.typeOnly && typeOnly;
-                        }
+                        var moduleSpecifier = fix.moduleSpecifier, importKind = fix.importKind, useRequire = fix.useRequire, addAsTypeOnly = fix.addAsTypeOnly;
+                        var entry = getNewImportEntry(moduleSpecifier, importKind, useRequire, addAsTypeOnly);
+                        ts.Debug.assert(entry.useRequire === useRequire, "(Add new) Tried to add an `import` and a `require` for the same module");
                         switch (importKind) {
                             case 1 /* Default */:
-                                ts.Debug.assert(entry.defaultImport === undefined || entry.defaultImport === symbolName, "(Add new) Default import should be missing or match symbolName");
-                                entry.defaultImport = symbolName;
+                                ts.Debug.assert(entry.defaultImport === undefined || entry.defaultImport.name === symbolName, "(Add new) Default import should be missing or match symbolName");
+                                entry.defaultImport = { name: symbolName, addAsTypeOnly: reduceAddAsTypeOnlyValues((_b = entry.defaultImport) === null || _b === void 0 ? void 0 : _b.addAsTypeOnly, addAsTypeOnly) };
                                 break;
                             case 0 /* Named */:
-                                ts.pushIfUnique(entry.namedImports || (entry.namedImports = []), symbolName);
+                                var prevValue = (entry.namedImports || (entry.namedImports = new ts.Map())).get(symbolName);
+                                entry.namedImports.set(symbolName, reduceAddAsTypeOnlyValues(prevValue, addAsTypeOnly));
                                 break;
                             case 3 /* CommonJS */:
                             case 2 /* Namespace */:
                                 ts.Debug.assert(entry.namespaceLikeImport === undefined || entry.namespaceLikeImport.name === symbolName, "Namespacelike import shoudl be missing or match symbolName");
-                                entry.namespaceLikeImport = { importKind: importKind, name: symbolName };
+                                entry.namespaceLikeImport = { importKind: importKind, name: symbolName, addAsTypeOnly: addAsTypeOnly };
                                 break;
                         }
                         break;
@@ -147216,6 +147466,50 @@ var ts;
                     default:
                         ts.Debug.assertNever(fix, "fix wasn't never - got kind " + fix.kind);
                 }
+                function reduceAddAsTypeOnlyValues(prevValue, newValue) {
+                    // `NotAllowed` overrides `Required` because one addition of a new import might be required to be type-only
+                    // because of `--importsNotUsedAsValues=error`, but if a second addition of the same import is `NotAllowed`
+                    // to be type-only, the reason the first one was `Required` - the unused runtime dependency - is now moot.
+                    // Alternatively, if one addition is `Required` because it has no value meaning under `--preserveValueImports`
+                    // and `--isolatedModules`, it should be impossible for another addition to be `NotAllowed` since that would
+                    // mean a type is being referenced in a value location.
+                    return Math.max(prevValue !== null && prevValue !== void 0 ? prevValue : 0, newValue);
+                }
+                function getNewImportEntry(moduleSpecifier, importKind, useRequire, addAsTypeOnly) {
+                    // A default import that requires type-only makes the whole import type-only.
+                    // (We could add `default` as a named import, but that style seems undesirable.)
+                    // Under `--preserveValueImports` and `--importsNotUsedAsValues=error`, if a
+                    // module default-exports a type but named-exports some values (weird), you would
+                    // have to use a type-only default import and non-type-only named imports. These
+                    // require two separate import declarations, so we build this into the map key.
+                    var typeOnlyKey = newImportsKey(moduleSpecifier, /*topLevelTypeOnly*/ true);
+                    var nonTypeOnlyKey = newImportsKey(moduleSpecifier, /*topLevelTypeOnly*/ false);
+                    var typeOnlyEntry = newImports.get(typeOnlyKey);
+                    var nonTypeOnlyEntry = newImports.get(nonTypeOnlyKey);
+                    var newEntry = {
+                        defaultImport: undefined,
+                        namedImports: undefined,
+                        namespaceLikeImport: undefined,
+                        useRequire: useRequire
+                    };
+                    if (importKind === 1 /* Default */ && addAsTypeOnly === 2 /* Required */) {
+                        if (typeOnlyEntry)
+                            return typeOnlyEntry;
+                        newImports.set(typeOnlyKey, newEntry);
+                        return newEntry;
+                    }
+                    if (addAsTypeOnly === 1 /* Allowed */ && (typeOnlyEntry || nonTypeOnlyEntry)) {
+                        return (typeOnlyEntry || nonTypeOnlyEntry);
+                    }
+                    if (nonTypeOnlyEntry) {
+                        return nonTypeOnlyEntry;
+                    }
+                    newImports.set(nonTypeOnlyKey, newEntry);
+                    return newEntry;
+                }
+                function newImportsKey(moduleSpecifier, topLevelTypeOnly) {
+                    return (topLevelTypeOnly ? 1 : 0) + "|" + moduleSpecifier;
+                }
             }
             function writeFixes(changeTracker) {
                 var quotePreference = ts.getQuotePreference(sourceFile, preferences);
@@ -147228,14 +147522,22 @@ var ts;
                     addImportType(changeTracker, sourceFile, fix, quotePreference);
                 }
                 addToExisting.forEach(function (_a) {
-                    var importClauseOrBindingPattern = _a.importClauseOrBindingPattern, defaultImport = _a.defaultImport, namedImports = _a.namedImports, canUseTypeOnlyImport = _a.canUseTypeOnlyImport;
-                    doAddExistingFix(changeTracker, sourceFile, importClauseOrBindingPattern, defaultImport, namedImports, canUseTypeOnlyImport);
+                    var importClauseOrBindingPattern = _a.importClauseOrBindingPattern, defaultImport = _a.defaultImport, namedImports = _a.namedImports;
+                    doAddExistingFix(changeTracker, sourceFile, importClauseOrBindingPattern, defaultImport, ts.arrayFrom(namedImports.entries(), function (_a) {
+                        var name = _a[0], addAsTypeOnly = _a[1];
+                        return ({ addAsTypeOnly: addAsTypeOnly, name: name });
+                    }), compilerOptions);
                 });
                 var newDeclarations;
-                newImports.forEach(function (_a, moduleSpecifier) {
-                    var useRequire = _a.useRequire, imports = __rest(_a, ["useRequire"]);
+                newImports.forEach(function (_a, key) {
+                    var useRequire = _a.useRequire, defaultImport = _a.defaultImport, namedImports = _a.namedImports, namespaceLikeImport = _a.namespaceLikeImport;
+                    var moduleSpecifier = key.slice(2); // From `${0 | 1}|${moduleSpecifier}` format
                     var getDeclarations = useRequire ? getNewRequires : getNewImports;
-                    newDeclarations = ts.combine(newDeclarations, getDeclarations(moduleSpecifier, quotePreference, imports));
+                    var declarations = getDeclarations(moduleSpecifier, quotePreference, defaultImport, namedImports && ts.arrayFrom(namedImports.entries(), function (_a) {
+                        var name = _a[0], addAsTypeOnly = _a[1];
+                        return ({ addAsTypeOnly: addAsTypeOnly, name: name });
+                    }), namespaceLikeImport);
+                    newDeclarations = ts.combine(newDeclarations, declarations);
                 });
                 if (newDeclarations) {
                     ts.insertImports(changeTracker, sourceFile, newDeclarations, /*blankLineBetween*/ true);
@@ -147246,24 +147548,37 @@ var ts;
         var ImportFixKind;
         (function (ImportFixKind) {
             ImportFixKind[ImportFixKind["UseNamespace"] = 0] = "UseNamespace";
-            ImportFixKind[ImportFixKind["ImportType"] = 1] = "ImportType";
+            ImportFixKind[ImportFixKind["JsdocTypeImport"] = 1] = "JsdocTypeImport";
             ImportFixKind[ImportFixKind["AddToExisting"] = 2] = "AddToExisting";
             ImportFixKind[ImportFixKind["AddNew"] = 3] = "AddNew";
         })(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.
+        // They're also ordered in terms of increasing priority for a fix-all scenario (see
+        // `reduceAddAsTypeOnlyValues`).
+        var AddAsTypeOnly;
+        (function (AddAsTypeOnly) {
+            AddAsTypeOnly[AddAsTypeOnly["Allowed"] = 1] = "Allowed";
+            AddAsTypeOnly[AddAsTypeOnly["Required"] = 2] = "Required";
+            AddAsTypeOnly[AddAsTypeOnly["NotAllowed"] = 4] = "NotAllowed";
+        })(AddAsTypeOnly || (AddAsTypeOnly = {}));
         function getImportCompletionAction(exportedSymbol, moduleSymbol, sourceFile, symbolName, host, program, formatContext, position, preferences) {
             var compilerOptions = program.getCompilerOptions();
             var exportInfos = ts.pathIsBareSpecifier(ts.stripQuotes(moduleSymbol.name))
                 ? [getSymbolExportInfoForSymbol(exportedSymbol, moduleSymbol, program, host)]
                 : getAllReExportingModules(sourceFile, exportedSymbol, moduleSymbol, symbolName, host, program, preferences, /*useAutoImportProvider*/ true);
             var useRequire = shouldUseRequire(sourceFile, program);
-            var preferTypeOnlyImport = compilerOptions.importsNotUsedAsValues === 2 /* Error */ && !ts.isSourceFileJS(sourceFile) && ts.isValidTypeOnlyAliasUseSite(ts.getTokenAtPosition(sourceFile, position));
-            var fix = ts.Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, position, preferTypeOnlyImport, useRequire, host, preferences));
-            return { moduleSpecifier: fix.moduleSpecifier, codeAction: codeFixActionToCodeAction(codeActionForFix({ host: host, formatContext: formatContext, preferences: preferences }, sourceFile, symbolName, fix, ts.getQuotePreference(sourceFile, preferences))) };
+            var isValidTypeOnlyUseSite = ts.isValidTypeOnlyAliasUseSite(ts.getTokenAtPosition(sourceFile, position));
+            var fix = ts.Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences));
+            return {
+                moduleSpecifier: fix.moduleSpecifier,
+                codeAction: codeFixActionToCodeAction(codeActionForFix({ host: host, formatContext: formatContext, preferences: preferences }, sourceFile, symbolName, fix, ts.getQuotePreference(sourceFile, preferences), compilerOptions))
+            };
         }
         codefix.getImportCompletionAction = getImportCompletionAction;
-        function getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, position, preferTypeOnlyImport, useRequire, host, preferences) {
+        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");
-            return getBestFix(getImportFixes(exportInfos, symbolName, position, preferTypeOnlyImport, useRequire, program, sourceFile, host, preferences), sourceFile, program, host, preferences);
+            return getBestFix(getImportFixes(exportInfos, symbolName, position, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences), sourceFile, program, host, preferences);
         }
         function codeFixActionToCodeAction(_a) {
             var description = _a.description, changes = _a.changes, commands = _a.commands;
@@ -147321,24 +147636,21 @@ var ts;
         function getModuleSpecifierForBestExportInfo(exportInfo, importingFile, program, host, preferences, fromCacheOnly) {
             var _a = getNewImportFixes(program, importingFile, 
             /*position*/ undefined, 
-            /*preferTypeOnlyImport*/ false, 
+            /*isValidTypeOnlyUseSite*/ false, 
             /*useRequire*/ false, exportInfo, host, preferences, fromCacheOnly), fixes = _a.fixes, computedWithoutCacheCount = _a.computedWithoutCacheCount;
             var result = getBestFix(fixes, importingFile, program, host, preferences);
             return result && __assign(__assign({}, result), { computedWithoutCacheCount: computedWithoutCacheCount });
         }
         codefix.getModuleSpecifierForBestExportInfo = getModuleSpecifierForBestExportInfo;
-        function isTypeOnlyPosition(sourceFile, position) {
-            return ts.isValidTypeOnlyAliasUseSite(ts.getTokenAtPosition(sourceFile, position));
-        }
         function getImportFixes(exportInfos, symbolName, 
         /** undefined only for missing JSX namespace */
-        position, preferTypeOnlyImport, useRequire, program, sourceFile, host, preferences) {
+        position, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences) {
             var checker = program.getTypeChecker();
             var existingImports = ts.flatMap(exportInfos, function (info) { return getExistingImportDeclarations(info, checker, sourceFile, program.getCompilerOptions()); });
             var useNamespace = position === undefined ? undefined : tryUseExistingNamespaceImport(existingImports, symbolName, position, checker);
-            var addToExisting = tryAddToExistingImport(existingImports, position !== undefined && isTypeOnlyPosition(sourceFile, position));
+            var addToExisting = tryAddToExistingImport(existingImports, isValidTypeOnlyUseSite, checker, program.getCompilerOptions());
             // Don't bother providing an action to add a new import if we can add to an existing one.
-            var addImport = addToExisting ? [addToExisting] : getFixesForAddImport(exportInfos, existingImports, program, sourceFile, position, preferTypeOnlyImport, useRequire, host, preferences);
+            var addImport = addToExisting ? [addToExisting] : getFixesForAddImport(exportInfos, existingImports, program, sourceFile, position, isValidTypeOnlyUseSite, useRequire, host, preferences);
             return __spreadArray(__spreadArray([], (useNamespace ? [useNamespace] : ts.emptyArray), true), addImport, true);
         }
         function tryUseExistingNamespaceImport(existingImports, symbolName, position, checker) {
@@ -147393,14 +147705,34 @@ var ts;
                     return ts.Debug.assertNever(declaration);
             }
         }
-        function tryAddToExistingImport(existingImports, canUseTypeOnlyImport) {
+        function getAddAsTypeOnly(isValidTypeOnlyUseSite, isForNewImportDeclaration, symbol, targetFlags, checker, compilerOptions) {
+            if (!isValidTypeOnlyUseSite) {
+                // Can't use a type-only import if the usage is an emitting position
+                return 4 /* NotAllowed */;
+            }
+            if (isForNewImportDeclaration && compilerOptions.importsNotUsedAsValues === 2 /* Error */) {
+                // Not writing a (top-level) type-only import here would create an error because the runtime dependency is unnecessary
+                return 2 /* Required */;
+            }
+            if (compilerOptions.isolatedModules && compilerOptions.preserveValueImports &&
+                (!(targetFlags & 111551 /* Value */) || !!checker.getTypeOnlyAliasDeclaration(symbol))) {
+                // A type-only import is required for this symbol if under these settings if the symbol will
+                // be erased, which will happen if the target symbol is purely a type or if it was exported/imported
+                // as type-only already somewhere between this import and the target.
+                return 2 /* Required */;
+            }
+            return 1 /* Allowed */;
+        }
+        function tryAddToExistingImport(existingImports, isValidTypeOnlyUseSite, checker, compilerOptions) {
             return ts.firstDefined(existingImports, function (_a) {
-                var declaration = _a.declaration, importKind = _a.importKind;
-                if (declaration.kind === 264 /* ImportEqualsDeclaration */)
+                var declaration = _a.declaration, importKind = _a.importKind, symbol = _a.symbol, targetFlags = _a.targetFlags;
+                if (importKind === 3 /* CommonJS */ || importKind === 2 /* Namespace */ || declaration.kind === 264 /* ImportEqualsDeclaration */) {
+                    // These kinds of imports are not combinable with anything
                     return undefined;
+                }
                 if (declaration.kind === 253 /* VariableDeclaration */) {
                     return (importKind === 0 /* Named */ || importKind === 1 /* Default */) && declaration.name.kind === 200 /* ObjectBindingPattern */
-                        ? { kind: 2 /* AddToExisting */, importClauseOrBindingPattern: declaration.name, importKind: importKind, moduleSpecifier: declaration.initializer.arguments[0].text, canUseTypeOnlyImport: false }
+                        ? { kind: 2 /* AddToExisting */, importClauseOrBindingPattern: declaration.name, importKind: importKind, moduleSpecifier: declaration.initializer.arguments[0].text, addAsTypeOnly: 4 /* NotAllowed */ }
                         : undefined;
                 }
                 var importClause = declaration.importClause;
@@ -147411,13 +147743,29 @@ var ts;
                 // be added to an existing type-only import is adding a named import to existing named bindings.
                 if (importClause.isTypeOnly && !(importKind === 0 /* Named */ && namedBindings))
                     return undefined;
-                return importKind === 1 /* Default */ && !name || importKind === 0 /* Named */ && (!namedBindings || namedBindings.kind === 268 /* NamedImports */)
-                    ? { kind: 2 /* AddToExisting */, importClauseOrBindingPattern: importClause, importKind: importKind, moduleSpecifier: declaration.moduleSpecifier.text, canUseTypeOnlyImport: canUseTypeOnlyImport }
-                    : undefined;
+                // N.B. we don't have to figure out whether to use the main program checker
+                // or the AutoImportProvider checker because we're adding to an existing import; the existence of
+                // the import guarantees the symbol came from the main program.
+                var addAsTypeOnly = getAddAsTypeOnly(isValidTypeOnlyUseSite, /*isForNewImportDeclaration*/ false, symbol, targetFlags, checker, compilerOptions);
+                if (importKind === 1 /* Default */ && (name || // Cannot add a default import to a declaration that already has one
+                    addAsTypeOnly === 2 /* Required */ && namedBindings // Cannot add a default import as type-only if the import already has named bindings
+                ))
+                    return undefined;
+                if (importKind === 0 /* Named */ &&
+                    (namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) === 267 /* NamespaceImport */ // Cannot add a named import to a declaration that has a namespace import
+                )
+                    return undefined;
+                return {
+                    kind: 2 /* AddToExisting */,
+                    importClauseOrBindingPattern: importClause,
+                    importKind: importKind,
+                    moduleSpecifier: declaration.moduleSpecifier.text,
+                    addAsTypeOnly: addAsTypeOnly,
+                };
             });
         }
         function getExistingImportDeclarations(_a, checker, importingFile, compilerOptions) {
-            var moduleSymbol = _a.moduleSymbol, exportKind = _a.exportKind, targetFlags = _a.targetFlags;
+            var moduleSymbol = _a.moduleSymbol, exportKind = _a.exportKind, targetFlags = _a.targetFlags, symbol = _a.symbol;
             // Can't use an es6 import for a type in JS.
             if (!(targetFlags & 111551 /* Value */) && ts.isSourceFileJS(importingFile))
                 return ts.emptyArray;
@@ -147425,10 +147773,10 @@ var ts;
             return ts.mapDefined(importingFile.imports, function (moduleSpecifier) {
                 var i = ts.importFromModuleSpecifier(moduleSpecifier);
                 if (ts.isRequireVariableDeclaration(i.parent)) {
-                    return checker.resolveExternalModuleName(moduleSpecifier) === moduleSymbol ? { declaration: i.parent, importKind: importKind } : undefined;
+                    return checker.resolveExternalModuleName(moduleSpecifier) === moduleSymbol ? { declaration: i.parent, importKind: importKind, symbol: symbol, targetFlags: targetFlags } : undefined;
                 }
                 if (i.kind === 265 /* ImportDeclaration */ || i.kind === 264 /* ImportEqualsDeclaration */) {
-                    return checker.getSymbolAtLocation(moduleSpecifier) === moduleSymbol ? { declaration: i, importKind: importKind } : undefined;
+                    return checker.getSymbolAtLocation(moduleSpecifier) === moduleSymbol ? { declaration: i, importKind: importKind, symbol: symbol, targetFlags: targetFlags } : undefined;
                 }
             });
         }
@@ -147460,44 +147808,50 @@ var ts;
             // 5. Literally nothing to go on
             return true;
         }
-        function getNewImportFixes(program, sourceFile, position, preferTypeOnlyImport, useRequire, moduleSymbols, host, preferences, fromCacheOnly) {
+        function getNewImportFixes(program, sourceFile, position, isValidTypeOnlyUseSite, useRequire, moduleSymbols, host, preferences, fromCacheOnly) {
             var isJs = ts.isSourceFileJS(sourceFile);
             var compilerOptions = program.getCompilerOptions();
             var moduleSpecifierResolutionHost = ts.createModuleSpecifierResolutionHost(program, host);
-            var checker = program.getTypeChecker();
+            var getChecker = ts.memoizeOne(function (isFromPackageJson) { return isFromPackageJson ? host.getPackageJsonAutoImportProvider().getTypeChecker() : program.getTypeChecker(); });
             var getModuleSpecifiers = fromCacheOnly
                 ? function (moduleSymbol) { return ({ moduleSpecifiers: ts.moduleSpecifiers.tryGetModuleSpecifiersFromCache(moduleSymbol, sourceFile, moduleSpecifierResolutionHost, preferences), computedWithoutCache: false }); }
-                : function (moduleSymbol) { return ts.moduleSpecifiers.getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions, sourceFile, moduleSpecifierResolutionHost, preferences); };
+                : function (moduleSymbol, checker) { return ts.moduleSpecifiers.getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions, sourceFile, moduleSpecifierResolutionHost, preferences); };
             var computedWithoutCacheCount = 0;
             var fixes = ts.flatMap(moduleSymbols, function (exportInfo) {
-                var _a = getModuleSpecifiers(exportInfo.moduleSymbol), computedWithoutCache = _a.computedWithoutCache, moduleSpecifiers = _a.moduleSpecifiers;
+                var checker = getChecker(exportInfo.isFromPackageJson);
+                var _a = getModuleSpecifiers(exportInfo.moduleSymbol, checker), computedWithoutCache = _a.computedWithoutCache, moduleSpecifiers = _a.moduleSpecifiers;
+                var importedSymbolHasValueMeaning = !!(exportInfo.targetFlags & 111551 /* Value */);
+                var addAsTypeOnly = getAddAsTypeOnly(isValidTypeOnlyUseSite, /*isForNewImportDeclaration*/ true, exportInfo.symbol, exportInfo.targetFlags, checker, compilerOptions);
                 computedWithoutCacheCount += computedWithoutCache ? 1 : 0;
                 return moduleSpecifiers === null || moduleSpecifiers === void 0 ? void 0 : moduleSpecifiers.map(function (moduleSpecifier) {
                     // `position` should only be undefined at a missing jsx namespace, in which case we shouldn't be looking for pure types.
-                    return !(exportInfo.targetFlags & 111551 /* Value */) && isJs && position !== undefined
-                        ? { kind: 1 /* ImportType */, moduleSpecifier: moduleSpecifier, position: position, exportInfo: exportInfo }
+                    return !importedSymbolHasValueMeaning && isJs && position !== undefined
+                        ? { kind: 1 /* JsdocTypeImport */, moduleSpecifier: moduleSpecifier, position: position, exportInfo: exportInfo }
                         : {
                             kind: 3 /* AddNew */,
                             moduleSpecifier: moduleSpecifier,
                             importKind: getImportKind(sourceFile, exportInfo.exportKind, compilerOptions),
                             useRequire: useRequire,
-                            typeOnly: preferTypeOnlyImport,
+                            addAsTypeOnly: addAsTypeOnly,
                             exportInfo: exportInfo,
                         };
                 });
             });
             return { computedWithoutCacheCount: computedWithoutCacheCount, fixes: fixes };
         }
-        function getFixesForAddImport(exportInfos, existingImports, program, sourceFile, position, preferTypeOnlyImport, useRequire, host, preferences) {
-            var existingDeclaration = ts.firstDefined(existingImports, function (info) { return newImportInfoFromExistingSpecifier(info, preferTypeOnlyImport, useRequire); });
-            return existingDeclaration ? [existingDeclaration] : getNewImportFixes(program, sourceFile, position, preferTypeOnlyImport, useRequire, exportInfos, host, preferences).fixes;
+        function getFixesForAddImport(exportInfos, existingImports, program, sourceFile, position, isValidTypeOnlyUseSite, useRequire, host, preferences) {
+            var existingDeclaration = ts.firstDefined(existingImports, function (info) { return newImportInfoFromExistingSpecifier(info, isValidTypeOnlyUseSite, useRequire, program.getTypeChecker(), program.getCompilerOptions()); });
+            return existingDeclaration ? [existingDeclaration] : getNewImportFixes(program, sourceFile, position, isValidTypeOnlyUseSite, useRequire, exportInfos, host, preferences).fixes;
         }
-        function newImportInfoFromExistingSpecifier(_a, preferTypeOnlyImport, useRequire) {
-            var declaration = _a.declaration, importKind = _a.importKind;
+        function newImportInfoFromExistingSpecifier(_a, isValidTypeOnlyUseSite, useRequire, checker, compilerOptions) {
+            var declaration = _a.declaration, importKind = _a.importKind, symbol = _a.symbol, targetFlags = _a.targetFlags;
             var moduleSpecifier = ts.tryGetModuleSpecifierFromDeclaration(declaration);
-            return moduleSpecifier
-                ? { kind: 3 /* AddNew */, moduleSpecifier: moduleSpecifier, importKind: importKind, typeOnly: preferTypeOnlyImport, useRequire: useRequire }
-                : undefined;
+            if (moduleSpecifier) {
+                var addAsTypeOnly = useRequire
+                    ? 4 /* NotAllowed */
+                    : getAddAsTypeOnly(isValidTypeOnlyUseSite, /*isForNewImportDeclaration*/ true, symbol, targetFlags, checker, compilerOptions);
+                return { kind: 3 /* AddNew */, moduleSpecifier: moduleSpecifier, importKind: importKind, addAsTypeOnly: addAsTypeOnly, useRequire: useRequire };
+            }
         }
         function getFixesInfo(context, errorCode, pos, useAutoImportProvider) {
             var symbolToken = ts.getTokenAtPosition(context.sourceFile, pos);
@@ -147547,7 +147901,7 @@ var ts;
             var symbolName = umdSymbol.name;
             var exportInfos = [{ symbol: umdSymbol, moduleSymbol: symbol, moduleFileName: undefined, exportKind: 3 /* UMD */, targetFlags: symbol.flags, isFromPackageJson: false }];
             var useRequire = shouldUseRequire(sourceFile, program);
-            var fixes = getImportFixes(exportInfos, symbolName, ts.isIdentifier(token) ? token.getStart(sourceFile) : undefined, /*preferTypeOnlyImport*/ false, useRequire, program, sourceFile, host, preferences);
+            var fixes = getImportFixes(exportInfos, symbolName, ts.isIdentifier(token) ? token.getStart(sourceFile) : undefined, /*isValidTypeOnlyUseSite*/ false, useRequire, program, sourceFile, host, preferences);
             return { fixes: fixes, symbolName: symbolName };
         }
         function getUmdSymbol(token, checker) {
@@ -147611,12 +147965,12 @@ var ts;
             var symbolName = getSymbolName(sourceFile, checker, symbolToken, compilerOptions);
             // "default" is a keyword and not a legal identifier for the import, so we don't expect it here
             ts.Debug.assert(symbolName !== "default" /* Default */, "'default' isn't a legal identifier and couldn't occur here");
-            var preferTypeOnlyImport = compilerOptions.importsNotUsedAsValues === 2 /* Error */ && ts.isValidTypeOnlyAliasUseSite(symbolToken);
+            var isValidTypeOnlyUseSite = ts.isValidTypeOnlyAliasUseSite(symbolToken);
             var useRequire = shouldUseRequire(sourceFile, program);
             var exportInfos = getExportInfos(symbolName, 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), preferTypeOnlyImport, useRequire, program, sourceFile, host, preferences);
+                return getImportFixes(exportInfos, symbolName, symbolToken.getStart(sourceFile), isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences);
             }));
             return { fixes: fixes, symbolName: symbolName };
         }
@@ -147694,63 +148048,81 @@ var ts;
             //    allowSyntheticDefaultImports/esModuleInterop is enabled.
             return allowSyntheticDefaults ? 1 /* Default */ : 3 /* CommonJS */;
         }
-        function codeActionForFix(context, sourceFile, symbolName, fix, quotePreference) {
+        function codeActionForFix(context, sourceFile, symbolName, fix, quotePreference, compilerOptions) {
             var diag;
             var changes = ts.textChanges.ChangeTracker.with(context, function (tracker) {
-                diag = codeActionForFixWorker(tracker, sourceFile, symbolName, fix, quotePreference);
+                diag = codeActionForFixWorker(tracker, sourceFile, symbolName, fix, quotePreference, compilerOptions);
             });
             return codefix.createCodeFixAction(codefix.importFixName, changes, diag, importFixId, ts.Diagnostics.Add_all_missing_imports);
         }
-        function codeActionForFixWorker(changes, sourceFile, symbolName, fix, quotePreference) {
+        function codeActionForFixWorker(changes, sourceFile, symbolName, fix, quotePreference, compilerOptions) {
             switch (fix.kind) {
                 case 0 /* UseNamespace */:
                     addNamespaceQualifier(changes, sourceFile, fix);
                     return [ts.Diagnostics.Change_0_to_1, symbolName, fix.namespacePrefix + "." + symbolName];
-                case 1 /* ImportType */:
+                case 1 /* JsdocTypeImport */:
                     addImportType(changes, sourceFile, fix, quotePreference);
                     return [ts.Diagnostics.Change_0_to_1, symbolName, getImportTypePrefix(fix.moduleSpecifier, quotePreference) + symbolName];
                 case 2 /* AddToExisting */: {
-                    var importClauseOrBindingPattern = fix.importClauseOrBindingPattern, importKind = fix.importKind, canUseTypeOnlyImport = fix.canUseTypeOnlyImport, moduleSpecifier = fix.moduleSpecifier;
-                    doAddExistingFix(changes, sourceFile, importClauseOrBindingPattern, importKind === 1 /* Default */ ? symbolName : undefined, importKind === 0 /* Named */ ? [symbolName] : ts.emptyArray, canUseTypeOnlyImport);
+                    var importClauseOrBindingPattern = fix.importClauseOrBindingPattern, importKind = fix.importKind, addAsTypeOnly = fix.addAsTypeOnly, moduleSpecifier = fix.moduleSpecifier;
+                    doAddExistingFix(changes, sourceFile, importClauseOrBindingPattern, importKind === 1 /* Default */ ? { name: symbolName, addAsTypeOnly: addAsTypeOnly } : undefined, importKind === 0 /* Named */ ? [{ name: symbolName, addAsTypeOnly: addAsTypeOnly }] : ts.emptyArray, compilerOptions);
                     var moduleSpecifierWithoutQuotes = ts.stripQuotes(moduleSpecifier);
-                    return [importKind === 1 /* Default */ ? ts.Diagnostics.Add_default_import_0_to_existing_import_declaration_from_1 : ts.Diagnostics.Add_0_to_existing_import_declaration_from_1, symbolName, moduleSpecifierWithoutQuotes]; // you too!
+                    return [
+                        importKind === 1 /* Default */ ? ts.Diagnostics.Add_default_import_0_to_existing_import_declaration_from_1 : ts.Diagnostics.Add_0_to_existing_import_declaration_from_1,
+                        symbolName,
+                        moduleSpecifierWithoutQuotes
+                    ]; // you too!
                 }
                 case 3 /* AddNew */: {
-                    var importKind = fix.importKind, moduleSpecifier = fix.moduleSpecifier, typeOnly = fix.typeOnly, useRequire = fix.useRequire;
+                    var importKind = fix.importKind, moduleSpecifier = fix.moduleSpecifier, addAsTypeOnly = fix.addAsTypeOnly, useRequire = fix.useRequire;
                     var getDeclarations = useRequire ? getNewRequires : getNewImports;
-                    var importsCollection = importKind === 1 /* Default */ ? { defaultImport: symbolName, typeOnly: typeOnly } :
-                        importKind === 0 /* Named */ ? { namedImports: [symbolName], typeOnly: typeOnly } :
-                            { namespaceLikeImport: { importKind: importKind, name: symbolName }, typeOnly: typeOnly };
-                    ts.insertImports(changes, sourceFile, getDeclarations(moduleSpecifier, quotePreference, importsCollection), /*blankLineBetween*/ true);
+                    var defaultImport = importKind === 1 /* Default */ ? { name: symbolName, addAsTypeOnly: addAsTypeOnly } : undefined;
+                    var namedImports = importKind === 0 /* Named */ ? [{ name: symbolName, addAsTypeOnly: addAsTypeOnly }] : undefined;
+                    var namespaceLikeImport = importKind === 2 /* Namespace */ || importKind === 3 /* CommonJS */ ? { importKind: importKind, name: symbolName, addAsTypeOnly: addAsTypeOnly } : undefined;
+                    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];
                 }
                 default:
                     return ts.Debug.assertNever(fix, "Unexpected fix kind " + fix.kind);
             }
         }
-        function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImports, canUseTypeOnlyImport) {
+        function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImports, compilerOptions) {
+            var _a;
             if (clause.kind === 200 /* ObjectBindingPattern */) {
                 if (defaultImport) {
-                    addElementToBindingPattern(clause, defaultImport, "default");
+                    addElementToBindingPattern(clause, defaultImport.name, "default");
                 }
                 for (var _i = 0, namedImports_1 = namedImports; _i < namedImports_1.length; _i++) {
                     var specifier = namedImports_1[_i];
-                    addElementToBindingPattern(clause, specifier, /*propertyName*/ undefined);
+                    addElementToBindingPattern(clause, specifier.name, /*propertyName*/ undefined);
                 }
                 return;
             }
-            var convertTypeOnlyToRegular = !canUseTypeOnlyImport && clause.isTypeOnly;
+            var promoteFromTypeOnly = clause.isTypeOnly && ts.some(__spreadArray([defaultImport], namedImports, true), function (i) { return (i === null || i === void 0 ? void 0 : i.addAsTypeOnly) === 4 /* NotAllowed */; });
+            var existingSpecifiers = clause.namedBindings && ((_a = ts.tryCast(clause.namedBindings, ts.isNamedImports)) === null || _a === void 0 ? void 0 : _a.elements);
+            // If we are promoting from a type-only import and `--isolatedModules` and `--preserveValueImports`
+            // are enabled, we need to make every existing import specifier type-only. It may be possible that
+            // some of them don't strictly need to be marked type-only (if they have a value meaning and are
+            // never used in an emitting position). These are allowed to be imported without being type-only,
+            // but the user has clearly already signified that they don't need them to be present at runtime
+            // by placing them in a type-only import. So, just mark each specifier as type-only.
+            var convertExistingToTypeOnly = promoteFromTypeOnly && compilerOptions.preserveValueImports && compilerOptions.isolatedModules;
             if (defaultImport) {
                 ts.Debug.assert(!clause.name, "Cannot add a default import to an import clause that already has one");
-                changes.insertNodeAt(sourceFile, clause.getStart(sourceFile), ts.factory.createIdentifier(defaultImport), { suffix: ", " });
+                changes.insertNodeAt(sourceFile, clause.getStart(sourceFile), ts.factory.createIdentifier(defaultImport.name), { suffix: ", " });
             }
             if (namedImports.length) {
-                var existingSpecifiers = clause.namedBindings && ts.cast(clause.namedBindings, ts.isNamedImports).elements;
-                var newSpecifiers = ts.stableSort(namedImports.map(function (name) { return ts.factory.createImportSpecifier(/*propertyName*/ undefined, ts.factory.createIdentifier(name)); }), ts.OrganizeImports.compareImportOrExportSpecifiers);
+                var newSpecifiers = ts.stableSort(namedImports.map(function (namedImport) { return ts.factory.createImportSpecifier((!clause.isTypeOnly || promoteFromTypeOnly) && needsTypeOnly(namedImport), 
+                /*propertyName*/ undefined, ts.factory.createIdentifier(namedImport.name)); }), ts.OrganizeImports.compareImportOrExportSpecifiers);
                 if ((existingSpecifiers === null || existingSpecifiers === void 0 ? void 0 : existingSpecifiers.length) && ts.OrganizeImports.importSpecifiersAreSorted(existingSpecifiers)) {
-                    for (var _a = 0, newSpecifiers_1 = newSpecifiers; _a < newSpecifiers_1.length; _a++) {
-                        var spec = newSpecifiers_1[_a];
-                        var insertionIndex = ts.OrganizeImports.getImportSpecifierInsertionIndex(existingSpecifiers, spec);
+                    for (var _b = 0, newSpecifiers_1 = newSpecifiers; _b < newSpecifiers_1.length; _b++) {
+                        var spec = newSpecifiers_1[_b];
+                        // Organize imports puts type-only import specifiers last, so if we're
+                        // adding a non-type-only specifier and converting all the other ones to
+                        // type-only, there's no need to ask for the insertion index - it's 0.
+                        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);
@@ -147761,8 +148133,8 @@ var ts;
                     }
                 }
                 else if (existingSpecifiers === null || existingSpecifiers === void 0 ? void 0 : existingSpecifiers.length) {
-                    for (var _b = 0, newSpecifiers_2 = newSpecifiers; _b < newSpecifiers_2.length; _b++) {
-                        var spec = newSpecifiers_2[_b];
+                    for (var _c = 0, newSpecifiers_2 = newSpecifiers; _c < newSpecifiers_2.length; _c++) {
+                        var spec = newSpecifiers_2[_c];
                         changes.insertNodeInListAfter(sourceFile, ts.last(existingSpecifiers), spec, existingSpecifiers);
                     }
                 }
@@ -147778,8 +148150,14 @@ var ts;
                     }
                 }
             }
-            if (convertTypeOnlyToRegular) {
+            if (promoteFromTypeOnly) {
                 changes.delete(sourceFile, ts.getTypeKeywordOfTypeOnlyImport(clause, sourceFile));
+                if (convertExistingToTypeOnly && existingSpecifiers) {
+                    for (var _d = 0, existingSpecifiers_1 = existingSpecifiers; _d < existingSpecifiers_1.length; _d++) {
+                        var specifier = existingSpecifiers_1[_d];
+                        changes.insertModifierBefore(sourceFile, 151 /* TypeKeyword */, specifier);
+                    }
+                }
             }
             function addElementToBindingPattern(bindingPattern, name, propertyName) {
                 var element = ts.factory.createBindingElement(/*dotDotDotToken*/ undefined, propertyName, name);
@@ -147803,44 +148181,53 @@ var ts;
             var quote = ts.getQuoteFromPreference(quotePreference);
             return "import(" + quote + moduleSpecifier + quote + ").";
         }
-        function getNewImports(moduleSpecifier, quotePreference, imports) {
-            var _a, _b;
+        function needsTypeOnly(_a) {
+            var addAsTypeOnly = _a.addAsTypeOnly;
+            return addAsTypeOnly === 2 /* Required */;
+        }
+        function getNewImports(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport) {
             var quotedModuleSpecifier = ts.makeStringLiteral(moduleSpecifier, quotePreference);
             var statements;
-            if (imports.defaultImport !== undefined || ((_a = imports.namedImports) === null || _a === void 0 ? void 0 : _a.length)) {
-                statements = ts.combine(statements, ts.makeImport(imports.defaultImport === undefined ? undefined : ts.factory.createIdentifier(imports.defaultImport), (_b = imports.namedImports) === null || _b === void 0 ? void 0 : _b.map(function (n) { return ts.factory.createImportSpecifier(/*propertyName*/ undefined, ts.factory.createIdentifier(n)); }), moduleSpecifier, quotePreference, imports.typeOnly));
+            if (defaultImport !== undefined || (namedImports === null || namedImports === void 0 ? void 0 : namedImports.length)) {
+                var topLevelTypeOnly_1 = (!defaultImport || needsTypeOnly(defaultImport)) && ts.every(namedImports, needsTypeOnly);
+                statements = ts.combine(statements, ts.makeImport(defaultImport && ts.factory.createIdentifier(defaultImport.name), namedImports === null || namedImports === void 0 ? void 0 : namedImports.map(function (_a) {
+                    var addAsTypeOnly = _a.addAsTypeOnly, name = _a.name;
+                    return ts.factory.createImportSpecifier(!topLevelTypeOnly_1 && addAsTypeOnly === 2 /* Required */, 
+                    /*propertyName*/ undefined, ts.factory.createIdentifier(name));
+                }), moduleSpecifier, quotePreference, topLevelTypeOnly_1));
             }
-            var namespaceLikeImport = imports.namespaceLikeImport, typeOnly = imports.typeOnly;
             if (namespaceLikeImport) {
                 var declaration = namespaceLikeImport.importKind === 3 /* CommonJS */
                     ? ts.factory.createImportEqualsDeclaration(
                     /*decorators*/ undefined, 
-                    /*modifiers*/ undefined, typeOnly, ts.factory.createIdentifier(namespaceLikeImport.name), ts.factory.createExternalModuleReference(quotedModuleSpecifier))
+                    /*modifiers*/ undefined, needsTypeOnly(namespaceLikeImport), ts.factory.createIdentifier(namespaceLikeImport.name), ts.factory.createExternalModuleReference(quotedModuleSpecifier))
                     : ts.factory.createImportDeclaration(
                     /*decorators*/ undefined, 
-                    /*modifiers*/ undefined, ts.factory.createImportClause(typeOnly, 
+                    /*modifiers*/ undefined, ts.factory.createImportClause(needsTypeOnly(namespaceLikeImport), 
                     /*name*/ undefined, ts.factory.createNamespaceImport(ts.factory.createIdentifier(namespaceLikeImport.name))), quotedModuleSpecifier, 
                     /*assertClause*/ undefined);
                 statements = ts.combine(statements, declaration);
             }
             return ts.Debug.checkDefined(statements);
         }
-        function getNewRequires(moduleSpecifier, quotePreference, imports) {
-            var _a, _b;
+        function getNewRequires(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport) {
             var quotedModuleSpecifier = ts.makeStringLiteral(moduleSpecifier, quotePreference);
             var statements;
             // const { default: foo, bar, etc } = require('./mod');
-            if (imports.defaultImport || ((_a = imports.namedImports) === null || _a === void 0 ? void 0 : _a.length)) {
-                var bindingElements = ((_b = imports.namedImports) === null || _b === void 0 ? void 0 : _b.map(function (name) { return ts.factory.createBindingElement(/*dotDotDotToken*/ undefined, /*propertyName*/ undefined, name); })) || [];
-                if (imports.defaultImport) {
-                    bindingElements.unshift(ts.factory.createBindingElement(/*dotDotDotToken*/ undefined, "default", imports.defaultImport));
+            if (defaultImport || (namedImports === null || namedImports === void 0 ? void 0 : namedImports.length)) {
+                var bindingElements = (namedImports === null || namedImports === void 0 ? void 0 : namedImports.map(function (_a) {
+                    var name = _a.name;
+                    return ts.factory.createBindingElement(/*dotDotDotToken*/ undefined, /*propertyName*/ undefined, name);
+                })) || [];
+                if (defaultImport) {
+                    bindingElements.unshift(ts.factory.createBindingElement(/*dotDotDotToken*/ undefined, "default", defaultImport.name));
                 }
                 var declaration = createConstEqualsRequireDeclaration(ts.factory.createObjectBindingPattern(bindingElements), quotedModuleSpecifier);
                 statements = ts.combine(statements, declaration);
             }
             // const foo = require('./mod');
-            if (imports.namespaceLikeImport) {
-                var declaration = createConstEqualsRequireDeclaration(imports.namespaceLikeImport.name, quotedModuleSpecifier);
+            if (namespaceLikeImport) {
+                var declaration = createConstEqualsRequireDeclaration(namespaceLikeImport.name, quotedModuleSpecifier);
                 statements = ts.combine(statements, declaration);
             }
             return ts.Debug.checkDefined(statements);
@@ -151752,7 +152139,7 @@ var ts;
             return ts.factory.createQualifiedName(replaceFirstIdentifierOfEntityName(name.left, newIdentifier), name.right);
         }
         function importSymbols(importAdder, symbols) {
-            symbols.forEach(function (s) { return importAdder.addImportFromExportedSymbol(s, /*usageIsTypeOnly*/ true); });
+            symbols.forEach(function (s) { return importAdder.addImportFromExportedSymbol(s, /*isValidTypeOnlyUseSite*/ true); });
         }
         codefix.importSymbols = importSymbols;
     })(codefix = ts.codefix || (ts.codefix = {}));
@@ -152224,7 +152611,7 @@ var ts;
                 if (!ts.isIdentifier(element.name) || element.initializer) {
                     return undefined;
                 }
-                importSpecifiers.push(ts.factory.createImportSpecifier(ts.tryCast(element.propertyName, ts.isIdentifier), element.name));
+                importSpecifiers.push(ts.factory.createImportSpecifier(/*isTypeOnly*/ false, ts.tryCast(element.propertyName, ts.isIdentifier), element.name));
             }
             if (importSpecifiers.length) {
                 return ts.factory.createNamedImports(importSpecifiers);
@@ -152971,10 +153358,10 @@ var ts;
             }
         }
         function makeImportSpecifier(propertyName, name) {
-            return ts.factory.createImportSpecifier(propertyName === name ? undefined : ts.factory.createIdentifier(propertyName), ts.factory.createIdentifier(name));
+            return ts.factory.createImportSpecifier(/*isTypeOnly*/ false, propertyName === name ? undefined : ts.factory.createIdentifier(propertyName), ts.factory.createIdentifier(name));
         }
         function makeExportSpecifier(propertyName, name) {
-            return ts.factory.createExportSpecifier(propertyName === name ? undefined : ts.factory.createIdentifier(propertyName), ts.factory.createIdentifier(name));
+            return ts.factory.createExportSpecifier(/*isTypeOnly*/ false, propertyName === name ? undefined : ts.factory.createIdentifier(propertyName), ts.factory.createIdentifier(name));
         }
     })(refactor = ts.refactor || (ts.refactor = {}));
 })(ts || (ts = {}));
@@ -153087,7 +153474,7 @@ var ts;
             }
             var importSpecifiers = [];
             exportNameToImportName.forEach(function (name, propertyName) {
-                importSpecifiers.push(ts.factory.createImportSpecifier(name === propertyName ? undefined : ts.factory.createIdentifier(propertyName), ts.factory.createIdentifier(name)));
+                importSpecifiers.push(ts.factory.createImportSpecifier(/*isTypeOnly*/ false, name === propertyName ? undefined : ts.factory.createIdentifier(propertyName), ts.factory.createIdentifier(name)));
             });
             var importDecl = toConvert.parent.parent;
             if (usedAsNamespaceOrDefault && !allowSyntheticDefaultImports) {
@@ -153158,7 +153545,7 @@ var ts;
             changes.replaceNode(sourceFile, toConvert, ts.factory.createNamespaceImport(ts.factory.createIdentifier(namespaceImportName)));
             if (neededNamedImports.size) {
                 var newNamedImports = ts.arrayFrom(neededNamedImports.values()).map(function (element) {
-                    return ts.factory.createImportSpecifier(element.propertyName && ts.factory.createIdentifier(element.propertyName.text), ts.factory.createIdentifier(element.name.text));
+                    return ts.factory.createImportSpecifier(element.isTypeOnly, element.propertyName && ts.factory.createIdentifier(element.propertyName.text), ts.factory.createIdentifier(element.name.text));
                 });
                 changes.insertNodeAfter(sourceFile, toConvert.parent.parent, updateImport(importDecl, /*defaultImportName*/ undefined, newNamedImports));
             }
@@ -155860,7 +156247,7 @@ var ts;
         function makeImportOrRequire(defaultImport, imports, path, useEs6Imports, quotePreference) {
             path = ts.ensurePathIsNonModuleName(path);
             if (useEs6Imports) {
-                var specifiers = imports.map(function (i) { return ts.factory.createImportSpecifier(/*propertyName*/ undefined, ts.factory.createIdentifier(i)); });
+                var specifiers = imports.map(function (i) { return ts.factory.createImportSpecifier(/*isTypeOnly*/ false, /*propertyName*/ undefined, ts.factory.createIdentifier(i)); });
                 return ts.makeImportIfNecessary(defaultImport, specifiers, path, quotePreference);
             }
             else {