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

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.5";
-    ts.version = ts.versionMajorMinor + ".0-insiders.20210927";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20211001";
     var NativeCollections;
     (function (NativeCollections) {
         function tryGetNativeMap() {
@@ -3294,6 +3294,7 @@ var ts;
         ModuleKind[ModuleKind["System"] = 4] = "System";
         ModuleKind[ModuleKind["ES2015"] = 5] = "ES2015";
         ModuleKind[ModuleKind["ES2020"] = 6] = "ES2020";
+        ModuleKind[ModuleKind["ES2022"] = 7] = "ES2022";
         ModuleKind[ModuleKind["ESNext"] = 99] = "ESNext";
         ModuleKind[ModuleKind["Node12"] = 100] = "Node12";
         ModuleKind[ModuleKind["NodeNext"] = 199] = "NodeNext";
@@ -5297,7 +5298,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."),
@@ -5315,7 +5316,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."),
@@ -5346,7 +5347,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 `}`?"),
@@ -5398,7 +5399,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}'?"),
@@ -5424,6 +5425,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.", undefined, 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}'.", undefined, 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}'.", undefined, 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."),
@@ -9723,7 +9726,7 @@ var ts;
         switch (node.kind) {
             case 269:
             case 274:
-                return node.parent.parent.isTypeOnly;
+                return node.isTypeOnly || node.parent.parent.isTypeOnly;
             case 267:
                 return node.parent.isTypeOnly;
             case 266:
@@ -15520,6 +15523,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:
@@ -15689,7 +15693,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();
@@ -15699,7 +15704,7 @@ var ts;
         return isDirectory ? [ts.getPathFromPathComponents(aParts), ts.getPathFromPathComponents(bParts)] : undefined;
     }
     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;
@@ -16239,10 +16244,6 @@ var ts;
             || !(isExpressionNode(useSite) || isShorthandPropertyNameUseSite(useSite));
     }
     ts.isValidTypeOnlyAliasUseSite = isValidTypeOnlyAliasUseSite;
-    function typeOnlyDeclarationIsExport(typeOnlyDeclaration) {
-        return typeOnlyDeclaration.kind === 274;
-    }
-    ts.typeOnlyDeclarationIsExport = typeOnlyDeclarationIsExport;
     function isShorthandPropertyNameUseSite(useSite) {
         return ts.isIdentifier(useSite) && ts.isShorthandPropertyAssignment(useSite.parent) && useSite.parent.name === useSite;
     }
@@ -16493,6 +16494,10 @@ var ts;
         return !!declaration && (ts.isParameter(declaration) || isCatchClauseVariableDeclaration(declaration));
     }
     ts.isParameterOrCatchClauseVariable = isParameterOrCatchClauseVariable;
+    function isFunctionExpressionOrArrowFunction(node) {
+        return node.kind === 212 || node.kind === 213;
+    }
+    ts.isFunctionExpressionOrArrowFunction = isFunctionExpressionOrArrowFunction;
 })(ts || (ts = {}));
 var ts;
 (function (ts) {
@@ -19699,8 +19704,9 @@ var ts;
                 ? update(createNamedImports(elements), node)
                 : node;
         }
-        function createImportSpecifier(propertyName, name) {
+        function createImportSpecifier(isTypeOnly, propertyName, name) {
             var node = createBaseNode(269);
+            node.isTypeOnly = isTypeOnly;
             node.propertyName = propertyName;
             node.name = name;
             node.transformFlags |=
@@ -19709,10 +19715,11 @@ var ts;
             node.transformFlags &= ~16777216;
             return node;
         }
-        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;
         }
         function createExportAssignment(decorators, modifiers, isExportEquals, expression) {
@@ -19766,8 +19773,9 @@ var ts;
                 ? update(createNamedExports(elements), node)
                 : node;
         }
-        function createExportSpecifier(propertyName, name) {
+        function createExportSpecifier(isTypeOnly, propertyName, name) {
             var node = createBaseNode(274);
+            node.isTypeOnly = isTypeOnly;
             node.propertyName = asName(propertyName);
             node.name = asName(name);
             node.transformFlags |=
@@ -19776,10 +19784,11 @@ var ts;
             node.transformFlags &= ~16777216;
             return node;
         }
-        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;
         }
         function createMissingDeclaration() {
@@ -20656,7 +20665,7 @@ var ts;
         }
         function createExternalModuleExport(exportName) {
             return createExportDeclaration(undefined, undefined, false, createNamedExports([
-                createExportSpecifier(undefined, exportName)
+                createExportSpecifier(false, undefined, exportName)
             ]));
         }
         function createTypeCheck(value, tag) {
@@ -23307,8 +23316,8 @@ var ts;
                     if (ts.some(helperNames)) {
                         helperNames.sort(ts.compareStringsCaseSensitive);
                         namedBindings = nodeFactory.createNamedImports(ts.map(helperNames, function (name) { return ts.isFileLevelUniqueName(sourceFile, name)
-                            ? nodeFactory.createImportSpecifier(undefined, nodeFactory.createIdentifier(name))
-                            : nodeFactory.createImportSpecifier(nodeFactory.createIdentifier(name), helperFactory.getUnscopedHelperName(name)); }));
+                            ? nodeFactory.createImportSpecifier(false, undefined, nodeFactory.createIdentifier(name))
+                            : nodeFactory.createImportSpecifier(false, nodeFactory.createIdentifier(name), helperFactory.getUnscopedHelperName(name)); }));
                         var parseNode = ts.getOriginalNode(sourceFile, ts.isSourceFile);
                         var emitNode = ts.getOrCreateEmitNode(parseNode);
                         emitNode.externalHelpers = true;
@@ -25288,7 +25297,6 @@ var ts;
                 case 88:
                     return nextTokenCanFollowDefaultKeyword();
                 case 124:
-                    return nextTokenIsOnSameLineAndCanFollowModifier();
                 case 136:
                 case 148:
                     nextToken();
@@ -28681,7 +28689,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 && permitInvalidConstAsModifier) {
@@ -28692,6 +28700,9 @@ var ts;
             else if (stopOnStartOfClassStaticBlock && token() === 124 && lookAhead(nextTokenIsOpenBrace)) {
                 return undefined;
             }
+            else if (hasSeenStaticModifier && token() === 124) {
+                return undefined;
+            }
             else {
                 if (!parseAnyContextualModifier()) {
                     return undefined;
@@ -28701,8 +28712,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)
+                    hasSeenStatic = true;
                 list = ts.append(list, modifier);
             }
             return list && createNodeArray(list, pos);
@@ -29079,27 +29092,60 @@ 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) {
-                propertyName = identifierName;
-                parseExpected(127);
-                checkIdentifierIsKeyword = ts.isKeyword(token()) && !isIdentifier();
-                checkIdentifierStart = scanner.getTokenPos();
-                checkIdentifierEnd = scanner.getTextPos();
-                name = parseIdentifierName();
+            var canParseAsKeyword = true;
+            var name = parseIdentifierName();
+            if (name.escapedText === "type") {
+                if (token() === 127) {
+                    var firstAs = parseIdentifierName();
+                    if (token() === 127) {
+                        var secondAs = parseIdentifierName();
+                        if (ts.tokenIsIdentifierOrKeyword(token())) {
+                            isTypeOnly = true;
+                            propertyName = firstAs;
+                            name = parseNameWithKeywordCheck();
+                            canParseAsKeyword = false;
+                        }
+                        else {
+                            propertyName = name;
+                            name = secondAs;
+                            canParseAsKeyword = false;
+                        }
+                    }
+                    else if (ts.tokenIsIdentifierOrKeyword(token())) {
+                        propertyName = name;
+                        canParseAsKeyword = false;
+                        name = parseNameWithKeywordCheck();
+                    }
+                    else {
+                        isTypeOnly = true;
+                        name = firstAs;
+                    }
+                }
+                else if (ts.tokenIsIdentifierOrKeyword(token())) {
+                    isTypeOnly = true;
+                    name = parseNameWithKeywordCheck();
+                }
             }
-            else {
-                name = identifierName;
+            if (canParseAsKeyword && token() === 127) {
+                propertyName = name;
+                parseExpected(127);
+                name = parseNameWithKeywordCheck();
             }
             if (kind === 269 && checkIdentifierIsKeyword) {
                 parseErrorAt(checkIdentifierStart, checkIdentifierEnd, ts.Diagnostics.Identifier_expected);
             }
             var node = kind === 269
-                ? 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);
@@ -30970,6 +31016,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,
@@ -32566,29 +32613,39 @@ var ts;
         }
         return result;
     }
-    function generateTSConfig(options, fileNames, newLine) {
+    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;
+    function getSerializedCompilerOption(options) {
         var compilerOptions = ts.extend(options, ts.defaultInitCompilerOptions);
-        var compilerOptionsMap = serializeCompilerOptions(compilerOptions);
+        return serializeCompilerOptions(compilerOptions);
+    }
+    function generateTSConfig(options, fileNames, newLine) {
+        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(" ");
         }
@@ -33416,6 +33473,25 @@ var ts;
                 });
         }
     }
+    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) {
@@ -37996,7 +38072,6 @@ var ts;
         Capitalize: 2,
         Uncapitalize: 3
     }));
-    var DEFAULT_TYPE_CHARS_LENGTH_TO_ADD_NEW_LINES = 30;
     function SymbolLinks() {
     }
     function NodeLinks() {
@@ -38402,6 +38477,7 @@ var ts;
             getLocalTypeParametersOfClassOrInterfaceOrTypeAlias: getLocalTypeParametersOfClassOrInterfaceOrTypeAlias,
             isDeclarationVisible: isDeclarationVisible,
             isPropertyAccessible: isPropertyAccessible,
+            getTypeOnlyAliasDeclaration: getTypeOnlyAliasDeclaration,
         };
         function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode) {
             var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression);
@@ -38660,17 +38736,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;
                         }
                     }
                 }
@@ -38692,11 +38760,25 @@ 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) {
             getDiagnostics(sourceFile, cancellationToken);
             return emitResolver;
@@ -39581,8 +39663,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
                         ? 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);
@@ -39593,7 +39674,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 ? ts.Diagnostics._0_was_exported_here : ts.Diagnostics._0_was_imported_here, unescapedName));
         }
         function getIsDeferredContext(location, lastLocation) {
             if (location.kind !== 213 && location.kind !== 212) {
@@ -39886,7 +39967,7 @@ var ts;
         function checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(node, resolved) {
             if (markSymbolOfAliasDeclarationIfTypeOnly(node, undefined, resolved, false) && !node.isTypeOnly) {
                 var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(getSymbolOfNode(node));
-                var isExport = ts.typeOnlyDeclarationIsExport(typeOnlyDeclaration);
+                var isExport = typeOnlyDeclaration.kind === 274;
                 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;
@@ -39907,7 +39988,20 @@ var ts;
         function isSyntacticDefault(node) {
             return ((ts.isExportAssignment(node) && !node.isExportEquals) || ts.hasSyntacticModifier(node, 512) || 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;
+                }
+            }
             if (!allowSyntheticDefaultImports) {
                 return false;
             }
@@ -39938,7 +40032,7 @@ var ts;
                     exportDefaultSymbol = resolveExportByName(moduleSymbol, "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";
@@ -40057,7 +40151,7 @@ var ts;
                     var symbolFromModule = getExportOfModule(targetSymbol, name, specifier, dontResolveAlias);
                     if (symbolFromModule === undefined && name.escapedText === "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);
                         }
                     }
@@ -40666,7 +40760,7 @@ var ts;
                             sigs = getSignaturesOfStructuredType(type, 1);
                         }
                         if (sigs && sigs.length) {
-                            var moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol);
+                            var moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol, ts.isImportCall(referenceParent) ? referenceParent.arguments[0] : referenceParent.moduleSpecifier);
                             var result = createSymbol(symbol.flags, symbol.escapedName);
                             result.declarations = symbol.declarations ? symbol.declarations.slice() : [];
                             result.parent = symbol.parent;
@@ -43088,7 +43182,7 @@ var ts;
                         var name_2 = ns.name;
                         var body = ns.body;
                         if (ts.length(excessExports)) {
-                            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(undefined, undefined, false, ts.factory.createNamedExports(ts.map(ts.flatMap(excessExports, function (e) { return getNamesOfDeclaration(e); }), function (id) { return ts.factory.createExportSpecifier(undefined, id); })), undefined)], false))));
+                            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(undefined, undefined, false, ts.factory.createNamedExports(ts.map(ts.flatMap(excessExports, function (e) { return getNamesOfDeclaration(e); }), function (id) { return ts.factory.createExportSpecifier(false, undefined, id); })), undefined)], false))));
                             statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, nsIndex), true), [ns], false), statements.slice(nsIndex + 1), true);
                         }
                         if (!ts.find(statements, function (s) { return s !== ns && ts.nodeHasName(s, name_2); })) {
@@ -43270,7 +43364,7 @@ var ts;
                                 if (propertyAccessRequire && ts.isBinaryExpression(propertyAccessRequire.parent) && ts.isIdentifier(propertyAccessRequire.parent.right)
                                     && ((_b = type.symbol) === null || _b === void 0 ? void 0 : _b.valueDeclaration) && ts.isSourceFile(type.symbol.valueDeclaration)) {
                                     var alias = localName === propertyAccessRequire.parent.right.escapedText ? undefined : propertyAccessRequire.parent.right;
-                                    addResult(ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(alias, localName)])), 0);
+                                    addResult(ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(false, alias, localName)])), 0);
                                     context.tracker.trackSymbol(type.symbol, context.enclosingDeclaration, 111551);
                                 }
                                 else {
@@ -43279,7 +43373,7 @@ var ts;
                                     ], flags)), textRange);
                                     addResult(statement, name !== localName ? modifierFlags & ~1 : modifierFlags);
                                     if (name !== localName && !isPrivate) {
-                                        addResult(ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(name, localName)])), 0);
+                                        addResult(ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(false, name, localName)])), 0);
                                         needsExportDeclaration = false;
                                         needsPostExportDefault = false;
                                     }
@@ -43328,7 +43422,7 @@ var ts;
                         addResult(ts.factory.createExportAssignment(undefined, undefined, false, ts.factory.createIdentifier(getInternalSymbolName(symbol, symbolName))), 0);
                     }
                     else if (needsExportDeclaration) {
-                        addResult(ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(getInternalSymbolName(symbol, symbolName), symbolName)])), 0);
+                        addResult(ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(false, getInternalSymbolName(symbol, symbolName), symbolName)])), 0);
                     }
                 }
                 function includePrivateSymbol(symbol) {
@@ -43433,7 +43527,7 @@ var ts;
                                 var target = aliasDecl && getTargetOfAliasDeclaration(aliasDecl, 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(false, name === targetName ? undefined : targetName, name);
                             })))]);
                         addResult(ts.factory.createModuleDeclaration(undefined, undefined, ts.factory.createIdentifier(localName), nsBody, 16), 0);
                     }
@@ -43493,7 +43587,7 @@ var ts;
                         addingDeclare = oldAddingDeclare;
                         var declarations = results;
                         results = oldResults;
-                        var defaultReplaced = ts.map(declarations, function (d) { return ts.isExportAssignment(d) && !d.isExportEquals && ts.isIdentifier(d.expression) ? ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(d.expression, ts.factory.createIdentifier("default"))])) : d; });
+                        var defaultReplaced = ts.map(declarations, function (d) { return ts.isExportAssignment(d) && !d.isExportEquals && ts.isIdentifier(d.expression) ? ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(false, d.expression, ts.factory.createIdentifier("default"))])) : d; });
                         var exportModifierStripped = ts.every(defaultReplaced, function (d) { return ts.hasSyntacticModifier(d, 1); }) ? ts.map(defaultReplaced, removeExportModifier) : defaultReplaced;
                         fakespace = ts.factory.updateModuleDeclaration(fakespace, fakespace.decorators, fakespace.modifiers, fakespace.name, ts.factory.createModuleBlock(exportModifierStripped));
                         addResult(fakespace, modifierFlags);
@@ -43616,7 +43710,7 @@ var ts;
                             if (((_b = (_a = node.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.kind) === 253) {
                                 var specifier_1 = getSpecifierForModuleSymbol(target.parent || target, context);
                                 var propertyName = node.propertyName;
-                                addResult(ts.factory.createImportDeclaration(undefined, undefined, ts.factory.createImportClause(false, 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), undefined), 0);
+                                addResult(ts.factory.createImportDeclaration(undefined, undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([ts.factory.createImportSpecifier(false, propertyName && ts.isIdentifier(propertyName) ? ts.factory.createIdentifier(ts.idText(propertyName)) : undefined, ts.factory.createIdentifier(localName))])), ts.factory.createStringLiteral(specifier_1), undefined), 0);
                                 break;
                             }
                             ts.Debug.failBadSyntaxKind(((_c = node.parent) === null || _c === void 0 ? void 0 : _c.parent) || node, "Unhandled binding element grandparent kind in declaration serialization");
@@ -43659,7 +43753,7 @@ var ts;
                             break;
                         case 269:
                             addResult(ts.factory.createImportDeclaration(undefined, undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
-                                ts.factory.createImportSpecifier(localName !== verbatimTargetName ? ts.factory.createIdentifier(verbatimTargetName) : undefined, ts.factory.createIdentifier(localName))
+                                ts.factory.createImportSpecifier(false, localName !== verbatimTargetName ? ts.factory.createIdentifier(verbatimTargetName) : undefined, ts.factory.createIdentifier(localName))
                             ])), ts.factory.createStringLiteral(getSpecifierForModuleSymbol(target.parent || target, context)), undefined), 0);
                             break;
                         case 274:
@@ -43684,7 +43778,7 @@ var ts;
                     }
                 }
                 function serializeExportSpecifier(localName, targetName, specifier) {
-                    addResult(ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(localName !== targetName ? targetName : undefined, localName)]), specifier), 0);
+                    addResult(ts.factory.createExportDeclaration(undefined, undefined, false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(false, localName !== targetName ? targetName : undefined, localName)]), specifier), 0);
                 }
                 function serializeMaybeAliasAssignment(symbol) {
                     if (symbol.flags & 4194304) {
@@ -46710,6 +46804,23 @@ var ts;
         function getIsLateCheckFlag(s) {
             return ts.getCheckFlags(s) & 4096;
         }
+        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) {
+                cb(stringType);
+            }
+            else {
+                for (var _b = 0, _c = getIndexInfosOfType(type); _b < _c.length; _b++) {
+                    var info = _c[_b];
+                    if (!stringsOnly || info.keyType.flags & (4 | 134217728)) {
+                        cb(info.keyType);
+                    }
+                }
+            }
+        }
         function resolveMappedTypeMembers(type) {
             var members = ts.createSymbolTable();
             var indexInfos;
@@ -46722,21 +46833,7 @@ var ts;
             var templateModifiers = getMappedTypeModifiers(type);
             var include = keyofStringsOnly ? 128 : 8576;
             if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
-                for (var _i = 0, _a = getPropertiesOfType(modifiersType); _i < _a.length; _i++) {
-                    var prop = _a[_i];
-                    addMemberForKeyType(getLiteralTypeFromProperty(prop, include));
-                }
-                if (modifiersType.flags & 1) {
-                    addMemberForKeyType(stringType);
-                }
-                else {
-                    for (var _b = 0, _c = getIndexInfosOfType(modifiersType); _b < _c.length; _b++) {
-                        var info = _c[_b];
-                        if (!keyofStringsOnly || info.keyType.flags & (4 | 134217728)) {
-                            addMemberForKeyType(info.keyType);
-                        }
-                    }
-                }
+                forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, include, keyofStringsOnly, addMemberForKeyType);
             }
             else {
                 forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
@@ -47338,7 +47435,7 @@ var ts;
                 else if (type !== firstType) {
                     checkFlags |= 64;
                 }
-                if (isLiteralType(type)) {
+                if (isLiteralType(type) || isPatternLiteralType(type)) {
                     checkFlags |= 128;
                 }
                 if (type.flags & 131072) {
@@ -49496,16 +49593,38 @@ var ts;
                 type.resolvedStringIndexType || (type.resolvedStringIndexType = createIndexType(type, true)) :
                 type.resolvedIndexType || (type.resolvedIndexType = createIndexType(type, 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 | 4)); });
-            var nameType = type.declaration.nameType && getTypeFromTypeNode(type.declaration.nameType);
-            var properties = nameType && everyType(constraint, function (t) { return !!(t.flags & (4 | 8 | 131072)); }) && 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); })), function (t) { return instantiateTypeAsMappedNameType(nameType, type, t); })]) :
-                constraint;
+        function getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) {
+            var typeParameter = getTypeParameterFromMappedType(type);
+            var constraintType = getConstraintTypeFromMappedType(type);
+            var nameType = getNameTypeFromMappedType(type.target || type);
+            if (!nameType && !noIndexSignatures) {
+                return constraintType;
+            }
+            var keyTypes = [];
+            if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
+                if (!isGenericIndexType(constraintType)) {
+                    var modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
+                    forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576, stringsOnly, addMemberForKeyType);
+                }
+                else {
+                    return getIndexTypeForGenericType(type, stringsOnly);
+                }
+            }
+            else {
+                forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
+            }
+            if (isGenericIndexType(constraintType)) {
+                forEachType(constraintType, addMemberForKeyType);
+            }
+            var result = noIndexSignatures ? filterType(getUnionType(keyTypes), function (t) { return !(t.flags & (1 | 4)); }) : getUnionType(keyTypes);
+            if (result.flags & 1048576 && constraintType.flags & 1048576 && getTypeListId(result.types) === getTypeListId(constraintType.types)) {
+                return constraintType;
+            }
+            return result;
+            function addMemberForKeyType(keyType) {
+                var propNameType = nameType ? instantiateType(nameType, appendTypeMapping(type.mapper, typeParameter, keyType)) : keyType;
+                keyTypes.push(propNameType === stringType ? stringOrNumberType : propNameType);
+            }
         }
         function hasDistributiveNameType(mappedType) {
             var typeVariable = getTypeParameterFromMappedType(mappedType);
@@ -49557,7 +49676,7 @@ var ts;
             return type.flags & 1048576 ? getIntersectionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
                 type.flags & 2097152 ? getUnionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
                     type.flags & 58982400 || isGenericTupleType(type) || isGenericMappedType(type) && !hasDistributiveNameType(type) ? getIndexTypeForGenericType(type, stringsOnly) :
-                        ts.getObjectFlags(type) & 32 ? getIndexTypeForMappedType(type, noIndexSignatures) :
+                        ts.getObjectFlags(type) & 32 ? getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) :
                             type === wildcardType ? wildcardType :
                                 type.flags & 2 ? neverType :
                                     type.flags & (1 | 131072) ? keyofConstraintType :
@@ -51239,7 +51358,7 @@ var ts;
             return !node.typeParameters && !ts.getEffectiveReturnTypeNode(node) && !!node.body && node.body.kind !== 234 && 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) {
@@ -52023,7 +52142,8 @@ var ts;
             var sourceStack;
             var targetStack;
             var maybeCount = 0;
-            var depth = 0;
+            var sourceDepth = 0;
+            var targetDepth = 0;
             var expandingFlags = 0;
             var overflow = false;
             var overrideNextErrorInfo = 0;
@@ -52031,12 +52151,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, !!errorNode, headMessage);
+            var result = isRelatedTo(source, target, 3, !!errorNode, headMessage);
             if (incompatibleStack.length) {
                 reportIncompatibleStack();
             }
             if (overflow) {
-                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes", "checkTypeRelatedTo_DepthLimit", { sourceId: source.id, targetId: target.id, depth: depth });
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("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);
@@ -52249,9 +52369,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);
                         }
                     }
                 }
@@ -52262,15 +52382,13 @@ 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(".", "") });
+            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);
@@ -52303,7 +52421,11 @@ var ts;
                 }
                 return true;
             }
-            function isRelatedTo(originalSource, originalTarget, reportErrors, headMessage, intersectionState) {
+            function isRelatedToWorker(source, target, reportErrors) {
+                return isRelatedTo(source, target, 3, reportErrors);
+            }
+            function isRelatedTo(originalSource, originalTarget, recursionFlags, reportErrors, headMessage, intersectionState) {
+                if (recursionFlags === void 0) { recursionFlags = 3; }
                 if (reportErrors === void 0) { reportErrors = false; }
                 if (intersectionState === void 0) { intersectionState = 0; }
                 if (originalSource.flags & 524288 && originalTarget.flags & 131068) {
@@ -52318,7 +52440,7 @@ var ts;
                 if (source === target)
                     return -1;
                 if (relation === identityRelation) {
-                    return isIdenticalTo(source, target);
+                    return isIdenticalTo(source, target, recursionFlags);
                 }
                 if (source.flags & 262144 && getConstraintOfType(source) === target) {
                     return -1;
@@ -52355,8 +52477,8 @@ var ts;
                         var targetString = typeToString(originalTarget.aliasSymbol ? originalTarget : target);
                         var calls = getSignaturesOfType(source, 0);
                         var constructs = getSignaturesOfType(source, 1);
-                        if (calls.length > 0 && isRelatedTo(getReturnTypeOfSignature(calls[0]), target, false) ||
-                            constructs.length > 0 && isRelatedTo(getReturnTypeOfSignature(constructs[0]), target, false)) {
+                        if (calls.length > 0 && isRelatedTo(getReturnTypeOfSignature(calls[0]), target, 1, false) ||
+                            constructs.length > 0 && isRelatedTo(getReturnTypeOfSignature(constructs[0]), target, 1, 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 {
@@ -52370,11 +52492,11 @@ var ts;
                 var saveErrorInfo = captureErrorCalculationState();
                 if (source.flags & 3145728 || target.flags & 3145728) {
                     result = getConstituentCount(source) * getConstituentCount(target) >= 4 ?
-                        recursiveTypeRelatedTo(source, target, reportErrors, intersectionState | 8) :
+                        recursiveTypeRelatedTo(source, target, reportErrors, intersectionState | 8, recursionFlags) :
                         structuredTypeRelatedTo(source, target, reportErrors, intersectionState | 8);
                 }
                 if (!result && !(source.flags & 1048576) && (source.flags & (469499904) || target.flags & 469499904)) {
-                    if (result = recursiveTypeRelatedTo(source, target, reportErrors, intersectionState)) {
+                    if (result = recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags)) {
                         resetErrorInfo(saveErrorInfo);
                     }
                 }
@@ -52382,7 +52504,7 @@ var ts;
                     var constraint = getEffectiveConstraintOfIntersection(source.flags & 2097152 ? source.types : [source], !!(target.flags & 1048576));
                     if (constraint && (source.flags & 2097152 || target.flags & 1048576)) {
                         if (everyType(constraint, function (c) { return c !== source; })) {
-                            if (result = isRelatedTo(constraint, target, false, undefined, intersectionState)) {
+                            if (result = isRelatedTo(constraint, target, 1, false, undefined, intersectionState)) {
                                 resetErrorInfo(saveErrorInfo);
                             }
                         }
@@ -52391,7 +52513,7 @@ var ts;
                 if (result && !inPropertyCheck && (target.flags & 2097152 && (isPerformingExcessPropertyChecks || isPerformingCommonPropertyChecks) ||
                     isNonGenericObjectType(target) && !isArrayType(target) && !isTupleType(target) && source.flags & 2097152 && getApparentType(source).flags & 3670016 && !ts.some(source.types, function (t) { return !!(ts.getObjectFlags(t) & 524288); }))) {
                     inPropertyCheck = true;
-                    result &= recursiveTypeRelatedTo(source, target, reportErrors, 4);
+                    result &= recursiveTypeRelatedTo(source, target, reportErrors, 4, recursionFlags);
                     inPropertyCheck = false;
                 }
                 reportErrorResults(source, target, result, isComparingJsxAttributes);
@@ -52463,7 +52585,7 @@ var ts;
                     }
                 }
             }
-            function isIdenticalTo(source, target) {
+            function isIdenticalTo(source, target, recursionFlags) {
                 if (source.flags !== target.flags)
                     return 0;
                 if (source.flags & 67358815)
@@ -52476,7 +52598,7 @@ var ts;
                     }
                     return result_7;
                 }
-                return recursiveTypeRelatedTo(source, target, false, 0);
+                return recursiveTypeRelatedTo(source, target, false, 0, recursionFlags);
             }
             function getTypeOfPropertyInTypes(types, name) {
                 var appendPropType = function (propTypes, type) {
@@ -52547,7 +52669,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, reportErrors)) {
                             if (reportErrors) {
                                 reportIncompatibleError(ts.Diagnostics.Types_of_property_0_are_incompatible, symbolToString(prop));
                             }
@@ -52587,7 +52709,7 @@ var ts;
                     }
                     var match = getMatchingUnionConstituentForType(target, source);
                     if (match) {
-                        var related = isRelatedTo(source, match, false);
+                        var related = isRelatedTo(source, match, 2, false);
                         if (related) {
                             return related;
                         }
@@ -52595,14 +52717,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, false);
+                    var related = isRelatedTo(source, type, 2, false);
                     if (related) {
                         return related;
                     }
                 }
                 if (reportErrors) {
                     var bestMatchingType = getBestMatchingType(source, target, isRelatedTo);
-                    isRelatedTo(source, bestMatchingType || targetTypes[targetTypes.length - 1], true);
+                    isRelatedTo(source, bestMatchingType || targetTypes[targetTypes.length - 1], 2, true);
                 }
                 return 0;
             }
@@ -52611,7 +52733,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, undefined, intersectionState);
+                    var related = isRelatedTo(source, targetType, 2, reportErrors, undefined, intersectionState);
                     if (!related) {
                         return 0;
                     }
@@ -52626,7 +52748,7 @@ var ts;
                 }
                 var len = sourceTypes.length;
                 for (var i = 0; i < len; i++) {
-                    var related = isRelatedTo(sourceTypes[i], target, reportErrors && i === len - 1, undefined, intersectionState);
+                    var related = isRelatedTo(sourceTypes[i], target, 1, reportErrors && i === len - 1, undefined, intersectionState);
                     if (related) {
                         return related;
                     }
@@ -52647,13 +52769,13 @@ var ts;
                 for (var i = 0; i < sourceTypes.length; i++) {
                     var sourceType = sourceTypes[i];
                     if (undefinedStrippedTarget.flags & 1048576 && sourceTypes.length >= undefinedStrippedTarget.types.length && sourceTypes.length % undefinedStrippedTarget.types.length === 0) {
-                        var related_1 = isRelatedTo(sourceType, undefinedStrippedTarget.types[i % undefinedStrippedTarget.types.length], false, undefined, intersectionState);
+                        var related_1 = isRelatedTo(sourceType, undefinedStrippedTarget.types[i % undefinedStrippedTarget.types.length], 3, false, undefined, intersectionState);
                         if (related_1) {
                             result &= related_1;
                             continue;
                         }
                     }
-                    var related = isRelatedTo(sourceType, target, reportErrors, undefined, intersectionState);
+                    var related = isRelatedTo(sourceType, target, 1, reportErrors, undefined, intersectionState);
                     if (!related) {
                         return 0;
                     }
@@ -52678,24 +52800,24 @@ var ts;
                         var t = targets[i];
                         var related = -1;
                         if (varianceFlags & 8) {
-                            related = relation === identityRelation ? isRelatedTo(s, t, false) : compareTypesIdentical(s, t);
+                            related = relation === identityRelation ? isRelatedTo(s, t, 3, false) : compareTypesIdentical(s, t);
                         }
                         else if (variance === 1) {
-                            related = isRelatedTo(s, t, reportErrors, undefined, intersectionState);
+                            related = isRelatedTo(s, t, 3, reportErrors, undefined, intersectionState);
                         }
                         else if (variance === 2) {
-                            related = isRelatedTo(t, s, reportErrors, undefined, intersectionState);
+                            related = isRelatedTo(t, s, 3, reportErrors, undefined, intersectionState);
                         }
                         else if (variance === 3) {
-                            related = isRelatedTo(t, s, false);
+                            related = isRelatedTo(t, s, 3, false);
                             if (!related) {
-                                related = isRelatedTo(s, t, reportErrors, undefined, intersectionState);
+                                related = isRelatedTo(s, t, 3, reportErrors, undefined, intersectionState);
                             }
                         }
                         else {
-                            related = isRelatedTo(s, t, reportErrors, undefined, intersectionState);
+                            related = isRelatedTo(s, t, 3, reportErrors, undefined, intersectionState);
                             if (related) {
-                                related &= isRelatedTo(t, s, reportErrors, undefined, intersectionState);
+                                related &= isRelatedTo(t, s, 3, reportErrors, undefined, intersectionState);
                             }
                         }
                         if (!related) {
@@ -52706,7 +52828,7 @@ var ts;
                 }
                 return result;
             }
-            function recursiveTypeRelatedTo(source, target, reportErrors, intersectionState) {
+            function recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags) {
                 if (overflow) {
                     return 0;
                 }
@@ -52743,7 +52865,7 @@ var ts;
                             return 3;
                         }
                     }
-                    if (depth === 100) {
+                    if (sourceDepth === 100 || targetDepth === 100) {
                         overflow = true;
                         return 0;
                     }
@@ -52751,13 +52873,18 @@ var ts;
                 var maybeStart = maybeCount;
                 maybeKeys[maybeCount] = id;
                 maybeCount++;
-                sourceStack[depth] = source;
-                targetStack[depth] = target;
-                depth++;
+                if (recursionFlags & 1) {
+                    sourceStack[sourceDepth] = source;
+                    sourceDepth++;
+                }
+                if (recursionFlags & 2) {
+                    targetStack[targetDepth] = target;
+                    targetDepth++;
+                }
                 var saveExpandingFlags = expandingFlags;
-                if (!(expandingFlags & 1) && isDeeplyNestedType(source, sourceStack, depth))
+                if (!(expandingFlags & 1) && isDeeplyNestedType(source, sourceStack, sourceDepth))
                     expandingFlags |= 1;
-                if (!(expandingFlags & 2) && isDeeplyNestedType(target, targetStack, depth))
+                if (!(expandingFlags & 2) && isDeeplyNestedType(target, targetStack, targetDepth))
                     expandingFlags |= 2;
                 var originalHandler;
                 var propagatingVarianceFlags = 0;
@@ -52774,7 +52901,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 ? structuredTypeRelatedTo(source, target, reportErrors, intersectionState) : 3;
@@ -52782,9 +52910,14 @@ var ts;
                     outofbandVarianceMarkerHandler = originalHandler;
                 }
                 expandingFlags = saveExpandingFlags;
-                depth--;
+                if (recursionFlags & 1) {
+                    sourceDepth--;
+                }
+                if (recursionFlags & 2) {
+                    targetDepth--;
+                }
                 if (result) {
-                    if (result === -1 || depth === 0) {
+                    if (result === -1 || (sourceDepth === 0 && targetDepth === 0)) {
                         if (result === -1 || result === 3) {
                             for (var i = maybeStart; i < maybeCount; i++) {
                                 relation.set(maybeKeys[i], 1 | propagatingVarianceFlags);
@@ -52826,7 +52959,7 @@ var ts;
                         if (constraints !== source.types) {
                             source = getIntersectionType(constraints);
                             if (!(source.flags & 2097152)) {
-                                return isRelatedTo(source, target, false);
+                                return isRelatedTo(source, target, 1, false);
                             }
                         }
                     }
@@ -52835,22 +52968,22 @@ var ts;
                 var flags = source.flags & target.flags;
                 if (relation === identityRelation && !(flags & 524288)) {
                     if (flags & 4194304) {
-                        return isRelatedTo(source.type, target.type, false);
+                        return isRelatedTo(source.type, target.type, 3, false);
                     }
                     var result_8 = 0;
                     if (flags & 8388608) {
-                        if (result_8 = isRelatedTo(source.objectType, target.objectType, false)) {
-                            if (result_8 &= isRelatedTo(source.indexType, target.indexType, false)) {
+                        if (result_8 = isRelatedTo(source.objectType, target.objectType, 3, false)) {
+                            if (result_8 &= isRelatedTo(source.indexType, target.indexType, 3, false)) {
                                 return result_8;
                             }
                         }
                     }
                     if (flags & 16777216) {
                         if (source.root.isDistributive === target.root.isDistributive) {
-                            if (result_8 = isRelatedTo(source.checkType, target.checkType, false)) {
-                                if (result_8 &= isRelatedTo(source.extendsType, target.extendsType, false)) {
-                                    if (result_8 &= isRelatedTo(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target), false)) {
-                                        if (result_8 &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), false)) {
+                            if (result_8 = isRelatedTo(source.checkType, target.checkType, 3, false)) {
+                                if (result_8 &= isRelatedTo(source.extendsType, target.extendsType, 3, false)) {
+                                    if (result_8 &= isRelatedTo(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target), 3, false)) {
+                                        if (result_8 &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), 3, false)) {
                                             return result_8;
                                         }
                                     }
@@ -52859,7 +52992,7 @@ var ts;
                         }
                     }
                     if (flags & 33554432) {
-                        return isRelatedTo(source.substitute, target.substitute, false);
+                        return isRelatedTo(source.substitute, target.substitute, 3, false);
                     }
                     return 0;
                 }
@@ -52879,37 +53012,54 @@ var ts;
                         return varianceResult;
                     }
                 }
-                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)) ||
+                    isSingleElementGenericTupleType(target) && (target.target.readonly || isMutableArrayOrTuple(getBaseConstraintOfType(source) || source)) && (result = isRelatedTo(source, getTypeArguments(target)[0], 2))) {
                     return result;
                 }
                 if (target.flags & 262144) {
-                    if (ts.getObjectFlags(source) & 32 && !source.declaration.nameType && isRelatedTo(getIndexType(target), getConstraintTypeFromMappedType(source))) {
+                    if (ts.getObjectFlags(source) & 32 && !source.declaration.nameType && isRelatedTo(getIndexType(target), getConstraintTypeFromMappedType(source), 3)) {
                         if (!(getMappedTypeModifiers(source) & 4)) {
                             var templateType = getTemplateTypeFromMappedType(source);
                             var indexedAccessType = getIndexedAccessType(target, getTypeParameterFromMappedType(source));
-                            if (result = isRelatedTo(templateType, indexedAccessType, reportErrors)) {
+                            if (result = isRelatedTo(templateType, indexedAccessType, 3, reportErrors)) {
                                 return result;
                             }
                         }
                     }
                 }
                 else if (target.flags & 4194304) {
-                    var targetType = target.type;
+                    var targetType_1 = target.type;
                     if (source.flags & 4194304) {
-                        if (result = isRelatedTo(targetType, source.type, false)) {
+                        if (result = isRelatedTo(targetType_1, source.type, 3, false)) {
                             return result;
                         }
                     }
-                    if (isTupleType(targetType)) {
-                        if (result = isRelatedTo(source, getKnownKeysOfTupleType(targetType), reportErrors)) {
+                    if (isTupleType(targetType_1)) {
+                        if (result = isRelatedTo(source, getKnownKeysOfTupleType(targetType_1), 2, reportErrors)) {
                             return result;
                         }
                     }
                     else {
-                        var constraint = getSimplifiedTypeOrConstraint(targetType);
+                        var constraint = getSimplifiedTypeOrConstraint(targetType_1);
                         if (constraint) {
-                            if (isRelatedTo(source, getIndexType(constraint, target.stringsOnly), reportErrors) === -1) {
+                            if (isRelatedTo(source, getIndexType(constraint, target.stringsOnly), 2, reportErrors) === -1) {
+                                return -1;
+                            }
+                        }
+                        else if (isGenericMappedType(targetType_1)) {
+                            var nameType_1 = getNameTypeFromMappedType(targetType_1);
+                            var constraintType = getConstraintTypeFromMappedType(targetType_1);
+                            var targetKeys = void 0;
+                            if (nameType_1 && isMappedTypeWithKeyofConstraintDeclaration(targetType_1)) {
+                                var modifiersType = getApparentType(getModifiersTypeFromMappedType(targetType_1));
+                                var mappedKeys_1 = [];
+                                forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576, false, function (t) { return void mappedKeys_1.push(instantiateType(nameType_1, appendTypeMapping(targetType_1.mapper, getTypeParameterFromMappedType(targetType_1), t))); });
+                                targetKeys = getUnionType(__spreadArray(__spreadArray([], mappedKeys_1, true), [nameType_1], false));
+                            }
+                            else {
+                                targetKeys = nameType_1 || constraintType;
+                            }
+                            if (isRelatedTo(source, targetKeys, 2, reportErrors) === -1) {
                                 return -1;
                             }
                         }
@@ -52917,8 +53067,8 @@ var ts;
                 }
                 else if (target.flags & 8388608) {
                     if (source.flags & 8388608) {
-                        if (result = isRelatedTo(source.objectType, target.objectType, reportErrors)) {
-                            result &= isRelatedTo(source.indexType, target.indexType, reportErrors);
+                        if (result = isRelatedTo(source.objectType, target.objectType, 3, reportErrors)) {
+                            result &= isRelatedTo(source.indexType, target.indexType, 3, reportErrors);
                         }
                         if (result) {
                             resetErrorInfo(saveErrorInfo);
@@ -52940,7 +53090,7 @@ var ts;
                                 if (reportErrors && originalErrorInfo) {
                                     resetErrorInfo(saveErrorInfo);
                                 }
-                                if (result = isRelatedTo(source, constraint, reportErrors)) {
+                                if (result = isRelatedTo(source, constraint, 2, reportErrors)) {
                                     return result;
                                 }
                                 if (reportErrors && originalErrorInfo && errorInfo) {
@@ -52969,11 +53119,12 @@ var ts;
                             var filteredByApplicability = includeOptional ? intersectTypes(targetKeys, sourceKeys) : undefined;
                             if (includeOptional
                                 ? !(filteredByApplicability.flags & 131072)
-                                : isRelatedTo(targetKeys, sourceKeys)) {
+                                : isRelatedTo(targetKeys, sourceKeys, 3)) {
+                                var templateType_1 = getTemplateTypeFromMappedType(target);
                                 var typeParameter = getTypeParameterFromMappedType(target);
-                                var nonNullComponent = extractTypesOfKind(templateType, ~98304);
+                                var nonNullComponent = extractTypesOfKind(templateType_1, ~98304);
                                 if (!keysRemapped && nonNullComponent.flags & 8388608 && nonNullComponent.indexType === typeParameter) {
-                                    if (result = isRelatedTo(source, nonNullComponent.objectType, reportErrors)) {
+                                    if (result = isRelatedTo(source, nonNullComponent.objectType, 2, reportErrors)) {
                                         return result;
                                     }
                                 }
@@ -52984,7 +53135,7 @@ var ts;
                                             ? getIntersectionType([filteredByApplicability, typeParameter])
                                             : typeParameter;
                                     var indexedAccessType = getIndexedAccessType(source, indexingType);
-                                    if (result = isRelatedTo(indexedAccessType, templateType, reportErrors)) {
+                                    if (result = isRelatedTo(indexedAccessType, templateType_1, 3, reportErrors)) {
                                         return result;
                                     }
                                 }
@@ -53005,10 +53156,11 @@ var ts;
                         distributionMapper = prependTypeMapping(checkVar, newParam, c.mapper);
                         newParam.mapper = distributionMapper;
                     }
-                    var localResult = void 0;
-                    if (skipTrue || (localResult = isRelatedTo(source, distributionMapper ? instantiateType(getTypeFromTypeNode(c.root.node.trueType), distributionMapper) : getTrueTypeFromConditionalType(c), false))) {
-                        if (!skipFalse) {
-                            localResult = (localResult || 3) & isRelatedTo(source, distributionMapper ? instantiateType(getTypeFromTypeNode(c.root.node.falseType), distributionMapper) : getFalseTypeFromConditionalType(c), false);
+                    var expanding = isDeeplyNestedType(target, targetStack, targetDepth);
+                    var localResult = expanding ? 3 : undefined;
+                    if (skipTrue || expanding || (localResult = isRelatedTo(source, distributionMapper ? instantiateType(getTypeFromTypeNode(c.root.node.trueType), distributionMapper) : getTrueTypeFromConditionalType(c), 2, false))) {
+                        if (!skipFalse && !expanding) {
+                            localResult = (localResult || 3) & isRelatedTo(source, distributionMapper ? instantiateType(getTypeFromTypeNode(c.root.node.falseType), distributionMapper) : getFalseTypeFromConditionalType(c), 2, false);
                         }
                     }
                     if (localResult) {
@@ -53018,6 +53170,9 @@ var ts;
                 }
                 else if (target.flags & 134217728) {
                     if (source.flags & 134217728) {
+                        if (relation === comparableRelation) {
+                            return templateLiteralTypesDefinitelyUnrelated(source, target) ? 0 : -1;
+                        }
                         instantiateType(source, makeFunctionTypeMapper(reportUnreliableMarkers));
                     }
                     var result_9 = inferTypesFromTemplateLiteralType(source, target);
@@ -53029,32 +53184,31 @@ var ts;
                     if (!(source.flags & 8388608 && target.flags & 8388608)) {
                         var constraint = getConstraintOfType(source);
                         if (!constraint || (source.flags & 262144 && constraint.flags & 1)) {
-                            if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864))) {
+                            if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864), 3)) {
                                 resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
-                        else if (result = isRelatedTo(constraint, target, false, undefined, intersectionState)) {
+                        else if (result = isRelatedTo(constraint, target, 1, false, undefined, intersectionState)) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
-                        else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, reportErrors && !(target.flags & source.flags & 262144), undefined, intersectionState)) {
+                        else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1, reportErrors && !(target.flags & source.flags & 262144), undefined, intersectionState)) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
                 }
                 else if (source.flags & 4194304) {
-                    if (result = isRelatedTo(keyofConstraintType, target, reportErrors)) {
+                    if (result = isRelatedTo(keyofConstraintType, target, 1, reportErrors)) {
                         resetErrorInfo(saveErrorInfo);
                         return result;
                     }
                 }
-                else if (source.flags & 134217728) {
+                else if (source.flags & 134217728 && !(target.flags & 524288)) {
                     if (!(target.flags & 134217728)) {
-                        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, reportErrors))) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
@@ -53062,14 +53216,14 @@ var ts;
                 }
                 else if (source.flags & 268435456) {
                     if (target.flags & 268435456 && source.symbol === target.symbol) {
-                        if (result = isRelatedTo(source.type, target.type, reportErrors)) {
+                        if (result = isRelatedTo(source.type, target.type, 3, reportErrors)) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
                     else {
                         var constraint = getBaseConstraintOfType(source);
-                        if (constraint && (result = isRelatedTo(constraint, target, reportErrors))) {
+                        if (constraint && (result = isRelatedTo(constraint, target, 1, reportErrors))) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
@@ -53077,40 +53231,44 @@ var ts;
                 }
                 else if (source.flags & 16777216) {
                     if (target.flags & 16777216) {
-                        var sourceParams = source.root.inferTypeParameters;
-                        var sourceExtends = source.extendsType;
-                        var mapper = void 0;
-                        if (sourceParams) {
-                            var ctx = createInferenceContext(sourceParams, undefined, 0, isRelatedTo);
-                            inferTypes(ctx.inferences, target.extendsType, sourceExtends, 512 | 1024);
-                            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 (!isDeeplyNestedType(source, sourceStack, sourceDepth) && !isDeeplyNestedType(target, targetStack, targetDepth)) {
+                            var sourceParams = source.root.inferTypeParameters;
+                            var sourceExtends = source.extendsType;
+                            var mapper = void 0;
+                            if (sourceParams) {
+                                var ctx = createInferenceContext(sourceParams, undefined, 0, isRelatedToWorker);
+                                inferTypes(ctx.inferences, target.extendsType, sourceExtends, 512 | 1024);
+                                sourceExtends = instantiateType(sourceExtends, ctx.mapper);
+                                mapper = ctx.mapper;
                             }
-                            if (result) {
-                                resetErrorInfo(saveErrorInfo);
-                                return result;
+                            if (isTypeIdenticalTo(sourceExtends, target.extendsType) &&
+                                (isRelatedTo(source.checkType, target.checkType, 3) || isRelatedTo(target.checkType, source.checkType, 3))) {
+                                if (result = isRelatedTo(instantiateType(getTrueTypeFromConditionalType(source), mapper), getTrueTypeFromConditionalType(target), 3, reportErrors)) {
+                                    result &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), 3, reportErrors);
+                                }
+                                if (result) {
+                                    resetErrorInfo(saveErrorInfo);
+                                    return result;
+                                }
                             }
                         }
                     }
                     else {
                         var distributiveConstraint = getConstraintOfDistributiveConditionalType(source);
                         if (distributiveConstraint) {
-                            if (result = isRelatedTo(distributiveConstraint, target, reportErrors)) {
+                            if (result = isRelatedTo(distributiveConstraint, target, 1, reportErrors)) {
                                 resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
                     }
-                    var defaultConstraint = getDefaultConstraintOfConditionalType(source);
-                    if (defaultConstraint) {
-                        if (result = isRelatedTo(defaultConstraint, target, reportErrors)) {
-                            resetErrorInfo(saveErrorInfo);
-                            return result;
+                    if (!isDeeplyNestedType(source, sourceStack, sourceDepth)) {
+                        var defaultConstraint = getDefaultConstraintOfConditionalType(source);
+                        if (defaultConstraint) {
+                            if (result = isRelatedTo(defaultConstraint, target, 1, reportErrors)) {
+                                resetErrorInfo(saveErrorInfo);
+                                return result;
+                            }
                         }
                     }
                 }
@@ -53147,7 +53305,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, reportErrors);
                         }
                         else {
                             return 0;
@@ -53230,10 +53388,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, 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, reportErrors);
                         }
                     }
                 }
@@ -53339,7 +53497,7 @@ var ts;
                 var targetIsOptional = strictNullChecks && !!(ts.getCheckFlags(targetProp) & 48);
                 var effectiveTarget = addOptionality(getNonMissingTypeOfSymbol(targetProp), false, targetIsOptional);
                 var effectiveSource = getTypeOfSourceProperty(sourceProp);
-                return isRelatedTo(effectiveSource, effectiveTarget, reportErrors, undefined, intersectionState);
+                return isRelatedTo(effectiveSource, effectiveTarget, 3, reportErrors, undefined, intersectionState);
             }
             function propertyRelatedTo(source, target, sourceProp, targetProp, getTypeOfSourceProperty, reportErrors, intersectionState, skipOptional) {
                 var sourcePropFlags = ts.getDeclarationModifierFlagsFromSymbol(sourceProp);
@@ -53509,7 +53667,7 @@ var ts;
                             var targetType = targetTypeArguments[i];
                             var targetCheckType = sourceFlags & 8 && targetFlags & 4 ? createArrayType(targetType) :
                                 removeMissingType(targetType, !!(targetFlags & 2));
-                            var related = isRelatedTo(sourceType, targetCheckType, reportErrors, undefined, intersectionState);
+                            var related = isRelatedTo(sourceType, targetCheckType, 3, reportErrors, undefined, intersectionState);
                             if (!related) {
                                 if (reportErrors && (targetArity > 1 || sourceArity > 1)) {
                                     if (i < startCount || i >= targetArity - endCount || sourceArity - startCount - endCount === 1) {
@@ -53684,7 +53842,7 @@ var ts;
                 return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible, typeToString(source), typeToString(target)); };
             }
             function signatureRelatedTo(source, target, erase, reportErrors, incompatibleReporter) {
-                return compareSignaturesRelated(erase ? getErasedSignature(source) : source, erase ? getErasedSignature(target) : target, relation === strictSubtypeRelation ? 8 : 0, reportErrors, reportError, incompatibleReporter, isRelatedTo, makeFunctionTypeMapper(reportUnreliableMarkers));
+                return compareSignaturesRelated(erase ? getErasedSignature(source) : source, erase ? getErasedSignature(target) : target, relation === strictSubtypeRelation ? 8 : 0, reportErrors, reportError, incompatibleReporter, isRelatedToWorker, makeFunctionTypeMapper(reportUnreliableMarkers));
             }
             function signaturesIdenticalTo(source, target, kind) {
                 var sourceSignatures = getSignaturesOfType(source, kind);
@@ -53716,7 +53874,7 @@ var ts;
                         var type = exactOptionalPropertyTypes || propType.flags & 32768 || keyType === numberType || !(prop.flags & 16777216)
                             ? propType
                             : getTypeWithFacts(propType, 524288);
-                        var related = isRelatedTo(type, targetInfo.type, reportErrors);
+                        var related = isRelatedTo(type, targetInfo.type, 3, reportErrors);
                         if (!related) {
                             if (reportErrors) {
                                 reportError(ts.Diagnostics.Property_0_is_incompatible_with_index_signature, symbolToString(prop));
@@ -53739,7 +53897,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, reportErrors);
                 if (!related && reportErrors) {
                     if (sourceInfo.keyType === targetInfo.keyType) {
                         reportError(ts.Diagnostics._0_index_signatures_are_incompatible, typeToString(sourceInfo.keyType));
@@ -53760,7 +53918,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 ? -1 :
-                        isGenericMappedType(source) && targetHasStringIndex ? isRelatedTo(getTemplateTypeFromMappedType(source), targetInfo.type, reportErrors) :
+                        isGenericMappedType(source) && targetHasStringIndex ? isRelatedTo(getTemplateTypeFromMappedType(source), targetInfo.type, 3, reportErrors) :
                             typeRelatedToIndexInfo(source, targetInfo, reportErrors, intersectionState);
                     if (!related) {
                         return 0;
@@ -53791,7 +53949,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) && sourceInfo.isReadonly === targetInfo.isReadonly)) {
                         return 0;
                     }
                 }
@@ -55021,6 +55179,16 @@ var ts;
         function isFromInferenceBlockedSource(type) {
             return !!(type.symbol && ts.some(type.symbol.declarations, hasSkipDirectInferenceFlag));
         }
+        function templateLiteralTypesDefinitelyUnrelated(source, target) {
+            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, false);
             var success = true;
@@ -55925,7 +56093,7 @@ var ts;
                     if (prop.isDiscriminantProperty === undefined) {
                         prop.isDiscriminantProperty =
                             (prop.checkFlags & 192) === 192 &&
-                                !maybeTypeOfKind(getTypeOfSymbol(prop), 465829888 & ~134217728);
+                                !isGenericType(getTypeOfSymbol(prop));
                     }
                     return !!prop.isDiscriminantProperty;
                 }
@@ -56415,13 +56583,13 @@ var ts;
             return filterType(type, function (t) { return (t.flags & kind) !== 0; });
         }
         function replacePrimitivesWithLiterals(typeWithPrimitives, typeWithLiterals) {
-            if (isTypeSubsetOf(stringType, typeWithPrimitives) && maybeTypeOfKind(typeWithLiterals, 128) ||
-                isTypeSubsetOf(numberType, typeWithPrimitives) && maybeTypeOfKind(typeWithLiterals, 256) ||
-                isTypeSubsetOf(bigintType, typeWithPrimitives) && maybeTypeOfKind(typeWithLiterals, 2048)) {
+            if (maybeTypeOfKind(typeWithPrimitives, 4 | 134217728 | 8 | 64) &&
+                maybeTypeOfKind(typeWithLiterals, 128 | 134217728 | 268435456 | 256 | 2048)) {
                 return mapType(typeWithPrimitives, function (t) {
-                    return t.flags & 4 ? extractTypesOfKind(typeWithLiterals, 4 | 128) :
-                        t.flags & 8 ? extractTypesOfKind(typeWithLiterals, 8 | 256) :
-                            t.flags & 64 ? extractTypesOfKind(typeWithLiterals, 64 | 2048) : t;
+                    return t.flags & 4 ? extractTypesOfKind(typeWithLiterals, 4 | 128 | 134217728 | 268435456) :
+                        isPatternLiteralType(t) && !maybeTypeOfKind(typeWithLiterals, 4 | 134217728 | 268435456) ? extractTypesOfKind(typeWithLiterals, 128) :
+                            t.flags & 8 ? extractTypesOfKind(typeWithLiterals, 8 | 256) :
+                                t.flags & 64 ? extractTypesOfKind(typeWithLiterals, 64 | 2048) : t;
                 });
             }
             return typeWithPrimitives;
@@ -56492,10 +56660,10 @@ var ts;
                 isTypeAssignableToKind(getTypeOfExpression(parent.argumentExpression), 296);
             return isLengthPushOrUnshift || isElementAssignment;
         }
-        function isDeclarationWithExplicitTypeAnnotation(declaration) {
-            return (declaration.kind === 253 || declaration.kind === 163 ||
-                declaration.kind === 166 || declaration.kind === 165) &&
-                !!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 | 8192 | 32 | 512)) {
@@ -57118,7 +57286,7 @@ var ts;
                 var narrowedPropType = narrowType(propType);
                 return filterType(type, function (t) {
                     var discriminantType = getTypeOfPropertyOrIndexSignature(t, propName);
-                    return !(discriminantType.flags & 131072) && isTypeComparableTo(discriminantType, narrowedPropType);
+                    return !(narrowedPropType.flags & 131072) && isTypeComparableTo(narrowedPropType, discriminantType);
                 });
             }
             function narrowTypeByDiscriminantProperty(type, access, operator, value, assumeTrue) {
@@ -57512,16 +57680,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 (type.flags & 1048576) {
                     var assignableType = filterType(type, function (t) { return isRelated(t, candidate); });
@@ -58721,8 +58880,8 @@ var ts;
                     return getTypeOfPropertyOfContextualType(type, getSymbolOfNode(element).escapedName);
                 }
                 if (element.name) {
-                    var nameType_1 = getLiteralTypeFromPropertyName(element.name);
-                    return mapType(type, function (t) { var _a; return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType_1)) === null || _a === void 0 ? void 0 : _a.type; }, true);
+                    var nameType_2 = getLiteralTypeFromPropertyName(element.name);
+                    return mapType(type, function (t) { var _a; return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType_2)) === null || _a === void 0 ? void 0 : _a.type; }, true);
                 }
             }
             return undefined;
@@ -59112,11 +59271,8 @@ var ts;
             }
             return !hasEffectiveRestParameter(signature) && getParameterCount(signature) < targetParameterCount;
         }
-        function isFunctionExpressionOrArrowFunction(node) {
-            return node.kind === 212 || node.kind === 213;
-        }
         function getContextualSignatureForFunctionLikeDeclaration(node) {
-            return isFunctionExpressionOrArrowFunction(node) || ts.isObjectLiteralMethod(node)
+            return ts.isFunctionExpressionOrArrowFunction(node) || ts.isObjectLiteralMethod(node)
                 ? getContextualSignature(node)
                 : undefined;
         }
@@ -59922,6 +60078,13 @@ var ts;
                         markAliasSymbolAsReferenced(jsxFactorySym);
                     }
                 }
+                if (ts.isJsxOpeningFragment(node)) {
+                    var file = ts.getSourceFileOfNode(node);
+                    var localJsxNamespace = getLocalJsxNamespace(file);
+                    if (localJsxNamespace) {
+                        resolveName(jsxFactoryLocation, localJsxNamespace, 111551, jsxFactoryRefErr, localJsxNamespace, true);
+                    }
+                }
             }
             if (isNodeOpeningLikeElement) {
                 var jsxOpeningLikeNode = node;
@@ -61345,7 +61508,7 @@ var ts;
                 return false;
             var symbol = resolveName(node.expression, node.expression.escapedText, 111551, 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(false);
@@ -62385,18 +62548,18 @@ var ts;
             if (moduleSymbol) {
                 var esModuleSymbol = resolveESModuleSymbol(moduleSymbol, specifier, true, 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, false);
+                    var hasSyntheticDefault = canHaveSyntheticDefault(file, originalSymbol, false, moduleSpecifier);
                     if (hasSyntheticDefault) {
                         var memberTable = ts.createSymbolTable();
                         var newSymbol = createSymbol(2097152, "default");
@@ -62555,16 +62718,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), "Containing file is missing import meta node flag.");
             return node.name.escapedText === "meta" ? getGlobalImportMetaType() : errorType;
@@ -63390,9 +63551,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) {
+                            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) {
                                 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);
                             }
                         }
@@ -64671,7 +64832,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);
             }
@@ -66257,6 +66418,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:
@@ -69076,11 +69243,15 @@ var ts;
         }
         function checkGrammarExportDeclaration(node) {
             var _a;
-            var isTypeOnlyExportStar = node.isTypeOnly && ((_a = node.exportClause) === null || _a === void 0 ? void 0 : _a.kind) !== 272;
-            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) {
+                    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 || node.parent.kind === 261 || node.parent.kind === 260;
@@ -69374,6 +69545,10 @@ var ts;
                     return;
                 case 307:
                     return checkSourceElement(node.type);
+                case 331:
+                case 333:
+                case 332:
+                    return checkJSDocAccessibilityModifiers(node);
                 case 193:
                     return checkIndexedAccessType(node);
                 case 194:
@@ -71817,8 +71992,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) {
-                                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) {
+                                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));
                             }
                         }
                     }
@@ -72425,14 +72600,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) {
+                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
+                        ? 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);
@@ -73103,7 +73291,7 @@ var ts;
                 return factory.updateNamedImports(node, nodesVisitor(node.elements, visitor, ts.isImportSpecifier));
             case 269:
                 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:
                 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));
@@ -73115,7 +73303,7 @@ var ts;
                 return factory.updateNamedExports(node, nodesVisitor(node.elements, visitor, ts.isExportSpecifier));
             case 274:
                 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));
             case 276:
                 ts.Debug.type(node);
                 return factory.updateExternalModuleReference(node, nodeVisitor(node.expression, visitor, ts.isExpression));
@@ -73446,7 +73634,7 @@ var ts;
         }
     }
     ts.createSourceMapGenerator = createSourceMapGenerator;
-    var sourceMapCommentRegExp = /^\/\/[@#] source[M]appingURL=(.+)$/;
+    var sourceMapCommentRegExp = /^\/\/[@#] source[M]appingURL=(.+)\r?\n?$/;
     var whitespaceOrMapCommentRegExp = /^\s*(\/\/[@#] .*)?$/;
     function getLineInfo(text, lineStarts) {
         return {
@@ -75736,6 +75924,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);
         }
@@ -75893,12 +76082,14 @@ var ts;
                 return shouldEmitAliasDeclaration(node) ? node : undefined;
             }
             else {
+                var allowEmpty = compilerOptions.preserveValueImports && (compilerOptions.importsNotUsedAsValues === 1 ||
+                    compilerOptions.importsNotUsedAsValues === 2);
                 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;
             }
         }
         function visitImportSpecifier(node) {
-            return shouldEmitAliasDeclaration(node) ? node : undefined;
+            return !node.isTypeOnly && shouldEmitAliasDeclaration(node) ? node : undefined;
         }
         function visitExportAssignment(node) {
             return resolver.isValueAliasDeclaration(node)
@@ -75912,26 +76103,25 @@ var ts;
             if (!node.exportClause || ts.isNamespaceExport(node.exportClause)) {
                 return node;
             }
-            if (!resolver.isValueAliasDeclaration(node)) {
-                return undefined;
-            }
-            var exportClause = ts.visitNode(node.exportClause, visitNamedExportBindings, ts.isNamedExportBindings);
+            var allowEmpty = !!node.moduleSpecifier && (compilerOptions.importsNotUsedAsValues === 1 ||
+                compilerOptions.importsNotUsedAsValues === 2);
+            var exportClause = ts.visitNode(node.exportClause, function (bindings) { return visitNamedExportBindings(bindings, allowEmpty); }, ts.isNamedExportBindings);
             return exportClause
                 ? factory.updateExportDeclaration(node, undefined, undefined, node.isTypeOnly, exportClause, node.moduleSpecifier, node.assertClause)
                 : undefined;
         }
-        function visitNamedExports(node) {
+        function visitNamedExports(node, allowEmpty) {
             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);
         }
         function visitExportSpecifier(node) {
-            return resolver.isValueAliasDeclaration(node) ? node : undefined;
+            return !node.isTypeOnly && resolver.isValueAliasDeclaration(node) ? node : undefined;
         }
         function shouldEmitImportEqualsDeclaration(node) {
             return shouldEmitAliasDeclaration(node)
@@ -78905,7 +79095,7 @@ var ts;
                 currentFileState.utilizedImplicitRuntimeImports.set(importSource, specifierSourceImports);
             }
             var generatedName = factory.createUniqueName("_" + name, 16 | 32 | 64);
-            var specifier = factory.createImportSpecifier(factory.createIdentifier(name), generatedName);
+            var specifier = factory.createImportSpecifier(false, factory.createIdentifier(name), generatedName);
             generatedName.generatedImportReference = specifier;
             specifierSourceImports.set(name, specifier);
             return generatedName;
@@ -85223,7 +85413,7 @@ var ts;
             if (!importRequireStatements) {
                 var createRequireName = factory.createUniqueName("_createRequire", 16 | 32);
                 var importStatement = factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamedImports([
-                    factory.createImportSpecifier(factory.createIdentifier("createRequire"), createRequireName)
+                    factory.createImportSpecifier(false, factory.createIdentifier("createRequire"), createRequireName)
                 ])), factory.createStringLiteral("module"));
                 var requireHelperName = factory.createUniqueName("__require", 16 | 32);
                 var requireStatement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
@@ -85248,7 +85438,7 @@ var ts;
         }
         function appendExportsOfImportEqualsDeclaration(statements, node) {
             if (ts.hasSyntacticModifier(node, 1)) {
-                statements = ts.append(statements, factory.createExportDeclaration(undefined, undefined, node.isTypeOnly, factory.createNamedExports([factory.createExportSpecifier(undefined, ts.idText(node.name))])));
+                statements = ts.append(statements, factory.createExportDeclaration(undefined, undefined, node.isTypeOnly, factory.createNamedExports([factory.createExportSpecifier(false, undefined, ts.idText(node.name))])));
             }
             return statements;
         }
@@ -85266,7 +85456,7 @@ var ts;
             var synthName = factory.getGeneratedNameForNode(oldIdentifier);
             var importDecl = factory.createImportDeclaration(undefined, undefined, factory.createImportClause(false, undefined, factory.createNamespaceImport(synthName)), node.moduleSpecifier, node.assertClause);
             ts.setOriginalNode(importDecl, node.exportClause);
-            var exportDecl = ts.isExportNamespaceAsDefaultDeclaration(node) ? factory.createExportDefault(synthName) : factory.createExportDeclaration(undefined, undefined, false, factory.createNamedExports([factory.createExportSpecifier(synthName, oldIdentifier)]));
+            var exportDecl = ts.isExportNamespaceAsDefaultDeclaration(node) ? factory.createExportDefault(synthName) : factory.createExportDeclaration(undefined, undefined, false, factory.createNamedExports([factory.createExportSpecifier(false, synthName, oldIdentifier)]));
             ts.setOriginalNode(exportDecl, node);
             return [importDecl, exportDecl];
         }
@@ -86680,7 +86870,7 @@ var ts;
                         else {
                             declarations.push(factory.createExportDeclaration(undefined, undefined, false, factory.createNamedExports(ts.map(exportMappings_1, function (_a) {
                                 var gen = _a[0], exp = _a[1];
-                                return factory.createExportSpecifier(gen, exp);
+                                return factory.createExportSpecifier(false, gen, exp);
                             }))));
                         }
                         var namespaceDecl = factory.createModuleDeclaration(undefined, ensureModifiers(input), input.name, factory.createModuleBlock(declarations), 16);
@@ -87017,6 +87207,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;
@@ -90274,6 +90465,10 @@ var ts;
             writePunctuation("}");
         }
         function emitImportOrExportSpecifier(node) {
+            if (node.isTypeOnly) {
+                writeKeyword("type");
+                writeSpace();
+            }
             if (node.propertyName) {
                 emit(node.propertyName);
                 writeSpace();
@@ -98096,7 +98291,7 @@ var ts;
             }
             var nodeModulesDirectoryName = moduleSpecifier.substring(parts.topLevelPackageNameIndex + 1);
             var packageName = ts.getPackageNameFromTypesPackageName(nodeModulesDirectoryName);
-            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");
@@ -101137,7 +101332,7 @@ var ts;
     }
     function printEasyHelp(sys, simpleOptions) {
         var colors = createColors(sys);
-        var output = __spreadArray([], getHelpHeader(sys), true);
+        var output = __spreadArray([], getHeader(sys, ts.getDiagnosticText(ts.Diagnostics.tsc_Colon_The_TypeScript_Compiler) + " - " + ts.getDiagnosticText(ts.Diagnostics.Version_0, ts.version)), true);
         output.push(colors.bold(ts.getDiagnosticText(ts.Diagnostics.COMMON_COMMANDS)) + sys.newLine + sys.newLine);
         example("tsc", ts.Diagnostics.Compiles_the_current_project_tsconfig_json_in_the_working_directory);
         example("tsc app.ts util.ts", ts.Diagnostics.Ignoring_tsconfig_json_compiles_the_specified_files_with_default_compiler_options);
@@ -101163,7 +101358,7 @@ var ts;
         }
     }
     function printAllHelp(sys, compilerOptions, buildOptions, watchOptions) {
-        var output = __spreadArray([], getHelpHeader(sys), true);
+        var output = __spreadArray([], getHeader(sys, ts.getDiagnosticText(ts.Diagnostics.tsc_Colon_The_TypeScript_Compiler) + " - " + ts.getDiagnosticText(ts.Diagnostics.Version_0, ts.version)), true);
         output = __spreadArray(__spreadArray([], output, true), generateSectionOptionsOutput(sys, ts.getDiagnosticText(ts.Diagnostics.ALL_COMPILER_OPTIONS), compilerOptions, true, undefined, ts.formatMessage(undefined, ts.Diagnostics.You_can_learn_about_all_of_the_compiler_options_at_0, "https://aka.ms/tsconfig-reference")), true);
         output = __spreadArray(__spreadArray([], output, true), generateSectionOptionsOutput(sys, ts.getDiagnosticText(ts.Diagnostics.WATCH_OPTIONS), watchOptions, false, ts.getDiagnosticText(ts.Diagnostics.Including_watch_w_will_start_watching_the_current_project_for_the_file_changes_Once_set_you_can_config_watch_mode_with_Colon)), true);
         output = __spreadArray(__spreadArray([], output, true), generateSectionOptionsOutput(sys, ts.getDiagnosticText(ts.Diagnostics.BUILD_OPTIONS), buildOptions, false, ts.formatMessage(undefined, ts.Diagnostics.Using_build_b_will_make_tsc_behave_more_like_a_build_orchestrator_than_a_compiler_This_is_used_to_trigger_building_composite_projects_which_you_can_learn_more_about_at_0, "https://aka.ms/tsc-composite-builds")), true);
@@ -101173,31 +101368,30 @@ var ts;
         }
     }
     function printBuildHelp(sys, buildOptions) {
-        var output = __spreadArray([], getHelpHeader(sys), true);
+        var output = __spreadArray([], getHeader(sys, ts.getDiagnosticText(ts.Diagnostics.tsc_Colon_The_TypeScript_Compiler) + " - " + ts.getDiagnosticText(ts.Diagnostics.Version_0, ts.version)), true);
         output = __spreadArray(__spreadArray([], output, true), generateSectionOptionsOutput(sys, ts.getDiagnosticText(ts.Diagnostics.BUILD_OPTIONS), buildOptions, false, ts.formatMessage(undefined, ts.Diagnostics.Using_build_b_will_make_tsc_behave_more_like_a_build_orchestrator_than_a_compiler_This_is_used_to_trigger_building_composite_projects_which_you_can_learn_more_about_at_0, "https://aka.ms/tsc-composite-builds")), true);
         for (var _i = 0, output_3 = output; _i < output_3.length; _i++) {
             var line = output_3[_i];
             sys.write(line);
         }
     }
-    function getHelpHeader(sys) {
+    function getHeader(sys, message) {
         var _a, _b;
         var colors = createColors(sys);
         var header = [];
-        var tscExplanation = ts.getDiagnosticText(ts.Diagnostics.tsc_Colon_The_TypeScript_Compiler) + " - " + ts.getDiagnosticText(ts.Diagnostics.Version_0, ts.version);
         var terminalWidth = (_b = (_a = sys.getWidthOfTerminal) === null || _a === void 0 ? void 0 : _a.call(sys)) !== null && _b !== void 0 ? _b : 0;
         ;
         var tsIconLength = 5;
         var tsIconFirstLine = colors.blueBackground(ts.padLeft("", tsIconLength));
         var tsIconSecondLine = colors.blueBackground(colors.brightWhite(ts.padLeft("TS ", tsIconLength)));
-        if (terminalWidth >= tscExplanation.length + tsIconLength) {
+        if (terminalWidth >= message.length + tsIconLength) {
             var rightAlign = terminalWidth > 120 ? 120 : terminalWidth;
             var leftAlign = rightAlign - tsIconLength;
-            header.push(ts.padRight(tscExplanation, leftAlign) + tsIconFirstLine + sys.newLine);
+            header.push(ts.padRight(message, leftAlign) + tsIconFirstLine + sys.newLine);
             header.push(ts.padLeft("", leftAlign) + tsIconSecondLine + sys.newLine);
         }
         else {
-            header.push(tscExplanation + sys.newLine);
+            header.push(message + sys.newLine);
             header.push(sys.newLine);
         }
         return header;
@@ -101612,7 +101806,13 @@ var ts;
         }
         else {
             sys.writeFile(file, ts.generateTSConfig(options, fileNames, sys.newLine));
-            reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.Successfully_created_a_tsconfig_json_file));
+            var output = __spreadArray([sys.newLine], getHeader(sys, "Created a new tsconfig.json with:"), true);
+            output.push(ts.getCompilerOptionsDiffValue(options, sys.newLine) + sys.newLine + sys.newLine);
+            output.push("You can learn more at https://aka.ms/tsconfig.json" + sys.newLine);
+            for (var _i = 0, output_4 = output; _i < output_4.length; _i++) {
+                var line = output_4[_i];
+                sys.write(line);
+            }
         }
         return;
     }