npm - typescript - Versions diffs - 5.3.0-dev.20231025 → 5.3.0-dev.20231027 - Mend

typescript 5.3.0-dev.20231025 → 5.3.0-dev.20231027

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/lib/tsc.js +493 -412
package/lib/tsserver.js +596 -515
package/lib/typescript.d.ts +26 -25
package/lib/typescript.js +596 -515
package/lib/typingsInstaller.js +111 -86
package/package.json +2 -2

package/lib/tsserver.js CHANGED Viewed

@@ -56,7 +56,7 @@ var init_corePublic = __esm({
   "src/compiler/corePublic.ts"() {
     "use strict";
     versionMajorMinor = "5.3";
-    version = `${versionMajorMinor}.0-dev.20231025`;
+    version = `${versionMajorMinor}.0-dev.20231027`;
     Comparison = /* @__PURE__ */ ((Comparison3) => {
       Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
       Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -3971,32 +3971,43 @@ var init_types = __esm({
     })(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) => {
@@ -7964,7 +7975,7 @@ var init_diagnosticInformationMap_generated = __esm({
       Import_assertion_values_must_be_string_literal_expressions: diag(2837, 1 /* Error */, "Import_assertion_values_must_be_string_literal_expressions_2837", "Import assertion values must be string literal expressions."),
       All_declarations_of_0_must_have_identical_constraints: diag(2838, 1 /* Error */, "All_declarations_of_0_must_have_identical_constraints_2838", "All declarations of '{0}' must have identical constraints."),
       This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value: diag(2839, 1 /* Error */, "This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value_2839", "This condition will always return '{0}' since JavaScript compares objects by reference, not value."),
-      An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_classes: diag(2840, 1 /* Error */, "An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_clas_2840", "An interface cannot extend a primitive type like '{0}'; an interface can only extend named types and classes"),
+      An_interface_cannot_extend_a_primitive_type_like_0_It_can_only_extend_other_named_object_types: diag(2840, 1 /* Error */, "An_interface_cannot_extend_a_primitive_type_like_0_It_can_only_extend_other_named_object_types_2840", "An interface cannot extend a primitive type like '{0}'. It can only extend other named object types."),
       _0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation: diag(2842, 1 /* Error */, "_0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation_2842", "'{0}' is an unused renaming of '{1}'. Did you intend to use it as a type annotation?"),
       We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here: diag(2843, 1 /* Error */, "We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here_2843", "We can only write a type for '{0}' by adding a type for the entire parameter here."),
       Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2844, 1 /* Error */, "Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2844", "Type of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
@@ -7985,6 +7996,8 @@ var init_diagnosticInformationMap_generated = __esm({
       The_left_hand_side_of_an_instanceof_expression_must_be_assignable_to_the_first_argument_of_the_right_hand_side_s_Symbol_hasInstance_method: diag(2860, 1 /* Error */, "The_left_hand_side_of_an_instanceof_expression_must_be_assignable_to_the_first_argument_of_the_right_2860", "The left-hand side of an 'instanceof' expression must be assignable to the first argument of the right-hand side's '[Symbol.hasInstance]' method."),
       An_object_s_Symbol_hasInstance_method_must_return_a_boolean_value_for_it_to_be_used_on_the_right_hand_side_of_an_instanceof_expression: diag(2861, 1 /* Error */, "An_object_s_Symbol_hasInstance_method_must_return_a_boolean_value_for_it_to_be_used_on_the_right_han_2861", "An object's '[Symbol.hasInstance]' method must return a boolean value for it to be used on the right-hand side of an 'instanceof' expression."),
       Type_0_is_generic_and_can_only_be_indexed_for_reading: diag(2862, 1 /* Error */, "Type_0_is_generic_and_can_only_be_indexed_for_reading_2862", "Type '{0}' is generic and can only be indexed for reading."),
+      A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values: diag(2863, 1 /* Error */, "A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values_2863", "A class cannot extend a primitive type like '{0}'. Classes can only extend constructable values."),
+      A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types: diag(2864, 1 /* Error */, "A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types_2864", "A class cannot implement a primitive type like '{0}'. It can only implement other named object types."),
       Import_declaration_0_is_using_private_name_1: diag(4e3, 1 /* Error */, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
       Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, 1 /* Error */, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
       Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, 1 /* Error */, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -11497,7 +11510,7 @@ function getTypeParameterOwner(d) {
   }
 }
 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 +11799,7 @@ function getDecorators(node) {
   }
 }
 function getModifiers(node) {
-  if (hasSyntacticModifier(node, 126975 /* Modifier */)) {
+  if (hasSyntacticModifier(node, 98303 /* Modifier */)) {
     return filter(node.modifiers, isModifier);
   }
 }
@@ -12220,7 +12233,7 @@ function isModifierKind(token) {
   return false;
 }
 function isParameterPropertyModifier(kind) {
-  return !!(modifierToFlag(kind) & 16476 /* ParameterPropertyModifier */);
+  return !!(modifierToFlag(kind) & 31 /* ParameterPropertyModifier */);
 }
 function isClassMemberModifier(idToken) {
   return isParameterPropertyModifier(idToken) || idToken === 126 /* StaticKeyword */ || idToken === 164 /* OverrideKeyword */ || idToken === 129 /* AccessorKeyword */;
@@ -12584,10 +12597,10 @@ function hasScopeMarker(statements) {
   return some(statements, isScopeMarker);
 }
 function needsScopeMarker(result) {
-  return !isAnyImportOrReExport(result) && !isExportAssignment(result) && !hasSyntacticModifier(result, 1 /* Export */) && !isAmbientModule(result);
+  return !isAnyImportOrReExport(result) && !isExportAssignment(result) && !hasSyntacticModifier(result, 32 /* Export */) && !isAmbientModule(result);
 }
 function isExternalModuleIndicator(result) {
-  return isAnyImportOrReExport(result) || isExportAssignment(result) || hasSyntacticModifier(result, 1 /* Export */);
+  return isAnyImportOrReExport(result) || isExportAssignment(result) || hasSyntacticModifier(result, 32 /* Export */);
 }
 function isForInOrOfStatement(node) {
   return node.kind === 249 /* ForInStatement */ || node.kind === 250 /* ForOfStatement */;
@@ -13463,7 +13476,7 @@ function isEffectiveStrictModeSourceFile(node, compilerOptions) {
   return false;
 }
 function isAmbientPropertyDeclaration(node) {
-  return !!(node.flags & 33554432 /* Ambient */) || hasSyntacticModifier(node, 2 /* Ambient */);
+  return !!(node.flags & 33554432 /* Ambient */) || hasSyntacticModifier(node, 128 /* Ambient */);
 }
 function isBlockScope(node, parentNode) {
   switch (node.kind) {
@@ -13816,10 +13829,10 @@ function isJsonSourceFile(file) {
   return file.scriptKind === 6 /* JSON */;
 }
 function isEnumConst(node) {
-  return !!(getCombinedModifierFlags(node) & 2048 /* Const */);
+  return !!(getCombinedModifierFlags(node) & 4096 /* Const */);
 }
 function isDeclarationReadonly(declaration) {
-  return !!(getCombinedModifierFlags(declaration) & 64 /* Readonly */ && !isParameterPropertyDeclaration(declaration, declaration.parent));
+  return !!(getCombinedModifierFlags(declaration) & 8 /* Readonly */ && !isParameterPropertyDeclaration(declaration, declaration.parent));
 }
 function isVarAwaitUsing(node) {
   return (getCombinedNodeFlags(node) & 7 /* BlockScoped */) === 6 /* AwaitUsing */;
@@ -15548,7 +15561,7 @@ function getFunctionFlags(node) {
         flags |= 1 /* Generator */;
       }
     case 219 /* ArrowFunction */:
-      if (hasSyntacticModifier(node, 512 /* Async */)) {
+      if (hasSyntacticModifier(node, 1024 /* Async */)) {
         flags |= 2 /* Async */;
       }
       break;
@@ -15564,7 +15577,7 @@ function isAsyncFunction(node) {
     case 218 /* FunctionExpression */:
     case 219 /* ArrowFunction */:
     case 174 /* MethodDeclaration */:
-      return node.body !== void 0 && node.asteriskToken === void 0 && hasSyntacticModifier(node, 512 /* Async */);
+      return node.body !== void 0 && node.asteriskToken === void 0 && hasSyntacticModifier(node, 1024 /* Async */);
   }
   return false;
 }
@@ -16663,25 +16676,25 @@ function isStatic(node) {
   return isClassElement(node) && hasStaticModifier(node) || isClassStaticBlockDeclaration(node);
 }
 function hasStaticModifier(node) {
-  return hasSyntacticModifier(node, 32 /* Static */);
+  return hasSyntacticModifier(node, 256 /* Static */);
 }
 function hasOverrideModifier(node) {
-  return hasEffectiveModifier(node, 16384 /* Override */);
+  return hasEffectiveModifier(node, 16 /* Override */);
 }
 function hasAbstractModifier(node) {
-  return hasSyntacticModifier(node, 256 /* Abstract */);
+  return hasSyntacticModifier(node, 64 /* Abstract */);
 }
 function hasAmbientModifier(node) {
-  return hasSyntacticModifier(node, 2 /* Ambient */);
+  return hasSyntacticModifier(node, 128 /* Ambient */);
 }
 function hasAccessorModifier(node) {
-  return hasSyntacticModifier(node, 128 /* Accessor */);
+  return hasSyntacticModifier(node, 512 /* Accessor */);
 }
 function hasEffectiveReadonlyModifier(node) {
-  return hasEffectiveModifier(node, 64 /* Readonly */);
+  return hasEffectiveModifier(node, 8 /* Readonly */);
 }
 function hasDecorators(node) {
-  return hasSyntacticModifier(node, 131072 /* Decorator */);
+  return hasSyntacticModifier(node, 32768 /* Decorator */);
 }
 function getSelectedEffectiveModifierFlags(node, flags) {
   return getEffectiveModifierFlags(node) & flags;
@@ -16696,10 +16709,13 @@ function getModifierFlagsWorker(node, includeJSDoc, alwaysIncludeJSDoc) {
   if (!(node.modifierFlagsCache & 536870912 /* HasComputedFlags */)) {
     node.modifierFlagsCache = getSyntacticModifierFlagsNoCache(node) | 536870912 /* HasComputedFlags */;
   }
-  if (includeJSDoc && !(node.modifierFlagsCache & 4096 /* HasComputedJSDocModifiers */) && (alwaysIncludeJSDoc || isInJSFile(node)) && node.parent) {
-    node.modifierFlagsCache |= getJSDocModifierFlagsNoCache(node) | 4096 /* HasComputedJSDocModifiers */;
+  if (alwaysIncludeJSDoc || includeJSDoc && isInJSFile(node)) {
+    if (!(node.modifierFlagsCache & 268435456 /* HasComputedJSDocModifiers */) && node.parent) {
+      node.modifierFlagsCache |= getRawJSDocModifierFlagsNoCache(node) | 268435456 /* HasComputedJSDocModifiers */;
+    }
+    return selectEffectiveModifierFlags(node.modifierFlagsCache);
   }
-  return node.modifierFlagsCache & ~(536870912 /* HasComputedFlags */ | 4096 /* HasComputedJSDocModifiers */);
+  return selectSyntacticModifierFlags(node.modifierFlagsCache);
 }
 function getEffectiveModifierFlags(node) {
   return getModifierFlagsWorker(
@@ -16724,33 +16740,42 @@ function getSyntacticModifierFlags(node) {
     false
   );
 }
-function getJSDocModifierFlagsNoCache(node) {
+function getRawJSDocModifierFlagsNoCache(node) {
   let flags = 0 /* None */;
   if (!!node.parent && !isParameter(node)) {
     if (isInJSFile(node)) {
       if (getJSDocPublicTagNoCache(node))
-        flags |= 4 /* Public */;
+        flags |= 8388608 /* JSDocPublic */;
       if (getJSDocPrivateTagNoCache(node))
-        flags |= 8 /* Private */;
+        flags |= 16777216 /* JSDocPrivate */;
       if (getJSDocProtectedTagNoCache(node))
-        flags |= 16 /* Protected */;
+        flags |= 33554432 /* JSDocProtected */;
       if (getJSDocReadonlyTagNoCache(node))
-        flags |= 64 /* Readonly */;
+        flags |= 67108864 /* JSDocReadonly */;
       if (getJSDocOverrideTagNoCache(node))
-        flags |= 16384 /* Override */;
+        flags |= 134217728 /* JSDocOverride */;
     }
     if (getJSDocDeprecatedTagNoCache(node))
-      flags |= 8192 /* Deprecated */;
+      flags |= 65536 /* Deprecated */;
   }
   return flags;
 }
+function selectSyntacticModifierFlags(flags) {
+  return flags & 65535 /* SyntacticModifiers */;
+}
+function selectEffectiveModifierFlags(flags) {
+  return flags & 131071 /* NonCacheOnlyModifiers */ | (flags & 260046848 /* JSDocCacheOnlyModifiers */) >>> 23;
+}
+function getJSDocModifierFlagsNoCache(node) {
+  return selectEffectiveModifierFlags(getRawJSDocModifierFlagsNoCache(node));
+}
 function getEffectiveModifierFlagsNoCache(node) {
   return getSyntacticModifierFlagsNoCache(node) | getJSDocModifierFlagsNoCache(node);
 }
 function getSyntacticModifierFlagsNoCache(node) {
   let flags = canHaveModifiers(node) ? modifiersToFlags(node.modifiers) : 0 /* None */;
   if (node.flags & 8 /* NestedNamespace */ || node.kind === 80 /* Identifier */ && node.flags & 4096 /* IdentifierIsInJSDocNamespace */) {
-    flags |= 1 /* Export */;
+    flags |= 32 /* Export */;
   }
   return flags;
 }
@@ -16766,37 +16791,37 @@ function modifiersToFlags(modifiers) {
 function modifierToFlag(token) {
   switch (token) {
     case 126 /* StaticKeyword */:
-      return 32 /* Static */;
+      return 256 /* Static */;
     case 125 /* PublicKeyword */:
-      return 4 /* Public */;
+      return 1 /* Public */;
     case 124 /* ProtectedKeyword */:
-      return 16 /* Protected */;
+      return 4 /* Protected */;
     case 123 /* PrivateKeyword */:
-      return 8 /* Private */;
+      return 2 /* Private */;
     case 128 /* AbstractKeyword */:
-      return 256 /* Abstract */;
+      return 64 /* Abstract */;
     case 129 /* AccessorKeyword */:
-      return 128 /* Accessor */;
+      return 512 /* Accessor */;
     case 95 /* ExportKeyword */:
-      return 1 /* Export */;
+      return 32 /* Export */;
     case 138 /* DeclareKeyword */:
-      return 2 /* Ambient */;
+      return 128 /* Ambient */;
     case 87 /* ConstKeyword */:
-      return 2048 /* Const */;
+      return 4096 /* Const */;
     case 90 /* DefaultKeyword */:
-      return 1024 /* Default */;
+      return 2048 /* Default */;
     case 134 /* AsyncKeyword */:
-      return 512 /* Async */;
+      return 1024 /* Async */;
     case 148 /* ReadonlyKeyword */:
-      return 64 /* Readonly */;
+      return 8 /* Readonly */;
     case 164 /* OverrideKeyword */:
-      return 16384 /* Override */;
+      return 16 /* Override */;
     case 103 /* InKeyword */:
-      return 32768 /* In */;
+      return 8192 /* In */;
     case 147 /* OutKeyword */:
-      return 65536 /* Out */;
+      return 16384 /* Out */;
     case 170 /* Decorator */:
-      return 131072 /* Decorator */;
+      return 32768 /* Decorator */;
   }
   return 0 /* None */;
 }
@@ -16936,7 +16961,7 @@ function getLocalSymbolForExportDefault(symbol) {
   return void 0;
 }
 function isExportDefaultSymbol(symbol) {
-  return symbol && length(symbol.declarations) > 0 && hasSyntacticModifier(symbol.declarations[0], 1024 /* Default */);
+  return symbol && length(symbol.declarations) > 0 && hasSyntacticModifier(symbol.declarations[0], 2048 /* Default */);
 }
 function tryExtractTSExtension(fileName) {
   return find(supportedTSExtensionsForExtractExtension, (extension) => fileExtensionIs(fileName, extension));
@@ -17216,16 +17241,16 @@ function getDeclarationModifierFlagsFromSymbol(s, isWrite = false) {
   if (s.valueDeclaration) {
     const declaration = isWrite && s.declarations && find(s.declarations, isSetAccessorDeclaration) || s.flags & 32768 /* GetAccessor */ && find(s.declarations, isGetAccessorDeclaration) || s.valueDeclaration;
     const flags = getCombinedModifierFlags(declaration);
-    return s.parent && s.parent.flags & 32 /* Class */ ? flags : flags & ~28 /* AccessibilityModifier */;
+    return s.parent && s.parent.flags & 32 /* Class */ ? flags : flags & ~7 /* AccessibilityModifier */;
   }
   if (getCheckFlags(s) & 6 /* Synthetic */) {
     const checkFlags = s.links.checkFlags;
-    const accessModifier = checkFlags & 1024 /* ContainsPrivate */ ? 8 /* Private */ : checkFlags & 256 /* ContainsPublic */ ? 4 /* Public */ : 16 /* Protected */;
-    const staticModifier = checkFlags & 2048 /* ContainsStatic */ ? 32 /* Static */ : 0;
+    const accessModifier = checkFlags & 1024 /* ContainsPrivate */ ? 2 /* Private */ : checkFlags & 256 /* ContainsPublic */ ? 1 /* Public */ : 4 /* Protected */;
+    const staticModifier = checkFlags & 2048 /* ContainsStatic */ ? 256 /* Static */ : 0;
     return accessModifier | staticModifier;
   }
   if (s.flags & 4194304 /* Prototype */) {
-    return 4 /* Public */ | 32 /* Static */;
+    return 1 /* Public */ | 256 /* Static */;
   }
   return 0;
 }
@@ -17324,7 +17349,7 @@ function mutateMap(map2, newMap, options) {
 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 +18569,7 @@ function isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(node) {
   if (node.kind !== 167 /* ComputedPropertyName */) {
     return false;
   }
-  if (hasSyntacticModifier(node.parent, 256 /* Abstract */)) {
+  if (hasSyntacticModifier(node.parent, 64 /* Abstract */)) {
     return true;
   }
   const containerKind = node.parent.parent.kind;
@@ -21127,35 +21152,35 @@ function createNodeFactory(flags, baseFactory2) {
   }
   function createModifiersFromModifierFlags(flags2) {
     const result = [];
-    if (flags2 & 1 /* Export */)
+    if (flags2 & 32 /* Export */)
       result.push(createModifier(95 /* ExportKeyword */));
-    if (flags2 & 2 /* Ambient */)
+    if (flags2 & 128 /* Ambient */)
       result.push(createModifier(138 /* DeclareKeyword */));
-    if (flags2 & 1024 /* Default */)
+    if (flags2 & 2048 /* Default */)
       result.push(createModifier(90 /* DefaultKeyword */));
-    if (flags2 & 2048 /* Const */)
+    if (flags2 & 4096 /* Const */)
       result.push(createModifier(87 /* ConstKeyword */));
-    if (flags2 & 4 /* Public */)
+    if (flags2 & 1 /* Public */)
       result.push(createModifier(125 /* PublicKeyword */));
-    if (flags2 & 8 /* Private */)
+    if (flags2 & 2 /* Private */)
       result.push(createModifier(123 /* PrivateKeyword */));
-    if (flags2 & 16 /* Protected */)
+    if (flags2 & 4 /* Protected */)
       result.push(createModifier(124 /* ProtectedKeyword */));
-    if (flags2 & 256 /* Abstract */)
+    if (flags2 & 64 /* Abstract */)
       result.push(createModifier(128 /* AbstractKeyword */));
-    if (flags2 & 32 /* Static */)
+    if (flags2 & 256 /* Static */)
       result.push(createModifier(126 /* StaticKeyword */));
-    if (flags2 & 16384 /* Override */)
+    if (flags2 & 16 /* Override */)
       result.push(createModifier(164 /* OverrideKeyword */));
-    if (flags2 & 64 /* Readonly */)
+    if (flags2 & 8 /* Readonly */)
       result.push(createModifier(148 /* ReadonlyKeyword */));
-    if (flags2 & 128 /* Accessor */)
+    if (flags2 & 512 /* Accessor */)
       result.push(createModifier(129 /* AccessorKeyword */));
-    if (flags2 & 512 /* Async */)
+    if (flags2 & 1024 /* Async */)
       result.push(createModifier(134 /* AsyncKeyword */));
-    if (flags2 & 32768 /* In */)
+    if (flags2 & 8192 /* In */)
       result.push(createModifier(103 /* InKeyword */));
-    if (flags2 & 65536 /* Out */)
+    if (flags2 & 16384 /* Out */)
       result.push(createModifier(147 /* OutKeyword */));
     return result.length ? result : void 0;
   }
@@ -21204,7 +21229,7 @@ function createNodeFactory(flags, baseFactory2) {
     if (isThisIdentifier(node.name)) {
       node.transformFlags = 1 /* ContainsTypeScript */;
     } else {
-      node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.dotDotDotToken) | propagateNameFlags(node.name) | propagateChildFlags(node.questionToken) | propagateChildFlags(node.initializer) | (node.questionToken ?? node.type ? 1 /* ContainsTypeScript */ : 0 /* None */) | (node.dotDotDotToken ?? node.initializer ? 1024 /* ContainsES2015 */ : 0 /* None */) | (modifiersToFlags(node.modifiers) & 16476 /* ParameterPropertyModifier */ ? 8192 /* ContainsTypeScriptClassSyntax */ : 0 /* None */);
+      node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.dotDotDotToken) | propagateNameFlags(node.name) | propagateChildFlags(node.questionToken) | propagateChildFlags(node.initializer) | (node.questionToken ?? node.type ? 1 /* ContainsTypeScript */ : 0 /* None */) | (node.dotDotDotToken ?? node.initializer ? 1024 /* ContainsES2015 */ : 0 /* None */) | (modifiersToFlags(node.modifiers) & 31 /* ParameterPropertyModifier */ ? 8192 /* ContainsTypeScriptClassSyntax */ : 0 /* None */);
     }
     node.jsDoc = void 0;
     return node;
@@ -21253,8 +21278,8 @@ function createNodeFactory(flags, baseFactory2) {
     node.exclamationToken = questionOrExclamationToken && isExclamationToken(questionOrExclamationToken) ? questionOrExclamationToken : void 0;
     node.type = type;
     node.initializer = asInitializer(initializer);
-    const isAmbient = node.flags & 33554432 /* Ambient */ || modifiersToFlags(node.modifiers) & 2 /* Ambient */;
-    node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateNameFlags(node.name) | propagateChildFlags(node.initializer) | (isAmbient || node.questionToken || node.exclamationToken || node.type ? 1 /* ContainsTypeScript */ : 0 /* None */) | (isComputedPropertyName(node.name) || modifiersToFlags(node.modifiers) & 32 /* Static */ && node.initializer ? 8192 /* ContainsTypeScriptClassSyntax */ : 0 /* None */) | 16777216 /* ContainsClassFields */;
+    const isAmbient = node.flags & 33554432 /* Ambient */ || modifiersToFlags(node.modifiers) & 128 /* Ambient */;
+    node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateNameFlags(node.name) | propagateChildFlags(node.initializer) | (isAmbient || node.questionToken || node.exclamationToken || node.type ? 1 /* ContainsTypeScript */ : 0 /* None */) | (isComputedPropertyName(node.name) || modifiersToFlags(node.modifiers) & 256 /* Static */ && node.initializer ? 8192 /* ContainsTypeScriptClassSyntax */ : 0 /* None */) | 16777216 /* ContainsClassFields */;
     node.jsDoc = void 0;
     return node;
   }
@@ -21293,7 +21318,7 @@ function createNodeFactory(flags, baseFactory2) {
     if (!node.body) {
       node.transformFlags = 1 /* ContainsTypeScript */;
     } else {
-      const isAsync = modifiersToFlags(node.modifiers) & 512 /* Async */;
+      const isAsync = modifiersToFlags(node.modifiers) & 1024 /* Async */;
       const isGenerator = !!node.asteriskToken;
       const isAsyncGenerator = isAsync && isGenerator;
       node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.asteriskToken) | propagateNameFlags(node.name) | propagateChildFlags(node.questionToken) | propagateChildrenFlags(node.typeParameters) | propagateChildrenFlags(node.parameters) | propagateChildFlags(node.type) | propagateChildFlags(node.body) & ~67108864 /* ContainsPossibleTopLevelAwait */ | (isAsyncGenerator ? 128 /* ContainsES2018 */ : isAsync ? 256 /* ContainsES2017 */ : isGenerator ? 2048 /* ContainsGenerator */ : 0 /* None */) | (node.questionToken || node.typeParameters || node.type ? 1 /* ContainsTypeScript */ : 0 /* None */) | 1024 /* ContainsES2015 */;
@@ -22036,7 +22061,7 @@ function createNodeFactory(flags, baseFactory2) {
     node.parameters = createNodeArray(parameters);
     node.type = type;
     node.body = body;
-    const isAsync = modifiersToFlags(node.modifiers) & 512 /* Async */;
+    const isAsync = modifiersToFlags(node.modifiers) & 1024 /* Async */;
     const isGenerator = !!node.asteriskToken;
     const isAsyncGenerator = isAsync && isGenerator;
     node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.asteriskToken) | propagateNameFlags(node.name) | propagateChildrenFlags(node.typeParameters) | propagateChildrenFlags(node.parameters) | propagateChildFlags(node.type) | propagateChildFlags(node.body) & ~67108864 /* ContainsPossibleTopLevelAwait */ | (isAsyncGenerator ? 128 /* ContainsES2018 */ : isAsync ? 256 /* ContainsES2017 */ : isGenerator ? 2048 /* ContainsGenerator */ : 0 /* None */) | (node.typeParameters || node.type ? 1 /* ContainsTypeScript */ : 0 /* None */) | 4194304 /* ContainsHoistedDeclarationOrCompletion */;
@@ -22060,7 +22085,7 @@ function createNodeFactory(flags, baseFactory2) {
     node.type = type;
     node.equalsGreaterThanToken = equalsGreaterThanToken ?? createToken(39 /* EqualsGreaterThanToken */);
     node.body = parenthesizerRules().parenthesizeConciseBodyOfArrowFunction(body);
-    const isAsync = modifiersToFlags(node.modifiers) & 512 /* Async */;
+    const isAsync = modifiersToFlags(node.modifiers) & 1024 /* Async */;
     node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildrenFlags(node.typeParameters) | propagateChildrenFlags(node.parameters) | propagateChildFlags(node.type) | propagateChildFlags(node.equalsGreaterThanToken) | propagateChildFlags(node.body) & ~67108864 /* ContainsPossibleTopLevelAwait */ | (node.typeParameters || node.type ? 1 /* ContainsTypeScript */ : 0 /* None */) | (isAsync ? 256 /* ContainsES2017 */ | 16384 /* ContainsLexicalThis */ : 0 /* None */) | 1024 /* ContainsES2015 */;
     node.typeArguments = void 0;
     node.jsDoc = void 0;
@@ -22412,7 +22437,7 @@ function createNodeFactory(flags, baseFactory2) {
     node.modifiers = asNodeArray(modifiers);
     node.declarationList = isArray(declarationList) ? createVariableDeclarationList(declarationList) : declarationList;
     node.transformFlags |= propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.declarationList);
-    if (modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
+    if (modifiersToFlags(node.modifiers) & 128 /* Ambient */) {
       node.transformFlags = 1 /* ContainsTypeScript */;
     }
     node.jsDoc = void 0;
@@ -22662,10 +22687,10 @@ function createNodeFactory(flags, baseFactory2) {
     node.parameters = createNodeArray(parameters);
     node.type = type;
     node.body = body;
-    if (!node.body || modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
+    if (!node.body || modifiersToFlags(node.modifiers) & 128 /* Ambient */) {
       node.transformFlags = 1 /* ContainsTypeScript */;
     } else {
-      const isAsync = modifiersToFlags(node.modifiers) & 512 /* Async */;
+      const isAsync = modifiersToFlags(node.modifiers) & 1024 /* Async */;
       const isGenerator = !!node.asteriskToken;
       const isAsyncGenerator = isAsync && isGenerator;
       node.transformFlags = propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.asteriskToken) | propagateNameFlags(node.name) | propagateChildrenFlags(node.typeParameters) | propagateChildrenFlags(node.parameters) | propagateChildFlags(node.type) | propagateChildFlags(node.body) & ~67108864 /* ContainsPossibleTopLevelAwait */ | (isAsyncGenerator ? 128 /* ContainsES2018 */ : isAsync ? 256 /* ContainsES2017 */ : isGenerator ? 2048 /* ContainsGenerator */ : 0 /* None */) | (node.typeParameters || node.type ? 1 /* ContainsTypeScript */ : 0 /* None */) | 4194304 /* ContainsHoistedDeclarationOrCompletion */;
@@ -22696,7 +22721,7 @@ function createNodeFactory(flags, baseFactory2) {
     node.typeParameters = asNodeArray(typeParameters);
     node.heritageClauses = asNodeArray(heritageClauses);
     node.members = createNodeArray(members);
-    if (modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
+    if (modifiersToFlags(node.modifiers) & 128 /* Ambient */) {
       node.transformFlags = 1 /* ContainsTypeScript */;
     } else {
       node.transformFlags |= propagateChildrenFlags(node.modifiers) | propagateNameFlags(node.name) | propagateChildrenFlags(node.typeParameters) | propagateChildrenFlags(node.heritageClauses) | propagateChildrenFlags(node.members) | (node.typeParameters ? 1 /* ContainsTypeScript */ : 0 /* None */) | 1024 /* ContainsES2015 */;
@@ -22758,7 +22783,7 @@ function createNodeFactory(flags, baseFactory2) {
     node.flags |= flags2 & (32 /* Namespace */ | 8 /* NestedNamespace */ | 2048 /* GlobalAugmentation */);
     node.name = name;
     node.body = body;
-    if (modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
+    if (modifiersToFlags(node.modifiers) & 128 /* Ambient */) {
       node.transformFlags = 1 /* ContainsTypeScript */;
     } else {
       node.transformFlags |= propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.name) | propagateChildFlags(node.body) | 1 /* ContainsTypeScript */;
@@ -24189,7 +24214,7 @@ function createNodeFactory(flags, baseFactory2) {
     return qualifiedName;
   }
   function getExternalModuleOrNamespaceExportName(ns, node, allowComments, allowSourceMaps) {
-    if (ns && hasSyntacticModifier(node, 1 /* Export */)) {
+    if (ns && hasSyntacticModifier(node, 32 /* Export */)) {
       return getNamespaceMemberName(ns, getName(node), allowComments, allowSourceMaps);
     }
     return getExportName(node, allowComments, allowSourceMaps);
@@ -33844,11 +33869,11 @@ var init_parser = __esm({
         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 +41937,7 @@ function getModuleInstanceStateWorker(node, visited) {
       break;
     case 272 /* ImportDeclaration */:
     case 271 /* ImportEqualsDeclaration */:
-      if (!hasSyntacticModifier(node, 1 /* Export */)) {
+      if (!hasSyntacticModifier(node, 32 /* Export */)) {
         return 0 /* NonInstantiated */;
       }
       break;
@@ -42189,7 +42214,7 @@ function createBinder() {
   }
   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 +42258,7 @@ function createBinder() {
             }
           }
           const relatedInformation = [];
-          if (isTypeAliasDeclaration(node) && nodeIsMissing(node.type) && hasSyntacticModifier(node, 1 /* Export */) && symbol.flags & (2097152 /* Alias */ | 788968 /* Type */ | 1920 /* Namespace */)) {
+          if (isTypeAliasDeclaration(node) && nodeIsMissing(node.type) && hasSyntacticModifier(node, 32 /* Export */) && symbol.flags & (2097152 /* Alias */ | 788968 /* Type */ | 1920 /* Namespace */)) {
             relatedInformation.push(createDiagnosticForNode2(node, Diagnostics.Did_you_mean_0, `export type { ${unescapeLeadingUnderscores(node.name.escapedText)} }`));
           }
           const declarationName = getNameOfDeclaration(node) || node;
@@ -42262,7 +42287,7 @@ function createBinder() {
     return symbol;
   }
   function declareModuleMember(node, symbolFlags, symbolExcludes) {
-    const hasExportModifier = !!(getCombinedModifierFlags(node) & 1 /* Export */) || jsdocTreatAsExported(node);
+    const hasExportModifier = !!(getCombinedModifierFlags(node) & 32 /* Export */) || jsdocTreatAsExported(node);
     if (symbolFlags & 2097152 /* Alias */) {
       if (node.kind === 281 /* ExportSpecifier */ || node.kind === 271 /* ImportEqualsDeclaration */ && hasExportModifier) {
         return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
@@ -42281,7 +42306,7 @@ function createBinder() {
       if (isJSDocTypeAlias(node))
         Debug.assert(isInJSFile(node));
       if (!isAmbientModule(node) && (hasExportModifier || container.flags & 128 /* ExportContext */)) {
-        if (!canHaveLocals(container) || !container.locals || hasSyntacticModifier(node, 1024 /* Default */) && !getDeclarationName(node)) {
+        if (!canHaveLocals(container) || !container.locals || hasSyntacticModifier(node, 2048 /* Default */) && !getDeclarationName(node)) {
           return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
         }
         const exportKind = symbolFlags & 111551 /* Value */ ? 1048576 /* ExportValue */ : 0;
@@ -42322,7 +42347,7 @@ function createBinder() {
       return false;
     if (isPropertyAccessEntityNameExpression(declName.parent) && isTopLevelNamespaceAssignment(declName.parent))
       return true;
-    if (isDeclaration(declName.parent) && getCombinedModifierFlags(declName.parent) & 1 /* Export */)
+    if (isDeclaration(declName.parent) && getCombinedModifierFlags(declName.parent) & 32 /* Export */)
       return true;
     return false;
   }
@@ -42353,7 +42378,7 @@ function createBinder() {
       const saveExceptionTarget = currentExceptionTarget;
       const saveActiveLabelList = activeLabelList;
       const saveHasExplicitReturn = hasExplicitReturn;
-      const isImmediatelyInvoked = containerFlags & 16 /* IsFunctionExpression */ && !hasSyntacticModifier(node, 512 /* Async */) && !node.asteriskToken && !!getImmediatelyInvokedFunctionExpression(node) || node.kind === 175 /* ClassStaticBlockDeclaration */;
+      const isImmediatelyInvoked = containerFlags & 16 /* IsFunctionExpression */ && !hasSyntacticModifier(node, 1024 /* Async */) && !node.asteriskToken && !!getImmediatelyInvokedFunctionExpression(node) || node.kind === 175 /* ClassStaticBlockDeclaration */;
       if (!isImmediatelyInvoked) {
         currentFlow = initFlowNode({ flags: 2 /* Start */ });
         if (containerFlags & (16 /* IsFunctionExpression */ | 128 /* IsObjectLiteralOrClassExpressionMethodOrAccessor */)) {
@@ -43400,7 +43425,7 @@ function createBinder() {
   function bindModuleDeclaration(node) {
     setExportContextFlag(node);
     if (isAmbientModule(node)) {
-      if (hasSyntacticModifier(node, 1 /* Export */)) {
+      if (hasSyntacticModifier(node, 32 /* Export */)) {
         errorOnFirstToken(node, Diagnostics.export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible);
       }
       if (isModuleAugmentationExternal(node)) {
@@ -44461,7 +44486,7 @@ function createBinder() {
     }
     if (!isBindingPattern(node.name)) {
       const possibleVariableDecl = node.kind === 260 /* VariableDeclaration */ ? node : node.parent.parent;
-      if (isInJSFile(node) && shouldResolveJsRequire(options) && isVariableDeclarationInitializedToBareOrAccessedRequire(possibleVariableDecl) && !getJSDocTypeTag(node) && !(getCombinedModifierFlags(node) & 1 /* Export */)) {
+      if (isInJSFile(node) && shouldResolveJsRequire(options) && isVariableDeclarationInitializedToBareOrAccessedRequire(possibleVariableDecl) && !getJSDocTypeTag(node) && !(getCombinedModifierFlags(node) & 32 /* Export */)) {
         declareSymbolAndAddToSymbolTable(node, 2097152 /* Alias */, 2097152 /* AliasExcludes */);
       } else if (isBlockOrCatchScoped(node)) {
         bindBlockScopedDeclaration(node, 2 /* BlockScopedVariable */, 111551 /* BlockScopedVariableExcludes */);
@@ -44613,7 +44638,7 @@ function isPurelyTypeDeclaration(s) {
     case 267 /* ModuleDeclaration */:
       return getModuleInstanceState(s) !== 1 /* Instantiated */;
     case 266 /* EnumDeclaration */:
-      return hasSyntacticModifier(s, 2048 /* Const */);
+      return hasSyntacticModifier(s, 4096 /* Const */);
     default:
       return false;
   }
@@ -47684,7 +47709,7 @@ function createTypeChecker(host) {
     if (lastLocation && lastLocation === location.name) {
       return false;
     }
-    if (location.asteriskToken || hasSyntacticModifier(location, 512 /* Async */)) {
+    if (location.asteriskToken || hasSyntacticModifier(location, 1024 /* Async */)) {
       return true;
     }
     return !getImmediatelyInvokedFunctionExpression(location);
@@ -47848,8 +47873,17 @@ function createTypeChecker(host) {
   function checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) {
     if (meaning & 111551 /* Value */) {
       if (isPrimitiveTypeName(name)) {
-        if (isExtendedByInterface(errorLocation)) {
-          error2(errorLocation, Diagnostics.An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_classes, unescapeLeadingUnderscores(name));
+        const grandparent = errorLocation.parent.parent;
+        if (grandparent && grandparent.parent && isHeritageClause(grandparent)) {
+          const heritageKind = grandparent.token;
+          const containerKind = grandparent.parent.kind;
+          if (containerKind === 264 /* InterfaceDeclaration */ && heritageKind === 96 /* ExtendsKeyword */) {
+            error2(errorLocation, Diagnostics.An_interface_cannot_extend_a_primitive_type_like_0_It_can_only_extend_other_named_object_types, unescapeLeadingUnderscores(name));
+          } else if (containerKind === 263 /* ClassDeclaration */ && heritageKind === 96 /* ExtendsKeyword */) {
+            error2(errorLocation, Diagnostics.A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values, unescapeLeadingUnderscores(name));
+          } else if (containerKind === 263 /* ClassDeclaration */ && heritageKind === 119 /* ImplementsKeyword */) {
+            error2(errorLocation, Diagnostics.A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types, unescapeLeadingUnderscores(name));
+          }
         } else {
           error2(errorLocation, Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, unescapeLeadingUnderscores(name));
         }
@@ -47881,16 +47915,6 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function isExtendedByInterface(node) {
-    const grandparent = node.parent.parent;
-    const parentOfGrandparent = grandparent.parent;
-    if (grandparent && parentOfGrandparent) {
-      const isExtending = isHeritageClause(grandparent) && grandparent.token === 96 /* ExtendsKeyword */;
-      const isInterface = isInterfaceDeclaration(parentOfGrandparent);
-      return isExtending && isInterface;
-    }
-    return false;
-  }
   function maybeMappedType(node, symbol) {
     const container = findAncestor(node.parent, (n) => isComputedPropertyName(n) || isPropertySignature(n) ? false : isTypeLiteralNode(n) || "quit");
     if (container && container.members.length === 1) {
@@ -48069,7 +48093,7 @@ function createTypeChecker(host) {
     return resolved;
   }
   function isSyntacticDefault(node) {
-    return isExportAssignment(node) && !node.isExportEquals || hasSyntacticModifier(node, 1024 /* Default */) || isExportSpecifier(node) || isNamespaceExport(node);
+    return isExportAssignment(node) && !node.isExportEquals || hasSyntacticModifier(node, 2048 /* Default */) || isExportSpecifier(node) || isNamespaceExport(node);
   }
   function getUsageModeForExpression(usage) {
     return isStringLiteralLike(usage) ? getModeForUsageLocation(getSourceFileOfNode(usage), usage) : void 0;
@@ -49995,20 +50019,20 @@ function createTypeChecker(host) {
       var _a, _b;
       if (!isDeclarationVisible(declaration)) {
         const anyImportSyntax = getAnyImportSyntax(declaration);
-        if (anyImportSyntax && !hasSyntacticModifier(anyImportSyntax, 1 /* Export */) && // import clause without export
+        if (anyImportSyntax && !hasSyntacticModifier(anyImportSyntax, 32 /* Export */) && // import clause without export
         isDeclarationVisible(anyImportSyntax.parent)) {
           return addVisibleAlias(declaration, anyImportSyntax);
-        } else if (isVariableDeclaration(declaration) && isVariableStatement(declaration.parent.parent) && !hasSyntacticModifier(declaration.parent.parent, 1 /* Export */) && // unexported variable statement
+        } else if (isVariableDeclaration(declaration) && isVariableStatement(declaration.parent.parent) && !hasSyntacticModifier(declaration.parent.parent, 32 /* Export */) && // unexported variable statement
         isDeclarationVisible(declaration.parent.parent.parent)) {
           return addVisibleAlias(declaration, declaration.parent.parent);
-        } else if (isLateVisibilityPaintedStatement(declaration) && !hasSyntacticModifier(declaration, 1 /* Export */) && isDeclarationVisible(declaration.parent)) {
+        } else if (isLateVisibilityPaintedStatement(declaration) && !hasSyntacticModifier(declaration, 32 /* Export */) && isDeclarationVisible(declaration.parent)) {
           return addVisibleAlias(declaration, declaration);
         } else if (isBindingElement(declaration)) {
-          if (symbol.flags & 2097152 /* Alias */ && isInJSFile(declaration) && ((_a = declaration.parent) == null ? void 0 : _a.parent) && isVariableDeclaration(declaration.parent.parent) && ((_b = declaration.parent.parent.parent) == null ? void 0 : _b.parent) && isVariableStatement(declaration.parent.parent.parent.parent) && !hasSyntacticModifier(declaration.parent.parent.parent.parent, 1 /* Export */) && declaration.parent.parent.parent.parent.parent && isDeclarationVisible(declaration.parent.parent.parent.parent.parent)) {
+          if (symbol.flags & 2097152 /* Alias */ && isInJSFile(declaration) && ((_a = declaration.parent) == null ? void 0 : _a.parent) && isVariableDeclaration(declaration.parent.parent) && ((_b = declaration.parent.parent.parent) == null ? void 0 : _b.parent) && isVariableStatement(declaration.parent.parent.parent.parent) && !hasSyntacticModifier(declaration.parent.parent.parent.parent, 32 /* Export */) && declaration.parent.parent.parent.parent.parent && isDeclarationVisible(declaration.parent.parent.parent.parent.parent)) {
             return addVisibleAlias(declaration, declaration.parent.parent.parent.parent);
           } else if (symbol.flags & 2 /* BlockScopedVariable */) {
             const variableStatement = findAncestor(declaration, isVariableStatement);
-            if (hasSyntacticModifier(variableStatement, 1 /* Export */)) {
+            if (hasSyntacticModifier(variableStatement, 32 /* Export */)) {
               return true;
             }
             if (!isDeclarationVisible(variableStatement.parent)) {
@@ -50231,7 +50255,8 @@ function createTypeChecker(host) {
         visitedTypes: void 0,
         symbolDepth: void 0,
         inferTypeParameters: void 0,
-        approximateLength: 0
+        approximateLength: 0,
+        trackedSymbols: void 0
       };
       context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
       const resultingNode = cb(context);
@@ -50685,7 +50710,7 @@ function createTypeChecker(host) {
         }
       }
       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 +50727,13 @@ function createTypeChecker(host) {
         }
         const cachedResult = (_a2 = links == null ? void 0 : links.serializedTypes) == null ? void 0 : _a2.get(key);
         if (cachedResult) {
+          (_b2 = cachedResult.trackedSymbols) == null ? void 0 : _b2.forEach(
+            ([symbol, enclosingDeclaration, meaning]) => context.tracker.trackSymbol(
+              symbol,
+              enclosingDeclaration,
+              meaning
+            )
+          );
           if (cachedResult.truncating) {
             context.truncating = true;
           }
@@ -50721,7 +50753,12 @@ function createTypeChecker(host) {
         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 +51000,7 @@ function createTypeChecker(host) {
             if (propertySymbol.flags & 4194304 /* Prototype */) {
               continue;
             }
-            if (getDeclarationModifierFlagsFromSymbol(propertySymbol) & (8 /* Private */ | 16 /* Protected */) && context.tracker.reportPrivateInBaseOfClassExpression) {
+            if (getDeclarationModifierFlagsFromSymbol(propertySymbol) & (2 /* Private */ | 4 /* Protected */) && context.tracker.reportPrivateInBaseOfClassExpression) {
               context.tracker.reportPrivateInBaseOfClassExpression(unescapeLeadingUnderscores(propertySymbol.escapedName));
             }
           }
@@ -51266,7 +51303,7 @@ function createTypeChecker(host) {
       let modifiers = options == null ? void 0 : options.modifiers;
       if (kind === 185 /* ConstructorType */ && signature.flags & 4 /* Abstract */) {
         const flags = modifiersToFlags(modifiers);
-        modifiers = factory.createModifiersFromModifierFlags(flags | 256 /* Abstract */);
+        modifiers = factory.createModifiersFromModifierFlags(flags | 64 /* Abstract */);
       }
       const node = kind === 179 /* CallSignature */ ? factory.createCallSignature(typeParameters, parameters, returnTypeNode) : kind === 180 /* ConstructSignature */ ? factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : kind === 173 /* MethodSignature */ ? factory.createMethodSignature(modifiers, (options == null ? void 0 : options.name) ?? factory.createIdentifier(""), options == null ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : kind === 174 /* MethodDeclaration */ ? factory.createMethodDeclaration(
         modifiers,
@@ -52323,7 +52360,7 @@ function createTypeChecker(host) {
         const nsIndex = findIndex(statements, isModuleDeclaration);
         let ns = nsIndex !== -1 ? statements[nsIndex] : void 0;
         if (ns && exportAssignment && exportAssignment.isExportEquals && isIdentifier(exportAssignment.expression) && isIdentifier(ns.name) && idText(ns.name) === idText(exportAssignment.expression) && ns.body && isModuleBlock(ns.body)) {
-          const excessExports = filter(statements, (s) => !!(getEffectiveModifierFlags(s) & 1 /* Export */));
+          const excessExports = filter(statements, (s) => !!(getEffectiveModifierFlags(s) & 32 /* Export */));
           const name = ns.name;
           let body = ns.body;
           if (length(excessExports)) {
@@ -52357,9 +52394,9 @@ function createTypeChecker(host) {
           }
           if (!find(statements, (s) => s !== ns && nodeHasName(s, name))) {
             results = [];
-            const mixinExportFlag = !some(body.statements, (s) => hasSyntacticModifier(s, 1 /* Export */) || isExportAssignment(s) || isExportDeclaration(s));
+            const mixinExportFlag = !some(body.statements, (s) => hasSyntacticModifier(s, 32 /* Export */) || isExportAssignment(s) || isExportDeclaration(s));
             forEach(body.statements, (s) => {
-              addResult(s, mixinExportFlag ? 1 /* Export */ : 0 /* None */);
+              addResult(s, mixinExportFlag ? 32 /* Export */ : 0 /* None */);
             });
             statements = [...filter(statements, (s) => s !== ns && s !== exportAssignment), ...results];
           }
@@ -52451,11 +52488,11 @@ function createTypeChecker(host) {
         return statements;
       }
       function addExportModifier(node) {
-        const flags = (getEffectiveModifierFlags(node) | 1 /* Export */) & ~2 /* Ambient */;
+        const flags = (getEffectiveModifierFlags(node) | 32 /* Export */) & ~128 /* Ambient */;
         return factory.replaceModifiers(node, flags);
       }
       function removeExportModifier(node) {
-        const flags = getEffectiveModifierFlags(node) & ~1 /* Export */;
+        const flags = getEffectiveModifierFlags(node) & ~32 /* Export */;
         return factory.replaceModifiers(node, flags);
       }
       function visitSymbolTable(symbolTable2, suppressNewPrivateContext, propertyAsAlias) {
@@ -52496,6 +52533,12 @@ function createTypeChecker(host) {
           if (context.reportedDiagnostic) {
             oldcontext.reportedDiagnostic = context.reportedDiagnostic;
           }
+          if (context.trackedSymbols) {
+            if (!oldContext.trackedSymbols)
+              oldContext.trackedSymbols = context.trackedSymbols;
+            else
+              Debug.assert(context.trackedSymbols === oldContext.trackedSymbols);
+          }
           context = oldContext;
         }
       }
@@ -52512,7 +52555,7 @@ function createTypeChecker(host) {
         if (needsPostExportDefault || needsExportDeclaration) {
           isPrivate = true;
         }
-        const modifierFlags = (!isPrivate ? 1 /* Export */ : 0) | (isDefault && !needsPostExportDefault ? 1024 /* Default */ : 0);
+        const modifierFlags = (!isPrivate ? 32 /* Export */ : 0) | (isDefault && !needsPostExportDefault ? 2048 /* Default */ : 0);
         const isConstMergedWithNS = symbol.flags & 1536 /* Module */ && symbol.flags & (2 /* BlockScopedVariable */ | 1 /* FunctionScopedVariable */ | 4 /* Property */) && escapedSymbolName !== "export=" /* ExportEquals */;
         const isConstMergedWithNSPrintableAsSignatureMerge = isConstMergedWithNS && isTypeRepresentableAsFunctionNamespaceMerge(getTypeOfSymbol(symbol), symbol);
         if (symbol.flags & (16 /* Function */ | 8192 /* Method */) || isConstMergedWithNSPrintableAsSignatureMerge) {
@@ -52582,7 +52625,7 @@ function createTypeChecker(host) {
                   ),
                   textRange
                 );
-                addResult(statement, name !== localName ? modifierFlags & ~1 /* Export */ : modifierFlags);
+                addResult(statement, name !== localName ? modifierFlags & ~32 /* Export */ : modifierFlags);
                 if (name !== localName && !isPrivate) {
                   addResult(
                     factory.createExportDeclaration(
@@ -52687,14 +52730,14 @@ function createTypeChecker(host) {
         if (canHaveModifiers(node)) {
           let newModifierFlags = 0 /* None */;
           const enclosingDeclaration2 = context.enclosingDeclaration && (isJSDocTypeAlias(context.enclosingDeclaration) ? getSourceFileOfNode(context.enclosingDeclaration) : context.enclosingDeclaration);
-          if (additionalModifierFlags & 1 /* Export */ && enclosingDeclaration2 && (isExportingScope(enclosingDeclaration2) || isModuleDeclaration(enclosingDeclaration2)) && canHaveExportModifier(node)) {
-            newModifierFlags |= 1 /* Export */;
+          if (additionalModifierFlags & 32 /* Export */ && enclosingDeclaration2 && (isExportingScope(enclosingDeclaration2) || isModuleDeclaration(enclosingDeclaration2)) && canHaveExportModifier(node)) {
+            newModifierFlags |= 32 /* Export */;
           }
-          if (addingDeclare && !(newModifierFlags & 1 /* Export */) && (!enclosingDeclaration2 || !(enclosingDeclaration2.flags & 33554432 /* Ambient */)) && (isEnumDeclaration(node) || isVariableStatement(node) || isFunctionDeclaration(node) || isClassDeclaration(node) || isModuleDeclaration(node))) {
-            newModifierFlags |= 2 /* Ambient */;
+          if (addingDeclare && !(newModifierFlags & 32 /* Export */) && (!enclosingDeclaration2 || !(enclosingDeclaration2.flags & 33554432 /* Ambient */)) && (isEnumDeclaration(node) || isVariableStatement(node) || isFunctionDeclaration(node) || isClassDeclaration(node) || isModuleDeclaration(node))) {
+            newModifierFlags |= 128 /* Ambient */;
           }
-          if (additionalModifierFlags & 1024 /* Default */ && (isClassDeclaration(node) || isInterfaceDeclaration(node) || isFunctionDeclaration(node))) {
-            newModifierFlags |= 1024 /* Default */;
+          if (additionalModifierFlags & 2048 /* Default */ && (isClassDeclaration(node) || isInterfaceDeclaration(node) || isFunctionDeclaration(node))) {
+            newModifierFlags |= 2048 /* Default */;
           }
           if (newModifierFlags) {
             node = factory.replaceModifiers(node, newModifierFlags | getEffectiveModifierFlags(node));
@@ -52816,7 +52859,7 @@ function createTypeChecker(host) {
       function serializeEnum(symbol, symbolName2, modifierFlags) {
         addResult(
           factory.createEnumDeclaration(
-            factory.createModifiersFromModifierFlags(isConstEnumSymbol(symbol) ? 2048 /* Const */ : 0),
+            factory.createModifiersFromModifierFlags(isConstEnumSymbol(symbol) ? 4096 /* Const */ : 0),
             getInternalSymbolName(symbol, symbolName2),
             map(filter(getPropertiesOfType(getTypeOfSymbol(symbol)), (p) => !!(p.flags & 8 /* EnumMember */)), (p) => {
               const initializedValue = p.declarations && p.declarations[0] && isEnumMember(p.declarations[0]) ? getConstantValue2(p.declarations[0]) : void 0;
@@ -52900,7 +52943,7 @@ function createTypeChecker(host) {
               factory.createIdentifier("default" /* Default */)
             )])
           ) : d);
-          const exportModifierStripped = every(defaultReplaced, (d) => hasSyntacticModifier(d, 1 /* Export */)) ? map(defaultReplaced, removeExportModifier) : defaultReplaced;
+          const exportModifierStripped = every(defaultReplaced, (d) => hasSyntacticModifier(d, 32 /* Export */)) ? map(defaultReplaced, removeExportModifier) : defaultReplaced;
           fakespace = factory.updateModuleDeclaration(
             fakespace,
             fakespace.modifiers,
@@ -53003,7 +53046,7 @@ function createTypeChecker(host) {
         );
         const isNonConstructableClassLikeInJsFile = !isClass && !!symbol.valueDeclaration && isInJSFile(symbol.valueDeclaration) && !some(getSignaturesOfType(staticType, 1 /* Construct */));
         const constructors = isNonConstructableClassLikeInJsFile ? [factory.createConstructorDeclaration(
-          factory.createModifiersFromModifierFlags(8 /* Private */),
+          factory.createModifiersFromModifierFlags(2 /* Private */),
           [],
           /*body*/
           void 0
@@ -53356,7 +53399,7 @@ function createTypeChecker(host) {
           const varName = getUnusedName(name, symbol);
           const typeToSerialize = getWidenedType(getTypeOfSymbol(getMergedSymbol(symbol)));
           if (isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, symbol)) {
-            serializeAsFunctionNamespaceMerge(typeToSerialize, symbol, varName, isExportAssignmentCompatibleSymbolName ? 0 /* None */ : 1 /* Export */);
+            serializeAsFunctionNamespaceMerge(typeToSerialize, symbol, varName, isExportAssignmentCompatibleSymbolName ? 0 /* None */ : 32 /* Export */);
           } else {
             const flags = ((_a2 = context.enclosingDeclaration) == null ? void 0 : _a2.kind) === 267 /* ModuleDeclaration */ && (!(symbol.flags & 98304 /* Accessor */) || symbol.flags & 65536 /* SetAccessor */) ? 1 /* Let */ : 2 /* Const */;
             const statement = factory.createVariableStatement(
@@ -53373,7 +53416,7 @@ function createTypeChecker(host) {
             );
             addResult(
               statement,
-              target && target.flags & 4 /* Property */ && target.escapedName === "export=" /* ExportEquals */ ? 2 /* Ambient */ : name === varName ? 1 /* Export */ : 0 /* None */
+              target && target.flags & 4 /* Property */ && target.escapedName === "export=" /* ExportEquals */ ? 128 /* Ambient */ : name === varName ? 32 /* Export */ : 0 /* None */
             );
           }
           if (isExportAssignmentCompatibleSymbolName) {
@@ -53409,14 +53452,14 @@ function createTypeChecker(host) {
         return function serializePropertySymbol(p, isStatic2, baseType) {
           var _a2, _b, _c, _d, _e;
           const modifierFlags = getDeclarationModifierFlagsFromSymbol(p);
-          const isPrivate = !!(modifierFlags & 8 /* Private */);
+          const isPrivate = !!(modifierFlags & 2 /* Private */);
           if (isStatic2 && p.flags & (788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */)) {
             return [];
           }
           if (p.flags & 4194304 /* Prototype */ || p.escapedName === "constructor" || baseType && getPropertyOfType(baseType, p.escapedName) && isReadonlySymbol(getPropertyOfType(baseType, p.escapedName)) === isReadonlySymbol(p) && (p.flags & 16777216 /* Optional */) === (getPropertyOfType(baseType, p.escapedName).flags & 16777216 /* Optional */) && isTypeIdenticalTo(getTypeOfSymbol(p), getTypeOfPropertyOfType(baseType, p.escapedName))) {
             return [];
           }
-          const flag = modifierFlags & ~512 /* Async */ | (isStatic2 ? 32 /* Static */ : 0);
+          const flag = modifierFlags & ~1024 /* Async */ | (isStatic2 ? 256 /* Static */ : 0);
           const name = getPropertyNameNodeForSymbol(p, context);
           const firstPropertyLikeDecl = (_a2 = p.declarations) == null ? void 0 : _a2.find(or(isPropertyDeclaration, isAccessor, isVariableDeclaration, isPropertySignature, isBinaryExpression, isPropertyAccessExpression));
           if (p.flags & 98304 /* Accessor */ && useAccessors) {
@@ -53458,7 +53501,7 @@ function createTypeChecker(host) {
               ));
             }
             if (p.flags & 32768 /* GetAccessor */) {
-              const isPrivate2 = modifierFlags & 8 /* Private */;
+              const isPrivate2 = modifierFlags & 2 /* Private */;
               result.push(setTextRange(
                 factory.createGetAccessorDeclaration(
                   factory.createModifiersFromModifierFlags(flag),
@@ -53475,7 +53518,7 @@ function createTypeChecker(host) {
           } else if (p.flags & (4 /* Property */ | 3 /* Variable */ | 98304 /* Accessor */)) {
             return setTextRange(
               createProperty2(
-                factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 64 /* Readonly */ : 0) | flag),
+                factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag),
                 name,
                 p.flags & 16777216 /* Optional */ ? factory.createToken(58 /* QuestionToken */) : void 0,
                 isPrivate ? void 0 : serializeTypeForDeclaration(context, getWriteTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled),
@@ -53490,10 +53533,10 @@ function createTypeChecker(host) {
           if (p.flags & (8192 /* Method */ | 16 /* Function */)) {
             const type = getTypeOfSymbol(p);
             const signatures = getSignaturesOfType(type, 0 /* Call */);
-            if (flag & 8 /* Private */) {
+            if (flag & 2 /* Private */) {
               return setTextRange(
                 createProperty2(
-                  factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 64 /* Readonly */ : 0) | flag),
+                  factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag),
                   name,
                   p.flags & 16777216 /* Optional */ ? factory.createToken(58 /* QuestionToken */) : void 0,
                   /*type*/
@@ -53569,7 +53612,7 @@ function createTypeChecker(host) {
           let privateProtected = 0;
           for (const s of signatures) {
             if (s.declaration) {
-              privateProtected |= getSelectedEffectiveModifierFlags(s.declaration, 8 /* Private */ | 16 /* Protected */);
+              privateProtected |= getSelectedEffectiveModifierFlags(s.declaration, 2 /* Private */ | 4 /* Protected */);
             }
           }
           if (privateProtected) {
@@ -53762,10 +53805,10 @@ function createTypeChecker(host) {
     return result || types;
   }
   function visibilityToString(flags) {
-    if (flags === 8 /* Private */) {
+    if (flags === 2 /* Private */) {
       return "private";
     }
-    if (flags === 16 /* Protected */) {
+    if (flags === 4 /* Protected */) {
       return "protected";
     }
     return "public";
@@ -53883,7 +53926,7 @@ function createTypeChecker(host) {
             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 +53936,7 @@ function createTypeChecker(host) {
         case 178 /* SetAccessor */:
         case 174 /* MethodDeclaration */:
         case 173 /* MethodSignature */:
-          if (hasEffectiveModifier(node, 8 /* Private */ | 16 /* Protected */)) {
+          if (hasEffectiveModifier(node, 2 /* Private */ | 4 /* Protected */)) {
             return false;
           }
         case 176 /* Constructor */:
@@ -54112,7 +54155,7 @@ function createTypeChecker(host) {
     const unspreadableToRestKeys = [];
     for (const prop of getPropertiesOfType(source)) {
       const literalTypeFromProperty = getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */);
-      if (!isTypeAssignableTo(literalTypeFromProperty, omitKeyType) && !(getDeclarationModifierFlagsFromSymbol(prop) & (8 /* Private */ | 16 /* Protected */)) && isSpreadableProperty(prop)) {
+      if (!isTypeAssignableTo(literalTypeFromProperty, omitKeyType) && !(getDeclarationModifierFlagsFromSymbol(prop) & (2 /* Private */ | 4 /* Protected */)) && isSpreadableProperty(prop)) {
         spreadableProperties.push(prop);
       } else {
         unspreadableToRestKeys.push(literalTypeFromProperty);
@@ -54318,7 +54361,7 @@ function createTypeChecker(host) {
     if (declaredType) {
       return addOptionality(declaredType, isProperty, isOptional);
     }
-    if ((noImplicitAny || isInJSFile(declaration)) && isVariableDeclaration(declaration) && !isBindingPattern(declaration.name) && !(getCombinedModifierFlagsCached(declaration) & 1 /* Export */) && !(declaration.flags & 33554432 /* Ambient */)) {
+    if ((noImplicitAny || isInJSFile(declaration)) && isVariableDeclaration(declaration) && !isBindingPattern(declaration.name) && !(getCombinedModifierFlagsCached(declaration) & 32 /* Export */) && !(declaration.flags & 33554432 /* Ambient */)) {
       if (!(getCombinedNodeFlagsCached(declaration) & 6 /* Constant */) && (!declaration.initializer || isNullOrUndefined2(declaration.initializer))) {
         return autoType;
       }
@@ -54366,7 +54409,7 @@ function createTypeChecker(host) {
     if (isPropertyDeclaration(declaration) && (noImplicitAny || isInJSFile(declaration))) {
       if (!hasStaticModifier(declaration)) {
         const constructor = findConstructorDeclaration(declaration.parent);
-        const type = constructor ? getFlowTypeInConstructor(declaration.symbol, constructor) : getEffectiveModifierFlags(declaration) & 2 /* Ambient */ ? getTypeOfPropertyInBaseClass(declaration.symbol) : void 0;
+        const type = constructor ? getFlowTypeInConstructor(declaration.symbol, constructor) : getEffectiveModifierFlags(declaration) & 128 /* Ambient */ ? getTypeOfPropertyInBaseClass(declaration.symbol) : void 0;
         return type && addOptionality(
           type,
           /*isProperty*/
@@ -54375,7 +54418,7 @@ function createTypeChecker(host) {
         );
       } else {
         const staticBlocks = filter(declaration.parent.members, isClassStaticBlockDeclaration);
-        const type = staticBlocks.length ? getFlowTypeInStaticBlocks(declaration.symbol, staticBlocks) : getEffectiveModifierFlags(declaration) & 2 /* Ambient */ ? getTypeOfPropertyInBaseClass(declaration.symbol) : void 0;
+        const type = staticBlocks.length ? getFlowTypeInStaticBlocks(declaration.symbol, staticBlocks) : getEffectiveModifierFlags(declaration) & 128 /* Ambient */ ? getTypeOfPropertyInBaseClass(declaration.symbol) : void 0;
         return type && addOptionality(
           type,
           /*isProperty*/
@@ -54479,7 +54522,7 @@ function createTypeChecker(host) {
     return everyType(flowType, isNullableType) ? void 0 : convertAutoToAny(flowType);
   }
   function getFlowTypeOfProperty(reference, prop) {
-    const initialType = (prop == null ? void 0 : prop.valueDeclaration) && (!isAutoTypedProperty(prop) || getEffectiveModifierFlags(prop.valueDeclaration) & 2 /* Ambient */) && getTypeOfPropertyInBaseClass(prop) || undefinedType;
+    const initialType = (prop == null ? void 0 : prop.valueDeclaration) && (!isAutoTypedProperty(prop) || getEffectiveModifierFlags(prop.valueDeclaration) & 128 /* Ambient */) && getTypeOfPropertyInBaseClass(prop) || undefinedType;
     return getFlowTypeOfReference(reference, autoType, initialType);
   }
   function getWidenedTypeForAssignmentDeclaration(symbol, resolvedSymbol) {
@@ -56132,7 +56175,7 @@ function createTypeChecker(host) {
     const baseConstructorType = getBaseConstructorTypeOfClass(classType);
     const baseSignatures = getSignaturesOfType(baseConstructorType, 1 /* Construct */);
     const declaration = getClassLikeDeclarationOfSymbol(classType.symbol);
-    const isAbstract = !!declaration && hasSyntacticModifier(declaration, 256 /* Abstract */);
+    const isAbstract = !!declaration && hasSyntacticModifier(declaration, 64 /* Abstract */);
     if (baseSignatures.length === 0) {
       return [createSignature(
         /*declaration*/
@@ -56908,7 +56951,7 @@ function createTypeChecker(host) {
   }
   function isConstTypeVariable(type, depth = 0) {
     var _a;
-    return depth < 5 && !!(type && (type.flags & 262144 /* TypeParameter */ && some((_a = type.symbol) == null ? void 0 : _a.declarations, (d) => hasSyntacticModifier(d, 2048 /* Const */)) || type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, (t) => isConstTypeVariable(t, depth)) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType, depth + 1) || type.flags & 16777216 /* Conditional */ && isConstTypeVariable(getConstraintOfConditionalType(type), depth + 1) || type.flags & 33554432 /* Substitution */ && isConstTypeVariable(type.baseType, depth) || isGenericTupleType(type) && findIndex(getElementTypes(type), (t, i) => !!(type.target.elementFlags[i] & 8 /* Variadic */) && isConstTypeVariable(t, depth)) >= 0));
+    return depth < 5 && !!(type && (type.flags & 262144 /* TypeParameter */ && some((_a = type.symbol) == null ? void 0 : _a.declarations, (d) => hasSyntacticModifier(d, 4096 /* Const */)) || type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, (t) => isConstTypeVariable(t, depth)) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType, depth + 1) || type.flags & 16777216 /* Conditional */ && isConstTypeVariable(getConstraintOfConditionalType(type), depth + 1) || type.flags & 33554432 /* Substitution */ && isConstTypeVariable(type.baseType, depth) || isGenericTupleType(type) && findIndex(getElementTypes(type), (t, i) => !!(type.target.elementFlags[i] & 8 /* Variadic */) && isConstTypeVariable(t, depth)) >= 0));
   }
   function getConstraintOfIndexedAccess(type) {
     return hasNonCircularBaseConstraint(type) ? getConstraintFromIndexedAccess(type) : void 0;
@@ -57234,7 +57277,7 @@ function createTypeChecker(host) {
           } else if (!isUnion && !isReadonlySymbol(prop)) {
             checkFlags &= ~8 /* Readonly */;
           }
-          checkFlags |= (!(modifiers & 24 /* NonPublicAccessibilityModifier */) ? 256 /* ContainsPublic */ : 0) | (modifiers & 16 /* Protected */ ? 512 /* ContainsProtected */ : 0) | (modifiers & 8 /* Private */ ? 1024 /* ContainsPrivate */ : 0) | (modifiers & 32 /* Static */ ? 2048 /* ContainsStatic */ : 0);
+          checkFlags |= (!(modifiers & 6 /* NonPublicAccessibilityModifier */) ? 256 /* ContainsPublic */ : 0) | (modifiers & 4 /* Protected */ ? 512 /* ContainsProtected */ : 0) | (modifiers & 2 /* Private */ ? 1024 /* ContainsPrivate */ : 0) | (modifiers & 256 /* Static */ ? 2048 /* ContainsStatic */ : 0);
           if (!isPrototypeProperty(prop)) {
             syntheticFlag = 2 /* SyntheticProperty */;
           }
@@ -57686,7 +57729,7 @@ function createTypeChecker(host) {
       if (hasRestParameter(declaration) || isInJSFile(declaration) && maybeAddJsSyntheticRestParameter(declaration, parameters)) {
         flags |= 1 /* HasRestParameter */;
       }
-      if (isConstructorTypeNode(declaration) && hasSyntacticModifier(declaration, 256 /* Abstract */) || isConstructorDeclaration(declaration) && hasSyntacticModifier(declaration.parent, 256 /* Abstract */)) {
+      if (isConstructorTypeNode(declaration) && hasSyntacticModifier(declaration, 64 /* Abstract */) || isConstructorDeclaration(declaration) && hasSyntacticModifier(declaration.parent, 64 /* Abstract */)) {
         flags |= 4 /* Abstract */;
       }
       links.resolvedSignature = createSignature(
@@ -58056,7 +58099,7 @@ function createTypeChecker(host) {
           if (parameter.type) {
             forEachType(getTypeFromTypeNode(parameter.type), (keyType) => {
               if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos, keyType)) {
-                indexInfos.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, hasEffectiveModifier(declaration, 64 /* Readonly */), declaration));
+                indexInfos.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, hasEffectiveModifier(declaration, 8 /* Readonly */), declaration));
               }
             });
           }
@@ -59881,7 +59924,7 @@ function createTypeChecker(host) {
     return neverType;
   }
   function getLiteralTypeFromProperty(prop, include, includeNonPublic) {
-    if (includeNonPublic || !(getDeclarationModifierFlagsFromSymbol(prop) & 24 /* NonPublicAccessibilityModifier */)) {
+    if (includeNonPublic || !(getDeclarationModifierFlagsFromSymbol(prop) & 6 /* NonPublicAccessibilityModifier */)) {
       let type = getSymbolLinks(getLateBoundSymbol(prop)).nameType;
       if (!type) {
         const name = getNameOfDeclaration(prop.valueDeclaration);
@@ -60315,7 +60358,7 @@ function createTypeChecker(host) {
   }
   function isPatternLiteralPlaceholderType(type) {
     if (type.flags & 2097152 /* Intersection */) {
-      return some(type.types, (t) => !!(t.flags & (2944 /* Literal */ | 65536 /* Null */ | 32768 /* Undefined */)) || isPatternLiteralPlaceholderType(t));
+      return !isGenericType(type) && some(type.types, (t) => !!(t.flags & (2944 /* Literal */ | 98304 /* Nullable */)) || isPatternLiteralPlaceholderType(t));
     }
     return !!(type.flags & (1 /* Any */ | 4 /* String */ | 8 /* Number */ | 64 /* BigInt */)) || isPatternLiteralType(type);
   }
@@ -60826,7 +60869,7 @@ function createTypeChecker(host) {
     function getAnonymousPartialType(type2) {
       const members = createSymbolTable();
       for (const prop of getPropertiesOfType(type2)) {
-        if (getDeclarationModifierFlagsFromSymbol(prop) & (8 /* Private */ | 16 /* Protected */)) {
+        if (getDeclarationModifierFlagsFromSymbol(prop) & (2 /* Private */ | 4 /* Protected */)) {
         } else if (isSpreadableProperty(prop)) {
           const isSetonlyAccessor = prop.flags & 65536 /* SetAccessor */ && !(prop.flags & 32768 /* GetAccessor */);
           const flags = 4 /* Property */ | 16777216 /* Optional */;
@@ -60888,7 +60931,7 @@ function createTypeChecker(host) {
     const skippedPrivateMembers = /* @__PURE__ */ new Set();
     const indexInfos = left === emptyObjectType ? getIndexInfosOfType(right) : getUnionIndexInfos([left, right]);
     for (const rightProp of getPropertiesOfType(right)) {
-      if (getDeclarationModifierFlagsFromSymbol(rightProp) & (8 /* Private */ | 16 /* Protected */)) {
+      if (getDeclarationModifierFlagsFromSymbol(rightProp) & (2 /* Private */ | 4 /* Protected */)) {
         skippedPrivateMembers.add(rightProp.escapedName);
       } else if (isSpreadableProperty(rightProp)) {
         members.set(rightProp.escapedName, getSpreadSymbol(rightProp, readonly));
@@ -64455,25 +64498,25 @@ function createTypeChecker(host) {
     function propertyRelatedTo(source2, target2, sourceProp, targetProp, getTypeOfSourceProperty, reportErrors2, intersectionState, skipOptional) {
       const sourcePropFlags = getDeclarationModifierFlagsFromSymbol(sourceProp);
       const targetPropFlags = getDeclarationModifierFlagsFromSymbol(targetProp);
-      if (sourcePropFlags & 8 /* Private */ || targetPropFlags & 8 /* Private */) {
+      if (sourcePropFlags & 2 /* Private */ || targetPropFlags & 2 /* Private */) {
         if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) {
           if (reportErrors2) {
-            if (sourcePropFlags & 8 /* Private */ && targetPropFlags & 8 /* Private */) {
+            if (sourcePropFlags & 2 /* Private */ && targetPropFlags & 2 /* Private */) {
               reportError(Diagnostics.Types_have_separate_declarations_of_a_private_property_0, symbolToString(targetProp));
             } else {
-              reportError(Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 8 /* Private */ ? source2 : target2), typeToString(sourcePropFlags & 8 /* Private */ ? target2 : source2));
+              reportError(Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 2 /* Private */ ? source2 : target2), typeToString(sourcePropFlags & 2 /* Private */ ? target2 : source2));
             }
           }
           return 0 /* False */;
         }
-      } else if (targetPropFlags & 16 /* Protected */) {
+      } else if (targetPropFlags & 4 /* Protected */) {
         if (!isValidOverrideOf(sourceProp, targetProp)) {
           if (reportErrors2) {
             reportError(Diagnostics.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2, symbolToString(targetProp), typeToString(getDeclaringClass(sourceProp) || source2), typeToString(getDeclaringClass(targetProp) || target2));
           }
           return 0 /* False */;
         }
-      } else if (sourcePropFlags & 16 /* Protected */) {
+      } else if (sourcePropFlags & 4 /* Protected */) {
         if (reportErrors2) {
           reportError(Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2, symbolToString(targetProp), typeToString(source2), typeToString(target2));
         }
@@ -65003,15 +65046,15 @@ function createTypeChecker(host) {
       if (!sourceSignature.declaration || !targetSignature.declaration) {
         return true;
       }
-      const sourceAccessibility = getSelectedEffectiveModifierFlags(sourceSignature.declaration, 24 /* NonPublicAccessibilityModifier */);
-      const targetAccessibility = getSelectedEffectiveModifierFlags(targetSignature.declaration, 24 /* NonPublicAccessibilityModifier */);
-      if (targetAccessibility === 8 /* Private */) {
+      const sourceAccessibility = getSelectedEffectiveModifierFlags(sourceSignature.declaration, 6 /* NonPublicAccessibilityModifier */);
+      const targetAccessibility = getSelectedEffectiveModifierFlags(targetSignature.declaration, 6 /* NonPublicAccessibilityModifier */);
+      if (targetAccessibility === 2 /* Private */) {
         return true;
       }
-      if (targetAccessibility === 16 /* Protected */ && sourceAccessibility !== 8 /* Private */) {
+      if (targetAccessibility === 4 /* Protected */ && sourceAccessibility !== 2 /* Private */) {
         return true;
       }
-      if (targetAccessibility !== 16 /* Protected */ && !sourceAccessibility) {
+      if (targetAccessibility !== 4 /* Protected */ && !sourceAccessibility) {
         return true;
       }
       if (reportErrors2) {
@@ -65111,7 +65154,7 @@ function createTypeChecker(host) {
       const variances = [];
       for (const tp of typeParameters) {
         const modifiers = getTypeParameterModifiers(tp);
-        let variance = modifiers & 65536 /* Out */ ? modifiers & 32768 /* In */ ? 0 /* Invariant */ : 1 /* Covariant */ : modifiers & 32768 /* In */ ? 2 /* Contravariant */ : void 0;
+        let variance = modifiers & 16384 /* Out */ ? modifiers & 8192 /* In */ ? 0 /* Invariant */ : 1 /* Covariant */ : modifiers & 8192 /* In */ ? 2 /* Contravariant */ : void 0;
         if (variance === void 0) {
           let unmeasurable = false;
           let unreliable = false;
@@ -65159,7 +65202,7 @@ function createTypeChecker(host) {
   }
   function getTypeParameterModifiers(tp) {
     var _a;
-    return reduceLeft((_a = tp.symbol) == null ? void 0 : _a.declarations, (modifiers, d) => modifiers | getEffectiveModifierFlags(d), 0 /* None */) & (32768 /* In */ | 65536 /* Out */ | 2048 /* Const */);
+    return reduceLeft((_a = tp.symbol) == null ? void 0 : _a.declarations, (modifiers, d) => modifiers | getEffectiveModifierFlags(d), 0 /* None */) & (8192 /* In */ | 16384 /* Out */ | 4096 /* Const */);
   }
   function hasCovariantVoidArgument(typeArguments, variances) {
     for (let i = 0; i < variances.length; i++) {
@@ -65244,10 +65287,10 @@ function createTypeChecker(host) {
     });
   }
   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 +65367,8 @@ function createTypeChecker(host) {
     if (sourceProp === targetProp) {
       return -1 /* True */;
     }
-    const sourcePropAccessibility = getDeclarationModifierFlagsFromSymbol(sourceProp) & 24 /* NonPublicAccessibilityModifier */;
-    const targetPropAccessibility = getDeclarationModifierFlagsFromSymbol(targetProp) & 24 /* NonPublicAccessibilityModifier */;
+    const sourcePropAccessibility = getDeclarationModifierFlagsFromSymbol(sourceProp) & 6 /* NonPublicAccessibilityModifier */;
+    const targetPropAccessibility = getDeclarationModifierFlagsFromSymbol(targetProp) & 6 /* NonPublicAccessibilityModifier */;
     if (sourcePropAccessibility !== targetPropAccessibility) {
       return 0 /* False */;
     }
@@ -69319,7 +69362,7 @@ function createTypeChecker(host) {
       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 +69775,7 @@ function createTypeChecker(host) {
     let inAsyncFunction = false;
     if (!isCallExpression2) {
       while (container && container.kind === 219 /* ArrowFunction */) {
-        if (hasSyntacticModifier(container, 512 /* Async */))
+        if (hasSyntacticModifier(container, 1024 /* Async */))
           inAsyncFunction = true;
         container = getSuperContainer(
           container,
@@ -69741,7 +69784,7 @@ function createTypeChecker(host) {
         );
         needToCaptureLexicalThis = languageVersion < 2 /* ES2015 */;
       }
-      if (container && hasSyntacticModifier(container, 512 /* Async */))
+      if (container && hasSyntacticModifier(container, 1024 /* Async */))
         inAsyncFunction = true;
     }
     let nodeCheckFlag = 0;
@@ -70073,7 +70116,24 @@ function createTypeChecker(host) {
     }
     const signature = getContextualSignatureForFunctionLikeDeclaration(functionDecl);
     if (signature && !isResolvingReturnTypeOfSignature(signature)) {
-      return getReturnTypeOfSignature(signature);
+      const returnType2 = getReturnTypeOfSignature(signature);
+      const functionFlags = getFunctionFlags(functionDecl);
+      if (functionFlags & 1 /* Generator */) {
+        return filterType(returnType2, (t) => {
+          return !!(t.flags & (3 /* AnyOrUnknown */ | 16384 /* Void */ | 58982400 /* InstantiableNonPrimitive */)) || checkGeneratorInstantiationAssignabilityToReturnType(
+            t,
+            functionFlags,
+            /*errorNode*/
+            void 0
+          );
+        });
+      }
+      if (functionFlags & 2 /* Async */) {
+        return filterType(returnType2, (t) => {
+          return !!(t.flags & (3 /* AnyOrUnknown */ | 16384 /* Void */ | 58982400 /* InstantiableNonPrimitive */)) || !!getAwaitedTypeOfPromise(t);
+        });
+      }
+      return returnType2;
     }
     const iife = getImmediatelyInvokedFunctionExpression(functionDecl);
     if (iife) {
@@ -71929,20 +71989,20 @@ function createTypeChecker(host) {
           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 +72011,10 @@ function createTypeChecker(host) {
         return false;
       }
     }
-    if (!(flags & 24 /* NonPublicAccessibilityModifier */)) {
+    if (!(flags & 6 /* NonPublicAccessibilityModifier */)) {
       return true;
     }
-    if (flags & 8 /* Private */) {
+    if (flags & 2 /* Private */) {
       const declaringClassDeclaration = getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop));
       if (!isNodeWithinClass(location, declaringClassDeclaration)) {
         if (errorNode) {
@@ -71974,14 +72034,14 @@ function createTypeChecker(host) {
     if (!enclosingClass) {
       enclosingClass = getEnclosingClassFromThisParameter(location);
       enclosingClass = enclosingClass && isClassDerivedFromDeclaringClasses(enclosingClass, prop, writing);
-      if (flags & 32 /* Static */ || !enclosingClass) {
+      if (flags & 256 /* Static */ || !enclosingClass) {
         if (errorNode) {
           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 +72461,7 @@ function createTypeChecker(host) {
     }
     let diagnosticMessage;
     const declarationName = idText(right);
-    if (isInPropertyInitializerOrClassStaticBlock(node) && !isOptionalPropertyDeclaration(valueDeclaration) && !(isAccessExpression(node) && isAccessExpression(node.expression)) && !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right) && !(isMethodDeclaration(valueDeclaration) && getCombinedModifierFlagsCached(valueDeclaration) & 32 /* Static */) && (useDefineForClassFields || !isPropertyDeclaredInAncestorClass(prop))) {
+    if (isInPropertyInitializerOrClassStaticBlock(node) && !isOptionalPropertyDeclaration(valueDeclaration) && !(isAccessExpression(node) && isAccessExpression(node.expression)) && !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right) && !(isMethodDeclaration(valueDeclaration) && getCombinedModifierFlagsCached(valueDeclaration) & 256 /* Static */) && (useDefineForClassFields || !isPropertyDeclaredInAncestorClass(prop))) {
       diagnosticMessage = 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 +72715,7 @@ function createTypeChecker(host) {
     if (!valueDeclaration) {
       return;
     }
-    const hasPrivateModifier = hasEffectiveModifier(valueDeclaration, 8 /* Private */);
+    const hasPrivateModifier = hasEffectiveModifier(valueDeclaration, 2 /* Private */);
     const hasPrivateIdentifier = prop.valueDeclaration && isNamedDeclaration(prop.valueDeclaration) && isPrivateIdentifier(prop.valueDeclaration.name);
     if (!hasPrivateModifier && !hasPrivateIdentifier) {
       return;
@@ -74100,7 +74160,7 @@ function createTypeChecker(host) {
         return resolveErrorCall(node);
       }
       const valueDecl = expressionType.symbol && getClassLikeDeclarationOfSymbol(expressionType.symbol);
-      if (valueDecl && hasSyntacticModifier(valueDecl, 256 /* Abstract */)) {
+      if (valueDecl && hasSyntacticModifier(valueDecl, 64 /* Abstract */)) {
         error2(node, Diagnostics.Cannot_create_an_instance_of_an_abstract_class);
         return resolveErrorCall(node);
       }
@@ -74163,7 +74223,7 @@ function createTypeChecker(host) {
       return true;
     }
     const declaration = signature.declaration;
-    const modifiers = getSelectedEffectiveModifierFlags(declaration, 24 /* NonPublicAccessibilityModifier */);
+    const modifiers = getSelectedEffectiveModifierFlags(declaration, 6 /* NonPublicAccessibilityModifier */);
     if (!modifiers || declaration.kind !== 176 /* Constructor */) {
       return true;
     }
@@ -74171,16 +74231,16 @@ function createTypeChecker(host) {
     const declaringClass = getDeclaredTypeOfSymbol(declaration.parent.symbol);
     if (!isNodeWithinClass(node, declaringClassDeclaration)) {
       const containingClass = getContainingClass(node);
-      if (containingClass && modifiers & 16 /* Protected */) {
+      if (containingClass && modifiers & 4 /* Protected */) {
         const containingType = getTypeOfNode(containingClass);
         if (typeHasProtectedAccessibleBase(declaration.parent.symbol, containingType)) {
           return true;
         }
       }
-      if (modifiers & 8 /* Private */) {
+      if (modifiers & 2 /* Private */) {
         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 +76217,7 @@ function createTypeChecker(host) {
     return !setProp;
   }
   function isReadonlySymbol(symbol) {
-    return !!(getCheckFlags(symbol) & 8 /* Readonly */ || symbol.flags & 4 /* Property */ && getDeclarationModifierFlagsFromSymbol(symbol) & 64 /* Readonly */ || symbol.flags & 3 /* Variable */ && getDeclarationNodeFlagsFromSymbol(symbol) & 6 /* Constant */ || symbol.flags & 98304 /* Accessor */ && !(symbol.flags & 65536 /* SetAccessor */) || symbol.flags & 8 /* EnumMember */ || some(symbol.declarations, isReadonlyAssignmentDeclaration));
+    return !!(getCheckFlags(symbol) & 8 /* Readonly */ || symbol.flags & 4 /* Property */ && getDeclarationModifierFlagsFromSymbol(symbol) & 8 /* Readonly */ || symbol.flags & 3 /* Variable */ && getDeclarationNodeFlagsFromSymbol(symbol) & 6 /* Constant */ || symbol.flags & 98304 /* Accessor */ && !(symbol.flags & 65536 /* SetAccessor */) || symbol.flags & 8 /* EnumMember */ || some(symbol.declarations, isReadonlyAssignmentDeclaration));
   }
   function isAssignmentToReadonlyEntity(expr, symbol, assignmentKind) {
     var _a, _b;
@@ -77274,7 +77334,15 @@ function createTypeChecker(host) {
         checkExternalEmitHelpers(node, 256 /* Values */);
       }
     }
-    const returnType = getReturnTypeFromAnnotation(func);
+    let returnType = getReturnTypeFromAnnotation(func);
+    if (returnType && returnType.flags & 1048576 /* Union */) {
+      returnType = filterType(returnType, (t) => checkGeneratorInstantiationAssignabilityToReturnType(
+        t,
+        functionFlags,
+        /*errorNode*/
+        void 0
+      ));
+    }
     const iterationTypes = returnType && getIterationTypesOfGeneratorFunctionReturnType(returnType, isAsync);
     const signatureYieldType = iterationTypes && iterationTypes.yieldType || anyType;
     const signatureNextType = iterationTypes && iterationTypes.nextType || anyType;
@@ -77895,15 +77963,15 @@ function createTypeChecker(host) {
     var _a, _b;
     if (isInterfaceDeclaration(node.parent) || isClassLike(node.parent) || isTypeAliasDeclaration(node.parent)) {
       const typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node));
-      const modifiers = getTypeParameterModifiers(typeParameter) & (32768 /* In */ | 65536 /* Out */);
+      const modifiers = getTypeParameterModifiers(typeParameter) & (8192 /* In */ | 16384 /* Out */);
       if (modifiers) {
         const symbol = getSymbolOfDeclaration(node.parent);
         if (isTypeAliasDeclaration(node.parent) && !(getObjectFlags(getDeclaredTypeOfSymbol(symbol)) & (16 /* Anonymous */ | 32 /* Mapped */))) {
           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 +77985,7 @@ function createTypeChecker(host) {
     checkGrammarModifiers(node);
     checkVariableLikeDeclaration(node);
     const func = getContainingFunction(node);
-    if (hasSyntacticModifier(node, 16476 /* ParameterPropertyModifier */)) {
+    if (hasSyntacticModifier(node, 31 /* ParameterPropertyModifier */)) {
       if (!(func.kind === 176 /* Constructor */ && nodeIsPresent(func.body))) {
         error2(node, Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
       }
@@ -78087,11 +78155,7 @@ function createTypeChecker(host) {
           if (returnType === voidType) {
             error2(returnTypeErrorLocation, Diagnostics.A_generator_cannot_have_a_void_type_annotation);
           } else {
-            const generatorYieldType = getIterationTypeOfGeneratorFunctionReturnType(0 /* Yield */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || anyType;
-            const generatorReturnType = getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || generatorYieldType;
-            const generatorNextType = getIterationTypeOfGeneratorFunctionReturnType(2 /* Next */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || unknownType;
-            const generatorInstantiation = createGeneratorReturnType(generatorYieldType, generatorReturnType, generatorNextType, !!(functionFlags2 & 2 /* Async */));
-            checkTypeAssignableTo(generatorInstantiation, returnType, returnTypeErrorLocation);
+            checkGeneratorInstantiationAssignabilityToReturnType(returnType, functionFlags2, returnTypeErrorLocation);
           }
         } else if ((functionFlags2 & 3 /* AsyncGenerator */) === 2 /* Async */) {
           checkAsyncFunctionReturnType(node, returnTypeNode, returnTypeErrorLocation);
@@ -78102,6 +78166,13 @@ function createTypeChecker(host) {
       }
     }
   }
+  function checkGeneratorInstantiationAssignabilityToReturnType(returnType, functionFlags, errorNode) {
+    const generatorYieldType = getIterationTypeOfGeneratorFunctionReturnType(0 /* Yield */, returnType, (functionFlags & 2 /* Async */) !== 0) || anyType;
+    const generatorReturnType = getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, returnType, (functionFlags & 2 /* Async */) !== 0) || generatorYieldType;
+    const generatorNextType = getIterationTypeOfGeneratorFunctionReturnType(2 /* Next */, returnType, (functionFlags & 2 /* Async */) !== 0) || unknownType;
+    const generatorInstantiation = createGeneratorReturnType(generatorYieldType, generatorReturnType, generatorNextType, !!(functionFlags & 2 /* Async */));
+    return checkTypeAssignableTo(generatorInstantiation, returnType, errorNode);
+  }
   function checkClassForDuplicateDeclarations(node) {
     const instanceNames = /* @__PURE__ */ new Map();
     const staticNames = /* @__PURE__ */ new Map();
@@ -78249,7 +78320,7 @@ function createTypeChecker(host) {
       checkGrammarComputedPropertyName(node.name);
     checkVariableLikeDeclaration(node);
     setNodeLinksForPrivateIdentifierScope(node);
-    if (hasSyntacticModifier(node, 256 /* Abstract */) && node.kind === 172 /* PropertyDeclaration */ && node.initializer) {
+    if (hasSyntacticModifier(node, 64 /* Abstract */) && node.kind === 172 /* PropertyDeclaration */ && node.initializer) {
       error2(node, Diagnostics.Property_0_cannot_have_an_initializer_because_it_is_marked_abstract, declarationNameToString(node.name));
     }
   }
@@ -78266,7 +78337,7 @@ function createTypeChecker(host) {
       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 +78394,7 @@ function createTypeChecker(host) {
           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 +78463,11 @@ function createTypeChecker(host) {
           getNodeLinks(getter).flags |= 1 /* TypeChecked */;
           const getterFlags = getEffectiveModifierFlags(getter);
           const setterFlags = getEffectiveModifierFlags(setter);
-          if ((getterFlags & 256 /* Abstract */) !== (setterFlags & 256 /* Abstract */)) {
+          if ((getterFlags & 64 /* Abstract */) !== (setterFlags & 64 /* Abstract */)) {
             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 +78647,7 @@ function createTypeChecker(host) {
       const propertyName = getPropertyNameFromIndex(indexType, accessNode);
       if (propertyName) {
         const propertySymbol = forEachType(apparentObjectType, (t) => getPropertyOfType(t, propertyName));
-        if (propertySymbol && getDeclarationModifierFlagsFromSymbol(propertySymbol) & 24 /* NonPublicAccessibilityModifier */) {
+        if (propertySymbol && getDeclarationModifierFlagsFromSymbol(propertySymbol) & 6 /* NonPublicAccessibilityModifier */) {
           error2(accessNode, Diagnostics.Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter, unescapeLeadingUnderscores(propertyName));
           return errorType;
         }
@@ -78674,16 +78745,16 @@ function createTypeChecker(host) {
     getTypeFromTypeNode(node);
   }
   function isPrivateWithinAmbient(node) {
-    return (hasEffectiveModifier(node, 8 /* Private */) || isPrivateIdentifierClassElementDeclaration(node)) && !!(node.flags & 33554432 /* Ambient */);
+    return (hasEffectiveModifier(node, 2 /* Private */) || isPrivateIdentifierClassElementDeclaration(node)) && !!(node.flags & 33554432 /* Ambient */);
   }
   function getEffectiveDeclarationFlags(n, flagsToCheck) {
     let flags = getCombinedModifierFlagsCached(n);
     if (n.parent.kind !== 264 /* InterfaceDeclaration */ && n.parent.kind !== 263 /* ClassDeclaration */ && n.parent.kind !== 231 /* ClassExpression */ && n.flags & 33554432 /* Ambient */) {
       const container = getEnclosingContainer(n);
-      if (container && container.flags & 128 /* ExportContext */ && !(flags & 2 /* Ambient */) && !(isModuleBlock(n.parent) && isModuleDeclaration(n.parent.parent) && isGlobalScopeAugmentation(n.parent.parent))) {
-        flags |= 1 /* Export */;
+      if (container && container.flags & 128 /* ExportContext */ && !(flags & 128 /* Ambient */) && !(isModuleBlock(n.parent) && isModuleDeclaration(n.parent.parent) && isGlobalScopeAugmentation(n.parent.parent))) {
+        flags |= 32 /* Export */;
       }
-      flags |= 2 /* Ambient */;
+      flags |= 128 /* Ambient */;
     }
     return flags & flagsToCheck;
   }
@@ -78701,13 +78772,13 @@ function createTypeChecker(host) {
         const canonicalFlags = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck2);
         forEach(overloads, (o) => {
           const deviation = getEffectiveDeclarationFlags(o, flagsToCheck2) ^ canonicalFlags;
-          if (deviation & 1 /* Export */) {
+          if (deviation & 32 /* Export */) {
             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 +78795,7 @@ function createTypeChecker(host) {
         });
       }
     }
-    const flagsToCheck = 1 /* Export */ | 2 /* Ambient */ | 8 /* Private */ | 16 /* Protected */ | 256 /* Abstract */;
+    const flagsToCheck = 32 /* Export */ | 128 /* Ambient */ | 2 /* Private */ | 4 /* Protected */ | 64 /* Abstract */;
     let someNodeFlags = 0 /* None */;
     let allNodeFlags = flagsToCheck;
     let someHaveQuestionToken = false;
@@ -78772,7 +78843,7 @@ function createTypeChecker(host) {
       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 +78929,7 @@ function createTypeChecker(host) {
         }
       });
     }
-    if (lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && !hasSyntacticModifier(lastSeenNonAmbientDeclaration, 256 /* Abstract */) && !lastSeenNonAmbientDeclaration.questionToken) {
+    if (lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && !hasSyntacticModifier(lastSeenNonAmbientDeclaration, 64 /* Abstract */) && !lastSeenNonAmbientDeclaration.questionToken) {
       reportImplementationExpectedError(lastSeenNonAmbientDeclaration);
     }
     if (hasOverloads) {
@@ -78901,9 +78972,9 @@ function createTypeChecker(host) {
     let defaultExportedDeclarationSpaces = 0 /* None */;
     for (const d of symbol.declarations) {
       const declarationSpaces = getDeclarationSpaces(d);
-      const effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 1 /* Export */ | 1024 /* Default */);
-      if (effectiveDeclarationFlags & 1 /* Export */) {
-        if (effectiveDeclarationFlags & 1024 /* Default */) {
+      const effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 32 /* Export */ | 2048 /* Default */);
+      if (effectiveDeclarationFlags & 32 /* Export */) {
+        if (effectiveDeclarationFlags & 2048 /* Default */) {
           defaultExportedDeclarationSpaces |= declarationSpaces;
         } else {
           exportedDeclarationSpaces |= declarationSpaces;
@@ -79544,6 +79615,12 @@ function createTypeChecker(host) {
       }
     }
   }
+  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 +79783,13 @@ function createTypeChecker(host) {
             break;
           }
           const symbol = getSymbolOfDeclaration(member);
-          if (!symbol.isReferenced && (hasEffectiveModifier(member, 8 /* Private */) || isNamedDeclaration(member) && isPrivateIdentifier(member.name)) && !(member.flags & 33554432 /* Ambient */)) {
+          if (!symbol.isReferenced && (hasEffectiveModifier(member, 2 /* Private */) || isNamedDeclaration(member) && isPrivateIdentifier(member.name)) && !(member.flags & 33554432 /* Ambient */)) {
             addDiagnostic(member, 0 /* Local */, createDiagnosticForNode(member.name, Diagnostics._0_is_declared_but_its_value_is_never_read, symbolToString(symbol)));
           }
           break;
         case 176 /* Constructor */:
           for (const parameter of member.parameters) {
-            if (!parameter.symbol.isReferenced && hasSyntacticModifier(parameter, 8 /* Private */)) {
+            if (!parameter.symbol.isReferenced && hasSyntacticModifier(parameter, 2 /* Private */)) {
               addDiagnostic(parameter, 0 /* Local */, createDiagnosticForNode(parameter.name, Diagnostics.Property_0_is_declared_but_its_value_is_never_read, symbolName(parameter.symbol)));
             }
           }
@@ -80288,7 +80365,7 @@ function createTypeChecker(host) {
     if (hasQuestionToken(left) !== hasQuestionToken(right)) {
       return false;
     }
-    const interestingFlags = 8 /* Private */ | 16 /* Protected */ | 512 /* Async */ | 256 /* Abstract */ | 64 /* Readonly */ | 32 /* Static */;
+    const interestingFlags = 2 /* Private */ | 4 /* Protected */ | 1024 /* Async */ | 64 /* Abstract */ | 8 /* Readonly */ | 256 /* Static */;
     return getSelectedEffectiveModifierFlags(left, interestingFlags) === getSelectedEffectiveModifierFlags(right, interestingFlags);
   }
   function checkVariableDeclaration(node) {
@@ -81616,7 +81693,7 @@ function createTypeChecker(host) {
     if (legacyDecorators && firstDecorator && some(node.members, (p) => hasStaticModifier(p) && isPrivateIdentifierClassElementDeclaration(p))) {
       grammarErrorOnNode(firstDecorator, Diagnostics.Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator);
     }
-    if (!node.name && !hasSyntacticModifier(node, 1024 /* Default */)) {
+    if (!node.name && !hasSyntacticModifier(node, 2048 /* Default */)) {
       grammarErrorOnFirstToken(node, Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name);
     }
     checkClassLikeDeclaration(node);
@@ -81682,7 +81759,7 @@ function createTypeChecker(host) {
               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 +81973,7 @@ function createTypeChecker(host) {
     const signatures = getSignaturesOfType(type, 1 /* Construct */);
     if (signatures.length) {
       const declaration = signatures[0].declaration;
-      if (declaration && hasEffectiveModifier(declaration, 8 /* Private */)) {
+      if (declaration && hasEffectiveModifier(declaration, 2 /* Private */)) {
         const typeClassDeclaration = getClassLikeDeclarationOfSymbol(type.symbol);
         if (!isNodeWithinClass(node, typeClassDeclaration)) {
           error2(node, Diagnostics.Cannot_extend_a_class_0_Class_constructor_is_marked_as_private, getFullyQualifiedName(type.symbol));
@@ -81916,7 +81993,7 @@ function createTypeChecker(host) {
     const baseTypes = baseTypeNode && getBaseTypes(type);
     const baseWithThis = (baseTypes == null ? void 0 : baseTypes.length) ? getTypeWithThisArgument(first(baseTypes), type.thisType) : void 0;
     const baseStaticType = getBaseConstructorTypeOfClass(type);
-    const memberHasOverrideModifier = member.parent ? hasOverrideModifier(member) : hasSyntacticModifier(member, 16384 /* Override */);
+    const memberHasOverrideModifier = member.parent ? hasOverrideModifier(member) : hasSyntacticModifier(member, 16 /* Override */);
     return checkMemberForOverrideModifier(
       node,
       staticType,
@@ -81957,7 +82034,7 @@ function createTypeChecker(host) {
         Debug.assert(!!derived, "derived should point to something, even if it is the base class' declaration.");
         if (derived === base) {
           const derivedClassDecl = getClassLikeDeclarationOfSymbol(type.symbol);
-          if (baseDeclarationFlags & 256 /* Abstract */ && (!derivedClassDecl || !hasSyntacticModifier(derivedClassDecl, 256 /* Abstract */))) {
+          if (baseDeclarationFlags & 64 /* Abstract */ && (!derivedClassDecl || !hasSyntacticModifier(derivedClassDecl, 64 /* Abstract */))) {
             for (const otherBaseType of getBaseTypes(type)) {
               if (otherBaseType === baseType)
                 continue;
@@ -82000,7 +82077,7 @@ function createTypeChecker(host) {
           }
         } else {
           const derivedDeclarationFlags = getDeclarationModifierFlagsFromSymbol(derived);
-          if (baseDeclarationFlags & 8 /* Private */ || derivedDeclarationFlags & 8 /* Private */) {
+          if (baseDeclarationFlags & 2 /* Private */ || derivedDeclarationFlags & 2 /* Private */) {
             continue;
           }
           let errorMessage;
@@ -82017,7 +82094,7 @@ function createTypeChecker(host) {
               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 +82121,7 @@ function createTypeChecker(host) {
       }
   }
   function isPropertyAbstractOrInterface(declaration, baseDeclarationFlags) {
-    return baseDeclarationFlags & 256 /* Abstract */ && (!isPropertyDeclaration(declaration) || !declaration.initializer) || isInterfaceDeclaration(declaration.parent);
+    return baseDeclarationFlags & 64 /* Abstract */ && (!isPropertyDeclaration(declaration) || !declaration.initializer) || isInterfaceDeclaration(declaration.parent);
   }
   function getNonInheritedProperties(type, baseTypes, properties) {
     if (!length(baseTypes)) {
@@ -82109,7 +82186,7 @@ function createTypeChecker(host) {
     }
     const constructor = findConstructorDeclaration(node);
     for (const member of node.members) {
-      if (getEffectiveModifierFlags(member) & 2 /* Ambient */) {
+      if (getEffectiveModifierFlags(member) & 128 /* Ambient */) {
         continue;
       }
       if (!isStatic(member) && isPropertyWithoutInitializer(member)) {
@@ -82696,7 +82773,7 @@ function createTypeChecker(host) {
                   name
                 );
               }
-              if (isType && node.kind === 271 /* ImportEqualsDeclaration */ && hasEffectiveModifier(node, 1 /* Export */)) {
+              if (isType && node.kind === 271 /* ImportEqualsDeclaration */ && hasEffectiveModifier(node, 32 /* Export */)) {
                 error2(node, Diagnostics.Cannot_use_export_import_on_a_type_or_type_only_namespace_when_0_is_enabled, isolatedModulesLikeFlagName);
               }
               break;
@@ -82818,7 +82895,7 @@ function createTypeChecker(host) {
     checkGrammarModifiers(node);
     if (isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
       checkImportBinding(node);
-      if (hasSyntacticModifier(node, 1 /* Export */)) {
+      if (hasSyntacticModifier(node, 32 /* Export */)) {
         markExportAsReferenced(node);
       }
       if (node.moduleReference.kind !== 283 /* ExternalModuleReference */) {
@@ -83230,6 +83307,8 @@ function createTypeChecker(host) {
         return checkJSDocAccessibilityModifiers(node);
       case 357 /* JSDocSatisfiesTag */:
         return checkJSDocSatisfiesTag(node);
+      case 350 /* JSDocThisTag */:
+        return checkJSDocThisTag(node);
       case 199 /* IndexedAccessType */:
         return checkIndexedAccessType(node);
       case 200 /* MappedType */:
@@ -84456,7 +84535,7 @@ function createTypeChecker(host) {
         return true;
       }
       const target = getSymbolLinks(symbol).aliasTarget;
-      if (target && getEffectiveModifierFlags(node) & 1 /* Export */ && getSymbolFlags(target) & 111551 /* Value */ && (shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target))) {
+      if (target && getEffectiveModifierFlags(node) & 32 /* Export */ && getSymbolFlags(target) & 111551 /* Value */ && (shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target))) {
         return true;
       }
     }
@@ -84481,10 +84560,10 @@ function createTypeChecker(host) {
     return false;
   }
   function isRequiredInitializedParameter(parameter) {
-    return !!strictNullChecks && !isOptionalParameter(parameter) && !isJSDocParameterTag(parameter) && !!parameter.initializer && !hasSyntacticModifier(parameter, 16476 /* ParameterPropertyModifier */);
+    return !!strictNullChecks && !isOptionalParameter(parameter) && !isJSDocParameterTag(parameter) && !!parameter.initializer && !hasSyntacticModifier(parameter, 31 /* ParameterPropertyModifier */);
   }
   function isOptionalUninitializedParameterProperty(parameter) {
-    return strictNullChecks && isOptionalParameter(parameter) && !parameter.initializer && hasSyntacticModifier(parameter, 16476 /* ParameterPropertyModifier */);
+    return strictNullChecks && isOptionalParameter(parameter) && !parameter.initializer && hasSyntacticModifier(parameter, 31 /* ParameterPropertyModifier */);
   }
   function isExpandoFunctionDeclaration(node) {
     const declaration = getParseTreeNode(node, isFunctionDeclaration);
@@ -85338,10 +85417,10 @@ function createTypeChecker(host) {
             return grammarErrorOnFirstToken(node, Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name);
           }
         }
-        if (flags & ~(1025 /* ExportDefault */ | 131072 /* Decorator */)) {
+        if (flags & ~(2080 /* ExportDefault */ | 32768 /* Decorator */)) {
           return grammarErrorOnNode(modifier, Diagnostics.Decorators_are_not_valid_here);
         }
-        if (hasLeadingDecorators && flags & 126975 /* Modifier */) {
+        if (hasLeadingDecorators && flags & 98303 /* Modifier */) {
           Debug.assertIsDefined(firstDecorator);
           const sourceFile = getSourceFileOfNode(modifier);
           if (!hasParseDiagnostics(sourceFile)) {
@@ -85353,10 +85432,10 @@ function createTypeChecker(host) {
           }
           return false;
         }
-        flags |= 131072 /* Decorator */;
-        if (!(flags & 126975 /* Modifier */)) {
+        flags |= 32768 /* Decorator */;
+        if (!(flags & 98303 /* Modifier */)) {
           hasLeadingDecorators = true;
-        } else if (flags & 1 /* Export */) {
+        } else if (flags & 32 /* Export */) {
           sawExportBeforeDecorators = true;
         }
         firstDecorator ?? (firstDecorator = modifier);
@@ -85385,39 +85464,39 @@ function createTypeChecker(host) {
             }
             break;
           case 164 /* OverrideKeyword */:
-            if (flags & 16384 /* Override */) {
+            if (flags & 16 /* Override */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "override");
-            } else if (flags & 2 /* Ambient */) {
+            } else if (flags & 128 /* Ambient */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "override", "declare");
-            } else if (flags & 64 /* Readonly */) {
+            } else if (flags & 8 /* Readonly */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "override", "readonly");
-            } else if (flags & 128 /* Accessor */) {
+            } else if (flags & 512 /* Accessor */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "override", "accessor");
-            } else if (flags & 512 /* Async */) {
+            } else if (flags & 1024 /* Async */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "override", "async");
             }
-            flags |= 16384 /* Override */;
+            flags |= 16 /* Override */;
             lastOverride = modifier;
             break;
           case 125 /* PublicKeyword */:
           case 124 /* ProtectedKeyword */:
           case 123 /* PrivateKeyword */:
             const text = visibilityToString(modifierToFlag(modifier.kind));
-            if (flags & 28 /* AccessibilityModifier */) {
+            if (flags & 7 /* AccessibilityModifier */) {
               return grammarErrorOnNode(modifier, Diagnostics.Accessibility_modifier_already_seen);
-            } else if (flags & 16384 /* Override */) {
+            } else if (flags & 16 /* Override */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "override");
-            } else if (flags & 32 /* Static */) {
+            } else if (flags & 256 /* Static */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "static");
-            } else if (flags & 128 /* Accessor */) {
+            } else if (flags & 512 /* Accessor */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "accessor");
-            } else if (flags & 64 /* Readonly */) {
+            } else if (flags & 8 /* Readonly */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "readonly");
-            } else if (flags & 512 /* Async */) {
+            } else if (flags & 1024 /* Async */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "async");
             } else if (node.parent.kind === 268 /* ModuleBlock */ || node.parent.kind === 312 /* SourceFile */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, text);
-            } else if (flags & 256 /* Abstract */) {
+            } else if (flags & 64 /* Abstract */) {
               if (modifier.kind === 123 /* PrivateKeyword */) {
                 return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, text, "abstract");
               } else {
@@ -85429,60 +85508,60 @@ function createTypeChecker(host) {
             flags |= modifierToFlag(modifier.kind);
             break;
           case 126 /* StaticKeyword */:
-            if (flags & 32 /* Static */) {
+            if (flags & 256 /* Static */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "static");
-            } else if (flags & 64 /* Readonly */) {
+            } else if (flags & 8 /* Readonly */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "readonly");
-            } else if (flags & 512 /* Async */) {
+            } else if (flags & 1024 /* Async */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "async");
-            } else if (flags & 128 /* Accessor */) {
+            } else if (flags & 512 /* Accessor */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "accessor");
             } else if (node.parent.kind === 268 /* ModuleBlock */ || node.parent.kind === 312 /* SourceFile */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, "static");
             } else if (node.kind === 169 /* Parameter */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static");
-            } else if (flags & 256 /* Abstract */) {
+            } else if (flags & 64 /* Abstract */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
-            } else if (flags & 16384 /* Override */) {
+            } else if (flags & 16 /* Override */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "override");
             }
-            flags |= 32 /* Static */;
+            flags |= 256 /* Static */;
             lastStatic = modifier;
             break;
           case 129 /* AccessorKeyword */:
-            if (flags & 128 /* Accessor */) {
+            if (flags & 512 /* Accessor */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "accessor");
-            } else if (flags & 64 /* Readonly */) {
+            } else if (flags & 8 /* Readonly */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "accessor", "readonly");
-            } else if (flags & 2 /* Ambient */) {
+            } else if (flags & 128 /* Ambient */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "accessor", "declare");
             } else if (node.kind !== 172 /* PropertyDeclaration */) {
               return grammarErrorOnNode(modifier, Diagnostics.accessor_modifier_can_only_appear_on_a_property_declaration);
             }
-            flags |= 128 /* Accessor */;
+            flags |= 512 /* Accessor */;
             break;
           case 148 /* ReadonlyKeyword */:
-            if (flags & 64 /* Readonly */) {
+            if (flags & 8 /* Readonly */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "readonly");
             } else if (node.kind !== 172 /* PropertyDeclaration */ && node.kind !== 171 /* PropertySignature */ && node.kind !== 181 /* IndexSignature */ && node.kind !== 169 /* Parameter */) {
               return grammarErrorOnNode(modifier, Diagnostics.readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature);
-            } else if (flags & 128 /* Accessor */) {
+            } else if (flags & 512 /* Accessor */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "readonly", "accessor");
             }
-            flags |= 64 /* Readonly */;
+            flags |= 8 /* Readonly */;
             break;
           case 95 /* ExportKeyword */:
             if (compilerOptions.verbatimModuleSyntax && !(node.flags & 33554432 /* Ambient */) && node.kind !== 265 /* TypeAliasDeclaration */ && node.kind !== 264 /* InterfaceDeclaration */ && // ModuleDeclaration needs to be checked that it is uninstantiated later
             node.kind !== 267 /* ModuleDeclaration */ && node.parent.kind === 312 /* SourceFile */ && (moduleKind === 1 /* CommonJS */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */)) {
               return grammarErrorOnNode(modifier, Diagnostics.A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled);
             }
-            if (flags & 1 /* Export */) {
+            if (flags & 32 /* Export */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "export");
-            } else if (flags & 2 /* Ambient */) {
+            } else if (flags & 128 /* Ambient */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare");
-            } else if (flags & 256 /* Abstract */) {
+            } else if (flags & 64 /* Abstract */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "abstract");
-            } else if (flags & 512 /* Async */) {
+            } else if (flags & 1024 /* Async */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "async");
             } else if (isClassLike(node.parent)) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_class_elements_of_this_kind, "export");
@@ -85493,7 +85572,7 @@ function createTypeChecker(host) {
             } else if (blockScopeKind === 6 /* AwaitUsing */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_an_await_using_declaration, "export");
             }
-            flags |= 1 /* Export */;
+            flags |= 32 /* Export */;
             break;
           case 90 /* DefaultKeyword */:
             const container = node.parent.kind === 312 /* SourceFile */ ? node.parent : node.parent.parent;
@@ -85503,19 +85582,19 @@ function createTypeChecker(host) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_using_declaration, "default");
             } else if (blockScopeKind === 6 /* AwaitUsing */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_an_await_using_declaration, "default");
-            } else if (!(flags & 1 /* Export */)) {
+            } else if (!(flags & 32 /* Export */)) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "default");
             } else if (sawExportBeforeDecorators) {
               return grammarErrorOnNode(firstDecorator, Diagnostics.Decorators_are_not_valid_here);
             }
-            flags |= 1024 /* Default */;
+            flags |= 2048 /* Default */;
             break;
           case 138 /* DeclareKeyword */:
-            if (flags & 2 /* Ambient */) {
+            if (flags & 128 /* Ambient */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "declare");
-            } else if (flags & 512 /* Async */) {
+            } else if (flags & 1024 /* Async */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
-            } else if (flags & 16384 /* Override */) {
+            } else if (flags & 16 /* Override */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "override");
             } else if (isClassLike(node.parent) && !isPropertyDeclaration(node)) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_class_elements_of_this_kind, "declare");
@@ -85529,62 +85608,62 @@ function createTypeChecker(host) {
               return grammarErrorOnNode(modifier, Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context);
             } else if (isPrivateIdentifierClassElementDeclaration(node)) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "declare");
-            } else if (flags & 128 /* Accessor */) {
+            } else if (flags & 512 /* Accessor */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "declare", "accessor");
             }
-            flags |= 2 /* Ambient */;
+            flags |= 128 /* Ambient */;
             lastDeclare = modifier;
             break;
           case 128 /* AbstractKeyword */:
-            if (flags & 256 /* Abstract */) {
+            if (flags & 64 /* Abstract */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "abstract");
             }
             if (node.kind !== 263 /* ClassDeclaration */ && node.kind !== 185 /* ConstructorType */) {
               if (node.kind !== 174 /* MethodDeclaration */ && node.kind !== 172 /* PropertyDeclaration */ && node.kind !== 177 /* GetAccessor */ && node.kind !== 178 /* SetAccessor */) {
                 return grammarErrorOnNode(modifier, Diagnostics.abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration);
               }
-              if (!(node.parent.kind === 263 /* ClassDeclaration */ && hasSyntacticModifier(node.parent, 256 /* Abstract */))) {
+              if (!(node.parent.kind === 263 /* ClassDeclaration */ && hasSyntacticModifier(node.parent, 64 /* Abstract */))) {
                 const message = node.kind === 172 /* PropertyDeclaration */ ? Diagnostics.Abstract_properties_can_only_appear_within_an_abstract_class : Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class;
                 return grammarErrorOnNode(modifier, message);
               }
-              if (flags & 32 /* Static */) {
+              if (flags & 256 /* Static */) {
                 return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
               }
-              if (flags & 8 /* Private */) {
+              if (flags & 2 /* Private */) {
                 return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract");
               }
-              if (flags & 512 /* Async */ && lastAsync) {
+              if (flags & 1024 /* Async */ && lastAsync) {
                 return grammarErrorOnNode(lastAsync, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "async", "abstract");
               }
-              if (flags & 16384 /* Override */) {
+              if (flags & 16 /* Override */) {
                 return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "abstract", "override");
               }
-              if (flags & 128 /* Accessor */) {
+              if (flags & 512 /* Accessor */) {
                 return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "abstract", "accessor");
               }
             }
             if (isNamedDeclaration(node) && node.name.kind === 81 /* PrivateIdentifier */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "abstract");
             }
-            flags |= 256 /* Abstract */;
+            flags |= 64 /* Abstract */;
             break;
           case 134 /* AsyncKeyword */:
-            if (flags & 512 /* Async */) {
+            if (flags & 1024 /* Async */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "async");
-            } else if (flags & 2 /* Ambient */ || node.parent.flags & 33554432 /* Ambient */) {
+            } else if (flags & 128 /* Ambient */ || node.parent.flags & 33554432 /* Ambient */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
             } else if (node.kind === 169 /* Parameter */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "async");
             }
-            if (flags & 256 /* Abstract */) {
+            if (flags & 64 /* Abstract */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "async", "abstract");
             }
-            flags |= 512 /* Async */;
+            flags |= 1024 /* Async */;
             lastAsync = modifier;
             break;
           case 103 /* InKeyword */:
           case 147 /* OutKeyword */:
-            const inOutFlag = modifier.kind === 103 /* InKeyword */ ? 32768 /* In */ : 65536 /* Out */;
+            const inOutFlag = modifier.kind === 103 /* InKeyword */ ? 8192 /* In */ : 16384 /* Out */;
             const inOutText = modifier.kind === 103 /* InKeyword */ ? "in" : "out";
             if (node.kind !== 168 /* TypeParameter */ || !(isInterfaceDeclaration(node.parent) || isClassLike(node.parent) || isTypeAliasDeclaration(node.parent))) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias, inOutText);
@@ -85592,7 +85671,7 @@ function createTypeChecker(host) {
             if (flags & inOutFlag) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, inOutText);
             }
-            if (inOutFlag & 32768 /* In */ && flags & 65536 /* Out */) {
+            if (inOutFlag & 8192 /* In */ && flags & 16384 /* Out */) {
               return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "in", "out");
             }
             flags |= inOutFlag;
@@ -85601,24 +85680,24 @@ function createTypeChecker(host) {
       }
     }
     if (node.kind === 176 /* Constructor */) {
-      if (flags & 32 /* Static */) {
+      if (flags & 256 /* Static */) {
         return grammarErrorOnNode(lastStatic, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static");
       }
-      if (flags & 16384 /* Override */) {
+      if (flags & 16 /* Override */) {
         return grammarErrorOnNode(lastOverride, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "override");
       }
-      if (flags & 512 /* Async */) {
+      if (flags & 1024 /* Async */) {
         return grammarErrorOnNode(lastAsync, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "async");
       }
       return false;
-    } else if ((node.kind === 272 /* ImportDeclaration */ || node.kind === 271 /* ImportEqualsDeclaration */) && flags & 2 /* Ambient */) {
+    } else if ((node.kind === 272 /* ImportDeclaration */ || node.kind === 271 /* ImportEqualsDeclaration */) && flags & 128 /* Ambient */) {
       return grammarErrorOnNode(lastDeclare, Diagnostics.A_0_modifier_cannot_be_used_with_an_import_declaration, "declare");
-    } else if (node.kind === 169 /* Parameter */ && flags & 16476 /* ParameterPropertyModifier */ && isBindingPattern(node.name)) {
+    } else if (node.kind === 169 /* Parameter */ && flags & 31 /* ParameterPropertyModifier */ && isBindingPattern(node.name)) {
       return grammarErrorOnNode(node, Diagnostics.A_parameter_property_may_not_be_declared_using_a_binding_pattern);
-    } else if (node.kind === 169 /* Parameter */ && flags & 16476 /* ParameterPropertyModifier */ && node.dotDotDotToken) {
+    } else if (node.kind === 169 /* Parameter */ && flags & 31 /* ParameterPropertyModifier */ && node.dotDotDotToken) {
       return grammarErrorOnNode(node, Diagnostics.A_parameter_property_cannot_be_declared_using_a_rest_parameter);
     }
-    if (flags & 512 /* Async */) {
+    if (flags & 1024 /* Async */) {
       return checkGrammarAsyncModifier(node, lastAsync);
     }
     return false;
@@ -86138,12 +86217,12 @@ function createTypeChecker(host) {
       if (languageVersion < 2 /* ES2015 */ && isPrivateIdentifier(accessor.name)) {
         return grammarErrorOnNode(accessor.name, Diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher);
       }
-      if (accessor.body === void 0 && !hasSyntacticModifier(accessor, 256 /* Abstract */)) {
+      if (accessor.body === void 0 && !hasSyntacticModifier(accessor, 64 /* Abstract */)) {
         return grammarErrorAtPos(accessor, accessor.end - 1, ";".length, Diagnostics._0_expected, "{");
       }
     }
     if (accessor.body) {
-      if (hasSyntacticModifier(accessor, 256 /* Abstract */)) {
+      if (hasSyntacticModifier(accessor, 64 /* Abstract */)) {
         return grammarErrorOnNode(accessor, Diagnostics.An_abstract_accessor_cannot_have_an_implementation);
       }
       if (accessor.parent.kind === 187 /* TypeLiteral */ || accessor.parent.kind === 264 /* InterfaceDeclaration */) {
@@ -86215,7 +86294,7 @@ function createTypeChecker(host) {
           }
           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 +86464,7 @@ function createTypeChecker(host) {
       const message = node.initializer ? Diagnostics.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions : !node.type ? Diagnostics.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations : Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context;
       return grammarErrorOnNode(node.exclamationToken, message);
     }
-    if ((moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */) && moduleKind !== 4 /* System */ && !(node.parent.parent.flags & 33554432 /* Ambient */) && hasSyntacticModifier(node.parent.parent, 1 /* Export */)) {
+    if ((moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */) && moduleKind !== 4 /* System */ && !(node.parent.parent.flags & 33554432 /* Ambient */) && hasSyntacticModifier(node.parent.parent, 32 /* Export */)) {
       checkESModuleMarker(node.name);
     }
     return !!blockScopeKind && checkGrammarNameInLetOrConstDeclarations(node.name);
@@ -86575,7 +86654,7 @@ function createTypeChecker(host) {
     }
   }
   function checkGrammarTopLevelElementForRequiredDeclareModifier(node) {
-    if (node.kind === 264 /* InterfaceDeclaration */ || node.kind === 265 /* TypeAliasDeclaration */ || node.kind === 272 /* ImportDeclaration */ || node.kind === 271 /* ImportEqualsDeclaration */ || node.kind === 278 /* ExportDeclaration */ || node.kind === 277 /* ExportAssignment */ || node.kind === 270 /* NamespaceExportDeclaration */ || hasSyntacticModifier(node, 2 /* Ambient */ | 1 /* Export */ | 1024 /* Default */)) {
+    if (node.kind === 264 /* InterfaceDeclaration */ || node.kind === 265 /* TypeAliasDeclaration */ || node.kind === 272 /* ImportDeclaration */ || node.kind === 271 /* ImportEqualsDeclaration */ || node.kind === 278 /* ExportDeclaration */ || node.kind === 277 /* ExportAssignment */ || node.kind === 270 /* NamespaceExportDeclaration */ || hasSyntacticModifier(node, 128 /* Ambient */ | 32 /* Export */ | 2048 /* Default */)) {
       return false;
     }
     return grammarErrorOnFirstToken(node, Diagnostics.Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier);
@@ -87021,12 +87100,14 @@ var init_checker = __esm({
         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 +89170,15 @@ function collectExternalModuleInfo(context, sourceFile) {
         }
         break;
       case 243 /* VariableStatement */:
-        if (hasSyntacticModifier(node, 1 /* Export */)) {
+        if (hasSyntacticModifier(node, 32 /* Export */)) {
           for (const decl of node.declarationList.declarations) {
             exportedNames = collectExportedVariableInfo(decl, uniqueExports, exportedNames, exportedBindings);
           }
         }
         break;
       case 262 /* FunctionDeclaration */:
-        if (hasSyntacticModifier(node, 1 /* Export */)) {
-          if (hasSyntacticModifier(node, 1024 /* Default */)) {
+        if (hasSyntacticModifier(node, 32 /* Export */)) {
+          if (hasSyntacticModifier(node, 2048 /* Default */)) {
             if (!hasExportDefault) {
               multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), context.factory.getDeclarationName(node));
               hasExportDefault = true;
@@ -89113,8 +89194,8 @@ function collectExternalModuleInfo(context, sourceFile) {
         }
         break;
       case 263 /* ClassDeclaration */:
-        if (hasSyntacticModifier(node, 1 /* Export */)) {
-          if (hasSyntacticModifier(node, 1024 /* Default */)) {
+        if (hasSyntacticModifier(node, 32 /* Export */)) {
+          if (hasSyntacticModifier(node, 2048 /* Default */)) {
             if (!hasExportDefault) {
               multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), context.factory.getDeclarationName(node));
               hasExportDefault = true;
@@ -90004,7 +90085,7 @@ var init_classThis = __esm({
 // 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 +90456,13 @@ function transformTypeScript(context) {
         break;
       case 263 /* ClassDeclaration */:
       case 262 /* FunctionDeclaration */:
-        if (hasSyntacticModifier(node, 2 /* Ambient */)) {
+        if (hasSyntacticModifier(node, 128 /* Ambient */)) {
           break;
         }
         if (node.name) {
           recordEmittedDeclarationInScope(node);
         } else {
-          Debug.assert(node.kind === 263 /* ClassDeclaration */ || hasSyntacticModifier(node, 1024 /* Default */));
+          Debug.assert(node.kind === 263 /* ClassDeclaration */ || hasSyntacticModifier(node, 2048 /* Default */));
         }
         break;
     }
@@ -90436,7 +90517,7 @@ function transformTypeScript(context) {
   function namespaceElementVisitorWorker(node) {
     if (node.kind === 278 /* ExportDeclaration */ || node.kind === 272 /* ImportDeclaration */ || node.kind === 273 /* ImportClause */ || node.kind === 271 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 283 /* ExternalModuleReference */) {
       return void 0;
-    } else if (node.transformFlags & 1 /* ContainsTypeScript */ || hasSyntacticModifier(node, 1 /* Export */)) {
+    } else if (node.transformFlags & 1 /* ContainsTypeScript */ || hasSyntacticModifier(node, 32 /* Export */)) {
       return visitTypeScript(node);
     }
     return node;
@@ -90494,7 +90575,7 @@ function transformTypeScript(context) {
   function modifierVisitor(node) {
     if (isDecorator(node))
       return void 0;
-    if (modifierToFlag(node.kind) & 117086 /* TypeScriptModifier */) {
+    if (modifierToFlag(node.kind) & 28895 /* TypeScriptModifier */) {
       return void 0;
     } else if (currentNamespace && node.kind === 95 /* ExportKeyword */) {
       return void 0;
@@ -90502,7 +90583,7 @@ function transformTypeScript(context) {
     return node;
   }
   function visitTypeScript(node) {
-    if (isStatement(node) && hasSyntacticModifier(node, 2 /* Ambient */)) {
+    if (isStatement(node) && hasSyntacticModifier(node, 128 /* Ambient */)) {
       return factory2.createNotEmittedStatement(node);
     }
     switch (node.kind) {
@@ -90992,7 +91073,7 @@ function transformTypeScript(context) {
     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 +91082,7 @@ function transformTypeScript(context) {
     if (isAmbient) {
       return factory2.updatePropertyDeclaration(
         node,
-        concatenate(modifiers, factory2.createModifiersFromModifierFlags(2 /* Ambient */)),
+        concatenate(modifiers, factory2.createModifiersFromModifierFlags(128 /* Ambient */)),
         Debug.checkDefined(visitNode(node.name, visitor, isPropertyName)),
         /*questionOrExclamationToken*/
         void 0,
@@ -91164,7 +91245,7 @@ function transformTypeScript(context) {
     );
   }
   function shouldEmitAccessorDeclaration(node) {
-    return !(nodeIsMissing(node.body) && hasSyntacticModifier(node, 256 /* Abstract */));
+    return !(nodeIsMissing(node.body) && hasSyntacticModifier(node, 64 /* Abstract */));
   }
   function visitGetAccessor(node, parent2) {
     if (!(node.transformFlags & 1 /* ContainsTypeScript */)) {
@@ -91897,16 +91978,16 @@ function transformTypeScript(context) {
     }
   }
   function isExportOfNamespace(node) {
-    return currentNamespace !== void 0 && hasSyntacticModifier(node, 1 /* Export */);
+    return currentNamespace !== void 0 && hasSyntacticModifier(node, 32 /* Export */);
   }
   function isExternalModuleExport(node) {
-    return currentNamespace === void 0 && hasSyntacticModifier(node, 1 /* Export */);
+    return currentNamespace === void 0 && hasSyntacticModifier(node, 32 /* Export */);
   }
   function isNamedExternalModuleExport(node) {
-    return isExternalModuleExport(node) && !hasSyntacticModifier(node, 1024 /* Default */);
+    return isExternalModuleExport(node) && !hasSyntacticModifier(node, 2048 /* Default */);
   }
   function isDefaultExternalModuleExport(node) {
-    return isExternalModuleExport(node) && hasSyntacticModifier(node, 1024 /* Default */);
+    return isExternalModuleExport(node) && hasSyntacticModifier(node, 2048 /* Default */);
   }
   function createExportMemberAssignmentStatement(node) {
     const expression = factory2.createAssignment(
@@ -93247,8 +93328,8 @@ function transformClassFields(context) {
       getClassLexicalEnvironment().classThis = node.emitNode.classThis;
     }
     const isClassWithConstructorReference = resolver.getNodeCheckFlags(node) & 262144 /* ContainsConstructorReference */;
-    const isExport = hasSyntacticModifier(node, 1 /* Export */);
-    const isDefault = hasSyntacticModifier(node, 1024 /* Default */);
+    const isExport = hasSyntacticModifier(node, 32 /* Export */);
+    const isDefault = hasSyntacticModifier(node, 2048 /* Default */);
     let modifiers = visitNodes2(node.modifiers, modifierVisitor, isModifier);
     const heritageClauses = visitNodes2(node.heritageClauses, heritageClauseVisitor, isHeritageClause);
     const { members, prologue } = transformClassMembers(node);
@@ -93794,7 +93875,7 @@ function transformClassFields(context) {
       return void 0;
     }
     const propertyOriginalNode = getOriginalNode(property);
-    if (hasSyntacticModifier(propertyOriginalNode, 256 /* Abstract */)) {
+    if (hasSyntacticModifier(propertyOriginalNode, 64 /* Abstract */)) {
       return void 0;
     }
     let initializer = visitNode(property.initializer, visitor, isExpression);
@@ -94842,8 +94923,8 @@ function transformLegacyDecorators(context) {
     return addRange([updated], decorationStatements);
   }
   function transformClassDeclarationWithClassDecorators(node, name) {
-    const isExport = hasSyntacticModifier(node, 1 /* Export */);
-    const isDefault = hasSyntacticModifier(node, 1024 /* Default */);
+    const isExport = hasSyntacticModifier(node, 32 /* Export */);
+    const isDefault = hasSyntacticModifier(node, 2048 /* Default */);
     const modifiers = visitNodes2(node.modifiers, (node2) => isExportOrDefaultModifier(node2) || isDecorator(node2) ? void 0 : node2, isModifierLike);
     const location = moveRangePastModifiers(node);
     const classAlias = getClassAliasIfNeeded(node);
@@ -94864,7 +94945,7 @@ function transformLegacyDecorators(context) {
     let members = visitNodes2(node.members, visitor, isClassElement);
     let decorationStatements = [];
     ({ members, decorationStatements } = transformDecoratorsOfClassElements(node, members));
-    const assignClassAliasInStaticBlock = languageVersion >= 9 /* ES2022 */ && !!classAlias && some(members, (member) => isPropertyDeclaration(member) && hasSyntacticModifier(member, 32 /* Static */) || isClassStaticBlockDeclaration(member));
+    const assignClassAliasInStaticBlock = languageVersion >= 9 /* ES2022 */ && !!classAlias && some(members, (member) => isPropertyDeclaration(member) && hasSyntacticModifier(member, 256 /* Static */) || isClassStaticBlockDeclaration(member));
     if (assignClassAliasInStaticBlock) {
       members = setTextRange(
         factory2.createNodeArray([
@@ -94995,7 +95076,7 @@ function transformLegacyDecorators(context) {
     );
   }
   function visitPropertyDeclaration(node) {
-    if (node.flags & 33554432 /* Ambient */ || hasSyntacticModifier(node, 2 /* Ambient */)) {
+    if (node.flags & 33554432 /* Ambient */ || hasSyntacticModifier(node, 128 /* Ambient */)) {
       return void 0;
     }
     return finishClassElement(
@@ -95083,7 +95164,7 @@ function transformLegacyDecorators(context) {
     const memberName = getExpressionForPropertyName(
       member,
       /*generateNameForComputedPropertyName*/
-      !hasSyntacticModifier(member, 2 /* Ambient */)
+      !hasSyntacticModifier(member, 128 /* Ambient */)
     );
     const descriptor = languageVersion > 0 /* ES3 */ ? isPropertyDeclaration(member) && !hasAccessorModifier(member) ? factory2.createVoidZero() : factory2.createNull() : void 0;
     const helper = emitHelpers().createDecorateHelper(
@@ -95872,8 +95953,8 @@ function transformESDecorators(context) {
       const statements = [];
       const originalClass = getOriginalNode(node, isClassLike) ?? node;
       const className = originalClass.name ? factory2.createStringLiteralFromNode(originalClass.name) : factory2.createStringLiteral("default");
-      const isExport = hasSyntacticModifier(node, 1 /* Export */);
-      const isDefault = hasSyntacticModifier(node, 1024 /* Default */);
+      const isExport = hasSyntacticModifier(node, 32 /* Export */);
+      const isDefault = hasSyntacticModifier(node, 2048 /* Default */);
       if (!node.name) {
         node = injectClassNamedEvaluationHelperBlockIfMissing(context, node, className);
       }
@@ -98196,7 +98277,7 @@ function transformES2018(context) {
     return visitEachChild(node, visitor, context);
   }
   function visitVariableStatement(node) {
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
       const savedExportedVariableStatement = exportedVariableStatement;
       exportedVariableStatement = true;
       const visited = visitEachChild(node, visitor, context);
@@ -99432,7 +99513,7 @@ function transformESNext(context) {
       addRange(topLevelStatements, endLexicalEnvironment());
       if (exportVars.length) {
         topLevelStatements.push(factory2.createVariableStatement(
-          factory2.createModifiersFromModifierFlags(1 /* Export */),
+          factory2.createModifiersFromModifierFlags(32 /* Export */),
           factory2.createVariableDeclarationList(
             exportVars,
             1 /* Let */
@@ -99729,8 +99810,8 @@ function transformESNext(context) {
     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 +99859,7 @@ function transformESNext(context) {
   }
   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 +101410,8 @@ function transformES2015(context) {
     setTextRange(statement, node);
     startOnNewLine(statement);
     statements.push(statement);
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
-      const exportStatement = hasSyntacticModifier(node, 1024 /* Default */) ? factory2.createExportDefault(factory2.getLocalName(node)) : factory2.createExternalModuleExport(factory2.getLocalName(node));
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
+      const exportStatement = hasSyntacticModifier(node, 2048 /* Default */) ? factory2.createExportDefault(factory2.getLocalName(node)) : factory2.createExternalModuleExport(factory2.getLocalName(node));
       setOriginalNode(exportStatement, statement);
       statements.push(exportStatement);
     }
@@ -102522,7 +102603,7 @@ function transformES2015(context) {
     return node.declarationList.declarations.length === 1 && !!node.declarationList.declarations[0].initializer && !!(getInternalEmitFlags(node.declarationList.declarations[0].initializer) & 1 /* TypeScriptClassWrapper */);
   }
   function visitVariableStatement(node) {
-    const ancestorFacts = enterSubtree(0 /* None */, hasSyntacticModifier(node, 1 /* Export */) ? 32 /* ExportedVariableStatement */ : 0 /* None */);
+    const ancestorFacts = enterSubtree(0 /* None */, hasSyntacticModifier(node, 32 /* Export */) ? 32 /* ExportedVariableStatement */ : 0 /* None */);
     let updated;
     if (convertedLoopState && (node.declarationList.flags & 7 /* BlockScoped */) === 0 && !isVariableStatementOfTypeScriptClassWrapper(node)) {
       let assignments;
@@ -107489,7 +107570,7 @@ function transformModule(context) {
     Debug.assert(isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer.");
     let statements;
     if (moduleKind !== 2 /* AMD */) {
-      if (hasSyntacticModifier(node, 1 /* Export */)) {
+      if (hasSyntacticModifier(node, 32 /* Export */)) {
         statements = append(
           statements,
           setOriginalNode(
@@ -107535,7 +107616,7 @@ function transformModule(context) {
         );
       }
     } else {
-      if (hasSyntacticModifier(node, 1 /* Export */)) {
+      if (hasSyntacticModifier(node, 32 /* Export */)) {
         statements = append(
           statements,
           setOriginalNode(
@@ -107673,7 +107754,7 @@ function transformModule(context) {
   }
   function visitFunctionDeclaration(node) {
     let statements;
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
       statements = append(
         statements,
         setOriginalNode(
@@ -107710,7 +107791,7 @@ function transformModule(context) {
   }
   function visitClassDeclaration(node) {
     let statements;
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
       statements = append(
         statements,
         setOriginalNode(
@@ -107744,7 +107825,7 @@ function transformModule(context) {
     let statements;
     let variables;
     let expressions;
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
       let modifiers;
       let removeCommentsOnExpressions = false;
       for (const variable of node.declarationList.declarations) {
@@ -107930,8 +108011,8 @@ function transformModule(context) {
       return statements;
     }
     const seen = new IdentifierNameMap();
-    if (hasSyntacticModifier(decl, 1 /* Export */)) {
-      const exportName = hasSyntacticModifier(decl, 1024 /* Default */) ? factory2.createIdentifier("default") : factory2.getDeclarationName(decl);
+    if (hasSyntacticModifier(decl, 32 /* Export */)) {
+      const exportName = hasSyntacticModifier(decl, 2048 /* Default */) ? factory2.createIdentifier("default") : factory2.getDeclarationName(decl);
       statements = appendExportStatement(
         statements,
         seen,
@@ -108425,7 +108506,7 @@ function transformSystemModule(context) {
     addRange(statements, hoistedStatements);
     insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
     const exportStarFunction = addExportStarIfNeeded(statements);
-    const modifiers = node.transformFlags & 2097152 /* ContainsAwait */ ? factory2.createModifiersFromModifierFlags(512 /* Async */) : void 0;
+    const modifiers = node.transformFlags & 2097152 /* ContainsAwait */ ? factory2.createModifiersFromModifierFlags(1024 /* Async */) : void 0;
     const moduleObject = factory2.createObjectLiteralExpression(
       [
         factory2.createPropertyAssignment("setters", createSettersArray(exportStarFunction, dependencyGroups)),
@@ -108627,7 +108708,7 @@ function transformSystemModule(context) {
                 factory2.createAssignment(importVariableName, parameterName)
               )
             );
-            if (hasSyntacticModifier(entry, 1 /* Export */)) {
+            if (hasSyntacticModifier(entry, 32 /* Export */)) {
               statements.push(
                 factory2.createExpressionStatement(
                   factory2.createCallExpression(
@@ -108780,7 +108861,7 @@ function transformSystemModule(context) {
     );
   }
   function visitFunctionDeclaration(node) {
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
       hoistedStatements = append(
         hoistedStatements,
         factory2.updateFunctionDeclaration(
@@ -108867,7 +108948,7 @@ function transformSystemModule(context) {
       statements = append(statements, factory2.updateVariableStatement(node, modifiers, declarationList));
     } else {
       let expressions;
-      const isExportedDeclaration = hasSyntacticModifier(node, 1 /* Export */);
+      const isExportedDeclaration = hasSyntacticModifier(node, 32 /* Export */);
       for (const variable of node.declarationList.declarations) {
         if (variable.initializer) {
           expressions = append(expressions, transformInitializedVariable(variable, isExportedDeclaration));
@@ -109003,8 +109084,8 @@ function transformSystemModule(context) {
       return statements;
     }
     let excludeName;
-    if (hasSyntacticModifier(decl, 1 /* Export */)) {
-      const exportName = hasSyntacticModifier(decl, 1024 /* Default */) ? factory2.createStringLiteral("default") : decl.name;
+    if (hasSyntacticModifier(decl, 32 /* Export */)) {
+      const exportName = hasSyntacticModifier(decl, 2048 /* Default */) ? factory2.createStringLiteral("default") : decl.name;
       statements = appendExportStatement(statements, exportName, factory2.getLocalName(decl));
       excludeName = getTextOfIdentifierOrLiteral(exportName);
     }
@@ -109755,7 +109836,7 @@ function transformECMAScriptModule(context) {
     return singleOrMany(statements);
   }
   function appendExportsOfImportEqualsDeclaration(statements, node) {
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
       statements = append(
         statements,
         factory2.createExportDeclaration(
@@ -109977,7 +110058,7 @@ function createGetSymbolAccessibilityDiagnosticForNode(node) {
   } else if (isConstructSignatureDeclaration(node) || isCallSignatureDeclaration(node) || isMethodDeclaration(node) || isMethodSignature(node) || isFunctionDeclaration(node) || isIndexSignatureDeclaration(node)) {
     return getReturnTypeVisibilityError;
   } else if (isParameter(node)) {
-    if (isParameterPropertyDeclaration(node, node.parent) && hasSyntacticModifier(node.parent, 8 /* Private */)) {
+    if (isParameterPropertyDeclaration(node, node.parent) && hasSyntacticModifier(node.parent, 2 /* Private */)) {
       return getVariableDeclarationTypeVisibilityError;
     }
     return getParameterDeclarationTypeVisibilityError;
@@ -109995,7 +110076,7 @@ function createGetSymbolAccessibilityDiagnosticForNode(node) {
   function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult) {
     if (node.kind === 260 /* VariableDeclaration */ || node.kind === 208 /* BindingElement */) {
       return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Exported_variable_0_has_or_is_using_private_name_1;
-    } else if (node.kind === 172 /* PropertyDeclaration */ || node.kind === 211 /* PropertyAccessExpression */ || node.kind === 212 /* ElementAccessExpression */ || node.kind === 226 /* BinaryExpression */ || node.kind === 171 /* PropertySignature */ || node.kind === 169 /* Parameter */ && hasSyntacticModifier(node.parent, 8 /* Private */)) {
+    } else if (node.kind === 172 /* PropertyDeclaration */ || node.kind === 211 /* PropertyAccessExpression */ || node.kind === 212 /* ElementAccessExpression */ || node.kind === 226 /* BinaryExpression */ || node.kind === 171 /* PropertySignature */ || node.kind === 169 /* Parameter */ && hasSyntacticModifier(node.parent, 2 /* Private */)) {
       if (isStatic(node)) {
         return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1;
       } else if (node.parent.kind === 263 /* ClassDeclaration */ || node.kind === 169 /* Parameter */) {
@@ -110721,7 +110802,7 @@ function transformDeclarations(context) {
     return void 0;
   }
   function ensureType(node, type, ignorePrivate) {
-    if (!ignorePrivate && hasEffectiveModifier(node, 8 /* Private */)) {
+    if (!ignorePrivate && hasEffectiveModifier(node, 2 /* Private */)) {
       return;
     }
     if (shouldPrintWithInitializer(node)) {
@@ -110801,7 +110882,7 @@ function transformDeclarations(context) {
     }
   }
   function updateParamsList(node, params, modifierMask) {
-    if (hasEffectiveModifier(node, 8 /* Private */)) {
+    if (hasEffectiveModifier(node, 2 /* Private */)) {
       return factory2.createNodeArray();
     }
     const newParams = map(params, (p) => ensureParameter(p, modifierMask));
@@ -110846,7 +110927,7 @@ function transformDeclarations(context) {
     return factory2.createNodeArray(newParams || emptyArray);
   }
   function ensureTypeParams(node, params) {
-    return hasEffectiveModifier(node, 8 /* Private */) ? void 0 : visitNodes2(params, visitDeclarationSubtree, isTypeParameterDeclaration);
+    return hasEffectiveModifier(node, 2 /* Private */) ? void 0 : visitNodes2(params, visitDeclarationSubtree, isTypeParameterDeclaration);
   }
   function isEnclosingDeclaration(node) {
     return isSourceFile(node) || isTypeAliasDeclaration(node) || isModuleDeclaration(node) || isClassDeclaration(node) || isInterfaceDeclaration(node) || isFunctionLike(node) || isIndexSignatureDeclaration(node) || isMappedTypeNode(node);
@@ -111032,7 +111113,7 @@ function transformDeclarations(context) {
     const oldWithinObjectLiteralType = suppressNewDiagnosticContexts;
     let shouldEnterSuppressNewDiagnosticsContextContext = (input.kind === 187 /* TypeLiteral */ || input.kind === 200 /* MappedType */) && input.parent.kind !== 265 /* TypeAliasDeclaration */;
     if (isMethodDeclaration(input) || isMethodSignature(input)) {
-      if (hasEffectiveModifier(input, 8 /* Private */)) {
+      if (hasEffectiveModifier(input, 2 /* Private */)) {
         if (input.symbol && input.symbol.declarations && input.symbol.declarations[0] !== input)
           return;
         return cleanup(factory2.createPropertyDeclaration(
@@ -111120,7 +111201,7 @@ function transformDeclarations(context) {
             input,
             ensureModifiers(input),
             input.name,
-            updateAccessorParamsList(input, hasEffectiveModifier(input, 8 /* Private */)),
+            updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
             ensureType(input, accessorType),
             /*body*/
             void 0
@@ -111137,7 +111218,7 @@ function transformDeclarations(context) {
             input,
             ensureModifiers(input),
             input.name,
-            updateAccessorParamsList(input, hasEffectiveModifier(input, 8 /* Private */)),
+            updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
             /*body*/
             void 0
           ));
@@ -111294,7 +111375,7 @@ function transformDeclarations(context) {
     }
   }
   function isPrivateMethodTypeParameter(node) {
-    return node.parent.kind === 174 /* MethodDeclaration */ && hasEffectiveModifier(node.parent, 8 /* Private */);
+    return node.parent.kind === 174 /* MethodDeclaration */ && hasEffectiveModifier(node.parent, 2 /* Private */);
   }
   function visitDeclarationStatements(input) {
     if (!isPreservedDeclarationStatement(input)) {
@@ -111353,10 +111434,10 @@ function transformDeclarations(context) {
     return input;
   }
   function stripExportModifiers(statement) {
-    if (isImportEqualsDeclaration(statement) || hasEffectiveModifier(statement, 1024 /* Default */) || !canHaveModifiers(statement)) {
+    if (isImportEqualsDeclaration(statement) || hasEffectiveModifier(statement, 2048 /* Default */) || !canHaveModifiers(statement)) {
       return statement;
     }
-    const modifiers = factory2.createModifiersFromModifierFlags(getEffectiveModifierFlags(statement) & (258047 /* All */ ^ 1 /* Export */));
+    const modifiers = factory2.createModifiersFromModifierFlags(getEffectiveModifierFlags(statement) & (131071 /* All */ ^ 32 /* Export */));
     return factory2.replaceModifiers(statement, modifiers);
   }
   function updateModuleDeclarationAndKeyword(node, modifiers, name, body) {
@@ -111506,10 +111587,10 @@ function transformDeclarations(context) {
             ));
           }
           const namespaceDecl = factory2.createModuleDeclaration(ensureModifiers(input), input.name, factory2.createModuleBlock(declarations), 32 /* Namespace */);
-          if (!hasEffectiveModifier(clean2, 1024 /* Default */)) {
+          if (!hasEffectiveModifier(clean2, 2048 /* Default */)) {
             return [clean2, namespaceDecl];
           }
-          const modifiers = factory2.createModifiersFromModifierFlags(getEffectiveModifierFlags(clean2) & ~1025 /* ExportDefault */ | 2 /* Ambient */);
+          const modifiers = factory2.createModifiersFromModifierFlags(getEffectiveModifierFlags(clean2) & ~2080 /* ExportDefault */ | 128 /* Ambient */);
           const cleanDeclaration = factory2.updateFunctionDeclaration(
             clean2,
             modifiers,
@@ -111601,7 +111682,7 @@ function transformDeclarations(context) {
         if (ctor) {
           const oldDiag2 = getSymbolAccessibilityDiagnostic;
           parameterProperties = compact(flatMap(ctor.parameters, (param) => {
-            if (!hasSyntacticModifier(param, 16476 /* ParameterPropertyModifier */) || shouldStripInternal(param))
+            if (!hasSyntacticModifier(param, 31 /* ParameterPropertyModifier */) || shouldStripInternal(param))
               return;
             getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(param);
             if (param.name.kind === 80 /* Identifier */) {
@@ -111830,11 +111911,11 @@ function transformDeclarations(context) {
     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 +111957,13 @@ function isAlwaysType(node) {
 function maskModifiers(factory2, node, modifierMask, modifierAdditions) {
   return factory2.createModifiersFromModifierFlags(maskModifierFlags(node, modifierMask, modifierAdditions));
 }
-function maskModifierFlags(node, modifierMask = 258047 /* All */ ^ 4 /* Public */, modifierAdditions = 0 /* None */) {
+function maskModifierFlags(node, modifierMask = 131071 /* All */ ^ 1 /* Public */, modifierAdditions = 0 /* None */) {
   let flags = getEffectiveModifierFlags(node) & modifierMask | modifierAdditions;
-  if (flags & 1024 /* Default */ && !(flags & 1 /* Export */)) {
-    flags ^= 1 /* Export */;
+  if (flags & 2048 /* Default */ && !(flags & 32 /* Export */)) {
+    flags ^= 32 /* Export */;
   }
-  if (flags & 1024 /* Default */ && flags & 2 /* Ambient */) {
-    flags ^= 2 /* Ambient */;
+  if (flags & 2048 /* Default */ && flags & 128 /* Ambient */) {
+    flags ^= 128 /* Ambient */;
   }
   return flags;
 }
@@ -111895,7 +111976,7 @@ function canHaveLiteralInitializer(node) {
   switch (node.kind) {
     case 172 /* PropertyDeclaration */:
     case 171 /* PropertySignature */:
-      return !hasEffectiveModifier(node, 8 /* Private */);
+      return !hasEffectiveModifier(node, 2 /* Private */);
     case 169 /* Parameter */:
     case 260 /* VariableDeclaration */:
       return true;
@@ -120628,7 +120709,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
           }
         }
       } else if (isModuleDeclaration(node)) {
-        if (isAmbientModule(node) && (inAmbientModule || hasSyntacticModifier(node, 2 /* Ambient */) || file.isDeclarationFile)) {
+        if (isAmbientModule(node) && (inAmbientModule || hasSyntacticModifier(node, 128 /* Ambient */) || file.isDeclarationFile)) {
           node.name.parent = node;
           const nameText = getTextOfIdentifierOrLiteral(node.name);
           if (isExternalModuleFile || inAmbientModule && !isExternalModuleNameRelative(nameText)) {
@@ -129876,7 +129957,7 @@ function getNodeKind(node) {
     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 +130860,19 @@ function nodeHasTokens(n, sourceFile) {
 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 +132250,7 @@ function isNonGlobalDeclaration(declaration) {
   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 +133934,7 @@ var init_documentHighlights = __esm({
           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 +133948,12 @@ var init_documentHighlights = __esm({
           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 +136447,7 @@ function getItemName(node, name) {
     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 +136597,7 @@ function getFunctionOrClassName(node) {
     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 +136757,15 @@ var require_convertExport = __commonJS({
       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 +137753,7 @@ var require_moveToNewFile = __commonJS({
           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 +137899,7 @@ function getTargetFileImportsAndAddExportInOldFile(oldFile, targetFile, importsT
       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 +138139,7 @@ function addExports(sourceFile, toMove, needExport, useEs6Exports) {
 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 +138434,7 @@ function isPureImport(node) {
     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 +138605,7 @@ function moveStatementsToTargetFile(changes, program, statements, targetFile, to
     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 +139271,7 @@ var require_convertArrowFunctionOrFunctionExpression = __commonJS({
       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 +140610,7 @@ function getRangeToExtract(sourceFile, span, invoked = true) {
       }
       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 +141618,7 @@ function collectReadsAndWrites(targetRange, scopes, enclosingTextRange, sourceFi
     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 +142238,14 @@ function collectTokens(program, sourceFile, span, collector, cancellationToken)
           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 +144377,7 @@ var init_services = __esm({
               forEachChild(node, visit);
               break;
             case 169 /* Parameter */:
-              if (!hasSyntacticModifier(node, 16476 /* ParameterPropertyModifier */)) {
+              if (!hasSyntacticModifier(node, 31 /* ParameterPropertyModifier */)) {
                 break;
               }
             case 260 /* VariableDeclaration */:
@@ -144783,7 +144864,7 @@ function spanInSourceFileAtLocation(sourceFile, position) {
       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 +144872,7 @@ function spanInSourceFileAtLocation(sourceFile, position) {
       }
     }
     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 +144891,7 @@ function spanInSourceFileAtLocation(sourceFile, position) {
       }
     }
     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 +145462,7 @@ function collectCallSitesOfSourceFile(node, collect) {
   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 +145807,7 @@ var require_addMissingAsync = __commonJS({
           /*includeTrivia*/
           true
         ),
-        factory.createNodeArray(factory.createModifiersFromModifierFlags(getSyntacticModifierFlags(insertionSite) | 512 /* Async */))
+        factory.createNodeArray(factory.createModifiersFromModifierFlags(getSyntacticModifierFlags(insertionSite) | 1024 /* Async */))
       );
       changeTracker.replaceNode(
         sourceFile,
@@ -145858,7 +145939,7 @@ var require_addMissingAwait = __commonJS({
         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 +148690,7 @@ var require_fixClassIncorrectlyImplementsInterface = __commonJS({
       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 +150720,7 @@ var require_fixSpelling = __commonJS({
         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 +150901,7 @@ var require_returnValueCorrect = __commonJS({
       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 +151122,13 @@ var require_fixAddMissingMember = __commonJS({
                 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 +151209,13 @@ var require_fixAddMissingMember = __commonJS({
         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 +151227,7 @@ var require_fixAddMissingMember = __commonJS({
         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 +151245,11 @@ var require_fixAddMissingMember = __commonJS({
       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 +151293,15 @@ var require_fixAddMissingMember = __commonJS({
     }
     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 +151388,9 @@ var require_fixAddMissingMember = __commonJS({
       }
       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 +151827,7 @@ var require_fixClassDoesntImplementInheritedAbstractMember = __commonJS({
     }
     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 +154304,10 @@ function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, con
   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 +154986,24 @@ function createAccessorAccessExpression(fieldName, isStatic2, container) {
   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, start2, end, considerEmptySpans = true) {
   const node = getTokenAtPosition(file, start2);
   const cursorRequest = start2 === 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, start2, end) || cursorRequest)) {
     return {
       error: getLocaleSpecificMessage(Diagnostics.Could_not_find_property_for_which_to_generate_accessor)
@@ -154933,7 +155014,7 @@ function getAccessorConvertiblePropertyAtPosition(file, program, start2, end, co
       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 +155402,7 @@ var require_fixStrictClassInitialization = __commonJS({
         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 +157258,7 @@ function getEntryForMemberCompletion(host, program, options, preferences, name,
   }
   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 +157277,10 @@ function getEntryForMemberCompletion(host, program, options, preferences, name,
     (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 +157294,21 @@ function getEntryForMemberCompletion(host, program, options, preferences, name,
   );
   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 +157345,7 @@ function getPresentModifiers(contextToken, sourceFile, position) {
   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 +159086,24 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
     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 +159406,10 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
       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 +159418,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
       }
     }
     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 +159667,7 @@ function getApparentProperties(type, node, checker) {
   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 +159827,7 @@ function isProbablyGlobalType(type, sourceFile, checker) {
   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 +161038,7 @@ function getImportersForExport(sourceFiles, sourceFilesSet, allDirectImports, {
             handleNamespaceImport(
               direct,
               direct.name,
-              hasSyntacticModifier(direct, 1 /* Export */),
+              hasSyntacticModifier(direct, 32 /* Export */),
               /*alreadyAddedDirect*/
               false
             );
@@ -161272,7 +161353,7 @@ function getImportOrExportSymbol(node, symbol, checker, comingFromExport) {
       }
     } 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 +161430,7 @@ function getImportOrExportSymbol(node, symbol, checker, comingFromExport) {
     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 +161574,7 @@ function getContextNodeForNodeEntry(node) {
   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 +162557,7 @@ var init_findAllReferences = __esm({
           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 +163067,7 @@ var init_findAllReferences = __esm({
         if (!searchSpaceNode) {
           return void 0;
         }
-        let staticFlag = 32 /* Static */;
+        let staticFlag = 256 /* Static */;
         switch (searchSpaceNode.kind) {
           case 172 /* PropertyDeclaration */:
           case 171 /* PropertySignature */:
@@ -163026,7 +163107,7 @@ var init_findAllReferences = __esm({
           /*includeClassComputedPropertyName*/
           false
         );
-        let staticFlag = 32 /* Static */;
+        let staticFlag = 256 /* Static */;
         switch (searchSpaceNode.kind) {
           case 174 /* MethodDeclaration */:
           case 173 /* MethodSignature */:
@@ -163268,7 +163349,7 @@ var init_findAllReferences = __esm({
         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 +163905,7 @@ function isDefinitionVisible(checker, declaration) {
     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 +167105,7 @@ function getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeCheck
 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 +167381,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
         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,