@typescript-deploys/pr-build 5.1.0-pr-53489-6 → 5.1.0-pr-53225-3

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-insiders.20230324`;
+var version = `${versionMajorMinor}.0-insiders.20230327`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -5746,7 +5746,6 @@ var Diagnostics = {
   _0_modifier_cannot_appear_on_an_index_signature: diag(1071, 1 /* Error */, "_0_modifier_cannot_appear_on_an_index_signature_1071", "'{0}' modifier cannot appear on an index signature."),
   A_0_modifier_cannot_be_used_with_an_import_declaration: diag(1079, 1 /* Error */, "A_0_modifier_cannot_be_used_with_an_import_declaration_1079", "A '{0}' modifier cannot be used with an import declaration."),
   Invalid_reference_directive_syntax: diag(1084, 1 /* Error */, "Invalid_reference_directive_syntax_1084", "Invalid 'reference' directive syntax."),
-  Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0: diag(1085, 1 /* Error */, "Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0_1085", "Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '{0}'."),
   _0_modifier_cannot_appear_on_a_constructor_declaration: diag(1089, 1 /* Error */, "_0_modifier_cannot_appear_on_a_constructor_declaration_1089", "'{0}' modifier cannot appear on a constructor declaration."),
   _0_modifier_cannot_appear_on_a_parameter: diag(1090, 1 /* Error */, "_0_modifier_cannot_appear_on_a_parameter_1090", "'{0}' modifier cannot appear on a parameter."),
   Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement: diag(1091, 1 /* Error */, "Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement_1091", "Only a single variable declaration is allowed in a 'for...in' statement."),
@@ -5777,7 +5776,7 @@ var Diagnostics = {
   An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name: diag(1118, 1 /* Error */, "An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name_1118", "An object literal cannot have multiple get/set accessors with the same name."),
   An_object_literal_cannot_have_property_and_accessor_with_the_same_name: diag(1119, 1 /* Error */, "An_object_literal_cannot_have_property_and_accessor_with_the_same_name_1119", "An object literal cannot have property and accessor with the same name."),
   An_export_assignment_cannot_have_modifiers: diag(1120, 1 /* Error */, "An_export_assignment_cannot_have_modifiers_1120", "An export assignment cannot have modifiers."),
-  Octal_literals_are_not_allowed_in_strict_mode: diag(1121, 1 /* Error */, "Octal_literals_are_not_allowed_in_strict_mode_1121", "Octal literals are not allowed in strict mode."),
+  Octal_literals_are_not_allowed_Use_the_syntax_0: diag(1121, 1 /* Error */, "Octal_literals_are_not_allowed_Use_the_syntax_0_1121", "Octal literals are not allowed. Use the syntax '{0}'."),
   Variable_declaration_list_cannot_be_empty: diag(1123, 1 /* Error */, "Variable_declaration_list_cannot_be_empty_1123", "Variable declaration list cannot be empty."),
   Digit_expected: diag(1124, 1 /* Error */, "Digit_expected_1124", "Digit expected."),
   Hexadecimal_digit_expected: diag(1125, 1 /* Error */, "Hexadecimal_digit_expected_1125", "Hexadecimal digit expected."),
@@ -6088,6 +6087,9 @@ var Diagnostics = {
   _0_is_a_type_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled: diag(1484, 1 /* Error */, "_0_is_a_type_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled_1484", "'{0}' is a type and must be imported using a type-only import when 'verbatimModuleSyntax' is enabled."),
   _0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_verbatimModuleSyntax_is_enabled: diag(1485, 1 /* Error */, "_0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_verbatimMo_1485", "'{0}' resolves to a type-only declaration and must be imported using a type-only import when 'verbatimModuleSyntax' is enabled."),
   Decorator_used_before_export_here: diag(1486, 1 /* Error */, "Decorator_used_before_export_here_1486", "Decorator used before 'export' here."),
+  Octal_escape_sequences_are_not_allowed_Use_the_syntax_0: diag(1487, 1 /* Error */, "Octal_escape_sequences_are_not_allowed_Use_the_syntax_0_1487", "Octal escape sequences are not allowed. Use the syntax '{0}'."),
+  Escape_sequence_0_is_not_allowed: diag(1488, 1 /* Error */, "Escape_sequence_0_is_not_allowed_1488", "Escape sequence '{0}' is not allowed."),
+  Decimals_with_leading_zeros_are_not_allowed: diag(1489, 1 /* Error */, "Decimals_with_leading_zeros_are_not_allowed_1489", "Decimals with leading zeros are not allowed."),
   The_types_of_0_are_incompatible_between_these_types: diag(2200, 1 /* Error */, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."),
   The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, 1 /* Error */, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."),
   Call_signature_return_types_0_and_1_are_incompatible: diag(
@@ -7428,8 +7430,6 @@ var Diagnostics = {
   Parameter_modifiers_can_only_be_used_in_TypeScript_files: diag(8012, 1 /* Error */, "Parameter_modifiers_can_only_be_used_in_TypeScript_files_8012", "Parameter modifiers can only be used in TypeScript files."),
   Non_null_assertions_can_only_be_used_in_TypeScript_files: diag(8013, 1 /* Error */, "Non_null_assertions_can_only_be_used_in_TypeScript_files_8013", "Non-null assertions can only be used in TypeScript files."),
   Type_assertion_expressions_can_only_be_used_in_TypeScript_files: diag(8016, 1 /* Error */, "Type_assertion_expressions_can_only_be_used_in_TypeScript_files_8016", "Type assertion expressions can only be used in TypeScript files."),
-  Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0: diag(8017, 1 /* Error */, "Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0_8017", "Octal literal types must use ES2015 syntax. Use the syntax '{0}'."),
-  Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0: diag(8018, 1 /* Error */, "Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0_8018", "Octal literals are not allowed in enums members initializer. Use the syntax '{0}'."),
   Report_errors_in_js_files: diag(8019, 3 /* Message */, "Report_errors_in_js_files_8019", "Report errors in .js files."),
   JSDoc_types_can_only_be_used_inside_documentation_comments: diag(8020, 1 /* Error */, "JSDoc_types_can_only_be_used_inside_documentation_comments_8020", "JSDoc types can only be used inside documentation comments."),
   JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags: diag(8021, 1 /* Error */, "JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags_8021", "JSDoc '@typedef' tag should either have a type annotation or be followed by '@property' or '@member' tags."),
@@ -8411,7 +8411,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     isReservedWord: () => token >= 82 /* FirstReservedWord */ && token <= 117 /* LastReservedWord */,
     isUnterminated: () => (tokenFlags & 4 /* Unterminated */) !== 0,
     getCommentDirectives: () => commentDirectives,
-    getNumericLiteralFlags: () => tokenFlags & 1008 /* NumericLiteralFlags */,
+    getNumericLiteralFlags: () => tokenFlags & 25584 /* NumericLiteralFlags */,
     getTokenFlags: () => tokenFlags,
     reScanGreaterToken,
     reScanAsteriskEqualsToken,
@@ -8452,11 +8452,11 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     });
   }
   return scanner;
-  function error(message, errPos = pos, length3) {
+  function error(message, errPos = pos, length3, arg0) {
     if (onError) {
       const oldPos = pos;
       pos = errPos;
-      onError(message, length3 || 0);
+      onError(message, length3 || 0, arg0);
       pos = oldPos;
     }
   }
@@ -8473,10 +8473,13 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           allowSeparator = false;
           isPreviousTokenSeparator = true;
           result += text.substring(start2, pos);
-        } else if (isPreviousTokenSeparator) {
-          error(Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1);
         } else {
-          error(Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1);
+          tokenFlags |= 16384 /* ContainsInvalidSeparator */;
+          if (isPreviousTokenSeparator) {
+            error(Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1);
+          } else {
+            error(Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1);
+          }
         }
         pos++;
         start2 = pos;
@@ -8491,13 +8494,39 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       break;
     }
     if (text.charCodeAt(pos - 1) === 95 /* _ */) {
+      tokenFlags |= 16384 /* ContainsInvalidSeparator */;
       error(Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1);
     }
     return result + text.substring(start2, pos);
   }
   function scanNumber() {
-    const start2 = pos;
-    const mainFragment = scanNumberFragment();
+    let start2 = pos;
+    let mainFragment;
+    if (text.charCodeAt(pos) === 48 /* _0 */) {
+      pos++;
+      if (text.charCodeAt(pos) === 95 /* _ */) {
+        tokenFlags |= 512 /* ContainsSeparator */ | 16384 /* ContainsInvalidSeparator */;
+        error(Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1);
+        pos--;
+        mainFragment = scanNumberFragment();
+      } else if (!scanDigits()) {
+        tokenFlags |= 8192 /* ContainsLeadingZero */;
+        mainFragment = "" + +tokenValue;
+      } else if (!tokenValue) {
+        mainFragment = "0";
+      } else {
+        tokenValue = "" + parseInt(tokenValue, 8);
+        tokenFlags |= 32 /* Octal */;
+        const withMinus = token === 40 /* MinusToken */;
+        const literal = (withMinus ? "-" : "") + "0o" + (+tokenValue).toString(8);
+        if (withMinus)
+          start2--;
+        error(Diagnostics.Octal_literals_are_not_allowed_Use_the_syntax_0, start2, pos - start2, literal);
+        return { type: 8 /* NumericLiteral */, value: tokenValue };
+      }
+    } else {
+      mainFragment = scanNumberFragment();
+    }
     let decimalFragment;
     let scientificFragment;
     if (text.charCodeAt(pos) === 46 /* dot */) {
@@ -8531,6 +8560,10 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     } else {
       result = text.substring(start2, end2);
     }
+    if (tokenFlags & 8192 /* ContainsLeadingZero */) {
+      error(Diagnostics.Decimals_with_leading_zeros_are_not_allowed, start2, end2 - start2);
+      return { type: 8 /* NumericLiteral */, value: "" + +result };
+    }
     if (decimalFragment !== void 0 || tokenFlags & 16 /* Scientific */) {
       checkForIdentifierStartAfterNumericLiteral(start2, decimalFragment === void 0 && !!(tokenFlags & 16 /* Scientific */));
       return {
@@ -8562,12 +8595,17 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       pos = identifierStart;
     }
   }
-  function scanOctalDigits() {
+  function scanDigits() {
     const start2 = pos;
-    while (isOctalDigit(text.charCodeAt(pos))) {
+    let isOctal = true;
+    while (isDigit(text.charCodeAt(pos))) {
+      if (!isOctalDigit(text.charCodeAt(pos))) {
+        isOctal = false;
+      }
       pos++;
     }
-    return +text.substring(start2, pos);
+    tokenValue = text.substring(start2, pos);
+    return isOctal;
   }
   function scanExactNumberOfHexDigits(count, canHaveSeparators) {
     const valueString = scanHexDigits(
@@ -8645,7 +8683,10 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       }
       if (ch === 92 /* backslash */ && !jsxAttributeString) {
         result += text.substring(start2, pos);
-        result += scanEscapeSequence();
+        result += scanEscapeSequence(
+          /*shouldEmitInvalidEscapeError*/
+          true
+        );
         start2 = pos;
         continue;
       }
@@ -8659,7 +8700,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     }
     return result;
   }
-  function scanTemplateAndSetTokenValue(isTaggedTemplate) {
+  function scanTemplateAndSetTokenValue(shouldEmitInvalidEscapeError) {
     const startedWithBacktick = text.charCodeAt(pos) === 96 /* backtick */;
     pos++;
     let start2 = pos;
@@ -8688,7 +8729,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       }
       if (currChar === 92 /* backslash */) {
         contents += text.substring(start2, pos);
-        contents += scanEscapeSequence(isTaggedTemplate);
+        contents += scanEscapeSequence(shouldEmitInvalidEscapeError);
         start2 = pos;
         continue;
       }
@@ -8708,7 +8749,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     tokenValue = contents;
     return resultingToken;
   }
-  function scanEscapeSequence(isTaggedTemplate) {
+  function scanEscapeSequence(shouldEmitInvalidEscapeError) {
     const start2 = pos;
     pos++;
     if (pos >= end) {
@@ -8719,12 +8760,37 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     pos++;
     switch (ch) {
       case 48 /* _0 */:
-        if (isTaggedTemplate && pos < end && isDigit(text.charCodeAt(pos))) {
+        if (pos >= end || !isDigit(text.charCodeAt(pos))) {
+          return "\0";
+        }
+      case 49 /* _1 */:
+      case 50 /* _2 */:
+      case 51 /* _3 */:
+        if (pos < end && isOctalDigit(text.charCodeAt(pos))) {
           pos++;
-          tokenFlags |= 2048 /* ContainsInvalidEscape */;
-          return text.substring(start2, pos);
         }
-        return "\0";
+      case 52 /* _4 */:
+      case 53 /* _5 */:
+      case 54 /* _6 */:
+      case 55 /* _7 */:
+        if (pos < end && isOctalDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        tokenFlags |= 2048 /* ContainsInvalidEscape */;
+        if (shouldEmitInvalidEscapeError) {
+          const code = parseInt(text.substring(start2 + 1, pos), 8);
+          error(Diagnostics.Octal_escape_sequences_are_not_allowed_Use_the_syntax_0, start2, pos - start2, "\\x" + padLeft(code.toString(16), 2, "0"));
+          return String.fromCharCode(code);
+        }
+        return text.substring(start2, pos);
+      case 56 /* _8 */:
+      case 57 /* _9 */:
+        tokenFlags |= 2048 /* ContainsInvalidEscape */;
+        if (shouldEmitInvalidEscapeError) {
+          error(Diagnostics.Escape_sequence_0_is_not_allowed, start2, pos - start2, text.substring(start2, pos));
+          return String.fromCharCode(ch);
+        }
+        return text.substring(start2, pos);
       case 98 /* b */:
         return "\b";
       case 116 /* t */:
@@ -8742,59 +8808,69 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       case 34 /* doubleQuote */:
         return '"';
       case 117 /* u */:
-        if (isTaggedTemplate) {
-          for (let escapePos = pos; escapePos < pos + 4; escapePos++) {
-            if (escapePos < end && !isHexDigit(text.charCodeAt(escapePos)) && text.charCodeAt(escapePos) !== 123 /* openBrace */) {
-              pos = escapePos;
-              tokenFlags |= 2048 /* ContainsInvalidEscape */;
-              return text.substring(start2, pos);
-            }
-          }
-        }
         if (pos < end && text.charCodeAt(pos) === 123 /* openBrace */) {
           pos++;
-          if (isTaggedTemplate && !isHexDigit(text.charCodeAt(pos))) {
+          const escapedValueString = scanMinimumNumberOfHexDigits(
+            1,
+            /*canHaveSeparators*/
+            false
+          );
+          const escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1;
+          if (escapedValue < 0) {
             tokenFlags |= 2048 /* ContainsInvalidEscape */;
+            if (shouldEmitInvalidEscapeError) {
+              error(Diagnostics.Hexadecimal_digit_expected);
+            }
             return text.substring(start2, pos);
           }
-          if (isTaggedTemplate) {
-            const savePos = pos;
-            const escapedValueString = scanMinimumNumberOfHexDigits(
-              1,
-              /*canHaveSeparators*/
-              false
-            );
-            const escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1;
-            if (!isCodePoint(escapedValue) || text.charCodeAt(pos) !== 125 /* closeBrace */) {
-              tokenFlags |= 2048 /* ContainsInvalidEscape */;
-              return text.substring(start2, pos);
-            } else {
-              pos = savePos;
+          if (!isCodePoint(escapedValue)) {
+            tokenFlags |= 2048 /* ContainsInvalidEscape */;
+            if (shouldEmitInvalidEscapeError) {
+              error(Diagnostics.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive);
             }
+            return text.substring(start2, pos);
           }
+          if (pos >= end) {
+            tokenFlags |= 2048 /* ContainsInvalidEscape */;
+            if (shouldEmitInvalidEscapeError) {
+              error(Diagnostics.Unexpected_end_of_text);
+            }
+            return text.substring(start2, pos);
+          }
+          if (text.charCodeAt(pos) !== 125 /* closeBrace */) {
+            tokenFlags |= 2048 /* ContainsInvalidEscape */;
+            if (shouldEmitInvalidEscapeError) {
+              error(Diagnostics.Unterminated_Unicode_escape_sequence);
+            }
+            return text.substring(start2, pos);
+          }
+          pos++;
           tokenFlags |= 8 /* ExtendedUnicodeEscape */;
-          return scanExtendedUnicodeEscape();
+          return utf16EncodeAsString(escapedValue);
         }
-        tokenFlags |= 1024 /* UnicodeEscape */;
-        return scanHexadecimalEscape(
-          /*numDigits*/
-          4
-        );
-      case 120 /* x */:
-        if (isTaggedTemplate) {
-          if (!isHexDigit(text.charCodeAt(pos))) {
+        for (; pos < start2 + 6; pos++) {
+          if (!(pos < end && isHexDigit(text.charCodeAt(pos)))) {
             tokenFlags |= 2048 /* ContainsInvalidEscape */;
+            if (shouldEmitInvalidEscapeError) {
+              error(Diagnostics.Hexadecimal_digit_expected);
+            }
             return text.substring(start2, pos);
-          } else if (!isHexDigit(text.charCodeAt(pos + 1))) {
-            pos++;
+          }
+        }
+        tokenFlags |= 1024 /* UnicodeEscape */;
+        return String.fromCharCode(parseInt(text.substring(start2 + 2, pos), 16));
+      case 120 /* x */:
+        for (; pos < start2 + 4; pos++) {
+          if (!(pos < end && isHexDigit(text.charCodeAt(pos)))) {
             tokenFlags |= 2048 /* ContainsInvalidEscape */;
+            if (shouldEmitInvalidEscapeError) {
+              error(Diagnostics.Hexadecimal_digit_expected);
+            }
             return text.substring(start2, pos);
           }
         }
-        return scanHexadecimalEscape(
-          /*numDigits*/
-          2
-        );
+        tokenFlags |= 4096 /* HexEscape */;
+        return String.fromCharCode(parseInt(text.substring(start2 + 2, pos), 16));
       case 13 /* carriageReturn */:
         if (pos < end && text.charCodeAt(pos) === 10 /* lineFeed */) {
           pos++;
@@ -8807,19 +8883,6 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         return String.fromCharCode(ch);
     }
   }
-  function scanHexadecimalEscape(numDigits) {
-    const escapedValue = scanExactNumberOfHexDigits(
-      numDigits,
-      /*canHaveSeparators*/
-      false
-    );
-    if (escapedValue >= 0) {
-      return String.fromCharCode(escapedValue);
-    } else {
-      error(Diagnostics.Hexadecimal_digit_expected);
-      return "";
-    }
-  }
   function scanExtendedUnicodeEscape() {
     const escapedValueString = scanMinimumNumberOfHexDigits(
       1,
@@ -9048,7 +9111,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           return token = 10 /* StringLiteral */;
         case 96 /* backtick */:
           return token = scanTemplateAndSetTokenValue(
-            /*isTaggedTemplate*/
+            /*shouldEmitInvalidEscapeError*/
             false
           );
         case 37 /* percent */:
@@ -9223,11 +9286,6 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             tokenFlags |= 256 /* OctalSpecifier */;
             return token = checkBigIntSuffix();
           }
-          if (pos + 1 < end && isOctalDigit(text.charCodeAt(pos + 1))) {
-            tokenValue = "" + scanOctalDigits();
-            tokenFlags |= 32 /* Octal */;
-            return token = 8 /* NumericLiteral */;
-          }
         case 49 /* _1 */:
         case 50 /* _2 */:
         case 51 /* _3 */:
@@ -9544,14 +9602,13 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     return void 0;
   }
   function reScanTemplateToken(isTaggedTemplate) {
-    Debug.assert(token === 19 /* CloseBraceToken */, "'reScanTemplateToken' should only be called on a '}'");
     pos = tokenStart;
-    return token = scanTemplateAndSetTokenValue(isTaggedTemplate);
+    return token = scanTemplateAndSetTokenValue(!isTaggedTemplate);
   }
   function reScanTemplateHeadOrNoSubstitutionTemplate() {
     pos = tokenStart;
     return token = scanTemplateAndSetTokenValue(
-      /*isTaggedTemplate*/
+      /*shouldEmitInvalidEscapeError*/
       true
     );
   }
@@ -12041,8 +12098,13 @@ function canUseOriginalText(node, flags) {
   if (nodeIsSynthesized(node) || !node.parent || flags & 4 /* TerminateUnterminatedLiterals */ && node.isUnterminated) {
     return false;
   }
-  if (isNumericLiteral(node) && node.numericLiteralFlags & 512 /* ContainsSeparator */) {
-    return !!(flags & 8 /* AllowNumericSeparator */);
+  if (isNumericLiteral(node)) {
+    if (node.numericLiteralFlags & 26656 /* IsInvalid */) {
+      return false;
+    }
+    if (node.numericLiteralFlags & 512 /* ContainsSeparator */) {
+      return !!(flags & 8 /* AllowNumericSeparator */);
+    }
   }
   return !isBigIntLiteral(node);
 }
@@ -12558,15 +12620,6 @@ function isPartOfTypeNode(node) {
   }
   return false;
 }
-function isChildOfNodeWithKind(node, kind) {
-  while (node) {
-    if (node.kind === kind) {
-      return true;
-    }
-    node = node.parent;
-  }
-  return false;
-}
 function forEachReturnStatement(body, visitor) {
   return traverse(body);
   function traverse(node) {
@@ -19824,7 +19877,7 @@ function createNodeFactory(flags, baseFactory2) {
     return node.head !== head || node.templateSpans !== templateSpans ? update(createTemplateExpression(head, templateSpans), node) : node;
   }
   function checkTemplateLiteralLikeNode(kind, text, rawText, templateFlags = 0 /* None */) {
-    Debug.assert(!(templateFlags & ~2048 /* TemplateLiteralLikeFlags */), "Unsupported template flags.");
+    Debug.assert(!(templateFlags & ~7176 /* TemplateLiteralLikeFlags */), "Unsupported template flags.");
     let cooked = void 0;
     if (rawText !== void 0 && rawText !== text) {
       cooked = getCookedText(kind, rawText);
@@ -19853,7 +19906,7 @@ function createNodeFactory(flags, baseFactory2) {
     const node = createBaseToken(kind);
     node.text = text;
     node.rawText = rawText;
-    node.templateFlags = templateFlags & 2048 /* TemplateLiteralLikeFlags */;
+    node.templateFlags = templateFlags & 7176 /* TemplateLiteralLikeFlags */;
     node.transformFlags = getTransformFlagsOfTemplateLiteralLike(node.templateFlags);
     return node;
   }
@@ -19861,7 +19914,7 @@ function createNodeFactory(flags, baseFactory2) {
     const node = createBaseDeclaration(kind);
     node.text = text;
     node.rawText = rawText;
-    node.templateFlags = templateFlags & 2048 /* TemplateLiteralLikeFlags */;
+    node.templateFlags = templateFlags & 7176 /* TemplateLiteralLikeFlags */;
     node.transformFlags = getTransformFlagsOfTemplateLiteralLike(node.templateFlags);
     return node;
   }
@@ -26526,8 +26579,8 @@ var Parser;
   function parseErrorAtRange(range, message, ...args) {
     parseErrorAt(range.pos, range.end, message, ...args);
   }
-  function scanError(message, length2) {
-    parseErrorAtPosition(scanner.getTokenEnd(), length2, message);
+  function scanError(message, length2, arg0) {
+    parseErrorAtPosition(scanner.getTokenEnd(), length2, message, arg0);
   }
   function getNodePos() {
     return scanner.getTokenFullStart();
@@ -26566,9 +26619,6 @@ var Parser;
   function reScanTemplateToken(isTaggedTemplate) {
     return currentToken = scanner.reScanTemplateToken(isTaggedTemplate);
   }
-  function reScanTemplateHeadOrNoSubstitutionTemplate() {
-    return currentToken = scanner.reScanTemplateHeadOrNoSubstitutionTemplate();
-  }
   function reScanLessThanToken() {
     return currentToken = scanner.reScanLessThanToken();
   }
@@ -27640,8 +27690,11 @@ var Parser;
     return parseLiteralLikeNode(token());
   }
   function parseTemplateHead(isTaggedTemplate) {
-    if (isTaggedTemplate) {
-      reScanTemplateHeadOrNoSubstitutionTemplate();
+    if (!isTaggedTemplate && scanner.getTokenFlags() & 26656 /* IsInvalid */) {
+      reScanTemplateToken(
+        /*isTaggedTemplate*/
+        false
+      );
     }
     const fragment = parseLiteralLikeNode(token());
     Debug.assert(fragment.kind === 15 /* TemplateHead */, "Template head has wrong token kind");
@@ -27659,8 +27712,7 @@ var Parser;
   }
   function parseLiteralLikeNode(kind) {
     const pos = getNodePos();
-    const node = isTemplateLiteralKind(kind) ? factory2.createTemplateLiteralLikeNode(kind, scanner.getTokenValue(), getTemplateLiteralRawText(kind), scanner.getTokenFlags() & 2048 /* TemplateLiteralLikeFlags */) : (
-      // Octal literals are not allowed in strict mode or ES5
+    const node = isTemplateLiteralKind(kind) ? factory2.createTemplateLiteralLikeNode(kind, scanner.getTokenValue(), getTemplateLiteralRawText(kind), scanner.getTokenFlags() & 7176 /* TemplateLiteralLikeFlags */) : (
       // Note that theoretically the following condition would hold true literals like 009,
       // which is not octal. But because of how the scanner separates the tokens, we would
       // never get a token like this. Instead, we would get 00 and 9 as two separate tokens.
@@ -29716,7 +29768,10 @@ var Parser;
     const tagExpression = factory2.createTaggedTemplateExpression(
       tag,
       typeArguments,
-      token() === 14 /* NoSubstitutionTemplateLiteral */ ? (reScanTemplateHeadOrNoSubstitutionTemplate(), parseLiteralNode()) : parseTemplateExpression(
+      token() === 14 /* NoSubstitutionTemplateLiteral */ ? (reScanTemplateToken(
+        /*isTaggedTemplate*/
+        true
+      ), parseLiteralNode()) : parseTemplateExpression(
         /*isTaggedTemplate*/
         true
       )
@@ -29804,10 +29859,16 @@ var Parser;
   }
   function parsePrimaryExpression() {
     switch (token()) {
+      case 14 /* NoSubstitutionTemplateLiteral */:
+        if (scanner.getTokenFlags() & 26656 /* IsInvalid */) {
+          reScanTemplateToken(
+            /*isTaggedTemplate*/
+            false
+          );
+        }
       case 8 /* NumericLiteral */:
       case 9 /* BigIntLiteral */:
       case 10 /* StringLiteral */:
-      case 14 /* NoSubstitutionTemplateLiteral */:
         return parseLiteralNode();
       case 109 /* ThisKeyword */:
       case 107 /* SuperKeyword */:
@@ -40414,11 +40475,6 @@ function createBinder() {
       }
     }
   }
-  function checkStrictModeNumericLiteral(node) {
-    if (languageVersion < 1 /* ES5 */ && inStrictMode && node.numericLiteralFlags & 32 /* Octal */) {
-      file.bindDiagnostics.push(createDiagnosticForNode2(node, Diagnostics.Octal_literals_are_not_allowed_in_strict_mode));
-    }
-  }
   function checkStrictModePostfixUnaryExpression(node) {
     if (inStrictMode) {
       checkStrictModeEvalOrArguments(node, node.operand);
@@ -40610,8 +40666,6 @@ function createBinder() {
         return checkStrictModeCatchClause(node);
       case 218 /* DeleteExpression */:
         return checkStrictModeDeleteExpression(node);
-      case 8 /* NumericLiteral */:
-        return checkStrictModeNumericLiteral(node);
       case 223 /* PostfixUnaryExpression */:
         return checkStrictModePostfixUnaryExpression(node);
       case 222 /* PrefixUnaryExpression */:
@@ -49858,6 +49912,7 @@ function createTypeChecker(host) {
         ), 0 /* None */);
       }
       function serializeMaybeAliasAssignment(symbol) {
+        var _a2;
         if (symbol.flags & 4194304 /* Prototype */) {
           return false;
         }
@@ -49937,7 +49992,7 @@ function createTypeChecker(host) {
                   void 0,
                   serializeTypeForDeclaration(context, typeToSerialize, symbol, enclosingDeclaration, includePrivateSymbol, bundled)
                 )
-              ], 2 /* Const */)
+              ], ((_a2 = context.enclosingDeclaration) == null ? void 0 : _a2.kind) === 265 /* ModuleDeclaration */ ? 1 /* Let */ : 2 /* Const */)
             );
             addResult(
               statement,
@@ -49973,7 +50028,7 @@ function createTypeChecker(host) {
           if (isStatic2 && p.flags & (788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */)) {
             return [];
           }
-          if (p.flags & 4194304 /* Prototype */ || baseType && getPropertyOfType(baseType, p.escapedName) && isReadonlySymbol(getPropertyOfType(baseType, p.escapedName)) === isReadonlySymbol(p) && (p.flags & 16777216 /* Optional */) === (getPropertyOfType(baseType, p.escapedName).flags & 16777216 /* Optional */) && isTypeIdenticalTo(getTypeOfSymbol(p), getTypeOfPropertyOfType(baseType, p.escapedName))) {
+          if (p.flags & 4194304 /* Prototype */ || p.escapedName === "constructor" || baseType && getPropertyOfType(baseType, p.escapedName) && isReadonlySymbol(getPropertyOfType(baseType, p.escapedName)) === isReadonlySymbol(p) && (p.flags & 16777216 /* Optional */) === (getPropertyOfType(baseType, p.escapedName).flags & 16777216 /* Optional */) && isTypeIdenticalTo(getTypeOfSymbol(p), getTypeOfPropertyOfType(baseType, p.escapedName))) {
             return [];
           }
           const flag = modifierFlags & ~512 /* Async */ | (isStatic2 ? 32 /* Static */ : 0);
@@ -53473,6 +53528,9 @@ function createTypeChecker(host) {
     return type.resolvedDefaultConstraint;
   }
   function getConstraintOfDistributiveConditionalType(type) {
+    if (type.resolvedConstraintOfDistributive !== void 0) {
+      return type.resolvedConstraintOfDistributive || void 0;
+    }
     if (type.root.isDistributive && type.restrictiveInstantiation !== type) {
       const simplified = getSimplifiedType(
         type.checkType,
@@ -53483,10 +53541,12 @@ function createTypeChecker(host) {
       if (constraint && constraint !== type.checkType) {
         const instantiated = getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
         if (!(instantiated.flags & 131072 /* Never */)) {
+          type.resolvedConstraintOfDistributive = instantiated;
           return instantiated;
         }
       }
     }
+    type.resolvedConstraintOfDistributive = false;
     return void 0;
   }
   function getConstraintFromConditionalType(type) {
@@ -53978,35 +54038,7 @@ function createTypeChecker(host) {
     return emptyArray;
   }
   function getSignaturesOfType(type, kind) {
-    const result = getSignaturesOfStructuredType(getReducedApparentType(type), kind);
-    if (kind === 0 /* Call */ && !length(result) && type.flags & 1048576 /* Union */) {
-      if (type.arrayFallbackSignatures) {
-        return type.arrayFallbackSignatures;
-      }
-      let memberName;
-      if (everyType(type, (t) => {
-        var _a2;
-        return !!((_a2 = t.symbol) == null ? void 0 : _a2.parent) && isArrayOrTupleSymbol(t.symbol.parent) && (!memberName ? (memberName = t.symbol.escapedName, true) : memberName === t.symbol.escapedName);
-      })) {
-        const arrayArg = mapType(type, (t) => getMappedType((isReadonlyArraySymbol(t.symbol.parent) ? globalReadonlyArrayType : globalArrayType).typeParameters[0], t.mapper));
-        const arrayType = createArrayType(arrayArg, someType(type, (t) => isReadonlyArraySymbol(t.symbol.parent)));
-        return type.arrayFallbackSignatures = getSignaturesOfType(getTypeOfPropertyOfType(arrayType, memberName), kind);
-      }
-      type.arrayFallbackSignatures = result;
-    }
-    return result;
-  }
-  function isArrayOrTupleSymbol(symbol) {
-    if (!symbol || !globalArrayType.symbol || !globalReadonlyArrayType.symbol) {
-      return false;
-    }
-    return !!getSymbolIfSameReference(symbol, globalArrayType.symbol) || !!getSymbolIfSameReference(symbol, globalReadonlyArrayType.symbol);
-  }
-  function isReadonlyArraySymbol(symbol) {
-    if (!symbol || !globalReadonlyArrayType.symbol) {
-      return false;
-    }
-    return !!getSymbolIfSameReference(symbol, globalReadonlyArrayType.symbol);
+    return getSignaturesOfStructuredType(getReducedApparentType(type), kind);
   }
   function findIndexInfo(indexInfos, keyType) {
     return find(indexInfos, (info) => info.keyType === keyType);
@@ -72202,7 +72234,7 @@ function createTypeChecker(host) {
     function checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics() {
       const functionFlags = getFunctionFlags(func);
       const type = returnType && unwrapReturnType(returnType, functionFlags);
-      if (type && maybeTypeOfKind(type, 32768 /* Undefined */ | 16384 /* Void */ | 1 /* Any */)) {
+      if (type && maybeTypeOfKind(type, 32768 /* Undefined */ | 16384 /* Void */ | 1 /* Any */ | 2 /* Unknown */)) {
         return;
       }
       if (func.kind === 171 /* MethodSignature */ || nodeIsMissing(func.body) || func.body.kind !== 239 /* Block */ || !functionHasImplicitReturn(func)) {
@@ -82706,25 +82738,6 @@ function createTypeChecker(host) {
     return false;
   }
   function checkGrammarNumericLiteral(node) {
-    if (node.numericLiteralFlags & 32 /* Octal */) {
-      let diagnosticMessage;
-      if (languageVersion >= 1 /* ES5 */) {
-        diagnosticMessage = Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0;
-      } else if (isChildOfNodeWithKind(node, 199 /* LiteralType */)) {
-        diagnosticMessage = Diagnostics.Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0;
-      } else if (isChildOfNodeWithKind(node, 303 /* EnumMember */)) {
-        diagnosticMessage = Diagnostics.Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0;
-      }
-      if (diagnosticMessage) {
-        const withMinus = isPrefixUnaryExpression(node.parent) && node.parent.operator === 40 /* MinusToken */;
-        const literal = (withMinus ? "-" : "") + "0o" + node.text;
-        return grammarErrorOnNode(withMinus ? node.parent : node, diagnosticMessage, literal);
-      }
-    }
-    checkNumericLiteralValueSize(node);
-    return false;
-  }
-  function checkNumericLiteralValueSize(node) {
     const isFractional = getTextOfNode(node).indexOf(".") !== -1;
     const isScientific = node.numericLiteralFlags & 16 /* Scientific */;
     if (isFractional || isScientific) {
@@ -85665,7 +85678,7 @@ function processTaggedTemplateExpression(context, node, visitor, currentSourceFi
   );
 }
 function createTemplateCooked(factory2, template) {
-  return template.templateFlags ? factory2.createVoidZero() : factory2.createStringLiteral(template.text);
+  return template.templateFlags & 26656 /* IsInvalid */ ? factory2.createVoidZero() : factory2.createStringLiteral(template.text);
 }
 function getRawLiteral(factory2, node, currentSourceFile) {
   let text = node.rawText;
@@ -108863,7 +108876,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
         /*jsxAttributeEscape*/
         false
       );
-      return !expression.numericLiteralFlags && !stringContains(text, tokenToString(24 /* DotToken */));
+      return !(expression.numericLiteralFlags & 448 /* WithSpecifier */) && !stringContains(text, tokenToString(24 /* DotToken */)) && !stringContains(text, String.fromCharCode(69 /* E */)) && !stringContains(text, String.fromCharCode(101 /* e */));
     } else if (isAccessExpression(expression)) {
       const constantValue = getConstantValue(expression);
       return typeof constantValue === "number" && isFinite(constantValue) && Math.floor(constantValue) === constantValue;
@@ -113111,7 +113124,6 @@ var plainJSErrors = /* @__PURE__ */ new Set([
   Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode.code,
   Diagnostics.Invalid_use_of_0_in_strict_mode.code,
   Diagnostics.A_label_is_not_allowed_here.code,
-  Diagnostics.Octal_literals_are_not_allowed_in_strict_mode.code,
   Diagnostics.with_statements_are_not_allowed_in_strict_mode.code,
   // grammar errors
   Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement.code,