@typescript-deploys/pr-build 5.4.0-pr-56183-8 → 5.4.0-pr-55600-40

package/lib/tsc.js

@@ -3795,6 +3795,24 @@ var ScriptKind = /* @__PURE__ */ ((ScriptKind3) => {
   ScriptKind3[ScriptKind3["Deferred"] = 7] = "Deferred";
   return ScriptKind3;
 })(ScriptKind || {});
+var ScriptTarget = /* @__PURE__ */ ((ScriptTarget3) => {
+  ScriptTarget3[ScriptTarget3["ES3"] = 0] = "ES3";
+  ScriptTarget3[ScriptTarget3["ES5"] = 1] = "ES5";
+  ScriptTarget3[ScriptTarget3["ES2015"] = 2] = "ES2015";
+  ScriptTarget3[ScriptTarget3["ES2016"] = 3] = "ES2016";
+  ScriptTarget3[ScriptTarget3["ES2017"] = 4] = "ES2017";
+  ScriptTarget3[ScriptTarget3["ES2018"] = 5] = "ES2018";
+  ScriptTarget3[ScriptTarget3["ES2019"] = 6] = "ES2019";
+  ScriptTarget3[ScriptTarget3["ES2020"] = 7] = "ES2020";
+  ScriptTarget3[ScriptTarget3["ES2021"] = 8] = "ES2021";
+  ScriptTarget3[ScriptTarget3["ES2022"] = 9] = "ES2022";
+  ScriptTarget3[ScriptTarget3["ES2023"] = 10] = "ES2023";
+  ScriptTarget3[ScriptTarget3["ES2024"] = 11] = "ES2024";
+  ScriptTarget3[ScriptTarget3["ESNext"] = 99] = "ESNext";
+  ScriptTarget3[ScriptTarget3["JSON"] = 100] = "JSON";
+  ScriptTarget3[ScriptTarget3["Latest"] = 99 /* ESNext */] = "Latest";
+  return ScriptTarget3;
+})(ScriptTarget || {});
 var TransformFlags = /* @__PURE__ */ ((TransformFlags3) => {
   TransformFlags3[TransformFlags3["None"] = 0] = "None";
   TransformFlags3[TransformFlags3["ContainsTypeScript"] = 1] = "ContainsTypeScript";
@@ -6107,6 +6125,43 @@ var Diagnostics = {
   The_left_hand_side_of_a_for_in_statement_cannot_be_an_await_using_declaration: diag(1494, 1 /* Error */, "The_left_hand_side_of_a_for_in_statement_cannot_be_an_await_using_declaration_1494", "The left-hand side of a 'for...in' statement cannot be an 'await using' declaration."),
   _0_modifier_cannot_appear_on_an_await_using_declaration: diag(1495, 1 /* Error */, "_0_modifier_cannot_appear_on_an_await_using_declaration_1495", "'{0}' modifier cannot appear on an 'await using' declaration."),
   Identifier_string_literal_or_number_literal_expected: diag(1496, 1 /* Error */, "Identifier_string_literal_or_number_literal_expected_1496", "Identifier, string literal, or number literal expected."),
+  Unknown_regular_expression_flag: diag(1497, 1 /* Error */, "Unknown_regular_expression_flag_1497", "Unknown regular expression flag."),
+  Duplicate_regular_expression_flag: diag(1498, 1 /* Error */, "Duplicate_regular_expression_flag_1498", "Duplicate regular expression flag."),
+  This_regular_expression_flag_is_only_available_when_targeting_0_or_later: diag(1499, 1 /* Error */, "This_regular_expression_flag_is_only_available_when_targeting_0_or_later_1499", "This regular expression flag is only available when targeting '{0}' or later."),
+  The_Unicode_u_flag_and_the_Unicode_Sets_v_flag_cannot_be_set_simultaneously: diag(1500, 1 /* Error */, "The_Unicode_u_flag_and_the_Unicode_Sets_v_flag_cannot_be_set_simultaneously_1500", "The Unicode (u) flag and the Unicode Sets (v) flag cannot be set simultaneously."),
+  Named_capturing_groups_are_only_available_when_targeting_ES2018_or_later: diag(1501, 1 /* Error */, "Named_capturing_groups_are_only_available_when_targeting_ES2018_or_later_1501", "Named capturing groups are only available when targeting 'ES2018' or later."),
+  Subpattern_flags_must_be_present_when_there_is_a_minus_sign: diag(1502, 1 /* Error */, "Subpattern_flags_must_be_present_when_there_is_a_minus_sign_1502", "Subpattern flags must be present when there is a minus sign."),
+  Incomplete_quantifier_Digit_expected: diag(1503, 1 /* Error */, "Incomplete_quantifier_Digit_expected_1503", "Incomplete quantifier. Digit expected."),
+  Numbers_out_of_order_in_quantifier: diag(1504, 1 /* Error */, "Numbers_out_of_order_in_quantifier_1504", "Numbers out of order in quantifier."),
+  There_is_nothing_available_for_repetition: diag(1505, 1 /* Error */, "There_is_nothing_available_for_repetition_1505", "There is nothing available for repetition."),
+  Unexpected_0_Did_you_mean_to_escape_it_with_backslash: diag(1506, 1 /* Error */, "Unexpected_0_Did_you_mean_to_escape_it_with_backslash_1506", "Unexpected '{0}'. Did you mean to escape it with backslash?"),
+  This_regular_expression_flag_cannot_be_toggled_within_a_subpattern: diag(1507, 1 /* Error */, "This_regular_expression_flag_cannot_be_toggled_within_a_subpattern_1507", "This regular expression flag cannot be toggled within a subpattern."),
+  k_must_be_followed_by_a_capturing_group_name_enclosed_in_angle_brackets: diag(1508, 1 /* Error */, "k_must_be_followed_by_a_capturing_group_name_enclosed_in_angle_brackets_1508", "'\\k' must be followed by a capturing group name enclosed in angle brackets."),
+  q_is_only_available_inside_character_class: diag(1509, 1 /* Error */, "q_is_only_available_inside_character_class_1509", "'\\q' is only available inside character class."),
+  c_must_be_followed_by_an_ASCII_letter: diag(1510, 1 /* Error */, "c_must_be_followed_by_an_ASCII_letter_1510", "'\\c' must be followed by an ASCII letter."),
+  Undetermined_character_escape: diag(1511, 1 /* Error */, "Undetermined_character_escape_1511", "Undetermined character escape."),
+  Expected_a_capturing_group_name: diag(1512, 1 /* Error */, "Expected_a_capturing_group_name_1512", "Expected a capturing group name."),
+  Named_capturing_groups_with_the_same_name_must_be_mutually_exclusive_to_each_other: diag(1513, 1 /* Error */, "Named_capturing_groups_with_the_same_name_must_be_mutually_exclusive_to_each_other_1513", "Named capturing groups with the same name must be mutually exclusive to each other."),
+  A_character_class_range_must_not_be_bounded_by_another_character_class: diag(1514, 1 /* Error */, "A_character_class_range_must_not_be_bounded_by_another_character_class_1514", "A character class range must not be bounded by another character class."),
+  Range_out_of_order_in_character_class: diag(1515, 1 /* Error */, "Range_out_of_order_in_character_class_1515", "Range out of order in character class."),
+  Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class: diag(1516, 1 /* Error */, "Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_characte_1516", "Anything that would possibly match more than a single character is invalid inside a negated character class."),
+  Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead: diag(1517, 1 /* Error */, "Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead_1517", "Operators must not be mixed within a character class. Wrap it in a nested class instead."),
+  Expected_a_class_set_oprand: diag(1518, 1 /* Error */, "Expected_a_class_set_oprand_1518", "Expected a class set oprand."),
+  q_must_be_followed_by_string_alternatives_enclosed_in_braces: diag(1519, 1 /* Error */, "q_must_be_followed_by_string_alternatives_enclosed_in_braces_1519", "'\\q' must be followed by string alternatives enclosed in braces."),
+  A_character_class_must_not_contain_a_reserved_double_punctuator_Did_you_mean_to_escape_it_with_backslash: diag(1520, 1 /* Error */, "A_character_class_must_not_contain_a_reserved_double_punctuator_Did_you_mean_to_escape_it_with_backs_1520", "A character class must not contain a reserved double punctuator. Did you mean to escape it with backslash?"),
+  Expected_a_Unicode_property_name: diag(1521, 1 /* Error */, "Expected_a_Unicode_property_name_1521", "Expected a Unicode property name."),
+  Unknown_Unicode_property_name: diag(1522, 1 /* Error */, "Unknown_Unicode_property_name_1522", "Unknown Unicode property name."),
+  Expected_a_Unicode_property_value: diag(1523, 1 /* Error */, "Expected_a_Unicode_property_value_1523", "Expected a Unicode property value."),
+  Unknown_Unicode_property_value: diag(1524, 1 /* Error */, "Unknown_Unicode_property_value_1524", "Unknown Unicode property value."),
+  Expected_a_Unicode_property_name_or_value: diag(1525, 1 /* Error */, "Expected_a_Unicode_property_name_or_value_1525", "Expected a Unicode property name or value."),
+  Any_Unicode_property_that_would_possibly_match_more_than_a_single_character_is_only_available_when_the_Unicode_Sets_v_flag_is_set: diag(1526, 1 /* Error */, "Any_Unicode_property_that_would_possibly_match_more_than_a_single_character_is_only_available_when_t_1526", "Any Unicode property that would possibly match more than a single character is only available when the Unicode Sets (v) flag is set."),
+  Unknown_Unicode_property_name_or_value: diag(1527, 1 /* Error */, "Unknown_Unicode_property_name_or_value_1527", "Unknown Unicode property name or value."),
+  Unicode_property_value_expressions_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_set: diag(1528, 1 /* Error */, "Unicode_property_value_expressions_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v__1528", "Unicode property value expressions are only available when the Unicode (u) flag or the Unicode Sets (v) flag is set."),
+  _0_must_be_followed_by_a_Unicode_property_value_expression_enclosed_in_braces: diag(1529, 1 /* Error */, "_0_must_be_followed_by_a_Unicode_property_value_expression_enclosed_in_braces_1529", "'\\{0}' must be followed by a Unicode property value expression enclosed in braces."),
+  There_is_no_capturing_group_named_0_in_this_regular_expression: diag(1530, 1 /* Error */, "There_is_no_capturing_group_named_0_in_this_regular_expression_1530", "There is no capturing group named '{0}' in this regular expression."),
+  A_decimal_escape_must_refer_to_an_existent_capturing_group_There_are_only_0_capturing_groups_in_this_regular_expression: diag(1531, 1 /* Error */, "A_decimal_escape_must_refer_to_an_existent_capturing_group_There_are_only_0_capturing_groups_in_this_1531", "A decimal escape must refer to an existent capturing group. There are only {0} capturing groups in this regular expression."),
+  Decimal_escapes_are_invalid_when_there_are_no_capturing_groups_in_a_regular_expression: diag(1532, 1 /* Error */, "Decimal_escapes_are_invalid_when_there_are_no_capturing_groups_in_a_regular_expression_1532", "Decimal escapes are invalid when there are no capturing groups in a regular expression."),
+  _0_is_not_a_valid_character_escape: diag(1533, 1 /* Error */, "_0_is_not_a_valid_character_escape_1533", "'\\{0}' is not a valid character escape."),
   The_types_of_0_are_incompatible_between_these_types: diag(2200, 1 /* Error */, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."),
   The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, 1 /* Error */, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."),
   Call_signature_return_types_0_and_1_are_incompatible: diag(
@@ -7949,6 +8004,26 @@ var textToToken = new Map(Object.entries({
   "#": 63 /* HashToken */,
   "`": 62 /* BacktickToken */
 }));
+var charToRegExpFlag = new Map(Object.entries({
+  d: 1 /* HasIndices */,
+  g: 2 /* Global */,
+  i: 4 /* IgnoreCase */,
+  m: 8 /* Multiline */,
+  s: 16 /* DotAll */,
+  u: 32 /* Unicode */,
+  v: 64 /* UnicodeSets */,
+  y: 128 /* Sticky */
+}));
+var regExpFlagToFirstAvailableLanguageVersion = /* @__PURE__ */ new Map([
+  [1 /* HasIndices */, 9 /* ES2022 */],
+  [2 /* Global */, 0 /* ES3 */],
+  [4 /* IgnoreCase */, 0 /* ES3 */],
+  [8 /* Multiline */, 0 /* ES3 */],
+  [16 /* DotAll */, 5 /* ES2018 */],
+  [32 /* Unicode */, 2 /* ES2015 */],
+  [64 /* UnicodeSets */, 11 /* ES2024 */],
+  [128 /* Sticky */, 2 /* ES2015 */]
+]);
 var unicodeES3IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1610, 1649, 1747, 1749, 1749, 1765, 1766, 1786, 1788, 1808, 1808, 1810, 1836, 1920, 1957, 2309, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2784, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3294, 3294, 3296, 3297, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3424, 3425, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3805, 3840, 3840, 3904, 3911, 3913, 3946, 3976, 3979, 4096, 4129, 4131, 4135, 4137, 4138, 4176, 4181, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6067, 6176, 6263, 6272, 6312, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8319, 8319, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12353, 12436, 12445, 12446, 12449, 12538, 12540, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65138, 65140, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500];
 var unicodeES3IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 768, 846, 864, 866, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1155, 1158, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1441, 1443, 1465, 1467, 1469, 1471, 1471, 1473, 1474, 1476, 1476, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1621, 1632, 1641, 1648, 1747, 1749, 1756, 1759, 1768, 1770, 1773, 1776, 1788, 1808, 1836, 1840, 1866, 1920, 1968, 2305, 2307, 2309, 2361, 2364, 2381, 2384, 2388, 2392, 2403, 2406, 2415, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2562, 2562, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2649, 2652, 2654, 2654, 2662, 2676, 2689, 2691, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2784, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2876, 2883, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2913, 2918, 2927, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3047, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3168, 3169, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3297, 3302, 3311, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3390, 3395, 3398, 3400, 3402, 3405, 3415, 3415, 3424, 3425, 3430, 3439, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3805, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3946, 3953, 3972, 3974, 3979, 3984, 3991, 3993, 4028, 4038, 4038, 4096, 4129, 4131, 4135, 4137, 4138, 4140, 4146, 4150, 4153, 4160, 4169, 4176, 4185, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 4969, 4977, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6099, 6112, 6121, 6160, 6169, 6176, 6263, 6272, 6313, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8319, 8319, 8400, 8412, 8417, 8417, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12346, 12353, 12436, 12441, 12442, 12445, 12446, 12449, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65056, 65059, 65075, 65076, 65101, 65103, 65136, 65138, 65140, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500];
 var unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6e3, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43e3, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500];
@@ -7999,6 +8074,13 @@ function tokenToString(t) {
 function stringToToken(s) {
   return textToToken.get(s);
 }
+var regExpFlagChars = makeReverseMap(charToRegExpFlag);
+function characterToRegularExpressionFlag(c) {
+  return charToRegExpFlag.get(c);
+}
+function regularExpressionFlagToFirstAvailableLanguageVersion(f) {
+  return regExpFlagToFirstAvailableLanguageVersion.get(f);
+}
 function computeLineStarts(text) {
   const result = [];
   let pos = 0;
@@ -8095,8 +8177,11 @@ function isDigit(ch) {
 function isHexDigit(ch) {
   return isDigit(ch) || ch >= 65 /* A */ && ch <= 70 /* F */ || ch >= 97 /* a */ && ch <= 102 /* f */;
 }
-function isCodePoint(code) {
-  return code <= 1114111;
+function isASCIILetter(ch) {
+  return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */;
+}
+function isWordCharacter(ch) {
+  return isASCIILetter(ch) || isDigit(ch) || ch === 95 /* _ */;
 }
 function isOctalDigit(ch) {
   return ch >= 48 /* _0 */ && ch <= 55 /* _7 */;
@@ -8414,10 +8499,10 @@ function getShebang(text) {
   }
 }
 function isIdentifierStart(ch, languageVersion) {
-  return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch === 36 /* $ */ || ch === 95 /* _ */ || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierStart(ch, languageVersion);
+  return isASCIILetter(ch) || ch === 36 /* $ */ || ch === 95 /* _ */ || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierStart(ch, languageVersion);
 }
 function isIdentifierPart(ch, languageVersion, identifierVariant) {
-  return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch === 36 /* $ */ || ch === 95 /* _ */ || // "-" and ":" are valid in JSX Identifiers
+  return isWordCharacter(ch) || ch === 36 /* $ */ || // "-" and ":" are valid in JSX Identifiers
   (identifierVariant === 1 /* JSX */ ? ch === 45 /* minus */ || ch === 58 /* colon */ : false) || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierPart(ch, languageVersion);
 }
 function isIdentifierText(name, languageVersion, identifierVariant) {
@@ -8738,7 +8823,9 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         result += text.substring(start2, pos);
         result += scanEscapeSequence(
           /*shouldEmitInvalidEscapeError*/
-          true
+          true,
+          /*isRegularExpression*/
+          false
         );
         start2 = pos;
         continue;
@@ -8782,7 +8869,11 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       }
       if (currChar === 92 /* backslash */) {
         contents += text.substring(start2, pos);
-        contents += scanEscapeSequence(shouldEmitInvalidEscapeError);
+        contents += scanEscapeSequence(
+          shouldEmitInvalidEscapeError,
+          /*isRegularExpression*/
+          false
+        );
         start2 = pos;
         continue;
       }
@@ -8802,7 +8893,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     tokenValue = contents;
     return resultingToken;
   }
-  function scanEscapeSequence(shouldEmitInvalidEscapeError) {
+  function scanEscapeSequence(shouldEmitInvalidEscapeError, isRegularExpression) {
     const start2 = pos;
     pos++;
     if (pos >= end) {
@@ -8830,7 +8921,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           pos++;
         }
         tokenFlags |= 2048 /* ContainsInvalidEscape */;
-        if (shouldEmitInvalidEscapeError) {
+        if (isRegularExpression || shouldEmitInvalidEscapeError) {
           const code = parseInt(text.substring(start2 + 1, pos), 8);
           error(Diagnostics.Octal_escape_sequences_are_not_allowed_Use_the_syntax_0, start2, pos - start2, "\\x" + code.toString(16).padStart(2, "0"));
           return String.fromCharCode(code);
@@ -8839,7 +8930,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       case 56 /* _8 */:
       case 57 /* _9 */:
         tokenFlags |= 2048 /* ContainsInvalidEscape */;
-        if (shouldEmitInvalidEscapeError) {
+        if (isRegularExpression || shouldEmitInvalidEscapeError) {
           error(Diagnostics.Escape_sequence_0_is_not_allowed, start2, pos - start2, text.substring(start2, pos));
           return String.fromCharCode(ch);
         }
@@ -8861,62 +8952,42 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       case 34 /* doubleQuote */:
         return '"';
       case 117 /* u */:
-        if (pos < end && text.charCodeAt(pos) === 123 /* openBrace */) {
-          pos++;
-          const escapedValueString = scanMinimumNumberOfHexDigits(
-            1,
-            /*canHaveSeparators*/
-            false
-          );
-          const escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1;
-          if (escapedValue < 0) {
-            tokenFlags |= 2048 /* ContainsInvalidEscape */;
-            if (shouldEmitInvalidEscapeError) {
-              error(Diagnostics.Hexadecimal_digit_expected);
-            }
-            return text.substring(start2, pos);
-          }
-          if (!isCodePoint(escapedValue)) {
-            tokenFlags |= 2048 /* ContainsInvalidEscape */;
-            if (shouldEmitInvalidEscapeError) {
-              error(Diagnostics.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive);
-            }
-            return text.substring(start2, pos);
-          }
-          if (pos >= end) {
-            tokenFlags |= 2048 /* ContainsInvalidEscape */;
-            if (shouldEmitInvalidEscapeError) {
-              error(Diagnostics.Unexpected_end_of_text);
-            }
-            return text.substring(start2, pos);
-          }
-          if (text.charCodeAt(pos) !== 125 /* closeBrace */) {
-            tokenFlags |= 2048 /* ContainsInvalidEscape */;
-            if (shouldEmitInvalidEscapeError) {
-              error(Diagnostics.Unterminated_Unicode_escape_sequence);
-            }
-            return text.substring(start2, pos);
-          }
-          pos++;
-          tokenFlags |= 8 /* ExtendedUnicodeEscape */;
-          return utf16EncodeAsString(escapedValue);
+        if ((!isRegularExpression || shouldEmitInvalidEscapeError) && pos < end && text.charCodeAt(pos) === 123 /* openBrace */) {
+          pos -= 2;
+          return scanExtendedUnicodeEscape(isRegularExpression || shouldEmitInvalidEscapeError);
         }
         for (; pos < start2 + 6; pos++) {
           if (!(pos < end && isHexDigit(text.charCodeAt(pos)))) {
             tokenFlags |= 2048 /* ContainsInvalidEscape */;
-            if (shouldEmitInvalidEscapeError) {
+            if (isRegularExpression || shouldEmitInvalidEscapeError) {
               error(Diagnostics.Hexadecimal_digit_expected);
             }
             return text.substring(start2, pos);
           }
         }
         tokenFlags |= 1024 /* UnicodeEscape */;
-        return String.fromCharCode(parseInt(text.substring(start2 + 2, pos), 16));
+        const escapedValue = parseInt(text.substring(start2 + 2, pos), 16);
+        const escapedValueString = String.fromCharCode(escapedValue);
+        if (isRegularExpression && shouldEmitInvalidEscapeError && escapedValue >= 55296 && escapedValue <= 56319 && pos + 6 < end && text.substring(pos, pos + 2) === "\\u" && text.charCodeAt(pos + 2) !== 123 /* openBrace */) {
+          const nextStart = pos;
+          let nextPos = pos + 2;
+          for (; nextPos < nextStart + 6; nextPos++) {
+            if (!isHexDigit(text.charCodeAt(pos))) {
+              return escapedValueString;
+            }
+          }
+          const nextEscapedValue = parseInt(text.substring(nextStart + 2, nextPos), 16);
+          if (nextEscapedValue >= 56320 && nextEscapedValue <= 57343) {
+            pos = nextPos;
+            return escapedValueString + String.fromCharCode(nextEscapedValue);
+          }
+        }
+        return escapedValueString;
       case 120 /* x */:
         for (; pos < start2 + 4; pos++) {
           if (!(pos < end && isHexDigit(text.charCodeAt(pos)))) {
             tokenFlags |= 2048 /* ContainsInvalidEscape */;
-            if (shouldEmitInvalidEscapeError) {
+            if (isRegularExpression || shouldEmitInvalidEscapeError) {
               error(Diagnostics.Hexadecimal_digit_expected);
             }
             return text.substring(start2, pos);
@@ -8933,10 +9004,16 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       case 8233 /* paragraphSeparator */:
         return "";
       default:
+        if (isRegularExpression && (shouldEmitInvalidEscapeError || isIdentifierPart(ch, languageVersion))) {
+          error(Diagnostics._0_is_not_a_valid_character_escape, pos - 2, 2, String.fromCharCode(ch));
+        }
         return String.fromCharCode(ch);
     }
   }
-  function scanExtendedUnicodeEscape() {
+  function scanExtendedUnicodeEscape(shouldEmitInvalidEscapeError = true) {
+    const start2 = pos;
+    pos += 3;
+    const escapedStart = pos;
     const escapedValueString = scanMinimumNumberOfHexDigits(
       1,
       /*canHaveSeparators*/
@@ -8945,24 +9022,34 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     const escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1;
     let isInvalidExtendedEscape = false;
     if (escapedValue < 0) {
-      error(Diagnostics.Hexadecimal_digit_expected);
+      if (shouldEmitInvalidEscapeError) {
+        error(Diagnostics.Hexadecimal_digit_expected);
+      }
       isInvalidExtendedEscape = true;
     } else if (escapedValue > 1114111) {
-      error(Diagnostics.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive);
+      if (shouldEmitInvalidEscapeError) {
+        error(Diagnostics.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive, escapedStart, pos - escapedStart);
+      }
       isInvalidExtendedEscape = true;
     }
     if (pos >= end) {
-      error(Diagnostics.Unexpected_end_of_text);
+      if (shouldEmitInvalidEscapeError) {
+        error(Diagnostics.Unexpected_end_of_text);
+      }
       isInvalidExtendedEscape = true;
     } else if (text.charCodeAt(pos) === 125 /* closeBrace */) {
       pos++;
     } else {
-      error(Diagnostics.Unterminated_Unicode_escape_sequence);
+      if (shouldEmitInvalidEscapeError) {
+        error(Diagnostics.Unterminated_Unicode_escape_sequence);
+      }
       isInvalidExtendedEscape = true;
     }
     if (isInvalidExtendedEscape) {
-      return "";
+      tokenFlags |= 2048 /* ContainsInvalidEscape */;
+      return text.substring(start2, pos);
     }
+    tokenFlags |= 8 /* ExtendedUnicodeEscape */;
     return utf16EncodeAsString(escapedValue);
   }
   function peekUnicodeEscape() {
@@ -9004,8 +9091,6 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       } else if (ch === 92 /* backslash */) {
         ch = peekExtendedUnicodeEscape();
         if (ch >= 0 && isIdentifierPart(ch, languageVersion)) {
-          pos += 3;
-          tokenFlags |= 8 /* ExtendedUnicodeEscape */;
           result += scanExtendedUnicodeEscape();
           start2 = pos;
           continue;
@@ -9476,8 +9561,6 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         case 92 /* backslash */:
           const extendedCookedChar = peekExtendedUnicodeEscape();
           if (extendedCookedChar >= 0 && isIdentifierStart(extendedCookedChar, languageVersion)) {
-            pos += 3;
-            tokenFlags |= 8 /* ExtendedUnicodeEscape */;
             tokenValue = scanExtendedUnicodeEscape() + scanIdentifierParts();
             return token = getIdentifierToken();
           }
@@ -9493,7 +9576,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           return token = 0 /* Unknown */;
         case 35 /* hash */:
           if (pos !== 0 && text[pos + 1] === "!") {
-            error(Diagnostics.can_only_be_used_at_the_start_of_a_file);
+            error(Diagnostics.can_only_be_used_at_the_start_of_a_file, pos, 2);
             pos++;
             return token = 0 /* Unknown */;
           }
@@ -9502,8 +9585,6 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             pos++;
             const extendedCookedChar2 = peekExtendedUnicodeEscape();
             if (extendedCookedChar2 >= 0 && isIdentifierStart(extendedCookedChar2, languageVersion)) {
-              pos += 3;
-              tokenFlags |= 8 /* ExtendedUnicodeEscape */;
               tokenValue = "#" + scanExtendedUnicodeEscape() + scanIdentifierParts();
               return token = 81 /* PrivateIdentifier */;
             }
@@ -9641,14 +9722,841 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         }
         p++;
       }
-      while (p < end && isIdentifierPart(text.charCodeAt(p), languageVersion)) {
+      const isUnterminated = !!(tokenFlags & 4 /* Unterminated */);
+      const endOfBody = p - (isUnterminated ? 0 : 1);
+      let regExpFlags = 0 /* None */;
+      while (p < end) {
+        const ch = text.charCodeAt(p);
+        if (!isIdentifierPart(ch, languageVersion)) {
+          break;
+        }
+        const flag = characterToRegularExpressionFlag(String.fromCharCode(ch));
+        if (flag === void 0) {
+          error(Diagnostics.Unknown_regular_expression_flag, p, 1);
+        } else if (regExpFlags & flag) {
+          error(Diagnostics.Duplicate_regular_expression_flag, p, 1);
+        } else if (((regExpFlags | flag) & 96 /* UnicodeMode */) === 96 /* UnicodeMode */) {
+          error(Diagnostics.The_Unicode_u_flag_and_the_Unicode_Sets_v_flag_cannot_be_set_simultaneously, p, 1);
+        } else {
+          regExpFlags |= flag;
+          const availableFrom = regularExpressionFlagToFirstAvailableLanguageVersion(flag);
+          if (languageVersion < availableFrom) {
+            error(Diagnostics.This_regular_expression_flag_is_only_available_when_targeting_0_or_later, p, 1, ScriptTarget[availableFrom]);
+          }
+        }
         p++;
       }
-      pos = p;
+      pos = tokenStart + 1;
+      const saveTokenPos = tokenStart;
+      const saveTokenFlags = tokenFlags;
+      scanRegularExpressionWorker(text.slice(0, endOfBody), endOfBody, regExpFlags, isUnterminated);
+      if (!isUnterminated) {
+        pos = p;
+      }
+      tokenStart = saveTokenPos;
+      tokenFlags = saveTokenFlags;
       tokenValue = text.substring(tokenStart, pos);
       token = 14 /* RegularExpressionLiteral */;
     }
     return token;
+    function scanRegularExpressionWorker(text2, end2, regExpFlags, isUnterminated) {
+      const unicodeMode = !!(regExpFlags & 96 /* UnicodeMode */);
+      const unicodeSetsMode = !!(regExpFlags & 64 /* UnicodeSets */);
+      let mayContainStrings = false;
+      let numberOfCapturingGroups = 0;
+      const groupSpecifiers = /* @__PURE__ */ new Set();
+      const groupNameReferences = [];
+      const decimalEscapes = [];
+      const namedCapturingGroups = [];
+      function scanDisjunction(isInGroup) {
+        while (true) {
+          namedCapturingGroups.push(/* @__PURE__ */ new Set());
+          scanAlternative(isInGroup);
+          namedCapturingGroups.pop();
+          if (text2.charCodeAt(pos) !== 124 /* bar */) {
+            return;
+          }
+          pos++;
+        }
+      }
+      function scanAlternative(isInGroup) {
+        let isPreviousTermQuantifiable = false;
+        while (pos < end2) {
+          const start2 = pos;
+          const ch = text2.charCodeAt(pos);
+          switch (ch) {
+            case 94 /* caret */:
+            case 36 /* $ */:
+              pos++;
+              isPreviousTermQuantifiable = false;
+              break;
+            case 92 /* backslash */:
+              pos++;
+              switch (text2.charCodeAt(pos)) {
+                case 98 /* b */:
+                case 66 /* B */:
+                  pos++;
+                  isPreviousTermQuantifiable = false;
+                  break;
+                default:
+                  scanAtomEscape();
+                  isPreviousTermQuantifiable = true;
+                  break;
+              }
+              break;
+            case 40 /* openParen */:
+              pos++;
+              if (text2.charCodeAt(pos) === 63 /* question */) {
+                pos++;
+                switch (text2.charCodeAt(pos)) {
+                  case 61 /* equals */:
+                  case 33 /* exclamation */:
+                    pos++;
+                    isPreviousTermQuantifiable = false;
+                    break;
+                  case 60 /* lessThan */:
+                    const groupNameStart = pos;
+                    pos++;
+                    switch (text2.charCodeAt(pos)) {
+                      case 61 /* equals */:
+                      case 33 /* exclamation */:
+                        pos++;
+                        isPreviousTermQuantifiable = false;
+                        break;
+                      default:
+                        scanGroupName(
+                          /*isReference*/
+                          false
+                        );
+                        scanExpectedChar(62 /* greaterThan */);
+                        if (languageVersion < 5 /* ES2018 */) {
+                          error(Diagnostics.Named_capturing_groups_are_only_available_when_targeting_ES2018_or_later, groupNameStart, pos - groupNameStart);
+                        }
+                        numberOfCapturingGroups++;
+                        isPreviousTermQuantifiable = true;
+                        break;
+                    }
+                    break;
+                  default:
+                    const start3 = pos;
+                    const setFlags = scanPatternModifiers();
+                    if (text2.charCodeAt(pos) === 45 /* minus */) {
+                      pos++;
+                      scanPatternModifiers(setFlags);
+                      if (pos === start3 + 1) {
+                        error(Diagnostics.Subpattern_flags_must_be_present_when_there_is_a_minus_sign, start3, pos - start3);
+                      }
+                    }
+                    scanExpectedChar(58 /* colon */);
+                    isPreviousTermQuantifiable = true;
+                    break;
+                }
+              } else {
+                numberOfCapturingGroups++;
+                isPreviousTermQuantifiable = true;
+              }
+              scanDisjunction(
+                /*isInGroup*/
+                true
+              );
+              scanExpectedChar(41 /* closeParen */);
+              break;
+            case 123 /* openBrace */:
+              pos++;
+              const digitsStart = pos;
+              scanDigits();
+              const min2 = tokenValue;
+              if (text2.charCodeAt(pos) === 44 /* comma */) {
+                pos++;
+                scanDigits();
+                const max = tokenValue;
+                if (!min2) {
+                  if (max || text2.charCodeAt(pos) === 125 /* closeBrace */) {
+                    error(Diagnostics.Incomplete_quantifier_Digit_expected, digitsStart, 0);
+                  } else {
+                    if (unicodeMode) {
+                      error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, start2, 1, String.fromCharCode(ch));
+                    }
+                    isPreviousTermQuantifiable = true;
+                    break;
+                  }
+                }
+                if (max && Number.parseInt(min2) > Number.parseInt(max)) {
+                  error(Diagnostics.Numbers_out_of_order_in_quantifier, digitsStart, pos - digitsStart);
+                }
+              } else if (!min2) {
+                if (unicodeMode) {
+                  error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, start2, 1, String.fromCharCode(ch));
+                }
+                isPreviousTermQuantifiable = true;
+                break;
+              }
+              scanExpectedChar(125 /* closeBrace */);
+              pos--;
+            case 42 /* asterisk */:
+            case 43 /* plus */:
+            case 63 /* question */:
+              pos++;
+              if (text2.charCodeAt(pos) === 63 /* question */) {
+                pos++;
+              }
+              if (!isPreviousTermQuantifiable) {
+                error(Diagnostics.There_is_nothing_available_for_repetition, start2, pos - start2);
+              }
+              isPreviousTermQuantifiable = false;
+              break;
+            case 46 /* dot */:
+              pos++;
+              isPreviousTermQuantifiable = true;
+              break;
+            case 91 /* openBracket */:
+              pos++;
+              if (unicodeSetsMode) {
+                scanClassSetExpression();
+              } else {
+                scanClassRanges();
+              }
+              scanExpectedChar(93 /* closeBracket */);
+              isPreviousTermQuantifiable = true;
+              break;
+            case 41 /* closeParen */:
+              if (isInGroup) {
+                return;
+              }
+            case 93 /* closeBracket */:
+            case 125 /* closeBrace */:
+              if (isUnterminated && !isInGroup) {
+                return;
+              }
+              if (unicodeMode) {
+                error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
+              }
+              pos++;
+              isPreviousTermQuantifiable = true;
+              break;
+            case 47 /* slash */:
+            case 124 /* bar */:
+              return;
+            default:
+              scanSourceCharacter();
+              isPreviousTermQuantifiable = true;
+              break;
+          }
+        }
+      }
+      function scanPatternModifiers(currFlags = 0 /* None */) {
+        while (pos < end2) {
+          const ch = text2.charCodeAt(pos);
+          if (!isIdentifierPart(ch, languageVersion)) {
+            break;
+          }
+          const flag = characterToRegularExpressionFlag(String.fromCharCode(ch));
+          if (flag === void 0) {
+            error(Diagnostics.Unknown_regular_expression_flag, pos, 1);
+          } else if (currFlags & flag) {
+            error(Diagnostics.Duplicate_regular_expression_flag, pos, 1);
+          } else if (!(flag & 28 /* Modifiers */)) {
+            error(Diagnostics.This_regular_expression_flag_cannot_be_toggled_within_a_subpattern, pos, 1);
+          } else {
+            currFlags |= flag;
+            const availableFrom = regularExpressionFlagToFirstAvailableLanguageVersion(flag);
+            if (languageVersion < availableFrom) {
+              error(Diagnostics.This_regular_expression_flag_is_only_available_when_targeting_0_or_later, pos, 1, ScriptTarget[availableFrom]);
+            }
+          }
+          pos++;
+        }
+        return currFlags;
+      }
+      function scanAtomEscape() {
+        Debug.assertEqual(text2.charCodeAt(pos - 1), 92 /* backslash */);
+        switch (text2.charCodeAt(pos)) {
+          case 107 /* k */:
+            pos++;
+            if (text2.charCodeAt(pos) === 60 /* lessThan */) {
+              pos++;
+              scanGroupName(
+                /*isReference*/
+                true
+              );
+              scanExpectedChar(62 /* greaterThan */);
+            } else if (unicodeMode) {
+              error(Diagnostics.k_must_be_followed_by_a_capturing_group_name_enclosed_in_angle_brackets, pos - 2, 2);
+            }
+            break;
+          case 113 /* q */:
+            if (unicodeSetsMode) {
+              pos++;
+              error(Diagnostics.q_is_only_available_inside_character_class, pos - 2, 2);
+              break;
+            }
+          default:
+            scanCharacterClassEscape() || scanDecimalEscape() || scanCharacterEscape();
+            break;
+        }
+      }
+      function scanDecimalEscape() {
+        Debug.assertEqual(text2.charCodeAt(pos - 1), 92 /* backslash */);
+        const ch = text2.charCodeAt(pos);
+        if (ch >= 49 /* _1 */ && ch <= 57 /* _9 */) {
+          const start2 = pos;
+          scanDigits();
+          decimalEscapes.push({ pos: start2, end: pos, value: +tokenValue });
+          return true;
+        }
+        return false;
+      }
+      function scanCharacterEscape() {
+        Debug.assertEqual(text2.charCodeAt(pos - 1), 92 /* backslash */);
+        let ch = text2.charCodeAt(pos);
+        switch (ch) {
+          case 99 /* c */:
+            pos++;
+            ch = text2.charCodeAt(pos);
+            if (isASCIILetter(ch)) {
+              pos++;
+              return String.fromCharCode(ch & 31);
+            }
+            if (unicodeMode) {
+              error(Diagnostics.c_must_be_followed_by_an_ASCII_letter, pos - 2, 2);
+            }
+            return String.fromCharCode(ch);
+          case 94 /* caret */:
+          case 36 /* $ */:
+          case 47 /* slash */:
+          case 92 /* backslash */:
+          case 46 /* dot */:
+          case 42 /* asterisk */:
+          case 43 /* plus */:
+          case 63 /* question */:
+          case 40 /* openParen */:
+          case 41 /* closeParen */:
+          case 91 /* openBracket */:
+          case 93 /* closeBracket */:
+          case 123 /* openBrace */:
+          case 125 /* closeBrace */:
+          case 124 /* bar */:
+            pos++;
+            return String.fromCharCode(ch);
+          default:
+            if (pos >= end2) {
+              error(Diagnostics.Undetermined_character_escape, pos - 1, 1, ch);
+              return "\\";
+            }
+            pos--;
+            return scanEscapeSequence(
+              /*shouldEmitInvalidEscapeError*/
+              unicodeMode,
+              /*isRegularExpression*/
+              true
+            );
+        }
+      }
+      function scanGroupName(isReference) {
+        Debug.assertEqual(text2.charCodeAt(pos - 1), 60 /* lessThan */);
+        tokenStart = pos;
+        scanIdentifier(codePointAt(text2, pos), languageVersion);
+        if (pos === tokenStart) {
+          error(Diagnostics.Expected_a_capturing_group_name);
+        } else if (isReference) {
+          groupNameReferences.push({ pos: tokenStart, end: pos, name: tokenValue });
+        } else if (namedCapturingGroups.some((group2) => group2.has(tokenValue))) {
+          error(Diagnostics.Named_capturing_groups_with_the_same_name_must_be_mutually_exclusive_to_each_other, tokenStart, pos - tokenStart);
+        } else {
+          last(namedCapturingGroups).add(tokenValue);
+          groupSpecifiers.add(tokenValue);
+        }
+      }
+      function isClassContentExit(ch) {
+        return ch === 93 /* closeBracket */ || pos >= end2;
+      }
+      function scanClassRanges() {
+        Debug.assertEqual(text2.charCodeAt(pos - 1), 91 /* openBracket */);
+        if (text2.charCodeAt(pos) === 94 /* caret */) {
+          pos++;
+        }
+        while (pos < end2) {
+          const ch = text2.charCodeAt(pos);
+          if (isClassContentExit(ch)) {
+            return;
+          }
+          const minStart = pos;
+          const minCharacter = scanClassAtom();
+          if (text2.charCodeAt(pos) === 45 /* minus */) {
+            pos++;
+            const ch2 = text2.charCodeAt(pos);
+            if (isClassContentExit(ch2)) {
+              return;
+            }
+            if (!minCharacter) {
+              error(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, minStart, pos - 1 - minStart);
+            }
+            const maxStart = pos;
+            const maxCharacter = scanClassAtom();
+            if (!maxCharacter) {
+              error(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, maxStart, pos - maxStart);
+              continue;
+            }
+            if (!minCharacter) {
+              continue;
+            }
+            const minCharacterValue = codePointAt(minCharacter, 0);
+            const maxCharacterValue = codePointAt(maxCharacter, 0);
+            if (minCharacter.length === charSize(minCharacterValue) && maxCharacter.length === charSize(maxCharacterValue) && minCharacterValue > maxCharacterValue) {
+              error(Diagnostics.Range_out_of_order_in_character_class, minStart, pos - minStart);
+            }
+          }
+        }
+      }
+      function scanClassSetExpression() {
+        Debug.assertEqual(text2.charCodeAt(pos - 1), 91 /* openBracket */);
+        let isCharacterComplement = false;
+        if (text2.charCodeAt(pos) === 94 /* caret */) {
+          pos++;
+          isCharacterComplement = true;
+        }
+        let expressionMayContainStrings = false;
+        let ch = text2.charCodeAt(pos);
+        if (isClassContentExit(ch)) {
+          return;
+        }
+        let start2 = pos;
+        let oprand;
+        switch (text2.slice(pos, pos + 2)) {
+          case "--":
+          case "&&":
+            error(Diagnostics.Expected_a_class_set_oprand);
+            mayContainStrings = false;
+            break;
+          default:
+            oprand = scanClassSetOprand();
+            break;
+        }
+        switch (text2.charCodeAt(pos)) {
+          case 45 /* minus */:
+            if (text2.charCodeAt(pos + 1) === 45 /* minus */) {
+              if (isCharacterComplement && mayContainStrings) {
+                error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, start2, pos - start2);
+              }
+              expressionMayContainStrings = mayContainStrings;
+              scanClassSetSubExpression(3 /* ClassSubtraction */);
+              mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
+              return;
+            }
+            break;
+          case 38 /* ampersand */:
+            if (text2.charCodeAt(pos + 1) === 38 /* ampersand */) {
+              scanClassSetSubExpression(2 /* ClassIntersection */);
+              if (isCharacterComplement && mayContainStrings) {
+                error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, start2, pos - start2);
+              }
+              expressionMayContainStrings = mayContainStrings;
+              mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
+              return;
+            } else {
+              error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
+            }
+            break;
+          default:
+            if (isCharacterComplement && mayContainStrings) {
+              error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, start2, pos - start2);
+            }
+            expressionMayContainStrings = mayContainStrings;
+            break;
+        }
+        while (pos < end2) {
+          ch = text2.charCodeAt(pos);
+          switch (ch) {
+            case 45 /* minus */:
+              pos++;
+              ch = text2.charCodeAt(pos);
+              if (isClassContentExit(ch)) {
+                mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
+                return;
+              }
+              if (ch === 45 /* minus */) {
+                pos++;
+                error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
+                start2 = pos - 2;
+                oprand = text2.slice(start2, pos);
+                continue;
+              } else {
+                if (!oprand) {
+                  error(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, start2, pos - 1 - start2);
+                }
+                const secondStart = pos;
+                const secondOprand = scanClassSetOprand();
+                if (isCharacterComplement && mayContainStrings) {
+                  error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, secondStart, pos - secondStart);
+                }
+                expressionMayContainStrings || (expressionMayContainStrings = mayContainStrings);
+                if (!secondOprand) {
+                  error(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, secondStart, pos - secondStart);
+                  break;
+                }
+                if (!oprand) {
+                  break;
+                }
+                const minCharacterValue = codePointAt(oprand, 0);
+                const maxCharacterValue = codePointAt(secondOprand, 0);
+                if (oprand.length === charSize(minCharacterValue) && secondOprand.length === charSize(maxCharacterValue) && minCharacterValue > maxCharacterValue) {
+                  error(Diagnostics.Range_out_of_order_in_character_class, start2, pos - start2);
+                }
+              }
+              break;
+            case 38 /* ampersand */:
+              start2 = pos;
+              pos++;
+              if (text2.charCodeAt(pos) === 38 /* ampersand */) {
+                pos++;
+                error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
+                if (text2.charCodeAt(pos) === 38 /* ampersand */) {
+                  error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
+                  pos++;
+                }
+              } else {
+                error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos - 1, 1, String.fromCharCode(ch));
+              }
+              oprand = text2.slice(start2, pos);
+              continue;
+          }
+          if (isClassContentExit(text2.charCodeAt(pos))) {
+            break;
+          }
+          start2 = pos;
+          switch (text2.slice(pos, pos + 2)) {
+            case "--":
+            case "&&":
+              error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos, 2);
+              pos += 2;
+              oprand = text2.slice(start2, pos);
+              break;
+            default:
+              oprand = scanClassSetOprand();
+              break;
+          }
+        }
+        mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
+      }
+      function scanClassSetSubExpression(expressionType) {
+        let expressionMayContainStrings = mayContainStrings;
+        while (pos < end2) {
+          let ch = text2.charCodeAt(pos);
+          if (isClassContentExit(ch)) {
+            break;
+          }
+          switch (ch) {
+            case 45 /* minus */:
+              pos++;
+              if (text2.charCodeAt(pos) === 45 /* minus */) {
+                pos++;
+                if (expressionType !== 3 /* ClassSubtraction */) {
+                  error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
+                }
+              } else {
+                error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 1, 1);
+              }
+              break;
+            case 38 /* ampersand */:
+              pos++;
+              if (text2.charCodeAt(pos) === 38 /* ampersand */) {
+                pos++;
+                if (expressionType !== 2 /* ClassIntersection */) {
+                  error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
+                }
+                if (text2.charCodeAt(pos) === 38 /* ampersand */) {
+                  error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
+                  pos++;
+                }
+              } else {
+                error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos - 1, 1, String.fromCharCode(ch));
+              }
+              break;
+            default:
+              switch (expressionType) {
+                case 3 /* ClassSubtraction */:
+                  error(Diagnostics._0_expected, pos, 0, "--");
+                  break;
+                case 2 /* ClassIntersection */:
+                  error(Diagnostics._0_expected, pos, 0, "&&");
+                  break;
+                default:
+                  break;
+              }
+              break;
+          }
+          ch = text2.charCodeAt(pos);
+          if (isClassContentExit(ch)) {
+            error(Diagnostics.Expected_a_class_set_oprand);
+            break;
+          }
+          scanClassSetOprand();
+          expressionMayContainStrings && (expressionMayContainStrings = mayContainStrings);
+        }
+        mayContainStrings = expressionMayContainStrings;
+      }
+      function scanClassSetOprand() {
+        mayContainStrings = false;
+        switch (text2.charCodeAt(pos)) {
+          case 91 /* openBracket */:
+            pos++;
+            scanClassSetExpression();
+            scanExpectedChar(93 /* closeBracket */);
+            return "";
+          case 92 /* backslash */:
+            pos++;
+            if (scanCharacterClassEscape()) {
+              return "";
+            } else if (text2.charCodeAt(pos) === 113 /* q */) {
+              pos++;
+              if (text2.charCodeAt(pos) === 123 /* openBrace */) {
+                pos++;
+                scanClassStringDisjunctionContents();
+                scanExpectedChar(125 /* closeBrace */);
+                return "";
+              } else {
+                error(Diagnostics.q_must_be_followed_by_string_alternatives_enclosed_in_braces, pos - 2, 2);
+                return "q";
+              }
+            }
+            pos--;
+          default:
+            return scanClassSetCharacter();
+        }
+      }
+      function scanClassStringDisjunctionContents() {
+        Debug.assertEqual(text2.charCodeAt(pos - 1), 123 /* openBrace */);
+        let characterCount = 0;
+        while (pos < end2) {
+          const ch = text2.charCodeAt(pos);
+          switch (ch) {
+            case 125 /* closeBrace */:
+              if (characterCount !== 1) {
+                mayContainStrings = true;
+              }
+              return;
+            case 124 /* bar */:
+              if (characterCount !== 1) {
+                mayContainStrings = true;
+              }
+              pos++;
+              start = pos;
+              characterCount = 0;
+              break;
+            default:
+              scanClassSetCharacter();
+              characterCount++;
+              break;
+          }
+        }
+      }
+      function scanClassSetCharacter() {
+        const ch = text2.charCodeAt(pos);
+        if (ch === 92 /* backslash */) {
+          pos++;
+          const ch2 = text2.charCodeAt(pos);
+          switch (ch2) {
+            case 98 /* b */:
+              pos++;
+              return "\b";
+            case 38 /* ampersand */:
+            case 45 /* minus */:
+            case 33 /* exclamation */:
+            case 35 /* hash */:
+            case 37 /* percent */:
+            case 44 /* comma */:
+            case 58 /* colon */:
+            case 59 /* semicolon */:
+            case 60 /* lessThan */:
+            case 61 /* equals */:
+            case 62 /* greaterThan */:
+            case 64 /* at */:
+            case 96 /* backtick */:
+            case 126 /* tilde */:
+              pos++;
+              return String.fromCharCode(ch2);
+            default:
+              return scanCharacterEscape();
+          }
+        } else if (ch === text2.charCodeAt(pos + 1)) {
+          switch (ch) {
+            case 38 /* ampersand */:
+            case 33 /* exclamation */:
+            case 35 /* hash */:
+            case 37 /* percent */:
+            case 42 /* asterisk */:
+            case 43 /* plus */:
+            case 44 /* comma */:
+            case 46 /* dot */:
+            case 58 /* colon */:
+            case 59 /* semicolon */:
+            case 60 /* lessThan */:
+            case 61 /* equals */:
+            case 62 /* greaterThan */:
+            case 63 /* question */:
+            case 64 /* at */:
+            case 96 /* backtick */:
+            case 126 /* tilde */:
+              error(Diagnostics.A_character_class_must_not_contain_a_reserved_double_punctuator_Did_you_mean_to_escape_it_with_backslash, pos, 2);
+              pos += 2;
+              return text2.substring(pos - 2, pos);
+          }
+        }
+        switch (ch) {
+          case 47 /* slash */:
+          case 40 /* openParen */:
+          case 41 /* closeParen */:
+          case 91 /* openBracket */:
+          case 93 /* closeBracket */:
+          case 123 /* openBrace */:
+          case 125 /* closeBrace */:
+          case 45 /* minus */:
+          case 124 /* bar */:
+            error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
+            pos++;
+            return String.fromCharCode(ch);
+        }
+        return scanSourceCharacter();
+      }
+      function scanClassAtom() {
+        if (text2.charCodeAt(pos) === 92 /* backslash */) {
+          pos++;
+          const ch = text2.charCodeAt(pos);
+          switch (ch) {
+            case 98 /* b */:
+              pos++;
+              return "\b";
+            case 45 /* minus */:
+              pos++;
+              return String.fromCharCode(ch);
+            default:
+              if (scanCharacterClassEscape()) {
+                return "";
+              }
+              return scanCharacterEscape();
+          }
+        } else {
+          return scanSourceCharacter();
+        }
+      }
+      function scanCharacterClassEscape() {
+        Debug.assertEqual(text2.charCodeAt(pos - 1), 92 /* backslash */);
+        let isCharacterComplement = false;
+        const start2 = pos - 1;
+        const ch = text2.charCodeAt(pos);
+        switch (ch) {
+          case 100 /* d */:
+          case 68 /* D */:
+          case 115 /* s */:
+          case 83 /* S */:
+          case 119 /* w */:
+          case 87 /* W */:
+            pos++;
+            return true;
+          case 80 /* P */:
+            isCharacterComplement = true;
+          case 112 /* p */:
+            pos++;
+            if (text2.charCodeAt(pos) === 123 /* openBrace */) {
+              pos++;
+              const propertyNameOrValueStart = pos;
+              const propertyNameOrValue = scanWordCharacters();
+              if (text2.charCodeAt(pos) === 61 /* equals */) {
+                const propertyName = nonBinaryUnicodeProperties.get(propertyNameOrValue);
+                if (pos === propertyNameOrValueStart) {
+                  error(Diagnostics.Expected_a_Unicode_property_name);
+                } else if (propertyName === void 0) {
+                  error(Diagnostics.Unknown_Unicode_property_name, propertyNameOrValueStart, pos - propertyNameOrValueStart);
+                  const suggestion = getSpellingSuggestion(propertyNameOrValue, nonBinaryUnicodeProperties.keys(), identity);
+                  if (suggestion) {
+                    error(Diagnostics.Did_you_mean_0, propertyNameOrValueStart, pos - propertyNameOrValueStart, suggestion);
+                  }
+                }
+                pos++;
+                const propertyValueStart = pos;
+                const propertyValue = scanWordCharacters();
+                if (pos === propertyValueStart) {
+                  error(Diagnostics.Expected_a_Unicode_property_value);
+                } else if (propertyName !== void 0 && !valuesOfNonBinaryUnicodeProperties[propertyName].has(propertyValue)) {
+                  error(Diagnostics.Unknown_Unicode_property_value, propertyValueStart, pos - propertyValueStart);
+                  const suggestion = getSpellingSuggestion(propertyValue, valuesOfNonBinaryUnicodeProperties[propertyName], identity);
+                  if (suggestion) {
+                    error(Diagnostics.Did_you_mean_0, propertyValueStart, pos - propertyValueStart, suggestion);
+                  }
+                }
+              } else {
+                if (pos === propertyNameOrValueStart) {
+                  error(Diagnostics.Expected_a_Unicode_property_name_or_value);
+                } else if (binaryUnicodePropertiesOfStrings.has(propertyNameOrValue)) {
+                  if (!unicodeSetsMode) {
+                    error(Diagnostics.Any_Unicode_property_that_would_possibly_match_more_than_a_single_character_is_only_available_when_the_Unicode_Sets_v_flag_is_set, propertyNameOrValueStart, pos - propertyNameOrValueStart);
+                  } else if (isCharacterComplement) {
+                    error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, propertyNameOrValueStart, pos - propertyNameOrValueStart);
+                  } else {
+                    mayContainStrings = true;
+                  }
+                } else if (!valuesOfNonBinaryUnicodeProperties.General_Category.has(propertyNameOrValue) && !binaryUnicodeProperties.has(propertyNameOrValue)) {
+                  error(Diagnostics.Unknown_Unicode_property_name_or_value, propertyNameOrValueStart, pos - propertyNameOrValueStart);
+                  const suggestion = getSpellingSuggestion(propertyNameOrValue, [...valuesOfNonBinaryUnicodeProperties.General_Category, ...binaryUnicodeProperties, ...binaryUnicodePropertiesOfStrings], identity);
+                  if (suggestion) {
+                    error(Diagnostics.Did_you_mean_0, propertyNameOrValueStart, pos - propertyNameOrValueStart, suggestion);
+                  }
+                }
+              }
+              scanExpectedChar(125 /* closeBrace */);
+              if (!unicodeMode) {
+                error(Diagnostics.Unicode_property_value_expressions_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_set, start2, pos - start2);
+              }
+            } else if (unicodeMode) {
+              error(Diagnostics._0_must_be_followed_by_a_Unicode_property_value_expression_enclosed_in_braces, pos - 2, 2, String.fromCharCode(ch));
+            }
+            return true;
+        }
+        return false;
+      }
+      function scanWordCharacters() {
+        let value = "";
+        while (pos < end2) {
+          const ch = text2.charCodeAt(pos);
+          if (!isWordCharacter(ch)) {
+            break;
+          }
+          value += String.fromCharCode(ch);
+          pos++;
+        }
+        return value;
+      }
+      function scanSourceCharacter() {
+        const size = unicodeMode ? charSize(codePointAt(text2, pos)) : 1;
+        pos += size;
+        return text2.substring(pos - size, pos);
+      }
+      function scanExpectedChar(ch) {
+        if (text2.charCodeAt(pos) === ch) {
+          pos++;
+        } else {
+          error(Diagnostics._0_expected, pos, 0, String.fromCharCode(ch));
+        }
+      }
+      scanDisjunction(
+        /*isInGroup*/
+        false
+      );
+      forEach(groupNameReferences, (reference) => {
+        if (!groupSpecifiers.has(reference.name)) {
+          error(Diagnostics.There_is_no_capturing_group_named_0_in_this_regular_expression, reference.pos, reference.end - reference.pos, reference.name);
+        }
+      });
+      forEach(decimalEscapes, (escape) => {
+        if (escape.value > numberOfCapturingGroups) {
+          if (numberOfCapturingGroups) {
+            error(Diagnostics.A_decimal_escape_must_refer_to_an_existent_capturing_group_There_are_only_0_capturing_groups_in_this_regular_expression, escape.pos, escape.end - escape.pos, numberOfCapturingGroups);
+          } else {
+            error(Diagnostics.Decimal_escapes_are_invalid_when_there_are_no_capturing_groups_in_a_regular_expression, escape.pos, escape.end - escape.pos);
+          }
+        }
+      });
+    }
   }
   function appendIfCommentDirective(commentDirectives2, text2, commentDirectiveRegEx, lineStart) {
     const type = getDirectiveFromComment(text2.trimStart(), commentDirectiveRegEx);
@@ -9871,8 +10779,6 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         pos--;
         const extendedCookedChar = peekExtendedUnicodeEscape();
         if (extendedCookedChar >= 0 && isIdentifierStart(extendedCookedChar, languageVersion)) {
-          pos += 3;
-          tokenFlags |= 8 /* ExtendedUnicodeEscape */;
           tokenValue = scanExtendedUnicodeEscape() + scanIdentifierParts();
           return token = getIdentifierToken();
         }
@@ -10013,6 +10919,22 @@ var utf16EncodeAsStringWorker = String.fromCodePoint ? (codePoint) => String.fro
 function utf16EncodeAsString(codePoint) {
   return utf16EncodeAsStringWorker(codePoint);
 }
+var nonBinaryUnicodeProperties = new Map(Object.entries({
+  General_Category: "General_Category",
+  gc: "General_Category",
+  Script: "Script",
+  sc: "Script",
+  Script_Extensions: "Script_Extensions",
+  scx: "Script_Extensions"
+}));
+var binaryUnicodeProperties = /* @__PURE__ */ new Set(["ASCII", "ASCII_Hex_Digit", "AHex", "Alphabetic", "Alpha", "Any", "Assigned", "Bidi_Control", "Bidi_C", "Bidi_Mirrored", "Bidi_M", "Case_Ignorable", "CI", "Cased", "Changes_When_Casefolded", "CWCF", "Changes_When_Casemapped", "CWCM", "Changes_When_Lowercased", "CWL", "Changes_When_NFKC_Casefolded", "CWKCF", "Changes_When_Titlecased", "CWT", "Changes_When_Uppercased", "CWU", "Dash", "Default_Ignorable_Code_Point", "DI", "Deprecated", "Dep", "Diacritic", "Dia", "Emoji", "Emoji_Component", "EComp", "Emoji_Modifier", "EMod", "Emoji_Modifier_Base", "EBase", "Emoji_Presentation", "EPres", "Extended_Pictographic", "ExtPict", "Extender", "Ext", "Grapheme_Base", "Gr_Base", "Grapheme_Extend", "Gr_Ext", "Hex_Digit", "Hex", "IDS_Binary_Operator", "IDSB", "IDS_Trinary_Operator", "IDST", "ID_Continue", "IDC", "ID_Start", "IDS", "Ideographic", "Ideo", "Join_Control", "Join_C", "Logical_Order_Exception", "LOE", "Lowercase", "Lower", "Math", "Noncharacter_Code_Point", "NChar", "Pattern_Syntax", "Pat_Syn", "Pattern_White_Space", "Pat_WS", "Quotation_Mark", "QMark", "Radical", "Regional_Indicator", "RI", "Sentence_Terminal", "STerm", "Soft_Dotted", "SD", "Terminal_Punctuation", "Term", "Unified_Ideograph", "UIdeo", "Uppercase", "Upper", "Variation_Selector", "VS", "White_Space", "space", "XID_Continue", "XIDC", "XID_Start", "XIDS"]);
+var binaryUnicodePropertiesOfStrings = /* @__PURE__ */ new Set(["Basic_Emoji", "Emoji_Keycap_Sequence", "RGI_Emoji_Modifier_Sequence", "RGI_Emoji_Flag_Sequence", "RGI_Emoji_Tag_Sequence", "RGI_Emoji_ZWJ_Sequence", "RGI_Emoji"]);
+var valuesOfNonBinaryUnicodeProperties = {
+  General_Category: /* @__PURE__ */ new Set(["C", "Other", "Cc", "Control", "cntrl", "Cf", "Format", "Cn", "Unassigned", "Co", "Private_Use", "Cs", "Surrogate", "L", "Letter", "LC", "Cased_Letter", "Ll", "Lowercase_Letter", "Lm", "Modifier_Letter", "Lo", "Other_Letter", "Lt", "Titlecase_Letter", "Lu", "Uppercase_Letter", "M", "Mark", "Combining_Mark", "Mc", "Spacing_Mark", "Me", "Enclosing_Mark", "Mn", "Nonspacing_Mark", "N", "Number", "Nd", "Decimal_Number", "digit", "Nl", "Letter_Number", "No", "Other_Number", "P", "Punctuation", "punct", "Pc", "Connector_Punctuation", "Pd", "Dash_Punctuation", "Pe", "Close_Punctuation", "Pf", "Final_Punctuation", "Pi", "Initial_Punctuation", "Po", "Other_Punctuation", "Ps", "Open_Punctuation", "S", "Symbol", "Sc", "Currency_Symbol", "Sk", "Modifier_Symbol", "Sm", "Math_Symbol", "So", "Other_Symbol", "Z", "Separator", "Zl", "Line_Separator", "Zp", "Paragraph_Separator", "Zs", "Space_Separator"]),
+  Script: /* @__PURE__ */ new Set(["Adlm", "Adlam", "Aghb", "Caucasian_Albanian", "Ahom", "Ahom", "Arab", "Arabic", "Armi", "Imperial_Aramaic", "Armn", "Armenian", "Avst", "Avestan", "Bali", "Balinese", "Bamu", "Bamum", "Bass", "Bassa_Vah", "Batk", "Batak", "Beng", "Bengali", "Bhks", "Bhaiksuki", "Bopo", "Bopomofo", "Brah", "Brahmi", "Brai", "Braille", "Bugi", "Buginese", "Buhd", "Buhid", "Cakm", "Chakma", "Cans", "Canadian_Aboriginal", "Cari", "Carian", "Cham", "Cham", "Cher", "Cherokee", "Chrs", "Chorasmian", "Copt", "Coptic", "Qaac", "Cpmn", "Cypro_Minoan", "Cprt", "Cypriot", "Cyrl", "Cyrillic", "Deva", "Devanagari", "Diak", "Dives_Akuru", "Dogr", "Dogra", "Dsrt", "Deseret", "Dupl", "Duployan", "Egyp", "Egyptian_Hieroglyphs", "Elba", "Elbasan", "Elym", "Elymaic", "Ethi", "Ethiopic", "Geor", "Georgian", "Glag", "Glagolitic", "Gong", "Gunjala_Gondi", "Gonm", "Masaram_Gondi", "Goth", "Gothic", "Gran", "Grantha", "Grek", "Greek", "Gujr", "Gujarati", "Guru", "Gurmukhi", "Hang", "Hangul", "Hani", "Han", "Hano", "Hanunoo", "Hatr", "Hatran", "Hebr", "Hebrew", "Hira", "Hiragana", "Hluw", "Anatolian_Hieroglyphs", "Hmng", "Pahawh_Hmong", "Hmnp", "Nyiakeng_Puachue_Hmong", "Hrkt", "Katakana_Or_Hiragana", "Hung", "Old_Hungarian", "Ital", "Old_Italic", "Java", "Javanese", "Kali", "Kayah_Li", "Kana", "Katakana", "Kawi", "Kawi", "Khar", "Kharoshthi", "Khmr", "Khmer", "Khoj", "Khojki", "Kits", "Khitan_Small_Script", "Knda", "Kannada", "Kthi", "Kaithi", "Lana", "Tai_Tham", "Laoo", "Lao", "Latn", "Latin", "Lepc", "Lepcha", "Limb", "Limbu", "Lina", "Linear_A", "Linb", "Linear_B", "Lisu", "Lisu", "Lyci", "Lycian", "Lydi", "Lydian", "Mahj", "Mahajani", "Maka", "Makasar", "Mand", "Mandaic", "Mani", "Manichaean", "Marc", "Marchen", "Medf", "Medefaidrin", "Mend", "Mende_Kikakui", "Merc", "Meroitic_Cursive", "Mero", "Meroitic_Hieroglyphs", "Mlym", "Malayalam", "Modi", "Modi", "Mong", "Mongolian", "Mroo", "Mro", "Mtei", "Meetei_Mayek", "Mult", "Multani", "Mymr", "Myanmar", "Nagm", "Nag_Mundari", "Nand", "Nandinagari", "Narb", "Old_North_Arabian", "Nbat", "Nabataean", "Newa", "Newa", "Nkoo", "Nko", "Nshu", "Nushu", "Ogam", "Ogham", "Olck", "Ol_Chiki", "Orkh", "Old_Turkic", "Orya", "Oriya", "Osge", "Osage", "Osma", "Osmanya", "Ougr", "Old_Uyghur", "Palm", "Palmyrene", "Pauc", "Pau_Cin_Hau", "Perm", "Old_Permic", "Phag", "Phags_Pa", "Phli", "Inscriptional_Pahlavi", "Phlp", "Psalter_Pahlavi", "Phnx", "Phoenician", "Plrd", "Miao", "Prti", "Inscriptional_Parthian", "Rjng", "Rejang", "Rohg", "Hanifi_Rohingya", "Runr", "Runic", "Samr", "Samaritan", "Sarb", "Old_South_Arabian", "Saur", "Saurashtra", "Sgnw", "SignWriting", "Shaw", "Shavian", "Shrd", "Sharada", "Sidd", "Siddham", "Sind", "Khudawadi", "Sinh", "Sinhala", "Sogd", "Sogdian", "Sogo", "Old_Sogdian", "Sora", "Sora_Sompeng", "Soyo", "Soyombo", "Sund", "Sundanese", "Sylo", "Syloti_Nagri", "Syrc", "Syriac", "Tagb", "Tagbanwa", "Takr", "Takri", "Tale", "Tai_Le", "Talu", "New_Tai_Lue", "Taml", "Tamil", "Tang", "Tangut", "Tavt", "Tai_Viet", "Telu", "Telugu", "Tfng", "Tifinagh", "Tglg", "Tagalog", "Thaa", "Thaana", "Thai", "Thai", "Tibt", "Tibetan", "Tirh", "Tirhuta", "Tnsa", "Tangsa", "Toto", "Toto", "Ugar", "Ugaritic", "Vaii", "Vai", "Vith", "Vithkuqi", "Wara", "Warang_Citi", "Wcho", "Wancho", "Xpeo", "Old_Persian", "Xsux", "Cuneiform", "Yezi", "Yezidi", "Yiii", "Yi", "Zanb", "Zanabazar_Square", "Zinh", "Inherited", "Qaai", "Zyyy", "Common", "Zzzz", "Unknown"]),
+  Script_Extensions: /* @__PURE__ */ new Set()
+  // Currently empty
+};
 
 // src/compiler/utilitiesPublic.ts
 function isExternalModuleNameRelative(moduleName) {
@@ -27022,7 +27944,10 @@ var Parser;
   function parseErrorAtPosition(start, length2, message, ...args) {
     const lastError = lastOrUndefined(parseDiagnostics);
     let result;
-    if (!lastError || start !== lastError.start) {
+    if (message.category === 3 /* Message */ && lastError && start === lastError.start && length2 === lastError.length) {
+      result = createDetachedDiagnostic(fileName, sourceText, start, length2, message, ...args);
+      addRelatedInfo(lastError, result);
+    } else if (!lastError || start !== lastError.start) {
       result = createDetachedDiagnostic(fileName, sourceText, start, length2, message, ...args);
       parseDiagnostics.push(result);
     }
@@ -27178,7 +28103,7 @@ var Parser;
         parseErrorForInvalidName(Diagnostics.Type_alias_name_cannot_be_0, Diagnostics.Type_alias_must_be_given_a_name, 64 /* EqualsToken */);
         return;
     }
-    const suggestion = getSpellingSuggestion(expressionText, viableKeywordSuggestions, (n) => n) ?? getSpaceSuggestion(expressionText);
+    const suggestion = getSpellingSuggestion(expressionText, viableKeywordSuggestions, identity) ?? getSpaceSuggestion(expressionText);
     if (suggestion) {
       parseErrorAt(pos, node.end, Diagnostics.Unknown_keyword_or_identifier_Did_you_mean_0, suggestion);
       return;
@@ -68111,17 +69036,6 @@ function createTypeChecker(host) {
       isTypeAssignableTo
     );
   }
-  function filterContextualTypeForLiteralExpressionOfObject(node, contextualType) {
-    if (!isLiteralExpressionOfObject(node)) {
-      return contextualType;
-    }
-    return filterType(contextualType, (t) => {
-      if (!t.symbol || !(t.symbol.flags & 32 /* Class */)) {
-        return true;
-      }
-      return every(getPropertiesOfType(t), (p) => !p.valueDeclaration || !isNamedDeclaration(p.valueDeclaration) || !isPrivateIdentifier(p.valueDeclaration.name) && !(getDeclarationModifierFlagsFromSymbol(p) & 6 /* NonPublicAccessibilityModifier */));
-    });
-  }
   function getApparentTypeOfContextualType(node, contextFlags) {
     const contextualType = isObjectLiteralMethod(node) ? getContextualTypeForObjectLiteralMethod(node, contextFlags) : getContextualType(node, contextFlags);
     const instantiatedType = instantiateContextualType(contextualType, node, contextFlags);
@@ -68165,6 +69079,7 @@ function createTypeChecker(host) {
     return type;
   }
   function getContextualType(node, contextFlags) {
+    var _a;
     if (node.flags & 67108864 /* InWithStatement */) {
       return void 0;
     }
@@ -68176,14 +69091,6 @@ function createTypeChecker(host) {
     if (index >= 0) {
       return contextualTypes[index];
     }
-    const contextualType = getContextualTypeWorker(node, contextFlags);
-    if (!contextualType) {
-      return void 0;
-    }
-    return filterContextualTypeForLiteralExpressionOfObject(node, contextualType);
-  }
-  function getContextualTypeWorker(node, contextFlags) {
-    var _a;
     const { parent } = node;
     switch (parent.kind) {
       case 260 /* VariableDeclaration */:
@@ -74964,11 +75871,10 @@ function createTypeChecker(host) {
     return node;
   }
   function checkExpressionWithContextualType(node, contextualType, inferenceContext, checkMode) {
-    const filteredContextualType = filterContextualTypeForLiteralExpressionOfObject(node, contextualType);
     const contextNode = getContextNode(node);
     pushContextualType(
       contextNode,
-      filteredContextualType,
+      contextualType,
       /*isCache*/
       false
     );
@@ -74978,7 +75884,7 @@ function createTypeChecker(host) {
       inferenceContext.intraExpressionInferenceSites = void 0;
     }
     const result = maybeTypeOfKind(type, 2944 /* Literal */) && isLiteralOfContextualType(type, instantiateContextualType(
-      filteredContextualType,
+      contextualType,
       node,
       /*contextFlags*/
       void 0