@typescript-deploys/pr-build 5.1.0-pr-51837-45 → 5.1.0-pr-50951-3

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.20230311`;
+var version = `${versionMajorMinor}.0-insiders.20230313`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -5789,6 +5789,7 @@ 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."),
@@ -5819,7 +5820,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_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}'."),
+  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."),
   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."),
@@ -6129,9 +6130,6 @@ 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(
@@ -7468,6 +7466,8 @@ 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."),
@@ -8449,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 & 25584 /* NumericLiteralFlags */,
+    getNumericLiteralFlags: () => tokenFlags & 1008 /* NumericLiteralFlags */,
     getTokenFlags: () => tokenFlags,
     reScanGreaterToken,
     reScanAsteriskEqualsToken,
@@ -8490,11 +8490,11 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     });
   }
   return scanner;
-  function error(message, errPos = pos, length3, arg0) {
+  function error(message, errPos = pos, length3) {
     if (onError) {
       const oldPos = pos;
       pos = errPos;
-      onError(message, length3 || 0, arg0);
+      onError(message, length3 || 0);
       pos = oldPos;
     }
   }
@@ -8511,13 +8511,10 @@ 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 {
-          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);
-          }
+          error(Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1);
         }
         pos++;
         start2 = pos;
@@ -8532,38 +8529,13 @@ 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() {
-    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();
-    }
+    const start2 = pos;
+    const mainFragment = scanNumberFragment();
     let decimalFragment;
     let scientificFragment;
     if (text.charCodeAt(pos) === 46 /* dot */) {
@@ -8597,10 +8569,6 @@ 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 {
@@ -8632,17 +8600,12 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       pos = identifierStart;
     }
   }
-  function scanDigits() {
+  function scanOctalDigits() {
     const start2 = pos;
-    let isOctal = true;
-    while (isDigit(text.charCodeAt(pos))) {
-      if (!isOctalDigit(text.charCodeAt(pos))) {
-        isOctal = false;
-      }
+    while (isOctalDigit(text.charCodeAt(pos))) {
       pos++;
     }
-    tokenValue = text.substring(start2, pos);
-    return isOctal;
+    return +text.substring(start2, pos);
   }
   function scanExactNumberOfHexDigits(count, canHaveSeparators) {
     const valueString = scanHexDigits(
@@ -8720,10 +8683,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       }
       if (ch === 92 /* backslash */ && !jsxAttributeString) {
         result += text.substring(start2, pos);
-        result += scanEscapeSequence(
-          /*shouldEmitInvalidEscapeError*/
-          true
-        );
+        result += scanEscapeSequence();
         start2 = pos;
         continue;
       }
@@ -8737,7 +8697,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     }
     return result;
   }
-  function scanTemplateAndSetTokenValue(shouldEmitInvalidEscapeError) {
+  function scanTemplateAndSetTokenValue(isTaggedTemplate) {
     const startedWithBacktick = text.charCodeAt(pos) === 96 /* backtick */;
     pos++;
     let start2 = pos;
@@ -8766,7 +8726,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       }
       if (currChar === 92 /* backslash */) {
         contents += text.substring(start2, pos);
-        contents += scanEscapeSequence(shouldEmitInvalidEscapeError);
+        contents += scanEscapeSequence(isTaggedTemplate);
         start2 = pos;
         continue;
       }
@@ -8786,7 +8746,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     tokenValue = contents;
     return resultingToken;
   }
-  function scanEscapeSequence(shouldEmitInvalidEscapeError) {
+  function scanEscapeSequence(isTaggedTemplate) {
     const start2 = pos;
     pos++;
     if (pos >= end) {
@@ -8797,37 +8757,12 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     pos++;
     switch (ch) {
       case 48 /* _0 */:
-        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))) {
+        if (isTaggedTemplate && pos < end && isDigit(text.charCodeAt(pos))) {
           pos++;
+          tokenFlags |= 2048 /* ContainsInvalidEscape */;
+          return text.substring(start2, pos);
         }
-      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);
+        return "\0";
       case 98 /* b */:
         return "\b";
       case 116 /* t */:
@@ -8845,69 +8780,59 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       case 34 /* doubleQuote */:
         return '"';
       case 117 /* u */:
-        if (pos < end && text.charCodeAt(pos) === 123 /* openBrace */) {
-          pos++;
-          const escapedValueString = scanMinimumNumberOfHexDigits(
-            1,
-            /*canHaveSeparators*/
-            false
-          );
-          const escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1;
-          if (escapedValue < 0) {
-            tokenFlags |= 2048 /* ContainsInvalidEscape */;
-            if (shouldEmitInvalidEscapeError) {
-              error(Diagnostics.Hexadecimal_digit_expected);
+        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);
             }
-            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 (pos >= end) {
+        }
+        if (pos < end && text.charCodeAt(pos) === 123 /* openBrace */) {
+          pos++;
+          if (isTaggedTemplate && !isHexDigit(text.charCodeAt(pos))) {
             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);
+          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;
             }
-            return text.substring(start2, pos);
           }
-          pos++;
           tokenFlags |= 8 /* ExtendedUnicodeEscape */;
-          return utf16EncodeAsString(escapedValue);
-        }
-        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);
-          }
+          return scanExtendedUnicodeEscape();
         }
         tokenFlags |= 1024 /* UnicodeEscape */;
-        return String.fromCharCode(parseInt(text.substring(start2 + 2, pos), 16));
+        return scanHexadecimalEscape(
+          /*numDigits*/
+          4
+        );
       case 120 /* x */:
-        for (; pos < start2 + 4; pos++) {
-          if (!(pos < end && isHexDigit(text.charCodeAt(pos)))) {
+        if (isTaggedTemplate) {
+          if (!isHexDigit(text.charCodeAt(pos))) {
+            tokenFlags |= 2048 /* ContainsInvalidEscape */;
+            return text.substring(start2, pos);
+          } else if (!isHexDigit(text.charCodeAt(pos + 1))) {
+            pos++;
             tokenFlags |= 2048 /* ContainsInvalidEscape */;
-            if (shouldEmitInvalidEscapeError) {
-              error(Diagnostics.Hexadecimal_digit_expected);
-            }
             return text.substring(start2, pos);
           }
         }
-        tokenFlags |= 4096 /* HexEscape */;
-        return String.fromCharCode(parseInt(text.substring(start2 + 2, pos), 16));
+        return scanHexadecimalEscape(
+          /*numDigits*/
+          2
+        );
       case 13 /* carriageReturn */:
         if (pos < end && text.charCodeAt(pos) === 10 /* lineFeed */) {
           pos++;
@@ -8920,6 +8845,19 @@ 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,
@@ -9148,7 +9086,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           return token = 10 /* StringLiteral */;
         case 96 /* backtick */:
           return token = scanTemplateAndSetTokenValue(
-            /*shouldEmitInvalidEscapeError*/
+            /* isTaggedTemplate */
             false
           );
         case 37 /* percent */:
@@ -9323,6 +9261,11 @@ 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 */:
@@ -9639,13 +9582,14 @@ 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(
-      /*shouldEmitInvalidEscapeError*/
+      /* isTaggedTemplate */
       true
     );
   }
@@ -10337,32 +10281,36 @@ function getModifiers(node) {
     return filter(node.modifiers, isModifier);
   }
 }
-function getJSDocParameterTagsWorker(param, noCache) {
-  if (param.name) {
-    if (isIdentifier(param.name)) {
-      const name = param.name.escapedText;
-      return getJSDocTagsWorker(param.parent, noCache).filter((tag) => isJSDocParameterTag(tag) && isIdentifier(tag.name) && tag.name.escapedText === name);
-    } else {
-      const i = param.parent.parameters.indexOf(param);
-      Debug.assert(i > -1, "Parameters should always be in their parents' parameter list");
-      const paramTags = getJSDocTagsWorker(param.parent, noCache).filter(isJSDocParameterTag);
-      if (i < paramTags.length) {
-        return [paramTags[i]];
-      }
+function getJSDocParameterTagsWorker(node, noCache) {
+  const declaration = getRootDeclaration(node);
+  if (isParameter(declaration)) {
+    const name = node.name;
+    const signatureDeclaration = declaration.parent;
+    const jsDocParameterTags = filter(getJSDocTagsWorker(signatureDeclaration, noCache), isJSDocParameterTag);
+    if (length(jsDocParameterTags) === 0) {
+      return emptyArray;
+    }
+    if (isIdentifier(name)) {
+      return filter(jsDocParameterTags, (tag) => isIdentifier(tag.name) && tag.name.escapedText === name.escapedText);
+    }
+    const i = signatureDeclaration.parameters.indexOf(declaration);
+    Debug.assert(i > -1, "Parameters should always be in their parents' parameter list");
+    if (i < length(jsDocParameterTags)) {
+      return [jsDocParameterTags[i]];
     }
   }
   return emptyArray;
 }
-function getJSDocParameterTags(param) {
+function getJSDocParameterTags(node) {
   return getJSDocParameterTagsWorker(
-    param,
+    node,
     /*noCache*/
     false
   );
 }
-function getJSDocParameterTagsNoCache(param) {
+function getJSDocParameterTagsNoCache(node) {
   return getJSDocParameterTagsWorker(
-    param,
+    node,
     /*noCache*/
     true
   );
@@ -12135,13 +12083,8 @@ function canUseOriginalText(node, flags) {
   if (nodeIsSynthesized(node) || !node.parent || flags & 4 /* TerminateUnterminatedLiterals */ && node.isUnterminated) {
     return false;
   }
-  if (isNumericLiteral(node)) {
-    if (node.numericLiteralFlags & 26656 /* IsInvalid */) {
-      return false;
-    }
-    if (node.numericLiteralFlags & 512 /* ContainsSeparator */) {
-      return !!(flags & 8 /* AllowNumericSeparator */);
-    }
+  if (isNumericLiteral(node) && node.numericLiteralFlags & 512 /* ContainsSeparator */) {
+    return !!(flags & 8 /* AllowNumericSeparator */);
   }
   return !isBigIntLiteral(node);
 }
@@ -12658,6 +12601,15 @@ 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) {
@@ -13786,7 +13738,7 @@ function getJSDocCommentsAndTags(hostNode, noCache) {
     if (hasJSDocNodes(node)) {
       result = addRange(result, filterOwnedJSDocTags(hostNode, last(node.jsDoc)));
     }
-    if (node.kind === 167 /* Parameter */) {
+    if (node.kind === 167 /* Parameter */ || node.kind === 206 /* BindingElement */) {
       result = addRange(result, (noCache ? getJSDocParameterTagsNoCache : getJSDocParameterTags)(node));
       break;
     }
@@ -19907,7 +19859,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 & ~7176 /* TemplateLiteralLikeFlags */), "Unsupported template flags.");
+    Debug.assert(!(templateFlags & ~2048 /* TemplateLiteralLikeFlags */), "Unsupported template flags.");
     let cooked = void 0;
     if (rawText !== void 0 && rawText !== text) {
       cooked = getCookedText(kind, rawText);
@@ -19936,7 +19888,7 @@ function createNodeFactory(flags, baseFactory2) {
     const node = createBaseToken(kind);
     node.text = text;
     node.rawText = rawText;
-    node.templateFlags = templateFlags & 7176 /* TemplateLiteralLikeFlags */;
+    node.templateFlags = templateFlags & 2048 /* TemplateLiteralLikeFlags */;
     node.transformFlags = getTransformFlagsOfTemplateLiteralLike(node.templateFlags);
     return node;
   }
@@ -19944,7 +19896,7 @@ function createNodeFactory(flags, baseFactory2) {
     const node = createBaseDeclaration(kind);
     node.text = text;
     node.rawText = rawText;
-    node.templateFlags = templateFlags & 7176 /* TemplateLiteralLikeFlags */;
+    node.templateFlags = templateFlags & 2048 /* TemplateLiteralLikeFlags */;
     node.transformFlags = getTransformFlagsOfTemplateLiteralLike(node.templateFlags);
     return node;
   }
@@ -26611,8 +26563,8 @@ var Parser;
   function parseErrorAtRange(range, message, arg0) {
     parseErrorAt(range.pos, range.end, message, arg0);
   }
-  function scanError(message, length2, arg0) {
-    parseErrorAtPosition(scanner.getTokenEnd(), length2, message, arg0);
+  function scanError(message, length2) {
+    parseErrorAtPosition(scanner.getTokenEnd(), length2, message);
   }
   function getNodePos() {
     return scanner.getTokenFullStart();
@@ -26651,6 +26603,9 @@ var Parser;
   function reScanTemplateToken(isTaggedTemplate) {
     return currentToken = scanner.reScanTemplateToken(isTaggedTemplate);
   }
+  function reScanTemplateHeadOrNoSubstitutionTemplate() {
+    return currentToken = scanner.reScanTemplateHeadOrNoSubstitutionTemplate();
+  }
   function reScanLessThanToken() {
     return currentToken = scanner.reScanLessThanToken();
   }
@@ -27717,11 +27672,8 @@ var Parser;
     return parseLiteralLikeNode(token());
   }
   function parseTemplateHead(isTaggedTemplate) {
-    if (!isTaggedTemplate && scanner.getTokenFlags() & 26656 /* IsInvalid */) {
-      reScanTemplateToken(
-        /*isTaggedTemplate*/
-        false
-      );
+    if (isTaggedTemplate) {
+      reScanTemplateHeadOrNoSubstitutionTemplate();
     }
     const fragment = parseLiteralLikeNode(token());
     Debug.assert(fragment.kind === 15 /* TemplateHead */, "Template head has wrong token kind");
@@ -27739,7 +27691,8 @@ var Parser;
   }
   function parseLiteralLikeNode(kind) {
     const pos = getNodePos();
-    const node = isTemplateLiteralKind(kind) ? factory2.createTemplateLiteralLikeNode(kind, scanner.getTokenValue(), getTemplateLiteralRawText(kind), scanner.getTokenFlags() & 7176 /* TemplateLiteralLikeFlags */) : (
+    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
       // 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.
@@ -29794,10 +29747,7 @@ var Parser;
     const tagExpression = factory2.createTaggedTemplateExpression(
       tag,
       typeArguments,
-      token() === 14 /* NoSubstitutionTemplateLiteral */ ? (reScanTemplateToken(
-        /*isTaggedTemplate*/
-        true
-      ), parseLiteralNode()) : parseTemplateExpression(
+      token() === 14 /* NoSubstitutionTemplateLiteral */ ? (reScanTemplateHeadOrNoSubstitutionTemplate(), parseLiteralNode()) : parseTemplateExpression(
         /*isTaggedTemplate*/
         true
       )
@@ -29885,16 +29835,10 @@ 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 */:
@@ -40616,6 +40560,11 @@ 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);
@@ -40807,6 +40756,8 @@ 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 */:
@@ -82604,6 +82555,25 @@ 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) {
@@ -85542,7 +85512,7 @@ function processTaggedTemplateExpression(context, node, visitor, currentSourceFi
   );
 }
 function createTemplateCooked(factory2, template) {
-  return template.templateFlags & 26656 /* IsInvalid */ ? factory2.createVoidZero() : factory2.createStringLiteral(template.text);
+  return template.templateFlags ? factory2.createVoidZero() : factory2.createStringLiteral(template.text);
 }
 function getRawLiteral(factory2, node, currentSourceFile) {
   let text = node.rawText;
@@ -108711,7 +108681,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
         /*jsxAttributeEscape*/
         false
       );
-      return !(expression.numericLiteralFlags & 448 /* WithSpecifier */) && !stringContains(text, tokenToString(24 /* DotToken */)) && !stringContains(text, String.fromCharCode(69 /* E */)) && !stringContains(text, String.fromCharCode(101 /* e */));
+      return !expression.numericLiteralFlags && !stringContains(text, tokenToString(24 /* DotToken */));
     } else if (isAccessExpression(expression)) {
       const constantValue = getConstantValue(expression);
       return typeof constantValue === "number" && isFinite(constantValue) && Math.floor(constantValue) === constantValue;
@@ -112959,6 +112929,7 @@ 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,