typescript 5.5.0-dev.20240530 → 5.5.0-dev.20240601

package/lib/typescript.js

@@ -260,6 +260,7 @@ __export(typescript_exports, {
   canHaveModifiers: () => canHaveModifiers,
   canHaveModuleSpecifier: () => canHaveModuleSpecifier,
   canHaveSymbol: () => canHaveSymbol,
+  canIncludeBindAndCheckDiagnsotics: () => canIncludeBindAndCheckDiagnsotics,
   canJsonReportNoInputFiles: () => canJsonReportNoInputFiles,
   canProduceDiagnostics: () => canProduceDiagnostics,
   canUsePropertyAccess: () => canUsePropertyAccess,
@@ -2370,7 +2371,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240530`;
+var version = `${versionMajorMinor}.0-dev.20240601`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -4252,6 +4253,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 +6554,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";
@@ -13391,7 +13402,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         pos++;
         let regExpFlags = 0 /* None */;
         while (true) {
-          const ch = codePointChecked(pos);
+          const ch = charCodeChecked(pos);
           if (ch === -1 /* EOF */ || !isIdentifierPart(ch, languageVersion)) {
             break;
           }
@@ -14642,10 +14653,10 @@ var binaryUnicodeProperties = /* @__PURE__ */ new Set(["ASCII", "ASCII_Hex_Digit
 var binaryUnicodePropertiesOfStrings = /* @__PURE__ */ new Set(["Basic_Emoji", "Emoji_Keycap_Sequence", "RGI_Emoji_Modifier_Sequence", "RGI_Emoji_Flag_Sequence", "RGI_Emoji_Tag_Sequence", "RGI_Emoji_ZWJ_Sequence", "RGI_Emoji"]);
 var valuesOfNonBinaryUnicodeProperties = {
   General_Category: /* @__PURE__ */ new Set(["C", "Other", "Cc", "Control", "cntrl", "Cf", "Format", "Cn", "Unassigned", "Co", "Private_Use", "Cs", "Surrogate", "L", "Letter", "LC", "Cased_Letter", "Ll", "Lowercase_Letter", "Lm", "Modifier_Letter", "Lo", "Other_Letter", "Lt", "Titlecase_Letter", "Lu", "Uppercase_Letter", "M", "Mark", "Combining_Mark", "Mc", "Spacing_Mark", "Me", "Enclosing_Mark", "Mn", "Nonspacing_Mark", "N", "Number", "Nd", "Decimal_Number", "digit", "Nl", "Letter_Number", "No", "Other_Number", "P", "Punctuation", "punct", "Pc", "Connector_Punctuation", "Pd", "Dash_Punctuation", "Pe", "Close_Punctuation", "Pf", "Final_Punctuation", "Pi", "Initial_Punctuation", "Po", "Other_Punctuation", "Ps", "Open_Punctuation", "S", "Symbol", "Sc", "Currency_Symbol", "Sk", "Modifier_Symbol", "Sm", "Math_Symbol", "So", "Other_Symbol", "Z", "Separator", "Zl", "Line_Separator", "Zp", "Paragraph_Separator", "Zs", "Space_Separator"]),
-  Script: /* @__PURE__ */ new Set(["Adlm", "Adlam", "Aghb", "Caucasian_Albanian", "Ahom", "Ahom", "Arab", "Arabic", "Armi", "Imperial_Aramaic", "Armn", "Armenian", "Avst", "Avestan", "Bali", "Balinese", "Bamu", "Bamum", "Bass", "Bassa_Vah", "Batk", "Batak", "Beng", "Bengali", "Bhks", "Bhaiksuki", "Bopo", "Bopomofo", "Brah", "Brahmi", "Brai", "Braille", "Bugi", "Buginese", "Buhd", "Buhid", "Cakm", "Chakma", "Cans", "Canadian_Aboriginal", "Cari", "Carian", "Cham", "Cham", "Cher", "Cherokee", "Chrs", "Chorasmian", "Copt", "Coptic", "Qaac", "Cpmn", "Cypro_Minoan", "Cprt", "Cypriot", "Cyrl", "Cyrillic", "Deva", "Devanagari", "Diak", "Dives_Akuru", "Dogr", "Dogra", "Dsrt", "Deseret", "Dupl", "Duployan", "Egyp", "Egyptian_Hieroglyphs", "Elba", "Elbasan", "Elym", "Elymaic", "Ethi", "Ethiopic", "Geor", "Georgian", "Glag", "Glagolitic", "Gong", "Gunjala_Gondi", "Gonm", "Masaram_Gondi", "Goth", "Gothic", "Gran", "Grantha", "Grek", "Greek", "Gujr", "Gujarati", "Guru", "Gurmukhi", "Hang", "Hangul", "Hani", "Han", "Hano", "Hanunoo", "Hatr", "Hatran", "Hebr", "Hebrew", "Hira", "Hiragana", "Hluw", "Anatolian_Hieroglyphs", "Hmng", "Pahawh_Hmong", "Hmnp", "Nyiakeng_Puachue_Hmong", "Hrkt", "Katakana_Or_Hiragana", "Hung", "Old_Hungarian", "Ital", "Old_Italic", "Java", "Javanese", "Kali", "Kayah_Li", "Kana", "Katakana", "Kawi", "Kawi", "Khar", "Kharoshthi", "Khmr", "Khmer", "Khoj", "Khojki", "Kits", "Khitan_Small_Script", "Knda", "Kannada", "Kthi", "Kaithi", "Lana", "Tai_Tham", "Laoo", "Lao", "Latn", "Latin", "Lepc", "Lepcha", "Limb", "Limbu", "Lina", "Linear_A", "Linb", "Linear_B", "Lisu", "Lisu", "Lyci", "Lycian", "Lydi", "Lydian", "Mahj", "Mahajani", "Maka", "Makasar", "Mand", "Mandaic", "Mani", "Manichaean", "Marc", "Marchen", "Medf", "Medefaidrin", "Mend", "Mende_Kikakui", "Merc", "Meroitic_Cursive", "Mero", "Meroitic_Hieroglyphs", "Mlym", "Malayalam", "Modi", "Modi", "Mong", "Mongolian", "Mroo", "Mro", "Mtei", "Meetei_Mayek", "Mult", "Multani", "Mymr", "Myanmar", "Nagm", "Nag_Mundari", "Nand", "Nandinagari", "Narb", "Old_North_Arabian", "Nbat", "Nabataean", "Newa", "Newa", "Nkoo", "Nko", "Nshu", "Nushu", "Ogam", "Ogham", "Olck", "Ol_Chiki", "Orkh", "Old_Turkic", "Orya", "Oriya", "Osge", "Osage", "Osma", "Osmanya", "Ougr", "Old_Uyghur", "Palm", "Palmyrene", "Pauc", "Pau_Cin_Hau", "Perm", "Old_Permic", "Phag", "Phags_Pa", "Phli", "Inscriptional_Pahlavi", "Phlp", "Psalter_Pahlavi", "Phnx", "Phoenician", "Plrd", "Miao", "Prti", "Inscriptional_Parthian", "Rjng", "Rejang", "Rohg", "Hanifi_Rohingya", "Runr", "Runic", "Samr", "Samaritan", "Sarb", "Old_South_Arabian", "Saur", "Saurashtra", "Sgnw", "SignWriting", "Shaw", "Shavian", "Shrd", "Sharada", "Sidd", "Siddham", "Sind", "Khudawadi", "Sinh", "Sinhala", "Sogd", "Sogdian", "Sogo", "Old_Sogdian", "Sora", "Sora_Sompeng", "Soyo", "Soyombo", "Sund", "Sundanese", "Sylo", "Syloti_Nagri", "Syrc", "Syriac", "Tagb", "Tagbanwa", "Takr", "Takri", "Tale", "Tai_Le", "Talu", "New_Tai_Lue", "Taml", "Tamil", "Tang", "Tangut", "Tavt", "Tai_Viet", "Telu", "Telugu", "Tfng", "Tifinagh", "Tglg", "Tagalog", "Thaa", "Thaana", "Thai", "Thai", "Tibt", "Tibetan", "Tirh", "Tirhuta", "Tnsa", "Tangsa", "Toto", "Toto", "Ugar", "Ugaritic", "Vaii", "Vai", "Vith", "Vithkuqi", "Wara", "Warang_Citi", "Wcho", "Wancho", "Xpeo", "Old_Persian", "Xsux", "Cuneiform", "Yezi", "Yezidi", "Yiii", "Yi", "Zanb", "Zanabazar_Square", "Zinh", "Inherited", "Qaai", "Zyyy", "Common", "Zzzz", "Unknown"]),
-  Script_Extensions: /* @__PURE__ */ new Set()
-  // Currently empty
+  Script: /* @__PURE__ */ new Set(["Adlm", "Adlam", "Aghb", "Caucasian_Albanian", "Ahom", "Arab", "Arabic", "Armi", "Imperial_Aramaic", "Armn", "Armenian", "Avst", "Avestan", "Bali", "Balinese", "Bamu", "Bamum", "Bass", "Bassa_Vah", "Batk", "Batak", "Beng", "Bengali", "Bhks", "Bhaiksuki", "Bopo", "Bopomofo", "Brah", "Brahmi", "Brai", "Braille", "Bugi", "Buginese", "Buhd", "Buhid", "Cakm", "Chakma", "Cans", "Canadian_Aboriginal", "Cari", "Carian", "Cham", "Cher", "Cherokee", "Chrs", "Chorasmian", "Copt", "Coptic", "Qaac", "Cpmn", "Cypro_Minoan", "Cprt", "Cypriot", "Cyrl", "Cyrillic", "Deva", "Devanagari", "Diak", "Dives_Akuru", "Dogr", "Dogra", "Dsrt", "Deseret", "Dupl", "Duployan", "Egyp", "Egyptian_Hieroglyphs", "Elba", "Elbasan", "Elym", "Elymaic", "Ethi", "Ethiopic", "Geor", "Georgian", "Glag", "Glagolitic", "Gong", "Gunjala_Gondi", "Gonm", "Masaram_Gondi", "Goth", "Gothic", "Gran", "Grantha", "Grek", "Greek", "Gujr", "Gujarati", "Guru", "Gurmukhi", "Hang", "Hangul", "Hani", "Han", "Hano", "Hanunoo", "Hatr", "Hatran", "Hebr", "Hebrew", "Hira", "Hiragana", "Hluw", "Anatolian_Hieroglyphs", "Hmng", "Pahawh_Hmong", "Hmnp", "Nyiakeng_Puachue_Hmong", "Hrkt", "Katakana_Or_Hiragana", "Hung", "Old_Hungarian", "Ital", "Old_Italic", "Java", "Javanese", "Kali", "Kayah_Li", "Kana", "Katakana", "Kawi", "Khar", "Kharoshthi", "Khmr", "Khmer", "Khoj", "Khojki", "Kits", "Khitan_Small_Script", "Knda", "Kannada", "Kthi", "Kaithi", "Lana", "Tai_Tham", "Laoo", "Lao", "Latn", "Latin", "Lepc", "Lepcha", "Limb", "Limbu", "Lina", "Linear_A", "Linb", "Linear_B", "Lisu", "Lyci", "Lycian", "Lydi", "Lydian", "Mahj", "Mahajani", "Maka", "Makasar", "Mand", "Mandaic", "Mani", "Manichaean", "Marc", "Marchen", "Medf", "Medefaidrin", "Mend", "Mende_Kikakui", "Merc", "Meroitic_Cursive", "Mero", "Meroitic_Hieroglyphs", "Mlym", "Malayalam", "Modi", "Mong", "Mongolian", "Mroo", "Mro", "Mtei", "Meetei_Mayek", "Mult", "Multani", "Mymr", "Myanmar", "Nagm", "Nag_Mundari", "Nand", "Nandinagari", "Narb", "Old_North_Arabian", "Nbat", "Nabataean", "Newa", "Nkoo", "Nko", "Nshu", "Nushu", "Ogam", "Ogham", "Olck", "Ol_Chiki", "Orkh", "Old_Turkic", "Orya", "Oriya", "Osge", "Osage", "Osma", "Osmanya", "Ougr", "Old_Uyghur", "Palm", "Palmyrene", "Pauc", "Pau_Cin_Hau", "Perm", "Old_Permic", "Phag", "Phags_Pa", "Phli", "Inscriptional_Pahlavi", "Phlp", "Psalter_Pahlavi", "Phnx", "Phoenician", "Plrd", "Miao", "Prti", "Inscriptional_Parthian", "Rjng", "Rejang", "Rohg", "Hanifi_Rohingya", "Runr", "Runic", "Samr", "Samaritan", "Sarb", "Old_South_Arabian", "Saur", "Saurashtra", "Sgnw", "SignWriting", "Shaw", "Shavian", "Shrd", "Sharada", "Sidd", "Siddham", "Sind", "Khudawadi", "Sinh", "Sinhala", "Sogd", "Sogdian", "Sogo", "Old_Sogdian", "Sora", "Sora_Sompeng", "Soyo", "Soyombo", "Sund", "Sundanese", "Sylo", "Syloti_Nagri", "Syrc", "Syriac", "Tagb", "Tagbanwa", "Takr", "Takri", "Tale", "Tai_Le", "Talu", "New_Tai_Lue", "Taml", "Tamil", "Tang", "Tangut", "Tavt", "Tai_Viet", "Telu", "Telugu", "Tfng", "Tifinagh", "Tglg", "Tagalog", "Thaa", "Thaana", "Thai", "Tibt", "Tibetan", "Tirh", "Tirhuta", "Tnsa", "Tangsa", "Toto", "Ugar", "Ugaritic", "Vaii", "Vai", "Vith", "Vithkuqi", "Wara", "Warang_Citi", "Wcho", "Wancho", "Xpeo", "Old_Persian", "Xsux", "Cuneiform", "Yezi", "Yezidi", "Yiii", "Yi", "Zanb", "Zanabazar_Square", "Zinh", "Inherited", "Qaai", "Zyyy", "Common", "Zzzz", "Unknown"]),
+  Script_Extensions: void 0
 };
+valuesOfNonBinaryUnicodeProperties.Script_Extensions = valuesOfNonBinaryUnicodeProperties.Script;
 
 // src/compiler/utilitiesPublic.ts
 function isExternalModuleNameRelative(moduleName) {
@@ -17504,6 +17515,26 @@ function getErrorSpanForNode(sourceFile, node) {
       const pos2 = skipTrivia(sourceFile.text, node.tagName.pos);
       return getSpanOfTokenAtPosition(sourceFile, pos2);
     }
+    case 176 /* Constructor */: {
+      const constructorDeclaration = node;
+      const start = skipTrivia(sourceFile.text, constructorDeclaration.pos);
+      const scanner2 = createScanner(
+        sourceFile.languageVersion,
+        /*skipTrivia*/
+        true,
+        sourceFile.languageVariant,
+        sourceFile.text,
+        /*onError*/
+        void 0,
+        start
+      );
+      let token = scanner2.scan();
+      while (token !== 137 /* ConstructorKeyword */ && token !== 1 /* EndOfFileToken */) {
+        token = scanner2.scan();
+      }
+      const end = scanner2.getTokenEnd();
+      return createTextSpanFromBounds(start, end);
+    }
   }
   if (errorNode === void 0) {
     return getSpanOfTokenAtPosition(sourceFile, node.pos);
@@ -22501,7 +22532,15 @@ function rangeOfTypeParameters(sourceFile, typeParameters) {
   return { pos, end };
 }
 function skipTypeChecking(sourceFile, options, host) {
-  return options.skipLibCheck && sourceFile.isDeclarationFile || options.skipDefaultLibCheck && sourceFile.hasNoDefaultLib || options.noCheck || host.isSourceOfProjectReferenceRedirect(sourceFile.fileName);
+  return options.skipLibCheck && sourceFile.isDeclarationFile || options.skipDefaultLibCheck && sourceFile.hasNoDefaultLib || options.noCheck || host.isSourceOfProjectReferenceRedirect(sourceFile.fileName) || !canIncludeBindAndCheckDiagnsotics(sourceFile, options);
+}
+function canIncludeBindAndCheckDiagnsotics(sourceFile, options) {
+  if (!!sourceFile.checkJsDirective && sourceFile.checkJsDirective.enabled === false) return false;
+  if (sourceFile.scriptKind === 3 /* TS */ || sourceFile.scriptKind === 4 /* TSX */ || sourceFile.scriptKind === 5 /* External */) return true;
+  const isJs = sourceFile.scriptKind === 1 /* JS */ || sourceFile.scriptKind === 2 /* JSX */;
+  const isCheckJs = isJs && isCheckJsEnabledForFile(sourceFile, options);
+  const isPlainJs = isPlainJsFile(sourceFile, options.checkJs);
+  return isPlainJs || isCheckJs || sourceFile.scriptKind === 7 /* Deferred */;
 }
 function isJsonEqual(a, b) {
   return a === b || typeof a === "object" && a !== null && typeof b === "object" && b !== null && equalOwnProperties(a, b, isJsonEqual);
@@ -40337,7 +40376,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,
@@ -50132,6 +50171,7 @@ function createTypeChecker(host) {
     getImmediateAliasedSymbol,
     getAliasedSymbol: resolveAlias,
     getEmitResolver,
+    requiresAddingImplicitUndefined,
     getExportsOfModule: getExportsOfModuleAsArray,
     getExportsAndPropertiesOfModule,
     forEachExportAndPropertyOfModule,
@@ -52480,10 +52520,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;
     }
@@ -54001,7 +54053,7 @@ function createTypeChecker(host) {
       return noMappedTypes && mappedType !== type ? void 0 : mappedType;
     }
     function setTextRange2(context, range, location) {
-      if (!nodeIsSynthesized(range) && !(range.flags & 16 /* Synthesized */) && (!context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(range))) {
+      if (!nodeIsSynthesized(range) || !(range.flags & 16 /* Synthesized */) || !context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(getOriginalNode(range))) {
         range = factory.cloneNode(range);
       }
       if (range === location) return range;
@@ -54940,7 +54992,8 @@ function createTypeChecker(host) {
           const getterDeclaration = getDeclarationOfKind(propertySymbol, 177 /* GetAccessor */);
           const getterSignature = getSignatureFromDeclaration(getterDeclaration);
           typeElements.push(
-            setCommentRange(
+            setCommentRange2(
+              context,
               signatureToSignatureDeclarationHelper(getterSignature, 177 /* GetAccessor */, context, { name: propertyName }),
               getterDeclaration
             )
@@ -54948,7 +55001,8 @@ function createTypeChecker(host) {
           const setterDeclaration = getDeclarationOfKind(propertySymbol, 178 /* SetAccessor */);
           const setterSignature = getSignatureFromDeclaration(setterDeclaration);
           typeElements.push(
-            setCommentRange(
+            setCommentRange2(
+              context,
               signatureToSignatureDeclarationHelper(setterSignature, 178 /* SetAccessor */, context, { name: propertyName }),
               setterDeclaration
             )
@@ -55006,11 +55060,17 @@ function createTypeChecker(host) {
             setSyntheticLeadingComments(node, [{ kind: 3 /* MultiLineCommentTrivia */, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]);
           }
         } else if (propertySymbol.valueDeclaration) {
-          setCommentRange(node, propertySymbol.valueDeclaration);
+          setCommentRange2(context, node, propertySymbol.valueDeclaration);
         }
         return node;
       }
     }
+    function setCommentRange2(context, node, range) {
+      if (context.enclosingFile && context.enclosingFile === getSourceFileOfNode(range)) {
+        return setCommentRange(node, range);
+      }
+      return node;
+    }
     function mapToTypeNodes(types, context, isBareList) {
       if (some(types)) {
         if (checkTruncationLength(context)) {
@@ -55786,7 +55846,7 @@ function createTypeChecker(host) {
       return false;
     }
     function typeParameterToName(type, context) {
-      var _a, _b;
+      var _a, _b, _c, _d;
       if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && context.typeParameterNames) {
         const cached = context.typeParameterNames.get(getTypeId(type));
         if (cached) {
@@ -55803,11 +55863,15 @@ function createTypeChecker(host) {
       if (!(result.kind & 80 /* Identifier */)) {
         return factory.createIdentifier("(Missing type parameter)");
       }
+      const decl = (_b = (_a = type.symbol) == null ? void 0 : _a.declarations) == null ? void 0 : _b[0];
+      if (decl && isTypeParameterDeclaration(decl)) {
+        result = setTextRange2(context, result, decl.name);
+      }
       if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
         const rawtext = result.escapedText;
-        let i = ((_a = context.typeParameterNamesByTextNextNameCount) == null ? void 0 : _a.get(rawtext)) || 0;
+        let i = ((_c = context.typeParameterNamesByTextNextNameCount) == null ? void 0 : _c.get(rawtext)) || 0;
         let text = rawtext;
-        while (((_b = context.typeParameterNamesByText) == null ? void 0 : _b.has(text)) || typeParameterShadowsOtherTypeParameterInScope(text, context, type)) {
+        while (((_d = context.typeParameterNamesByText) == null ? void 0 : _d.has(text)) || typeParameterShadowsOtherTypeParameterInScope(text, context, type)) {
           i++;
           text = `${rawtext}_${i}`;
         }
@@ -56226,21 +56290,136 @@ 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();
-        return result === node ? setTextRange2(context, factory.cloneNode(result), node) : result;
+        if (hadError) {
+          if (isTypeNode(node) && !isTypePredicateNode(node)) {
+            recover();
+            return serializeExistingTypeNode(context, node);
+          }
+          return node;
+        }
+        return result ? setTextRange2(context, result, node) : void 0;
+      }
+      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));
       }
+      function tryVisitTypeReference(node) {
+        if (canReuseTypeNode(context, node)) {
+          const { introducesError, node: newName } = trackExistingEntityName(node.typeName, context);
+          const typeArguments = visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode);
+          if (!introducesError) {
+            const updated = factory.updateTypeReferenceNode(
+              node,
+              newName,
+              typeArguments
+            );
+            return setTextRange2(context, updated, node);
+          } else {
+            const serializedName = serializeTypeName(
+              context,
+              node.typeName,
+              /*isTypeOf*/
+              false,
+              typeArguments
+            );
+            if (serializedName) {
+              return setTextRange2(context, serializedName, node.typeName);
+            }
+          }
+        }
+      }
       function visitExistingNodeTreeSymbolsWorker(node) {
         if (isJSDocTypeExpression(node)) {
           return visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode);
@@ -56337,7 +56516,8 @@ function createTypeChecker(host) {
           if (canReuseTypeNode(context, node)) {
             return node;
           }
-          return serializeExistingTypeNode(context, node);
+          hadError = true;
+          return node;
         }
         if (isTypeParameterDeclaration(node)) {
           return factory.updateTypeParameterDeclaration(
@@ -56348,31 +56528,21 @@ function createTypeChecker(host) {
             visitNode(node.default, visitExistingNodeTreeSymbols, isTypeNode)
           );
         }
+        if (isIndexedAccessTypeNode(node) && isTypeReferenceNode(node.objectType)) {
+          const objectType = tryVisitTypeReference(node.objectType);
+          if (!objectType) {
+            hadError = true;
+            return node;
+          }
+          return factory.updateIndexedAccessTypeNode(node, objectType, visitNode(node.indexType, visitExistingNodeTreeSymbols, isTypeNode));
+        }
         if (isTypeReferenceNode(node)) {
-          if (canReuseTypeNode(context, node)) {
-            const { introducesError, node: newName } = trackExistingEntityName(node.typeName, context);
-            const typeArguments = visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode);
-            if (!introducesError) {
-              const updated = factory.updateTypeReferenceNode(
-                node,
-                newName,
-                typeArguments
-              );
-              return setTextRange2(context, updated, node);
-            } else {
-              const serializedName = serializeTypeName(
-                context,
-                node.typeName,
-                /*isTypeOf*/
-                false,
-                typeArguments
-              );
-              if (serializedName) {
-                return setTextRange2(context, serializedName, node.typeName);
-              }
-            }
+          const result = tryVisitTypeReference(node);
+          if (result) {
+            return result;
           }
-          return serializeExistingTypeNode(context, node);
+          hadError = true;
+          return node;
         }
         if (isLiteralImportTypeNode(node)) {
           const nodeSymbol = getNodeLinks(node).resolvedSymbol;
@@ -56396,12 +56566,7 @@ function createTypeChecker(host) {
           }
         }
         if (isFunctionLike(node) && !node.type || isPropertyDeclaration(node) && !node.type && !node.initializer || isPropertySignature(node) && !node.type && !node.initializer || isParameter(node) && !node.type && !node.initializer) {
-          let visited = visitEachChild(
-            node,
-            visitExistingNodeTreeSymbols,
-            /*context*/
-            void 0
-          );
+          let visited = visitEachChild2(node, visitExistingNodeTreeSymbols);
           if (visited === node) {
             visited = setTextRange2(context, factory.cloneNode(node), node);
           }
@@ -56423,7 +56588,8 @@ function createTypeChecker(host) {
             if (serializedName) {
               return setTextRange2(context, serializedName, node.exprName);
             }
-            return serializeExistingTypeNode(context, node);
+            hadError = true;
+            return node;
           }
           return factory.updateTypeQueryNode(
             node,
@@ -56461,12 +56627,7 @@ function createTypeChecker(host) {
           return factory.updateTypePredicateNode(node, node.assertsModifier, parameterName, visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode));
         }
         if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) {
-          const visited = visitEachChild(
-            node,
-            visitExistingNodeTreeSymbols,
-            /*context*/
-            void 0
-          );
+          const visited = visitEachChild2(node, visitExistingNodeTreeSymbols);
           const clone2 = setTextRange2(context, visited === node ? factory.cloneNode(node) : visited, node);
           const flags = getEmitFlags(clone2);
           setEmitFlags(clone2, flags | (context.flags & 1024 /* MultilineObjectLiterals */ && isTypeLiteralNode(node) ? 0 : 1 /* SingleLine */));
@@ -56492,17 +56653,46 @@ function createTypeChecker(host) {
             falseType2
           );
         }
-        if (isTypeOperatorNode(node) && node.operator === 158 /* UniqueKeyword */ && node.type.kind === 155 /* SymbolKeyword */) {
-          if (!canReuseTypeNode(context, node)) {
-            return serializeExistingTypeNode(context, node);
+        if (isTypeOperatorNode(node)) {
+          if (node.operator === 158 /* UniqueKeyword */ && node.type.kind === 155 /* SymbolKeyword */) {
+            if (!canReuseTypeNode(context, node)) {
+              hadError = true;
+              return node;
+            }
+          } else if (node.operator === 143 /* KeyOfKeyword */) {
+            if (isTypeReferenceNode(node.type)) {
+              const type = tryVisitTypeReference(node.type);
+              if (!type) {
+                hadError = true;
+                return node;
+              }
+              return factory.updateTypeOperatorNode(node, type);
+            }
           }
         }
-        return visitEachChild(
-          node,
-          visitExistingNodeTreeSymbols,
-          /*context*/
-          void 0
-        );
+        return visitEachChild2(node, visitExistingNodeTreeSymbols);
+        function visitEachChild2(node2, visitor) {
+          const nonlocalNode = !context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(node2);
+          return visitEachChild(
+            node2,
+            visitor,
+            /*context*/
+            void 0,
+            nonlocalNode ? visitNodesWithoutCopyingPositions : void 0
+          );
+        }
+        function visitNodesWithoutCopyingPositions(nodes, visitor, test, start, count) {
+          let result = visitNodes2(nodes, visitor, test, start, count);
+          if (result) {
+            if (result.pos !== -1 || result.end !== -1) {
+              if (result === nodes) {
+                result = factory.createNodeArray(nodes, nodes.hasTrailingComma);
+              }
+              setTextRangePosEnd(result, -1, -1);
+            }
+          }
+          return result;
+        }
         function getEffectiveDotDotDotForParameter(p) {
           return p.dotDotDotToken || (p.type && isJSDocVariadicType(p.type) ? factory.createToken(26 /* DotDotDotToken */) : void 0);
         }
@@ -56511,13 +56701,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);
         }
@@ -61542,7 +61758,16 @@ function createTypeChecker(host) {
     }
   }
   function getApparentTypeOfIntersectionType(type, thisArgument) {
-    return type.resolvedApparentType || (type.resolvedApparentType = getTypeWithThisArgument(
+    if (type === thisArgument) {
+      return type.resolvedApparentType || (type.resolvedApparentType = getTypeWithThisArgument(
+        type,
+        thisArgument,
+        /*needApparentType*/
+        true
+      ));
+    }
+    const key = `I${getTypeId(type)},${getTypeId(thisArgument)}`;
+    return getCachedType(key) ?? setCachedType(key, getTypeWithThisArgument(
       type,
       thisArgument,
       /*needApparentType*/
@@ -64485,7 +64710,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;
@@ -64493,9 +64717,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];
@@ -73920,6 +74141,9 @@ function createTypeChecker(host) {
     return contextualType && !isGenericType(contextualType);
   }
   function getNarrowableTypeForReference(type, reference, checkMode) {
+    if (isNoInferType(type)) {
+      type = type.baseType;
+    }
     const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
     return substituteConstraints ? mapType(type, getBaseConstraintOrType) : type;
   }
@@ -73985,9 +74209,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);
@@ -73997,6 +74218,9 @@ function createTypeChecker(host) {
         if (isExportSpecifier(location)) {
           return markExportSpecifierAliasReferenced(location);
         }
+        if (isFunctionLikeDeclaration(location) || isMethodSignature(location)) {
+          markAsyncFunctionAliasReferenced(location);
+        }
         if (!compilerOptions.emitDecoratorMetadata) {
           return;
         }
@@ -74334,18 +74558,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) {
@@ -74364,17 +74582,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(
@@ -74401,6 +74616,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) {
@@ -89411,7 +89647,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,
@@ -89422,8 +89657,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*/
@@ -89505,6 +89740,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);
@@ -89603,6 +89841,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 && canIncludeBindAndCheckDiagnsotics(getSourceFileOfNode(node), compilerOptions)) {
+      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(
@@ -89623,7 +89963,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)) {
@@ -89974,9 +90322,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,
@@ -89999,6 +90348,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,
@@ -91136,7 +91489,6 @@ function createTypeChecker(host) {
             return true;
           }
         }
-        return false;
       }
     }
     if (isForOfStatement(forInOrOfStatement) && !(forInOrOfStatement.flags & 65536 /* AwaitContext */) && isIdentifier(forInOrOfStatement.initializer) && forInOrOfStatement.initializer.escapedText === "async") {
@@ -97987,7 +98339,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)) {
@@ -98094,7 +98446,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);
@@ -98156,15 +98508,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*/
@@ -98732,7 +99083,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);
@@ -98886,7 +99237,7 @@ function transformClassFields(context) {
       prefix,
       suffix
     );
-    if (resolver.getNodeCheckFlags(node) & 32768 /* BlockScopedBindingInLoop */) {
+    if (resolver.hasNodeCheckFlag(node, 32768 /* BlockScopedBindingInLoop */)) {
       addBlockScopedVariable(identifier);
     } else {
       hoistVariableDeclaration(identifier);
@@ -99125,7 +99476,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];
@@ -99992,7 +100343,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;
@@ -100025,7 +100376,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];
@@ -102334,7 +102685,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) {
@@ -102345,9 +102696,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);
         }
       }
@@ -102414,7 +102765,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");
@@ -102469,7 +102820,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) {
@@ -102488,9 +102839,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);
         }
       }
@@ -102549,7 +102900,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;
@@ -102653,7 +103004,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);
@@ -103748,7 +104099,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);
@@ -103758,9 +104109,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);
       }
     }
@@ -103893,7 +104244,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;
@@ -104524,10 +104875,10 @@ function transformESNext(context) {
   function visitForOfStatement(node) {
     if (isUsingVariableDeclarationList(node.initializer)) {
       const forInitializer = node.initializer;
-      Debug.assertNode(forInitializer, isUsingVariableDeclarationList);
-      Debug.assert(forInitializer.declarations.length === 1, "ForInitializer may only have one declaration");
-      const forDecl = forInitializer.declarations[0];
-      Debug.assert(!forDecl.initializer, "ForInitializer may not have an initializer");
+      const forDecl = firstOrUndefined(forInitializer.declarations) || factory2.createVariableDeclaration(factory2.createTempVariable(
+        /*recordTempVariable*/
+        void 0
+      ));
       const isAwaitUsing = getUsingKindOfVariableDeclarationList(forInitializer) === 2 /* Async */;
       const temp = factory2.getGeneratedNameForNode(forDecl.name);
       const usingVar = factory2.updateVariableDeclaration(
@@ -107598,9 +107949,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;
@@ -108051,7 +108401,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);
@@ -108066,7 +108416,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) {
@@ -108615,11 +108965,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)) {
@@ -117653,6 +118003,11 @@ function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, decla
       emitSkipped = true;
       return;
     }
+    (isSourceFile(sourceFileOrBundle) ? [sourceFileOrBundle] : filter(sourceFileOrBundle.sourceFiles, isSourceFileNotJson)).forEach(
+      (sourceFile) => {
+        if (compilerOptions.noCheck || !canIncludeBindAndCheckDiagnsotics(sourceFile, compilerOptions)) markLinkedReferences(sourceFile);
+      }
+    );
     const transform2 = transformNodes(
       resolver,
       host,
@@ -117702,9 +118057,11 @@ function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, decla
     const sourceFiles = isSourceFile(sourceFileOrBundle) ? [sourceFileOrBundle] : sourceFileOrBundle.sourceFiles;
     const filesForEmit = forceDtsEmit ? sourceFiles : filter(sourceFiles, isSourceFileNotJson);
     const inputListOrBundle = compilerOptions.outFile ? [factory.createBundle(filesForEmit)] : filesForEmit;
-    if (emitOnly && !getEmitDeclarations(compilerOptions) || compilerOptions.noCheck || emitResolverSkipsTypeChecking(emitOnly, forceDtsEmit)) {
-      filesForEmit.forEach(collectLinkedAliases);
-    }
+    filesForEmit.forEach((sourceFile) => {
+      if (emitOnly && !getEmitDeclarations(compilerOptions) || compilerOptions.noCheck || emitResolverSkipsTypeChecking(emitOnly, forceDtsEmit) || !canIncludeBindAndCheckDiagnsotics(sourceFile, compilerOptions)) {
+        collectLinkedAliases(sourceFile);
+      }
+    });
     const declarationTransform = transformNodes(
       resolver,
       host,
@@ -117787,6 +118144,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;
@@ -117918,10 +118282,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,
@@ -124794,15 +125159,13 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       const isJs = sourceFile.scriptKind === 1 /* JS */ || sourceFile.scriptKind === 2 /* JSX */;
       const isCheckJs = isJs && isCheckJsEnabledForFile(sourceFile, options);
       const isPlainJs = isPlainJsFile(sourceFile, options.checkJs);
-      const isTsNoCheck = !!sourceFile.checkJsDirective && sourceFile.checkJsDirective.enabled === false;
-      const includeBindAndCheckDiagnostics = !isTsNoCheck && (sourceFile.scriptKind === 3 /* TS */ || sourceFile.scriptKind === 4 /* TSX */ || sourceFile.scriptKind === 5 /* External */ || isPlainJs || isCheckJs || sourceFile.scriptKind === 7 /* Deferred */);
-      let bindDiagnostics = includeBindAndCheckDiagnostics ? sourceFile.bindDiagnostics : emptyArray;
-      let checkDiagnostics = includeBindAndCheckDiagnostics ? typeChecker2.getDiagnostics(sourceFile, cancellationToken) : emptyArray;
+      let bindDiagnostics = sourceFile.bindDiagnostics;
+      let checkDiagnostics = typeChecker2.getDiagnostics(sourceFile, cancellationToken);
       if (isPlainJs) {
         bindDiagnostics = filter(bindDiagnostics, (d) => plainJSErrors.has(d.code));
         checkDiagnostics = filter(checkDiagnostics, (d) => plainJSErrors.has(d.code));
       }
-      return getMergedBindAndCheckDiagnostics(sourceFile, includeBindAndCheckDiagnostics && !isPlainJs, bindDiagnostics, checkDiagnostics, isCheckJs ? sourceFile.jsDocDiagnostics : void 0);
+      return getMergedBindAndCheckDiagnostics(sourceFile, !isPlainJs, bindDiagnostics, checkDiagnostics, isCheckJs ? sourceFile.jsDocDiagnostics : void 0);
     });
   }
   function getMergedBindAndCheckDiagnostics(sourceFile, includeBindAndCheckDiagnostics, ...allDiagnostics) {
@@ -126057,9 +126420,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");
@@ -141185,7 +141545,6 @@ function transpileWorker(input, transpileOptions, declaration) {
     options.declaration = true;
     options.emitDeclarationOnly = true;
     options.isolatedDeclarations = true;
-    options.noCheck = true;
   } else {
     options.declaration = false;
   }
@@ -143863,7 +144222,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);
       }
     });
@@ -158283,7 +158642,7 @@ registerCodeFix({
     addCodeAction(addAnnotationFix, fixes, context, 2 /* Widened */, (f) => f.addTypeAnnotation(context.span));
     addCodeAction(addInlineTypeAssertion, fixes, context, 0 /* Full */, (f) => f.addInlineAssertion(context.span));
     addCodeAction(addInlineTypeAssertion, fixes, context, 1 /* Relative */, (f) => f.addInlineAssertion(context.span));
-    addCodeAction(addAnnotationFix, fixes, context, 2 /* Widened */, (f) => f.addInlineAssertion(context.span));
+    addCodeAction(addInlineTypeAssertion, fixes, context, 2 /* Widened */, (f) => f.addInlineAssertion(context.span));
     addCodeAction(extractExpression, fixes, context, 0 /* Full */, (f) => f.extractAsVariable(context.span));
     return fixes;
   },
@@ -158314,7 +158673,6 @@ function withContext(context, typePrintMode, cb) {
   const sourceFile = context.sourceFile;
   const program = context.program;
   const typeChecker = program.getTypeChecker();
-  const emitResolver = typeChecker.getEmitResolver();
   const scriptTarget = getEmitScriptTarget(program.getCompilerOptions());
   const importAdder = createImportAdder(context.sourceFile, context.program, context.preferences, context.host);
   const fixedNodes = /* @__PURE__ */ new Set();
@@ -158877,7 +159235,7 @@ function withContext(context, typePrintMode, cb) {
       }
       type = widenedType;
     }
-    if (isParameter(node) && emitResolver.requiresAddingImplicitUndefined(node)) {
+    if (isParameter(node) && typeChecker.requiresAddingImplicitUndefined(node)) {
       type = typeChecker.getUnionType([typeChecker.getUndefinedType(), type], 0 /* None */);
     }
     const flags = (isVariableDeclaration(node) || isPropertyDeclaration(node) && hasSyntacticModifier(node, 256 /* Static */ | 8 /* Readonly */)) && type.flags & 8192 /* UniqueESSymbol */ ? 1048576 /* AllowUniqueESSymbolType */ : 0 /* None */;
@@ -159073,23 +159431,23 @@ function withContext(context, typePrintMode, cb) {
     setEmitFlags(node, 0 /* None */);
     return result2;
   }
-}
-function findAncestorWithMissingType(node) {
-  return findAncestor(node, (n) => {
-    return canHaveTypeAnnotation.has(n.kind) && (!isObjectBindingPattern(n) && !isArrayBindingPattern(n) || isVariableDeclaration(n.parent));
-  });
-}
-function findBestFittingNode(node, span) {
-  while (node && node.end < span.start + span.length) {
-    node = node.parent;
-  }
-  while (node.parent.pos === node.pos && node.parent.end === node.end) {
-    node = node.parent;
+  function findAncestorWithMissingType(node) {
+    return findAncestor(node, (n) => {
+      return canHaveTypeAnnotation.has(n.kind) && (!isObjectBindingPattern(n) && !isArrayBindingPattern(n) || isVariableDeclaration(n.parent));
+    });
   }
-  if (isIdentifier(node) && hasInitializer(node.parent) && node.parent.initializer) {
-    return node.parent.initializer;
+  function findBestFittingNode(node, span) {
+    while (node && node.end < span.start + span.length) {
+      node = node.parent;
+    }
+    while (node.parent.pos === node.pos && node.parent.end === node.end) {
+      node = node.parent;
+    }
+    if (isIdentifier(node) && hasInitializer(node.parent) && node.parent.initializer) {
+      return node.parent.initializer;
+    }
+    return node;
   }
-  return node;
 }
 
 // src/services/codefixes/fixAwaitInSyncFunction.ts
@@ -160367,7 +160725,8 @@ function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, con
   switch (kind) {
     case 171 /* PropertySignature */:
     case 172 /* PropertyDeclaration */:
-      const flags = quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : void 0;
+      let flags = 1 /* NoTruncation */;
+      flags |= quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0;
       let typeNode = checker.typeToTypeNode(type, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context));
       if (importAdder) {
         const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
@@ -178094,6 +178453,7 @@ __export(ts_exports2, {
   canHaveModifiers: () => canHaveModifiers,
   canHaveModuleSpecifier: () => canHaveModuleSpecifier,
   canHaveSymbol: () => canHaveSymbol,
+  canIncludeBindAndCheckDiagnsotics: () => canIncludeBindAndCheckDiagnsotics,
   canJsonReportNoInputFiles: () => canJsonReportNoInputFiles,
   canProduceDiagnostics: () => canProduceDiagnostics,
   canUsePropertyAccess: () => canUsePropertyAccess,
@@ -192525,6 +192885,7 @@ if (typeof console !== "undefined") {
   canHaveModifiers,
   canHaveModuleSpecifier,
   canHaveSymbol,
+  canIncludeBindAndCheckDiagnsotics,
   canJsonReportNoInputFiles,
   canProduceDiagnostics,
   canUsePropertyAccess,