typescript 5.3.0-dev.20231025 → 5.3.0-dev.20231026

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.3";
-var version = `${versionMajorMinor}.0-dev.20231025`;
+var version = `${versionMajorMinor}.0-dev.20231026`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -3460,32 +3460,43 @@ var NodeFlags = /* @__PURE__ */ ((NodeFlags3) => {
 })(NodeFlags || {});
 var ModifierFlags = /* @__PURE__ */ ((ModifierFlags3) => {
   ModifierFlags3[ModifierFlags3["None"] = 0] = "None";
-  ModifierFlags3[ModifierFlags3["Export"] = 1] = "Export";
-  ModifierFlags3[ModifierFlags3["Ambient"] = 2] = "Ambient";
-  ModifierFlags3[ModifierFlags3["Public"] = 4] = "Public";
-  ModifierFlags3[ModifierFlags3["Private"] = 8] = "Private";
-  ModifierFlags3[ModifierFlags3["Protected"] = 16] = "Protected";
-  ModifierFlags3[ModifierFlags3["Static"] = 32] = "Static";
-  ModifierFlags3[ModifierFlags3["Readonly"] = 64] = "Readonly";
-  ModifierFlags3[ModifierFlags3["Accessor"] = 128] = "Accessor";
-  ModifierFlags3[ModifierFlags3["Abstract"] = 256] = "Abstract";
-  ModifierFlags3[ModifierFlags3["Async"] = 512] = "Async";
-  ModifierFlags3[ModifierFlags3["Default"] = 1024] = "Default";
-  ModifierFlags3[ModifierFlags3["Const"] = 2048] = "Const";
-  ModifierFlags3[ModifierFlags3["HasComputedJSDocModifiers"] = 4096] = "HasComputedJSDocModifiers";
-  ModifierFlags3[ModifierFlags3["Deprecated"] = 8192] = "Deprecated";
-  ModifierFlags3[ModifierFlags3["Override"] = 16384] = "Override";
-  ModifierFlags3[ModifierFlags3["In"] = 32768] = "In";
-  ModifierFlags3[ModifierFlags3["Out"] = 65536] = "Out";
-  ModifierFlags3[ModifierFlags3["Decorator"] = 131072] = "Decorator";
+  ModifierFlags3[ModifierFlags3["Public"] = 1] = "Public";
+  ModifierFlags3[ModifierFlags3["Private"] = 2] = "Private";
+  ModifierFlags3[ModifierFlags3["Protected"] = 4] = "Protected";
+  ModifierFlags3[ModifierFlags3["Readonly"] = 8] = "Readonly";
+  ModifierFlags3[ModifierFlags3["Override"] = 16] = "Override";
+  ModifierFlags3[ModifierFlags3["Export"] = 32] = "Export";
+  ModifierFlags3[ModifierFlags3["Abstract"] = 64] = "Abstract";
+  ModifierFlags3[ModifierFlags3["Ambient"] = 128] = "Ambient";
+  ModifierFlags3[ModifierFlags3["Static"] = 256] = "Static";
+  ModifierFlags3[ModifierFlags3["Accessor"] = 512] = "Accessor";
+  ModifierFlags3[ModifierFlags3["Async"] = 1024] = "Async";
+  ModifierFlags3[ModifierFlags3["Default"] = 2048] = "Default";
+  ModifierFlags3[ModifierFlags3["Const"] = 4096] = "Const";
+  ModifierFlags3[ModifierFlags3["In"] = 8192] = "In";
+  ModifierFlags3[ModifierFlags3["Out"] = 16384] = "Out";
+  ModifierFlags3[ModifierFlags3["Decorator"] = 32768] = "Decorator";
+  ModifierFlags3[ModifierFlags3["Deprecated"] = 65536] = "Deprecated";
+  ModifierFlags3[ModifierFlags3["JSDocPublic"] = 8388608] = "JSDocPublic";
+  ModifierFlags3[ModifierFlags3["JSDocPrivate"] = 16777216] = "JSDocPrivate";
+  ModifierFlags3[ModifierFlags3["JSDocProtected"] = 33554432] = "JSDocProtected";
+  ModifierFlags3[ModifierFlags3["JSDocReadonly"] = 67108864] = "JSDocReadonly";
+  ModifierFlags3[ModifierFlags3["JSDocOverride"] = 134217728] = "JSDocOverride";
+  ModifierFlags3[ModifierFlags3["SyntacticOrJSDocModifiers"] = 31] = "SyntacticOrJSDocModifiers";
+  ModifierFlags3[ModifierFlags3["SyntacticOnlyModifiers"] = 65504] = "SyntacticOnlyModifiers";
+  ModifierFlags3[ModifierFlags3["SyntacticModifiers"] = 65535] = "SyntacticModifiers";
+  ModifierFlags3[ModifierFlags3["JSDocCacheOnlyModifiers"] = 260046848] = "JSDocCacheOnlyModifiers";
+  ModifierFlags3[ModifierFlags3["JSDocOnlyModifiers"] = 65536 /* Deprecated */] = "JSDocOnlyModifiers";
+  ModifierFlags3[ModifierFlags3["NonCacheOnlyModifiers"] = 131071] = "NonCacheOnlyModifiers";
+  ModifierFlags3[ModifierFlags3["HasComputedJSDocModifiers"] = 268435456] = "HasComputedJSDocModifiers";
   ModifierFlags3[ModifierFlags3["HasComputedFlags"] = 536870912] = "HasComputedFlags";
-  ModifierFlags3[ModifierFlags3["AccessibilityModifier"] = 28] = "AccessibilityModifier";
-  ModifierFlags3[ModifierFlags3["ParameterPropertyModifier"] = 16476] = "ParameterPropertyModifier";
-  ModifierFlags3[ModifierFlags3["NonPublicAccessibilityModifier"] = 24] = "NonPublicAccessibilityModifier";
-  ModifierFlags3[ModifierFlags3["TypeScriptModifier"] = 117086] = "TypeScriptModifier";
-  ModifierFlags3[ModifierFlags3["ExportDefault"] = 1025] = "ExportDefault";
-  ModifierFlags3[ModifierFlags3["All"] = 258047] = "All";
-  ModifierFlags3[ModifierFlags3["Modifier"] = 126975] = "Modifier";
+  ModifierFlags3[ModifierFlags3["AccessibilityModifier"] = 7] = "AccessibilityModifier";
+  ModifierFlags3[ModifierFlags3["ParameterPropertyModifier"] = 31] = "ParameterPropertyModifier";
+  ModifierFlags3[ModifierFlags3["NonPublicAccessibilityModifier"] = 6] = "NonPublicAccessibilityModifier";
+  ModifierFlags3[ModifierFlags3["TypeScriptModifier"] = 28895] = "TypeScriptModifier";
+  ModifierFlags3[ModifierFlags3["ExportDefault"] = 2080] = "ExportDefault";
+  ModifierFlags3[ModifierFlags3["All"] = 131071] = "All";
+  ModifierFlags3[ModifierFlags3["Modifier"] = 98303] = "Modifier";
   return ModifierFlags3;
 })(ModifierFlags || {});
 var RelationComparisonResult = /* @__PURE__ */ ((RelationComparisonResult3) => {
@@ -10070,7 +10081,7 @@ function createTextChangeRange(span, newLength) {
 }
 var unchangedTextChangeRange = createTextChangeRange(createTextSpan(0, 0), 0);
 function isParameterPropertyDeclaration(node, parent) {
-  return isParameter(node) && hasSyntacticModifier(node, 16476 /* ParameterPropertyModifier */) && parent.kind === 176 /* Constructor */;
+  return isParameter(node) && hasSyntacticModifier(node, 31 /* ParameterPropertyModifier */) && parent.kind === 176 /* Constructor */;
 }
 function walkUpBindingElementsAndPatterns(binding) {
   let node = binding.parent;
@@ -10345,7 +10356,7 @@ function getDecorators(node) {
   }
 }
 function getModifiers(node) {
-  if (hasSyntacticModifier(node, 126975 /* Modifier */)) {
+  if (hasSyntacticModifier(node, 98303 /* Modifier */)) {
     return filter(node.modifiers, isModifier);
   }
 }
@@ -10739,7 +10750,7 @@ function isModifierKind(token) {
   return false;
 }
 function isParameterPropertyModifier(kind) {
-  return !!(modifierToFlag(kind) & 16476 /* ParameterPropertyModifier */);
+  return !!(modifierToFlag(kind) & 31 /* ParameterPropertyModifier */);
 }
 function isClassMemberModifier(idToken) {
   return isParameterPropertyModifier(idToken) || idToken === 126 /* StaticKeyword */ || idToken === 164 /* OverrideKeyword */ || idToken === 129 /* AccessorKeyword */;
@@ -11083,10 +11094,10 @@ function hasScopeMarker(statements) {
   return some(statements, isScopeMarker);
 }
 function needsScopeMarker(result) {
-  return !isAnyImportOrReExport(result) && !isExportAssignment(result) && !hasSyntacticModifier(result, 1 /* Export */) && !isAmbientModule(result);
+  return !isAnyImportOrReExport(result) && !isExportAssignment(result) && !hasSyntacticModifier(result, 32 /* Export */) && !isAmbientModule(result);
 }
 function isExternalModuleIndicator(result) {
-  return isAnyImportOrReExport(result) || isExportAssignment(result) || hasSyntacticModifier(result, 1 /* Export */);
+  return isAnyImportOrReExport(result) || isExportAssignment(result) || hasSyntacticModifier(result, 32 /* Export */);
 }
 function isForInOrOfStatement(node) {
   return node.kind === 249 /* ForInStatement */ || node.kind === 250 /* ForOfStatement */;
@@ -12273,7 +12284,7 @@ function isEffectiveStrictModeSourceFile(node, compilerOptions) {
   return false;
 }
 function isAmbientPropertyDeclaration(node) {
-  return !!(node.flags & 33554432 /* Ambient */) || hasSyntacticModifier(node, 2 /* Ambient */);
+  return !!(node.flags & 33554432 /* Ambient */) || hasSyntacticModifier(node, 128 /* Ambient */);
 }
 function isBlockScope(node, parentNode) {
   switch (node.kind) {
@@ -12583,10 +12594,10 @@ function isJsonSourceFile(file) {
   return file.scriptKind === 6 /* JSON */;
 }
 function isEnumConst(node) {
-  return !!(getCombinedModifierFlags(node) & 2048 /* Const */);
+  return !!(getCombinedModifierFlags(node) & 4096 /* Const */);
 }
 function isDeclarationReadonly(declaration) {
-  return !!(getCombinedModifierFlags(declaration) & 64 /* Readonly */ && !isParameterPropertyDeclaration(declaration, declaration.parent));
+  return !!(getCombinedModifierFlags(declaration) & 8 /* Readonly */ && !isParameterPropertyDeclaration(declaration, declaration.parent));
 }
 function isVarAwaitUsing(node) {
   return (getCombinedNodeFlags(node) & 7 /* BlockScoped */) === 6 /* AwaitUsing */;
@@ -14231,7 +14242,7 @@ function getFunctionFlags(node) {
         flags |= 1 /* Generator */;
       }
     case 219 /* ArrowFunction */:
-      if (hasSyntacticModifier(node, 512 /* Async */)) {
+      if (hasSyntacticModifier(node, 1024 /* Async */)) {
         flags |= 2 /* Async */;
       }
       break;
@@ -14247,7 +14258,7 @@ function isAsyncFunction(node) {
     case 218 /* FunctionExpression */:
     case 219 /* ArrowFunction */:
     case 174 /* MethodDeclaration */:
-      return node.body !== void 0 && node.asteriskToken === void 0 && hasSyntacticModifier(node, 512 /* Async */);
+      return node.body !== void 0 && node.asteriskToken === void 0 && hasSyntacticModifier(node, 1024 /* Async */);
   }
   return false;
 }
@@ -15359,25 +15370,25 @@ function isStatic(node) {
   return isClassElement(node) && hasStaticModifier(node) || isClassStaticBlockDeclaration(node);
 }
 function hasStaticModifier(node) {
-  return hasSyntacticModifier(node, 32 /* Static */);
+  return hasSyntacticModifier(node, 256 /* Static */);
 }
 function hasOverrideModifier(node) {
-  return hasEffectiveModifier(node, 16384 /* Override */);
+  return hasEffectiveModifier(node, 16 /* Override */);
 }
 function hasAbstractModifier(node) {
-  return hasSyntacticModifier(node, 256 /* Abstract */);
+  return hasSyntacticModifier(node, 64 /* Abstract */);
 }
 function hasAmbientModifier(node) {
-  return hasSyntacticModifier(node, 2 /* Ambient */);
+  return hasSyntacticModifier(node, 128 /* Ambient */);
 }
 function hasAccessorModifier(node) {
-  return hasSyntacticModifier(node, 128 /* Accessor */);
+  return hasSyntacticModifier(node, 512 /* Accessor */);
 }
 function hasEffectiveReadonlyModifier(node) {
-  return hasEffectiveModifier(node, 64 /* Readonly */);
+  return hasEffectiveModifier(node, 8 /* Readonly */);
 }
 function hasDecorators(node) {
-  return hasSyntacticModifier(node, 131072 /* Decorator */);
+  return hasSyntacticModifier(node, 32768 /* Decorator */);
 }
 function getSelectedEffectiveModifierFlags(node, flags) {
   return getEffectiveModifierFlags(node) & flags;
@@ -15392,10 +15403,13 @@ function getModifierFlagsWorker(node, includeJSDoc, alwaysIncludeJSDoc) {
   if (!(node.modifierFlagsCache & 536870912 /* HasComputedFlags */)) {
     node.modifierFlagsCache = getSyntacticModifierFlagsNoCache(node) | 536870912 /* HasComputedFlags */;
   }
-  if (includeJSDoc && !(node.modifierFlagsCache & 4096 /* HasComputedJSDocModifiers */) && (alwaysIncludeJSDoc || isInJSFile(node)) && node.parent) {
-    node.modifierFlagsCache |= getJSDocModifierFlagsNoCache(node) | 4096 /* HasComputedJSDocModifiers */;
+  if (alwaysIncludeJSDoc || includeJSDoc && isInJSFile(node)) {
+    if (!(node.modifierFlagsCache & 268435456 /* HasComputedJSDocModifiers */) && node.parent) {
+      node.modifierFlagsCache |= getRawJSDocModifierFlagsNoCache(node) | 268435456 /* HasComputedJSDocModifiers */;
+    }
+    return selectEffectiveModifierFlags(node.modifierFlagsCache);
   }
-  return node.modifierFlagsCache & ~(536870912 /* HasComputedFlags */ | 4096 /* HasComputedJSDocModifiers */);
+  return selectSyntacticModifierFlags(node.modifierFlagsCache);
 }
 function getEffectiveModifierFlags(node) {
   return getModifierFlagsWorker(
@@ -15411,33 +15425,42 @@ function getSyntacticModifierFlags(node) {
     false
   );
 }
-function getJSDocModifierFlagsNoCache(node) {
+function getRawJSDocModifierFlagsNoCache(node) {
   let flags = 0 /* None */;
   if (!!node.parent && !isParameter(node)) {
     if (isInJSFile(node)) {
       if (getJSDocPublicTagNoCache(node))
-        flags |= 4 /* Public */;
+        flags |= 8388608 /* JSDocPublic */;
       if (getJSDocPrivateTagNoCache(node))
-        flags |= 8 /* Private */;
+        flags |= 16777216 /* JSDocPrivate */;
       if (getJSDocProtectedTagNoCache(node))
-        flags |= 16 /* Protected */;
+        flags |= 33554432 /* JSDocProtected */;
       if (getJSDocReadonlyTagNoCache(node))
-        flags |= 64 /* Readonly */;
+        flags |= 67108864 /* JSDocReadonly */;
       if (getJSDocOverrideTagNoCache(node))
-        flags |= 16384 /* Override */;
+        flags |= 134217728 /* JSDocOverride */;
     }
     if (getJSDocDeprecatedTagNoCache(node))
-      flags |= 8192 /* Deprecated */;
+      flags |= 65536 /* Deprecated */;
   }
   return flags;
 }
+function selectSyntacticModifierFlags(flags) {
+  return flags & 65535 /* SyntacticModifiers */;
+}
+function selectEffectiveModifierFlags(flags) {
+  return flags & 131071 /* NonCacheOnlyModifiers */ | (flags & 260046848 /* JSDocCacheOnlyModifiers */) >>> 23;
+}
+function getJSDocModifierFlagsNoCache(node) {
+  return selectEffectiveModifierFlags(getRawJSDocModifierFlagsNoCache(node));
+}
 function getEffectiveModifierFlagsNoCache(node) {
   return getSyntacticModifierFlagsNoCache(node) | getJSDocModifierFlagsNoCache(node);
 }
 function getSyntacticModifierFlagsNoCache(node) {
   let flags = canHaveModifiers(node) ? modifiersToFlags(node.modifiers) : 0 /* None */;
   if (node.flags & 8 /* NestedNamespace */ || node.kind === 80 /* Identifier */ && node.flags & 4096 /* IdentifierIsInJSDocNamespace */) {
-    flags |= 1 /* Export */;
+    flags |= 32 /* Export */;
   }
   return flags;
 }
@@ -15453,37 +15476,37 @@ function modifiersToFlags(modifiers) {
 function modifierToFlag(token) {
   switch (token) {
     case 126 /* StaticKeyword */:
-      return 32 /* Static */;
+      return 256 /* Static */;
     case 125 /* PublicKeyword */:
-      return 4 /* Public */;
+      return 1 /* Public */;
     case 124 /* ProtectedKeyword */:
-      return 16 /* Protected */;
+      return 4 /* Protected */;
     case 123 /* PrivateKeyword */:
-      return 8 /* Private */;
+      return 2 /* Private */;
     case 128 /* AbstractKeyword */:
-      return 256 /* Abstract */;
+      return 64 /* Abstract */;
     case 129 /* AccessorKeyword */:
-      return 128 /* Accessor */;
+      return 512 /* Accessor */;
     case 95 /* ExportKeyword */:
-      return 1 /* Export */;
+      return 32 /* Export */;
     case 138 /* DeclareKeyword */:
-      return 2 /* Ambient */;
+      return 128 /* Ambient */;
     case 87 /* ConstKeyword */:
-      return 2048 /* Const */;
+      return 4096 /* Const */;
     case 90 /* DefaultKeyword */:
-      return 1024 /* Default */;
+      return 2048 /* Default */;
     case 134 /* AsyncKeyword */:
-      return 512 /* Async */;
+      return 1024 /* Async */;
     case 148 /* ReadonlyKeyword */:
-      return 64 /* Readonly */;
+      return 8 /* Readonly */;
     case 164 /* OverrideKeyword */:
-      return 16384 /* Override */;
+      return 16 /* Override */;
     case 103 /* InKeyword */:
-      return 32768 /* In */;
+      return 8192 /* In */;
     case 147 /* OutKeyword */:
-      return 65536 /* Out */;
+      return 16384 /* Out */;
     case 170 /* Decorator */:
-      return 131072 /* Decorator */;
+      return 32768 /* Decorator */;
   }
   return 0 /* None */;
 }
@@ -15620,7 +15643,7 @@ function getLocalSymbolForExportDefault(symbol) {
   return void 0;
 }
 function isExportDefaultSymbol(symbol) {
-  return symbol && length(symbol.declarations) > 0 && hasSyntacticModifier(symbol.declarations[0], 1024 /* Default */);
+  return symbol && length(symbol.declarations) > 0 && hasSyntacticModifier(symbol.declarations[0], 2048 /* Default */);
 }
 function tryExtractTSExtension(fileName) {
   return find(supportedTSExtensionsForExtractExtension, (extension) => fileExtensionIs(fileName, extension));
@@ -15839,16 +15862,16 @@ function getDeclarationModifierFlagsFromSymbol(s, isWrite = false) {
   if (s.valueDeclaration) {
     const declaration = isWrite && s.declarations && find(s.declarations, isSetAccessorDeclaration) || s.flags & 32768 /* GetAccessor */ && find(s.declarations, isGetAccessorDeclaration) || s.valueDeclaration;
     const flags = getCombinedModifierFlags(declaration);
-    return s.parent && s.parent.flags & 32 /* Class */ ? flags : flags & ~28 /* AccessibilityModifier */;
+    return s.parent && s.parent.flags & 32 /* Class */ ? flags : flags & ~7 /* AccessibilityModifier */;
   }
   if (getCheckFlags(s) & 6 /* Synthetic */) {
     const checkFlags = s.links.checkFlags;
-    const accessModifier = checkFlags & 1024 /* ContainsPrivate */ ? 8 /* Private */ : checkFlags & 256 /* ContainsPublic */ ? 4 /* Public */ : 16 /* Protected */;
-    const staticModifier = checkFlags & 2048 /* ContainsStatic */ ? 32 /* Static */ : 0;
+    const accessModifier = checkFlags & 1024 /* ContainsPrivate */ ? 2 /* Private */ : checkFlags & 256 /* ContainsPublic */ ? 1 /* Public */ : 4 /* Protected */;
+    const staticModifier = checkFlags & 2048 /* ContainsStatic */ ? 256 /* Static */ : 0;
     return accessModifier | staticModifier;
   }
   if (s.flags & 4194304 /* Prototype */) {
-    return 4 /* Public */ | 32 /* Static */;
+    return 1 /* Public */ | 256 /* Static */;
   }
   return 0;
 }
@@ -17110,7 +17133,7 @@ function isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(node) {
   if (node.kind !== 167 /* ComputedPropertyName */) {
     return false;
   }
-  if (hasSyntacticModifier(node.parent, 256 /* Abstract */)) {
+  if (hasSyntacticModifier(node.parent, 64 /* Abstract */)) {
     return true;
   }
   const containerKind = node.parent.parent.kind;
@@ -19084,35 +19107,35 @@ function createNodeFactory(flags, baseFactory2) {
   }
   function createModifiersFromModifierFlags(flags2) {
     const result = [];
-    if (flags2 & 1 /* Export */)
+    if (flags2 & 32 /* Export */)
       result.push(createModifier(95 /* ExportKeyword */));
-    if (flags2 & 2 /* Ambient */)
+    if (flags2 & 128 /* Ambient */)
       result.push(createModifier(138 /* DeclareKeyword */));
-    if (flags2 & 1024 /* Default */)
+    if (flags2 & 2048 /* Default */)
       result.push(createModifier(90 /* DefaultKeyword */));
-    if (flags2 & 2048 /* Const */)
+    if (flags2 & 4096 /* Const */)
       result.push(createModifier(87 /* ConstKeyword */));
-    if (flags2 & 4 /* Public */)
+    if (flags2 & 1 /* Public */)
       result.push(createModifier(125 /* PublicKeyword */));
-    if (flags2 & 8 /* Private */)
+    if (flags2 & 2 /* Private */)
       result.push(createModifier(123 /* PrivateKeyword */));
-    if (flags2 & 16 /* Protected */)
+    if (flags2 & 4 /* Protected */)
       result.push(createModifier(124 /* ProtectedKeyword */));
-    if (flags2 & 256 /* Abstract */)
+    if (flags2 & 64 /* Abstract */)
       result.push(createModifier(128 /* AbstractKeyword */));
-    if (flags2 & 32 /* Static */)
+    if (flags2 & 256 /* Static */)
       result.push(createModifier(126 /* StaticKeyword */));
-    if (flags2 & 16384 /* Override */)
+    if (flags2 & 16 /* Override */)
       result.push(createModifier(164 /* OverrideKeyword */));
-    if (flags2 & 64 /* Readonly */)
+    if (flags2 & 8 /* Readonly */)
       result.push(createModifier(148 /* ReadonlyKeyword */));
-    if (flags2 & 128 /* Accessor */)
+    if (flags2 & 512 /* Accessor */)
       result.push(createModifier(129 /* AccessorKeyword */));
-    if (flags2 & 512 /* Async */)
+    if (flags2 & 1024 /* Async */)
       result.push(createModifier(134 /* AsyncKeyword */));
-    if (flags2 & 32768 /* In */)
+    if (flags2 & 8192 /* In */)
       result.push(createModifier(103 /* InKeyword */));
-    if (flags2 & 65536 /* Out */)
+    if (flags2 & 16384 /* Out */)
       result.push(createModifier(147 /* OutKeyword */));
     return result.length ? result : void 0;
   }
@@ -19161,7 +19184,7 @@ function createNodeFactory(flags, baseFactory2) {
     if (isThisIdentifier(node.name)) {
       node.transformFlags = 1 /* ContainsTypeScript */;
     } else {
-      node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.dotDotDotToken) | propagateNameFlags(node.name) | propagateChildFlags(node.questionToken) | propagateChildFlags(node.initializer) | (node.questionToken ?? node.type ? 1 /* ContainsTypeScript */ : 0 /* None */) | (node.dotDotDotToken ?? node.initializer ? 1024 /* ContainsES2015 */ : 0 /* None */) | (modifiersToFlags(node.modifiers) & 16476 /* ParameterPropertyModifier */ ? 8192 /* ContainsTypeScriptClassSyntax */ : 0 /* None */);
+      node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.dotDotDotToken) | propagateNameFlags(node.name) | propagateChildFlags(node.questionToken) | propagateChildFlags(node.initializer) | (node.questionToken ?? node.type ? 1 /* ContainsTypeScript */ : 0 /* None */) | (node.dotDotDotToken ?? node.initializer ? 1024 /* ContainsES2015 */ : 0 /* None */) | (modifiersToFlags(node.modifiers) & 31 /* ParameterPropertyModifier */ ? 8192 /* ContainsTypeScriptClassSyntax */ : 0 /* None */);
     }
     node.jsDoc = void 0;
     return node;
@@ -19210,8 +19233,8 @@ function createNodeFactory(flags, baseFactory2) {
     node.exclamationToken = questionOrExclamationToken && isExclamationToken(questionOrExclamationToken) ? questionOrExclamationToken : void 0;
     node.type = type;
     node.initializer = asInitializer(initializer);
-    const isAmbient = node.flags & 33554432 /* Ambient */ || modifiersToFlags(node.modifiers) & 2 /* Ambient */;
-    node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateNameFlags(node.name) | propagateChildFlags(node.initializer) | (isAmbient || node.questionToken || node.exclamationToken || node.type ? 1 /* ContainsTypeScript */ : 0 /* None */) | (isComputedPropertyName(node.name) || modifiersToFlags(node.modifiers) & 32 /* Static */ && node.initializer ? 8192 /* ContainsTypeScriptClassSyntax */ : 0 /* None */) | 16777216 /* ContainsClassFields */;
+    const isAmbient = node.flags & 33554432 /* Ambient */ || modifiersToFlags(node.modifiers) & 128 /* Ambient */;
+    node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateNameFlags(node.name) | propagateChildFlags(node.initializer) | (isAmbient || node.questionToken || node.exclamationToken || node.type ? 1 /* ContainsTypeScript */ : 0 /* None */) | (isComputedPropertyName(node.name) || modifiersToFlags(node.modifiers) & 256 /* Static */ && node.initializer ? 8192 /* ContainsTypeScriptClassSyntax */ : 0 /* None */) | 16777216 /* ContainsClassFields */;
     node.jsDoc = void 0;
     return node;
   }
@@ -19250,7 +19273,7 @@ function createNodeFactory(flags, baseFactory2) {
     if (!node.body) {
       node.transformFlags = 1 /* ContainsTypeScript */;
     } else {
-      const isAsync = modifiersToFlags(node.modifiers) & 512 /* Async */;
+      const isAsync = modifiersToFlags(node.modifiers) & 1024 /* Async */;
       const isGenerator = !!node.asteriskToken;
       const isAsyncGenerator = isAsync && isGenerator;
       node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.asteriskToken) | propagateNameFlags(node.name) | propagateChildFlags(node.questionToken) | propagateChildrenFlags(node.typeParameters) | propagateChildrenFlags(node.parameters) | propagateChildFlags(node.type) | propagateChildFlags(node.body) & ~67108864 /* ContainsPossibleTopLevelAwait */ | (isAsyncGenerator ? 128 /* ContainsES2018 */ : isAsync ? 256 /* ContainsES2017 */ : isGenerator ? 2048 /* ContainsGenerator */ : 0 /* None */) | (node.questionToken || node.typeParameters || node.type ? 1 /* ContainsTypeScript */ : 0 /* None */) | 1024 /* ContainsES2015 */;
@@ -19993,7 +20016,7 @@ function createNodeFactory(flags, baseFactory2) {
     node.parameters = createNodeArray(parameters);
     node.type = type;
     node.body = body;
-    const isAsync = modifiersToFlags(node.modifiers) & 512 /* Async */;
+    const isAsync = modifiersToFlags(node.modifiers) & 1024 /* Async */;
     const isGenerator = !!node.asteriskToken;
     const isAsyncGenerator = isAsync && isGenerator;
     node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.asteriskToken) | propagateNameFlags(node.name) | propagateChildrenFlags(node.typeParameters) | propagateChildrenFlags(node.parameters) | propagateChildFlags(node.type) | propagateChildFlags(node.body) & ~67108864 /* ContainsPossibleTopLevelAwait */ | (isAsyncGenerator ? 128 /* ContainsES2018 */ : isAsync ? 256 /* ContainsES2017 */ : isGenerator ? 2048 /* ContainsGenerator */ : 0 /* None */) | (node.typeParameters || node.type ? 1 /* ContainsTypeScript */ : 0 /* None */) | 4194304 /* ContainsHoistedDeclarationOrCompletion */;
@@ -20017,7 +20040,7 @@ function createNodeFactory(flags, baseFactory2) {
     node.type = type;
     node.equalsGreaterThanToken = equalsGreaterThanToken ?? createToken(39 /* EqualsGreaterThanToken */);
     node.body = parenthesizerRules().parenthesizeConciseBodyOfArrowFunction(body);
-    const isAsync = modifiersToFlags(node.modifiers) & 512 /* Async */;
+    const isAsync = modifiersToFlags(node.modifiers) & 1024 /* Async */;
     node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildrenFlags(node.typeParameters) | propagateChildrenFlags(node.parameters) | propagateChildFlags(node.type) | propagateChildFlags(node.equalsGreaterThanToken) | propagateChildFlags(node.body) & ~67108864 /* ContainsPossibleTopLevelAwait */ | (node.typeParameters || node.type ? 1 /* ContainsTypeScript */ : 0 /* None */) | (isAsync ? 256 /* ContainsES2017 */ | 16384 /* ContainsLexicalThis */ : 0 /* None */) | 1024 /* ContainsES2015 */;
     node.typeArguments = void 0;
     node.jsDoc = void 0;
@@ -20369,7 +20392,7 @@ function createNodeFactory(flags, baseFactory2) {
     node.modifiers = asNodeArray(modifiers);
     node.declarationList = isArray(declarationList) ? createVariableDeclarationList(declarationList) : declarationList;
     node.transformFlags |= propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.declarationList);
-    if (modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
+    if (modifiersToFlags(node.modifiers) & 128 /* Ambient */) {
       node.transformFlags = 1 /* ContainsTypeScript */;
     }
     node.jsDoc = void 0;
@@ -20619,10 +20642,10 @@ function createNodeFactory(flags, baseFactory2) {
     node.parameters = createNodeArray(parameters);
     node.type = type;
     node.body = body;
-    if (!node.body || modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
+    if (!node.body || modifiersToFlags(node.modifiers) & 128 /* Ambient */) {
       node.transformFlags = 1 /* ContainsTypeScript */;
     } else {
-      const isAsync = modifiersToFlags(node.modifiers) & 512 /* Async */;
+      const isAsync = modifiersToFlags(node.modifiers) & 1024 /* Async */;
       const isGenerator = !!node.asteriskToken;
       const isAsyncGenerator = isAsync && isGenerator;
       node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.asteriskToken) | propagateNameFlags(node.name) | propagateChildrenFlags(node.typeParameters) | propagateChildrenFlags(node.parameters) | propagateChildFlags(node.type) | propagateChildFlags(node.body) & ~67108864 /* ContainsPossibleTopLevelAwait */ | (isAsyncGenerator ? 128 /* ContainsES2018 */ : isAsync ? 256 /* ContainsES2017 */ : isGenerator ? 2048 /* ContainsGenerator */ : 0 /* None */) | (node.typeParameters || node.type ? 1 /* ContainsTypeScript */ : 0 /* None */) | 4194304 /* ContainsHoistedDeclarationOrCompletion */;
@@ -20653,7 +20676,7 @@ function createNodeFactory(flags, baseFactory2) {
     node.typeParameters = asNodeArray(typeParameters);
     node.heritageClauses = asNodeArray(heritageClauses);
     node.members = createNodeArray(members);
-    if (modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
+    if (modifiersToFlags(node.modifiers) & 128 /* Ambient */) {
       node.transformFlags = 1 /* ContainsTypeScript */;
     } else {
       node.transformFlags |= propagateChildrenFlags(node.modifiers) | propagateNameFlags(node.name) | propagateChildrenFlags(node.typeParameters) | propagateChildrenFlags(node.heritageClauses) | propagateChildrenFlags(node.members) | (node.typeParameters ? 1 /* ContainsTypeScript */ : 0 /* None */) | 1024 /* ContainsES2015 */;
@@ -20715,7 +20738,7 @@ function createNodeFactory(flags, baseFactory2) {
     node.flags |= flags2 & (32 /* Namespace */ | 8 /* NestedNamespace */ | 2048 /* GlobalAugmentation */);
     node.name = name;
     node.body = body;
-    if (modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
+    if (modifiersToFlags(node.modifiers) & 128 /* Ambient */) {
       node.transformFlags = 1 /* ContainsTypeScript */;
     } else {
       node.transformFlags |= propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.name) | propagateChildFlags(node.body) | 1 /* ContainsTypeScript */;
@@ -22146,7 +22169,7 @@ function createNodeFactory(flags, baseFactory2) {
     return qualifiedName;
   }
   function getExternalModuleOrNamespaceExportName(ns, node, allowComments, allowSourceMaps) {
-    if (ns && hasSyntacticModifier(node, 1 /* Export */)) {
+    if (ns && hasSyntacticModifier(node, 32 /* Export */)) {
       return getNamespaceMemberName(ns, getName(node), allowComments, allowSourceMaps);
     }
     return getExportName(node, allowComments, allowSourceMaps);
@@ -31347,11 +31370,11 @@ var Parser;
     const modifierFlags = modifiersToFlags(modifiers);
     parseExpected(100 /* FunctionKeyword */);
     const asteriskToken = parseOptionalToken(42 /* AsteriskToken */);
-    const name = modifierFlags & 1024 /* Default */ ? parseOptionalBindingIdentifier() : parseBindingIdentifier();
+    const name = modifierFlags & 2048 /* Default */ ? parseOptionalBindingIdentifier() : parseBindingIdentifier();
     const isGenerator = asteriskToken ? 1 /* Yield */ : 0 /* None */;
-    const isAsync = modifierFlags & 512 /* Async */ ? 2 /* Await */ : 0 /* None */;
+    const isAsync = modifierFlags & 1024 /* Async */ ? 2 /* Await */ : 0 /* None */;
     const typeParameters = parseTypeParameters();
-    if (modifierFlags & 1 /* Export */)
+    if (modifierFlags & 32 /* Export */)
       setAwaitContext(
         /*value*/
         true
@@ -39376,7 +39399,7 @@ function getModuleInstanceStateWorker(node, visited) {
       break;
     case 272 /* ImportDeclaration */:
     case 271 /* ImportEqualsDeclaration */:
-      if (!hasSyntacticModifier(node, 1 /* Export */)) {
+      if (!hasSyntacticModifier(node, 32 /* Export */)) {
         return 0 /* NonInstantiated */;
       }
       break;
@@ -39654,7 +39677,7 @@ function createBinder() {
   }
   function declareSymbol(symbolTable, parent2, node, includes, excludes, isReplaceableByMethod, isComputedName) {
     Debug.assert(isComputedName || !hasDynamicName(node));
-    const isDefaultExport = hasSyntacticModifier(node, 1024 /* Default */) || isExportSpecifier(node) && node.name.escapedText === "default";
+    const isDefaultExport = hasSyntacticModifier(node, 2048 /* Default */) || isExportSpecifier(node) && node.name.escapedText === "default";
     const name = isComputedName ? "__computed" /* Computed */ : isDefaultExport && parent2 ? "default" /* Default */ : getDeclarationName(node);
     let symbol;
     if (name === void 0) {
@@ -39698,7 +39721,7 @@ function createBinder() {
             }
           }
           const relatedInformation = [];
-          if (isTypeAliasDeclaration(node) && nodeIsMissing(node.type) && hasSyntacticModifier(node, 1 /* Export */) && symbol.flags & (2097152 /* Alias */ | 788968 /* Type */ | 1920 /* Namespace */)) {
+          if (isTypeAliasDeclaration(node) && nodeIsMissing(node.type) && hasSyntacticModifier(node, 32 /* Export */) && symbol.flags & (2097152 /* Alias */ | 788968 /* Type */ | 1920 /* Namespace */)) {
             relatedInformation.push(createDiagnosticForNode2(node, Diagnostics.Did_you_mean_0, `export type { ${unescapeLeadingUnderscores(node.name.escapedText)} }`));
           }
           const declarationName = getNameOfDeclaration(node) || node;
@@ -39727,7 +39750,7 @@ function createBinder() {
     return symbol;
   }
   function declareModuleMember(node, symbolFlags, symbolExcludes) {
-    const hasExportModifier = !!(getCombinedModifierFlags(node) & 1 /* Export */) || jsdocTreatAsExported(node);
+    const hasExportModifier = !!(getCombinedModifierFlags(node) & 32 /* Export */) || jsdocTreatAsExported(node);
     if (symbolFlags & 2097152 /* Alias */) {
       if (node.kind === 281 /* ExportSpecifier */ || node.kind === 271 /* ImportEqualsDeclaration */ && hasExportModifier) {
         return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
@@ -39746,7 +39769,7 @@ function createBinder() {
       if (isJSDocTypeAlias(node))
         Debug.assert(isInJSFile(node));
       if (!isAmbientModule(node) && (hasExportModifier || container.flags & 128 /* ExportContext */)) {
-        if (!canHaveLocals(container) || !container.locals || hasSyntacticModifier(node, 1024 /* Default */) && !getDeclarationName(node)) {
+        if (!canHaveLocals(container) || !container.locals || hasSyntacticModifier(node, 2048 /* Default */) && !getDeclarationName(node)) {
           return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
         }
         const exportKind = symbolFlags & 111551 /* Value */ ? 1048576 /* ExportValue */ : 0;
@@ -39787,7 +39810,7 @@ function createBinder() {
       return false;
     if (isPropertyAccessEntityNameExpression(declName.parent) && isTopLevelNamespaceAssignment(declName.parent))
       return true;
-    if (isDeclaration(declName.parent) && getCombinedModifierFlags(declName.parent) & 1 /* Export */)
+    if (isDeclaration(declName.parent) && getCombinedModifierFlags(declName.parent) & 32 /* Export */)
       return true;
     return false;
   }
@@ -39818,7 +39841,7 @@ function createBinder() {
       const saveExceptionTarget = currentExceptionTarget;
       const saveActiveLabelList = activeLabelList;
       const saveHasExplicitReturn = hasExplicitReturn;
-      const isImmediatelyInvoked = containerFlags & 16 /* IsFunctionExpression */ && !hasSyntacticModifier(node, 512 /* Async */) && !node.asteriskToken && !!getImmediatelyInvokedFunctionExpression(node) || node.kind === 175 /* ClassStaticBlockDeclaration */;
+      const isImmediatelyInvoked = containerFlags & 16 /* IsFunctionExpression */ && !hasSyntacticModifier(node, 1024 /* Async */) && !node.asteriskToken && !!getImmediatelyInvokedFunctionExpression(node) || node.kind === 175 /* ClassStaticBlockDeclaration */;
       if (!isImmediatelyInvoked) {
         currentFlow = initFlowNode({ flags: 2 /* Start */ });
         if (containerFlags & (16 /* IsFunctionExpression */ | 128 /* IsObjectLiteralOrClassExpressionMethodOrAccessor */)) {
@@ -40865,7 +40888,7 @@ function createBinder() {
   function bindModuleDeclaration(node) {
     setExportContextFlag(node);
     if (isAmbientModule(node)) {
-      if (hasSyntacticModifier(node, 1 /* Export */)) {
+      if (hasSyntacticModifier(node, 32 /* Export */)) {
         errorOnFirstToken(node, Diagnostics.export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible);
       }
       if (isModuleAugmentationExternal(node)) {
@@ -41926,7 +41949,7 @@ function createBinder() {
     }
     if (!isBindingPattern(node.name)) {
       const possibleVariableDecl = node.kind === 260 /* VariableDeclaration */ ? node : node.parent.parent;
-      if (isInJSFile(node) && shouldResolveJsRequire(options) && isVariableDeclarationInitializedToBareOrAccessedRequire(possibleVariableDecl) && !getJSDocTypeTag(node) && !(getCombinedModifierFlags(node) & 1 /* Export */)) {
+      if (isInJSFile(node) && shouldResolveJsRequire(options) && isVariableDeclarationInitializedToBareOrAccessedRequire(possibleVariableDecl) && !getJSDocTypeTag(node) && !(getCombinedModifierFlags(node) & 32 /* Export */)) {
         declareSymbolAndAddToSymbolTable(node, 2097152 /* Alias */, 2097152 /* AliasExcludes */);
       } else if (isBlockOrCatchScoped(node)) {
         bindBlockScopedDeclaration(node, 2 /* BlockScopedVariable */, 111551 /* BlockScopedVariableExcludes */);
@@ -42078,7 +42101,7 @@ function isPurelyTypeDeclaration(s) {
     case 267 /* ModuleDeclaration */:
       return getModuleInstanceState(s) !== 1 /* Instantiated */;
     case 266 /* EnumDeclaration */:
-      return hasSyntacticModifier(s, 2048 /* Const */);
+      return hasSyntacticModifier(s, 4096 /* Const */);
     default:
       return false;
   }
@@ -45184,7 +45207,7 @@ function createTypeChecker(host) {
     if (lastLocation && lastLocation === location.name) {
       return false;
     }
-    if (location.asteriskToken || hasSyntacticModifier(location, 512 /* Async */)) {
+    if (location.asteriskToken || hasSyntacticModifier(location, 1024 /* Async */)) {
       return true;
     }
     return !getImmediatelyInvokedFunctionExpression(location);
@@ -45569,7 +45592,7 @@ function createTypeChecker(host) {
     return resolved;
   }
   function isSyntacticDefault(node) {
-    return isExportAssignment(node) && !node.isExportEquals || hasSyntacticModifier(node, 1024 /* Default */) || isExportSpecifier(node) || isNamespaceExport(node);
+    return isExportAssignment(node) && !node.isExportEquals || hasSyntacticModifier(node, 2048 /* Default */) || isExportSpecifier(node) || isNamespaceExport(node);
   }
   function getUsageModeForExpression(usage) {
     return isStringLiteralLike(usage) ? getModeForUsageLocation(getSourceFileOfNode(usage), usage) : void 0;
@@ -47495,20 +47518,20 @@ function createTypeChecker(host) {
       var _a, _b;
       if (!isDeclarationVisible(declaration)) {
         const anyImportSyntax = getAnyImportSyntax(declaration);
-        if (anyImportSyntax && !hasSyntacticModifier(anyImportSyntax, 1 /* Export */) && // import clause without export
+        if (anyImportSyntax && !hasSyntacticModifier(anyImportSyntax, 32 /* Export */) && // import clause without export
         isDeclarationVisible(anyImportSyntax.parent)) {
           return addVisibleAlias(declaration, anyImportSyntax);
-        } else if (isVariableDeclaration(declaration) && isVariableStatement(declaration.parent.parent) && !hasSyntacticModifier(declaration.parent.parent, 1 /* Export */) && // unexported variable statement
+        } else if (isVariableDeclaration(declaration) && isVariableStatement(declaration.parent.parent) && !hasSyntacticModifier(declaration.parent.parent, 32 /* Export */) && // unexported variable statement
         isDeclarationVisible(declaration.parent.parent.parent)) {
           return addVisibleAlias(declaration, declaration.parent.parent);
-        } else if (isLateVisibilityPaintedStatement(declaration) && !hasSyntacticModifier(declaration, 1 /* Export */) && isDeclarationVisible(declaration.parent)) {
+        } else if (isLateVisibilityPaintedStatement(declaration) && !hasSyntacticModifier(declaration, 32 /* Export */) && isDeclarationVisible(declaration.parent)) {
           return addVisibleAlias(declaration, declaration);
         } else if (isBindingElement(declaration)) {
-          if (symbol.flags & 2097152 /* Alias */ && isInJSFile(declaration) && ((_a = declaration.parent) == null ? void 0 : _a.parent) && isVariableDeclaration(declaration.parent.parent) && ((_b = declaration.parent.parent.parent) == null ? void 0 : _b.parent) && isVariableStatement(declaration.parent.parent.parent.parent) && !hasSyntacticModifier(declaration.parent.parent.parent.parent, 1 /* Export */) && declaration.parent.parent.parent.parent.parent && isDeclarationVisible(declaration.parent.parent.parent.parent.parent)) {
+          if (symbol.flags & 2097152 /* Alias */ && isInJSFile(declaration) && ((_a = declaration.parent) == null ? void 0 : _a.parent) && isVariableDeclaration(declaration.parent.parent) && ((_b = declaration.parent.parent.parent) == null ? void 0 : _b.parent) && isVariableStatement(declaration.parent.parent.parent.parent) && !hasSyntacticModifier(declaration.parent.parent.parent.parent, 32 /* Export */) && declaration.parent.parent.parent.parent.parent && isDeclarationVisible(declaration.parent.parent.parent.parent.parent)) {
             return addVisibleAlias(declaration, declaration.parent.parent.parent.parent);
           } else if (symbol.flags & 2 /* BlockScopedVariable */) {
             const variableStatement = findAncestor(declaration, isVariableStatement);
-            if (hasSyntacticModifier(variableStatement, 1 /* Export */)) {
+            if (hasSyntacticModifier(variableStatement, 32 /* Export */)) {
               return true;
             }
             if (!isDeclarationVisible(variableStatement.parent)) {
@@ -47731,7 +47754,8 @@ function createTypeChecker(host) {
         visitedTypes: void 0,
         symbolDepth: void 0,
         inferTypeParameters: void 0,
-        approximateLength: 0
+        approximateLength: 0,
+        trackedSymbols: void 0
       };
       context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
       const resultingNode = cb(context);
@@ -48185,7 +48209,7 @@ function createTypeChecker(host) {
         }
       }
       function visitAndTransformType(type2, transform) {
-        var _a2, _b2;
+        var _a2, _b2, _c;
         const typeId = type2.id;
         const isConstructorObject = getObjectFlags(type2) & 16 /* Anonymous */ && type2.symbol && type2.symbol.flags & 32 /* Class */;
         const id = getObjectFlags(type2) & 4 /* Reference */ && type2.node ? "N" + getNodeId(type2.node) : type2.flags & 16777216 /* Conditional */ ? "N" + getNodeId(type2.root.node) : type2.symbol ? (isConstructorObject ? "+" : "") + getSymbolId(type2.symbol) : void 0;
@@ -48202,6 +48226,13 @@ function createTypeChecker(host) {
         }
         const cachedResult = (_a2 = links == null ? void 0 : links.serializedTypes) == null ? void 0 : _a2.get(key);
         if (cachedResult) {
+          (_b2 = cachedResult.trackedSymbols) == null ? void 0 : _b2.forEach(
+            ([symbol, enclosingDeclaration, meaning]) => context.tracker.trackSymbol(
+              symbol,
+              enclosingDeclaration,
+              meaning
+            )
+          );
           if (cachedResult.truncating) {
             context.truncating = true;
           }
@@ -48221,7 +48252,12 @@ function createTypeChecker(host) {
         const result = transform(type2);
         const addedLength = context.approximateLength - startLength;
         if (!context.reportedDiagnostic && !context.encounteredError) {
-          (_b2 = links == null ? void 0 : links.serializedTypes) == null ? void 0 : _b2.set(key, { node: result, truncating: context.truncating, addedLength });
+          (_c = links == null ? void 0 : links.serializedTypes) == null ? void 0 : _c.set(key, {
+            node: result,
+            truncating: context.truncating,
+            addedLength,
+            trackedSymbols: context.trackedSymbols
+          });
         }
         context.visitedTypes.delete(typeId);
         if (id) {
@@ -48463,7 +48499,7 @@ function createTypeChecker(host) {
             if (propertySymbol.flags & 4194304 /* Prototype */) {
               continue;
             }
-            if (getDeclarationModifierFlagsFromSymbol(propertySymbol) & (8 /* Private */ | 16 /* Protected */) && context.tracker.reportPrivateInBaseOfClassExpression) {
+            if (getDeclarationModifierFlagsFromSymbol(propertySymbol) & (2 /* Private */ | 4 /* Protected */) && context.tracker.reportPrivateInBaseOfClassExpression) {
               context.tracker.reportPrivateInBaseOfClassExpression(unescapeLeadingUnderscores(propertySymbol.escapedName));
             }
           }
@@ -48766,7 +48802,7 @@ function createTypeChecker(host) {
       let modifiers = options == null ? void 0 : options.modifiers;
       if (kind === 185 /* ConstructorType */ && signature.flags & 4 /* Abstract */) {
         const flags = modifiersToFlags(modifiers);
-        modifiers = factory.createModifiersFromModifierFlags(flags | 256 /* Abstract */);
+        modifiers = factory.createModifiersFromModifierFlags(flags | 64 /* Abstract */);
       }
       const node = kind === 179 /* CallSignature */ ? factory.createCallSignature(typeParameters, parameters, returnTypeNode) : kind === 180 /* ConstructSignature */ ? factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : kind === 173 /* MethodSignature */ ? factory.createMethodSignature(modifiers, (options == null ? void 0 : options.name) ?? factory.createIdentifier(""), options == null ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : kind === 174 /* MethodDeclaration */ ? factory.createMethodDeclaration(
         modifiers,
@@ -49823,7 +49859,7 @@ function createTypeChecker(host) {
         const nsIndex = findIndex(statements, isModuleDeclaration);
         let ns = nsIndex !== -1 ? statements[nsIndex] : void 0;
         if (ns && exportAssignment && exportAssignment.isExportEquals && isIdentifier(exportAssignment.expression) && isIdentifier(ns.name) && idText(ns.name) === idText(exportAssignment.expression) && ns.body && isModuleBlock(ns.body)) {
-          const excessExports = filter(statements, (s) => !!(getEffectiveModifierFlags(s) & 1 /* Export */));
+          const excessExports = filter(statements, (s) => !!(getEffectiveModifierFlags(s) & 32 /* Export */));
           const name = ns.name;
           let body = ns.body;
           if (length(excessExports)) {
@@ -49857,9 +49893,9 @@ function createTypeChecker(host) {
           }
           if (!find(statements, (s) => s !== ns && nodeHasName(s, name))) {
             results = [];
-            const mixinExportFlag = !some(body.statements, (s) => hasSyntacticModifier(s, 1 /* Export */) || isExportAssignment(s) || isExportDeclaration(s));
+            const mixinExportFlag = !some(body.statements, (s) => hasSyntacticModifier(s, 32 /* Export */) || isExportAssignment(s) || isExportDeclaration(s));
             forEach(body.statements, (s) => {
-              addResult(s, mixinExportFlag ? 1 /* Export */ : 0 /* None */);
+              addResult(s, mixinExportFlag ? 32 /* Export */ : 0 /* None */);
             });
             statements = [...filter(statements, (s) => s !== ns && s !== exportAssignment), ...results];
           }
@@ -49951,11 +49987,11 @@ function createTypeChecker(host) {
         return statements;
       }
       function addExportModifier(node) {
-        const flags = (getEffectiveModifierFlags(node) | 1 /* Export */) & ~2 /* Ambient */;
+        const flags = (getEffectiveModifierFlags(node) | 32 /* Export */) & ~128 /* Ambient */;
         return factory.replaceModifiers(node, flags);
       }
       function removeExportModifier(node) {
-        const flags = getEffectiveModifierFlags(node) & ~1 /* Export */;
+        const flags = getEffectiveModifierFlags(node) & ~32 /* Export */;
         return factory.replaceModifiers(node, flags);
       }
       function visitSymbolTable(symbolTable2, suppressNewPrivateContext, propertyAsAlias) {
@@ -49996,6 +50032,12 @@ function createTypeChecker(host) {
           if (context.reportedDiagnostic) {
             oldcontext.reportedDiagnostic = context.reportedDiagnostic;
           }
+          if (context.trackedSymbols) {
+            if (!oldContext.trackedSymbols)
+              oldContext.trackedSymbols = context.trackedSymbols;
+            else
+              Debug.assert(context.trackedSymbols === oldContext.trackedSymbols);
+          }
           context = oldContext;
         }
       }
@@ -50012,7 +50054,7 @@ function createTypeChecker(host) {
         if (needsPostExportDefault || needsExportDeclaration) {
           isPrivate = true;
         }
-        const modifierFlags = (!isPrivate ? 1 /* Export */ : 0) | (isDefault && !needsPostExportDefault ? 1024 /* Default */ : 0);
+        const modifierFlags = (!isPrivate ? 32 /* Export */ : 0) | (isDefault && !needsPostExportDefault ? 2048 /* Default */ : 0);
         const isConstMergedWithNS = symbol.flags & 1536 /* Module */ && symbol.flags & (2 /* BlockScopedVariable */ | 1 /* FunctionScopedVariable */ | 4 /* Property */) && escapedSymbolName !== "export=" /* ExportEquals */;
         const isConstMergedWithNSPrintableAsSignatureMerge = isConstMergedWithNS && isTypeRepresentableAsFunctionNamespaceMerge(getTypeOfSymbol(symbol), symbol);
         if (symbol.flags & (16 /* Function */ | 8192 /* Method */) || isConstMergedWithNSPrintableAsSignatureMerge) {
@@ -50082,7 +50124,7 @@ function createTypeChecker(host) {
                   ),
                   textRange
                 );
-                addResult(statement, name !== localName ? modifierFlags & ~1 /* Export */ : modifierFlags);
+                addResult(statement, name !== localName ? modifierFlags & ~32 /* Export */ : modifierFlags);
                 if (name !== localName && !isPrivate) {
                   addResult(
                     factory.createExportDeclaration(
@@ -50187,14 +50229,14 @@ function createTypeChecker(host) {
         if (canHaveModifiers(node)) {
           let newModifierFlags = 0 /* None */;
           const enclosingDeclaration2 = context.enclosingDeclaration && (isJSDocTypeAlias(context.enclosingDeclaration) ? getSourceFileOfNode(context.enclosingDeclaration) : context.enclosingDeclaration);
-          if (additionalModifierFlags & 1 /* Export */ && enclosingDeclaration2 && (isExportingScope(enclosingDeclaration2) || isModuleDeclaration(enclosingDeclaration2)) && canHaveExportModifier(node)) {
-            newModifierFlags |= 1 /* Export */;
+          if (additionalModifierFlags & 32 /* Export */ && enclosingDeclaration2 && (isExportingScope(enclosingDeclaration2) || isModuleDeclaration(enclosingDeclaration2)) && canHaveExportModifier(node)) {
+            newModifierFlags |= 32 /* Export */;
           }
-          if (addingDeclare && !(newModifierFlags & 1 /* Export */) && (!enclosingDeclaration2 || !(enclosingDeclaration2.flags & 33554432 /* Ambient */)) && (isEnumDeclaration(node) || isVariableStatement(node) || isFunctionDeclaration(node) || isClassDeclaration(node) || isModuleDeclaration(node))) {
-            newModifierFlags |= 2 /* Ambient */;
+          if (addingDeclare && !(newModifierFlags & 32 /* Export */) && (!enclosingDeclaration2 || !(enclosingDeclaration2.flags & 33554432 /* Ambient */)) && (isEnumDeclaration(node) || isVariableStatement(node) || isFunctionDeclaration(node) || isClassDeclaration(node) || isModuleDeclaration(node))) {
+            newModifierFlags |= 128 /* Ambient */;
           }
-          if (additionalModifierFlags & 1024 /* Default */ && (isClassDeclaration(node) || isInterfaceDeclaration(node) || isFunctionDeclaration(node))) {
-            newModifierFlags |= 1024 /* Default */;
+          if (additionalModifierFlags & 2048 /* Default */ && (isClassDeclaration(node) || isInterfaceDeclaration(node) || isFunctionDeclaration(node))) {
+            newModifierFlags |= 2048 /* Default */;
           }
           if (newModifierFlags) {
             node = factory.replaceModifiers(node, newModifierFlags | getEffectiveModifierFlags(node));
@@ -50316,7 +50358,7 @@ function createTypeChecker(host) {
       function serializeEnum(symbol, symbolName2, modifierFlags) {
         addResult(
           factory.createEnumDeclaration(
-            factory.createModifiersFromModifierFlags(isConstEnumSymbol(symbol) ? 2048 /* Const */ : 0),
+            factory.createModifiersFromModifierFlags(isConstEnumSymbol(symbol) ? 4096 /* Const */ : 0),
             getInternalSymbolName(symbol, symbolName2),
             map(filter(getPropertiesOfType(getTypeOfSymbol(symbol)), (p) => !!(p.flags & 8 /* EnumMember */)), (p) => {
               const initializedValue = p.declarations && p.declarations[0] && isEnumMember(p.declarations[0]) ? getConstantValue2(p.declarations[0]) : void 0;
@@ -50400,7 +50442,7 @@ function createTypeChecker(host) {
               factory.createIdentifier("default" /* Default */)
             )])
           ) : d);
-          const exportModifierStripped = every(defaultReplaced, (d) => hasSyntacticModifier(d, 1 /* Export */)) ? map(defaultReplaced, removeExportModifier) : defaultReplaced;
+          const exportModifierStripped = every(defaultReplaced, (d) => hasSyntacticModifier(d, 32 /* Export */)) ? map(defaultReplaced, removeExportModifier) : defaultReplaced;
           fakespace = factory.updateModuleDeclaration(
             fakespace,
             fakespace.modifiers,
@@ -50503,7 +50545,7 @@ function createTypeChecker(host) {
         );
         const isNonConstructableClassLikeInJsFile = !isClass && !!symbol.valueDeclaration && isInJSFile(symbol.valueDeclaration) && !some(getSignaturesOfType(staticType, 1 /* Construct */));
         const constructors = isNonConstructableClassLikeInJsFile ? [factory.createConstructorDeclaration(
-          factory.createModifiersFromModifierFlags(8 /* Private */),
+          factory.createModifiersFromModifierFlags(2 /* Private */),
           [],
           /*body*/
           void 0
@@ -50856,7 +50898,7 @@ function createTypeChecker(host) {
           const varName = getUnusedName(name, symbol);
           const typeToSerialize = getWidenedType(getTypeOfSymbol(getMergedSymbol(symbol)));
           if (isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, symbol)) {
-            serializeAsFunctionNamespaceMerge(typeToSerialize, symbol, varName, isExportAssignmentCompatibleSymbolName ? 0 /* None */ : 1 /* Export */);
+            serializeAsFunctionNamespaceMerge(typeToSerialize, symbol, varName, isExportAssignmentCompatibleSymbolName ? 0 /* None */ : 32 /* Export */);
           } else {
             const flags = ((_a2 = context.enclosingDeclaration) == null ? void 0 : _a2.kind) === 267 /* ModuleDeclaration */ && (!(symbol.flags & 98304 /* Accessor */) || symbol.flags & 65536 /* SetAccessor */) ? 1 /* Let */ : 2 /* Const */;
             const statement = factory.createVariableStatement(
@@ -50873,7 +50915,7 @@ function createTypeChecker(host) {
             );
             addResult(
               statement,
-              target && target.flags & 4 /* Property */ && target.escapedName === "export=" /* ExportEquals */ ? 2 /* Ambient */ : name === varName ? 1 /* Export */ : 0 /* None */
+              target && target.flags & 4 /* Property */ && target.escapedName === "export=" /* ExportEquals */ ? 128 /* Ambient */ : name === varName ? 32 /* Export */ : 0 /* None */
             );
           }
           if (isExportAssignmentCompatibleSymbolName) {
@@ -50909,14 +50951,14 @@ function createTypeChecker(host) {
         return function serializePropertySymbol(p, isStatic2, baseType) {
           var _a2, _b, _c, _d, _e;
           const modifierFlags = getDeclarationModifierFlagsFromSymbol(p);
-          const isPrivate = !!(modifierFlags & 8 /* Private */);
+          const isPrivate = !!(modifierFlags & 2 /* Private */);
           if (isStatic2 && p.flags & (788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */)) {
             return [];
           }
           if (p.flags & 4194304 /* Prototype */ || p.escapedName === "constructor" || baseType && getPropertyOfType(baseType, p.escapedName) && isReadonlySymbol(getPropertyOfType(baseType, p.escapedName)) === isReadonlySymbol(p) && (p.flags & 16777216 /* Optional */) === (getPropertyOfType(baseType, p.escapedName).flags & 16777216 /* Optional */) && isTypeIdenticalTo(getTypeOfSymbol(p), getTypeOfPropertyOfType(baseType, p.escapedName))) {
             return [];
           }
-          const flag = modifierFlags & ~512 /* Async */ | (isStatic2 ? 32 /* Static */ : 0);
+          const flag = modifierFlags & ~1024 /* Async */ | (isStatic2 ? 256 /* Static */ : 0);
           const name = getPropertyNameNodeForSymbol(p, context);
           const firstPropertyLikeDecl = (_a2 = p.declarations) == null ? void 0 : _a2.find(or(isPropertyDeclaration, isAccessor, isVariableDeclaration, isPropertySignature, isBinaryExpression, isPropertyAccessExpression));
           if (p.flags & 98304 /* Accessor */ && useAccessors) {
@@ -50958,7 +51000,7 @@ function createTypeChecker(host) {
               ));
             }
             if (p.flags & 32768 /* GetAccessor */) {
-              const isPrivate2 = modifierFlags & 8 /* Private */;
+              const isPrivate2 = modifierFlags & 2 /* Private */;
               result.push(setTextRange(
                 factory.createGetAccessorDeclaration(
                   factory.createModifiersFromModifierFlags(flag),
@@ -50975,7 +51017,7 @@ function createTypeChecker(host) {
           } else if (p.flags & (4 /* Property */ | 3 /* Variable */ | 98304 /* Accessor */)) {
             return setTextRange(
               createProperty2(
-                factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 64 /* Readonly */ : 0) | flag),
+                factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag),
                 name,
                 p.flags & 16777216 /* Optional */ ? factory.createToken(58 /* QuestionToken */) : void 0,
                 isPrivate ? void 0 : serializeTypeForDeclaration(context, getWriteTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled),
@@ -50990,10 +51032,10 @@ function createTypeChecker(host) {
           if (p.flags & (8192 /* Method */ | 16 /* Function */)) {
             const type = getTypeOfSymbol(p);
             const signatures = getSignaturesOfType(type, 0 /* Call */);
-            if (flag & 8 /* Private */) {
+            if (flag & 2 /* Private */) {
               return setTextRange(
                 createProperty2(
-                  factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 64 /* Readonly */ : 0) | flag),
+                  factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag),
                   name,
                   p.flags & 16777216 /* Optional */ ? factory.createToken(58 /* QuestionToken */) : void 0,
                   /*type*/
@@ -51069,7 +51111,7 @@ function createTypeChecker(host) {
           let privateProtected = 0;
           for (const s of signatures) {
             if (s.declaration) {
-              privateProtected |= getSelectedEffectiveModifierFlags(s.declaration, 8 /* Private */ | 16 /* Protected */);
+              privateProtected |= getSelectedEffectiveModifierFlags(s.declaration, 2 /* Private */ | 4 /* Protected */);
             }
           }
           if (privateProtected) {
@@ -51262,10 +51304,10 @@ function createTypeChecker(host) {
     return result || types;
   }
   function visibilityToString(flags) {
-    if (flags === 8 /* Private */) {
+    if (flags === 2 /* Private */) {
       return "private";
     }
-    if (flags === 16 /* Protected */) {
+    if (flags === 4 /* Protected */) {
       return "protected";
     }
     return "public";
@@ -51383,7 +51425,7 @@ function createTypeChecker(host) {
             return true;
           }
           const parent = getDeclarationContainer(node);
-          if (!(getCombinedModifierFlagsCached(node) & 1 /* Export */) && !(node.kind !== 271 /* ImportEqualsDeclaration */ && parent.kind !== 312 /* SourceFile */ && parent.flags & 33554432 /* Ambient */)) {
+          if (!(getCombinedModifierFlagsCached(node) & 32 /* Export */) && !(node.kind !== 271 /* ImportEqualsDeclaration */ && parent.kind !== 312 /* SourceFile */ && parent.flags & 33554432 /* Ambient */)) {
             return isGlobalSourceFile(parent);
           }
           return isDeclarationVisible(parent);
@@ -51393,7 +51435,7 @@ function createTypeChecker(host) {
         case 178 /* SetAccessor */:
         case 174 /* MethodDeclaration */:
         case 173 /* MethodSignature */:
-          if (hasEffectiveModifier(node, 8 /* Private */ | 16 /* Protected */)) {
+          if (hasEffectiveModifier(node, 2 /* Private */ | 4 /* Protected */)) {
             return false;
           }
         case 176 /* Constructor */:
@@ -51612,7 +51654,7 @@ function createTypeChecker(host) {
     const unspreadableToRestKeys = [];
     for (const prop of getPropertiesOfType(source)) {
       const literalTypeFromProperty = getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */);
-      if (!isTypeAssignableTo(literalTypeFromProperty, omitKeyType) && !(getDeclarationModifierFlagsFromSymbol(prop) & (8 /* Private */ | 16 /* Protected */)) && isSpreadableProperty(prop)) {
+      if (!isTypeAssignableTo(literalTypeFromProperty, omitKeyType) && !(getDeclarationModifierFlagsFromSymbol(prop) & (2 /* Private */ | 4 /* Protected */)) && isSpreadableProperty(prop)) {
         spreadableProperties.push(prop);
       } else {
         unspreadableToRestKeys.push(literalTypeFromProperty);
@@ -51818,7 +51860,7 @@ function createTypeChecker(host) {
     if (declaredType) {
       return addOptionality(declaredType, isProperty, isOptional);
     }
-    if ((noImplicitAny || isInJSFile(declaration)) && isVariableDeclaration(declaration) && !isBindingPattern(declaration.name) && !(getCombinedModifierFlagsCached(declaration) & 1 /* Export */) && !(declaration.flags & 33554432 /* Ambient */)) {
+    if ((noImplicitAny || isInJSFile(declaration)) && isVariableDeclaration(declaration) && !isBindingPattern(declaration.name) && !(getCombinedModifierFlagsCached(declaration) & 32 /* Export */) && !(declaration.flags & 33554432 /* Ambient */)) {
       if (!(getCombinedNodeFlagsCached(declaration) & 6 /* Constant */) && (!declaration.initializer || isNullOrUndefined2(declaration.initializer))) {
         return autoType;
       }
@@ -51866,7 +51908,7 @@ function createTypeChecker(host) {
     if (isPropertyDeclaration(declaration) && (noImplicitAny || isInJSFile(declaration))) {
       if (!hasStaticModifier(declaration)) {
         const constructor = findConstructorDeclaration(declaration.parent);
-        const type = constructor ? getFlowTypeInConstructor(declaration.symbol, constructor) : getEffectiveModifierFlags(declaration) & 2 /* Ambient */ ? getTypeOfPropertyInBaseClass(declaration.symbol) : void 0;
+        const type = constructor ? getFlowTypeInConstructor(declaration.symbol, constructor) : getEffectiveModifierFlags(declaration) & 128 /* Ambient */ ? getTypeOfPropertyInBaseClass(declaration.symbol) : void 0;
         return type && addOptionality(
           type,
           /*isProperty*/
@@ -51875,7 +51917,7 @@ function createTypeChecker(host) {
         );
       } else {
         const staticBlocks = filter(declaration.parent.members, isClassStaticBlockDeclaration);
-        const type = staticBlocks.length ? getFlowTypeInStaticBlocks(declaration.symbol, staticBlocks) : getEffectiveModifierFlags(declaration) & 2 /* Ambient */ ? getTypeOfPropertyInBaseClass(declaration.symbol) : void 0;
+        const type = staticBlocks.length ? getFlowTypeInStaticBlocks(declaration.symbol, staticBlocks) : getEffectiveModifierFlags(declaration) & 128 /* Ambient */ ? getTypeOfPropertyInBaseClass(declaration.symbol) : void 0;
         return type && addOptionality(
           type,
           /*isProperty*/
@@ -51979,7 +52021,7 @@ function createTypeChecker(host) {
     return everyType(flowType, isNullableType) ? void 0 : convertAutoToAny(flowType);
   }
   function getFlowTypeOfProperty(reference, prop) {
-    const initialType = (prop == null ? void 0 : prop.valueDeclaration) && (!isAutoTypedProperty(prop) || getEffectiveModifierFlags(prop.valueDeclaration) & 2 /* Ambient */) && getTypeOfPropertyInBaseClass(prop) || undefinedType;
+    const initialType = (prop == null ? void 0 : prop.valueDeclaration) && (!isAutoTypedProperty(prop) || getEffectiveModifierFlags(prop.valueDeclaration) & 128 /* Ambient */) && getTypeOfPropertyInBaseClass(prop) || undefinedType;
     return getFlowTypeOfReference(reference, autoType, initialType);
   }
   function getWidenedTypeForAssignmentDeclaration(symbol, resolvedSymbol) {
@@ -53632,7 +53674,7 @@ function createTypeChecker(host) {
     const baseConstructorType = getBaseConstructorTypeOfClass(classType);
     const baseSignatures = getSignaturesOfType(baseConstructorType, 1 /* Construct */);
     const declaration = getClassLikeDeclarationOfSymbol(classType.symbol);
-    const isAbstract = !!declaration && hasSyntacticModifier(declaration, 256 /* Abstract */);
+    const isAbstract = !!declaration && hasSyntacticModifier(declaration, 64 /* Abstract */);
     if (baseSignatures.length === 0) {
       return [createSignature(
         /*declaration*/
@@ -54408,7 +54450,7 @@ function createTypeChecker(host) {
   }
   function isConstTypeVariable(type, depth = 0) {
     var _a;
-    return depth < 5 && !!(type && (type.flags & 262144 /* TypeParameter */ && some((_a = type.symbol) == null ? void 0 : _a.declarations, (d) => hasSyntacticModifier(d, 2048 /* Const */)) || type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, (t) => isConstTypeVariable(t, depth)) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType, depth + 1) || type.flags & 16777216 /* Conditional */ && isConstTypeVariable(getConstraintOfConditionalType(type), depth + 1) || type.flags & 33554432 /* Substitution */ && isConstTypeVariable(type.baseType, depth) || isGenericTupleType(type) && findIndex(getElementTypes(type), (t, i) => !!(type.target.elementFlags[i] & 8 /* Variadic */) && isConstTypeVariable(t, depth)) >= 0));
+    return depth < 5 && !!(type && (type.flags & 262144 /* TypeParameter */ && some((_a = type.symbol) == null ? void 0 : _a.declarations, (d) => hasSyntacticModifier(d, 4096 /* Const */)) || type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, (t) => isConstTypeVariable(t, depth)) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType, depth + 1) || type.flags & 16777216 /* Conditional */ && isConstTypeVariable(getConstraintOfConditionalType(type), depth + 1) || type.flags & 33554432 /* Substitution */ && isConstTypeVariable(type.baseType, depth) || isGenericTupleType(type) && findIndex(getElementTypes(type), (t, i) => !!(type.target.elementFlags[i] & 8 /* Variadic */) && isConstTypeVariable(t, depth)) >= 0));
   }
   function getConstraintOfIndexedAccess(type) {
     return hasNonCircularBaseConstraint(type) ? getConstraintFromIndexedAccess(type) : void 0;
@@ -54734,7 +54776,7 @@ function createTypeChecker(host) {
           } else if (!isUnion && !isReadonlySymbol(prop)) {
             checkFlags &= ~8 /* Readonly */;
           }
-          checkFlags |= (!(modifiers & 24 /* NonPublicAccessibilityModifier */) ? 256 /* ContainsPublic */ : 0) | (modifiers & 16 /* Protected */ ? 512 /* ContainsProtected */ : 0) | (modifiers & 8 /* Private */ ? 1024 /* ContainsPrivate */ : 0) | (modifiers & 32 /* Static */ ? 2048 /* ContainsStatic */ : 0);
+          checkFlags |= (!(modifiers & 6 /* NonPublicAccessibilityModifier */) ? 256 /* ContainsPublic */ : 0) | (modifiers & 4 /* Protected */ ? 512 /* ContainsProtected */ : 0) | (modifiers & 2 /* Private */ ? 1024 /* ContainsPrivate */ : 0) | (modifiers & 256 /* Static */ ? 2048 /* ContainsStatic */ : 0);
           if (!isPrototypeProperty(prop)) {
             syntheticFlag = 2 /* SyntheticProperty */;
           }
@@ -55186,7 +55228,7 @@ function createTypeChecker(host) {
       if (hasRestParameter(declaration) || isInJSFile(declaration) && maybeAddJsSyntheticRestParameter(declaration, parameters)) {
         flags |= 1 /* HasRestParameter */;
       }
-      if (isConstructorTypeNode(declaration) && hasSyntacticModifier(declaration, 256 /* Abstract */) || isConstructorDeclaration(declaration) && hasSyntacticModifier(declaration.parent, 256 /* Abstract */)) {
+      if (isConstructorTypeNode(declaration) && hasSyntacticModifier(declaration, 64 /* Abstract */) || isConstructorDeclaration(declaration) && hasSyntacticModifier(declaration.parent, 64 /* Abstract */)) {
         flags |= 4 /* Abstract */;
       }
       links.resolvedSignature = createSignature(
@@ -55556,7 +55598,7 @@ function createTypeChecker(host) {
           if (parameter.type) {
             forEachType(getTypeFromTypeNode(parameter.type), (keyType) => {
               if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos, keyType)) {
-                indexInfos.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, hasEffectiveModifier(declaration, 64 /* Readonly */), declaration));
+                indexInfos.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, hasEffectiveModifier(declaration, 8 /* Readonly */), declaration));
               }
             });
           }
@@ -57381,7 +57423,7 @@ function createTypeChecker(host) {
     return neverType;
   }
   function getLiteralTypeFromProperty(prop, include, includeNonPublic) {
-    if (includeNonPublic || !(getDeclarationModifierFlagsFromSymbol(prop) & 24 /* NonPublicAccessibilityModifier */)) {
+    if (includeNonPublic || !(getDeclarationModifierFlagsFromSymbol(prop) & 6 /* NonPublicAccessibilityModifier */)) {
       let type = getSymbolLinks(getLateBoundSymbol(prop)).nameType;
       if (!type) {
         const name = getNameOfDeclaration(prop.valueDeclaration);
@@ -58326,7 +58368,7 @@ function createTypeChecker(host) {
     function getAnonymousPartialType(type2) {
       const members = createSymbolTable();
       for (const prop of getPropertiesOfType(type2)) {
-        if (getDeclarationModifierFlagsFromSymbol(prop) & (8 /* Private */ | 16 /* Protected */)) {
+        if (getDeclarationModifierFlagsFromSymbol(prop) & (2 /* Private */ | 4 /* Protected */)) {
         } else if (isSpreadableProperty(prop)) {
           const isSetonlyAccessor = prop.flags & 65536 /* SetAccessor */ && !(prop.flags & 32768 /* GetAccessor */);
           const flags = 4 /* Property */ | 16777216 /* Optional */;
@@ -58388,7 +58430,7 @@ function createTypeChecker(host) {
     const skippedPrivateMembers = /* @__PURE__ */ new Set();
     const indexInfos = left === emptyObjectType ? getIndexInfosOfType(right) : getUnionIndexInfos([left, right]);
     for (const rightProp of getPropertiesOfType(right)) {
-      if (getDeclarationModifierFlagsFromSymbol(rightProp) & (8 /* Private */ | 16 /* Protected */)) {
+      if (getDeclarationModifierFlagsFromSymbol(rightProp) & (2 /* Private */ | 4 /* Protected */)) {
         skippedPrivateMembers.add(rightProp.escapedName);
       } else if (isSpreadableProperty(rightProp)) {
         members.set(rightProp.escapedName, getSpreadSymbol(rightProp, readonly));
@@ -61955,25 +61997,25 @@ function createTypeChecker(host) {
     function propertyRelatedTo(source2, target2, sourceProp, targetProp, getTypeOfSourceProperty, reportErrors2, intersectionState, skipOptional) {
       const sourcePropFlags = getDeclarationModifierFlagsFromSymbol(sourceProp);
       const targetPropFlags = getDeclarationModifierFlagsFromSymbol(targetProp);
-      if (sourcePropFlags & 8 /* Private */ || targetPropFlags & 8 /* Private */) {
+      if (sourcePropFlags & 2 /* Private */ || targetPropFlags & 2 /* Private */) {
         if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) {
           if (reportErrors2) {
-            if (sourcePropFlags & 8 /* Private */ && targetPropFlags & 8 /* Private */) {
+            if (sourcePropFlags & 2 /* Private */ && targetPropFlags & 2 /* Private */) {
               reportError(Diagnostics.Types_have_separate_declarations_of_a_private_property_0, symbolToString(targetProp));
             } else {
-              reportError(Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 8 /* Private */ ? source2 : target2), typeToString(sourcePropFlags & 8 /* Private */ ? target2 : source2));
+              reportError(Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 2 /* Private */ ? source2 : target2), typeToString(sourcePropFlags & 2 /* Private */ ? target2 : source2));
             }
           }
           return 0 /* False */;
         }
-      } else if (targetPropFlags & 16 /* Protected */) {
+      } else if (targetPropFlags & 4 /* Protected */) {
         if (!isValidOverrideOf(sourceProp, targetProp)) {
           if (reportErrors2) {
             reportError(Diagnostics.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2, symbolToString(targetProp), typeToString(getDeclaringClass(sourceProp) || source2), typeToString(getDeclaringClass(targetProp) || target2));
           }
           return 0 /* False */;
         }
-      } else if (sourcePropFlags & 16 /* Protected */) {
+      } else if (sourcePropFlags & 4 /* Protected */) {
         if (reportErrors2) {
           reportError(Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2, symbolToString(targetProp), typeToString(source2), typeToString(target2));
         }
@@ -62503,15 +62545,15 @@ function createTypeChecker(host) {
       if (!sourceSignature.declaration || !targetSignature.declaration) {
         return true;
       }
-      const sourceAccessibility = getSelectedEffectiveModifierFlags(sourceSignature.declaration, 24 /* NonPublicAccessibilityModifier */);
-      const targetAccessibility = getSelectedEffectiveModifierFlags(targetSignature.declaration, 24 /* NonPublicAccessibilityModifier */);
-      if (targetAccessibility === 8 /* Private */) {
+      const sourceAccessibility = getSelectedEffectiveModifierFlags(sourceSignature.declaration, 6 /* NonPublicAccessibilityModifier */);
+      const targetAccessibility = getSelectedEffectiveModifierFlags(targetSignature.declaration, 6 /* NonPublicAccessibilityModifier */);
+      if (targetAccessibility === 2 /* Private */) {
         return true;
       }
-      if (targetAccessibility === 16 /* Protected */ && sourceAccessibility !== 8 /* Private */) {
+      if (targetAccessibility === 4 /* Protected */ && sourceAccessibility !== 2 /* Private */) {
         return true;
       }
-      if (targetAccessibility !== 16 /* Protected */ && !sourceAccessibility) {
+      if (targetAccessibility !== 4 /* Protected */ && !sourceAccessibility) {
         return true;
       }
       if (reportErrors2) {
@@ -62611,7 +62653,7 @@ function createTypeChecker(host) {
       const variances = [];
       for (const tp of typeParameters) {
         const modifiers = getTypeParameterModifiers(tp);
-        let variance = modifiers & 65536 /* Out */ ? modifiers & 32768 /* In */ ? 0 /* Invariant */ : 1 /* Covariant */ : modifiers & 32768 /* In */ ? 2 /* Contravariant */ : void 0;
+        let variance = modifiers & 16384 /* Out */ ? modifiers & 8192 /* In */ ? 0 /* Invariant */ : 1 /* Covariant */ : modifiers & 8192 /* In */ ? 2 /* Contravariant */ : void 0;
         if (variance === void 0) {
           let unmeasurable = false;
           let unreliable = false;
@@ -62659,7 +62701,7 @@ function createTypeChecker(host) {
   }
   function getTypeParameterModifiers(tp) {
     var _a;
-    return reduceLeft((_a = tp.symbol) == null ? void 0 : _a.declarations, (modifiers, d) => modifiers | getEffectiveModifierFlags(d), 0 /* None */) & (32768 /* In */ | 65536 /* Out */ | 2048 /* Const */);
+    return reduceLeft((_a = tp.symbol) == null ? void 0 : _a.declarations, (modifiers, d) => modifiers | getEffectiveModifierFlags(d), 0 /* None */) & (8192 /* In */ | 16384 /* Out */ | 4096 /* Const */);
   }
   function hasCovariantVoidArgument(typeArguments, variances) {
     for (let i = 0; i < variances.length; i++) {
@@ -62744,10 +62786,10 @@ function createTypeChecker(host) {
     });
   }
   function isValidOverrideOf(sourceProp, targetProp) {
-    return !forEachProperty(targetProp, (tp) => getDeclarationModifierFlagsFromSymbol(tp) & 16 /* Protected */ ? !isPropertyInClassDerivedFrom(sourceProp, getDeclaringClass(tp)) : false);
+    return !forEachProperty(targetProp, (tp) => getDeclarationModifierFlagsFromSymbol(tp) & 4 /* Protected */ ? !isPropertyInClassDerivedFrom(sourceProp, getDeclaringClass(tp)) : false);
   }
   function isClassDerivedFromDeclaringClasses(checkClass, prop, writing) {
-    return forEachProperty(prop, (p) => getDeclarationModifierFlagsFromSymbol(p, writing) & 16 /* Protected */ ? !hasBaseType(checkClass, getDeclaringClass(p)) : false) ? void 0 : checkClass;
+    return forEachProperty(prop, (p) => getDeclarationModifierFlagsFromSymbol(p, writing) & 4 /* Protected */ ? !hasBaseType(checkClass, getDeclaringClass(p)) : false) ? void 0 : checkClass;
   }
   function isDeeplyNestedType(type, stack, depth, maxDepth = 3) {
     if (depth >= maxDepth) {
@@ -62824,8 +62866,8 @@ function createTypeChecker(host) {
     if (sourceProp === targetProp) {
       return -1 /* True */;
     }
-    const sourcePropAccessibility = getDeclarationModifierFlagsFromSymbol(sourceProp) & 24 /* NonPublicAccessibilityModifier */;
-    const targetPropAccessibility = getDeclarationModifierFlagsFromSymbol(targetProp) & 24 /* NonPublicAccessibilityModifier */;
+    const sourcePropAccessibility = getDeclarationModifierFlagsFromSymbol(sourceProp) & 6 /* NonPublicAccessibilityModifier */;
+    const targetPropAccessibility = getDeclarationModifierFlagsFromSymbol(targetProp) & 6 /* NonPublicAccessibilityModifier */;
     if (sourcePropAccessibility !== targetPropAccessibility) {
       return 0 /* False */;
     }
@@ -66819,7 +66861,7 @@ function createTypeChecker(host) {
       if (languageVersion < 2 /* ES2015 */) {
         if (container.kind === 219 /* ArrowFunction */) {
           error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression);
-        } else if (hasSyntacticModifier(container, 512 /* Async */)) {
+        } else if (hasSyntacticModifier(container, 1024 /* Async */)) {
           error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_using_a_standard_function_or_method);
         }
       }
@@ -67232,7 +67274,7 @@ function createTypeChecker(host) {
     let inAsyncFunction = false;
     if (!isCallExpression2) {
       while (container && container.kind === 219 /* ArrowFunction */) {
-        if (hasSyntacticModifier(container, 512 /* Async */))
+        if (hasSyntacticModifier(container, 1024 /* Async */))
           inAsyncFunction = true;
         container = getSuperContainer(
           container,
@@ -67241,7 +67283,7 @@ function createTypeChecker(host) {
         );
         needToCaptureLexicalThis = languageVersion < 2 /* ES2015 */;
       }
-      if (container && hasSyntacticModifier(container, 512 /* Async */))
+      if (container && hasSyntacticModifier(container, 1024 /* Async */))
         inAsyncFunction = true;
     }
     let nodeCheckFlag = 0;
@@ -69429,20 +69471,20 @@ function createTypeChecker(host) {
           return false;
         }
       }
-      if (flags & 256 /* Abstract */) {
+      if (flags & 64 /* Abstract */) {
         if (errorNode) {
           error(errorNode, Diagnostics.Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression, symbolToString(prop), typeToString(getDeclaringClass(prop)));
         }
         return false;
       }
-      if (!(flags & 32 /* Static */) && ((_a = prop.declarations) == null ? void 0 : _a.some(isClassInstanceProperty))) {
+      if (!(flags & 256 /* Static */) && ((_a = prop.declarations) == null ? void 0 : _a.some(isClassInstanceProperty))) {
         if (errorNode) {
           error(errorNode, Diagnostics.Class_field_0_defined_by_the_parent_class_is_not_accessible_in_the_child_class_via_super, symbolToString(prop));
         }
         return false;
       }
     }
-    if (flags & 256 /* Abstract */ && symbolHasNonMethodDeclaration(prop) && (isThisProperty(location) || isThisInitializedObjectBindingExpression(location) || isObjectBindingPattern(location.parent) && isThisInitializedDeclaration(location.parent.parent))) {
+    if (flags & 64 /* Abstract */ && symbolHasNonMethodDeclaration(prop) && (isThisProperty(location) || isThisInitializedObjectBindingExpression(location) || isObjectBindingPattern(location.parent) && isThisInitializedDeclaration(location.parent.parent))) {
       const declaringClassDeclaration = getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop));
       if (declaringClassDeclaration && isNodeUsedDuringClassInitialization(location)) {
         if (errorNode) {
@@ -69451,10 +69493,10 @@ function createTypeChecker(host) {
         return false;
       }
     }
-    if (!(flags & 24 /* NonPublicAccessibilityModifier */)) {
+    if (!(flags & 6 /* NonPublicAccessibilityModifier */)) {
       return true;
     }
-    if (flags & 8 /* Private */) {
+    if (flags & 2 /* Private */) {
       const declaringClassDeclaration = getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop));
       if (!isNodeWithinClass(location, declaringClassDeclaration)) {
         if (errorNode) {
@@ -69474,14 +69516,14 @@ function createTypeChecker(host) {
     if (!enclosingClass) {
       enclosingClass = getEnclosingClassFromThisParameter(location);
       enclosingClass = enclosingClass && isClassDerivedFromDeclaringClasses(enclosingClass, prop, writing);
-      if (flags & 32 /* Static */ || !enclosingClass) {
+      if (flags & 256 /* Static */ || !enclosingClass) {
         if (errorNode) {
           error(errorNode, Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses, symbolToString(prop), typeToString(getDeclaringClass(prop) || containingType));
         }
         return false;
       }
     }
-    if (flags & 32 /* Static */) {
+    if (flags & 256 /* Static */) {
       return true;
     }
     if (containingType.flags & 262144 /* TypeParameter */) {
@@ -69901,7 +69943,7 @@ function createTypeChecker(host) {
     }
     let diagnosticMessage;
     const declarationName = idText(right);
-    if (isInPropertyInitializerOrClassStaticBlock(node) && !isOptionalPropertyDeclaration(valueDeclaration) && !(isAccessExpression(node) && isAccessExpression(node.expression)) && !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right) && !(isMethodDeclaration(valueDeclaration) && getCombinedModifierFlagsCached(valueDeclaration) & 32 /* Static */) && (useDefineForClassFields || !isPropertyDeclaredInAncestorClass(prop))) {
+    if (isInPropertyInitializerOrClassStaticBlock(node) && !isOptionalPropertyDeclaration(valueDeclaration) && !(isAccessExpression(node) && isAccessExpression(node.expression)) && !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right) && !(isMethodDeclaration(valueDeclaration) && getCombinedModifierFlagsCached(valueDeclaration) & 256 /* Static */) && (useDefineForClassFields || !isPropertyDeclaredInAncestorClass(prop))) {
       diagnosticMessage = error(right, Diagnostics.Property_0_is_used_before_its_initialization, declarationName);
     } else if (valueDeclaration.kind === 263 /* ClassDeclaration */ && node.parent.kind !== 183 /* TypeReference */ && !(valueDeclaration.flags & 33554432 /* Ambient */) && !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right)) {
       diagnosticMessage = error(right, Diagnostics.Class_0_used_before_its_declaration, declarationName);
@@ -70155,7 +70197,7 @@ function createTypeChecker(host) {
     if (!valueDeclaration) {
       return;
     }
-    const hasPrivateModifier = hasEffectiveModifier(valueDeclaration, 8 /* Private */);
+    const hasPrivateModifier = hasEffectiveModifier(valueDeclaration, 2 /* Private */);
     const hasPrivateIdentifier = prop.valueDeclaration && isNamedDeclaration(prop.valueDeclaration) && isPrivateIdentifier(prop.valueDeclaration.name);
     if (!hasPrivateModifier && !hasPrivateIdentifier) {
       return;
@@ -71600,7 +71642,7 @@ function createTypeChecker(host) {
         return resolveErrorCall(node);
       }
       const valueDecl = expressionType.symbol && getClassLikeDeclarationOfSymbol(expressionType.symbol);
-      if (valueDecl && hasSyntacticModifier(valueDecl, 256 /* Abstract */)) {
+      if (valueDecl && hasSyntacticModifier(valueDecl, 64 /* Abstract */)) {
         error(node, Diagnostics.Cannot_create_an_instance_of_an_abstract_class);
         return resolveErrorCall(node);
       }
@@ -71663,7 +71705,7 @@ function createTypeChecker(host) {
       return true;
     }
     const declaration = signature.declaration;
-    const modifiers = getSelectedEffectiveModifierFlags(declaration, 24 /* NonPublicAccessibilityModifier */);
+    const modifiers = getSelectedEffectiveModifierFlags(declaration, 6 /* NonPublicAccessibilityModifier */);
     if (!modifiers || declaration.kind !== 176 /* Constructor */) {
       return true;
     }
@@ -71671,16 +71713,16 @@ function createTypeChecker(host) {
     const declaringClass = getDeclaredTypeOfSymbol(declaration.parent.symbol);
     if (!isNodeWithinClass(node, declaringClassDeclaration)) {
       const containingClass = getContainingClass(node);
-      if (containingClass && modifiers & 16 /* Protected */) {
+      if (containingClass && modifiers & 4 /* Protected */) {
         const containingType = getTypeOfNode(containingClass);
         if (typeHasProtectedAccessibleBase(declaration.parent.symbol, containingType)) {
           return true;
         }
       }
-      if (modifiers & 8 /* Private */) {
+      if (modifiers & 2 /* Private */) {
         error(node, Diagnostics.Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration, typeToString(declaringClass));
       }
-      if (modifiers & 16 /* Protected */) {
+      if (modifiers & 4 /* Protected */) {
         error(node, Diagnostics.Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration, typeToString(declaringClass));
       }
       return false;
@@ -73657,7 +73699,7 @@ function createTypeChecker(host) {
     return !setProp;
   }
   function isReadonlySymbol(symbol) {
-    return !!(getCheckFlags(symbol) & 8 /* Readonly */ || symbol.flags & 4 /* Property */ && getDeclarationModifierFlagsFromSymbol(symbol) & 64 /* Readonly */ || symbol.flags & 3 /* Variable */ && getDeclarationNodeFlagsFromSymbol(symbol) & 6 /* Constant */ || symbol.flags & 98304 /* Accessor */ && !(symbol.flags & 65536 /* SetAccessor */) || symbol.flags & 8 /* EnumMember */ || some(symbol.declarations, isReadonlyAssignmentDeclaration));
+    return !!(getCheckFlags(symbol) & 8 /* Readonly */ || symbol.flags & 4 /* Property */ && getDeclarationModifierFlagsFromSymbol(symbol) & 8 /* Readonly */ || symbol.flags & 3 /* Variable */ && getDeclarationNodeFlagsFromSymbol(symbol) & 6 /* Constant */ || symbol.flags & 98304 /* Accessor */ && !(symbol.flags & 65536 /* SetAccessor */) || symbol.flags & 8 /* EnumMember */ || some(symbol.declarations, isReadonlyAssignmentDeclaration));
   }
   function isAssignmentToReadonlyEntity(expr, symbol, assignmentKind) {
     var _a, _b;
@@ -75395,15 +75437,15 @@ function createTypeChecker(host) {
     var _a, _b;
     if (isInterfaceDeclaration(node.parent) || isClassLike(node.parent) || isTypeAliasDeclaration(node.parent)) {
       const typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node));
-      const modifiers = getTypeParameterModifiers(typeParameter) & (32768 /* In */ | 65536 /* Out */);
+      const modifiers = getTypeParameterModifiers(typeParameter) & (8192 /* In */ | 16384 /* Out */);
       if (modifiers) {
         const symbol = getSymbolOfDeclaration(node.parent);
         if (isTypeAliasDeclaration(node.parent) && !(getObjectFlags(getDeclaredTypeOfSymbol(symbol)) & (16 /* Anonymous */ | 32 /* Mapped */))) {
           error(node, Diagnostics.Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types);
-        } else if (modifiers === 32768 /* In */ || modifiers === 65536 /* Out */) {
+        } else if (modifiers === 8192 /* In */ || modifiers === 16384 /* Out */) {
           (_a = tracing) == null ? void 0 : _a.push(tracing.Phase.CheckTypes, "checkTypeParameterDeferred", { parent: getTypeId(getDeclaredTypeOfSymbol(symbol)), id: getTypeId(typeParameter) });
-          const source = createMarkerType(symbol, typeParameter, modifiers === 65536 /* Out */ ? markerSubTypeForCheck : markerSuperTypeForCheck);
-          const target = createMarkerType(symbol, typeParameter, modifiers === 65536 /* Out */ ? markerSuperTypeForCheck : markerSubTypeForCheck);
+          const source = createMarkerType(symbol, typeParameter, modifiers === 16384 /* Out */ ? markerSubTypeForCheck : markerSuperTypeForCheck);
+          const target = createMarkerType(symbol, typeParameter, modifiers === 16384 /* Out */ ? markerSuperTypeForCheck : markerSubTypeForCheck);
           const saveVarianceTypeParameter = typeParameter;
           varianceTypeParameter = typeParameter;
           checkTypeAssignableTo(source, target, node, Diagnostics.Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation);
@@ -75417,7 +75459,7 @@ function createTypeChecker(host) {
     checkGrammarModifiers(node);
     checkVariableLikeDeclaration(node);
     const func = getContainingFunction(node);
-    if (hasSyntacticModifier(node, 16476 /* ParameterPropertyModifier */)) {
+    if (hasSyntacticModifier(node, 31 /* ParameterPropertyModifier */)) {
       if (!(func.kind === 176 /* Constructor */ && nodeIsPresent(func.body))) {
         error(node, Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
       }
@@ -75749,7 +75791,7 @@ function createTypeChecker(host) {
       checkGrammarComputedPropertyName(node.name);
     checkVariableLikeDeclaration(node);
     setNodeLinksForPrivateIdentifierScope(node);
-    if (hasSyntacticModifier(node, 256 /* Abstract */) && node.kind === 172 /* PropertyDeclaration */ && node.initializer) {
+    if (hasSyntacticModifier(node, 64 /* Abstract */) && node.kind === 172 /* PropertyDeclaration */ && node.initializer) {
       error(node, Diagnostics.Property_0_cannot_have_an_initializer_because_it_is_marked_abstract, declarationNameToString(node.name));
     }
   }
@@ -75766,7 +75808,7 @@ function createTypeChecker(host) {
       error(node.name, Diagnostics.Class_constructor_may_not_be_a_generator);
     }
     checkFunctionOrMethodDeclaration(node);
-    if (hasSyntacticModifier(node, 256 /* Abstract */) && node.kind === 174 /* MethodDeclaration */ && node.body) {
+    if (hasSyntacticModifier(node, 64 /* Abstract */) && node.kind === 174 /* MethodDeclaration */ && node.body) {
       error(node, Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, declarationNameToString(node.name));
     }
     if (isPrivateIdentifier(node.name) && !getContainingClass(node)) {
@@ -75823,7 +75865,7 @@ function createTypeChecker(host) {
           if (classExtendsNull) {
             error(superCall, Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null);
           }
-          const superCallShouldBeRootLevel = !emitStandardClassFields && (some(node.parent.members, isInstancePropertyWithInitializerOrPrivateIdentifierProperty) || some(node.parameters, (p) => hasSyntacticModifier(p, 16476 /* ParameterPropertyModifier */)));
+          const superCallShouldBeRootLevel = !emitStandardClassFields && (some(node.parent.members, isInstancePropertyWithInitializerOrPrivateIdentifierProperty) || some(node.parameters, (p) => hasSyntacticModifier(p, 31 /* ParameterPropertyModifier */)));
           if (superCallShouldBeRootLevel) {
             if (!superCallIsRootLevelInConstructor(superCall, node.body)) {
               error(superCall, Diagnostics.A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_initialized_properties_parameter_properties_or_private_identifiers);
@@ -75892,11 +75934,11 @@ function createTypeChecker(host) {
           getNodeLinks(getter).flags |= 1 /* TypeChecked */;
           const getterFlags = getEffectiveModifierFlags(getter);
           const setterFlags = getEffectiveModifierFlags(setter);
-          if ((getterFlags & 256 /* Abstract */) !== (setterFlags & 256 /* Abstract */)) {
+          if ((getterFlags & 64 /* Abstract */) !== (setterFlags & 64 /* Abstract */)) {
             error(getter.name, Diagnostics.Accessors_must_both_be_abstract_or_non_abstract);
             error(setter.name, Diagnostics.Accessors_must_both_be_abstract_or_non_abstract);
           }
-          if (getterFlags & 16 /* Protected */ && !(setterFlags & (16 /* Protected */ | 8 /* Private */)) || getterFlags & 8 /* Private */ && !(setterFlags & 8 /* Private */)) {
+          if (getterFlags & 4 /* Protected */ && !(setterFlags & (4 /* Protected */ | 2 /* Private */)) || getterFlags & 2 /* Private */ && !(setterFlags & 2 /* Private */)) {
             error(getter.name, Diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter);
             error(setter.name, Diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter);
           }
@@ -76076,7 +76118,7 @@ function createTypeChecker(host) {
       const propertyName = getPropertyNameFromIndex(indexType, accessNode);
       if (propertyName) {
         const propertySymbol = forEachType(apparentObjectType, (t) => getPropertyOfType(t, propertyName));
-        if (propertySymbol && getDeclarationModifierFlagsFromSymbol(propertySymbol) & 24 /* NonPublicAccessibilityModifier */) {
+        if (propertySymbol && getDeclarationModifierFlagsFromSymbol(propertySymbol) & 6 /* NonPublicAccessibilityModifier */) {
           error(accessNode, Diagnostics.Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter, unescapeLeadingUnderscores(propertyName));
           return errorType;
         }
@@ -76174,16 +76216,16 @@ function createTypeChecker(host) {
     getTypeFromTypeNode(node);
   }
   function isPrivateWithinAmbient(node) {
-    return (hasEffectiveModifier(node, 8 /* Private */) || isPrivateIdentifierClassElementDeclaration(node)) && !!(node.flags & 33554432 /* Ambient */);
+    return (hasEffectiveModifier(node, 2 /* Private */) || isPrivateIdentifierClassElementDeclaration(node)) && !!(node.flags & 33554432 /* Ambient */);
   }
   function getEffectiveDeclarationFlags(n, flagsToCheck) {
     let flags = getCombinedModifierFlagsCached(n);
     if (n.parent.kind !== 264 /* InterfaceDeclaration */ && n.parent.kind !== 263 /* ClassDeclaration */ && n.parent.kind !== 231 /* ClassExpression */ && n.flags & 33554432 /* Ambient */) {
       const container = getEnclosingContainer(n);
-      if (container && container.flags & 128 /* ExportContext */ && !(flags & 2 /* Ambient */) && !(isModuleBlock(n.parent) && isModuleDeclaration(n.parent.parent) && isGlobalScopeAugmentation(n.parent.parent))) {
-        flags |= 1 /* Export */;
+      if (container && container.flags & 128 /* ExportContext */ && !(flags & 128 /* Ambient */) && !(isModuleBlock(n.parent) && isModuleDeclaration(n.parent.parent) && isGlobalScopeAugmentation(n.parent.parent))) {
+        flags |= 32 /* Export */;
       }
-      flags |= 2 /* Ambient */;
+      flags |= 128 /* Ambient */;
     }
     return flags & flagsToCheck;
   }
@@ -76201,13 +76243,13 @@ function createTypeChecker(host) {
         const canonicalFlags = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck2);
         forEach(overloads, (o) => {
           const deviation = getEffectiveDeclarationFlags(o, flagsToCheck2) ^ canonicalFlags;
-          if (deviation & 1 /* Export */) {
+          if (deviation & 32 /* Export */) {
             error(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_exported_or_non_exported);
-          } else if (deviation & 2 /* Ambient */) {
+          } else if (deviation & 128 /* Ambient */) {
             error(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient);
-          } else if (deviation & (8 /* Private */ | 16 /* Protected */)) {
+          } else if (deviation & (2 /* Private */ | 4 /* Protected */)) {
             error(getNameOfDeclaration(o) || o, Diagnostics.Overload_signatures_must_all_be_public_private_or_protected);
-          } else if (deviation & 256 /* Abstract */) {
+          } else if (deviation & 64 /* Abstract */) {
             error(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_abstract_or_non_abstract);
           }
         });
@@ -76224,7 +76266,7 @@ function createTypeChecker(host) {
         });
       }
     }
-    const flagsToCheck = 1 /* Export */ | 2 /* Ambient */ | 8 /* Private */ | 16 /* Protected */ | 256 /* Abstract */;
+    const flagsToCheck = 32 /* Export */ | 128 /* Ambient */ | 2 /* Private */ | 4 /* Protected */ | 64 /* Abstract */;
     let someNodeFlags = 0 /* None */;
     let allNodeFlags = flagsToCheck;
     let someHaveQuestionToken = false;
@@ -76272,7 +76314,7 @@ function createTypeChecker(host) {
       if (isConstructor) {
         error(errorNode, Diagnostics.Constructor_implementation_is_missing);
       } else {
-        if (hasSyntacticModifier(node, 256 /* Abstract */)) {
+        if (hasSyntacticModifier(node, 64 /* Abstract */)) {
           error(errorNode, Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive);
         } else {
           error(errorNode, Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration);
@@ -76358,7 +76400,7 @@ function createTypeChecker(host) {
         }
       });
     }
-    if (lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && !hasSyntacticModifier(lastSeenNonAmbientDeclaration, 256 /* Abstract */) && !lastSeenNonAmbientDeclaration.questionToken) {
+    if (lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && !hasSyntacticModifier(lastSeenNonAmbientDeclaration, 64 /* Abstract */) && !lastSeenNonAmbientDeclaration.questionToken) {
       reportImplementationExpectedError(lastSeenNonAmbientDeclaration);
     }
     if (hasOverloads) {
@@ -76401,9 +76443,9 @@ function createTypeChecker(host) {
     let defaultExportedDeclarationSpaces = 0 /* None */;
     for (const d of symbol.declarations) {
       const declarationSpaces = getDeclarationSpaces(d);
-      const effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 1 /* Export */ | 1024 /* Default */);
-      if (effectiveDeclarationFlags & 1 /* Export */) {
-        if (effectiveDeclarationFlags & 1024 /* Default */) {
+      const effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 32 /* Export */ | 2048 /* Default */);
+      if (effectiveDeclarationFlags & 32 /* Export */) {
+        if (effectiveDeclarationFlags & 2048 /* Default */) {
           defaultExportedDeclarationSpaces |= declarationSpaces;
         } else {
           exportedDeclarationSpaces |= declarationSpaces;
@@ -77044,6 +77086,12 @@ function createTypeChecker(host) {
       }
     }
   }
+  function checkJSDocThisTag(node) {
+    const host2 = getEffectiveJSDocHost(node);
+    if (host2 && isArrowFunction(host2)) {
+      error(node.tagName, Diagnostics.An_arrow_function_cannot_have_a_this_parameter);
+    }
+  }
   function checkJSDocImplementsTag(node) {
     const classLike = getEffectiveJSDocHost(node);
     if (!classLike || !isClassDeclaration(classLike) && !isClassExpression(classLike)) {
@@ -77206,13 +77254,13 @@ function createTypeChecker(host) {
             break;
           }
           const symbol = getSymbolOfDeclaration(member);
-          if (!symbol.isReferenced && (hasEffectiveModifier(member, 8 /* Private */) || isNamedDeclaration(member) && isPrivateIdentifier(member.name)) && !(member.flags & 33554432 /* Ambient */)) {
+          if (!symbol.isReferenced && (hasEffectiveModifier(member, 2 /* Private */) || isNamedDeclaration(member) && isPrivateIdentifier(member.name)) && !(member.flags & 33554432 /* Ambient */)) {
             addDiagnostic(member, 0 /* Local */, createDiagnosticForNode(member.name, Diagnostics._0_is_declared_but_its_value_is_never_read, symbolToString(symbol)));
           }
           break;
         case 176 /* Constructor */:
           for (const parameter of member.parameters) {
-            if (!parameter.symbol.isReferenced && hasSyntacticModifier(parameter, 8 /* Private */)) {
+            if (!parameter.symbol.isReferenced && hasSyntacticModifier(parameter, 2 /* Private */)) {
               addDiagnostic(parameter, 0 /* Local */, createDiagnosticForNode(parameter.name, Diagnostics.Property_0_is_declared_but_its_value_is_never_read, symbolName(parameter.symbol)));
             }
           }
@@ -77788,7 +77836,7 @@ function createTypeChecker(host) {
     if (hasQuestionToken(left) !== hasQuestionToken(right)) {
       return false;
     }
-    const interestingFlags = 8 /* Private */ | 16 /* Protected */ | 512 /* Async */ | 256 /* Abstract */ | 64 /* Readonly */ | 32 /* Static */;
+    const interestingFlags = 2 /* Private */ | 4 /* Protected */ | 1024 /* Async */ | 64 /* Abstract */ | 8 /* Readonly */ | 256 /* Static */;
     return getSelectedEffectiveModifierFlags(left, interestingFlags) === getSelectedEffectiveModifierFlags(right, interestingFlags);
   }
   function checkVariableDeclaration(node) {
@@ -79116,7 +79164,7 @@ function createTypeChecker(host) {
     if (legacyDecorators && firstDecorator && some(node.members, (p) => hasStaticModifier(p) && isPrivateIdentifierClassElementDeclaration(p))) {
       grammarErrorOnNode(firstDecorator, Diagnostics.Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator);
     }
-    if (!node.name && !hasSyntacticModifier(node, 1024 /* Default */)) {
+    if (!node.name && !hasSyntacticModifier(node, 2048 /* Default */)) {
       grammarErrorOnFirstToken(node, Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name);
     }
     checkClassLikeDeclaration(node);
@@ -79182,7 +79230,7 @@ function createTypeChecker(host) {
               error(node.name || node, Diagnostics.A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any);
             } else {
               const constructSignatures = getSignaturesOfType(baseConstructorType, 1 /* Construct */);
-              if (constructSignatures.some((signature) => signature.flags & 4 /* Abstract */) && !hasSyntacticModifier(node, 256 /* Abstract */)) {
+              if (constructSignatures.some((signature) => signature.flags & 4 /* Abstract */) && !hasSyntacticModifier(node, 64 /* Abstract */)) {
                 error(node.name || node, Diagnostics.A_mixin_class_that_extends_from_a_type_variable_containing_an_abstract_construct_signature_must_also_be_declared_abstract);
               }
             }
@@ -79396,7 +79444,7 @@ function createTypeChecker(host) {
     const signatures = getSignaturesOfType(type, 1 /* Construct */);
     if (signatures.length) {
       const declaration = signatures[0].declaration;
-      if (declaration && hasEffectiveModifier(declaration, 8 /* Private */)) {
+      if (declaration && hasEffectiveModifier(declaration, 2 /* Private */)) {
         const typeClassDeclaration = getClassLikeDeclarationOfSymbol(type.symbol);
         if (!isNodeWithinClass(node, typeClassDeclaration)) {
           error(node, Diagnostics.Cannot_extend_a_class_0_Class_constructor_is_marked_as_private, getFullyQualifiedName(type.symbol));
@@ -79416,7 +79464,7 @@ function createTypeChecker(host) {
     const baseTypes = baseTypeNode && getBaseTypes(type);
     const baseWithThis = (baseTypes == null ? void 0 : baseTypes.length) ? getTypeWithThisArgument(first(baseTypes), type.thisType) : void 0;
     const baseStaticType = getBaseConstructorTypeOfClass(type);
-    const memberHasOverrideModifier = member.parent ? hasOverrideModifier(member) : hasSyntacticModifier(member, 16384 /* Override */);
+    const memberHasOverrideModifier = member.parent ? hasOverrideModifier(member) : hasSyntacticModifier(member, 16 /* Override */);
     return checkMemberForOverrideModifier(
       node,
       staticType,
@@ -79457,7 +79505,7 @@ function createTypeChecker(host) {
         Debug.assert(!!derived, "derived should point to something, even if it is the base class' declaration.");
         if (derived === base) {
           const derivedClassDecl = getClassLikeDeclarationOfSymbol(type.symbol);
-          if (baseDeclarationFlags & 256 /* Abstract */ && (!derivedClassDecl || !hasSyntacticModifier(derivedClassDecl, 256 /* Abstract */))) {
+          if (baseDeclarationFlags & 64 /* Abstract */ && (!derivedClassDecl || !hasSyntacticModifier(derivedClassDecl, 64 /* Abstract */))) {
             for (const otherBaseType of getBaseTypes(type)) {
               if (otherBaseType === baseType)
                 continue;
@@ -79500,7 +79548,7 @@ function createTypeChecker(host) {
           }
         } else {
           const derivedDeclarationFlags = getDeclarationModifierFlagsFromSymbol(derived);
-          if (baseDeclarationFlags & 8 /* Private */ || derivedDeclarationFlags & 8 /* Private */) {
+          if (baseDeclarationFlags & 2 /* Private */ || derivedDeclarationFlags & 2 /* Private */) {
             continue;
           }
           let errorMessage;
@@ -79517,7 +79565,7 @@ function createTypeChecker(host) {
               error(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage2, symbolToString(base), typeToString(baseType), typeToString(type));
             } else if (useDefineForClassFields) {
               const uninitialized = (_c = derived.declarations) == null ? void 0 : _c.find((d) => d.kind === 172 /* PropertyDeclaration */ && !d.initializer);
-              if (uninitialized && !(derived.flags & 33554432 /* Transient */) && !(baseDeclarationFlags & 256 /* Abstract */) && !(derivedDeclarationFlags & 256 /* Abstract */) && !((_d = derived.declarations) == null ? void 0 : _d.some((d) => !!(d.flags & 33554432 /* Ambient */)))) {
+              if (uninitialized && !(derived.flags & 33554432 /* Transient */) && !(baseDeclarationFlags & 64 /* Abstract */) && !(derivedDeclarationFlags & 64 /* Abstract */) && !((_d = derived.declarations) == null ? void 0 : _d.some((d) => !!(d.flags & 33554432 /* Ambient */)))) {
                 const constructor = findConstructorDeclaration(getClassLikeDeclarationOfSymbol(type.symbol));
                 const propName = uninitialized.name;
                 if (uninitialized.exclamationToken || !constructor || !isIdentifier(propName) || !strictNullChecks || !isPropertyInitializedInConstructor(propName, type, constructor)) {
@@ -79544,7 +79592,7 @@ function createTypeChecker(host) {
       }
   }
   function isPropertyAbstractOrInterface(declaration, baseDeclarationFlags) {
-    return baseDeclarationFlags & 256 /* Abstract */ && (!isPropertyDeclaration(declaration) || !declaration.initializer) || isInterfaceDeclaration(declaration.parent);
+    return baseDeclarationFlags & 64 /* Abstract */ && (!isPropertyDeclaration(declaration) || !declaration.initializer) || isInterfaceDeclaration(declaration.parent);
   }
   function getNonInheritedProperties(type, baseTypes, properties) {
     if (!length(baseTypes)) {
@@ -79609,7 +79657,7 @@ function createTypeChecker(host) {
     }
     const constructor = findConstructorDeclaration(node);
     for (const member of node.members) {
-      if (getEffectiveModifierFlags(member) & 2 /* Ambient */) {
+      if (getEffectiveModifierFlags(member) & 128 /* Ambient */) {
         continue;
       }
       if (!isStatic(member) && isPropertyWithoutInitializer(member)) {
@@ -80196,7 +80244,7 @@ function createTypeChecker(host) {
                   name
                 );
               }
-              if (isType && node.kind === 271 /* ImportEqualsDeclaration */ && hasEffectiveModifier(node, 1 /* Export */)) {
+              if (isType && node.kind === 271 /* ImportEqualsDeclaration */ && hasEffectiveModifier(node, 32 /* Export */)) {
                 error(node, Diagnostics.Cannot_use_export_import_on_a_type_or_type_only_namespace_when_0_is_enabled, isolatedModulesLikeFlagName);
               }
               break;
@@ -80318,7 +80366,7 @@ function createTypeChecker(host) {
     checkGrammarModifiers(node);
     if (isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
       checkImportBinding(node);
-      if (hasSyntacticModifier(node, 1 /* Export */)) {
+      if (hasSyntacticModifier(node, 32 /* Export */)) {
         markExportAsReferenced(node);
       }
       if (node.moduleReference.kind !== 283 /* ExternalModuleReference */) {
@@ -80730,6 +80778,8 @@ function createTypeChecker(host) {
         return checkJSDocAccessibilityModifiers(node);
       case 357 /* JSDocSatisfiesTag */:
         return checkJSDocSatisfiesTag(node);
+      case 350 /* JSDocThisTag */:
+        return checkJSDocThisTag(node);
       case 199 /* IndexedAccessType */:
         return checkIndexedAccessType(node);
       case 200 /* MappedType */:
@@ -81956,7 +82006,7 @@ function createTypeChecker(host) {
         return true;
       }
       const target = getSymbolLinks(symbol).aliasTarget;
-      if (target && getEffectiveModifierFlags(node) & 1 /* Export */ && getSymbolFlags(target) & 111551 /* Value */ && (shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target))) {
+      if (target && getEffectiveModifierFlags(node) & 32 /* Export */ && getSymbolFlags(target) & 111551 /* Value */ && (shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target))) {
         return true;
       }
     }
@@ -81981,10 +82031,10 @@ function createTypeChecker(host) {
     return false;
   }
   function isRequiredInitializedParameter(parameter) {
-    return !!strictNullChecks && !isOptionalParameter(parameter) && !isJSDocParameterTag(parameter) && !!parameter.initializer && !hasSyntacticModifier(parameter, 16476 /* ParameterPropertyModifier */);
+    return !!strictNullChecks && !isOptionalParameter(parameter) && !isJSDocParameterTag(parameter) && !!parameter.initializer && !hasSyntacticModifier(parameter, 31 /* ParameterPropertyModifier */);
   }
   function isOptionalUninitializedParameterProperty(parameter) {
-    return strictNullChecks && isOptionalParameter(parameter) && !parameter.initializer && hasSyntacticModifier(parameter, 16476 /* ParameterPropertyModifier */);
+    return strictNullChecks && isOptionalParameter(parameter) && !parameter.initializer && hasSyntacticModifier(parameter, 31 /* ParameterPropertyModifier */);
   }
   function isExpandoFunctionDeclaration(node) {
     const declaration = getParseTreeNode(node, isFunctionDeclaration);
@@ -82838,10 +82888,10 @@ function createTypeChecker(host) {
             return grammarErrorOnFirstToken(node, Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name);
           }
         }
-        if (flags & ~(1025 /* ExportDefault */ | 131072 /* Decorator */)) {
+        if (flags & ~(2080 /* ExportDefault */ | 32768 /* Decorator */)) {
           return grammarErrorOnNode(modifier, Diagnostics.Decorators_are_not_valid_here);
         }
-        if (hasLeadingDecorators && flags & 126975 /* Modifier */) {
+        if (hasLeadingDecorators && flags & 98303 /* Modifier */) {
           Debug.assertIsDefined(firstDecorator);
           const sourceFile = getSourceFileOfNode(modifier);
           if (!hasParseDiagnostics(sourceFile)) {
@@ -82853,10 +82903,10 @@ function createTypeChecker(host) {
           }
           return false;
         }
-        flags |= 131072 /* Decorator */;
-        if (!(flags & 126975 /* Modifier */)) {
+        flags |= 32768 /* Decorator */;
+        if (!(flags & 98303 /* Modifier */)) {
           hasLeadingDecorators = true;
-        } else if (flags & 1 /* Export */) {
+        } else if (flags & 32 /* Export */) {
           sawExportBeforeDecorators = true;
         }
         firstDecorator ?? (firstDecorator = modifier);
@@ -82885,39 +82935,39 @@ function createTypeChecker(host) {
             }
             break;
           case 164 /* OverrideKeyword */:
-            if (flags & 16384 /* Override */) {
+            if (flags & 16 /* Override */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "override");
-            } else if (flags & 2 /* Ambient */) {
+            } else if (flags & 128 /* Ambient */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "override", "declare");
-            } else if (flags & 64 /* Readonly */) {
+            } else if (flags & 8 /* Readonly */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "override", "readonly");
-            } else if (flags & 128 /* Accessor */) {
+            } else if (flags & 512 /* Accessor */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "override", "accessor");
-            } else if (flags & 512 /* Async */) {
+            } else if (flags & 1024 /* Async */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "override", "async");
             }
-            flags |= 16384 /* Override */;
+            flags |= 16 /* Override */;
             lastOverride = modifier;
             break;
           case 125 /* PublicKeyword */:
           case 124 /* ProtectedKeyword */:
           case 123 /* PrivateKeyword */:
             const text = visibilityToString(modifierToFlag(modifier.kind));
-            if (flags & 28 /* AccessibilityModifier */) {
+            if (flags & 7 /* AccessibilityModifier */) {
               return grammarErrorOnNode(modifier, Diagnostics.Accessibility_modifier_already_seen);
-            } else if (flags & 16384 /* Override */) {
+            } else if (flags & 16 /* Override */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "override");
-            } else if (flags & 32 /* Static */) {
+            } else if (flags & 256 /* Static */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "static");
-            } else if (flags & 128 /* Accessor */) {
+            } else if (flags & 512 /* Accessor */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "accessor");
-            } else if (flags & 64 /* Readonly */) {
+            } else if (flags & 8 /* Readonly */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "readonly");
-            } else if (flags & 512 /* Async */) {
+            } else if (flags & 1024 /* Async */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "async");
             } else if (node.parent.kind === 268 /* ModuleBlock */ || node.parent.kind === 312 /* SourceFile */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, text);
-            } else if (flags & 256 /* Abstract */) {
+            } else if (flags & 64 /* Abstract */) {
               if (modifier.kind === 123 /* PrivateKeyword */) {
                 return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, text, "abstract");
               } else {
@@ -82929,60 +82979,60 @@ function createTypeChecker(host) {
             flags |= modifierToFlag(modifier.kind);
             break;
           case 126 /* StaticKeyword */:
-            if (flags & 32 /* Static */) {
+            if (flags & 256 /* Static */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "static");
-            } else if (flags & 64 /* Readonly */) {
+            } else if (flags & 8 /* Readonly */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "readonly");
-            } else if (flags & 512 /* Async */) {
+            } else if (flags & 1024 /* Async */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "async");
-            } else if (flags & 128 /* Accessor */) {
+            } else if (flags & 512 /* Accessor */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "accessor");
             } else if (node.parent.kind === 268 /* ModuleBlock */ || node.parent.kind === 312 /* SourceFile */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, "static");
             } else if (node.kind === 169 /* Parameter */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static");
-            } else if (flags & 256 /* Abstract */) {
+            } else if (flags & 64 /* Abstract */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
-            } else if (flags & 16384 /* Override */) {
+            } else if (flags & 16 /* Override */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "override");
             }
-            flags |= 32 /* Static */;
+            flags |= 256 /* Static */;
             lastStatic = modifier;
             break;
           case 129 /* AccessorKeyword */:
-            if (flags & 128 /* Accessor */) {
+            if (flags & 512 /* Accessor */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "accessor");
-            } else if (flags & 64 /* Readonly */) {
+            } else if (flags & 8 /* Readonly */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "accessor", "readonly");
-            } else if (flags & 2 /* Ambient */) {
+            } else if (flags & 128 /* Ambient */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "accessor", "declare");
             } else if (node.kind !== 172 /* PropertyDeclaration */) {
               return grammarErrorOnNode(modifier, Diagnostics.accessor_modifier_can_only_appear_on_a_property_declaration);
             }
-            flags |= 128 /* Accessor */;
+            flags |= 512 /* Accessor */;
             break;
           case 148 /* ReadonlyKeyword */:
-            if (flags & 64 /* Readonly */) {
+            if (flags & 8 /* Readonly */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "readonly");
             } else if (node.kind !== 172 /* PropertyDeclaration */ && node.kind !== 171 /* PropertySignature */ && node.kind !== 181 /* IndexSignature */ && node.kind !== 169 /* Parameter */) {
               return grammarErrorOnNode(modifier, Diagnostics.readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature);
-            } else if (flags & 128 /* Accessor */) {
+            } else if (flags & 512 /* Accessor */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "readonly", "accessor");
             }
-            flags |= 64 /* Readonly */;
+            flags |= 8 /* Readonly */;
             break;
           case 95 /* ExportKeyword */:
             if (compilerOptions.verbatimModuleSyntax && !(node.flags & 33554432 /* Ambient */) && node.kind !== 265 /* TypeAliasDeclaration */ && node.kind !== 264 /* InterfaceDeclaration */ && // ModuleDeclaration needs to be checked that it is uninstantiated later
             node.kind !== 267 /* ModuleDeclaration */ && node.parent.kind === 312 /* SourceFile */ && (moduleKind === 1 /* CommonJS */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */)) {
               return grammarErrorOnNode(modifier, Diagnostics.A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled);
             }
-            if (flags & 1 /* Export */) {
+            if (flags & 32 /* Export */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "export");
-            } else if (flags & 2 /* Ambient */) {
+            } else if (flags & 128 /* Ambient */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare");
-            } else if (flags & 256 /* Abstract */) {
+            } else if (flags & 64 /* Abstract */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "abstract");
-            } else if (flags & 512 /* Async */) {
+            } else if (flags & 1024 /* Async */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "async");
             } else if (isClassLike(node.parent)) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_class_elements_of_this_kind, "export");
@@ -82993,7 +83043,7 @@ function createTypeChecker(host) {
             } else if (blockScopeKind === 6 /* AwaitUsing */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_an_await_using_declaration, "export");
             }
-            flags |= 1 /* Export */;
+            flags |= 32 /* Export */;
             break;
           case 90 /* DefaultKeyword */:
             const container = node.parent.kind === 312 /* SourceFile */ ? node.parent : node.parent.parent;
@@ -83003,19 +83053,19 @@ function createTypeChecker(host) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_using_declaration, "default");
             } else if (blockScopeKind === 6 /* AwaitUsing */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_an_await_using_declaration, "default");
-            } else if (!(flags & 1 /* Export */)) {
+            } else if (!(flags & 32 /* Export */)) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "default");
             } else if (sawExportBeforeDecorators) {
               return grammarErrorOnNode(firstDecorator, Diagnostics.Decorators_are_not_valid_here);
             }
-            flags |= 1024 /* Default */;
+            flags |= 2048 /* Default */;
             break;
           case 138 /* DeclareKeyword */:
-            if (flags & 2 /* Ambient */) {
+            if (flags & 128 /* Ambient */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "declare");
-            } else if (flags & 512 /* Async */) {
+            } else if (flags & 1024 /* Async */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
-            } else if (flags & 16384 /* Override */) {
+            } else if (flags & 16 /* Override */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "override");
             } else if (isClassLike(node.parent) && !isPropertyDeclaration(node)) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_class_elements_of_this_kind, "declare");
@@ -83029,62 +83079,62 @@ function createTypeChecker(host) {
               return grammarErrorOnNode(modifier, Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context);
             } else if (isPrivateIdentifierClassElementDeclaration(node)) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "declare");
-            } else if (flags & 128 /* Accessor */) {
+            } else if (flags & 512 /* Accessor */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "declare", "accessor");
             }
-            flags |= 2 /* Ambient */;
+            flags |= 128 /* Ambient */;
             lastDeclare = modifier;
             break;
           case 128 /* AbstractKeyword */:
-            if (flags & 256 /* Abstract */) {
+            if (flags & 64 /* Abstract */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "abstract");
             }
             if (node.kind !== 263 /* ClassDeclaration */ && node.kind !== 185 /* ConstructorType */) {
               if (node.kind !== 174 /* MethodDeclaration */ && node.kind !== 172 /* PropertyDeclaration */ && node.kind !== 177 /* GetAccessor */ && node.kind !== 178 /* SetAccessor */) {
                 return grammarErrorOnNode(modifier, Diagnostics.abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration);
               }
-              if (!(node.parent.kind === 263 /* ClassDeclaration */ && hasSyntacticModifier(node.parent, 256 /* Abstract */))) {
+              if (!(node.parent.kind === 263 /* ClassDeclaration */ && hasSyntacticModifier(node.parent, 64 /* Abstract */))) {
                 const message = node.kind === 172 /* PropertyDeclaration */ ? Diagnostics.Abstract_properties_can_only_appear_within_an_abstract_class : Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class;
                 return grammarErrorOnNode(modifier, message);
               }
-              if (flags & 32 /* Static */) {
+              if (flags & 256 /* Static */) {
                 return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
               }
-              if (flags & 8 /* Private */) {
+              if (flags & 2 /* Private */) {
                 return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract");
               }
-              if (flags & 512 /* Async */ && lastAsync) {
+              if (flags & 1024 /* Async */ && lastAsync) {
                 return grammarErrorOnNode(lastAsync, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "async", "abstract");
               }
-              if (flags & 16384 /* Override */) {
+              if (flags & 16 /* Override */) {
                 return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "abstract", "override");
               }
-              if (flags & 128 /* Accessor */) {
+              if (flags & 512 /* Accessor */) {
                 return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "abstract", "accessor");
               }
             }
             if (isNamedDeclaration(node) && node.name.kind === 81 /* PrivateIdentifier */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "abstract");
             }
-            flags |= 256 /* Abstract */;
+            flags |= 64 /* Abstract */;
             break;
           case 134 /* AsyncKeyword */:
-            if (flags & 512 /* Async */) {
+            if (flags & 1024 /* Async */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "async");
-            } else if (flags & 2 /* Ambient */ || node.parent.flags & 33554432 /* Ambient */) {
+            } else if (flags & 128 /* Ambient */ || node.parent.flags & 33554432 /* Ambient */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
             } else if (node.kind === 169 /* Parameter */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "async");
             }
-            if (flags & 256 /* Abstract */) {
+            if (flags & 64 /* Abstract */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "async", "abstract");
             }
-            flags |= 512 /* Async */;
+            flags |= 1024 /* Async */;
             lastAsync = modifier;
             break;
           case 103 /* InKeyword */:
           case 147 /* OutKeyword */:
-            const inOutFlag = modifier.kind === 103 /* InKeyword */ ? 32768 /* In */ : 65536 /* Out */;
+            const inOutFlag = modifier.kind === 103 /* InKeyword */ ? 8192 /* In */ : 16384 /* Out */;
             const inOutText = modifier.kind === 103 /* InKeyword */ ? "in" : "out";
             if (node.kind !== 168 /* TypeParameter */ || !(isInterfaceDeclaration(node.parent) || isClassLike(node.parent) || isTypeAliasDeclaration(node.parent))) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias, inOutText);
@@ -83092,7 +83142,7 @@ function createTypeChecker(host) {
             if (flags & inOutFlag) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, inOutText);
             }
-            if (inOutFlag & 32768 /* In */ && flags & 65536 /* Out */) {
+            if (inOutFlag & 8192 /* In */ && flags & 16384 /* Out */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "in", "out");
             }
             flags |= inOutFlag;
@@ -83101,24 +83151,24 @@ function createTypeChecker(host) {
       }
     }
     if (node.kind === 176 /* Constructor */) {
-      if (flags & 32 /* Static */) {
+      if (flags & 256 /* Static */) {
         return grammarErrorOnNode(lastStatic, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static");
       }
-      if (flags & 16384 /* Override */) {
+      if (flags & 16 /* Override */) {
         return grammarErrorOnNode(lastOverride, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "override");
       }
-      if (flags & 512 /* Async */) {
+      if (flags & 1024 /* Async */) {
         return grammarErrorOnNode(lastAsync, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "async");
       }
       return false;
-    } else if ((node.kind === 272 /* ImportDeclaration */ || node.kind === 271 /* ImportEqualsDeclaration */) && flags & 2 /* Ambient */) {
+    } else if ((node.kind === 272 /* ImportDeclaration */ || node.kind === 271 /* ImportEqualsDeclaration */) && flags & 128 /* Ambient */) {
       return grammarErrorOnNode(lastDeclare, Diagnostics.A_0_modifier_cannot_be_used_with_an_import_declaration, "declare");
-    } else if (node.kind === 169 /* Parameter */ && flags & 16476 /* ParameterPropertyModifier */ && isBindingPattern(node.name)) {
+    } else if (node.kind === 169 /* Parameter */ && flags & 31 /* ParameterPropertyModifier */ && isBindingPattern(node.name)) {
       return grammarErrorOnNode(node, Diagnostics.A_parameter_property_may_not_be_declared_using_a_binding_pattern);
-    } else if (node.kind === 169 /* Parameter */ && flags & 16476 /* ParameterPropertyModifier */ && node.dotDotDotToken) {
+    } else if (node.kind === 169 /* Parameter */ && flags & 31 /* ParameterPropertyModifier */ && node.dotDotDotToken) {
       return grammarErrorOnNode(node, Diagnostics.A_parameter_property_cannot_be_declared_using_a_rest_parameter);
     }
-    if (flags & 512 /* Async */) {
+    if (flags & 1024 /* Async */) {
       return checkGrammarAsyncModifier(node, lastAsync);
     }
     return false;
@@ -83638,12 +83688,12 @@ function createTypeChecker(host) {
       if (languageVersion < 2 /* ES2015 */ && isPrivateIdentifier(accessor.name)) {
         return grammarErrorOnNode(accessor.name, Diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher);
       }
-      if (accessor.body === void 0 && !hasSyntacticModifier(accessor, 256 /* Abstract */)) {
+      if (accessor.body === void 0 && !hasSyntacticModifier(accessor, 64 /* Abstract */)) {
         return grammarErrorAtPos(accessor, accessor.end - 1, ";".length, Diagnostics._0_expected, "{");
       }
     }
     if (accessor.body) {
-      if (hasSyntacticModifier(accessor, 256 /* Abstract */)) {
+      if (hasSyntacticModifier(accessor, 64 /* Abstract */)) {
         return grammarErrorOnNode(accessor, Diagnostics.An_abstract_accessor_cannot_have_an_implementation);
       }
       if (accessor.parent.kind === 187 /* TypeLiteral */ || accessor.parent.kind === 264 /* InterfaceDeclaration */) {
@@ -83715,7 +83765,7 @@ function createTypeChecker(host) {
           }
           break;
         case 171 /* PropertySignature */:
-          if (!hasSyntacticModifier(parent, 64 /* Readonly */)) {
+          if (!hasSyntacticModifier(parent, 8 /* Readonly */)) {
             return grammarErrorOnNode(parent.name, Diagnostics.A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly);
           }
           break;
@@ -83885,7 +83935,7 @@ function createTypeChecker(host) {
       const message = node.initializer ? Diagnostics.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions : !node.type ? Diagnostics.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations : Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context;
       return grammarErrorOnNode(node.exclamationToken, message);
     }
-    if ((moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */) && moduleKind !== 4 /* System */ && !(node.parent.parent.flags & 33554432 /* Ambient */) && hasSyntacticModifier(node.parent.parent, 1 /* Export */)) {
+    if ((moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */) && moduleKind !== 4 /* System */ && !(node.parent.parent.flags & 33554432 /* Ambient */) && hasSyntacticModifier(node.parent.parent, 32 /* Export */)) {
       checkESModuleMarker(node.name);
     }
     return !!blockScopeKind && checkGrammarNameInLetOrConstDeclarations(node.name);
@@ -84075,7 +84125,7 @@ function createTypeChecker(host) {
     }
   }
   function checkGrammarTopLevelElementForRequiredDeclareModifier(node) {
-    if (node.kind === 264 /* InterfaceDeclaration */ || node.kind === 265 /* TypeAliasDeclaration */ || node.kind === 272 /* ImportDeclaration */ || node.kind === 271 /* ImportEqualsDeclaration */ || node.kind === 278 /* ExportDeclaration */ || node.kind === 277 /* ExportAssignment */ || node.kind === 270 /* NamespaceExportDeclaration */ || hasSyntacticModifier(node, 2 /* Ambient */ | 1 /* Export */ | 1024 /* Default */)) {
+    if (node.kind === 264 /* InterfaceDeclaration */ || node.kind === 265 /* TypeAliasDeclaration */ || node.kind === 272 /* ImportDeclaration */ || node.kind === 271 /* ImportEqualsDeclaration */ || node.kind === 278 /* ExportDeclaration */ || node.kind === 277 /* ExportAssignment */ || node.kind === 270 /* NamespaceExportDeclaration */ || hasSyntacticModifier(node, 128 /* Ambient */ | 32 /* Export */ | 2048 /* Default */)) {
       return false;
     }
     return grammarErrorOnFirstToken(node, Diagnostics.Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier);
@@ -84390,12 +84440,14 @@ var SymbolTrackerImpl = class _SymbolTrackerImpl {
     this.canTrackSymbol = !!((_a = this.inner) == null ? void 0 : _a.trackSymbol);
   }
   trackSymbol(symbol, enclosingDeclaration, meaning) {
-    var _a;
+    var _a, _b;
     if (((_a = this.inner) == null ? void 0 : _a.trackSymbol) && !this.disableTrackSymbol) {
       if (this.inner.trackSymbol(symbol, enclosingDeclaration, meaning)) {
         this.onDiagnosticReported();
         return true;
       }
+      if (!(symbol.flags & 262144 /* TypeParameter */))
+        ((_b = this.context).trackedSymbols ?? (_b.trackedSymbols = [])).push([symbol, enclosingDeclaration, meaning]);
     }
     return false;
   }
@@ -86280,15 +86332,15 @@ function collectExternalModuleInfo(context, sourceFile) {
         }
         break;
       case 243 /* VariableStatement */:
-        if (hasSyntacticModifier(node, 1 /* Export */)) {
+        if (hasSyntacticModifier(node, 32 /* Export */)) {
           for (const decl of node.declarationList.declarations) {
             exportedNames = collectExportedVariableInfo(decl, uniqueExports, exportedNames, exportedBindings);
           }
         }
         break;
       case 262 /* FunctionDeclaration */:
-        if (hasSyntacticModifier(node, 1 /* Export */)) {
-          if (hasSyntacticModifier(node, 1024 /* Default */)) {
+        if (hasSyntacticModifier(node, 32 /* Export */)) {
+          if (hasSyntacticModifier(node, 2048 /* Default */)) {
             if (!hasExportDefault) {
               multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), context.factory.getDeclarationName(node));
               hasExportDefault = true;
@@ -86304,8 +86356,8 @@ function collectExternalModuleInfo(context, sourceFile) {
         }
         break;
       case 263 /* ClassDeclaration */:
-        if (hasSyntacticModifier(node, 1 /* Export */)) {
-          if (hasSyntacticModifier(node, 1024 /* Default */)) {
+        if (hasSyntacticModifier(node, 32 /* Export */)) {
+          if (hasSyntacticModifier(node, 2048 /* Default */)) {
             if (!hasExportDefault) {
               multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), context.factory.getDeclarationName(node));
               hasExportDefault = true;
@@ -87170,7 +87222,7 @@ function injectClassThisAssignmentIfMissing(factory2, node, classThis, thisExpre
 // src/compiler/transformers/namedEvaluation.ts
 function getAssignedNameOfIdentifier(factory2, name, expression) {
   const original = getOriginalNode(skipOuterExpressions(expression));
-  if ((isClassDeclaration(original) || isFunctionDeclaration(original)) && !original.name && hasSyntacticModifier(original, 1024 /* Default */)) {
+  if ((isClassDeclaration(original) || isFunctionDeclaration(original)) && !original.name && hasSyntacticModifier(original, 2048 /* Default */)) {
     return factory2.createStringLiteral("default");
   }
   return factory2.createStringLiteralFromNode(name);
@@ -87524,13 +87576,13 @@ function transformTypeScript(context) {
         break;
       case 263 /* ClassDeclaration */:
       case 262 /* FunctionDeclaration */:
-        if (hasSyntacticModifier(node, 2 /* Ambient */)) {
+        if (hasSyntacticModifier(node, 128 /* Ambient */)) {
           break;
         }
         if (node.name) {
           recordEmittedDeclarationInScope(node);
         } else {
-          Debug.assert(node.kind === 263 /* ClassDeclaration */ || hasSyntacticModifier(node, 1024 /* Default */));
+          Debug.assert(node.kind === 263 /* ClassDeclaration */ || hasSyntacticModifier(node, 2048 /* Default */));
         }
         break;
     }
@@ -87585,7 +87637,7 @@ function transformTypeScript(context) {
   function namespaceElementVisitorWorker(node) {
     if (node.kind === 278 /* ExportDeclaration */ || node.kind === 272 /* ImportDeclaration */ || node.kind === 273 /* ImportClause */ || node.kind === 271 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 283 /* ExternalModuleReference */) {
       return void 0;
-    } else if (node.transformFlags & 1 /* ContainsTypeScript */ || hasSyntacticModifier(node, 1 /* Export */)) {
+    } else if (node.transformFlags & 1 /* ContainsTypeScript */ || hasSyntacticModifier(node, 32 /* Export */)) {
       return visitTypeScript(node);
     }
     return node;
@@ -87643,7 +87695,7 @@ function transformTypeScript(context) {
   function modifierVisitor(node) {
     if (isDecorator(node))
       return void 0;
-    if (modifierToFlag(node.kind) & 117086 /* TypeScriptModifier */) {
+    if (modifierToFlag(node.kind) & 28895 /* TypeScriptModifier */) {
       return void 0;
     } else if (currentNamespace && node.kind === 95 /* ExportKeyword */) {
       return void 0;
@@ -87651,7 +87703,7 @@ function transformTypeScript(context) {
     return node;
   }
   function visitTypeScript(node) {
-    if (isStatement(node) && hasSyntacticModifier(node, 2 /* Ambient */)) {
+    if (isStatement(node) && hasSyntacticModifier(node, 128 /* Ambient */)) {
       return factory2.createNotEmittedStatement(node);
     }
     switch (node.kind) {
@@ -88141,7 +88193,7 @@ function transformTypeScript(context) {
     return !nodeIsMissing(node.body);
   }
   function visitPropertyDeclaration(node, parent) {
-    const isAmbient = node.flags & 33554432 /* Ambient */ || hasSyntacticModifier(node, 256 /* Abstract */);
+    const isAmbient = node.flags & 33554432 /* Ambient */ || hasSyntacticModifier(node, 64 /* Abstract */);
     if (isAmbient && !(legacyDecorators && hasDecorators(node))) {
       return void 0;
     }
@@ -88150,7 +88202,7 @@ function transformTypeScript(context) {
     if (isAmbient) {
       return factory2.updatePropertyDeclaration(
         node,
-        concatenate(modifiers, factory2.createModifiersFromModifierFlags(2 /* Ambient */)),
+        concatenate(modifiers, factory2.createModifiersFromModifierFlags(128 /* Ambient */)),
         Debug.checkDefined(visitNode(node.name, visitor, isPropertyName)),
         /*questionOrExclamationToken*/
         void 0,
@@ -88313,7 +88365,7 @@ function transformTypeScript(context) {
     );
   }
   function shouldEmitAccessorDeclaration(node) {
-    return !(nodeIsMissing(node.body) && hasSyntacticModifier(node, 256 /* Abstract */));
+    return !(nodeIsMissing(node.body) && hasSyntacticModifier(node, 64 /* Abstract */));
   }
   function visitGetAccessor(node, parent) {
     if (!(node.transformFlags & 1 /* ContainsTypeScript */)) {
@@ -89046,16 +89098,16 @@ function transformTypeScript(context) {
     }
   }
   function isExportOfNamespace(node) {
-    return currentNamespace !== void 0 && hasSyntacticModifier(node, 1 /* Export */);
+    return currentNamespace !== void 0 && hasSyntacticModifier(node, 32 /* Export */);
   }
   function isExternalModuleExport(node) {
-    return currentNamespace === void 0 && hasSyntacticModifier(node, 1 /* Export */);
+    return currentNamespace === void 0 && hasSyntacticModifier(node, 32 /* Export */);
   }
   function isNamedExternalModuleExport(node) {
-    return isExternalModuleExport(node) && !hasSyntacticModifier(node, 1024 /* Default */);
+    return isExternalModuleExport(node) && !hasSyntacticModifier(node, 2048 /* Default */);
   }
   function isDefaultExternalModuleExport(node) {
-    return isExternalModuleExport(node) && hasSyntacticModifier(node, 1024 /* Default */);
+    return isExternalModuleExport(node) && hasSyntacticModifier(node, 2048 /* Default */);
   }
   function createExportMemberAssignmentStatement(node) {
     const expression = factory2.createAssignment(
@@ -90388,8 +90440,8 @@ function transformClassFields(context) {
       getClassLexicalEnvironment().classThis = node.emitNode.classThis;
     }
     const isClassWithConstructorReference = resolver.getNodeCheckFlags(node) & 262144 /* ContainsConstructorReference */;
-    const isExport = hasSyntacticModifier(node, 1 /* Export */);
-    const isDefault = hasSyntacticModifier(node, 1024 /* Default */);
+    const isExport = hasSyntacticModifier(node, 32 /* Export */);
+    const isDefault = hasSyntacticModifier(node, 2048 /* Default */);
     let modifiers = visitNodes2(node.modifiers, modifierVisitor, isModifier);
     const heritageClauses = visitNodes2(node.heritageClauses, heritageClauseVisitor, isHeritageClause);
     const { members, prologue } = transformClassMembers(node);
@@ -90935,7 +90987,7 @@ function transformClassFields(context) {
       return void 0;
     }
     const propertyOriginalNode = getOriginalNode(property);
-    if (hasSyntacticModifier(propertyOriginalNode, 256 /* Abstract */)) {
+    if (hasSyntacticModifier(propertyOriginalNode, 64 /* Abstract */)) {
       return void 0;
     }
     let initializer = visitNode(property.initializer, visitor, isExpression);
@@ -91971,8 +92023,8 @@ function transformLegacyDecorators(context) {
     return addRange([updated], decorationStatements);
   }
   function transformClassDeclarationWithClassDecorators(node, name) {
-    const isExport = hasSyntacticModifier(node, 1 /* Export */);
-    const isDefault = hasSyntacticModifier(node, 1024 /* Default */);
+    const isExport = hasSyntacticModifier(node, 32 /* Export */);
+    const isDefault = hasSyntacticModifier(node, 2048 /* Default */);
     const modifiers = visitNodes2(node.modifiers, (node2) => isExportOrDefaultModifier(node2) || isDecorator(node2) ? void 0 : node2, isModifierLike);
     const location = moveRangePastModifiers(node);
     const classAlias = getClassAliasIfNeeded(node);
@@ -91993,7 +92045,7 @@ function transformLegacyDecorators(context) {
     let members = visitNodes2(node.members, visitor, isClassElement);
     let decorationStatements = [];
     ({ members, decorationStatements } = transformDecoratorsOfClassElements(node, members));
-    const assignClassAliasInStaticBlock = languageVersion >= 9 /* ES2022 */ && !!classAlias && some(members, (member) => isPropertyDeclaration(member) && hasSyntacticModifier(member, 32 /* Static */) || isClassStaticBlockDeclaration(member));
+    const assignClassAliasInStaticBlock = languageVersion >= 9 /* ES2022 */ && !!classAlias && some(members, (member) => isPropertyDeclaration(member) && hasSyntacticModifier(member, 256 /* Static */) || isClassStaticBlockDeclaration(member));
     if (assignClassAliasInStaticBlock) {
       members = setTextRange(
         factory2.createNodeArray([
@@ -92124,7 +92176,7 @@ function transformLegacyDecorators(context) {
     );
   }
   function visitPropertyDeclaration(node) {
-    if (node.flags & 33554432 /* Ambient */ || hasSyntacticModifier(node, 2 /* Ambient */)) {
+    if (node.flags & 33554432 /* Ambient */ || hasSyntacticModifier(node, 128 /* Ambient */)) {
       return void 0;
     }
     return finishClassElement(
@@ -92212,7 +92264,7 @@ function transformLegacyDecorators(context) {
     const memberName = getExpressionForPropertyName(
       member,
       /*generateNameForComputedPropertyName*/
-      !hasSyntacticModifier(member, 2 /* Ambient */)
+      !hasSyntacticModifier(member, 128 /* Ambient */)
     );
     const descriptor = languageVersion > 0 /* ES3 */ ? isPropertyDeclaration(member) && !hasAccessorModifier(member) ? factory2.createVoidZero() : factory2.createNull() : void 0;
     const helper = emitHelpers().createDecorateHelper(
@@ -92995,8 +93047,8 @@ function transformESDecorators(context) {
       const statements = [];
       const originalClass = getOriginalNode(node, isClassLike) ?? node;
       const className = originalClass.name ? factory2.createStringLiteralFromNode(originalClass.name) : factory2.createStringLiteral("default");
-      const isExport = hasSyntacticModifier(node, 1 /* Export */);
-      const isDefault = hasSyntacticModifier(node, 1024 /* Default */);
+      const isExport = hasSyntacticModifier(node, 32 /* Export */);
+      const isDefault = hasSyntacticModifier(node, 2048 /* Default */);
       if (!node.name) {
         node = injectClassNamedEvaluationHelperBlockIfMissing(context, node, className);
       }
@@ -95307,7 +95359,7 @@ function transformES2018(context) {
     return visitEachChild(node, visitor, context);
   }
   function visitVariableStatement(node) {
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
       const savedExportedVariableStatement = exportedVariableStatement;
       exportedVariableStatement = true;
       const visited = visitEachChild(node, visitor, context);
@@ -96519,7 +96571,7 @@ function transformESNext(context) {
       addRange(topLevelStatements, endLexicalEnvironment());
       if (exportVars.length) {
         topLevelStatements.push(factory2.createVariableStatement(
-          factory2.createModifiersFromModifierFlags(1 /* Export */),
+          factory2.createModifiersFromModifierFlags(32 /* Export */),
           factory2.createVariableDeclarationList(
             exportVars,
             1 /* Let */
@@ -96816,8 +96868,8 @@ function transformESNext(context) {
     if (!node.name && defaultExportBinding) {
       return node;
     }
-    const isExported = hasSyntacticModifier(node, 1 /* Export */);
-    const isDefault = hasSyntacticModifier(node, 1024 /* Default */);
+    const isExported = hasSyntacticModifier(node, 32 /* Export */);
+    const isDefault = hasSyntacticModifier(node, 2048 /* Default */);
     let expression = factory2.converters.convertToClassExpression(node);
     if (node.name) {
       hoistBindingIdentifier(
@@ -96865,7 +96917,7 @@ function transformESNext(context) {
   }
   function hoistVariableStatement(node) {
     let expressions;
-    const isExported = hasSyntacticModifier(node, 1 /* Export */);
+    const isExported = hasSyntacticModifier(node, 32 /* Export */);
     for (const variable of node.declarationList.declarations) {
       hoistBindingElement(variable, isExported, variable);
       if (variable.initializer) {
@@ -98397,8 +98449,8 @@ function transformES2015(context) {
     setTextRange(statement, node);
     startOnNewLine(statement);
     statements.push(statement);
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
-      const exportStatement = hasSyntacticModifier(node, 1024 /* Default */) ? factory2.createExportDefault(factory2.getLocalName(node)) : factory2.createExternalModuleExport(factory2.getLocalName(node));
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
+      const exportStatement = hasSyntacticModifier(node, 2048 /* Default */) ? factory2.createExportDefault(factory2.getLocalName(node)) : factory2.createExternalModuleExport(factory2.getLocalName(node));
       setOriginalNode(exportStatement, statement);
       statements.push(exportStatement);
     }
@@ -99590,7 +99642,7 @@ function transformES2015(context) {
     return node.declarationList.declarations.length === 1 && !!node.declarationList.declarations[0].initializer && !!(getInternalEmitFlags(node.declarationList.declarations[0].initializer) & 1 /* TypeScriptClassWrapper */);
   }
   function visitVariableStatement(node) {
-    const ancestorFacts = enterSubtree(0 /* None */, hasSyntacticModifier(node, 1 /* Export */) ? 32 /* ExportedVariableStatement */ : 0 /* None */);
+    const ancestorFacts = enterSubtree(0 /* None */, hasSyntacticModifier(node, 32 /* Export */) ? 32 /* ExportedVariableStatement */ : 0 /* None */);
     let updated;
     if (convertedLoopState && (node.declarationList.flags & 7 /* BlockScoped */) === 0 && !isVariableStatementOfTypeScriptClassWrapper(node)) {
       let assignments;
@@ -104539,7 +104591,7 @@ function transformModule(context) {
     Debug.assert(isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer.");
     let statements;
     if (moduleKind !== 2 /* AMD */) {
-      if (hasSyntacticModifier(node, 1 /* Export */)) {
+      if (hasSyntacticModifier(node, 32 /* Export */)) {
         statements = append(
           statements,
           setOriginalNode(
@@ -104585,7 +104637,7 @@ function transformModule(context) {
         );
       }
     } else {
-      if (hasSyntacticModifier(node, 1 /* Export */)) {
+      if (hasSyntacticModifier(node, 32 /* Export */)) {
         statements = append(
           statements,
           setOriginalNode(
@@ -104723,7 +104775,7 @@ function transformModule(context) {
   }
   function visitFunctionDeclaration(node) {
     let statements;
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
       statements = append(
         statements,
         setOriginalNode(
@@ -104760,7 +104812,7 @@ function transformModule(context) {
   }
   function visitClassDeclaration(node) {
     let statements;
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
       statements = append(
         statements,
         setOriginalNode(
@@ -104794,7 +104846,7 @@ function transformModule(context) {
     let statements;
     let variables;
     let expressions;
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
       let modifiers;
       let removeCommentsOnExpressions = false;
       for (const variable of node.declarationList.declarations) {
@@ -104980,8 +105032,8 @@ function transformModule(context) {
       return statements;
     }
     const seen = new IdentifierNameMap();
-    if (hasSyntacticModifier(decl, 1 /* Export */)) {
-      const exportName = hasSyntacticModifier(decl, 1024 /* Default */) ? factory2.createIdentifier("default") : factory2.getDeclarationName(decl);
+    if (hasSyntacticModifier(decl, 32 /* Export */)) {
+      const exportName = hasSyntacticModifier(decl, 2048 /* Default */) ? factory2.createIdentifier("default") : factory2.getDeclarationName(decl);
       statements = appendExportStatement(
         statements,
         seen,
@@ -105468,7 +105520,7 @@ function transformSystemModule(context) {
     addRange(statements, hoistedStatements);
     insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
     const exportStarFunction = addExportStarIfNeeded(statements);
-    const modifiers = node.transformFlags & 2097152 /* ContainsAwait */ ? factory2.createModifiersFromModifierFlags(512 /* Async */) : void 0;
+    const modifiers = node.transformFlags & 2097152 /* ContainsAwait */ ? factory2.createModifiersFromModifierFlags(1024 /* Async */) : void 0;
     const moduleObject = factory2.createObjectLiteralExpression(
       [
         factory2.createPropertyAssignment("setters", createSettersArray(exportStarFunction, dependencyGroups)),
@@ -105670,7 +105722,7 @@ function transformSystemModule(context) {
                 factory2.createAssignment(importVariableName, parameterName)
               )
             );
-            if (hasSyntacticModifier(entry, 1 /* Export */)) {
+            if (hasSyntacticModifier(entry, 32 /* Export */)) {
               statements.push(
                 factory2.createExpressionStatement(
                   factory2.createCallExpression(
@@ -105823,7 +105875,7 @@ function transformSystemModule(context) {
     );
   }
   function visitFunctionDeclaration(node) {
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
       hoistedStatements = append(
         hoistedStatements,
         factory2.updateFunctionDeclaration(
@@ -105910,7 +105962,7 @@ function transformSystemModule(context) {
       statements = append(statements, factory2.updateVariableStatement(node, modifiers, declarationList));
     } else {
       let expressions;
-      const isExportedDeclaration = hasSyntacticModifier(node, 1 /* Export */);
+      const isExportedDeclaration = hasSyntacticModifier(node, 32 /* Export */);
       for (const variable of node.declarationList.declarations) {
         if (variable.initializer) {
           expressions = append(expressions, transformInitializedVariable(variable, isExportedDeclaration));
@@ -106046,8 +106098,8 @@ function transformSystemModule(context) {
       return statements;
     }
     let excludeName;
-    if (hasSyntacticModifier(decl, 1 /* Export */)) {
-      const exportName = hasSyntacticModifier(decl, 1024 /* Default */) ? factory2.createStringLiteral("default") : decl.name;
+    if (hasSyntacticModifier(decl, 32 /* Export */)) {
+      const exportName = hasSyntacticModifier(decl, 2048 /* Default */) ? factory2.createStringLiteral("default") : decl.name;
       statements = appendExportStatement(statements, exportName, factory2.getLocalName(decl));
       excludeName = getTextOfIdentifierOrLiteral(exportName);
     }
@@ -106792,7 +106844,7 @@ function transformECMAScriptModule(context) {
     return singleOrMany(statements);
   }
   function appendExportsOfImportEqualsDeclaration(statements, node) {
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
       statements = append(
         statements,
         factory2.createExportDeclaration(
@@ -107002,7 +107054,7 @@ function createGetSymbolAccessibilityDiagnosticForNode(node) {
   } else if (isConstructSignatureDeclaration(node) || isCallSignatureDeclaration(node) || isMethodDeclaration(node) || isMethodSignature(node) || isFunctionDeclaration(node) || isIndexSignatureDeclaration(node)) {
     return getReturnTypeVisibilityError;
   } else if (isParameter(node)) {
-    if (isParameterPropertyDeclaration(node, node.parent) && hasSyntacticModifier(node.parent, 8 /* Private */)) {
+    if (isParameterPropertyDeclaration(node, node.parent) && hasSyntacticModifier(node.parent, 2 /* Private */)) {
       return getVariableDeclarationTypeVisibilityError;
     }
     return getParameterDeclarationTypeVisibilityError;
@@ -107020,7 +107072,7 @@ function createGetSymbolAccessibilityDiagnosticForNode(node) {
   function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult) {
     if (node.kind === 260 /* VariableDeclaration */ || node.kind === 208 /* BindingElement */) {
       return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Exported_variable_0_has_or_is_using_private_name_1;
-    } else if (node.kind === 172 /* PropertyDeclaration */ || node.kind === 211 /* PropertyAccessExpression */ || node.kind === 212 /* ElementAccessExpression */ || node.kind === 226 /* BinaryExpression */ || node.kind === 171 /* PropertySignature */ || node.kind === 169 /* Parameter */ && hasSyntacticModifier(node.parent, 8 /* Private */)) {
+    } else if (node.kind === 172 /* PropertyDeclaration */ || node.kind === 211 /* PropertyAccessExpression */ || node.kind === 212 /* ElementAccessExpression */ || node.kind === 226 /* BinaryExpression */ || node.kind === 171 /* PropertySignature */ || node.kind === 169 /* Parameter */ && hasSyntacticModifier(node.parent, 2 /* Private */)) {
       if (isStatic(node)) {
         return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1;
       } else if (node.parent.kind === 263 /* ClassDeclaration */ || node.kind === 169 /* Parameter */) {
@@ -107741,7 +107793,7 @@ function transformDeclarations(context) {
     return void 0;
   }
   function ensureType(node, type, ignorePrivate) {
-    if (!ignorePrivate && hasEffectiveModifier(node, 8 /* Private */)) {
+    if (!ignorePrivate && hasEffectiveModifier(node, 2 /* Private */)) {
       return;
     }
     if (shouldPrintWithInitializer(node)) {
@@ -107821,7 +107873,7 @@ function transformDeclarations(context) {
     }
   }
   function updateParamsList(node, params, modifierMask) {
-    if (hasEffectiveModifier(node, 8 /* Private */)) {
+    if (hasEffectiveModifier(node, 2 /* Private */)) {
       return factory2.createNodeArray();
     }
     const newParams = map(params, (p) => ensureParameter(p, modifierMask));
@@ -107866,7 +107918,7 @@ function transformDeclarations(context) {
     return factory2.createNodeArray(newParams || emptyArray);
   }
   function ensureTypeParams(node, params) {
-    return hasEffectiveModifier(node, 8 /* Private */) ? void 0 : visitNodes2(params, visitDeclarationSubtree, isTypeParameterDeclaration);
+    return hasEffectiveModifier(node, 2 /* Private */) ? void 0 : visitNodes2(params, visitDeclarationSubtree, isTypeParameterDeclaration);
   }
   function isEnclosingDeclaration(node) {
     return isSourceFile(node) || isTypeAliasDeclaration(node) || isModuleDeclaration(node) || isClassDeclaration(node) || isInterfaceDeclaration(node) || isFunctionLike(node) || isIndexSignatureDeclaration(node) || isMappedTypeNode(node);
@@ -108052,7 +108104,7 @@ function transformDeclarations(context) {
     const oldWithinObjectLiteralType = suppressNewDiagnosticContexts;
     let shouldEnterSuppressNewDiagnosticsContextContext = (input.kind === 187 /* TypeLiteral */ || input.kind === 200 /* MappedType */) && input.parent.kind !== 265 /* TypeAliasDeclaration */;
     if (isMethodDeclaration(input) || isMethodSignature(input)) {
-      if (hasEffectiveModifier(input, 8 /* Private */)) {
+      if (hasEffectiveModifier(input, 2 /* Private */)) {
         if (input.symbol && input.symbol.declarations && input.symbol.declarations[0] !== input)
           return;
         return cleanup(factory2.createPropertyDeclaration(
@@ -108140,7 +108192,7 @@ function transformDeclarations(context) {
             input,
             ensureModifiers(input),
             input.name,
-            updateAccessorParamsList(input, hasEffectiveModifier(input, 8 /* Private */)),
+            updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
             ensureType(input, accessorType),
             /*body*/
             void 0
@@ -108157,7 +108209,7 @@ function transformDeclarations(context) {
             input,
             ensureModifiers(input),
             input.name,
-            updateAccessorParamsList(input, hasEffectiveModifier(input, 8 /* Private */)),
+            updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
             /*body*/
             void 0
           ));
@@ -108314,7 +108366,7 @@ function transformDeclarations(context) {
     }
   }
   function isPrivateMethodTypeParameter(node) {
-    return node.parent.kind === 174 /* MethodDeclaration */ && hasEffectiveModifier(node.parent, 8 /* Private */);
+    return node.parent.kind === 174 /* MethodDeclaration */ && hasEffectiveModifier(node.parent, 2 /* Private */);
   }
   function visitDeclarationStatements(input) {
     if (!isPreservedDeclarationStatement(input)) {
@@ -108373,10 +108425,10 @@ function transformDeclarations(context) {
     return input;
   }
   function stripExportModifiers(statement) {
-    if (isImportEqualsDeclaration(statement) || hasEffectiveModifier(statement, 1024 /* Default */) || !canHaveModifiers(statement)) {
+    if (isImportEqualsDeclaration(statement) || hasEffectiveModifier(statement, 2048 /* Default */) || !canHaveModifiers(statement)) {
       return statement;
     }
-    const modifiers = factory2.createModifiersFromModifierFlags(getEffectiveModifierFlags(statement) & (258047 /* All */ ^ 1 /* Export */));
+    const modifiers = factory2.createModifiersFromModifierFlags(getEffectiveModifierFlags(statement) & (131071 /* All */ ^ 32 /* Export */));
     return factory2.replaceModifiers(statement, modifiers);
   }
   function updateModuleDeclarationAndKeyword(node, modifiers, name, body) {
@@ -108526,10 +108578,10 @@ function transformDeclarations(context) {
             ));
           }
           const namespaceDecl = factory2.createModuleDeclaration(ensureModifiers(input), input.name, factory2.createModuleBlock(declarations), 32 /* Namespace */);
-          if (!hasEffectiveModifier(clean2, 1024 /* Default */)) {
+          if (!hasEffectiveModifier(clean2, 2048 /* Default */)) {
             return [clean2, namespaceDecl];
           }
-          const modifiers = factory2.createModifiersFromModifierFlags(getEffectiveModifierFlags(clean2) & ~1025 /* ExportDefault */ | 2 /* Ambient */);
+          const modifiers = factory2.createModifiersFromModifierFlags(getEffectiveModifierFlags(clean2) & ~2080 /* ExportDefault */ | 128 /* Ambient */);
           const cleanDeclaration = factory2.updateFunctionDeclaration(
             clean2,
             modifiers,
@@ -108621,7 +108673,7 @@ function transformDeclarations(context) {
         if (ctor) {
           const oldDiag2 = getSymbolAccessibilityDiagnostic;
           parameterProperties = compact(flatMap(ctor.parameters, (param) => {
-            if (!hasSyntacticModifier(param, 16476 /* ParameterPropertyModifier */) || shouldStripInternal(param))
+            if (!hasSyntacticModifier(param, 31 /* ParameterPropertyModifier */) || shouldStripInternal(param))
               return;
             getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(param);
             if (param.name.kind === 80 /* Identifier */) {
@@ -108850,11 +108902,11 @@ function transformDeclarations(context) {
     return factory2.createModifiersFromModifierFlags(newFlags);
   }
   function ensureModifierFlags(node) {
-    let mask = 258047 /* All */ ^ (4 /* Public */ | 512 /* Async */ | 16384 /* Override */);
-    let additions = needsDeclare && !isAlwaysType(node) ? 2 /* Ambient */ : 0 /* None */;
+    let mask = 131071 /* All */ ^ (1 /* Public */ | 1024 /* Async */ | 16 /* Override */);
+    let additions = needsDeclare && !isAlwaysType(node) ? 128 /* Ambient */ : 0 /* None */;
     const parentIsFile = node.parent.kind === 312 /* SourceFile */;
     if (!parentIsFile || isBundledEmit && parentIsFile && isExternalModule(node.parent)) {
-      mask ^= 2 /* Ambient */;
+      mask ^= 128 /* Ambient */;
       additions = 0 /* None */;
     }
     return maskModifierFlags(node, mask, additions);
@@ -108896,13 +108948,13 @@ function isAlwaysType(node) {
 function maskModifiers(factory2, node, modifierMask, modifierAdditions) {
   return factory2.createModifiersFromModifierFlags(maskModifierFlags(node, modifierMask, modifierAdditions));
 }
-function maskModifierFlags(node, modifierMask = 258047 /* All */ ^ 4 /* Public */, modifierAdditions = 0 /* None */) {
+function maskModifierFlags(node, modifierMask = 131071 /* All */ ^ 1 /* Public */, modifierAdditions = 0 /* None */) {
   let flags = getEffectiveModifierFlags(node) & modifierMask | modifierAdditions;
-  if (flags & 1024 /* Default */ && !(flags & 1 /* Export */)) {
-    flags ^= 1 /* Export */;
+  if (flags & 2048 /* Default */ && !(flags & 32 /* Export */)) {
+    flags ^= 32 /* Export */;
   }
-  if (flags & 1024 /* Default */ && flags & 2 /* Ambient */) {
-    flags ^= 2 /* Ambient */;
+  if (flags & 2048 /* Default */ && flags & 128 /* Ambient */) {
+    flags ^= 128 /* Ambient */;
   }
   return flags;
 }
@@ -108915,7 +108967,7 @@ function canHaveLiteralInitializer(node) {
   switch (node.kind) {
     case 172 /* PropertyDeclaration */:
     case 171 /* PropertySignature */:
-      return !hasEffectiveModifier(node, 8 /* Private */);
+      return !hasEffectiveModifier(node, 2 /* Private */);
     case 169 /* Parameter */:
     case 260 /* VariableDeclaration */:
       return true;
@@ -117674,7 +117726,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
           }
         }
       } else if (isModuleDeclaration(node)) {
-        if (isAmbientModule(node) && (inAmbientModule || hasSyntacticModifier(node, 2 /* Ambient */) || file.isDeclarationFile)) {
+        if (isAmbientModule(node) && (inAmbientModule || hasSyntacticModifier(node, 128 /* Ambient */) || file.isDeclarationFile)) {
           node.name.parent = node;
           const nameText = getTextOfIdentifierOrLiteral(node.name);
           if (isExternalModuleFile || inAmbientModule && !isExternalModuleNameRelative(nameText)) {