@html-validate/commitlint-config 3.4.2 → 3.4.3

package/dist/commitlint.js

@@ -19340,6 +19340,7 @@ var require_typescript = __commonJS({
         createPrinterWithRemoveCommentsNeverAsciiEscape: () => createPrinterWithRemoveCommentsNeverAsciiEscape,
         createPrinterWithRemoveCommentsOmitTrailingSemicolon: () => createPrinterWithRemoveCommentsOmitTrailingSemicolon,
         createProgram: () => createProgram,
+        createProgramDiagnostics: () => createProgramDiagnostics,
         createProgramHost: () => createProgramHost,
         createPropertyNameNodeForIdentifierOrLiteral: () => createPropertyNameNodeForIdentifierOrLiteral,
         createQueue: () => createQueue,
@@ -19509,6 +19510,8 @@ var require_typescript = __commonJS({
         forEachLeadingCommentRange: () => forEachLeadingCommentRange,
         forEachNameInAccessChainWalkingLeft: () => forEachNameInAccessChainWalkingLeft,
         forEachNameOfDefaultExport: () => forEachNameOfDefaultExport,
+        forEachOptionsSyntaxByName: () => forEachOptionsSyntaxByName,
+        forEachProjectReference: () => forEachProjectReference,
         forEachPropertyAssignment: () => forEachPropertyAssignment,
         forEachResolvedProjectReference: () => forEachResolvedProjectReference,
         forEachReturnStatement: () => forEachReturnStatement,
@@ -19748,6 +19751,8 @@ var require_typescript = __commonJS({
         getLeadingCommentRangesOfNode: () => getLeadingCommentRangesOfNode,
         getLeftmostAccessExpression: () => getLeftmostAccessExpression,
         getLeftmostExpression: () => getLeftmostExpression,
+        getLibFileNameFromLibReference: () => getLibFileNameFromLibReference,
+        getLibNameFromLibReference: () => getLibNameFromLibReference,
         getLibraryNameFromLibFileName: () => getLibraryNameFromLibFileName,
         getLineAndCharacterOfPosition: () => getLineAndCharacterOfPosition,
         getLineInfo: () => getLineInfo,
@@ -19820,6 +19825,8 @@ var require_typescript = __commonJS({
         getOptionFromName: () => getOptionFromName,
         getOptionsForLibraryResolution: () => getOptionsForLibraryResolution,
         getOptionsNameMap: () => getOptionsNameMap,
+        getOptionsSyntaxByArrayElementValue: () => getOptionsSyntaxByArrayElementValue,
+        getOptionsSyntaxByValue: () => getOptionsSyntaxByValue,
         getOrCreateEmitNode: () => getOrCreateEmitNode,
         getOrUpdate: () => getOrUpdate,
         getOriginalNode: () => getOriginalNode,
@@ -19856,7 +19863,6 @@ var require_typescript = __commonJS({
         getPrivateIdentifier: () => getPrivateIdentifier,
         getProperties: () => getProperties,
         getProperty: () => getProperty,
-        getPropertyArrayElementValue: () => getPropertyArrayElementValue,
         getPropertyAssignmentAliasLikeExpression: () => getPropertyAssignmentAliasLikeExpression,
         getPropertyNameForPropertyNameNode: () => getPropertyNameForPropertyNameNode,
         getPropertyNameFromType: () => getPropertyNameFromType,
@@ -20767,6 +20773,7 @@ var require_typescript = __commonJS({
         moduleResolutionUsesNodeModules: () => moduleResolutionUsesNodeModules,
         moduleSpecifierToValidIdentifier: () => moduleSpecifierToValidIdentifier,
         moduleSpecifiers: () => ts_moduleSpecifiers_exports,
+        moduleSupportsImportAttributes: () => moduleSupportsImportAttributes,
         moduleSymbolToValidIdentifier: () => moduleSymbolToValidIdentifier,
         moveEmitHelpers: () => moveEmitHelpers,
         moveRangeEnd: () => moveRangeEnd,
@@ -21179,8 +21186,8 @@ var require_typescript = __commonJS({
         zipWith: () => zipWith
       });
       module2.exports = __toCommonJS(typescript_exports);
-      var versionMajorMinor = "5.7";
-      var version = "5.7.3";
+      var versionMajorMinor = "5.8";
+      var version = "5.8.2";
       var Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -25777,6 +25784,7 @@ ${lanes.join("\n")}
         ModuleKind3[ModuleKind3["ES2022"] = 7] = "ES2022";
         ModuleKind3[ModuleKind3["ESNext"] = 99] = "ESNext";
         ModuleKind3[ModuleKind3["Node16"] = 100] = "Node16";
+        ModuleKind3[ModuleKind3["Node18"] = 101] = "Node18";
         ModuleKind3[ModuleKind3["NodeNext"] = 199] = "NodeNext";
         ModuleKind3[ModuleKind3["Preserve"] = 200] = "Preserve";
         return ModuleKind3;
@@ -26261,8 +26269,9 @@ ${lanes.join("\n")}
         OuterExpressionKinds2[OuterExpressionKinds2["NonNullAssertions"] = 4] = "NonNullAssertions";
         OuterExpressionKinds2[OuterExpressionKinds2["PartiallyEmittedExpressions"] = 8] = "PartiallyEmittedExpressions";
         OuterExpressionKinds2[OuterExpressionKinds2["ExpressionsWithTypeArguments"] = 16] = "ExpressionsWithTypeArguments";
-        OuterExpressionKinds2[OuterExpressionKinds2["Assertions"] = 6] = "Assertions";
-        OuterExpressionKinds2[OuterExpressionKinds2["All"] = 31] = "All";
+        OuterExpressionKinds2[OuterExpressionKinds2["Satisfies"] = 32] = "Satisfies";
+        OuterExpressionKinds2[OuterExpressionKinds2["Assertions"] = 38] = "Assertions";
+        OuterExpressionKinds2[OuterExpressionKinds2["All"] = 63] = "All";
         OuterExpressionKinds2[OuterExpressionKinds2["ExcludeJSDocTypeAssertion"] = -2147483648] = "ExcludeJSDocTypeAssertion";
         return OuterExpressionKinds2;
       })(OuterExpressionKinds || {});
@@ -28075,23 +28084,105 @@ ${lanes.join("\n")}
       function getNormalizedPathComponents(path14, currentDirectory) {
         return reducePathComponents(getPathComponents(path14, currentDirectory));
       }
-      function getNormalizedAbsolutePath(fileName, currentDirectory) {
-        return getPathFromPathComponents(getNormalizedPathComponents(fileName, currentDirectory));
+      function getNormalizedAbsolutePath(path14, currentDirectory) {
+        let rootLength = getRootLength(path14);
+        if (rootLength === 0 && currentDirectory) {
+          path14 = combinePaths(currentDirectory, path14);
+          rootLength = getRootLength(path14);
+        } else {
+          path14 = normalizeSlashes(path14);
+        }
+        const simpleNormalized = simpleNormalizePath(path14);
+        if (simpleNormalized !== void 0) {
+          return simpleNormalized.length > rootLength ? removeTrailingDirectorySeparator(simpleNormalized) : simpleNormalized;
+        }
+        const length2 = path14.length;
+        const root = path14.substring(0, rootLength);
+        let normalized;
+        let index = rootLength;
+        let segmentStart = index;
+        let normalizedUpTo = index;
+        let seenNonDotDotSegment = rootLength !== 0;
+        while (index < length2) {
+          segmentStart = index;
+          let ch = path14.charCodeAt(index);
+          while (ch === 47 && index + 1 < length2) {
+            index++;
+            ch = path14.charCodeAt(index);
+          }
+          if (index > segmentStart) {
+            normalized ?? (normalized = path14.substring(0, segmentStart - 1));
+            segmentStart = index;
+          }
+          let segmentEnd = path14.indexOf(directorySeparator, index + 1);
+          if (segmentEnd === -1) {
+            segmentEnd = length2;
+          }
+          const segmentLength = segmentEnd - segmentStart;
+          if (segmentLength === 1 && path14.charCodeAt(index) === 46) {
+            normalized ?? (normalized = path14.substring(0, normalizedUpTo));
+          } else if (segmentLength === 2 && path14.charCodeAt(index) === 46 && path14.charCodeAt(index + 1) === 46) {
+            if (!seenNonDotDotSegment) {
+              if (normalized !== void 0) {
+                normalized += normalized.length === rootLength ? ".." : "/..";
+              } else {
+                normalizedUpTo = index + 2;
+              }
+            } else if (normalized === void 0) {
+              if (normalizedUpTo - 2 >= 0) {
+                normalized = path14.substring(0, Math.max(rootLength, path14.lastIndexOf(directorySeparator, normalizedUpTo - 2)));
+              } else {
+                normalized = path14.substring(0, normalizedUpTo);
+              }
+            } else {
+              const lastSlash = normalized.lastIndexOf(directorySeparator);
+              if (lastSlash !== -1) {
+                normalized = normalized.substring(0, Math.max(rootLength, lastSlash));
+              } else {
+                normalized = root;
+              }
+              if (normalized.length === rootLength) {
+                seenNonDotDotSegment = rootLength !== 0;
+              }
+            }
+          } else if (normalized !== void 0) {
+            if (normalized.length !== rootLength) {
+              normalized += directorySeparator;
+            }
+            seenNonDotDotSegment = true;
+            normalized += path14.substring(segmentStart, segmentEnd);
+          } else {
+            seenNonDotDotSegment = true;
+            normalizedUpTo = segmentEnd;
+          }
+          index = segmentEnd + 1;
+        }
+        return normalized ?? (length2 > rootLength ? removeTrailingDirectorySeparator(path14) : path14);
       }
       function normalizePath(path14) {
         path14 = normalizeSlashes(path14);
+        let normalized = simpleNormalizePath(path14);
+        if (normalized !== void 0) {
+          return normalized;
+        }
+        normalized = getNormalizedAbsolutePath(path14, "");
+        return normalized && hasTrailingDirectorySeparator(path14) ? ensureTrailingDirectorySeparator(normalized) : normalized;
+      }
+      function simpleNormalizePath(path14) {
         if (!relativePathSegmentRegExp.test(path14)) {
           return path14;
         }
-        const simplified = path14.replace(/\/\.\//g, "/").replace(/^\.\//, "");
+        let simplified = path14.replace(/\/\.\//g, "/");
+        if (simplified.startsWith("./")) {
+          simplified = simplified.slice(2);
+        }
         if (simplified !== path14) {
           path14 = simplified;
           if (!relativePathSegmentRegExp.test(path14)) {
             return path14;
           }
         }
-        const normalized = getPathFromPathComponents(reducePathComponents(getPathComponents(path14)));
-        return normalized && hasTrailingDirectorySeparator(path14) ? ensureTrailingDirectorySeparator(normalized) : normalized;
+        return void 0;
       }
       function getPathWithoutRoot(pathComponents2) {
         if (pathComponents2.length === 0) return "";
@@ -28517,6 +28608,7 @@ ${lanes.join("\n")}
         _0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_import_type_where_0_is_imported: diag(1291, 1, "_0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enable_1291", "'{0}' resolves to a type and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'import type' where '{0}' is imported."),
         _0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default: diag(1292, 1, "_0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enable_1292", "'{0}' resolves to a type and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'export type { {0} as default }'."),
         ESM_syntax_is_not_allowed_in_a_CommonJS_module_when_module_is_set_to_preserve: diag(1293, 1, "ESM_syntax_is_not_allowed_in_a_CommonJS_module_when_module_is_set_to_preserve_1293", "ESM syntax is not allowed in a CommonJS module when 'module' is set to 'preserve'."),
+        This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled: diag(1294, 1, "This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled_1294", "This syntax is not allowed when 'erasableSyntaxOnly' is enabled."),
         with_statements_are_not_allowed_in_an_async_function_block: diag(1300, 1, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."),
         await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1308, 1, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."),
         The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level: diag(1309, 1, "The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level_1309", "The current file is a CommonJS module and cannot use 'await' at the top level."),
@@ -28531,8 +28623,8 @@ ${lanes.join("\n")}
         Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1320, 1, "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, 1, "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, 1, "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_es2022_esnext_commonjs_amd_system_umd_node16_or_nodenext: diag(1323, 1, "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd__1323", "Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'es2022', 'esnext', 'commonjs', 'amd', 'system', 'umd', 'node16', or 'nodenext'."),
-        Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_nodenext_or_preserve: diag(1324, 1, "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_nodene_1324", "Dynamic imports only support a second argument when the '--module' option is set to 'esnext', 'node16', 'nodenext', or 'preserve'."),
+        Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node16_node18_or_nodenext: diag(1323, 1, "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd__1323", "Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'es2022', 'esnext', 'commonjs', 'amd', 'system', 'umd', 'node16', 'node18', or 'nodenext'."),
+        Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_node18_nodenext_or_preserve: diag(1324, 1, "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_node18_1324", "Dynamic imports only support a second argument when the '--module' option is set to 'esnext', 'node16', 'node18', 'nodenext', or 'preserve'."),
         Argument_of_dynamic_import_cannot_be_spread_element: diag(1325, 1, "Argument_of_dynamic_import_cannot_be_spread_element_1325", "Argument of dynamic import cannot be spread element."),
         This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments: diag(1326, 1, "This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot__1326", "This use of 'import' is invalid. 'import()' calls can be written, but they must have parentheses and cannot have type arguments."),
         String_literal_with_double_quotes_expected: diag(1327, 1, "String_literal_with_double_quotes_expected_1327", "String literal with double quotes expected."),
@@ -28549,7 +28641,7 @@ ${lanes.join("\n")}
         Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here: diag(1339, 1, "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, 1, "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}')'?"),
         Class_constructor_may_not_be_an_accessor: diag(1341, 1, "Class_constructor_may_not_be_an_accessor_1341", "Class constructor may not be an accessor."),
-        The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node16_or_nodenext: diag(1343, 1, "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system__1343", "The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node16', or 'nodenext'."),
+        The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node16_node18_or_nodenext: diag(1343, 1, "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system__1343", "The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node16', 'node18', or 'nodenext'."),
         A_label_is_not_allowed_here: diag(1344, 1, "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, 1, "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, 1, "This_parameter_is_not_allowed_with_use_strict_directive_1346", "This parameter is not allowed with 'use strict' directive."),
@@ -28579,7 +28671,7 @@ ${lanes.join("\n")}
         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, 1, "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, 3, "_0_was_imported_here_1376", "'{0}' was imported here."),
         _0_was_exported_here: diag(1377, 3, "_0_was_exported_here_1377", "'{0}' was exported here."),
-        Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher: diag(1378, 1, "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_n_1378", "Top-level 'await' expressions are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', 'nodenext', or 'preserve', and the 'target' option is set to 'es2017' or higher."),
+        Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher: diag(1378, 1, "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_n_1378", "Top-level 'await' expressions are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', 'node18', 'nodenext', or 'preserve', 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, 1, "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, 1, "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, 1, "Unexpected_token_Did_you_mean_or_rbrace_1381", "Unexpected token. Did you mean `{'}'}` or `&rbrace;`?"),
@@ -28630,7 +28722,7 @@ ${lanes.join("\n")}
         File_redirects_to_file_0: diag(1429, 3, "File_redirects_to_file_0_1429", "File redirects to file '{0}'"),
         The_file_is_in_the_program_because_Colon: diag(1430, 3, "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, 1, "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_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher: diag(1432, 1, "Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_nod_1432", "Top-level 'for await' loops are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', 'nodenext', or 'preserve', and the 'target' option is set to 'es2017' or higher."),
+        Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher: diag(1432, 1, "Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_nod_1432", "Top-level 'for await' loops are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', 'node18', 'nodenext', or 'preserve', and the 'target' option is set to 'es2017' or higher."),
         Neither_decorators_nor_modifiers_may_be_applied_to_this_parameters: diag(1433, 1, "Neither_decorators_nor_modifiers_may_be_applied_to_this_parameters_1433", "Neither decorators nor modifiers may be applied to 'this' parameters."),
         Unexpected_keyword_or_identifier: diag(1434, 1, "Unexpected_keyword_or_identifier_1434", "Unexpected keyword or identifier."),
         Unknown_keyword_or_identifier_Did_you_mean_0: diag(1435, 1, "Unknown_keyword_or_identifier_Did_you_mean_0_1435", "Unknown keyword or identifier. Did you mean '{0}'?"),
@@ -29272,9 +29364,9 @@ ${lanes.join("\n")}
         Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializers: diag(2818, 1, "Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializer_2818", "Duplicate identifier '{0}'. Compiler reserves name '{1}' when emitting 'super' references in static initializers."),
         Namespace_name_cannot_be_0: diag(2819, 1, "Namespace_name_cannot_be_0_2819", "Namespace name cannot be '{0}'."),
         Type_0_is_not_assignable_to_type_1_Did_you_mean_2: diag(2820, 1, "Type_0_is_not_assignable_to_type_1_Did_you_mean_2_2820", "Type '{0}' is not assignable to type '{1}'. Did you mean '{2}'?"),
-        Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_nodenext_or_preserve: diag(2821, 1, "Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_nodenext_or_preserve_2821", "Import assertions are only supported when the '--module' option is set to 'esnext', 'nodenext', or 'preserve'."),
+        Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_node18_nodenext_or_preserve: diag(2821, 1, "Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_node18_nodenext_or_pres_2821", "Import assertions are only supported when the '--module' option is set to 'esnext', 'node18', 'nodenext', or 'preserve'."),
         Import_assertions_cannot_be_used_with_type_only_imports_or_exports: diag(2822, 1, "Import_assertions_cannot_be_used_with_type_only_imports_or_exports_2822", "Import assertions cannot be used with type-only imports or exports."),
-        Import_attributes_are_only_supported_when_the_module_option_is_set_to_esnext_nodenext_or_preserve: diag(2823, 1, "Import_attributes_are_only_supported_when_the_module_option_is_set_to_esnext_nodenext_or_preserve_2823", "Import attributes are only supported when the '--module' option is set to 'esnext', 'nodenext', or 'preserve'."),
+        Import_attributes_are_only_supported_when_the_module_option_is_set_to_esnext_node18_nodenext_or_preserve: diag(2823, 1, "Import_attributes_are_only_supported_when_the_module_option_is_set_to_esnext_node18_nodenext_or_pres_2823", "Import attributes are only supported when the '--module' option is set to 'esnext', 'node18', 'nodenext', or 'preserve'."),
         Cannot_find_namespace_0_Did_you_mean_1: diag(2833, 1, "Cannot_find_namespace_0_Did_you_mean_1_2833", "Cannot find namespace '{0}'. Did you mean '{1}'?"),
         Relative_import_paths_need_explicit_file_extensions_in_ECMAScript_imports_when_moduleResolution_is_node16_or_nodenext_Consider_adding_an_extension_to_the_import_path: diag(2834, 1, "Relative_import_paths_need_explicit_file_extensions_in_ECMAScript_imports_when_moduleResolution_is_n_2834", "Relative import paths need explicit file extensions in ECMAScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Consider adding an extension to the import path."),
         Relative_import_paths_need_explicit_file_extensions_in_ECMAScript_imports_when_moduleResolution_is_node16_or_nodenext_Did_you_mean_0: diag(2835, 1, "Relative_import_paths_need_explicit_file_extensions_in_ECMAScript_imports_when_moduleResolution_is_n_2835", "Relative import paths need explicit file extensions in ECMAScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Did you mean '{0}'?"),
@@ -29294,7 +29386,7 @@ ${lanes.join("\n")}
         The_initializer_of_an_await_using_declaration_must_be_either_an_object_with_a_Symbol_asyncDispose_or_Symbol_dispose_method_or_be_null_or_undefined: diag(2851, 1, "The_initializer_of_an_await_using_declaration_must_be_either_an_object_with_a_Symbol_asyncDispose_or_2851", "The initializer of an 'await using' declaration must be either an object with a '[Symbol.asyncDispose]()' or '[Symbol.dispose]()' method, or be 'null' or 'undefined'."),
         await_using_statements_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(2852, 1, "await_using_statements_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_2852", "'await using' statements are only allowed within async functions and at the top levels of modules."),
         await_using_statements_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(2853, 1, "await_using_statements_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_th_2853", "'await using' statements 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_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher: diag(2854, 1, "Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_sys_2854", "Top-level 'await using' statements are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', 'nodenext', or 'preserve', and the 'target' option is set to 'es2017' or higher."),
+        Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher: diag(2854, 1, "Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_sys_2854", "Top-level 'await using' statements are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', 'node18', 'nodenext', or 'preserve', and the 'target' option is set to 'es2017' or higher."),
         Class_field_0_defined_by_the_parent_class_is_not_accessible_in_the_child_class_via_super: diag(2855, 1, "Class_field_0_defined_by_the_parent_class_is_not_accessible_in_the_child_class_via_super_2855", "Class field '{0}' defined by the parent class is not accessible in the child class via super."),
         Import_attributes_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls: diag(2856, 1, "Import_attributes_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls_2856", "Import attributes are not allowed on statements that compile to CommonJS 'require' calls."),
         Import_attributes_cannot_be_used_with_type_only_imports_or_exports: diag(2857, 1, "Import_attributes_cannot_be_used_with_type_only_imports_or_exports_2857", "Import attributes cannot be used with type-only imports or exports."),
@@ -29320,6 +29412,7 @@ ${lanes.join("\n")}
         This_import_uses_a_0_extension_to_resolve_to_an_input_TypeScript_file_but_will_not_be_rewritten_during_emit_because_it_is_not_a_relative_path: diag(2877, 1, "This_import_uses_a_0_extension_to_resolve_to_an_input_TypeScript_file_but_will_not_be_rewritten_duri_2877", "This import uses a '{0}' extension to resolve to an input TypeScript file, but will not be rewritten during emit because it is not a relative path."),
         This_import_path_is_unsafe_to_rewrite_because_it_resolves_to_another_project_and_the_relative_path_between_the_projects_output_files_is_not_the_same_as_the_relative_path_between_its_input_files: diag(2878, 1, "This_import_path_is_unsafe_to_rewrite_because_it_resolves_to_another_project_and_the_relative_path_b_2878", "This import path is unsafe to rewrite because it resolves to another project, and the relative path between the projects' output files is not the same as the relative path between its input files."),
         Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found: diag(2879, 1, "Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found_2879", "Using JSX fragments requires fragment factory '{0}' to be in scope, but it could not be found."),
+        Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert: diag(2880, 1, "Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert_2880", "Import assertions have been replaced by import attributes. Use 'with' instead of 'assert'."),
         Import_declaration_0_is_using_private_name_1: diag(4e3, 1, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, 1, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, 1, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -29429,6 +29522,8 @@ ${lanes.join("\n")}
         Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next: diag(4124, 1, "Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_w_4124", "Compiler option '{0}' of value '{1}' is unstable. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'."),
         Each_declaration_of_0_1_differs_in_its_value_where_2_was_expected_but_3_was_given: diag(4125, 1, "Each_declaration_of_0_1_differs_in_its_value_where_2_was_expected_but_3_was_given_4125", "Each declaration of '{0}.{1}' differs in its value, where '{2}' was expected but '{3}' was given."),
         One_value_of_0_1_is_the_string_2_and_the_other_is_assumed_to_be_an_unknown_numeric_value: diag(4126, 1, "One_value_of_0_1_is_the_string_2_and_the_other_is_assumed_to_be_an_unknown_numeric_value_4126", "One value of '{0}.{1}' is the string '{2}', and the other is assumed to be an unknown numeric value."),
+        This_member_cannot_have_an_override_modifier_because_its_name_is_dynamic: diag(4127, 1, "This_member_cannot_have_an_override_modifier_because_its_name_is_dynamic_4127", "This member cannot have an 'override' modifier because its name is dynamic."),
+        This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_name_is_dynamic: diag(4128, 1, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_name_is_dynamic_4128", "This member cannot have a JSDoc comment with an '@override' tag because its name is dynamic."),
         The_current_host_does_not_support_the_0_option: diag(5001, 1, "The_current_host_does_not_support_the_0_option_5001", "The current host does not support the '{0}' option."),
         Cannot_find_the_common_subdirectory_path_for_the_input_files: diag(5009, 1, "Cannot_find_the_common_subdirectory_path_for_the_input_files_5009", "Cannot find the common subdirectory path for the input files."),
         File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: diag(5010, 1, "File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0_5010", "File specification cannot end in a recursive directory wildcard ('**'): '{0}'."),
@@ -30001,11 +30096,13 @@ ${lanes.join("\n")}
         Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types: diag(6718, 3, "Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types_6718", "Specify emit/checking behavior for imports that are only used for types."),
         Require_sufficient_annotation_on_exports_so_other_tools_can_trivially_generate_declaration_files: diag(6719, 3, "Require_sufficient_annotation_on_exports_so_other_tools_can_trivially_generate_declaration_files_6719", "Require sufficient annotation on exports so other tools can trivially generate declaration files."),
         Built_in_iterators_are_instantiated_with_a_TReturn_type_of_undefined_instead_of_any: diag(6720, 3, "Built_in_iterators_are_instantiated_with_a_TReturn_type_of_undefined_instead_of_any_6720", "Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'."),
+        Do_not_allow_runtime_constructs_that_are_not_part_of_ECMAScript: diag(6721, 3, "Do_not_allow_runtime_constructs_that_are_not_part_of_ECMAScript_6721", "Do not allow runtime constructs that are not part of ECMAScript."),
         Default_catch_clause_variables_as_unknown_instead_of_any: diag(6803, 3, "Default_catch_clause_variables_as_unknown_instead_of_any_6803", "Default catch clause variables as 'unknown' instead of 'any'."),
         Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_in_the_output_file_s_format_based_on_the_module_setting: diag(6804, 3, "Do_not_transform_or_elide_any_imports_or_exports_not_marked_as_type_only_ensuring_they_are_written_i_6804", "Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting."),
         Disable_full_type_checking_only_critical_parse_and_emit_errors_will_be_reported: diag(6805, 3, "Disable_full_type_checking_only_critical_parse_and_emit_errors_will_be_reported_6805", "Disable full type checking (only critical parse and emit errors will be reported)."),
         Check_side_effect_imports: diag(6806, 3, "Check_side_effect_imports_6806", "Check side effect imports."),
         This_operation_can_be_simplified_This_shift_is_identical_to_0_1_2: diag(6807, 1, "This_operation_can_be_simplified_This_shift_is_identical_to_0_1_2_6807", "This operation can be simplified. This shift is identical to `{0} {1} {2}`."),
+        Enable_lib_replacement: diag(6808, 3, "Enable_lib_replacement_6808", "Enable lib replacement."),
         one_of_Colon: diag(6900, 3, "one_of_Colon_6900", "one of:"),
         one_or_more_Colon: diag(6901, 3, "one_or_more_Colon_6901", "one or more:"),
         type_Colon: diag(6902, 3, "type_Colon_6902", "type:"),
@@ -36102,6 +36199,9 @@ ${lanes.join("\n")}
               "trunc",
               "fround",
               "cbrt"
+            ],
+            esnext: [
+              "f16round"
             ]
           })),
           Map: new Map(Object.entries({
@@ -36271,6 +36371,10 @@ ${lanes.join("\n")}
               "setBigUint64",
               "getBigInt64",
               "getBigUint64"
+            ],
+            esnext: [
+              "setFloat16",
+              "getFloat16"
             ]
           })),
           BigInt: new Map(Object.entries({
@@ -36374,6 +36478,9 @@ ${lanes.join("\n")}
               "with"
             ]
           })),
+          Float16Array: new Map(Object.entries({
+            esnext: emptyArray
+          })),
           Float32Array: new Map(Object.entries({
             es2022: [
               "at"
@@ -36565,7 +36672,7 @@ ${lanes.join("\n")}
         return (_a2 = symbol.declarations) == null ? void 0 : _a2.find((d) => !isExternalModuleAugmentation(d) && !(isModuleDeclaration(d) && isGlobalScopeAugmentation(d)));
       }
       function isCommonJSContainingModuleKind(kind) {
-        return kind === 1 || kind === 100 || kind === 199;
+        return kind === 1 || 100 <= kind && kind <= 199;
       }
       function isEffectiveExternalModule(node, compilerOptions) {
         return isExternalModule(node) || isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator;
@@ -37287,9 +37394,6 @@ ${lanes.join("\n")}
           return key === propName || key2 && key2 === propName ? callback(property) : void 0;
         });
       }
-      function getPropertyArrayElementValue(objectLiteral, propKey, elementValue) {
-        return forEachPropertyAssignment(objectLiteral, propKey, (property) => isArrayLiteralExpression(property.initializer) ? find(property.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : void 0);
-      }
       function getTsConfigObjectLiteralExpression(tsConfigSourceFile) {
         if (tsConfigSourceFile && tsConfigSourceFile.statements.length) {
           const expression = tsConfigSourceFile.statements[0].expression;
@@ -41245,7 +41349,7 @@ ${lanes.join("\n")}
           dependencies: ["module"],
           computeValue: (compilerOptions) => {
             const target = compilerOptions.target === 0 ? void 0 : compilerOptions.target;
-            return target ?? (compilerOptions.module === 100 && 9 || compilerOptions.module === 199 && 99 || 1);
+            return target ?? (compilerOptions.module === 100 && 9 || compilerOptions.module === 101 && 9 || compilerOptions.module === 199 && 99 || 1);
           }
         },
         module: {
@@ -41264,6 +41368,7 @@ ${lanes.join("\n")}
                   moduleResolution = 2;
                   break;
                 case 100:
+                case 101:
                   moduleResolution = 3;
                   break;
                 case 199:
@@ -41283,7 +41388,11 @@ ${lanes.join("\n")}
         moduleDetection: {
           dependencies: ["module", "target"],
           computeValue: (compilerOptions) => {
-            return compilerOptions.moduleDetection || (_computedOptions.module.computeValue(compilerOptions) === 100 || _computedOptions.module.computeValue(compilerOptions) === 199 ? 3 : 2);
+            if (compilerOptions.moduleDetection !== void 0) {
+              return compilerOptions.moduleDetection;
+            }
+            const moduleKind = _computedOptions.module.computeValue(compilerOptions);
+            return 100 <= moduleKind && moduleKind <= 199 ? 3 : 2;
           }
         },
         isolatedModules: {
@@ -41300,6 +41409,7 @@ ${lanes.join("\n")}
             }
             switch (_computedOptions.module.computeValue(compilerOptions)) {
               case 100:
+              case 101:
               case 199:
               case 200:
                 return true;
@@ -41493,6 +41603,9 @@ ${lanes.join("\n")}
       function moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution) {
         return moduleResolution >= 3 && moduleResolution <= 99 || moduleResolution === 100;
       }
+      function moduleSupportsImportAttributes(moduleKind) {
+        return 101 <= moduleKind && moduleKind <= 199 || moduleKind === 200 || moduleKind === 99;
+      }
       function getStrictOptionValue(compilerOptions, flag) {
         return compilerOptions[flag] === void 0 ? !!compilerOptions.strict : !!compilerOptions[flag];
       }
@@ -42338,7 +42451,7 @@ ${lanes.join("\n")}
         return success && result === 10 && scanner2.getTokenEnd() === s.length + 1 && !(flags & 512) && (!roundTripOnly || s === pseudoBigIntToString({ negative, base10Value: parsePseudoBigInt(scanner2.getTokenValue()) }));
       }
       function isValidTypeOnlyAliasUseSite(useSite) {
-        return !!(useSite.flags & 33554432) || isPartOfTypeQuery(useSite) || isIdentifierInNonEmittingHeritageClause(useSite) || isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(useSite) || !(isExpressionNode(useSite) || isShorthandPropertyNameUseSite(useSite));
+        return !!(useSite.flags & 33554432) || isInJSDoc(useSite) || isPartOfTypeQuery(useSite) || isIdentifierInNonEmittingHeritageClause(useSite) || isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(useSite) || !(isExpressionNode(useSite) || isShorthandPropertyNameUseSite(useSite));
       }
       function isShorthandPropertyNameUseSite(useSite) {
         return isIdentifier(useSite) && isShorthandPropertyAssignment(useSite.parent) && useSite.parent.name === useSite;
@@ -43559,6 +43672,64 @@ ${lanes.join("\n")}
       function isNewScopeNode(node) {
         return isFunctionLike(node) || isJSDocSignature(node) || isMappedTypeNode(node);
       }
+      function getLibNameFromLibReference(libReference) {
+        return toFileNameLowerCase(libReference.fileName);
+      }
+      function getLibFileNameFromLibReference(libReference) {
+        const libName = getLibNameFromLibReference(libReference);
+        return libMap.get(libName);
+      }
+      function forEachResolvedProjectReference(resolvedProjectReferences, cb) {
+        return forEachProjectReference(
+          /*projectReferences*/
+          void 0,
+          resolvedProjectReferences,
+          (resolvedRef, parent2) => resolvedRef && cb(resolvedRef, parent2)
+        );
+      }
+      function forEachProjectReference(projectReferences, resolvedProjectReferences, cbResolvedRef, cbRef) {
+        let seenResolvedRefs;
+        return worker(
+          projectReferences,
+          resolvedProjectReferences,
+          /*parent*/
+          void 0
+        );
+        function worker(projectReferences2, resolvedProjectReferences2, parent2) {
+          if (cbRef) {
+            const result = cbRef(projectReferences2, parent2);
+            if (result) return result;
+          }
+          let skipChildren;
+          return forEach(
+            resolvedProjectReferences2,
+            (resolvedRef, index) => {
+              if (resolvedRef && (seenResolvedRefs == null ? void 0 : seenResolvedRefs.has(resolvedRef.sourceFile.path))) {
+                (skipChildren ?? (skipChildren = /* @__PURE__ */ new Set())).add(resolvedRef);
+                return void 0;
+              }
+              const result = cbResolvedRef(resolvedRef, parent2, index);
+              if (result || !resolvedRef) return result;
+              (seenResolvedRefs || (seenResolvedRefs = /* @__PURE__ */ new Set())).add(resolvedRef.sourceFile.path);
+            }
+          ) || forEach(
+            resolvedProjectReferences2,
+            (resolvedRef) => resolvedRef && !(skipChildren == null ? void 0 : skipChildren.has(resolvedRef)) ? worker(resolvedRef.commandLine.projectReferences, resolvedRef.references, resolvedRef) : void 0
+          );
+        }
+      }
+      function getOptionsSyntaxByArrayElementValue(optionsObject, name, value2) {
+        return optionsObject && getPropertyArrayElementValue(optionsObject, name, value2);
+      }
+      function getPropertyArrayElementValue(objectLiteral, propKey, elementValue) {
+        return forEachPropertyAssignment(objectLiteral, propKey, (property) => isArrayLiteralExpression(property.initializer) ? find(property.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : void 0);
+      }
+      function getOptionsSyntaxByValue(optionsObject, name, value2) {
+        return forEachOptionsSyntaxByName(optionsObject, name, (property) => isStringLiteral(property.initializer) && property.initializer.text === value2 ? property.initializer : void 0);
+      }
+      function forEachOptionsSyntaxByName(optionsObject, name, callback) {
+        return forEachPropertyAssignment(optionsObject, name, callback);
+      }
       function createBaseNodeFactory() {
         let NodeConstructor2;
         let TokenConstructor2;
@@ -46666,6 +46837,8 @@ ${lanes.join("\n")}
           );
           node.whenFalse = parenthesizerRules().parenthesizeBranchOfConditionalExpression(whenFalse);
           node.transformFlags |= propagateChildFlags(node.condition) | propagateChildFlags(node.questionToken) | propagateChildFlags(node.whenTrue) | propagateChildFlags(node.colonToken) | propagateChildFlags(node.whenFalse);
+          node.flowNodeWhenFalse = void 0;
+          node.flowNodeWhenTrue = void 0;
           return node;
         }
         function updateConditionalExpression(node, condition, questionToken, whenTrue, colonToken, whenFalse) {
@@ -48781,7 +48954,7 @@ ${lanes.join("\n")}
         function isIgnorableParen(node) {
           return isParenthesizedExpression(node) && nodeIsSynthesized(node) && nodeIsSynthesized(getSourceMapRange(node)) && nodeIsSynthesized(getCommentRange(node)) && !some(getSyntheticLeadingComments(node)) && !some(getSyntheticTrailingComments(node));
         }
-        function restoreOuterExpressions(outerExpression, innerExpression, kinds = 31) {
+        function restoreOuterExpressions(outerExpression, innerExpression, kinds = 63) {
           if (outerExpression && isOuterExpression(outerExpression, kinds) && !isIgnorableParen(outerExpression)) {
             return updateOuterExpression(
               outerExpression,
@@ -48829,7 +49002,7 @@ ${lanes.join("\n")}
         function createCallBinding(expression, recordTempVariable, languageVersion, cacheIdentifiers = false) {
           const callee = skipOuterExpressions(
             expression,
-            31
+            63
             /* All */
           );
           let thisArg;
@@ -51864,7 +52037,7 @@ ${lanes.join("\n")}
         Debug.assertIsDefined(type);
         return type;
       }
-      function isOuterExpression(node, kinds = 31) {
+      function isOuterExpression(node, kinds = 63) {
         switch (node.kind) {
           case 217:
             if (kinds & -2147483648 && isJSDocTypeAssertion(node)) {
@@ -51873,8 +52046,9 @@ ${lanes.join("\n")}
             return (kinds & 1) !== 0;
           case 216:
           case 234:
-          case 238:
             return (kinds & 2) !== 0;
+          case 238:
+            return (kinds & (2 | 32)) !== 0;
           case 233:
             return (kinds & 16) !== 0;
           case 235:
@@ -51884,13 +52058,13 @@ ${lanes.join("\n")}
         }
         return false;
       }
-      function skipOuterExpressions(node, kinds = 31) {
+      function skipOuterExpressions(node, kinds = 63) {
         while (isOuterExpression(node, kinds)) {
           node = node.expression;
         }
         return node;
       }
-      function walkUpOuterExpressions(node, kinds = 31) {
+      function walkUpOuterExpressions(node, kinds = 63) {
         let parent2 = node.parent;
         while (isOuterExpression(parent2, kinds)) {
           parent2 = parent2.parent;
@@ -61256,6 +61430,7 @@ ${lanes.join("\n")}
               const node = factory2.createExpressionWithTypeArguments(expression, typeArguments);
               const res = finishNode(node, pos);
               if (usedBrace) {
+                skipWhitespace();
                 parseExpected(
                   20
                   /* CloseBraceToken */
@@ -62352,6 +62527,8 @@ ${lanes.join("\n")}
         ["esnext.regexp", "lib.es2024.regexp.d.ts"],
         ["esnext.string", "lib.es2024.string.d.ts"],
         ["esnext.iterator", "lib.esnext.iterator.d.ts"],
+        ["esnext.promise", "lib.esnext.promise.d.ts"],
+        ["esnext.float16", "lib.esnext.float16.d.ts"],
         ["decorators", "lib.decorators.d.ts"],
         ["decorators.legacy", "lib.decorators.legacy.d.ts"]
       ];
@@ -62686,6 +62863,7 @@ ${lanes.join("\n")}
           es2022: 7,
           esnext: 99,
           node16: 100,
+          node18: 101,
           nodenext: 199,
           preserve: 200
           /* Preserve */
@@ -62941,6 +63119,23 @@ ${lanes.join("\n")}
           affectsBuildInfo: true,
           affectsSemanticDiagnostics: true
         },
+        {
+          name: "erasableSyntaxOnly",
+          type: "boolean",
+          category: Diagnostics.Interop_Constraints,
+          description: Diagnostics.Do_not_allow_runtime_constructs_that_are_not_part_of_ECMAScript,
+          defaultValueDescription: false,
+          affectsBuildInfo: true,
+          affectsSemanticDiagnostics: true
+        },
+        {
+          name: "libReplacement",
+          type: "boolean",
+          affectsProgramStructure: true,
+          category: Diagnostics.Language_and_Environment,
+          description: Diagnostics.Enable_lib_replacement,
+          defaultValueDescription: true
+        },
         // Strict Type Checks
         {
           name: "strict",
@@ -67220,9 +67415,7 @@ ${lanes.join("\n")}
       }
       function loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson = true) {
         const packageInfo = considerPackageJson ? getPackageJsonInfo(candidate, onlyRecordFailures, state) : void 0;
-        const packageJsonContent = packageInfo && packageInfo.contents.packageJsonContent;
-        const versionPaths = packageInfo && getVersionPathsOfPackageJsonInfo(packageInfo, state);
-        return withPackageId(packageInfo, loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageJsonContent, versionPaths), state);
+        return withPackageId(packageInfo, loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageInfo), state);
       }
       function getEntrypointsFromPackageJsonInfo(packageJsonInfo, options, host, cache2, resolveJs) {
         if (!resolveJs && packageJsonInfo.contents.resolvedEntrypoints !== void 0) {
@@ -67240,8 +67433,7 @@ ${lanes.join("\n")}
           /*onlyRecordFailures*/
           false,
           loadPackageJsonMainState,
-          packageJsonInfo.contents.packageJsonContent,
-          getVersionPathsOfPackageJsonInfo(packageJsonInfo, loadPackageJsonMainState)
+          packageJsonInfo
         );
         entrypoints = append(entrypoints, mainResolution == null ? void 0 : mainResolution.path);
         if (features & 8 && packageJsonInfo.contents.packageJsonContent.exports) {
@@ -67452,13 +67644,14 @@ ${lanes.join("\n")}
           (_f = state.failedLookupLocations) == null ? void 0 : _f.push(packageJsonPath);
         }
       }
-      function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, jsonContent, versionPaths) {
+      function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageJson) {
+        const versionPaths = packageJson && getVersionPathsOfPackageJsonInfo(packageJson, state);
         let packageFile;
-        if (jsonContent) {
+        if (packageJson && arePathsEqual(packageJson == null ? void 0 : packageJson.packageDirectory, candidate, state.host)) {
           if (state.isConfigLookup) {
-            packageFile = readPackageJsonTSConfigField(jsonContent, candidate, state);
+            packageFile = readPackageJsonTSConfigField(packageJson.contents.packageJsonContent, packageJson.packageDirectory, state);
           } else {
-            packageFile = extensions & 4 && readPackageJsonTypesFields(jsonContent, candidate, state) || extensions & (3 | 4) && readPackageJsonMainField(jsonContent, candidate, state) || void 0;
+            packageFile = extensions & 4 && readPackageJsonTypesFields(packageJson.contents.packageJsonContent, packageJson.packageDirectory, state) || extensions & (3 | 4) && readPackageJsonMainField(packageJson.contents.packageJsonContent, packageJson.packageDirectory, state) || void 0;
           }
         }
         const loader = (extensions2, candidate2, onlyRecordFailures2, state2) => {
@@ -67477,7 +67670,7 @@ ${lanes.join("\n")}
           const features = state2.features;
           const candidateIsFromPackageJsonField = state2.candidateIsFromPackageJsonField;
           state2.candidateIsFromPackageJsonField = true;
-          if ((jsonContent == null ? void 0 : jsonContent.type) !== "module") {
+          if ((packageJson == null ? void 0 : packageJson.contents.packageJsonContent.type) !== "module") {
             state2.features &= ~32;
           }
           const result = nodeLoadModuleByRelativeName(
@@ -67748,6 +67941,7 @@ ${lanes.join("\n")}
       function getLoadModuleFromTargetExportOrImport(extensions, state, cache2, redirectedReference, moduleName2, scope, isImports) {
         return loadModuleFromTargetExportOrImport;
         function loadModuleFromTargetExportOrImport(target, subpath, pattern, key) {
+          var _a2, _b2;
           if (typeof target === "string") {
             if (!pattern && subpath.length > 0 && !endsWith(target, "/")) {
               if (state.traceEnabled) {
@@ -67776,6 +67970,8 @@ ${lanes.join("\n")}
                   redirectedReference,
                   state.conditions
                 );
+                (_a2 = state.failedLookupLocations) == null ? void 0 : _a2.push(...result.failedLookupLocations ?? emptyArray);
+                (_b2 = state.affectingLocations) == null ? void 0 : _b2.push(...result.affectingLocations ?? emptyArray);
                 return toSearchResult(
                   result.resolvedModule ? {
                     path: result.resolvedModule.resolvedFileName,
@@ -67885,20 +68081,20 @@ ${lanes.join("\n")}
             void 0
           );
           function toAbsolutePath(path14) {
-            var _a2, _b2;
+            var _a22, _b22;
             if (path14 === void 0) return path14;
-            return getNormalizedAbsolutePath(path14, (_b2 = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b2.call(_a2));
+            return getNormalizedAbsolutePath(path14, (_b22 = (_a22 = state.host).getCurrentDirectory) == null ? void 0 : _b22.call(_a22));
           }
           function combineDirectoryPath(root, dir) {
             return ensureTrailingDirectorySeparator(combinePaths(root, dir));
           }
           function tryLoadInputFileForPath(finalPath, entry, packagePath, isImports2) {
-            var _a2, _b2, _c2, _d;
+            var _a22, _b22, _c2, _d;
             if (!state.isConfigLookup && (state.compilerOptions.declarationDir || state.compilerOptions.outDir) && !finalPath.includes("/node_modules/") && (state.compilerOptions.configFile ? containsPath(scope.packageDirectory, toAbsolutePath(state.compilerOptions.configFile.fileName), !useCaseSensitiveFileNames(state)) : true)) {
               const getCanonicalFileName = hostGetCanonicalFileName({ useCaseSensitiveFileNames: () => useCaseSensitiveFileNames(state) });
               const commonSourceDirGuesses = [];
               if (state.compilerOptions.rootDir || state.compilerOptions.composite && state.compilerOptions.configFilePath) {
-                const commonDir = toAbsolutePath(getCommonSourceDirectory(state.compilerOptions, () => [], ((_b2 = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b2.call(_a2)) || "", getCanonicalFileName));
+                const commonDir = toAbsolutePath(getCommonSourceDirectory(state.compilerOptions, () => [], ((_b22 = (_a22 = state.host).getCurrentDirectory) == null ? void 0 : _b22.call(_a22)) || "", getCanonicalFileName));
                 commonSourceDirGuesses.push(commonDir);
               } else if (state.requestContainingDirectory) {
                 const requestingFile = toAbsolutePath(combinePaths(state.requestContainingDirectory, "index.ts"));
@@ -67963,8 +68159,8 @@ ${lanes.join("\n")}
             }
             return void 0;
             function getOutputDirectoriesForBaseDirectory(commonSourceDirGuess) {
-              var _a22, _b22;
-              const currentDir = state.compilerOptions.configFile ? ((_b22 = (_a22 = state.host).getCurrentDirectory) == null ? void 0 : _b22.call(_a22)) || "" : commonSourceDirGuess;
+              var _a3, _b3;
+              const currentDir = state.compilerOptions.configFile ? ((_b3 = (_a3 = state.host).getCurrentDirectory) == null ? void 0 : _b3.call(_a3)) || "" : commonSourceDirGuess;
               const candidateDirectories = [];
               if (state.compilerOptions.declarationDir) {
                 candidateDirectories.push(toAbsolutePath(combineDirectoryPath(currentDir, state.compilerOptions.declarationDir)));
@@ -68011,7 +68207,7 @@ ${lanes.join("\n")}
         );
       }
       function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName2, directory, state, typesScopeOnly, cache2, redirectedReference) {
-        const mode = state.features === 0 ? void 0 : state.features & 32 ? 99 : 1;
+        const mode = state.features === 0 ? void 0 : state.features & 32 || state.conditions.includes("import") ? 99 : 1;
         const priorityExtensions = extensions & (1 | 4);
         const secondaryExtensions = extensions & ~(1 | 4);
         if (priorityExtensions) {
@@ -68089,8 +68285,7 @@ ${lanes.join("\n")}
             candidate,
             !nodeModulesDirectoryExists,
             state,
-            packageInfo.contents.packageJsonContent,
-            getVersionPathsOfPackageJsonInfo(packageInfo, state)
+            packageInfo
           );
           return withPackageId(packageInfo, fromDirectory, state);
         }
@@ -68100,10 +68295,9 @@ ${lanes.join("\n")}
             candidate2,
             onlyRecordFailures,
             state2,
-            packageInfo && packageInfo.contents.packageJsonContent,
-            packageInfo && getVersionPathsOfPackageJsonInfo(packageInfo, state2)
+            packageInfo
           );
-          if (!pathAndExtension && packageInfo && (packageInfo.contents.packageJsonContent.exports === void 0 || packageInfo.contents.packageJsonContent.exports === null) && state2.features & 32) {
+          if (!pathAndExtension && !rest && packageInfo && (packageInfo.contents.packageJsonContent.exports === void 0 || packageInfo.contents.packageJsonContent.exports === null) && state2.features & 32) {
             pathAndExtension = loadModuleFromFile(extensions2, combinePaths(candidate2, "index.js"), onlyRecordFailures, state2);
           }
           return withPackageId(packageInfo, pathAndExtension, state2);
@@ -68554,6 +68748,7 @@ ${lanes.join("\n")}
         var preSwitchCaseFlow;
         var activeLabelList;
         var hasExplicitReturn;
+        var inReturnPosition;
         var hasFlowEffects;
         var emitFlags;
         var inStrictMode;
@@ -68626,6 +68821,7 @@ ${lanes.join("\n")}
           currentExceptionTarget = void 0;
           activeLabelList = void 0;
           hasExplicitReturn = false;
+          inReturnPosition = false;
           hasFlowEffects = false;
           inAssignmentPattern = false;
           emitFlags = 0;
@@ -68878,6 +69074,8 @@ ${lanes.join("\n")}
           const saveContainer = container;
           const saveThisParentContainer = thisParentContainer;
           const savedBlockScopeContainer = blockScopeContainer;
+          const savedInReturnPosition = inReturnPosition;
+          if (node.kind === 219 && node.body.kind !== 241) inReturnPosition = true;
           if (containerFlags & 1) {
             if (node.kind !== 219) {
               thisParentContainer = container;
@@ -68959,6 +69157,7 @@ ${lanes.join("\n")}
           } else {
             bindChildren(node);
           }
+          inReturnPosition = savedInReturnPosition;
           container = saveContainer;
           thisParentContainer = saveThisParentContainer;
           blockScopeContainer = savedBlockScopeContainer;
@@ -68980,6 +69179,9 @@ ${lanes.join("\n")}
           const saveInAssignmentPattern = inAssignmentPattern;
           inAssignmentPattern = false;
           if (checkUnreachable(node)) {
+            if (canHaveFlowNode(node) && node.flowNode) {
+              node.flowNode = void 0;
+            }
             bindEachChild(node);
             bindJSDoc(node);
             inAssignmentPattern = saveInAssignmentPattern;
@@ -69175,7 +69377,9 @@ ${lanes.join("\n")}
             case 36:
             case 37:
             case 38:
-              return isNarrowableOperand(expr.left) || isNarrowableOperand(expr.right) || isNarrowingTypeofOperands(expr.right, expr.left) || isNarrowingTypeofOperands(expr.left, expr.right) || (isBooleanLiteral(expr.right) && isNarrowingExpression(expr.left) || isBooleanLiteral(expr.left) && isNarrowingExpression(expr.right));
+              const left2 = skipParentheses(expr.left);
+              const right2 = skipParentheses(expr.right);
+              return isNarrowableOperand(left2) || isNarrowableOperand(right2) || isNarrowingTypeofOperands(right2, left2) || isNarrowingTypeofOperands(left2, right2) || (isBooleanLiteral(right2) && isNarrowingExpression(left2) || isBooleanLiteral(left2) && isNarrowingExpression(right2));
             case 104:
               return isNarrowableOperand(expr.left);
             case 103:
@@ -69367,13 +69571,16 @@ ${lanes.join("\n")}
         function bindForStatement(node) {
           const preLoopLabel = setContinueTarget(node, createLoopLabel());
           const preBodyLabel = createBranchLabel();
+          const preIncrementorLabel = createBranchLabel();
           const postLoopLabel = createBranchLabel();
           bind(node.initializer);
           addAntecedent(preLoopLabel, currentFlow);
           currentFlow = preLoopLabel;
           bindCondition(node.condition, preBodyLabel, postLoopLabel);
           currentFlow = finishFlowLabel(preBodyLabel);
-          bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel);
+          bindIterativeStatement(node.statement, postLoopLabel, preIncrementorLabel);
+          addAntecedent(preIncrementorLabel, currentFlow);
+          currentFlow = finishFlowLabel(preIncrementorLabel);
           bind(node.incrementor);
           addAntecedent(preLoopLabel, currentFlow);
           currentFlow = finishFlowLabel(postLoopLabel);
@@ -69410,7 +69617,10 @@ ${lanes.join("\n")}
           currentFlow = finishFlowLabel(postIfLabel);
         }
         function bindReturnOrThrow(node) {
+          const savedInReturnPosition = inReturnPosition;
+          inReturnPosition = true;
           bind(node.expression);
+          inReturnPosition = savedInReturnPosition;
           if (node.kind === 253) {
             hasExplicitReturn = true;
             if (currentReturnTarget) {
@@ -69775,10 +69985,16 @@ ${lanes.join("\n")}
           hasFlowEffects = false;
           bindCondition(node.condition, trueLabel, falseLabel);
           currentFlow = finishFlowLabel(trueLabel);
+          if (inReturnPosition) {
+            node.flowNodeWhenTrue = currentFlow;
+          }
           bind(node.questionToken);
           bind(node.whenTrue);
           addAntecedent(postExpressionLabel, currentFlow);
           currentFlow = finishFlowLabel(falseLabel);
+          if (inReturnPosition) {
+            node.flowNodeWhenFalse = currentFlow;
+          }
           bind(node.colonToken);
           bind(node.whenFalse);
           addAntecedent(postExpressionLabel, currentFlow);
@@ -73502,6 +73718,7 @@ ${lanes.join("\n")}
           getNumberLiteralType,
           getBigIntType: () => bigintType,
           getBigIntLiteralType,
+          getUnknownType: () => unknownType,
           createPromiseType,
           createArrayType,
           getElementTypeOfArrayType,
@@ -73622,8 +73839,13 @@ ${lanes.join("\n")}
           getMemberOverrideModifierStatus,
           isTypeParameterPossiblyReferenced,
           typeHasCallOrConstructSignatures,
-          getSymbolFlags
+          getSymbolFlags,
+          getTypeArgumentsForResolvedSignature
         };
+        function getTypeArgumentsForResolvedSignature(signature) {
+          if (signature.mapper === void 0) return void 0;
+          return instantiateTypes((signature.target || signature).typeParameters, signature.mapper);
+        }
         function getCandidateSignaturesForStringLiteralCompletions(call, editingArgument) {
           const candidatesSet = /* @__PURE__ */ new Set();
           const candidates = [];
@@ -75104,9 +75326,9 @@ ${lanes.join("\n")}
                 const containerKind = grandparent.parent.kind;
                 if (containerKind === 264 && heritageKind === 96) {
                   error2(errorLocation, Diagnostics.An_interface_cannot_extend_a_primitive_type_like_0_It_can_only_extend_other_named_object_types, unescapeLeadingUnderscores(name));
-                } else if (containerKind === 263 && heritageKind === 96) {
+                } else if (isClassLike(grandparent.parent) && heritageKind === 96) {
                   error2(errorLocation, Diagnostics.A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values, unescapeLeadingUnderscores(name));
-                } else if (containerKind === 263 && heritageKind === 119) {
+                } else if (isClassLike(grandparent.parent) && heritageKind === 119) {
                   error2(errorLocation, Diagnostics.A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types, unescapeLeadingUnderscores(name));
                 }
               } else {
@@ -76320,7 +76542,7 @@ ${lanes.join("\n")}
                   moduleReference
                 );
               }
-              if (errorNode && (moduleResolutionKind === 3 || moduleResolutionKind === 99)) {
+              if (errorNode && (moduleKind === 100 || moduleKind === 101)) {
                 const isSyncImport = currentSourceFile.impliedNodeFormat === 1 && !findAncestor(location, isImportCall) || !!findAncestor(location, isImportEqualsDeclaration);
                 const overrideHost = findAncestor(location, (l2) => isImportTypeNode(l2) || isExportDeclaration(l2) || isImportDeclaration(l2) || isJSDocImportTag(l2));
                 if (isSyncImport && sourceFile.impliedNodeFormat === 99 && !hasResolutionModeOverride(overrideHost)) {
@@ -77656,12 +77878,7 @@ ${lanes.join("\n")}
             enterNewScope(context, node) {
               if (isFunctionLike(node) || isJSDocSignature(node)) {
                 const signature = getSignatureFromDeclaration(node);
-                const expandedParams = getExpandedParameters(
-                  signature,
-                  /*skipUnionExpanding*/
-                  true
-                )[0];
-                return enterNewScope(context, node, expandedParams, signature.typeParameters);
+                return enterNewScope(context, node, signature.parameters, signature.typeParameters);
               } else {
                 const typeParameters = isConditionalTypeNode(node) ? getInferTypeParameters(node) : [getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter))];
                 return enterNewScope(
@@ -78405,7 +78622,7 @@ ${lanes.join("\n")}
               function shouldWriteTypeOfFunctionSymbol() {
                 var _a3;
                 const isStaticMethodSymbol = !!(symbol.flags & 8192) && // typeof static method
-                some(symbol.declarations, (declaration) => isStatic(declaration));
+                some(symbol.declarations, (declaration) => isStatic(declaration) && !isLateBindableIndexSignature(getNameOfDeclaration(declaration)));
                 const isNonLocalFunctionSymbol = !!(symbol.flags & 16) && (symbol.parent || // is exported function symbol
                 forEach(
                   symbol.declarations,
@@ -78734,6 +78951,44 @@ ${lanes.join("\n")}
               ids.unshift(state);
               return ids;
             }
+            function indexInfoToObjectComputedNamesOrSignatureDeclaration(indexInfo, context2, typeNode) {
+              if (indexInfo.components) {
+                const allComponentComputedNamesSerializable = every(indexInfo.components, (e) => {
+                  var _a22;
+                  return !!(e.name && isComputedPropertyName(e.name) && isEntityNameExpression(e.name.expression) && context2.enclosingDeclaration && ((_a22 = isEntityNameVisible(
+                    e.name.expression,
+                    context2.enclosingDeclaration,
+                    /*shouldComputeAliasToMakeVisible*/
+                    false
+                  )) == null ? void 0 : _a22.accessibility) === 0);
+                });
+                if (allComponentComputedNamesSerializable) {
+                  const newComponents = filter(indexInfo.components, (e) => {
+                    return !hasLateBindableName(e);
+                  });
+                  return map(newComponents, (e) => {
+                    trackComputedName(e.name.expression, context2.enclosingDeclaration, context2);
+                    return setTextRange2(
+                      context2,
+                      factory.createPropertySignature(
+                        indexInfo.isReadonly ? [factory.createModifier(
+                          148
+                          /* ReadonlyKeyword */
+                        )] : void 0,
+                        e.name,
+                        (isPropertySignature(e) || isPropertyDeclaration(e) || isMethodSignature(e) || isMethodDeclaration(e) || isGetAccessor(e) || isSetAccessor(e)) && e.questionToken ? factory.createToken(
+                          58
+                          /* QuestionToken */
+                        ) : void 0,
+                        typeNode || typeToTypeNodeHelper(getTypeOfSymbol(e.symbol), context2)
+                      ),
+                      e
+                    );
+                  });
+                }
+              }
+              return [indexInfoToIndexSignatureDeclarationHelper(indexInfo, context2, typeNode)];
+            }
             function createTypeNodesFromResolvedType(resolvedType) {
               if (checkTruncationLength(context)) {
                 if (context.flags & 1) {
@@ -78758,7 +79013,7 @@ ${lanes.join("\n")}
                 typeElements.push(signatureToSignatureDeclarationHelper(signature, 180, context));
               }
               for (const info of resolvedType.indexInfos) {
-                typeElements.push(indexInfoToIndexSignatureDeclarationHelper(info, context, resolvedType.objectFlags & 1024 ? createElidedInformationPlaceholder(context) : void 0));
+                typeElements.push(...indexInfoToObjectComputedNamesOrSignatureDeclaration(info, context, resolvedType.objectFlags & 1024 ? createElidedInformationPlaceholder(context) : void 0));
               }
               const properties = resolvedType.properties;
               if (!properties) {
@@ -79527,7 +79782,7 @@ ${lanes.join("\n")}
             if (!context.tracker.canTrackSymbol) return;
             const firstIdentifier = getFirstIdentifier(accessExpression);
             const name = resolveName(
-              firstIdentifier,
+              enclosingDeclaration,
               firstIdentifier.escapedText,
               111551 | 1048576,
               /*nameNotFoundMessage*/
@@ -79542,6 +79797,24 @@ ${lanes.join("\n")}
                 111551
                 /* Value */
               );
+            } else {
+              const fallback = resolveName(
+                firstIdentifier,
+                firstIdentifier.escapedText,
+                111551 | 1048576,
+                /*nameNotFoundMessage*/
+                void 0,
+                /*isUse*/
+                true
+              );
+              if (fallback) {
+                context.tracker.trackSymbol(
+                  fallback,
+                  enclosingDeclaration,
+                  111551
+                  /* Value */
+                );
+              }
             }
           }
           function lookupSymbolChain(symbol, context, meaning, yieldModuleSymbol) {
@@ -86907,8 +87180,8 @@ ${lanes.join("\n")}
             /* Index */
           );
         }
-        function createIndexInfo(keyType, type, isReadonly, declaration) {
-          return { keyType, type, isReadonly, declaration };
+        function createIndexInfo(keyType, type, isReadonly, declaration, components) {
+          return { keyType, type, isReadonly, declaration, components };
         }
         function getIndexInfosOfSymbol(symbol) {
           const indexSymbol = getIndexSymbol(symbol);
@@ -87446,6 +87719,9 @@ ${lanes.join("\n")}
               case "Number":
                 checkNoTypeArguments(node);
                 return numberType;
+              case "BigInt":
+                checkNoTypeArguments(node);
+                return bigintType;
               case "Boolean":
                 checkNoTypeArguments(node);
                 return booleanType;
@@ -90117,7 +90393,7 @@ ${lanes.join("\n")}
           return result;
         }
         function getIndexInfoWithReadonly(info, readonly) {
-          return info.isReadonly !== readonly ? createIndexInfo(info.keyType, info.type, readonly, info.declaration) : info;
+          return info.isReadonly !== readonly ? createIndexInfo(info.keyType, info.type, readonly, info.declaration, info.components) : info;
         }
         function createLiteralType(flags, value2, symbol, regularType) {
           const type = createTypeWithSymbol(flags, symbol);
@@ -90889,7 +91165,7 @@ ${lanes.join("\n")}
           return type.restrictiveInstantiation;
         }
         function instantiateIndexInfo(info, mapper) {
-          return createIndexInfo(info.keyType, instantiateType(info.type, mapper), info.isReadonly, info.declaration);
+          return createIndexInfo(info.keyType, instantiateType(info.type, mapper), info.isReadonly, info.declaration, info.components);
         }
         function isContextSensitive(node) {
           Debug.assert(node.kind !== 174 || isObjectLiteralMethod(node));
@@ -95250,7 +95526,7 @@ ${lanes.join("\n")}
               }
             }
           }
-          const result = createAnonymousType(type.symbol, members, emptyArray, emptyArray, sameMap(getIndexInfosOfType(type), (info) => createIndexInfo(info.keyType, getWidenedType(info.type), info.isReadonly)));
+          const result = createAnonymousType(type.symbol, members, emptyArray, emptyArray, sameMap(getIndexInfosOfType(type), (info) => createIndexInfo(info.keyType, getWidenedType(info.type), info.isReadonly, info.declaration, info.components)));
           result.objectFlags |= getObjectFlags(type) & (4096 | 262144);
           return result;
         }
@@ -96786,6 +97062,7 @@ ${lanes.join("\n")}
               return target.kind === 108;
             case 235:
             case 217:
+            case 238:
               return isMatchingReference(source.expression, target);
             case 211:
             case 212:
@@ -98826,6 +99103,7 @@ ${lanes.join("\n")}
               if (checkDerived) {
                 return filterType(type, (t) => !isTypeDerivedFrom(t, candidate));
               }
+              type = type.flags & 2 ? unknownUnionType : type;
               const trueType2 = getNarrowedType(
                 type,
                 candidate,
@@ -98834,7 +99112,7 @@ ${lanes.join("\n")}
                 /*checkDerived*/
                 false
               );
-              return filterType(type, (t) => !isTypeSubsetOf(t, trueType2));
+              return recombineUnknownType(filterType(type, (t) => !isTypeSubsetOf(t, trueType2)));
             }
             if (type.flags & 3) {
               return candidate;
@@ -98948,6 +99226,7 @@ ${lanes.join("\n")}
                 return narrowTypeByCallExpression(type, expr, assumeTrue);
               case 217:
               case 235:
+              case 238:
                 return narrowType(type, expr.expression, assumeTrue);
               case 226:
                 return narrowTypeByBinaryExpression(type, expr, assumeTrue);
@@ -99371,8 +99650,9 @@ ${lanes.join("\n")}
             }
             if (isJsxOpeningFragment(node)) {
               const file = getSourceFileOfNode(node);
-              const localJsxNamespace = getLocalJsxNamespace(file);
-              if (localJsxNamespace) {
+              const entity = getJsxFactoryEntity(file);
+              if (entity) {
+                const localJsxNamespace = getFirstIdentifier(entity).escapedText;
                 resolveName(
                   jsxFactoryLocation,
                   localJsxNamespace,
@@ -101732,12 +102012,22 @@ ${lanes.join("\n")}
             /* ESSymbol */
           );
         }
+        function isSymbolWithComputedName(symbol) {
+          var _a2;
+          const firstDecl = (_a2 = symbol.declarations) == null ? void 0 : _a2[0];
+          return firstDecl && isNamedDeclaration(firstDecl) && isComputedPropertyName(firstDecl.name);
+        }
         function getObjectLiteralIndexInfo(isReadonly, offset, properties, keyType) {
+          var _a2;
           const propTypes = [];
+          let components;
           for (let i = offset; i < properties.length; i++) {
             const prop = properties[i];
             if (keyType === stringType && !isSymbolWithSymbolName(prop) || keyType === numberType && isSymbolWithNumericName(prop) || keyType === esSymbolType && isSymbolWithSymbolName(prop)) {
               propTypes.push(getTypeOfSymbol(properties[i]));
+              if (isSymbolWithComputedName(properties[i])) {
+                components = append(components, (_a2 = properties[i].declarations) == null ? void 0 : _a2[0]);
+              }
             }
           }
           const unionType = propTypes.length ? getUnionType(
@@ -101745,7 +102035,14 @@ ${lanes.join("\n")}
             2
             /* Subtype */
           ) : undefinedType;
-          return createIndexInfo(keyType, unionType, isReadonly);
+          return createIndexInfo(
+            keyType,
+            unionType,
+            isReadonly,
+            /*declaration*/
+            void 0,
+            components
+          );
         }
         function getImmediateAliasedSymbol(symbol) {
           Debug.assert((symbol.flags & 2097152) !== 0, "Should only get Alias here.");
@@ -102332,6 +102629,9 @@ ${lanes.join("\n")}
           return getNameFromJsxElementAttributesContainer(JsxNames.ElementAttributesPropertyNameContainer, jsxNamespace);
         }
         function getJsxElementChildrenPropertyName(jsxNamespace) {
+          if (compilerOptions.jsx === 4 || compilerOptions.jsx === 5) {
+            return "children";
+          }
           return getNameFromJsxElementAttributesContainer(JsxNames.ElementChildrenAttributeNameContainer, jsxNamespace);
         }
         function getUninstantiatedJsxSignaturesOfType(elementType, caller) {
@@ -104010,8 +104310,8 @@ ${lanes.join("\n")}
           }
         }
         function getEffectiveCheckNode(argument) {
-          argument = skipParentheses(argument);
-          return isSatisfiesExpression(argument) ? skipParentheses(argument.expression) : argument;
+          const flags = isInJSFile(argument) ? 1 | 32 | -2147483648 : 1 | 32;
+          return skipOuterExpressions(argument, flags);
         }
         function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors2, containingMessageChain, inferenceContext) {
           const errorOutputContainer = { errors: void 0, skipLogging: true };
@@ -104436,11 +104736,16 @@ ${lanes.join("\n")}
           if (!result) {
             result = chooseOverload(candidates, assignableRelation, isSingleNonGenericCandidate, signatureHelpTrailingComma);
           }
+          const links = getNodeLinks(node);
+          if (links.resolvedSignature !== resolvingSignature && !candidatesOutArray) {
+            Debug.assert(links.resolvedSignature);
+            return links.resolvedSignature;
+          }
           if (result) {
             return result;
           }
           result = getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
-          getNodeLinks(node).resolvedSignature = result;
+          links.resolvedSignature = result;
           if (reportErrors2) {
             if (!headMessage && isInstanceof) {
               headMessage = Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_assignable_to_the_first_argument_of_the_right_hand_side_s_Symbol_hasInstance_method;
@@ -105456,7 +105761,7 @@ ${lanes.join("\n")}
             resolutionStart = resolutionTargets.length;
           }
           links.resolvedSignature = resolvingSignature;
-          let result = resolveSignature(
+          const result = resolveSignature(
             node,
             candidatesOutArray,
             checkMode || 0
@@ -105464,9 +105769,6 @@ ${lanes.join("\n")}
           );
           resolutionStart = saveResolutionStart;
           if (result !== resolvingSignature) {
-            if (links.resolvedSignature !== resolvingSignature) {
-              result = links.resolvedSignature;
-            }
             links.resolvedSignature = flowLoopStart === flowLoopCount ? result : cached;
           }
           return result;
@@ -106073,12 +106375,12 @@ ${lanes.join("\n")}
           }
         }
         function checkImportMetaProperty(node) {
-          if (moduleKind === 100 || moduleKind === 199) {
+          if (100 <= moduleKind && moduleKind <= 199) {
             if (getSourceFileOfNode(node).impliedNodeFormat !== 99) {
               error2(node, Diagnostics.The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output);
             }
           } else if (moduleKind < 6 && moduleKind !== 4) {
-            error2(node, Diagnostics.The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node16_or_nodenext);
+            error2(node, Diagnostics.The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node16_node18_or_nodenext);
           }
           const file = getSourceFileOfNode(node);
           Debug.assert(!!(file.flags & 8388608), "Containing file is missing import meta node flag.");
@@ -106953,7 +107255,7 @@ ${lanes.join("\n")}
             }
             return !someType(operandConstraint, (t) => getTypeFacts(t, notEqualFacts) === notEqualFacts);
           }
-          const type = checkExpressionCached(node.expression);
+          const type = getBaseConstraintOrType(checkExpressionCached(node.expression));
           if (!isLiteralType(type)) {
             return false;
           }
@@ -107229,19 +107531,7 @@ ${lanes.join("\n")}
               const exprType = checkExpression(node.body);
               const returnOrPromisedType = returnType && unwrapReturnType(returnType, functionFlags);
               if (returnOrPromisedType) {
-                const effectiveCheckNode = getEffectiveCheckNode(node.body);
-                if ((functionFlags & 3) === 2) {
-                  const awaitedType = checkAwaitedType(
-                    exprType,
-                    /*withAlias*/
-                    false,
-                    effectiveCheckNode,
-                    Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
-                  );
-                  checkTypeAssignableToAndOptionallyElaborate(awaitedType, returnOrPromisedType, effectiveCheckNode, effectiveCheckNode);
-                } else {
-                  checkTypeAssignableToAndOptionallyElaborate(exprType, returnOrPromisedType, effectiveCheckNode, effectiveCheckNode);
-                }
+                checkReturnExpression(node, returnOrPromisedType, node.body, node.body, exprType);
               }
             }
           }
@@ -107295,7 +107585,7 @@ ${lanes.join("\n")}
           }
           if (isReadonlySymbol(symbol)) {
             if (symbol.flags & 4 && isAccessExpression(expr) && expr.expression.kind === 110) {
-              const ctor = getContainingFunction(expr);
+              const ctor = getControlFlowContainer(expr);
               if (!(ctor && (ctor.kind === 176 || isJSConstructor(ctor)))) {
                 return true;
               }
@@ -107326,7 +107616,7 @@ ${lanes.join("\n")}
         function checkReferenceExpression(expr, invalidReferenceMessage, invalidOptionalChainMessage) {
           const node = skipOuterExpressions(
             expr,
-            6 | 1
+            38 | 1
             /* Parentheses */
           );
           if (node.kind !== 80 && !isAccessExpression(node)) {
@@ -107399,6 +107689,7 @@ ${lanes.join("\n")}
                 }
                 switch (moduleKind) {
                   case 100:
+                  case 101:
                   case 199:
                     if (sourceFile.impliedNodeFormat === 1) {
                       span ?? (span = getSpanOfTokenAtPosition(sourceFile, node.pos));
@@ -107419,7 +107710,7 @@ ${lanes.join("\n")}
                   // fallthrough
                   default:
                     span ?? (span = getSpanOfTokenAtPosition(sourceFile, node.pos));
-                    const message2 = isAwaitExpression(node) ? Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher : Diagnostics.Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher;
+                    const message2 = isAwaitExpression(node) ? Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher : Diagnostics.Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher;
                     diagnostics.add(createFileDiagnostic(sourceFile, span.start, span.length, message2));
                     hasError = true;
                     break;
@@ -108059,7 +108350,7 @@ ${lanes.join("\n")}
             }
             const leftTarget = skipOuterExpressions(
               left2,
-              31
+              63
               /* All */
             );
             const nullishSemantics = getSyntacticNullishnessSemantics(leftTarget);
@@ -109460,6 +109751,9 @@ ${lanes.join("\n")}
             31
             /* ParameterPropertyModifier */
           )) {
+            if (compilerOptions.erasableSyntaxOnly) {
+              error2(node, Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled);
+            }
             if (!(func.kind === 176 && nodeIsPresent(func.body))) {
               error2(node, Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
             }
@@ -112959,7 +113253,6 @@ ${lanes.join("\n")}
           }
           const signature = getSignatureFromDeclaration(container);
           const returnType = getReturnTypeOfSignature(signature);
-          const functionFlags = getFunctionFlags(container);
           if (strictNullChecks || node.expression || returnType.flags & 131072) {
             const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
             if (container.kind === 178) {
@@ -112967,26 +113260,57 @@ ${lanes.join("\n")}
                 error2(node, Diagnostics.Setters_cannot_return_a_value);
               }
             } else if (container.kind === 176) {
-              if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression)) {
+              const exprType2 = node.expression ? checkExpressionCached(node.expression) : undefinedType;
+              if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType2, returnType, node, node.expression)) {
                 error2(node, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
               }
             } else if (getReturnTypeFromAnnotation(container)) {
-              const unwrappedReturnType = unwrapReturnType(returnType, functionFlags) ?? returnType;
-              const unwrappedExprType = functionFlags & 2 ? checkAwaitedType(
-                exprType,
-                /*withAlias*/
-                false,
-                node,
-                Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
-              ) : exprType;
-              if (unwrappedReturnType) {
-                checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, node, node.expression);
-              }
+              const unwrappedReturnType = unwrapReturnType(returnType, getFunctionFlags(container)) ?? returnType;
+              checkReturnExpression(container, unwrappedReturnType, node, node.expression, exprType);
             }
           } else if (container.kind !== 176 && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeUndefinedVoidOrAny(container, returnType)) {
             error2(node, Diagnostics.Not_all_code_paths_return_a_value);
           }
         }
+        function checkReturnExpression(container, unwrappedReturnType, node, expr, exprType, inConditionalExpression = false) {
+          const excludeJSDocTypeAssertions = isInJSFile(node);
+          const functionFlags = getFunctionFlags(container);
+          if (expr) {
+            const unwrappedExpr = skipParentheses(expr, excludeJSDocTypeAssertions);
+            if (isConditionalExpression(unwrappedExpr)) {
+              checkReturnExpression(
+                container,
+                unwrappedReturnType,
+                node,
+                unwrappedExpr.whenTrue,
+                checkExpression(unwrappedExpr.whenTrue),
+                /*inConditionalExpression*/
+                true
+              );
+              checkReturnExpression(
+                container,
+                unwrappedReturnType,
+                node,
+                unwrappedExpr.whenFalse,
+                checkExpression(unwrappedExpr.whenFalse),
+                /*inConditionalExpression*/
+                true
+              );
+              return;
+            }
+          }
+          const inReturnStatement = node.kind === 253;
+          const unwrappedExprType = functionFlags & 2 ? checkAwaitedType(
+            exprType,
+            /*withAlias*/
+            false,
+            node,
+            Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
+          ) : exprType;
+          const effectiveExpr = expr && getEffectiveCheckNode(expr);
+          const errorNode = inReturnStatement && !inConditionalExpression ? node : effectiveExpr;
+          checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, effectiveExpr);
+        }
         function checkWithStatement(node) {
           if (!checkGrammarStatementInAmbientContext(node)) {
             if (node.flags & 65536) {
@@ -113118,7 +113442,7 @@ ${lanes.join("\n")}
           const typeDeclaration = symbol.valueDeclaration;
           if (typeDeclaration && isClassLike(typeDeclaration)) {
             for (const member of typeDeclaration.members) {
-              if (!isStatic(member) && !hasBindableName(member)) {
+              if ((!isStaticIndex && !isStatic(member) || isStaticIndex && isStatic(member)) && !hasBindableName(member)) {
                 const symbol2 = getSymbolOfDeclaration(member);
                 checkIndexConstraintForProperty(type, symbol2, getTypeOfExpression(member.name.expression), getNonMissingTypeOfSymbol(symbol2));
               }
@@ -113604,6 +113928,13 @@ ${lanes.join("\n")}
         function checkMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, memberHasOverrideModifier, memberHasAbstractModifier, memberIsStatic, memberIsParameterProperty, member, errorNode) {
           const isJs = isInJSFile(node);
           const nodeInAmbientContext = !!(node.flags & 33554432);
+          if (memberHasOverrideModifier && (member == null ? void 0 : member.valueDeclaration) && isClassElement(member.valueDeclaration) && member.valueDeclaration.name && isNonBindableDynamicName(member.valueDeclaration.name)) {
+            error2(
+              errorNode,
+              isJs ? Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_name_is_dynamic : Diagnostics.This_member_cannot_have_an_override_modifier_because_its_name_is_dynamic
+            );
+            return 2;
+          }
           if (baseWithThis && (memberHasOverrideModifier || compilerOptions.noImplicitOverride)) {
             const thisType = memberIsStatic ? staticType : typeWithThis;
             const baseType = memberIsStatic ? baseStaticType : baseWithThis;
@@ -114220,6 +114551,9 @@ ${lanes.join("\n")}
           checkCollisionsForDeclarationName(node, node.name);
           checkExportsOnMergedDeclarations(node);
           node.members.forEach(checkEnumMember);
+          if (compilerOptions.erasableSyntaxOnly && !(node.flags & 33554432)) {
+            error2(node, Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled);
+          }
           computeEnumMemberValues(node);
           const enumSymbol = getSymbolOfDeclaration(node);
           const firstDeclaration = getDeclarationOfKind(enumSymbol, node.kind);
@@ -114321,6 +114655,9 @@ ${lanes.join("\n")}
             checkExportsOnMergedDeclarations(node);
             const symbol = getSymbolOfDeclaration(node);
             if (symbol.flags & 512 && !inAmbientContext && isInstantiatedModule(node, shouldPreserveConstEnums(compilerOptions))) {
+              if (compilerOptions.erasableSyntaxOnly) {
+                error2(node.name, Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled);
+              }
               if (getIsolatedModules(compilerOptions) && !getSourceFileOfNode(node).externalModuleIndicator) {
                 error2(node.name, Diagnostics.Namespaces_are_not_allowed_in_global_script_files_when_0_is_enabled_If_this_file_is_not_intended_to_be_a_global_script_set_moduleDetection_to_force_or_add_an_empty_export_statement, isolatedModulesLikeFlagName);
               }
@@ -114659,10 +114996,20 @@ ${lanes.join("\n")}
             if (validForTypeAttributes && override) {
               return;
             }
-            const mode = moduleKind === 199 && declaration.moduleSpecifier && getEmitSyntaxForModuleSpecifierExpression(declaration.moduleSpecifier);
-            if (mode !== 99 && moduleKind !== 99 && moduleKind !== 200) {
-              const message2 = isImportAttributes2 ? moduleKind === 199 ? Diagnostics.Import_attributes_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls : Diagnostics.Import_attributes_are_only_supported_when_the_module_option_is_set_to_esnext_nodenext_or_preserve : moduleKind === 199 ? Diagnostics.Import_assertions_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls : Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_nodenext_or_preserve;
-              return grammarErrorOnNode(node, message2);
+            if (!moduleSupportsImportAttributes(moduleKind)) {
+              return grammarErrorOnNode(
+                node,
+                isImportAttributes2 ? Diagnostics.Import_attributes_are_only_supported_when_the_module_option_is_set_to_esnext_node18_nodenext_or_preserve : Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_node18_nodenext_or_preserve
+              );
+            }
+            if (moduleKind === 199 && !isImportAttributes2) {
+              return grammarErrorOnFirstToken(node, Diagnostics.Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert);
+            }
+            if (declaration.moduleSpecifier && getEmitSyntaxForModuleSpecifierExpression(declaration.moduleSpecifier) === 1) {
+              return grammarErrorOnNode(
+                node,
+                isImportAttributes2 ? Diagnostics.Import_attributes_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls : Diagnostics.Import_assertions_are_not_allowed_on_statements_that_compile_to_CommonJS_require_calls
+              );
             }
             const isTypeOnly = isJSDocImportTag(declaration) || (isImportDeclaration(declaration) ? (_a2 = declaration.importClause) == null ? void 0 : _a2.isTypeOnly : declaration.isTypeOnly);
             if (isTypeOnly) {
@@ -114707,7 +115054,7 @@ ${lanes.join("\n")}
                   }
                 }
               }
-              if (!importClause.isTypeOnly && moduleKind === 199 && isOnlyImportableAsDefault(node.moduleSpecifier, resolvedModule) && !hasTypeJsonImportAttribute(node)) {
+              if (!importClause.isTypeOnly && 101 <= moduleKind && moduleKind <= 199 && isOnlyImportableAsDefault(node.moduleSpecifier, resolvedModule) && !hasTypeJsonImportAttribute(node)) {
                 error2(node.moduleSpecifier, Diagnostics.Importing_a_JSON_file_into_an_ECMAScript_module_requires_a_type_Colon_json_import_attribute_when_module_is_set_to_0, ModuleKind[moduleKind]);
               }
             } else if (noUncheckedSideEffectImports && !importClause) {
@@ -114727,6 +115074,9 @@ ${lanes.join("\n")}
             return;
           }
           checkGrammarModifiers(node);
+          if (compilerOptions.erasableSyntaxOnly && !(node.flags & 33554432)) {
+            error2(node, Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled);
+          }
           if (isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
             checkImportBinding(node);
             markLinkedReferences(
@@ -114871,6 +115221,9 @@ ${lanes.join("\n")}
           if (checkGrammarModuleElementContext(node, illegalContextMessage)) {
             return;
           }
+          if (compilerOptions.erasableSyntaxOnly && node.isExportEquals && !(node.flags & 33554432)) {
+            error2(node, Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled);
+          }
           const container = node.parent.kind === 307 ? node.parent : node.parent.parent;
           if (container.kind === 267 && !isAmbientModule(container)) {
             if (node.isExportEquals) {
@@ -115914,7 +116267,7 @@ ${lanes.join("\n")}
               name,
               meaning,
               /*ignoreErrors*/
-              false,
+              true,
               /*dontResolveAlias*/
               true
             );
@@ -115924,8 +116277,9 @@ ${lanes.join("\n")}
             return resolveEntityName(
               name,
               /*meaning*/
-              1
-              /* FunctionScopedVariable */
+              1,
+              /*ignoreErrors*/
+              true
             );
           }
           return void 0;
@@ -116116,8 +116470,9 @@ ${lanes.join("\n")}
           if (location && location.kind === 304) {
             return resolveEntityName(
               location.name,
-              111551 | 2097152
-              /* Alias */
+              111551 | 2097152,
+              /*ignoreErrors*/
+              true
             );
           }
           return void 0;
@@ -116129,15 +116484,17 @@ ${lanes.join("\n")}
               // Skip for invalid syntax like this: export { "x" }
               resolveEntityName(
                 name,
-                111551 | 788968 | 1920 | 2097152
-                /* Alias */
+                111551 | 788968 | 1920 | 2097152,
+                /*ignoreErrors*/
+                true
               )
             );
           } else {
             return resolveEntityName(
               node,
-              111551 | 788968 | 1920 | 2097152
-              /* Alias */
+              111551 | 788968 | 1920 | 2097152,
+              /*ignoreErrors*/
+              true
             );
           }
         }
@@ -117174,6 +117531,44 @@ ${lanes.join("\n")}
                 for (const info of infoList) {
                   if (info.declaration) continue;
                   if (info === anyBaseTypeIndexInfo) continue;
+                  if (info.components) {
+                    const allComponentComputedNamesSerializable = every(info.components, (e) => {
+                      var _a2;
+                      return !!(e.name && isComputedPropertyName(e.name) && isEntityNameExpression(e.name.expression) && enclosing && ((_a2 = isEntityNameVisible(
+                        e.name.expression,
+                        enclosing,
+                        /*shouldComputeAliasToMakeVisible*/
+                        false
+                      )) == null ? void 0 : _a2.accessibility) === 0);
+                    });
+                    if (allComponentComputedNamesSerializable) {
+                      const newComponents = filter(info.components, (e) => {
+                        return !hasLateBindableName(e);
+                      });
+                      result.push(...map(newComponents, (e) => {
+                        trackComputedName(e.name.expression);
+                        const mods = infoList === staticInfos ? [factory.createModifier(
+                          126
+                          /* StaticKeyword */
+                        )] : void 0;
+                        return factory.createPropertyDeclaration(
+                          append(mods, info.isReadonly ? factory.createModifier(
+                            148
+                            /* ReadonlyKeyword */
+                          ) : void 0),
+                          e.name,
+                          (isPropertySignature(e) || isPropertyDeclaration(e) || isMethodSignature(e) || isMethodDeclaration(e) || isGetAccessor(e) || isSetAccessor(e)) && e.questionToken ? factory.createToken(
+                            58
+                            /* QuestionToken */
+                          ) : void 0,
+                          nodeBuilder.typeToTypeNode(getTypeOfSymbol(e.symbol), enclosing, flags, internalFlags, tracker),
+                          /*initializer*/
+                          void 0
+                        );
+                      }));
+                      continue;
+                    }
+                  }
                   const node = nodeBuilder.indexInfoToIndexSignatureDeclaration(info, enclosing, flags, internalFlags, tracker);
                   if (node && infoList === staticInfos) {
                     (node.modifiers || (node.modifiers = factory.createNodeArray())).unshift(factory.createModifier(
@@ -117187,6 +117582,27 @@ ${lanes.join("\n")}
                 }
               }
               return result;
+              function trackComputedName(accessExpression) {
+                if (!tracker.trackSymbol) return;
+                const firstIdentifier = getFirstIdentifier(accessExpression);
+                const name = resolveName(
+                  firstIdentifier,
+                  firstIdentifier.escapedText,
+                  111551 | 1048576,
+                  /*nameNotFoundMessage*/
+                  void 0,
+                  /*isUse*/
+                  true
+                );
+                if (name) {
+                  tracker.trackSymbol(
+                    name,
+                    enclosing,
+                    111551
+                    /* Value */
+                  );
+                }
+              }
             }
           };
           function isImportRequiredByAugmentation(node) {
@@ -118311,6 +118727,7 @@ ${lanes.join("\n")}
                   }
                   switch (moduleKind) {
                     case 100:
+                    case 101:
                     case 199:
                       if (sourceFile.impliedNodeFormat === 1) {
                         diagnostics.add(
@@ -118329,7 +118746,7 @@ ${lanes.join("\n")}
                     // fallthrough
                     default:
                       diagnostics.add(
-                        createDiagnosticForNode(forInOrOfStatement.awaitModifier, Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher)
+                        createDiagnosticForNode(forInOrOfStatement.awaitModifier, Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher)
                       );
                       break;
                   }
@@ -118491,7 +118908,7 @@ ${lanes.join("\n")}
           }
         }
         function checkGrammarForInvalidDynamicName(node, message2) {
-          if (isNonBindableDynamicName(node)) {
+          if (isNonBindableDynamicName(node) && !isEntityNameExpression(isElementAccessExpression(node) ? skipParentheses(node.argumentExpression) : node.expression)) {
             return grammarErrorOnNode(node, message2);
           }
         }
@@ -118958,17 +119375,17 @@ ${lanes.join("\n")}
             return grammarErrorOnNode(node, Diagnostics.ESM_syntax_is_not_allowed_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled);
           }
           if (moduleKind === 5) {
-            return grammarErrorOnNode(node, Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node16_or_nodenext);
+            return grammarErrorOnNode(node, Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node16_node18_or_nodenext);
           }
           if (node.typeArguments) {
             return grammarErrorOnNode(node, Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments);
           }
           const nodeArguments = node.arguments;
-          if (moduleKind !== 99 && moduleKind !== 199 && moduleKind !== 100 && moduleKind !== 200) {
+          if (!(100 <= moduleKind && moduleKind <= 199) && moduleKind !== 99 && moduleKind !== 200) {
             checkGrammarForDisallowedTrailingComma(nodeArguments);
             if (nodeArguments.length > 1) {
               const importAttributesArgument = nodeArguments[1];
-              return grammarErrorOnNode(importAttributesArgument, Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_nodenext_or_preserve);
+              return grammarErrorOnNode(importAttributesArgument, Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_node18_nodenext_or_preserve);
             }
           }
           if (nodeArguments.length === 0 || nodeArguments.length > 2) {
@@ -123992,7 +124409,7 @@ ${lanes.join("\n")}
           return updated;
         }
         function visitParenthesizedExpression(node) {
-          const innerExpression = skipOuterExpressions(node.expression, ~(6 | 16));
+          const innerExpression = skipOuterExpressions(node.expression, ~(38 | 16));
           if (isAssertionExpression(innerExpression) || isSatisfiesExpression(innerExpression)) {
             const expression = visitNode(node.expression, visitor, isExpression);
             Debug.assert(expression);
@@ -143681,7 +144098,7 @@ ${lanes.join("\n")}
               if (node === (importsAndRequiresToRewriteOrShim == null ? void 0 : importsAndRequiresToRewriteOrShim[0])) {
                 return visitImportOrRequireCall(importsAndRequiresToRewriteOrShim.shift());
               }
-              break;
+            // fallthrough
             default:
               if ((importsAndRequiresToRewriteOrShim == null ? void 0 : importsAndRequiresToRewriteOrShim.length) && rangeContainsRange(node, importsAndRequiresToRewriteOrShim[0])) {
                 return visitEachChild(node, visitor, context);
@@ -144533,11 +144950,7 @@ ${lanes.join("\n")}
           if (isSetAccessor(node.parent)) {
             return createAccessorTypeError(node.parent);
           }
-          const addUndefined = resolver.requiresAddingImplicitUndefined(
-            node,
-            /*enclosingDeclaration*/
-            void 0
-          );
+          const addUndefined = resolver.requiresAddingImplicitUndefined(node, node.parent);
           if (!addUndefined && node.initializer) {
             return createExpressionError(node.initializer);
           }
@@ -146334,6 +146747,7 @@ ${lanes.join("\n")}
           case 6:
           case 5:
           case 100:
+          case 101:
           case 199:
           case 1:
             return transformImpliedNodeFormatDependentModule;
@@ -153197,45 +153611,6 @@ ${lanes.join("\n")}
         }
         return resolutions;
       }
-      function forEachResolvedProjectReference(resolvedProjectReferences, cb) {
-        return forEachProjectReference(
-          /*projectReferences*/
-          void 0,
-          resolvedProjectReferences,
-          (resolvedRef, parent2) => resolvedRef && cb(resolvedRef, parent2)
-        );
-      }
-      function forEachProjectReference(projectReferences, resolvedProjectReferences, cbResolvedRef, cbRef) {
-        let seenResolvedRefs;
-        return worker(
-          projectReferences,
-          resolvedProjectReferences,
-          /*parent*/
-          void 0
-        );
-        function worker(projectReferences2, resolvedProjectReferences2, parent2) {
-          if (cbRef) {
-            const result = cbRef(projectReferences2, parent2);
-            if (result) return result;
-          }
-          let skipChildren;
-          return forEach(
-            resolvedProjectReferences2,
-            (resolvedRef, index) => {
-              if (resolvedRef && (seenResolvedRefs == null ? void 0 : seenResolvedRefs.has(resolvedRef.sourceFile.path))) {
-                (skipChildren ?? (skipChildren = /* @__PURE__ */ new Set())).add(resolvedRef);
-                return void 0;
-              }
-              const result = cbResolvedRef(resolvedRef, parent2, index);
-              if (result || !resolvedRef) return result;
-              (seenResolvedRefs || (seenResolvedRefs = /* @__PURE__ */ new Set())).add(resolvedRef.sourceFile.path);
-            }
-          ) || forEach(
-            resolvedProjectReferences2,
-            (resolvedRef) => resolvedRef && !(skipChildren == null ? void 0 : skipChildren.has(resolvedRef)) ? worker(resolvedRef.commandLine.projectReferences, resolvedRef.references, resolvedRef) : void 0
-          );
-        }
-      }
       var inferredTypesContainingFile = "__inferred type names__.ts";
       function getInferredLibraryNameResolveFrom(options, currentDirectory, libFileName) {
         const containingDirectory = options.configFilePath ? getDirectoryPath(options.configFilePath) : currentDirectory;
@@ -153251,13 +153626,6 @@ ${lanes.join("\n")}
         }
         return "@typescript/lib-" + path14;
       }
-      function getLibNameFromLibReference(libReference) {
-        return toFileNameLowerCase(libReference.fileName);
-      }
-      function getLibFileNameFromLibReference(libReference) {
-        const libName = getLibNameFromLibReference(libReference);
-        return libMap.get(libName);
-      }
       function isReferencedFile(reason) {
         switch (reason == null ? void 0 : reason.kind) {
           case 3:
@@ -153492,11 +153860,13 @@ ${lanes.join("\n")}
           typeScriptVersion: typeScriptVersion3
         };
       }
-      function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) {
+      function createProgram(_rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) {
         var _a2, _b2, _c2, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
-        const createProgramOptions = isArray(rootNamesOrOptions) ? createCreateProgramOptions(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) : rootNamesOrOptions;
-        const { rootNames, options, configFileParsingDiagnostics, projectReferences, typeScriptVersion: typeScriptVersion3 } = createProgramOptions;
-        let { oldProgram } = createProgramOptions;
+        let _createProgramOptions = isArray(_rootNamesOrOptions) ? createCreateProgramOptions(_rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) : _rootNamesOrOptions;
+        const { rootNames, options, configFileParsingDiagnostics, projectReferences, typeScriptVersion: typeScriptVersion3, host: createProgramOptionsHost } = _createProgramOptions;
+        let { oldProgram } = _createProgramOptions;
+        _createProgramOptions = void 0;
+        _rootNamesOrOptions = void 0;
         for (const option of commandLineOptionOfCustomType) {
           if (hasProperty(options, option.name)) {
             if (typeof options[option.name] === "string") {
@@ -153509,16 +153879,12 @@ ${lanes.join("\n")}
         let processingOtherFiles;
         let files;
         let symlinks;
-        let commonSourceDirectory;
         let typeChecker;
         let classifiableNames;
-        let fileReasons = createMultiMap();
         let filesWithReferencesProcessed;
-        let fileReasonsToChain;
-        let reasonToRelatedInfo;
         let cachedBindAndCheckDiagnosticsForFile;
         let cachedDeclarationDiagnosticsForFile;
-        let fileProcessingDiagnostics;
+        const programDiagnostics = createProgramDiagnostics(getCompilerOptionsObjectLiteralSyntax);
         let automaticTypeDirectiveNames;
         let automaticTypeDirectiveResolutions;
         let resolvedLibReferences;
@@ -153540,13 +153906,12 @@ ${lanes.join("\n")}
           true
         );
         mark("beforeProgram");
-        const host = createProgramOptions.host || createCompilerHost(options);
+        const host = createProgramOptionsHost || createCompilerHost(options);
         const configParsingHost = parseConfigHostFromCompilerHostLike(host);
         let skipDefaultLib = options.noLib;
         const getDefaultLibraryFileName = memoize(() => host.getDefaultLibFileName(options));
         const defaultLibraryPath = host.getDefaultLibLocation ? host.getDefaultLibLocation() : getDirectoryPath(getDefaultLibraryFileName());
-        const programDiagnostics = createDiagnosticCollection();
-        let lazyProgramDiagnosticExplainingFile = [];
+        let skipVerifyCompilerOptions = false;
         const currentDirectory = host.getCurrentDirectory();
         const supportedExtensions = getSupportedExtensions(options);
         const supportedExtensionsWithJsonIfResolveJsonModule = getSupportedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);
@@ -153831,7 +154196,7 @@ ${lanes.join("\n")}
           getTypeCount: () => getTypeChecker().getTypeCount(),
           getInstantiationCount: () => getTypeChecker().getInstantiationCount(),
           getRelationCacheSizes: () => getTypeChecker().getRelationCacheSizes(),
-          getFileProcessingDiagnostics: () => fileProcessingDiagnostics,
+          getFileProcessingDiagnostics: () => programDiagnostics.getFileProcessingDiagnostics(),
           getAutomaticTypeDirectiveNames: () => automaticTypeDirectiveNames,
           getAutomaticTypeDirectiveResolutions: () => automaticTypeDirectiveResolutions,
           isSourceFileFromExternalLibrary,
@@ -153847,6 +154212,7 @@ ${lanes.join("\n")}
           resolvedModules,
           resolvedTypeReferenceDirectiveNames,
           resolvedLibReferences,
+          getProgramDiagnosticsContainer: () => programDiagnostics,
           getResolvedModule,
           getResolvedModuleFromModuleSpecifier,
           getResolvedTypeReferenceDirective,
@@ -153879,70 +154245,19 @@ ${lanes.join("\n")}
           realpath: (_o = host.realpath) == null ? void 0 : _o.bind(host),
           useCaseSensitiveFileNames: () => host.useCaseSensitiveFileNames(),
           getCanonicalFileName,
-          getFileIncludeReasons: () => fileReasons,
+          getFileIncludeReasons: () => programDiagnostics.getFileReasons(),
           structureIsReused,
           writeFile: writeFile22,
           getGlobalTypingsCacheLocation: maybeBind(host, host.getGlobalTypingsCacheLocation)
         };
         onProgramCreateComplete();
-        verifyCompilerOptions();
+        if (!skipVerifyCompilerOptions) {
+          verifyCompilerOptions();
+        }
         mark("afterProgram");
         measure("Program", "beforeProgram", "afterProgram");
         (_p = tracing) == null ? void 0 : _p.pop();
         return program;
-        function updateAndGetProgramDiagnostics() {
-          if (lazyProgramDiagnosticExplainingFile) {
-            fileProcessingDiagnostics == null ? void 0 : fileProcessingDiagnostics.forEach((diagnostic) => {
-              switch (diagnostic.kind) {
-                case 1:
-                  return programDiagnostics.add(
-                    createDiagnosticExplainingFile(
-                      diagnostic.file && getSourceFileByPath(diagnostic.file),
-                      diagnostic.fileProcessingReason,
-                      diagnostic.diagnostic,
-                      diagnostic.args || emptyArray
-                    )
-                  );
-                case 0:
-                  return programDiagnostics.add(filePreprocessingLibreferenceDiagnostic(diagnostic));
-                case 2:
-                  return diagnostic.diagnostics.forEach((d) => programDiagnostics.add(d));
-                default:
-                  Debug.assertNever(diagnostic);
-              }
-            });
-            lazyProgramDiagnosticExplainingFile.forEach(
-              ({ file, diagnostic, args }) => programDiagnostics.add(
-                createDiagnosticExplainingFile(
-                  file,
-                  /*fileProcessingReason*/
-                  void 0,
-                  diagnostic,
-                  args
-                )
-              )
-            );
-            lazyProgramDiagnosticExplainingFile = void 0;
-            fileReasonsToChain = void 0;
-            reasonToRelatedInfo = void 0;
-          }
-          return programDiagnostics;
-        }
-        function filePreprocessingLibreferenceDiagnostic({ reason }) {
-          const { file, pos, end } = getReferencedFileLocation(program, reason);
-          const libReference = file.libReferenceDirectives[reason.index];
-          const libName = getLibNameFromLibReference(libReference);
-          const unqualifiedLibName = removeSuffix(removePrefix(libName, "lib."), ".d.ts");
-          const suggestion = getSpellingSuggestion(unqualifiedLibName, libs, identity);
-          return createFileDiagnostic(
-            file,
-            Debug.checkDefined(pos),
-            Debug.checkDefined(end) - pos,
-            suggestion ? Diagnostics.Cannot_find_lib_definition_for_0_Did_you_mean_1 : Diagnostics.Cannot_find_lib_definition_for_0,
-            libName,
-            suggestion
-          );
-        }
         function getResolvedModule(file, moduleName2, mode) {
           var _a22;
           return (_a22 = resolvedModules == null ? void 0 : resolvedModules.get(file.path)) == null ? void 0 : _a22.get(moduleName2, mode);
@@ -153991,7 +154306,7 @@ ${lanes.join("\n")}
         function addResolutionDiagnostics(resolution) {
           var _a22;
           if (!((_a22 = resolution.resolutionDiagnostics) == null ? void 0 : _a22.length)) return;
-          (fileProcessingDiagnostics ?? (fileProcessingDiagnostics = [])).push({
+          programDiagnostics.addFileProcessingDiagnostic({
             kind: 2,
             diagnostics: resolution.resolutionDiagnostics
           });
@@ -154085,16 +154400,19 @@ ${lanes.join("\n")}
           return toPath3(fileName, currentDirectory, getCanonicalFileName);
         }
         function getCommonSourceDirectory2() {
-          if (commonSourceDirectory === void 0) {
-            const emittedFiles = filter(files, (file) => sourceFileMayBeEmitted(file, program));
-            commonSourceDirectory = getCommonSourceDirectory(
-              options,
-              () => mapDefined(emittedFiles, (file) => file.isDeclarationFile ? void 0 : file.fileName),
-              currentDirectory,
-              getCanonicalFileName,
-              (commonSourceDirectory2) => checkSourceFilesBelongToPath(emittedFiles, commonSourceDirectory2)
-            );
+          let commonSourceDirectory = programDiagnostics.getCommonSourceDirectory();
+          if (commonSourceDirectory !== void 0) {
+            return commonSourceDirectory;
           }
+          const emittedFiles = filter(files, (file) => sourceFileMayBeEmitted(file, program));
+          commonSourceDirectory = getCommonSourceDirectory(
+            options,
+            () => mapDefined(emittedFiles, (file) => file.isDeclarationFile ? void 0 : file.fileName),
+            currentDirectory,
+            getCanonicalFileName,
+            (commonSourceDirectory2) => checkSourceFilesBelongToPath(emittedFiles, commonSourceDirectory2)
+          );
+          programDiagnostics.setCommonSourceDirectory(commonSourceDirectory);
           return commonSourceDirectory;
         }
         function getClassifiableNames() {
@@ -154405,9 +154723,10 @@ ${lanes.join("\n")}
             }
             filesByName.set(path14, filesByName.get(oldFile.path));
           });
+          const isConfigIdentical = oldOptions.configFile && oldOptions.configFile === options.configFile || !oldOptions.configFile && !options.configFile && !optionsHaveChanges(oldOptions, options, optionDeclarations);
+          programDiagnostics.reuseStateFromOldProgram(oldProgram.getProgramDiagnosticsContainer(), isConfigIdentical);
+          skipVerifyCompilerOptions = isConfigIdentical;
           files = newSourceFiles;
-          fileReasons = oldProgram.getFileIncludeReasons();
-          fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics();
           automaticTypeDirectiveNames = oldProgram.getAutomaticTypeDirectiveNames();
           automaticTypeDirectiveResolutions = oldProgram.getAutomaticTypeDirectiveResolutions();
           sourceFileToPackageName = oldProgram.sourceFileToPackageName;
@@ -154623,7 +154942,7 @@ ${lanes.join("\n")}
           if (skipTypeChecking(sourceFile, options, program)) {
             return emptyArray;
           }
-          const programDiagnosticsInFile = updateAndGetProgramDiagnostics().getDiagnostics(sourceFile.fileName);
+          const programDiagnosticsInFile = programDiagnostics.getCombinedDiagnostics(program).getDiagnostics(sourceFile.fileName);
           if (!((_a22 = sourceFile.commentDirectives) == null ? void 0 : _a22.length)) {
             return programDiagnosticsInFile;
           }
@@ -154997,15 +155316,15 @@ ${lanes.join("\n")}
         }
         function getOptionsDiagnostics() {
           return sortAndDeduplicateDiagnostics(concatenate(
-            updateAndGetProgramDiagnostics().getGlobalDiagnostics(),
+            programDiagnostics.getCombinedDiagnostics(program).getGlobalDiagnostics(),
             getOptionsDiagnosticsOfConfigFile()
           ));
         }
         function getOptionsDiagnosticsOfConfigFile() {
           if (!options.configFile) return emptyArray;
-          let diagnostics = updateAndGetProgramDiagnostics().getDiagnostics(options.configFile.fileName);
+          let diagnostics = programDiagnostics.getCombinedDiagnostics(program).getDiagnostics(options.configFile.fileName);
           forEachResolvedProjectReference2((resolvedRef) => {
-            diagnostics = concatenate(diagnostics, updateAndGetProgramDiagnostics().getDiagnostics(resolvedRef.sourceFile.fileName));
+            diagnostics = concatenate(diagnostics, programDiagnostics.getCombinedDiagnostics(program).getDiagnostics(resolvedRef.sourceFile.fileName));
           });
           return diagnostics;
         }
@@ -155220,7 +155539,7 @@ ${lanes.join("\n")}
           );
         }
         function reportFileNamesDifferOnlyInCasingError(fileName, existingFile, reason) {
-          const hasExistingReasonToReportErrorOn = !isReferencedFile(reason) && some(fileReasons.get(existingFile.path), isReferencedFile);
+          const hasExistingReasonToReportErrorOn = !isReferencedFile(reason) && some(programDiagnostics.getFileReasons().get(existingFile.path), isReferencedFile);
           if (hasExistingReasonToReportErrorOn) {
             addFilePreprocessingFileExplainingDiagnostic(existingFile, reason, Diagnostics.Already_included_file_name_0_differs_from_file_name_1_only_in_casing, [existingFile.fileName, fileName]);
           } else {
@@ -155407,7 +155726,7 @@ ${lanes.join("\n")}
         }
         function addFileIncludeReason(file, reason, checkExisting) {
           if (file && (!checkExisting || !isReferencedFile(reason) || !(filesWithReferencesProcessed == null ? void 0 : filesWithReferencesProcessed.has(reason.file)))) {
-            fileReasons.add(file.path, reason);
+            programDiagnostics.getFileReasons().add(file.path, reason);
             return true;
           }
           return false;
@@ -155575,6 +155894,16 @@ ${lanes.join("\n")}
           var _a22, _b22, _c22, _d2, _e2;
           const existing = resolvedLibProcessing == null ? void 0 : resolvedLibProcessing.get(libFileName);
           if (existing) return existing;
+          if (options.libReplacement === false) {
+            const result2 = {
+              resolution: {
+                resolvedModule: void 0
+              },
+              actual: combinePaths(defaultLibraryPath, libFileName)
+            };
+            (resolvedLibProcessing ?? (resolvedLibProcessing = /* @__PURE__ */ new Map())).set(libFileName, result2);
+            return result2;
+          }
           if (structureIsReused !== 0 && oldProgram && !hasInvalidatedLibResolutions(libFileName)) {
             const oldResolution = (_a22 = oldProgram.resolvedLibReferences) == null ? void 0 : _a22.get(libFileName);
             if (oldResolution) {
@@ -155622,7 +155951,7 @@ ${lanes.join("\n")}
                 { kind: 7, file: file.path, index }
               );
             } else {
-              (fileProcessingDiagnostics || (fileProcessingDiagnostics = [])).push({
+              programDiagnostics.addFileProcessingDiagnostic({
                 kind: 0,
                 reason: { kind: 7, file: file.path, index }
               });
@@ -155685,10 +156014,11 @@ ${lanes.join("\n")}
             if (!sourceFile.isDeclarationFile) {
               const absoluteSourceFilePath = host.getCanonicalFileName(getNormalizedAbsolutePath(sourceFile.fileName, currentDirectory));
               if (absoluteSourceFilePath.indexOf(absoluteRootDirectoryPath) !== 0) {
-                addLazyProgramDiagnosticExplainingFile(
+                programDiagnostics.addLazyConfigDiagnostic(
                   sourceFile,
                   Diagnostics.File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files,
-                  [sourceFile.fileName, rootDirectory]
+                  sourceFile.fileName,
+                  rootDirectory
                 );
                 allFilesBelongToPath = false;
               }
@@ -155807,7 +156137,7 @@ ${lanes.join("\n")}
           }
           const outputFile = options.outFile;
           if (!options.tsBuildInfoFile && options.incremental && !outputFile && !options.configFilePath) {
-            programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBuildInfoFile_is_specified));
+            programDiagnostics.addConfigDiagnostic(createCompilerDiagnostic(Diagnostics.Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBuildInfoFile_is_specified));
           }
           verifyDeprecatedCompilerOptions();
           verifyProjectReferences();
@@ -155815,10 +156145,11 @@ ${lanes.join("\n")}
             const rootPaths = new Set(rootNames.map(toPath32));
             for (const file of files) {
               if (sourceFileMayBeEmitted(file, program) && !rootPaths.has(file.path)) {
-                addLazyProgramDiagnosticExplainingFile(
+                programDiagnostics.addLazyConfigDiagnostic(
                   file,
                   Diagnostics.File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_include_pattern,
-                  [file.fileName, options.configFilePath || ""]
+                  file.fileName,
+                  options.configFilePath || ""
                 );
               }
             }
@@ -155909,14 +156240,14 @@ ${lanes.join("\n")}
             }
           } else if (firstNonAmbientExternalModuleSourceFile && languageVersion < 2 && options.module === 0) {
             const span = getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, typeof firstNonAmbientExternalModuleSourceFile.externalModuleIndicator === "boolean" ? firstNonAmbientExternalModuleSourceFile : firstNonAmbientExternalModuleSourceFile.externalModuleIndicator);
-            programDiagnostics.add(createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none));
+            programDiagnostics.addConfigDiagnostic(createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none));
           }
           if (outputFile && !options.emitDeclarationOnly) {
             if (options.module && !(options.module === 2 || options.module === 4)) {
               createDiagnosticForOptionName(Diagnostics.Only_amd_and_system_modules_are_supported_alongside_0, "outFile", "module");
             } else if (options.module === void 0 && firstNonAmbientExternalModuleSourceFile) {
               const span = getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, typeof firstNonAmbientExternalModuleSourceFile.externalModuleIndicator === "boolean" ? firstNonAmbientExternalModuleSourceFile : firstNonAmbientExternalModuleSourceFile.externalModuleIndicator);
-              programDiagnostics.add(createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system, "outFile"));
+              programDiagnostics.addConfigDiagnostic(createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system, "outFile"));
             }
           }
           if (getResolveJsonModule(options)) {
@@ -156005,7 +156336,8 @@ ${lanes.join("\n")}
           }
           if (ModuleKind[moduleKind] && (100 <= moduleKind && moduleKind <= 199) && !(3 <= moduleResolution && moduleResolution <= 99)) {
             const moduleKindName = ModuleKind[moduleKind];
-            createOptionValueDiagnostic("moduleResolution", Diagnostics.Option_moduleResolution_must_be_set_to_0_or_left_unspecified_when_option_module_is_set_to_1, moduleKindName, moduleKindName);
+            const moduleResolutionName = ModuleResolutionKind[moduleKindName] ? moduleKindName : "Node16";
+            createOptionValueDiagnostic("moduleResolution", Diagnostics.Option_moduleResolution_must_be_set_to_0_or_left_unspecified_when_option_module_is_set_to_1, moduleResolutionName, moduleKindName);
           } else if (ModuleResolutionKind[moduleResolution] && (3 <= moduleResolution && moduleResolution <= 99) && !(100 <= moduleKind && moduleKind <= 199)) {
             const moduleResolutionName = ModuleResolutionKind[moduleResolution];
             createOptionValueDiagnostic("module", Diagnostics.Option_module_must_be_set_to_0_when_option_moduleResolution_is_set_to_1, moduleResolutionName, moduleResolutionName);
@@ -156167,90 +156499,8 @@ ${lanes.join("\n")}
             }
           });
         }
-        function createDiagnosticExplainingFile(file, fileProcessingReason, diagnostic, args) {
-          let seenReasons;
-          const reasons = file && fileReasons.get(file.path);
-          let fileIncludeReasons;
-          let relatedInfo;
-          let locationReason = isReferencedFile(fileProcessingReason) ? fileProcessingReason : void 0;
-          let fileIncludeReasonDetails;
-          let redirectInfo;
-          let cachedChain = file && (fileReasonsToChain == null ? void 0 : fileReasonsToChain.get(file.path));
-          let chain;
-          if (cachedChain) {
-            if (cachedChain.fileIncludeReasonDetails) {
-              seenReasons = new Set(reasons);
-              reasons == null ? void 0 : reasons.forEach(populateRelatedInfo);
-            } else {
-              reasons == null ? void 0 : reasons.forEach(processReason);
-            }
-            redirectInfo = cachedChain.redirectInfo;
-          } else {
-            reasons == null ? void 0 : reasons.forEach(processReason);
-            redirectInfo = file && explainIfFileIsRedirectAndImpliedFormat(file, getCompilerOptionsForFile(file));
-          }
-          if (fileProcessingReason) processReason(fileProcessingReason);
-          const processedExtraReason = (seenReasons == null ? void 0 : seenReasons.size) !== (reasons == null ? void 0 : reasons.length);
-          if (locationReason && (seenReasons == null ? void 0 : seenReasons.size) === 1) seenReasons = void 0;
-          if (seenReasons && cachedChain) {
-            if (cachedChain.details && !processedExtraReason) {
-              chain = chainDiagnosticMessages(cachedChain.details, diagnostic, ...args || emptyArray);
-            } else if (cachedChain.fileIncludeReasonDetails) {
-              if (!processedExtraReason) {
-                if (!cachedFileIncludeDetailsHasProcessedExtraReason()) {
-                  fileIncludeReasonDetails = cachedChain.fileIncludeReasonDetails;
-                } else {
-                  fileIncludeReasons = cachedChain.fileIncludeReasonDetails.next.slice(0, reasons.length);
-                }
-              } else {
-                if (!cachedFileIncludeDetailsHasProcessedExtraReason()) {
-                  fileIncludeReasons = [...cachedChain.fileIncludeReasonDetails.next, fileIncludeReasons[0]];
-                } else {
-                  fileIncludeReasons = append(cachedChain.fileIncludeReasonDetails.next.slice(0, reasons.length), fileIncludeReasons[0]);
-                }
-              }
-            }
-          }
-          if (!chain) {
-            if (!fileIncludeReasonDetails) fileIncludeReasonDetails = seenReasons && chainDiagnosticMessages(fileIncludeReasons, Diagnostics.The_file_is_in_the_program_because_Colon);
-            chain = chainDiagnosticMessages(
-              redirectInfo ? fileIncludeReasonDetails ? [fileIncludeReasonDetails, ...redirectInfo] : redirectInfo : fileIncludeReasonDetails,
-              diagnostic,
-              ...args || emptyArray
-            );
-          }
-          if (file) {
-            if (cachedChain) {
-              if (!cachedChain.fileIncludeReasonDetails || !processedExtraReason && fileIncludeReasonDetails) {
-                cachedChain.fileIncludeReasonDetails = fileIncludeReasonDetails;
-              }
-            } else {
-              (fileReasonsToChain ?? (fileReasonsToChain = /* @__PURE__ */ new Map())).set(file.path, cachedChain = { fileIncludeReasonDetails, redirectInfo });
-            }
-            if (!cachedChain.details && !processedExtraReason) cachedChain.details = chain.next;
-          }
-          const location = locationReason && getReferencedFileLocation(program, locationReason);
-          return location && isReferenceFileLocation(location) ? createFileDiagnosticFromMessageChain(location.file, location.pos, location.end - location.pos, chain, relatedInfo) : createCompilerDiagnosticFromMessageChain(chain, relatedInfo);
-          function processReason(reason) {
-            if (seenReasons == null ? void 0 : seenReasons.has(reason)) return;
-            (seenReasons ?? (seenReasons = /* @__PURE__ */ new Set())).add(reason);
-            (fileIncludeReasons ?? (fileIncludeReasons = [])).push(fileIncludeReasonToDiagnostics(program, reason));
-            populateRelatedInfo(reason);
-          }
-          function populateRelatedInfo(reason) {
-            if (!locationReason && isReferencedFile(reason)) {
-              locationReason = reason;
-            } else if (locationReason !== reason) {
-              relatedInfo = append(relatedInfo, getFileIncludeReasonToRelatedInformation(reason));
-            }
-          }
-          function cachedFileIncludeDetailsHasProcessedExtraReason() {
-            var _a22;
-            return ((_a22 = cachedChain.fileIncludeReasonDetails.next) == null ? void 0 : _a22.length) !== (reasons == null ? void 0 : reasons.length);
-          }
-        }
         function addFilePreprocessingFileExplainingDiagnostic(file, fileProcessingReason, diagnostic, args) {
-          (fileProcessingDiagnostics || (fileProcessingDiagnostics = [])).push({
+          programDiagnostics.addFileProcessingDiagnostic({
             kind: 1,
             file: file && file.path,
             fileProcessingReason,
@@ -156258,99 +156508,6 @@ ${lanes.join("\n")}
             args
           });
         }
-        function addLazyProgramDiagnosticExplainingFile(file, diagnostic, args) {
-          lazyProgramDiagnosticExplainingFile.push({ file, diagnostic, args });
-        }
-        function getFileIncludeReasonToRelatedInformation(reason) {
-          let relatedInfo = reasonToRelatedInfo == null ? void 0 : reasonToRelatedInfo.get(reason);
-          if (relatedInfo === void 0) (reasonToRelatedInfo ?? (reasonToRelatedInfo = /* @__PURE__ */ new Map())).set(reason, relatedInfo = fileIncludeReasonToRelatedInformation(reason) ?? false);
-          return relatedInfo || void 0;
-        }
-        function fileIncludeReasonToRelatedInformation(reason) {
-          if (isReferencedFile(reason)) {
-            const referenceLocation = getReferencedFileLocation(program, reason);
-            let message22;
-            switch (reason.kind) {
-              case 3:
-                message22 = Diagnostics.File_is_included_via_import_here;
-                break;
-              case 4:
-                message22 = Diagnostics.File_is_included_via_reference_here;
-                break;
-              case 5:
-                message22 = Diagnostics.File_is_included_via_type_library_reference_here;
-                break;
-              case 7:
-                message22 = Diagnostics.File_is_included_via_library_reference_here;
-                break;
-              default:
-                Debug.assertNever(reason);
-            }
-            return isReferenceFileLocation(referenceLocation) ? createFileDiagnostic(
-              referenceLocation.file,
-              referenceLocation.pos,
-              referenceLocation.end - referenceLocation.pos,
-              message22
-            ) : void 0;
-          }
-          if (!options.configFile) return void 0;
-          let configFileNode;
-          let message2;
-          switch (reason.kind) {
-            case 0:
-              if (!options.configFile.configFileSpecs) return void 0;
-              const fileName = getNormalizedAbsolutePath(rootNames[reason.index], currentDirectory);
-              const matchedByFiles = getMatchedFileSpec(program, fileName);
-              if (matchedByFiles) {
-                configFileNode = getTsConfigPropArrayElementValue(options.configFile, "files", matchedByFiles);
-                message2 = Diagnostics.File_is_matched_by_files_list_specified_here;
-                break;
-              }
-              const matchedByInclude = getMatchedIncludeSpec(program, fileName);
-              if (!matchedByInclude || !isString(matchedByInclude)) return void 0;
-              configFileNode = getTsConfigPropArrayElementValue(options.configFile, "include", matchedByInclude);
-              message2 = Diagnostics.File_is_matched_by_include_pattern_specified_here;
-              break;
-            case 1:
-            case 2:
-              const referencedResolvedRef = Debug.checkDefined(resolvedProjectReferences == null ? void 0 : resolvedProjectReferences[reason.index]);
-              const referenceInfo = forEachProjectReference(
-                projectReferences,
-                resolvedProjectReferences,
-                (resolvedRef, parent2, index2) => resolvedRef === referencedResolvedRef ? { sourceFile: (parent2 == null ? void 0 : parent2.sourceFile) || options.configFile, index: index2 } : void 0
-              );
-              if (!referenceInfo) return void 0;
-              const { sourceFile, index } = referenceInfo;
-              const referencesSyntax = forEachTsConfigPropArray(sourceFile, "references", (property) => isArrayLiteralExpression(property.initializer) ? property.initializer : void 0);
-              return referencesSyntax && referencesSyntax.elements.length > index ? createDiagnosticForNodeInSourceFile(
-                sourceFile,
-                referencesSyntax.elements[index],
-                reason.kind === 2 ? Diagnostics.File_is_output_from_referenced_project_specified_here : Diagnostics.File_is_source_from_referenced_project_specified_here
-              ) : void 0;
-            case 8:
-              if (!options.types) return void 0;
-              configFileNode = getOptionsSyntaxByArrayElementValue("types", reason.typeReference);
-              message2 = Diagnostics.File_is_entry_point_of_type_library_specified_here;
-              break;
-            case 6:
-              if (reason.index !== void 0) {
-                configFileNode = getOptionsSyntaxByArrayElementValue("lib", options.lib[reason.index]);
-                message2 = Diagnostics.File_is_library_specified_here;
-                break;
-              }
-              const target = getNameOfScriptTarget(getEmitScriptTarget(options));
-              configFileNode = target ? getOptionsSyntaxByValue("target", target) : void 0;
-              message2 = Diagnostics.File_is_default_library_for_target_specified_here;
-              break;
-            default:
-              Debug.assertNever(reason);
-          }
-          return configFileNode && createDiagnosticForNodeInSourceFile(
-            options.configFile,
-            configFileNode,
-            message2
-          );
-        }
         function verifyProjectReferences() {
           const buildInfoPath = !options.suppressOutputPathCheck ? getTsBuildInfoEmitOutputFilePath(options) : void 0;
           forEachProjectReference(
@@ -156386,7 +156543,7 @@ ${lanes.join("\n")}
               forEachPropertyAssignment(pathProp.initializer, key, (keyProps) => {
                 const initializer = keyProps.initializer;
                 if (isArrayLiteralExpression(initializer) && initializer.elements.length > valueIndex) {
-                  programDiagnostics.add(createDiagnosticForNodeInSourceFile(options.configFile, initializer.elements[valueIndex], message2, ...args));
+                  programDiagnostics.addConfigDiagnostic(createDiagnosticForNodeInSourceFile(options.configFile, initializer.elements[valueIndex], message2, ...args));
                   needCompilerDiagnostic = false;
                 }
               });
@@ -156415,18 +156572,8 @@ ${lanes.join("\n")}
             createCompilerOptionsDiagnostic(message2, ...args);
           }
         }
-        function forEachOptionsSyntaxByName(name, callback) {
-          return forEachPropertyAssignment(getCompilerOptionsObjectLiteralSyntax(), name, callback);
-        }
         function forEachOptionPathsSyntax(callback) {
-          return forEachOptionsSyntaxByName("paths", callback);
-        }
-        function getOptionsSyntaxByValue(name, value2) {
-          return forEachOptionsSyntaxByName(name, (property) => isStringLiteral(property.initializer) && property.initializer.text === value2 ? property.initializer : void 0);
-        }
-        function getOptionsSyntaxByArrayElementValue(name, value2) {
-          const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();
-          return compilerOptionsObjectLiteralSyntax && getPropertyArrayElementValue(compilerOptionsObjectLiteralSyntax, name, value2);
+          return forEachOptionsSyntaxByName(getCompilerOptionsObjectLiteralSyntax(), "paths", callback);
         }
         function createDiagnosticForOptionName(message2, option1, option2, option3) {
           createDiagnosticForOption(
@@ -156454,9 +156601,9 @@ ${lanes.join("\n")}
         function createDiagnosticForReference(sourceFile, index, message2, ...args) {
           const referencesSyntax = forEachTsConfigPropArray(sourceFile || options.configFile, "references", (property) => isArrayLiteralExpression(property.initializer) ? property.initializer : void 0);
           if (referencesSyntax && referencesSyntax.elements.length > index) {
-            programDiagnostics.add(createDiagnosticForNodeInSourceFile(sourceFile || options.configFile, referencesSyntax.elements[index], message2, ...args));
+            programDiagnostics.addConfigDiagnostic(createDiagnosticForNodeInSourceFile(sourceFile || options.configFile, referencesSyntax.elements[index], message2, ...args));
           } else {
-            programDiagnostics.add(createCompilerDiagnostic(message2, ...args));
+            programDiagnostics.addConfigDiagnostic(createCompilerDiagnostic(message2, ...args));
           }
         }
         function createDiagnosticForOption(onKey, option1, option2, message2, ...args) {
@@ -156470,14 +156617,14 @@ ${lanes.join("\n")}
           const compilerOptionsProperty = getCompilerOptionsPropertySyntax();
           if (compilerOptionsProperty) {
             if ("messageText" in message2) {
-              programDiagnostics.add(createDiagnosticForNodeFromMessageChain(options.configFile, compilerOptionsProperty.name, message2));
+              programDiagnostics.addConfigDiagnostic(createDiagnosticForNodeFromMessageChain(options.configFile, compilerOptionsProperty.name, message2));
             } else {
-              programDiagnostics.add(createDiagnosticForNodeInSourceFile(options.configFile, compilerOptionsProperty.name, message2, ...args));
+              programDiagnostics.addConfigDiagnostic(createDiagnosticForNodeInSourceFile(options.configFile, compilerOptionsProperty.name, message2, ...args));
             }
           } else if ("messageText" in message2) {
-            programDiagnostics.add(createCompilerDiagnosticFromMessageChain(message2));
+            programDiagnostics.addConfigDiagnostic(createCompilerDiagnosticFromMessageChain(message2));
           } else {
-            programDiagnostics.add(createCompilerDiagnostic(message2, ...args));
+            programDiagnostics.addConfigDiagnostic(createCompilerDiagnostic(message2, ...args));
           }
         }
         function getCompilerOptionsObjectLiteralSyntax() {
@@ -156501,9 +156648,9 @@ ${lanes.join("\n")}
           let needsCompilerDiagnostic = false;
           forEachPropertyAssignment(objectLiteral, key1, (prop) => {
             if ("messageText" in message2) {
-              programDiagnostics.add(createDiagnosticForNodeFromMessageChain(options.configFile, onKey ? prop.name : prop.initializer, message2));
+              programDiagnostics.addConfigDiagnostic(createDiagnosticForNodeFromMessageChain(options.configFile, onKey ? prop.name : prop.initializer, message2));
             } else {
-              programDiagnostics.add(createDiagnosticForNodeInSourceFile(options.configFile, onKey ? prop.name : prop.initializer, message2, ...args));
+              programDiagnostics.addConfigDiagnostic(createDiagnosticForNodeInSourceFile(options.configFile, onKey ? prop.name : prop.initializer, message2, ...args));
             }
             needsCompilerDiagnostic = true;
           }, key2);
@@ -156511,7 +156658,7 @@ ${lanes.join("\n")}
         }
         function blockEmittingOfFile(emitFileName, diag2) {
           hasEmitBlockingDiagnostics.set(toPath32(emitFileName), true);
-          programDiagnostics.add(diag2);
+          programDiagnostics.addConfigDiagnostic(diag2);
         }
         function isEmittedFile(file) {
           if (options.noEmit) {
@@ -156851,6 +156998,291 @@ ${lanes.join("\n")}
         }
         Debug.fail("should never ask for module name at index higher than possible module name");
       }
+      function createProgramDiagnostics(getCompilerOptionsObjectLiteralSyntax) {
+        let computedDiagnostics;
+        let fileReasons = createMultiMap();
+        let fileProcessingDiagnostics;
+        let commonSourceDirectory;
+        let configDiagnostics;
+        let lazyConfigDiagnostics;
+        let fileReasonsToChain;
+        let reasonToRelatedInfo;
+        return {
+          addConfigDiagnostic(diag2) {
+            Debug.assert(computedDiagnostics === void 0, "Cannot modify program diagnostic state after requesting combined diagnostics");
+            (configDiagnostics ?? (configDiagnostics = createDiagnosticCollection())).add(diag2);
+          },
+          addLazyConfigDiagnostic(file, message2, ...args) {
+            Debug.assert(computedDiagnostics === void 0, "Cannot modify program diagnostic state after requesting combined diagnostics");
+            (lazyConfigDiagnostics ?? (lazyConfigDiagnostics = [])).push({ file, diagnostic: message2, args });
+          },
+          addFileProcessingDiagnostic(diag2) {
+            Debug.assert(computedDiagnostics === void 0, "Cannot modify program diagnostic state after requesting combined diagnostics");
+            (fileProcessingDiagnostics ?? (fileProcessingDiagnostics = [])).push(diag2);
+          },
+          setCommonSourceDirectory(directory) {
+            commonSourceDirectory = directory;
+          },
+          reuseStateFromOldProgram(oldProgramDiagnostics, isConfigIdentical) {
+            fileReasons = oldProgramDiagnostics.getFileReasons();
+            fileProcessingDiagnostics = oldProgramDiagnostics.getFileProcessingDiagnostics();
+            if (isConfigIdentical) {
+              commonSourceDirectory = oldProgramDiagnostics.getCommonSourceDirectory();
+              configDiagnostics = oldProgramDiagnostics.getConfigDiagnostics();
+              lazyConfigDiagnostics = oldProgramDiagnostics.getLazyConfigDiagnostics();
+            }
+          },
+          getFileProcessingDiagnostics() {
+            return fileProcessingDiagnostics;
+          },
+          getFileReasons() {
+            return fileReasons;
+          },
+          getCommonSourceDirectory() {
+            return commonSourceDirectory;
+          },
+          getConfigDiagnostics() {
+            return configDiagnostics;
+          },
+          getLazyConfigDiagnostics() {
+            return lazyConfigDiagnostics;
+          },
+          getCombinedDiagnostics(program) {
+            if (computedDiagnostics) {
+              return computedDiagnostics;
+            }
+            computedDiagnostics = createDiagnosticCollection();
+            configDiagnostics == null ? void 0 : configDiagnostics.getDiagnostics().forEach((d) => computedDiagnostics.add(d));
+            fileProcessingDiagnostics == null ? void 0 : fileProcessingDiagnostics.forEach((diagnostic) => {
+              switch (diagnostic.kind) {
+                case 1:
+                  return computedDiagnostics.add(
+                    createDiagnosticExplainingFile(
+                      program,
+                      diagnostic.file && program.getSourceFileByPath(diagnostic.file),
+                      diagnostic.fileProcessingReason,
+                      diagnostic.diagnostic,
+                      diagnostic.args || emptyArray
+                    )
+                  );
+                case 0:
+                  return computedDiagnostics.add(filePreprocessingLibreferenceDiagnostic(program, diagnostic));
+                case 2:
+                  return diagnostic.diagnostics.forEach((d) => computedDiagnostics.add(d));
+                default:
+                  Debug.assertNever(diagnostic);
+              }
+            });
+            lazyConfigDiagnostics == null ? void 0 : lazyConfigDiagnostics.forEach(
+              ({ file, diagnostic, args }) => computedDiagnostics.add(
+                createDiagnosticExplainingFile(
+                  program,
+                  file,
+                  /*fileProcessingReason*/
+                  void 0,
+                  diagnostic,
+                  args
+                )
+              )
+            );
+            fileReasonsToChain = void 0;
+            reasonToRelatedInfo = void 0;
+            return computedDiagnostics;
+          }
+        };
+        function filePreprocessingLibreferenceDiagnostic(program, { reason }) {
+          const { file, pos, end } = getReferencedFileLocation(program, reason);
+          const libReference = file.libReferenceDirectives[reason.index];
+          const libName = getLibNameFromLibReference(libReference);
+          const unqualifiedLibName = removeSuffix(removePrefix(libName, "lib."), ".d.ts");
+          const suggestion = getSpellingSuggestion(unqualifiedLibName, libs, identity);
+          return createFileDiagnostic(
+            file,
+            Debug.checkDefined(pos),
+            Debug.checkDefined(end) - pos,
+            suggestion ? Diagnostics.Cannot_find_lib_definition_for_0_Did_you_mean_1 : Diagnostics.Cannot_find_lib_definition_for_0,
+            libName,
+            suggestion
+          );
+        }
+        function createDiagnosticExplainingFile(program, file, fileProcessingReason, diagnostic, args) {
+          let seenReasons;
+          let fileIncludeReasons;
+          let relatedInfo;
+          let fileIncludeReasonDetails;
+          let redirectInfo;
+          let chain;
+          const reasons = file && fileReasons.get(file.path);
+          let locationReason = isReferencedFile(fileProcessingReason) ? fileProcessingReason : void 0;
+          let cachedChain = file && (fileReasonsToChain == null ? void 0 : fileReasonsToChain.get(file.path));
+          if (cachedChain) {
+            if (cachedChain.fileIncludeReasonDetails) {
+              seenReasons = new Set(reasons);
+              reasons == null ? void 0 : reasons.forEach(populateRelatedInfo);
+            } else {
+              reasons == null ? void 0 : reasons.forEach(processReason);
+            }
+            redirectInfo = cachedChain.redirectInfo;
+          } else {
+            reasons == null ? void 0 : reasons.forEach(processReason);
+            redirectInfo = file && explainIfFileIsRedirectAndImpliedFormat(file, program.getCompilerOptionsForFile(file));
+          }
+          if (fileProcessingReason) processReason(fileProcessingReason);
+          const processedExtraReason = (seenReasons == null ? void 0 : seenReasons.size) !== (reasons == null ? void 0 : reasons.length);
+          if (locationReason && (seenReasons == null ? void 0 : seenReasons.size) === 1) seenReasons = void 0;
+          if (seenReasons && cachedChain) {
+            if (cachedChain.details && !processedExtraReason) {
+              chain = chainDiagnosticMessages(cachedChain.details, diagnostic, ...args ?? emptyArray);
+            } else if (cachedChain.fileIncludeReasonDetails) {
+              if (!processedExtraReason) {
+                if (!cachedFileIncludeDetailsHasProcessedExtraReason()) {
+                  fileIncludeReasonDetails = cachedChain.fileIncludeReasonDetails;
+                } else {
+                  fileIncludeReasons = cachedChain.fileIncludeReasonDetails.next.slice(0, reasons.length);
+                }
+              } else {
+                if (!cachedFileIncludeDetailsHasProcessedExtraReason()) {
+                  fileIncludeReasons = [...cachedChain.fileIncludeReasonDetails.next, fileIncludeReasons[0]];
+                } else {
+                  fileIncludeReasons = append(cachedChain.fileIncludeReasonDetails.next.slice(0, reasons.length), fileIncludeReasons[0]);
+                }
+              }
+            }
+          }
+          if (!chain) {
+            if (!fileIncludeReasonDetails) fileIncludeReasonDetails = seenReasons && chainDiagnosticMessages(fileIncludeReasons, Diagnostics.The_file_is_in_the_program_because_Colon);
+            chain = chainDiagnosticMessages(
+              redirectInfo ? fileIncludeReasonDetails ? [fileIncludeReasonDetails, ...redirectInfo] : redirectInfo : fileIncludeReasonDetails,
+              diagnostic,
+              ...args || emptyArray
+            );
+          }
+          if (file) {
+            if (cachedChain) {
+              if (!cachedChain.fileIncludeReasonDetails || !processedExtraReason && fileIncludeReasonDetails) {
+                cachedChain.fileIncludeReasonDetails = fileIncludeReasonDetails;
+              }
+            } else {
+              (fileReasonsToChain ?? (fileReasonsToChain = /* @__PURE__ */ new Map())).set(file.path, cachedChain = { fileIncludeReasonDetails, redirectInfo });
+            }
+            if (!cachedChain.details && !processedExtraReason) cachedChain.details = chain.next;
+          }
+          const location = locationReason && getReferencedFileLocation(program, locationReason);
+          return location && isReferenceFileLocation(location) ? createFileDiagnosticFromMessageChain(location.file, location.pos, location.end - location.pos, chain, relatedInfo) : createCompilerDiagnosticFromMessageChain(chain, relatedInfo);
+          function processReason(reason) {
+            if (seenReasons == null ? void 0 : seenReasons.has(reason)) return;
+            (seenReasons ?? (seenReasons = /* @__PURE__ */ new Set())).add(reason);
+            (fileIncludeReasons ?? (fileIncludeReasons = [])).push(fileIncludeReasonToDiagnostics(program, reason));
+            populateRelatedInfo(reason);
+          }
+          function populateRelatedInfo(reason) {
+            if (!locationReason && isReferencedFile(reason)) {
+              locationReason = reason;
+            } else if (locationReason !== reason) {
+              relatedInfo = append(relatedInfo, getFileIncludeReasonToRelatedInformation(program, reason));
+            }
+          }
+          function cachedFileIncludeDetailsHasProcessedExtraReason() {
+            var _a2;
+            return ((_a2 = cachedChain.fileIncludeReasonDetails.next) == null ? void 0 : _a2.length) !== (reasons == null ? void 0 : reasons.length);
+          }
+        }
+        function getFileIncludeReasonToRelatedInformation(program, reason) {
+          let relatedInfo = reasonToRelatedInfo == null ? void 0 : reasonToRelatedInfo.get(reason);
+          if (relatedInfo === void 0) (reasonToRelatedInfo ?? (reasonToRelatedInfo = /* @__PURE__ */ new Map())).set(reason, relatedInfo = fileIncludeReasonToRelatedInformation(program, reason) ?? false);
+          return relatedInfo || void 0;
+        }
+        function fileIncludeReasonToRelatedInformation(program, reason) {
+          if (isReferencedFile(reason)) {
+            const referenceLocation = getReferencedFileLocation(program, reason);
+            let message22;
+            switch (reason.kind) {
+              case 3:
+                message22 = Diagnostics.File_is_included_via_import_here;
+                break;
+              case 4:
+                message22 = Diagnostics.File_is_included_via_reference_here;
+                break;
+              case 5:
+                message22 = Diagnostics.File_is_included_via_type_library_reference_here;
+                break;
+              case 7:
+                message22 = Diagnostics.File_is_included_via_library_reference_here;
+                break;
+              default:
+                Debug.assertNever(reason);
+            }
+            return isReferenceFileLocation(referenceLocation) ? createFileDiagnostic(
+              referenceLocation.file,
+              referenceLocation.pos,
+              referenceLocation.end - referenceLocation.pos,
+              message22
+            ) : void 0;
+          }
+          const currentDirectory = program.getCurrentDirectory();
+          const rootNames = program.getRootFileNames();
+          const options = program.getCompilerOptions();
+          if (!options.configFile) return void 0;
+          let configFileNode;
+          let message2;
+          switch (reason.kind) {
+            case 0:
+              if (!options.configFile.configFileSpecs) return void 0;
+              const fileName = getNormalizedAbsolutePath(rootNames[reason.index], currentDirectory);
+              const matchedByFiles = getMatchedFileSpec(program, fileName);
+              if (matchedByFiles) {
+                configFileNode = getTsConfigPropArrayElementValue(options.configFile, "files", matchedByFiles);
+                message2 = Diagnostics.File_is_matched_by_files_list_specified_here;
+                break;
+              }
+              const matchedByInclude = getMatchedIncludeSpec(program, fileName);
+              if (!matchedByInclude || !isString(matchedByInclude)) return void 0;
+              configFileNode = getTsConfigPropArrayElementValue(options.configFile, "include", matchedByInclude);
+              message2 = Diagnostics.File_is_matched_by_include_pattern_specified_here;
+              break;
+            case 1:
+            case 2:
+              const resolvedProjectReferences = program.getResolvedProjectReferences();
+              const projectReferences = program.getProjectReferences();
+              const referencedResolvedRef = Debug.checkDefined(resolvedProjectReferences == null ? void 0 : resolvedProjectReferences[reason.index]);
+              const referenceInfo = forEachProjectReference(
+                projectReferences,
+                resolvedProjectReferences,
+                (resolvedRef, parent2, index2) => resolvedRef === referencedResolvedRef ? { sourceFile: (parent2 == null ? void 0 : parent2.sourceFile) || options.configFile, index: index2 } : void 0
+              );
+              if (!referenceInfo) return void 0;
+              const { sourceFile, index } = referenceInfo;
+              const referencesSyntax = forEachTsConfigPropArray(sourceFile, "references", (property) => isArrayLiteralExpression(property.initializer) ? property.initializer : void 0);
+              return referencesSyntax && referencesSyntax.elements.length > index ? createDiagnosticForNodeInSourceFile(
+                sourceFile,
+                referencesSyntax.elements[index],
+                reason.kind === 2 ? Diagnostics.File_is_output_from_referenced_project_specified_here : Diagnostics.File_is_source_from_referenced_project_specified_here
+              ) : void 0;
+            case 8:
+              if (!options.types) return void 0;
+              configFileNode = getOptionsSyntaxByArrayElementValue(getCompilerOptionsObjectLiteralSyntax(), "types", reason.typeReference);
+              message2 = Diagnostics.File_is_entry_point_of_type_library_specified_here;
+              break;
+            case 6:
+              if (reason.index !== void 0) {
+                configFileNode = getOptionsSyntaxByArrayElementValue(getCompilerOptionsObjectLiteralSyntax(), "lib", options.lib[reason.index]);
+                message2 = Diagnostics.File_is_library_specified_here;
+                break;
+              }
+              const target = getNameOfScriptTarget(getEmitScriptTarget(options));
+              configFileNode = target ? getOptionsSyntaxByValue(getCompilerOptionsObjectLiteralSyntax(), "target", target) : void 0;
+              message2 = Diagnostics.File_is_default_library_for_target_specified_here;
+              break;
+            default:
+              Debug.assertNever(reason);
+          }
+          return configFileNode && createDiagnosticForNodeInSourceFile(
+            options.configFile,
+            configFileNode,
+            message2
+          );
+        }
+      }
       function getFileEmitOutput(program, sourceFile, emitOnlyDtsFiles, cancellationToken, customTransformers, forceDtsEmit) {
         const outputFiles = [];
         const { emitSkipped, diagnostics } = program.emit(sourceFile, writeFile22, cancellationToken, emitOnlyDtsFiles, customTransformers, forceDtsEmit);
@@ -165258,18 +165690,21 @@ ${lanes.join("\n")}
           return failed;
         }
         function typeFromFunctionLikeExpression(fnNode, context) {
-          const oldNoInferenceFallback = context.noInferenceFallback;
-          context.noInferenceFallback = true;
-          createReturnFromSignature(
+          const returnType = createReturnFromSignature(
             fnNode,
             /*symbol*/
             void 0,
             context
           );
-          reuseTypeParameters(fnNode.typeParameters, context);
-          fnNode.parameters.map((p) => ensureParameter(p, context));
-          context.noInferenceFallback = oldNoInferenceFallback;
-          return notImplemented2;
+          const typeParameters = reuseTypeParameters(fnNode.typeParameters, context);
+          const parameters = fnNode.parameters.map((p) => ensureParameter(p, context));
+          return syntacticResult(
+            factory.createFunctionTypeNode(
+              typeParameters,
+              parameters,
+              returnType
+            )
+          );
         }
         function canGetTypeFromArrayLiteral(arrayLiteral, context, isConstContext) {
           if (!isConstContext) {
@@ -168992,7 +169427,7 @@ ${lanes.join("\n")}
         return moduleSpecifierToValidIdentifier(removeFileExtension(stripQuotes2(moduleSymbol.name)), target, forceCapitalize);
       }
       function moduleSpecifierToValidIdentifier(moduleSpecifier, target, forceCapitalize) {
-        const baseName = getBaseFileName(removeSuffix(moduleSpecifier, "/index"));
+        const baseName = getBaseFileName(removeSuffix(removeFileExtension(moduleSpecifier), "/index"));
         let res = "";
         let lastCharWasValid = true;
         const firstCharCode = baseName.charCodeAt(0);
@@ -175153,7 +175588,7 @@ interface Symbol {
         const unusedImportsFromOldFile = /* @__PURE__ */ new Set();
         for (const statement of toMove) {
           forEachReference(statement, checker, enclosingRange, (symbol, isValidTypeOnlyUseSite) => {
-            if (!symbol.declarations) {
+            if (!some(symbol.declarations)) {
               return;
             }
             if (existingTargetLocals.has(skipAlias(symbol, checker))) {
@@ -185945,6 +186380,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode.code,
         Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig.code,
         Diagnostics.Cannot_find_namespace_0_Did_you_mean_1.code,
+        Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements.code,
         Diagnostics.This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found.code
       ];
       registerCodeFix({
@@ -187060,6 +187496,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           case 200:
             return 2;
           case 100:
+          case 101:
           case 199:
             return getImpliedNodeFormatForEmit(importingFile, program) === 99 ? 2 : 3;
           default:
@@ -188486,7 +188923,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2.code,
         Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more.code,
         Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code,
-        Diagnostics.Cannot_find_name_0.code
+        Diagnostics.Cannot_find_name_0.code,
+        Diagnostics.Type_0_does_not_satisfy_the_expected_type_1.code
       ];
       registerCodeFix({
         errorCodes: errorCodes28,
@@ -188523,9 +188961,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
             eachDiagnostic(context, errorCodes28, (diag2) => {
               const info = getInfo10(diag2.file, diag2.start, diag2.code, checker, context.program);
-              if (!info || !addToSeen(seen, getNodeId(info.parentDeclaration) + "#" + (info.kind === 3 ? info.identifier : info.token.text))) {
-                return;
-              }
+              if (info === void 0) return;
+              const nodeId = getNodeId(info.parentDeclaration) + "#" + (info.kind === 3 ? info.identifier || getNodeId(info.token) : info.token.text);
+              if (!addToSeen(seen, nodeId)) return;
               if (fixId56 === fixMissingFunctionDeclaration && (info.kind === 2 || info.kind === 5)) {
                 addFunctionDeclaration(changes, context, info);
               } else if (fixId56 === fixMissingProperties && info.kind === 3) {
@@ -188577,7 +189015,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         }
       });
       function getInfo10(sourceFile, tokenPos, errorCode, checker, program) {
-        var _a2, _b2, _c2;
+        var _a2, _b2;
         const token = getTokenAtPosition(sourceFile, tokenPos);
         const parent2 = token.parent;
         if (errorCode === Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code) {
@@ -188599,23 +189037,25 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           if (!length(properties)) return void 0;
           return { kind: 3, token: param.name, identifier: param.name.text, properties, parentDeclaration: parent2 };
         }
-        if (token.kind === 19 && isObjectLiteralExpression(parent2)) {
-          const targetType = (_a2 = checker.getContextualType(parent2) || checker.getTypeAtLocation(parent2)) == null ? void 0 : _a2.getNonNullableType();
-          const properties = arrayFrom(checker.getUnmatchedProperties(
-            checker.getTypeAtLocation(parent2),
-            targetType,
-            /*requireOptionalProperties*/
-            false,
-            /*matchDiscriminantProperties*/
-            false
-          ));
-          if (!length(properties)) return void 0;
-          const identifier = "";
-          return { kind: 3, token: parent2, identifier, properties, parentDeclaration: parent2 };
+        if (token.kind === 19 || isSatisfiesExpression(parent2) || isReturnStatement(parent2)) {
+          const expression = (isSatisfiesExpression(parent2) || isReturnStatement(parent2)) && parent2.expression ? parent2.expression : parent2;
+          if (isObjectLiteralExpression(expression)) {
+            const targetType = isSatisfiesExpression(parent2) ? checker.getTypeFromTypeNode(parent2.type) : checker.getContextualType(expression) || checker.getTypeAtLocation(expression);
+            const properties = arrayFrom(checker.getUnmatchedProperties(
+              checker.getTypeAtLocation(parent2),
+              targetType.getNonNullableType(),
+              /*requireOptionalProperties*/
+              false,
+              /*matchDiscriminantProperties*/
+              false
+            ));
+            if (!length(properties)) return void 0;
+            return { kind: 3, token: parent2, identifier: void 0, properties, parentDeclaration: expression, indentation: isReturnStatement(expression.parent) || isYieldExpression(expression.parent) ? 0 : void 0 };
+          }
         }
         if (!isMemberName(token)) return void 0;
         if (isIdentifier(token) && hasInitializer(parent2) && parent2.initializer && isObjectLiteralExpression(parent2.initializer)) {
-          const targetType = (_b2 = checker.getContextualType(token) || checker.getTypeAtLocation(token)) == null ? void 0 : _b2.getNonNullableType();
+          const targetType = (_a2 = checker.getContextualType(token) || checker.getTypeAtLocation(token)) == null ? void 0 : _a2.getNonNullableType();
           const properties = arrayFrom(checker.getUnmatchedProperties(
             checker.getTypeAtLocation(parent2.initializer),
             targetType,
@@ -188634,7 +189074,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           return { kind: 4, token, attributes, parentDeclaration: token.parent };
         }
         if (isIdentifier(token)) {
-          const type = (_c2 = checker.getContextualType(token)) == null ? void 0 : _c2.getNonNullableType();
+          const type = (_b2 = checker.getContextualType(token)) == null ? void 0 : _b2.getNonNullableType();
           if (type && getObjectFlags(type) & 16) {
             const signature = firstOrUndefined(checker.getSignaturesOfType(
               type,
@@ -189676,9 +190116,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
       registerCodeFix({
         errorCodes: [
-          Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher.code,
-          Diagnostics.Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher.code,
-          Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher.code
+          Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher.code,
+          Diagnostics.Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher.code,
+          Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_node18_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher.code
         ],
         getCodeActions: function getCodeActionsToFixModuleAndTarget(context) {
           const compilerOptions = context.program.getCompilerOptions();
@@ -190139,6 +190579,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
                   break;
                 } else if (canDeleteEntireVariableStatement(sourceFile, token)) {
                   deleteEntireVariableStatement(changes, sourceFile, token.parent);
+                } else if (isIdentifier(token) && isFunctionDeclaration(token.parent)) {
+                  deleteFunctionLikeDeclaration(changes, sourceFile, token.parent);
                 } else {
                   tryDeleteDeclaration(
                     sourceFile,
@@ -193246,12 +193688,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         return typeNodeToAutoImportableTypeNode(typeNode, importAdder, scriptTarget);
       }
       function typeNodeToAutoImportableTypeNode(typeNode, importAdder, scriptTarget) {
-        if (typeNode && isImportTypeNode(typeNode)) {
-          const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
-          if (importableReference) {
-            importSymbols(importAdder, importableReference.symbols);
-            typeNode = importableReference.typeNode;
-          }
+        const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
+        if (importableReference) {
+          importSymbols(importAdder, importableReference.symbols);
+          typeNode = importableReference.typeNode;
         }
         return getSynthesizedDeepClone(typeNode);
       }
@@ -202069,7 +202509,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
               } else {
                 addIfImplementation(body);
               }
-            } else if (isAssertionExpression(typeHavingNode)) {
+            } else if (isAssertionExpression(typeHavingNode) || isSatisfiesExpression(typeHavingNode)) {
               addIfImplementation(typeHavingNode.expression);
             }
           }
@@ -202537,7 +202977,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         const { parent: parent2 } = node;
         const typeChecker = program.getTypeChecker();
         if (node.kind === 164 || isIdentifier(node) && isJSDocOverrideTag(parent2) && parent2.tagName === node) {
-          return getDefinitionFromOverriddenMember(typeChecker, node) || emptyArray;
+          const def = getDefinitionFromOverriddenMember(typeChecker, node);
+          if (def !== void 0 || node.kind !== 164) {
+            return def || emptyArray;
+          }
         }
         if (isJumpStatementTarget(node)) {
           const label = getTargetLabel(node.parent, node.text);
@@ -202551,9 +202994,6 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           )] : void 0;
         }
         switch (node.kind) {
-          case 107:
-            const functionDeclaration = findAncestor(node.parent, (n) => isClassStaticBlockDeclaration(n) ? "quit" : isFunctionLikeDeclaration(n));
-            return functionDeclaration ? [createDefinitionFromSignatureDeclaration(typeChecker, functionDeclaration)] : void 0;
           case 90:
             if (!isDefaultClause(node.parent)) {
               break;
@@ -202566,19 +203006,14 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             }
             break;
         }
-        if (node.kind === 135) {
-          const functionDeclaration = findAncestor(node, (n) => isFunctionLikeDeclaration(n));
-          const isAsyncFunction2 = functionDeclaration && some(
-            functionDeclaration.modifiers,
-            (node2) => node2.kind === 134
-            /* AsyncKeyword */
-          );
-          return isAsyncFunction2 ? [createDefinitionFromSignatureDeclaration(typeChecker, functionDeclaration)] : void 0;
-        }
-        if (node.kind === 127) {
-          const functionDeclaration = findAncestor(node, (n) => isFunctionLikeDeclaration(n));
-          const isGeneratorFunction = functionDeclaration && functionDeclaration.asteriskToken;
-          return isGeneratorFunction ? [createDefinitionFromSignatureDeclaration(typeChecker, functionDeclaration)] : void 0;
+        let findFunctionDecl;
+        switch (node.kind) {
+          case 107:
+          case 135:
+          case 127:
+            findFunctionDecl = isFunctionLikeDeclaration;
+            const functionDeclaration = findAncestor(node, findFunctionDecl);
+            return functionDeclaration ? [createDefinitionFromSignatureDeclaration(typeChecker, functionDeclaration)] : void 0;
         }
         if (isStaticModifier(node) && isClassStaticBlockDeclaration(node.parent)) {
           const classDecl = node.parent.parent;
@@ -202628,6 +203063,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             }];
           }
         }
+        if (isModifier(node) && (isClassElement(parent2) || isNamedDeclaration(parent2))) {
+          symbol = parent2.symbol;
+        }
         if (!symbol) {
           return concatenate(fileReferenceDefinition, getDefinitionInfoForIndexSignatures(node, typeChecker));
         }
@@ -202824,12 +203262,16 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             false
           );
         }
-        const { symbol, failedAliasResolution } = getSymbol(
+        let { symbol, failedAliasResolution } = getSymbol(
           node,
           typeChecker,
           /*stopAtAlias*/
           false
         );
+        if (isModifier(node) && (isClassElement(node.parent) || isNamedDeclaration(node.parent))) {
+          symbol = node.parent.symbol;
+          failedAliasResolution = false;
+        }
         if (!symbol) return void 0;
         const typeAtLocation = typeChecker.getTypeOfSymbolAtLocation(symbol, node);
         const returnType = tryGetReturnTypeOfFunction(symbol, typeAtLocation, typeChecker);
@@ -203334,22 +203776,24 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           if (!signature) {
             return;
           }
-          for (let i = 0; i < node.parameters.length && i < signature.parameters.length; ++i) {
-            const param = node.parameters[i];
-            if (!isHintableDeclaration(param)) {
-              continue;
-            }
-            const effectiveTypeAnnotation = getEffectiveTypeAnnotationNode(param);
-            if (effectiveTypeAnnotation) {
-              continue;
+          let pos = 0;
+          for (const param of node.parameters) {
+            if (isHintableDeclaration(param)) {
+              addParameterTypeHint(param, parameterIsThisKeyword(param) ? signature.thisParameter : signature.parameters[pos]);
             }
-            const typeHints = getParameterDeclarationTypeHints(signature.parameters[i]);
-            if (!typeHints) {
+            if (parameterIsThisKeyword(param)) {
               continue;
             }
-            addTypeHints(typeHints, param.questionToken ? param.questionToken.end : param.name.end);
+            pos++;
           }
         }
+        function addParameterTypeHint(node, symbol) {
+          const effectiveTypeAnnotation = getEffectiveTypeAnnotationNode(node);
+          if (effectiveTypeAnnotation || symbol === void 0) return;
+          const typeHints = getParameterDeclarationTypeHints(symbol);
+          if (typeHints === void 0) return;
+          addTypeHints(typeHints, node.questionToken ? node.questionToken.end : node.name.end);
+        }
         function getParameterDeclarationTypeHints(symbol) {
           const valueDeclaration = symbol.valueDeclaration;
           if (!valueDeclaration || !isParameter(valueDeclaration)) {
@@ -213221,6 +213665,7 @@ ${options.prefix}` : "\n" : options.prefix
         createPrinterWithRemoveCommentsNeverAsciiEscape: () => createPrinterWithRemoveCommentsNeverAsciiEscape,
         createPrinterWithRemoveCommentsOmitTrailingSemicolon: () => createPrinterWithRemoveCommentsOmitTrailingSemicolon,
         createProgram: () => createProgram,
+        createProgramDiagnostics: () => createProgramDiagnostics,
         createProgramHost: () => createProgramHost,
         createPropertyNameNodeForIdentifierOrLiteral: () => createPropertyNameNodeForIdentifierOrLiteral,
         createQueue: () => createQueue,
@@ -213390,6 +213835,8 @@ ${options.prefix}` : "\n" : options.prefix
         forEachLeadingCommentRange: () => forEachLeadingCommentRange,
         forEachNameInAccessChainWalkingLeft: () => forEachNameInAccessChainWalkingLeft,
         forEachNameOfDefaultExport: () => forEachNameOfDefaultExport,
+        forEachOptionsSyntaxByName: () => forEachOptionsSyntaxByName,
+        forEachProjectReference: () => forEachProjectReference,
         forEachPropertyAssignment: () => forEachPropertyAssignment,
         forEachResolvedProjectReference: () => forEachResolvedProjectReference,
         forEachReturnStatement: () => forEachReturnStatement,
@@ -213629,6 +214076,8 @@ ${options.prefix}` : "\n" : options.prefix
         getLeadingCommentRangesOfNode: () => getLeadingCommentRangesOfNode,
         getLeftmostAccessExpression: () => getLeftmostAccessExpression,
         getLeftmostExpression: () => getLeftmostExpression,
+        getLibFileNameFromLibReference: () => getLibFileNameFromLibReference,
+        getLibNameFromLibReference: () => getLibNameFromLibReference,
         getLibraryNameFromLibFileName: () => getLibraryNameFromLibFileName,
         getLineAndCharacterOfPosition: () => getLineAndCharacterOfPosition,
         getLineInfo: () => getLineInfo,
@@ -213701,6 +214150,8 @@ ${options.prefix}` : "\n" : options.prefix
         getOptionFromName: () => getOptionFromName,
         getOptionsForLibraryResolution: () => getOptionsForLibraryResolution,
         getOptionsNameMap: () => getOptionsNameMap,
+        getOptionsSyntaxByArrayElementValue: () => getOptionsSyntaxByArrayElementValue,
+        getOptionsSyntaxByValue: () => getOptionsSyntaxByValue,
         getOrCreateEmitNode: () => getOrCreateEmitNode,
         getOrUpdate: () => getOrUpdate,
         getOriginalNode: () => getOriginalNode,
@@ -213737,7 +214188,6 @@ ${options.prefix}` : "\n" : options.prefix
         getPrivateIdentifier: () => getPrivateIdentifier,
         getProperties: () => getProperties,
         getProperty: () => getProperty,
-        getPropertyArrayElementValue: () => getPropertyArrayElementValue,
         getPropertyAssignmentAliasLikeExpression: () => getPropertyAssignmentAliasLikeExpression,
         getPropertyNameForPropertyNameNode: () => getPropertyNameForPropertyNameNode,
         getPropertyNameFromType: () => getPropertyNameFromType,
@@ -214648,6 +215098,7 @@ ${options.prefix}` : "\n" : options.prefix
         moduleResolutionUsesNodeModules: () => moduleResolutionUsesNodeModules,
         moduleSpecifierToValidIdentifier: () => moduleSpecifierToValidIdentifier,
         moduleSpecifiers: () => ts_moduleSpecifiers_exports,
+        moduleSupportsImportAttributes: () => moduleSupportsImportAttributes,
         moduleSymbolToValidIdentifier: () => moduleSymbolToValidIdentifier,
         moveEmitHelpers: () => moveEmitHelpers,
         moveRangeEnd: () => moveRangeEnd,
@@ -216012,6 +216463,7 @@ ${options.prefix}` : "\n" : options.prefix
         ModuleKind3["ES2022"] = "es2022";
         ModuleKind3["ESNext"] = "esnext";
         ModuleKind3["Node16"] = "node16";
+        ModuleKind3["Node18"] = "node18";
         ModuleKind3["NodeNext"] = "nodenext";
         ModuleKind3["Preserve"] = "preserve";
         return ModuleKind3;
@@ -226438,20 +226890,19 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
           try {
             codeActions = project.getLanguageService().getCodeFixesAtPosition(file, startPosition, endPosition, args.errorCodes, this.getFormatOptions(file), this.getPreferences(file));
           } catch (e) {
+            const error2 = e instanceof Error ? e : new Error(e);
             const ls = project.getLanguageService();
             const existingDiagCodes = [
               ...ls.getSyntacticDiagnostics(file),
               ...ls.getSemanticDiagnostics(file),
               ...ls.getSuggestionDiagnostics(file)
-            ].map(
-              (d) => decodedTextSpanIntersectsWith(startPosition, endPosition - startPosition, d.start, d.length) && d.code
-            );
+            ].filter((d) => decodedTextSpanIntersectsWith(startPosition, endPosition - startPosition, d.start, d.length)).map((d) => d.code);
             const badCode = args.errorCodes.find((c) => !existingDiagCodes.includes(c));
             if (badCode !== void 0) {
-              e.message = `BADCLIENT: Bad error code, ${badCode} not found in range ${startPosition}..${endPosition} (found: ${existingDiagCodes.join(", ")}); could have caused this error:
-${e.message}`;
+              error2.message += `
+Additional information: BADCLIENT: Bad error code, ${badCode} not found in range ${startPosition}..${endPosition} (found: ${existingDiagCodes.join(", ")})`;
             }
-            throw e;
+            throw error2;
           }
           return simplifiedResult ? codeActions.map((codeAction) => this.mapCodeFixAction(codeAction)) : codeActions;
         }
@@ -260921,13 +261372,13 @@ var require_git_raw_commits = __commonJS({
 });
 
 // node_modules/@commitlint/cli/lib/cli.js
-import { createRequire as createRequire4 } from "module";
-import path13 from "path";
-import { fileURLToPath as fileURLToPath9, pathToFileURL as pathToFileURL4 } from "url";
-import util2 from "util";
+import { createRequire as createRequire4 } from "node:module";
+import path13 from "node:path";
+import { fileURLToPath as fileURLToPath9, pathToFileURL as pathToFileURL4 } from "node:url";
+import util2 from "node:util";
 
 // node_modules/@commitlint/lint/lib/lint.js
-import util from "util";
+import util from "node:util";
 
 // node_modules/@commitlint/is-ignored/lib/defaults.js
 var import_semver = __toESM(require_semver2(), 1);
@@ -260953,35 +261404,18 @@ var wildcards = [
   test(/^Auto-merged (.*?) into (.*)/)
 ];
 
-// node_modules/@commitlint/is-ignored/lib/validate-ignore-func.js
-function validateIgnoreFunction(fn) {
-  const fnString = fn.toString();
-  const dangerousPattern = /(?:process|require|import|eval|fetch|XMLHttpRequest|fs|child_process)(?:\s*\.|\s*\()|(?:exec|execFile|spawn)\s*\(/;
-  if (dangerousPattern.test(fnString)) {
-    const match2 = fnString.match(dangerousPattern);
-    throw new Error(`Ignore function contains forbidden pattern: ${match2?.[0].trim()}`);
-  }
-}
-
 // node_modules/@commitlint/is-ignored/lib/is-ignored.js
 function isIgnored(commit = "", opts = {}) {
   const ignores = typeof opts.ignores === "undefined" ? [] : opts.ignores;
   if (!Array.isArray(ignores)) {
     throw new Error(`ignores must be of type array, received ${ignores} of type ${typeof ignores}`);
   }
-  ignores.forEach(validateIgnoreFunction);
   const invalids = ignores.filter((c) => typeof c !== "function");
   if (invalids.length > 0) {
     throw new Error(`ignores must be array of type function, received items of type: ${invalids.map((i) => typeof i).join(", ")}`);
   }
   const base = opts.defaults === false ? [] : wildcards;
-  return [...base, ...ignores].some((w) => {
-    const result = w(commit);
-    if (typeof result !== "boolean") {
-      throw new Error(`Ignore function must return a boolean, received ${typeof result}`);
-    }
-    return result;
-  });
+  return [...base, ...ignores].some((w) => w(commit));
 }
 
 // node_modules/@commitlint/parse/lib/index.js
@@ -261534,7 +261968,7 @@ var subjectExclamationMark = (parsed, when = "always") => {
 };
 
 // node_modules/@commitlint/rules/lib/trailer-exists.js
-import { spawnSync } from "child_process";
+import { spawnSync } from "node:child_process";
 var trailerExists = (parsed, when = "always", value2 = "") => {
   const trailers = spawnSync("git", ["interpret-trailers", "--parse"], {
     input: parsed.raw || ""
@@ -261791,11 +262225,11 @@ async function lint(message2, rawRulesConfig, rawOpts) {
 }
 
 // node_modules/@commitlint/load/lib/load.js
-import path8 from "path";
+import path8 from "node:path";
 
 // node_modules/@commitlint/config-validator/lib/validate.js
 var import_ajv = __toESM(require_ajv(), 1);
-import { createRequire } from "module";
+import { createRequire } from "node:module";
 
 // node_modules/@commitlint/config-validator/lib/formatErrors.js
 function formatErrors(errors) {
@@ -261872,9 +262306,9 @@ function executable(config) {
 }
 
 // node_modules/@commitlint/resolve-extends/lib/index.js
-import fs3 from "fs";
-import path4 from "path";
-import { pathToFileURL as pathToFileURL2, fileURLToPath as fileURLToPath4 } from "url";
+import fs3 from "node:fs";
+import path4 from "node:path";
+import { pathToFileURL as pathToFileURL2, fileURLToPath as fileURLToPath4 } from "node:url";
 
 // node_modules/global-directory/index.js
 var import_ini = __toESM(require_ini(), 1);
@@ -263353,8 +263787,8 @@ var import_lodash9 = __toESM(require_lodash9(), 1);
 
 // node_modules/@commitlint/load/lib/utils/load-config.js
 var import_cosmiconfig = __toESM(require_dist(), 1);
-import { existsSync, readFileSync } from "fs";
-import path5 from "path";
+import { existsSync, readFileSync } from "node:fs";
+import path5 from "node:path";
 
 // node_modules/jiti/lib/jiti.mjs
 var import_jiti = __toESM(require_jiti(), 1);
@@ -263519,9 +263953,9 @@ async function loadParserOpts(pendingParser) {
 }
 
 // node_modules/@commitlint/load/lib/utils/load-plugin.js
-import { createRequire as createRequire3 } from "module";
-import path7 from "path";
-import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL3 } from "url";
+import { createRequire as createRequire3 } from "node:module";
+import path7 from "node:path";
+import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL3 } from "node:url";
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -264013,7 +264447,7 @@ var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
 // node_modules/@commitlint/load/lib/utils/plugin-naming.js
-import path6 from "path";
+import path6 from "node:path";
 var prefix = "commitlint-plugin";
 function convertPathToPosix(filepath) {
   const normalizedFilepath = path6.normalize(filepath);
@@ -264211,7 +264645,7 @@ async function getHistoryCommits(options, opts = {}) {
 }
 
 // node_modules/@commitlint/top-level/lib/index.js
-import path11 from "path";
+import path11 from "node:path";
 
 // node_modules/find-up/index.js
 import path10 from "node:path";
@@ -264278,6 +264712,12 @@ var Queue = class {
       current = current.next;
     }
   }
+  *drain() {
+    let current;
+    while ((current = this.dequeue()) !== void 0) {
+      yield current;
+    }
+  }
 };
 
 // node_modules/p-locate/node_modules/p-limit/index.js
@@ -264460,7 +264900,7 @@ async function searchDotGit(cwd) {
 import fs6 from "fs/promises";
 
 // node_modules/@commitlint/read/lib/get-edit-file-path.js
-import path12 from "path";
+import path12 from "node:path";
 import fs5 from "fs/promises";
 async function getEditFilePath(top2, edit) {
   if (typeof edit === "string") {