@typescript-deploys/pr-build 5.3.0-pr-55600-13 → 5.3.0-pr-55601-8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/tsc.js CHANGED
@@ -18,7 +18,7 @@ and limitations under the License.
18
18
 
19
19
  // src/compiler/corePublic.ts
20
20
  var versionMajorMinor = "5.3";
21
- var version = `${versionMajorMinor}.0-insiders.20230901`;
21
+ var version = `${versionMajorMinor}.0-insiders.20230902`;
22
22
 
23
23
  // src/compiler/core.ts
24
24
  var emptyArray = [];
@@ -3781,24 +3781,6 @@ var ScriptKind = /* @__PURE__ */ ((ScriptKind3) => {
3781
3781
  ScriptKind3[ScriptKind3["Deferred"] = 7] = "Deferred";
3782
3782
  return ScriptKind3;
3783
3783
  })(ScriptKind || {});
3784
- var ScriptTarget = /* @__PURE__ */ ((ScriptTarget3) => {
3785
- ScriptTarget3[ScriptTarget3["ES3"] = 0] = "ES3";
3786
- ScriptTarget3[ScriptTarget3["ES5"] = 1] = "ES5";
3787
- ScriptTarget3[ScriptTarget3["ES2015"] = 2] = "ES2015";
3788
- ScriptTarget3[ScriptTarget3["ES2016"] = 3] = "ES2016";
3789
- ScriptTarget3[ScriptTarget3["ES2017"] = 4] = "ES2017";
3790
- ScriptTarget3[ScriptTarget3["ES2018"] = 5] = "ES2018";
3791
- ScriptTarget3[ScriptTarget3["ES2019"] = 6] = "ES2019";
3792
- ScriptTarget3[ScriptTarget3["ES2020"] = 7] = "ES2020";
3793
- ScriptTarget3[ScriptTarget3["ES2021"] = 8] = "ES2021";
3794
- ScriptTarget3[ScriptTarget3["ES2022"] = 9] = "ES2022";
3795
- ScriptTarget3[ScriptTarget3["ES2023"] = 10] = "ES2023";
3796
- ScriptTarget3[ScriptTarget3["ES2024"] = 11] = "ES2024";
3797
- ScriptTarget3[ScriptTarget3["ESNext"] = 99] = "ESNext";
3798
- ScriptTarget3[ScriptTarget3["JSON"] = 100] = "JSON";
3799
- ScriptTarget3[ScriptTarget3["Latest"] = 99 /* ESNext */] = "Latest";
3800
- return ScriptTarget3;
3801
- })(ScriptTarget || {});
3802
3784
  var TransformFlags = /* @__PURE__ */ ((TransformFlags3) => {
3803
3785
  TransformFlags3[TransformFlags3["None"] = 0] = "None";
3804
3786
  TransformFlags3[TransformFlags3["ContainsTypeScript"] = 1] = "ContainsTypeScript";
@@ -6109,43 +6091,6 @@ var Diagnostics = {
6109
6091
  The_left_hand_side_of_a_for_in_statement_cannot_be_a_using_declaration: diag(1493, 1 /* Error */, "The_left_hand_side_of_a_for_in_statement_cannot_be_a_using_declaration_1493", "The left-hand side of a 'for...in' statement cannot be a 'using' declaration."),
6110
6092
  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."),
6111
6093
  _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."),
6112
- _0_is_not_a_valid_character_escape: diag(1496, 1 /* Error */, "_0_is_not_a_valid_character_escape_1496", "'\\{0}' is not a valid character escape."),
6113
- Unknown_regular_expression_flag: diag(1497, 1 /* Error */, "Unknown_regular_expression_flag_1497", "Unknown regular expression flag."),
6114
- Duplicate_regular_expression_flag: diag(1498, 1 /* Error */, "Duplicate_regular_expression_flag_1498", "Duplicate regular expression flag."),
6115
- 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."),
6116
- 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."),
6117
- 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."),
6118
- 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."),
6119
- Incomplete_quantifier_Digit_expected: diag(1503, 1 /* Error */, "Incomplete_quantifier_Digit_expected_1503", "Incomplete quantifier. Digit expected."),
6120
- Numbers_out_of_order_in_quantifier: diag(1504, 1 /* Error */, "Numbers_out_of_order_in_quantifier_1504", "Numbers out of order in quantifier."),
6121
- There_is_nothing_available_for_repetition: diag(1505, 1 /* Error */, "There_is_nothing_available_for_repetition_1505", "There is nothing available for repetition."),
6122
- 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?"),
6123
- 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."),
6124
- 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."),
6125
- 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."),
6126
- 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."),
6127
- Undetermined_character_escape: diag(1511, 1 /* Error */, "Undetermined_character_escape_1511", "Undetermined character escape."),
6128
- Expected_a_capturing_group_name: diag(1512, 1 /* Error */, "Expected_a_capturing_group_name_1512", "Expected a capturing group name."),
6129
- 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."),
6130
- 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."),
6131
- 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."),
6132
- 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."),
6133
- 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."),
6134
- Expected_a_class_set_oprand: diag(1518, 1 /* Error */, "Expected_a_class_set_oprand_1518", "Expected a class set oprand."),
6135
- 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."),
6136
- 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?"),
6137
- Expected_a_Unicode_property_name: diag(1521, 1 /* Error */, "Expected_a_Unicode_property_name_1521", "Expected a Unicode property name."),
6138
- Unknown_Unicode_property_name: diag(1522, 1 /* Error */, "Unknown_Unicode_property_name_1522", "Unknown Unicode property name."),
6139
- Expected_a_Unicode_property_value: diag(1523, 1 /* Error */, "Expected_a_Unicode_property_value_1523", "Expected a Unicode property value."),
6140
- Unknown_Unicode_property_value: diag(1524, 1 /* Error */, "Unknown_Unicode_property_value_1524", "Unknown Unicode property value."),
6141
- 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."),
6142
- 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."),
6143
- Unknown_Unicode_property_name_or_value: diag(1527, 1 /* Error */, "Unknown_Unicode_property_name_or_value_1527", "Unknown Unicode property name or value."),
6144
- 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."),
6145
- _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."),
6146
- 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."),
6147
- 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."),
6148
- 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."),
6149
6094
  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."),
6150
6095
  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."),
6151
6096
  Call_signature_return_types_0_and_1_are_incompatible: diag(
@@ -7979,26 +7924,6 @@ var textToToken = new Map(Object.entries({
7979
7924
  "#": 63 /* HashToken */,
7980
7925
  "`": 62 /* BacktickToken */
7981
7926
  }));
7982
- var charToRegExpFlag = new Map(Object.entries({
7983
- d: 1 /* HasIndices */,
7984
- g: 2 /* Global */,
7985
- i: 4 /* IgnoreCase */,
7986
- m: 8 /* Multiline */,
7987
- s: 16 /* DotAll */,
7988
- u: 32 /* Unicode */,
7989
- v: 64 /* UnicodeSets */,
7990
- y: 128 /* Sticky */
7991
- }));
7992
- var regExpFlagToFirstAvailableLanguageVersion = /* @__PURE__ */ new Map([
7993
- [1 /* HasIndices */, 9 /* ES2022 */],
7994
- [2 /* Global */, 0 /* ES3 */],
7995
- [4 /* IgnoreCase */, 0 /* ES3 */],
7996
- [8 /* Multiline */, 0 /* ES3 */],
7997
- [16 /* DotAll */, 5 /* ES2018 */],
7998
- [32 /* Unicode */, 2 /* ES2015 */],
7999
- [64 /* UnicodeSets */, 11 /* ES2024 */],
8000
- [128 /* Sticky */, 2 /* ES2015 */]
8001
- ]);
8002
7927
  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];
8003
7928
  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];
8004
7929
  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];
@@ -8048,13 +7973,6 @@ function tokenToString(t) {
8048
7973
  function stringToToken(s) {
8049
7974
  return textToToken.get(s);
8050
7975
  }
8051
- var regExpFlagChars = makeReverseMap(charToRegExpFlag);
8052
- function characterToRegularExpressionFlag(c) {
8053
- return charToRegExpFlag.get(c);
8054
- }
8055
- function regularExpressionFlagToFirstAvailableLanguageVersion(f) {
8056
- return regExpFlagToFirstAvailableLanguageVersion.get(f);
8057
- }
8058
7976
  function computeLineStarts(text) {
8059
7977
  const result = [];
8060
7978
  let pos = 0;
@@ -8151,11 +8069,8 @@ function isDigit(ch) {
8151
8069
  function isHexDigit(ch) {
8152
8070
  return isDigit(ch) || ch >= 65 /* A */ && ch <= 70 /* F */ || ch >= 97 /* a */ && ch <= 102 /* f */;
8153
8071
  }
8154
- function isASCIILetter(ch) {
8155
- return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */;
8156
- }
8157
- function isWordCharacter(ch) {
8158
- return isASCIILetter(ch) || isDigit(ch) || ch === 95 /* _ */;
8072
+ function isCodePoint(code) {
8073
+ return code <= 1114111;
8159
8074
  }
8160
8075
  function isOctalDigit(ch) {
8161
8076
  return ch >= 48 /* _0 */ && ch <= 55 /* _7 */;
@@ -8473,10 +8388,10 @@ function getShebang(text) {
8473
8388
  }
8474
8389
  }
8475
8390
  function isIdentifierStart(ch, languageVersion) {
8476
- return isASCIILetter(ch) || ch === 36 /* $ */ || ch === 95 /* _ */ || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierStart(ch, languageVersion);
8391
+ return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch === 36 /* $ */ || ch === 95 /* _ */ || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierStart(ch, languageVersion);
8477
8392
  }
8478
8393
  function isIdentifierPart(ch, languageVersion, identifierVariant) {
8479
- return isWordCharacter(ch) || ch === 36 /* $ */ || // "-" and ":" are valid in JSX Identifiers
8394
+ 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
8480
8395
  (identifierVariant === 1 /* JSX */ ? ch === 45 /* minus */ || ch === 58 /* colon */ : false) || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierPart(ch, languageVersion);
8481
8396
  }
8482
8397
  function isIdentifierText(name, languageVersion, identifierVariant) {
@@ -8562,8 +8477,13 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
8562
8477
  });
8563
8478
  }
8564
8479
  return scanner;
8565
- function error(message, errPos = pos, length3 = 0, ...args) {
8566
- return onError == null ? void 0 : onError(message, errPos, length3, ...args);
8480
+ function error(message, errPos = pos, length3, arg0) {
8481
+ if (onError) {
8482
+ const oldPos = pos;
8483
+ pos = errPos;
8484
+ onError(message, length3 || 0, arg0);
8485
+ pos = oldPos;
8486
+ }
8567
8487
  }
8568
8488
  function scanNumberFragment() {
8569
8489
  let start2 = pos;
@@ -8788,9 +8708,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
8788
8708
  result += text.substring(start2, pos);
8789
8709
  result += scanEscapeSequence(
8790
8710
  /*shouldEmitInvalidEscapeError*/
8791
- true,
8792
- /*isRegularExpression*/
8793
- false
8711
+ true
8794
8712
  );
8795
8713
  start2 = pos;
8796
8714
  continue;
@@ -8834,11 +8752,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
8834
8752
  }
8835
8753
  if (currChar === 92 /* backslash */) {
8836
8754
  contents += text.substring(start2, pos);
8837
- contents += scanEscapeSequence(
8838
- shouldEmitInvalidEscapeError,
8839
- /*isRegularExpression*/
8840
- false
8841
- );
8755
+ contents += scanEscapeSequence(shouldEmitInvalidEscapeError);
8842
8756
  start2 = pos;
8843
8757
  continue;
8844
8758
  }
@@ -8858,7 +8772,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
8858
8772
  tokenValue = contents;
8859
8773
  return resultingToken;
8860
8774
  }
8861
- function scanEscapeSequence(shouldEmitInvalidEscapeError, isRegularExpression) {
8775
+ function scanEscapeSequence(shouldEmitInvalidEscapeError) {
8862
8776
  const start2 = pos;
8863
8777
  pos++;
8864
8778
  if (pos >= end) {
@@ -8917,9 +8831,45 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
8917
8831
  case 34 /* doubleQuote */:
8918
8832
  return '"';
8919
8833
  case 117 /* u */:
8920
- if ((!isRegularExpression || shouldEmitInvalidEscapeError) && pos < end && text.charCodeAt(pos) === 123 /* openBrace */) {
8921
- pos -= 2;
8922
- return scanExtendedUnicodeEscape(shouldEmitInvalidEscapeError);
8834
+ if (pos < end && text.charCodeAt(pos) === 123 /* openBrace */) {
8835
+ pos++;
8836
+ const escapedValueString = scanMinimumNumberOfHexDigits(
8837
+ 1,
8838
+ /*canHaveSeparators*/
8839
+ false
8840
+ );
8841
+ const escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1;
8842
+ if (escapedValue < 0) {
8843
+ tokenFlags |= 2048 /* ContainsInvalidEscape */;
8844
+ if (shouldEmitInvalidEscapeError) {
8845
+ error(Diagnostics.Hexadecimal_digit_expected);
8846
+ }
8847
+ return text.substring(start2, pos);
8848
+ }
8849
+ if (!isCodePoint(escapedValue)) {
8850
+ tokenFlags |= 2048 /* ContainsInvalidEscape */;
8851
+ if (shouldEmitInvalidEscapeError) {
8852
+ error(Diagnostics.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive);
8853
+ }
8854
+ return text.substring(start2, pos);
8855
+ }
8856
+ if (pos >= end) {
8857
+ tokenFlags |= 2048 /* ContainsInvalidEscape */;
8858
+ if (shouldEmitInvalidEscapeError) {
8859
+ error(Diagnostics.Unexpected_end_of_text);
8860
+ }
8861
+ return text.substring(start2, pos);
8862
+ }
8863
+ if (text.charCodeAt(pos) !== 125 /* closeBrace */) {
8864
+ tokenFlags |= 2048 /* ContainsInvalidEscape */;
8865
+ if (shouldEmitInvalidEscapeError) {
8866
+ error(Diagnostics.Unterminated_Unicode_escape_sequence);
8867
+ }
8868
+ return text.substring(start2, pos);
8869
+ }
8870
+ pos++;
8871
+ tokenFlags |= 8 /* ExtendedUnicodeEscape */;
8872
+ return utf16EncodeAsString(escapedValue);
8923
8873
  }
8924
8874
  for (; pos < start2 + 6; pos++) {
8925
8875
  if (!(pos < end && isHexDigit(text.charCodeAt(pos)))) {
@@ -8931,23 +8881,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
8931
8881
  }
8932
8882
  }
8933
8883
  tokenFlags |= 1024 /* UnicodeEscape */;
8934
- const escapedValue = parseInt(text.substring(start2 + 2, pos), 16);
8935
- const escapedValueString = String.fromCharCode(escapedValue);
8936
- if (isRegularExpression && shouldEmitInvalidEscapeError && escapedValue >= 55296 && escapedValue <= 56319 && pos + 6 < end && text.substring(pos, pos + 2) === "\\u" && text.charCodeAt(pos + 2) !== 123 /* openBrace */) {
8937
- const nextStart = pos;
8938
- let nextPos = pos + 2;
8939
- for (; nextPos < nextStart + 6; nextPos++) {
8940
- if (!isHexDigit(text.charCodeAt(pos))) {
8941
- return escapedValueString;
8942
- }
8943
- }
8944
- const nextEscapedValue = parseInt(text.substring(nextStart + 2, nextPos), 16);
8945
- if (nextEscapedValue >= 56320 && nextEscapedValue <= 57343) {
8946
- pos = nextPos;
8947
- return escapedValueString + String.fromCharCode(nextEscapedValue);
8948
- }
8949
- }
8950
- return escapedValueString;
8884
+ return String.fromCharCode(parseInt(text.substring(start2 + 2, pos), 16));
8951
8885
  case 120 /* x */:
8952
8886
  for (; pos < start2 + 4; pos++) {
8953
8887
  if (!(pos < end && isHexDigit(text.charCodeAt(pos)))) {
@@ -8969,16 +8903,10 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
8969
8903
  case 8233 /* paragraphSeparator */:
8970
8904
  return "";
8971
8905
  default:
8972
- if (isRegularExpression && (shouldEmitInvalidEscapeError || isIdentifierPart(ch, languageVersion))) {
8973
- error(Diagnostics._0_is_not_a_valid_character_escape, pos - 2, 2, String.fromCharCode(ch));
8974
- }
8975
8906
  return String.fromCharCode(ch);
8976
8907
  }
8977
8908
  }
8978
- function scanExtendedUnicodeEscape(shouldEmitInvalidEscapeError = true) {
8979
- const start2 = pos;
8980
- pos += 3;
8981
- const escapedStart = pos;
8909
+ function scanExtendedUnicodeEscape() {
8982
8910
  const escapedValueString = scanMinimumNumberOfHexDigits(
8983
8911
  1,
8984
8912
  /*canHaveSeparators*/
@@ -8987,34 +8915,24 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
8987
8915
  const escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1;
8988
8916
  let isInvalidExtendedEscape = false;
8989
8917
  if (escapedValue < 0) {
8990
- if (shouldEmitInvalidEscapeError) {
8991
- error(Diagnostics.Hexadecimal_digit_expected);
8992
- }
8918
+ error(Diagnostics.Hexadecimal_digit_expected);
8993
8919
  isInvalidExtendedEscape = true;
8994
8920
  } else if (escapedValue > 1114111) {
8995
- if (shouldEmitInvalidEscapeError) {
8996
- error(Diagnostics.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive, escapedStart, pos - escapedStart);
8997
- }
8921
+ error(Diagnostics.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive);
8998
8922
  isInvalidExtendedEscape = true;
8999
8923
  }
9000
8924
  if (pos >= end) {
9001
- if (shouldEmitInvalidEscapeError) {
9002
- error(Diagnostics.Unexpected_end_of_text);
9003
- }
8925
+ error(Diagnostics.Unexpected_end_of_text);
9004
8926
  isInvalidExtendedEscape = true;
9005
8927
  } else if (text.charCodeAt(pos) === 125 /* closeBrace */) {
9006
8928
  pos++;
9007
8929
  } else {
9008
- if (shouldEmitInvalidEscapeError) {
9009
- error(Diagnostics.Unterminated_Unicode_escape_sequence);
9010
- }
8930
+ error(Diagnostics.Unterminated_Unicode_escape_sequence);
9011
8931
  isInvalidExtendedEscape = true;
9012
8932
  }
9013
8933
  if (isInvalidExtendedEscape) {
9014
- tokenFlags |= 2048 /* ContainsInvalidEscape */;
9015
- return text.substring(start2, pos);
8934
+ return "";
9016
8935
  }
9017
- tokenFlags |= 8 /* ExtendedUnicodeEscape */;
9018
8936
  return utf16EncodeAsString(escapedValue);
9019
8937
  }
9020
8938
  function peekUnicodeEscape() {
@@ -9056,6 +8974,8 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
9056
8974
  } else if (ch === 92 /* backslash */) {
9057
8975
  ch = peekExtendedUnicodeEscape();
9058
8976
  if (ch >= 0 && isIdentifierPart(ch, languageVersion)) {
8977
+ pos += 3;
8978
+ tokenFlags |= 8 /* ExtendedUnicodeEscape */;
9059
8979
  result += scanExtendedUnicodeEscape();
9060
8980
  start2 = pos;
9061
8981
  continue;
@@ -9525,6 +9445,8 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
9525
9445
  case 92 /* backslash */:
9526
9446
  const extendedCookedChar = peekExtendedUnicodeEscape();
9527
9447
  if (extendedCookedChar >= 0 && isIdentifierStart(extendedCookedChar, languageVersion)) {
9448
+ pos += 3;
9449
+ tokenFlags |= 8 /* ExtendedUnicodeEscape */;
9528
9450
  tokenValue = scanExtendedUnicodeEscape() + scanIdentifierParts();
9529
9451
  return token = getIdentifierToken();
9530
9452
  }
@@ -9540,7 +9462,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
9540
9462
  return token = 0 /* Unknown */;
9541
9463
  case 35 /* hash */:
9542
9464
  if (pos !== 0 && text[pos + 1] === "!") {
9543
- error(Diagnostics.can_only_be_used_at_the_start_of_a_file, pos, 2);
9465
+ error(Diagnostics.can_only_be_used_at_the_start_of_a_file);
9544
9466
  pos++;
9545
9467
  return token = 0 /* Unknown */;
9546
9468
  }
@@ -9549,6 +9471,8 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
9549
9471
  pos++;
9550
9472
  const extendedCookedChar2 = peekExtendedUnicodeEscape();
9551
9473
  if (extendedCookedChar2 >= 0 && isIdentifierStart(extendedCookedChar2, languageVersion)) {
9474
+ pos += 3;
9475
+ tokenFlags |= 8 /* ExtendedUnicodeEscape */;
9552
9476
  tokenValue = "#" + scanExtendedUnicodeEscape() + scanIdentifierParts();
9553
9477
  return token = 81 /* PrivateIdentifier */;
9554
9478
  }
@@ -9671,831 +9595,14 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
9671
9595
  }
9672
9596
  p++;
9673
9597
  }
9674
- const isUnterminated = !!(tokenFlags & 4 /* Unterminated */);
9675
- const endOfBody = p - (isUnterminated ? 0 : 1);
9676
- let regExpFlags = 0 /* None */;
9677
- while (p < end) {
9678
- const ch = text.charCodeAt(p);
9679
- if (!isIdentifierPart(ch, languageVersion)) {
9680
- break;
9681
- }
9682
- const flag = characterToRegularExpressionFlag(String.fromCharCode(ch));
9683
- if (flag === void 0) {
9684
- error(Diagnostics.Unknown_regular_expression_flag, p, 1);
9685
- } else if (regExpFlags & flag) {
9686
- error(Diagnostics.Duplicate_regular_expression_flag, p, 1);
9687
- } else if (((regExpFlags | flag) & 96 /* UnicodeMode */) === 96 /* UnicodeMode */) {
9688
- error(Diagnostics.The_Unicode_u_flag_and_the_Unicode_Sets_v_flag_cannot_be_set_simultaneously, p, 1);
9689
- } else {
9690
- regExpFlags |= flag;
9691
- const availableFrom = regularExpressionFlagToFirstAvailableLanguageVersion(flag);
9692
- if (languageVersion < availableFrom) {
9693
- error(Diagnostics.This_regular_expression_flag_is_only_available_when_targeting_0_or_later, p, 1, ScriptTarget[availableFrom]);
9694
- }
9695
- }
9598
+ while (p < end && isIdentifierPart(text.charCodeAt(p), languageVersion)) {
9696
9599
  p++;
9697
9600
  }
9698
- pos = tokenStart + 1;
9699
- const saveTokenPos = tokenStart;
9700
- const saveTokenFlags = tokenFlags;
9701
- scanRegularExpressionWorker(text.slice(0, endOfBody), endOfBody, regExpFlags, isUnterminated);
9702
- if (!isUnterminated) {
9703
- pos = p;
9704
- }
9705
- tokenStart = saveTokenPos;
9706
- tokenFlags = saveTokenFlags;
9601
+ pos = p;
9707
9602
  tokenValue = text.substring(tokenStart, pos);
9708
9603
  token = 14 /* RegularExpressionLiteral */;
9709
9604
  }
9710
9605
  return token;
9711
- function scanRegularExpressionWorker(text2, end2, regExpFlags, isUnterminated) {
9712
- const unicodeMode = !!(regExpFlags & 96 /* UnicodeMode */);
9713
- const unicodeSetsMode = !!(regExpFlags & 64 /* UnicodeSets */);
9714
- let mayContainStrings = false;
9715
- let numberOfCapturingGroups = 0;
9716
- const groupSpecifiers = /* @__PURE__ */ new Set();
9717
- const groupNameReferences = [];
9718
- const decimalEscapes = [];
9719
- const namedCapturingGroups = [];
9720
- function scanDisjunction(isInGroup) {
9721
- while (true) {
9722
- namedCapturingGroups.push(/* @__PURE__ */ new Set());
9723
- scanAlternative(isInGroup);
9724
- namedCapturingGroups.pop();
9725
- if (text2.charCodeAt(pos) !== 124 /* bar */) {
9726
- return;
9727
- }
9728
- pos++;
9729
- }
9730
- }
9731
- function scanAlternative(isInGroup) {
9732
- let isPreviousTermQuantifiable = false;
9733
- while (pos < end2) {
9734
- const start2 = pos;
9735
- const ch = text2.charCodeAt(pos);
9736
- switch (ch) {
9737
- case 94 /* caret */:
9738
- case 36 /* $ */:
9739
- pos++;
9740
- isPreviousTermQuantifiable = false;
9741
- break;
9742
- case 92 /* backslash */:
9743
- pos++;
9744
- switch (text2.charCodeAt(pos)) {
9745
- case 98 /* b */:
9746
- case 66 /* B */:
9747
- pos++;
9748
- isPreviousTermQuantifiable = false;
9749
- break;
9750
- default:
9751
- scanAtomEscape();
9752
- isPreviousTermQuantifiable = true;
9753
- break;
9754
- }
9755
- break;
9756
- case 40 /* openParen */:
9757
- pos++;
9758
- if (text2.charCodeAt(pos) === 63 /* question */) {
9759
- pos++;
9760
- switch (text2.charCodeAt(pos)) {
9761
- case 61 /* equals */:
9762
- case 33 /* exclamation */:
9763
- pos++;
9764
- isPreviousTermQuantifiable = false;
9765
- break;
9766
- case 60 /* lessThan */:
9767
- const groupNameStart = pos;
9768
- pos++;
9769
- switch (text2.charCodeAt(pos)) {
9770
- case 61 /* equals */:
9771
- case 33 /* exclamation */:
9772
- pos++;
9773
- isPreviousTermQuantifiable = false;
9774
- break;
9775
- default:
9776
- scanGroupName(
9777
- /*isReference*/
9778
- false
9779
- );
9780
- scanExpectedChar(62 /* greaterThan */);
9781
- if (languageVersion < 5 /* ES2018 */) {
9782
- error(Diagnostics.Named_capturing_groups_are_only_available_when_targeting_ES2018_or_later, groupNameStart, pos - groupNameStart);
9783
- }
9784
- numberOfCapturingGroups++;
9785
- isPreviousTermQuantifiable = true;
9786
- break;
9787
- }
9788
- break;
9789
- default:
9790
- const start3 = pos;
9791
- const setFlags = scanPatternModifiers();
9792
- if (text2.charCodeAt(pos) === 45 /* minus */) {
9793
- pos++;
9794
- scanPatternModifiers(setFlags);
9795
- if (pos === start3 + 1) {
9796
- error(Diagnostics.Subpattern_flags_must_be_present_when_there_is_a_minus_sign, start3, pos - start3);
9797
- }
9798
- }
9799
- scanExpectedChar(58 /* colon */);
9800
- isPreviousTermQuantifiable = true;
9801
- break;
9802
- }
9803
- } else {
9804
- numberOfCapturingGroups++;
9805
- isPreviousTermQuantifiable = true;
9806
- }
9807
- scanDisjunction(
9808
- /*isInGroup*/
9809
- true
9810
- );
9811
- scanExpectedChar(41 /* closeParen */);
9812
- break;
9813
- case 123 /* openBrace */:
9814
- pos++;
9815
- const digitsStart = pos;
9816
- scanDigits();
9817
- const min2 = tokenValue;
9818
- if (!min2) {
9819
- error(Diagnostics.Incomplete_quantifier_Digit_expected);
9820
- }
9821
- if (text2.charCodeAt(pos) === 44 /* comma */) {
9822
- pos++;
9823
- scanDigits();
9824
- const max = tokenValue;
9825
- if (max && Number.parseInt(min2) > Number.parseInt(max)) {
9826
- error(Diagnostics.Numbers_out_of_order_in_quantifier, digitsStart, pos - digitsStart);
9827
- }
9828
- }
9829
- scanExpectedChar(125 /* closeBrace */);
9830
- pos--;
9831
- case 42 /* asterisk */:
9832
- case 43 /* plus */:
9833
- case 63 /* question */:
9834
- pos++;
9835
- if (text2.charCodeAt(pos) === 63 /* question */) {
9836
- pos++;
9837
- }
9838
- if (!isPreviousTermQuantifiable) {
9839
- error(Diagnostics.There_is_nothing_available_for_repetition, start2, pos - start2);
9840
- }
9841
- isPreviousTermQuantifiable = false;
9842
- break;
9843
- case 46 /* dot */:
9844
- pos++;
9845
- isPreviousTermQuantifiable = true;
9846
- break;
9847
- case 91 /* openBracket */:
9848
- pos++;
9849
- if (unicodeSetsMode) {
9850
- scanClassSetExpression();
9851
- } else {
9852
- scanClassRanges();
9853
- }
9854
- scanExpectedChar(93 /* closeBracket */);
9855
- isPreviousTermQuantifiable = true;
9856
- break;
9857
- case 41 /* closeParen */:
9858
- if (isInGroup) {
9859
- return;
9860
- }
9861
- case 93 /* closeBracket */:
9862
- case 125 /* closeBrace */:
9863
- if (isUnterminated && !isInGroup) {
9864
- return;
9865
- }
9866
- error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
9867
- pos++;
9868
- isPreviousTermQuantifiable = true;
9869
- break;
9870
- case 47 /* slash */:
9871
- case 124 /* bar */:
9872
- return;
9873
- default:
9874
- if (isLineBreak(ch)) {
9875
- return;
9876
- }
9877
- scanSourceCharacter();
9878
- isPreviousTermQuantifiable = true;
9879
- break;
9880
- }
9881
- }
9882
- }
9883
- function scanPatternModifiers(currFlags = 0 /* None */) {
9884
- while (pos < end2) {
9885
- const ch = text2.charCodeAt(pos);
9886
- if (!isIdentifierPart(ch, languageVersion)) {
9887
- break;
9888
- }
9889
- const flag = characterToRegularExpressionFlag(String.fromCharCode(ch));
9890
- if (flag === void 0) {
9891
- error(Diagnostics.Unknown_regular_expression_flag, pos, 1);
9892
- } else if (currFlags & flag) {
9893
- error(Diagnostics.Duplicate_regular_expression_flag, pos, 1);
9894
- } else if (!(flag & 28 /* Modifiers */)) {
9895
- error(Diagnostics.This_regular_expression_flag_cannot_be_toggled_within_a_subpattern, pos, 1);
9896
- } else {
9897
- currFlags |= flag;
9898
- const availableFrom = regularExpressionFlagToFirstAvailableLanguageVersion(flag);
9899
- if (languageVersion < availableFrom) {
9900
- error(Diagnostics.This_regular_expression_flag_is_only_available_when_targeting_0_or_later, pos, 1, ScriptTarget[availableFrom]);
9901
- }
9902
- }
9903
- pos++;
9904
- }
9905
- return currFlags;
9906
- }
9907
- function scanAtomEscape() {
9908
- Debug.assertEqual(text2.charCodeAt(pos - 1), 92 /* backslash */);
9909
- switch (text2.charCodeAt(pos)) {
9910
- case 107 /* k */:
9911
- pos++;
9912
- if (text2.charCodeAt(pos) === 60 /* lessThan */) {
9913
- pos++;
9914
- scanGroupName(
9915
- /*isReference*/
9916
- true
9917
- );
9918
- scanExpectedChar(62 /* greaterThan */);
9919
- } else if (unicodeMode) {
9920
- error(Diagnostics.k_must_be_followed_by_a_capturing_group_name_enclosed_in_angle_brackets, pos - 2, 2);
9921
- }
9922
- break;
9923
- case 113 /* q */:
9924
- if (unicodeSetsMode) {
9925
- pos++;
9926
- error(Diagnostics.q_is_only_available_inside_character_class, pos - 2, 2);
9927
- break;
9928
- }
9929
- default:
9930
- scanCharacterClassEscape() || scanDecimalEscape() || scanCharacterEscape();
9931
- break;
9932
- }
9933
- }
9934
- function scanDecimalEscape() {
9935
- Debug.assertEqual(text2.charCodeAt(pos - 1), 92 /* backslash */);
9936
- const ch = text2.charCodeAt(pos);
9937
- if (ch >= 49 /* _1 */ && ch <= 57 /* _9 */) {
9938
- const start2 = pos;
9939
- scanDigits();
9940
- decimalEscapes.push({ pos: start2, end: pos, value: +tokenValue });
9941
- return true;
9942
- }
9943
- return false;
9944
- }
9945
- function scanCharacterEscape() {
9946
- Debug.assertEqual(text2.charCodeAt(pos - 1), 92 /* backslash */);
9947
- let ch = text2.charCodeAt(pos);
9948
- switch (ch) {
9949
- case 99 /* c */:
9950
- pos++;
9951
- ch = text2.charCodeAt(pos);
9952
- if (isASCIILetter(ch)) {
9953
- pos++;
9954
- return String.fromCharCode(ch & 31);
9955
- }
9956
- if (unicodeMode) {
9957
- error(Diagnostics.c_must_be_followed_by_an_ASCII_letter, pos - 2, 2);
9958
- }
9959
- return String.fromCharCode(ch);
9960
- case 94 /* caret */:
9961
- case 36 /* $ */:
9962
- case 47 /* slash */:
9963
- case 92 /* backslash */:
9964
- case 46 /* dot */:
9965
- case 42 /* asterisk */:
9966
- case 43 /* plus */:
9967
- case 63 /* question */:
9968
- case 40 /* openParen */:
9969
- case 41 /* closeParen */:
9970
- case 91 /* openBracket */:
9971
- case 93 /* closeBracket */:
9972
- case 123 /* openBrace */:
9973
- case 125 /* closeBrace */:
9974
- case 124 /* bar */:
9975
- pos++;
9976
- return String.fromCharCode(ch);
9977
- default:
9978
- if (pos >= end2 || isLineBreak(ch)) {
9979
- error(Diagnostics.Undetermined_character_escape, pos - 1, 1, ch);
9980
- return "\\";
9981
- }
9982
- pos--;
9983
- return scanEscapeSequence(
9984
- /*shouldEmitInvalidEscapeError*/
9985
- unicodeMode,
9986
- /*isRegularExpression*/
9987
- true
9988
- );
9989
- }
9990
- }
9991
- function scanGroupName(isReference) {
9992
- Debug.assertEqual(text2.charCodeAt(pos - 1), 60 /* lessThan */);
9993
- tokenStart = pos;
9994
- scanIdentifier(codePointAt(text2, pos), languageVersion);
9995
- if (pos === tokenStart) {
9996
- error(Diagnostics.Expected_a_capturing_group_name);
9997
- } else if (isReference) {
9998
- groupNameReferences.push({ pos: tokenStart, end: pos, name: tokenValue });
9999
- } else if (namedCapturingGroups.some((group2) => group2.has(tokenValue))) {
10000
- error(Diagnostics.Named_capturing_groups_with_the_same_name_must_be_mutually_exclusive_to_each_other, tokenStart, pos - tokenStart);
10001
- } else {
10002
- last(namedCapturingGroups).add(tokenValue);
10003
- groupSpecifiers.add(tokenValue);
10004
- }
10005
- }
10006
- function isClassContentExit(ch) {
10007
- return ch === 93 /* closeBracket */ || pos >= end2 || isLineBreak(ch);
10008
- }
10009
- function scanClassRanges() {
10010
- Debug.assertEqual(text2.charCodeAt(pos - 1), 91 /* openBracket */);
10011
- if (text2.charCodeAt(pos) === 94 /* caret */) {
10012
- pos++;
10013
- }
10014
- while (pos < end2) {
10015
- const ch = text2.charCodeAt(pos);
10016
- if (isClassContentExit(ch)) {
10017
- return;
10018
- }
10019
- const minStart = pos;
10020
- const minCharacter = scanClassAtom();
10021
- if (text2.charCodeAt(pos) === 45 /* minus */) {
10022
- pos++;
10023
- const ch2 = text2.charCodeAt(pos);
10024
- if (isClassContentExit(ch2)) {
10025
- return;
10026
- }
10027
- if (!minCharacter) {
10028
- error(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, minStart, pos - 1 - minStart);
10029
- }
10030
- const maxStart = pos;
10031
- const maxCharacter = scanClassAtom();
10032
- if (!maxCharacter) {
10033
- error(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, maxStart, pos - maxStart);
10034
- continue;
10035
- }
10036
- if (!minCharacter) {
10037
- continue;
10038
- }
10039
- const minCharacterValue = codePointAt(minCharacter, 0);
10040
- const maxCharacterValue = codePointAt(maxCharacter, 0);
10041
- if (minCharacter.length === charSize(minCharacterValue) && maxCharacter.length === charSize(maxCharacterValue) && minCharacterValue > maxCharacterValue) {
10042
- error(Diagnostics.Range_out_of_order_in_character_class, minStart, pos - minStart);
10043
- }
10044
- }
10045
- }
10046
- }
10047
- function scanClassSetExpression() {
10048
- Debug.assertEqual(text2.charCodeAt(pos - 1), 91 /* openBracket */);
10049
- let isCharacterComplement = false;
10050
- if (text2.charCodeAt(pos) === 94 /* caret */) {
10051
- pos++;
10052
- isCharacterComplement = true;
10053
- }
10054
- let expressionMayContainStrings = false;
10055
- let ch = text2.charCodeAt(pos);
10056
- if (isClassContentExit(ch)) {
10057
- return;
10058
- }
10059
- let start2 = pos;
10060
- let oprand;
10061
- switch (text2.slice(pos, pos + 2)) {
10062
- case "--":
10063
- case "&&":
10064
- error(Diagnostics.Expected_a_class_set_oprand);
10065
- mayContainStrings = false;
10066
- break;
10067
- default:
10068
- oprand = scanClassSetOprand();
10069
- break;
10070
- }
10071
- switch (text2.charCodeAt(pos)) {
10072
- case 45 /* minus */:
10073
- if (text2.charCodeAt(pos + 1) === 45 /* minus */) {
10074
- if (isCharacterComplement && mayContainStrings) {
10075
- error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, start2, pos - start2);
10076
- }
10077
- expressionMayContainStrings = mayContainStrings;
10078
- scanClassSetSubExpression(3 /* ClassSubtraction */);
10079
- mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
10080
- return;
10081
- }
10082
- break;
10083
- case 38 /* ampersand */:
10084
- if (text2.charCodeAt(pos + 1) === 38 /* ampersand */) {
10085
- scanClassSetSubExpression(2 /* ClassIntersection */);
10086
- if (isCharacterComplement && mayContainStrings) {
10087
- error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, start2, pos - start2);
10088
- }
10089
- expressionMayContainStrings = mayContainStrings;
10090
- mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
10091
- return;
10092
- } else {
10093
- error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
10094
- }
10095
- break;
10096
- default:
10097
- if (isCharacterComplement && mayContainStrings) {
10098
- error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, start2, pos - start2);
10099
- }
10100
- expressionMayContainStrings = mayContainStrings;
10101
- break;
10102
- }
10103
- while (pos < end2) {
10104
- ch = text2.charCodeAt(pos);
10105
- switch (ch) {
10106
- case 45 /* minus */:
10107
- pos++;
10108
- ch = text2.charCodeAt(pos);
10109
- if (isClassContentExit(ch)) {
10110
- mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
10111
- return;
10112
- }
10113
- if (ch === 45 /* minus */) {
10114
- pos++;
10115
- error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
10116
- start2 = pos - 2;
10117
- oprand = text2.slice(start2, pos);
10118
- continue;
10119
- } else {
10120
- if (!oprand) {
10121
- error(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, start2, pos - 1 - start2);
10122
- }
10123
- const secondStart = pos;
10124
- const secondOprand = scanClassSetOprand();
10125
- if (isCharacterComplement && mayContainStrings) {
10126
- error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, secondStart, pos - secondStart);
10127
- }
10128
- expressionMayContainStrings || (expressionMayContainStrings = mayContainStrings);
10129
- if (!secondOprand) {
10130
- error(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, secondStart, pos - secondStart);
10131
- break;
10132
- }
10133
- if (!oprand) {
10134
- break;
10135
- }
10136
- const minCharacterValue = codePointAt(oprand, 0);
10137
- const maxCharacterValue = codePointAt(secondOprand, 0);
10138
- if (oprand.length === charSize(minCharacterValue) && secondOprand.length === charSize(maxCharacterValue) && minCharacterValue > maxCharacterValue) {
10139
- error(Diagnostics.Range_out_of_order_in_character_class, start2, pos - start2);
10140
- }
10141
- }
10142
- break;
10143
- case 38 /* ampersand */:
10144
- start2 = pos;
10145
- pos++;
10146
- if (text2.charCodeAt(pos) === 38 /* ampersand */) {
10147
- pos++;
10148
- error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
10149
- if (text2.charCodeAt(pos) === 38 /* ampersand */) {
10150
- error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
10151
- pos++;
10152
- }
10153
- } else {
10154
- error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos - 1, 1, String.fromCharCode(ch));
10155
- }
10156
- oprand = text2.slice(start2, pos);
10157
- continue;
10158
- }
10159
- if (isClassContentExit(text2.charCodeAt(pos))) {
10160
- break;
10161
- }
10162
- start2 = pos;
10163
- switch (text2.slice(pos, pos + 2)) {
10164
- case "--":
10165
- case "&&":
10166
- error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos, 2);
10167
- pos += 2;
10168
- oprand = text2.slice(start2, pos);
10169
- break;
10170
- default:
10171
- oprand = scanClassSetOprand();
10172
- break;
10173
- }
10174
- }
10175
- mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
10176
- }
10177
- function scanClassSetSubExpression(expressionType) {
10178
- let expressionMayContainStrings = mayContainStrings;
10179
- while (pos < end2) {
10180
- let ch = text2.charCodeAt(pos);
10181
- if (isClassContentExit(ch)) {
10182
- break;
10183
- }
10184
- switch (ch) {
10185
- case 45 /* minus */:
10186
- pos++;
10187
- if (text2.charCodeAt(pos) === 45 /* minus */) {
10188
- pos++;
10189
- if (expressionType !== 3 /* ClassSubtraction */) {
10190
- error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
10191
- }
10192
- } else {
10193
- error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 1, 1);
10194
- }
10195
- break;
10196
- case 38 /* ampersand */:
10197
- pos++;
10198
- if (text2.charCodeAt(pos) === 38 /* ampersand */) {
10199
- pos++;
10200
- if (expressionType !== 2 /* ClassIntersection */) {
10201
- error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
10202
- }
10203
- if (text2.charCodeAt(pos) === 38 /* ampersand */) {
10204
- error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
10205
- pos++;
10206
- }
10207
- } else {
10208
- error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos - 1, 1, String.fromCharCode(ch));
10209
- }
10210
- break;
10211
- default:
10212
- switch (expressionType) {
10213
- case 3 /* ClassSubtraction */:
10214
- error(Diagnostics._0_expected, pos, 0, "--");
10215
- break;
10216
- case 2 /* ClassIntersection */:
10217
- error(Diagnostics._0_expected, pos, 0, "&&");
10218
- break;
10219
- default:
10220
- break;
10221
- }
10222
- break;
10223
- }
10224
- ch = text2.charCodeAt(pos);
10225
- if (isClassContentExit(ch)) {
10226
- error(Diagnostics.Expected_a_class_set_oprand);
10227
- break;
10228
- }
10229
- scanClassSetOprand();
10230
- expressionMayContainStrings && (expressionMayContainStrings = mayContainStrings);
10231
- }
10232
- mayContainStrings = expressionMayContainStrings;
10233
- }
10234
- function scanClassSetOprand() {
10235
- mayContainStrings = false;
10236
- switch (text2.charCodeAt(pos)) {
10237
- case 91 /* openBracket */:
10238
- pos++;
10239
- scanClassSetExpression();
10240
- scanExpectedChar(93 /* closeBracket */);
10241
- return "";
10242
- case 92 /* backslash */:
10243
- pos++;
10244
- if (scanCharacterClassEscape()) {
10245
- return "";
10246
- } else if (text2.charCodeAt(pos) === 113 /* q */) {
10247
- pos++;
10248
- if (text2.charCodeAt(pos) === 123 /* openBrace */) {
10249
- pos++;
10250
- scanClassStringDisjunctionContents();
10251
- scanExpectedChar(125 /* closeBrace */);
10252
- return "";
10253
- } else {
10254
- error(Diagnostics.q_must_be_followed_by_string_alternatives_enclosed_in_braces, pos - 2, 2);
10255
- return "q";
10256
- }
10257
- }
10258
- pos--;
10259
- default:
10260
- return scanClassSetCharacter();
10261
- }
10262
- }
10263
- function scanClassStringDisjunctionContents() {
10264
- Debug.assertEqual(text2.charCodeAt(pos - 1), 123 /* openBrace */);
10265
- let characterCount = 0;
10266
- while (pos < end2) {
10267
- const ch = text2.charCodeAt(pos);
10268
- switch (ch) {
10269
- case 125 /* closeBrace */:
10270
- if (characterCount !== 1) {
10271
- mayContainStrings = true;
10272
- }
10273
- return;
10274
- case 124 /* bar */:
10275
- if (characterCount !== 1) {
10276
- mayContainStrings = true;
10277
- }
10278
- pos++;
10279
- start = pos;
10280
- characterCount = 0;
10281
- break;
10282
- default:
10283
- if (isLineBreak(ch)) {
10284
- break;
10285
- }
10286
- scanClassSetCharacter();
10287
- characterCount++;
10288
- break;
10289
- }
10290
- }
10291
- }
10292
- function scanClassSetCharacter() {
10293
- const ch = text2.charCodeAt(pos);
10294
- if (ch === 92 /* backslash */) {
10295
- pos++;
10296
- const ch2 = text2.charCodeAt(pos);
10297
- switch (ch2) {
10298
- case 98 /* b */:
10299
- pos++;
10300
- return "\b";
10301
- case 38 /* ampersand */:
10302
- case 45 /* minus */:
10303
- case 33 /* exclamation */:
10304
- case 35 /* hash */:
10305
- case 37 /* percent */:
10306
- case 44 /* comma */:
10307
- case 58 /* colon */:
10308
- case 59 /* semicolon */:
10309
- case 60 /* lessThan */:
10310
- case 61 /* equals */:
10311
- case 62 /* greaterThan */:
10312
- case 64 /* at */:
10313
- case 96 /* backtick */:
10314
- case 126 /* tilde */:
10315
- pos++;
10316
- return String.fromCharCode(ch2);
10317
- default:
10318
- return scanCharacterEscape();
10319
- }
10320
- } else if (ch === text2.charCodeAt(pos + 1)) {
10321
- switch (ch) {
10322
- case 38 /* ampersand */:
10323
- case 33 /* exclamation */:
10324
- case 35 /* hash */:
10325
- case 37 /* percent */:
10326
- case 42 /* asterisk */:
10327
- case 43 /* plus */:
10328
- case 44 /* comma */:
10329
- case 46 /* dot */:
10330
- case 58 /* colon */:
10331
- case 59 /* semicolon */:
10332
- case 60 /* lessThan */:
10333
- case 61 /* equals */:
10334
- case 62 /* greaterThan */:
10335
- case 63 /* question */:
10336
- case 64 /* at */:
10337
- case 96 /* backtick */:
10338
- case 126 /* tilde */:
10339
- error(Diagnostics.A_character_class_must_not_contain_a_reserved_double_punctuator_Did_you_mean_to_escape_it_with_backslash, pos, 2);
10340
- pos += 2;
10341
- return text2.substring(pos - 2, pos);
10342
- }
10343
- }
10344
- switch (ch) {
10345
- case 47 /* slash */:
10346
- case 40 /* openParen */:
10347
- case 41 /* closeParen */:
10348
- case 91 /* openBracket */:
10349
- case 93 /* closeBracket */:
10350
- case 123 /* openBrace */:
10351
- case 125 /* closeBrace */:
10352
- case 45 /* minus */:
10353
- case 124 /* bar */:
10354
- error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
10355
- pos++;
10356
- return String.fromCharCode(ch);
10357
- }
10358
- return scanSourceCharacter();
10359
- }
10360
- function scanClassAtom() {
10361
- if (text2.charCodeAt(pos) === 92 /* backslash */) {
10362
- pos++;
10363
- const ch = text2.charCodeAt(pos);
10364
- switch (ch) {
10365
- case 98 /* b */:
10366
- pos++;
10367
- return "\b";
10368
- case 45 /* minus */:
10369
- pos++;
10370
- return String.fromCharCode(ch);
10371
- default:
10372
- if (scanCharacterClassEscape()) {
10373
- return "";
10374
- }
10375
- return scanCharacterEscape();
10376
- }
10377
- } else {
10378
- return scanSourceCharacter();
10379
- }
10380
- }
10381
- function scanCharacterClassEscape() {
10382
- Debug.assertEqual(text2.charCodeAt(pos - 1), 92 /* backslash */);
10383
- let isCharacterComplement = false;
10384
- const start2 = pos - 1;
10385
- const ch = text2.charCodeAt(pos);
10386
- switch (ch) {
10387
- case 100 /* d */:
10388
- case 68 /* D */:
10389
- case 115 /* s */:
10390
- case 83 /* S */:
10391
- case 119 /* w */:
10392
- case 87 /* W */:
10393
- pos++;
10394
- return true;
10395
- case 80 /* P */:
10396
- isCharacterComplement = true;
10397
- case 112 /* p */:
10398
- pos++;
10399
- if (text2.charCodeAt(pos) === 123 /* openBrace */) {
10400
- pos++;
10401
- const propertyNameOrValueStart = pos;
10402
- const propertyNameOrValue = scanWordCharacters();
10403
- if (text2.charCodeAt(pos) === 61 /* equals */) {
10404
- const propertyName = nonBinaryUnicodeProperties.get(propertyNameOrValue);
10405
- if (pos === propertyNameOrValueStart) {
10406
- error(Diagnostics.Expected_a_Unicode_property_name);
10407
- } else if (propertyName === void 0) {
10408
- error(Diagnostics.Unknown_Unicode_property_name, propertyNameOrValueStart, pos - propertyNameOrValueStart);
10409
- const suggestion = getSpellingSuggestion(propertyNameOrValue, nonBinaryUnicodeProperties.keys(), identity);
10410
- if (suggestion) {
10411
- error(Diagnostics.Did_you_mean_0, propertyNameOrValueStart, pos - propertyNameOrValueStart, suggestion);
10412
- }
10413
- }
10414
- pos++;
10415
- const propertyValueStart = pos;
10416
- const propertyValue = scanWordCharacters();
10417
- if (pos === propertyValueStart) {
10418
- error(Diagnostics.Expected_a_Unicode_property_value);
10419
- } else if (propertyName !== void 0 && !valuesOfNonBinaryUnicodeProperties[propertyName].has(propertyValue)) {
10420
- error(Diagnostics.Unknown_Unicode_property_value, propertyValueStart, pos - propertyValueStart);
10421
- const suggestion = getSpellingSuggestion(propertyValue, valuesOfNonBinaryUnicodeProperties[propertyName], identity);
10422
- if (suggestion) {
10423
- error(Diagnostics.Did_you_mean_0, propertyValueStart, pos - propertyValueStart, suggestion);
10424
- }
10425
- }
10426
- } else {
10427
- if (pos === propertyNameOrValueStart) {
10428
- error(Diagnostics.Expected_a_Unicode_property_name_or_value);
10429
- } else if (binaryUnicodePropertiesOfStrings.has(propertyNameOrValue)) {
10430
- if (!unicodeSetsMode) {
10431
- 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);
10432
- } else if (isCharacterComplement) {
10433
- error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, propertyNameOrValueStart, pos - propertyNameOrValueStart);
10434
- } else {
10435
- mayContainStrings = true;
10436
- }
10437
- } else if (!valuesOfNonBinaryUnicodeProperties.General_Category.has(propertyNameOrValue) && !binaryUnicodeProperties.has(propertyNameOrValue)) {
10438
- error(Diagnostics.Unknown_Unicode_property_name_or_value, propertyNameOrValueStart, pos - propertyNameOrValueStart);
10439
- const suggestion = getSpellingSuggestion(propertyNameOrValue, [...valuesOfNonBinaryUnicodeProperties.General_Category, ...binaryUnicodeProperties, ...binaryUnicodePropertiesOfStrings], identity);
10440
- if (suggestion) {
10441
- error(Diagnostics.Did_you_mean_0, propertyNameOrValueStart, pos - propertyNameOrValueStart, suggestion);
10442
- }
10443
- }
10444
- }
10445
- scanExpectedChar(125 /* closeBrace */);
10446
- if (!unicodeMode) {
10447
- 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);
10448
- }
10449
- } else if (unicodeMode) {
10450
- error(Diagnostics._0_must_be_followed_by_a_Unicode_property_value_expression_enclosed_in_braces, pos - 2, 2, String.fromCharCode(ch));
10451
- }
10452
- return true;
10453
- }
10454
- return false;
10455
- }
10456
- function scanWordCharacters() {
10457
- let value = "";
10458
- while (pos < end2) {
10459
- const ch = text2.charCodeAt(pos);
10460
- if (!isWordCharacter(ch)) {
10461
- break;
10462
- }
10463
- value += String.fromCharCode(ch);
10464
- pos++;
10465
- }
10466
- return value;
10467
- }
10468
- function scanSourceCharacter() {
10469
- const size = unicodeMode ? charSize(codePointAt(text2, pos)) : 1;
10470
- pos += size;
10471
- return text2.substring(pos - size, pos);
10472
- }
10473
- function scanExpectedChar(ch) {
10474
- if (text2.charCodeAt(pos) === ch) {
10475
- pos++;
10476
- } else {
10477
- error(Diagnostics._0_expected, pos, 0, String.fromCharCode(ch));
10478
- }
10479
- }
10480
- scanDisjunction(
10481
- /*isInGroup*/
10482
- false
10483
- );
10484
- forEach(groupNameReferences, (reference) => {
10485
- if (!groupSpecifiers.has(reference.name)) {
10486
- error(Diagnostics.There_is_no_capturing_group_named_0_in_this_regular_expression, reference.pos, reference.end - reference.pos, reference.name);
10487
- }
10488
- });
10489
- forEach(decimalEscapes, (escape) => {
10490
- if (escape.value > numberOfCapturingGroups) {
10491
- if (numberOfCapturingGroups) {
10492
- 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);
10493
- } else {
10494
- error(Diagnostics.Decimal_escapes_are_invalid_when_there_are_no_capturing_groups_in_a_regular_expression, escape.pos, escape.end - escape.pos);
10495
- }
10496
- }
10497
- });
10498
- }
10499
9606
  }
10500
9607
  function appendIfCommentDirective(commentDirectives2, text2, commentDirectiveRegEx, lineStart) {
10501
9608
  const type = getDirectiveFromComment(text2.trimStart(), commentDirectiveRegEx);
@@ -10718,6 +9825,8 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
10718
9825
  pos--;
10719
9826
  const extendedCookedChar = peekExtendedUnicodeEscape();
10720
9827
  if (extendedCookedChar >= 0 && isIdentifierStart(extendedCookedChar, languageVersion)) {
9828
+ pos += 3;
9829
+ tokenFlags |= 8 /* ExtendedUnicodeEscape */;
10721
9830
  tokenValue = scanExtendedUnicodeEscape() + scanIdentifierParts();
10722
9831
  return token = getIdentifierToken();
10723
9832
  }
@@ -10852,22 +9961,6 @@ var utf16EncodeAsStringWorker = String.fromCodePoint ? (codePoint) => String.fro
10852
9961
  function utf16EncodeAsString(codePoint) {
10853
9962
  return utf16EncodeAsStringWorker(codePoint);
10854
9963
  }
10855
- var nonBinaryUnicodeProperties = new Map(Object.entries({
10856
- General_Category: "General_Category",
10857
- gc: "General_Category",
10858
- Script: "Script",
10859
- sc: "Script",
10860
- Script_Extensions: "Script_Extensions",
10861
- scx: "Script_Extensions"
10862
- }));
10863
- 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"]);
10864
- 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"]);
10865
- var valuesOfNonBinaryUnicodeProperties = {
10866
- 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"]),
10867
- 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"]),
10868
- Script_Extensions: /* @__PURE__ */ new Set()
10869
- // Currently empty
10870
- };
10871
9964
 
10872
9965
  // src/compiler/utilitiesPublic.ts
10873
9966
  function isExternalModuleNameRelative(moduleName) {
@@ -16931,7 +16024,7 @@ var objectAllocator = {
16931
16024
  getSourceMapSourceConstructor: () => SourceMapSource
16932
16025
  };
16933
16026
  function formatStringFromArgs(text, args) {
16934
- return text.replace(/\{(\d+)\}/g, (_match, index) => "" + Debug.checkDefined(args[+index]));
16027
+ return text.replace(/{(\d+)}/g, (_match, index) => "" + Debug.checkDefined(args[+index]));
16935
16028
  }
16936
16029
  var localizedDiagnosticMessages;
16937
16030
  function setLocalizedDiagnosticMessages(messages) {
@@ -17922,7 +17015,7 @@ function isValidBigIntString(s, roundTripOnly) {
17922
17015
  false
17923
17016
  );
17924
17017
  let success = true;
17925
- scanner.setOnError(() => void (success = false));
17018
+ scanner.setOnError(() => success = false);
17926
17019
  scanner.setText(s + "n");
17927
17020
  let result = scanner.scan();
17928
17021
  const negative = result === 41 /* MinusToken */;
@@ -27766,10 +26859,7 @@ var Parser;
27766
26859
  function parseErrorAtPosition(start, length2, message, ...args) {
27767
26860
  const lastError = lastOrUndefined(parseDiagnostics);
27768
26861
  let result;
27769
- if (message.category === 3 /* Message */ && lastError && start === lastError.start && length2 === lastError.length) {
27770
- result = createDetachedDiagnostic(fileName, sourceText, start, length2, message, ...args);
27771
- addRelatedInfo(lastError, result);
27772
- } else if (!lastError || start !== lastError.start) {
26862
+ if (!lastError || start !== lastError.start) {
27773
26863
  result = createDetachedDiagnostic(fileName, sourceText, start, length2, message, ...args);
27774
26864
  parseDiagnostics.push(result);
27775
26865
  }
@@ -27780,10 +26870,10 @@ var Parser;
27780
26870
  return parseErrorAtPosition(start, end - start, message, ...args);
27781
26871
  }
27782
26872
  function parseErrorAtRange(range, message, ...args) {
27783
- return parseErrorAt(range.pos, range.end, message, ...args);
26873
+ parseErrorAt(range.pos, range.end, message, ...args);
27784
26874
  }
27785
- function scanError(message, pos, length2, ...args) {
27786
- return parseErrorAtPosition(pos, length2, message, ...args);
26875
+ function scanError(message, length2, arg0) {
26876
+ parseErrorAtPosition(scanner.getTokenEnd(), length2, message, arg0);
27787
26877
  }
27788
26878
  function getNodePos() {
27789
26879
  return scanner.getTokenFullStart();
@@ -27925,7 +27015,7 @@ var Parser;
27925
27015
  parseErrorForInvalidName(Diagnostics.Type_alias_name_cannot_be_0, Diagnostics.Type_alias_must_be_given_a_name, 64 /* EqualsToken */);
27926
27016
  return;
27927
27017
  }
27928
- const suggestion = getSpellingSuggestion(expressionText, viableKeywordSuggestions, identity) ?? getSpaceSuggestion(expressionText);
27018
+ const suggestion = getSpellingSuggestion(expressionText, viableKeywordSuggestions, (n) => n) ?? getSpaceSuggestion(expressionText);
27929
27019
  if (suggestion) {
27930
27020
  parseErrorAt(pos, node.end, Diagnostics.Unknown_keyword_or_identifier_Did_you_mean_0, suggestion);
27931
27021
  return;
@@ -53938,7 +53028,7 @@ function createTypeChecker(host) {
53938
53028
  if (!lateSymbol)
53939
53029
  lateSymbols.set(memberName, lateSymbol = createSymbol(0 /* None */, memberName, 4096 /* Late */));
53940
53030
  const earlySymbol = earlySymbols && earlySymbols.get(memberName);
53941
- if (lateSymbol.flags & getExcludedSymbolFlags(symbolFlags) || earlySymbol) {
53031
+ if (!(parent.flags & 32 /* Class */) && (lateSymbol.flags & getExcludedSymbolFlags(symbolFlags) || earlySymbol)) {
53942
53032
  const declarations = earlySymbol ? concatenate(earlySymbol.declarations, lateSymbol.declarations) : lateSymbol.declarations;
53943
53033
  const name = !(type.flags & 8192 /* UniqueESSymbol */) && unescapeLeadingUnderscores(memberName) || declarationNameToString(declName);
53944
53034
  forEach(declarations, (declaration) => error(getNameOfDeclaration(declaration) || declaration, Diagnostics.Property_0_was_also_declared_here, name));
@@ -73689,6 +72779,10 @@ function createTypeChecker(host) {
73689
72779
  const nextTypes = [];
73690
72780
  const isAsync = (getFunctionFlags(func) & 2 /* Async */) !== 0;
73691
72781
  forEachYieldExpression(func.body, (yieldExpression) => {
72782
+ const statement = findAncestor(yieldExpression, isStatement);
72783
+ if (canHaveFlowNode(statement) && !statement.flowNode && !compilerOptions.allowUnreachableCode) {
72784
+ return;
72785
+ }
73692
72786
  const yieldExpressionType = yieldExpression.expression ? checkExpression(yieldExpression.expression, checkMode) : undefinedWideningType;
73693
72787
  pushIfUnique(yieldTypes, getYieldedTypeOfYieldExpression(yieldExpression, yieldExpressionType, anyType, isAsync));
73694
72788
  let nextType;
@@ -73779,6 +72873,9 @@ function createTypeChecker(host) {
73779
72873
  hasReturnOfTypeNever = true;
73780
72874
  return;
73781
72875
  }
72876
+ if (!returnStatement.flowNode && !compilerOptions.allowUnreachableCode) {
72877
+ return;
72878
+ }
73782
72879
  let type = checkExpressionCached(expr, checkMode && checkMode & ~8 /* SkipGenericFunctions */);
73783
72880
  if (functionFlags & 2 /* Async */) {
73784
72881
  type = unwrapAwaitedType(checkAwaitedType(
@@ -75952,7 +75049,7 @@ function createTypeChecker(host) {
75952
75049
  const isPrivate = isPrivateIdentifier(name);
75953
75050
  const privateStaticFlags = isPrivate && isStaticMember ? 16 /* PrivateStatic */ : 0;
75954
75051
  const names = isPrivate ? privateIdentifiers : isStaticMember ? staticNames : instanceNames;
75955
- const memberName = name && getPropertyNameForPropertyNameNode(name);
75052
+ const memberName = name && getEffectivePropertyNameForPropertyNameNode(name);
75956
75053
  if (memberName) {
75957
75054
  switch (member.kind) {
75958
75055
  case 177 /* GetAccessor */:
@@ -75999,7 +75096,7 @@ function createTypeChecker(host) {
75999
75096
  const memberNameNode = member.name;
76000
75097
  const isStaticMember = isStatic(member);
76001
75098
  if (isStaticMember && memberNameNode) {
76002
- const memberName = getPropertyNameForPropertyNameNode(memberNameNode);
75099
+ const memberName = getEffectivePropertyNameForPropertyNameNode(memberNameNode);
76003
75100
  switch (memberName) {
76004
75101
  case "name":
76005
75102
  case "length":