@typescript-deploys/pr-build 5.5.0-pr-58361-3 → 5.5.0-pr-58380-2

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-insiders.20240429`;
+var version = `${versionMajorMinor}.0-insiders.20240430`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -6203,7 +6203,7 @@ var Diagnostics = {
   Range_out_of_order_in_character_class: diag(1517, 1 /* Error */, "Range_out_of_order_in_character_class_1517", "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(1518, 1 /* Error */, "Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_characte_1518", "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(1519, 1 /* Error */, "Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead_1519", "Operators must not be mixed within a character class. Wrap it in a nested class instead."),
-  Expected_a_class_set_oprand: diag(1520, 1 /* Error */, "Expected_a_class_set_oprand_1520", "Expected a class set oprand."),
+  Expected_a_class_set_operand: diag(1520, 1 /* Error */, "Expected_a_class_set_operand_1520", "Expected a class set operand."),
   q_must_be_followed_by_string_alternatives_enclosed_in_braces: diag(1521, 1 /* Error */, "q_must_be_followed_by_string_alternatives_enclosed_in_braces_1521", "'\\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(1522, 1 /* Error */, "A_character_class_must_not_contain_a_reserved_double_punctuator_Did_you_mean_to_escape_it_with_backs_1522", "A character class must not contain a reserved double punctuator. Did you mean to escape it with backslash?"),
   Expected_a_Unicode_property_name: diag(1523, 1 /* Error */, "Expected_a_Unicode_property_name_1523", "Expected a Unicode property name."),
@@ -7716,6 +7716,16 @@ var Diagnostics = {
   Export_0_from_module_1: diag(90059, 3 /* Message */, "Export_0_from_module_1_90059", "Export '{0}' from module '{1}'"),
   Export_all_referenced_locals: diag(90060, 3 /* Message */, "Export_all_referenced_locals_90060", "Export all referenced locals"),
   Update_modifiers_of_0: diag(90061, 3 /* Message */, "Update_modifiers_of_0_90061", "Update modifiers of '{0}'"),
+  Add_annotation_of_type_0: diag(90062, 3 /* Message */, "Add_annotation_of_type_0_90062", "Add annotation of type '{0}'"),
+  Add_return_type_0: diag(90063, 3 /* Message */, "Add_return_type_0_90063", "Add return type '{0}'"),
+  Extract_base_class_to_variable: diag(90064, 3 /* Message */, "Extract_base_class_to_variable_90064", "Extract base class to variable"),
+  Extract_default_export_to_variable: diag(90065, 3 /* Message */, "Extract_default_export_to_variable_90065", "Extract default export to variable"),
+  Extract_binding_expressions_to_variable: diag(90066, 3 /* Message */, "Extract_binding_expressions_to_variable_90066", "Extract binding expressions to variable"),
+  Add_all_missing_type_annotations: diag(90067, 3 /* Message */, "Add_all_missing_type_annotations_90067", "Add all missing type annotations"),
+  Add_satisfies_and_an_inline_type_assertion_with_0: diag(90068, 3 /* Message */, "Add_satisfies_and_an_inline_type_assertion_with_0_90068", "Add satisfies and an inline type assertion with '{0}'"),
+  Extract_to_variable_and_replace_with_0_as_typeof_0: diag(90069, 3 /* Message */, "Extract_to_variable_and_replace_with_0_as_typeof_0_90069", "Extract to variable and replace with '{0} as typeof {0}'"),
+  Mark_array_literal_as_const: diag(90070, 3 /* Message */, "Mark_array_literal_as_const_90070", "Mark array literal as const"),
+  Annotate_types_of_properties_expando_function_in_a_namespace: diag(90071, 3 /* Message */, "Annotate_types_of_properties_expando_function_in_a_namespace_90071", "Annotate types of properties expando function in a namespace"),
   Convert_function_to_an_ES2015_class: diag(95001, 3 /* Message */, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"),
   Convert_0_to_1_in_0: diag(95003, 3 /* Message */, "Convert_0_to_1_in_0_95003", "Convert '{0}' to '{1} in {0}'"),
   Extract_to_0_in_1: diag(95004, 3 /* Message */, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"),
@@ -8689,6 +8699,18 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     });
   }
   return scanner;
+  function codePointUnchecked(pos2) {
+    return codePointAt(text, pos2);
+  }
+  function codePointChecked(pos2) {
+    return pos2 >= 0 && pos2 < end ? codePointUnchecked(pos2) : -1 /* EOF */;
+  }
+  function charCodeUnchecked(pos2) {
+    return text.charCodeAt(pos2);
+  }
+  function charCodeChecked(pos2) {
+    return pos2 >= 0 && pos2 < end ? charCodeUnchecked(pos2) : -1 /* EOF */;
+  }
   function error(message, errPos = pos, length3, arg0) {
     if (onError) {
       const oldPos = pos;
@@ -8703,7 +8725,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     let isPreviousTokenSeparator = false;
     let result = "";
     while (true) {
-      const ch = text.charCodeAt(pos);
+      const ch = charCodeUnchecked(pos);
       if (ch === 95 /* _ */) {
         tokenFlags |= 512 /* ContainsSeparator */;
         if (allowSeparator) {
@@ -8730,7 +8752,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       }
       break;
     }
-    if (text.charCodeAt(pos - 1) === 95 /* _ */) {
+    if (charCodeUnchecked(pos - 1) === 95 /* _ */) {
       tokenFlags |= 16384 /* ContainsInvalidSeparator */;
       error(Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1);
     }
@@ -8739,9 +8761,9 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
   function scanNumber() {
     let start2 = pos;
     let mainFragment;
-    if (text.charCodeAt(pos) === 48 /* _0 */) {
+    if (charCodeUnchecked(pos) === 48 /* _0 */) {
       pos++;
-      if (text.charCodeAt(pos) === 95 /* _ */) {
+      if (charCodeUnchecked(pos) === 95 /* _ */) {
         tokenFlags |= 512 /* ContainsSeparator */ | 16384 /* ContainsInvalidSeparator */;
         error(Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1);
         pos--;
@@ -8766,15 +8788,15 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     }
     let decimalFragment;
     let scientificFragment;
-    if (text.charCodeAt(pos) === 46 /* dot */) {
+    if (charCodeUnchecked(pos) === 46 /* dot */) {
       pos++;
       decimalFragment = scanNumberFragment();
     }
     let end2 = pos;
-    if (text.charCodeAt(pos) === 69 /* E */ || text.charCodeAt(pos) === 101 /* e */) {
+    if (charCodeUnchecked(pos) === 69 /* E */ || charCodeUnchecked(pos) === 101 /* e */) {
       pos++;
       tokenFlags |= 16 /* Scientific */;
-      if (text.charCodeAt(pos) === 43 /* plus */ || text.charCodeAt(pos) === 45 /* minus */)
+      if (charCodeUnchecked(pos) === 43 /* plus */ || charCodeUnchecked(pos) === 45 /* minus */)
         pos++;
       const preNumericPart = pos;
       const finalFragment = scanNumberFragment();
@@ -8814,7 +8836,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     }
   }
   function checkForIdentifierStartAfterNumericLiteral(numericStart, isScientific) {
-    if (!isIdentifierStart(codePointAt(text, pos), languageVersion)) {
+    if (!isIdentifierStart(codePointUnchecked(pos), languageVersion)) {
       return;
     }
     const identifierStart = pos;
@@ -8833,8 +8855,8 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
   function scanDigits() {
     const start2 = pos;
     let isOctal = true;
-    while (isDigit(text.charCodeAt(pos))) {
-      if (!isOctalDigit(text.charCodeAt(pos))) {
+    while (isDigit(charCodeChecked(pos))) {
+      if (!isOctalDigit(charCodeUnchecked(pos))) {
         isOctal = false;
       }
       pos++;
@@ -8866,7 +8888,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     let allowSeparator = false;
     let isPreviousTokenSeparator = false;
     while (valueChars.length < minCount || scanAsManyAsPossible) {
-      let ch = text.charCodeAt(pos);
+      let ch = charCodeUnchecked(pos);
       if (canHaveSeparators && ch === 95 /* _ */) {
         tokenFlags |= 512 /* ContainsSeparator */;
         if (allowSeparator) {
@@ -8893,13 +8915,13 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     if (valueChars.length < minCount) {
       valueChars = [];
     }
-    if (text.charCodeAt(pos - 1) === 95 /* _ */) {
+    if (charCodeUnchecked(pos - 1) === 95 /* _ */) {
       error(Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1);
     }
     return String.fromCharCode(...valueChars);
   }
   function scanString(jsxAttributeString = false) {
-    const quote = text.charCodeAt(pos);
+    const quote = charCodeUnchecked(pos);
     pos++;
     let result = "";
     let start2 = pos;
@@ -8910,7 +8932,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         error(Diagnostics.Unterminated_string_literal);
         break;
       }
-      const ch = text.charCodeAt(pos);
+      const ch = charCodeUnchecked(pos);
       if (ch === quote) {
         result += text.substring(start2, pos);
         pos++;
@@ -8938,7 +8960,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     return result;
   }
   function scanTemplateAndSetTokenValue(shouldEmitInvalidEscapeError) {
-    const startedWithBacktick = text.charCodeAt(pos) === 96 /* backtick */;
+    const startedWithBacktick = charCodeUnchecked(pos) === 96 /* backtick */;
     pos++;
     let start2 = pos;
     let contents = "";
@@ -8951,14 +8973,14 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         resultingToken = startedWithBacktick ? 15 /* NoSubstitutionTemplateLiteral */ : 18 /* TemplateTail */;
         break;
       }
-      const currChar = text.charCodeAt(pos);
+      const currChar = charCodeUnchecked(pos);
       if (currChar === 96 /* backtick */) {
         contents += text.substring(start2, pos);
         pos++;
         resultingToken = startedWithBacktick ? 15 /* NoSubstitutionTemplateLiteral */ : 18 /* TemplateTail */;
         break;
       }
-      if (currChar === 36 /* $ */ && pos + 1 < end && text.charCodeAt(pos + 1) === 123 /* openBrace */) {
+      if (currChar === 36 /* $ */ && pos + 1 < end && charCodeUnchecked(pos + 1) === 123 /* openBrace */) {
         contents += text.substring(start2, pos);
         pos += 2;
         resultingToken = startedWithBacktick ? 16 /* TemplateHead */ : 17 /* TemplateMiddle */;
@@ -8977,7 +8999,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       if (currChar === 13 /* carriageReturn */) {
         contents += text.substring(start2, pos);
         pos++;
-        if (pos < end && text.charCodeAt(pos) === 10 /* lineFeed */) {
+        if (pos < end && charCodeUnchecked(pos) === 10 /* lineFeed */) {
           pos++;
         }
         contents += "\n";
@@ -8997,24 +9019,24 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       error(Diagnostics.Unexpected_end_of_text);
       return "";
     }
-    const ch = text.charCodeAt(pos);
+    const ch = charCodeUnchecked(pos);
     pos++;
     switch (ch) {
       case 48 /* _0 */:
-        if (pos >= end || !isDigit(text.charCodeAt(pos))) {
+        if (pos >= end || !isDigit(charCodeUnchecked(pos))) {
           return "\0";
         }
       case 49 /* _1 */:
       case 50 /* _2 */:
       case 51 /* _3 */:
-        if (pos < end && isOctalDigit(text.charCodeAt(pos))) {
+        if (pos < end && isOctalDigit(charCodeUnchecked(pos))) {
           pos++;
         }
       case 52 /* _4 */:
       case 53 /* _5 */:
       case 54 /* _6 */:
       case 55 /* _7 */:
-        if (pos < end && isOctalDigit(text.charCodeAt(pos))) {
+        if (pos < end && isOctalDigit(charCodeUnchecked(pos))) {
           pos++;
         }
         tokenFlags |= 2048 /* ContainsInvalidEscape */;
@@ -9051,12 +9073,12 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       case 34 /* doubleQuote */:
         return '"';
       case 117 /* u */:
-        if ((!isRegularExpression || shouldEmitInvalidEscapeError) && pos < end && text.charCodeAt(pos) === 123 /* openBrace */) {
+        if ((!isRegularExpression || shouldEmitInvalidEscapeError) && pos < end && charCodeUnchecked(pos) === 123 /* openBrace */) {
           pos -= 2;
           return scanExtendedUnicodeEscape(!!isRegularExpression || shouldEmitInvalidEscapeError);
         }
         for (; pos < start2 + 6; pos++) {
-          if (!(pos < end && isHexDigit(text.charCodeAt(pos)))) {
+          if (!(pos < end && isHexDigit(charCodeUnchecked(pos)))) {
             tokenFlags |= 2048 /* ContainsInvalidEscape */;
             if (isRegularExpression || shouldEmitInvalidEscapeError) {
               error(Diagnostics.Hexadecimal_digit_expected);
@@ -9067,11 +9089,11 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         tokenFlags |= 1024 /* UnicodeEscape */;
         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 */) {
+        if (isRegularExpression && shouldEmitInvalidEscapeError && escapedValue >= 55296 && escapedValue <= 56319 && pos + 6 < end && text.substring(pos, pos + 2) === "\\u" && charCodeUnchecked(pos + 2) !== 123 /* openBrace */) {
           const nextStart = pos;
           let nextPos = pos + 2;
           for (; nextPos < nextStart + 6; nextPos++) {
-            if (!isHexDigit(text.charCodeAt(pos))) {
+            if (!isHexDigit(charCodeUnchecked(pos))) {
               return escapedValueString;
             }
           }
@@ -9084,7 +9106,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         return escapedValueString;
       case 120 /* x */:
         for (; pos < start2 + 4; pos++) {
-          if (!(pos < end && isHexDigit(text.charCodeAt(pos)))) {
+          if (!(pos < end && isHexDigit(charCodeUnchecked(pos)))) {
             tokenFlags |= 2048 /* ContainsInvalidEscape */;
             if (isRegularExpression || shouldEmitInvalidEscapeError) {
               error(Diagnostics.Hexadecimal_digit_expected);
@@ -9095,7 +9117,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         tokenFlags |= 4096 /* HexEscape */;
         return String.fromCharCode(parseInt(text.substring(start2 + 2, pos), 16));
       case 13 /* carriageReturn */:
-        if (pos < end && text.charCodeAt(pos) === 10 /* lineFeed */) {
+        if (pos < end && charCodeUnchecked(pos) === 10 /* lineFeed */) {
           pos++;
         }
       case 10 /* lineFeed */:
@@ -9136,7 +9158,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         error(Diagnostics.Unexpected_end_of_text);
       }
       isInvalidExtendedEscape = true;
-    } else if (text.charCodeAt(pos) === 125 /* closeBrace */) {
+    } else if (charCodeUnchecked(pos) === 125 /* closeBrace */) {
       pos++;
     } else {
       if (shouldEmitInvalidEscapeError) {
@@ -9152,7 +9174,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     return utf16EncodeAsString(escapedValue);
   }
   function peekUnicodeEscape() {
-    if (pos + 5 < end && text.charCodeAt(pos + 1) === 117 /* u */) {
+    if (pos + 5 < end && charCodeUnchecked(pos + 1) === 117 /* u */) {
       const start2 = pos;
       pos += 2;
       const value = scanExactNumberOfHexDigits(
@@ -9166,7 +9188,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     return -1;
   }
   function peekExtendedUnicodeEscape() {
-    if (codePointAt(text, pos + 1) === 117 /* u */ && codePointAt(text, pos + 2) === 123 /* openBrace */) {
+    if (codePointUnchecked(pos + 1) === 117 /* u */ && codePointUnchecked(pos + 2) === 123 /* openBrace */) {
       const start2 = pos;
       pos += 3;
       const escapedValueString = scanMinimumNumberOfHexDigits(
@@ -9184,7 +9206,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     let result = "";
     let start2 = pos;
     while (pos < end) {
-      let ch = codePointAt(text, pos);
+      let ch = codePointUnchecked(pos);
       if (isIdentifierPart(ch, languageVersion)) {
         pos += charSize(ch);
       } else if (ch === 92 /* backslash */) {
@@ -9231,7 +9253,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     let separatorAllowed = false;
     let isPreviousTokenSeparator = false;
     while (true) {
-      const ch = text.charCodeAt(pos);
+      const ch = charCodeUnchecked(pos);
       if (ch === 95 /* _ */) {
         tokenFlags |= 512 /* ContainsSeparator */;
         if (separatorAllowed) {
@@ -9253,13 +9275,13 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       pos++;
       isPreviousTokenSeparator = false;
     }
-    if (text.charCodeAt(pos - 1) === 95 /* _ */) {
+    if (charCodeUnchecked(pos - 1) === 95 /* _ */) {
       error(Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1);
     }
     return value;
   }
   function checkBigIntSuffix() {
-    if (text.charCodeAt(pos) === 110 /* n */) {
+    if (charCodeUnchecked(pos) === 110 /* n */) {
       tokenValue += "n";
       if (tokenFlags & 384 /* BinaryOrOctalSpecifier */) {
         tokenValue = parsePseudoBigInt(tokenValue) + "n";
@@ -9281,7 +9303,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       if (pos >= end) {
         return token = 1 /* EndOfFileToken */;
       }
-      const ch = codePointAt(text, pos);
+      const ch = codePointUnchecked(pos);
       if (pos === 0) {
         if (ch === 35 /* hash */ && isShebangTrivia(text, pos)) {
           pos = scanShebangTrivia(text, pos);
@@ -9300,7 +9322,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             pos++;
             continue;
           } else {
-            if (ch === 13 /* carriageReturn */ && pos + 1 < end && text.charCodeAt(pos + 1) === 10 /* lineFeed */) {
+            if (ch === 13 /* carriageReturn */ && pos + 1 < end && charCodeUnchecked(pos + 1) === 10 /* lineFeed */) {
               pos += 2;
             } else {
               pos++;
@@ -9333,14 +9355,14 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             pos++;
             continue;
           } else {
-            while (pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos))) {
+            while (pos < end && isWhiteSpaceSingleLine(charCodeUnchecked(pos))) {
               pos++;
             }
             return token = 5 /* WhitespaceTrivia */;
           }
         case 33 /* exclamation */:
-          if (text.charCodeAt(pos + 1) === 61 /* equals */) {
-            if (text.charCodeAt(pos + 2) === 61 /* equals */) {
+          if (charCodeUnchecked(pos + 1) === 61 /* equals */) {
+            if (charCodeUnchecked(pos + 2) === 61 /* equals */) {
               return pos += 3, token = 38 /* ExclamationEqualsEqualsToken */;
             }
             return pos += 2, token = 36 /* ExclamationEqualsToken */;
@@ -9357,19 +9379,19 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             false
           );
         case 37 /* percent */:
-          if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+          if (charCodeUnchecked(pos + 1) === 61 /* equals */) {
             return pos += 2, token = 70 /* PercentEqualsToken */;
           }
           pos++;
           return token = 45 /* PercentToken */;
         case 38 /* ampersand */:
-          if (text.charCodeAt(pos + 1) === 38 /* ampersand */) {
-            if (text.charCodeAt(pos + 2) === 61 /* equals */) {
+          if (charCodeUnchecked(pos + 1) === 38 /* ampersand */) {
+            if (charCodeUnchecked(pos + 2) === 61 /* equals */) {
               return pos += 3, token = 77 /* AmpersandAmpersandEqualsToken */;
             }
             return pos += 2, token = 56 /* AmpersandAmpersandToken */;
           }
-          if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+          if (charCodeUnchecked(pos + 1) === 61 /* equals */) {
             return pos += 2, token = 74 /* AmpersandEqualsToken */;
           }
           pos++;
@@ -9381,11 +9403,11 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           pos++;
           return token = 22 /* CloseParenToken */;
         case 42 /* asterisk */:
-          if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+          if (charCodeUnchecked(pos + 1) === 61 /* equals */) {
             return pos += 2, token = 67 /* AsteriskEqualsToken */;
           }
-          if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
-            if (text.charCodeAt(pos + 2) === 61 /* equals */) {
+          if (charCodeUnchecked(pos + 1) === 42 /* asterisk */) {
+            if (charCodeUnchecked(pos + 2) === 61 /* equals */) {
               return pos += 3, token = 68 /* AsteriskAsteriskEqualsToken */;
             }
             return pos += 2, token = 43 /* AsteriskAsteriskToken */;
@@ -9397,10 +9419,10 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           }
           return token = 42 /* AsteriskToken */;
         case 43 /* plus */:
-          if (text.charCodeAt(pos + 1) === 43 /* plus */) {
+          if (charCodeUnchecked(pos + 1) === 43 /* plus */) {
             return pos += 2, token = 46 /* PlusPlusToken */;
           }
-          if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+          if (charCodeUnchecked(pos + 1) === 61 /* equals */) {
             return pos += 2, token = 65 /* PlusEqualsToken */;
           }
           pos++;
@@ -9409,29 +9431,29 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           pos++;
           return token = 28 /* CommaToken */;
         case 45 /* minus */:
-          if (text.charCodeAt(pos + 1) === 45 /* minus */) {
+          if (charCodeUnchecked(pos + 1) === 45 /* minus */) {
             return pos += 2, token = 47 /* MinusMinusToken */;
           }
-          if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+          if (charCodeUnchecked(pos + 1) === 61 /* equals */) {
             return pos += 2, token = 66 /* MinusEqualsToken */;
           }
           pos++;
           return token = 41 /* MinusToken */;
         case 46 /* dot */:
-          if (isDigit(text.charCodeAt(pos + 1))) {
+          if (isDigit(charCodeUnchecked(pos + 1))) {
             scanNumber();
             return token = 9 /* NumericLiteral */;
           }
-          if (text.charCodeAt(pos + 1) === 46 /* dot */ && text.charCodeAt(pos + 2) === 46 /* dot */) {
+          if (charCodeUnchecked(pos + 1) === 46 /* dot */ && charCodeUnchecked(pos + 2) === 46 /* dot */) {
             return pos += 3, token = 26 /* DotDotDotToken */;
           }
           pos++;
           return token = 25 /* DotToken */;
         case 47 /* slash */:
-          if (text.charCodeAt(pos + 1) === 47 /* slash */) {
+          if (charCodeUnchecked(pos + 1) === 47 /* slash */) {
             pos += 2;
             while (pos < end) {
-              if (isLineBreak(text.charCodeAt(pos))) {
+              if (isLineBreak(charCodeUnchecked(pos))) {
                 break;
               }
               pos++;
@@ -9448,14 +9470,14 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
               return token = 2 /* SingleLineCommentTrivia */;
             }
           }
-          if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
+          if (charCodeUnchecked(pos + 1) === 42 /* asterisk */) {
             pos += 2;
-            const isJSDoc2 = text.charCodeAt(pos) === 42 /* asterisk */ && text.charCodeAt(pos + 1) !== 47 /* slash */;
+            const isJSDoc2 = charCodeUnchecked(pos) === 42 /* asterisk */ && charCodeUnchecked(pos + 1) !== 47 /* slash */;
             let commentClosed = false;
             let lastLineStart = tokenStart;
             while (pos < end) {
-              const ch2 = text.charCodeAt(pos);
-              if (ch2 === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
+              const ch2 = charCodeUnchecked(pos);
+              if (ch2 === 42 /* asterisk */ && charCodeUnchecked(pos + 1) === 47 /* slash */) {
                 pos += 2;
                 commentClosed = true;
                 break;
@@ -9482,13 +9504,13 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
               return token = 3 /* MultiLineCommentTrivia */;
             }
           }
-          if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+          if (charCodeUnchecked(pos + 1) === 61 /* equals */) {
             return pos += 2, token = 69 /* SlashEqualsToken */;
           }
           pos++;
           return token = 44 /* SlashToken */;
         case 48 /* _0 */:
-          if (pos + 2 < end && (text.charCodeAt(pos + 1) === 88 /* X */ || text.charCodeAt(pos + 1) === 120 /* x */)) {
+          if (pos + 2 < end && (charCodeUnchecked(pos + 1) === 88 /* X */ || charCodeUnchecked(pos + 1) === 120 /* x */)) {
             pos += 2;
             tokenValue = scanMinimumNumberOfHexDigits(
               1,
@@ -9502,7 +9524,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             tokenValue = "0x" + tokenValue;
             tokenFlags |= 64 /* HexSpecifier */;
             return token = checkBigIntSuffix();
-          } else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 66 /* B */ || text.charCodeAt(pos + 1) === 98 /* b */)) {
+          } else if (pos + 2 < end && (charCodeUnchecked(pos + 1) === 66 /* B */ || charCodeUnchecked(pos + 1) === 98 /* b */)) {
             pos += 2;
             tokenValue = scanBinaryOrOctalDigits(
               /* base */
@@ -9515,7 +9537,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             tokenValue = "0b" + tokenValue;
             tokenFlags |= 128 /* BinarySpecifier */;
             return token = checkBigIntSuffix();
-          } else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 79 /* O */ || text.charCodeAt(pos + 1) === 111 /* o */)) {
+          } else if (pos + 2 < end && (charCodeUnchecked(pos + 1) === 79 /* O */ || charCodeUnchecked(pos + 1) === 111 /* o */)) {
             pos += 2;
             tokenValue = scanBinaryOrOctalDigits(
               /* base */
@@ -9554,16 +9576,16 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
               return token = 7 /* ConflictMarkerTrivia */;
             }
           }
-          if (text.charCodeAt(pos + 1) === 60 /* lessThan */) {
-            if (text.charCodeAt(pos + 2) === 61 /* equals */) {
+          if (charCodeUnchecked(pos + 1) === 60 /* lessThan */) {
+            if (charCodeUnchecked(pos + 2) === 61 /* equals */) {
               return pos += 3, token = 71 /* LessThanLessThanEqualsToken */;
             }
             return pos += 2, token = 48 /* LessThanLessThanToken */;
           }
-          if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+          if (charCodeUnchecked(pos + 1) === 61 /* equals */) {
             return pos += 2, token = 33 /* LessThanEqualsToken */;
           }
-          if (languageVariant === 1 /* JSX */ && text.charCodeAt(pos + 1) === 47 /* slash */ && text.charCodeAt(pos + 2) !== 42 /* asterisk */) {
+          if (languageVariant === 1 /* JSX */ && charCodeUnchecked(pos + 1) === 47 /* slash */ && charCodeUnchecked(pos + 2) !== 42 /* asterisk */) {
             return pos += 2, token = 31 /* LessThanSlashToken */;
           }
           pos++;
@@ -9577,13 +9599,13 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
               return token = 7 /* ConflictMarkerTrivia */;
             }
           }
-          if (text.charCodeAt(pos + 1) === 61 /* equals */) {
-            if (text.charCodeAt(pos + 2) === 61 /* equals */) {
+          if (charCodeUnchecked(pos + 1) === 61 /* equals */) {
+            if (charCodeUnchecked(pos + 2) === 61 /* equals */) {
               return pos += 3, token = 37 /* EqualsEqualsEqualsToken */;
             }
             return pos += 2, token = 35 /* EqualsEqualsToken */;
           }
-          if (text.charCodeAt(pos + 1) === 62 /* greaterThan */) {
+          if (charCodeUnchecked(pos + 1) === 62 /* greaterThan */) {
             return pos += 2, token = 39 /* EqualsGreaterThanToken */;
           }
           pos++;
@@ -9600,11 +9622,11 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           pos++;
           return token = 32 /* GreaterThanToken */;
         case 63 /* question */:
-          if (text.charCodeAt(pos + 1) === 46 /* dot */ && !isDigit(text.charCodeAt(pos + 2))) {
+          if (charCodeUnchecked(pos + 1) === 46 /* dot */ && !isDigit(charCodeUnchecked(pos + 2))) {
             return pos += 2, token = 29 /* QuestionDotToken */;
           }
-          if (text.charCodeAt(pos + 1) === 63 /* question */) {
-            if (text.charCodeAt(pos + 2) === 61 /* equals */) {
+          if (charCodeUnchecked(pos + 1) === 63 /* question */) {
+            if (charCodeUnchecked(pos + 2) === 61 /* equals */) {
               return pos += 3, token = 78 /* QuestionQuestionEqualsToken */;
             }
             return pos += 2, token = 61 /* QuestionQuestionToken */;
@@ -9618,7 +9640,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           pos++;
           return token = 24 /* CloseBracketToken */;
         case 94 /* caret */:
-          if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+          if (charCodeUnchecked(pos + 1) === 61 /* equals */) {
             return pos += 2, token = 79 /* CaretEqualsToken */;
           }
           pos++;
@@ -9635,13 +9657,13 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
               return token = 7 /* ConflictMarkerTrivia */;
             }
           }
-          if (text.charCodeAt(pos + 1) === 124 /* bar */) {
-            if (text.charCodeAt(pos + 2) === 61 /* equals */) {
+          if (charCodeUnchecked(pos + 1) === 124 /* bar */) {
+            if (charCodeUnchecked(pos + 2) === 61 /* equals */) {
               return pos += 3, token = 76 /* BarBarEqualsToken */;
             }
             return pos += 2, token = 57 /* BarBarToken */;
           }
-          if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+          if (charCodeUnchecked(pos + 1) === 61 /* equals */) {
             return pos += 2, token = 75 /* BarEqualsToken */;
           }
           pos++;
@@ -9680,7 +9702,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             pos++;
             return token = 0 /* Unknown */;
           }
-          const charAfterHash = codePointAt(text, pos + 1);
+          const charAfterHash = codePointUnchecked(pos + 1);
           if (charAfterHash === 92 /* backslash */) {
             pos++;
             const extendedCookedChar2 = peekExtendedUnicodeEscape();
@@ -9750,7 +9772,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     Debug.assert(token === 0 /* Unknown */, "'reScanInvalidIdentifier' should only be called when the current token is 'SyntaxKind.Unknown'.");
     pos = tokenStart = fullStartPos;
     tokenFlags = 0;
-    const ch = codePointAt(text, pos);
+    const ch = codePointUnchecked(pos);
     const identifierKind = scanIdentifier(ch, 99 /* ESNext */);
     if (identifierKind) {
       return token = identifierKind;
@@ -9762,7 +9784,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     let ch = startCharacter;
     if (isIdentifierStart(ch, languageVersion2)) {
       pos += charSize(ch);
-      while (pos < end && isIdentifierPart(ch = codePointAt(text, pos), languageVersion2))
+      while (pos < end && isIdentifierPart(ch = codePointUnchecked(pos), languageVersion2))
         pos += charSize(ch);
       tokenValue = text.substring(tokenStart, pos);
       if (ch === 92 /* backslash */) {
@@ -9773,20 +9795,20 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
   }
   function reScanGreaterToken() {
     if (token === 32 /* GreaterThanToken */) {
-      if (text.charCodeAt(pos) === 62 /* greaterThan */) {
-        if (text.charCodeAt(pos + 1) === 62 /* greaterThan */) {
-          if (text.charCodeAt(pos + 2) === 61 /* equals */) {
+      if (charCodeUnchecked(pos) === 62 /* greaterThan */) {
+        if (charCodeUnchecked(pos + 1) === 62 /* greaterThan */) {
+          if (charCodeUnchecked(pos + 2) === 61 /* equals */) {
             return pos += 3, token = 73 /* GreaterThanGreaterThanGreaterThanEqualsToken */;
           }
           return pos += 2, token = 50 /* GreaterThanGreaterThanGreaterThanToken */;
         }
-        if (text.charCodeAt(pos + 1) === 61 /* equals */) {
+        if (charCodeUnchecked(pos + 1) === 61 /* equals */) {
           return pos += 2, token = 72 /* GreaterThanGreaterThanEqualsToken */;
         }
         pos++;
         return token = 49 /* GreaterThanGreaterThanToken */;
       }
-      if (text.charCodeAt(pos) === 61 /* equals */) {
+      if (charCodeUnchecked(pos) === 61 /* equals */) {
         pos++;
         return token = 34 /* GreaterThanEqualsToken */;
       }
@@ -9809,7 +9831,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           error(Diagnostics.Unterminated_regular_expression_literal);
           break;
         }
-        const ch = text.charCodeAt(p);
+        const ch = charCodeUnchecked(p);
         if (isLineBreak(ch)) {
           tokenFlags |= 4 /* Unterminated */;
           error(Diagnostics.Unterminated_regular_expression_literal);
@@ -9833,7 +9855,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       const endOfBody = p - (isUnterminated ? 0 : 1);
       let regExpFlags = 0 /* None */;
       while (p < end) {
-        const ch = text.charCodeAt(p);
+        const ch = charCodeUnchecked(p);
         if (!isIdentifierPart(ch, languageVersion)) {
           break;
         }
@@ -9852,845 +9874,860 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         }
         p++;
       }
+      pos = p;
       if (reportErrors2) {
-        pos = tokenStart + 1;
-        const saveTokenPos = tokenStart;
+        const saveTokenStart = tokenStart;
         const saveTokenFlags = tokenFlags;
+        const savePos = pos;
+        const saveEnd = end;
+        pos = tokenStart + 1;
+        end = endOfBody;
         scanRegularExpressionWorker(
-          text,
-          endOfBody,
           regExpFlags,
           isUnterminated,
           /*annexB*/
           true
         );
-        if (!isUnterminated) {
-          pos = p;
-        }
-        tokenStart = saveTokenPos;
+        tokenStart = saveTokenStart;
         tokenFlags = saveTokenFlags;
-      } else {
-        pos = p;
+        pos = savePos;
+        end = saveEnd;
       }
       tokenValue = text.substring(tokenStart, pos);
       token = 14 /* RegularExpressionLiteral */;
     }
     return token;
-    function scanRegularExpressionWorker(text2, end2, regExpFlags, isUnterminated, annexB) {
-      const unicodeSetsMode = !!(regExpFlags & 64 /* UnicodeSets */);
-      const unicodeMode = !!(regExpFlags & 96 /* UnicodeMode */);
-      if (unicodeMode) {
-        annexB = false;
-      }
-      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 scanRegularExpressionWorker(regExpFlags, isUnterminated, annexB) {
+    var unicodeSetsMode = !!(regExpFlags & 64 /* UnicodeSets */);
+    var unicodeMode = !!(regExpFlags & 96 /* UnicodeMode */);
+    if (unicodeMode) {
+      annexB = false;
+    }
+    var mayContainStrings = false;
+    var numberOfCapturingGroups = 0;
+    var groupSpecifiers;
+    var groupNameReferences;
+    var decimalEscapes;
+    var namedCapturingGroupsScopeStack = [];
+    var topNamedCapturingGroupsScope;
+    function scanDisjunction(isInGroup) {
+      while (true) {
+        namedCapturingGroupsScopeStack.push(topNamedCapturingGroupsScope);
+        topNamedCapturingGroupsScope = void 0;
+        scanAlternative(isInGroup);
+        topNamedCapturingGroupsScope = namedCapturingGroupsScopeStack.pop();
+        if (charCodeChecked(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 */:
+    }
+    function scanAlternative(isInGroup) {
+      let isPreviousTermQuantifiable = false;
+      while (true) {
+        const start2 = pos;
+        const ch = charCodeChecked(pos);
+        switch (ch) {
+          case -1 /* EOF */:
+            return;
+          case 94 /* caret */:
+          case 36 /* $ */:
+            pos++;
+            isPreviousTermQuantifiable = false;
+            break;
+          case 92 /* backslash */:
+            pos++;
+            switch (charCodeChecked(pos)) {
+              case 98 /* b */:
+              case 66 /* B */:
+                pos++;
+                isPreviousTermQuantifiable = false;
+                break;
+              default:
+                scanAtomEscape();
+                isPreviousTermQuantifiable = true;
+                break;
+            }
+            break;
+          case 40 /* openParen */:
+            pos++;
+            if (charCodeChecked(pos) === 63 /* question */) {
               pos++;
-              switch (text2.charCodeAt(pos)) {
-                case 98 /* b */:
-                case 66 /* B */:
+              switch (charCodeChecked(pos)) {
+                case 61 /* equals */:
+                case 33 /* exclamation */:
                   pos++;
-                  isPreviousTermQuantifiable = false;
-                  break;
-                default:
-                  scanAtomEscape();
-                  isPreviousTermQuantifiable = true;
+                  isPreviousTermQuantifiable = annexB;
                   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 = annexB;
-                    break;
-                  case 60 /* lessThan */:
-                    const groupNameStart = pos;
-                    pos++;
-                    switch (text2.charCodeAt(pos)) {
-                      case 61 /* equals */:
-                      case 33 /* exclamation */:
-                        pos++;
-                        isPreviousTermQuantifiable = false;
-                        break;
-                      default:
-                        scanGroupName(
-                          /*isReference*/
-                          false
-                        );
-                        scanExpectedChar(62 /* greaterThan */);
-                        if (languageVersion < 5 /* ES2018 */) {
-                          error(Diagnostics.Named_capturing_groups_are_only_available_when_targeting_ES2018_or_later, groupNameStart, pos - groupNameStart);
-                        }
-                        numberOfCapturingGroups++;
-                        isPreviousTermQuantifiable = true;
-                        break;
-                    }
-                    break;
-                  default:
-                    const start3 = pos;
-                    const setFlags = scanPatternModifiers(0 /* None */);
-                    if (text2.charCodeAt(pos) === 45 /* minus */) {
+                case 60 /* lessThan */:
+                  const groupNameStart = pos;
+                  pos++;
+                  switch (charCodeChecked(pos)) {
+                    case 61 /* equals */:
+                    case 33 /* exclamation */:
                       pos++;
-                      scanPatternModifiers(setFlags);
-                      if (pos === start3 + 1) {
-                        error(Diagnostics.Subpattern_flags_must_be_present_when_there_is_a_minus_sign, start3, pos - start3);
+                      isPreviousTermQuantifiable = false;
+                      break;
+                    default:
+                      scanGroupName(
+                        /*isReference*/
+                        false
+                      );
+                      scanExpectedChar(62 /* greaterThan */);
+                      if (languageVersion < 5 /* ES2018 */) {
+                        error(Diagnostics.Named_capturing_groups_are_only_available_when_targeting_ES2018_or_later, groupNameStart, pos - groupNameStart);
                       }
+                      numberOfCapturingGroups++;
+                      isPreviousTermQuantifiable = true;
+                      break;
+                  }
+                  break;
+                default:
+                  const start3 = pos;
+                  const setFlags = scanPatternModifiers(0 /* None */);
+                  if (charCodeChecked(pos) === 45 /* minus */) {
+                    pos++;
+                    scanPatternModifiers(setFlags);
+                    if (pos === start3 + 1) {
+                      error(Diagnostics.Subpattern_flags_must_be_present_when_there_is_a_minus_sign, start3, pos - start3);
                     }
-                    scanExpectedChar(58 /* colon */);
-                    isPreviousTermQuantifiable = true;
-                    break;
-                }
-              } else {
-                numberOfCapturingGroups++;
-                isPreviousTermQuantifiable = true;
+                  }
+                  scanExpectedChar(58 /* colon */);
+                  isPreviousTermQuantifiable = true;
+                  break;
               }
-              scanDisjunction(
-                /*isInGroup*/
-                true
-              );
-              scanExpectedChar(41 /* closeParen */);
-              break;
-            case 123 /* openBrace */:
+            } else {
+              numberOfCapturingGroups++;
+              isPreviousTermQuantifiable = true;
+            }
+            scanDisjunction(
+              /*isInGroup*/
+              true
+            );
+            scanExpectedChar(41 /* closeParen */);
+            break;
+          case 123 /* openBrace */:
+            pos++;
+            const digitsStart = pos;
+            scanDigits();
+            const min2 = tokenValue;
+            if (charCodeChecked(pos) === 44 /* comma */) {
               pos++;
-              const digitsStart = pos;
               scanDigits();
-              const min2 = tokenValue;
-              if (text2.charCodeAt(pos) === 44 /* comma */) {
-                pos++;
-                scanDigits();
-                const max = tokenValue;
-                if (!min2) {
-                  if (max || text2.charCodeAt(pos) === 125 /* closeBrace */) {
-                    error(Diagnostics.Incomplete_quantifier_Digit_expected, digitsStart, 0);
-                  } else {
-                    if (unicodeMode) {
-                      error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, start2, 1, String.fromCharCode(ch));
-                    }
-                    isPreviousTermQuantifiable = true;
-                    break;
+              const max = tokenValue;
+              if (!min2) {
+                if (max || charCodeChecked(pos) === 125 /* closeBrace */) {
+                  error(Diagnostics.Incomplete_quantifier_Digit_expected, digitsStart, 0);
+                } else {
+                  if (unicodeMode) {
+                    error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, start2, 1, String.fromCharCode(ch));
                   }
+                  isPreviousTermQuantifiable = true;
+                  break;
                 }
-                if (max && Number.parseInt(min2) > Number.parseInt(max)) {
-                  error(Diagnostics.Numbers_out_of_order_in_quantifier, digitsStart, pos - digitsStart);
-                }
-              } else if (!min2) {
-                if (unicodeMode) {
-                  error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, start2, 1, String.fromCharCode(ch));
-                }
-                isPreviousTermQuantifiable = true;
-                break;
-              }
-              scanExpectedChar(125 /* closeBrace */);
-              pos--;
-            case 42 /* asterisk */:
-            case 43 /* plus */:
-            case 63 /* question */:
-              pos++;
-              if (text2.charCodeAt(pos) === 63 /* question */) {
-                pos++;
-              }
-              if (!isPreviousTermQuantifiable) {
-                error(Diagnostics.There_is_nothing_available_for_repetition, start2, pos - start2);
-              }
-              isPreviousTermQuantifiable = false;
-              break;
-            case 46 /* dot */:
-              pos++;
-              isPreviousTermQuantifiable = true;
-              break;
-            case 91 /* openBracket */:
-              pos++;
-              if (unicodeSetsMode) {
-                scanClassSetExpression();
-              } else {
-                scanClassRanges();
-              }
-              scanExpectedChar(93 /* closeBracket */);
-              isPreviousTermQuantifiable = true;
-              break;
-            case 41 /* closeParen */:
-              if (isInGroup) {
-                return;
               }
-            case 93 /* closeBracket */:
-            case 125 /* closeBrace */:
-              if (isUnterminated && !isInGroup) {
-                return;
+              if (max && Number.parseInt(min2) > Number.parseInt(max)) {
+                error(Diagnostics.Numbers_out_of_order_in_quantifier, digitsStart, pos - digitsStart);
               }
-              if (unicodeMode || ch === 41 /* closeParen */) {
-                error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
+            } else if (!min2) {
+              if (unicodeMode) {
+                error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, start2, 1, String.fromCharCode(ch));
               }
-              pos++;
-              isPreviousTermQuantifiable = true;
-              break;
-            case 47 /* slash */:
-            case 124 /* bar */:
-              return;
-            default:
-              scanSourceCharacter();
               isPreviousTermQuantifiable = true;
               break;
-          }
-        }
-      }
-      function scanPatternModifiers(currFlags) {
-        while (pos < end2) {
-          const ch = text2.charCodeAt(pos);
-          if (!isIdentifierPart(ch, languageVersion)) {
-            break;
-          }
-          const flag = characterToRegularExpressionFlag(String.fromCharCode(ch));
-          if (flag === void 0) {
-            error(Diagnostics.Unknown_regular_expression_flag, pos, 1);
-          } else if (currFlags & flag) {
-            error(Diagnostics.Duplicate_regular_expression_flag, pos, 1);
-          } else if (!(flag & 28 /* Modifiers */)) {
-            error(Diagnostics.This_regular_expression_flag_cannot_be_toggled_within_a_subpattern, pos, 1);
-          } else {
-            currFlags |= flag;
-            checkRegularExpressionFlagAvailable(flag, pos);
-          }
-          pos++;
-        }
-        return currFlags;
-      }
-      function scanAtomEscape() {
-        Debug.assertEqual(text2.charCodeAt(pos - 1), 92 /* backslash */);
-        switch (text2.charCodeAt(pos)) {
-          case 107 /* k */:
+            }
+            scanExpectedChar(125 /* closeBrace */);
+            pos--;
+          case 42 /* asterisk */:
+          case 43 /* plus */:
+          case 63 /* question */:
             pos++;
-            if (text2.charCodeAt(pos) === 60 /* lessThan */) {
+            if (charCodeChecked(pos) === 63 /* question */) {
               pos++;
-              scanGroupName(
-                /*isReference*/
-                true
-              );
-              scanExpectedChar(62 /* greaterThan */);
-            } else if (unicodeMode) {
-              error(Diagnostics.k_must_be_followed_by_a_capturing_group_name_enclosed_in_angle_brackets, pos - 2, 2);
             }
-            break;
-          case 113 /* q */:
-            if (unicodeSetsMode) {
-              pos++;
-              error(Diagnostics.q_is_only_available_inside_character_class, pos - 2, 2);
-              break;
+            if (!isPreviousTermQuantifiable) {
+              error(Diagnostics.There_is_nothing_available_for_repetition, start2, pos - start2);
             }
-          default:
-            Debug.assert(scanCharacterClassEscape() || scanDecimalEscape() || scanCharacterEscape(
-              /*atomEscape*/
-              true
-            ));
+            isPreviousTermQuantifiable = false;
             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(atomEscape) {
-        Debug.assertEqual(text2.charCodeAt(pos - 1), 92 /* backslash */);
-        let ch = text2.charCodeAt(pos);
-        switch (ch) {
-          case 99 /* c */:
+          case 46 /* dot */:
             pos++;
-            ch = text2.charCodeAt(pos);
-            if (isASCIILetter(ch)) {
-              pos++;
-              return String.fromCharCode(ch & 31);
-            }
-            if (unicodeMode) {
-              error(Diagnostics.c_must_be_followed_by_an_ASCII_letter, pos - 2, 2);
-            } else if (atomEscape && annexB) {
-              pos--;
-              return "\\";
+            isPreviousTermQuantifiable = true;
+            break;
+          case 91 /* openBracket */:
+            pos++;
+            if (unicodeSetsMode) {
+              scanClassSetExpression();
+            } else {
+              scanClassRanges();
             }
-            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 */:
+            scanExpectedChar(93 /* closeBracket */);
+            isPreviousTermQuantifiable = true;
+            break;
           case 41 /* closeParen */:
-          case 91 /* openBracket */:
+            if (isInGroup) {
+              return;
+            }
           case 93 /* closeBracket */:
-          case 123 /* openBrace */:
           case 125 /* closeBrace */:
-          case 124 /* bar */:
+            if (isUnterminated && !isInGroup) {
+              return;
+            }
+            if (unicodeMode || ch === 41 /* closeParen */) {
+              error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
+            }
             pos++;
-            return String.fromCharCode(ch);
+            isPreviousTermQuantifiable = true;
+            break;
+          case 47 /* slash */:
+          case 124 /* bar */:
+            return;
           default:
-            if (pos >= end2) {
-              error(Diagnostics.Undetermined_character_escape, pos - 1, 1, ch);
-              return "\\";
-            }
-            pos--;
-            return scanEscapeSequence(
-              /*shouldEmitInvalidEscapeError*/
-              unicodeMode,
-              /*isRegularExpression*/
-              annexB ? "annex-b" : true
-            );
+            scanSourceCharacter();
+            isPreviousTermQuantifiable = true;
+            break;
         }
       }
-      function scanGroupName(isReference) {
-        Debug.assertEqual(text2.charCodeAt(pos - 1), 60 /* lessThan */);
-        tokenStart = pos;
-        scanIdentifier(codePointAt(text2, pos), languageVersion);
-        if (pos === tokenStart) {
-          error(Diagnostics.Expected_a_capturing_group_name);
-        } else if (isReference) {
-          groupNameReferences.push({ pos: tokenStart, end: pos, name: tokenValue });
-        } else if (namedCapturingGroups.some((group2) => group2.has(tokenValue))) {
-          error(Diagnostics.Named_capturing_groups_with_the_same_name_must_be_mutually_exclusive_to_each_other, tokenStart, pos - tokenStart);
+    }
+    function scanPatternModifiers(currFlags) {
+      while (true) {
+        const ch = charCodeChecked(pos);
+        if (ch === -1 /* EOF */ || !isIdentifierPart(ch, languageVersion)) {
+          break;
+        }
+        const flag = characterToRegularExpressionFlag(String.fromCharCode(ch));
+        if (flag === void 0) {
+          error(Diagnostics.Unknown_regular_expression_flag, pos, 1);
+        } else if (currFlags & flag) {
+          error(Diagnostics.Duplicate_regular_expression_flag, pos, 1);
+        } else if (!(flag & 28 /* Modifiers */)) {
+          error(Diagnostics.This_regular_expression_flag_cannot_be_toggled_within_a_subpattern, pos, 1);
         } else {
-          last(namedCapturingGroups).add(tokenValue);
-          groupSpecifiers.add(tokenValue);
+          currFlags |= flag;
+          checkRegularExpressionFlagAvailable(flag, pos);
         }
+        pos++;
+      }
+      return currFlags;
+    }
+    function scanAtomEscape() {
+      Debug.assertEqual(charCodeUnchecked(pos - 1), 92 /* backslash */);
+      switch (charCodeChecked(pos)) {
+        case 107 /* k */:
+          pos++;
+          if (charCodeChecked(pos) === 60 /* lessThan */) {
+            pos++;
+            scanGroupName(
+              /*isReference*/
+              true
+            );
+            scanExpectedChar(62 /* greaterThan */);
+          } else if (unicodeMode) {
+            error(Diagnostics.k_must_be_followed_by_a_capturing_group_name_enclosed_in_angle_brackets, pos - 2, 2);
+          }
+          break;
+        case 113 /* q */:
+          if (unicodeSetsMode) {
+            pos++;
+            error(Diagnostics.q_is_only_available_inside_character_class, pos - 2, 2);
+            break;
+          }
+        default:
+          Debug.assert(scanCharacterClassEscape() || scanDecimalEscape() || scanCharacterEscape(
+            /*atomEscape*/
+            true
+          ));
+          break;
+      }
+    }
+    function scanDecimalEscape() {
+      Debug.assertEqual(charCodeUnchecked(pos - 1), 92 /* backslash */);
+      const ch = charCodeChecked(pos);
+      if (ch >= 49 /* _1 */ && ch <= 57 /* _9 */) {
+        const start2 = pos;
+        scanDigits();
+        decimalEscapes = append(decimalEscapes, { pos: start2, end: pos, value: +tokenValue });
+        return true;
+      }
+      return false;
+    }
+    function scanCharacterEscape(atomEscape) {
+      Debug.assertEqual(charCodeUnchecked(pos - 1), 92 /* backslash */);
+      let ch = charCodeChecked(pos);
+      switch (ch) {
+        case 99 /* c */:
+          pos++;
+          ch = charCodeChecked(pos);
+          if (isASCIILetter(ch)) {
+            pos++;
+            return String.fromCharCode(ch & 31);
+          }
+          if (unicodeMode) {
+            error(Diagnostics.c_must_be_followed_by_an_ASCII_letter, pos - 2, 2);
+          } else if (atomEscape && annexB) {
+            pos--;
+            return "\\";
+          }
+          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 >= end) {
+            error(Diagnostics.Undetermined_character_escape, pos - 1, 1);
+            return "\\";
+          }
+          pos--;
+          return scanEscapeSequence(
+            /*shouldEmitInvalidEscapeError*/
+            unicodeMode,
+            /*isRegularExpression*/
+            annexB ? "annex-b" : true
+          );
+      }
+    }
+    function scanGroupName(isReference) {
+      Debug.assertEqual(charCodeUnchecked(pos - 1), 60 /* lessThan */);
+      tokenStart = pos;
+      scanIdentifier(codePointChecked(pos), languageVersion);
+      if (pos === tokenStart) {
+        error(Diagnostics.Expected_a_capturing_group_name);
+      } else if (isReference) {
+        groupNameReferences = append(groupNameReferences, { pos: tokenStart, end: pos, name: tokenValue });
+      } else if ((topNamedCapturingGroupsScope == null ? void 0 : topNamedCapturingGroupsScope.has(tokenValue)) || namedCapturingGroupsScopeStack.some((group2) => group2 == null ? void 0 : group2.has(tokenValue))) {
+        error(Diagnostics.Named_capturing_groups_with_the_same_name_must_be_mutually_exclusive_to_each_other, tokenStart, pos - tokenStart);
+      } else {
+        topNamedCapturingGroupsScope ?? (topNamedCapturingGroupsScope = /* @__PURE__ */ new Set());
+        topNamedCapturingGroupsScope.add(tokenValue);
+        groupSpecifiers ?? (groupSpecifiers = /* @__PURE__ */ new Set());
+        groupSpecifiers.add(tokenValue);
       }
-      function isClassContentExit(ch) {
-        return ch === 93 /* closeBracket */ || pos >= end2;
+    }
+    function isClassContentExit(ch) {
+      return ch === 93 /* closeBracket */ || ch === -1 /* EOF */ || pos >= end;
+    }
+    function scanClassRanges() {
+      Debug.assertEqual(charCodeUnchecked(pos - 1), 91 /* openBracket */);
+      if (charCodeChecked(pos) === 94 /* caret */) {
+        pos++;
       }
-      function scanClassRanges() {
-        Debug.assertEqual(text2.charCodeAt(pos - 1), 91 /* openBracket */);
-        if (text2.charCodeAt(pos) === 94 /* caret */) {
+      while (true) {
+        const ch = charCodeChecked(pos);
+        if (isClassContentExit(ch)) {
+          return;
+        }
+        const minStart = pos;
+        const minCharacter = scanClassAtom();
+        if (charCodeChecked(pos) === 45 /* minus */) {
           pos++;
+          const ch2 = charCodeChecked(pos);
+          if (isClassContentExit(ch2)) {
+            return;
+          }
+          if (!minCharacter && !annexB) {
+            error(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, minStart, pos - 1 - minStart);
+          }
+          const maxStart = pos;
+          const maxCharacter = scanClassAtom();
+          if (!maxCharacter && !annexB) {
+            error(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, maxStart, pos - maxStart);
+            continue;
+          }
+          if (!minCharacter) {
+            continue;
+          }
+          const minCharacterValue = codePointAt(minCharacter, 0);
+          const maxCharacterValue = codePointAt(maxCharacter, 0);
+          if (minCharacter.length === charSize(minCharacterValue) && maxCharacter.length === charSize(maxCharacterValue) && minCharacterValue > maxCharacterValue) {
+            error(Diagnostics.Range_out_of_order_in_character_class, minStart, pos - minStart);
+          }
         }
-        while (pos < end2) {
-          const ch = text2.charCodeAt(pos);
-          if (isClassContentExit(ch)) {
+      }
+    }
+    function scanClassSetExpression() {
+      Debug.assertEqual(charCodeUnchecked(pos - 1), 91 /* openBracket */);
+      let isCharacterComplement = false;
+      if (charCodeChecked(pos) === 94 /* caret */) {
+        pos++;
+        isCharacterComplement = true;
+      }
+      let expressionMayContainStrings = false;
+      let ch = charCodeChecked(pos);
+      if (isClassContentExit(ch)) {
+        return;
+      }
+      let start2 = pos;
+      let operand;
+      switch (text.slice(pos, pos + 2)) {
+        case "--":
+        case "&&":
+          error(Diagnostics.Expected_a_class_set_operand);
+          mayContainStrings = false;
+          break;
+        default:
+          operand = scanClassSetOperand();
+          break;
+      }
+      switch (charCodeChecked(pos)) {
+        case 45 /* minus */:
+          if (charCodeChecked(pos + 1) === 45 /* minus */) {
+            if (isCharacterComplement && mayContainStrings) {
+              error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, start2, pos - start2);
+            }
+            expressionMayContainStrings = mayContainStrings;
+            scanClassSetSubExpression(3 /* ClassSubtraction */);
+            mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
             return;
           }
-          const minStart = pos;
-          const minCharacter = scanClassAtom();
-          if (text2.charCodeAt(pos) === 45 /* minus */) {
+          break;
+        case 38 /* ampersand */:
+          if (charCodeChecked(pos + 1) === 38 /* ampersand */) {
+            scanClassSetSubExpression(2 /* ClassIntersection */);
+            if (isCharacterComplement && mayContainStrings) {
+              error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, start2, pos - start2);
+            }
+            expressionMayContainStrings = mayContainStrings;
+            mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
+            return;
+          } else {
+            error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
+          }
+          break;
+        default:
+          if (isCharacterComplement && mayContainStrings) {
+            error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, start2, pos - start2);
+          }
+          expressionMayContainStrings = mayContainStrings;
+          break;
+      }
+      while (true) {
+        ch = charCodeChecked(pos);
+        if (ch === -1 /* EOF */) {
+          break;
+        }
+        switch (ch) {
+          case 45 /* minus */:
             pos++;
-            const ch2 = text2.charCodeAt(pos);
-            if (isClassContentExit(ch2)) {
+            ch = charCodeChecked(pos);
+            if (isClassContentExit(ch)) {
+              mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
               return;
             }
-            if (!minCharacter && !annexB) {
-              error(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, minStart, pos - 1 - minStart);
-            }
-            const maxStart = pos;
-            const maxCharacter = scanClassAtom();
-            if (!maxCharacter && !annexB) {
-              error(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, maxStart, pos - maxStart);
-              continue;
-            }
-            if (!minCharacter) {
+            if (ch === 45 /* minus */) {
+              pos++;
+              error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
+              start2 = pos - 2;
+              operand = text.slice(start2, pos);
               continue;
+            } else {
+              if (!operand) {
+                error(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, start2, pos - 1 - start2);
+              }
+              const secondStart = pos;
+              const secondOperand = scanClassSetOperand();
+              if (isCharacterComplement && mayContainStrings) {
+                error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, secondStart, pos - secondStart);
+              }
+              expressionMayContainStrings || (expressionMayContainStrings = mayContainStrings);
+              if (!secondOperand) {
+                error(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, secondStart, pos - secondStart);
+                break;
+              }
+              if (!operand) {
+                break;
+              }
+              const minCharacterValue = codePointAt(operand, 0);
+              const maxCharacterValue = codePointAt(secondOperand, 0);
+              if (operand.length === charSize(minCharacterValue) && secondOperand.length === charSize(maxCharacterValue) && minCharacterValue > maxCharacterValue) {
+                error(Diagnostics.Range_out_of_order_in_character_class, start2, pos - start2);
+              }
             }
-            const minCharacterValue = codePointAt(minCharacter, 0);
-            const maxCharacterValue = codePointAt(maxCharacter, 0);
-            if (minCharacter.length === charSize(minCharacterValue) && maxCharacter.length === charSize(maxCharacterValue) && minCharacterValue > maxCharacterValue) {
-              error(Diagnostics.Range_out_of_order_in_character_class, minStart, pos - minStart);
+            break;
+          case 38 /* ampersand */:
+            start2 = pos;
+            pos++;
+            if (charCodeChecked(pos) === 38 /* ampersand */) {
+              pos++;
+              error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
+              if (charCodeChecked(pos) === 38 /* ampersand */) {
+                error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
+                pos++;
+              }
+            } else {
+              error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos - 1, 1, String.fromCharCode(ch));
             }
-          }
-        }
-      }
-      function scanClassSetExpression() {
-        Debug.assertEqual(text2.charCodeAt(pos - 1), 91 /* openBracket */);
-        let isCharacterComplement = false;
-        if (text2.charCodeAt(pos) === 94 /* caret */) {
-          pos++;
-          isCharacterComplement = true;
+            operand = text.slice(start2, pos);
+            continue;
         }
-        let expressionMayContainStrings = false;
-        let ch = text2.charCodeAt(pos);
-        if (isClassContentExit(ch)) {
-          return;
+        if (isClassContentExit(charCodeChecked(pos))) {
+          break;
         }
-        let start2 = pos;
-        let oprand;
-        switch (text2.slice(pos, pos + 2)) {
+        start2 = pos;
+        switch (text.slice(pos, pos + 2)) {
           case "--":
           case "&&":
-            error(Diagnostics.Expected_a_class_set_oprand);
-            mayContainStrings = false;
+            error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos, 2);
+            pos += 2;
+            operand = text.slice(start2, pos);
             break;
           default:
-            oprand = scanClassSetOprand();
+            operand = scanClassSetOperand();
             break;
         }
-        switch (text2.charCodeAt(pos)) {
+      }
+      mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
+    }
+    function scanClassSetSubExpression(expressionType) {
+      let expressionMayContainStrings = mayContainStrings;
+      while (true) {
+        let ch = charCodeChecked(pos);
+        if (isClassContentExit(ch)) {
+          break;
+        }
+        switch (ch) {
           case 45 /* minus */:
-            if (text2.charCodeAt(pos + 1) === 45 /* minus */) {
-              if (isCharacterComplement && mayContainStrings) {
-                error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, start2, pos - start2);
+            pos++;
+            if (charCodeChecked(pos) === 45 /* minus */) {
+              pos++;
+              if (expressionType !== 3 /* ClassSubtraction */) {
+                error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
               }
-              expressionMayContainStrings = mayContainStrings;
-              scanClassSetSubExpression(3 /* ClassSubtraction */);
-              mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
-              return;
+            } else {
+              error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 1, 1);
             }
             break;
           case 38 /* ampersand */:
-            if (text2.charCodeAt(pos + 1) === 38 /* ampersand */) {
-              scanClassSetSubExpression(2 /* ClassIntersection */);
-              if (isCharacterComplement && mayContainStrings) {
-                error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, start2, pos - start2);
+            pos++;
+            if (charCodeChecked(pos) === 38 /* ampersand */) {
+              pos++;
+              if (expressionType !== 2 /* ClassIntersection */) {
+                error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
+              }
+              if (charCodeChecked(pos) === 38 /* ampersand */) {
+                error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
+                pos++;
               }
-              expressionMayContainStrings = mayContainStrings;
-              mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
-              return;
             } else {
-              error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
+              error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos - 1, 1, String.fromCharCode(ch));
             }
             break;
           default:
-            if (isCharacterComplement && mayContainStrings) {
-              error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, start2, pos - start2);
+            switch (expressionType) {
+              case 3 /* ClassSubtraction */:
+                error(Diagnostics._0_expected, pos, 0, "--");
+                break;
+              case 2 /* ClassIntersection */:
+                error(Diagnostics._0_expected, pos, 0, "&&");
+                break;
+              default:
+                break;
             }
-            expressionMayContainStrings = mayContainStrings;
             break;
         }
-        while (pos < end2) {
-          ch = text2.charCodeAt(pos);
-          switch (ch) {
-            case 45 /* minus */:
-              pos++;
-              ch = text2.charCodeAt(pos);
-              if (isClassContentExit(ch)) {
-                mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
-                return;
-              }
-              if (ch === 45 /* minus */) {
-                pos++;
-                error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
-                start2 = pos - 2;
-                oprand = text2.slice(start2, pos);
-                continue;
-              } else {
-                if (!oprand) {
-                  error(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, start2, pos - 1 - start2);
-                }
-                const secondStart = pos;
-                const secondOprand = scanClassSetOprand();
-                if (isCharacterComplement && mayContainStrings) {
-                  error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, secondStart, pos - secondStart);
-                }
-                expressionMayContainStrings || (expressionMayContainStrings = mayContainStrings);
-                if (!secondOprand) {
-                  error(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, secondStart, pos - secondStart);
-                  break;
-                }
-                if (!oprand) {
-                  break;
-                }
-                const minCharacterValue = codePointAt(oprand, 0);
-                const maxCharacterValue = codePointAt(secondOprand, 0);
-                if (oprand.length === charSize(minCharacterValue) && secondOprand.length === charSize(maxCharacterValue) && minCharacterValue > maxCharacterValue) {
-                  error(Diagnostics.Range_out_of_order_in_character_class, start2, pos - start2);
-                }
-              }
-              break;
-            case 38 /* ampersand */:
-              start2 = pos;
-              pos++;
-              if (text2.charCodeAt(pos) === 38 /* ampersand */) {
-                pos++;
-                error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
-                if (text2.charCodeAt(pos) === 38 /* ampersand */) {
-                  error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
-                  pos++;
-                }
-              } else {
-                error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos - 1, 1, String.fromCharCode(ch));
-              }
-              oprand = text2.slice(start2, pos);
-              continue;
-          }
-          if (isClassContentExit(text2.charCodeAt(pos))) {
-            break;
-          }
-          start2 = pos;
-          switch (text2.slice(pos, pos + 2)) {
-            case "--":
-            case "&&":
-              error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos, 2);
-              pos += 2;
-              oprand = text2.slice(start2, pos);
-              break;
-            default:
-              oprand = scanClassSetOprand();
-              break;
-          }
+        ch = charCodeChecked(pos);
+        if (isClassContentExit(ch)) {
+          error(Diagnostics.Expected_a_class_set_operand);
+          break;
         }
-        mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
+        scanClassSetOperand();
+        expressionMayContainStrings && (expressionMayContainStrings = mayContainStrings);
       }
-      function scanClassSetSubExpression(expressionType) {
-        let expressionMayContainStrings = mayContainStrings;
-        while (pos < end2) {
-          let ch = text2.charCodeAt(pos);
-          if (isClassContentExit(ch)) {
-            break;
-          }
-          switch (ch) {
-            case 45 /* minus */:
-              pos++;
-              if (text2.charCodeAt(pos) === 45 /* minus */) {
-                pos++;
-                if (expressionType !== 3 /* ClassSubtraction */) {
-                  error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
-                }
-              } else {
-                error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 1, 1);
-              }
-              break;
-            case 38 /* ampersand */:
+      mayContainStrings = expressionMayContainStrings;
+    }
+    function scanClassSetOperand() {
+      mayContainStrings = false;
+      switch (charCodeChecked(pos)) {
+        case -1 /* EOF */:
+          return "";
+        case 91 /* openBracket */:
+          pos++;
+          scanClassSetExpression();
+          scanExpectedChar(93 /* closeBracket */);
+          return "";
+        case 92 /* backslash */:
+          pos++;
+          if (scanCharacterClassEscape()) {
+            return "";
+          } else if (charCodeChecked(pos) === 113 /* q */) {
+            pos++;
+            if (charCodeChecked(pos) === 123 /* openBrace */) {
               pos++;
-              if (text2.charCodeAt(pos) === 38 /* ampersand */) {
-                pos++;
-                if (expressionType !== 2 /* ClassIntersection */) {
-                  error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos - 2, 2);
-                }
-                if (text2.charCodeAt(pos) === 38 /* ampersand */) {
-                  error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
-                  pos++;
-                }
-              } else {
-                error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos - 1, 1, String.fromCharCode(ch));
-              }
-              break;
-            default:
-              switch (expressionType) {
-                case 3 /* ClassSubtraction */:
-                  error(Diagnostics._0_expected, pos, 0, "--");
-                  break;
-                case 2 /* ClassIntersection */:
-                  error(Diagnostics._0_expected, pos, 0, "&&");
-                  break;
-                default:
-                  break;
-              }
-              break;
+              scanClassStringDisjunctionContents();
+              scanExpectedChar(125 /* closeBrace */);
+              return "";
+            } else {
+              error(Diagnostics.q_must_be_followed_by_string_alternatives_enclosed_in_braces, pos - 2, 2);
+              return "q";
+            }
           }
-          ch = text2.charCodeAt(pos);
-          if (isClassContentExit(ch)) {
-            error(Diagnostics.Expected_a_class_set_oprand);
+          pos--;
+        default:
+          return scanClassSetCharacter();
+      }
+    }
+    function scanClassStringDisjunctionContents() {
+      Debug.assertEqual(charCodeUnchecked(pos - 1), 123 /* openBrace */);
+      let characterCount = 0;
+      while (true) {
+        const ch = charCodeChecked(pos);
+        switch (ch) {
+          case -1 /* EOF */:
+            return;
+          case 125 /* closeBrace */:
+            if (characterCount !== 1) {
+              mayContainStrings = true;
+            }
+            return;
+          case 124 /* bar */:
+            if (characterCount !== 1) {
+              mayContainStrings = true;
+            }
+            pos++;
+            start = pos;
+            characterCount = 0;
+            break;
+          default:
+            scanClassSetCharacter();
+            characterCount++;
             break;
-          }
-          scanClassSetOprand();
-          expressionMayContainStrings && (expressionMayContainStrings = mayContainStrings);
         }
-        mayContainStrings = expressionMayContainStrings;
       }
-      function scanClassSetOprand() {
-        mayContainStrings = false;
-        switch (text2.charCodeAt(pos)) {
-          case 91 /* openBracket */:
+    }
+    function scanClassSetCharacter() {
+      const ch = charCodeChecked(pos);
+      if (ch === -1 /* EOF */) {
+        return "";
+      }
+      if (ch === 92 /* backslash */) {
+        pos++;
+        const ch2 = charCodeChecked(pos);
+        switch (ch2) {
+          case 98 /* b */:
             pos++;
-            scanClassSetExpression();
-            scanExpectedChar(93 /* closeBracket */);
-            return "";
-          case 92 /* backslash */:
+            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++;
-            if (scanCharacterClassEscape()) {
-              return "";
-            } else if (text2.charCodeAt(pos) === 113 /* q */) {
-              pos++;
-              if (text2.charCodeAt(pos) === 123 /* openBrace */) {
-                pos++;
-                scanClassStringDisjunctionContents();
-                scanExpectedChar(125 /* closeBrace */);
-                return "";
-              } else {
-                error(Diagnostics.q_must_be_followed_by_string_alternatives_enclosed_in_braces, pos - 2, 2);
-                return "q";
-              }
-            }
-            pos--;
+            return String.fromCharCode(ch2);
           default:
-            return scanClassSetCharacter();
-        }
-      }
-      function scanClassStringDisjunctionContents() {
-        Debug.assertEqual(text2.charCodeAt(pos - 1), 123 /* openBrace */);
-        let characterCount = 0;
-        while (pos < end2) {
-          const ch = text2.charCodeAt(pos);
-          switch (ch) {
-            case 125 /* closeBrace */:
-              if (characterCount !== 1) {
-                mayContainStrings = true;
-              }
-              return;
-            case 124 /* bar */:
-              if (characterCount !== 1) {
-                mayContainStrings = true;
-              }
-              pos++;
-              start = pos;
-              characterCount = 0;
-              break;
-            default:
-              scanClassSetCharacter();
-              characterCount++;
-              break;
-          }
+            return scanCharacterEscape(
+              /*atomEscape*/
+              false
+            );
+        }
+      } else if (ch === charCodeChecked(pos + 1)) {
+        switch (ch) {
+          case 38 /* ampersand */:
+          case 33 /* exclamation */:
+          case 35 /* hash */:
+          case 37 /* percent */:
+          case 42 /* asterisk */:
+          case 43 /* plus */:
+          case 44 /* comma */:
+          case 46 /* dot */:
+          case 58 /* colon */:
+          case 59 /* semicolon */:
+          case 60 /* lessThan */:
+          case 61 /* equals */:
+          case 62 /* greaterThan */:
+          case 63 /* question */:
+          case 64 /* at */:
+          case 96 /* backtick */:
+          case 126 /* tilde */:
+            error(Diagnostics.A_character_class_must_not_contain_a_reserved_double_punctuator_Did_you_mean_to_escape_it_with_backslash, pos, 2);
+            pos += 2;
+            return text.substring(pos - 2, pos);
         }
       }
-      function scanClassSetCharacter() {
-        const ch = text2.charCodeAt(pos);
-        if (ch === 92 /* backslash */) {
+      switch (ch) {
+        case 47 /* slash */:
+        case 40 /* openParen */:
+        case 41 /* closeParen */:
+        case 91 /* openBracket */:
+        case 93 /* closeBracket */:
+        case 123 /* openBrace */:
+        case 125 /* closeBrace */:
+        case 45 /* minus */:
+        case 124 /* bar */:
+          error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
           pos++;
-          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(
-                /*atomEscape*/
-                false
-              );
-          }
-        } else if (ch === text2.charCodeAt(pos + 1)) {
-          switch (ch) {
-            case 38 /* ampersand */:
-            case 33 /* exclamation */:
-            case 35 /* hash */:
-            case 37 /* percent */:
-            case 42 /* asterisk */:
-            case 43 /* plus */:
-            case 44 /* comma */:
-            case 46 /* dot */:
-            case 58 /* colon */:
-            case 59 /* semicolon */:
-            case 60 /* lessThan */:
-            case 61 /* equals */:
-            case 62 /* greaterThan */:
-            case 63 /* question */:
-            case 64 /* at */:
-            case 96 /* backtick */:
-            case 126 /* tilde */:
-              error(Diagnostics.A_character_class_must_not_contain_a_reserved_double_punctuator_Did_you_mean_to_escape_it_with_backslash, pos, 2);
-              pos += 2;
-              return text2.substring(pos - 2, pos);
-          }
-        }
+          return String.fromCharCode(ch);
+      }
+      return scanSourceCharacter();
+    }
+    function scanClassAtom() {
+      if (charCodeChecked(pos) === 92 /* backslash */) {
+        pos++;
+        const ch = charCodeChecked(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 98 /* b */:
+            pos++;
+            return "\b";
           case 45 /* minus */:
-          case 124 /* bar */:
-            error(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
             pos++;
             return String.fromCharCode(ch);
+          default:
+            if (scanCharacterClassEscape()) {
+              return "";
+            }
+            return scanCharacterEscape(
+              /*atomEscape*/
+              false
+            );
         }
+      } else {
         return scanSourceCharacter();
       }
-      function scanClassAtom() {
-        if (text2.charCodeAt(pos) === 92 /* backslash */) {
+    }
+    function scanCharacterClassEscape() {
+      Debug.assertEqual(charCodeUnchecked(pos - 1), 92 /* backslash */);
+      let isCharacterComplement = false;
+      const start2 = pos - 1;
+      const ch = charCodeChecked(pos);
+      switch (ch) {
+        case 100 /* d */:
+        case 68 /* D */:
+        case 115 /* s */:
+        case 83 /* S */:
+        case 119 /* w */:
+        case 87 /* W */:
           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(
-                /*atomEscape*/
-                false
-              );
-          }
-        } 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 */:
+          return true;
+        case 80 /* P */:
+          isCharacterComplement = true;
+        case 112 /* p */:
+          pos++;
+          if (charCodeChecked(pos) === 123 /* openBrace */) {
             pos++;
-            if (text2.charCodeAt(pos) === 123 /* openBrace */) {
+            const propertyNameOrValueStart = pos;
+            const propertyNameOrValue = scanWordCharacters();
+            if (charCodeChecked(pos) === 61 /* equals */) {
+              const propertyName = nonBinaryUnicodeProperties.get(propertyNameOrValue);
+              if (pos === propertyNameOrValueStart) {
+                error(Diagnostics.Expected_a_Unicode_property_name);
+              } else if (propertyName === void 0) {
+                error(Diagnostics.Unknown_Unicode_property_name, propertyNameOrValueStart, pos - propertyNameOrValueStart);
+                const suggestion = getSpellingSuggestion(propertyNameOrValue, nonBinaryUnicodeProperties.keys(), identity);
+                if (suggestion) {
+                  error(Diagnostics.Did_you_mean_0, propertyNameOrValueStart, pos - propertyNameOrValueStart, suggestion);
+                }
+              }
               pos++;
-              const propertyNameOrValueStart = pos;
-              const propertyNameOrValue = scanWordCharacters();
-              if (text2.charCodeAt(pos) === 61 /* equals */) {
-                const propertyName = nonBinaryUnicodeProperties.get(propertyNameOrValue);
-                if (pos === propertyNameOrValueStart) {
-                  error(Diagnostics.Expected_a_Unicode_property_name);
-                } else if (propertyName === void 0) {
-                  error(Diagnostics.Unknown_Unicode_property_name, propertyNameOrValueStart, pos - propertyNameOrValueStart);
-                  const suggestion = getSpellingSuggestion(propertyNameOrValue, nonBinaryUnicodeProperties.keys(), identity);
-                  if (suggestion) {
-                    error(Diagnostics.Did_you_mean_0, propertyNameOrValueStart, pos - propertyNameOrValueStart, suggestion);
-                  }
+              const propertyValueStart = pos;
+              const propertyValue = scanWordCharacters();
+              if (pos === propertyValueStart) {
+                error(Diagnostics.Expected_a_Unicode_property_value);
+              } else if (propertyName !== void 0 && !valuesOfNonBinaryUnicodeProperties[propertyName].has(propertyValue)) {
+                error(Diagnostics.Unknown_Unicode_property_value, propertyValueStart, pos - propertyValueStart);
+                const suggestion = getSpellingSuggestion(propertyValue, valuesOfNonBinaryUnicodeProperties[propertyName], identity);
+                if (suggestion) {
+                  error(Diagnostics.Did_you_mean_0, propertyValueStart, pos - propertyValueStart, suggestion);
                 }
-                pos++;
-                const propertyValueStart = pos;
-                const propertyValue = scanWordCharacters();
-                if (pos === propertyValueStart) {
-                  error(Diagnostics.Expected_a_Unicode_property_value);
-                } else if (propertyName !== void 0 && !valuesOfNonBinaryUnicodeProperties[propertyName].has(propertyValue)) {
-                  error(Diagnostics.Unknown_Unicode_property_value, propertyValueStart, pos - propertyValueStart);
-                  const suggestion = getSpellingSuggestion(propertyValue, valuesOfNonBinaryUnicodeProperties[propertyName], identity);
-                  if (suggestion) {
-                    error(Diagnostics.Did_you_mean_0, propertyValueStart, pos - propertyValueStart, suggestion);
-                  }
+              }
+            } else {
+              if (pos === propertyNameOrValueStart) {
+                error(Diagnostics.Expected_a_Unicode_property_name_or_value);
+              } else if (binaryUnicodePropertiesOfStrings.has(propertyNameOrValue)) {
+                if (!unicodeSetsMode) {
+                  error(Diagnostics.Any_Unicode_property_that_would_possibly_match_more_than_a_single_character_is_only_available_when_the_Unicode_Sets_v_flag_is_set, propertyNameOrValueStart, pos - propertyNameOrValueStart);
+                } else if (isCharacterComplement) {
+                  error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, propertyNameOrValueStart, pos - propertyNameOrValueStart);
+                } else {
+                  mayContainStrings = true;
                 }
-              } else {
-                if (pos === propertyNameOrValueStart) {
-                  error(Diagnostics.Expected_a_Unicode_property_name_or_value);
-                } else if (binaryUnicodePropertiesOfStrings.has(propertyNameOrValue)) {
-                  if (!unicodeSetsMode) {
-                    error(Diagnostics.Any_Unicode_property_that_would_possibly_match_more_than_a_single_character_is_only_available_when_the_Unicode_Sets_v_flag_is_set, propertyNameOrValueStart, pos - propertyNameOrValueStart);
-                  } else if (isCharacterComplement) {
-                    error(Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class, propertyNameOrValueStart, pos - propertyNameOrValueStart);
-                  } else {
-                    mayContainStrings = true;
-                  }
-                } else if (!valuesOfNonBinaryUnicodeProperties.General_Category.has(propertyNameOrValue) && !binaryUnicodeProperties.has(propertyNameOrValue)) {
-                  error(Diagnostics.Unknown_Unicode_property_name_or_value, propertyNameOrValueStart, pos - propertyNameOrValueStart);
-                  const suggestion = getSpellingSuggestion(propertyNameOrValue, [...valuesOfNonBinaryUnicodeProperties.General_Category, ...binaryUnicodeProperties, ...binaryUnicodePropertiesOfStrings], identity);
-                  if (suggestion) {
-                    error(Diagnostics.Did_you_mean_0, propertyNameOrValueStart, pos - propertyNameOrValueStart, suggestion);
-                  }
+              } else if (!valuesOfNonBinaryUnicodeProperties.General_Category.has(propertyNameOrValue) && !binaryUnicodeProperties.has(propertyNameOrValue)) {
+                error(Diagnostics.Unknown_Unicode_property_name_or_value, propertyNameOrValueStart, pos - propertyNameOrValueStart);
+                const suggestion = getSpellingSuggestion(propertyNameOrValue, [...valuesOfNonBinaryUnicodeProperties.General_Category, ...binaryUnicodeProperties, ...binaryUnicodePropertiesOfStrings], identity);
+                if (suggestion) {
+                  error(Diagnostics.Did_you_mean_0, propertyNameOrValueStart, pos - propertyNameOrValueStart, suggestion);
                 }
               }
-              scanExpectedChar(125 /* closeBrace */);
-              if (!unicodeMode) {
-                error(Diagnostics.Unicode_property_value_expressions_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_set, start2, pos - start2);
-              }
-            } else if (unicodeMode) {
-              error(Diagnostics._0_must_be_followed_by_a_Unicode_property_value_expression_enclosed_in_braces, pos - 2, 2, String.fromCharCode(ch));
             }
-            return true;
-        }
-        return false;
-      }
-      function scanWordCharacters() {
-        let value = "";
-        while (pos < end2) {
-          const ch = text2.charCodeAt(pos);
-          if (!isWordCharacter(ch)) {
-            break;
+            scanExpectedChar(125 /* closeBrace */);
+            if (!unicodeMode) {
+              error(Diagnostics.Unicode_property_value_expressions_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_set, start2, pos - start2);
+            }
+          } else if (unicodeMode) {
+            error(Diagnostics._0_must_be_followed_by_a_Unicode_property_value_expression_enclosed_in_braces, pos - 2, 2, String.fromCharCode(ch));
           }
-          value += String.fromCharCode(ch);
-          pos++;
+          return true;
+      }
+      return false;
+    }
+    function scanWordCharacters() {
+      let value = "";
+      while (true) {
+        const ch = charCodeChecked(pos);
+        if (ch === -1 /* EOF */ || !isWordCharacter(ch)) {
+          break;
         }
-        return value;
+        value += String.fromCharCode(ch);
+        pos++;
       }
-      function scanSourceCharacter() {
-        const size = unicodeMode ? charSize(codePointAt(text2, pos)) : 1;
-        pos += size;
-        return text2.substring(pos - size, pos);
+      return value;
+    }
+    function scanSourceCharacter() {
+      const size = unicodeMode ? charSize(charCodeChecked(pos)) : 1;
+      pos += size;
+      return size > 0 ? text.substring(pos - size, pos) : "";
+    }
+    function scanExpectedChar(ch) {
+      if (charCodeChecked(pos) === ch) {
+        pos++;
+      } else {
+        error(Diagnostics._0_expected, pos, 0, String.fromCharCode(ch));
       }
-      function scanExpectedChar(ch) {
-        if (text2.charCodeAt(pos) === ch) {
-          pos++;
-        } else {
-          error(Diagnostics._0_expected, pos, 0, String.fromCharCode(ch));
-        }
+    }
+    scanDisjunction(
+      /*isInGroup*/
+      false
+    );
+    forEach(groupNameReferences, (reference) => {
+      if (!(groupSpecifiers == null ? void 0 : groupSpecifiers.has(reference.name))) {
+        error(Diagnostics.There_is_no_capturing_group_named_0_in_this_regular_expression, reference.pos, reference.end - reference.pos, reference.name);
       }
-      scanDisjunction(
-        /*isInGroup*/
-        false
-      );
-      forEach(groupNameReferences, (reference) => {
-        if (!groupSpecifiers.has(reference.name)) {
-          error(Diagnostics.There_is_no_capturing_group_named_0_in_this_regular_expression, reference.pos, reference.end - reference.pos, reference.name);
-        }
-      });
-      forEach(decimalEscapes, (escape) => {
-        if (!annexB && escape.value > numberOfCapturingGroups) {
-          if (numberOfCapturingGroups) {
-            error(Diagnostics.This_backreference_refers_to_a_group_that_does_not_exist_There_are_only_0_capturing_groups_in_this_regular_expression, escape.pos, escape.end - escape.pos, numberOfCapturingGroups);
-          } else {
-            error(Diagnostics.This_backreference_is_invalid_because_the_containing_regular_expression_contains_no_capturing_groups, escape.pos, escape.end - escape.pos);
-          }
+    });
+    forEach(decimalEscapes, (escape) => {
+      if (!annexB && escape.value > numberOfCapturingGroups) {
+        if (numberOfCapturingGroups) {
+          error(Diagnostics.This_backreference_refers_to_a_group_that_does_not_exist_There_are_only_0_capturing_groups_in_this_regular_expression, escape.pos, escape.end - escape.pos, numberOfCapturingGroups);
+        } else {
+          error(Diagnostics.This_backreference_is_invalid_because_the_containing_regular_expression_contains_no_capturing_groups, escape.pos, escape.end - escape.pos);
         }
-      });
-    }
-    function checkRegularExpressionFlagAvailable(flag, pos2) {
-      const availableFrom = regExpFlagToFirstAvailableLanguageVersion.get(flag);
-      if (availableFrom && languageVersion < availableFrom) {
-        error(Diagnostics.This_regular_expression_flag_is_only_available_when_targeting_0_or_later, pos2, 1, getNameOfScriptTarget(availableFrom));
       }
+    });
+  }
+  function checkRegularExpressionFlagAvailable(flag, pos2) {
+    const availableFrom = regExpFlagToFirstAvailableLanguageVersion.get(flag);
+    if (availableFrom && languageVersion < availableFrom) {
+      error(Diagnostics.This_regular_expression_flag_is_only_available_when_targeting_0_or_later, pos2, 1, getNameOfScriptTarget(availableFrom));
     }
   }
   function appendIfCommentDirective(commentDirectives2, text2, commentDirectiveRegEx, lineStart) {
@@ -10758,9 +10795,9 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     if (pos >= end) {
       return token = 1 /* EndOfFileToken */;
     }
-    let char = text.charCodeAt(pos);
+    let char = charCodeUnchecked(pos);
     if (char === 60 /* lessThan */) {
-      if (text.charCodeAt(pos + 1) === 47 /* slash */) {
+      if (charCodeUnchecked(pos + 1) === 47 /* slash */) {
         pos += 2;
         return token = 31 /* LessThanSlashToken */;
       }
@@ -10773,7 +10810,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     }
     let firstNonWhitespace = 0;
     while (pos < end) {
-      char = text.charCodeAt(pos);
+      char = charCodeUnchecked(pos);
       if (char === 123 /* openBrace */) {
         break;
       }
@@ -10805,7 +10842,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
   function scanJsxIdentifier() {
     if (tokenIsIdentifierOrKeyword(token)) {
       while (pos < end) {
-        const ch = text.charCodeAt(pos);
+        const ch = charCodeUnchecked(pos);
         if (ch === 45 /* minus */) {
           tokenValue += "-";
           pos++;
@@ -10823,7 +10860,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
   }
   function scanJsxAttributeValue() {
     fullStartPos = pos;
-    switch (text.charCodeAt(pos)) {
+    switch (charCodeUnchecked(pos)) {
       case 34 /* doubleQuote */:
       case 39 /* singleQuote */:
         tokenValue = scanString(
@@ -10845,11 +10882,11 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     if (pos >= end) {
       return token = 1 /* EndOfFileToken */;
     }
-    for (let ch = text.charCodeAt(pos); pos < end && (!isLineBreak(ch) && ch !== 96 /* backtick */); ch = codePointAt(text, ++pos)) {
+    for (let ch = charCodeUnchecked(pos); pos < end && (!isLineBreak(ch) && ch !== 96 /* backtick */); ch = codePointUnchecked(++pos)) {
       if (!inBackticks) {
         if (ch === 123 /* openBrace */) {
           break;
-        } else if (ch === 64 /* at */ && pos - 1 >= 0 && isWhiteSpaceSingleLine(text.charCodeAt(pos - 1)) && !(pos + 1 < end && isWhiteSpaceLike(text.charCodeAt(pos + 1)))) {
+        } else if (ch === 64 /* at */ && pos - 1 >= 0 && isWhiteSpaceSingleLine(charCodeUnchecked(pos - 1)) && !(pos + 1 < end && isWhiteSpaceLike(charCodeUnchecked(pos + 1)))) {
           break;
         }
       }
@@ -10866,21 +10903,21 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     if (pos >= end) {
       return token = 1 /* EndOfFileToken */;
     }
-    const ch = codePointAt(text, pos);
+    const ch = codePointUnchecked(pos);
     pos += charSize(ch);
     switch (ch) {
       case 9 /* tab */:
       case 11 /* verticalTab */:
       case 12 /* formFeed */:
       case 32 /* space */:
-        while (pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos))) {
+        while (pos < end && isWhiteSpaceSingleLine(charCodeUnchecked(pos))) {
           pos++;
         }
         return token = 5 /* WhitespaceTrivia */;
       case 64 /* at */:
         return token = 60 /* AtToken */;
       case 13 /* carriageReturn */:
-        if (text.charCodeAt(pos) === 10 /* lineFeed */) {
+        if (charCodeUnchecked(pos) === 10 /* lineFeed */) {
           pos++;
         }
       case 10 /* lineFeed */:
@@ -10936,7 +10973,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     }
     if (isIdentifierStart(ch, languageVersion)) {
       let char = ch;
-      while (pos < end && isIdentifierPart(char = codePointAt(text, pos), languageVersion) || text.charCodeAt(pos) === 45 /* minus */)
+      while (pos < end && isIdentifierPart(char = codePointUnchecked(pos), languageVersion) || char === 45 /* minus */)
         pos += charSize(char);
       tokenValue = text.substring(tokenStart, pos);
       if (char === 92 /* backslash */) {
@@ -11046,6 +11083,9 @@ function charSize(ch) {
   if (ch >= 65536) {
     return 2;
   }
+  if (ch === -1 /* EOF */) {
+    return 0;
+  }
   return 1;
 }
 function utf16EncodeAsStringFallback(codePoint) {
@@ -44084,7 +44124,7 @@ function createBinder() {
       const reportError = (
         // report error on all statements except empty ones
         isStatementButNotDeclaration(node) && node.kind !== 242 /* EmptyStatement */ || // report error on class declarations
-        node.kind === 263 /* ClassDeclaration */ || // report error on instantiated modules or const-enums only modules if preserveConstEnums is set
+        node.kind === 263 /* ClassDeclaration */ || node.kind === 266 /* EnumDeclaration */ && (!isEnumConst(node) || shouldPreserveConstEnums(options)) || // report error on instantiated modules or const-enums only modules if preserveConstEnums is set
         node.kind === 267 /* ModuleDeclaration */ && shouldReportErrorOnModuleDeclaration(node)
       );
       if (reportError) {
@@ -45523,6 +45563,7 @@ function createTypeChecker(host) {
     getBaseTypes,
     getBaseTypeOfLiteralType,
     getWidenedType,
+    getWidenedLiteralType,
     getTypeFromTypeNode: (nodeIn) => {
       const node = getParseTreeNode(nodeIn, isTypeNode);
       return node ? getTypeFromTypeNode(node) : errorType;
@@ -48100,12 +48141,6 @@ function createTypeChecker(host) {
       }
     }
   }
-  function markConstEnumAliasAsReferenced(symbol) {
-    const links = getSymbolLinks(symbol);
-    if (!links.constEnumReferenced) {
-      links.constEnumReferenced = true;
-    }
-  }
   function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, dontResolveAlias) {
     if (entityName.kind === 80 /* Identifier */ && isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
       entityName = entityName.parent;
@@ -54807,7 +54842,7 @@ function createTypeChecker(host) {
         }
         type = anyType;
       }
-      links.type = type;
+      links.type ?? (links.type = type);
     }
     return links.type;
   }
@@ -54825,7 +54860,7 @@ function createTypeChecker(host) {
         }
         writeType = anyType;
       }
-      links.writeType = writeType || getTypeOfAccessors(symbol);
+      links.writeType ?? (links.writeType = writeType || getTypeOfAccessors(symbol));
     }
     return links.writeType;
   }
@@ -54902,10 +54937,10 @@ function createTypeChecker(host) {
         true
       );
       const declaredType = firstDefined(exportSymbol == null ? void 0 : exportSymbol.declarations, (d) => isExportAssignment(d) ? tryGetTypeFromEffectiveTypeNode(d) : void 0);
-      links.type = (exportSymbol == null ? void 0 : exportSymbol.declarations) && isDuplicatedCommonJSExport(exportSymbol.declarations) && symbol.declarations.length ? getFlowTypeFromCommonJSExport(exportSymbol) : isDuplicatedCommonJSExport(symbol.declarations) ? autoType : declaredType ? declaredType : getSymbolFlags(targetSymbol) & 111551 /* Value */ ? getTypeOfSymbol(targetSymbol) : errorType;
+      links.type ?? (links.type = (exportSymbol == null ? void 0 : exportSymbol.declarations) && isDuplicatedCommonJSExport(exportSymbol.declarations) && symbol.declarations.length ? getFlowTypeFromCommonJSExport(exportSymbol) : isDuplicatedCommonJSExport(symbol.declarations) ? autoType : declaredType ? declaredType : getSymbolFlags(targetSymbol) & 111551 /* Value */ ? getTypeOfSymbol(targetSymbol) : errorType);
       if (!popTypeResolution()) {
         reportCircularityError(exportSymbol ?? symbol);
-        return links.type = errorType;
+        return links.type ?? (links.type = errorType);
       }
     }
     return links.type;
@@ -55171,7 +55206,7 @@ function createTypeChecker(host) {
       }
       if (!popTypeResolution()) {
         error(type.symbol.valueDeclaration, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_base_expression, symbolToString(type.symbol));
-        return type.resolvedBaseConstructorType = errorType;
+        return type.resolvedBaseConstructorType ?? (type.resolvedBaseConstructorType = errorType);
       }
       if (!(baseConstructorType.flags & 1 /* Any */) && baseConstructorType !== nullWideningType && !isConstructorType(baseConstructorType)) {
         const err = error(baseTypeNode.expression, Diagnostics.Type_0_is_not_a_constructor_function_type, typeToString(baseConstructorType));
@@ -55188,9 +55223,9 @@ function createTypeChecker(host) {
             addRelatedInfo(err, createDiagnosticForNode(baseConstructorType.symbol.declarations[0], Diagnostics.Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1, symbolToString(baseConstructorType.symbol), typeToString(ctorReturn)));
           }
         }
-        return type.resolvedBaseConstructorType = errorType;
+        return type.resolvedBaseConstructorType ?? (type.resolvedBaseConstructorType = errorType);
       }
-      type.resolvedBaseConstructorType = baseConstructorType;
+      type.resolvedBaseConstructorType ?? (type.resolvedBaseConstructorType = baseConstructorType);
     }
     return type.resolvedBaseConstructorType;
   }
@@ -55431,7 +55466,7 @@ function createTypeChecker(host) {
           error(isNamedDeclaration(declaration) ? declaration.name || declaration : declaration, Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
         }
       }
-      links.declaredType = type;
+      links.declaredType ?? (links.declaredType = type);
     }
     return links.declaredType;
   }
@@ -56549,6 +56584,7 @@ function createTypeChecker(host) {
     }
   }
   function getTypeOfMappedSymbol(symbol) {
+    var _a;
     if (!symbol.links.type) {
       const mappedType = symbol.links.mappedType;
       if (!pushTypeResolution(symbol, 0 /* Type */)) {
@@ -56567,7 +56603,7 @@ function createTypeChecker(host) {
         error(currentNode, Diagnostics.Type_of_property_0_circularly_references_itself_in_mapped_type_1, symbolToString(symbol), typeToString(mappedType));
         type = errorType;
       }
-      symbol.links.type = type;
+      (_a = symbol.links).type ?? (_a.type = type);
     }
     return symbol.links.type;
   }
@@ -56920,7 +56956,7 @@ function createTypeChecker(host) {
           }
           result = circularConstraintType;
         }
-        t.immediateBaseConstraint = result || noConstraintType;
+        t.immediateBaseConstraint ?? (t.immediateBaseConstraint = result || noConstraintType);
       }
       return t.immediateBaseConstraint;
     }
@@ -57794,7 +57830,7 @@ function createTypeChecker(host) {
         }
         type = anyType;
       }
-      signature.resolvedReturnType = type;
+      signature.resolvedReturnType ?? (signature.resolvedReturnType = type);
     }
     return signature.resolvedReturnType;
   }
@@ -58140,9 +58176,9 @@ function createTypeChecker(host) {
       const node = type.node;
       const typeArguments = !node ? emptyArray : node.kind === 183 /* TypeReference */ ? concatenate(type.target.outerTypeParameters, getEffectiveTypeArguments(node, type.target.localTypeParameters)) : node.kind === 188 /* ArrayType */ ? [getTypeFromTypeNode(node.elementType)] : map(node.elements, getTypeFromTypeNode);
       if (popTypeResolution()) {
-        type.resolvedTypeArguments = type.mapper ? instantiateTypes(typeArguments, type.mapper) : typeArguments;
+        type.resolvedTypeArguments ?? (type.resolvedTypeArguments = type.mapper ? instantiateTypes(typeArguments, type.mapper) : typeArguments);
       } else {
-        type.resolvedTypeArguments = ((_b = type.target.localTypeParameters) == null ? void 0 : _b.map(() => errorType)) || emptyArray;
+        type.resolvedTypeArguments ?? (type.resolvedTypeArguments = ((_b = type.target.localTypeParameters) == null ? void 0 : _b.map(() => errorType)) || emptyArray);
         error(
           type.node || currentNode,
           type.target.symbol ? Diagnostics.Type_arguments_for_0_circularly_reference_themselves : Diagnostics.Tuple_type_arguments_circularly_reference_themselves,
@@ -65199,6 +65235,7 @@ function createTypeChecker(host) {
     if (!links.variances) {
       (_a = tracing) == null ? void 0 : _a.push(tracing.Phase.CheckTypes, "getVariancesWorker", { arity: typeParameters.length, id: getTypeId(getDeclaredTypeOfSymbol(symbol)) });
       const oldVarianceComputation = inVarianceComputation;
+      const saveResolutionStart = resolutionStart;
       if (!inVarianceComputation) {
         inVarianceComputation = true;
         resolutionStart = resolutionTargets.length;
@@ -65233,7 +65270,7 @@ function createTypeChecker(host) {
       }
       if (!oldVarianceComputation) {
         inVarianceComputation = false;
-        resolutionStart = 0;
+        resolutionStart = saveResolutionStart;
       }
       links.variances = variances;
       (_b = tracing) == null ? void 0 : _b.pop({ variances: variances.map(Debug.formatVariance) });
@@ -69426,7 +69463,7 @@ function createTypeChecker(host) {
         reportCircularityError(declaration.symbol);
         return true;
       }
-      links.parameterInitializerContainsUndefined = containsUndefined;
+      links.parameterInitializerContainsUndefined ?? (links.parameterInitializerContainsUndefined = containsUndefined);
     }
     return links.parameterInitializerContainsUndefined;
   }
@@ -69488,8 +69525,6 @@ function createTypeChecker(host) {
       ) & (111551 /* Value */ | 1048576 /* ExportValue */)) {
         if (getIsolatedModules(compilerOptions) || shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(location) || !isConstEnumOrConstEnumOnlyModule(getExportSymbolOfValueSymbolIfExported(target))) {
           markAliasSymbolAsReferenced(symbol);
-        } else {
-          markConstEnumAliasAsReferenced(symbol);
         }
       }
     }
@@ -70746,60 +70781,71 @@ function createTypeChecker(host) {
     return false;
   }
   function discriminateContextualTypeByObjectMembers(node, contextualType) {
-    return getMatchingUnionConstituentForObjectLiteral(contextualType, node) || discriminateTypeByDiscriminableItems(
-      contextualType,
-      concatenate(
-        map(
-          filter(node.properties, (p) => {
-            if (!p.symbol) {
+    const key = `D${getNodeId(node)},${getTypeId(contextualType)}`;
+    return getCachedType(key) ?? setCachedType(
+      key,
+      getMatchingUnionConstituentForObjectLiteral(contextualType, node) ?? discriminateTypeByDiscriminableItems(
+        contextualType,
+        concatenate(
+          map(
+            filter(node.properties, (p) => {
+              if (!p.symbol) {
+                return false;
+              }
+              if (p.kind === 303 /* PropertyAssignment */) {
+                return isPossiblyDiscriminantValue(p.initializer) && isDiscriminantProperty(contextualType, p.symbol.escapedName);
+              }
+              if (p.kind === 304 /* ShorthandPropertyAssignment */) {
+                return isDiscriminantProperty(contextualType, p.symbol.escapedName);
+              }
               return false;
-            }
-            if (p.kind === 303 /* PropertyAssignment */) {
-              return isPossiblyDiscriminantValue(p.initializer) && isDiscriminantProperty(contextualType, p.symbol.escapedName);
-            }
-            if (p.kind === 304 /* ShorthandPropertyAssignment */) {
-              return isDiscriminantProperty(contextualType, p.symbol.escapedName);
-            }
-            return false;
-          }),
-          (prop) => [() => getContextFreeTypeOfExpression(prop.kind === 303 /* PropertyAssignment */ ? prop.initializer : prop.name), prop.symbol.escapedName]
+            }),
+            (prop) => [() => getContextFreeTypeOfExpression(prop.kind === 303 /* PropertyAssignment */ ? prop.initializer : prop.name), prop.symbol.escapedName]
+          ),
+          map(
+            filter(getPropertiesOfType(contextualType), (s) => {
+              var _a;
+              return !!(s.flags & 16777216 /* Optional */) && !!((_a = node == null ? void 0 : node.symbol) == null ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName);
+            }),
+            (s) => [() => undefinedType, s.escapedName]
+          )
         ),
-        map(
-          filter(getPropertiesOfType(contextualType), (s) => {
-            var _a;
-            return !!(s.flags & 16777216 /* Optional */) && !!((_a = node == null ? void 0 : node.symbol) == null ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName);
-          }),
-          (s) => [() => undefinedType, s.escapedName]
-        )
-      ),
-      isTypeAssignableTo
+        isTypeAssignableTo
+      )
     );
   }
   function discriminateContextualTypeByJSXAttributes(node, contextualType) {
+    const key = `D${getNodeId(node)},${getTypeId(contextualType)}`;
+    const cached = getCachedType(key);
+    if (cached)
+      return cached;
     const jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
-    return discriminateTypeByDiscriminableItems(
-      contextualType,
-      concatenate(
-        map(
-          filter(node.properties, (p) => !!p.symbol && p.kind === 291 /* JsxAttribute */ && isDiscriminantProperty(contextualType, p.symbol.escapedName) && (!p.initializer || isPossiblyDiscriminantValue(p.initializer))),
-          (prop) => [!prop.initializer ? () => trueType : () => getContextFreeTypeOfExpression(prop.initializer), prop.symbol.escapedName]
+    return setCachedType(
+      key,
+      discriminateTypeByDiscriminableItems(
+        contextualType,
+        concatenate(
+          map(
+            filter(node.properties, (p) => !!p.symbol && p.kind === 291 /* JsxAttribute */ && isDiscriminantProperty(contextualType, p.symbol.escapedName) && (!p.initializer || isPossiblyDiscriminantValue(p.initializer))),
+            (prop) => [!prop.initializer ? () => trueType : () => getContextFreeTypeOfExpression(prop.initializer), prop.symbol.escapedName]
+          ),
+          map(
+            filter(getPropertiesOfType(contextualType), (s) => {
+              var _a;
+              if (!(s.flags & 16777216 /* Optional */) || !((_a = node == null ? void 0 : node.symbol) == null ? void 0 : _a.members)) {
+                return false;
+              }
+              const element = node.parent.parent;
+              if (s.escapedName === jsxChildrenPropertyName && isJsxElement(element) && getSemanticJsxChildren(element.children).length) {
+                return false;
+              }
+              return !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName);
+            }),
+            (s) => [() => undefinedType, s.escapedName]
+          )
         ),
-        map(
-          filter(getPropertiesOfType(contextualType), (s) => {
-            var _a;
-            if (!(s.flags & 16777216 /* Optional */) || !((_a = node == null ? void 0 : node.symbol) == null ? void 0 : _a.members)) {
-              return false;
-            }
-            const element = node.parent.parent;
-            if (s.escapedName === jsxChildrenPropertyName && isJsxElement(element) && getSemanticJsxChildren(element.children).length) {
-              return false;
-            }
-            return !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName);
-          }),
-          (s) => [() => undefinedType, s.escapedName]
-        )
-      ),
-      isTypeAssignableTo
+        isTypeAssignableTo
+      )
     );
   }
   function getApparentTypeOfContextualType(node, contextFlags) {
@@ -71233,7 +71279,7 @@ function createTypeChecker(host) {
   }
   function checkGrammarRegularExpressionLiteral(node) {
     const sourceFile = getSourceFileOfNode(node);
-    if (!hasParseDiagnostics(sourceFile)) {
+    if (!hasParseDiagnostics(sourceFile) && !node.isUnterminated) {
       let lastError;
       scanner ?? (scanner = createScanner(
         99 /* ESNext */,
@@ -74835,8 +74881,13 @@ function createTypeChecker(host) {
     if (cached && cached !== resolvingSignature && !candidatesOutArray) {
       return cached;
     }
+    const saveResolutionStart = resolutionStart;
+    if (!cached) {
+      resolutionStart = resolutionTargets.length;
+    }
     links.resolvedSignature = resolvingSignature;
     let result = resolveSignature(node, candidatesOutArray, checkMode || 0 /* Normal */);
+    resolutionStart = saveResolutionStart;
     if (result !== resolvingSignature) {
       if (links.resolvedSignature !== resolvingSignature) {
         result = links.resolvedSignature;
@@ -118968,6 +119019,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   const createProgramOptions = isArray(rootNamesOrOptions) ? createCreateProgramOptions(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) : rootNamesOrOptions;
   const { rootNames, options, configFileParsingDiagnostics, projectReferences, typeScriptVersion: typeScriptVersion2 } = createProgramOptions;
   let { oldProgram } = createProgramOptions;
+  const reportInvalidIgnoreDeprecations = memoize(() => createOptionValueDiagnostic("ignoreDeprecations", Diagnostics.Invalid_value_for_ignoreDeprecations));
   let processingDefaultLibFiles;
   let processingOtherFiles;
   let files;
@@ -119254,7 +119306,6 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   resolvedLibProcessing = void 0;
   resolvedModulesProcessing = void 0;
   resolvedTypeReferenceDirectiveNamesProcessing = void 0;
-  let ignoreDeprecationsVersion;
   const program = {
     getRootFileNames: () => rootNames,
     getSourceFile,
@@ -121506,26 +121557,22 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     }
   }
   function getIgnoreDeprecationsVersion() {
-    if (!ignoreDeprecationsVersion) {
-      ignoreDeprecationsVersion = Version.zero;
-      const ignoreDeprecations = options.ignoreDeprecations;
-      if (ignoreDeprecations) {
-        if (ignoreDeprecations === "5.0") {
-          ignoreDeprecationsVersion = new Version(ignoreDeprecations);
-        } else {
-          createOptionValueDiagnostic("ignoreDeprecations", Diagnostics.Invalid_value_for_ignoreDeprecations);
-        }
+    const ignoreDeprecations = options.ignoreDeprecations;
+    if (ignoreDeprecations) {
+      if (ignoreDeprecations === "5.0") {
+        return new Version(ignoreDeprecations);
       }
+      reportInvalidIgnoreDeprecations();
     }
-    return ignoreDeprecationsVersion;
+    return Version.zero;
   }
   function checkDeprecations(deprecatedIn, removedIn, createDiagnostic, fn) {
     const deprecatedInVersion = new Version(deprecatedIn);
     const removedInVersion = new Version(removedIn);
     const typescriptVersion = new Version(typeScriptVersion2 || versionMajorMinor);
-    const ignoreDeprecationsVersion2 = getIgnoreDeprecationsVersion();
+    const ignoreDeprecationsVersion = getIgnoreDeprecationsVersion();
     const mustBeRemoved = !(removedInVersion.compareTo(typescriptVersion) === 1 /* GreaterThan */);
-    const canBeSilenced = !mustBeRemoved && ignoreDeprecationsVersion2.compareTo(deprecatedInVersion) === -1 /* LessThan */;
+    const canBeSilenced = !mustBeRemoved && ignoreDeprecationsVersion.compareTo(deprecatedInVersion) === -1 /* LessThan */;
     if (mustBeRemoved || canBeSilenced) {
       fn((name, value, useInstead) => {
         if (mustBeRemoved) {