@typescript-deploys/pr-build 4.5.0-pr-46071-5 → 4.5.0-pr-46071-13

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-insiders.20210927";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20211001";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -5154,6 +5154,7 @@ var ts;
         //       module kind).
         ModuleKind[ModuleKind["ES2015"] = 5] = "ES2015";
         ModuleKind[ModuleKind["ES2020"] = 6] = "ES2020";
+        ModuleKind[ModuleKind["ES2022"] = 7] = "ES2022";
         ModuleKind[ModuleKind["ESNext"] = 99] = "ESNext";
         // Node12+ is an amalgam of commonjs (albeit updated) and es2020+, and represents a distinct module system from es2020/esnext
         ModuleKind[ModuleKind["Node12"] = 100] = "Node12";
@@ -8071,7 +8072,7 @@ var ts;
         Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1320, ts.DiagnosticCategory.Error, "Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member_1320", "Type of 'await' operand must either be a valid promise or must not contain a callable 'then' member."),
         Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1321, ts.DiagnosticCategory.Error, "Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_cal_1321", "Type of 'yield' operand in an async generator must either be a valid promise or must not contain a callable 'then' member."),
         Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1322, ts.DiagnosticCategory.Error, "Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_con_1322", "Type of iterated elements of a 'yield*' operand must either be a valid promise or must not contain a callable 'then' member."),
-        Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_esnext_commonjs_amd_system_umd_node12_or_nodenext: diag(1323, ts.DiagnosticCategory.Error, "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_esnext_commonjs_amd_system__1323", "Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'esnext', 'commonjs', 'amd', 'system', 'umd', 'node12', or 'nodenext'."),
+        Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node12_or_nodenext: diag(1323, ts.DiagnosticCategory.Error, "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd__1323", "Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'es2022', 'esnext', 'commonjs', 'amd', 'system', 'umd', 'node12', or 'nodenext'."),
         Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext: diag(1324, ts.DiagnosticCategory.Error, "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_1324", "Dynamic imports only support a second argument when the '--module' option is set to 'esnext'."),
         Argument_of_dynamic_import_cannot_be_spread_element: diag(1325, ts.DiagnosticCategory.Error, "Argument_of_dynamic_import_cannot_be_spread_element_1325", "Argument of dynamic import cannot be spread element."),
         Dynamic_import_cannot_have_type_arguments: diag(1326, ts.DiagnosticCategory.Error, "Dynamic_import_cannot_have_type_arguments_1326", "Dynamic import cannot have type arguments."),
@@ -8089,7 +8090,7 @@ var ts;
         Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here: diag(1339, ts.DiagnosticCategory.Error, "Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here_1339", "Module '{0}' does not refer to a value, but is used as a value here."),
         Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0: diag(1340, ts.DiagnosticCategory.Error, "Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0_1340", "Module '{0}' does not refer to a type, but is used as a type here. Did you mean 'typeof import('{0}')'?"),
         Type_arguments_cannot_be_used_here: diag(1342, ts.DiagnosticCategory.Error, "Type_arguments_cannot_be_used_here_1342", "Type arguments cannot be used here."),
-        The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_esnext_system_node12_or_nodenext: diag(1343, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_esnext_system_node12__1343", "The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'esnext', 'system', 'node12', or 'nodenext'."),
+        The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node12_or_nodenext: diag(1343, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system__1343", "The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node12', or 'nodenext'."),
         A_label_is_not_allowed_here: diag(1344, ts.DiagnosticCategory.Error, "A_label_is_not_allowed_here_1344", "'A label is not allowed here."),
         An_expression_of_type_void_cannot_be_tested_for_truthiness: diag(1345, ts.DiagnosticCategory.Error, "An_expression_of_type_void_cannot_be_tested_for_truthiness_1345", "An expression of type 'void' cannot be tested for truthiness."),
         This_parameter_is_not_allowed_with_use_strict_directive: diag(1346, ts.DiagnosticCategory.Error, "This_parameter_is_not_allowed_with_use_strict_directive_1346", "This parameter is not allowed with 'use strict' directive."),
@@ -8120,7 +8121,7 @@ var ts;
         await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module: diag(1375, ts.DiagnosticCategory.Error, "await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_fi_1375", "'await' expressions are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module."),
         _0_was_imported_here: diag(1376, ts.DiagnosticCategory.Message, "_0_was_imported_here_1376", "'{0}' was imported here."),
         _0_was_exported_here: diag(1377, ts.DiagnosticCategory.Message, "_0_was_exported_here_1377", "'{0}' was exported here."),
-        Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher: diag(1378, ts.DiagnosticCategory.Error, "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_esnext_system_or_noden_1378", "Top-level 'await' expressions are only allowed when the 'module' option is set to 'esnext', 'system', or 'nodenext', and the 'target' option is set to 'es2017' or higher."),
+        Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher: diag(1378, ts.DiagnosticCategory.Error, "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_o_1378", "Top-level 'await' expressions are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', or 'nodenext', and the 'target' option is set to 'es2017' or higher."),
         An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type: diag(1379, ts.DiagnosticCategory.Error, "An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type_1379", "An import alias cannot reference a declaration that was exported using 'export type'."),
         An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type: diag(1380, ts.DiagnosticCategory.Error, "An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type_1380", "An import alias cannot reference a declaration that was imported using 'import type'."),
         Unexpected_token_Did_you_mean_or_rbrace: diag(1381, ts.DiagnosticCategory.Error, "Unexpected_token_Did_you_mean_or_rbrace_1381", "Unexpected token. Did you mean `{'}'}` or `}`?"),
@@ -8172,7 +8173,7 @@ var ts;
         File_redirects_to_file_0: diag(1429, ts.DiagnosticCategory.Message, "File_redirects_to_file_0_1429", "File redirects to file '{0}'"),
         The_file_is_in_the_program_because_Colon: diag(1430, ts.DiagnosticCategory.Message, "The_file_is_in_the_program_because_Colon_1430", "The file is in the program because:"),
         for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module: diag(1431, ts.DiagnosticCategory.Error, "for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_1431", "'for await' loops are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module."),
-        Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher: diag(1432, ts.DiagnosticCategory.Error, "Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_esnext_system_or_nodenex_1432", "Top-level 'for await' loops are only allowed when the 'module' option is set to 'esnext', 'system', or 'nodenext', and the 'target' option is set to 'es2017' or higher."),
+        Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher: diag(1432, ts.DiagnosticCategory.Error, "Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_or__1432", "Top-level 'for await' loops are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', or 'nodenext', and the 'target' option is set to 'es2017' or higher."),
         Decorators_may_not_be_applied_to_this_parameters: diag(1433, ts.DiagnosticCategory.Error, "Decorators_may_not_be_applied_to_this_parameters_1433", "Decorators may not be applied to 'this' parameters."),
         Unexpected_keyword_or_identifier: diag(1434, ts.DiagnosticCategory.Error, "Unexpected_keyword_or_identifier_1434", "Unexpected keyword or identifier."),
         Unknown_keyword_or_identifier_Did_you_mean_0: diag(1435, ts.DiagnosticCategory.Error, "Unknown_keyword_or_identifier_Did_you_mean_0_1435", "Unknown keyword or identifier. Did you mean '{0}'?"),
@@ -8198,6 +8199,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 +12988,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 */:
@@ -19623,6 +19626,7 @@ var ts;
             case ts.ModuleKind.AMD:
             case ts.ModuleKind.ES2015:
             case ts.ModuleKind.ES2020:
+            case ts.ModuleKind.ES2022:
             case ts.ModuleKind.ESNext:
                 return true;
             default:
@@ -19796,7 +19800,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 +19813,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 +20444,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;
     }
@@ -20730,6 +20731,10 @@ var ts;
         return !!declaration && (ts.isParameter(declaration) || isCatchClauseVariableDeclaration(declaration));
     }
     ts.isParameterOrCatchClauseVariable = isParameterOrCatchClauseVariable;
+    function isFunctionExpressionOrArrowFunction(node) {
+        return node.kind === 212 /* FunctionExpression */ || node.kind === 213 /* ArrowFunction */;
+    }
+    ts.isFunctionExpressionOrArrowFunction = isFunctionExpressionOrArrowFunction;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
@@ -24464,8 +24469,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 +24481,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 +24546,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 +24558,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 +25670,7 @@ var ts;
             /*decorators*/ undefined, 
             /*modifiers*/ undefined, 
             /*isTypeOnly*/ false, createNamedExports([
-                createExportSpecifier(/*propertyName*/ undefined, exportName)
+                createExportSpecifier(/*isTypeOnly*/ false, /*propertyName*/ undefined, exportName)
             ]));
         }
         //
@@ -28928,8 +28937,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;
@@ -31350,7 +31359,6 @@ var ts;
                 case 88 /* DefaultKeyword */:
                     return nextTokenCanFollowDefaultKeyword();
                 case 124 /* StaticKeyword */:
-                    return nextTokenIsOnSameLineAndCanFollowModifier();
                 case 136 /* GetKeyword */:
                 case 148 /* SetKeyword */:
                     nextToken();
@@ -35593,7 +35601,7 @@ var ts;
             }
             return list && createNodeArray(list, pos);
         }
-        function tryParseModifier(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock) {
+        function tryParseModifier(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock, hasSeenStaticModifier) {
             var pos = getNodePos();
             var kind = token();
             if (token() === 85 /* ConstKeyword */ && permitInvalidConstAsModifier) {
@@ -35606,6 +35614,9 @@ var ts;
             else if (stopOnStartOfClassStaticBlock && token() === 124 /* StaticKeyword */ && lookAhead(nextTokenIsOpenBrace)) {
                 return undefined;
             }
+            else if (hasSeenStaticModifier && token() === 124 /* StaticKeyword */) {
+                return undefined;
+            }
             else {
                 if (!parseAnyContextualModifier()) {
                     return undefined;
@@ -35622,8 +35633,10 @@ var ts;
          */
         function parseModifiers(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock) {
             var pos = getNodePos();
-            var list, modifier;
-            while (modifier = tryParseModifier(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock)) {
+            var list, modifier, hasSeenStatic = false;
+            while (modifier = tryParseModifier(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock, hasSeenStatic)) {
+                if (modifier.kind === 124 /* StaticKeyword */)
+                    hasSeenStatic = true;
                 list = ts.append(list, modifier);
             }
             return list && createNodeArray(list, pos);
@@ -36056,27 +36069,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);
@@ -38281,6 +38341,7 @@ var ts;
                 es6: ts.ModuleKind.ES2015,
                 es2015: ts.ModuleKind.ES2015,
                 es2020: ts.ModuleKind.ES2020,
+                es2022: ts.ModuleKind.ES2022,
                 esnext: ts.ModuleKind.ESNext,
                 node12: ts.ModuleKind.Node12,
                 nodenext: ts.ModuleKind.NodeNext,
@@ -39988,6 +40049,44 @@ var ts;
         }
         return result;
     }
+    /**
+     * Generate a list of the compiler options whose value is not the default.
+     * @param options compilerOptions to be evaluated.
+    /** @internal */
+    function getCompilerOptionsDiffValue(options, newLine) {
+        var compilerOptionsMap = getSerializedCompilerOption(options);
+        return getOverwrittenDefaultOptions();
+        function makePadding(paddingLength) {
+            return Array(paddingLength + 1).join(" ");
+        }
+        function getOverwrittenDefaultOptions() {
+            var result = [];
+            var tab = makePadding(2);
+            commandOptionsWithoutBuild.forEach(function (cmd) {
+                if (!compilerOptionsMap.has(cmd.name)) {
+                    return;
+                }
+                var newValue = compilerOptionsMap.get(cmd.name);
+                var defaultValue = getDefaultValueForOption(cmd);
+                if (newValue !== defaultValue) {
+                    result.push("" + tab + cmd.name + ": " + newValue);
+                }
+                else if (ts.hasProperty(ts.defaultInitCompilerOptions, cmd.name)) {
+                    result.push("" + tab + cmd.name + ": " + defaultValue);
+                }
+            });
+            return result.join(newLine) + newLine;
+        }
+    }
+    ts.getCompilerOptionsDiffValue = getCompilerOptionsDiffValue;
+    /**
+     * Get the compiler options to be written into the tsconfig.json.
+     * @param options commandlineOptions to be included in the compileOptions.
+     */
+    function getSerializedCompilerOption(options) {
+        var compilerOptions = ts.extend(options, ts.defaultInitCompilerOptions);
+        return serializeCompilerOptions(compilerOptions);
+    }
     /**
      * Generate tsconfig configuration when running command line "--init"
      * @param options commandlineOptions to be generated into tsconfig.json
@@ -39995,28 +40094,8 @@ var ts;
      */
     /* @internal */
     function generateTSConfig(options, fileNames, newLine) {
-        var compilerOptions = ts.extend(options, ts.defaultInitCompilerOptions);
-        var compilerOptionsMap = serializeCompilerOptions(compilerOptions);
+        var compilerOptionsMap = getSerializedCompilerOption(options);
         return writeConfigurations();
-        function getDefaultValueForOption(option) {
-            switch (option.type) {
-                case "number":
-                    return 1;
-                case "boolean":
-                    return true;
-                case "string":
-                    return option.isFilePath ? "./" : "";
-                case "list":
-                    return [];
-                case "object":
-                    return {};
-                default:
-                    var iterResult = option.type.keys().next();
-                    if (!iterResult.done)
-                        return iterResult.value;
-                    return ts.Debug.fail("Expected 'option.type' to have entries.");
-            }
-        }
         function makePadding(paddingLength) {
             return Array(paddingLength + 1).join(" ");
         }
@@ -41003,6 +41082,25 @@ var ts;
                 }); // TODO: GH#18217
         }
     }
+    function getDefaultValueForOption(option) {
+        switch (option.type) {
+            case "number":
+                return 1;
+            case "boolean":
+                return true;
+            case "string":
+                return option.isFilePath ? "./" : "";
+            case "list":
+                return [];
+            case "object":
+                return {};
+            default:
+                var iterResult = option.type.keys().next();
+                if (!iterResult.done)
+                    return iterResult.value;
+                return ts.Debug.fail("Expected 'option.type' to have entries.");
+        }
+    }
 })(ts || (ts = {}));
 var ts;
 (function (ts) {
@@ -46414,6 +46512,13 @@ var ts;
         IntersectionState[IntersectionState["UnionIntersectionCheck"] = 8] = "UnionIntersectionCheck";
         IntersectionState[IntersectionState["InPropertyCheck"] = 16] = "InPropertyCheck";
     })(IntersectionState || (IntersectionState = {}));
+    var RecursionFlags;
+    (function (RecursionFlags) {
+        RecursionFlags[RecursionFlags["None"] = 0] = "None";
+        RecursionFlags[RecursionFlags["Source"] = 1] = "Source";
+        RecursionFlags[RecursionFlags["Target"] = 2] = "Target";
+        RecursionFlags[RecursionFlags["Both"] = 3] = "Both";
+    })(RecursionFlags || (RecursionFlags = {}));
     var MappedTypeModifiers;
     (function (MappedTypeModifiers) {
         MappedTypeModifiers[MappedTypeModifiers["IncludeReadonly"] = 1] = "IncludeReadonly";
@@ -46475,7 +46580,6 @@ var ts;
         Capitalize: 2 /* Capitalize */,
         Uncapitalize: 3 /* Uncapitalize */
     }));
-    var DEFAULT_TYPE_CHARS_LENGTH_TO_ADD_NEW_LINES = 30;
     function SymbolLinks() {
     }
     function NodeLinks() {
@@ -46907,6 +47011,7 @@ var ts;
             getLocalTypeParametersOfClassOrInterfaceOrTypeAlias: getLocalTypeParametersOfClassOrInterfaceOrTypeAlias,
             isDeclarationVisible: isDeclarationVisible,
             isPropertyAccessible: isPropertyAccessible,
+            getTypeOnlyAliasDeclaration: getTypeOnlyAliasDeclaration,
         };
         function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode) {
             var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression);
@@ -47176,17 +47281,9 @@ var ts;
                         }
                     }
                     else {
-                        if (file.localJsxNamespace) {
-                            return file.localJsxNamespace;
-                        }
-                        var jsxPragma = file.pragmas.get("jsx");
-                        if (jsxPragma) {
-                            var chosenPragma = ts.isArray(jsxPragma) ? jsxPragma[0] : jsxPragma;
-                            file.localJsxFactory = ts.parseIsolatedEntityName(chosenPragma.arguments.factory, languageVersion);
-                            ts.visitNode(file.localJsxFactory, markAsSynthetic);
-                            if (file.localJsxFactory) {
-                                return file.localJsxNamespace = ts.getFirstIdentifier(file.localJsxFactory).escapedText;
-                            }
+                        var localJsxNamespace = getLocalJsxNamespace(file);
+                        if (localJsxNamespace) {
+                            return file.localJsxNamespace = localJsxNamespace;
                         }
                     }
                 }
@@ -47208,10 +47305,24 @@ var ts;
                 _jsxFactoryEntity = ts.factory.createQualifiedName(ts.factory.createIdentifier(ts.unescapeLeadingUnderscores(_jsxNamespace)), "createElement");
             }
             return _jsxNamespace;
-            function markAsSynthetic(node) {
-                ts.setTextRangePosEnd(node, -1, -1);
-                return ts.visitEachChild(node, markAsSynthetic, ts.nullTransformationContext);
+        }
+        function getLocalJsxNamespace(file) {
+            if (file.localJsxNamespace) {
+                return file.localJsxNamespace;
             }
+            var jsxPragma = file.pragmas.get("jsx");
+            if (jsxPragma) {
+                var chosenPragma = ts.isArray(jsxPragma) ? jsxPragma[0] : jsxPragma;
+                file.localJsxFactory = ts.parseIsolatedEntityName(chosenPragma.arguments.factory, languageVersion);
+                ts.visitNode(file.localJsxFactory, markAsSynthetic);
+                if (file.localJsxFactory) {
+                    return file.localJsxNamespace = ts.getFirstIdentifier(file.localJsxFactory).escapedText;
+                }
+            }
+        }
+        function markAsSynthetic(node) {
+            ts.setTextRangePosEnd(node, -1, -1);
+            return ts.visitEachChild(node, markAsSynthetic, ts.nullTransformationContext);
         }
         function getEmitResolver(sourceFile, cancellationToken) {
             // Ensure we have all the type information in place for this file so that all the
@@ -48283,8 +48394,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);
@@ -48295,7 +48405,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 */) {
@@ -48619,15 +48729,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));
             }
@@ -48642,7 +48750,21 @@ var ts;
         function isSyntacticDefault(node) {
             return ((ts.isExportAssignment(node) && !node.isExportEquals) || ts.hasSyntacticModifier(node, 512 /* Default */) || ts.isExportSpecifier(node));
         }
-        function canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias) {
+        function getUsageModeForExpression(usage) {
+            return ts.isStringLiteralLike(usage) ? ts.getModeForUsageLocation(ts.getSourceFileOfNode(usage), usage) : undefined;
+        }
+        function isESMFormatImportImportingCommonjsFormatFile(usageMode, targetMode) {
+            return usageMode === ts.ModuleKind.ESNext && targetMode === ts.ModuleKind.CommonJS;
+        }
+        function canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, usage) {
+            var usageMode = file && getUsageModeForExpression(usage);
+            if (file && usageMode !== undefined) {
+                var result = isESMFormatImportImportingCommonjsFormatFile(usageMode, file.impliedNodeFormat);
+                if (usageMode === ts.ModuleKind.ESNext || result) {
+                    return result;
+                }
+                // fallthrough on cjs usages so we imply defaults for interop'd imports, too
+            }
             if (!allowSyntheticDefaultImports) {
                 return false;
             }
@@ -48684,7 +48806,7 @@ var ts;
                     exportDefaultSymbol = resolveExportByName(moduleSymbol, "default" /* Default */, node, dontResolveAlias);
                 }
                 var file = (_a = moduleSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile);
-                var hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias);
+                var hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, node.parent.moduleSpecifier);
                 if (!exportDefaultSymbol && !hasSyntheticDefault) {
                     if (hasExportAssignmentSymbol(moduleSymbol)) {
                         var compilerOptionName = moduleKind >= ts.ModuleKind.ES2015 ? "allowSyntheticDefaultImports" : "esModuleInterop";
@@ -48824,7 +48946,7 @@ var ts;
                     var symbolFromModule = getExportOfModule(targetSymbol, name, specifier, dontResolveAlias);
                     if (symbolFromModule === undefined && name.escapedText === "default" /* Default */) {
                         var file = (_a = moduleSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile);
-                        if (canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias)) {
+                        if (canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, moduleSpecifier)) {
                             symbolFromModule = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
                         }
                     }
@@ -49043,13 +49165,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))
@@ -49515,7 +49637,7 @@ var ts;
                             sigs = getSignaturesOfStructuredType(type, 1 /* Construct */);
                         }
                         if (sigs && sigs.length) {
-                            var moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol);
+                            var moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol, ts.isImportCall(referenceParent) ? referenceParent.arguments[0] : referenceParent.moduleSpecifier);
                             // Create a new symbol which has the module's type less the call and construct signatures
                             var result = createSymbol(symbol.flags, symbol.escapedName);
                             result.declarations = symbol.declarations ? symbol.declarations.slice() : [];
@@ -52182,7 +52304,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);
                         }
@@ -52410,7 +52532,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 {
@@ -52443,7 +52565,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;
                                     }
@@ -52501,7 +52623,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) {
@@ -52623,7 +52745,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, 
@@ -52714,7 +52836,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
@@ -52865,7 +52987,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;
                             }
@@ -52949,7 +53072,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;
@@ -52985,7 +53109,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
@@ -56480,6 +56604,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();
@@ -56497,21 +56638,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);
@@ -57206,7 +57333,7 @@ var ts;
                 else if (type !== firstType) {
                     checkFlags |= 64 /* HasNonUniformType */;
                 }
-                if (isLiteralType(type)) {
+                if (isLiteralType(type) || isPatternLiteralType(type)) {
                     checkFlags |= 128 /* HasLiteralType */;
                 }
                 if (type.flags & 131072 /* Never */) {
@@ -59628,18 +59755,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
@@ -59697,7 +59862,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 :
@@ -61562,7 +61727,7 @@ var ts;
             return !node.typeParameters && !ts.getEffectiveReturnTypeNode(node) && !!node.body && node.body.kind !== 234 /* Block */ && isContextSensitive(node.body);
         }
         function isContextSensitiveFunctionOrObjectLiteralMethod(func) {
-            return (ts.isInJSFile(func) && ts.isFunctionDeclaration(func) || isFunctionExpressionOrArrowFunction(func) || ts.isObjectLiteralMethod(func)) &&
+            return (ts.isInJSFile(func) && ts.isFunctionDeclaration(func) || ts.isFunctionExpressionOrArrowFunction(func) || ts.isObjectLiteralMethod(func)) &&
                 isContextSensitiveFunctionLikeDeclaration(func);
         }
         function getTypeWithoutSignatures(type) {
@@ -62434,7 +62599,8 @@ var ts;
             var sourceStack;
             var targetStack;
             var maybeCount = 0;
-            var depth = 0;
+            var sourceDepth = 0;
+            var targetDepth = 0;
             var expandingFlags = 0 /* None */;
             var overflow = false;
             var overrideNextErrorInfo = 0; // How many `reportRelationError` calls should be skipped in the elaboration pyramid
@@ -62442,12 +62608,12 @@ var ts;
             var incompatibleStack = [];
             var inPropertyCheck = false;
             ts.Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
-            var result = isRelatedTo(source, target, /*reportErrors*/ !!errorNode, headMessage);
+            var result = isRelatedTo(source, target, 3 /* Both */, /*reportErrors*/ !!errorNode, headMessage);
             if (incompatibleStack.length) {
                 reportIncompatibleStack();
             }
             if (overflow) {
-                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "checkTypeRelatedTo_DepthLimit", { sourceId: source.id, targetId: target.id, depth: depth });
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "checkTypeRelatedTo_DepthLimit", { sourceId: source.id, targetId: target.id, depth: sourceDepth, targetDepth: targetDepth });
                 var diag = error(errorNode || currentNode, ts.Diagnostics.Excessive_stack_depth_comparing_types_0_and_1, typeToString(source), typeToString(target));
                 if (errorOutputContainer) {
                     (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag);
@@ -62674,9 +62840,9 @@ var ts;
                             }
                         }
                         message = ts.Diagnostics.Type_0_is_not_assignable_to_type_1;
-                        if (shouldInsertNewLines([sourceType, targetType])) {
-                            reportError(transformMessageToSupportNewLines(message), sourceType, targetType);
-                            return;
+                        var typeLengthLimit = 30;
+                        if (!errorInfo && compilerOptions.pretty && (sourceType.length > typeLengthLimit || targetType.length > typeLengthLimit)) {
+                            message = formatMessageForTypes(message, typeLengthLimit, sourceType, targetType);
                         }
                     }
                 }
@@ -62687,15 +62853,14 @@ var ts;
                 }
                 reportError(message, generalizedSourceType, targetType);
             }
-            function shouldInsertNewLines(types, charsLength) {
-                if (charsLength === void 0) { charsLength = DEFAULT_TYPE_CHARS_LENGTH_TO_ADD_NEW_LINES; }
-                return types.filter(function (type) { return type.length > charsLength; }).length > 0;
-            }
-            function transformMessageToSupportNewLines(message) {
-                return __assign(__assign({}, message), { message: message.message
-                        .replace(" '{0}' ", ":\n{0}\n\n")
-                        .replace(" '{1}'", ":\n{1}\n")
-                        .replace(".", "") });
+            /** Move a printed type to be on its own line if it is longer than 30 characters */
+            function formatMessageForTypes(diagnostic, typeLengthLimit, source, target) {
+                var message = diagnostic.message;
+                if (source.length > typeLengthLimit)
+                    message = message.replace(" '{0}' ", ":\n{0}\n\n");
+                if (target.length > typeLengthLimit)
+                    message = message.replace(" '{1}'", ":\n{1}").replace(".", "");
+                return __assign(__assign({}, diagnostic), { message: message });
             }
             function tryElaborateErrorsForPrimitivesAndObjects(source, target) {
                 var sourceType = symbolValueDeclarationIsContextSensitive(source.symbol) ? typeToString(source, source.symbol.valueDeclaration) : typeToString(source);
@@ -62741,13 +62906,17 @@ var ts;
                 }
                 return true;
             }
+            function isRelatedToWorker(source, target, reportErrors) {
+                return isRelatedTo(source, target, 3 /* Both */, reportErrors);
+            }
             /**
              * Compare two types and return
              * * Ternary.True if they are related with no assumptions,
              * * Ternary.Maybe if they are related with assumptions of other relationships, or
              * * Ternary.False if they are not related.
              */
-            function isRelatedTo(originalSource, originalTarget, reportErrors, headMessage, intersectionState) {
+            function isRelatedTo(originalSource, originalTarget, recursionFlags, reportErrors, headMessage, intersectionState) {
+                if (recursionFlags === void 0) { recursionFlags = 3 /* Both */; }
                 if (reportErrors === void 0) { reportErrors = false; }
                 if (intersectionState === void 0) { intersectionState = 0 /* None */; }
                 // Before normalization: if `source` is type an object type, and `target` is primitive,
@@ -62768,7 +62937,7 @@ var ts;
                 if (source === target)
                     return -1 /* True */;
                 if (relation === identityRelation) {
-                    return isIdenticalTo(source, target);
+                    return isIdenticalTo(source, target, recursionFlags);
                 }
                 // We fastpath comparing a type parameter to exactly its constraint, as this is _super_ common,
                 // and otherwise, for type parameters in large unions, causes us to need to compare the union to itself,
@@ -62819,8 +62988,8 @@ var ts;
                         var targetString = typeToString(originalTarget.aliasSymbol ? originalTarget : target);
                         var calls = getSignaturesOfType(source, 0 /* Call */);
                         var constructs = getSignaturesOfType(source, 1 /* Construct */);
-                        if (calls.length > 0 && isRelatedTo(getReturnTypeOfSignature(calls[0]), target, /*reportErrors*/ false) ||
-                            constructs.length > 0 && isRelatedTo(getReturnTypeOfSignature(constructs[0]), target, /*reportErrors*/ false)) {
+                        if (calls.length > 0 && isRelatedTo(getReturnTypeOfSignature(calls[0]), target, 1 /* Source */, /*reportErrors*/ false) ||
+                            constructs.length > 0 && isRelatedTo(getReturnTypeOfSignature(constructs[0]), target, 1 /* Source */, /*reportErrors*/ false)) {
                             reportError(ts.Diagnostics.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it, sourceString, targetString);
                         }
                         else {
@@ -62837,11 +63006,11 @@ var ts;
                 // and we need to handle "each" relations before "some" relations for the same kind of type.
                 if (source.flags & 3145728 /* UnionOrIntersection */ || target.flags & 3145728 /* UnionOrIntersection */) {
                     result = getConstituentCount(source) * getConstituentCount(target) >= 4 ?
-                        recursiveTypeRelatedTo(source, target, reportErrors, intersectionState | 8 /* UnionIntersectionCheck */) :
+                        recursiveTypeRelatedTo(source, target, reportErrors, intersectionState | 8 /* UnionIntersectionCheck */, recursionFlags) :
                         structuredTypeRelatedTo(source, target, reportErrors, intersectionState | 8 /* UnionIntersectionCheck */);
                 }
                 if (!result && !(source.flags & 1048576 /* Union */) && (source.flags & (469499904 /* StructuredOrInstantiable */) || target.flags & 469499904 /* StructuredOrInstantiable */)) {
-                    if (result = recursiveTypeRelatedTo(source, target, reportErrors, intersectionState)) {
+                    if (result = recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags)) {
                         resetErrorInfo(saveErrorInfo);
                     }
                 }
@@ -62863,7 +63032,7 @@ var ts;
                     if (constraint && (source.flags & 2097152 /* Intersection */ || target.flags & 1048576 /* Union */)) {
                         if (everyType(constraint, function (c) { return c !== source; })) { // Skip comparison if expansion contains the source itself
                             // TODO: Stack errors so we get a pyramid for the "normal" comparison above, _and_ a second for this
-                            if (result = isRelatedTo(constraint, target, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
+                            if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
                                 resetErrorInfo(saveErrorInfo);
                             }
                         }
@@ -62887,7 +63056,7 @@ var ts;
                 if (result && !inPropertyCheck && (target.flags & 2097152 /* Intersection */ && (isPerformingExcessPropertyChecks || isPerformingCommonPropertyChecks) ||
                     isNonGenericObjectType(target) && !isArrayType(target) && !isTupleType(target) && source.flags & 2097152 /* Intersection */ && getApparentType(source).flags & 3670016 /* StructuredType */ && !ts.some(source.types, function (t) { return !!(ts.getObjectFlags(t) & 524288 /* NonInferrableType */); }))) {
                     inPropertyCheck = true;
-                    result &= recursiveTypeRelatedTo(source, target, reportErrors, 4 /* PropertyCheck */);
+                    result &= recursiveTypeRelatedTo(source, target, reportErrors, 4 /* PropertyCheck */, recursionFlags);
                     inPropertyCheck = false;
                 }
                 reportErrorResults(source, target, result, isComparingJsxAttributes);
@@ -62962,7 +63131,7 @@ var ts;
                     }
                 }
             }
-            function isIdenticalTo(source, target) {
+            function isIdenticalTo(source, target, recursionFlags) {
                 if (source.flags !== target.flags)
                     return 0 /* False */;
                 if (source.flags & 67358815 /* Singleton */)
@@ -62975,7 +63144,7 @@ var ts;
                     }
                     return result_7;
                 }
-                return recursiveTypeRelatedTo(source, target, /*reportErrors*/ false, 0 /* None */);
+                return recursiveTypeRelatedTo(source, target, /*reportErrors*/ false, 0 /* None */, recursionFlags);
             }
             function getTypeOfPropertyInTypes(types, name) {
                 var appendPropType = function (propTypes, type) {
@@ -63056,7 +63225,7 @@ var ts;
                             }
                             return { value: true };
                         }
-                        if (checkTypes && !isRelatedTo(getTypeOfSymbol(prop), getTypeOfPropertyInTypes(checkTypes, prop.escapedName), reportErrors)) {
+                        if (checkTypes && !isRelatedTo(getTypeOfSymbol(prop), getTypeOfPropertyInTypes(checkTypes, prop.escapedName), 3 /* Both */, reportErrors)) {
                             if (reportErrors) {
                                 reportIncompatibleError(ts.Diagnostics.Types_of_property_0_are_incompatible, symbolToString(prop));
                             }
@@ -63096,7 +63265,7 @@ var ts;
                     }
                     var match = getMatchingUnionConstituentForType(target, source);
                     if (match) {
-                        var related = isRelatedTo(source, match, /*reportErrors*/ false);
+                        var related = isRelatedTo(source, match, 2 /* Target */, /*reportErrors*/ false);
                         if (related) {
                             return related;
                         }
@@ -63104,14 +63273,14 @@ var ts;
                 }
                 for (var _i = 0, targetTypes_1 = targetTypes; _i < targetTypes_1.length; _i++) {
                     var type = targetTypes_1[_i];
-                    var related = isRelatedTo(source, type, /*reportErrors*/ false);
+                    var related = isRelatedTo(source, type, 2 /* Target */, /*reportErrors*/ false);
                     if (related) {
                         return related;
                     }
                 }
                 if (reportErrors) {
                     var bestMatchingType = getBestMatchingType(source, target, isRelatedTo);
-                    isRelatedTo(source, bestMatchingType || targetTypes[targetTypes.length - 1], /*reportErrors*/ true);
+                    isRelatedTo(source, bestMatchingType || targetTypes[targetTypes.length - 1], 2 /* Target */, /*reportErrors*/ true);
                 }
                 return 0 /* False */;
             }
@@ -63120,7 +63289,7 @@ var ts;
                 var targetTypes = target.types;
                 for (var _i = 0, targetTypes_2 = targetTypes; _i < targetTypes_2.length; _i++) {
                     var targetType = targetTypes_2[_i];
-                    var related = isRelatedTo(source, targetType, reportErrors, /*headMessage*/ undefined, intersectionState);
+                    var related = isRelatedTo(source, targetType, 2 /* Target */, reportErrors, /*headMessage*/ undefined, intersectionState);
                     if (!related) {
                         return 0 /* False */;
                     }
@@ -63135,7 +63304,7 @@ var ts;
                 }
                 var len = sourceTypes.length;
                 for (var i = 0; i < len; i++) {
-                    var related = isRelatedTo(sourceTypes[i], target, reportErrors && i === len - 1, /*headMessage*/ undefined, intersectionState);
+                    var related = isRelatedTo(sourceTypes[i], target, 1 /* Source */, reportErrors && i === len - 1, /*headMessage*/ undefined, intersectionState);
                     if (related) {
                         return related;
                     }
@@ -63165,13 +63334,13 @@ var ts;
                         // union has a union of objects intersected with it. In such cases, if the input was, eg `("a" | "b" | "c") & (string | boolean | {} | {whatever})`,
                         // the result will have the structure `"a" | "b" | "c" | "a" & {} | "b" & {} | "c" & {} | "a" & {whatever} | "b" & {whatever} | "c" & {whatever}`
                         // - the resulting union has a length which is a multiple of the original union, and the elements correspond modulo the length of the original union
-                        var related_1 = isRelatedTo(sourceType, undefinedStrippedTarget.types[i % undefinedStrippedTarget.types.length], /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState);
+                        var related_1 = isRelatedTo(sourceType, undefinedStrippedTarget.types[i % undefinedStrippedTarget.types.length], 3 /* Both */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState);
                         if (related_1) {
                             result &= related_1;
                             continue;
                         }
                     }
-                    var related = isRelatedTo(sourceType, target, reportErrors, /*headMessage*/ undefined, intersectionState);
+                    var related = isRelatedTo(sourceType, target, 1 /* Source */, reportErrors, /*headMessage*/ undefined, intersectionState);
                     if (!related) {
                         return 0 /* False */;
                     }
@@ -63203,31 +63372,31 @@ var ts;
                             // Even an `Unmeasurable` variance works out without a structural check if the source and target are _identical_.
                             // We can't simply assume invariance, because `Unmeasurable` marks nonlinear relations, for example, a relation tained by
                             // the `-?` modifier in a mapped type (where, no matter how the inputs are related, the outputs still might not be)
-                            related = relation === identityRelation ? isRelatedTo(s, t, /*reportErrors*/ false) : compareTypesIdentical(s, t);
+                            related = relation === identityRelation ? isRelatedTo(s, t, 3 /* Both */, /*reportErrors*/ false) : compareTypesIdentical(s, t);
                         }
                         else if (variance === 1 /* Covariant */) {
-                            related = isRelatedTo(s, t, reportErrors, /*headMessage*/ undefined, intersectionState);
+                            related = isRelatedTo(s, t, 3 /* Both */, reportErrors, /*headMessage*/ undefined, intersectionState);
                         }
                         else if (variance === 2 /* Contravariant */) {
-                            related = isRelatedTo(t, s, reportErrors, /*headMessage*/ undefined, intersectionState);
+                            related = isRelatedTo(t, s, 3 /* Both */, reportErrors, /*headMessage*/ undefined, intersectionState);
                         }
                         else if (variance === 3 /* Bivariant */) {
                             // In the bivariant case we first compare contravariantly without reporting
                             // errors. Then, if that doesn't succeed, we compare covariantly with error
                             // reporting. Thus, error elaboration will be based on the the covariant check,
                             // which is generally easier to reason about.
-                            related = isRelatedTo(t, s, /*reportErrors*/ false);
+                            related = isRelatedTo(t, s, 3 /* Both */, /*reportErrors*/ false);
                             if (!related) {
-                                related = isRelatedTo(s, t, reportErrors, /*headMessage*/ undefined, intersectionState);
+                                related = isRelatedTo(s, t, 3 /* Both */, reportErrors, /*headMessage*/ undefined, intersectionState);
                             }
                         }
                         else {
                             // In the invariant case we first compare covariantly, and only when that
                             // succeeds do we proceed to compare contravariantly. Thus, error elaboration
                             // will typically be based on the covariant check.
-                            related = isRelatedTo(s, t, reportErrors, /*headMessage*/ undefined, intersectionState);
+                            related = isRelatedTo(s, t, 3 /* Both */, reportErrors, /*headMessage*/ undefined, intersectionState);
                             if (related) {
-                                related &= isRelatedTo(t, s, reportErrors, /*headMessage*/ undefined, intersectionState);
+                                related &= isRelatedTo(t, s, 3 /* Both */, reportErrors, /*headMessage*/ undefined, intersectionState);
                             }
                         }
                         if (!related) {
@@ -63243,7 +63412,7 @@ var ts;
             // Third, check if both types are part of deeply nested chains of generic type instantiations and if so assume the types are
             // equal and infinitely expanding. Fourth, if we have reached a depth of 100 nested comparisons, assume we have runaway recursion
             // and issue an error. Otherwise, actually compare the structure of the two types.
-            function recursiveTypeRelatedTo(source, target, reportErrors, intersectionState) {
+            function recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags) {
                 if (overflow) {
                     return 0 /* False */;
                 }
@@ -63287,7 +63456,7 @@ var ts;
                             return 3 /* Maybe */;
                         }
                     }
-                    if (depth === 100) {
+                    if (sourceDepth === 100 || targetDepth === 100) {
                         overflow = true;
                         return 0 /* False */;
                     }
@@ -63295,13 +63464,18 @@ var ts;
                 var maybeStart = maybeCount;
                 maybeKeys[maybeCount] = id;
                 maybeCount++;
-                sourceStack[depth] = source;
-                targetStack[depth] = target;
-                depth++;
+                if (recursionFlags & 1 /* Source */) {
+                    sourceStack[sourceDepth] = source;
+                    sourceDepth++;
+                }
+                if (recursionFlags & 2 /* Target */) {
+                    targetStack[targetDepth] = target;
+                    targetDepth++;
+                }
                 var saveExpandingFlags = expandingFlags;
-                if (!(expandingFlags & 1 /* Source */) && isDeeplyNestedType(source, sourceStack, depth))
+                if (!(expandingFlags & 1 /* Source */) && isDeeplyNestedType(source, sourceStack, sourceDepth))
                     expandingFlags |= 1 /* Source */;
-                if (!(expandingFlags & 2 /* Target */) && isDeeplyNestedType(target, targetStack, depth))
+                if (!(expandingFlags & 2 /* Target */) && isDeeplyNestedType(target, targetStack, targetDepth))
                     expandingFlags |= 2 /* Target */;
                 var originalHandler;
                 var propagatingVarianceFlags = 0;
@@ -63318,7 +63492,8 @@ var ts;
                         sourceIdStack: sourceStack.map(function (t) { return t.id; }),
                         targetId: target.id,
                         targetIdStack: targetStack.map(function (t) { return t.id; }),
-                        depth: depth,
+                        depth: sourceDepth,
+                        targetDepth: targetDepth
                     });
                 }
                 var result = expandingFlags !== 3 /* Both */ ? structuredTypeRelatedTo(source, target, reportErrors, intersectionState) : 3 /* Maybe */;
@@ -63326,9 +63501,14 @@ var ts;
                     outofbandVarianceMarkerHandler = originalHandler;
                 }
                 expandingFlags = saveExpandingFlags;
-                depth--;
+                if (recursionFlags & 1 /* Source */) {
+                    sourceDepth--;
+                }
+                if (recursionFlags & 2 /* Target */) {
+                    targetDepth--;
+                }
                 if (result) {
-                    if (result === -1 /* True */ || depth === 0) {
+                    if (result === -1 /* True */ || (sourceDepth === 0 && targetDepth === 0)) {
                         if (result === -1 /* True */ || result === 3 /* Maybe */) {
                             // If result is definitely true, record all maybe keys as having succeeded. Also, record Ternary.Maybe
                             // results as having succeeded once we reach depth 0, but never record Ternary.Unknown results.
@@ -63382,7 +63562,7 @@ var ts;
                         if (constraints !== source.types) {
                             source = getIntersectionType(constraints);
                             if (!(source.flags & 2097152 /* Intersection */)) {
-                                return isRelatedTo(source, target, /*reportErrors*/ false);
+                                return isRelatedTo(source, target, 1 /* Source */, /*reportErrors*/ false);
                             }
                         }
                     }
@@ -63404,22 +63584,22 @@ var ts;
                 var flags = source.flags & target.flags;
                 if (relation === identityRelation && !(flags & 524288 /* Object */)) {
                     if (flags & 4194304 /* Index */) {
-                        return isRelatedTo(source.type, target.type, /*reportErrors*/ false);
+                        return isRelatedTo(source.type, target.type, 3 /* Both */, /*reportErrors*/ false);
                     }
                     var result_8 = 0 /* False */;
                     if (flags & 8388608 /* IndexedAccess */) {
-                        if (result_8 = isRelatedTo(source.objectType, target.objectType, /*reportErrors*/ false)) {
-                            if (result_8 &= isRelatedTo(source.indexType, target.indexType, /*reportErrors*/ false)) {
+                        if (result_8 = isRelatedTo(source.objectType, target.objectType, 3 /* Both */, /*reportErrors*/ false)) {
+                            if (result_8 &= isRelatedTo(source.indexType, target.indexType, 3 /* Both */, /*reportErrors*/ false)) {
                                 return result_8;
                             }
                         }
                     }
                     if (flags & 16777216 /* Conditional */) {
                         if (source.root.isDistributive === target.root.isDistributive) {
-                            if (result_8 = isRelatedTo(source.checkType, target.checkType, /*reportErrors*/ false)) {
-                                if (result_8 &= isRelatedTo(source.extendsType, target.extendsType, /*reportErrors*/ false)) {
-                                    if (result_8 &= isRelatedTo(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target), /*reportErrors*/ false)) {
-                                        if (result_8 &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), /*reportErrors*/ false)) {
+                            if (result_8 = isRelatedTo(source.checkType, target.checkType, 3 /* Both */, /*reportErrors*/ false)) {
+                                if (result_8 &= isRelatedTo(source.extendsType, target.extendsType, 3 /* Both */, /*reportErrors*/ false)) {
+                                    if (result_8 &= isRelatedTo(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target), 3 /* Both */, /*reportErrors*/ false)) {
+                                        if (result_8 &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), 3 /* Both */, /*reportErrors*/ false)) {
                                             return result_8;
                                         }
                                     }
@@ -63428,7 +63608,7 @@ var ts;
                         }
                     }
                     if (flags & 33554432 /* Substitution */) {
-                        return isRelatedTo(source.substitute, target.substitute, /*reportErrors*/ false);
+                        return isRelatedTo(source.substitute, target.substitute, 3 /* Both */, /*reportErrors*/ false);
                     }
                     return 0 /* False */;
                 }
@@ -63453,47 +63633,71 @@ var ts;
                 }
                 // For a generic type T and a type U that is assignable to T, [...U] is assignable to T, U is assignable to readonly [...T],
                 // and U is assignable to [...T] when U is constrained to a mutable array or tuple type.
-                if (isSingleElementGenericTupleType(source) && !source.target.readonly && (result = isRelatedTo(getTypeArguments(source)[0], target)) ||
-                    isSingleElementGenericTupleType(target) && (target.target.readonly || isMutableArrayOrTuple(getBaseConstraintOfType(source) || source)) && (result = isRelatedTo(source, getTypeArguments(target)[0]))) {
+                if (isSingleElementGenericTupleType(source) && !source.target.readonly && (result = isRelatedTo(getTypeArguments(source)[0], target, 1 /* Source */)) ||
+                    isSingleElementGenericTupleType(target) && (target.target.readonly || isMutableArrayOrTuple(getBaseConstraintOfType(source) || source)) && (result = isRelatedTo(source, getTypeArguments(target)[0], 2 /* Target */))) {
                     return result;
                 }
                 if (target.flags & 262144 /* TypeParameter */) {
                     // A source type { [P in Q]: X } is related to a target type T if keyof T is related to Q and X is related to T[Q].
-                    if (ts.getObjectFlags(source) & 32 /* Mapped */ && !source.declaration.nameType && isRelatedTo(getIndexType(target), getConstraintTypeFromMappedType(source))) {
+                    if (ts.getObjectFlags(source) & 32 /* Mapped */ && !source.declaration.nameType && isRelatedTo(getIndexType(target), getConstraintTypeFromMappedType(source), 3 /* Both */)) {
                         if (!(getMappedTypeModifiers(source) & 4 /* IncludeOptional */)) {
                             var templateType = getTemplateTypeFromMappedType(source);
                             var indexedAccessType = getIndexedAccessType(target, getTypeParameterFromMappedType(source));
-                            if (result = isRelatedTo(templateType, indexedAccessType, reportErrors)) {
+                            if (result = isRelatedTo(templateType, indexedAccessType, 3 /* Both */, reportErrors)) {
                                 return result;
                             }
                         }
                     }
                 }
                 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, 3 /* Both */, /*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), 2 /* Target */, 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 }',
                             // 'keyof T' has itself as its constraint and produces a Ternary.Maybe when
                             // related to other types.
-                            if (isRelatedTo(source, getIndexType(constraint, target.stringsOnly), reportErrors) === -1 /* True */) {
+                            if (isRelatedTo(source, getIndexType(constraint, target.stringsOnly), 2 /* Target */, reportErrors) === -1 /* True */) {
+                                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, 2 /* Target */, reportErrors) === -1 /* True */) {
                                 return -1 /* True */;
                             }
                         }
@@ -63503,8 +63707,8 @@ var ts;
                     if (source.flags & 8388608 /* IndexedAccess */) {
                         // Relate components directly before falling back to constraint relationships
                         // A type S[K] is related to a type T[J] if S is related to T and K is related to J.
-                        if (result = isRelatedTo(source.objectType, target.objectType, reportErrors)) {
-                            result &= isRelatedTo(source.indexType, target.indexType, reportErrors);
+                        if (result = isRelatedTo(source.objectType, target.objectType, 3 /* Both */, reportErrors)) {
+                            result &= isRelatedTo(source.indexType, target.indexType, 3 /* Both */, reportErrors);
                         }
                         if (result) {
                             resetErrorInfo(saveErrorInfo);
@@ -63529,7 +63733,7 @@ var ts;
                                     // create a new chain for the constraint error
                                     resetErrorInfo(saveErrorInfo);
                                 }
-                                if (result = isRelatedTo(source, constraint, reportErrors)) {
+                                if (result = isRelatedTo(source, constraint, 2 /* Target */, reportErrors)) {
                                     return result;
                                 }
                                 // prefer the shorter chain of the constraint comparison chain, and the direct comparison chain
@@ -63569,13 +63773,14 @@ var ts;
                             // A source type `S` is related to a target type `{ [P in Q as R]?: T }` if some constituent `R'` of `R` is related to `keyof S` and `S[R']` is related to `T`.
                             if (includeOptional
                                 ? !(filteredByApplicability.flags & 131072 /* Never */)
-                                : isRelatedTo(targetKeys, sourceKeys)) {
+                                : isRelatedTo(targetKeys, sourceKeys, 3 /* Both */)) {
+                                var templateType_1 = getTemplateTypeFromMappedType(target);
                                 var typeParameter = getTypeParameterFromMappedType(target);
                                 // Fastpath: When the template type has the form `Obj[P]` where `P` is the mapped type parameter, directly compare source `S` with `Obj`
                                 // to avoid creating the (potentially very large) number of new intermediate types made by manufacturing `S[P]`.
-                                var nonNullComponent = extractTypesOfKind(templateType, ~98304 /* Nullable */);
+                                var nonNullComponent = extractTypesOfKind(templateType_1, ~98304 /* Nullable */);
                                 if (!keysRemapped && nonNullComponent.flags & 8388608 /* IndexedAccess */ && nonNullComponent.indexType === typeParameter) {
-                                    if (result = isRelatedTo(source, nonNullComponent.objectType, reportErrors)) {
+                                    if (result = isRelatedTo(source, nonNullComponent.objectType, 2 /* Target */, reportErrors)) {
                                         return result;
                                     }
                                 }
@@ -63595,7 +63800,7 @@ var ts;
                                             : typeParameter;
                                     var indexedAccessType = getIndexedAccessType(source, indexingType);
                                     // Compare `S[indexingType]` to `T`, where `T` is the type of a property of the target type.
-                                    if (result = isRelatedTo(indexedAccessType, templateType, reportErrors)) {
+                                    if (result = isRelatedTo(indexedAccessType, templateType_1, 3 /* Both */, reportErrors)) {
                                         return result;
                                     }
                                 }
@@ -63622,10 +63827,11 @@ var ts;
                         newParam.mapper = distributionMapper;
                     }
                     // TODO: Find a nice way to include potential conditional type breakdowns in error output, if they seem good (they usually don't)
-                    var localResult = void 0;
-                    if (skipTrue || (localResult = isRelatedTo(source, distributionMapper ? instantiateType(getTypeFromTypeNode(c.root.node.trueType), distributionMapper) : getTrueTypeFromConditionalType(c), /*reportErrors*/ false))) {
-                        if (!skipFalse) {
-                            localResult = (localResult || 3 /* Maybe */) & isRelatedTo(source, distributionMapper ? instantiateType(getTypeFromTypeNode(c.root.node.falseType), distributionMapper) : getFalseTypeFromConditionalType(c), /*reportErrors*/ false);
+                    var expanding = isDeeplyNestedType(target, targetStack, targetDepth);
+                    var localResult = expanding ? 3 /* Maybe */ : undefined;
+                    if (skipTrue || expanding || (localResult = isRelatedTo(source, distributionMapper ? instantiateType(getTypeFromTypeNode(c.root.node.trueType), distributionMapper) : getTrueTypeFromConditionalType(c), 2 /* Target */, /*reportErrors*/ false))) {
+                        if (!skipFalse && !expanding) {
+                            localResult = (localResult || 3 /* Maybe */) & isRelatedTo(source, distributionMapper ? instantiateType(getTypeFromTypeNode(c.root.node.falseType), distributionMapper) : getFalseTypeFromConditionalType(c), 2 /* Target */, /*reportErrors*/ false);
                         }
                     }
                     if (localResult) {
@@ -63635,6 +63841,9 @@ var ts;
                 }
                 else if (target.flags & 134217728 /* TemplateLiteral */) {
                     if (source.flags & 134217728 /* TemplateLiteral */) {
+                        if (relation === comparableRelation) {
+                            return templateLiteralTypesDefinitelyUnrelated(source, target) ? 0 /* False */ : -1 /* True */;
+                        }
                         // Report unreliable variance for type variables referenced in template literal type placeholders.
                         // For example, `foo-${number}` is related to `foo-${string}` even though number isn't related to string.
                         instantiateType(source, makeFunctionTypeMapper(reportUnreliableMarkers));
@@ -63650,34 +63859,33 @@ var ts;
                         var constraint = getConstraintOfType(source);
                         if (!constraint || (source.flags & 262144 /* TypeParameter */ && constraint.flags & 1 /* Any */)) {
                             // A type variable with no constraint is not related to the non-primitive object type.
-                            if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864 /* NonPrimitive */))) {
+                            if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864 /* NonPrimitive */), 3 /* Both */)) {
                                 resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
                         // hi-speed no-this-instantiation check (less accurate, but avoids costly `this`-instantiation when the constraint will suffice), see #28231 for report on why this is needed
-                        else if (result = isRelatedTo(constraint, target, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
+                        else if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                         // slower, fuller, this-instantiated check (necessary when comparing raw `this` types from base classes), see `subclassWithPolymorphicThisIsAssignable.ts` test for example
-                        else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, reportErrors && !(target.flags & source.flags & 262144 /* TypeParameter */), /*headMessage*/ undefined, intersectionState)) {
+                        else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1 /* Source */, reportErrors && !(target.flags & source.flags & 262144 /* TypeParameter */), /*headMessage*/ undefined, intersectionState)) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
                 }
                 else if (source.flags & 4194304 /* Index */) {
-                    if (result = isRelatedTo(keyofConstraintType, target, reportErrors)) {
+                    if (result = isRelatedTo(keyofConstraintType, target, 1 /* Source */, reportErrors)) {
                         resetErrorInfo(saveErrorInfo);
                         return result;
                     }
                 }
-                else if (source.flags & 134217728 /* TemplateLiteral */) {
+                else if (source.flags & 134217728 /* TemplateLiteral */ && !(target.flags & 524288 /* Object */)) {
                     if (!(target.flags & 134217728 /* TemplateLiteral */)) {
-                        var baseConstraint = getBaseConstraintOfType(source);
-                        var constraint = baseConstraint && baseConstraint !== source ? baseConstraint : stringType;
-                        if (result = isRelatedTo(constraint, target, reportErrors)) {
+                        var constraint = getBaseConstraintOfType(source);
+                        if (constraint && constraint !== source && (result = isRelatedTo(constraint, target, 1 /* Source */, reportErrors))) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
@@ -63685,14 +63893,14 @@ var ts;
                 }
                 else if (source.flags & 268435456 /* StringMapping */) {
                     if (target.flags & 268435456 /* StringMapping */ && source.symbol === target.symbol) {
-                        if (result = isRelatedTo(source.type, target.type, reportErrors)) {
+                        if (result = isRelatedTo(source.type, target.type, 3 /* Both */, reportErrors)) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
                     else {
                         var constraint = getBaseConstraintOfType(source);
-                        if (constraint && (result = isRelatedTo(constraint, target, reportErrors))) {
+                        if (constraint && (result = isRelatedTo(constraint, target, 1 /* Source */, reportErrors))) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
@@ -63700,27 +63908,32 @@ var ts;
                 }
                 else if (source.flags & 16777216 /* Conditional */) {
                     if (target.flags & 16777216 /* Conditional */) {
-                        // Two conditional types 'T1 extends U1 ? X1 : Y1' and 'T2 extends U2 ? X2 : Y2' are related if
-                        // one of T1 and T2 is related to the other, U1 and U2 are identical types, X1 is related to X2,
-                        // and Y1 is related to Y2.
-                        var sourceParams = source.root.inferTypeParameters;
-                        var sourceExtends = source.extendsType;
-                        var mapper = void 0;
-                        if (sourceParams) {
-                            // If the source has infer type parameters, we instantiate them in the context of the target
-                            var ctx = createInferenceContext(sourceParams, /*signature*/ undefined, 0 /* None */, isRelatedTo);
-                            inferTypes(ctx.inferences, target.extendsType, sourceExtends, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
-                            sourceExtends = instantiateType(sourceExtends, ctx.mapper);
-                            mapper = ctx.mapper;
-                        }
-                        if (isTypeIdenticalTo(sourceExtends, target.extendsType) &&
-                            (isRelatedTo(source.checkType, target.checkType) || isRelatedTo(target.checkType, source.checkType))) {
-                            if (result = isRelatedTo(instantiateType(getTrueTypeFromConditionalType(source), mapper), getTrueTypeFromConditionalType(target), reportErrors)) {
-                                result &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), reportErrors);
-                            }
-                            if (result) {
-                                resetErrorInfo(saveErrorInfo);
-                                return result;
+                        // If one of the conditionals under comparison seems to be infinitely expanding, stop comparing it - back out, try
+                        // the constraint, and failing that, give up trying to relate the two. This is the only way we can handle recursive conditional
+                        // types, which might expand forever.
+                        if (!isDeeplyNestedType(source, sourceStack, sourceDepth) && !isDeeplyNestedType(target, targetStack, targetDepth)) {
+                            // Two conditional types 'T1 extends U1 ? X1 : Y1' and 'T2 extends U2 ? X2 : Y2' are related if
+                            // one of T1 and T2 is related to the other, U1 and U2 are identical types, X1 is related to X2,
+                            // and Y1 is related to Y2.
+                            var sourceParams = source.root.inferTypeParameters;
+                            var sourceExtends = source.extendsType;
+                            var mapper = void 0;
+                            if (sourceParams) {
+                                // If the source has infer type parameters, we instantiate them in the context of the target
+                                var ctx = createInferenceContext(sourceParams, /*signature*/ undefined, 0 /* None */, isRelatedToWorker);
+                                inferTypes(ctx.inferences, target.extendsType, sourceExtends, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
+                                sourceExtends = instantiateType(sourceExtends, ctx.mapper);
+                                mapper = ctx.mapper;
+                            }
+                            if (isTypeIdenticalTo(sourceExtends, target.extendsType) &&
+                                (isRelatedTo(source.checkType, target.checkType, 3 /* Both */) || isRelatedTo(target.checkType, source.checkType, 3 /* Both */))) {
+                                if (result = isRelatedTo(instantiateType(getTrueTypeFromConditionalType(source), mapper), getTrueTypeFromConditionalType(target), 3 /* Both */, reportErrors)) {
+                                    result &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), 3 /* Both */, reportErrors);
+                                }
+                                if (result) {
+                                    resetErrorInfo(saveErrorInfo);
+                                    return result;
+                                }
                             }
                         }
                     }
@@ -63729,19 +63942,23 @@ var ts;
                         // more assignments than are desirable (since it maps the source check type to its constraint, it loses information)
                         var distributiveConstraint = getConstraintOfDistributiveConditionalType(source);
                         if (distributiveConstraint) {
-                            if (result = isRelatedTo(distributiveConstraint, target, reportErrors)) {
+                            if (result = isRelatedTo(distributiveConstraint, target, 1 /* Source */, reportErrors)) {
                                 resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
                     }
-                    // conditionals _can_ be related to one another via normal constraint, as, eg, `A extends B ? O : never` should be assignable to `O`
-                    // when `O` is a conditional (`never` is trivially aissgnable to `O`, as is `O`!).
-                    var defaultConstraint = getDefaultConstraintOfConditionalType(source);
-                    if (defaultConstraint) {
-                        if (result = isRelatedTo(defaultConstraint, target, reportErrors)) {
-                            resetErrorInfo(saveErrorInfo);
-                            return result;
+                    // We'll repeatedly decompose source side conditionals if they're recursive - check if we've already recured on the constraint a lot and, if so, bail
+                    // on the comparison.
+                    if (!isDeeplyNestedType(source, sourceStack, sourceDepth)) {
+                        // conditionals _can_ be related to one another via normal constraint, as, eg, `A extends B ? O : never` should be assignable to `O`
+                        // when `O` is a conditional (`never` is trivially assignable to `O`, as is `O`!).
+                        var defaultConstraint = getDefaultConstraintOfConditionalType(source);
+                        if (defaultConstraint) {
+                            if (result = isRelatedTo(defaultConstraint, target, 1 /* Source */, reportErrors)) {
+                                resetErrorInfo(saveErrorInfo);
+                                return result;
+                            }
                         }
                     }
                 }
@@ -63785,7 +64002,7 @@ var ts;
                     }
                     else if (isReadonlyArrayType(target) ? isArrayType(source) || isTupleType(source) : isArrayType(target) && isTupleType(source) && !source.target.readonly) {
                         if (relation !== identityRelation) {
-                            return isRelatedTo(getIndexTypeOfType(source, numberType) || anyType, getIndexTypeOfType(target, numberType) || anyType, reportErrors);
+                            return isRelatedTo(getIndexTypeOfType(source, numberType) || anyType, getIndexTypeOfType(target, numberType) || anyType, 3 /* Both */, reportErrors);
                         }
                         else {
                             // By flags alone, we know that the `target` is a readonly array while the source is a normal array or tuple
@@ -63907,10 +64124,10 @@ var ts;
                     var result_11;
                     var targetConstraint = getConstraintTypeFromMappedType(target);
                     var sourceConstraint = instantiateType(getConstraintTypeFromMappedType(source), makeFunctionTypeMapper(getCombinedMappedTypeOptionality(source) < 0 ? reportUnmeasurableMarkers : reportUnreliableMarkers));
-                    if (result_11 = isRelatedTo(targetConstraint, sourceConstraint, reportErrors)) {
+                    if (result_11 = isRelatedTo(targetConstraint, sourceConstraint, 3 /* Both */, reportErrors)) {
                         var mapper = createTypeMapper([getTypeParameterFromMappedType(source)], [getTypeParameterFromMappedType(target)]);
                         if (instantiateType(getNameTypeFromMappedType(source), mapper) === instantiateType(getNameTypeFromMappedType(target), mapper)) {
-                            return result_11 & isRelatedTo(instantiateType(getTemplateTypeFromMappedType(source), mapper), getTemplateTypeFromMappedType(target), reportErrors);
+                            return result_11 & isRelatedTo(instantiateType(getTemplateTypeFromMappedType(source), mapper), getTemplateTypeFromMappedType(target), 3 /* Both */, reportErrors);
                         }
                     }
                 }
@@ -64042,7 +64259,7 @@ var ts;
                 var targetIsOptional = strictNullChecks && !!(ts.getCheckFlags(targetProp) & 48 /* Partial */);
                 var effectiveTarget = addOptionality(getNonMissingTypeOfSymbol(targetProp), /*isProperty*/ false, targetIsOptional);
                 var effectiveSource = getTypeOfSourceProperty(sourceProp);
-                return isRelatedTo(effectiveSource, effectiveTarget, reportErrors, /*headMessage*/ undefined, intersectionState);
+                return isRelatedTo(effectiveSource, effectiveTarget, 3 /* Both */, reportErrors, /*headMessage*/ undefined, intersectionState);
             }
             function propertyRelatedTo(source, target, sourceProp, targetProp, getTypeOfSourceProperty, reportErrors, intersectionState, skipOptional) {
                 var sourcePropFlags = ts.getDeclarationModifierFlagsFromSymbol(sourceProp);
@@ -64224,7 +64441,7 @@ var ts;
                             var targetType = targetTypeArguments[i];
                             var targetCheckType = sourceFlags & 8 /* Variadic */ && targetFlags & 4 /* Rest */ ? createArrayType(targetType) :
                                 removeMissingType(targetType, !!(targetFlags & 2 /* Optional */));
-                            var related = isRelatedTo(sourceType, targetCheckType, reportErrors, /*headMessage*/ undefined, intersectionState);
+                            var related = isRelatedTo(sourceType, targetCheckType, 3 /* Both */, reportErrors, /*headMessage*/ undefined, intersectionState);
                             if (!related) {
                                 if (reportErrors && (targetArity > 1 || sourceArity > 1)) {
                                     if (i < startCount || i >= targetArity - endCount || sourceArity - startCount - endCount === 1) {
@@ -64418,7 +64635,7 @@ var ts;
              * See signatureAssignableTo, compareSignaturesIdentical
              */
             function signatureRelatedTo(source, target, erase, reportErrors, incompatibleReporter) {
-                return compareSignaturesRelated(erase ? getErasedSignature(source) : source, erase ? getErasedSignature(target) : target, relation === strictSubtypeRelation ? 8 /* StrictArity */ : 0, reportErrors, reportError, incompatibleReporter, isRelatedTo, makeFunctionTypeMapper(reportUnreliableMarkers));
+                return compareSignaturesRelated(erase ? getErasedSignature(source) : source, erase ? getErasedSignature(target) : target, relation === strictSubtypeRelation ? 8 /* StrictArity */ : 0, reportErrors, reportError, incompatibleReporter, isRelatedToWorker, makeFunctionTypeMapper(reportUnreliableMarkers));
             }
             function signaturesIdenticalTo(source, target, kind) {
                 var sourceSignatures = getSignaturesOfType(source, kind);
@@ -64451,7 +64668,7 @@ var ts;
                         var type = exactOptionalPropertyTypes || propType.flags & 32768 /* Undefined */ || keyType === numberType || !(prop.flags & 16777216 /* Optional */)
                             ? propType
                             : getTypeWithFacts(propType, 524288 /* NEUndefined */);
-                        var related = isRelatedTo(type, targetInfo.type, reportErrors);
+                        var related = isRelatedTo(type, targetInfo.type, 3 /* Both */, reportErrors);
                         if (!related) {
                             if (reportErrors) {
                                 reportError(ts.Diagnostics.Property_0_is_incompatible_with_index_signature, symbolToString(prop));
@@ -64474,7 +64691,7 @@ var ts;
                 return result;
             }
             function indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors) {
-                var related = isRelatedTo(sourceInfo.type, targetInfo.type, reportErrors);
+                var related = isRelatedTo(sourceInfo.type, targetInfo.type, 3 /* Both */, reportErrors);
                 if (!related && reportErrors) {
                     if (sourceInfo.keyType === targetInfo.keyType) {
                         reportError(ts.Diagnostics._0_index_signatures_are_incompatible, typeToString(sourceInfo.keyType));
@@ -64495,7 +64712,7 @@ var ts;
                 for (var _i = 0, indexInfos_3 = indexInfos; _i < indexInfos_3.length; _i++) {
                     var targetInfo = indexInfos_3[_i];
                     var related = !sourceIsPrimitive && targetHasStringIndex && targetInfo.type.flags & 1 /* Any */ ? -1 /* True */ :
-                        isGenericMappedType(source) && targetHasStringIndex ? isRelatedTo(getTemplateTypeFromMappedType(source), targetInfo.type, reportErrors) :
+                        isGenericMappedType(source) && targetHasStringIndex ? isRelatedTo(getTemplateTypeFromMappedType(source), targetInfo.type, 3 /* Both */, reportErrors) :
                             typeRelatedToIndexInfo(source, targetInfo, reportErrors, intersectionState);
                     if (!related) {
                         return 0 /* False */;
@@ -64527,7 +64744,7 @@ var ts;
                 for (var _i = 0, targetInfos_1 = targetInfos; _i < targetInfos_1.length; _i++) {
                     var targetInfo = targetInfos_1[_i];
                     var sourceInfo = getIndexInfoOfType(source, targetInfo.keyType);
-                    if (!(sourceInfo && isRelatedTo(sourceInfo.type, targetInfo.type) && sourceInfo.isReadonly === targetInfo.isReadonly)) {
+                    if (!(sourceInfo && isRelatedTo(sourceInfo.type, targetInfo.type, 3 /* Both */) && sourceInfo.isReadonly === targetInfo.isReadonly)) {
                         return 0 /* False */;
                     }
                 }
@@ -65941,6 +66158,17 @@ var ts;
         function isFromInferenceBlockedSource(type) {
             return !!(type.symbol && ts.some(type.symbol.declarations, hasSkipDirectInferenceFlag));
         }
+        function templateLiteralTypesDefinitelyUnrelated(source, target) {
+            // Two template literal types with diffences in their starting or ending text spans are definitely unrelated.
+            var sourceStart = source.texts[0];
+            var targetStart = target.texts[0];
+            var sourceEnd = source.texts[source.texts.length - 1];
+            var targetEnd = target.texts[target.texts.length - 1];
+            var startLen = Math.min(sourceStart.length, targetStart.length);
+            var endLen = Math.min(sourceEnd.length, targetEnd.length);
+            return sourceStart.slice(0, startLen) !== targetStart.slice(0, startLen) ||
+                sourceEnd.slice(sourceEnd.length - endLen) !== targetEnd.slice(targetEnd.length - endLen);
+        }
         function isValidBigIntString(s) {
             var scanner = ts.createScanner(99 /* ESNext */, /*skipTrivia*/ false);
             var success = true;
@@ -67003,7 +67231,7 @@ var ts;
                     if (prop.isDiscriminantProperty === undefined) {
                         prop.isDiscriminantProperty =
                             (prop.checkFlags & 192 /* Discriminant */) === 192 /* Discriminant */ &&
-                                !maybeTypeOfKind(getTypeOfSymbol(prop), 465829888 /* Instantiable */ & ~134217728 /* TemplateLiteral */);
+                                !isGenericType(getTypeOfSymbol(prop));
                     }
                     return !!prop.isDiscriminantProperty;
                 }
@@ -67522,17 +67750,19 @@ var ts;
         function extractTypesOfKind(type, kind) {
             return filterType(type, function (t) { return (t.flags & kind) !== 0; });
         }
-        // Return a new type in which occurrences of the string and number primitive types in
-        // typeWithPrimitives have been replaced with occurrences of string literals and numeric
-        // literals in typeWithLiterals, respectively.
+        // Return a new type in which occurrences of the string, number and bigint primitives and placeholder template
+        // literal types in typeWithPrimitives have been replaced with occurrences of compatible and more specific types
+        // from typeWithLiterals. This is essentially a limited form of intersection between the two types. We avoid a
+        // true intersection because it is more costly and, when applied to union types, generates a large number of
+        // types we don't actually care about.
         function replacePrimitivesWithLiterals(typeWithPrimitives, typeWithLiterals) {
-            if (isTypeSubsetOf(stringType, typeWithPrimitives) && maybeTypeOfKind(typeWithLiterals, 128 /* StringLiteral */) ||
-                isTypeSubsetOf(numberType, typeWithPrimitives) && maybeTypeOfKind(typeWithLiterals, 256 /* NumberLiteral */) ||
-                isTypeSubsetOf(bigintType, typeWithPrimitives) && maybeTypeOfKind(typeWithLiterals, 2048 /* BigIntLiteral */)) {
+            if (maybeTypeOfKind(typeWithPrimitives, 4 /* String */ | 134217728 /* TemplateLiteral */ | 8 /* Number */ | 64 /* BigInt */) &&
+                maybeTypeOfKind(typeWithLiterals, 128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */ | 256 /* NumberLiteral */ | 2048 /* BigIntLiteral */)) {
                 return mapType(typeWithPrimitives, function (t) {
-                    return t.flags & 4 /* String */ ? extractTypesOfKind(typeWithLiterals, 4 /* String */ | 128 /* StringLiteral */) :
-                        t.flags & 8 /* Number */ ? extractTypesOfKind(typeWithLiterals, 8 /* Number */ | 256 /* NumberLiteral */) :
-                            t.flags & 64 /* BigInt */ ? extractTypesOfKind(typeWithLiterals, 64 /* BigInt */ | 2048 /* BigIntLiteral */) : t;
+                    return t.flags & 4 /* String */ ? extractTypesOfKind(typeWithLiterals, 4 /* String */ | 128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) :
+                        isPatternLiteralType(t) && !maybeTypeOfKind(typeWithLiterals, 4 /* String */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ? extractTypesOfKind(typeWithLiterals, 128 /* StringLiteral */) :
+                            t.flags & 8 /* Number */ ? extractTypesOfKind(typeWithLiterals, 8 /* Number */ | 256 /* NumberLiteral */) :
+                                t.flags & 64 /* BigInt */ ? extractTypesOfKind(typeWithLiterals, 64 /* BigInt */ | 2048 /* BigIntLiteral */) : t;
                 });
             }
             return typeWithPrimitives;
@@ -67613,10 +67843,10 @@ var ts;
                 isTypeAssignableToKind(getTypeOfExpression(parent.argumentExpression), 296 /* NumberLike */);
             return isLengthPushOrUnshift || isElementAssignment;
         }
-        function isDeclarationWithExplicitTypeAnnotation(declaration) {
-            return (declaration.kind === 253 /* VariableDeclaration */ || declaration.kind === 163 /* Parameter */ ||
-                declaration.kind === 166 /* PropertyDeclaration */ || declaration.kind === 165 /* PropertySignature */) &&
-                !!ts.getEffectiveTypeAnnotationNode(declaration);
+        function isDeclarationWithExplicitTypeAnnotation(node) {
+            return (ts.isVariableDeclaration(node) || ts.isPropertyDeclaration(node) || ts.isPropertySignature(node) || ts.isParameter(node)) &&
+                !!(ts.getEffectiveTypeAnnotationNode(node) ||
+                    ts.isInJSFile(node) && ts.hasInitializer(node) && node.initializer && ts.isFunctionExpressionOrArrowFunction(node.initializer) && ts.getEffectiveReturnTypeNode(node.initializer));
         }
         function getExplicitTypeOfSymbol(symbol, diagnostic) {
             if (symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 512 /* ValueModule */)) {
@@ -68333,7 +68563,7 @@ var ts;
                 var narrowedPropType = narrowType(propType);
                 return filterType(type, function (t) {
                     var discriminantType = getTypeOfPropertyOrIndexSignature(t, propName);
-                    return !(discriminantType.flags & 131072 /* Never */) && isTypeComparableTo(discriminantType, narrowedPropType);
+                    return !(narrowedPropType.flags & 131072 /* Never */) && isTypeComparableTo(narrowedPropType, discriminantType);
                 });
             }
             function narrowTypeByDiscriminantProperty(type, access, operator, value, assumeTrue) {
@@ -68802,16 +69032,7 @@ var ts;
             }
             function getNarrowedType(type, candidate, assumeTrue, isRelated) {
                 if (!assumeTrue) {
-                    return filterType(type, function (t) {
-                        if (!isRelated(t, candidate)) {
-                            return true;
-                        }
-                        var constraint = getBaseConstraintOfType(t);
-                        if (constraint && constraint !== t) {
-                            return !isRelated(constraint, candidate);
-                        }
-                        return false;
-                    });
+                    return filterType(type, function (t) { return !isRelated(t, candidate); });
                 }
                 // If the current type is a union type, remove all constituents that couldn't be instances of
                 // the candidate type. If one or more constituents remain, return a union of those.
@@ -70253,9 +70474,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;
@@ -70713,12 +70934,9 @@ var ts;
             }
             return !hasEffectiveRestParameter(signature) && getParameterCount(signature) < targetParameterCount;
         }
-        function isFunctionExpressionOrArrowFunction(node) {
-            return node.kind === 212 /* FunctionExpression */ || node.kind === 213 /* ArrowFunction */;
-        }
         function getContextualSignatureForFunctionLikeDeclaration(node) {
             // Only function expressions, arrow functions, and object literal methods are contextually typed.
-            return isFunctionExpressionOrArrowFunction(node) || ts.isObjectLiteralMethod(node)
+            return ts.isFunctionExpressionOrArrowFunction(node) || ts.isObjectLiteralMethod(node)
                 ? getContextualSignature(node)
                 : undefined;
         }
@@ -71685,6 +71903,14 @@ var ts;
                         markAliasSymbolAsReferenced(jsxFactorySym);
                     }
                 }
+                // For JsxFragment, mark jsx pragma as referenced via resolveName
+                if (ts.isJsxOpeningFragment(node)) {
+                    var file = ts.getSourceFileOfNode(node);
+                    var localJsxNamespace = getLocalJsxNamespace(file);
+                    if (localJsxNamespace) {
+                        resolveName(jsxFactoryLocation, localJsxNamespace, 111551 /* Value */, jsxFactoryRefErr, localJsxNamespace, /*isUse*/ true);
+                    }
+                }
             }
             if (isNodeOpeningLikeElement) {
                 var jsxOpeningLikeNode = node;
@@ -73357,7 +73583,7 @@ var ts;
                 return false;
             var symbol = resolveName(node.expression, node.expression.escapedText, 111551 /* Value */, undefined, undefined, false);
             var decl = symbol === null || symbol === void 0 ? void 0 : symbol.valueDeclaration;
-            if (!decl || !ts.isParameter(decl) || !isFunctionExpressionOrArrowFunction(decl.parent) || !ts.isNewExpression(decl.parent.parent) || !ts.isIdentifier(decl.parent.parent.expression)) {
+            if (!decl || !ts.isParameter(decl) || !ts.isFunctionExpressionOrArrowFunction(decl.parent) || !ts.isNewExpression(decl.parent.parent) || !ts.isIdentifier(decl.parent.parent.expression)) {
                 return false;
             }
             var globalPromiseSymbol = getGlobalPromiseConstructorSymbol(/*reportErrors*/ false);
@@ -74601,18 +74827,18 @@ var ts;
             if (moduleSymbol) {
                 var esModuleSymbol = resolveESModuleSymbol(moduleSymbol, specifier, /*dontRecursivelyResolve*/ true, /*suppressUsageError*/ false);
                 if (esModuleSymbol) {
-                    return createPromiseReturnType(node, getTypeWithSyntheticDefaultImportType(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol));
+                    return createPromiseReturnType(node, getTypeWithSyntheticDefaultImportType(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol, specifier));
                 }
             }
             return createPromiseReturnType(node, anyType);
         }
-        function getTypeWithSyntheticDefaultImportType(type, symbol, originalSymbol) {
+        function getTypeWithSyntheticDefaultImportType(type, symbol, originalSymbol, moduleSpecifier) {
             var _a;
             if (allowSyntheticDefaultImports && type && !isErrorType(type)) {
                 var synthType = type;
                 if (!synthType.syntheticType) {
                     var file = (_a = originalSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile);
-                    var hasSyntheticDefault = canHaveSyntheticDefault(file, originalSymbol, /*dontResolveAlias*/ false);
+                    var hasSyntheticDefault = canHaveSyntheticDefault(file, originalSymbol, /*dontResolveAlias*/ false, moduleSpecifier);
                     if (hasSyntheticDefault) {
                         var memberTable = ts.createSymbolTable();
                         var newSymbol = createSymbol(2097152 /* Alias */, "default" /* Default */);
@@ -74774,16 +75000,14 @@ var ts;
             }
         }
         function checkImportMetaProperty(node) {
-            if (moduleKind !== ts.ModuleKind.ES2020 && moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System) {
-                if (moduleKind === ts.ModuleKind.Node12 || moduleKind === ts.ModuleKind.NodeNext) {
-                    if (ts.getSourceFileOfNode(node).impliedNodeFormat !== ts.ModuleKind.ESNext) {
-                        error(node, ts.Diagnostics.The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output);
-                    }
-                }
-                else {
-                    error(node, ts.Diagnostics.The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_esnext_system_node12_or_nodenext);
+            if (moduleKind === ts.ModuleKind.Node12 || moduleKind === ts.ModuleKind.NodeNext) {
+                if (ts.getSourceFileOfNode(node).impliedNodeFormat !== ts.ModuleKind.ESNext) {
+                    error(node, ts.Diagnostics.The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output);
                 }
             }
+            else if (moduleKind < ts.ModuleKind.ES2020 && moduleKind !== ts.ModuleKind.System) {
+                error(node, ts.Diagnostics.The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node12_or_nodenext);
+            }
             var file = ts.getSourceFileOfNode(node);
             ts.Debug.assert(!!(file.flags & 2097152 /* PossiblyContainsImportMeta */), "Containing file is missing import meta node flag.");
             return node.name.escapedText === "meta" ? getGlobalImportMetaType() : errorType;
@@ -75726,9 +75950,9 @@ var ts;
                                 var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module);
                                 diagnostics.add(diagnostic);
                             }
-                            if ((moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System && !(moduleKind === ts.ModuleKind.NodeNext && ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.ESNext)) || languageVersion < 4 /* ES2017 */) {
+                            if ((moduleKind !== ts.ModuleKind.ES2022 && moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System && !(moduleKind === ts.ModuleKind.NodeNext && ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.ESNext)) || languageVersion < 4 /* ES2017 */) {
                                 span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos);
-                                var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher);
+                                var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher);
                                 diagnostics.add(diagnostic);
                             }
                         }
@@ -77166,7 +77390,7 @@ var ts;
             }
         }
         function checkParenthesizedExpression(node, checkMode) {
-            if (ts.isJSDocTypeAssertion(node)) {
+            if (ts.hasJSDocNodes(node) && ts.isJSDocTypeAssertion(node)) {
                 var type = ts.getJSDocTypeAssertionType(node);
                 return checkAssertionWorker(type, type, node.expression, checkMode);
             }
@@ -79063,6 +79287,12 @@ var ts;
                 }
             }
         }
+        function checkJSDocAccessibilityModifiers(node) {
+            var host = ts.getJSDocHost(node);
+            if (host && ts.isPrivateIdentifierClassElementDeclaration(host)) {
+                error(node, ts.Diagnostics.An_accessibility_modifier_cannot_be_used_with_a_private_identifier);
+            }
+        }
         function getIdentifierFromEntityNameExpression(node) {
             switch (node.kind) {
                 case 79 /* Identifier */:
@@ -82398,11 +82628,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 */;
@@ -82712,6 +82946,10 @@ var ts;
                     return;
                 case 307 /* JSDocTypeExpression */:
                     return checkSourceElement(node.type);
+                case 331 /* JSDocPublicTag */:
+                case 333 /* JSDocProtectedTag */:
+                case 332 /* JSDocPrivateTag */:
+                    return checkJSDocAccessibilityModifiers(node);
                 case 193 /* IndexedAccessType */:
                     return checkIndexedAccessType(node);
                 case 194 /* MappedType */:
@@ -85407,8 +85645,8 @@ var ts;
                             if (!ts.isEffectiveExternalModule(sourceFile, compilerOptions)) {
                                 diagnostics.add(ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module));
                             }
-                            if ((moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System && !(moduleKind === ts.ModuleKind.NodeNext && ts.getSourceFileOfNode(forInOrOfStatement).impliedNodeFormat === ts.ModuleKind.ESNext)) || languageVersion < 4 /* ES2017 */) {
-                                diagnostics.add(ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher));
+                            if ((moduleKind !== ts.ModuleKind.ES2022 && moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System && !(moduleKind === ts.ModuleKind.NodeNext && ts.getSourceFileOfNode(forInOrOfStatement).impliedNodeFormat === ts.ModuleKind.ESNext)) || languageVersion < 4 /* ES2017 */) {
+                                diagnostics.add(ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher));
                             }
                         }
                     }
@@ -86077,14 +86315,27 @@ 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);
+                return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node12_or_nodenext);
             }
             if (node.typeArguments) {
                 return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_import_cannot_have_type_arguments);
@@ -86813,7 +87064,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));
@@ -86825,7 +87076,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);
@@ -87198,7 +87449,7 @@ var ts;
     }
     ts.createSourceMapGenerator = createSourceMapGenerator;
     // Sometimes tools can see the following line as a source mapping url comment, so we mangle it a bit (the [M])
-    var sourceMapCommentRegExp = /^\/\/[@#] source[M]appingURL=(.+)$/;
+    var sourceMapCommentRegExp = /^\/\/[@#] source[M]appingURL=(.+)\r?\n?$/;
     var whitespaceOrMapCommentRegExp = /^\s*(\/\/[@#] .*)?$/;
     function getLineInfo(text, lineStarts) {
         return {
@@ -90490,6 +90741,7 @@ var ts;
                 || (isExternalModuleExport(node)
                     && moduleKind !== ts.ModuleKind.ES2015
                     && moduleKind !== ts.ModuleKind.ES2020
+                    && moduleKind !== ts.ModuleKind.ES2022
                     && moduleKind !== ts.ModuleKind.ESNext
                     && moduleKind !== ts.ModuleKind.System);
         }
@@ -90766,9 +91018,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;
             }
         }
         /**
@@ -90777,7 +91031,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
@@ -90806,12 +91060,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, 
@@ -90824,16 +91076,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.
@@ -90842,7 +91094,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.
@@ -94443,7 +94695,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;
@@ -104159,7 +104411,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(
@@ -104199,7 +104451,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;
         }
@@ -104227,7 +104479,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];
         }
@@ -105794,7 +106046,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 */);
@@ -106168,6 +106420,7 @@ var ts;
     function getModuleTransformer(moduleKind) {
         switch (moduleKind) {
             case ts.ModuleKind.ESNext:
+            case ts.ModuleKind.ES2022:
             case ts.ModuleKind.ES2020:
             case ts.ModuleKind.ES2015:
                 return ts.transformECMAScriptModule;
@@ -109733,6 +109986,10 @@ var ts;
             writePunctuation("}");
         }
         function emitImportOrExportSpecifier(node) {
+            if (node.isTypeOnly) {
+                writeKeyword("type");
+                writeSpace();
+            }
             if (node.propertyName) {
                 emit(node.propertyName);
                 writeSpace();
@@ -118754,7 +119011,7 @@ var ts;
             var nodeModulesDirectoryName = moduleSpecifier.substring(parts.topLevelPackageNameIndex + 1);
             var packageName = ts.getPackageNameFromTypesPackageName(nodeModulesDirectoryName);
             // For classic resolution, only allow importing from node_modules/@types, not other node_modules
-            return ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeJs && packageName === nodeModulesDirectoryName ? undefined : packageName;
+            return ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Classic && packageName === nodeModulesDirectoryName ? undefined : packageName;
             function tryDirectoryWithPackageJson(packageRootIndex) {
                 var packageRootPath = path.substring(0, packageRootIndex);
                 var packageJsonPath = ts.combinePaths(packageRootPath, "package.json");
@@ -123773,6 +124030,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 */;
@@ -126737,7 +126998,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 */: {
@@ -127509,6 +127770,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;
@@ -127610,7 +127872,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);
             }
@@ -127661,25 +127923,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);
@@ -127690,7 +127968,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 {
@@ -127698,7 +127976,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; }));
@@ -127804,10 +128082,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;
@@ -127858,7 +128136,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;
                 }
             }
@@ -127931,22 +128209,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) {
@@ -127970,12 +128252,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.
@@ -127991,7 +128272,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;
                 }
@@ -128140,7 +128421,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);
                     }
@@ -128179,7 +128460,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)] };
                 }
@@ -128342,6 +128623,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;
@@ -128359,22 +128641,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 */) {
@@ -128494,10 +128788,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 = [];
@@ -128531,7 +128823,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));
@@ -128551,6 +128845,7 @@ var ts;
                 symbolToOriginInfoMap: symbolToOriginInfoMap,
                 recommendedCompletion: recommendedCompletion,
                 previousToken: previousToken,
+                contextToken: contextToken,
                 isJsxInitializer: isJsxInitializer,
                 insideJsDocTagTypeExpression: insideJsDocTagTypeExpression,
                 symbolToSortTextIdMap: symbolToSortTextIdMap,
@@ -128937,8 +129232,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);
@@ -129071,6 +129372,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.|
@@ -129209,23 +129511,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 */;
             }
             /**
@@ -129486,6 +129803,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 */:
@@ -129495,8 +129820,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);
                 }
@@ -129857,6 +130184,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);
                 }
@@ -130130,34 +130459,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))
@@ -136297,7 +136659,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
@@ -136431,7 +136793,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;
@@ -138908,7 +139271,7 @@ var ts;
                     if (!typeDisplayString) {
                         continue;
                     }
-                    addTypeHints(typeDisplayString, param.end);
+                    addTypeHints(typeDisplayString, param.name.end);
                 }
             }
             function getParameterDeclarationTypeDisplayString(symbol) {
@@ -146589,7 +146952,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);
             }
@@ -146611,7 +146974,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;
@@ -146753,7 +147116,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*.
@@ -146811,7 +147174,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 */));
@@ -147136,13 +147499,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) {
@@ -147161,8 +147524,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) {
@@ -147171,67 +147535,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;
@@ -147239,6 +147602,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);
@@ -147251,14 +147658,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);
@@ -147269,24 +147684,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;
@@ -147344,24 +147772,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) {
@@ -147416,14 +147841,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;
@@ -147434,13 +147879,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;
@@ -147448,10 +147909,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;
                 }
             });
         }
@@ -147483,44 +147944,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);
@@ -147570,7 +148037,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) {
@@ -147616,6 +148083,7 @@ var ts;
                 case ts.ModuleKind.System:
                 case ts.ModuleKind.ES2015:
                 case ts.ModuleKind.ES2020:
+                case ts.ModuleKind.ES2022:
                 case ts.ModuleKind.ESNext:
                 case ts.ModuleKind.None:
                     // Fall back to the `import * as ns` style import.
@@ -147634,12 +148102,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 };
         }
@@ -147717,63 +148185,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);
@@ -147784,8 +148270,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);
                     }
                 }
@@ -147801,8 +148287,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);
@@ -147826,44 +148318,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);
@@ -149350,8 +149851,8 @@ var ts;
     (function (codefix) {
         codefix.registerCodeFix({
             errorCodes: [
-                ts.Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher.code,
-                ts.Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher.code,
+                ts.Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher.code,
+                ts.Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher.code,
             ],
             getCodeActions: function (context) {
                 var compilerOptions = context.program.getCompilerOptions();
@@ -151775,7 +152276,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 = {}));
@@ -152247,7 +152748,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);
@@ -152994,10 +153495,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 = {}));
@@ -153110,7 +153611,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) {
@@ -153181,7 +153682,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));
             }
@@ -155883,7 +156384,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 {