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

package/lib/typescript.js

@@ -56,7 +56,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.3";
-      version = `${versionMajorMinor}.0-dev.20231025`;
+      version = `${versionMajorMinor}.0-dev.20231026`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -3971,32 +3971,43 @@ ${lanes.join("\n")}
       })(NodeFlags || {});
       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 || {});
       JsxFlags = /* @__PURE__ */ ((JsxFlags2) => {
@@ -11497,7 +11508,7 @@ ${lanes.join("\n")}
     }
   }
   function isParameterPropertyDeclaration(node, parent2) {
-    return isParameter(node) && hasSyntacticModifier(node, 16476 /* ParameterPropertyModifier */) && parent2.kind === 176 /* Constructor */;
+    return isParameter(node) && hasSyntacticModifier(node, 31 /* ParameterPropertyModifier */) && parent2.kind === 176 /* Constructor */;
   }
   function isEmptyBindingPattern(node) {
     if (isBindingPattern(node)) {
@@ -11786,7 +11797,7 @@ ${lanes.join("\n")}
     }
   }
   function getModifiers(node) {
-    if (hasSyntacticModifier(node, 126975 /* Modifier */)) {
+    if (hasSyntacticModifier(node, 98303 /* Modifier */)) {
       return filter(node.modifiers, isModifier);
     }
   }
@@ -12220,7 +12231,7 @@ ${lanes.join("\n")}
     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 */;
@@ -12584,10 +12595,10 @@ ${lanes.join("\n")}
     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 */;
@@ -13463,7 +13474,7 @@ ${lanes.join("\n")}
     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) {
@@ -13816,10 +13827,10 @@ ${lanes.join("\n")}
     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 */;
@@ -15548,7 +15559,7 @@ ${lanes.join("\n")}
           flags |= 1 /* Generator */;
         }
       case 219 /* ArrowFunction */:
-        if (hasSyntacticModifier(node, 512 /* Async */)) {
+        if (hasSyntacticModifier(node, 1024 /* Async */)) {
           flags |= 2 /* Async */;
         }
         break;
@@ -15564,7 +15575,7 @@ ${lanes.join("\n")}
       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;
   }
@@ -16663,25 +16674,25 @@ ${lanes.join("\n")}
     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;
@@ -16696,10 +16707,13 @@ ${lanes.join("\n")}
     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(
@@ -16724,33 +16738,42 @@ ${lanes.join("\n")}
       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;
   }
@@ -16766,37 +16789,37 @@ ${lanes.join("\n")}
   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 */;
   }
@@ -16936,7 +16959,7 @@ ${lanes.join("\n")}
     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));
@@ -17216,16 +17239,16 @@ ${lanes.join("\n")}
     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;
   }
@@ -17324,7 +17347,7 @@ ${lanes.join("\n")}
   function isAbstractConstructorSymbol(symbol) {
     if (symbol.flags & 32 /* Class */) {
       const declaration = getClassLikeDeclarationOfSymbol(symbol);
-      return !!declaration && hasSyntacticModifier(declaration, 256 /* Abstract */);
+      return !!declaration && hasSyntacticModifier(declaration, 64 /* Abstract */);
     }
     return false;
   }
@@ -18544,7 +18567,7 @@ ${lanes.join("\n")}
     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;
@@ -21127,35 +21150,35 @@ ${lanes.join("\n")}
     }
     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;
     }
@@ -21204,7 +21227,7 @@ ${lanes.join("\n")}
       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;
@@ -21253,8 +21276,8 @@ ${lanes.join("\n")}
       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;
     }
@@ -21293,7 +21316,7 @@ ${lanes.join("\n")}
       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 */;
@@ -22036,7 +22059,7 @@ ${lanes.join("\n")}
       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 */;
@@ -22060,7 +22083,7 @@ ${lanes.join("\n")}
       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;
@@ -22412,7 +22435,7 @@ ${lanes.join("\n")}
       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;
@@ -22662,10 +22685,10 @@ ${lanes.join("\n")}
       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 */;
@@ -22696,7 +22719,7 @@ ${lanes.join("\n")}
       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 */;
@@ -22758,7 +22781,7 @@ ${lanes.join("\n")}
       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 */;
@@ -24189,7 +24212,7 @@ ${lanes.join("\n")}
       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);
@@ -33844,11 +33867,11 @@ ${lanes.join("\n")}
           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
@@ -41912,7 +41935,7 @@ ${lanes.join("\n")}
         break;
       case 272 /* ImportDeclaration */:
       case 271 /* ImportEqualsDeclaration */:
-        if (!hasSyntacticModifier(node, 1 /* Export */)) {
+        if (!hasSyntacticModifier(node, 32 /* Export */)) {
           return 0 /* NonInstantiated */;
         }
         break;
@@ -42189,7 +42212,7 @@ ${lanes.join("\n")}
     }
     function declareSymbol(symbolTable, parent3, 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 && parent3 ? "default" /* Default */ : getDeclarationName(node);
       let symbol;
       if (name === void 0) {
@@ -42233,7 +42256,7 @@ ${lanes.join("\n")}
               }
             }
             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;
@@ -42262,7 +42285,7 @@ ${lanes.join("\n")}
       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);
@@ -42281,7 +42304,7 @@ ${lanes.join("\n")}
         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;
@@ -42322,7 +42345,7 @@ ${lanes.join("\n")}
         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;
     }
@@ -42353,7 +42376,7 @@ ${lanes.join("\n")}
         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 */)) {
@@ -43400,7 +43423,7 @@ ${lanes.join("\n")}
     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)) {
@@ -44461,7 +44484,7 @@ ${lanes.join("\n")}
       }
       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 */);
@@ -44613,7 +44636,7 @@ ${lanes.join("\n")}
       case 267 /* ModuleDeclaration */:
         return getModuleInstanceState(s) !== 1 /* Instantiated */;
       case 266 /* EnumDeclaration */:
-        return hasSyntacticModifier(s, 2048 /* Const */);
+        return hasSyntacticModifier(s, 4096 /* Const */);
       default:
         return false;
     }
@@ -47684,7 +47707,7 @@ ${lanes.join("\n")}
       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);
@@ -48069,7 +48092,7 @@ ${lanes.join("\n")}
       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;
@@ -49995,20 +50018,20 @@ ${lanes.join("\n")}
         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)) {
@@ -50231,7 +50254,8 @@ ${lanes.join("\n")}
           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);
@@ -50685,7 +50709,7 @@ ${lanes.join("\n")}
           }
         }
         function visitAndTransformType(type2, transform2) {
-          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;
@@ -50702,6 +50726,13 @@ ${lanes.join("\n")}
           }
           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;
             }
@@ -50721,7 +50752,12 @@ ${lanes.join("\n")}
           const result = transform2(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) {
@@ -50963,7 +50999,7 @@ ${lanes.join("\n")}
               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));
               }
             }
@@ -51266,7 +51302,7 @@ ${lanes.join("\n")}
         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,
@@ -52323,7 +52359,7 @@ ${lanes.join("\n")}
           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)) {
@@ -52357,9 +52393,9 @@ ${lanes.join("\n")}
             }
             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];
             }
@@ -52451,11 +52487,11 @@ ${lanes.join("\n")}
           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) {
@@ -52496,6 +52532,12 @@ ${lanes.join("\n")}
             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;
           }
         }
@@ -52512,7 +52554,7 @@ ${lanes.join("\n")}
           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) {
@@ -52582,7 +52624,7 @@ ${lanes.join("\n")}
                     ),
                     textRange
                   );
-                  addResult(statement, name !== localName ? modifierFlags & ~1 /* Export */ : modifierFlags);
+                  addResult(statement, name !== localName ? modifierFlags & ~32 /* Export */ : modifierFlags);
                   if (name !== localName && !isPrivate) {
                     addResult(
                       factory.createExportDeclaration(
@@ -52687,14 +52729,14 @@ ${lanes.join("\n")}
           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));
@@ -52816,7 +52858,7 @@ ${lanes.join("\n")}
         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;
@@ -52900,7 +52942,7 @@ ${lanes.join("\n")}
                 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,
@@ -53003,7 +53045,7 @@ ${lanes.join("\n")}
           );
           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
@@ -53356,7 +53398,7 @@ ${lanes.join("\n")}
             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(
@@ -53373,7 +53415,7 @@ ${lanes.join("\n")}
               );
               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) {
@@ -53409,14 +53451,14 @@ ${lanes.join("\n")}
           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) {
@@ -53458,7 +53500,7 @@ ${lanes.join("\n")}
                 ));
               }
               if (p.flags & 32768 /* GetAccessor */) {
-                const isPrivate2 = modifierFlags & 8 /* Private */;
+                const isPrivate2 = modifierFlags & 2 /* Private */;
                 result.push(setTextRange(
                   factory.createGetAccessorDeclaration(
                     factory.createModifiersFromModifierFlags(flag),
@@ -53475,7 +53517,7 @@ ${lanes.join("\n")}
             } 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),
@@ -53490,10 +53532,10 @@ ${lanes.join("\n")}
             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*/
@@ -53569,7 +53611,7 @@ ${lanes.join("\n")}
             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) {
@@ -53762,10 +53804,10 @@ ${lanes.join("\n")}
       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";
@@ -53883,7 +53925,7 @@ ${lanes.join("\n")}
               return true;
             }
             const parent2 = getDeclarationContainer(node);
-            if (!(getCombinedModifierFlagsCached(node) & 1 /* Export */) && !(node.kind !== 271 /* ImportEqualsDeclaration */ && parent2.kind !== 312 /* SourceFile */ && parent2.flags & 33554432 /* Ambient */)) {
+            if (!(getCombinedModifierFlagsCached(node) & 32 /* Export */) && !(node.kind !== 271 /* ImportEqualsDeclaration */ && parent2.kind !== 312 /* SourceFile */ && parent2.flags & 33554432 /* Ambient */)) {
               return isGlobalSourceFile(parent2);
             }
             return isDeclarationVisible(parent2);
@@ -53893,7 +53935,7 @@ ${lanes.join("\n")}
           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 */:
@@ -54112,7 +54154,7 @@ ${lanes.join("\n")}
       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);
@@ -54318,7 +54360,7 @@ ${lanes.join("\n")}
       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;
         }
@@ -54366,7 +54408,7 @@ ${lanes.join("\n")}
       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*/
@@ -54375,7 +54417,7 @@ ${lanes.join("\n")}
           );
         } 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*/
@@ -54479,7 +54521,7 @@ ${lanes.join("\n")}
       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) {
@@ -56132,7 +56174,7 @@ ${lanes.join("\n")}
       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*/
@@ -56908,7 +56950,7 @@ ${lanes.join("\n")}
     }
     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;
@@ -57234,7 +57276,7 @@ ${lanes.join("\n")}
             } 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 */;
             }
@@ -57686,7 +57728,7 @@ ${lanes.join("\n")}
         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(
@@ -58056,7 +58098,7 @@ ${lanes.join("\n")}
             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));
                 }
               });
             }
@@ -59881,7 +59923,7 @@ ${lanes.join("\n")}
       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);
@@ -60826,7 +60868,7 @@ ${lanes.join("\n")}
       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 */;
@@ -60888,7 +60930,7 @@ ${lanes.join("\n")}
       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));
@@ -64455,25 +64497,25 @@ ${lanes.join("\n")}
       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));
           }
@@ -65003,15 +65045,15 @@ ${lanes.join("\n")}
         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) {
@@ -65111,7 +65153,7 @@ ${lanes.join("\n")}
         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;
@@ -65159,7 +65201,7 @@ ${lanes.join("\n")}
     }
     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++) {
@@ -65244,10 +65286,10 @@ ${lanes.join("\n")}
       });
     }
     function isValidOverrideOf(sourceProp, targetProp) {
-      return !forEachProperty2(targetProp, (tp) => getDeclarationModifierFlagsFromSymbol(tp) & 16 /* Protected */ ? !isPropertyInClassDerivedFrom(sourceProp, getDeclaringClass(tp)) : false);
+      return !forEachProperty2(targetProp, (tp) => getDeclarationModifierFlagsFromSymbol(tp) & 4 /* Protected */ ? !isPropertyInClassDerivedFrom(sourceProp, getDeclaringClass(tp)) : false);
     }
     function isClassDerivedFromDeclaringClasses(checkClass, prop, writing) {
-      return forEachProperty2(prop, (p) => getDeclarationModifierFlagsFromSymbol(p, writing) & 16 /* Protected */ ? !hasBaseType(checkClass, getDeclaringClass(p)) : false) ? void 0 : checkClass;
+      return forEachProperty2(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) {
@@ -65324,8 +65366,8 @@ ${lanes.join("\n")}
       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 */;
       }
@@ -69319,7 +69361,7 @@ ${lanes.join("\n")}
         if (languageVersion < 2 /* ES2015 */) {
           if (container.kind === 219 /* ArrowFunction */) {
             error2(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 */)) {
             error2(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);
           }
         }
@@ -69732,7 +69774,7 @@ ${lanes.join("\n")}
       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,
@@ -69741,7 +69783,7 @@ ${lanes.join("\n")}
           );
           needToCaptureLexicalThis = languageVersion < 2 /* ES2015 */;
         }
-        if (container && hasSyntacticModifier(container, 512 /* Async */))
+        if (container && hasSyntacticModifier(container, 1024 /* Async */))
           inAsyncFunction = true;
       }
       let nodeCheckFlag = 0;
@@ -71929,20 +71971,20 @@ ${lanes.join("\n")}
             return false;
           }
         }
-        if (flags & 256 /* Abstract */) {
+        if (flags & 64 /* Abstract */) {
           if (errorNode) {
             error2(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) {
             error2(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) {
@@ -71951,10 +71993,10 @@ ${lanes.join("\n")}
           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) {
@@ -71974,14 +72016,14 @@ ${lanes.join("\n")}
       if (!enclosingClass) {
         enclosingClass = getEnclosingClassFromThisParameter(location);
         enclosingClass = enclosingClass && isClassDerivedFromDeclaringClasses(enclosingClass, prop, writing);
-        if (flags & 32 /* Static */ || !enclosingClass) {
+        if (flags & 256 /* Static */ || !enclosingClass) {
           if (errorNode) {
             error2(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 */) {
@@ -72401,7 +72443,7 @@ ${lanes.join("\n")}
       }
       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 = error2(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 = error2(right, Diagnostics.Class_0_used_before_its_declaration, declarationName);
@@ -72655,7 +72697,7 @@ ${lanes.join("\n")}
       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;
@@ -74100,7 +74142,7 @@ ${lanes.join("\n")}
           return resolveErrorCall(node);
         }
         const valueDecl = expressionType.symbol && getClassLikeDeclarationOfSymbol(expressionType.symbol);
-        if (valueDecl && hasSyntacticModifier(valueDecl, 256 /* Abstract */)) {
+        if (valueDecl && hasSyntacticModifier(valueDecl, 64 /* Abstract */)) {
           error2(node, Diagnostics.Cannot_create_an_instance_of_an_abstract_class);
           return resolveErrorCall(node);
         }
@@ -74163,7 +74205,7 @@ ${lanes.join("\n")}
         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;
       }
@@ -74171,16 +74213,16 @@ ${lanes.join("\n")}
       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 */) {
           error2(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 */) {
           error2(node, Diagnostics.Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration, typeToString(declaringClass));
         }
         return false;
@@ -76157,7 +76199,7 @@ ${lanes.join("\n")}
       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;
@@ -77895,15 +77937,15 @@ ${lanes.join("\n")}
       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 */))) {
             error2(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);
@@ -77917,7 +77959,7 @@ ${lanes.join("\n")}
       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))) {
           error2(node, Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
         }
@@ -78249,7 +78291,7 @@ ${lanes.join("\n")}
         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) {
         error2(node, Diagnostics.Property_0_cannot_have_an_initializer_because_it_is_marked_abstract, declarationNameToString(node.name));
       }
     }
@@ -78266,7 +78308,7 @@ ${lanes.join("\n")}
         error2(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) {
         error2(node, Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, declarationNameToString(node.name));
       }
       if (isPrivateIdentifier(node.name) && !getContainingClass(node)) {
@@ -78323,7 +78365,7 @@ ${lanes.join("\n")}
             if (classExtendsNull) {
               error2(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)) {
                 error2(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);
@@ -78392,11 +78434,11 @@ ${lanes.join("\n")}
             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 */)) {
               error2(getter.name, Diagnostics.Accessors_must_both_be_abstract_or_non_abstract);
               error2(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 */)) {
               error2(getter.name, Diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter);
               error2(setter.name, Diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter);
             }
@@ -78576,7 +78618,7 @@ ${lanes.join("\n")}
         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 */) {
             error2(accessNode, Diagnostics.Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter, unescapeLeadingUnderscores(propertyName));
             return errorType;
           }
@@ -78674,16 +78716,16 @@ ${lanes.join("\n")}
       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;
     }
@@ -78701,13 +78743,13 @@ ${lanes.join("\n")}
           const canonicalFlags = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck2);
           forEach(overloads, (o) => {
             const deviation = getEffectiveDeclarationFlags(o, flagsToCheck2) ^ canonicalFlags;
-            if (deviation & 1 /* Export */) {
+            if (deviation & 32 /* Export */) {
               error2(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_exported_or_non_exported);
-            } else if (deviation & 2 /* Ambient */) {
+            } else if (deviation & 128 /* Ambient */) {
               error2(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 */)) {
               error2(getNameOfDeclaration(o) || o, Diagnostics.Overload_signatures_must_all_be_public_private_or_protected);
-            } else if (deviation & 256 /* Abstract */) {
+            } else if (deviation & 64 /* Abstract */) {
               error2(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_abstract_or_non_abstract);
             }
           });
@@ -78724,7 +78766,7 @@ ${lanes.join("\n")}
           });
         }
       }
-      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;
@@ -78772,7 +78814,7 @@ ${lanes.join("\n")}
         if (isConstructor) {
           error2(errorNode, Diagnostics.Constructor_implementation_is_missing);
         } else {
-          if (hasSyntacticModifier(node, 256 /* Abstract */)) {
+          if (hasSyntacticModifier(node, 64 /* Abstract */)) {
             error2(errorNode, Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive);
           } else {
             error2(errorNode, Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration);
@@ -78858,7 +78900,7 @@ ${lanes.join("\n")}
           }
         });
       }
-      if (lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && !hasSyntacticModifier(lastSeenNonAmbientDeclaration, 256 /* Abstract */) && !lastSeenNonAmbientDeclaration.questionToken) {
+      if (lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && !hasSyntacticModifier(lastSeenNonAmbientDeclaration, 64 /* Abstract */) && !lastSeenNonAmbientDeclaration.questionToken) {
         reportImplementationExpectedError(lastSeenNonAmbientDeclaration);
       }
       if (hasOverloads) {
@@ -78901,9 +78943,9 @@ ${lanes.join("\n")}
       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;
@@ -79544,6 +79586,12 @@ ${lanes.join("\n")}
         }
       }
     }
+    function checkJSDocThisTag(node) {
+      const host2 = getEffectiveJSDocHost(node);
+      if (host2 && isArrowFunction(host2)) {
+        error2(node.tagName, Diagnostics.An_arrow_function_cannot_have_a_this_parameter);
+      }
+    }
     function checkJSDocImplementsTag(node) {
       const classLike = getEffectiveJSDocHost(node);
       if (!classLike || !isClassDeclaration(classLike) && !isClassExpression(classLike)) {
@@ -79706,13 +79754,13 @@ ${lanes.join("\n")}
               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)));
               }
             }
@@ -80288,7 +80336,7 @@ ${lanes.join("\n")}
       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) {
@@ -81616,7 +81664,7 @@ ${lanes.join("\n")}
       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);
@@ -81682,7 +81730,7 @@ ${lanes.join("\n")}
                 error2(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 */)) {
                   error2(node.name || node, Diagnostics.A_mixin_class_that_extends_from_a_type_variable_containing_an_abstract_construct_signature_must_also_be_declared_abstract);
                 }
               }
@@ -81896,7 +81944,7 @@ ${lanes.join("\n")}
       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)) {
             error2(node, Diagnostics.Cannot_extend_a_class_0_Class_constructor_is_marked_as_private, getFullyQualifiedName(type.symbol));
@@ -81916,7 +81964,7 @@ ${lanes.join("\n")}
       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,
@@ -81957,7 +82005,7 @@ ${lanes.join("\n")}
           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;
@@ -82000,7 +82048,7 @@ ${lanes.join("\n")}
             }
           } else {
             const derivedDeclarationFlags = getDeclarationModifierFlagsFromSymbol(derived);
-            if (baseDeclarationFlags & 8 /* Private */ || derivedDeclarationFlags & 8 /* Private */) {
+            if (baseDeclarationFlags & 2 /* Private */ || derivedDeclarationFlags & 2 /* Private */) {
               continue;
             }
             let errorMessage;
@@ -82017,7 +82065,7 @@ ${lanes.join("\n")}
                 error2(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)) {
@@ -82044,7 +82092,7 @@ ${lanes.join("\n")}
         }
     }
     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)) {
@@ -82109,7 +82157,7 @@ ${lanes.join("\n")}
       }
       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)) {
@@ -82696,7 +82744,7 @@ ${lanes.join("\n")}
                     name
                   );
                 }
-                if (isType && node.kind === 271 /* ImportEqualsDeclaration */ && hasEffectiveModifier(node, 1 /* Export */)) {
+                if (isType && node.kind === 271 /* ImportEqualsDeclaration */ && hasEffectiveModifier(node, 32 /* Export */)) {
                   error2(node, Diagnostics.Cannot_use_export_import_on_a_type_or_type_only_namespace_when_0_is_enabled, isolatedModulesLikeFlagName);
                 }
                 break;
@@ -82818,7 +82866,7 @@ ${lanes.join("\n")}
       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 */) {
@@ -83230,6 +83278,8 @@ ${lanes.join("\n")}
           return checkJSDocAccessibilityModifiers(node);
         case 357 /* JSDocSatisfiesTag */:
           return checkJSDocSatisfiesTag(node);
+        case 350 /* JSDocThisTag */:
+          return checkJSDocThisTag(node);
         case 199 /* IndexedAccessType */:
           return checkIndexedAccessType(node);
         case 200 /* MappedType */:
@@ -84456,7 +84506,7 @@ ${lanes.join("\n")}
           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;
         }
       }
@@ -84481,10 +84531,10 @@ ${lanes.join("\n")}
       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);
@@ -85338,10 +85388,10 @@ ${lanes.join("\n")}
               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)) {
@@ -85353,10 +85403,10 @@ ${lanes.join("\n")}
             }
             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);
@@ -85385,39 +85435,39 @@ ${lanes.join("\n")}
               }
               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 {
@@ -85429,60 +85479,60 @@ ${lanes.join("\n")}
               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");
@@ -85493,7 +85543,7 @@ ${lanes.join("\n")}
               } 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;
@@ -85503,19 +85553,19 @@ ${lanes.join("\n")}
                 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");
@@ -85529,62 +85579,62 @@ ${lanes.join("\n")}
                 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);
@@ -85592,7 +85642,7 @@ ${lanes.join("\n")}
               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;
@@ -85601,24 +85651,24 @@ ${lanes.join("\n")}
         }
       }
       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;
@@ -86138,12 +86188,12 @@ ${lanes.join("\n")}
         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 */) {
@@ -86215,7 +86265,7 @@ ${lanes.join("\n")}
             }
             break;
           case 171 /* PropertySignature */:
-            if (!hasSyntacticModifier(parent2, 64 /* Readonly */)) {
+            if (!hasSyntacticModifier(parent2, 8 /* Readonly */)) {
               return grammarErrorOnNode(parent2.name, Diagnostics.A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly);
             }
             break;
@@ -86385,7 +86435,7 @@ ${lanes.join("\n")}
         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);
@@ -86575,7 +86625,7 @@ ${lanes.join("\n")}
       }
     }
     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);
@@ -87021,12 +87071,14 @@ ${lanes.join("\n")}
           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;
         }
@@ -89089,15 +89141,15 @@ ${lanes.join("\n")}
           }
           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;
@@ -89113,8 +89165,8 @@ ${lanes.join("\n")}
           }
           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;
@@ -90004,7 +90056,7 @@ ${lanes.join("\n")}
   // 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);
@@ -90375,13 +90427,13 @@ ${lanes.join("\n")}
           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;
       }
@@ -90436,7 +90488,7 @@ ${lanes.join("\n")}
     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;
@@ -90494,7 +90546,7 @@ ${lanes.join("\n")}
     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;
@@ -90502,7 +90554,7 @@ ${lanes.join("\n")}
       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) {
@@ -90992,7 +91044,7 @@ ${lanes.join("\n")}
       return !nodeIsMissing(node.body);
     }
     function visitPropertyDeclaration(node, parent2) {
-      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;
       }
@@ -91001,7 +91053,7 @@ ${lanes.join("\n")}
       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,
@@ -91164,7 +91216,7 @@ ${lanes.join("\n")}
       );
     }
     function shouldEmitAccessorDeclaration(node) {
-      return !(nodeIsMissing(node.body) && hasSyntacticModifier(node, 256 /* Abstract */));
+      return !(nodeIsMissing(node.body) && hasSyntacticModifier(node, 64 /* Abstract */));
     }
     function visitGetAccessor(node, parent2) {
       if (!(node.transformFlags & 1 /* ContainsTypeScript */)) {
@@ -91897,16 +91949,16 @@ ${lanes.join("\n")}
       }
     }
     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(
@@ -93247,8 +93299,8 @@ ${lanes.join("\n")}
         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);
@@ -93794,7 +93846,7 @@ ${lanes.join("\n")}
         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);
@@ -94842,8 +94894,8 @@ ${lanes.join("\n")}
       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);
@@ -94864,7 +94916,7 @@ ${lanes.join("\n")}
       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([
@@ -94995,7 +95047,7 @@ ${lanes.join("\n")}
       );
     }
     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(
@@ -95083,7 +95135,7 @@ ${lanes.join("\n")}
       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(
@@ -95872,8 +95924,8 @@ ${lanes.join("\n")}
         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);
         }
@@ -98196,7 +98248,7 @@ ${lanes.join("\n")}
       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);
@@ -99432,7 +99484,7 @@ ${lanes.join("\n")}
         addRange(topLevelStatements, endLexicalEnvironment());
         if (exportVars.length) {
           topLevelStatements.push(factory2.createVariableStatement(
-            factory2.createModifiersFromModifierFlags(1 /* Export */),
+            factory2.createModifiersFromModifierFlags(32 /* Export */),
             factory2.createVariableDeclarationList(
               exportVars,
               1 /* Let */
@@ -99729,8 +99781,8 @@ ${lanes.join("\n")}
       if (!node.name && defaultExportBinding) {
         return node;
       }
-      const isExported2 = hasSyntacticModifier(node, 1 /* Export */);
-      const isDefault = hasSyntacticModifier(node, 1024 /* Default */);
+      const isExported2 = hasSyntacticModifier(node, 32 /* Export */);
+      const isDefault = hasSyntacticModifier(node, 2048 /* Default */);
       let expression = factory2.converters.convertToClassExpression(node);
       if (node.name) {
         hoistBindingIdentifier(
@@ -99778,7 +99830,7 @@ ${lanes.join("\n")}
     }
     function hoistVariableStatement(node) {
       let expressions;
-      const isExported2 = hasSyntacticModifier(node, 1 /* Export */);
+      const isExported2 = hasSyntacticModifier(node, 32 /* Export */);
       for (const variable of node.declarationList.declarations) {
         hoistBindingElement(variable, isExported2, variable);
         if (variable.initializer) {
@@ -101329,8 +101381,8 @@ ${lanes.join("\n")}
       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);
       }
@@ -102522,7 +102574,7 @@ ${lanes.join("\n")}
       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;
@@ -107489,7 +107541,7 @@ ${lanes.join("\n")}
       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(
@@ -107535,7 +107587,7 @@ ${lanes.join("\n")}
           );
         }
       } else {
-        if (hasSyntacticModifier(node, 1 /* Export */)) {
+        if (hasSyntacticModifier(node, 32 /* Export */)) {
           statements = append(
             statements,
             setOriginalNode(
@@ -107673,7 +107725,7 @@ ${lanes.join("\n")}
     }
     function visitFunctionDeclaration(node) {
       let statements;
-      if (hasSyntacticModifier(node, 1 /* Export */)) {
+      if (hasSyntacticModifier(node, 32 /* Export */)) {
         statements = append(
           statements,
           setOriginalNode(
@@ -107710,7 +107762,7 @@ ${lanes.join("\n")}
     }
     function visitClassDeclaration(node) {
       let statements;
-      if (hasSyntacticModifier(node, 1 /* Export */)) {
+      if (hasSyntacticModifier(node, 32 /* Export */)) {
         statements = append(
           statements,
           setOriginalNode(
@@ -107744,7 +107796,7 @@ ${lanes.join("\n")}
       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) {
@@ -107930,8 +107982,8 @@ ${lanes.join("\n")}
         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,
@@ -108425,7 +108477,7 @@ ${lanes.join("\n")}
       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)),
@@ -108627,7 +108679,7 @@ ${lanes.join("\n")}
                   factory2.createAssignment(importVariableName, parameterName)
                 )
               );
-              if (hasSyntacticModifier(entry, 1 /* Export */)) {
+              if (hasSyntacticModifier(entry, 32 /* Export */)) {
                 statements.push(
                   factory2.createExpressionStatement(
                     factory2.createCallExpression(
@@ -108780,7 +108832,7 @@ ${lanes.join("\n")}
       );
     }
     function visitFunctionDeclaration(node) {
-      if (hasSyntacticModifier(node, 1 /* Export */)) {
+      if (hasSyntacticModifier(node, 32 /* Export */)) {
         hoistedStatements = append(
           hoistedStatements,
           factory2.updateFunctionDeclaration(
@@ -108867,7 +108919,7 @@ ${lanes.join("\n")}
         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));
@@ -109003,8 +109055,8 @@ ${lanes.join("\n")}
         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);
       }
@@ -109755,7 +109807,7 @@ ${lanes.join("\n")}
       return singleOrMany(statements);
     }
     function appendExportsOfImportEqualsDeclaration(statements, node) {
-      if (hasSyntacticModifier(node, 1 /* Export */)) {
+      if (hasSyntacticModifier(node, 32 /* Export */)) {
         statements = append(
           statements,
           factory2.createExportDeclaration(
@@ -109977,7 +110029,7 @@ ${lanes.join("\n")}
     } 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;
@@ -109995,7 +110047,7 @@ ${lanes.join("\n")}
     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 */) {
@@ -110721,7 +110773,7 @@ ${lanes.join("\n")}
       return void 0;
     }
     function ensureType(node, type, ignorePrivate) {
-      if (!ignorePrivate && hasEffectiveModifier(node, 8 /* Private */)) {
+      if (!ignorePrivate && hasEffectiveModifier(node, 2 /* Private */)) {
         return;
       }
       if (shouldPrintWithInitializer(node)) {
@@ -110801,7 +110853,7 @@ ${lanes.join("\n")}
       }
     }
     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));
@@ -110846,7 +110898,7 @@ ${lanes.join("\n")}
       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);
@@ -111032,7 +111084,7 @@ ${lanes.join("\n")}
       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(
@@ -111120,7 +111172,7 @@ ${lanes.join("\n")}
               input,
               ensureModifiers(input),
               input.name,
-              updateAccessorParamsList(input, hasEffectiveModifier(input, 8 /* Private */)),
+              updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
               ensureType(input, accessorType),
               /*body*/
               void 0
@@ -111137,7 +111189,7 @@ ${lanes.join("\n")}
               input,
               ensureModifiers(input),
               input.name,
-              updateAccessorParamsList(input, hasEffectiveModifier(input, 8 /* Private */)),
+              updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
               /*body*/
               void 0
             ));
@@ -111294,7 +111346,7 @@ ${lanes.join("\n")}
       }
     }
     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)) {
@@ -111353,10 +111405,10 @@ ${lanes.join("\n")}
       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) {
@@ -111506,10 +111558,10 @@ ${lanes.join("\n")}
               ));
             }
             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,
@@ -111601,7 +111653,7 @@ ${lanes.join("\n")}
           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 */) {
@@ -111830,11 +111882,11 @@ ${lanes.join("\n")}
       return factory2.createModifiersFromModifierFlags(newFlags);
     }
     function ensureModifierFlags(node) {
-      let mask2 = 258047 /* All */ ^ (4 /* Public */ | 512 /* Async */ | 16384 /* Override */);
-      let additions = needsDeclare && !isAlwaysType(node) ? 2 /* Ambient */ : 0 /* None */;
+      let mask2 = 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)) {
-        mask2 ^= 2 /* Ambient */;
+        mask2 ^= 128 /* Ambient */;
         additions = 0 /* None */;
       }
       return maskModifierFlags(node, mask2, additions);
@@ -111876,13 +111928,13 @@ ${lanes.join("\n")}
   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;
   }
@@ -111895,7 +111947,7 @@ ${lanes.join("\n")}
     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;
@@ -120628,7 +120680,7 @@ ${lanes.join("\n")}
             }
           }
         } 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)) {
@@ -129876,7 +129928,7 @@ ${lanes.join("\n")}
       case 306 /* EnumMember */:
         return "enum member" /* enumMemberElement */;
       case 169 /* Parameter */:
-        return hasSyntacticModifier(node, 16476 /* ParameterPropertyModifier */) ? "property" /* memberVariableElement */ : "parameter" /* parameterElement */;
+        return hasSyntacticModifier(node, 31 /* ParameterPropertyModifier */) ? "property" /* memberVariableElement */ : "parameter" /* parameterElement */;
       case 271 /* ImportEqualsDeclaration */:
       case 276 /* ImportSpecifier */:
       case 281 /* ExportSpecifier */:
@@ -130779,19 +130831,19 @@ ${lanes.join("\n")}
   function getNodeModifiers(node, excludeFlags = 0 /* None */) {
     const result = [];
     const flags = isDeclaration(node) ? getCombinedNodeFlagsAlwaysIncludeJSDoc(node) & ~excludeFlags : 0 /* None */;
-    if (flags & 8 /* Private */)
+    if (flags & 2 /* Private */)
       result.push("private" /* privateMemberModifier */);
-    if (flags & 16 /* Protected */)
+    if (flags & 4 /* Protected */)
       result.push("protected" /* protectedMemberModifier */);
-    if (flags & 4 /* Public */)
+    if (flags & 1 /* Public */)
       result.push("public" /* publicMemberModifier */);
-    if (flags & 32 /* Static */ || isClassStaticBlockDeclaration(node))
+    if (flags & 256 /* Static */ || isClassStaticBlockDeclaration(node))
       result.push("static" /* staticModifier */);
-    if (flags & 256 /* Abstract */)
+    if (flags & 64 /* Abstract */)
       result.push("abstract" /* abstractModifier */);
-    if (flags & 1 /* Export */)
+    if (flags & 32 /* Export */)
       result.push("export" /* exportedModifier */);
-    if (flags & 8192 /* Deprecated */)
+    if (flags & 65536 /* Deprecated */)
       result.push("deprecated" /* deprecatedModifier */);
     if (node.flags & 33554432 /* Ambient */)
       result.push("declare" /* ambientModifier */);
@@ -132169,7 +132221,7 @@ ${lanes.join("\n")}
     return isInJSFile(declaration) || !findAncestor(declaration, (d) => isModuleDeclaration(d) && isGlobalScopeAugmentation(d));
   }
   function isDeprecatedDeclaration(decl) {
-    return !!(getCombinedNodeFlagsAlwaysIncludeJSDoc(decl) & 8192 /* Deprecated */);
+    return !!(getCombinedNodeFlagsAlwaysIncludeJSDoc(decl) & 65536 /* Deprecated */);
   }
   function shouldUseUriStyleNodeCoreModules(file, program) {
     const decisionFromFile = firstDefined(file.imports, (node) => {
@@ -133853,7 +133905,7 @@ ${lanes.join("\n")}
             case 241 /* Block */:
             case 296 /* CaseClause */:
             case 297 /* DefaultClause */:
-              if (modifierFlag & 256 /* Abstract */ && isClassDeclaration(declaration)) {
+              if (modifierFlag & 64 /* Abstract */ && isClassDeclaration(declaration)) {
                 return [...declaration.members, declaration];
               } else {
                 return container.statements;
@@ -133867,12 +133919,12 @@ ${lanes.join("\n")}
             case 264 /* InterfaceDeclaration */:
             case 187 /* TypeLiteral */:
               const nodes = container.members;
-              if (modifierFlag & (28 /* AccessibilityModifier */ | 64 /* Readonly */)) {
+              if (modifierFlag & (7 /* AccessibilityModifier */ | 8 /* Readonly */)) {
                 const constructor = find(container.members, isConstructorDeclaration);
                 if (constructor) {
                   return [...nodes, ...constructor.parameters];
                 }
-              } else if (modifierFlag & 256 /* Abstract */) {
+              } else if (modifierFlag & 64 /* Abstract */) {
                 return [...nodes, container];
               }
               return nodes;
@@ -136366,7 +136418,7 @@ ${lanes.join("\n")}
       case 218 /* FunctionExpression */:
       case 263 /* ClassDeclaration */:
       case 231 /* ClassExpression */:
-        if (getSyntacticModifierFlags(node) & 1024 /* Default */) {
+        if (getSyntacticModifierFlags(node) & 2048 /* Default */) {
           return "default";
         }
         return getFunctionOrClassName(node);
@@ -136516,7 +136568,7 @@ ${lanes.join("\n")}
       return nodeText(parent2.left).replace(whiteSpaceRegex, "");
     } else if (isPropertyAssignment(parent2)) {
       return nodeText(parent2.name);
-    } else if (getSyntacticModifierFlags(node) & 1024 /* Default */) {
+    } else if (getSyntacticModifierFlags(node) & 2048 /* Default */) {
       return "default";
     } else if (isClassLike(node)) {
       return "<class>";
@@ -136676,15 +136728,15 @@ ${lanes.join("\n")}
         const { file, program } = context;
         const span = getRefactorContextSpan(context);
         const token = getTokenAtPosition(file, span.start);
-        const exportNode = !!(token.parent && getSyntacticModifierFlags(token.parent) & 1 /* Export */) && considerPartialSpans ? token.parent : getParentNodeInSpan(token, file, span);
+        const exportNode = !!(token.parent && getSyntacticModifierFlags(token.parent) & 32 /* Export */) && considerPartialSpans ? token.parent : getParentNodeInSpan(token, file, span);
         if (!exportNode || !isSourceFile(exportNode.parent) && !(isModuleBlock(exportNode.parent) && isAmbientModule(exportNode.parent.parent))) {
           return { error: getLocaleSpecificMessage(Diagnostics.Could_not_find_export_statement) };
         }
         const checker = program.getTypeChecker();
         const exportingModuleSymbol = getExportingModuleSymbol(exportNode.parent, checker);
-        const flags = getSyntacticModifierFlags(exportNode) || (isExportAssignment(exportNode) && !exportNode.isExportEquals ? 1025 /* ExportDefault */ : 0 /* None */);
-        const wasDefault = !!(flags & 1024 /* Default */);
-        if (!(flags & 1 /* Export */) || !wasDefault && exportingModuleSymbol.exports.has("default" /* Default */)) {
+        const flags = getSyntacticModifierFlags(exportNode) || (isExportAssignment(exportNode) && !exportNode.isExportEquals ? 2080 /* ExportDefault */ : 0 /* None */);
+        const wasDefault = !!(flags & 2048 /* Default */);
+        if (!(flags & 32 /* Export */) || !wasDefault && exportingModuleSymbol.exports.has("default" /* Default */)) {
           return { error: getLocaleSpecificMessage(Diagnostics.This_file_already_has_a_default_export) };
         }
         const noSymbolError = (id) => isIdentifier(id) && checker.getSymbolAtLocation(id) ? void 0 : { error: getLocaleSpecificMessage(Diagnostics.Can_only_convert_named_export) };
@@ -137672,7 +137724,7 @@ ${lanes.join("\n")}
             if (markSeenTop(top)) {
               addExportToChanges(oldFile, top, name, changes, useEsModuleSyntax);
             }
-            if (hasSyntacticModifier(decl, 1024 /* Default */)) {
+            if (hasSyntacticModifier(decl, 2048 /* Default */)) {
               oldFileDefault = name;
             } else {
               oldFileNamedImports.push(name.text);
@@ -137818,7 +137870,7 @@ ${lanes.join("\n")}
         if (importAdder && checker.isUnknownSymbol(symbol)) {
           importAdder.addImportFromExportedSymbol(skipAlias(symbol, checker));
         } else {
-          if (hasSyntacticModifier(decl, 1024 /* Default */)) {
+          if (hasSyntacticModifier(decl, 2048 /* Default */)) {
             oldFileDefault = name;
           } else {
             oldFileNamedImports.push(name.text);
@@ -138058,7 +138110,7 @@ ${lanes.join("\n")}
   function isExported(sourceFile, decl, useEs6Exports, name) {
     var _a;
     if (useEs6Exports) {
-      return !isExpressionStatement(decl) && hasSyntacticModifier(decl, 1 /* Export */) || !!(name && sourceFile.symbol && ((_a = sourceFile.symbol.exports) == null ? void 0 : _a.has(name.escapedText)));
+      return !isExpressionStatement(decl) && hasSyntacticModifier(decl, 32 /* Export */) || !!(name && sourceFile.symbol && ((_a = sourceFile.symbol.exports) == null ? void 0 : _a.has(name.escapedText)));
     }
     return !!sourceFile.symbol && !!sourceFile.symbol.exports && getNamesToExportInCommonJS(decl).some((name2) => sourceFile.symbol.exports.has(escapeLeadingUnderscores(name2)));
   }
@@ -138353,7 +138405,7 @@ ${lanes.join("\n")}
       case 272 /* ImportDeclaration */:
         return true;
       case 271 /* ImportEqualsDeclaration */:
-        return !hasSyntacticModifier(node, 1 /* Export */);
+        return !hasSyntacticModifier(node, 32 /* Export */);
       case 243 /* VariableStatement */:
         return node.declarationList.declarations.every((d) => !!d.initializer && isRequireCall(
           d.initializer,
@@ -138524,7 +138576,7 @@ ${lanes.join("\n")}
       const checker = program.getTypeChecker();
       const targetToSourceExports = /* @__PURE__ */ new Map();
       for (const node of toMove.all) {
-        if (isTopLevelDeclarationStatement(node) && hasSyntacticModifier(node, 1 /* Export */)) {
+        if (isTopLevelDeclarationStatement(node) && hasSyntacticModifier(node, 32 /* Export */)) {
           forEachTopLevelDeclaration(node, (declaration) => {
             var _a2;
             const targetDeclarations = canHaveSymbol(declaration) ? (_a2 = targetExports.get(declaration.symbol.escapedName)) == null ? void 0 : _a2.declarations : void 0;
@@ -139190,7 +139242,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         const body = convertToBlock(func.body);
         const { variableDeclaration, variableDeclarationList, statement, name } = variableInfo;
         suppressLeadingTrivia(statement);
-        const modifiersFlags = getCombinedModifierFlags(variableDeclaration) & 1 /* Export */ | getEffectiveModifierFlags(func);
+        const modifiersFlags = getCombinedModifierFlags(variableDeclaration) & 32 /* Export */ | getEffectiveModifierFlags(func);
         const modifiers = factory.createModifiersFromModifierFlags(modifiersFlags);
         const newNode = factory.createFunctionDeclaration(length(modifiers) ? modifiers : void 0, func.asteriskToken, name, func.typeParameters, func.parameters, func.type, body);
         if (variableDeclarationList.declarations.length === 1) {
@@ -140529,7 +140581,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         }
         if (isDeclaration(node2)) {
           const declaringNode = node2.kind === 260 /* VariableDeclaration */ ? node2.parent.parent : node2;
-          if (hasSyntacticModifier(declaringNode, 1 /* Export */)) {
+          if (hasSyntacticModifier(declaringNode, 32 /* Export */)) {
             (errors2 || (errors2 = [])).push(createDiagnosticForNode(node2, Messages.cannotExtractExportedEntity));
             return true;
           }
@@ -141537,7 +141589,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       usagesPerScope[i].usages.forEach((value) => {
         if (value.usage === 2 /* Write */) {
           hasWrite = true;
-          if (value.symbol.flags & 106500 /* ClassMember */ && value.symbol.valueDeclaration && hasEffectiveModifier(value.symbol.valueDeclaration, 64 /* Readonly */)) {
+          if (value.symbol.flags & 106500 /* ClassMember */ && value.symbol.valueDeclaration && hasEffectiveModifier(value.symbol.valueDeclaration, 8 /* Readonly */)) {
             readonlyClassPropertyWrite = value.symbol.valueDeclaration;
           }
         }
@@ -142157,14 +142209,14 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             if (decl) {
               const modifiers = getCombinedModifierFlags(decl);
               const nodeFlags = getCombinedNodeFlags(decl);
-              if (modifiers & 32 /* Static */) {
+              if (modifiers & 256 /* Static */) {
                 modifierSet |= 1 << 1 /* static */;
               }
-              if (modifiers & 512 /* Async */) {
+              if (modifiers & 1024 /* Async */) {
                 modifierSet |= 1 << 2 /* async */;
               }
               if (typeIdx !== 0 /* class */ && typeIdx !== 2 /* interface */) {
-                if (modifiers & 64 /* Readonly */ || nodeFlags & 2 /* Const */ || symbol.getFlags() & 8 /* EnumMember */) {
+                if (modifiers & 8 /* Readonly */ || nodeFlags & 2 /* Const */ || symbol.getFlags() & 8 /* EnumMember */) {
                   modifierSet |= 1 << 3 /* readonly */;
                 }
               }
@@ -144296,7 +144348,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
                 forEachChild(node, visit);
                 break;
               case 169 /* Parameter */:
-                if (!hasSyntacticModifier(node, 16476 /* ParameterPropertyModifier */)) {
+                if (!hasSyntacticModifier(node, 31 /* ParameterPropertyModifier */)) {
                   break;
                 }
               case 260 /* VariableDeclaration */:
@@ -144783,7 +144835,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         if (isBindingPattern(variableDeclaration.name)) {
           return spanInBindingPattern(variableDeclaration.name);
         }
-        if (hasOnlyExpressionInitializer(variableDeclaration) && variableDeclaration.initializer || hasSyntacticModifier(variableDeclaration, 1 /* Export */) || parent2.parent.kind === 250 /* ForOfStatement */) {
+        if (hasOnlyExpressionInitializer(variableDeclaration) && variableDeclaration.initializer || hasSyntacticModifier(variableDeclaration, 32 /* Export */) || parent2.parent.kind === 250 /* ForOfStatement */) {
           return textSpanFromVariableDeclaration(variableDeclaration);
         }
         if (isVariableDeclarationList(variableDeclaration.parent) && variableDeclaration.parent.declarations[0] !== variableDeclaration) {
@@ -144791,7 +144843,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         }
       }
       function canHaveSpanInParameterDeclaration(parameter) {
-        return !!parameter.initializer || parameter.dotDotDotToken !== void 0 || hasSyntacticModifier(parameter, 4 /* Public */ | 8 /* Private */);
+        return !!parameter.initializer || parameter.dotDotDotToken !== void 0 || hasSyntacticModifier(parameter, 1 /* Public */ | 2 /* Private */);
       }
       function spanInParameterDeclaration(parameter) {
         if (isBindingPattern(parameter.name)) {
@@ -144810,7 +144862,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         }
       }
       function canFunctionHaveSpanInWholeDeclaration(functionDeclaration) {
-        return hasSyntacticModifier(functionDeclaration, 1 /* Export */) || functionDeclaration.parent.kind === 263 /* ClassDeclaration */ && functionDeclaration.kind !== 176 /* Constructor */;
+        return hasSyntacticModifier(functionDeclaration, 32 /* Export */) || functionDeclaration.parent.kind === 263 /* ClassDeclaration */ && functionDeclaration.kind !== 176 /* Constructor */;
       }
       function spanInFunctionDeclaration(functionDeclaration) {
         if (!functionDeclaration.body) {
@@ -145381,7 +145433,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     forEach(node.statements, collect);
   }
   function collectCallSitesOfModuleDeclaration(node, collect) {
-    if (!hasSyntacticModifier(node, 2 /* Ambient */) && node.body && isModuleBlock(node.body)) {
+    if (!hasSyntacticModifier(node, 128 /* Ambient */) && node.body && isModuleBlock(node.body)) {
       forEach(node.body.statements, collect);
     }
   }
@@ -145726,7 +145778,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             /*includeTrivia*/
             true
           ),
-          factory.createNodeArray(factory.createModifiersFromModifierFlags(getSyntacticModifierFlags(insertionSite) | 512 /* Async */))
+          factory.createNodeArray(factory.createModifiersFromModifierFlags(getSyntacticModifierFlags(insertionSite) | 1024 /* Async */))
         );
         changeTracker.replaceNode(
           sourceFile,
@@ -145858,7 +145910,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           const declaration = tryCast(symbol.valueDeclaration, isVariableDeclaration);
           const variableName = declaration && tryCast(declaration.name, isIdentifier);
           const variableStatement = getAncestor(declaration, 243 /* VariableStatement */);
-          if (!declaration || !variableStatement || declaration.type || !declaration.initializer || variableStatement.getSourceFile() !== sourceFile || hasSyntacticModifier(variableStatement, 1 /* Export */) || !variableName || !isInsideAwaitableBody(declaration.initializer)) {
+          if (!declaration || !variableStatement || declaration.type || !declaration.initializer || variableStatement.getSourceFile() !== sourceFile || hasSyntacticModifier(variableStatement, 32 /* Export */) || !variableName || !isInsideAwaitableBody(declaration.initializer)) {
             isCompleteFix = false;
             continue;
           }
@@ -148609,7 +148661,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         return Debug.checkDefined(getContainingClass(getTokenAtPosition(sourceFile, pos)), "There should be a containing class");
       }
       function symbolPointsToNonPrivateMember(symbol) {
-        return !symbol.valueDeclaration || !(getEffectiveModifierFlags(symbol.valueDeclaration) & 8 /* Private */);
+        return !symbol.valueDeclaration || !(getEffectiveModifierFlags(symbol.valueDeclaration) & 2 /* Private */);
       }
       function addMissingDeclarations(context, implementedTypeNode, sourceFile, classDeclaration, changeTracker, preferences) {
         const checker = context.program.getTypeChecker();
@@ -150639,7 +150691,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           const tag = findAncestor(node, isJsxOpeningLikeElement);
           const props = checker.getContextualTypeForArgumentAtIndex(tag, 0);
           suggestedSymbol = checker.getSuggestedSymbolForNonexistentJSXAttribute(node, props);
-        } else if (hasSyntacticModifier(parent2, 16384 /* Override */) && isClassElement(parent2) && parent2.name === node) {
+        } else if (hasOverrideModifier(parent2) && isClassElement(parent2) && parent2.name === node) {
           const baseDeclaration = findAncestor(node, isClassLike);
           const baseTypeNode = baseDeclaration ? getEffectiveBaseTypeNode(baseDeclaration) : void 0;
           const baseType = baseTypeNode ? checker.getTypeAtLocation(baseTypeNode) : void 0;
@@ -150820,7 +150872,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         if (isFunctionType) {
           const sig = checker.getSignatureFromDeclaration(declaration);
           if (sig) {
-            if (hasSyntacticModifier(declaration, 512 /* Async */)) {
+            if (hasSyntacticModifier(declaration, 1024 /* Async */)) {
               exprType = checker.createPromiseType(exprType);
             }
             const newSig = checker.createSignature(
@@ -151041,13 +151093,13 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
                   continue;
                 const { parentDeclaration, declSourceFile, modifierFlags, token, call, isJSFile } = info;
                 if (call && !isPrivateIdentifier(token)) {
-                  addMethodDeclaration(context, changes, call, token, modifierFlags & 32 /* Static */, parentDeclaration, declSourceFile);
+                  addMethodDeclaration(context, changes, call, token, modifierFlags & 256 /* Static */, parentDeclaration, declSourceFile);
                 } else {
                   if (isJSFile && !isInterfaceDeclaration(parentDeclaration) && !isTypeLiteralNode(parentDeclaration)) {
-                    addMissingMemberInJs(changes, declSourceFile, parentDeclaration, token, !!(modifierFlags & 32 /* Static */));
+                    addMissingMemberInJs(changes, declSourceFile, parentDeclaration, token, !!(modifierFlags & 256 /* Static */));
                   } else {
                     const typeNode = getTypeNode2(checker, parentDeclaration, token);
-                    addPropertyDeclaration(changes, declSourceFile, parentDeclaration, token.text, typeNode, modifierFlags & 32 /* Static */);
+                    addPropertyDeclaration(changes, declSourceFile, parentDeclaration, token.text, typeNode, modifierFlags & 256 /* Static */);
                   }
                 }
               }
@@ -151128,13 +151180,13 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           const moduleDeclaration = find(symbol.declarations, isModuleDeclaration);
           const moduleDeclarationSourceFile = moduleDeclaration == null ? void 0 : moduleDeclaration.getSourceFile();
           if (moduleDeclaration && moduleDeclarationSourceFile && !isSourceFileFromLibrary(program, moduleDeclarationSourceFile)) {
-            return { kind: 2 /* Function */, token, call: parent2.parent, sourceFile, modifierFlags: 1 /* Export */, parentDeclaration: moduleDeclaration };
+            return { kind: 2 /* Function */, token, call: parent2.parent, sourceFile, modifierFlags: 32 /* Export */, parentDeclaration: moduleDeclaration };
           }
           const moduleSourceFile = find(symbol.declarations, isSourceFile);
           if (sourceFile.commonJsModuleIndicator)
             return void 0;
           if (moduleSourceFile && !isSourceFileFromLibrary(program, moduleSourceFile)) {
-            return { kind: 2 /* Function */, token, call: parent2.parent, sourceFile: moduleSourceFile, modifierFlags: 1 /* Export */, parentDeclaration: moduleSourceFile };
+            return { kind: 2 /* Function */, token, call: parent2.parent, sourceFile: moduleSourceFile, modifierFlags: 32 /* Export */, parentDeclaration: moduleSourceFile };
           }
         }
         const classDeclaration = find(symbol.declarations, isClassLike);
@@ -151146,7 +151198,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           if (makeStatic && (isPrivateIdentifier(token) || isInterfaceDeclaration(declaration)))
             return void 0;
           const declSourceFile = declaration.getSourceFile();
-          const modifierFlags = isTypeLiteralNode(declaration) ? 0 /* None */ : (makeStatic ? 32 /* Static */ : 0 /* None */) | (startsWithUnderscore(token.text) ? 8 /* Private */ : 0 /* None */);
+          const modifierFlags = isTypeLiteralNode(declaration) ? 0 /* None */ : (makeStatic ? 256 /* Static */ : 0 /* None */) | (startsWithUnderscore(token.text) ? 2 /* Private */ : 0 /* None */);
           const isJSFile = isSourceFileJS(declSourceFile);
           const call = tryCast(parent2.parent, isCallExpression);
           return { kind: 0 /* TypeLikeDeclaration */, token, call, modifierFlags, parentDeclaration: declaration, declSourceFile, isJSFile };
@@ -151164,11 +151216,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         if (isInterfaceDeclaration(parentDeclaration) || isTypeLiteralNode(parentDeclaration)) {
           return void 0;
         }
-        const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingMemberInJs(t, declSourceFile, parentDeclaration, token, !!(modifierFlags & 32 /* Static */)));
+        const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingMemberInJs(t, declSourceFile, parentDeclaration, token, !!(modifierFlags & 256 /* Static */)));
         if (changes.length === 0) {
           return void 0;
         }
-        const diagnostic = modifierFlags & 32 /* Static */ ? Diagnostics.Initialize_static_property_0 : isPrivateIdentifier(token) ? Diagnostics.Declare_a_private_field_named_0 : Diagnostics.Initialize_property_0_in_the_constructor;
+        const diagnostic = modifierFlags & 256 /* Static */ ? Diagnostics.Initialize_static_property_0 : isPrivateIdentifier(token) ? Diagnostics.Declare_a_private_field_named_0 : Diagnostics.Initialize_property_0_in_the_constructor;
         return createCodeFixAction(fixMissingMember, changes, [diagnostic, token.text], fixMissingMember, Diagnostics.Add_all_missing_members);
       }
       function addMissingMemberInJs(changeTracker, sourceFile, classDeclaration, token, makeStatic) {
@@ -151212,15 +151264,15 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
       function createActionsForAddMissingMemberInTypeScriptFile(context, { parentDeclaration, declSourceFile, modifierFlags, token }) {
         const memberName = token.text;
-        const isStatic2 = modifierFlags & 32 /* Static */;
+        const isStatic2 = modifierFlags & 256 /* Static */;
         const typeNode = getTypeNode2(context.program.getTypeChecker(), parentDeclaration, token);
         const addPropertyDeclarationChanges = (modifierFlags2) => ts_textChanges_exports.ChangeTracker.with(context, (t) => addPropertyDeclaration(t, declSourceFile, parentDeclaration, memberName, typeNode, modifierFlags2));
-        const actions2 = [createCodeFixAction(fixMissingMember, addPropertyDeclarationChanges(modifierFlags & 32 /* Static */), [isStatic2 ? Diagnostics.Declare_static_property_0 : Diagnostics.Declare_property_0, memberName], fixMissingMember, Diagnostics.Add_all_missing_members)];
+        const actions2 = [createCodeFixAction(fixMissingMember, addPropertyDeclarationChanges(modifierFlags & 256 /* Static */), [isStatic2 ? Diagnostics.Declare_static_property_0 : Diagnostics.Declare_property_0, memberName], fixMissingMember, Diagnostics.Add_all_missing_members)];
         if (isStatic2 || isPrivateIdentifier(token)) {
           return actions2;
         }
-        if (modifierFlags & 8 /* Private */) {
-          actions2.unshift(createCodeFixActionWithoutFixAll(fixMissingMember, addPropertyDeclarationChanges(8 /* Private */), [Diagnostics.Declare_private_property_0, memberName]));
+        if (modifierFlags & 2 /* Private */) {
+          actions2.unshift(createCodeFixActionWithoutFixAll(fixMissingMember, addPropertyDeclarationChanges(2 /* Private */), [Diagnostics.Declare_private_property_0, memberName]));
         }
         actions2.push(createAddIndexSignatureAction(context, declSourceFile, parentDeclaration, token.text, typeNode));
         return actions2;
@@ -151307,9 +151359,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         }
         const methodName = token.text;
         const addMethodDeclarationChanges = (modifierFlags2) => ts_textChanges_exports.ChangeTracker.with(context, (t) => addMethodDeclaration(context, t, call, token, modifierFlags2, parentDeclaration, declSourceFile));
-        const actions2 = [createCodeFixAction(fixMissingMember, addMethodDeclarationChanges(modifierFlags & 32 /* Static */), [modifierFlags & 32 /* Static */ ? Diagnostics.Declare_static_method_0 : Diagnostics.Declare_method_0, methodName], fixMissingMember, Diagnostics.Add_all_missing_members)];
-        if (modifierFlags & 8 /* Private */) {
-          actions2.unshift(createCodeFixActionWithoutFixAll(fixMissingMember, addMethodDeclarationChanges(8 /* Private */), [Diagnostics.Declare_private_method_0, methodName]));
+        const actions2 = [createCodeFixAction(fixMissingMember, addMethodDeclarationChanges(modifierFlags & 256 /* Static */), [modifierFlags & 256 /* Static */ ? Diagnostics.Declare_static_method_0 : Diagnostics.Declare_method_0, methodName], fixMissingMember, Diagnostics.Add_all_missing_members)];
+        if (modifierFlags & 2 /* Private */) {
+          actions2.unshift(createCodeFixActionWithoutFixAll(fixMissingMember, addMethodDeclarationChanges(2 /* Private */), [Diagnostics.Declare_private_method_0, methodName]));
         }
         return actions2;
       }
@@ -151746,7 +151798,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
       function symbolPointsToNonPrivateAndAbstractMember(symbol) {
         const flags = getSyntacticModifierFlags(first(symbol.getDeclarations()));
-        return !(flags & 8 /* Private */) && !!(flags & 256 /* Abstract */);
+        return !(flags & 2 /* Private */) && !!(flags & 64 /* Abstract */);
       }
     }
   });
@@ -154223,10 +154275,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     const kind = (declaration == null ? void 0 : declaration.kind) ?? 171 /* PropertySignature */;
     const declarationName = createDeclarationName(symbol, declaration);
     const effectiveModifierFlags = declaration ? getEffectiveModifierFlags(declaration) : 0 /* None */;
-    let modifierFlags = effectiveModifierFlags & 32 /* Static */;
-    modifierFlags |= effectiveModifierFlags & 4 /* Public */ ? 4 /* Public */ : effectiveModifierFlags & 16 /* Protected */ ? 16 /* Protected */ : 0 /* None */;
+    let modifierFlags = effectiveModifierFlags & 256 /* Static */;
+    modifierFlags |= effectiveModifierFlags & 1 /* Public */ ? 1 /* Public */ : effectiveModifierFlags & 4 /* Protected */ ? 4 /* Protected */ : 0 /* None */;
     if (declaration && isAutoAccessorPropertyDeclaration(declaration)) {
-      modifierFlags |= 128 /* Accessor */;
+      modifierFlags |= 512 /* Accessor */;
     }
     const modifiers = createModifiers();
     const type = checker.getWidenedType(checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration));
@@ -154905,24 +154957,24 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     return isIdentifier(fieldName) ? factory.createPropertyAccessExpression(leftHead, fieldName) : factory.createElementAccessExpression(leftHead, factory.createStringLiteralFromNode(fieldName));
   }
   function prepareModifierFlagsForAccessor(modifierFlags) {
-    modifierFlags &= ~64 /* Readonly */;
-    modifierFlags &= ~8 /* Private */;
-    if (!(modifierFlags & 16 /* Protected */)) {
-      modifierFlags |= 4 /* Public */;
+    modifierFlags &= ~8 /* Readonly */;
+    modifierFlags &= ~2 /* Private */;
+    if (!(modifierFlags & 4 /* Protected */)) {
+      modifierFlags |= 1 /* Public */;
     }
     return modifierFlags;
   }
   function prepareModifierFlagsForField(modifierFlags) {
-    modifierFlags &= ~4 /* Public */;
-    modifierFlags &= ~16 /* Protected */;
-    modifierFlags |= 8 /* Private */;
+    modifierFlags &= ~1 /* Public */;
+    modifierFlags &= ~4 /* Protected */;
+    modifierFlags |= 2 /* Private */;
     return modifierFlags;
   }
   function getAccessorConvertiblePropertyAtPosition(file, program, start, end, considerEmptySpans = true) {
     const node = getTokenAtPosition(file, start);
     const cursorRequest = start === end && considerEmptySpans;
     const declaration = findAncestor(node.parent, isAcceptedDeclaration);
-    const meaning = 28 /* AccessibilityModifier */ | 32 /* Static */ | 64 /* Readonly */;
+    const meaning = 7 /* AccessibilityModifier */ | 256 /* Static */ | 8 /* Readonly */;
     if (!declaration || !(nodeOverlapsWithStartEnd(declaration.name, file, start, end) || cursorRequest)) {
       return {
         error: getLocaleSpecificMessage(Diagnostics.Could_not_find_property_for_which_to_generate_accessor)
@@ -154933,7 +154985,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         error: getLocaleSpecificMessage(Diagnostics.Name_is_not_valid)
       };
     }
-    if ((getEffectiveModifierFlags(declaration) & 126975 /* Modifier */ | meaning) !== meaning) {
+    if ((getEffectiveModifierFlags(declaration) & 98303 /* Modifier */ | meaning) !== meaning) {
       return {
         error: getLocaleSpecificMessage(Diagnostics.Can_only_convert_property_with_modifier)
       };
@@ -155321,7 +155373,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           return firstDefined(type.types, (t) => getDefaultValueFromType(checker, t));
         } else if (type.isClass()) {
           const classDeclaration = getClassLikeDeclarationOfSymbol(type.symbol);
-          if (!classDeclaration || hasSyntacticModifier(classDeclaration, 256 /* Abstract */))
+          if (!classDeclaration || hasSyntacticModifier(classDeclaration, 64 /* Abstract */))
             return void 0;
           const constructorDeclaration = getFirstConstructorWithBody(classDeclaration);
           if (constructorDeclaration && constructorDeclaration.parameters.length)
@@ -157177,7 +157229,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     let modifiers = 0 /* None */;
     const { modifiers: presentModifiers, range: eraseRange, decorators: presentDecorators } = getPresentModifiers(contextToken, sourceFile, position);
-    const isAbstract = presentModifiers & 256 /* Abstract */ && classLikeDeclaration.modifierFlagsCache & 256 /* Abstract */;
+    const isAbstract = presentModifiers & 64 /* Abstract */ && classLikeDeclaration.modifierFlagsCache & 64 /* Abstract */;
     let completionNodes = [];
     ts_codefix_exports.addNewNodeForMemberSymbol(
       symbol,
@@ -157196,10 +157248,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       (node) => {
         let requiredModifiers = 0 /* None */;
         if (isAbstract) {
-          requiredModifiers |= 256 /* Abstract */;
+          requiredModifiers |= 64 /* Abstract */;
         }
         if (isClassElement(node) && checker.getMemberOverrideModifierStatus(classLikeDeclaration, node, symbol) === 1 /* NeedsOverride */) {
-          requiredModifiers |= 16384 /* Override */;
+          requiredModifiers |= 16 /* Override */;
         }
         if (!completionNodes.length) {
           modifiers = node.modifierFlagsCache | requiredModifiers;
@@ -157213,21 +157265,21 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     );
     if (completionNodes.length) {
       const isMethod = symbol.flags & 8192 /* Method */;
-      let allowedModifiers = modifiers | 16384 /* Override */ | 4 /* Public */;
+      let allowedModifiers = modifiers | 16 /* Override */ | 1 /* Public */;
       if (!isMethod) {
-        allowedModifiers |= 2 /* Ambient */ | 64 /* Readonly */;
+        allowedModifiers |= 128 /* Ambient */ | 8 /* Readonly */;
       } else {
-        allowedModifiers |= 512 /* Async */;
+        allowedModifiers |= 1024 /* Async */;
       }
       const allowedAndPresent = presentModifiers & allowedModifiers;
       if (presentModifiers & ~allowedModifiers) {
         return void 0;
       }
-      if (modifiers & 16 /* Protected */ && allowedAndPresent & 4 /* Public */) {
-        modifiers &= ~16 /* Protected */;
+      if (modifiers & 4 /* Protected */ && allowedAndPresent & 1 /* Public */) {
+        modifiers &= ~4 /* Protected */;
       }
-      if (allowedAndPresent !== 0 /* None */ && !(allowedAndPresent & 4 /* Public */)) {
-        modifiers &= ~4 /* Public */;
+      if (allowedAndPresent !== 0 /* None */ && !(allowedAndPresent & 1 /* Public */)) {
+        modifiers &= ~1 /* Public */;
       }
       modifiers |= allowedAndPresent;
       completionNodes = completionNodes.map((node) => factory.replaceModifiers(node, modifiers));
@@ -157264,7 +157316,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     let contextMod;
     const range = { pos: position, end: position };
     if (isPropertyDeclaration(contextToken.parent) && contextToken.parent.modifiers) {
-      modifiers |= modifiersToFlags(contextToken.parent.modifiers) & 126975 /* Modifier */;
+      modifiers |= modifiersToFlags(contextToken.parent.modifiers) & 98303 /* Modifier */;
       decorators = contextToken.parent.modifiers.filter(isDecorator) || [];
       range.pos = Math.min(range.pos, contextToken.parent.modifiers.pos);
     }
@@ -159005,24 +159057,24 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       if (contextToken.kind === 80 /* Identifier */ && !isCurrentlyEditingNode(contextToken)) {
         switch (contextToken.getText()) {
           case "private":
-            classElementModifierFlags = classElementModifierFlags | 8 /* Private */;
+            classElementModifierFlags = classElementModifierFlags | 2 /* Private */;
             break;
           case "static":
-            classElementModifierFlags = classElementModifierFlags | 32 /* Static */;
+            classElementModifierFlags = classElementModifierFlags | 256 /* Static */;
             break;
           case "override":
-            classElementModifierFlags = classElementModifierFlags | 16384 /* Override */;
+            classElementModifierFlags = classElementModifierFlags | 16 /* Override */;
             break;
         }
       }
       if (isClassStaticBlockDeclaration(classElement)) {
-        classElementModifierFlags |= 32 /* Static */;
+        classElementModifierFlags |= 256 /* Static */;
       }
-      if (!(classElementModifierFlags & 8 /* Private */)) {
-        const baseTypeNodes = isClassLike(decl) && classElementModifierFlags & 16384 /* Override */ ? singleElementArray(getEffectiveBaseTypeNode(decl)) : getAllSuperTypeNodes(decl);
+      if (!(classElementModifierFlags & 2 /* Private */)) {
+        const baseTypeNodes = isClassLike(decl) && classElementModifierFlags & 16 /* Override */ ? singleElementArray(getEffectiveBaseTypeNode(decl)) : getAllSuperTypeNodes(decl);
         const baseSymbols = flatMap(baseTypeNodes, (baseTypeNode) => {
           const type = typeChecker.getTypeAtLocation(baseTypeNode);
-          return classElementModifierFlags & 32 /* Static */ ? (type == null ? void 0 : type.symbol) && typeChecker.getPropertiesOfType(typeChecker.getTypeOfSymbolAtLocation(type.symbol, decl)) : type && typeChecker.getPropertiesOfType(type);
+          return classElementModifierFlags & 256 /* Static */ ? (type == null ? void 0 : type.symbol) && typeChecker.getPropertiesOfType(typeChecker.getTypeOfSymbolAtLocation(type.symbol, decl)) : type && typeChecker.getPropertiesOfType(type);
         });
         symbols = concatenate(symbols, filterClassMembersList(baseSymbols, decl.members, classElementModifierFlags));
         forEach(symbols, (symbol, index) => {
@@ -159325,10 +159377,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         if (isCurrentlyEditingNode(m)) {
           continue;
         }
-        if (hasEffectiveModifier(m, 8 /* Private */)) {
+        if (hasEffectiveModifier(m, 2 /* Private */)) {
           continue;
         }
-        if (isStatic(m) !== !!(currentClassElementModifierFlags & 32 /* Static */)) {
+        if (isStatic(m) !== !!(currentClassElementModifierFlags & 256 /* Static */)) {
           continue;
         }
         const existingName = getPropertyNameForPropertyNameNode(m.name);
@@ -159337,7 +159389,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         }
       }
       return baseSymbols.filter(
-        (propertySymbol) => !existingMemberNames.has(propertySymbol.escapedName) && !!propertySymbol.declarations && !(getDeclarationModifierFlagsFromSymbol(propertySymbol) & 8 /* Private */) && !(propertySymbol.valueDeclaration && isPrivateIdentifierClassElementDeclaration(propertySymbol.valueDeclaration))
+        (propertySymbol) => !existingMemberNames.has(propertySymbol.escapedName) && !!propertySymbol.declarations && !(getDeclarationModifierFlagsFromSymbol(propertySymbol) & 2 /* Private */) && !(propertySymbol.valueDeclaration && isPrivateIdentifierClassElementDeclaration(propertySymbol.valueDeclaration))
       );
     }
     function filterJsxAttributes(symbols2, attributes) {
@@ -159586,7 +159638,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     return checker.getAllPossiblePropertiesOfTypes(filter(type.types, (memberType) => !(memberType.flags & 402784252 /* Primitive */ || checker.isArrayLikeType(memberType) || checker.isTypeInvalidDueToUnionDiscriminant(memberType, node) || checker.typeHasCallOrConstructSignatures(memberType) || memberType.isClass() && containsNonPublicProperties(memberType.getApparentProperties()))));
   }
   function containsNonPublicProperties(props) {
-    return some(props, (p) => !!(getDeclarationModifierFlagsFromSymbol(p) & 24 /* NonPublicAccessibilityModifier */));
+    return some(props, (p) => !!(getDeclarationModifierFlagsFromSymbol(p) & 6 /* NonPublicAccessibilityModifier */));
   }
   function getPropertiesForCompletion(type, checker) {
     return type.isUnion() ? Debug.checkEachDefined(checker.getAllPossiblePropertiesOfTypes(type.types), "getAllPossiblePropertiesOfTypes() should all be defined") : Debug.checkEachDefined(type.getApparentProperties(), "getApparentProperties() should all be defined");
@@ -159746,7 +159798,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     return false;
   }
   function isStaticProperty(symbol) {
-    return !!(symbol.valueDeclaration && getEffectiveModifierFlags(symbol.valueDeclaration) & 32 /* Static */ && isClassLike(symbol.valueDeclaration.parent));
+    return !!(symbol.valueDeclaration && getEffectiveModifierFlags(symbol.valueDeclaration) & 256 /* Static */ && isClassLike(symbol.valueDeclaration.parent));
   }
   function tryGetObjectLiteralContextualType(node, typeChecker) {
     const type = typeChecker.getContextualType(node);
@@ -160957,7 +161009,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
               handleNamespaceImport(
                 direct,
                 direct.name,
-                hasSyntacticModifier(direct, 1 /* Export */),
+                hasSyntacticModifier(direct, 32 /* Export */),
                 /*alreadyAddedDirect*/
                 false
               );
@@ -161272,7 +161324,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         }
       } else {
         const exportNode = getExportNode(parent2, node);
-        if (exportNode && hasSyntacticModifier(exportNode, 1 /* Export */)) {
+        if (exportNode && hasSyntacticModifier(exportNode, 32 /* Export */)) {
           if (isImportEqualsDeclaration(exportNode) && exportNode.moduleReference === node) {
             if (comingFromExport) {
               return void 0;
@@ -161349,7 +161401,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       return exportInfo2 && { kind: 1 /* Export */, symbol: symbol2, exportInfo: exportInfo2 };
     }
     function getExportKindForDeclaration(node2) {
-      return hasSyntacticModifier(node2, 1024 /* Default */) ? 1 /* Default */ : 0 /* Named */;
+      return hasSyntacticModifier(node2, 2048 /* Default */) ? 1 /* Default */ : 0 /* Named */;
     }
   }
   function getExportEqualsLocalSymbol(importedSymbol, checker) {
@@ -161493,7 +161545,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     if (node.parent.name === node || // node is name of declaration, use parent
     isConstructorDeclaration(node.parent) || isExportAssignment(node.parent) || // Property name of the import export specifier or binding pattern, use parent
     (isImportOrExportSpecifier(node.parent) || isBindingElement(node.parent)) && node.parent.propertyName === node || // Is default export
-    node.kind === 90 /* DefaultKeyword */ && hasSyntacticModifier(node.parent, 1025 /* ExportDefault */)) {
+    node.kind === 90 /* DefaultKeyword */ && hasSyntacticModifier(node.parent, 2080 /* ExportDefault */)) {
       return getContextNode(node.parent);
     }
     return void 0;
@@ -162476,7 +162528,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             return void 0;
           }
           if (flags & (4 /* Property */ | 8192 /* Method */)) {
-            const privateDeclaration = find(declarations, (d) => hasEffectiveModifier(d, 8 /* Private */) || isPrivateIdentifierClassElementDeclaration(d));
+            const privateDeclaration = find(declarations, (d) => hasEffectiveModifier(d, 2 /* Private */) || isPrivateIdentifierClassElementDeclaration(d));
             if (privateDeclaration) {
               return getAncestor(privateDeclaration, 263 /* ClassDeclaration */);
             }
@@ -162986,7 +163038,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           if (!searchSpaceNode) {
             return void 0;
           }
-          let staticFlag = 32 /* Static */;
+          let staticFlag = 256 /* Static */;
           switch (searchSpaceNode.kind) {
             case 172 /* PropertyDeclaration */:
             case 171 /* PropertySignature */:
@@ -163026,7 +163078,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             /*includeClassComputedPropertyName*/
             false
           );
-          let staticFlag = 32 /* Static */;
+          let staticFlag = 256 /* Static */;
           switch (searchSpaceNode.kind) {
             case 174 /* MethodDeclaration */:
             case 173 /* MethodSignature */:
@@ -163268,7 +163320,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           if (!symbol.valueDeclaration)
             return false;
           const modifierFlags = getEffectiveModifierFlags(symbol.valueDeclaration);
-          return !!(modifierFlags & 32 /* Static */);
+          return !!(modifierFlags & 256 /* Static */);
         }
         function getRelatedSymbol(search, referenceSymbol, referenceLocation, state) {
           const { checker } = state;
@@ -163824,7 +163876,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       case 177 /* GetAccessor */:
       case 178 /* SetAccessor */:
       case 174 /* MethodDeclaration */:
-        if (hasEffectiveModifier(declaration, 8 /* Private */))
+        if (hasEffectiveModifier(declaration, 2 /* Private */))
           return false;
       case 176 /* Constructor */:
       case 303 /* PropertyAssignment */:
@@ -167024,7 +167076,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
   function getNormalizedSymbolModifiers(symbol) {
     if (symbol.declarations && symbol.declarations.length) {
       const [declaration, ...declarations] = symbol.declarations;
-      const excludeFlags = length(declarations) && isDeprecatedDeclaration(declaration) && some(declarations, (d) => !isDeprecatedDeclaration(d)) ? 8192 /* Deprecated */ : 0 /* None */;
+      const excludeFlags = length(declarations) && isDeprecatedDeclaration(declaration) && some(declarations, (d) => !isDeprecatedDeclaration(d)) ? 65536 /* Deprecated */ : 0 /* None */;
       const modifiers = getNodeModifiers(declaration, excludeFlags);
       if (modifiers) {
         return modifiers.split(",");
@@ -167300,7 +167352,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           const resolvedNode = resolvedSymbol.declarations[0];
           const declarationName = getNameOfDeclaration(resolvedNode);
           if (declarationName && !hasAddedSymbolInfo) {
-            const isExternalModuleDeclaration = isModuleWithStringLiteralName(resolvedNode) && hasSyntacticModifier(resolvedNode, 2 /* Ambient */);
+            const isExternalModuleDeclaration = isModuleWithStringLiteralName(resolvedNode) && hasSyntacticModifier(resolvedNode, 128 /* Ambient */);
             const shouldUseAliasName = symbol.name !== "default" && !isExternalModuleDeclaration;
             const resolvedInfo = getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
               typeChecker,