typescript 5.5.0-dev.20240529 → 5.5.0-dev.20240531

package/lib/typescript.js

@@ -2370,7 +2370,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240529`;
+var version = `${versionMajorMinor}.0-dev.20240531`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -4252,6 +4252,15 @@ Node ${formatSyntaxKind(node.kind)} was unexpected.`,
     );
   }
   Debug2.formatNodeFlags = formatNodeFlags;
+  function formatNodeCheckFlags(flags) {
+    return formatEnum(
+      flags,
+      NodeCheckFlags,
+      /*isFlags*/
+      true
+    );
+  }
+  Debug2.formatNodeCheckFlags = formatNodeCheckFlags;
   function formatModifierFlags(flags) {
     return formatEnum(
       flags,
@@ -6544,32 +6553,33 @@ var InternalSymbolName = /* @__PURE__ */ ((InternalSymbolName2) => {
   InternalSymbolName2["ImportAttributes"] = "__importAttributes";
   return InternalSymbolName2;
 })(InternalSymbolName || {});
-var NodeCheckFlags = /* @__PURE__ */ ((NodeCheckFlags2) => {
-  NodeCheckFlags2[NodeCheckFlags2["None"] = 0] = "None";
-  NodeCheckFlags2[NodeCheckFlags2["TypeChecked"] = 1] = "TypeChecked";
-  NodeCheckFlags2[NodeCheckFlags2["LexicalThis"] = 2] = "LexicalThis";
-  NodeCheckFlags2[NodeCheckFlags2["CaptureThis"] = 4] = "CaptureThis";
-  NodeCheckFlags2[NodeCheckFlags2["CaptureNewTarget"] = 8] = "CaptureNewTarget";
-  NodeCheckFlags2[NodeCheckFlags2["SuperInstance"] = 16] = "SuperInstance";
-  NodeCheckFlags2[NodeCheckFlags2["SuperStatic"] = 32] = "SuperStatic";
-  NodeCheckFlags2[NodeCheckFlags2["ContextChecked"] = 64] = "ContextChecked";
-  NodeCheckFlags2[NodeCheckFlags2["MethodWithSuperPropertyAccessInAsync"] = 128] = "MethodWithSuperPropertyAccessInAsync";
-  NodeCheckFlags2[NodeCheckFlags2["MethodWithSuperPropertyAssignmentInAsync"] = 256] = "MethodWithSuperPropertyAssignmentInAsync";
-  NodeCheckFlags2[NodeCheckFlags2["CaptureArguments"] = 512] = "CaptureArguments";
-  NodeCheckFlags2[NodeCheckFlags2["EnumValuesComputed"] = 1024] = "EnumValuesComputed";
-  NodeCheckFlags2[NodeCheckFlags2["LexicalModuleMergesWithClass"] = 2048] = "LexicalModuleMergesWithClass";
-  NodeCheckFlags2[NodeCheckFlags2["LoopWithCapturedBlockScopedBinding"] = 4096] = "LoopWithCapturedBlockScopedBinding";
-  NodeCheckFlags2[NodeCheckFlags2["ContainsCapturedBlockScopeBinding"] = 8192] = "ContainsCapturedBlockScopeBinding";
-  NodeCheckFlags2[NodeCheckFlags2["CapturedBlockScopedBinding"] = 16384] = "CapturedBlockScopedBinding";
-  NodeCheckFlags2[NodeCheckFlags2["BlockScopedBindingInLoop"] = 32768] = "BlockScopedBindingInLoop";
-  NodeCheckFlags2[NodeCheckFlags2["NeedsLoopOutParameter"] = 65536] = "NeedsLoopOutParameter";
-  NodeCheckFlags2[NodeCheckFlags2["AssignmentsMarked"] = 131072] = "AssignmentsMarked";
-  NodeCheckFlags2[NodeCheckFlags2["ContainsConstructorReference"] = 262144] = "ContainsConstructorReference";
-  NodeCheckFlags2[NodeCheckFlags2["ConstructorReference"] = 536870912] = "ConstructorReference";
-  NodeCheckFlags2[NodeCheckFlags2["ContainsClassWithPrivateIdentifiers"] = 1048576] = "ContainsClassWithPrivateIdentifiers";
-  NodeCheckFlags2[NodeCheckFlags2["ContainsSuperPropertyInStaticInitializer"] = 2097152] = "ContainsSuperPropertyInStaticInitializer";
-  NodeCheckFlags2[NodeCheckFlags2["InCheckIdentifier"] = 4194304] = "InCheckIdentifier";
-  return NodeCheckFlags2;
+var NodeCheckFlags = /* @__PURE__ */ ((NodeCheckFlags3) => {
+  NodeCheckFlags3[NodeCheckFlags3["None"] = 0] = "None";
+  NodeCheckFlags3[NodeCheckFlags3["TypeChecked"] = 1] = "TypeChecked";
+  NodeCheckFlags3[NodeCheckFlags3["LexicalThis"] = 2] = "LexicalThis";
+  NodeCheckFlags3[NodeCheckFlags3["CaptureThis"] = 4] = "CaptureThis";
+  NodeCheckFlags3[NodeCheckFlags3["CaptureNewTarget"] = 8] = "CaptureNewTarget";
+  NodeCheckFlags3[NodeCheckFlags3["SuperInstance"] = 16] = "SuperInstance";
+  NodeCheckFlags3[NodeCheckFlags3["SuperStatic"] = 32] = "SuperStatic";
+  NodeCheckFlags3[NodeCheckFlags3["ContextChecked"] = 64] = "ContextChecked";
+  NodeCheckFlags3[NodeCheckFlags3["MethodWithSuperPropertyAccessInAsync"] = 128] = "MethodWithSuperPropertyAccessInAsync";
+  NodeCheckFlags3[NodeCheckFlags3["MethodWithSuperPropertyAssignmentInAsync"] = 256] = "MethodWithSuperPropertyAssignmentInAsync";
+  NodeCheckFlags3[NodeCheckFlags3["CaptureArguments"] = 512] = "CaptureArguments";
+  NodeCheckFlags3[NodeCheckFlags3["EnumValuesComputed"] = 1024] = "EnumValuesComputed";
+  NodeCheckFlags3[NodeCheckFlags3["LexicalModuleMergesWithClass"] = 2048] = "LexicalModuleMergesWithClass";
+  NodeCheckFlags3[NodeCheckFlags3["LoopWithCapturedBlockScopedBinding"] = 4096] = "LoopWithCapturedBlockScopedBinding";
+  NodeCheckFlags3[NodeCheckFlags3["ContainsCapturedBlockScopeBinding"] = 8192] = "ContainsCapturedBlockScopeBinding";
+  NodeCheckFlags3[NodeCheckFlags3["CapturedBlockScopedBinding"] = 16384] = "CapturedBlockScopedBinding";
+  NodeCheckFlags3[NodeCheckFlags3["BlockScopedBindingInLoop"] = 32768] = "BlockScopedBindingInLoop";
+  NodeCheckFlags3[NodeCheckFlags3["NeedsLoopOutParameter"] = 65536] = "NeedsLoopOutParameter";
+  NodeCheckFlags3[NodeCheckFlags3["AssignmentsMarked"] = 131072] = "AssignmentsMarked";
+  NodeCheckFlags3[NodeCheckFlags3["ContainsConstructorReference"] = 262144] = "ContainsConstructorReference";
+  NodeCheckFlags3[NodeCheckFlags3["ConstructorReference"] = 536870912] = "ConstructorReference";
+  NodeCheckFlags3[NodeCheckFlags3["ContainsClassWithPrivateIdentifiers"] = 1048576] = "ContainsClassWithPrivateIdentifiers";
+  NodeCheckFlags3[NodeCheckFlags3["ContainsSuperPropertyInStaticInitializer"] = 2097152] = "ContainsSuperPropertyInStaticInitializer";
+  NodeCheckFlags3[NodeCheckFlags3["InCheckIdentifier"] = 4194304] = "InCheckIdentifier";
+  NodeCheckFlags3[NodeCheckFlags3["LazyFlags"] = 539358128] = "LazyFlags";
+  return NodeCheckFlags3;
 })(NodeCheckFlags || {});
 var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
   TypeFlags2[TypeFlags2["Any"] = 1] = "Any";
@@ -9700,8 +9710,10 @@ var Diagnostics = {
   _0_must_be_followed_by_a_Unicode_property_value_expression_enclosed_in_braces: diag(1531, 1 /* Error */, "_0_must_be_followed_by_a_Unicode_property_value_expression_enclosed_in_braces_1531", "'\\{0}' must be followed by a Unicode property value expression enclosed in braces."),
   There_is_no_capturing_group_named_0_in_this_regular_expression: diag(1532, 1 /* Error */, "There_is_no_capturing_group_named_0_in_this_regular_expression_1532", "There is no capturing group named '{0}' in this regular expression."),
   This_backreference_refers_to_a_group_that_does_not_exist_There_are_only_0_capturing_groups_in_this_regular_expression: diag(1533, 1 /* Error */, "This_backreference_refers_to_a_group_that_does_not_exist_There_are_only_0_capturing_groups_in_this_r_1533", "This backreference refers to a group that does not exist. There are only {0} capturing groups in this regular expression."),
-  This_backreference_is_invalid_because_the_containing_regular_expression_contains_no_capturing_groups: diag(1534, 1 /* Error */, "This_backreference_is_invalid_because_the_containing_regular_expression_contains_no_capturing_groups_1534", "This backreference is invalid because the containing regular expression contains no capturing groups."),
+  This_backreference_refers_to_a_group_that_does_not_exist_There_are_no_capturing_groups_in_this_regular_expression: diag(1534, 1 /* Error */, "This_backreference_refers_to_a_group_that_does_not_exist_There_are_no_capturing_groups_in_this_regul_1534", "This backreference refers to a group that does not exist. There are no capturing groups in this regular expression."),
   This_character_cannot_be_escaped_in_a_regular_expression: diag(1535, 1 /* Error */, "This_character_cannot_be_escaped_in_a_regular_expression_1535", "This character cannot be escaped in a regular expression."),
+  Octal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class_If_this_was_intended_as_an_escape_sequence_use_the_syntax_0_instead: diag(1536, 1 /* Error */, "Octal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class_If_this_was_intended__1536", "Octal escape sequences and backreferences are not allowed in a character class. If this was intended as an escape sequence, use the syntax '{0}' instead."),
+  Decimal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class: diag(1537, 1 /* Error */, "Decimal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class_1537", "Decimal escape sequences and backreferences are not allowed in a character class."),
   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(
@@ -12445,12 +12457,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       }
       if (ch === 92 /* backslash */ && !jsxAttributeString) {
         result += text.substring(start2, pos);
-        result += scanEscapeSequence(
-          /*shouldEmitInvalidEscapeError*/
-          true,
-          /*isRegularExpression*/
-          false
-        );
+        result += scanEscapeSequence(1 /* String */ | 2 /* ReportErrors */);
         start2 = pos;
         continue;
       }
@@ -12493,11 +12500,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       }
       if (currChar === 92 /* backslash */) {
         contents += text.substring(start2, pos);
-        contents += scanEscapeSequence(
-          shouldEmitInvalidEscapeError,
-          /*isRegularExpression*/
-          false
-        );
+        contents += scanEscapeSequence(1 /* String */ | (shouldEmitInvalidEscapeError ? 2 /* ReportErrors */ : 0));
         start2 = pos;
         continue;
       }
@@ -12517,7 +12520,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     tokenValue = contents;
     return resultingToken;
   }
-  function scanEscapeSequence(shouldEmitInvalidEscapeError, isRegularExpression) {
+  function scanEscapeSequence(flags) {
     const start2 = pos;
     pos++;
     if (pos >= end) {
@@ -12545,9 +12548,11 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           pos++;
         }
         tokenFlags |= 2048 /* ContainsInvalidEscape */;
-        if (isRegularExpression || shouldEmitInvalidEscapeError) {
+        if (flags & 6 /* ReportInvalidEscapeErrors */) {
           const code = parseInt(text.substring(start2 + 1, pos), 8);
-          if (isRegularExpression !== "annex-b") {
+          if (flags & 4 /* RegularExpression */ && !(flags & 32 /* AtomEscape */) && ch !== 48 /* _0 */) {
+            error2(Diagnostics.Octal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class_If_this_was_intended_as_an_escape_sequence_use_the_syntax_0_instead, start2, pos - start2, "\\x" + code.toString(16).padStart(2, "0"));
+          } else {
             error2(Diagnostics.Octal_escape_sequences_are_not_allowed_Use_the_syntax_0, start2, pos - start2, "\\x" + code.toString(16).padStart(2, "0"));
           }
           return String.fromCharCode(code);
@@ -12556,8 +12561,12 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       case 56 /* _8 */:
       case 57 /* _9 */:
         tokenFlags |= 2048 /* ContainsInvalidEscape */;
-        if (isRegularExpression || shouldEmitInvalidEscapeError) {
-          error2(Diagnostics.Escape_sequence_0_is_not_allowed, start2, pos - start2, text.substring(start2, pos));
+        if (flags & 6 /* ReportInvalidEscapeErrors */) {
+          if (flags & 4 /* RegularExpression */ && !(flags & 32 /* AtomEscape */)) {
+            error2(Diagnostics.Decimal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class, start2, pos - start2);
+          } else {
+            error2(Diagnostics.Escape_sequence_0_is_not_allowed, start2, pos - start2, text.substring(start2, pos));
+          }
           return String.fromCharCode(ch);
         }
         return text.substring(start2, pos);
@@ -12578,14 +12587,14 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       case 34 /* doubleQuote */:
         return '"';
       case 117 /* u */:
-        if ((!isRegularExpression || shouldEmitInvalidEscapeError) && pos < end && charCodeUnchecked(pos) === 123 /* openBrace */) {
+        if (flags & 17 /* ScanExtendedUnicodeEscape */ && pos < end && charCodeUnchecked(pos) === 123 /* openBrace */) {
           pos -= 2;
-          return scanExtendedUnicodeEscape(!!isRegularExpression || shouldEmitInvalidEscapeError);
+          return scanExtendedUnicodeEscape(!!(flags & 6 /* ReportInvalidEscapeErrors */));
         }
         for (; pos < start2 + 6; pos++) {
           if (!(pos < end && isHexDigit(charCodeUnchecked(pos)))) {
             tokenFlags |= 2048 /* ContainsInvalidEscape */;
-            if (isRegularExpression || shouldEmitInvalidEscapeError) {
+            if (flags & 6 /* ReportInvalidEscapeErrors */) {
               error2(Diagnostics.Hexadecimal_digit_expected);
             }
             return text.substring(start2, pos);
@@ -12594,7 +12603,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         tokenFlags |= 1024 /* UnicodeEscape */;
         const escapedValue = parseInt(text.substring(start2 + 2, pos), 16);
         const escapedValueString = String.fromCharCode(escapedValue);
-        if (isRegularExpression && shouldEmitInvalidEscapeError && escapedValue >= 55296 && escapedValue <= 56319 && pos + 6 < end && text.substring(pos, pos + 2) === "\\u" && charCodeUnchecked(pos + 2) !== 123 /* openBrace */) {
+        if (flags & 16 /* AnyUnicodeMode */ && escapedValue >= 55296 && escapedValue <= 56319 && pos + 6 < end && text.substring(pos, pos + 2) === "\\u" && charCodeUnchecked(pos + 2) !== 123 /* openBrace */) {
           const nextStart = pos;
           let nextPos = pos + 2;
           for (; nextPos < nextStart + 6; nextPos++) {
@@ -12613,7 +12622,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         for (; pos < start2 + 4; pos++) {
           if (!(pos < end && isHexDigit(charCodeUnchecked(pos)))) {
             tokenFlags |= 2048 /* ContainsInvalidEscape */;
-            if (isRegularExpression || shouldEmitInvalidEscapeError) {
+            if (flags & 6 /* ReportInvalidEscapeErrors */) {
               error2(Diagnostics.Hexadecimal_digit_expected);
             }
             return text.substring(start2, pos);
@@ -12630,7 +12639,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       case 8233 /* paragraphSeparator */:
         return "";
       default:
-        if (isRegularExpression === true && (shouldEmitInvalidEscapeError || isIdentifierPart(ch, languageVersion))) {
+        if (flags & 16 /* AnyUnicodeMode */ || flags & 4 /* RegularExpression */ && !(flags & 8 /* AnnexB */) && isIdentifierPart(ch, languageVersion)) {
           error2(Diagnostics.This_character_cannot_be_escaped_in_a_regular_expression, pos - 2, 2);
         }
         return String.fromCharCode(ch);
@@ -13329,6 +13338,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       const startOfRegExpBody = tokenStart + 1;
       pos = startOfRegExpBody;
       let inEscape = false;
+      let namedCaptureGroups = false;
       let inCharacterClass = false;
       while (true) {
         const ch = charCodeChecked(pos);
@@ -13346,6 +13356,8 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           inEscape = true;
         } else if (ch === 93 /* closeBracket */) {
           inCharacterClass = false;
+        } else if (!inCharacterClass && ch === 40 /* openParen */ && charCodeChecked(pos + 1) === 63 /* question */ && charCodeChecked(pos + 2) === 60 /* lessThan */ && charCodeChecked(pos + 3) !== 61 /* equals */ && charCodeChecked(pos + 3) !== 33 /* exclamation */) {
+          namedCaptureGroups = true;
         }
         pos++;
       }
@@ -13413,7 +13425,8 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             scanRegularExpressionWorker(
               regExpFlags,
               /*annexB*/
-              true
+              true,
+              namedCaptureGroups
             );
           });
         }
@@ -13423,12 +13436,10 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
     }
     return token;
   }
-  function scanRegularExpressionWorker(regExpFlags, annexB) {
+  function scanRegularExpressionWorker(regExpFlags, annexB, namedCaptureGroups) {
     var unicodeSetsMode = !!(regExpFlags & 64 /* UnicodeSets */);
     var anyUnicodeMode = !!(regExpFlags & 96 /* AnyUnicodeMode */);
-    if (anyUnicodeMode) {
-      annexB = false;
-    }
+    var anyUnicodeModeOrNonAnnexB = anyUnicodeMode || !annexB;
     var mayContainStrings = false;
     var numberOfCapturingGroups = 0;
     var groupSpecifiers;
@@ -13483,7 +13494,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
                 case 61 /* equals */:
                 case 33 /* exclamation */:
                   pos++;
-                  isPreviousTermQuantifiable = annexB;
+                  isPreviousTermQuantifiable = !anyUnicodeModeOrNonAnnexB;
                   break;
                 case 60 /* lessThan */:
                   const groupNameStart = pos;
@@ -13537,6 +13548,10 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             const digitsStart = pos;
             scanDigits();
             const min2 = tokenValue;
+            if (!anyUnicodeModeOrNonAnnexB && !min2) {
+              isPreviousTermQuantifiable = true;
+              break;
+            }
             if (charCodeChecked(pos) === 44 /* comma */) {
               pos++;
               scanDigits();
@@ -13545,25 +13560,29 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
                 if (max || charCodeChecked(pos) === 125 /* closeBrace */) {
                   error2(Diagnostics.Incomplete_quantifier_Digit_expected, digitsStart, 0);
                 } else {
-                  if (anyUnicodeMode) {
-                    error2(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, start2, 1, String.fromCharCode(ch));
-                  }
+                  error2(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, start2, 1, String.fromCharCode(ch));
                   isPreviousTermQuantifiable = true;
                   break;
                 }
-              }
-              if (max && Number.parseInt(min2) > Number.parseInt(max)) {
+              } else if (max && Number.parseInt(min2) > Number.parseInt(max) && (anyUnicodeModeOrNonAnnexB || charCodeChecked(pos) === 125 /* closeBrace */)) {
                 error2(Diagnostics.Numbers_out_of_order_in_quantifier, digitsStart, pos - digitsStart);
               }
             } else if (!min2) {
-              if (anyUnicodeMode) {
+              if (anyUnicodeModeOrNonAnnexB) {
                 error2(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, start2, 1, String.fromCharCode(ch));
               }
               isPreviousTermQuantifiable = true;
               break;
             }
-            scanExpectedChar(125 /* closeBrace */);
-            pos--;
+            if (charCodeChecked(pos) !== 125 /* closeBrace */) {
+              if (anyUnicodeModeOrNonAnnexB) {
+                error2(Diagnostics._0_expected, pos, 0, String.fromCharCode(125 /* closeBrace */));
+                pos--;
+              } else {
+                isPreviousTermQuantifiable = true;
+                break;
+              }
+            }
           case 42 /* asterisk */:
           case 43 /* plus */:
           case 63 /* question */:
@@ -13596,7 +13615,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             }
           case 93 /* closeBracket */:
           case 125 /* closeBrace */:
-            if (anyUnicodeMode || ch === 41 /* closeParen */) {
+            if (anyUnicodeModeOrNonAnnexB || ch === 41 /* closeParen */) {
               error2(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
             }
             pos++;
@@ -13645,7 +13664,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
               true
             );
             scanExpectedChar(62 /* greaterThan */);
-          } else if (anyUnicodeMode) {
+          } else if (anyUnicodeModeOrNonAnnexB || namedCaptureGroups) {
             error2(Diagnostics.k_must_be_followed_by_a_capturing_group_name_enclosed_in_angle_brackets, pos - 2, 2);
           }
           break;
@@ -13688,9 +13707,9 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             pos++;
             return String.fromCharCode(ch & 31);
           }
-          if (anyUnicodeMode) {
+          if (anyUnicodeModeOrNonAnnexB) {
             error2(Diagnostics.c_must_be_followed_by_an_ASCII_letter, pos - 2, 2);
-          } else if (atomEscape && annexB) {
+          } else if (atomEscape) {
             pos--;
             return "\\";
           }
@@ -13715,10 +13734,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         default:
           pos--;
           return scanEscapeSequence(
-            /*shouldEmitInvalidEscapeError*/
-            anyUnicodeMode,
-            /*isRegularExpression*/
-            annexB ? "annex-b" : true
+            4 /* RegularExpression */ | (annexB ? 8 /* AnnexB */ : 0) | (anyUnicodeMode ? 16 /* AnyUnicodeMode */ : 0) | (atomEscape ? 32 /* AtomEscape */ : 0)
           );
       }
     }
@@ -13760,12 +13776,12 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           if (isClassContentExit(ch2)) {
             return;
           }
-          if (!minCharacter && !annexB) {
+          if (!minCharacter && anyUnicodeModeOrNonAnnexB) {
             error2(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, minStart, pos - 1 - minStart);
           }
           const maxStart = pos;
           const maxCharacter = scanClassAtom();
-          if (!maxCharacter && !annexB) {
+          if (!maxCharacter && anyUnicodeModeOrNonAnnexB) {
             error2(Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class, maxStart, pos - maxStart);
             continue;
           }
@@ -14195,8 +14211,11 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             if (!anyUnicodeMode) {
               error2(Diagnostics.Unicode_property_value_expressions_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_set, start2, pos - start2);
             }
-          } else if (anyUnicodeMode) {
+          } else if (anyUnicodeModeOrNonAnnexB) {
             error2(Diagnostics._0_must_be_followed_by_a_Unicode_property_value_expression_enclosed_in_braces, pos - 2, 2, String.fromCharCode(ch));
+          } else {
+            pos--;
+            return false;
           }
           return true;
       }
@@ -14236,11 +14255,11 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       }
     });
     forEach(decimalEscapes, (escape) => {
-      if (!annexB && escape.value > numberOfCapturingGroups) {
+      if (escape.value > numberOfCapturingGroups) {
         if (numberOfCapturingGroups) {
           error2(Diagnostics.This_backreference_refers_to_a_group_that_does_not_exist_There_are_only_0_capturing_groups_in_this_regular_expression, escape.pos, escape.end - escape.pos, numberOfCapturingGroups);
         } else {
-          error2(Diagnostics.This_backreference_is_invalid_because_the_containing_regular_expression_contains_no_capturing_groups, escape.pos, escape.end - escape.pos);
+          error2(Diagnostics.This_backreference_refers_to_a_group_that_does_not_exist_There_are_no_capturing_groups_in_this_regular_expression, escape.pos, escape.end - escape.pos);
         }
       }
     });
@@ -29801,7 +29820,7 @@ var addDisposableResourceHelper = {
         var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
             if (value !== null && value !== void 0) {
                 if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-                var dispose;
+                var dispose, inner;
                 if (async) {
                     if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
                     dispose = value[Symbol.asyncDispose];
@@ -29809,8 +29828,10 @@ var addDisposableResourceHelper = {
                 if (dispose === void 0) {
                     if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
                     dispose = value[Symbol.dispose];
+                    if (async) inner = dispose;
                 }
                 if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+                if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
                 env.stack.push({ value: value, dispose: dispose, async: async });
             }
             else if (async) {
@@ -40326,7 +40347,7 @@ var commandOptionsWithoutBuild = [
     showInSimplifiedHelpView: false,
     category: Diagnostics.Compiler_Diagnostics,
     description: Diagnostics.Disable_full_type_checking_only_critical_parse_and_emit_errors_will_be_reported,
-    transpileOptionValue: void 0,
+    transpileOptionValue: true,
     defaultValueDescription: false,
     affectsSemanticDiagnostics: true,
     affectsBuildInfo: true,
@@ -52469,10 +52490,22 @@ function createTypeChecker(host) {
     return !!aliasDeclarationLinks.typeOnlyDeclaration;
   }
   function getTypeOnlyAliasDeclaration(symbol, include) {
+    var _a;
     if (!(symbol.flags & 2097152 /* Alias */)) {
       return void 0;
     }
     const links = getSymbolLinks(symbol);
+    if (links.typeOnlyDeclaration === void 0) {
+      links.typeOnlyDeclaration = false;
+      const resolved = resolveSymbol(symbol);
+      markSymbolOfAliasDeclarationIfTypeOnly(
+        (_a = symbol.declarations) == null ? void 0 : _a[0],
+        getDeclarationOfAliasSymbol(symbol) && getImmediateAliasedSymbol(symbol),
+        resolved,
+        /*overwriteEmpty*/
+        true
+      );
+    }
     if (include === void 0) {
       return links.typeOnlyDeclaration || void 0;
     }
@@ -56215,18 +56248,108 @@ function createTypeChecker(host) {
         cancellationToken.throwIfCancellationRequested();
       }
       let hadError = false;
+      const { finalizeBoundary, startRecoveryScope } = createRecoveryBoundary();
       const transformed = visitNode(existing, visitExistingNodeTreeSymbols, isTypeNode);
-      if (hadError) {
+      if (!finalizeBoundary()) {
         return void 0;
       }
       context.approximateLength += existing.end - existing.pos;
       return transformed;
       function visitExistingNodeTreeSymbols(node) {
+        if (hadError) return node;
+        const recover = startRecoveryScope();
         const onExitNewScope = isNewScopeNode(node) ? onEnterNewScope(node) : void 0;
         const result = visitExistingNodeTreeSymbolsWorker(node);
         onExitNewScope == null ? void 0 : onExitNewScope();
+        if (hadError) {
+          if (isTypeNode(node) && !isTypePredicateNode(node)) {
+            recover();
+            return serializeExistingTypeNode(context, node);
+          }
+          return node;
+        }
         return result === node ? setTextRange2(context, factory.cloneNode(result), node) : result;
       }
+      function createRecoveryBoundary() {
+        let unreportedErrors;
+        const oldTracker = context.tracker;
+        const oldTrackedSymbols = context.trackedSymbols;
+        context.trackedSymbols = [];
+        const oldEncounteredError = context.encounteredError;
+        context.tracker = new SymbolTrackerImpl(context, {
+          ...oldTracker.inner,
+          reportCyclicStructureError() {
+            markError(() => oldTracker.reportCyclicStructureError());
+          },
+          reportInaccessibleThisError() {
+            markError(() => oldTracker.reportInaccessibleThisError());
+          },
+          reportInaccessibleUniqueSymbolError() {
+            markError(() => oldTracker.reportInaccessibleUniqueSymbolError());
+          },
+          reportLikelyUnsafeImportRequiredError(specifier) {
+            markError(() => oldTracker.reportLikelyUnsafeImportRequiredError(specifier));
+          },
+          reportNonSerializableProperty(name) {
+            markError(() => oldTracker.reportNonSerializableProperty(name));
+          },
+          trackSymbol(sym, decl, meaning) {
+            const accessibility = isSymbolAccessible(
+              sym,
+              decl,
+              meaning,
+              /*shouldComputeAliasesToMakeVisible*/
+              false
+            );
+            if (accessibility.accessibility !== 0 /* Accessible */) {
+              (context.trackedSymbols ?? (context.trackedSymbols = [])).push([sym, decl, meaning]);
+              return true;
+            }
+            return false;
+          },
+          moduleResolverHost: context.tracker.moduleResolverHost
+        }, context.tracker.moduleResolverHost);
+        return {
+          startRecoveryScope: startRecoveryScope2,
+          finalizeBoundary: finalizeBoundary2
+        };
+        function markError(unreportedError) {
+          hadError = true;
+          (unreportedErrors ?? (unreportedErrors = [])).push(unreportedError);
+        }
+        function startRecoveryScope2() {
+          var _a;
+          const initialTrackedSymbolsTop = ((_a = context.trackedSymbols) == null ? void 0 : _a.length) ?? 0;
+          const unreportedErrorsTop = (unreportedErrors == null ? void 0 : unreportedErrors.length) ?? 0;
+          return () => {
+            hadError = false;
+            if (context.trackedSymbols) {
+              context.trackedSymbols.length = initialTrackedSymbolsTop;
+            }
+            if (unreportedErrors) {
+              unreportedErrors.length = unreportedErrorsTop;
+            }
+          };
+        }
+        function finalizeBoundary2() {
+          context.tracker = oldTracker;
+          const newTrackedSymbols = context.trackedSymbols;
+          context.trackedSymbols = oldTrackedSymbols;
+          context.encounteredError = oldEncounteredError;
+          unreportedErrors == null ? void 0 : unreportedErrors.forEach((fn) => fn());
+          if (hadError) {
+            return false;
+          }
+          newTrackedSymbols == null ? void 0 : newTrackedSymbols.forEach(
+            ([symbol, enclosingDeclaration, meaning]) => context.tracker.trackSymbol(
+              symbol,
+              enclosingDeclaration,
+              meaning
+            )
+          );
+          return true;
+        }
+      }
       function onEnterNewScope(node) {
         return enterNewScope(context, node, getParametersInScope(node), getTypeParametersInScope(node));
       }
@@ -56500,13 +56623,39 @@ function createTypeChecker(host) {
         }
         function rewriteModuleSpecifier(parent2, lit) {
           if (context.bundled || context.enclosingFile !== getSourceFileOfNode(lit)) {
-            const targetFile = getExternalModuleFileFromDeclaration(parent2);
-            if (targetFile) {
-              const newName = getSpecifierForModuleSymbol(targetFile.symbol, context);
-              if (newName !== lit.text) {
-                return setOriginalNode(factory.createStringLiteral(newName), lit);
+            let name = lit.text;
+            const nodeSymbol = getNodeLinks(node).resolvedSymbol;
+            const meaning = parent2.isTypeOf ? 111551 /* Value */ : 788968 /* Type */;
+            const parentSymbol = nodeSymbol && isSymbolAccessible(
+              nodeSymbol,
+              context.enclosingDeclaration,
+              meaning,
+              /*shouldComputeAliasesToMakeVisible*/
+              false
+            ).accessibility === 0 /* Accessible */ && lookupSymbolChain(
+              nodeSymbol,
+              context,
+              meaning,
+              /*yieldModuleSymbol*/
+              true
+            )[0];
+            if (parentSymbol && parentSymbol.flags & 1536 /* Module */) {
+              name = getSpecifierForModuleSymbol(parentSymbol, context);
+            } else {
+              const targetFile = getExternalModuleFileFromDeclaration(parent2);
+              if (targetFile) {
+                name = getSpecifierForModuleSymbol(targetFile.symbol, context);
               }
             }
+            if (name.includes("/node_modules/")) {
+              context.encounteredError = true;
+              if (context.tracker.reportLikelyUnsafeImportRequiredError) {
+                context.tracker.reportLikelyUnsafeImportRequiredError(name);
+              }
+            }
+            if (name !== lit.text) {
+              return setOriginalNode(factory.createStringLiteral(name), lit);
+            }
           }
           return visitNode(lit, visitExistingNodeTreeSymbols, isStringLiteral);
         }
@@ -64474,7 +64623,6 @@ function createTypeChecker(host) {
     return links.resolvedType;
   }
   function getTemplateLiteralType(texts, types) {
-    var _a, _b;
     const unionIndex = findIndex(types, (t) => !!(t.flags & (131072 /* Never */ | 1048576 /* Union */)));
     if (unionIndex >= 0) {
       return checkCrossProductUnion(types) ? mapType(types[unionIndex], (t) => getTemplateLiteralType(texts, replaceElement(types, unionIndex, t))) : errorType;
@@ -64482,9 +64630,6 @@ function createTypeChecker(host) {
     if (contains(types, wildcardType)) {
       return wildcardType;
     }
-    if (texts.length === 2 && texts[0] === "" && texts[1] === "" && !(types[0].flags & 2944 /* Literal */) && !((_b = (_a = types[0].symbol) == null ? void 0 : _a.declarations) == null ? void 0 : _b.some((d) => d.parent.kind === 195 /* InferType */)) && isTypeAssignableTo(types[0], stringType)) {
-      return types[0];
-    }
     const newTypes = [];
     const newTexts = [];
     let text = texts[0];
@@ -73974,9 +74119,6 @@ function createTypeChecker(host) {
         if (isJsxOpeningLikeElement(location) || isJsxOpeningFragment(location)) {
           return markJsxAliasReferenced(location);
         }
-        if (isFunctionLikeDeclaration(location) || isMethodSignature(location)) {
-          return markAsyncFunctionAliasReferenced(location);
-        }
         if (isImportEqualsDeclaration(location)) {
           if (isInternalModuleImportEqualsDeclaration(location) || checkExternalImportOrExportDeclaration(location)) {
             return markImportEqualsAliasReferenced(location);
@@ -73986,6 +74128,9 @@ function createTypeChecker(host) {
         if (isExportSpecifier(location)) {
           return markExportSpecifierAliasReferenced(location);
         }
+        if (isFunctionLikeDeclaration(location) || isMethodSignature(location)) {
+          markAsyncFunctionAliasReferenced(location);
+        }
         if (!compilerOptions.emitDecoratorMetadata) {
           return;
         }
@@ -74323,18 +74468,12 @@ function createTypeChecker(host) {
     }
     return type;
   }
-  function checkIdentifier(node, checkMode) {
-    if (isThisInTypeQuery(node)) {
-      return checkThisExpression(node);
-    }
-    const symbol = getResolvedSymbol(node);
-    if (symbol === unknownSymbol) {
-      return errorType;
-    }
+  function checkIdentifierCalculateNodeCheckFlags(node, symbol) {
+    if (isThisInTypeQuery(node)) return;
     if (symbol === argumentsSymbol) {
       if (isInPropertyInitializerOrClassStaticBlock(node)) {
         error2(node, Diagnostics.arguments_cannot_be_referenced_in_property_initializers);
-        return errorType;
+        return;
       }
       let container = getContainingFunction(node);
       if (container) {
@@ -74353,17 +74492,14 @@ function createTypeChecker(host) {
           }
         }
       }
-      return getTypeOfSymbol(symbol);
-    }
-    if (shouldMarkIdentifierAliasReferenced(node)) {
-      markLinkedReferences(node, 1 /* Identifier */);
+      return;
     }
     const localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol);
     const targetSymbol = resolveAliasWithDeprecationCheck(localOrExportSymbol, node);
     if (isDeprecatedSymbol(targetSymbol) && isUncalledFunctionReference(node, targetSymbol) && targetSymbol.declarations) {
       addDeprecatedSuggestion(node, targetSymbol.declarations, node.escapedText);
     }
-    let declaration = localOrExportSymbol.valueDeclaration;
+    const declaration = localOrExportSymbol.valueDeclaration;
     if (declaration && localOrExportSymbol.flags & 32 /* Class */) {
       if (isClassLike(declaration) && declaration.name !== node) {
         let container = getThisContainer(
@@ -74390,6 +74526,27 @@ function createTypeChecker(host) {
       }
     }
     checkNestedBlockScopedBinding(node, symbol);
+  }
+  function checkIdentifier(node, checkMode) {
+    if (isThisInTypeQuery(node)) {
+      return checkThisExpression(node);
+    }
+    const symbol = getResolvedSymbol(node);
+    if (symbol === unknownSymbol) {
+      return errorType;
+    }
+    checkIdentifierCalculateNodeCheckFlags(node, symbol);
+    if (symbol === argumentsSymbol) {
+      if (isInPropertyInitializerOrClassStaticBlock(node)) {
+        return errorType;
+      }
+      return getTypeOfSymbol(symbol);
+    }
+    if (shouldMarkIdentifierAliasReferenced(node)) {
+      markLinkedReferences(node, 1 /* Identifier */);
+    }
+    const localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol);
+    let declaration = localOrExportSymbol.valueDeclaration;
     let type = getNarrowedTypeOfSymbol(localOrExportSymbol, node, checkMode);
     const assignmentKind = getAssignmentTargetKind(node);
     if (assignmentKind) {
@@ -75055,7 +75212,31 @@ function createTypeChecker(host) {
         if (!node.asteriskToken && contextualReturnType.flags & 1048576 /* Union */) {
           contextualReturnType = filterType(contextualReturnType, (type) => !!getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, type, isAsyncGenerator));
         }
-        return node.asteriskToken ? contextualReturnType : getIterationTypeOfGeneratorFunctionReturnType(0 /* Yield */, contextualReturnType, isAsyncGenerator);
+        if (node.asteriskToken) {
+          const iterationTypes = getIterationTypesOfGeneratorFunctionReturnType(contextualReturnType, isAsyncGenerator);
+          const yieldType = (iterationTypes == null ? void 0 : iterationTypes.yieldType) ?? silentNeverType;
+          const returnType = getContextualType2(node, contextFlags) ?? silentNeverType;
+          const nextType = (iterationTypes == null ? void 0 : iterationTypes.nextType) ?? unknownType;
+          const generatorType = createGeneratorType(
+            yieldType,
+            returnType,
+            nextType,
+            /*isAsyncGenerator*/
+            false
+          );
+          if (isAsyncGenerator) {
+            const asyncGeneratorType = createGeneratorType(
+              yieldType,
+              returnType,
+              nextType,
+              /*isAsyncGenerator*/
+              true
+            );
+            return getUnionType([generatorType, asyncGeneratorType]);
+          }
+          return generatorType;
+        }
+        return getIterationTypeOfGeneratorFunctionReturnType(0 /* Yield */, contextualReturnType, isAsyncGenerator);
       }
     }
     return void 0;
@@ -80825,7 +81006,7 @@ function createTypeChecker(host) {
       if (nextType) nextType = getWidenedType(nextType);
     }
     if (isGenerator) {
-      return createGeneratorReturnType(
+      return createGeneratorType(
         yieldType || neverType,
         returnType || fallbackReturnType,
         nextType || getContextualIterationType(2 /* Next */, func) || unknownType,
@@ -80835,7 +81016,7 @@ function createTypeChecker(host) {
       return isAsync ? createPromiseType(returnType || fallbackReturnType) : returnType || fallbackReturnType;
     }
   }
-  function createGeneratorReturnType(yieldType, returnType, nextType, isAsyncGenerator) {
+  function createGeneratorType(yieldType, returnType, nextType, isAsyncGenerator) {
     const resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver;
     const globalGeneratorType = resolver.getGlobalGeneratorType(
       /*reportErrors*/
@@ -83220,7 +83401,7 @@ function createTypeChecker(host) {
     const generatorYieldType = getIterationTypeOfGeneratorFunctionReturnType(0 /* Yield */, returnType, (functionFlags & 2 /* Async */) !== 0) || anyType;
     const generatorReturnType = getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, returnType, (functionFlags & 2 /* Async */) !== 0) || generatorYieldType;
     const generatorNextType = getIterationTypeOfGeneratorFunctionReturnType(2 /* Next */, returnType, (functionFlags & 2 /* Async */) !== 0) || unknownType;
-    const generatorInstantiation = createGeneratorReturnType(generatorYieldType, generatorReturnType, generatorNextType, !!(functionFlags & 2 /* Async */));
+    const generatorInstantiation = createGeneratorType(generatorYieldType, generatorReturnType, generatorNextType, !!(functionFlags & 2 /* Async */));
     return checkTypeAssignableTo(generatorInstantiation, returnType, errorNode);
   }
   function checkClassForDuplicateDeclarations(node) {
@@ -89376,7 +89557,6 @@ function createTypeChecker(host) {
       if (links.isDeclarationWithCollidingName === void 0) {
         const container = getEnclosingBlockScopeContainer(symbol.valueDeclaration);
         if (isStatementWithLocals(container) || isSymbolOfDestructuredElementOfCatchBinding(symbol)) {
-          const nodeLinks2 = getNodeLinks(symbol.valueDeclaration);
           if (resolveName(
             container.parent,
             symbol.escapedName,
@@ -89387,8 +89567,8 @@ function createTypeChecker(host) {
             false
           )) {
             links.isDeclarationWithCollidingName = true;
-          } else if (nodeLinks2.flags & 16384 /* CapturedBlockScopedBinding */) {
-            const isDeclaredInLoop = nodeLinks2.flags & 32768 /* BlockScopedBindingInLoop */;
+          } else if (hasNodeCheckFlag(symbol.valueDeclaration, 16384 /* CapturedBlockScopedBinding */)) {
+            const isDeclaredInLoop = hasNodeCheckFlag(symbol.valueDeclaration, 32768 /* BlockScopedBindingInLoop */);
             const inLoopInitializer = isIterationStatement(
               container,
               /*lookInLabeledStatements*/
@@ -89470,6 +89650,9 @@ function createTypeChecker(host) {
     if (!symbol) {
       return false;
     }
+    const container = getSourceFileOfNode(symbol.valueDeclaration);
+    const fileSymbol = container && getSymbolOfDeclaration(container);
+    void resolveExternalModuleSymbol(fileSymbol);
     const target = getExportSymbolOfValueSymbolIfExported(resolveAlias(symbol));
     if (target === unknownSymbol) {
       return !excludeTypeOnlyValues || !getTypeOnlyAliasDeclaration(symbol);
@@ -89568,6 +89751,108 @@ function createTypeChecker(host) {
     if (nodeId < 0 || nodeId >= nodeLinks.length) return 0;
     return ((_a = nodeLinks[nodeId]) == null ? void 0 : _a.flags) || 0;
   }
+  function hasNodeCheckFlag(node, flag) {
+    calculateNodeCheckFlagWorker(node, flag);
+    return !!(getNodeCheckFlags(node) & flag);
+  }
+  function calculateNodeCheckFlagWorker(node, flag) {
+    if (!compilerOptions.noCheck) {
+      return;
+    }
+    const links = getNodeLinks(node);
+    if (links.calculatedFlags & flag) {
+      return;
+    }
+    switch (flag) {
+      case 16 /* SuperInstance */:
+      case 32 /* SuperStatic */:
+        return checkSingleSuperExpression(node);
+      case 128 /* MethodWithSuperPropertyAccessInAsync */:
+      case 256 /* MethodWithSuperPropertyAssignmentInAsync */:
+      case 2097152 /* ContainsSuperPropertyInStaticInitializer */:
+        return checkChildSuperExpressions(node);
+      case 512 /* CaptureArguments */:
+      case 8192 /* ContainsCapturedBlockScopeBinding */:
+      case 65536 /* NeedsLoopOutParameter */:
+      case 262144 /* ContainsConstructorReference */:
+        return checkChildIdentifiers(node);
+      case 536870912 /* ConstructorReference */:
+        return checkSingleIdentifier(node);
+      case 4096 /* LoopWithCapturedBlockScopedBinding */:
+      case 32768 /* BlockScopedBindingInLoop */:
+      case 16384 /* CapturedBlockScopedBinding */:
+        return checkContainingBlockScopeBindingUses(node);
+      default:
+        return Debug.assertNever(flag, `Unhandled node check flag calculation: ${Debug.formatNodeCheckFlags(flag)}`);
+    }
+    function forEachNodeRecursively(root, cb) {
+      const rootResult = cb(root, root.parent);
+      if (rootResult === "skip") return void 0;
+      if (rootResult) return rootResult;
+      return forEachChildRecursively(root, cb);
+    }
+    function checkSuperExpressions(node2) {
+      const links2 = getNodeLinks(node2);
+      if (links2.calculatedFlags & flag) return "skip";
+      links2.calculatedFlags |= 128 /* MethodWithSuperPropertyAccessInAsync */ | 256 /* MethodWithSuperPropertyAssignmentInAsync */ | 2097152 /* ContainsSuperPropertyInStaticInitializer */;
+      checkSingleSuperExpression(node2);
+      return void 0;
+    }
+    function checkChildSuperExpressions(node2) {
+      forEachNodeRecursively(node2, checkSuperExpressions);
+    }
+    function checkSingleSuperExpression(node2) {
+      const nodeLinks2 = getNodeLinks(node2);
+      nodeLinks2.calculatedFlags |= 16 /* SuperInstance */ | 32 /* SuperStatic */;
+      if (node2.kind === 108 /* SuperKeyword */) {
+        checkSuperExpression(node2);
+      }
+    }
+    function checkIdentifiers(node2) {
+      const links2 = getNodeLinks(node2);
+      if (links2.calculatedFlags & flag) return "skip";
+      links2.calculatedFlags |= 512 /* CaptureArguments */ | 8192 /* ContainsCapturedBlockScopeBinding */ | 65536 /* NeedsLoopOutParameter */ | 262144 /* ContainsConstructorReference */;
+      checkSingleIdentifier(node2);
+      return void 0;
+    }
+    function checkChildIdentifiers(node2) {
+      forEachNodeRecursively(node2, checkIdentifiers);
+    }
+    function checkSingleIdentifier(node2) {
+      const nodeLinks2 = getNodeLinks(node2);
+      nodeLinks2.calculatedFlags |= 536870912 /* ConstructorReference */ | 16384 /* CapturedBlockScopedBinding */ | 32768 /* BlockScopedBindingInLoop */;
+      if (isIdentifier(node2) && isExpressionNode(node2) && !(isPropertyAccessExpression(node2.parent) && node2.parent.name === node2)) {
+        const s = getSymbolAtLocation(
+          node2,
+          /*ignoreErrors*/
+          true
+        );
+        if (s && s !== unknownSymbol) {
+          checkIdentifierCalculateNodeCheckFlags(node2, s);
+        }
+      }
+    }
+    function checkBlockScopeBindings(node2) {
+      const links2 = getNodeLinks(node2);
+      if (links2.calculatedFlags & flag) return "skip";
+      links2.calculatedFlags |= 4096 /* LoopWithCapturedBlockScopedBinding */ | 32768 /* BlockScopedBindingInLoop */ | 16384 /* CapturedBlockScopedBinding */;
+      checkSingleBlockScopeBinding(node2);
+      return void 0;
+    }
+    function checkContainingBlockScopeBindingUses(node2) {
+      const scope = getEnclosingBlockScopeContainer(isDeclarationName(node2) ? node2.parent : node2);
+      forEachNodeRecursively(scope, checkBlockScopeBindings);
+    }
+    function checkSingleBlockScopeBinding(node2) {
+      checkSingleIdentifier(node2);
+      if (isComputedPropertyName(node2)) {
+        checkComputedPropertyName(node2);
+      }
+      if (isPrivateIdentifier(node2) && isClassElement(node2.parent)) {
+        setNodeLinksForPrivateIdentifierScope(node2.parent);
+      }
+    }
+  }
   function getEnumMemberValue(node) {
     computeEnumMemberValues(node.parent);
     return getNodeLinks(node).enumMemberValue ?? evaluatorResult(
@@ -89588,7 +89873,15 @@ function createTypeChecker(host) {
     if (node.kind === 306 /* EnumMember */) {
       return getEnumMemberValue(node).value;
     }
-    const symbol = getNodeLinks(node).resolvedSymbol;
+    if (!getNodeLinks(node).resolvedSymbol) {
+      void checkExpressionCached(node);
+    }
+    const symbol = getNodeLinks(node).resolvedSymbol || (isEntityNameExpression(node) ? resolveEntityName(
+      node,
+      111551 /* Value */,
+      /*ignoreErrors*/
+      true
+    ) : void 0);
     if (symbol && symbol.flags & 8 /* EnumMember */) {
       const member = symbol.valueDeclaration;
       if (isEnumConst(member.parent)) {
@@ -89939,9 +90232,10 @@ function createTypeChecker(host) {
         const node = getParseTreeNode(nodeIn);
         return node && canCollectSymbolAliasAccessabilityData ? isReferencedAliasDeclaration(node, checkChildren) : true;
       },
-      getNodeCheckFlags: (nodeIn) => {
+      hasNodeCheckFlag: (nodeIn, flag) => {
         const node = getParseTreeNode(nodeIn);
-        return node ? getNodeCheckFlags(node) : 0;
+        if (!node) return false;
+        return hasNodeCheckFlag(node, flag);
       },
       isTopLevelValueImportEqualsWithEntityName,
       isDeclarationVisible,
@@ -89964,6 +90258,10 @@ function createTypeChecker(host) {
         return node ? getEnumMemberValue(node) : void 0;
       },
       collectLinkedAliases,
+      markLinkedReferences: (nodeIn) => {
+        const node = getParseTreeNode(nodeIn);
+        return node && markLinkedReferences(node, 0 /* Unspecified */);
+      },
       getReferencedValueDeclaration,
       getReferencedValueDeclarations,
       getTypeReferenceSerializationKind,
@@ -97952,7 +98250,7 @@ function transformClassFields(context) {
           containsInstancePrivateElements || (containsInstancePrivateElements = isPrivateIdentifierClassElementDeclaration(member));
         } else if (isPrivateIdentifierClassElementDeclaration(member)) {
           containsInstancePrivateElements = true;
-          if (resolver.getNodeCheckFlags(member) & 262144 /* ContainsConstructorReference */) {
+          if (resolver.hasNodeCheckFlag(member, 262144 /* ContainsConstructorReference */)) {
             facts |= 2 /* NeedsClassConstructorReference */;
           }
         } else if (isPropertyDeclaration(member)) {
@@ -98059,7 +98357,7 @@ function transformClassFields(context) {
     if ((_b = node.emitNode) == null ? void 0 : _b.classThis) {
       getClassLexicalEnvironment().classThis = node.emitNode.classThis;
     }
-    const isClassWithConstructorReference = resolver.getNodeCheckFlags(node) & 262144 /* ContainsConstructorReference */;
+    const isClassWithConstructorReference = resolver.hasNodeCheckFlag(node, 262144 /* ContainsConstructorReference */);
     const isExport = hasSyntacticModifier(node, 32 /* Export */);
     const isDefault = hasSyntacticModifier(node, 2048 /* Default */);
     let modifiers = visitNodes2(node.modifiers, modifierVisitor, isModifier);
@@ -98121,15 +98419,14 @@ function transformClassFields(context) {
     var _a, _b, _c;
     const isDecoratedClassDeclaration = !!(facts & 1 /* ClassWasDecorated */);
     const staticPropertiesOrClassStaticBlocks = getStaticPropertiesAndClassStaticBlock(node);
-    const classCheckFlags = resolver.getNodeCheckFlags(node);
-    const isClassWithConstructorReference = classCheckFlags & 262144 /* ContainsConstructorReference */;
+    const isClassWithConstructorReference = resolver.hasNodeCheckFlag(node, 262144 /* ContainsConstructorReference */);
+    const requiresBlockScopedVar = resolver.hasNodeCheckFlag(node, 32768 /* BlockScopedBindingInLoop */);
     let temp;
     function createClassTempVar() {
       var _a2;
       if (shouldTransformPrivateElementsOrClassStaticBlocks && ((_a2 = node.emitNode) == null ? void 0 : _a2.classThis)) {
         return getClassLexicalEnvironment().classConstructor = node.emitNode.classThis;
       }
-      const requiresBlockScopedVar = classCheckFlags & 32768 /* BlockScopedBindingInLoop */;
       const temp2 = factory2.createTempVariable(
         requiresBlockScopedVar ? addBlockScopedVariable : hoistVariableDeclaration,
         /*reservedInNestedScopes*/
@@ -98697,7 +98994,7 @@ function transformClassFields(context) {
       const alreadyTransformed = !!cacheAssignment || isAssignmentExpression(innerExpression) && isGeneratedIdentifier(innerExpression.left);
       if (!alreadyTransformed && !inlinable && shouldHoist) {
         const generatedName = factory2.getGeneratedNameForNode(name);
-        if (resolver.getNodeCheckFlags(name) & 32768 /* BlockScopedBindingInLoop */) {
+        if (resolver.hasNodeCheckFlag(name, 32768 /* BlockScopedBindingInLoop */)) {
           addBlockScopedVariable(generatedName);
         } else {
           hoistVariableDeclaration(generatedName);
@@ -98851,7 +99148,7 @@ function transformClassFields(context) {
       prefix,
       suffix
     );
-    if (resolver.getNodeCheckFlags(node) & 32768 /* BlockScopedBindingInLoop */) {
+    if (resolver.hasNodeCheckFlag(node, 32768 /* BlockScopedBindingInLoop */)) {
       addBlockScopedVariable(identifier);
     } else {
       hoistVariableDeclaration(identifier);
@@ -99090,7 +99387,7 @@ function transformClassFields(context) {
   }
   function trySubstituteClassAlias(node) {
     if (enabledSubstitutions & 1 /* ClassAliases */) {
-      if (resolver.getNodeCheckFlags(node) & 536870912 /* ConstructorReference */) {
+      if (resolver.hasNodeCheckFlag(node, 536870912 /* ConstructorReference */)) {
         const declaration = resolver.getReferencedValueDeclaration(node);
         if (declaration) {
           const classAlias = classAliases[declaration.id];
@@ -99957,7 +100254,7 @@ function transformLegacyDecorators(context) {
     }
   }
   function getClassAliasIfNeeded(node) {
-    if (resolver.getNodeCheckFlags(node) & 262144 /* ContainsConstructorReference */) {
+    if (resolver.hasNodeCheckFlag(node, 262144 /* ContainsConstructorReference */)) {
       enableSubstitutionForClassAliases();
       const classAlias = factory2.createUniqueName(node.name && !isGeneratedIdentifier(node.name) ? idText(node.name) : "default");
       classAliases[getOriginalNodeId(node)] = classAlias;
@@ -99990,7 +100287,7 @@ function transformLegacyDecorators(context) {
   }
   function trySubstituteClassAlias(node) {
     if (classAliases) {
-      if (resolver.getNodeCheckFlags(node) & 536870912 /* ConstructorReference */) {
+      if (resolver.hasNodeCheckFlag(node, 536870912 /* ConstructorReference */)) {
         const declaration = resolver.getReferencedValueDeclaration(node);
         if (declaration) {
           const classAlias = classAliases[declaration.id];
@@ -102299,7 +102596,7 @@ function transformES2017(context) {
     hasSuperElementAccess = false;
     let updated = visitFunctionBody(node.body, visitor, context);
     const originalMethod = getOriginalNode(node, isFunctionLikeDeclaration);
-    const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */) && (getFunctionFlags(originalMethod) & 3 /* AsyncGenerator */) !== 3 /* AsyncGenerator */;
+    const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && (resolver.hasNodeCheckFlag(node, 256 /* MethodWithSuperPropertyAssignmentInAsync */) || resolver.hasNodeCheckFlag(node, 128 /* MethodWithSuperPropertyAccessInAsync */)) && (getFunctionFlags(originalMethod) & 3 /* AsyncGenerator */) !== 3 /* AsyncGenerator */;
     if (emitSuperHelpers) {
       enableSubstitutionForAsyncMethodsWithSuper();
       if (capturedSuperProperties.size) {
@@ -102310,9 +102607,9 @@ function transformES2017(context) {
         updated = factory2.updateBlock(updated, statements);
       }
       if (hasSuperElementAccess) {
-        if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
+        if (resolver.hasNodeCheckFlag(node, 256 /* MethodWithSuperPropertyAssignmentInAsync */)) {
           addEmitHelper(updated, advancedAsyncSuperHelper);
-        } else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
+        } else if (resolver.hasNodeCheckFlag(node, 128 /* MethodWithSuperPropertyAccessInAsync */)) {
           addEmitHelper(updated, asyncSuperHelper);
         }
       }
@@ -102379,7 +102676,7 @@ function transformES2017(context) {
     const promiseConstructor = languageVersion < 2 /* ES2015 */ ? getPromiseConstructor(nodeType) : void 0;
     const isArrowFunction2 = node.kind === 219 /* ArrowFunction */;
     const savedLexicalArgumentsBinding = lexicalArgumentsBinding;
-    const hasLexicalArguments = (resolver.getNodeCheckFlags(node) & 512 /* CaptureArguments */) !== 0;
+    const hasLexicalArguments = resolver.hasNodeCheckFlag(node, 512 /* CaptureArguments */);
     const captureLexicalArguments = hasLexicalArguments && !lexicalArgumentsBinding;
     if (captureLexicalArguments) {
       lexicalArgumentsBinding = factory2.createUniqueName("arguments");
@@ -102434,7 +102731,7 @@ function transformES2017(context) {
           )
         )
       );
-      const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */);
+      const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && (resolver.hasNodeCheckFlag(node, 256 /* MethodWithSuperPropertyAssignmentInAsync */) || resolver.hasNodeCheckFlag(node, 128 /* MethodWithSuperPropertyAccessInAsync */));
       if (emitSuperHelpers) {
         enableSubstitutionForAsyncMethodsWithSuper();
         if (capturedSuperProperties.size) {
@@ -102453,9 +102750,9 @@ function transformES2017(context) {
       );
       setTextRange(block, node.body);
       if (emitSuperHelpers && hasSuperElementAccess) {
-        if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
+        if (resolver.hasNodeCheckFlag(node, 256 /* MethodWithSuperPropertyAssignmentInAsync */)) {
           addEmitHelper(block, advancedAsyncSuperHelper);
-        } else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
+        } else if (resolver.hasNodeCheckFlag(node, 128 /* MethodWithSuperPropertyAccessInAsync */)) {
           addEmitHelper(block, asyncSuperHelper);
         }
       }
@@ -102514,7 +102811,7 @@ function transformES2017(context) {
   }
   function onEmitNode(hint, node, emitCallback) {
     if (enabledSubstitutions & 1 /* AsyncMethodsWithSuper */ && isSuperContainer(node)) {
-      const superContainerFlags = resolver.getNodeCheckFlags(node) & (128 /* MethodWithSuperPropertyAccessInAsync */ | 256 /* MethodWithSuperPropertyAssignmentInAsync */);
+      const superContainerFlags = (resolver.hasNodeCheckFlag(node, 128 /* MethodWithSuperPropertyAccessInAsync */) ? 128 /* MethodWithSuperPropertyAccessInAsync */ : 0) | (resolver.hasNodeCheckFlag(node, 256 /* MethodWithSuperPropertyAssignmentInAsync */) ? 256 /* MethodWithSuperPropertyAssignmentInAsync */ : 0);
       if (superContainerFlags !== enclosingSuperContainerFlags) {
         const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
         enclosingSuperContainerFlags = superContainerFlags;
@@ -102618,7 +102915,7 @@ function transformES2017(context) {
   }
 }
 function createSuperAccessVariableStatement(factory2, resolver, node, names) {
-  const hasBinding = (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) !== 0;
+  const hasBinding = resolver.hasNodeCheckFlag(node, 256 /* MethodWithSuperPropertyAssignmentInAsync */);
   const accessors = [];
   names.forEach((_, key) => {
     const name = unescapeLeadingUnderscores(key);
@@ -103713,7 +104010,7 @@ function transformES2018(context) {
         !!(hierarchyFacts & 1 /* HasLexicalThis */)
       )
     );
-    const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */);
+    const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && (resolver.hasNodeCheckFlag(node, 256 /* MethodWithSuperPropertyAssignmentInAsync */) || resolver.hasNodeCheckFlag(node, 128 /* MethodWithSuperPropertyAccessInAsync */));
     if (emitSuperHelpers) {
       enableSubstitutionForAsyncMethodsWithSuper();
       const variableStatement = createSuperAccessVariableStatement(factory2, resolver, node, capturedSuperProperties);
@@ -103723,9 +104020,9 @@ function transformES2018(context) {
     outerStatements.push(returnStatement);
     const block = factory2.updateBlock(node.body, outerStatements);
     if (emitSuperHelpers && hasSuperElementAccess) {
-      if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
+      if (resolver.hasNodeCheckFlag(node, 256 /* MethodWithSuperPropertyAssignmentInAsync */)) {
         addEmitHelper(block, advancedAsyncSuperHelper);
-      } else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
+      } else if (resolver.hasNodeCheckFlag(node, 128 /* MethodWithSuperPropertyAccessInAsync */)) {
         addEmitHelper(block, asyncSuperHelper);
       }
     }
@@ -103858,7 +104155,7 @@ function transformES2018(context) {
   }
   function onEmitNode(hint, node, emitCallback) {
     if (enabledSubstitutions & 1 /* AsyncMethodsWithSuper */ && isSuperContainer(node)) {
-      const superContainerFlags = resolver.getNodeCheckFlags(node) & (128 /* MethodWithSuperPropertyAccessInAsync */ | 256 /* MethodWithSuperPropertyAssignmentInAsync */);
+      const superContainerFlags = (resolver.hasNodeCheckFlag(node, 128 /* MethodWithSuperPropertyAccessInAsync */) ? 128 /* MethodWithSuperPropertyAccessInAsync */ : 0) | (resolver.hasNodeCheckFlag(node, 256 /* MethodWithSuperPropertyAssignmentInAsync */) ? 256 /* MethodWithSuperPropertyAssignmentInAsync */ : 0);
       if (superContainerFlags !== enclosingSuperContainerFlags) {
         const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
         enclosingSuperContainerFlags = superContainerFlags;
@@ -107563,9 +107860,8 @@ function transformES2015(context) {
     return createRange(pos, end);
   }
   function shouldEmitExplicitInitializerForLetDeclaration(node) {
-    const flags = resolver.getNodeCheckFlags(node);
-    const isCapturedInFunction = flags & 16384 /* CapturedBlockScopedBinding */;
-    const isDeclaredInLoop = flags & 32768 /* BlockScopedBindingInLoop */;
+    const isCapturedInFunction = resolver.hasNodeCheckFlag(node, 16384 /* CapturedBlockScopedBinding */);
+    const isDeclaredInLoop = resolver.hasNodeCheckFlag(node, 32768 /* BlockScopedBindingInLoop */);
     const emittedAsTopLevel = (hierarchyFacts & 64 /* TopLevel */) !== 0 || isCapturedInFunction && isDeclaredInLoop && (hierarchyFacts & 512 /* IterationStatementBlock */) !== 0;
     const emitExplicitInitializer = !emittedAsTopLevel && (hierarchyFacts & 4096 /* ForInOrForOfStatement */) === 0 && (!resolver.isDeclarationWithCollidingName(node) || isDeclaredInLoop && !isCapturedInFunction && (hierarchyFacts & (2048 /* ForStatement */ | 4096 /* ForInOrForOfStatement */)) === 0);
     return emitExplicitInitializer;
@@ -108016,7 +108312,7 @@ function transformES2015(context) {
     return factory2.inlineExpressions(expressions);
   }
   function shouldConvertPartOfIterationStatement(node) {
-    return (resolver.getNodeCheckFlags(node) & 8192 /* ContainsCapturedBlockScopeBinding */) !== 0;
+    return resolver.hasNodeCheckFlag(node, 8192 /* ContainsCapturedBlockScopeBinding */);
   }
   function shouldConvertInitializerOfForStatement(node) {
     return isForStatement(node) && !!node.initializer && shouldConvertPartOfIterationStatement(node.initializer);
@@ -108031,7 +108327,7 @@ function transformES2015(context) {
     return shouldConvertBodyOfIterationStatement(node) || shouldConvertInitializerOfForStatement(node);
   }
   function shouldConvertBodyOfIterationStatement(node) {
-    return (resolver.getNodeCheckFlags(node) & 4096 /* LoopWithCapturedBlockScopedBinding */) !== 0;
+    return resolver.hasNodeCheckFlag(node, 4096 /* LoopWithCapturedBlockScopedBinding */);
   }
   function hoistVariableDeclarationDeclaredInConvertedLoop(state, node) {
     if (!state.hoistedLocalVariables) {
@@ -108580,11 +108876,11 @@ function transformES2015(context) {
         void 0,
         name
       ));
-      const checkFlags = resolver.getNodeCheckFlags(decl);
-      if (checkFlags & 65536 /* NeedsLoopOutParameter */ || hasCapturedBindingsInForHead) {
+      const needsOutParam = resolver.hasNodeCheckFlag(decl, 65536 /* NeedsLoopOutParameter */);
+      if (needsOutParam || hasCapturedBindingsInForHead) {
         const outParamName = factory2.createUniqueName("out_" + idText(name));
         let flags = 0 /* None */;
-        if (checkFlags & 65536 /* NeedsLoopOutParameter */) {
+        if (needsOutParam) {
           flags |= 1 /* Body */;
         }
         if (isForStatement(container)) {
@@ -117618,6 +117914,9 @@ function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, decla
       emitSkipped = true;
       return;
     }
+    if (compilerOptions.noCheck) {
+      (isSourceFile(sourceFileOrBundle) ? [sourceFileOrBundle] : filter(sourceFileOrBundle.sourceFiles, isSourceFileNotJson)).forEach(markLinkedReferences);
+    }
     const transform2 = transformNodes(
       resolver,
       host,
@@ -117752,6 +118051,13 @@ function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, decla
     }
     forEachChild(node, collectLinkedAliases);
   }
+  function markLinkedReferences(file) {
+    forEachChildRecursively(file, (n) => {
+      if (isImportEqualsDeclaration(n) && !(getSyntacticModifierFlags(n) & 32 /* Export */)) return "skip";
+      if (isImportDeclaration(n)) return "skip";
+      resolver.markLinkedReferences(n);
+    });
+  }
   function printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform2, printer, mapOptions) {
     const sourceFileOrBundle = transform2.transformed[0];
     const bundle = sourceFileOrBundle.kind === 308 /* Bundle */ ? sourceFileOrBundle : void 0;
@@ -117883,10 +118189,11 @@ var notImplementedResolver = {
   isValueAliasDeclaration: notImplemented,
   isReferencedAliasDeclaration: notImplemented,
   isTopLevelValueImportEqualsWithEntityName: notImplemented,
-  getNodeCheckFlags: notImplemented,
+  hasNodeCheckFlag: notImplemented,
   isDeclarationVisible: notImplemented,
   isLateBound: (_node) => false,
   collectLinkedAliases: notImplemented,
+  markLinkedReferences: notImplemented,
   isImplementationOfOverload: notImplemented,
   requiresAddingImplicitUndefined: notImplemented,
   isExpandoFunctionDeclaration: notImplemented,
@@ -126022,9 +126329,6 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       if (options.noEmit) {
         createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "noCheck", "noEmit");
       }
-      if (!options.emitDeclarationOnly) {
-        createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "noCheck", "emitDeclarationOnly");
-      }
     }
     if (options.emitDecoratorMetadata && !options.experimentalDecorators) {
       createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "emitDecoratorMetadata", "experimentalDecorators");
@@ -141150,7 +141454,6 @@ function transpileWorker(input, transpileOptions, declaration) {
     options.declaration = true;
     options.emitDeclarationOnly = true;
     options.isolatedDeclarations = true;
-    options.noCheck = true;
   } else {
     options.declaration = false;
   }
@@ -143828,7 +144131,7 @@ function getExistingLocals(sourceFile, statements, checker) {
   for (const statement of statements) {
     forEachReference(statement, checker, (s) => {
       const symbol = skipAlias(s, checker);
-      if (symbol.valueDeclaration && getSourceFileOfNode(symbol.valueDeclaration) === sourceFile) {
+      if (symbol.valueDeclaration && getSourceFileOfNode(symbol.valueDeclaration).path === sourceFile.path) {
         existingLocals.add(symbol);
       }
     });
@@ -177780,7 +178083,14 @@ function pasteEdits(targetFile, pastedText, pasteLocations, copiedFrom, host, pr
     if (copiedFrom == null ? void 0 : copiedFrom.range) {
       Debug.assert(copiedFrom.range.length === pastedText.length);
       copiedFrom.range.forEach((copy) => {
-        addRange(statements, copiedFrom.file.statements, getLineOfLocalPosition(copiedFrom.file, copy.pos), getLineOfLocalPosition(copiedFrom.file, copy.end) + 1);
+        const statementsInSourceFile = copiedFrom.file.statements;
+        const startNodeIndex = findIndex(statementsInSourceFile, (s) => s.end > copy.pos);
+        if (startNodeIndex === -1) return void 0;
+        let endNodeIndex = findIndex(statementsInSourceFile, (s) => s.end >= copy.end, startNodeIndex);
+        if (endNodeIndex !== -1 && copy.end <= statementsInSourceFile[endNodeIndex].getStart()) {
+          endNodeIndex--;
+        }
+        statements.push(...statementsInSourceFile.slice(startNodeIndex, endNodeIndex === -1 ? statementsInSourceFile.length : endNodeIndex + 1));
       });
       const usage = getUsageInfo(copiedFrom.file, statements, originalProgram.getTypeChecker(), getExistingLocals(updatedFile, statements, originalProgram.getTypeChecker()));
       Debug.assertIsDefined(originalProgram);