typescript 4.5.0-dev.20210923 → 4.5.0-dev.20210927

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-dev.20210923";
+    ts.version = ts.versionMajorMinor + ".0-dev.20210927";
     var NativeCollections;
     (function (NativeCollections) {
         function tryGetNativeMap() {
@@ -3259,6 +3259,8 @@ var ts;
     (function (ModuleResolutionKind) {
         ModuleResolutionKind[ModuleResolutionKind["Classic"] = 1] = "Classic";
         ModuleResolutionKind[ModuleResolutionKind["NodeJs"] = 2] = "NodeJs";
+        ModuleResolutionKind[ModuleResolutionKind["Node12"] = 3] = "Node12";
+        ModuleResolutionKind[ModuleResolutionKind["NodeNext"] = 99] = "NodeNext";
     })(ModuleResolutionKind = ts.ModuleResolutionKind || (ts.ModuleResolutionKind = {}));
     var WatchFileKind;
     (function (WatchFileKind) {
@@ -3293,6 +3295,8 @@ var ts;
         ModuleKind[ModuleKind["ES2015"] = 5] = "ES2015";
         ModuleKind[ModuleKind["ES2020"] = 6] = "ES2020";
         ModuleKind[ModuleKind["ESNext"] = 99] = "ESNext";
+        ModuleKind[ModuleKind["Node12"] = 100] = "Node12";
+        ModuleKind[ModuleKind["NodeNext"] = 199] = "NodeNext";
     })(ModuleKind = ts.ModuleKind || (ts.ModuleKind = {}));
     ts.commentPragmas = {
         "reference": {
@@ -5293,7 +5297,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_or_umd: 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', or 'umd'."),
+        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_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."),
@@ -5311,7 +5315,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_or_system: diag(1343, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_esnext_or_system_1343", "The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'esnext', or 'system'."),
+        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'."),
         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."),
@@ -5342,7 +5346,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_or_system_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_or_system_and_t_1378", "Top-level 'await' expressions are only allowed when the 'module' option is set to 'esnext' or 'system', and the 'target' option is set to 'es2017' or higher."),
+        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."),
         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 `}`?"),
@@ -5394,7 +5398,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_or_system_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_or_system_and_the_1432", "Top-level 'for await' loops are only allowed when the 'module' option is set to 'esnext' or 'system', 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_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."),
         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}'?"),
@@ -5411,6 +5415,9 @@ var ts;
         _0_resolves_to_a_type_only_declaration_and_must_be_re_exported_using_a_type_only_re_export_when_isolatedModules_is_enabled: diag(1448, ts.DiagnosticCategory.Error, "_0_resolves_to_a_type_only_declaration_and_must_be_re_exported_using_a_type_only_re_export_when_isol_1448", "'{0}' resolves to a type-only declaration and must be re-exported using a type-only re-export when 'isolatedModules' is enabled."),
         Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed: diag(1449, ts.DiagnosticCategory.Message, "Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed_1449", "Preserve unused imported values in the JavaScript output that would otherwise be removed."),
         Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments: diag(1450, ts.DiagnosticCategory.Message, "Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments_1450", "Dynamic imports can only accept a module specifier and an optional assertion as arguments"),
+        Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression: diag(1451, ts.DiagnosticCategory.Error, "Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member__1451", "Private identifiers are only allowed in class bodies and may only be used as part of a class member declaration, property access, or on the left-hand-side of an 'in' expression"),
+        The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output: diag(1470, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output_1470", "The 'import.meta' meta-property is not allowed in files which will build into CommonJS output."),
+        Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_synchronously_Use_dynamic_import_instead: diag(1471, ts.DiagnosticCategory.Error, "Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_c_1471", "Module '{0}' cannot be imported using this construct. The specifier only resolves to an ES module, which cannot be imported synchronously. Use dynamic import instead."),
         The_types_of_0_are_incompatible_between_these_types: diag(2200, ts.DiagnosticCategory.Error, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."),
         The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, ts.DiagnosticCategory.Error, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."),
         Call_signature_return_types_0_and_1_are_incompatible: diag(2202, ts.DiagnosticCategory.Error, "Call_signature_return_types_0_and_1_are_incompatible_2202", "Call signature return types '{0}' and '{1}' are incompatible.", undefined, true),
@@ -5475,7 +5482,7 @@ var ts;
         The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access: diag(2357, ts.DiagnosticCategory.Error, "The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access_2357", "The operand of an increment or decrement operator must be a variable or a property access."),
         The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: diag(2358, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_paramete_2358", "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter."),
         The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type: diag(2359, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_F_2359", "The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type."),
-        The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol: diag(2360, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol_2360", "The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'."),
+        The_left_hand_side_of_an_in_expression_must_be_a_private_identifier_or_of_type_any_string_number_or_symbol: diag(2360, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_in_expression_must_be_a_private_identifier_or_of_type_any_string_number_or__2360", "The left-hand side of an 'in' expression must be a private identifier or of type 'any', 'string', 'number', or 'symbol'."),
         The_right_hand_side_of_an_in_expression_must_not_be_a_primitive: diag(2361, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_in_expression_must_not_be_a_primitive_2361", "The right-hand side of an 'in' expression must not be a primitive."),
         The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2362, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type_2362", "The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type."),
         The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2363, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type_2363", "The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type."),
@@ -6280,6 +6287,13 @@ var ts;
         Output_Formatting: diag(6256, ts.DiagnosticCategory.Message, "Output_Formatting_6256", "Output Formatting"),
         Completeness: diag(6257, ts.DiagnosticCategory.Message, "Completeness_6257", "Completeness"),
         _0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file: diag(6258, ts.DiagnosticCategory.Error, "_0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file_6258", "'{0}' should be set inside the 'compilerOptions' object of the config json file"),
+        Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve: diag(6270, ts.DiagnosticCategory.Message, "Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve_6270", "Directory '{0}' has no containing package.json scope. Imports will not resolve."),
+        Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1: diag(6271, ts.DiagnosticCategory.Message, "Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1_6271", "Import specifier '{0}' does not exist in package.json scope at path '{1}'."),
+        Invalid_import_specifier_0_has_no_possible_resolutions: diag(6272, ts.DiagnosticCategory.Message, "Invalid_import_specifier_0_has_no_possible_resolutions_6272", "Invalid import specifier '{0}' has no possible resolutions."),
+        package_json_scope_0_has_no_imports_defined: diag(6273, ts.DiagnosticCategory.Message, "package_json_scope_0_has_no_imports_defined_6273", "package.json scope '{0}' has no imports defined."),
+        package_json_scope_0_explicitly_maps_specifier_1_to_null: diag(6274, ts.DiagnosticCategory.Message, "package_json_scope_0_explicitly_maps_specifier_1_to_null_6274", "package.json scope '{0}' explicitly maps specifier '{1}' to null."),
+        package_json_scope_0_has_invalid_type_for_target_of_specifier_1: diag(6275, ts.DiagnosticCategory.Message, "package_json_scope_0_has_invalid_type_for_target_of_specifier_1_6275", "package.json scope '{0}' has invalid type for target of specifier '{1}'"),
+        Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1: diag(6276, ts.DiagnosticCategory.Message, "Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1_6276", "Export specifier '{0}' does not exist in package.json scope at path '{1}'."),
         Enable_project_compilation: diag(6302, ts.DiagnosticCategory.Message, "Enable_project_compilation_6302", "Enable project compilation"),
         Composite_projects_may_not_disable_declaration_emit: diag(6304, ts.DiagnosticCategory.Error, "Composite_projects_may_not_disable_declaration_emit_6304", "Composite projects may not disable declaration emit."),
         Output_file_0_has_not_been_built_from_source_file_1: diag(6305, ts.DiagnosticCategory.Error, "Output_file_0_has_not_been_built_from_source_file_1_6305", "Output file '{0}' has not been built from source file '{1}'."),
@@ -6539,6 +6553,8 @@ var ts;
         The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_type_annotation_is_needed: diag(7056, ts.DiagnosticCategory.Error, "The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_ty_7056", "The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed."),
         yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_type_annotation: diag(7057, ts.DiagnosticCategory.Error, "yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_t_7057", "'yield' expression implicitly results in an 'any' type because its containing generator lacks a return-type annotation."),
         If_the_0_package_actually_exposes_this_module_try_adding_a_new_declaration_d_ts_file_containing_declare_module_1: diag(7058, ts.DiagnosticCategory.Error, "If_the_0_package_actually_exposes_this_module_try_adding_a_new_declaration_d_ts_file_containing_decl_7058", "If the '{0}' package actually exposes this module, try adding a new declaration (.d.ts) file containing `declare module '{1}';`"),
+        This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead: diag(7059, ts.DiagnosticCategory.Error, "This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead_7059", "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead."),
+        This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_constraint: diag(7060, ts.DiagnosticCategory.Error, "This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_cons_7060", "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma or explicit constraint."),
         You_cannot_rename_this_element: diag(8000, ts.DiagnosticCategory.Error, "You_cannot_rename_this_element_8000", "You cannot rename this element."),
         You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: diag(8001, ts.DiagnosticCategory.Error, "You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library_8001", "You cannot rename elements that are defined in the standard TypeScript library."),
         import_can_only_be_used_in_TypeScript_files: diag(8002, ts.DiagnosticCategory.Error, "import_can_only_be_used_in_TypeScript_files_8002", "'import ... =' can only be used in TypeScript files."),
@@ -8911,7 +8927,7 @@ var ts;
     }
     ts.sortAndDeduplicateDiagnostics = sortAndDeduplicateDiagnostics;
     function getDefaultLibFileName(options) {
-        switch (options.target) {
+        switch (ts.getEmitScriptTarget(options)) {
             case 99:
                 return "lib.esnext.full.d.ts";
             case 8:
@@ -10030,6 +10046,7 @@ var ts;
             case 225:
             case 212:
             case 79:
+            case 80:
             case 13:
             case 8:
             case 9:
@@ -10597,22 +10614,22 @@ var ts;
         return node.end - node.pos;
     }
     ts.getFullWidth = getFullWidth;
-    function getResolvedModule(sourceFile, moduleNameText) {
-        return sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules.get(moduleNameText);
+    function getResolvedModule(sourceFile, moduleNameText, mode) {
+        return sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules.get(moduleNameText, mode);
     }
     ts.getResolvedModule = getResolvedModule;
-    function setResolvedModule(sourceFile, moduleNameText, resolvedModule) {
+    function setResolvedModule(sourceFile, moduleNameText, resolvedModule, mode) {
         if (!sourceFile.resolvedModules) {
-            sourceFile.resolvedModules = new ts.Map();
+            sourceFile.resolvedModules = ts.createModeAwareCache();
         }
-        sourceFile.resolvedModules.set(moduleNameText, resolvedModule);
+        sourceFile.resolvedModules.set(moduleNameText, mode, resolvedModule);
     }
     ts.setResolvedModule = setResolvedModule;
     function setResolvedTypeReferenceDirective(sourceFile, typeReferenceDirectiveName, resolvedTypeReferenceDirective) {
         if (!sourceFile.resolvedTypeReferenceDirectiveNames) {
-            sourceFile.resolvedTypeReferenceDirectiveNames = new ts.Map();
+            sourceFile.resolvedTypeReferenceDirectiveNames = ts.createModeAwareCache();
         }
-        sourceFile.resolvedTypeReferenceDirectiveNames.set(typeReferenceDirectiveName, resolvedTypeReferenceDirective);
+        sourceFile.resolvedTypeReferenceDirectiveNames.set(typeReferenceDirectiveName, undefined, resolvedTypeReferenceDirective);
     }
     ts.setResolvedTypeReferenceDirective = setResolvedTypeReferenceDirective;
     function projectReferenceIsEqualTo(oldRef, newRef) {
@@ -10644,11 +10661,11 @@ var ts;
             && oldResolution.originalPath === newResolution.originalPath;
     }
     ts.typeDirectiveIsEqualTo = typeDirectiveIsEqualTo;
-    function hasChangesInResolutions(names, newResolutions, oldResolutions, comparer) {
+    function hasChangesInResolutions(names, newResolutions, oldResolutions, oldSourceFile, comparer) {
         ts.Debug.assert(names.length === newResolutions.length);
         for (var i = 0; i < names.length; i++) {
             var newResolution = newResolutions[i];
-            var oldResolution = oldResolutions && oldResolutions.get(names[i]);
+            var oldResolution = oldResolutions && oldResolutions.get(names[i], oldSourceFile && ts.getModeForResolutionAtIndex(oldSourceFile, i));
             var changed = oldResolution
                 ? !newResolution || !comparer(oldResolution, newResolution)
                 : newResolution;
@@ -11092,8 +11109,11 @@ var ts;
         return (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.find(function (d) { return !isExternalModuleAugmentation(d) && !(ts.isModuleDeclaration(d) && isGlobalScopeAugmentation(d)); });
     }
     ts.getNonAugmentationDeclaration = getNonAugmentationDeclaration;
+    function isCommonJSContainingModuleKind(kind) {
+        return kind === ts.ModuleKind.CommonJS || kind === ts.ModuleKind.Node12 || kind === ts.ModuleKind.NodeNext;
+    }
     function isEffectiveExternalModule(node, compilerOptions) {
-        return ts.isExternalModule(node) || compilerOptions.isolatedModules || ((getEmitModuleKind(compilerOptions) === ts.ModuleKind.CommonJS) && !!node.commonJsModuleIndicator);
+        return ts.isExternalModule(node) || compilerOptions.isolatedModules || (isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator);
     }
     ts.isEffectiveExternalModule = isEffectiveExternalModule;
     function isEffectiveStrictModeSourceFile(node, compilerOptions) {
@@ -12118,6 +12138,8 @@ var ts;
                     node = node.parent;
                 }
                 return node.parent.kind === 180 || ts.isJSDocLinkLike(node.parent) || ts.isJSDocNameReference(node.parent) || ts.isJSDocMemberName(node.parent) || isJSXTagName(node);
+            case 80:
+                return ts.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 101;
             case 79:
                 if (node.parent.kind === 180 || ts.isJSDocLinkLike(node.parent) || ts.isJSDocNameReference(node.parent) || ts.isJSDocMemberName(node.parent) || isJSXTagName(node)) {
                     return true;
@@ -13475,6 +13497,7 @@ var ts;
             case 108:
             case 106:
             case 79:
+            case 80:
             case 104:
             case 110:
             case 95:
@@ -13948,9 +13971,17 @@ var ts;
         var path = outputDir
             ? getSourceFilePathInNewDirWorker(fileName, outputDir, currentDirectory, commonSourceDirectory, getCanonicalFileName)
             : fileName;
-        return removeFileExtension(path) + ".d.ts";
+        var declarationExtension = getDeclarationEmitExtensionForPath(path);
+        return removeFileExtension(path) + declarationExtension;
     }
     ts.getDeclarationEmitOutputFilePathWorker = getDeclarationEmitOutputFilePathWorker;
+    function getDeclarationEmitExtensionForPath(path) {
+        return ts.fileExtensionIsOneOf(path, [".mjs", ".mts"]) ? ".d.mts" :
+            ts.fileExtensionIsOneOf(path, [".cjs", ".cts"]) ? ".d.cts" :
+                ts.fileExtensionIsOneOf(path, [".json"]) ? ".json.d.ts" :
+                    ".d.ts";
+    }
+    ts.getDeclarationEmitExtensionForPath = getDeclarationEmitExtensionForPath;
     function outFile(options) {
         return options.outFile || options.out;
     }
@@ -14592,7 +14623,7 @@ var ts;
         return symbol && ts.length(symbol.declarations) > 0 && hasSyntacticModifier(symbol.declarations[0], 512);
     }
     function tryExtractTSExtension(fileName) {
-        return ts.find(ts.supportedTSExtensionsForExtractExtension, function (extension) { return ts.fileExtensionIs(fileName, extension); });
+        return ts.find(supportedTSExtensionsForExtractExtension, function (extension) { return ts.fileExtensionIs(fileName, extension); });
     }
     ts.tryExtractTSExtension = tryExtractTSExtension;
     function getExpandedCharCodes(input) {
@@ -15450,7 +15481,10 @@ var ts;
     }
     ts.getLanguageVariant = getLanguageVariant;
     function getEmitScriptTarget(compilerOptions) {
-        return compilerOptions.target || 0;
+        return compilerOptions.target ||
+            (compilerOptions.module === ts.ModuleKind.Node12 && 7) ||
+            (compilerOptions.module === ts.ModuleKind.NodeNext && 99) ||
+            0;
     }
     ts.getEmitScriptTarget = getEmitScriptTarget;
     function getEmitModuleKind(compilerOptions) {
@@ -15462,7 +15496,20 @@ var ts;
     function getEmitModuleResolutionKind(compilerOptions) {
         var moduleResolution = compilerOptions.moduleResolution;
         if (moduleResolution === undefined) {
-            moduleResolution = getEmitModuleKind(compilerOptions) === ts.ModuleKind.CommonJS ? ts.ModuleResolutionKind.NodeJs : ts.ModuleResolutionKind.Classic;
+            switch (getEmitModuleKind(compilerOptions)) {
+                case ts.ModuleKind.CommonJS:
+                    moduleResolution = ts.ModuleResolutionKind.NodeJs;
+                    break;
+                case ts.ModuleKind.Node12:
+                    moduleResolution = ts.ModuleResolutionKind.Node12;
+                    break;
+                case ts.ModuleKind.NodeNext:
+                    moduleResolution = ts.ModuleResolutionKind.NodeNext;
+                    break;
+                default:
+                    moduleResolution = ts.ModuleResolutionKind.Classic;
+                    break;
+            }
         }
         return moduleResolution;
     }
@@ -15492,11 +15539,23 @@ var ts;
         return !!(getEmitDeclarations(options) && options.declarationMap);
     }
     ts.getAreDeclarationMapsEnabled = getAreDeclarationMapsEnabled;
+    function getESModuleInterop(compilerOptions) {
+        if (compilerOptions.esModuleInterop !== undefined) {
+            return compilerOptions.esModuleInterop;
+        }
+        switch (getEmitModuleKind(compilerOptions)) {
+            case ts.ModuleKind.Node12:
+            case ts.ModuleKind.NodeNext:
+                return true;
+        }
+        return undefined;
+    }
+    ts.getESModuleInterop = getESModuleInterop;
     function getAllowSyntheticDefaultImports(compilerOptions) {
         var moduleKind = getEmitModuleKind(compilerOptions);
         return compilerOptions.allowSyntheticDefaultImports !== undefined
             ? compilerOptions.allowSyntheticDefaultImports
-            : compilerOptions.esModuleInterop ||
+            : getESModuleInterop(compilerOptions) ||
                 moduleKind === ts.ModuleKind.System;
     }
     ts.getAllowSyntheticDefaultImports = getAllowSyntheticDefaultImports;
@@ -15521,7 +15580,7 @@ var ts;
     }
     ts.getAllowJSCompilerOption = getAllowJSCompilerOption;
     function getUseDefineForClassFields(compilerOptions) {
-        return compilerOptions.useDefineForClassFields === undefined ? compilerOptions.target === 99 : compilerOptions.useDefineForClassFields;
+        return compilerOptions.useDefineForClassFields === undefined ? getEmitScriptTarget(compilerOptions) === 99 : compilerOptions.useDefineForClassFields;
     }
     ts.getUseDefineForClassFields = getUseDefineForClassFields;
     function compilerOptionsAffectSemanticDiagnostics(newOptions, oldOptions) {
@@ -15899,48 +15958,51 @@ var ts;
         }
     }
     ts.getScriptKindFromFileName = getScriptKindFromFileName;
-    ts.supportedTSExtensions = [".ts", ".tsx", ".d.ts"];
-    ts.supportedTSExtensionsWithJson = [".ts", ".tsx", ".d.ts", ".json"];
-    ts.supportedTSExtensionsForExtractExtension = [".d.ts", ".ts", ".tsx"];
-    ts.supportedJSExtensions = [".js", ".jsx"];
-    ts.supportedJSAndJsonExtensions = [".js", ".jsx", ".json"];
-    var allSupportedExtensions = __spreadArray(__spreadArray([], ts.supportedTSExtensions, true), ts.supportedJSExtensions, true);
-    var allSupportedExtensionsWithJson = __spreadArray(__spreadArray(__spreadArray([], ts.supportedTSExtensions, true), ts.supportedJSExtensions, true), [".json"], false);
+    ts.supportedTSExtensions = [[".ts", ".tsx", ".d.ts"], [".cts", ".d.cts"], [".mts", ".d.mts"]];
+    ts.supportedTSExtensionsFlat = ts.flatten(ts.supportedTSExtensions);
+    var supportedTSExtensionsWithJson = __spreadArray(__spreadArray([], ts.supportedTSExtensions, true), [[".json"]], false);
+    var supportedTSExtensionsForExtractExtension = [".d.ts", ".d.cts", ".d.mts", ".cts", ".mts", ".ts", ".tsx", ".cts", ".mts"];
+    ts.supportedJSExtensions = [[".js", ".jsx"], [".mjs"], [".cjs"]];
+    ts.supportedJSExtensionsFlat = ts.flatten(ts.supportedJSExtensions);
+    var allSupportedExtensions = [[".ts", ".tsx", ".d.ts", ".js", ".jsx"], [".cts", ".d.cts", ".cjs"], [".mts", ".d.mts", ".mjs"]];
+    var allSupportedExtensionsWithJson = __spreadArray(__spreadArray([], allSupportedExtensions, true), [[".json"]], false);
     function getSupportedExtensions(options, extraFileExtensions) {
         var needJsExtensions = options && getAllowJSCompilerOption(options);
         if (!extraFileExtensions || extraFileExtensions.length === 0) {
             return needJsExtensions ? allSupportedExtensions : ts.supportedTSExtensions;
         }
-        var extensions = __spreadArray(__spreadArray([], needJsExtensions ? allSupportedExtensions : ts.supportedTSExtensions, true), ts.mapDefined(extraFileExtensions, function (x) { return x.scriptKind === 7 || needJsExtensions && isJSLike(x.scriptKind) ? x.extension : undefined; }), true);
-        return ts.deduplicate(extensions, ts.equateStringsCaseSensitive, ts.compareStringsCaseSensitive);
+        var builtins = needJsExtensions ? allSupportedExtensions : ts.supportedTSExtensions;
+        var flatBuiltins = ts.flatten(builtins);
+        var extensions = __spreadArray(__spreadArray([], builtins, true), ts.mapDefined(extraFileExtensions, function (x) { return x.scriptKind === 7 || needJsExtensions && isJSLike(x.scriptKind) && flatBuiltins.indexOf(x.extension) === -1 ? [x.extension] : undefined; }), true);
+        return extensions;
     }
     ts.getSupportedExtensions = getSupportedExtensions;
-    function getSuppoertedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions) {
+    function getSupportedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions) {
         if (!options || !options.resolveJsonModule)
             return supportedExtensions;
         if (supportedExtensions === allSupportedExtensions)
             return allSupportedExtensionsWithJson;
         if (supportedExtensions === ts.supportedTSExtensions)
-            return ts.supportedTSExtensionsWithJson;
-        return __spreadArray(__spreadArray([], supportedExtensions, true), [".json"], false);
+            return supportedTSExtensionsWithJson;
+        return __spreadArray(__spreadArray([], supportedExtensions, true), [[".json"]], false);
     }
-    ts.getSuppoertedExtensionsWithJsonIfResolveJsonModule = getSuppoertedExtensionsWithJsonIfResolveJsonModule;
+    ts.getSupportedExtensionsWithJsonIfResolveJsonModule = getSupportedExtensionsWithJsonIfResolveJsonModule;
     function isJSLike(scriptKind) {
         return scriptKind === 1 || scriptKind === 2;
     }
     function hasJSFileExtension(fileName) {
-        return ts.some(ts.supportedJSExtensions, function (extension) { return ts.fileExtensionIs(fileName, extension); });
+        return ts.some(ts.supportedJSExtensionsFlat, function (extension) { return ts.fileExtensionIs(fileName, extension); });
     }
     ts.hasJSFileExtension = hasJSFileExtension;
     function hasTSFileExtension(fileName) {
-        return ts.some(ts.supportedTSExtensions, function (extension) { return ts.fileExtensionIs(fileName, extension); });
+        return ts.some(ts.supportedTSExtensionsFlat, function (extension) { return ts.fileExtensionIs(fileName, extension); });
     }
     ts.hasTSFileExtension = hasTSFileExtension;
     function isSupportedSourceFileName(fileName, compilerOptions, extraFileExtensions) {
         if (!fileName)
             return false;
         var supportedExtensions = getSupportedExtensions(compilerOptions, extraFileExtensions);
-        for (var _i = 0, _a = getSuppoertedExtensionsWithJsonIfResolveJsonModule(compilerOptions, supportedExtensions); _i < _a.length; _i++) {
+        for (var _i = 0, _a = ts.flatten(getSupportedExtensionsWithJsonIfResolveJsonModule(compilerOptions, supportedExtensions)); _i < _a.length; _i++) {
             var extension = _a[_i];
             if (ts.fileExtensionIs(fileName, extension)) {
                 return true;
@@ -15957,37 +16019,7 @@ var ts;
         return ts.compareValues(numberOfDirectorySeparators(path1), numberOfDirectorySeparators(path2));
     }
     ts.compareNumberOfDirectorySeparators = compareNumberOfDirectorySeparators;
-    function getExtensionPriority(path, supportedExtensions) {
-        for (var i = supportedExtensions.length - 1; i >= 0; i--) {
-            if (ts.fileExtensionIs(path, supportedExtensions[i])) {
-                return adjustExtensionPriority(i, supportedExtensions);
-            }
-        }
-        return 0;
-    }
-    ts.getExtensionPriority = getExtensionPriority;
-    function adjustExtensionPriority(extensionPriority, supportedExtensions) {
-        if (extensionPriority < 2) {
-            return 0;
-        }
-        else if (extensionPriority < supportedExtensions.length) {
-            return 2;
-        }
-        else {
-            return supportedExtensions.length;
-        }
-    }
-    ts.adjustExtensionPriority = adjustExtensionPriority;
-    function getNextLowestExtensionPriority(extensionPriority, supportedExtensions) {
-        if (extensionPriority < 2) {
-            return 2;
-        }
-        else {
-            return supportedExtensions.length;
-        }
-    }
-    ts.getNextLowestExtensionPriority = getNextLowestExtensionPriority;
-    var extensionsToRemove = [".d.ts", ".ts", ".js", ".tsx", ".jsx", ".json"];
+    var extensionsToRemove = [".d.ts", ".d.mts", ".d.cts", ".mjs", ".mts", ".cjs", ".cts", ".ts", ".js", ".tsx", ".jsx", ".json"];
     function removeFileExtension(path) {
         for (var _i = 0, extensionsToRemove_1 = extensionsToRemove; _i < extensionsToRemove_1.length; _i++) {
             var ext = extensionsToRemove_1[_i];
@@ -16033,7 +16065,7 @@ var ts;
     }
     ts.positionIsSynthesized = positionIsSynthesized;
     function extensionIsTS(ext) {
-        return ext === ".ts" || ext === ".tsx" || ext === ".d.ts";
+        return ext === ".ts" || ext === ".tsx" || ext === ".d.ts" || ext === ".cts" || ext === ".mts" || ext === ".d.mts" || ext === ".d.cts";
     }
     ts.extensionIsTS = extensionIsTS;
     function resolutionExtensionIsTSOrJson(ext) {
@@ -20435,6 +20467,7 @@ var ts;
             node.transformFlags =
                 propagateChildrenFlags(node.statements) |
                     propagateChildFlags(node.endOfFileToken);
+            node.impliedNodeFormat = source.impliedNodeFormat;
             return node;
         }
         function updateSourceFile(node, statements, isDeclarationFile, referencedFiles, typeReferenceDirectives, hasNoDefaultLib, libReferenceDirectives) {
@@ -21682,6 +21715,7 @@ var ts;
             createExportStarHelper: createExportStarHelper,
             createClassPrivateFieldGetHelper: createClassPrivateFieldGetHelper,
             createClassPrivateFieldSetHelper: createClassPrivateFieldSetHelper,
+            createClassPrivateFieldInHelper: createClassPrivateFieldInHelper
         };
         function getUnscopedHelperName(name) {
             return ts.setEmitFlags(factory.createIdentifier(name), 4096 | 2);
@@ -21714,7 +21748,7 @@ var ts;
             ]), location);
         }
         function createAssignHelper(attributesSegments) {
-            if (context.getCompilerOptions().target >= 2) {
+            if (ts.getEmitScriptTarget(context.getCompilerOptions()) >= 2) {
                 return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "assign"), undefined, attributesSegments);
             }
             context.requestEmitHelper(ts.assignHelper);
@@ -21847,6 +21881,10 @@ var ts;
             }
             return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldSet"), undefined, args);
         }
+        function createClassPrivateFieldInHelper(state, receiver) {
+            context.requestEmitHelper(ts.classPrivateFieldInHelper);
+            return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldIn"), undefined, [state, receiver]);
+        }
     }
     ts.createEmitHelperFactory = createEmitHelperFactory;
     function compareEmitHelpers(x, y) {
@@ -22031,6 +22069,12 @@ var ts;
         scoped: false,
         text: "\n            var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n                if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n                if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n                if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n                return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n            };"
     };
+    ts.classPrivateFieldInHelper = {
+        name: "typescript:classPrivateFieldIn",
+        importName: "__classPrivateFieldIn",
+        scoped: false,
+        text: "\n            var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(state, receiver) {\n                if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\n                return typeof state === \"function\" ? receiver === state : state.has(receiver);\n            };"
+    };
     var allUnscopedEmitHelpers;
     function getAllUnscopedEmitHelpers() {
         return allUnscopedEmitHelpers || (allUnscopedEmitHelpers = ts.arrayToMap([
@@ -22055,6 +22099,7 @@ var ts;
             ts.exportStarHelper,
             ts.classPrivateFieldGetHelper,
             ts.classPrivateFieldSetHelper,
+            ts.classPrivateFieldInHelper,
             ts.createBindingHelper,
             ts.setModuleDefaultHelper
         ], function (helper) { return helper.name; }));
@@ -23246,7 +23291,7 @@ var ts;
         if (compilerOptions.importHelpers && ts.isEffectiveExternalModule(sourceFile, compilerOptions)) {
             var namedBindings = void 0;
             var moduleKind = ts.getEmitModuleKind(compilerOptions);
-            if (moduleKind >= ts.ModuleKind.ES2015 && moduleKind <= ts.ModuleKind.ESNext) {
+            if ((moduleKind >= ts.ModuleKind.ES2015 && moduleKind <= ts.ModuleKind.ESNext) || sourceFile.impliedNodeFormat === ts.ModuleKind.ESNext) {
                 var helpers = ts.getEmitHelpers(sourceFile);
                 if (helpers) {
                     var helperNames = [];
@@ -23291,9 +23336,9 @@ var ts;
                 return externalHelpersModuleName;
             }
             var moduleKind = ts.getEmitModuleKind(compilerOptions);
-            var create = (hasExportStarsToExportValues || (compilerOptions.esModuleInterop && hasImportStarOrImportDefault))
+            var create = (hasExportStarsToExportValues || (ts.getESModuleInterop(compilerOptions) && hasImportStarOrImportDefault))
                 && moduleKind !== ts.ModuleKind.System
-                && moduleKind < ts.ModuleKind.ES2015;
+                && (moduleKind < ts.ModuleKind.ES2015 || node.impliedNodeFormat === ts.ModuleKind.CommonJS);
             if (!create) {
                 var helpers = ts.getEmitHelpers(node);
                 if (helpers) {
@@ -27672,6 +27717,8 @@ var ts;
                     break;
                 case 15:
                     return parseTemplateExpression(false);
+                case 80:
+                    return parsePrivateIdentifier();
             }
             return parseIdentifier(ts.Diagnostics.Expression_expected);
         }
@@ -30046,6 +30093,7 @@ var ts;
             updateTokenPositionsAndMarkElements(incrementalSourceFile, changeRange.span.start, ts.textSpanEnd(changeRange.span), ts.textSpanEnd(ts.textChangeRangeNewSpan(changeRange)), delta, oldText, newText, aggressiveChecks);
             var result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, true, sourceFile.scriptKind);
             result.commentDirectives = getNewCommentDirectives(sourceFile.commentDirectives, result.commentDirectives, changeRange.span.start, ts.textSpanEnd(changeRange.span), delta, oldText, newText, aggressiveChecks);
+            result.impliedNodeFormat = sourceFile.impliedNodeFormat;
             return result;
         }
         IncrementalParser.updateSourceFile = updateSourceFile;
@@ -30345,7 +30393,7 @@ var ts;
         IncrementalParser.createSyntaxCursor = createSyntaxCursor;
     })(IncrementalParser || (IncrementalParser = {}));
     function isDeclarationFileName(fileName) {
-        return ts.fileExtensionIs(fileName, ".d.ts");
+        return ts.fileExtensionIsOneOf(fileName, [".d.ts", ".d.mts", ".d.cts"]);
     }
     ts.isDeclarationFileName = isDeclarationFileName;
     function processCommentPragmas(context, sourceText) {
@@ -30922,7 +30970,9 @@ var ts;
                 es6: ts.ModuleKind.ES2015,
                 es2015: ts.ModuleKind.ES2015,
                 es2020: ts.ModuleKind.ES2020,
-                esnext: ts.ModuleKind.ESNext
+                esnext: ts.ModuleKind.ESNext,
+                node12: ts.ModuleKind.Node12,
+                nodenext: ts.ModuleKind.NodeNext,
             })),
             affectsModuleResolution: true,
             affectsEmit: true,
@@ -31792,7 +31842,7 @@ var ts;
     };
     ts.defaultInitCompilerOptions = {
         module: ts.ModuleKind.CommonJS,
-        target: 1,
+        target: 3,
         strict: true,
         esModuleInterop: true,
         forceConsistentCasingInFileNames: true,
@@ -33132,7 +33182,7 @@ var ts;
         var wildCardJsonFileMap = new ts.Map();
         var validatedFilesSpec = configFileSpecs.validatedFilesSpec, validatedIncludeSpecs = configFileSpecs.validatedIncludeSpecs, validatedExcludeSpecs = configFileSpecs.validatedExcludeSpecs;
         var supportedExtensions = ts.getSupportedExtensions(options, extraFileExtensions);
-        var supportedExtensionsWithJsonIfResolveJsonModule = ts.getSuppoertedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);
+        var supportedExtensionsWithJsonIfResolveJsonModule = ts.getSupportedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);
         if (validatedFilesSpec) {
             for (var _i = 0, validatedFilesSpec_1 = validatedFilesSpec; _i < validatedFilesSpec_1.length; _i++) {
                 var fileName = validatedFilesSpec_1[_i];
@@ -33167,7 +33217,7 @@ var ts;
                     wildcardFileMap.set(key, file);
                 }
             };
-            for (var _a = 0, _b = host.readDirectory(basePath, supportedExtensionsWithJsonIfResolveJsonModule, validatedExcludeSpecs, validatedIncludeSpecs, undefined); _a < _b.length; _a++) {
+            for (var _a = 0, _b = host.readDirectory(basePath, ts.flatten(supportedExtensionsWithJsonIfResolveJsonModule), validatedExcludeSpecs, validatedIncludeSpecs, undefined); _a < _b.length; _a++) {
                 var file = _b[_a];
                 _loop_6(file);
             }
@@ -33299,23 +33349,36 @@ var ts;
         return undefined;
     }
     function hasFileWithHigherPriorityExtension(file, literalFiles, wildcardFiles, extensions, keyMapper) {
-        var extensionPriority = ts.getExtensionPriority(file, extensions);
-        var adjustedExtensionPriority = ts.adjustExtensionPriority(extensionPriority, extensions);
-        for (var i = 0; i < adjustedExtensionPriority; i++) {
-            var higherPriorityExtension = extensions[i];
-            var higherPriorityPath = keyMapper(ts.changeExtension(file, higherPriorityExtension));
+        var extensionGroup = ts.forEach(extensions, function (group) { return ts.fileExtensionIsOneOf(file, group) ? group : undefined; });
+        if (!extensionGroup) {
+            return false;
+        }
+        for (var _i = 0, extensionGroup_1 = extensionGroup; _i < extensionGroup_1.length; _i++) {
+            var ext = extensionGroup_1[_i];
+            if (ts.fileExtensionIs(file, ext)) {
+                return false;
+            }
+            var higherPriorityPath = keyMapper(ts.changeExtension(file, ext));
             if (literalFiles.has(higherPriorityPath) || wildcardFiles.has(higherPriorityPath)) {
+                if (ext === ".d.ts" && (ts.fileExtensionIs(file, ".js") || ts.fileExtensionIs(file, ".jsx"))) {
+                    continue;
+                }
                 return true;
             }
         }
         return false;
     }
     function removeWildcardFilesWithLowerPriorityExtension(file, wildcardFiles, extensions, keyMapper) {
-        var extensionPriority = ts.getExtensionPriority(file, extensions);
-        var nextExtensionPriority = ts.getNextLowestExtensionPriority(extensionPriority, extensions);
-        for (var i = nextExtensionPriority; i < extensions.length; i++) {
-            var lowerPriorityExtension = extensions[i];
-            var lowerPriorityPath = keyMapper(ts.changeExtension(file, lowerPriorityExtension));
+        var extensionGroup = ts.forEach(extensions, function (group) { return ts.fileExtensionIsOneOf(file, group) ? group : undefined; });
+        if (!extensionGroup) {
+            return;
+        }
+        for (var i = extensionGroup.length - 1; i >= 0; i--) {
+            var ext = extensionGroup[i];
+            if (ts.fileExtensionIs(file, ext)) {
+                return;
+            }
+            var lowerPriorityPath = keyMapper(ts.changeExtension(file, ext));
             wildcardFiles.delete(lowerPriorityPath);
         }
     }
@@ -33551,7 +33614,7 @@ var ts;
         }
         var containingDirectory = containingFile ? ts.getDirectoryPath(containingFile) : undefined;
         var perFolderCache = containingDirectory ? cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference) : undefined;
-        var result = perFolderCache && perFolderCache.get(typeReferenceDirectiveName);
+        var result = perFolderCache && perFolderCache.get(typeReferenceDirectiveName, undefined);
         if (result) {
             if (traceEnabled) {
                 trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_1, typeReferenceDirectiveName, containingFile);
@@ -33585,7 +33648,7 @@ var ts;
             }
         }
         var failedLookupLocations = [];
-        var moduleResolutionState = { compilerOptions: options, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache };
+        var moduleResolutionState = { compilerOptions: options, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: NodeResolutionFeatures.AllFeatures, conditions: ["node", "require", "types"] };
         var resolved = primaryLookup();
         var primary = true;
         if (!resolved) {
@@ -33605,7 +33668,7 @@ var ts;
             };
         }
         result = { resolvedTypeReferenceDirective: resolvedTypeReferenceDirective, failedLookupLocations: failedLookupLocations };
-        perFolderCache === null || perFolderCache === void 0 ? void 0 : perFolderCache.set(typeReferenceDirectiveName, result);
+        perFolderCache === null || perFolderCache === void 0 ? void 0 : perFolderCache.set(typeReferenceDirectiveName, undefined, result);
         if (traceEnabled)
             traceResult(result);
         return result;
@@ -33797,9 +33860,54 @@ var ts;
         }
         function getOrCreateCacheForDirectory(directoryName, redirectedReference) {
             var path = ts.toPath(directoryName, currentDirectory, getCanonicalFileName);
-            return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path, function () { return new ts.Map(); });
+            return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path, function () { return createModeAwareCache(); });
         }
     }
+    function createModeAwareCache() {
+        var underlying = new ts.Map();
+        var memoizedReverseKeys = new ts.Map();
+        var cache = {
+            get: function (specifier, mode) {
+                return underlying.get(getUnderlyingCacheKey(specifier, mode));
+            },
+            set: function (specifier, mode, value) {
+                underlying.set(getUnderlyingCacheKey(specifier, mode), value);
+                return cache;
+            },
+            delete: function (specifier, mode) {
+                underlying.delete(getUnderlyingCacheKey(specifier, mode));
+                return cache;
+            },
+            has: function (specifier, mode) {
+                return underlying.has(getUnderlyingCacheKey(specifier, mode));
+            },
+            forEach: function (cb) {
+                return underlying.forEach(function (elem, key) {
+                    var _a = memoizedReverseKeys.get(key), specifier = _a[0], mode = _a[1];
+                    return cb(elem, specifier, mode);
+                });
+            },
+            size: function () {
+                return underlying.size;
+            }
+        };
+        return cache;
+        function getUnderlyingCacheKey(specifier, mode) {
+            var result = mode === undefined ? specifier : mode + "|" + specifier;
+            memoizedReverseKeys.set(result, [specifier, mode]);
+            return result;
+        }
+    }
+    ts.createModeAwareCache = createModeAwareCache;
+    function zipToModeAwareCache(file, keys, values) {
+        ts.Debug.assert(keys.length === values.length);
+        var map = createModeAwareCache();
+        for (var i = 0; i < keys.length; ++i) {
+            map.set(keys[i], ts.getModeForResolutionAtIndex(file, i), values[i]);
+        }
+        return map;
+    }
+    ts.zipToModeAwareCache = zipToModeAwareCache;
     function createModuleResolutionCache(currentDirectory, getCanonicalFileName, options, directoryToModuleNameMap, moduleNameToDirectoryMap) {
         var preDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap || (directoryToModuleNameMap = createCacheWithRedirects(options)));
         moduleNameToDirectoryMap || (moduleNameToDirectoryMap = createCacheWithRedirects(options));
@@ -33813,9 +33921,9 @@ var ts;
         function update(options) {
             updateRedirectsMap(options, directoryToModuleNameMap, moduleNameToDirectoryMap);
         }
-        function getOrCreateCacheForModuleName(nonRelativeModuleName, redirectedReference) {
+        function getOrCreateCacheForModuleName(nonRelativeModuleName, mode, redirectedReference) {
             ts.Debug.assert(!ts.isExternalModuleNameRelative(nonRelativeModuleName));
-            return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, nonRelativeModuleName, createPerModuleNameCache);
+            return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, mode === undefined ? nonRelativeModuleName : mode + "|" + nonRelativeModuleName, createPerModuleNameCache);
         }
         function createPerModuleNameCache() {
             var directoryPathMap = new ts.Map();
@@ -33875,13 +33983,15 @@ var ts;
         }
     }
     ts.createTypeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache;
-    function resolveModuleNameFromCache(moduleName, containingFile, cache) {
+    function resolveModuleNameFromCache(moduleName, containingFile, cache, mode) {
         var containingDirectory = ts.getDirectoryPath(containingFile);
         var perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory);
-        return perFolderCache && perFolderCache.get(moduleName);
+        if (!perFolderCache)
+            return undefined;
+        return perFolderCache.get(moduleName, mode);
     }
     ts.resolveModuleNameFromCache = resolveModuleNameFromCache;
-    function resolveModuleName(moduleName, containingFile, compilerOptions, host, cache, redirectedReference) {
+    function resolveModuleName(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
         var traceEnabled = isTraceEnabled(compilerOptions, host);
         if (redirectedReference) {
             compilerOptions = redirectedReference.commandLine.options;
@@ -33894,7 +34004,7 @@ var ts;
         }
         var containingDirectory = ts.getDirectoryPath(containingFile);
         var perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference);
-        var result = perFolderCache && perFolderCache.get(moduleName);
+        var result = perFolderCache && perFolderCache.get(moduleName, resolutionMode);
         if (result) {
             if (traceEnabled) {
                 trace(host, ts.Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);
@@ -33903,7 +34013,20 @@ var ts;
         else {
             var moduleResolution = compilerOptions.moduleResolution;
             if (moduleResolution === undefined) {
-                moduleResolution = ts.getEmitModuleKind(compilerOptions) === ts.ModuleKind.CommonJS ? ts.ModuleResolutionKind.NodeJs : ts.ModuleResolutionKind.Classic;
+                switch (ts.getEmitModuleKind(compilerOptions)) {
+                    case ts.ModuleKind.CommonJS:
+                        moduleResolution = ts.ModuleResolutionKind.NodeJs;
+                        break;
+                    case ts.ModuleKind.Node12:
+                        moduleResolution = ts.ModuleResolutionKind.Node12;
+                        break;
+                    case ts.ModuleKind.NodeNext:
+                        moduleResolution = ts.ModuleResolutionKind.NodeNext;
+                        break;
+                    default:
+                        moduleResolution = ts.ModuleResolutionKind.Classic;
+                        break;
+                }
                 if (traceEnabled) {
                     trace(host, ts.Diagnostics.Module_resolution_kind_is_not_specified_using_0, ts.ModuleResolutionKind[moduleResolution]);
                 }
@@ -33915,6 +34038,12 @@ var ts;
             }
             ts.perfLogger.logStartResolveModule(moduleName);
             switch (moduleResolution) {
+                case ts.ModuleResolutionKind.Node12:
+                    result = node12ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
+                    break;
+                case ts.ModuleResolutionKind.NodeNext:
+                    result = nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
+                    break;
                 case ts.ModuleResolutionKind.NodeJs:
                     result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);
                     break;
@@ -33928,9 +34057,9 @@ var ts;
                 ts.perfLogger.logInfoEvent("Module \"" + moduleName + "\" resolved to \"" + result.resolvedModule.resolvedFileName + "\"");
             ts.perfLogger.logStopResolveModule((result && result.resolvedModule) ? "" + result.resolvedModule.resolvedFileName : "null");
             if (perFolderCache) {
-                perFolderCache.set(moduleName, result);
+                perFolderCache.set(moduleName, resolutionMode, result);
                 if (!ts.isExternalModuleNameRelative(moduleName)) {
-                    cache.getOrCreateCacheForModuleName(moduleName, redirectedReference).set(containingDirectory, result);
+                    cache.getOrCreateCacheForModuleName(moduleName, resolutionMode, redirectedReference).set(containingDirectory, result);
                 }
             }
         }
@@ -34064,22 +34193,51 @@ var ts;
         return tryResolveJSModuleWorker(moduleName, initialDir, host).resolvedModule;
     }
     ts.tryResolveJSModule = tryResolveJSModule;
+    var NodeResolutionFeatures;
+    (function (NodeResolutionFeatures) {
+        NodeResolutionFeatures[NodeResolutionFeatures["None"] = 0] = "None";
+        NodeResolutionFeatures[NodeResolutionFeatures["Imports"] = 2] = "Imports";
+        NodeResolutionFeatures[NodeResolutionFeatures["SelfName"] = 4] = "SelfName";
+        NodeResolutionFeatures[NodeResolutionFeatures["Exports"] = 8] = "Exports";
+        NodeResolutionFeatures[NodeResolutionFeatures["ExportsPatternTrailers"] = 16] = "ExportsPatternTrailers";
+        NodeResolutionFeatures[NodeResolutionFeatures["AllFeatures"] = 30] = "AllFeatures";
+        NodeResolutionFeatures[NodeResolutionFeatures["EsmMode"] = 32] = "EsmMode";
+    })(NodeResolutionFeatures || (NodeResolutionFeatures = {}));
+    function node12ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
+        return nodeNextModuleNameResolverWorker(NodeResolutionFeatures.Imports | NodeResolutionFeatures.SelfName | NodeResolutionFeatures.Exports, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
+    }
+    function nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
+        return nodeNextModuleNameResolverWorker(NodeResolutionFeatures.AllFeatures, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
+    }
+    function nodeNextModuleNameResolverWorker(features, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
+        var containingDirectory = ts.getDirectoryPath(containingFile);
+        var esmMode = resolutionMode === ts.ModuleKind.ESNext ? NodeResolutionFeatures.EsmMode : 0;
+        return nodeModuleNameResolverWorker(features | esmMode, moduleName, containingDirectory, compilerOptions, host, cache, compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions, redirectedReference);
+    }
     var jsOnlyExtensions = [Extensions.JavaScript];
     var tsExtensions = [Extensions.TypeScript, Extensions.JavaScript];
     var tsPlusJsonExtensions = __spreadArray(__spreadArray([], tsExtensions, true), [Extensions.Json], false);
     var tsconfigExtensions = [Extensions.TSConfig];
     function tryResolveJSModuleWorker(moduleName, initialDir, host) {
-        return nodeModuleNameResolverWorker(moduleName, initialDir, { moduleResolution: ts.ModuleResolutionKind.NodeJs, allowJs: true }, host, undefined, jsOnlyExtensions, undefined);
+        return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, initialDir, { moduleResolution: ts.ModuleResolutionKind.NodeJs, allowJs: true }, host, undefined, jsOnlyExtensions, undefined);
     }
     function nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, lookupConfig) {
-        return nodeModuleNameResolverWorker(moduleName, ts.getDirectoryPath(containingFile), compilerOptions, host, cache, lookupConfig ? tsconfigExtensions : (compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions), redirectedReference);
+        return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, ts.getDirectoryPath(containingFile), compilerOptions, host, cache, lookupConfig ? tsconfigExtensions : (compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions), redirectedReference);
     }
     ts.nodeModuleNameResolver = nodeModuleNameResolver;
-    function nodeModuleNameResolverWorker(moduleName, containingDirectory, compilerOptions, host, cache, extensions, redirectedReference) {
+    function nodeModuleNameResolverWorker(features, moduleName, containingDirectory, compilerOptions, host, cache, extensions, redirectedReference) {
         var _a, _b;
         var traceEnabled = isTraceEnabled(compilerOptions, host);
         var failedLookupLocations = [];
-        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache };
+        var state = {
+            compilerOptions: compilerOptions,
+            host: host,
+            traceEnabled: traceEnabled,
+            failedLookupLocations: failedLookupLocations,
+            packageJsonInfoCache: cache,
+            features: features,
+            conditions: features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"]
+        };
         var result = ts.forEach(extensions, function (ext) { return tryResolve(ext); });
         return createResolvedModuleWithFailedLookupLocations((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, state.resultFromCache);
         function tryResolve(extensions) {
@@ -34089,10 +34247,19 @@ var ts;
                 return toSearchResult({ resolved: resolved, isExternalLibraryImport: pathContainsNodeModules(resolved.path) });
             }
             if (!ts.isExternalModuleNameRelative(moduleName)) {
-                if (traceEnabled) {
-                    trace(host, ts.Diagnostics.Loading_module_0_from_node_modules_folder_target_file_type_1, moduleName, Extensions[extensions]);
+                var resolved_1;
+                if (features & NodeResolutionFeatures.Imports && ts.startsWith(moduleName, "#")) {
+                    resolved_1 = loadModuleFromImports(extensions, moduleName, containingDirectory, state, cache, redirectedReference);
+                }
+                if (!resolved_1 && features & NodeResolutionFeatures.SelfName) {
+                    resolved_1 = loadModuleFromSelfNameReference(extensions, moduleName, containingDirectory, state, cache, redirectedReference);
+                }
+                if (!resolved_1) {
+                    if (traceEnabled) {
+                        trace(host, ts.Diagnostics.Loading_module_0_from_node_modules_folder_target_file_type_1, moduleName, Extensions[extensions]);
+                    }
+                    resolved_1 = loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, containingDirectory, state, cache, redirectedReference);
                 }
-                var resolved_1 = loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, containingDirectory, state, cache, redirectedReference);
                 if (!resolved_1)
                     return undefined;
                 var resolvedValue = resolved_1.value;
@@ -34182,22 +34349,35 @@ var ts;
     function loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) {
         if (extensions === Extensions.Json || extensions === Extensions.TSConfig) {
             var extensionLess = ts.tryRemoveExtension(candidate, ".json");
-            return (extensionLess === undefined && extensions === Extensions.Json) ? undefined : tryAddingExtensions(extensionLess || candidate, extensions, onlyRecordFailures, state);
+            var extension = extensionLess ? candidate.substring(extensionLess.length) : "";
+            return (extensionLess === undefined && extensions === Extensions.Json) ? undefined : tryAddingExtensions(extensionLess || candidate, extensions, extension, onlyRecordFailures, state);
         }
-        var resolvedByAddingExtension = tryAddingExtensions(candidate, extensions, onlyRecordFailures, state);
-        if (resolvedByAddingExtension) {
-            return resolvedByAddingExtension;
+        if (!(state.features & NodeResolutionFeatures.EsmMode)) {
+            var resolvedByAddingExtension = tryAddingExtensions(candidate, extensions, "", onlyRecordFailures, state);
+            if (resolvedByAddingExtension) {
+                return resolvedByAddingExtension;
+            }
         }
-        if (ts.hasJSFileExtension(candidate)) {
+        return loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state);
+    }
+    function loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state) {
+        if (ts.hasJSFileExtension(candidate) || (ts.fileExtensionIs(candidate, ".json") && state.compilerOptions.resolveJsonModule)) {
             var extensionless = ts.removeFileExtension(candidate);
+            var extension = candidate.substring(extensionless.length);
             if (state.traceEnabled) {
-                var extension = candidate.substring(extensionless.length);
                 trace(state.host, ts.Diagnostics.File_name_0_has_a_1_extension_stripping_it, candidate, extension);
             }
-            return tryAddingExtensions(extensionless, extensions, onlyRecordFailures, state);
+            return tryAddingExtensions(extensionless, extensions, extension, onlyRecordFailures, state);
+        }
+    }
+    function loadJSOrExactTSFileName(extensions, candidate, onlyRecordFailures, state) {
+        if ((extensions === Extensions.TypeScript || extensions === Extensions.DtsOnly) && ts.fileExtensionIsOneOf(candidate, [".d.ts", ".d.cts", ".d.mts"])) {
+            var result = tryFile(candidate, onlyRecordFailures, state);
+            return result !== undefined ? { path: candidate, ext: ts.forEach([".d.ts", ".d.cts", ".d.mts"], function (e) { return ts.fileExtensionIs(candidate, e) ? e : undefined; }) } : undefined;
         }
+        return loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state);
     }
-    function tryAddingExtensions(candidate, extensions, onlyRecordFailures, state) {
+    function tryAddingExtensions(candidate, extensions, originalExtension, onlyRecordFailures, state) {
         if (!onlyRecordFailures) {
             var directory = ts.getDirectoryPath(candidate);
             if (directory) {
@@ -34206,11 +34386,51 @@ var ts;
         }
         switch (extensions) {
             case Extensions.DtsOnly:
-                return tryExtension(".d.ts");
+                switch (originalExtension) {
+                    case ".mjs":
+                    case ".mts":
+                    case ".d.mts":
+                        return tryExtension(".d.mts");
+                    case ".cjs":
+                    case ".cts":
+                    case ".d.cts":
+                        return tryExtension(".d.cts");
+                    case ".json":
+                        candidate += ".json";
+                        return tryExtension(".d.ts");
+                    default: return tryExtension(".d.ts");
+                }
             case Extensions.TypeScript:
-                return tryExtension(".ts") || tryExtension(".tsx") || tryExtension(".d.ts");
+                switch (originalExtension) {
+                    case ".mjs":
+                    case ".mts":
+                    case ".d.mts":
+                        return tryExtension(".mts") || tryExtension(".d.mts");
+                    case ".cjs":
+                    case ".cts":
+                    case ".d.cts":
+                        return tryExtension(".cts") || tryExtension(".d.cts");
+                    case ".json":
+                        candidate += ".json";
+                        return tryExtension(".d.ts");
+                    default:
+                        return tryExtension(".ts") || tryExtension(".tsx") || tryExtension(".d.ts");
+                }
             case Extensions.JavaScript:
-                return tryExtension(".js") || tryExtension(".jsx");
+                switch (originalExtension) {
+                    case ".mjs":
+                    case ".mts":
+                    case ".d.mts":
+                        return tryExtension(".mjs");
+                    case ".cjs":
+                    case ".cts":
+                    case ".d.cts":
+                        return tryExtension(".cjs");
+                    case ".json":
+                        return tryExtension(".json");
+                    default:
+                        return tryExtension(".js") || tryExtension(".jsx");
+                }
             case Extensions.TSConfig:
             case Extensions.Json:
                 return tryExtension(".json");
@@ -34244,6 +34464,28 @@ var ts;
         var versionPaths = packageInfo && packageInfo.versionPaths;
         return withPackageId(packageInfo, loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageJsonContent, versionPaths));
     }
+    function getPackageScopeForPath(fileName, packageJsonInfoCache, host, options) {
+        var state = {
+            host: host,
+            compilerOptions: options,
+            traceEnabled: isTraceEnabled(options, host),
+            failedLookupLocations: [],
+            packageJsonInfoCache: packageJsonInfoCache,
+            features: 0,
+            conditions: [],
+        };
+        var parts = ts.getPathComponents(fileName);
+        parts.pop();
+        while (parts.length > 0) {
+            var pkg = getPackageJsonInfo(ts.getPathFromPathComponents(parts), false, state);
+            if (pkg) {
+                return pkg;
+            }
+            parts.pop();
+        }
+        return undefined;
+    }
+    ts.getPackageScopeForPath = getPackageScopeForPath;
     function getPackageJsonInfo(packageDirectory, onlyRecordFailures, state) {
         var _a, _b, _c;
         var host = state.host, traceEnabled = state.traceEnabled;
@@ -34285,6 +34527,7 @@ var ts;
             state.failedLookupLocations.push(packageJsonPath);
         }
     }
+    ts.getPackageJsonInfo = getPackageJsonInfo;
     function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, jsonContent, versionPaths) {
         var packageFile;
         if (jsonContent) {
@@ -34336,7 +34579,9 @@ var ts;
         var packageFileResult = packageFile && removeIgnoredPackageId(loader(extensions, packageFile, onlyRecordFailuresForPackageFile, state));
         if (packageFileResult)
             return packageFileResult;
-        return loadModuleFromFile(extensions, indexPath, onlyRecordFailuresForIndex, state);
+        if (!(state.features & NodeResolutionFeatures.EsmMode)) {
+            return loadModuleFromFile(extensions, indexPath, onlyRecordFailuresForIndex, state);
+        }
     }
     function resolvedIfExtensionMatches(extensions, path) {
         var ext = ts.tryGetExtensionFromPath(path);
@@ -34363,6 +34608,221 @@ var ts;
         return idx === -1 ? { packageName: moduleName, rest: "" } : { packageName: moduleName.slice(0, idx), rest: moduleName.slice(idx + 1) };
     }
     ts.parsePackageName = parsePackageName;
+    function allKeysStartWithDot(obj) {
+        return ts.every(ts.getOwnKeys(obj), function (k) { return ts.startsWith(k, "."); });
+    }
+    function noKeyStartsWithDot(obj) {
+        return !ts.some(ts.getOwnKeys(obj), function (k) { return ts.startsWith(k, "."); });
+    }
+    function loadModuleFromSelfNameReference(extensions, moduleName, directory, state, cache, redirectedReference) {
+        var _a, _b;
+        var useCaseSensitiveFileNames = typeof state.host.useCaseSensitiveFileNames === "function" ? state.host.useCaseSensitiveFileNames() : state.host.useCaseSensitiveFileNames;
+        var directoryPath = ts.toPath(ts.combinePaths(directory, "dummy"), (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a), ts.createGetCanonicalFileName(useCaseSensitiveFileNames === undefined ? true : useCaseSensitiveFileNames));
+        var scope = getPackageScopeForPath(directoryPath, state.packageJsonInfoCache, state.host, state.compilerOptions);
+        if (!scope || !scope.packageJsonContent.exports) {
+            return undefined;
+        }
+        var parts = ts.getPathComponents(moduleName);
+        if (scope.packageJsonContent.name !== parts[1]) {
+            return undefined;
+        }
+        var trailingParts = parts.slice(2);
+        return loadModuleFromExports(scope, extensions, !ts.length(trailingParts) ? "." : "." + ts.directorySeparator + trailingParts.join(ts.directorySeparator), state, cache, redirectedReference);
+    }
+    function loadModuleFromExports(scope, extensions, subpath, state, cache, redirectedReference) {
+        if (!scope.packageJsonContent.exports) {
+            return undefined;
+        }
+        if (subpath === ".") {
+            var mainExport = void 0;
+            if (typeof scope.packageJsonContent.exports === "string" || Array.isArray(scope.packageJsonContent.exports) || (typeof scope.packageJsonContent.exports === "object" && noKeyStartsWithDot(scope.packageJsonContent.exports))) {
+                mainExport = scope.packageJsonContent.exports;
+            }
+            else if (ts.hasProperty(scope.packageJsonContent.exports, ".")) {
+                mainExport = scope.packageJsonContent.exports["."];
+            }
+            if (mainExport) {
+                var loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, subpath, scope, false);
+                return loadModuleFromTargetImportOrExport(mainExport, "", false);
+            }
+        }
+        else if (allKeysStartWithDot(scope.packageJsonContent.exports)) {
+            if (typeof scope.packageJsonContent.exports !== "object") {
+                if (state.traceEnabled) {
+                    trace(state.host, ts.Diagnostics.Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1, subpath, scope.packageDirectory);
+                }
+                return toSearchResult(undefined);
+            }
+            var result = loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, subpath, scope.packageJsonContent.exports, scope, false);
+            if (result) {
+                return result;
+            }
+        }
+        if (state.traceEnabled) {
+            trace(state.host, ts.Diagnostics.Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1, subpath, scope.packageDirectory);
+        }
+        return toSearchResult(undefined);
+    }
+    function loadModuleFromImports(extensions, moduleName, directory, state, cache, redirectedReference) {
+        var _a, _b;
+        if (moduleName === "#" || ts.startsWith(moduleName, "#/")) {
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.Invalid_import_specifier_0_has_no_possible_resolutions, moduleName);
+            }
+            return toSearchResult(undefined);
+        }
+        var useCaseSensitiveFileNames = typeof state.host.useCaseSensitiveFileNames === "function" ? state.host.useCaseSensitiveFileNames() : state.host.useCaseSensitiveFileNames;
+        var directoryPath = ts.toPath(ts.combinePaths(directory, "dummy"), (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a), ts.createGetCanonicalFileName(useCaseSensitiveFileNames === undefined ? true : useCaseSensitiveFileNames));
+        var scope = getPackageScopeForPath(directoryPath, state.packageJsonInfoCache, state.host, state.compilerOptions);
+        if (!scope) {
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve, directoryPath);
+            }
+            return toSearchResult(undefined);
+        }
+        if (!scope.packageJsonContent.imports) {
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.package_json_scope_0_has_no_imports_defined, scope.packageDirectory);
+            }
+            return toSearchResult(undefined);
+        }
+        var result = loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, moduleName, scope.packageJsonContent.imports, scope, true);
+        if (result) {
+            return result;
+        }
+        if (state.traceEnabled) {
+            trace(state.host, ts.Diagnostics.Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1, moduleName, scope.packageDirectory);
+        }
+        return toSearchResult(undefined);
+    }
+    function loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, moduleName, lookupTable, scope, isImports) {
+        var loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports);
+        if (!ts.endsWith(moduleName, ts.directorySeparator) && moduleName.indexOf("*") === -1 && ts.hasProperty(lookupTable, moduleName)) {
+            var target = lookupTable[moduleName];
+            return loadModuleFromTargetImportOrExport(target, "", false);
+        }
+        var expandingKeys = ts.sort(ts.filter(ts.getOwnKeys(lookupTable), function (k) { return k.indexOf("*") !== -1 || ts.endsWith(k, "/"); }), function (a, b) { return a.length - b.length; });
+        for (var _i = 0, expandingKeys_1 = expandingKeys; _i < expandingKeys_1.length; _i++) {
+            var potentialTarget = expandingKeys_1[_i];
+            if (state.features & NodeResolutionFeatures.ExportsPatternTrailers && matchesPatternWithTrailer(potentialTarget, moduleName)) {
+                var target = lookupTable[potentialTarget];
+                var starPos = potentialTarget.indexOf("*");
+                var subpath = moduleName.substring(potentialTarget.substring(0, starPos).length, moduleName.length - (potentialTarget.length - 1 - starPos));
+                return loadModuleFromTargetImportOrExport(target, subpath, true);
+            }
+            else if (ts.endsWith(potentialTarget, "*") && ts.startsWith(moduleName, potentialTarget.substring(0, potentialTarget.length - 1))) {
+                var target = lookupTable[potentialTarget];
+                var subpath = moduleName.substring(potentialTarget.length - 1);
+                return loadModuleFromTargetImportOrExport(target, subpath, true);
+            }
+            else if (ts.startsWith(moduleName, potentialTarget)) {
+                var target = lookupTable[potentialTarget];
+                var subpath = moduleName.substring(potentialTarget.length);
+                return loadModuleFromTargetImportOrExport(target, subpath, false);
+            }
+        }
+        function matchesPatternWithTrailer(target, name) {
+            if (ts.endsWith(target, "*"))
+                return false;
+            var starPos = target.indexOf("*");
+            if (starPos === -1)
+                return false;
+            return ts.startsWith(name, target.substring(0, starPos)) && ts.endsWith(name, target.substring(starPos + 1));
+        }
+    }
+    function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports) {
+        return loadModuleFromTargetImportOrExport;
+        function loadModuleFromTargetImportOrExport(target, subpath, pattern) {
+            var _a, _b;
+            if (typeof target === "string") {
+                if (!pattern && subpath.length > 0 && !ts.endsWith(target, "/")) {
+                    if (state.traceEnabled) {
+                        trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
+                    }
+                    return toSearchResult(undefined);
+                }
+                if (!ts.startsWith(target, "./")) {
+                    if (isImports && !ts.startsWith(target, "../") && !ts.startsWith(target, "/") && !ts.isRootedDiskPath(target)) {
+                        var combinedLookup = pattern ? target.replace(/\*/g, subpath) : target + subpath;
+                        var result = nodeModuleNameResolverWorker(state.features, combinedLookup, scope.packageDirectory + "/", state.compilerOptions, state.host, cache, [extensions], redirectedReference);
+                        return toSearchResult(result.resolvedModule ? { path: result.resolvedModule.resolvedFileName, extension: result.resolvedModule.extension, packageId: result.resolvedModule.packageId, originalPath: result.resolvedModule.originalPath } : undefined);
+                    }
+                    if (state.traceEnabled) {
+                        trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
+                    }
+                    return toSearchResult(undefined);
+                }
+                var parts = ts.pathIsRelative(target) ? ts.getPathComponents(target).slice(1) : ts.getPathComponents(target);
+                var partsAfterFirst = parts.slice(1);
+                if (partsAfterFirst.indexOf("..") >= 0 || partsAfterFirst.indexOf(".") >= 0 || partsAfterFirst.indexOf("node_modules") >= 0) {
+                    if (state.traceEnabled) {
+                        trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
+                    }
+                    return toSearchResult(undefined);
+                }
+                var resolvedTarget = ts.combinePaths(scope.packageDirectory, target);
+                var subpathParts = ts.getPathComponents(subpath);
+                if (subpathParts.indexOf("..") >= 0 || subpathParts.indexOf(".") >= 0 || subpathParts.indexOf("node_modules") >= 0) {
+                    if (state.traceEnabled) {
+                        trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
+                    }
+                    return toSearchResult(undefined);
+                }
+                var finalPath = ts.getNormalizedAbsolutePath(pattern ? resolvedTarget.replace(/\*/g, subpath) : resolvedTarget + subpath, (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a));
+                return toSearchResult(withPackageId(scope, loadJSOrExactTSFileName(extensions, finalPath, false, state)));
+            }
+            else if (typeof target === "object" && target !== null) {
+                if (!Array.isArray(target)) {
+                    for (var _i = 0, _c = ts.getOwnKeys(target); _i < _c.length; _i++) {
+                        var key = _c[_i];
+                        if (key === "default" || state.conditions.indexOf(key) >= 0 || isApplicableVersionedTypesKey(state.conditions, key)) {
+                            var subTarget = target[key];
+                            var result = loadModuleFromTargetImportOrExport(subTarget, subpath, pattern);
+                            if (result) {
+                                return result;
+                            }
+                        }
+                    }
+                    return undefined;
+                }
+                else {
+                    if (!ts.length(target)) {
+                        if (state.traceEnabled) {
+                            trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
+                        }
+                        return toSearchResult(undefined);
+                    }
+                    for (var _d = 0, target_1 = target; _d < target_1.length; _d++) {
+                        var elem = target_1[_d];
+                        var result = loadModuleFromTargetImportOrExport(elem, subpath, pattern);
+                        if (result) {
+                            return result;
+                        }
+                    }
+                }
+            }
+            else if (target === null) {
+                if (state.traceEnabled) {
+                    trace(state.host, ts.Diagnostics.package_json_scope_0_explicitly_maps_specifier_1_to_null, scope.packageDirectory, moduleName);
+                }
+                return toSearchResult(undefined);
+            }
+            if (state.traceEnabled) {
+                trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
+            }
+            return toSearchResult(undefined);
+        }
+        function isApplicableVersionedTypesKey(conditions, key) {
+            if (conditions.indexOf("types") === -1)
+                return false;
+            if (!ts.startsWith(key, "types@"))
+                return false;
+            var range = ts.VersionRange.tryParse(key.substring("types@".length));
+            if (!range)
+                return false;
+            return range.test(ts.version);
+        }
+    }
     function loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, directory, state, cache, redirectedReference) {
         return loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, false, cache, redirectedReference);
     }
@@ -34370,24 +34830,24 @@ var ts;
         return loadModuleFromNearestNodeModulesDirectoryWorker(Extensions.DtsOnly, moduleName, directory, state, true, undefined, undefined);
     }
     function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) {
-        var perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName, redirectedReference);
+        var perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName, state.features === 0 ? undefined : state.features & NodeResolutionFeatures.EsmMode ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS, redirectedReference);
         return ts.forEachAncestorDirectory(ts.normalizeSlashes(directory), function (ancestorDirectory) {
             if (ts.getBaseFileName(ancestorDirectory) !== "node_modules") {
                 var resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, ancestorDirectory, state);
                 if (resolutionFromCache) {
                     return resolutionFromCache;
                 }
-                return toSearchResult(loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, ancestorDirectory, state, typesScopeOnly));
+                return toSearchResult(loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, ancestorDirectory, state, typesScopeOnly, cache, redirectedReference));
             }
         });
     }
-    function loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, directory, state, typesScopeOnly) {
+    function loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) {
         var nodeModulesFolder = ts.combinePaths(directory, "node_modules");
         var nodeModulesFolderExists = ts.directoryProbablyExists(nodeModulesFolder, state.host);
         if (!nodeModulesFolderExists && state.traceEnabled) {
             trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesFolder);
         }
-        var packageResult = typesScopeOnly ? undefined : loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesFolder, nodeModulesFolderExists, state);
+        var packageResult = typesScopeOnly ? undefined : loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesFolder, nodeModulesFolderExists, state, cache, redirectedReference);
         if (packageResult) {
             return packageResult;
         }
@@ -34400,26 +34860,32 @@ var ts;
                 }
                 nodeModulesAtTypesExists = false;
             }
-            return loadModuleFromSpecificNodeModulesDirectory(Extensions.DtsOnly, mangleScopedPackageNameWithTrace(moduleName, state), nodeModulesAtTypes_1, nodeModulesAtTypesExists, state);
+            return loadModuleFromSpecificNodeModulesDirectory(Extensions.DtsOnly, mangleScopedPackageNameWithTrace(moduleName, state), nodeModulesAtTypes_1, nodeModulesAtTypesExists, state, cache, redirectedReference);
         }
     }
-    function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesDirectory, nodeModulesDirectoryExists, state) {
+    function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesDirectory, nodeModulesDirectoryExists, state, cache, redirectedReference) {
         var candidate = ts.normalizePath(ts.combinePaths(nodeModulesDirectory, moduleName));
         var packageInfo = getPackageJsonInfo(candidate, !nodeModulesDirectoryExists, state);
-        if (packageInfo) {
-            var fromFile = loadModuleFromFile(extensions, candidate, !nodeModulesDirectoryExists, state);
-            if (fromFile) {
-                return noPackageId(fromFile);
+        if (!(state.features & NodeResolutionFeatures.Exports)) {
+            if (packageInfo) {
+                var fromFile = loadModuleFromFile(extensions, candidate, !nodeModulesDirectoryExists, state);
+                if (fromFile) {
+                    return noPackageId(fromFile);
+                }
+                var fromDirectory = loadNodeModuleFromDirectoryWorker(extensions, candidate, !nodeModulesDirectoryExists, state, packageInfo.packageJsonContent, packageInfo.versionPaths);
+                return withPackageId(packageInfo, fromDirectory);
             }
-            var fromDirectory = loadNodeModuleFromDirectoryWorker(extensions, candidate, !nodeModulesDirectoryExists, state, packageInfo.packageJsonContent, packageInfo.versionPaths);
-            return withPackageId(packageInfo, fromDirectory);
         }
+        var _a = parsePackageName(moduleName), packageName = _a.packageName, rest = _a.rest;
         var loader = function (extensions, candidate, onlyRecordFailures, state) {
+            var _a;
+            if (packageInfo && packageInfo.packageJsonContent.exports && state.features & NodeResolutionFeatures.Exports) {
+                return (_a = loadModuleFromExports(packageInfo, extensions, ts.combinePaths(".", rest), state, cache, redirectedReference)) === null || _a === void 0 ? void 0 : _a.value;
+            }
             var pathAndExtension = loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) ||
                 loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageInfo && packageInfo.packageJsonContent, packageInfo && packageInfo.versionPaths);
             return withPackageId(packageInfo, pathAndExtension);
         };
-        var _a = parsePackageName(moduleName), packageName = _a.packageName, rest = _a.rest;
         if (rest !== "") {
             var packageDirectory = ts.combinePaths(nodeModulesDirectory, packageName);
             packageInfo = getPackageJsonInfo(packageDirectory, !nodeModulesDirectoryExists, state);
@@ -34512,7 +34978,7 @@ var ts;
     function classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference) {
         var traceEnabled = isTraceEnabled(compilerOptions, host);
         var failedLookupLocations = [];
-        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache };
+        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: NodeResolutionFeatures.None, conditions: [] };
         var containingDirectory = ts.getDirectoryPath(containingFile);
         var resolved = tryResolve(Extensions.TypeScript) || tryResolve(Extensions.JavaScript);
         return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, false, failedLookupLocations, state.resultFromCache);
@@ -34522,7 +34988,7 @@ var ts;
                 return { value: resolvedUsingSettings };
             }
             if (!ts.isExternalModuleNameRelative(moduleName)) {
-                var perModuleNameCache_1 = cache && cache.getOrCreateCacheForModuleName(moduleName, redirectedReference);
+                var perModuleNameCache_1 = cache && cache.getOrCreateCacheForModuleName(moduleName, undefined, redirectedReference);
                 var resolved_3 = ts.forEachAncestorDirectory(containingDirectory, function (directory) {
                     var resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache_1, moduleName, directory, state);
                     if (resolutionFromCache) {
@@ -34551,8 +35017,8 @@ var ts;
             trace(host, ts.Diagnostics.Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2, projectName, moduleName, globalCache);
         }
         var failedLookupLocations = [];
-        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: packageJsonInfoCache };
-        var resolved = loadModuleFromImmediateNodeModulesDirectory(Extensions.DtsOnly, moduleName, globalCache, state, false);
+        var state = { compilerOptions: compilerOptions, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: packageJsonInfoCache, features: NodeResolutionFeatures.None, conditions: [] };
+        var resolved = loadModuleFromImmediateNodeModulesDirectory(Extensions.DtsOnly, moduleName, globalCache, state, false, undefined, undefined);
         return createResolvedModuleWithFailedLookupLocations(resolved, true, failedLookupLocations, state.resultFromCache);
     }
     ts.loadModuleFromGlobalCache = loadModuleFromGlobalCache;
@@ -36405,7 +36871,7 @@ var ts;
             }
         }
         function checkStrictModeLabeledStatement(node) {
-            if (inStrictMode && options.target >= 2) {
+            if (inStrictMode && ts.getEmitScriptTarget(options) >= 2) {
                 if (ts.isDeclarationStatement(node.statement) || ts.isVariableStatement(node.statement)) {
                     errorOnFirstToken(node.label, ts.Diagnostics.A_label_is_not_allowed_here);
                 }
@@ -37563,7 +38029,7 @@ var ts;
             host.getSourceFiles().forEach(function (sf) {
                 if (!sf.resolvedModules)
                     return;
-                ts.forEachEntry(sf.resolvedModules, function (r) {
+                sf.resolvedModules.forEach(function (r) {
                     if (r && r.packageId)
                         map.set(r.packageId.name, r.extension === ".d.ts" || !!map.get(r.packageId.name));
                 });
@@ -37959,10 +38425,13 @@ var ts;
         var undefinedProperties = new ts.Map();
         var unknownSymbol = createSymbol(4, "unknown");
         var resolvingSymbol = createSymbol(0, "__resolving__");
+        var unresolvedSymbols = new ts.Map();
+        var errorTypes = new ts.Map();
         var anyType = createIntrinsicType(1, "any");
         var autoType = createIntrinsicType(1, "any");
         var wildcardType = createIntrinsicType(1, "any");
         var errorType = createIntrinsicType(1, "error");
+        var unresolvedType = createIntrinsicType(1, "unresolved");
         var nonInferrableAnyType = createIntrinsicType(1, "any", 131072);
         var intrinsicMarkerType = createIntrinsicType(1, "intrinsic");
         var unknownType = createIntrinsicType(2, "unknown");
@@ -38623,7 +39092,7 @@ var ts;
                     return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, false);
                 }
                 else if (ts.isParameterPropertyDeclaration(declaration, declaration.parent)) {
-                    return !(compilerOptions.target === 99 && useDefineForClassFields
+                    return !(ts.getEmitScriptTarget(compilerOptions) === 99 && useDefineForClassFields
                         && ts.getContainingClass(declaration) === ts.getContainingClass(usage)
                         && isUsedInFunctionOrInstanceProperty(usage, declaration));
                 }
@@ -38639,7 +39108,7 @@ var ts;
                 return true;
             }
             if (isUsedInFunctionOrInstanceProperty(usage, declaration)) {
-                if (compilerOptions.target === 99 && useDefineForClassFields
+                if (ts.getEmitScriptTarget(compilerOptions) === 99 && useDefineForClassFields
                     && ts.getContainingClass(declaration)
                     && (ts.isPropertyDeclaration(declaration) || ts.isParameterPropertyDeclaration(declaration, declaration.parent))) {
                     return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, true);
@@ -38794,7 +39263,7 @@ var ts;
             return resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSymbol, issueSuggestions);
         }
         function resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, lookup, issueSuggestions) {
-            var _a;
+            var _a, _b, _c;
             var originalLocation = location;
             var result;
             var lastLocation;
@@ -38847,7 +39316,7 @@ var ts;
                             break;
                         isInExternalModule = true;
                     case 260:
-                        var moduleExports = getSymbolOfNode(location).exports || emptySymbols;
+                        var moduleExports = ((_a = getSymbolOfNode(location)) === null || _a === void 0 ? void 0 : _a.exports) || emptySymbols;
                         if (location.kind === 303 || (ts.isModuleDeclaration(location) && location.flags & 8388608 && !ts.isGlobalScopeAugmentation(location))) {
                             if (result = moduleExports.get("default")) {
                                 var localSymbol = ts.getLocalSymbolForExportDefault(result);
@@ -38864,7 +39333,7 @@ var ts;
                             }
                         }
                         if (name !== "default" && (result = lookup(moduleExports, name, meaning & 2623475))) {
-                            if (ts.isSourceFile(location) && location.commonJsModuleIndicator && !((_a = result.declarations) === null || _a === void 0 ? void 0 : _a.some(ts.isJSDocTypeAlias))) {
+                            if (ts.isSourceFile(location) && location.commonJsModuleIndicator && !((_b = result.declarations) === null || _b === void 0 ? void 0 : _b.some(ts.isJSDocTypeAlias))) {
                                 result = undefined;
                             }
                             else {
@@ -38873,7 +39342,7 @@ var ts;
                         }
                         break;
                     case 259:
-                        if (result = lookup(getSymbolOfNode(location).exports, name, meaning & 8)) {
+                        if (result = lookup(((_c = getSymbolOfNode(location)) === null || _c === void 0 ? void 0 : _c.exports) || emptySymbols, name, meaning & 8)) {
                             break loop;
                         }
                         break;
@@ -38930,7 +39399,7 @@ var ts;
                         }
                         break;
                     case 213:
-                        if (compilerOptions.target >= 2) {
+                        if (ts.getEmitScriptTarget(compilerOptions) >= 2) {
                             break;
                         }
                     case 168:
@@ -39072,7 +39541,7 @@ var ts;
                 return undefined;
             }
             if (nameNotFoundMessage) {
-                if (propertyWithInvalidInitializer && !(compilerOptions.target === 99 && useDefineForClassFields)) {
+                if (propertyWithInvalidInitializer && !(ts.getEmitScriptTarget(compilerOptions) === 99 && useDefineForClassFields)) {
                     var propertyName = propertyWithInvalidInitializer.name;
                     error(errorLocation, ts.Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, ts.declarationNameToString(propertyName), diagnosticName(nameArg));
                     return undefined;
@@ -39569,7 +40038,7 @@ var ts;
             if (!ts.isIdentifier(name)) {
                 return undefined;
             }
-            var suppressInteropError = name.escapedText === "default" && !!(compilerOptions.allowSyntheticDefaultImports || compilerOptions.esModuleInterop);
+            var suppressInteropError = name.escapedText === "default" && !!(compilerOptions.allowSyntheticDefaultImports || ts.getESModuleInterop(compilerOptions));
             var targetSymbol = resolveESModuleSymbol(moduleSymbol, moduleSpecifier, false, suppressInteropError);
             if (targetSymbol) {
                 if (name.escapedText) {
@@ -39645,18 +40114,18 @@ var ts;
         }
         function reportInvalidImportEqualsExportMember(node, name, declarationName, moduleName) {
             if (moduleKind >= ts.ModuleKind.ES2015) {
-                var message = compilerOptions.esModuleInterop ? ts.Diagnostics._0_can_only_be_imported_by_using_a_default_import :
+                var message = ts.getESModuleInterop(compilerOptions) ? ts.Diagnostics._0_can_only_be_imported_by_using_a_default_import :
                     ts.Diagnostics._0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import;
                 error(name, message, declarationName);
             }
             else {
                 if (ts.isInJSFile(node)) {
-                    var message = compilerOptions.esModuleInterop ? ts.Diagnostics._0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import :
+                    var message = ts.getESModuleInterop(compilerOptions) ? ts.Diagnostics._0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import :
                         ts.Diagnostics._0_can_only_be_imported_by_using_a_require_call_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import;
                     error(name, message, declarationName);
                 }
                 else {
-                    var message = compilerOptions.esModuleInterop ? ts.Diagnostics._0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import :
+                    var message = ts.getESModuleInterop(compilerOptions) ? ts.Diagnostics._0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import :
                         ts.Diagnostics._0_can_only_be_imported_by_using_import_1_require_2_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import;
                     error(name, message, declarationName, declarationName, moduleName);
                 }
@@ -40034,6 +40503,7 @@ var ts;
                 : undefined;
         }
         function resolveExternalModule(location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation) {
+            var _a, _b, _c, _d, _e, _f;
             if (isForAugmentation === void 0) { isForAugmentation = false; }
             if (ts.startsWith(moduleReference, "@types/")) {
                 var diag = ts.Diagnostics.Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1;
@@ -40045,7 +40515,15 @@ var ts;
                 return ambientModule;
             }
             var currentSourceFile = ts.getSourceFileOfNode(location);
-            var resolvedModule = ts.getResolvedModule(currentSourceFile, moduleReference);
+            var contextSpecifier = ts.isStringLiteralLike(location)
+                ? location
+                : ((_a = ts.findAncestor(location, ts.isImportCall)) === null || _a === void 0 ? void 0 : _a.arguments[0]) ||
+                    ((_b = ts.findAncestor(location, ts.isImportDeclaration)) === null || _b === void 0 ? void 0 : _b.moduleSpecifier) ||
+                    ((_c = ts.findAncestor(location, ts.isExternalModuleImportEqualsDeclaration)) === null || _c === void 0 ? void 0 : _c.moduleReference.expression) ||
+                    ((_d = ts.findAncestor(location, ts.isExportDeclaration)) === null || _d === void 0 ? void 0 : _d.moduleSpecifier) ||
+                    ((_e = (ts.isModuleDeclaration(location) ? location : location.parent && ts.isModuleDeclaration(location.parent) && location.parent.name === location ? location.parent : undefined)) === null || _e === void 0 ? void 0 : _e.name) ||
+                    ((_f = (ts.isLiteralImportTypeNode(location) ? location : undefined)) === null || _f === void 0 ? void 0 : _f.argument.literal);
+            var resolvedModule = ts.getResolvedModule(currentSourceFile, moduleReference, contextSpecifier && ts.isStringLiteralLike(contextSpecifier) ? ts.getModeForUsageLocation(currentSourceFile, contextSpecifier) : undefined);
             var resolutionDiagnostic = resolvedModule && ts.getResolutionDiagnostic(compilerOptions, resolvedModule);
             var sourceFile = resolvedModule && !resolutionDiagnostic && host.getSourceFile(resolvedModule.resolvedFileName);
             if (sourceFile) {
@@ -40053,6 +40531,12 @@ var ts;
                     if (resolvedModule.isExternalLibraryImport && !ts.resolutionExtensionIsTSOrJson(resolvedModule.extension)) {
                         errorOnImplicitAnyModule(false, errorNode, resolvedModule, moduleReference);
                     }
+                    if (ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Node12 || ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeNext) {
+                        var isSyncImport = (currentSourceFile.impliedNodeFormat === ts.ModuleKind.CommonJS && !ts.findAncestor(location, ts.isImportCall)) || !!ts.findAncestor(location, ts.isImportEqualsDeclaration);
+                        if (isSyncImport && sourceFile.impliedNodeFormat === ts.ModuleKind.ESNext) {
+                            error(errorNode, ts.Diagnostics.Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_synchronously_Use_dynamic_import_instead, moduleReference);
+                        }
+                    }
                     return getMergedSymbol(sourceFile.symbol);
                 }
                 if (moduleNotFoundError) {
@@ -40097,15 +40581,14 @@ var ts;
                         var diag = ts.Diagnostics.An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead;
                         var importSourceWithoutExtension = ts.removeExtension(moduleReference, tsExtension);
                         var replacedImportSource = importSourceWithoutExtension;
-                        var moduleKind_1 = ts.getEmitModuleKind(compilerOptions);
-                        if (moduleKind_1 >= ts.ModuleKind.ES2015) {
-                            replacedImportSource += ".js";
+                        if (moduleKind >= ts.ModuleKind.ES2015) {
+                            replacedImportSource += tsExtension === ".mts" ? ".mjs" : tsExtension === ".cts" ? ".cjs" : ".js";
                         }
                         error(errorNode, diag, tsExtension, replacedImportSource);
                     }
                     else if (!compilerOptions.resolveJsonModule &&
                         ts.fileExtensionIs(moduleReference, ".json") &&
-                        ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs &&
+                        ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Classic &&
                         ts.hasJsonModuleEmitEnabled(compilerOptions)) {
                         error(errorNode, ts.Diagnostics.Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension, moduleReference);
                     }
@@ -40172,7 +40655,7 @@ var ts;
                     error(referencingLocation, ts.Diagnostics.This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export, compilerOptionName);
                     return symbol;
                 }
-                if (compilerOptions.esModuleInterop) {
+                if (ts.getESModuleInterop(compilerOptions)) {
                     var referenceParent = referencingLocation.parent;
                     if ((ts.isImportDeclaration(referenceParent) && ts.getNamespaceDeclarationNode(referenceParent)) ||
                         ts.isImportCall(referenceParent)) {
@@ -40942,7 +41425,7 @@ var ts;
             var typeNode = nodeBuilder.typeToTypeNode(type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 | (noTruncation ? 1 : 0), writer);
             if (typeNode === undefined)
                 return ts.Debug.fail("should always get typenode");
-            var options = { removeComments: true };
+            var options = { removeComments: type !== unresolvedType };
             var printer = ts.createPrinter(options);
             var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration);
             printer.writeNode(4, typeNode, sourceFile, writer);
@@ -41021,6 +41504,7 @@ var ts;
                             isSourceOfProjectReferenceRedirect: function (fileName) { return host.isSourceOfProjectReferenceRedirect(fileName); },
                             fileExists: function (fileName) { return host.fileExists(fileName); },
                             getFileIncludeReasons: function () { return host.getFileIncludeReasons(); },
+                            readFile: host.readFile ? (function (fileName) { return host.readFile(fileName); }) : undefined,
                         } : undefined },
                     encounteredError: false,
                     reportedDiagnostic: false,
@@ -41086,6 +41570,12 @@ var ts;
                     type = getReducedType(type);
                 }
                 if (type.flags & 1) {
+                    if (type.aliasSymbol) {
+                        return ts.factory.createTypeReferenceNode(symbolToEntityNameNode(type.aliasSymbol), mapToTypeNodes(type.aliasTypeArguments, context));
+                    }
+                    if (type === unresolvedType) {
+                        return ts.addSyntheticLeadingComment(ts.factory.createKeywordTypeNode(130), 3, "unresolved");
+                    }
                     context.approximateLength += 3;
                     return ts.factory.createKeywordTypeNode(type === intrinsicMarkerType ? 138 : 130);
                 }
@@ -42101,6 +42591,10 @@ var ts;
                 }
                 return specifier;
             }
+            function symbolToEntityNameNode(symbol) {
+                var identifier = ts.factory.createIdentifier(ts.unescapeLeadingUnderscores(symbol.escapedName));
+                return symbol.parent ? ts.factory.createQualifiedName(symbolToEntityNameNode(symbol.parent), identifier) : identifier;
+            }
             function symbolToTypeNode(symbol, context, meaning, overrideTypeArguments) {
                 var chain = lookupSymbolChain(symbol, context, meaning, !(context.flags & 16384));
                 var isTypeOf = meaning === 111551;
@@ -42108,7 +42602,7 @@ var ts;
                     var nonRootParts = chain.length > 1 ? createAccessFromSymbolChain(chain, chain.length - 1, 1) : undefined;
                     var typeParameterNodes = overrideTypeArguments || lookupTypeParameterNodes(chain, 0, context);
                     var specifier = getSpecifierForModuleSymbol(chain[0], context);
-                    if (!(context.flags & 67108864) && ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs && specifier.indexOf("/node_modules/") >= 0) {
+                    if (!(context.flags & 67108864) && ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Classic && specifier.indexOf("/node_modules/") >= 0) {
                         context.encounteredError = true;
                         if (context.tracker.reportLikelyUnsafeImportRequiredError) {
                             context.tracker.reportLikelyUnsafeImportRequiredError(specifier);
@@ -42325,7 +42819,7 @@ var ts;
                 if (nameType) {
                     if (nameType.flags & 384) {
                         var name = "" + nameType.value;
-                        if (!ts.isIdentifierText(name, compilerOptions.target) && !isNumericLiteralName(name)) {
+                        if (!ts.isIdentifierText(name, ts.getEmitScriptTarget(compilerOptions)) && !isNumericLiteralName(name)) {
                             return ts.factory.createStringLiteral(name, !!singleQuote);
                         }
                         if (isNumericLiteralName(name) && ts.startsWith(name, "-")) {
@@ -42339,7 +42833,7 @@ var ts;
                 }
             }
             function createPropertyNameNodeForIdentifierOrLiteral(name, stringNamed, singleQuote) {
-                return ts.isIdentifierText(name, compilerOptions.target) ? ts.factory.createIdentifier(name) :
+                return ts.isIdentifierText(name, ts.getEmitScriptTarget(compilerOptions)) ? ts.factory.createIdentifier(name) :
                     !stringNamed && isNumericLiteralName(name) && +name >= 0 ? ts.factory.createNumericLiteral(+name) :
                         ts.factory.createStringLiteral(name, !!singleQuote);
             }
@@ -42364,7 +42858,7 @@ var ts;
                 return !(ts.getObjectFlags(type) & 4) || !ts.isTypeReferenceNode(existing) || ts.length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
             }
             function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled) {
-                if (type !== errorType && enclosingDeclaration) {
+                if (!isErrorType(type) && enclosingDeclaration) {
                     var declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration);
                     if (declWithExistingAnnotation && !ts.isFunctionLikeDeclaration(declWithExistingAnnotation) && !ts.isGetAccessorDeclaration(declWithExistingAnnotation)) {
                         var existing = ts.getEffectiveTypeAnnotationNode(declWithExistingAnnotation);
@@ -42386,7 +42880,7 @@ var ts;
                 return result;
             }
             function serializeReturnTypeForSignature(context, type, signature, includePrivateSymbol, bundled) {
-                if (type !== errorType && context.enclosingDeclaration) {
+                if (!isErrorType(type) && context.enclosingDeclaration) {
                     var annotation = signature.declaration && ts.getEffectiveReturnTypeNode(signature.declaration);
                     if (!!ts.findAncestor(annotation, function (n) { return n === context.enclosingDeclaration; }) && annotation) {
                         var annotated = getTypeFromTypeNode(annotation);
@@ -42479,7 +42973,7 @@ var ts;
                             return ts.factory.createFunctionTypeNode(ts.visitNodes(node.typeParameters, visitExistingNodeTreeSymbols), ts.map(node.parameters, function (p, i) { return ts.factory.createParameterDeclaration(undefined, undefined, getEffectiveDotDotDotForParameter(p), getNameForJSDocFunctionParameter(p, i), p.questionToken, ts.visitNode(p.type, visitExistingNodeTreeSymbols), undefined); }), ts.visitNode(node.type, visitExistingNodeTreeSymbols) || ts.factory.createKeywordTypeNode(130));
                         }
                     }
-                    if (ts.isTypeReferenceNode(node) && ts.isInJSDoc(node) && (!existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(node, getTypeFromTypeNode(node)) || getIntendedTypeFromJSDocTypeReference(node) || unknownSymbol === resolveTypeReferenceName(getTypeReferenceName(node), 788968, true))) {
+                    if (ts.isTypeReferenceNode(node) && ts.isInJSDoc(node) && (!existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(node, getTypeFromTypeNode(node)) || getIntendedTypeFromJSDocTypeReference(node) || unknownSymbol === resolveTypeReferenceName(node, 788968, true))) {
                         return ts.setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
                     }
                     if (ts.isLiteralImportTypeNode(node)) {
@@ -43081,6 +43575,26 @@ var ts;
                     context.enclosingDeclaration = oldEnclosing;
                     addResult(ts.setTextRange(ts.factory.createClassDeclaration(undefined, undefined, localName, typeParamDecls, heritageClauses, __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], indexSignatures, true), staticMembers, true), constructors, true), publicProperties, true), privateProperties, true)), symbol.declarations && ts.filter(symbol.declarations, function (d) { return ts.isClassDeclaration(d) || ts.isClassExpression(d); })[0]), modifierFlags);
                 }
+                function getSomeTargetNameFromDeclarations(declarations) {
+                    return ts.firstDefined(declarations, function (d) {
+                        if (ts.isImportSpecifier(d) || ts.isExportSpecifier(d)) {
+                            return ts.idText(d.propertyName || d.name);
+                        }
+                        if (ts.isBinaryExpression(d) || ts.isExportAssignment(d)) {
+                            var expression = ts.isExportAssignment(d) ? d.expression : d.right;
+                            if (ts.isPropertyAccessExpression(expression)) {
+                                return ts.idText(expression.name);
+                            }
+                        }
+                        if (isAliasSymbolDeclaration(d)) {
+                            var name = ts.getNameOfDeclaration(d);
+                            if (name && ts.isIdentifier(name)) {
+                                return ts.idText(name);
+                            }
+                        }
+                        return undefined;
+                    });
+                }
                 function serializeAsAlias(symbol, localName, modifierFlags) {
                     var _a, _b, _c, _d, _e;
                     var node = getDeclarationOfAliasSymbol(symbol);
@@ -43090,8 +43604,8 @@ var ts;
                     if (!target) {
                         return;
                     }
-                    var verbatimTargetName = ts.unescapeLeadingUnderscores(target.escapedName);
-                    if (verbatimTargetName === "export=" && (compilerOptions.esModuleInterop || compilerOptions.allowSyntheticDefaultImports)) {
+                    var verbatimTargetName = ts.isShorthandAmbientModuleSymbol(target) && getSomeTargetNameFromDeclarations(symbol.declarations) || ts.unescapeLeadingUnderscores(target.escapedName);
+                    if (verbatimTargetName === "export=" && (ts.getESModuleInterop(compilerOptions) || compilerOptions.allowSyntheticDefaultImports)) {
                         verbatimTargetName = "default";
                     }
                     var targetName = getInternalSymbolName(target, verbatimTargetName);
@@ -43518,7 +44032,7 @@ var ts;
             if (nameType) {
                 if (nameType.flags & 384) {
                     var name = "" + nameType.value;
-                    if (!ts.isIdentifierText(name, compilerOptions.target) && !isNumericLiteralName(name)) {
+                    if (!ts.isIdentifierText(name, ts.getEmitScriptTarget(compilerOptions)) && !isNumericLiteralName(name)) {
                         return "\"" + ts.escapeString(name, 34) + "\"";
                     }
                     if (isNumericLiteralName(name) && ts.startsWith(name, "-")) {
@@ -43774,6 +44288,9 @@ var ts;
         function isTypeAny(type) {
             return type && (type.flags & 1) !== 0;
         }
+        function isErrorType(type) {
+            return type === errorType || !!(type.flags & 1 && type.aliasSymbol);
+        }
         function getTypeForBindingElementParent(node) {
             var symbol = getSymbolOfNode(node);
             return symbol && getSymbolLinks(symbol).type || getTypeForVariableLikeDeclaration(node, false);
@@ -44230,7 +44747,7 @@ var ts;
                 if (!declaredType) {
                     return type;
                 }
-                else if (declaredType !== errorType && type !== errorType && !isTypeIdenticalTo(declaredType, type)) {
+                else if (!isErrorType(declaredType) && !isErrorType(type) && !isTypeIdenticalTo(declaredType, type)) {
                     errorNextVariableOrPropertyDeclarationMustHaveSameType(undefined, declaredType, declaration, type);
                 }
             }
@@ -45023,7 +45540,7 @@ var ts;
                     for (var _b = 0, implementsTypeNodes_1 = implementsTypeNodes; _b < implementsTypeNodes_1.length; _b++) {
                         var node = implementsTypeNodes_1[_b];
                         var implementsType = getTypeFromTypeNode(node);
-                        if (implementsType !== errorType) {
+                        if (!isErrorType(implementsType)) {
                             if (resolvedImplementsTypes === ts.emptyArray) {
                                 resolvedImplementsTypes = [implementsType];
                             }
@@ -45097,7 +45614,7 @@ var ts;
                 }
                 baseType = getReturnTypeOfSignature(constructors[0]);
             }
-            if (baseType === errorType) {
+            if (isErrorType(baseType)) {
                 return type.resolvedBaseTypes = ts.emptyArray;
             }
             var reducedBaseType = getReducedType(baseType);
@@ -45144,7 +45661,7 @@ var ts;
                         for (var _b = 0, _c = ts.getInterfaceBaseTypeNodes(declaration); _b < _c.length; _b++) {
                             var node = _c[_b];
                             var baseType = getReducedType(getTypeFromTypeNode(node));
-                            if (baseType !== errorType) {
+                            if (!isErrorType(baseType)) {
                                 if (isValidBaseType(baseType)) {
                                     if (type !== baseType && !hasBaseType(baseType, type)) {
                                         if (type.resolvedBaseTypes === ts.emptyArray) {
@@ -46722,7 +47239,7 @@ var ts;
             for (var _i = 0, _c = containingType.types; _i < _c.length; _i++) {
                 var current = _c[_i];
                 var type = getApparentType(current);
-                if (!(type === errorType || type.flags & 131072)) {
+                if (!(isErrorType(type) || type.flags & 131072)) {
                     var prop = getPropertyOfType(type, name, skipObjectFunctionPropertyAugment);
                     var modifiers = prop ? ts.getDeclarationModifierFlagsFromSymbol(prop) : 0;
                     if (prop) {
@@ -47557,7 +48074,7 @@ var ts;
                     }
                     else {
                         var type = getTypeFromTypeNode(constraintDeclaration);
-                        if (type.flags & 1 && type !== errorType) {
+                        if (type.flags & 1 && !isErrorType(type)) {
                             type = constraintDeclaration.parent.parent.kind === 194 ? keyofConstraintType : unknownType;
                         }
                         typeParameter.constraint = type;
@@ -47711,6 +48228,18 @@ var ts;
             return instantiation;
         }
         function getTypeFromTypeAliasReference(node, symbol) {
+            if (ts.getCheckFlags(symbol) & 1048576) {
+                var typeArguments = typeArgumentsFromTypeReferenceNode(node);
+                var id = getAliasId(symbol, typeArguments);
+                var errorType_1 = errorTypes.get(id);
+                if (!errorType_1) {
+                    errorType_1 = createIntrinsicType(1, "error");
+                    errorType_1.aliasSymbol = symbol;
+                    errorType_1.aliasTypeArguments = typeArguments;
+                    errorTypes.set(id, errorType_1);
+                }
+                return errorType_1;
+            }
             var type = getDeclaredTypeOfSymbol(symbol);
             var typeParameters = getSymbolLinks(symbol).typeParameters;
             if (typeParameters) {
@@ -47745,11 +48274,37 @@ var ts;
             }
             return undefined;
         }
-        function resolveTypeReferenceName(typeReferenceName, meaning, ignoreErrors) {
-            if (!typeReferenceName) {
+        function getSymbolPath(symbol) {
+            return symbol.parent ? getSymbolPath(symbol.parent) + "." + symbol.escapedName : symbol.escapedName;
+        }
+        function getUnresolvedSymbolForEntityName(name) {
+            var identifier = name.kind === 160 ? name.right :
+                name.kind === 205 ? name.name :
+                    name;
+            var text = identifier.escapedText;
+            if (text) {
+                var parentSymbol = name.kind === 160 ? getUnresolvedSymbolForEntityName(name.left) :
+                    name.kind === 205 ? getUnresolvedSymbolForEntityName(name.expression) :
+                        undefined;
+                var path = parentSymbol ? getSymbolPath(parentSymbol) + "." + text : text;
+                var result = unresolvedSymbols.get(path);
+                if (!result) {
+                    unresolvedSymbols.set(path, result = createSymbol(524288, text, 1048576));
+                    result.parent = parentSymbol;
+                    result.declaredType = unresolvedType;
+                }
+                return result;
+            }
+            return unknownSymbol;
+        }
+        function resolveTypeReferenceName(typeReference, meaning, ignoreErrors) {
+            var name = getTypeReferenceName(typeReference);
+            if (!name) {
                 return unknownSymbol;
             }
-            return resolveEntityName(typeReferenceName, meaning, ignoreErrors) || unknownSymbol;
+            var symbol = resolveEntityName(name, meaning, ignoreErrors);
+            return symbol && symbol !== unknownSymbol ? symbol :
+                ignoreErrors ? unknownSymbol : getUnresolvedSymbolForEntityName(name);
         }
         function getTypeReferenceType(node, symbol) {
             if (symbol === unknownSymbol) {
@@ -47772,7 +48327,7 @@ var ts;
                     return jsdocType;
                 }
                 else {
-                    resolveTypeReferenceName(getTypeReferenceName(node), 788968);
+                    resolveTypeReferenceName(node, 788968);
                     return getTypeOfSymbol(symbol);
                 }
             }
@@ -47906,18 +48461,18 @@ var ts;
                 if (isJSDocTypeReference(node)) {
                     type = getIntendedTypeFromJSDocTypeReference(node);
                     if (!type) {
-                        symbol = resolveTypeReferenceName(getTypeReferenceName(node), meaning, true);
+                        symbol = resolveTypeReferenceName(node, meaning, true);
                         if (symbol === unknownSymbol) {
-                            symbol = resolveTypeReferenceName(getTypeReferenceName(node), meaning | 111551);
+                            symbol = resolveTypeReferenceName(node, meaning | 111551);
                         }
                         else {
-                            resolveTypeReferenceName(getTypeReferenceName(node), meaning);
+                            resolveTypeReferenceName(node, meaning);
                         }
                         type = getTypeReferenceType(node, symbol);
                     }
                 }
                 if (!type) {
-                    symbol = resolveTypeReferenceName(getTypeReferenceName(node), meaning);
+                    symbol = resolveTypeReferenceName(node, meaning);
                     type = getTypeReferenceType(node, symbol);
                 }
                 links.resolvedSymbol = symbol;
@@ -48152,7 +48707,7 @@ var ts;
         function mayResolveTypeAlias(node) {
             switch (node.kind) {
                 case 177:
-                    return isJSDocTypeReference(node) || !!(resolveTypeReferenceName(node.typeName, 788968).flags & 524288);
+                    return isJSDocTypeReference(node) || !!(resolveTypeReferenceName(node, 788968).flags & 524288);
                 case 180:
                     return true;
                 case 192:
@@ -48402,8 +48957,6 @@ var ts;
             }
             if (!(flags & 131072)) {
                 includes |= flags & 205258751;
-                if (flags & 469499904)
-                    includes |= 262144;
                 if (type === wildcardType)
                     includes |= 8388608;
                 if (!strictNullChecks && flags & 98304) {
@@ -48685,11 +49238,17 @@ var ts;
                     if (type === wildcardType)
                         includes |= 8388608;
                 }
-                else if ((strictNullChecks || !(flags & 98304)) && !typeSet.has(type.id.toString())) {
-                    if (type.flags & 109440 && includes & 109440) {
-                        includes |= 67108864;
+                else if (strictNullChecks || !(flags & 98304)) {
+                    if (exactOptionalPropertyTypes && type === missingType) {
+                        includes |= 262144;
+                        type = undefinedType;
+                    }
+                    if (!typeSet.has(type.id.toString())) {
+                        if (type.flags & 109440 && includes & 109440) {
+                            includes |= 67108864;
+                        }
+                        typeSet.set(type.id.toString(), type);
                     }
-                    typeSet.set(type.id.toString(), type);
                 }
                 includes |= flags & 205258751;
             }
@@ -48753,14 +49312,13 @@ var ts;
             }
             return false;
         }
-        function extractIrreducible(types, flag) {
-            if (ts.every(types, function (t) { return !!(t.flags & 1048576) && ts.some(t.types, function (tt) { return !!(tt.flags & flag); }); })) {
-                for (var i = 0; i < types.length; i++) {
-                    types[i] = filterType(types[i], function (t) { return !(t.flags & flag); });
-                }
-                return true;
+        function eachIsUnionContaining(types, flag) {
+            return ts.every(types, function (t) { return !!(t.flags & 1048576) && ts.some(t.types, function (tt) { return !!(tt.flags & flag); }); });
+        }
+        function removeFromEach(types, flag) {
+            for (var i = 0; i < types.length; i++) {
+                types[i] = filterType(types[i], function (t) { return !(t.flags & flag); });
             }
-            return false;
         }
         function intersectUnionsOfPrimitiveTypes(types) {
             var unionTypes;
@@ -48840,6 +49398,9 @@ var ts;
             if (includes & 16777216 && includes & 524288) {
                 ts.orderedRemoveItemAt(typeSet, ts.findIndex(typeSet, isEmptyAnonymousObjectType));
             }
+            if (includes & 262144) {
+                typeSet[typeSet.indexOf(undefinedType)] = missingType;
+            }
             if (typeSet.length === 0) {
                 return unknownType;
             }
@@ -48853,10 +49414,13 @@ var ts;
                     if (intersectUnionsOfPrimitiveTypes(typeSet)) {
                         result = getIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
                     }
-                    else if (extractIrreducible(typeSet, 32768)) {
-                        result = getUnionType([getIntersectionType(typeSet), undefinedType], 1, aliasSymbol, aliasTypeArguments);
+                    else if (eachIsUnionContaining(typeSet, 32768)) {
+                        var undefinedOrMissingType = exactOptionalPropertyTypes && ts.some(typeSet, function (t) { return containsType(t.types, missingType); }) ? missingType : undefinedType;
+                        removeFromEach(typeSet, 32768);
+                        result = getUnionType([getIntersectionType(typeSet), undefinedOrMissingType], 1, aliasSymbol, aliasTypeArguments);
                     }
-                    else if (extractIrreducible(typeSet, 65536)) {
+                    else if (eachIsUnionContaining(typeSet, 65536)) {
+                        removeFromEach(typeSet, 65536);
                         result = getUnionType([getIntersectionType(typeSet), nullType], 1, aliasSymbol, aliasTypeArguments);
                     }
                     else {
@@ -50419,7 +50983,7 @@ var ts;
                 var mappedTypeVariable = instantiateType(typeVariable, mapper);
                 if (typeVariable !== mappedTypeVariable) {
                     return mapTypeWithAlias(getReducedType(mappedTypeVariable), function (t) {
-                        if (t.flags & (3 | 58982400 | 524288 | 2097152) && t !== wildcardType && t !== errorType) {
+                        if (t.flags & (3 | 58982400 | 524288 | 2097152) && t !== wildcardType && !isErrorType(t)) {
                             if (!type.declaration.nameType) {
                                 if (isArrayType(t)) {
                                     return instantiateMappedArrayType(t, type, prependTypeMapping(typeVariable, t, mapper));
@@ -50455,7 +51019,7 @@ var ts;
         }
         function instantiateMappedArrayType(arrayType, mappedType, mapper) {
             var elementType = instantiateMappedTypeTemplate(mappedType, numberType, true, mapper);
-            return elementType === errorType ? errorType :
+            return isErrorType(elementType) ? errorType :
                 createArrayType(elementType, getModifiedReadonlyState(isReadonlyArrayType(arrayType), getMappedTypeModifiers(mappedType)));
         }
         function instantiateMappedTupleType(tupleType, mappedType, mapper) {
@@ -51557,7 +52121,7 @@ var ts;
                             if (path.length === 0) {
                                 path = "" + str;
                             }
-                            else if (ts.isIdentifierText(str, compilerOptions.target)) {
+                            else if (ts.isIdentifierText(str, ts.getEmitScriptTarget(compilerOptions))) {
                                 path = path + "." + str;
                             }
                             else if (str[0] === "[" && str[str.length - 1] === "]") {
@@ -51844,7 +52408,7 @@ var ts;
                             var targetTypes = target.types;
                             var intrinsicAttributes = getJsxType(JsxNames.IntrinsicAttributes, errorNode);
                             var intrinsicClassAttributes = getJsxType(JsxNames.IntrinsicClassAttributes, errorNode);
-                            if (intrinsicAttributes !== errorType && intrinsicClassAttributes !== errorType &&
+                            if (!isErrorType(intrinsicAttributes) && !isErrorType(intrinsicClassAttributes) &&
                                 (ts.contains(targetTypes, intrinsicAttributes) || ts.contains(targetTypes, intrinsicClassAttributes))) {
                                 return result;
                             }
@@ -56646,6 +57210,9 @@ var ts;
                     case 102:
                         return narrowTypeByInstanceof(type, expr, assumeTrue);
                     case 101:
+                        if (ts.isPrivateIdentifier(expr.left)) {
+                            return narrowTypeByPrivateIdentifierInInExpression(type, expr, assumeTrue);
+                        }
                         var target = getReferenceCandidate(expr.right);
                         var leftType = getTypeOfNode(expr.left);
                         if (leftType.flags & 128) {
@@ -56672,6 +57239,22 @@ var ts;
                 }
                 return type;
             }
+            function narrowTypeByPrivateIdentifierInInExpression(type, expr, assumeTrue) {
+                var target = getReferenceCandidate(expr.right);
+                if (!isMatchingReference(reference, target)) {
+                    return type;
+                }
+                ts.Debug.assertNode(expr.left, ts.isPrivateIdentifier);
+                var symbol = getSymbolForPrivateIdentifierExpression(expr.left);
+                if (symbol === undefined) {
+                    return type;
+                }
+                var classSymbol = symbol.parent;
+                var targetType = ts.hasStaticModifier(ts.Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration"))
+                    ? getTypeOfSymbol(classSymbol)
+                    : getDeclaredTypeOfSymbol(classSymbol);
+                return getNarrowedType(type, targetType, assumeTrue, isTypeDerivedFrom);
+            }
             function narrowTypeByOptionalChainContainment(type, operator, value, assumeTrue) {
                 var equalsOperator = operator === 34 || operator === 36;
                 var nullableFlags = operator === 34 || operator === 35 ? 98304 : 32768;
@@ -58323,7 +58906,7 @@ var ts;
             var propsType = getTypeOfFirstParameterOfSignatureWithFallback(sig, unknownType);
             propsType = getJsxManagedAttributesFromLocatedAttributes(context, getJsxNamespaceAt(context), propsType);
             var intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context);
-            if (intrinsicAttribs !== errorType) {
+            if (!isErrorType(intrinsicAttribs)) {
                 propsType = intersectTypes(intrinsicAttribs, propsType);
             }
             return propsType;
@@ -58405,7 +58988,7 @@ var ts;
             else {
                 var apparentAttributesType = attributesType;
                 var intrinsicClassAttribs = getJsxType(JsxNames.IntrinsicClassAttributes, context);
-                if (intrinsicClassAttribs !== errorType) {
+                if (!isErrorType(intrinsicClassAttribs)) {
                     var typeParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(intrinsicClassAttribs.symbol);
                     var hostClassType = getReturnTypeOfSignature(sig);
                     apparentAttributesType = intersectTypes(typeParams
@@ -58413,7 +58996,7 @@ var ts;
                         : intrinsicClassAttribs, apparentAttributesType);
                 }
                 var intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context);
-                if (intrinsicAttribs !== errorType) {
+                if (!isErrorType(intrinsicAttribs)) {
                     apparentAttributesType = intersectTypes(intrinsicAttribs, apparentAttributesType);
                 }
                 return apparentAttributesType;
@@ -58809,7 +59392,7 @@ var ts;
                             checkSpreadPropOverrides(mergedType, allPropertiesTable, memberDecl);
                         }
                         offset = propertiesArray.length;
-                        if (spread === errorType) {
+                        if (isErrorType(spread)) {
                             continue;
                         }
                         spread = getSpreadType(spread, mergedType, node.symbol, objectFlags, inConstContext);
@@ -58857,7 +59440,7 @@ var ts;
                     }
                 }
             }
-            if (spread === errorType) {
+            if (isErrorType(spread)) {
                 return errorType;
             }
             if (spread !== emptyObjectType) {
@@ -59082,7 +59665,7 @@ var ts;
             var links = getNodeLinks(node);
             if (!links.resolvedSymbol) {
                 var intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements, node);
-                if (intrinsicElementsType !== errorType) {
+                if (!isErrorType(intrinsicElementsType)) {
                     if (!ts.isIdentifier(node.tagName))
                         return ts.Debug.fail();
                     var intrinsicProp = getPropertyOfType(intrinsicElementsType, node.tagName.escapedText);
@@ -59214,7 +59797,7 @@ var ts;
         }
         function getIntrinsicAttributesTypeFromStringLiteralType(type, location) {
             var intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements, location);
-            if (intrinsicElementsType !== errorType) {
+            if (!isErrorType(intrinsicElementsType)) {
                 var stringLiteralTypeName = type.value;
                 var intrinsicProp = getPropertyOfType(intrinsicElementsType, ts.escapeLeadingUnderscores(stringLiteralTypeName));
                 if (intrinsicProp) {
@@ -59275,7 +59858,7 @@ var ts;
         }
         function getJsxElementClassTypeAt(location) {
             var type = getJsxType(JsxNames.ElementClass, location);
-            if (type === errorType)
+            if (isErrorType(type))
                 return undefined;
             return type;
         }
@@ -59508,7 +60091,7 @@ var ts;
         }
         function checkNonNullNonVoidType(type, node) {
             var nonNullType = checkNonNullType(type, node);
-            if (nonNullType !== errorType && nonNullType.flags & 16384) {
+            if (nonNullType.flags & 16384) {
                 error(node, ts.Diagnostics.Object_is_possibly_undefined);
             }
             return nonNullType;
@@ -59542,6 +60125,36 @@ var ts;
                 }
             }
         }
+        function checkGrammarPrivateIdentifierExpression(privId) {
+            if (!ts.getContainingClass(privId)) {
+                return grammarErrorOnNode(privId, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
+            }
+            if (!ts.isExpressionNode(privId)) {
+                return grammarErrorOnNode(privId, ts.Diagnostics.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression);
+            }
+            if (!getSymbolForPrivateIdentifierExpression(privId)) {
+                return grammarErrorOnNode(privId, ts.Diagnostics.Cannot_find_name_0, ts.idText(privId));
+            }
+            return false;
+        }
+        function checkPrivateIdentifierExpression(privId) {
+            checkGrammarPrivateIdentifierExpression(privId);
+            var symbol = getSymbolForPrivateIdentifierExpression(privId);
+            if (symbol) {
+                markPropertyAsReferenced(symbol, undefined, false);
+            }
+            return anyType;
+        }
+        function getSymbolForPrivateIdentifierExpression(privId) {
+            if (!ts.isExpressionNode(privId)) {
+                return undefined;
+            }
+            var links = getNodeLinks(privId);
+            if (links.resolvedSymbol === undefined) {
+                links.resolvedSymbol = lookupSymbolForPrivateIdentifierDeclaration(privId.escapedText, privId);
+            }
+            return links.resolvedSymbol;
+        }
         function getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedIdentifier) {
             return getPropertyOfType(leftType, lexicallyScopedIdentifier.escapedName);
         }
@@ -59599,7 +60212,7 @@ var ts;
                 if (assignmentKind && lexicallyScopedSymbol && lexicallyScopedSymbol.valueDeclaration && ts.isMethodDeclaration(lexicallyScopedSymbol.valueDeclaration)) {
                     grammarErrorOnNode(right, ts.Diagnostics.Cannot_assign_to_private_method_0_Private_methods_are_not_writable, ts.idText(right));
                 }
-                if ((lexicallyScopedSymbol === null || lexicallyScopedSymbol === void 0 ? void 0 : lexicallyScopedSymbol.valueDeclaration) && (compilerOptions.target === 99 && !useDefineForClassFields)) {
+                if ((lexicallyScopedSymbol === null || lexicallyScopedSymbol === void 0 ? void 0 : lexicallyScopedSymbol.valueDeclaration) && (ts.getEmitScriptTarget(compilerOptions) === 99 && !useDefineForClassFields)) {
                     var lexicalClass_1 = ts.getContainingClass(lexicallyScopedSymbol.valueDeclaration);
                     var parentStaticFieldInitializer = ts.findAncestor(node, function (n) {
                         if (n === lexicalClass_1)
@@ -59618,7 +60231,7 @@ var ts;
                 }
                 if (isAnyLike) {
                     if (lexicallyScopedSymbol) {
-                        return apparentType;
+                        return isErrorType(apparentType) ? errorType : apparentType;
                     }
                     if (!ts.getContainingClass(right)) {
                         grammarErrorOnNode(right, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
@@ -59641,7 +60254,8 @@ var ts;
                     if (ts.isIdentifier(left) && parentSymbol) {
                         markAliasReferenced(parentSymbol, node);
                     }
-                    return apparentType;
+                    return isErrorType(apparentType) ? errorType : apparentType;
+                    ;
                 }
                 prop = getPropertyOfType(apparentType, right.escapedText);
             }
@@ -60044,14 +60658,14 @@ var ts;
             return isPropertyAccessible(node, node.kind === 205 && node.expression.kind === 106, false, type, property);
         }
         function isValidPropertyAccessWithType(node, isSuper, propertyName, type) {
-            if (type === errorType || isTypeAny(type)) {
+            if (isTypeAny(type)) {
                 return true;
             }
             var prop = getPropertyOfType(type, propertyName);
             return !!prop && isPropertyAccessible(node, isSuper, false, type, prop);
         }
         function isPropertyAccessible(node, isSuper, isWrite, containingType, property) {
-            if (containingType === errorType || isTypeAny(containingType)) {
+            if (isTypeAny(containingType)) {
                 return true;
             }
             if (property.valueDeclaration && ts.isPrivateIdentifierClassElementDeclaration(property.valueDeclaration)) {
@@ -60110,7 +60724,7 @@ var ts;
             var objectType = ts.getAssignmentTargetKind(node) !== 0 || isMethodAccessForCall(node) ? getWidenedType(exprType) : exprType;
             var indexExpression = node.argumentExpression;
             var indexType = checkExpression(indexExpression);
-            if (objectType === errorType || objectType === silentNeverType) {
+            if (isErrorType(objectType) || objectType === silentNeverType) {
                 return objectType;
             }
             if (isConstEnumObjectType(objectType) && !ts.isStringLiteralLike(indexExpression)) {
@@ -60315,7 +60929,7 @@ var ts;
                 return inferJsxTypeArguments(node, signature, checkMode, context);
             }
             if (node.kind !== 164) {
-                var contextualType = getContextualType(node, 8);
+                var contextualType = getContextualType(node, ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); }) ? 8 : 0);
                 if (contextualType) {
                     var outerContext = getInferenceContext(node);
                     var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1));
@@ -61121,7 +61735,7 @@ var ts;
                     }
                     return anySignature;
                 }
-                if (superType !== errorType) {
+                if (!isErrorType(superType)) {
                     var baseTypeNode = ts.getEffectiveBaseTypeNode(ts.getContainingClass(node));
                     if (baseTypeNode) {
                         var baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments, baseTypeNode);
@@ -61147,13 +61761,13 @@ var ts;
                 return silentNeverSignature;
             }
             var apparentType = getApparentType(funcType);
-            if (apparentType === errorType) {
+            if (isErrorType(apparentType)) {
                 return resolveErrorCall(node);
             }
             var callSignatures = getSignaturesOfType(apparentType, 0);
             var numConstructSignatures = getSignaturesOfType(apparentType, 1).length;
             if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, numConstructSignatures)) {
-                if (funcType !== errorType && node.typeArguments) {
+                if (!isErrorType(funcType) && node.typeArguments) {
                     error(node, ts.Diagnostics.Untyped_function_calls_may_not_accept_type_arguments);
                 }
                 return resolveUntypedCall(node);
@@ -61203,7 +61817,7 @@ var ts;
                 return silentNeverSignature;
             }
             expressionType = getApparentType(expressionType);
-            if (expressionType === errorType) {
+            if (isErrorType(expressionType)) {
                 return resolveErrorCall(node);
             }
             if (isTypeAny(expressionType)) {
@@ -61392,7 +62006,7 @@ var ts;
         function resolveTaggedTemplateExpression(node, candidatesOutArray, checkMode) {
             var tagType = checkExpression(node.tag);
             var apparentType = getApparentType(tagType);
-            if (apparentType === errorType) {
+            if (isErrorType(apparentType)) {
                 return resolveErrorCall(node);
             }
             var callSignatures = getSignaturesOfType(apparentType, 0);
@@ -61431,7 +62045,7 @@ var ts;
         function resolveDecorator(node, candidatesOutArray, checkMode) {
             var funcType = checkExpression(node.expression);
             var apparentType = getApparentType(funcType);
-            if (apparentType === errorType) {
+            if (isErrorType(apparentType)) {
                 return resolveErrorCall(node);
             }
             var callSignatures = getSignaturesOfType(apparentType, 0);
@@ -61481,7 +62095,7 @@ var ts;
             }
             var exprTypes = checkExpression(node.tagName);
             var apparentType = getApparentType(exprTypes);
-            if (apparentType === errorType) {
+            if (isErrorType(apparentType)) {
                 return resolveErrorCall(node);
             }
             var signatures = getUninstantiatedJsxSignaturesOfType(exprTypes, node);
@@ -61761,7 +62375,7 @@ var ts;
         }
         function getTypeWithSyntheticDefaultImportType(type, symbol, originalSymbol) {
             var _a;
-            if (allowSyntheticDefaultImports && type && type !== errorType) {
+            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);
@@ -61821,6 +62435,12 @@ var ts;
             return getReturnTypeOfSignature(signature);
         }
         function checkAssertion(node) {
+            if (node.kind === 210) {
+                var file = ts.getSourceFileOfNode(node);
+                if (file && ts.fileExtensionIsOneOf(file.fileName, [".cts", ".mts"])) {
+                    grammarErrorOnNode(node, ts.Diagnostics.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead);
+                }
+            }
             return checkAssertionWorker(node, node.type, node.expression);
         }
         function isValidConstAssertionArgument(node) {
@@ -61864,7 +62484,7 @@ var ts;
             checkSourceElement(type);
             exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(exprType));
             var targetType = getTypeFromTypeNode(type);
-            if (produceDiagnostics && targetType !== errorType) {
+            if (produceDiagnostics && !isErrorType(targetType)) {
                 var widenedType = getWidenedType(exprType);
                 if (!isTypeComparableTo(targetType, widenedType)) {
                     checkTypeComparableTo(exprType, targetType, errNode, ts.Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first);
@@ -61897,7 +62517,7 @@ var ts;
                     return getGlobalImportMetaExpressionType();
                 case 103:
                     var type = checkNewTargetMetaProperty(node);
-                    return type === errorType ? errorType : createNewTargetExpressionType(type);
+                    return isErrorType(type) ? errorType : createNewTargetExpressionType(type);
                 default:
                     ts.Debug.assertNever(node.keywordToken);
             }
@@ -61919,7 +62539,14 @@ var ts;
         }
         function checkImportMetaProperty(node) {
             if (moduleKind !== ts.ModuleKind.ES2020 && moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.System) {
-                error(node, ts.Diagnostics.The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_esnext_or_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);
+                }
             }
             var file = ts.getSourceFileOfNode(node);
             ts.Debug.assert(!!(file.flags & 2097152), "Containing file is missing import meta node flag.");
@@ -62746,9 +63373,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) || languageVersion < 4) {
+                            if ((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_or_system_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_esnext_system_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher);
                                 diagnostics.add(diagnostic);
                             }
                         }
@@ -62772,7 +63399,7 @@ var ts;
             }
             var operandType = checkExpression(node.expression);
             var awaitedType = checkAwaitedType(operandType, true, node, ts.Diagnostics.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
-            if (awaitedType === operandType && awaitedType !== errorType && !(operandType.flags & 3)) {
+            if (awaitedType === operandType && !isErrorType(awaitedType) && !(operandType.flags & 3)) {
                 addErrorOrSuggestion(false, ts.createDiagnosticForNode(node, ts.Diagnostics.await_has_no_effect_on_the_type_of_this_expression));
             }
             return awaitedType;
@@ -62910,12 +63537,23 @@ var ts;
             if (leftType === silentNeverType || rightType === silentNeverType) {
                 return silentNeverType;
             }
-            leftType = checkNonNullType(leftType, left);
-            rightType = checkNonNullType(rightType, right);
-            if (!(allTypesAssignableToKind(leftType, 402653316 | 296 | 12288) ||
-                isTypeAssignableToKind(leftType, 4194304 | 134217728 | 268435456 | 262144))) {
-                error(left, ts.Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol);
+            if (ts.isPrivateIdentifier(left)) {
+                if (languageVersion < 99) {
+                    checkExternalEmitHelpers(left, 2097152);
+                }
+                if (!getNodeLinks(left).resolvedSymbol && ts.getContainingClass(left)) {
+                    var isUncheckedJS = isUncheckedJSSuggestion(left, rightType.symbol, true);
+                    reportNonexistentProperty(left, rightType, isUncheckedJS);
+                }
+            }
+            else {
+                leftType = checkNonNullType(leftType, left);
+                if (!(allTypesAssignableToKind(leftType, 402653316 | 296 | 12288) ||
+                    isTypeAssignableToKind(leftType, 4194304 | 134217728 | 268435456 | 262144))) {
+                    error(left, ts.Diagnostics.The_left_hand_side_of_an_in_expression_must_be_a_private_identifier_or_of_type_any_string_number_or_symbol);
+                }
             }
+            rightType = checkNonNullType(rightType, right);
             var rightTypeConstraint = getConstraintOfType(rightType);
             if (!allTypesAssignableToKind(rightType, 67108864 | 58982400) ||
                 rightTypeConstraint && (isTypeAssignableToKind(rightType, 3145728) && !allTypesAssignableToKind(rightTypeConstraint, 67108864 | 58982400) ||
@@ -63344,7 +63982,7 @@ var ts;
                         resultType = stringType;
                     }
                     else if (isTypeAny(leftType) || isTypeAny(rightType)) {
-                        resultType = leftType === errorType || rightType === errorType ? errorType : anyType;
+                        resultType = isErrorType(leftType) || isErrorType(rightType) ? errorType : anyType;
                     }
                     if (resultType && !checkForDisallowedESSymbolOperand(operator)) {
                         return resultType;
@@ -64035,6 +64673,8 @@ var ts;
             switch (kind) {
                 case 79:
                     return checkIdentifier(node, checkMode);
+                case 80:
+                    return checkPrivateIdentifierExpression(node);
                 case 108:
                     return checkThisExpression(node);
                 case 106:
@@ -64563,7 +65203,7 @@ var ts;
                     if (classExtendsNull) {
                         error(superCall, ts.Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null);
                     }
-                    var superCallShouldBeFirst = (compilerOptions.target !== 99 || !useDefineForClassFields) &&
+                    var superCallShouldBeFirst = (ts.getEmitScriptTarget(compilerOptions) !== 99 || !useDefineForClassFields) &&
                         (ts.some(node.parent.members, isInstancePropertyWithInitializerOrPrivateIdentifierProperty) ||
                             ts.some(node.parameters, function (p) { return ts.hasSyntacticModifier(p, 16476); }));
                     if (superCallShouldBeFirst) {
@@ -64661,7 +65301,7 @@ var ts;
         }
         function getTypeParametersForTypeReference(node) {
             var type = getTypeFromTypeReference(node);
-            if (type !== errorType) {
+            if (!isErrorType(type)) {
                 var symbol = getNodeLinks(node).resolvedSymbol;
                 if (symbol) {
                     return symbol.flags & 524288 && getSymbolLinks(symbol).typeParameters ||
@@ -64677,7 +65317,7 @@ var ts;
             }
             ts.forEach(node.typeArguments, checkSourceElement);
             var type = getTypeFromTypeReference(node);
-            if (type !== errorType) {
+            if (!isErrorType(type)) {
                 if (node.typeArguments && produceDiagnostics) {
                     var typeParameters = getTypeParametersForTypeReference(node);
                     if (typeParameters) {
@@ -65302,7 +65942,7 @@ var ts;
         function checkAsyncFunctionReturnType(node, returnTypeNode) {
             var returnType = getTypeFromTypeNode(returnTypeNode);
             if (languageVersion >= 2) {
-                if (returnType === errorType) {
+                if (isErrorType(returnType)) {
                     return;
                 }
                 var globalPromiseType = getGlobalPromiseType(true);
@@ -65313,7 +65953,7 @@ var ts;
             }
             else {
                 markTypeNodeAsReferenced(returnTypeNode);
-                if (returnType === errorType) {
+                if (isErrorType(returnType)) {
                     return;
                 }
                 var promiseConstructorName = ts.getEntityNameFromTypeNode(returnTypeNode);
@@ -65323,7 +65963,7 @@ var ts;
                 }
                 var promiseConstructorSymbol = resolveEntityName(promiseConstructorName, 111551, true);
                 var promiseConstructorType = promiseConstructorSymbol ? getTypeOfSymbol(promiseConstructorSymbol) : errorType;
-                if (promiseConstructorType === errorType) {
+                if (isErrorType(promiseConstructorType)) {
                     if (promiseConstructorName.kind === 79 && promiseConstructorName.escapedText === "Promise" && getTargetType(returnType) === getGlobalPromiseType(false)) {
                         error(returnTypeNode, ts.Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option);
                     }
@@ -66010,7 +66650,7 @@ var ts;
             });
         }
         function checkCollisionWithRequireExportsInGeneratedCode(node, name) {
-            if (moduleKind >= ts.ModuleKind.ES2015) {
+            if (moduleKind >= ts.ModuleKind.ES2015 && !(moduleKind >= ts.ModuleKind.Node12 && ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.CommonJS)) {
                 return;
             }
             if (!name || !needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) {
@@ -66232,7 +66872,7 @@ var ts;
             }
             else {
                 var declarationType = convertAutoToAny(getWidenedTypeForVariableLikeDeclaration(node));
-                if (type !== errorType && declarationType !== errorType &&
+                if (!isErrorType(type) && !isErrorType(declarationType) &&
                     !isTypeIdenticalTo(type, declarationType) &&
                     !(symbol.flags & 67108864)) {
                     errorNextVariableOrPropertyDeclarationMustHaveSameType(symbol.valueDeclaration, type, node, declarationType);
@@ -67235,8 +67875,8 @@ var ts;
             }
         }
         function checkClassNameCollisionWithObject(name) {
-            if (languageVersion === 1 && name.escapedText === "Object"
-                && moduleKind < ts.ModuleKind.ES2015) {
+            if (languageVersion >= 1 && name.escapedText === "Object"
+                && (moduleKind < ts.ModuleKind.ES2015 || ts.getSourceFileOfNode(name).impliedNodeFormat === ts.ModuleKind.CommonJS)) {
                 error(name, ts.Diagnostics.Class_name_cannot_be_Object_when_targeting_ES5_with_module_0, ts.ModuleKind[moduleKind]);
             }
         }
@@ -67432,7 +68072,7 @@ var ts;
                     checkTypeReferenceNode(typeRefNode);
                     if (produceDiagnostics) {
                         var t = getReducedType(getTypeFromTypeNode(typeRefNode));
-                        if (t !== errorType) {
+                        if (!isErrorType(t)) {
                             if (isValidBaseType(t)) {
                                 var genericDiag = t.symbol && t.symbol.flags & 32 ?
                                     ts.Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass :
@@ -68293,8 +68933,8 @@ var ts;
             checkAliasSymbol(node);
             if (node.kind === 269 &&
                 ts.idText(node.propertyName || node.name) === "default" &&
-                compilerOptions.esModuleInterop &&
-                moduleKind !== ts.ModuleKind.System && moduleKind < ts.ModuleKind.ES2015) {
+                ts.getESModuleInterop(compilerOptions) &&
+                moduleKind !== ts.ModuleKind.System && (moduleKind < ts.ModuleKind.ES2015 || ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.CommonJS)) {
                 checkExternalEmitHelpers(node, 131072);
             }
         }
@@ -68325,7 +68965,7 @@ var ts;
                     if (importClause.namedBindings) {
                         if (importClause.namedBindings.kind === 267) {
                             checkImportBinding(importClause.namedBindings);
-                            if (moduleKind !== ts.ModuleKind.System && moduleKind < ts.ModuleKind.ES2015 && compilerOptions.esModuleInterop) {
+                            if (moduleKind !== ts.ModuleKind.System && (moduleKind < ts.ModuleKind.ES2015 || ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.CommonJS) && ts.getESModuleInterop(compilerOptions)) {
                                 checkExternalEmitHelpers(node, 65536);
                             }
                         }
@@ -68368,7 +69008,7 @@ var ts;
                     }
                 }
                 else {
-                    if (moduleKind >= ts.ModuleKind.ES2015 && !node.isTypeOnly && !(node.flags & 8388608)) {
+                    if (moduleKind >= ts.ModuleKind.ES2015 && ts.getSourceFileOfNode(node).impliedNodeFormat === undefined && !node.isTypeOnly && !(node.flags & 8388608)) {
                         grammarErrorOnNode(node, ts.Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead);
                     }
                 }
@@ -68382,7 +69022,7 @@ var ts;
                 grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers);
             }
             if (node.moduleSpecifier && node.exportClause && ts.isNamedExports(node.exportClause) && ts.length(node.exportClause.elements) && languageVersion === 0) {
-                checkExternalEmitHelpers(node, 2097152);
+                checkExternalEmitHelpers(node, 4194304);
             }
             checkGrammarExportDeclaration(node);
             if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) {
@@ -68403,9 +69043,9 @@ var ts;
                     else if (node.exportClause) {
                         checkAliasSymbol(node.exportClause);
                     }
-                    if (moduleKind !== ts.ModuleKind.System && moduleKind < ts.ModuleKind.ES2015) {
+                    if (moduleKind !== ts.ModuleKind.System && (moduleKind < ts.ModuleKind.ES2015 || ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.CommonJS)) {
                         if (node.exportClause) {
-                            if (compilerOptions.esModuleInterop) {
+                            if (ts.getESModuleInterop(compilerOptions)) {
                                 checkExternalEmitHelpers(node, 65536);
                             }
                         }
@@ -68486,9 +69126,9 @@ var ts;
                 }
             }
             else {
-                if (compilerOptions.esModuleInterop &&
+                if (ts.getESModuleInterop(compilerOptions) &&
                     moduleKind !== ts.ModuleKind.System &&
-                    moduleKind < ts.ModuleKind.ES2015 &&
+                    (moduleKind < ts.ModuleKind.ES2015 || ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.CommonJS) &&
                     ts.idText(node.propertyName || node.name) === "default") {
                     checkExternalEmitHelpers(node, 131072);
                 }
@@ -68543,7 +69183,7 @@ var ts;
                 grammarErrorOnNode(node.expression, ts.Diagnostics.The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context);
             }
             if (node.isExportEquals && !(node.flags & 8388608)) {
-                if (moduleKind >= ts.ModuleKind.ES2015) {
+                if (moduleKind >= ts.ModuleKind.ES2015 && ts.getSourceFileOfNode(node).impliedNodeFormat !== ts.ModuleKind.CommonJS) {
                     grammarErrorOnNode(node, ts.Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead);
                 }
                 else if (moduleKind === ts.ModuleKind.System) {
@@ -69262,6 +69902,9 @@ var ts;
                     }
                     return result;
                 }
+                else if (ts.isPrivateIdentifier(name)) {
+                    return getSymbolForPrivateIdentifierExpression(name);
+                }
                 else if (name.kind === 205 || name.kind === 160) {
                     var links = getNodeLinks(name);
                     if (links.resolvedSymbol) {
@@ -69284,7 +69927,8 @@ var ts;
             }
             else if (isTypeReferenceIdentifier(name)) {
                 var meaning = name.parent.kind === 177 ? 788968 : 1920;
-                return resolveEntityName(name, meaning, false, true);
+                var symbol = resolveEntityName(name, meaning, false, true);
+                return symbol && symbol !== unknownSymbol ? symbol : getUnresolvedSymbolForEntityName(name);
             }
             if (name.parent.kind === 176) {
                 return resolveEntityName(name, 1);
@@ -69486,7 +70130,7 @@ var ts;
                 var symbol = getSymbolAtLocation(node);
                 if (symbol) {
                     var declaredType = getDeclaredTypeOfSymbol(symbol);
-                    return declaredType !== errorType ? declaredType : getTypeOfSymbol(symbol);
+                    return !isErrorType(declaredType) ? declaredType : getTypeOfSymbol(symbol);
                 }
             }
             if (ts.isMetaProperty(node.parent) && node.parent.keywordToken === node.kind) {
@@ -69894,7 +70538,7 @@ var ts;
                 return isTypeOnly ? ts.TypeReferenceSerializationKind.ObjectType : ts.TypeReferenceSerializationKind.Unknown;
             }
             var type = getDeclaredTypeOfSymbol(typeSymbol);
-            if (type === errorType) {
+            if (isErrorType(type)) {
                 return isTypeOnly ? ts.TypeReferenceSerializationKind.ObjectType : ts.TypeReferenceSerializationKind.Unknown;
             }
             else if (type.flags & 3) {
@@ -70362,7 +71006,7 @@ var ts;
                     var helpersModule = resolveHelpersModule(sourceFile, location);
                     if (helpersModule !== unknownSymbol) {
                         var uncheckedHelpers = helpers & ~requestedExternalEmitHelpers;
-                        for (var helper = 1; helper <= 2097152; helper <<= 1) {
+                        for (var helper = 1; helper <= 4194304; helper <<= 1) {
                             if (uncheckedHelpers & helper) {
                                 var name = getHelperName(helper);
                                 var symbol = getSymbol(helpersModule.exports, ts.escapeLeadingUnderscores(name), 111551);
@@ -70414,7 +71058,8 @@ var ts;
                 case 262144: return "__makeTemplateObject";
                 case 524288: return "__classPrivateFieldGet";
                 case 1048576: return "__classPrivateFieldSet";
-                case 2097152: return "__createBinding";
+                case 2097152: return "__classPrivateFieldIn";
+                case 4194304: return "__createBinding";
                 default: return ts.Debug.fail("Unrecognized helper");
             }
         }
@@ -70838,6 +71483,11 @@ var ts;
             if (!ts.isArrowFunction(node)) {
                 return false;
             }
+            if (node.typeParameters && !(ts.length(node.typeParameters) > 1 || node.typeParameters.hasTrailingComma || node.typeParameters[0].constraint)) {
+                if (file && ts.fileExtensionIsOneOf(file.fileName, [".mts", ".cts"])) {
+                    grammarErrorOnNode(node.typeParameters[0], ts.Diagnostics.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_constraint);
+                }
+            }
             var equalsGreaterThanToken = node.equalsGreaterThanToken;
             var startLine = ts.getLineAndCharacterOfPosition(file, equalsGreaterThanToken.pos).line;
             var endLine = ts.getLineAndCharacterOfPosition(file, equalsGreaterThanToken.end).line;
@@ -71150,8 +71800,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) || 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_or_system_and_the_target_option_is_set_to_es2017_or_higher));
+                            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));
                             }
                         }
                     }
@@ -71468,8 +72118,7 @@ var ts;
                         : ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context;
                 return grammarErrorOnNode(node.exclamationToken, message);
             }
-            var moduleKind = ts.getEmitModuleKind(compilerOptions);
-            if (moduleKind < ts.ModuleKind.ES2015 && moduleKind !== ts.ModuleKind.System &&
+            if ((moduleKind < ts.ModuleKind.ES2015 || ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.CommonJS) && moduleKind !== ts.ModuleKind.System &&
                 !(node.parent.parent.flags & 8388608) && ts.hasSyntacticModifier(node.parent.parent, 1)) {
                 checkESModuleMarker(node.name);
             }
@@ -71766,7 +72415,7 @@ var ts;
         }
         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_or_umd);
+                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);
             }
             if (node.typeArguments) {
                 return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_import_cannot_have_type_arguments);
@@ -75532,7 +76181,7 @@ var ts;
         function transformSourceFile(node) {
             var options = context.getCompilerOptions();
             if (node.isDeclarationFile
-                || useDefineForClassFields && options.target === 99) {
+                || useDefineForClassFields && ts.getEmitScriptTarget(options) === 99) {
                 return node;
             }
             var visited = ts.visitEachChild(node, visitor, context);
@@ -75622,8 +76271,25 @@ var ts;
             if (!shouldTransformPrivateElementsOrClassStaticBlocks) {
                 return node;
             }
+            if (ts.isStatement(node.parent)) {
+                return node;
+            }
             return ts.setOriginalNode(factory.createIdentifier(""), node);
         }
+        function visitPrivateIdentifierInInExpression(node) {
+            if (!shouldTransformPrivateElementsOrClassStaticBlocks) {
+                return node;
+            }
+            var privId = node.left;
+            ts.Debug.assertNode(privId, ts.isPrivateIdentifier);
+            ts.Debug.assert(node.operatorToken.kind === 101);
+            var info = accessPrivateIdentifier(privId);
+            if (info) {
+                var receiver = ts.visitNode(node.right, visitor, ts.isExpression);
+                return ts.setOriginalNode(context.getEmitHelperFactory().createClassPrivateFieldInHelper(info.brandCheckIdentifier, receiver), node);
+            }
+            return ts.visitEachChild(node, visitor, context);
+        }
         function classElementVisitor(node) {
             switch (node.kind) {
                 case 170:
@@ -75966,6 +76632,9 @@ var ts;
                     }
                 }
             }
+            if (node.operatorToken.kind === 101 && ts.isPrivateIdentifier(node.left)) {
+                return visitPrivateIdentifierInInExpression(node);
+            }
             return ts.visitEachChild(node, visitor, context);
         }
         function createPrivateIdentifierAssignment(info, receiver, right, operator) {
@@ -78398,7 +79067,7 @@ var ts;
                 objectProperties = factory.createNull();
             }
             else {
-                var target = compilerOptions.target;
+                var target = ts.getEmitScriptTarget(compilerOptions);
                 if (target && target >= 5) {
                     objectProperties = factory.createObjectLiteralExpression(ts.flatten(ts.spanMap(attrs, ts.isJsxSpreadAttribute, function (attrs, isSpread) {
                         return isSpread ? ts.map(attrs, transformJsxSpreadAttributeToSpreadAssignment) : ts.map(attrs, transformJsxAttributeToObjectLiteralElement);
@@ -78547,7 +79216,8 @@ var ts;
             }
         }
         function visitJsxExpression(node) {
-            return ts.visitNode(node.expression, visitor, ts.isExpression);
+            var expression = ts.visitNode(node.expression, visitor, ts.isExpression);
+            return node.dotDotDotToken ? factory.createSpreadElement(expression) : expression;
         }
     }
     ts.transformJsx = transformJsx;
@@ -82823,7 +83493,7 @@ var ts;
                 case 348:
                     return visitPartiallyEmittedExpression(node, valueIsDiscarded);
                 case 207:
-                    if (ts.isImportCall(node)) {
+                    if (ts.isImportCall(node) && currentSourceFile.impliedNodeFormat === undefined) {
                         return visitImportCallExpression(node);
                     }
                     break;
@@ -82994,7 +83664,7 @@ var ts;
                 }
             }
             var promise = factory.createNewExpression(factory.createIdentifier("Promise"), undefined, [func]);
-            if (compilerOptions.esModuleInterop) {
+            if (ts.getESModuleInterop(compilerOptions)) {
                 return factory.createCallExpression(factory.createPropertyAccessExpression(promise, factory.createIdentifier("then")), undefined, [emitHelpers().createImportStarCallbackHelper()]);
             }
             return promise;
@@ -83002,7 +83672,7 @@ var ts;
         function createImportCallExpressionCommonJS(arg, containsLexicalThis) {
             var promiseResolveCall = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Promise"), "resolve"), undefined, []);
             var requireCall = factory.createCallExpression(factory.createIdentifier("require"), undefined, arg ? [arg] : []);
-            if (compilerOptions.esModuleInterop) {
+            if (ts.getESModuleInterop(compilerOptions)) {
                 requireCall = emitHelpers().createImportStarHelper(requireCall);
             }
             var func;
@@ -83018,7 +83688,7 @@ var ts;
             return factory.createCallExpression(factory.createPropertyAccessExpression(promiseResolveCall, "then"), undefined, [func]);
         }
         function getHelperExpressionForExport(node, innerExpr) {
-            if (!compilerOptions.esModuleInterop || ts.getEmitFlags(node) & 67108864) {
+            if (!ts.getESModuleInterop(compilerOptions) || ts.getEmitFlags(node) & 67108864) {
                 return innerExpr;
             }
             if (ts.getExportNeedsImportStarHelper(node)) {
@@ -83027,7 +83697,7 @@ var ts;
             return innerExpr;
         }
         function getHelperExpressionForImport(node, innerExpr) {
-            if (!compilerOptions.esModuleInterop || ts.getEmitFlags(node) & 67108864) {
+            if (!ts.getESModuleInterop(compilerOptions) || ts.getEmitFlags(node) & 67108864) {
                 return innerExpr;
             }
             if (ts.getImportNeedsImportStarHelper(node)) {
@@ -83126,7 +83796,7 @@ var ts;
                         statements.push(ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(emitHelpers().createCreateBindingHelper(generatedName, factory.createStringLiteralFromNode(specifier.propertyName || specifier.name), specifier.propertyName ? factory.createStringLiteralFromNode(specifier.name) : undefined)), specifier), specifier));
                     }
                     else {
-                        var exportNeedsImportDefault = !!compilerOptions.esModuleInterop &&
+                        var exportNeedsImportDefault = !!ts.getESModuleInterop(compilerOptions) &&
                             !(ts.getEmitFlags(node) & 67108864) &&
                             ts.idText(specifier.propertyName || specifier.name) === "default";
                         var exportedValue = factory.createPropertyAccessExpression(exportNeedsImportDefault ? emitHelpers().createImportDefaultHelper(generatedName) : generatedName, specifier.propertyName || specifier.name);
@@ -84469,7 +85139,10 @@ var ts;
 (function (ts) {
     function transformECMAScriptModule(context) {
         var factory = context.factory, emitHelpers = context.getEmitHelperFactory;
+        var host = context.getEmitHost();
+        var resolver = context.getEmitResolver();
         var compilerOptions = context.getCompilerOptions();
+        var languageVersion = ts.getEmitScriptTarget(compilerOptions);
         var previousOnEmitNode = context.onEmitNode;
         var previousOnSubstituteNode = context.onSubstituteNode;
         context.onEmitNode = onEmitNode;
@@ -84477,13 +85150,21 @@ var ts;
         context.enableEmitNotification(303);
         context.enableSubstitution(79);
         var helperNameSubstitutions;
+        var currentSourceFile;
+        var importRequireStatements;
         return ts.chainBundle(context, transformSourceFile);
         function transformSourceFile(node) {
             if (node.isDeclarationFile) {
                 return node;
             }
             if (ts.isExternalModule(node) || compilerOptions.isolatedModules) {
+                currentSourceFile = node;
+                importRequireStatements = undefined;
                 var result = updateExternalModule(node);
+                currentSourceFile = undefined;
+                if (importRequireStatements) {
+                    result = factory.updateSourceFile(result, ts.setTextRange(factory.createNodeArray(ts.insertStatementsAfterCustomPrologue(result.statements.slice(), importRequireStatements)), result.statements));
+                }
                 if (!ts.isExternalModule(node) || ts.some(result.statements, ts.isExternalModuleIndicator)) {
                     return result;
                 }
@@ -84507,7 +85188,7 @@ var ts;
         function visitor(node) {
             switch (node.kind) {
                 case 264:
-                    return undefined;
+                    return ts.getEmitScriptTarget(compilerOptions) >= ts.ModuleKind.ES2020 ? visitImportEqualsDeclaration(node) : undefined;
                 case 270:
                     return visitExportAssignment(node);
                 case 271:
@@ -84516,6 +85197,44 @@ var ts;
             }
             return node;
         }
+        function createRequireCall(importNode) {
+            var moduleName = ts.getExternalModuleNameLiteral(factory, importNode, ts.Debug.checkDefined(currentSourceFile), host, resolver, compilerOptions);
+            var args = [];
+            if (moduleName) {
+                args.push(moduleName);
+            }
+            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.createStringLiteral("module"));
+                var requireHelperName = factory.createUniqueName("__require", 16 | 32);
+                var requireStatement = factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+                    factory.createVariableDeclaration(requireHelperName, undefined, undefined, factory.createCallExpression(factory.cloneNode(createRequireName), undefined, [
+                        factory.createPropertyAccessExpression(factory.createMetaProperty(100, factory.createIdentifier("meta")), factory.createIdentifier("url"))
+                    ]))
+                ], languageVersion >= 2 ? 2 : 0));
+                importRequireStatements = [importStatement, requireStatement];
+            }
+            var name = importRequireStatements[1].declarationList.declarations[0].name;
+            ts.Debug.assertNode(name, ts.isIdentifier);
+            return factory.createCallExpression(factory.cloneNode(name), undefined, args);
+        }
+        function visitImportEqualsDeclaration(node) {
+            ts.Debug.assert(ts.isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer.");
+            var statements;
+            statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(factory.createVariableStatement(undefined, factory.createVariableDeclarationList([
+                factory.createVariableDeclaration(factory.cloneNode(node.name), undefined, undefined, createRequireCall(node))
+            ], languageVersion >= 2 ? 2 : 0)), node), node));
+            statements = appendExportsOfImportEqualsDeclaration(statements, node);
+            return ts.singleOrMany(statements);
+        }
+        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))])));
+            }
+            return statements;
+        }
         function visitExportAssignment(node) {
             return node.isExportEquals ? undefined : node;
         }
@@ -84565,6 +85284,74 @@ var ts;
     ts.transformECMAScriptModule = transformECMAScriptModule;
 })(ts || (ts = {}));
 var ts;
+(function (ts) {
+    function transformNodeModule(context) {
+        var previousOnSubstituteNode = context.onSubstituteNode;
+        var previousOnEmitNode = context.onEmitNode;
+        var esmTransform = ts.transformECMAScriptModule(context);
+        var esmOnSubstituteNode = context.onSubstituteNode;
+        var esmOnEmitNode = context.onEmitNode;
+        context.onSubstituteNode = previousOnSubstituteNode;
+        context.onEmitNode = previousOnEmitNode;
+        var cjsTransform = ts.transformModule(context);
+        var cjsOnSubstituteNode = context.onSubstituteNode;
+        var cjsOnEmitNode = context.onEmitNode;
+        context.onSubstituteNode = onSubstituteNode;
+        context.onEmitNode = onEmitNode;
+        context.enableSubstitution(303);
+        context.enableEmitNotification(303);
+        var currentSourceFile;
+        return transformSourceFileOrBundle;
+        function onSubstituteNode(hint, node) {
+            if (ts.isSourceFile(node)) {
+                currentSourceFile = node;
+                return previousOnSubstituteNode(hint, node);
+            }
+            else {
+                if (!currentSourceFile) {
+                    return previousOnSubstituteNode(hint, node);
+                }
+                if (currentSourceFile.impliedNodeFormat === ts.ModuleKind.ESNext) {
+                    return esmOnSubstituteNode(hint, node);
+                }
+                return cjsOnSubstituteNode(hint, node);
+            }
+        }
+        function onEmitNode(hint, node, emitCallback) {
+            if (ts.isSourceFile(node)) {
+                currentSourceFile = node;
+            }
+            if (!currentSourceFile) {
+                return previousOnEmitNode(hint, node, emitCallback);
+            }
+            if (currentSourceFile.impliedNodeFormat === ts.ModuleKind.ESNext) {
+                return esmOnEmitNode(hint, node, emitCallback);
+            }
+            return cjsOnEmitNode(hint, node, emitCallback);
+        }
+        function getModuleTransformForFile(file) {
+            return file.impliedNodeFormat === ts.ModuleKind.ESNext ? esmTransform : cjsTransform;
+        }
+        function transformSourceFile(node) {
+            if (node.isDeclarationFile) {
+                return node;
+            }
+            currentSourceFile = node;
+            var result = getModuleTransformForFile(node)(node);
+            currentSourceFile = undefined;
+            ts.Debug.assert(ts.isSourceFile(result));
+            return result;
+        }
+        function transformSourceFileOrBundle(node) {
+            return node.kind === 303 ? transformSourceFile(node) : transformBundle(node);
+        }
+        function transformBundle(node) {
+            return context.factory.createBundle(ts.map(node.sourceFiles, transformSourceFile), node.prepends);
+        }
+    }
+    ts.transformNodeModule = transformNodeModule;
+})(ts || (ts = {}));
+var ts;
 (function (ts) {
     function canProduceDiagnostics(node) {
         return ts.isVariableDeclaration(node) ||
@@ -86218,6 +87005,9 @@ var ts;
                 return ts.transformECMAScriptModule;
             case ts.ModuleKind.System:
                 return ts.transformSystemModule;
+            case ts.ModuleKind.Node12:
+            case ts.ModuleKind.NodeNext:
+                return ts.transformNodeModule;
             default:
                 return ts.transformModule;
         }
@@ -86714,7 +87504,7 @@ var ts;
             return getOutputPathsForBundle(options, forceDtsPaths);
         }
         else {
-            var ownOutputFilePath = ts.getOwnEmitOutputFilePath(sourceFile.fileName, host, getOutputExtension(sourceFile, options));
+            var ownOutputFilePath = ts.getOwnEmitOutputFilePath(sourceFile.fileName, host, getOutputExtension(sourceFile.fileName, options));
             var isJsonFile = ts.isJsonSourceFile(sourceFile);
             var isJsonEmittedToSameLocation = isJsonFile &&
                 ts.comparePaths(sourceFile.fileName, ownOutputFilePath, host.getCurrentDirectory(), !host.useCaseSensitiveFileNames()) === 0;
@@ -86729,21 +87519,12 @@ var ts;
     function getSourceMapFilePath(jsFilePath, options) {
         return (options.sourceMap && !options.inlineSourceMap) ? jsFilePath + ".map" : undefined;
     }
-    function getOutputExtension(sourceFile, options) {
-        if (ts.isJsonSourceFile(sourceFile)) {
-            return ".json";
-        }
-        if (options.jsx === 1) {
-            if (ts.isSourceFileJS(sourceFile)) {
-                if (ts.fileExtensionIs(sourceFile.fileName, ".jsx")) {
-                    return ".jsx";
-                }
-            }
-            else if (sourceFile.languageVariant === 1) {
-                return ".jsx";
-            }
-        }
-        return ".js";
+    function getOutputExtension(fileName, options) {
+        return ts.fileExtensionIs(fileName, ".json") ? ".json" :
+            options.jsx === 1 && ts.fileExtensionIsOneOf(fileName, [".jsx", ".tsx"]) ? ".jsx" :
+                ts.fileExtensionIsOneOf(fileName, [".mts", ".mjs"]) ? ".mjs" :
+                    ts.fileExtensionIsOneOf(fileName, [".cts", ".cjs"]) ? ".cjs" :
+                        ".js";
     }
     ts.getOutputExtension = getOutputExtension;
     function getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, outputDir, getCommonSourceDirectory) {
@@ -86752,19 +87533,14 @@ var ts;
             inputFileName;
     }
     function getOutputDeclarationFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory) {
-        ts.Debug.assert(!ts.fileExtensionIs(inputFileName, ".d.ts") && !ts.fileExtensionIs(inputFileName, ".json"));
-        return ts.changeExtension(getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.declarationDir || configFile.options.outDir, getCommonSourceDirectory), ".d.ts");
+        return ts.changeExtension(getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.declarationDir || configFile.options.outDir, getCommonSourceDirectory), ts.getDeclarationEmitExtensionForPath(inputFileName));
     }
     ts.getOutputDeclarationFileName = getOutputDeclarationFileName;
     function getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory) {
         if (configFile.options.emitDeclarationOnly)
             return undefined;
         var isJsonFile = ts.fileExtensionIs(inputFileName, ".json");
-        var outputFileName = ts.changeExtension(getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.outDir, getCommonSourceDirectory), isJsonFile ?
-            ".json" :
-            configFile.options.jsx === 1 && (ts.fileExtensionIs(inputFileName, ".tsx") || ts.fileExtensionIs(inputFileName, ".jsx")) ?
-                ".jsx" :
-                ".js");
+        var outputFileName = ts.changeExtension(getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.outDir, getCommonSourceDirectory), getOutputExtension(inputFileName, configFile.options));
         return !isJsonFile || ts.comparePaths(inputFileName, outputFileName, ts.Debug.checkDefined(configFile.options.configFilePath), ignoreCase) !== 0 ?
             outputFileName :
             undefined;
@@ -86828,7 +87604,7 @@ var ts;
     ts.getCommonSourceDirectory = getCommonSourceDirectory;
     function getCommonSourceDirectoryOfConfig(_a, ignoreCase) {
         var options = _a.options, fileNames = _a.fileNames;
-        return getCommonSourceDirectory(options, function () { return ts.filter(fileNames, function (file) { return !(options.noEmitForJsFiles && ts.fileExtensionIsOneOf(file, ts.supportedJSExtensions)) && !ts.fileExtensionIs(file, ".d.ts"); }); }, ts.getDirectoryPath(ts.normalizeSlashes(ts.Debug.checkDefined(options.configFilePath))), ts.createGetCanonicalFileName(!ignoreCase));
+        return getCommonSourceDirectory(options, function () { return ts.filter(fileNames, function (file) { return !(options.noEmitForJsFiles && ts.fileExtensionIsOneOf(file, ts.supportedJSExtensionsFlat)) && !ts.fileExtensionIs(file, ".d.ts"); }); }, ts.getDirectoryPath(ts.normalizeSlashes(ts.Debug.checkDefined(options.configFilePath))), ts.createGetCanonicalFileName(!ignoreCase));
     }
     ts.getCommonSourceDirectoryOfConfig = getCommonSourceDirectoryOfConfig;
     function getAllProjectOutputs(configFile, ignoreCase) {
@@ -88014,6 +88790,8 @@ var ts;
                         return emitLiteral(node, false);
                     case 79:
                         return emitIdentifier(node);
+                    case 80:
+                        return emitPrivateIdentifier(node);
                     case 203:
                         return emitArrayLiteralExpression(node);
                     case 204:
@@ -91604,7 +92382,7 @@ var ts;
             if (options.declarationDir)
                 return false;
         }
-        else if (!ts.fileExtensionIsOneOf(fileOrDirectoryPath, ts.supportedJSExtensions)) {
+        else if (!ts.fileExtensionIsOneOf(fileOrDirectoryPath, ts.supportedJSExtensionsFlat)) {
             return false;
         }
         var filePathWithoutExtension = ts.removeFileExtension(fileOrDirectoryPath);
@@ -92187,6 +92965,48 @@ var ts;
         return resolutions;
     }
     ts.loadWithLocalCache = loadWithLocalCache;
+    ;
+    function getModeForResolutionAtIndex(file, index) {
+        if (file.impliedNodeFormat === undefined)
+            return undefined;
+        return getModeForUsageLocation(file, getModuleNameStringLiteralAt(file, index));
+    }
+    ts.getModeForResolutionAtIndex = getModeForResolutionAtIndex;
+    function getModeForUsageLocation(file, usage) {
+        var _a;
+        if (file.impliedNodeFormat === undefined)
+            return undefined;
+        if (file.impliedNodeFormat !== ts.ModuleKind.ESNext) {
+            return ts.isImportCall(ts.walkUpParenthesizedExpressions(usage.parent)) ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS;
+        }
+        var exprParentParent = (_a = ts.walkUpParenthesizedExpressions(usage.parent)) === null || _a === void 0 ? void 0 : _a.parent;
+        return exprParentParent && ts.isImportEqualsDeclaration(exprParentParent) ? ts.ModuleKind.CommonJS : ts.ModuleKind.ESNext;
+    }
+    ts.getModeForUsageLocation = getModeForUsageLocation;
+    function loadWithModeAwareCache(names, containingFile, containingFileName, redirectedReference, loader) {
+        if (names.length === 0) {
+            return [];
+        }
+        var resolutions = [];
+        var cache = new ts.Map();
+        var i = 0;
+        for (var _i = 0, names_3 = names; _i < names_3.length; _i++) {
+            var name = names_3[_i];
+            var result = void 0;
+            var mode = getModeForResolutionAtIndex(containingFile, i);
+            i++;
+            var cacheKey = mode !== undefined ? mode + "|" + name : name;
+            if (cache.has(cacheKey)) {
+                result = cache.get(cacheKey);
+            }
+            else {
+                cache.set(cacheKey, result = loader(name, mode, containingFileName, redirectedReference));
+            }
+            resolutions.push(result);
+        }
+        return resolutions;
+    }
+    ts.loadWithModeAwareCache = loadWithModeAwareCache;
     function forEachResolvedProjectReference(resolvedProjectReferences, cb) {
         return forEachProjectReference(undefined, resolvedProjectReferences, function (resolvedRef, parent) { return resolvedRef && cb(resolvedRef, parent); });
     }
@@ -92238,7 +93058,7 @@ var ts;
         switch (kind) {
             case ts.FileIncludeKind.Import:
                 var importLiteral = getModuleNameStringLiteralAt(file, index);
-                packageId = (_e = (_d = file.resolvedModules) === null || _d === void 0 ? void 0 : _d.get(importLiteral.text)) === null || _e === void 0 ? void 0 : _e.packageId;
+                packageId = (_e = (_d = file.resolvedModules) === null || _d === void 0 ? void 0 : _d.get(importLiteral.text, getModeForResolutionAtIndex(file, index))) === null || _e === void 0 ? void 0 : _e.packageId;
                 if (importLiteral.pos === -1)
                     return { file: file, packageId: packageId, text: importLiteral.text };
                 pos = ts.skipTrivia(file.text, importLiteral.pos);
@@ -92249,7 +93069,7 @@ var ts;
                 break;
             case ts.FileIncludeKind.TypeReferenceDirective:
                 (_b = file.typeReferenceDirectives[index], pos = _b.pos, end = _b.end);
-                packageId = (_g = (_f = file.resolvedTypeReferenceDirectiveNames) === null || _f === void 0 ? void 0 : _f.get(ts.toFileNameLowerCase(file.typeReferenceDirectives[index].fileName))) === null || _g === void 0 ? void 0 : _g.packageId;
+                packageId = (_g = (_f = file.resolvedTypeReferenceDirectiveNames) === null || _f === void 0 ? void 0 : _f.get(ts.toFileNameLowerCase(file.typeReferenceDirectives[index].fileName), getModeForResolutionAtIndex(file, index))) === null || _g === void 0 ? void 0 : _g.packageId;
                 break;
             case ts.FileIncludeKind.LibReferenceDirective:
                 (_c = file.libReferenceDirectives[index], pos = _c.pos, end = _c.end);
@@ -92316,6 +93136,23 @@ var ts;
             configFileParseResult.errors;
     }
     ts.getConfigFileParsingDiagnostics = getConfigFileParsingDiagnostics;
+    function getImpliedNodeFormatForFile(fileName, packageJsonInfoCache, host, options) {
+        switch (ts.getEmitModuleResolutionKind(options)) {
+            case ts.ModuleResolutionKind.Node12:
+            case ts.ModuleResolutionKind.NodeNext:
+                return ts.fileExtensionIsOneOf(fileName, [".d.mts", ".mts", ".mjs"]) ? ts.ModuleKind.ESNext :
+                    ts.fileExtensionIsOneOf(fileName, [".d.cts", ".cts", ".cjs"]) ? ts.ModuleKind.CommonJS :
+                        ts.fileExtensionIsOneOf(fileName, [".d.ts", ".ts", ".tsx", ".js", ".jsx"]) ? lookupFromPackageJson() :
+                            undefined;
+            default:
+                return undefined;
+        }
+        function lookupFromPackageJson() {
+            var scope = ts.getPackageScopeForPath(fileName, packageJsonInfoCache, host, options);
+            return (scope === null || scope === void 0 ? void 0 : scope.packageJsonContent.type) === "module" ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS;
+        }
+    }
+    ts.getImpliedNodeFormatForFile = getImpliedNodeFormatForFile;
     function shouldProgramCreateNewSourceFiles(program, newOptions) {
         if (!program)
             return false;
@@ -92331,7 +93168,7 @@ var ts;
         };
     }
     function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         var createProgramOptions = ts.isArray(rootNamesOrOptions) ? createCreateProgramOptions(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) : rootNamesOrOptions;
         var rootNames = createProgramOptions.rootNames, options = createProgramOptions.options, configFileParsingDiagnostics = createProgramOptions.configFileParsingDiagnostics, projectReferences = createProgramOptions.projectReferences;
         var oldProgram = createProgramOptions.oldProgram;
@@ -92363,7 +93200,7 @@ var ts;
         var programDiagnostics = ts.createDiagnosticCollection();
         var currentDirectory = host.getCurrentDirectory();
         var supportedExtensions = ts.getSupportedExtensions(options);
-        var supportedExtensionsWithJsonIfResolveJsonModule = ts.getSuppoertedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);
+        var supportedExtensionsWithJsonIfResolveJsonModule = ts.getSupportedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);
         var hasEmitBlockingDiagnostics = new ts.Map();
         var _compilerOptionsObjectLiteralSyntax;
         var moduleResolutionCache;
@@ -92371,7 +93208,7 @@ var ts;
         var actualResolveModuleNamesWorker;
         var hasInvalidatedResolution = host.hasInvalidatedResolution || ts.returnFalse;
         if (host.resolveModuleNames) {
-            actualResolveModuleNamesWorker = function (moduleNames, containingFile, reusedNames, redirectedReference) { return host.resolveModuleNames(ts.Debug.checkEachDefined(moduleNames), containingFile, reusedNames, redirectedReference, options).map(function (resolved) {
+            actualResolveModuleNamesWorker = function (moduleNames, containingFile, containingFileName, reusedNames, redirectedReference) { return host.resolveModuleNames(ts.Debug.checkEachDefined(moduleNames), containingFileName, reusedNames, redirectedReference, options, containingFile).map(function (resolved) {
                 if (!resolved || resolved.extension !== undefined) {
                     return resolved;
                 }
@@ -92379,11 +93216,12 @@ var ts;
                 withExtension.extension = ts.extensionFromPath(resolved.resolvedFileName);
                 return withExtension;
             }); };
+            moduleResolutionCache = (_a = host.getModuleResolutionCache) === null || _a === void 0 ? void 0 : _a.call(host);
         }
         else {
             moduleResolutionCache = ts.createModuleResolutionCache(currentDirectory, getCanonicalFileName, options);
-            var loader_1 = function (moduleName, containingFile, redirectedReference) { return ts.resolveModuleName(moduleName, containingFile, options, host, moduleResolutionCache, redirectedReference).resolvedModule; };
-            actualResolveModuleNamesWorker = function (moduleNames, containingFile, _reusedNames, redirectedReference) { return loadWithLocalCache(ts.Debug.checkEachDefined(moduleNames), containingFile, redirectedReference, loader_1); };
+            var loader_1 = function (moduleName, resolverMode, containingFileName, redirectedReference) { return ts.resolveModuleName(moduleName, containingFileName, options, host, moduleResolutionCache, redirectedReference, resolverMode).resolvedModule; };
+            actualResolveModuleNamesWorker = function (moduleNames, containingFile, containingFileName, _reusedNames, redirectedReference) { return loadWithModeAwareCache(ts.Debug.checkEachDefined(moduleNames), containingFile, containingFileName, redirectedReference, loader_1); };
         }
         var actualResolveTypeReferenceDirectiveNamesWorker;
         if (host.resolveTypeReferenceDirectives) {
@@ -92405,9 +93243,9 @@ var ts;
         var projectReferenceRedirects;
         var mapFromFileToProjectReferenceRedirects;
         var mapFromToProjectReferenceRedirectSource;
-        var useSourceOfProjectReferenceRedirect = !!((_a = host.useSourceOfProjectReferenceRedirect) === null || _a === void 0 ? void 0 : _a.call(host)) &&
+        var useSourceOfProjectReferenceRedirect = !!((_b = host.useSourceOfProjectReferenceRedirect) === null || _b === void 0 ? void 0 : _b.call(host)) &&
             !options.disableSourceOfProjectReferenceRedirect;
-        var _d = updateHostForUseSourceOfProjectReferenceRedirect({
+        var _e = updateHostForUseSourceOfProjectReferenceRedirect({
             compilerHost: host,
             getSymlinkCache: getSymlinkCache,
             useSourceOfProjectReferenceRedirect: useSourceOfProjectReferenceRedirect,
@@ -92415,7 +93253,8 @@ var ts;
             getResolvedProjectReferences: getResolvedProjectReferences,
             getSourceOfProjectReferenceRedirect: getSourceOfProjectReferenceRedirect,
             forEachResolvedProjectReference: forEachResolvedProjectReference
-        }), onProgramCreateComplete = _d.onProgramCreateComplete, fileExists = _d.fileExists, directoryExists = _d.directoryExists;
+        }), onProgramCreateComplete = _e.onProgramCreateComplete, fileExists = _e.fileExists, directoryExists = _e.directoryExists;
+        var readFile = host.readFile.bind(host);
         ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program", "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
         var shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
         ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
@@ -92470,7 +93309,7 @@ var ts;
                 var containingFilename = ts.combinePaths(containingDirectory, ts.inferredTypesContainingFile);
                 var resolutions = resolveTypeReferenceDirectiveNamesWorker(typeReferences, containingFilename);
                 for (var i = 0; i < typeReferences.length; i++) {
-                    processTypeReferenceDirective(typeReferences[i], resolutions[i], { kind: ts.FileIncludeKind.AutomaticTypeDirectiveFile, typeReference: typeReferences[i], packageId: (_b = resolutions[i]) === null || _b === void 0 ? void 0 : _b.packageId });
+                    processTypeReferenceDirective(typeReferences[i], resolutions[i], { kind: ts.FileIncludeKind.AutomaticTypeDirectiveFile, typeReference: typeReferences[i], packageId: (_c = resolutions[i]) === null || _c === void 0 ? void 0 : _c.packageId });
                 }
                 ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             }
@@ -92575,9 +93414,10 @@ var ts;
             isSourceOfProjectReferenceRedirect: isSourceOfProjectReferenceRedirect,
             emitBuildInfo: emitBuildInfo,
             fileExists: fileExists,
+            readFile: readFile,
             directoryExists: directoryExists,
             getSymlinkCache: getSymlinkCache,
-            realpath: (_c = host.realpath) === null || _c === void 0 ? void 0 : _c.bind(host),
+            realpath: (_d = host.realpath) === null || _d === void 0 ? void 0 : _d.bind(host),
             useCaseSensitiveFileNames: function () { return host.useCaseSensitiveFileNames(); },
             getFileIncludeReasons: function () { return fileReasons; },
             structureIsReused: structureIsReused,
@@ -92606,7 +93446,7 @@ var ts;
             var redirectedReference = getRedirectReferenceForResolution(containingFile);
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program", "resolveModuleNamesWorker", { containingFileName: containingFileName });
             ts.performance.mark("beforeResolveModule");
-            var result = actualResolveModuleNamesWorker(moduleNames, containingFileName, reusedNames, redirectedReference);
+            var result = actualResolveModuleNamesWorker(moduleNames, containingFile, containingFileName, reusedNames, redirectedReference);
             ts.performance.mark("afterResolveModule");
             ts.performance.measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
@@ -92627,7 +93467,7 @@ var ts;
         }
         function getRedirectReferenceForResolution(file) {
             var redirect = getResolvedProjectReferenceToRedirect(file.originalFileName);
-            if (redirect || !ts.fileExtensionIs(file.originalFileName, ".d.ts"))
+            if (redirect || !ts.fileExtensionIsOneOf(file.originalFileName, [".d.ts", ".d.cts", ".d.mts"]))
                 return redirect;
             var resultFromDts = getRedirectReferenceForResolutionFromSourceOfProject(file.path);
             if (resultFromDts)
@@ -92665,8 +93505,8 @@ var ts;
             }
             return ts.libs.length + 2;
         }
-        function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile) {
-            return moduleResolutionCache && ts.resolveModuleNameFromCache(moduleName, containingFile, moduleResolutionCache);
+        function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, mode) {
+            return moduleResolutionCache && ts.resolveModuleNameFromCache(moduleName, containingFile, moduleResolutionCache, mode);
         }
         function toPath(fileName) {
             return ts.toPath(fileName, currentDirectory, getCanonicalFileName);
@@ -92697,9 +93537,11 @@ var ts;
             var oldSourceFile = oldProgram && oldProgram.getSourceFile(file.fileName);
             if (oldSourceFile !== file && file.resolvedModules) {
                 var result_14 = [];
+                var i = 0;
                 for (var _i = 0, moduleNames_1 = moduleNames; _i < moduleNames_1.length; _i++) {
                     var moduleName = moduleNames_1[_i];
-                    var resolvedModule = file.resolvedModules.get(moduleName);
+                    var resolvedModule = file.resolvedModules.get(moduleName, getModeForResolutionAtIndex(file, i));
+                    i++;
                     result_14.push(resolvedModule);
                 }
                 return result_14;
@@ -92711,7 +93553,7 @@ var ts;
             for (var i = 0; i < moduleNames.length; i++) {
                 var moduleName = moduleNames[i];
                 if (file === oldSourceFile && !hasInvalidatedResolution(oldSourceFile.path)) {
-                    var oldResolvedModule = ts.getResolvedModule(oldSourceFile, moduleName);
+                    var oldResolvedModule = ts.getResolvedModule(oldSourceFile, moduleName, getModeForResolutionAtIndex(oldSourceFile, i));
                     if (oldResolvedModule) {
                         if (ts.isTraceEnabled(options, host)) {
                             ts.trace(host, oldResolvedModule.packageId ?
@@ -92731,7 +93573,7 @@ var ts;
                     }
                 }
                 else {
-                    resolvesToAmbientModuleInNonModifiedFile = moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName);
+                    resolvesToAmbientModuleInNonModifiedFile = moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName, i);
                 }
                 if (resolvesToAmbientModuleInNonModifiedFile) {
                     (result || (result = new Array(moduleNames.length)))[i] = predictedToResolveToAmbientModuleMarker;
@@ -92761,8 +93603,10 @@ var ts;
             }
             ts.Debug.assert(j === resolutions.length);
             return result;
-            function moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName) {
-                var resolutionToFile = ts.getResolvedModule(oldSourceFile, moduleName);
+            function moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName, index) {
+                if (index >= ts.length(oldSourceFile === null || oldSourceFile === void 0 ? void 0 : oldSourceFile.imports) + ts.length(oldSourceFile === null || oldSourceFile === void 0 ? void 0 : oldSourceFile.moduleAugmentations))
+                    return false;
+                var resolutionToFile = ts.getResolvedModule(oldSourceFile, moduleName, oldSourceFile && getModeForResolutionAtIndex(oldSourceFile, index));
                 var resolvedFile = resolutionToFile && oldProgram.getSourceFile(resolutionToFile.resolvedFileName);
                 if (resolutionToFile && resolvedFile) {
                     return false;
@@ -92824,8 +93668,8 @@ var ts;
             for (var _i = 0, oldSourceFiles_2 = oldSourceFiles; _i < oldSourceFiles_2.length; _i++) {
                 var oldSourceFile = oldSourceFiles_2[_i];
                 var newSourceFile = host.getSourceFileByPath
-                    ? host.getSourceFileByPath(oldSourceFile.fileName, oldSourceFile.resolvedPath, options.target, undefined, shouldCreateNewSourceFile)
-                    : host.getSourceFile(oldSourceFile.fileName, options.target, undefined, shouldCreateNewSourceFile);
+                    ? host.getSourceFileByPath(oldSourceFile.fileName, oldSourceFile.resolvedPath, ts.getEmitScriptTarget(options), undefined, shouldCreateNewSourceFile)
+                    : host.getSourceFile(oldSourceFile.fileName, ts.getEmitScriptTarget(options), undefined, shouldCreateNewSourceFile);
                 if (!newSourceFile) {
                     return 0;
                 }
@@ -92908,20 +93752,20 @@ var ts;
                 var _f = modifiedSourceFiles_1[_e], oldSourceFile = _f.oldFile, newSourceFile = _f.newFile;
                 var moduleNames = getModuleNames(newSourceFile);
                 var resolutions = resolveModuleNamesReusingOldState(moduleNames, newSourceFile);
-                var resolutionsChanged = ts.hasChangesInResolutions(moduleNames, resolutions, oldSourceFile.resolvedModules, ts.moduleResolutionIsEqualTo);
+                var resolutionsChanged = ts.hasChangesInResolutions(moduleNames, resolutions, oldSourceFile.resolvedModules, oldSourceFile, ts.moduleResolutionIsEqualTo);
                 if (resolutionsChanged) {
                     structureIsReused = 1;
-                    newSourceFile.resolvedModules = ts.zipToMap(moduleNames, resolutions);
+                    newSourceFile.resolvedModules = ts.zipToModeAwareCache(newSourceFile, moduleNames, resolutions);
                 }
                 else {
                     newSourceFile.resolvedModules = oldSourceFile.resolvedModules;
                 }
                 var typesReferenceDirectives = ts.map(newSourceFile.typeReferenceDirectives, function (ref) { return ts.toFileNameLowerCase(ref.fileName); });
                 var typeReferenceResolutions = resolveTypeReferenceDirectiveNamesWorker(typesReferenceDirectives, newSourceFile);
-                var typeReferenceEesolutionsChanged = ts.hasChangesInResolutions(typesReferenceDirectives, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, ts.typeDirectiveIsEqualTo);
+                var typeReferenceEesolutionsChanged = ts.hasChangesInResolutions(typesReferenceDirectives, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, oldSourceFile, ts.typeDirectiveIsEqualTo);
                 if (typeReferenceEesolutionsChanged) {
                     structureIsReused = 1;
-                    newSourceFile.resolvedTypeReferenceDirectiveNames = ts.zipToMap(typesReferenceDirectives, typeReferenceResolutions);
+                    newSourceFile.resolvedTypeReferenceDirectiveNames = ts.zipToModeAwareCache(newSourceFile, typesReferenceDirectives, typeReferenceResolutions);
                 }
                 else {
                     newSourceFile.resolvedTypeReferenceDirectiveNames = oldSourceFile.resolvedTypeReferenceDirectiveNames;
@@ -93482,6 +94326,7 @@ var ts;
                 if (ts.isAnyImportOrReExport(node)) {
                     var moduleNameExpr = ts.getExternalModuleName(node);
                     if (moduleNameExpr && ts.isStringLiteral(moduleNameExpr) && moduleNameExpr.text && (!inAmbientModule || !ts.isExternalModuleNameRelative(moduleNameExpr.text))) {
+                        ts.setParentRecursive(node, false);
                         imports = ts.append(imports, moduleNameExpr);
                         if (!usesUriStyleNodeCoreModules && currentNodeModulesDepth === 0 && !file.isDeclarationFile) {
                             usesUriStyleNodeCoreModules = ts.startsWith(moduleNameExpr.text, "node:");
@@ -93490,6 +94335,7 @@ var ts;
                 }
                 else if (ts.isModuleDeclaration(node)) {
                     if (ts.isAmbientModule(node) && (inAmbientModule || ts.hasSyntacticModifier(node, 2) || file.isDeclarationFile)) {
+                        node.name.parent = node;
                         var nameText = ts.getTextOfIdentifierOrLiteral(node.name);
                         if (isExternalModuleFile || (inAmbientModule && !ts.isExternalModuleNameRelative(nameText))) {
                             (moduleAugmentations || (moduleAugmentations = [])).push(node.name);
@@ -93514,12 +94360,15 @@ var ts;
                 while (r.exec(file.text) !== null) {
                     var node = getNodeAtPosition(file, r.lastIndex);
                     if (isJavaScriptFile && ts.isRequireCall(node, true)) {
+                        ts.setParentRecursive(node, false);
                         imports = ts.append(imports, node.arguments[0]);
                     }
                     else if (ts.isImportCall(node) && node.arguments.length >= 1 && ts.isStringLiteralLike(node.arguments[0])) {
+                        ts.setParentRecursive(node, false);
                         imports = ts.append(imports, node.arguments[0]);
                     }
                     else if (ts.isLiteralImportTypeNode(node)) {
+                        ts.setParentRecursive(node, false);
                         imports = ts.append(imports, node.argument.literal);
                     }
                 }
@@ -93553,13 +94402,13 @@ var ts;
         function getSourceFileFromReferenceWorker(fileName, getSourceFile, fail, reason) {
             if (ts.hasExtension(fileName)) {
                 var canonicalFileName_1 = host.getCanonicalFileName(fileName);
-                if (!options.allowNonTsExtensions && !ts.forEach(supportedExtensionsWithJsonIfResolveJsonModule, function (extension) { return ts.fileExtensionIs(canonicalFileName_1, extension); })) {
+                if (!options.allowNonTsExtensions && !ts.forEach(ts.flatten(supportedExtensionsWithJsonIfResolveJsonModule), function (extension) { return ts.fileExtensionIs(canonicalFileName_1, extension); })) {
                     if (fail) {
                         if (ts.hasJSFileExtension(canonicalFileName_1)) {
                             fail(ts.Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option, fileName);
                         }
                         else {
-                            fail(ts.Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1, fileName, "'" + supportedExtensions.join("', '") + "'");
+                            fail(ts.Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1, fileName, "'" + ts.flatten(supportedExtensions).join("', '") + "'");
                         }
                     }
                     return undefined;
@@ -93589,9 +94438,9 @@ var ts;
                     fail(ts.Diagnostics.File_0_not_found, fileName);
                     return undefined;
                 }
-                var sourceFileWithAddedExtension = ts.forEach(supportedExtensions, function (extension) { return getSourceFile(fileName + extension); });
+                var sourceFileWithAddedExtension = ts.forEach(supportedExtensions[0], function (extension) { return getSourceFile(fileName + extension); });
                 if (fail && !sourceFileWithAddedExtension)
-                    fail(ts.Diagnostics.Could_not_resolve_the_path_0_with_the_extensions_Colon_1, fileName, "'" + supportedExtensions.join("', '") + "'");
+                    fail(ts.Diagnostics.Could_not_resolve_the_path_0_with_the_extensions_Colon_1, fileName, "'" + ts.flatten(supportedExtensions).join("', '") + "'");
                 return sourceFileWithAddedExtension;
             }
         }
@@ -93716,7 +94565,7 @@ var ts;
                     redirectedPath = toPath(redirect);
                 }
             }
-            var file = host.getSourceFile(fileName, options.target, function (hostErrorMessage) { return addFilePreprocessingFileExplainingDiagnostic(undefined, reason, ts.Diagnostics.Cannot_read_file_0_Colon_1, [fileName, hostErrorMessage]); }, shouldCreateNewSourceFile);
+            var file = host.getSourceFile(fileName, ts.getEmitScriptTarget(options), function (hostErrorMessage) { return addFilePreprocessingFileExplainingDiagnostic(undefined, reason, ts.Diagnostics.Cannot_read_file_0_Colon_1, [fileName, hostErrorMessage]); }, shouldCreateNewSourceFile);
             if (packageId) {
                 var packageIdKey = ts.packageIdToString(packageId);
                 var fileFromPackageId = packageIdToSourceFile.get(packageIdKey);
@@ -93741,6 +94590,7 @@ var ts;
                 file.path = path;
                 file.resolvedPath = toPath(fileName);
                 file.originalFileName = originalFileName;
+                file.impliedNodeFormat = getImpliedNodeFormatForFile(file.resolvedPath, moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.getPackageJsonInfoCache(), host, options);
                 addFileIncludeReason(file, reason);
                 if (host.useCaseSensitiveFileNames()) {
                     var pathLowerCase = ts.toFileNameLowerCase(path);
@@ -93919,7 +94769,7 @@ var ts;
                 i++;
             }
             var resolveFrom = ts.combinePaths(currentDirectory, "__lib_node_modules_lookup_" + libFileName + "__.ts");
-            var localOverrideModuleResult = ts.resolveModuleName("@typescript/" + path, resolveFrom, { moduleResolution: ts.ModuleResolutionKind.NodeJs }, host, moduleResolutionCache);
+            var localOverrideModuleResult = ts.resolveModuleName("@typescript/lib-" + path, resolveFrom, { moduleResolution: ts.ModuleResolutionKind.NodeJs }, host, moduleResolutionCache);
             if (localOverrideModuleResult === null || localOverrideModuleResult === void 0 ? void 0 : localOverrideModuleResult.resolvedModule) {
                 return localOverrideModuleResult.resolvedModule.resolvedFileName;
             }
@@ -93958,7 +94808,7 @@ var ts;
                 var optionsForFile = (useSourceOfProjectReferenceRedirect ? (_a = getRedirectReferenceForResolution(file)) === null || _a === void 0 ? void 0 : _a.commandLine.options : undefined) || options;
                 for (var index = 0; index < moduleNames.length; index++) {
                     var resolution = resolutions[index];
-                    ts.setResolvedModule(file, moduleNames[index], resolution);
+                    ts.setResolvedModule(file, moduleNames[index], resolution, getModeForResolutionAtIndex(file, index));
                     if (!resolution) {
                         continue;
                     }
@@ -94166,7 +95016,7 @@ var ts;
             if (options.noImplicitUseStrict && ts.getStrictOptionValue(options, "alwaysStrict")) {
                 createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "noImplicitUseStrict", "alwaysStrict");
             }
-            var languageVersion = options.target || 0;
+            var languageVersion = ts.getEmitScriptTarget(options);
             var firstNonAmbientExternalModuleSourceFile = ts.find(files, function (f) { return ts.isExternalModule(f) && !f.isDeclarationFile; });
             if (options.isolatedModules) {
                 if (options.module === ts.ModuleKind.None && languageVersion < 2) {
@@ -94410,7 +95260,7 @@ var ts;
                         message = ts.Diagnostics.File_is_library_specified_here;
                         break;
                     }
-                    var target = ts.forEachEntry(ts.targetOptionDeclaration.type, function (value, key) { return value === options.target ? key : undefined; });
+                    var target = ts.forEachEntry(ts.targetOptionDeclaration.type, function (value, key) { return value === ts.getEmitScriptTarget(options) ? key : undefined; });
                     configFileNode = target ? getOptionsSyntaxByValue("target", target) : undefined;
                     message = ts.Diagnostics.File_is_default_library_for_target_specified_here;
                     break;
@@ -94573,7 +95423,7 @@ var ts;
             if (options.outDir) {
                 return ts.containsPath(options.outDir, filePath, currentDirectory, !host.useCaseSensitiveFileNames());
             }
-            if (ts.fileExtensionIsOneOf(filePath, ts.supportedJSExtensions) || ts.fileExtensionIs(filePath, ".d.ts")) {
+            if (ts.fileExtensionIsOneOf(filePath, ts.supportedJSExtensionsFlat) || ts.fileExtensionIs(filePath, ".d.ts")) {
                 var filePathWithoutExtension = ts.removeFileExtension(filePath);
                 return !!getSourceFileByPath((filePathWithoutExtension + ".ts")) ||
                     !!getSourceFileByPath((filePathWithoutExtension + ".tsx"));
@@ -95037,7 +95887,7 @@ var ts;
                         }
                     }
                 }
-                fileInfos.set(sourceFile.resolvedPath, { version: version_2, signature: oldInfo && oldInfo.signature, affectsGlobalScope: isFileAffectingGlobalScope(sourceFile) || undefined });
+                fileInfos.set(sourceFile.resolvedPath, { version: version_2, signature: oldInfo && oldInfo.signature, affectsGlobalScope: isFileAffectingGlobalScope(sourceFile) || undefined, impliedFormat: sourceFile.impliedNodeFormat });
             }
             return {
                 fileInfos: fileInfos,
@@ -95105,7 +95955,7 @@ var ts;
                 var emitOutput_1 = getFileEmitOutput(programOfThisState, sourceFile, true, cancellationToken, undefined, true);
                 var firstDts_1 = ts.firstOrUndefined(emitOutput_1.outputFiles);
                 if (firstDts_1) {
-                    ts.Debug.assert(ts.fileExtensionIs(firstDts_1.name, ".d.ts"), "File extension for signature expected to be dts", function () { return "Found: " + ts.getAnyExtensionFromPath(firstDts_1.name) + " for " + firstDts_1.name + ":: All output files: " + JSON.stringify(emitOutput_1.outputFiles.map(function (f) { return f.name; })); });
+                    ts.Debug.assert(ts.fileExtensionIsOneOf(firstDts_1.name, [".d.ts", ".d.mts", ".d.cts"]), "File extension for signature expected to be dts", function () { return "Found: " + ts.getAnyExtensionFromPath(firstDts_1.name) + " for " + firstDts_1.name + ":: All output files: " + JSON.stringify(emitOutput_1.outputFiles.map(function (f) { return f.name; })); });
                     latestSignature = (computeHash || ts.generateDjb2Hash)(firstDts_1.text);
                     if (exportedModulesMapCache && latestSignature !== prevSignature) {
                         updateExportedModules(sourceFile, emitOutput_1.exportedModulesFromDeclarationEmit, exportedModulesMapCache);
@@ -95353,6 +96203,13 @@ var ts;
             ts.Debug.assert(!state.seenAffectedFiles || !state.seenAffectedFiles.size);
             state.seenAffectedFiles = state.seenAffectedFiles || new ts.Set();
         }
+        if (useOldState) {
+            ts.forEachEntry(oldState.fileInfos, function (info, sourceFilePath) {
+                if (state.fileInfos.has(sourceFilePath) && state.fileInfos.get(sourceFilePath).impliedFormat !== info.impliedFormat) {
+                    state.changedFilesSet.add(sourceFilePath);
+                }
+            });
+        }
         state.buildInfoEmitPending = !!state.changedFilesSet.size;
         return state;
     }
@@ -95652,13 +96509,13 @@ var ts;
             var actualSignature = signature !== null && signature !== void 0 ? signature : value.signature;
             return value.version === actualSignature ?
                 value.affectsGlobalScope ?
-                    { version: value.version, signature: undefined, affectsGlobalScope: true } :
+                    { version: value.version, signature: undefined, affectsGlobalScope: true, impliedFormat: value.impliedFormat } :
                     value.version :
                 actualSignature !== undefined ?
                     signature === undefined ?
                         value :
-                        { version: value.version, signature: signature, affectsGlobalScope: value.affectsGlobalScope } :
-                    { version: value.version, signature: false, affectsGlobalScope: value.affectsGlobalScope };
+                        { version: value.version, signature: signature, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat } :
+                    { version: value.version, signature: false, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat };
         });
         var referencedMap;
         if (state.referencedMap) {
@@ -96011,10 +96868,10 @@ var ts;
     }
     function toBuilderStateFileInfo(fileInfo) {
         return ts.isString(fileInfo) ?
-            { version: fileInfo, signature: fileInfo, affectsGlobalScope: undefined } :
+            { version: fileInfo, signature: fileInfo, affectsGlobalScope: undefined, impliedFormat: undefined } :
             ts.isString(fileInfo.signature) ?
                 fileInfo :
-                { version: fileInfo.version, signature: fileInfo.signature === false ? undefined : fileInfo.version, affectsGlobalScope: fileInfo.affectsGlobalScope };
+                { version: fileInfo.version, signature: fileInfo.signature === false ? undefined : fileInfo.version, affectsGlobalScope: fileInfo.affectsGlobalScope, impliedFormat: fileInfo.impliedFormat };
     }
     ts.toBuilderStateFileInfo = toBuilderStateFileInfo;
     function createBuildProgramUsingProgramBuildInfo(program, buildInfoPath, host) {
@@ -96314,14 +97171,14 @@ var ts;
         }
         function resolveNamesWithLocalCache(_a) {
             var _b, _c, _d;
-            var names = _a.names, containingFile = _a.containingFile, redirectedReference = _a.redirectedReference, cache = _a.cache, perDirectoryCacheWithRedirects = _a.perDirectoryCacheWithRedirects, loader = _a.loader, getResolutionWithResolvedFileName = _a.getResolutionWithResolvedFileName, shouldRetryResolution = _a.shouldRetryResolution, reusedNames = _a.reusedNames, logChanges = _a.logChanges;
+            var names = _a.names, containingFile = _a.containingFile, redirectedReference = _a.redirectedReference, cache = _a.cache, perDirectoryCacheWithRedirects = _a.perDirectoryCacheWithRedirects, loader = _a.loader, getResolutionWithResolvedFileName = _a.getResolutionWithResolvedFileName, shouldRetryResolution = _a.shouldRetryResolution, reusedNames = _a.reusedNames, logChanges = _a.logChanges, containingSourceFile = _a.containingSourceFile;
             var path = resolutionHost.toPath(containingFile);
-            var resolutionsInFile = cache.get(path) || cache.set(path, new ts.Map()).get(path);
+            var resolutionsInFile = cache.get(path) || cache.set(path, ts.createModeAwareCache()).get(path);
             var dirPath = ts.getDirectoryPath(path);
             var perDirectoryCache = perDirectoryCacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference);
             var perDirectoryResolution = perDirectoryCache.get(dirPath);
             if (!perDirectoryResolution) {
-                perDirectoryResolution = new ts.Map();
+                perDirectoryResolution = ts.createModeAwareCache();
                 perDirectoryCache.set(dirPath, perDirectoryResolution);
             }
             var resolvedModules = [];
@@ -96332,15 +97189,18 @@ var ts;
             var unmatchedRedirects = oldRedirect ?
                 !redirectedReference || redirectedReference.sourceFile.path !== oldRedirect.sourceFile.path :
                 !!redirectedReference;
-            var seenNamesInFile = new ts.Map();
-            for (var _i = 0, names_3 = names; _i < names_3.length; _i++) {
-                var name = names_3[_i];
-                var resolution = resolutionsInFile.get(name);
-                if (!seenNamesInFile.has(name) &&
+            var seenNamesInFile = ts.createModeAwareCache();
+            var i = 0;
+            for (var _i = 0, names_4 = names; _i < names_4.length; _i++) {
+                var name = names_4[_i];
+                var mode = containingSourceFile ? ts.getModeForResolutionAtIndex(containingSourceFile, i) : undefined;
+                i++;
+                var resolution = resolutionsInFile.get(name, mode);
+                if (!seenNamesInFile.has(name, mode) &&
                     unmatchedRedirects || !resolution || resolution.isInvalidated ||
                     (hasInvalidatedNonRelativeUnresolvedImport && !ts.isExternalModuleNameRelative(name) && shouldRetryResolution(resolution))) {
                     var existingResolution = resolution;
-                    var resolutionInDirectory = perDirectoryResolution.get(name);
+                    var resolutionInDirectory = perDirectoryResolution.get(name, mode);
                     if (resolutionInDirectory) {
                         resolution = resolutionInDirectory;
                         var host = ((_b = resolutionHost.getCompilerHost) === null || _b === void 0 ? void 0 : _b.call(resolutionHost)) || resolutionHost;
@@ -96360,10 +97220,10 @@ var ts;
                         }
                     }
                     else {
-                        resolution = loader(name, containingFile, compilerOptions, ((_c = resolutionHost.getCompilerHost) === null || _c === void 0 ? void 0 : _c.call(resolutionHost)) || resolutionHost, redirectedReference);
-                        perDirectoryResolution.set(name, resolution);
+                        resolution = loader(name, containingFile, compilerOptions, ((_c = resolutionHost.getCompilerHost) === null || _c === void 0 ? void 0 : _c.call(resolutionHost)) || resolutionHost, redirectedReference, containingSourceFile);
+                        perDirectoryResolution.set(name, mode, resolution);
                     }
-                    resolutionsInFile.set(name, resolution);
+                    resolutionsInFile.set(name, mode, resolution);
                     watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path, getResolutionWithResolvedFileName);
                     if (existingResolution) {
                         stopWatchFailedLookupLocationOfResolution(existingResolution, path, getResolutionWithResolvedFileName);
@@ -96375,7 +97235,7 @@ var ts;
                 }
                 else {
                     var host = ((_d = resolutionHost.getCompilerHost) === null || _d === void 0 ? void 0 : _d.call(resolutionHost)) || resolutionHost;
-                    if (ts.isTraceEnabled(compilerOptions, host) && !seenNamesInFile.has(name)) {
+                    if (ts.isTraceEnabled(compilerOptions, host) && !seenNamesInFile.has(name, mode)) {
                         var resolved = getResolutionWithResolvedFileName(resolution);
                         ts.trace(host, loader === resolveModuleName ?
                             (resolved === null || resolved === void 0 ? void 0 : resolved.resolvedFileName) ?
@@ -96391,13 +97251,13 @@ var ts;
                     }
                 }
                 ts.Debug.assert(resolution !== undefined && !resolution.isInvalidated);
-                seenNamesInFile.set(name, true);
+                seenNamesInFile.set(name, mode, true);
                 resolvedModules.push(getResolutionWithResolvedFileName(resolution));
             }
-            resolutionsInFile.forEach(function (resolution, name) {
-                if (!seenNamesInFile.has(name) && !ts.contains(reusedNames, name)) {
+            resolutionsInFile.forEach(function (resolution, name, mode) {
+                if (!seenNamesInFile.has(name, mode) && !ts.contains(reusedNames, name)) {
                     stopWatchFailedLookupLocationOfResolution(resolution, path, getResolutionWithResolvedFileName);
-                    resolutionsInFile.delete(name);
+                    resolutionsInFile.delete(name, mode);
                 }
             });
             return resolvedModules;
@@ -96431,7 +97291,7 @@ var ts;
                 shouldRetryResolution: function (resolution) { return resolution.resolvedTypeReferenceDirective === undefined; },
             });
         }
-        function resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference) {
+        function resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, containingSourceFile) {
             return resolveNamesWithLocalCache({
                 names: moduleNames,
                 containingFile: containingFile,
@@ -96443,11 +97303,14 @@ var ts;
                 shouldRetryResolution: function (resolution) { return !resolution.resolvedModule || !ts.resolutionExtensionIsTSOrJson(resolution.resolvedModule.extension); },
                 reusedNames: reusedNames,
                 logChanges: logChangesWhenResolvingModule,
+                containingSourceFile: containingSourceFile,
             });
         }
-        function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile) {
+        function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, resolutionMode) {
             var cache = resolvedModuleNames.get(resolutionHost.toPath(containingFile));
-            return cache && cache.get(moduleName);
+            if (!cache)
+                return undefined;
+            return cache.get(moduleName, resolutionMode);
         }
         function isNodeModulesAtTypesDirectory(dirPath) {
             return ts.endsWith(dirPath, "/node_modules/@types");
@@ -96781,7 +97644,7 @@ var ts;
 (function (ts) {
     var moduleSpecifiers;
     (function (moduleSpecifiers_1) {
-        function getPreferences(_a, compilerOptions, importingSourceFile) {
+        function getPreferences(host, _a, compilerOptions, importingSourceFile) {
             var importModuleSpecifierPreference = _a.importModuleSpecifierPreference, importModuleSpecifierEnding = _a.importModuleSpecifierEnding;
             return {
                 relativePreference: importModuleSpecifierPreference === "relative" ? 0 :
@@ -96795,28 +97658,46 @@ var ts;
                     case "minimal": return 0;
                     case "index": return 1;
                     case "js": return 2;
-                    default: return usesJsExtensionOnImports(importingSourceFile) ? 2
+                    default: return usesJsExtensionOnImports(importingSourceFile) || isFormatRequiringExtensions(compilerOptions, importingSourceFile.path, host) ? 2
                         : ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeJs ? 1 : 0;
                 }
             }
         }
-        function getPreferencesForUpdate(compilerOptions, oldImportSpecifier) {
+        function getPreferencesForUpdate(compilerOptions, oldImportSpecifier, importingSourceFileName, host) {
             return {
                 relativePreference: ts.isExternalModuleNameRelative(oldImportSpecifier) ? 0 : 1,
-                ending: ts.hasJSFileExtension(oldImportSpecifier) ?
+                ending: ts.hasJSFileExtension(oldImportSpecifier) || isFormatRequiringExtensions(compilerOptions, importingSourceFileName, host) ?
                     2 :
                     ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeJs || ts.endsWith(oldImportSpecifier, "index") ? 1 : 0,
             };
         }
+        function isFormatRequiringExtensions(compilerOptions, importingSourceFileName, host) {
+            if (ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Node12
+                && ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeNext) {
+                return false;
+            }
+            return ts.getImpliedNodeFormatForFile(importingSourceFileName, undefined, getModuleResolutionHost(host), compilerOptions) !== ts.ModuleKind.CommonJS;
+        }
+        function getModuleResolutionHost(host) {
+            var _a;
+            return {
+                fileExists: host.fileExists,
+                readFile: ts.Debug.checkDefined(host.readFile),
+                directoryExists: host.directoryExists,
+                getCurrentDirectory: host.getCurrentDirectory,
+                realpath: host.realpath,
+                useCaseSensitiveFileNames: (_a = host.useCaseSensitiveFileNames) === null || _a === void 0 ? void 0 : _a.call(host),
+            };
+        }
         function updateModuleSpecifier(compilerOptions, importingSourceFileName, toFileName, host, oldImportSpecifier) {
-            var res = getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, getPreferencesForUpdate(compilerOptions, oldImportSpecifier), {});
+            var res = getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, getPreferencesForUpdate(compilerOptions, oldImportSpecifier, importingSourceFileName, host), {});
             if (res === oldImportSpecifier)
                 return undefined;
             return res;
         }
         moduleSpecifiers_1.updateModuleSpecifier = updateModuleSpecifier;
         function getModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host) {
-            return getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, getPreferences({}, compilerOptions, importingSourceFile), {});
+            return getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, getPreferences(host, {}, compilerOptions, importingSourceFile), {});
         }
         moduleSpecifiers_1.getModuleSpecifier = getModuleSpecifier;
         function getNodeModulesPackageName(compilerOptions, importingSourceFileName, nodeModulesFileName, host, preferences) {
@@ -96868,7 +97749,7 @@ var ts;
         moduleSpecifiers_1.getModuleSpecifiersWithCacheInfo = getModuleSpecifiersWithCacheInfo;
         function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFile, host, userPreferences) {
             var info = getInfo(importingSourceFile.path, host);
-            var preferences = getPreferences(userPreferences, compilerOptions, importingSourceFile);
+            var preferences = getPreferences(host, userPreferences, compilerOptions, importingSourceFile);
             var existingSpecifier = ts.forEach(modulePaths, function (modulePath) { return ts.forEach(host.getFileIncludeReasons().get(ts.toPath(modulePath.path, host.getCurrentDirectory(), info.getCanonicalFileName)), function (reason) {
                 if (reason.kind !== ts.FileIncludeKind.Import || reason.file !== importingSourceFile.path)
                     return undefined;
@@ -97236,7 +98117,7 @@ var ts;
         function tryGetAnyFileFromPath(host, path) {
             if (!host.fileExists)
                 return;
-            var extensions = ts.getSupportedExtensions({ allowJs: true }, [{ extension: "node", isMixedContent: false }, { extension: "json", isMixedContent: false, scriptKind: 6 }]);
+            var extensions = ts.flatten(ts.getSupportedExtensions({ allowJs: true }, [{ extension: "node", isMixedContent: false }, { extension: "json", isMixedContent: false, scriptKind: 6 }]));
             for (var _i = 0, extensions_3 = extensions; _i < extensions_3.length; _i++) {
                 var e = extensions_3[_i];
                 var fullPath = path + e;
@@ -97294,9 +98175,11 @@ var ts;
             });
         }
         function removeExtensionAndIndexPostFix(fileName, ending, options) {
-            if (ts.fileExtensionIs(fileName, ".json"))
+            if (ts.fileExtensionIsOneOf(fileName, [".json", ".mjs", ".cjs"]))
                 return fileName;
             var noExtension = ts.removeFileExtension(fileName);
+            if (ts.fileExtensionIsOneOf(fileName, [".d.mts", ".mts", ".d.cts", ".cts"]))
+                return noExtension + getJSExtensionForFile(fileName, options);
             switch (ending) {
                 case 0:
                     return ts.removeSuffix(noExtension, "/index");
@@ -97324,6 +98207,14 @@ var ts;
                 case ".jsx":
                 case ".json":
                     return ext;
+                case ".d.mts":
+                case ".mts":
+                case ".mjs":
+                    return ".mjs";
+                case ".d.cts":
+                case ".cts":
+                case ".cjs":
+                    return ".cjs";
                 default:
                     return undefined;
             }
@@ -97577,7 +98468,7 @@ var ts;
             case ts.FileIncludeKind.LibFile:
                 if (reason.index !== undefined)
                     return ts.chainDiagnosticMessages(undefined, ts.Diagnostics.Library_0_specified_in_compilerOptions, options.lib[reason.index]);
-                var target = ts.forEachEntry(ts.targetOptionDeclaration.type, function (value, key) { return value === options.target ? key : undefined; });
+                var target = ts.forEachEntry(ts.targetOptionDeclaration.type, function (value, key) { return value === ts.getEmitScriptTarget(options) ? key : undefined; });
                 return ts.chainDiagnosticMessages(undefined, target ?
                     ts.Diagnostics.Default_library_for_target_0 :
                     ts.Diagnostics.Default_library, target);
@@ -97965,7 +98856,7 @@ var ts;
                 }
                 return host.resolveModuleNames.apply(host, args);
             }) :
-            (function (moduleNames, containingFile, reusedNames, redirectedReference) { return resolutionCache.resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference); });
+            (function (moduleNames, containingFile, reusedNames, redirectedReference, _options, sourceFile) { return resolutionCache.resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, sourceFile); });
         compilerHost.resolveTypeReferenceDirectives = host.resolveTypeReferenceDirectives ?
             (function () {
                 var args = [];
@@ -98611,10 +99502,11 @@ var ts;
         var moduleResolutionCache = !compilerHost.resolveModuleNames ? ts.createModuleResolutionCache(currentDirectory, getCanonicalFileName) : undefined;
         var typeReferenceDirectiveResolutionCache = !compilerHost.resolveTypeReferenceDirectives ? ts.createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, undefined, moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.getPackageJsonInfoCache()) : undefined;
         if (!compilerHost.resolveModuleNames) {
-            var loader_3 = function (moduleName, containingFile, redirectedReference) { return ts.resolveModuleName(moduleName, containingFile, state.projectCompilerOptions, compilerHost, moduleResolutionCache, redirectedReference).resolvedModule; };
-            compilerHost.resolveModuleNames = function (moduleNames, containingFile, _reusedNames, redirectedReference) {
-                return ts.loadWithLocalCache(ts.Debug.checkEachDefined(moduleNames), containingFile, redirectedReference, loader_3);
+            var loader_3 = function (moduleName, resolverMode, containingFile, redirectedReference) { return ts.resolveModuleName(moduleName, containingFile, state.projectCompilerOptions, compilerHost, moduleResolutionCache, redirectedReference, resolverMode).resolvedModule; };
+            compilerHost.resolveModuleNames = function (moduleNames, containingFile, _reusedNames, redirectedReference, _options, containingSourceFile) {
+                return ts.loadWithModeAwareCache(ts.Debug.checkEachDefined(moduleNames), ts.Debug.checkDefined(containingSourceFile), containingFile, redirectedReference, loader_3);
             };
+            compilerHost.getModuleResolutionCache = function () { return moduleResolutionCache; };
         }
         if (!compilerHost.resolveTypeReferenceDirectives) {
             var loader_4 = function (moduleName, containingFile, redirectedReference) { return ts.resolveTypeReferenceDirective(moduleName, containingFile, state.projectCompilerOptions, compilerHost, redirectedReference, state.typeReferenceDirectiveResolutionCache).resolvedTypeReferenceDirective; };
@@ -99972,10 +100864,10 @@ var ts;
             return "Definitions";
         }
         var path = file.path;
-        if (ts.fileExtensionIsOneOf(path, ts.supportedTSExtensions)) {
+        if (ts.fileExtensionIsOneOf(path, ts.supportedTSExtensionsFlat)) {
             return "TypeScript";
         }
-        else if (ts.fileExtensionIsOneOf(path, ts.supportedJSExtensions)) {
+        else if (ts.fileExtensionIsOneOf(path, ts.supportedJSExtensionsFlat)) {
             return "JavaScript";
         }
         else if (ts.fileExtensionIs(path, ".json")) {