@typescript-deploys/pr-build 5.1.0-pr-53192-9 → 5.1.0-pr-51837-45

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-insiders.20230310`;
+var version = `${versionMajorMinor}.0-insiders.20230311`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -1306,7 +1306,7 @@ function trimEndImpl(s) {
   return s.slice(0, end + 1);
 }
 function isNodeLikeSystem() {
-  return typeof process !== "undefined" && process.nextTick && !process.browser && typeof module === "object";
+  return typeof process !== "undefined" && !!process.nextTick && !process.browser && typeof module === "object";
 }
 
 // src/compiler/debug.ts
@@ -3743,7 +3743,7 @@ var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
   TypeFlags2[TypeFlags2["IncludesWildcard"] = 8388608 /* IndexedAccess */] = "IncludesWildcard";
   TypeFlags2[TypeFlags2["IncludesEmptyObject"] = 16777216 /* Conditional */] = "IncludesEmptyObject";
   TypeFlags2[TypeFlags2["IncludesInstantiable"] = 33554432 /* Substitution */] = "IncludesInstantiable";
-  TypeFlags2[TypeFlags2["NotPrimitiveUnion"] = 36323331] = "NotPrimitiveUnion";
+  TypeFlags2[TypeFlags2["NotPrimitiveUnion"] = 36323363] = "NotPrimitiveUnion";
   return TypeFlags2;
 })(TypeFlags || {});
 var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
@@ -4914,7 +4914,7 @@ var sys = (() => {
       getAccessibleSortedChildDirectories: (path) => getAccessibleFileSystemEntries(path).directories,
       realpath,
       tscWatchFile: process.env.TSC_WATCHFILE,
-      useNonPollingWatchers: process.env.TSC_NONPOLLING_WATCHER,
+      useNonPollingWatchers: !!process.env.TSC_NONPOLLING_WATCHER,
       tscWatchDirectory: process.env.TSC_WATCHDIRECTORY,
       inodeWatching: isLinuxOrMacOs,
       sysLog
@@ -5000,8 +5000,10 @@ var sys = (() => {
         process.stdout.write("\x1Bc");
       },
       setBlocking: () => {
-        if (process.stdout && process.stdout._handle && process.stdout._handle.setBlocking) {
-          process.stdout._handle.setBlocking(true);
+        var _a2;
+        const handle = (_a2 = process.stdout) == null ? void 0 : _a2._handle;
+        if (handle && handle.setBlocking) {
+          handle.setBlocking(true);
         }
       },
       bufferFrom,
@@ -5787,7 +5789,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."),
@@ -5818,7 +5819,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."),
@@ -6128,6 +6129,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(
@@ -7464,8 +7468,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."),
@@ -8447,7 +8449,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,
@@ -8488,11 +8490,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;
     }
   }
@@ -8509,10 +8511,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;
@@ -8527,13 +8532,38 @@ 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);
+        start2 -= +withMinus;
+        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 */) {
@@ -8567,6 +8597,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 {
@@ -8598,12 +8632,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(
@@ -8681,7 +8720,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;
       }
@@ -8695,7 +8737,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;
@@ -8724,7 +8766,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;
       }
@@ -8744,7 +8786,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) {
@@ -8755,12 +8797,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++;
+        }
+      case 52 /* _4 */:
+      case 53 /* _5 */:
+      case 54 /* _6 */:
+      case 55 /* _7 */:
+        if (pos < end && isOctalDigit(text.charCodeAt(pos))) {
           pos++;
-          tokenFlags |= 2048 /* ContainsInvalidEscape */;
-          return text.substring(start2, pos);
         }
-        return "\0";
+        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 */:
@@ -8778,59 +8845,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 (!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 (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 (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++;
@@ -8843,19 +8920,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,
@@ -9084,7 +9148,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           return token = 10 /* StringLiteral */;
         case 96 /* backtick */:
           return token = scanTemplateAndSetTokenValue(
-            /* isTaggedTemplate */
+            /*shouldEmitInvalidEscapeError*/
             false
           );
         case 37 /* percent */:
@@ -9259,11 +9323,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 */:
@@ -9580,14 +9639,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
     );
   }
@@ -12077,8 +12135,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);
 }
@@ -12595,15 +12658,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) {
@@ -19853,7 +19907,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);
@@ -19882,7 +19936,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;
   }
@@ -19890,7 +19944,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;
   }
@@ -26557,8 +26611,8 @@ var Parser;
   function parseErrorAtRange(range, message, arg0) {
     parseErrorAt(range.pos, range.end, message, arg0);
   }
-  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();
@@ -26597,9 +26651,6 @@ var Parser;
   function reScanTemplateToken(isTaggedTemplate) {
     return currentToken = scanner.reScanTemplateToken(isTaggedTemplate);
   }
-  function reScanTemplateHeadOrNoSubstitutionTemplate() {
-    return currentToken = scanner.reScanTemplateHeadOrNoSubstitutionTemplate();
-  }
   function reScanLessThanToken() {
     return currentToken = scanner.reScanLessThanToken();
   }
@@ -27666,8 +27717,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");
@@ -27685,8 +27739,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.
@@ -29741,7 +29794,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
       )
@@ -29829,10 +29885,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 */:
@@ -36574,6 +36636,10 @@ function getOriginalAndResolvedFileName(fileName, host, traceEnabled) {
     originalPath: pathsAreEqual ? void 0 : fileName
   };
 }
+function getCandidateFromTypeRoot(typeRoot, typeReferenceDirectiveName, moduleResolutionState) {
+  const nameForLookup = endsWith(typeRoot, "/node_modules/@types") || endsWith(typeRoot, "/node_modules/@types/") ? mangleScopedPackageNameWithTrace(typeReferenceDirectiveName, moduleResolutionState) : typeReferenceDirectiveName;
+  return combinePaths(typeRoot, nameForLookup);
+}
 function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, cache, resolutionMode) {
   Debug.assert(typeof typeReferenceDirectiveName === "string", "Non-string value passed to `ts.resolveTypeReferenceDirective`, likely by a wrapping package working with an outdated `resolveTypeReferenceDirectives` signature. This is probably not a problem in TS itself.");
   const traceEnabled = isTraceEnabled(options, host);
@@ -36692,7 +36758,7 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
         trace(host, Diagnostics.Resolving_with_primary_search_path_0, typeRoots.join(", "));
       }
       return firstDefined(typeRoots, (typeRoot) => {
-        const candidate = combinePaths(typeRoot, typeReferenceDirectiveName);
+        const candidate = getCandidateFromTypeRoot(typeRoot, typeReferenceDirectiveName, moduleResolutionState);
         const directoryExists = directoryProbablyExists(typeRoot, host);
         if (!directoryExists && traceEnabled) {
           trace(host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, typeRoot);
@@ -38678,7 +38744,7 @@ function resolveFromTypeRoot(moduleName, state) {
   if (!state.compilerOptions.typeRoots)
     return;
   for (const typeRoot of state.compilerOptions.typeRoots) {
-    const candidate = combinePaths(typeRoot, moduleName);
+    const candidate = getCandidateFromTypeRoot(typeRoot, moduleName, state);
     const directoryExists = directoryProbablyExists(typeRoot, state.host);
     if (!directoryExists && state.traceEnabled) {
       trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, typeRoot);
@@ -40550,11 +40616,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);
@@ -40746,8 +40807,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 */:
@@ -55995,7 +56054,7 @@ function createTypeChecker(host) {
         origin = createOriginUnionOrIntersectionType(1048576 /* Union */, reducedTypes);
       }
     }
-    const objectFlags = (includes & 36323331 /* NotPrimitiveUnion */ ? 0 : 32768 /* PrimitiveUnion */) | (includes & 2097152 /* Intersection */ ? 16777216 /* ContainsIntersections */ : 0);
+    const objectFlags = (includes & 36323363 /* NotPrimitiveUnion */ ? 0 : 32768 /* PrimitiveUnion */) | (includes & 2097152 /* Intersection */ ? 16777216 /* ContainsIntersections */ : 0);
     return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments, origin);
   }
   function getUnionOrIntersectionTypePredicate(signatures, kind) {
@@ -56120,7 +56179,7 @@ function createTypeChecker(host) {
   function eachUnionContains(unionTypes2, type) {
     for (const u of unionTypes2) {
       if (!containsType(u.types, type)) {
-        const primitive = type.flags & 128 /* StringLiteral */ ? stringType : type.flags & (32 /* Enum */ | 256 /* NumberLiteral */) ? numberType : type.flags & 2048 /* BigIntLiteral */ ? bigintType : type.flags & 8192 /* UniqueESSymbol */ ? esSymbolType : void 0;
+        const primitive = type.flags & 128 /* StringLiteral */ ? stringType : type.flags & 256 /* NumberLiteral */ ? numberType : type.flags & 2048 /* BigIntLiteral */ ? bigintType : type.flags & 8192 /* UniqueESSymbol */ ? esSymbolType : void 0;
         if (!primitive || !containsType(u.types, primitive)) {
           return false;
         }
@@ -56147,6 +56206,9 @@ function createTypeChecker(host) {
     }
     return false;
   }
+  function eachIsUnionContaining(types, flag) {
+    return every(types, (t) => !!(t.flags & 1048576 /* Union */) && some(t.types, (tt) => !!(tt.flags & flag)));
+  }
   function removeFromEach(types, flag) {
     for (let i = 0; i < types.length; i++) {
       types[i] = filterType(types[i], (t) => !(t.flags & flag));
@@ -56235,11 +56297,11 @@ function createTypeChecker(host) {
       if (includes & 1048576 /* Union */) {
         if (intersectUnionsOfPrimitiveTypes(typeSet)) {
           result = getIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
-        } else if (every(typeSet, (t) => !!(t.flags & 1048576 /* Union */ && t.types[0].flags & 32768 /* Undefined */))) {
+        } else if (eachIsUnionContaining(typeSet, 32768 /* Undefined */)) {
           const containedUndefinedType = some(typeSet, containsMissingType) ? missingType : undefinedType;
           removeFromEach(typeSet, 32768 /* Undefined */);
           result = getUnionType([getIntersectionType(typeSet), containedUndefinedType], 1 /* Literal */, aliasSymbol, aliasTypeArguments);
-        } else if (every(typeSet, (t) => !!(t.flags & 1048576 /* Union */ && (t.types[0].flags & 65536 /* Null */ || t.types[1].flags & 65536 /* Null */)))) {
+        } else if (eachIsUnionContaining(typeSet, 65536 /* Null */)) {
           removeFromEach(typeSet, 65536 /* Null */);
           result = getUnionType([getIntersectionType(typeSet), nullType], 1 /* Literal */, aliasSymbol, aliasTypeArguments);
         } else {
@@ -58642,20 +58704,8 @@ function createTypeChecker(host) {
         return result;
       }
       const moreThanOneRealChildren = length(validChildren) > 1;
-      let arrayLikeTargetParts;
-      let nonArrayLikeTargetParts;
-      const iterableType = getGlobalIterableType(
-        /*reportErrors*/
-        false
-      );
-      if (iterableType !== emptyGenericType) {
-        const anyIterable = createIterableType(anyType);
-        arrayLikeTargetParts = filterType(childrenTargetType, (t) => isTypeAssignableTo(t, anyIterable));
-        nonArrayLikeTargetParts = filterType(childrenTargetType, (t) => !isTypeAssignableTo(t, anyIterable));
-      } else {
-        arrayLikeTargetParts = filterType(childrenTargetType, isArrayOrTupleLikeType);
-        nonArrayLikeTargetParts = filterType(childrenTargetType, (t) => !isArrayOrTupleLikeType(t));
-      }
+      const arrayLikeTargetParts = filterType(childrenTargetType, isAssignableToAvailableAnyIterable);
+      const nonArrayLikeTargetParts = filterType(childrenTargetType, (t) => !isAssignableToAvailableAnyIterable(t));
       if (moreThanOneRealChildren) {
         if (arrayLikeTargetParts !== neverType) {
           const realSource = createTupleType(checkJsxChildren(containingElement, 0 /* Normal */));
@@ -59779,11 +59829,6 @@ function createTypeChecker(host) {
         if (containsType(targetTypes, source2)) {
           return -1 /* True */;
         }
-        if (getObjectFlags(target2) & 32768 /* PrimitiveUnion */ && !(source2.flags & 1024 /* EnumLiteral */) && (source2.flags & (128 /* StringLiteral */ | 512 /* BooleanLiteral */ | 2048 /* BigIntLiteral */) || (relation === subtypeRelation || relation === strictSubtypeRelation) && source2.flags & 256 /* NumberLiteral */)) {
-          const alternateForm = source2 === source2.regularType ? source2.freshType : source2.regularType;
-          const primitive = source2.flags & 128 /* StringLiteral */ ? stringType : source2.flags & 256 /* NumberLiteral */ ? numberType : source2.flags & 2048 /* BigIntLiteral */ ? bigintType : void 0;
-          return primitive && containsType(targetTypes, primitive) || alternateForm && containsType(targetTypes, alternateForm) ? -1 /* True */ : 0 /* False */;
-        }
         const match = getMatchingUnionConstituentForType(target2, source2);
         if (match) {
           const related = isRelatedTo(
@@ -61946,6 +61991,13 @@ function createTypeChecker(host) {
   function isArrayOrTupleLikeType(type) {
     return isArrayLikeType(type) || isTupleLikeType(type);
   }
+  function isAssignableToAvailableAnyIterable(type) {
+    const anyIterable = getGlobalIterableType(
+      /*reportErrors*/
+      false
+    ) !== emptyGenericType && createIterableType(anyType);
+    return anyIterable ? isTypeAssignableTo(type, anyIterable) : isArrayOrTupleLikeType(type);
+  }
   function getTupleElementType(type, index) {
     const propType = getTypeOfPropertyOfType(type, "" + index);
     if (propType) {
@@ -66699,7 +66751,7 @@ function createTypeChecker(host) {
     return void 0;
   }
   function getContextualTypeForElementExpression(arrayContextualType, index) {
-    return arrayContextualType && (index >= 0 && getTypeOfPropertyOfContextualType(arrayContextualType, "" + index) || mapType(
+    return arrayContextualType && (index >= 0 && getTypeOfPropertyOfContextualType(filterType(arrayContextualType, (t) => !!getIndexTypeOfType(t, numberType) || isAssignableToAvailableAnyIterable(t)), "" + index) || mapType(
       arrayContextualType,
       (t) => isTupleType(t) ? getElementTypeOfSliceOfTupleType(
         t,
@@ -82552,25 +82604,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) {
@@ -85509,7 +85542,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;
@@ -108678,7 +108711,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;
@@ -112926,7 +112959,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,