typescript 5.1.0-dev.20230324 → 5.1.0-dev.20230325

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230324`;
+      version = `${versionMajorMinor}.0-dev.20230325`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -4040,9 +4040,15 @@ ${lanes.join("\n")}
         TokenFlags2[TokenFlags2["ContainsSeparator"] = 512] = "ContainsSeparator";
         TokenFlags2[TokenFlags2["UnicodeEscape"] = 1024] = "UnicodeEscape";
         TokenFlags2[TokenFlags2["ContainsInvalidEscape"] = 2048] = "ContainsInvalidEscape";
+        TokenFlags2[TokenFlags2["HexEscape"] = 4096] = "HexEscape";
+        TokenFlags2[TokenFlags2["ContainsLeadingZero"] = 8192] = "ContainsLeadingZero";
+        TokenFlags2[TokenFlags2["ContainsInvalidSeparator"] = 16384] = "ContainsInvalidSeparator";
         TokenFlags2[TokenFlags2["BinaryOrOctalSpecifier"] = 384] = "BinaryOrOctalSpecifier";
-        TokenFlags2[TokenFlags2["NumericLiteralFlags"] = 1008] = "NumericLiteralFlags";
-        TokenFlags2[TokenFlags2["TemplateLiteralLikeFlags"] = 2048 /* ContainsInvalidEscape */] = "TemplateLiteralLikeFlags";
+        TokenFlags2[TokenFlags2["WithSpecifier"] = 448] = "WithSpecifier";
+        TokenFlags2[TokenFlags2["StringLiteralFlags"] = 7176] = "StringLiteralFlags";
+        TokenFlags2[TokenFlags2["NumericLiteralFlags"] = 25584] = "NumericLiteralFlags";
+        TokenFlags2[TokenFlags2["TemplateLiteralLikeFlags"] = 7176] = "TemplateLiteralLikeFlags";
+        TokenFlags2[TokenFlags2["IsInvalid"] = 26656] = "IsInvalid";
         return TokenFlags2;
       })(TokenFlags || {});
       FlowFlags = /* @__PURE__ */ ((FlowFlags2) => {
@@ -7056,7 +7062,6 @@ ${lanes.join("\n")}
         _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."),
@@ -7087,7 +7092,7 @@ ${lanes.join("\n")}
         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."),
@@ -7398,6 +7403,9 @@ ${lanes.join("\n")}
         _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(
@@ -8738,8 +8746,6 @@ ${lanes.join("\n")}
         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."),
@@ -9584,7 +9590,7 @@ ${lanes.join("\n")}
       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,
@@ -9625,11 +9631,11 @@ ${lanes.join("\n")}
       });
     }
     return scanner2;
-    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;
       }
     }
@@ -9646,10 +9652,13 @@ ${lanes.join("\n")}
             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;
@@ -9664,13 +9673,39 @@ ${lanes.join("\n")}
         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 */) {
@@ -9704,6 +9739,10 @@ ${lanes.join("\n")}
       } 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 {
@@ -9735,12 +9774,17 @@ ${lanes.join("\n")}
         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(
@@ -9818,7 +9862,10 @@ ${lanes.join("\n")}
         }
         if (ch === 92 /* backslash */ && !jsxAttributeString) {
           result += text.substring(start2, pos);
-          result += scanEscapeSequence();
+          result += scanEscapeSequence(
+            /*shouldEmitInvalidEscapeError*/
+            true
+          );
           start2 = pos;
           continue;
         }
@@ -9832,7 +9879,7 @@ ${lanes.join("\n")}
       }
       return result;
     }
-    function scanTemplateAndSetTokenValue(isTaggedTemplate) {
+    function scanTemplateAndSetTokenValue(shouldEmitInvalidEscapeError) {
       const startedWithBacktick = text.charCodeAt(pos) === 96 /* backtick */;
       pos++;
       let start2 = pos;
@@ -9861,7 +9908,7 @@ ${lanes.join("\n")}
         }
         if (currChar === 92 /* backslash */) {
           contents += text.substring(start2, pos);
-          contents += scanEscapeSequence(isTaggedTemplate);
+          contents += scanEscapeSequence(shouldEmitInvalidEscapeError);
           start2 = pos;
           continue;
         }
@@ -9881,7 +9928,7 @@ ${lanes.join("\n")}
       tokenValue = contents;
       return resultingToken;
     }
-    function scanEscapeSequence(isTaggedTemplate) {
+    function scanEscapeSequence(shouldEmitInvalidEscapeError) {
       const start2 = pos;
       pos++;
       if (pos >= end) {
@@ -9892,12 +9939,37 @@ ${lanes.join("\n")}
       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 */:
@@ -9915,59 +9987,69 @@ ${lanes.join("\n")}
         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++;
@@ -9980,19 +10062,6 @@ ${lanes.join("\n")}
           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,
@@ -10221,7 +10290,7 @@ ${lanes.join("\n")}
             return token = 10 /* StringLiteral */;
           case 96 /* backtick */:
             return token = scanTemplateAndSetTokenValue(
-              /*isTaggedTemplate*/
+              /*shouldEmitInvalidEscapeError*/
               false
             );
           case 37 /* percent */:
@@ -10396,11 +10465,6 @@ ${lanes.join("\n")}
               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 */:
@@ -10717,14 +10781,13 @@ ${lanes.join("\n")}
       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
       );
     }
@@ -13607,8 +13670,13 @@ ${lanes.join("\n")}
     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);
   }
@@ -21844,7 +21912,7 @@ ${lanes.join("\n")}
       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);
@@ -21873,7 +21941,7 @@ ${lanes.join("\n")}
       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;
     }
@@ -21881,7 +21949,7 @@ ${lanes.join("\n")}
       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;
     }
@@ -28997,8 +29065,8 @@ ${lanes.join("\n")}
         function parseErrorAtRange(range, message, ...args) {
           parseErrorAt(range.pos, range.end, message, ...args);
         }
-        function scanError(message, length2) {
-          parseErrorAtPosition(scanner2.getTokenEnd(), length2, message);
+        function scanError(message, length2, arg0) {
+          parseErrorAtPosition(scanner2.getTokenEnd(), length2, message, arg0);
         }
         function getNodePos() {
           return scanner2.getTokenFullStart();
@@ -29037,9 +29105,6 @@ ${lanes.join("\n")}
         function reScanTemplateToken(isTaggedTemplate) {
           return currentToken = scanner2.reScanTemplateToken(isTaggedTemplate);
         }
-        function reScanTemplateHeadOrNoSubstitutionTemplate() {
-          return currentToken = scanner2.reScanTemplateHeadOrNoSubstitutionTemplate();
-        }
         function reScanLessThanToken() {
           return currentToken = scanner2.reScanLessThanToken();
         }
@@ -30111,8 +30176,11 @@ ${lanes.join("\n")}
           return parseLiteralLikeNode(token());
         }
         function parseTemplateHead(isTaggedTemplate) {
-          if (isTaggedTemplate) {
-            reScanTemplateHeadOrNoSubstitutionTemplate();
+          if (!isTaggedTemplate && scanner2.getTokenFlags() & 26656 /* IsInvalid */) {
+            reScanTemplateToken(
+              /*isTaggedTemplate*/
+              false
+            );
           }
           const fragment = parseLiteralLikeNode(token());
           Debug.assert(fragment.kind === 15 /* TemplateHead */, "Template head has wrong token kind");
@@ -30130,8 +30198,7 @@ ${lanes.join("\n")}
         }
         function parseLiteralLikeNode(kind) {
           const pos = getNodePos();
-          const node = isTemplateLiteralKind(kind) ? factory2.createTemplateLiteralLikeNode(kind, scanner2.getTokenValue(), getTemplateLiteralRawText(kind), scanner2.getTokenFlags() & 2048 /* TemplateLiteralLikeFlags */) : (
-            // Octal literals are not allowed in strict mode or ES5
+          const node = isTemplateLiteralKind(kind) ? factory2.createTemplateLiteralLikeNode(kind, scanner2.getTokenValue(), getTemplateLiteralRawText(kind), scanner2.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.
@@ -32187,7 +32254,10 @@ ${lanes.join("\n")}
           const tagExpression = factory2.createTaggedTemplateExpression(
             tag,
             typeArguments,
-            token() === 14 /* NoSubstitutionTemplateLiteral */ ? (reScanTemplateHeadOrNoSubstitutionTemplate(), parseLiteralNode()) : parseTemplateExpression(
+            token() === 14 /* NoSubstitutionTemplateLiteral */ ? (reScanTemplateToken(
+              /*isTaggedTemplate*/
+              true
+            ), parseLiteralNode()) : parseTemplateExpression(
               /*isTaggedTemplate*/
               true
             )
@@ -32275,10 +32345,16 @@ ${lanes.join("\n")}
         }
         function parsePrimaryExpression() {
           switch (token()) {
+            case 14 /* NoSubstitutionTemplateLiteral */:
+              if (scanner2.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 */:
@@ -42893,11 +42969,6 @@ ${lanes.join("\n")}
         }
       }
     }
-    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);
@@ -43089,8 +43160,6 @@ ${lanes.join("\n")}
           return checkStrictModeCatchClause(node);
         case 218 /* DeleteExpression */:
           return checkStrictModeDeleteExpression(node);
-        case 8 /* NumericLiteral */:
-          return checkStrictModeNumericLiteral(node);
         case 223 /* PostfixUnaryExpression */:
           return checkStrictModePostfixUnaryExpression(node);
         case 222 /* PrefixUnaryExpression */:
@@ -85113,25 +85182,6 @@ ${lanes.join("\n")}
       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) {
@@ -88399,7 +88449,7 @@ ${lanes.join("\n")}
     );
   }
   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;
@@ -111717,7 +111767,7 @@ ${lanes.join("\n")}
           /*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;
@@ -119280,7 +119330,6 @@ ${lanes.join("\n")}
         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,