@typescript-deploys/pr-build 5.3.0-pr-55576-6 → 5.3.0-pr-55600-13

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.3";
-      version = `${versionMajorMinor}.0-insiders.20230830`;
+      version = `${versionMajorMinor}.0-insiders.20230901`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -3497,7 +3497,7 @@ ${lanes.join("\n")}
     const name = DiagnosticCategory[d.category];
     return lowerCase ? name.toLowerCase() : name;
   }
-  var SyntaxKind, NodeFlags, ModifierFlags, JsxFlags, RelationComparisonResult, GeneratedIdentifierFlags, TokenFlags, FlowFlags, CommentDirectiveType, OperationCanceledException, FileIncludeKind, FilePreprocessingDiagnosticsKind, EmitOnly, StructureIsReused, ExitStatus, MemberOverrideStatus, UnionReduction, ContextFlags, NodeBuilderFlags, TypeFormatFlags, SymbolFormatFlags, SymbolAccessibility, SyntheticSymbolKind, TypePredicateKind, TypeReferenceSerializationKind, SymbolFlags, EnumKind, CheckFlags, InternalSymbolName, NodeCheckFlags, TypeFlags, ObjectFlags, VarianceFlags, ElementFlags, AccessFlags, IndexFlags, JsxReferenceKind, SignatureKind, SignatureFlags, IndexKind, TypeMapKind, InferencePriority, InferenceFlags, Ternary, AssignmentDeclarationKind, DiagnosticCategory, ModuleResolutionKind, ModuleDetectionKind, WatchFileKind, WatchDirectoryKind, PollingWatchKind, ModuleKind, JsxEmit, ImportsNotUsedAsValues, NewLineKind, ScriptKind, ScriptTarget, LanguageVariant, WatchDirectoryFlags, CharacterCodes, Extension, TransformFlags, SnippetKind, EmitFlags, InternalEmitFlags, ExternalEmitHelpers, EmitHint, OuterExpressionKinds, LexicalEnvironmentFlags, BundleFileSectionKind, ListFormat, PragmaKindFlags, commentPragmas;
+  var SyntaxKind, NodeFlags, ModifierFlags, JsxFlags, RelationComparisonResult, GeneratedIdentifierFlags, RegularExpressionFlags, TokenFlags, FlowFlags, CommentDirectiveType, OperationCanceledException, FileIncludeKind, FilePreprocessingDiagnosticsKind, EmitOnly, StructureIsReused, ExitStatus, MemberOverrideStatus, UnionReduction, ContextFlags, NodeBuilderFlags, TypeFormatFlags, SymbolFormatFlags, SymbolAccessibility, SyntheticSymbolKind, TypePredicateKind, TypeReferenceSerializationKind, SymbolFlags, EnumKind, CheckFlags, InternalSymbolName, NodeCheckFlags, TypeFlags, ObjectFlags, VarianceFlags, ElementFlags, AccessFlags, IndexFlags, JsxReferenceKind, SignatureKind, SignatureFlags, IndexKind, TypeMapKind, InferencePriority, InferenceFlags, Ternary, AssignmentDeclarationKind, DiagnosticCategory, ModuleResolutionKind, ModuleDetectionKind, WatchFileKind, WatchDirectoryKind, PollingWatchKind, ModuleKind, JsxEmit, ImportsNotUsedAsValues, NewLineKind, ScriptKind, ScriptTarget, LanguageVariant, WatchDirectoryFlags, CharacterCodes, Extension, TransformFlags, SnippetKind, EmitFlags, InternalEmitFlags, ExternalEmitHelpers, EmitHint, OuterExpressionKinds, LexicalEnvironmentFlags, BundleFileSectionKind, ListFormat, PragmaKindFlags, commentPragmas;
   var init_types = __esm({
     "src/compiler/types.ts"() {
       "use strict";
@@ -4005,6 +4005,20 @@ ${lanes.join("\n")}
         GeneratedIdentifierFlags2[GeneratedIdentifierFlags2["AllowNameSubstitution"] = 64] = "AllowNameSubstitution";
         return GeneratedIdentifierFlags2;
       })(GeneratedIdentifierFlags || {});
+      RegularExpressionFlags = /* @__PURE__ */ ((RegularExpressionFlags2) => {
+        RegularExpressionFlags2[RegularExpressionFlags2["None"] = 0] = "None";
+        RegularExpressionFlags2[RegularExpressionFlags2["HasIndices"] = 1] = "HasIndices";
+        RegularExpressionFlags2[RegularExpressionFlags2["Global"] = 2] = "Global";
+        RegularExpressionFlags2[RegularExpressionFlags2["IgnoreCase"] = 4] = "IgnoreCase";
+        RegularExpressionFlags2[RegularExpressionFlags2["Multiline"] = 8] = "Multiline";
+        RegularExpressionFlags2[RegularExpressionFlags2["DotAll"] = 16] = "DotAll";
+        RegularExpressionFlags2[RegularExpressionFlags2["Unicode"] = 32] = "Unicode";
+        RegularExpressionFlags2[RegularExpressionFlags2["UnicodeSets"] = 64] = "UnicodeSets";
+        RegularExpressionFlags2[RegularExpressionFlags2["Sticky"] = 128] = "Sticky";
+        RegularExpressionFlags2[RegularExpressionFlags2["UnicodeMode"] = 96] = "UnicodeMode";
+        RegularExpressionFlags2[RegularExpressionFlags2["Modifiers"] = 28] = "Modifiers";
+        return RegularExpressionFlags2;
+      })(RegularExpressionFlags || {});
       TokenFlags = /* @__PURE__ */ ((TokenFlags2) => {
         TokenFlags2[TokenFlags2["None"] = 0] = "None";
         TokenFlags2[TokenFlags2["PrecedingLineBreak"] = 1] = "PrecedingLineBreak";
@@ -4708,6 +4722,8 @@ ${lanes.join("\n")}
         ScriptTarget11[ScriptTarget11["ES2020"] = 7] = "ES2020";
         ScriptTarget11[ScriptTarget11["ES2021"] = 8] = "ES2021";
         ScriptTarget11[ScriptTarget11["ES2022"] = 9] = "ES2022";
+        ScriptTarget11[ScriptTarget11["ES2023"] = 10] = "ES2023";
+        ScriptTarget11[ScriptTarget11["ES2024"] = 11] = "ES2024";
         ScriptTarget11[ScriptTarget11["ESNext"] = 99] = "ESNext";
         ScriptTarget11[ScriptTarget11["JSON"] = 100] = "JSON";
         ScriptTarget11[ScriptTarget11["Latest"] = 99 /* ESNext */] = "Latest";
@@ -7393,6 +7409,43 @@ ${lanes.join("\n")}
         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."),
         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."),
+        _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."),
+        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."),
         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(
@@ -9118,6 +9171,15 @@ ${lanes.join("\n")}
   function stringToToken(s) {
     return textToToken.get(s);
   }
+  function regularExpressionFlagToCharacter(f) {
+    return regExpFlagChars[f];
+  }
+  function characterToRegularExpressionFlag(c) {
+    return charToRegExpFlag.get(c);
+  }
+  function regularExpressionFlagToFirstAvailableLanguageVersion(f) {
+    return regExpFlagToFirstAvailableLanguageVersion.get(f);
+  }
   function computeLineStarts(text) {
     const result = [];
     let pos = 0;
@@ -9214,8 +9276,11 @@ ${lanes.join("\n")}
   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 */;
@@ -9552,10 +9617,10 @@ ${lanes.join("\n")}
     }
   }
   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) {
@@ -9641,13 +9706,8 @@ ${lanes.join("\n")}
       });
     }
     return scanner2;
-    function error2(message, errPos = pos, length3, arg0) {
-      if (onError) {
-        const oldPos = pos;
-        pos = errPos;
-        onError(message, length3 || 0, arg0);
-        pos = oldPos;
-      }
+    function error2(message, errPos = pos, length3 = 0, ...args) {
+      return onError == null ? void 0 : onError(message, errPos, length3, ...args);
     }
     function scanNumberFragment() {
       let start2 = pos;
@@ -9872,7 +9932,9 @@ ${lanes.join("\n")}
           result += text.substring(start2, pos);
           result += scanEscapeSequence(
             /*shouldEmitInvalidEscapeError*/
-            true
+            true,
+            /*isRegularExpression*/
+            false
           );
           start2 = pos;
           continue;
@@ -9916,7 +9978,11 @@ ${lanes.join("\n")}
         }
         if (currChar === 92 /* backslash */) {
           contents += text.substring(start2, pos);
-          contents += scanEscapeSequence(shouldEmitInvalidEscapeError);
+          contents += scanEscapeSequence(
+            shouldEmitInvalidEscapeError,
+            /*isRegularExpression*/
+            false
+          );
           start2 = pos;
           continue;
         }
@@ -9936,7 +10002,7 @@ ${lanes.join("\n")}
       tokenValue = contents;
       return resultingToken;
     }
-    function scanEscapeSequence(shouldEmitInvalidEscapeError) {
+    function scanEscapeSequence(shouldEmitInvalidEscapeError, isRegularExpression) {
       const start2 = pos;
       pos++;
       if (pos >= end) {
@@ -9995,45 +10061,9 @@ ${lanes.join("\n")}
         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) {
-                error2(Diagnostics.Hexadecimal_digit_expected);
-              }
-              return text.substring(start2, pos);
-            }
-            if (!isCodePoint(escapedValue)) {
-              tokenFlags |= 2048 /* ContainsInvalidEscape */;
-              if (shouldEmitInvalidEscapeError) {
-                error2(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) {
-                error2(Diagnostics.Unexpected_end_of_text);
-              }
-              return text.substring(start2, pos);
-            }
-            if (text.charCodeAt(pos) !== 125 /* closeBrace */) {
-              tokenFlags |= 2048 /* ContainsInvalidEscape */;
-              if (shouldEmitInvalidEscapeError) {
-                error2(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(shouldEmitInvalidEscapeError);
           }
           for (; pos < start2 + 6; pos++) {
             if (!(pos < end && isHexDigit(text.charCodeAt(pos)))) {
@@ -10045,7 +10075,23 @@ ${lanes.join("\n")}
             }
           }
           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)))) {
@@ -10067,10 +10113,16 @@ ${lanes.join("\n")}
         case 8233 /* paragraphSeparator */:
           return "";
         default:
+          if (isRegularExpression && (shouldEmitInvalidEscapeError || isIdentifierPart(ch, languageVersion))) {
+            error2(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*/
@@ -10079,24 +10131,34 @@ ${lanes.join("\n")}
       const escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1;
       let isInvalidExtendedEscape = false;
       if (escapedValue < 0) {
-        error2(Diagnostics.Hexadecimal_digit_expected);
+        if (shouldEmitInvalidEscapeError) {
+          error2(Diagnostics.Hexadecimal_digit_expected);
+        }
         isInvalidExtendedEscape = true;
       } else if (escapedValue > 1114111) {
-        error2(Diagnostics.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive);
+        if (shouldEmitInvalidEscapeError) {
+          error2(Diagnostics.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive, escapedStart, pos - escapedStart);
+        }
         isInvalidExtendedEscape = true;
       }
       if (pos >= end) {
-        error2(Diagnostics.Unexpected_end_of_text);
+        if (shouldEmitInvalidEscapeError) {
+          error2(Diagnostics.Unexpected_end_of_text);
+        }
         isInvalidExtendedEscape = true;
       } else if (text.charCodeAt(pos) === 125 /* closeBrace */) {
         pos++;
       } else {
-        error2(Diagnostics.Unterminated_Unicode_escape_sequence);
+        if (shouldEmitInvalidEscapeError) {
+          error2(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() {
@@ -10138,8 +10200,6 @@ ${lanes.join("\n")}
         } else if (ch === 92 /* backslash */) {
           ch = peekExtendedUnicodeEscape();
           if (ch >= 0 && isIdentifierPart(ch, languageVersion)) {
-            pos += 3;
-            tokenFlags |= 8 /* ExtendedUnicodeEscape */;
             result += scanExtendedUnicodeEscape();
             start2 = pos;
             continue;
@@ -10609,8 +10669,6 @@ ${lanes.join("\n")}
           case 92 /* backslash */:
             const extendedCookedChar = peekExtendedUnicodeEscape();
             if (extendedCookedChar >= 0 && isIdentifierStart(extendedCookedChar, languageVersion)) {
-              pos += 3;
-              tokenFlags |= 8 /* ExtendedUnicodeEscape */;
               tokenValue = scanExtendedUnicodeEscape() + scanIdentifierParts();
               return token = getIdentifierToken();
             }
@@ -10626,7 +10684,7 @@ ${lanes.join("\n")}
             return token = 0 /* Unknown */;
           case 35 /* hash */:
             if (pos !== 0 && text[pos + 1] === "!") {
-              error2(Diagnostics.can_only_be_used_at_the_start_of_a_file);
+              error2(Diagnostics.can_only_be_used_at_the_start_of_a_file, pos, 2);
               pos++;
               return token = 0 /* Unknown */;
             }
@@ -10635,8 +10693,6 @@ ${lanes.join("\n")}
               pos++;
               const extendedCookedChar2 = peekExtendedUnicodeEscape();
               if (extendedCookedChar2 >= 0 && isIdentifierStart(extendedCookedChar2, languageVersion)) {
-                pos += 3;
-                tokenFlags |= 8 /* ExtendedUnicodeEscape */;
                 tokenValue = "#" + scanExtendedUnicodeEscape() + scanIdentifierParts();
                 return token = 81 /* PrivateIdentifier */;
               }
@@ -10759,14 +10815,831 @@ ${lanes.join("\n")}
           }
           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) {
+            error2(Diagnostics.Unknown_regular_expression_flag, p, 1);
+          } else if (regExpFlags & flag) {
+            error2(Diagnostics.Duplicate_regular_expression_flag, p, 1);
+          } else if (((regExpFlags | flag) & 96 /* UnicodeMode */) === 96 /* UnicodeMode */) {
+            error2(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) {
+              error2(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 */) {
+                            error2(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) {
+                          error2(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 (!min2) {
+                  error2(Diagnostics.Incomplete_quantifier_Digit_expected);
+                }
+                if (text2.charCodeAt(pos) === 44 /* comma */) {
+                  pos++;
+                  scanDigits();
+                  const max = tokenValue;
+                  if (max && Number.parseInt(min2) > Number.parseInt(max)) {
+                    error2(Diagnostics.Numbers_out_of_order_in_quantifier, digitsStart, pos - digitsStart);
+                  }
+                }
+                scanExpectedChar(125 /* closeBrace */);
+                pos--;
+              case 42 /* asterisk */:
+              case 43 /* plus */:
+              case 63 /* question */:
+                pos++;
+                if (text2.charCodeAt(pos) === 63 /* question */) {
+                  pos++;
+                }
+                if (!isPreviousTermQuantifiable) {
+                  error2(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;
+                }
+                error2(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:
+                if (isLineBreak(ch)) {
+                  return;
+                }
+                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) {
+              error2(Diagnostics.Unknown_regular_expression_flag, pos, 1);
+            } else if (currFlags & flag) {
+              error2(Diagnostics.Duplicate_regular_expression_flag, pos, 1);
+            } else if (!(flag & 28 /* Modifiers */)) {
+              error2(Diagnostics.This_regular_expression_flag_cannot_be_toggled_within_a_subpattern, pos, 1);
+            } else {
+              currFlags |= flag;
+              const availableFrom = regularExpressionFlagToFirstAvailableLanguageVersion(flag);
+              if (languageVersion < availableFrom) {
+                error2(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) {
+                error2(Diagnostics.k_must_be_followed_by_a_capturing_group_name_enclosed_in_angle_brackets, pos - 2, 2);
+              }
+              break;
+            case 113 /* q */:
+              if (unicodeSetsMode) {
+                pos++;
+                error2(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) {
+                error2(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 || isLineBreak(ch)) {
+                error2(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) {
+            error2(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))) {
+            error2(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 || isLineBreak(ch);
+        }
+        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) {
+                error2(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) {
+                error2(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) {
+                error2(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 "&&":
+              error2(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) {
+                  error2(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) {
+                  error2(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 {
+                error2(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
+              }
+              break;
+            default:
+              if (isCharacterComplement && mayContainStrings) {
+                error2(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++;
+                  error2(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) {
+                    error2(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) {
+                    error2(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) {
+                    error2(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) {
+                    error2(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++;
+                  error2(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 */) {
+                    error2(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
+                    pos++;
+                  }
+                } else {
+                  error2(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 "&&":
+                error2(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 */) {
+                    error2(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
+                  }
+                } else {
+                  error2(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 */) {
+                    error2(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 */) {
+                    error2(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
+                    pos++;
+                  }
+                } else {
+                  error2(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos - 1, 1, String.fromCharCode(ch));
+                }
+                break;
+              default:
+                switch (expressionType) {
+                  case 3 /* ClassSubtraction */:
+                    error2(Diagnostics._0_expected, pos, 0, "--");
+                    break;
+                  case 2 /* ClassIntersection */:
+                    error2(Diagnostics._0_expected, pos, 0, "&&");
+                    break;
+                  default:
+                    break;
+                }
+                break;
+            }
+            ch = text2.charCodeAt(pos);
+            if (isClassContentExit(ch)) {
+              error2(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 {
+                  error2(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:
+                if (isLineBreak(ch)) {
+                  break;
+                }
+                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 */:
+                error2(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 */:
+              error2(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) {
+                    error2(Diagnostics.Expected_a_Unicode_property_name);
+                  } else if (propertyName === void 0) {
+                    error2(Diagnostics.Unknown_Unicode_property_name, propertyNameOrValueStart, pos - propertyNameOrValueStart);
+                    const suggestion = getSpellingSuggestion(propertyNameOrValue, nonBinaryUnicodeProperties.keys(), identity);
+                    if (suggestion) {
+                      error2(Diagnostics.Did_you_mean_0, propertyNameOrValueStart, pos - propertyNameOrValueStart, suggestion);
+                    }
+                  }
+                  pos++;
+                  const propertyValueStart = pos;
+                  const propertyValue = scanWordCharacters();
+                  if (pos === propertyValueStart) {
+                    error2(Diagnostics.Expected_a_Unicode_property_value);
+                  } else if (propertyName !== void 0 && !valuesOfNonBinaryUnicodeProperties[propertyName].has(propertyValue)) {
+                    error2(Diagnostics.Unknown_Unicode_property_value, propertyValueStart, pos - propertyValueStart);
+                    const suggestion = getSpellingSuggestion(propertyValue, valuesOfNonBinaryUnicodeProperties[propertyName], identity);
+                    if (suggestion) {
+                      error2(Diagnostics.Did_you_mean_0, propertyValueStart, pos - propertyValueStart, suggestion);
+                    }
+                  }
+                } else {
+                  if (pos === propertyNameOrValueStart) {
+                    error2(Diagnostics.Expected_a_Unicode_property_name_or_value);
+                  } else if (binaryUnicodePropertiesOfStrings.has(propertyNameOrValue)) {
+                    if (!unicodeSetsMode) {
+                      error2(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) {
+                      error2(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)) {
+                    error2(Diagnostics.Unknown_Unicode_property_name_or_value, propertyNameOrValueStart, pos - propertyNameOrValueStart);
+                    const suggestion = getSpellingSuggestion(propertyNameOrValue, [...valuesOfNonBinaryUnicodeProperties.General_Category, ...binaryUnicodeProperties, ...binaryUnicodePropertiesOfStrings], identity);
+                    if (suggestion) {
+                      error2(Diagnostics.Did_you_mean_0, propertyNameOrValueStart, pos - propertyNameOrValueStart, suggestion);
+                    }
+                  }
+                }
+                scanExpectedChar(125 /* closeBrace */);
+                if (!unicodeMode) {
+                  error2(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) {
+                error2(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 {
+            error2(Diagnostics._0_expected, pos, 0, String.fromCharCode(ch));
+          }
+        }
+        scanDisjunction(
+          /*isInGroup*/
+          false
+        );
+        forEach(groupNameReferences, (reference) => {
+          if (!groupSpecifiers.has(reference.name)) {
+            error2(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) {
+              error2(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 {
+              error2(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);
@@ -10989,8 +11862,6 @@ ${lanes.join("\n")}
           pos--;
           const extendedCookedChar = peekExtendedUnicodeEscape();
           if (extendedCookedChar >= 0 && isIdentifierStart(extendedCookedChar, languageVersion)) {
-            pos += 3;
-            tokenFlags |= 8 /* ExtendedUnicodeEscape */;
             tokenValue = scanExtendedUnicodeEscape() + scanIdentifierParts();
             return token = getIdentifierToken();
           }
@@ -11124,7 +11995,7 @@ ${lanes.join("\n")}
   function utf16EncodeAsString(codePoint) {
     return utf16EncodeAsStringWorker(codePoint);
   }
-  var textToKeywordObj, textToKeyword, textToToken, unicodeES3IdentifierStart, unicodeES3IdentifierPart, unicodeES5IdentifierStart, unicodeES5IdentifierPart, unicodeESNextIdentifierStart, unicodeESNextIdentifierPart, commentDirectiveRegExSingleLine, commentDirectiveRegExMultiLine, tokenStrings, mergeConflictMarkerLength, shebangTriviaRegex, utf16EncodeAsStringWorker;
+  var textToKeywordObj, textToKeyword, textToToken, charToRegExpFlag, regExpFlagToFirstAvailableLanguageVersion, unicodeES3IdentifierStart, unicodeES3IdentifierPart, unicodeES5IdentifierStart, unicodeES5IdentifierPart, unicodeESNextIdentifierStart, unicodeESNextIdentifierPart, commentDirectiveRegExSingleLine, commentDirectiveRegExMultiLine, tokenStrings, regExpFlagChars, mergeConflictMarkerLength, shebangTriviaRegex, utf16EncodeAsStringWorker, nonBinaryUnicodeProperties, binaryUnicodeProperties, binaryUnicodePropertiesOfStrings, valuesOfNonBinaryUnicodeProperties;
   var init_scanner = __esm({
     "src/compiler/scanner.ts"() {
       "use strict";
@@ -11279,6 +12150,26 @@ ${lanes.join("\n")}
         "#": 63 /* HashToken */,
         "`": 62 /* BacktickToken */
       }));
+      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 */
+      }));
+      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 */]
+      ]);
       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];
       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];
       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];
@@ -11288,9 +12179,26 @@ ${lanes.join("\n")}
       commentDirectiveRegExSingleLine = /^\/\/\/?\s*@(ts-expect-error|ts-ignore)/;
       commentDirectiveRegExMultiLine = /^(?:\/|\*)*\s*@(ts-expect-error|ts-ignore)/;
       tokenStrings = makeReverseMap(textToToken);
+      regExpFlagChars = makeReverseMap(charToRegExpFlag);
       mergeConflictMarkerLength = "<<<<<<<".length;
       shebangTriviaRegex = /^#!.*/;
       utf16EncodeAsStringWorker = String.fromCodePoint ? (codePoint) => String.fromCodePoint(codePoint) : utf16EncodeAsStringFallback;
+      nonBinaryUnicodeProperties = new Map(Object.entries({
+        General_Category: "General_Category",
+        gc: "General_Category",
+        Script: "Script",
+        sc: "Script",
+        Script_Extensions: "Script_Extensions",
+        scx: "Script_Extensions"
+      }));
+      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"]);
+      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"]);
+      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
+      };
     }
   });
 
@@ -17441,7 +18349,7 @@ ${lanes.join("\n")}
     forEach(objectAllocatorPatchers, (fn) => fn(objectAllocator));
   }
   function formatStringFromArgs(text, args) {
-    return text.replace(/{(\d+)}/g, (_match, index) => "" + Debug.checkDefined(args[+index]));
+    return text.replace(/\{(\d+)\}/g, (_match, index) => "" + Debug.checkDefined(args[+index]));
   }
   function setLocalizedDiagnosticMessages(messages) {
     localizedDiagnosticMessages = messages;
@@ -18427,7 +19335,7 @@ ${lanes.join("\n")}
       false
     );
     let success = true;
-    scanner2.setOnError(() => success = false);
+    scanner2.setOnError(() => void (success = false));
     scanner2.setText(s + "n");
     let result = scanner2.scan();
     const negative = result === 41 /* MinusToken */;
@@ -29328,7 +30236,10 @@ ${lanes.join("\n")}
         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);
           }
@@ -29339,10 +30250,10 @@ ${lanes.join("\n")}
           return parseErrorAtPosition(start, end - start, message, ...args);
         }
         function parseErrorAtRange(range, message, ...args) {
-          parseErrorAt(range.pos, range.end, message, ...args);
+          return parseErrorAt(range.pos, range.end, message, ...args);
         }
-        function scanError(message, length2, arg0) {
-          parseErrorAtPosition(scanner2.getTokenEnd(), length2, message, arg0);
+        function scanError(message, pos, length2, ...args) {
+          return parseErrorAtPosition(pos, length2, message, ...args);
         }
         function getNodePos() {
           return scanner2.getTokenFullStart();
@@ -29484,7 +30395,7 @@ ${lanes.join("\n")}
               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;
@@ -133605,6 +134516,21 @@ ${lanes.join("\n")}
   function createPatternMatcher(pattern) {
     const stringToWordSpans = /* @__PURE__ */ new Map();
     const dotSeparatedSegments = pattern.trim().split(".").map((p) => createSegment(p.trim()));
+    if (dotSeparatedSegments.length === 1 && dotSeparatedSegments[0].totalTextChunk.text === "") {
+      return {
+        getMatchForLastSegmentOfPattern: () => createPatternMatch(
+          2 /* substring */,
+          /*isCaseSensitive*/
+          true
+        ),
+        getFullMatch: () => createPatternMatch(
+          2 /* substring */,
+          /*isCaseSensitive*/
+          true
+        ),
+        patternContainsDots: false
+      };
+    }
     if (dotSeparatedSegments.some((segment) => !segment.subWordTextChunks.length))
       return void 0;
     return {
@@ -146148,8 +147074,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
   });
 
   // src/services/codefixes/addNameToNamelessParameter.ts
-  function makeChange7(changeTracker, sourceFile, pos) {
-    const token = getTokenAtPosition(sourceFile, pos);
+  function makeChange7(changeTracker, sourceFile, start) {
+    const token = getTokenAtPosition(sourceFile, start);
     const param = token.parent;
     if (!isParameter(param)) {
       return Debug.fail("Tried to add a parameter name to a non-parameter: " + Debug.formatSyntaxKind(token.kind));
@@ -146157,20 +147083,34 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     const i = param.parent.parameters.indexOf(param);
     Debug.assert(!param.type, "Tried to add a parameter name to a parameter that already had one.");
     Debug.assert(i > -1, "Parameter not found in parent parameter list.");
-    const typeNode = factory.createTypeReferenceNode(
+    let end = param.name.getEnd();
+    let typeNode = factory.createTypeReferenceNode(
       param.name,
       /*typeArguments*/
       void 0
     );
+    let nextParam = tryGetNextParam(sourceFile, param);
+    while (nextParam) {
+      typeNode = factory.createArrayTypeNode(typeNode);
+      end = nextParam.getEnd();
+      nextParam = tryGetNextParam(sourceFile, nextParam);
+    }
     const replacement = factory.createParameterDeclaration(
       param.modifiers,
       param.dotDotDotToken,
       "arg" + i,
       param.questionToken,
-      param.dotDotDotToken ? factory.createArrayTypeNode(typeNode) : typeNode,
+      param.dotDotDotToken && !isArrayTypeNode(typeNode) ? factory.createArrayTypeNode(typeNode) : typeNode,
       param.initializer
     );
-    changeTracker.replaceNode(sourceFile, param, replacement);
+    changeTracker.replaceRange(sourceFile, createRange(param.getStart(sourceFile), end), replacement);
+  }
+  function tryGetNextParam(sourceFile, param) {
+    const nextToken = findNextToken(param.name, param.parent, sourceFile);
+    if (nextToken && nextToken.kind === 23 /* OpenBracketToken */ && isArrayBindingPattern(nextToken.parent) && isParameter(nextToken.parent.parent)) {
+      return nextToken.parent.parent;
+    }
+    return void 0;
   }
   var fixId7, errorCodes7;
   var init_addNameToNamelessParameter = __esm({
@@ -183203,6 +184143,7 @@ ${e.message}`;
     PrivateIdentifierKind: () => PrivateIdentifierKind,
     ProcessLevel: () => ProcessLevel,
     QuotePreference: () => QuotePreference,
+    RegularExpressionFlags: () => RegularExpressionFlags,
     RelationComparisonResult: () => RelationComparisonResult,
     Rename: () => ts_Rename_exports,
     ScriptElementKind: () => ScriptElementKind,
@@ -183329,6 +184270,7 @@ ${e.message}`;
     changeExtension: () => changeExtension,
     changesAffectModuleResolution: () => changesAffectModuleResolution,
     changesAffectingProgramStructure: () => changesAffectingProgramStructure,
+    characterToRegularExpressionFlag: () => characterToRegularExpressionFlag,
     childIsDecorated: () => childIsDecorated,
     classElementOrClassElementParameterIsDecorated: () => classElementOrClassElementParameterIsDecorated,
     classHasClassThisAssignment: () => classHasClassThisAssignment,
@@ -185086,6 +186028,7 @@ ${e.message}`;
     reducePathComponents: () => reducePathComponents,
     refactor: () => ts_refactor_exports,
     regExpEscape: () => regExpEscape,
+    regularExpressionFlagToCharacter: () => regularExpressionFlagToCharacter,
     relativeComplement: () => relativeComplement,
     removeAllComments: () => removeAllComments,
     removeEmitHelper: () => removeEmitHelper,
@@ -185606,6 +186549,7 @@ ${e.message}`;
     PrivateIdentifierKind: () => PrivateIdentifierKind,
     ProcessLevel: () => ProcessLevel,
     QuotePreference: () => QuotePreference,
+    RegularExpressionFlags: () => RegularExpressionFlags,
     RelationComparisonResult: () => RelationComparisonResult,
     Rename: () => ts_Rename_exports,
     ScriptElementKind: () => ScriptElementKind,
@@ -185732,6 +186676,7 @@ ${e.message}`;
     changeExtension: () => changeExtension,
     changesAffectModuleResolution: () => changesAffectModuleResolution,
     changesAffectingProgramStructure: () => changesAffectingProgramStructure,
+    characterToRegularExpressionFlag: () => characterToRegularExpressionFlag,
     childIsDecorated: () => childIsDecorated,
     classElementOrClassElementParameterIsDecorated: () => classElementOrClassElementParameterIsDecorated,
     classHasClassThisAssignment: () => classHasClassThisAssignment,
@@ -187489,6 +188434,7 @@ ${e.message}`;
     reducePathComponents: () => reducePathComponents,
     refactor: () => ts_refactor_exports,
     regExpEscape: () => regExpEscape,
+    regularExpressionFlagToCharacter: () => regularExpressionFlagToCharacter,
     relativeComplement: () => relativeComplement,
     removeAllComments: () => removeAllComments,
     removeEmitHelper: () => removeEmitHelper,