@typescript-deploys/pr-build 5.3.0-pr-56201-9 → 5.3.0-pr-56220-2

package/lib/tsserver.js

@@ -2328,7 +2328,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.3";
-var version = `${versionMajorMinor}.0-insiders.20231024`;
+var version = `${versionMajorMinor}.0-insiders.20231031`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6185,32 +6185,43 @@ var NodeFlags = /* @__PURE__ */ ((NodeFlags3) => {
 })(NodeFlags || {});
 var ModifierFlags = /* @__PURE__ */ ((ModifierFlags3) => {
   ModifierFlags3[ModifierFlags3["None"] = 0] = "None";
-  ModifierFlags3[ModifierFlags3["Export"] = 1] = "Export";
-  ModifierFlags3[ModifierFlags3["Ambient"] = 2] = "Ambient";
-  ModifierFlags3[ModifierFlags3["Public"] = 4] = "Public";
-  ModifierFlags3[ModifierFlags3["Private"] = 8] = "Private";
-  ModifierFlags3[ModifierFlags3["Protected"] = 16] = "Protected";
-  ModifierFlags3[ModifierFlags3["Static"] = 32] = "Static";
-  ModifierFlags3[ModifierFlags3["Readonly"] = 64] = "Readonly";
-  ModifierFlags3[ModifierFlags3["Accessor"] = 128] = "Accessor";
-  ModifierFlags3[ModifierFlags3["Abstract"] = 256] = "Abstract";
-  ModifierFlags3[ModifierFlags3["Async"] = 512] = "Async";
-  ModifierFlags3[ModifierFlags3["Default"] = 1024] = "Default";
-  ModifierFlags3[ModifierFlags3["Const"] = 2048] = "Const";
-  ModifierFlags3[ModifierFlags3["HasComputedJSDocModifiers"] = 4096] = "HasComputedJSDocModifiers";
-  ModifierFlags3[ModifierFlags3["Deprecated"] = 8192] = "Deprecated";
-  ModifierFlags3[ModifierFlags3["Override"] = 16384] = "Override";
-  ModifierFlags3[ModifierFlags3["In"] = 32768] = "In";
-  ModifierFlags3[ModifierFlags3["Out"] = 65536] = "Out";
-  ModifierFlags3[ModifierFlags3["Decorator"] = 131072] = "Decorator";
+  ModifierFlags3[ModifierFlags3["Public"] = 1] = "Public";
+  ModifierFlags3[ModifierFlags3["Private"] = 2] = "Private";
+  ModifierFlags3[ModifierFlags3["Protected"] = 4] = "Protected";
+  ModifierFlags3[ModifierFlags3["Readonly"] = 8] = "Readonly";
+  ModifierFlags3[ModifierFlags3["Override"] = 16] = "Override";
+  ModifierFlags3[ModifierFlags3["Export"] = 32] = "Export";
+  ModifierFlags3[ModifierFlags3["Abstract"] = 64] = "Abstract";
+  ModifierFlags3[ModifierFlags3["Ambient"] = 128] = "Ambient";
+  ModifierFlags3[ModifierFlags3["Static"] = 256] = "Static";
+  ModifierFlags3[ModifierFlags3["Accessor"] = 512] = "Accessor";
+  ModifierFlags3[ModifierFlags3["Async"] = 1024] = "Async";
+  ModifierFlags3[ModifierFlags3["Default"] = 2048] = "Default";
+  ModifierFlags3[ModifierFlags3["Const"] = 4096] = "Const";
+  ModifierFlags3[ModifierFlags3["In"] = 8192] = "In";
+  ModifierFlags3[ModifierFlags3["Out"] = 16384] = "Out";
+  ModifierFlags3[ModifierFlags3["Decorator"] = 32768] = "Decorator";
+  ModifierFlags3[ModifierFlags3["Deprecated"] = 65536] = "Deprecated";
+  ModifierFlags3[ModifierFlags3["JSDocPublic"] = 8388608] = "JSDocPublic";
+  ModifierFlags3[ModifierFlags3["JSDocPrivate"] = 16777216] = "JSDocPrivate";
+  ModifierFlags3[ModifierFlags3["JSDocProtected"] = 33554432] = "JSDocProtected";
+  ModifierFlags3[ModifierFlags3["JSDocReadonly"] = 67108864] = "JSDocReadonly";
+  ModifierFlags3[ModifierFlags3["JSDocOverride"] = 134217728] = "JSDocOverride";
+  ModifierFlags3[ModifierFlags3["SyntacticOrJSDocModifiers"] = 31] = "SyntacticOrJSDocModifiers";
+  ModifierFlags3[ModifierFlags3["SyntacticOnlyModifiers"] = 65504] = "SyntacticOnlyModifiers";
+  ModifierFlags3[ModifierFlags3["SyntacticModifiers"] = 65535] = "SyntacticModifiers";
+  ModifierFlags3[ModifierFlags3["JSDocCacheOnlyModifiers"] = 260046848] = "JSDocCacheOnlyModifiers";
+  ModifierFlags3[ModifierFlags3["JSDocOnlyModifiers"] = 65536 /* Deprecated */] = "JSDocOnlyModifiers";
+  ModifierFlags3[ModifierFlags3["NonCacheOnlyModifiers"] = 131071] = "NonCacheOnlyModifiers";
+  ModifierFlags3[ModifierFlags3["HasComputedJSDocModifiers"] = 268435456] = "HasComputedJSDocModifiers";
   ModifierFlags3[ModifierFlags3["HasComputedFlags"] = 536870912] = "HasComputedFlags";
-  ModifierFlags3[ModifierFlags3["AccessibilityModifier"] = 28] = "AccessibilityModifier";
-  ModifierFlags3[ModifierFlags3["ParameterPropertyModifier"] = 16476] = "ParameterPropertyModifier";
-  ModifierFlags3[ModifierFlags3["NonPublicAccessibilityModifier"] = 24] = "NonPublicAccessibilityModifier";
-  ModifierFlags3[ModifierFlags3["TypeScriptModifier"] = 117086] = "TypeScriptModifier";
-  ModifierFlags3[ModifierFlags3["ExportDefault"] = 1025] = "ExportDefault";
-  ModifierFlags3[ModifierFlags3["All"] = 258047] = "All";
-  ModifierFlags3[ModifierFlags3["Modifier"] = 126975] = "Modifier";
+  ModifierFlags3[ModifierFlags3["AccessibilityModifier"] = 7] = "AccessibilityModifier";
+  ModifierFlags3[ModifierFlags3["ParameterPropertyModifier"] = 31] = "ParameterPropertyModifier";
+  ModifierFlags3[ModifierFlags3["NonPublicAccessibilityModifier"] = 6] = "NonPublicAccessibilityModifier";
+  ModifierFlags3[ModifierFlags3["TypeScriptModifier"] = 28895] = "TypeScriptModifier";
+  ModifierFlags3[ModifierFlags3["ExportDefault"] = 2080] = "ExportDefault";
+  ModifierFlags3[ModifierFlags3["All"] = 131071] = "All";
+  ModifierFlags3[ModifierFlags3["Modifier"] = 98303] = "Modifier";
   return ModifierFlags3;
 })(ModifierFlags || {});
 var JsxFlags = /* @__PURE__ */ ((JsxFlags2) => {
@@ -10161,7 +10172,7 @@ var Diagnostics = {
   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."),
@@ -10182,6 +10193,8 @@ var Diagnostics = {
   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}'."),
@@ -13686,7 +13699,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)) {
@@ -13976,7 +13989,7 @@ function getDecorators(node) {
   }
 }
 function getModifiers(node) {
-  if (hasSyntacticModifier(node, 126975 /* Modifier */)) {
+  if (hasSyntacticModifier(node, 98303 /* Modifier */)) {
     return filter(node.modifiers, isModifier);
   }
 }
@@ -14410,7 +14423,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 */;
@@ -14774,10 +14787,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 */;
@@ -16053,7 +16066,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) {
@@ -16406,10 +16419,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 */;
@@ -18158,7 +18171,7 @@ function getFunctionFlags(node) {
         flags |= 1 /* Generator */;
       }
     case 219 /* ArrowFunction */:
-      if (hasSyntacticModifier(node, 512 /* Async */)) {
+      if (hasSyntacticModifier(node, 1024 /* Async */)) {
         flags |= 2 /* Async */;
       }
       break;
@@ -18174,7 +18187,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;
 }
@@ -19338,25 +19351,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;
@@ -19371,10 +19384,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(
@@ -19399,33 +19415,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;
 }
@@ -19441,37 +19466,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 */;
 }
@@ -19611,7 +19636,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));
@@ -19894,16 +19919,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;
 }
@@ -20002,7 +20027,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;
 }
@@ -21296,7 +21321,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;
@@ -23292,35 +23317,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;
   }
@@ -23369,7 +23394,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;
@@ -23418,8 +23443,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;
   }
@@ -23458,7 +23483,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 */;
@@ -24201,7 +24226,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 */;
@@ -24225,7 +24250,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;
@@ -24577,7 +24602,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;
@@ -24827,10 +24852,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 */;
@@ -24861,7 +24886,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 */;
@@ -24923,7 +24948,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 */;
@@ -26354,7 +26379,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);
@@ -35751,11 +35776,11 @@ var Parser;
     const modifierFlags = modifiersToFlags(modifiers);
     parseExpected(100 /* FunctionKeyword */);
     const asteriskToken = parseOptionalToken(42 /* AsteriskToken */);
-    const name = modifierFlags & 1024 /* Default */ ? parseOptionalBindingIdentifier() : parseBindingIdentifier();
+    const name = modifierFlags & 2048 /* Default */ ? parseOptionalBindingIdentifier() : parseBindingIdentifier();
     const isGenerator = asteriskToken ? 1 /* Yield */ : 0 /* None */;
-    const isAsync = modifierFlags & 512 /* Async */ ? 2 /* Await */ : 0 /* None */;
+    const isAsync = modifierFlags & 1024 /* Async */ ? 2 /* Await */ : 0 /* None */;
     const typeParameters = parseTypeParameters();
-    if (modifierFlags & 1 /* Export */)
+    if (modifierFlags & 32 /* Export */)
       setAwaitContext(
         /*value*/
         true
@@ -41664,8 +41689,7 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
   if (resolutionMode === 99 /* ESNext */ && (3 /* Node16 */ <= moduleResolution && moduleResolution <= 99 /* NodeNext */)) {
     features |= 32 /* EsmMode */;
   }
-  const useImportCondition = resolutionMode === 99 /* ESNext */ || (resolutionMode !== void 0 ? false : void 0);
-  const conditions = features & 8 /* Exports */ ? getConditions(options, useImportCondition) : [];
+  const conditions = features & 8 /* Exports */ ? getConditions(options, resolutionMode) : [];
   const diagnostics = [];
   const moduleResolutionState = {
     compilerOptions: options,
@@ -41833,16 +41857,16 @@ function getNodeResolutionFeatures(options) {
   }
   return features;
 }
-function getConditions(options, esmMode) {
+function getConditions(options, resolutionMode) {
   const moduleResolution = getEmitModuleResolutionKind(options);
-  if (esmMode === void 0) {
+  if (resolutionMode === void 0) {
     if (moduleResolution === 100 /* Bundler */) {
-      esmMode ?? (esmMode = moduleResolution === 100 /* Bundler */);
+      resolutionMode = 99 /* ESNext */;
     } else if (moduleResolution === 2 /* Node10 */) {
       return [];
     }
   }
-  const conditions = esmMode ? ["import"] : ["require"];
+  const conditions = resolutionMode === 99 /* ESNext */ ? ["import"] : ["require"];
   if (!options.noDtsResolution) {
     conditions.push("types");
   }
@@ -42291,13 +42315,13 @@ function resolveModuleName(moduleName, containingFile, compilerOptions, host, ca
         result = nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
         break;
       case 2 /* Node10 */:
-        result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode ? getConditions(compilerOptions, resolutionMode === 99 /* ESNext */) : void 0);
+        result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode ? getConditions(compilerOptions, resolutionMode) : void 0);
         break;
       case 1 /* Classic */:
         result = classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);
         break;
       case 100 /* Bundler */:
-        result = bundlerModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode ? getConditions(compilerOptions, resolutionMode === 99 /* ESNext */) : void 0);
+        result = bundlerModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode ? getConditions(compilerOptions, resolutionMode) : void 0);
         break;
       default:
         return Debug.fail(`Unexpected moduleResolution: ${moduleResolution}`);
@@ -42575,7 +42599,7 @@ function nodeModuleNameResolverWorker(features, moduleName, containingDirectory,
   const moduleResolution = getEmitModuleResolutionKind(compilerOptions);
   conditions ?? (conditions = getConditions(
     compilerOptions,
-    moduleResolution === 100 /* Bundler */ || moduleResolution === 2 /* Node10 */ ? void 0 : !!(features & 32 /* EsmMode */)
+    moduleResolution === 100 /* Bundler */ || moduleResolution === 2 /* Node10 */ ? void 0 : features & 32 /* EsmMode */ ? 99 /* ESNext */ : 1 /* CommonJS */
   ));
   const diagnostics = [];
   const state = {
@@ -42886,15 +42910,7 @@ function getEntrypointsFromPackageJsonInfo(packageJsonInfo, options, host, cache
   entrypoints = append(entrypoints, mainResolution == null ? void 0 : mainResolution.path);
   if (features & 8 /* Exports */ && packageJsonInfo.contents.packageJsonContent.exports) {
     const conditionSets = deduplicate(
-      [getConditions(
-        options,
-        /*esmMode*/
-        true
-      ), getConditions(
-        options,
-        /*esmMode*/
-        false
-      )],
+      [getConditions(options, 99 /* ESNext */), getConditions(options, 1 /* CommonJS */)],
       arrayIsEqualTo
     );
     for (const conditions of conditionSets) {
@@ -44031,7 +44047,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;
@@ -44321,7 +44337,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) {
@@ -44365,7 +44381,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;
@@ -44394,7 +44410,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);
@@ -44413,7 +44429,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;
@@ -44454,7 +44470,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;
   }
@@ -44485,7 +44501,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 */)) {
@@ -45532,7 +45548,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)) {
@@ -46593,7 +46609,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 */);
@@ -46745,7 +46761,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;
   }
@@ -47607,7 +47623,7 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa
       if (getResolvePackageJsonExports(options)) {
         const nodeModulesDirectoryName2 = packageRootPath.substring(parts.topLevelPackageNameIndex + 1);
         const packageName2 = getPackageNameFromTypesPackageName(nodeModulesDirectoryName2);
-        const conditions = getConditions(options, importMode === 99 /* ESNext */);
+        const conditions = getConditions(options, importMode);
         const fromExports = packageJsonContent.exports ? tryGetModuleNameFromExports(options, path, packageRootPath, packageName2, packageJsonContent.exports, conditions) : void 0;
         if (fromExports) {
           const withJsExtension = !hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
@@ -49896,7 +49912,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);
@@ -50060,8 +50076,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));
         }
@@ -50093,16 +50118,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) {
@@ -50281,7 +50296,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;
@@ -52207,20 +52222,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)) {
@@ -52443,7 +52458,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);
@@ -52897,7 +52913,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;
@@ -52914,6 +52930,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;
           }
@@ -52933,7 +52956,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) {
@@ -53175,7 +53203,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));
             }
           }
@@ -53478,7 +53506,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,
@@ -54535,7 +54563,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)) {
@@ -54569,9 +54597,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];
           }
@@ -54663,11 +54691,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) {
@@ -54708,6 +54736,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;
         }
       }
@@ -54724,7 +54758,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) {
@@ -54794,7 +54828,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(
@@ -54899,14 +54933,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));
@@ -55028,7 +55062,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;
@@ -55112,7 +55146,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,
@@ -55215,7 +55249,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
@@ -55568,7 +55602,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(
@@ -55585,7 +55619,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) {
@@ -55621,14 +55655,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) {
@@ -55670,7 +55704,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),
@@ -55687,7 +55721,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),
@@ -55702,10 +55736,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*/
@@ -55781,7 +55815,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) {
@@ -55974,10 +56008,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";
@@ -56095,7 +56129,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);
@@ -56105,7 +56139,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 */:
@@ -56324,7 +56358,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);
@@ -56530,7 +56564,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 || isNullOrUndefined3(declaration.initializer))) {
         return autoType;
       }
@@ -56578,7 +56612,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*/
@@ -56587,7 +56621,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*/
@@ -56691,7 +56725,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) {
@@ -57315,6 +57349,9 @@ function createTypeChecker(host) {
   function getTypeOfAlias(symbol) {
     const links = getSymbolLinks(symbol);
     if (!links.type) {
+      if (!pushTypeResolution(symbol, 0 /* Type */)) {
+        return errorType;
+      }
       const targetSymbol = resolveAlias(symbol);
       const exportSymbol = symbol.declarations && getTargetOfAliasDeclaration(
         getDeclarationOfAliasSymbol(symbol),
@@ -57323,6 +57360,10 @@ function createTypeChecker(host) {
       );
       const declaredType = firstDefined(exportSymbol == null ? void 0 : exportSymbol.declarations, (d) => isExportAssignment(d) ? tryGetTypeFromEffectiveTypeNode(d) : void 0);
       links.type = (exportSymbol == null ? void 0 : exportSymbol.declarations) && isDuplicatedCommonJSExport(exportSymbol.declarations) && symbol.declarations.length ? getFlowTypeFromCommonJSExport(exportSymbol) : isDuplicatedCommonJSExport(symbol.declarations) ? autoType : declaredType ? declaredType : getSymbolFlags(targetSymbol) & 111551 /* Value */ ? getTypeOfSymbol(targetSymbol) : errorType;
+      if (!popTypeResolution()) {
+        reportCircularityError(exportSymbol ?? symbol);
+        return links.type = errorType;
+      }
     }
     return links.type;
   }
@@ -57336,12 +57377,19 @@ function createTypeChecker(host) {
   }
   function reportCircularityError(symbol) {
     const declaration = symbol.valueDeclaration;
-    if (getEffectiveTypeAnnotationNode(declaration)) {
-      error2(symbol.valueDeclaration, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
-      return errorType;
-    }
-    if (noImplicitAny && (declaration.kind !== 169 /* Parameter */ || declaration.initializer)) {
-      error2(symbol.valueDeclaration, Diagnostics._0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer, symbolToString(symbol));
+    if (declaration) {
+      if (getEffectiveTypeAnnotationNode(declaration)) {
+        error2(symbol.valueDeclaration, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
+        return errorType;
+      }
+      if (noImplicitAny && (declaration.kind !== 169 /* Parameter */ || declaration.initializer)) {
+        error2(symbol.valueDeclaration, Diagnostics._0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer, symbolToString(symbol));
+      }
+    } else if (symbol.flags & 2097152 /* Alias */) {
+      const node = getDeclarationOfAliasSymbol(symbol);
+      if (node) {
+        error2(node, Diagnostics.Circular_definition_of_import_alias_0, symbolToString(symbol));
+      }
     }
     return anyType;
   }
@@ -58344,7 +58392,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*/
@@ -59120,7 +59168,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;
@@ -59446,7 +59494,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 */;
           }
@@ -59898,7 +59946,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(
@@ -60268,7 +60316,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));
               }
             });
           }
@@ -62093,7 +62141,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);
@@ -62527,7 +62575,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);
   }
@@ -63038,7 +63086,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 */;
@@ -63100,7 +63148,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));
@@ -66667,25 +66715,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));
         }
@@ -67215,15 +67263,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) {
@@ -67323,7 +67371,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;
@@ -67371,7 +67419,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++) {
@@ -67456,10 +67504,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) {
@@ -67536,8 +67584,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 */;
     }
@@ -71531,7 +71579,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);
         }
       }
@@ -71944,7 +71992,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,
@@ -71953,7 +72001,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;
@@ -72285,7 +72333,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) {
@@ -72498,7 +72563,7 @@ function createTypeChecker(host) {
       type,
       (t) => {
         var _a;
-        if (isGenericMappedType(t) && (!t.declaration.nameType || isFilteringMappedType(t))) {
+        if (isGenericMappedType(t) && !t.declaration.nameType) {
           const constraint = getConstraintTypeFromMappedType(t);
           const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
           const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
@@ -74141,20 +74206,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) {
@@ -74163,10 +74228,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) {
@@ -74186,14 +74251,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 */) {
@@ -74613,7 +74678,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);
@@ -74867,7 +74932,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;
@@ -76312,7 +76377,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);
       }
@@ -76375,7 +76440,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;
     }
@@ -76383,16 +76448,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;
@@ -78369,7 +78434,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;
@@ -79486,7 +79551,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;
@@ -80107,15 +80180,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);
@@ -80129,7 +80202,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);
       }
@@ -80299,11 +80372,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);
@@ -80314,6 +80383,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();
@@ -80461,7 +80537,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));
     }
   }
@@ -80478,7 +80554,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)) {
@@ -80535,7 +80611,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);
@@ -80604,11 +80680,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);
           }
@@ -80788,7 +80864,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;
         }
@@ -80886,16 +80962,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;
   }
@@ -80913,13 +80989,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);
           }
         });
@@ -80936,7 +81012,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;
@@ -80984,7 +81060,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);
@@ -81070,7 +81146,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) {
@@ -81113,9 +81189,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;
@@ -81756,6 +81832,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)) {
@@ -81918,13 +82000,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)));
             }
           }
@@ -82370,7 +82452,7 @@ function createTypeChecker(host) {
       }
       forEach(node.name.elements, checkSourceElement);
     }
-    if (isParameter(node) && node.initializer && nodeIsMissing(getContainingFunction(node).body)) {
+    if (node.initializer && isParameterDeclaration(node) && nodeIsMissing(getContainingFunction(node).body)) {
       error2(node, Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation);
       return;
     }
@@ -82500,7 +82582,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) {
@@ -83828,7 +83910,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);
@@ -83894,7 +83976,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);
               }
             }
@@ -84108,7 +84190,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));
@@ -84128,7 +84210,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,
@@ -84169,7 +84251,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;
@@ -84212,7 +84294,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;
@@ -84229,7 +84311,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)) {
@@ -84256,7 +84338,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)) {
@@ -84321,7 +84403,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)) {
@@ -84908,7 +84990,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;
@@ -85030,7 +85112,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 */) {
@@ -85442,6 +85524,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 */:
@@ -86668,7 +86752,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;
       }
     }
@@ -86693,10 +86777,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);
@@ -87550,10 +87634,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)) {
@@ -87565,10 +87649,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);
@@ -87597,39 +87681,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 {
@@ -87641,60 +87725,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");
@@ -87705,7 +87789,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;
@@ -87715,19 +87799,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");
@@ -87741,62 +87825,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);
@@ -87804,7 +87888,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;
@@ -87813,24 +87897,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;
@@ -88350,12 +88434,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 */) {
@@ -88427,7 +88511,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;
@@ -88597,7 +88681,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);
@@ -88787,7 +88871,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);
@@ -89102,12 +89186,14 @@ var SymbolTrackerImpl = class _SymbolTrackerImpl {
     this.canTrackSymbol = !!((_a = this.inner) == null ? void 0 : _a.trackSymbol);
   }
   trackSymbol(symbol, enclosingDeclaration, meaning) {
-    var _a;
+    var _a, _b;
     if (((_a = this.inner) == null ? void 0 : _a.trackSymbol) && !this.disableTrackSymbol) {
       if (this.inner.trackSymbol(symbol, enclosingDeclaration, meaning)) {
         this.onDiagnosticReported();
         return true;
       }
+      if (!(symbol.flags & 262144 /* TypeParameter */))
+        ((_b = this.context).trackedSymbols ?? (_b.trackedSymbols = [])).push([symbol, enclosingDeclaration, meaning]);
     }
     return false;
   }
@@ -91153,15 +91239,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;
@@ -91177,8 +91263,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;
@@ -92048,7 +92134,7 @@ function injectClassThisAssignmentIfMissing(factory2, node, classThis, thisExpre
 // src/compiler/transformers/namedEvaluation.ts
 function getAssignedNameOfIdentifier(factory2, name, expression) {
   const original = getOriginalNode(skipOuterExpressions(expression));
-  if ((isClassDeclaration(original) || isFunctionDeclaration(original)) && !original.name && hasSyntacticModifier(original, 1024 /* Default */)) {
+  if ((isClassDeclaration(original) || isFunctionDeclaration(original)) && !original.name && hasSyntacticModifier(original, 2048 /* Default */)) {
     return factory2.createStringLiteral("default");
   }
   return factory2.createStringLiteralFromNode(name);
@@ -92407,13 +92493,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;
     }
@@ -92468,7 +92554,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;
@@ -92526,7 +92612,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;
@@ -92534,7 +92620,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) {
@@ -93024,7 +93110,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;
     }
@@ -93033,7 +93119,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,
@@ -93196,7 +93282,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 */)) {
@@ -93929,16 +94015,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(
@@ -95271,8 +95357,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);
@@ -95818,7 +95904,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);
@@ -96854,8 +96940,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);
@@ -96876,7 +96962,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([
@@ -97007,7 +97093,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(
@@ -97095,7 +97181,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(
@@ -97878,8 +97964,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);
       }
@@ -100190,7 +100276,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);
@@ -101402,7 +101488,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 */
@@ -101699,8 +101785,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(
@@ -101748,7 +101834,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) {
@@ -102336,7 +102422,7 @@ function transformJsx(context) {
   }
   function transformJsxSpreadAttributeToProps(node) {
     if (isObjectLiteralExpression(node.expression) && !hasProto(node.expression)) {
-      return node.expression.properties;
+      return sameMap(node.expression.properties, (p) => Debug.checkDefined(visitNode(p, visitor, isObjectLiteralElementLike)));
     }
     return factory2.createSpreadAssignment(Debug.checkDefined(visitNode(node.expression, visitor, isExpression)));
   }
@@ -103280,8 +103366,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);
     }
@@ -104473,7 +104559,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;
@@ -109422,7 +109508,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(
@@ -109468,7 +109554,7 @@ function transformModule(context) {
         );
       }
     } else {
-      if (hasSyntacticModifier(node, 1 /* Export */)) {
+      if (hasSyntacticModifier(node, 32 /* Export */)) {
         statements = append(
           statements,
           setOriginalNode(
@@ -109606,7 +109692,7 @@ function transformModule(context) {
   }
   function visitFunctionDeclaration(node) {
     let statements;
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
       statements = append(
         statements,
         setOriginalNode(
@@ -109643,7 +109729,7 @@ function transformModule(context) {
   }
   function visitClassDeclaration(node) {
     let statements;
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
       statements = append(
         statements,
         setOriginalNode(
@@ -109677,7 +109763,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) {
@@ -109863,8 +109949,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,
@@ -110351,7 +110437,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)),
@@ -110553,7 +110639,7 @@ function transformSystemModule(context) {
                 factory2.createAssignment(importVariableName, parameterName)
               )
             );
-            if (hasSyntacticModifier(entry, 1 /* Export */)) {
+            if (hasSyntacticModifier(entry, 32 /* Export */)) {
               statements.push(
                 factory2.createExpressionStatement(
                   factory2.createCallExpression(
@@ -110706,7 +110792,7 @@ function transformSystemModule(context) {
     );
   }
   function visitFunctionDeclaration(node) {
-    if (hasSyntacticModifier(node, 1 /* Export */)) {
+    if (hasSyntacticModifier(node, 32 /* Export */)) {
       hoistedStatements = append(
         hoistedStatements,
         factory2.updateFunctionDeclaration(
@@ -110793,7 +110879,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));
@@ -110929,8 +111015,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);
     }
@@ -111675,7 +111761,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(
@@ -111885,7 +111971,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;
@@ -111903,7 +111989,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 */) {
@@ -112624,7 +112710,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)) {
@@ -112704,7 +112790,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));
@@ -112749,7 +112835,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);
@@ -112935,7 +113021,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(
@@ -113023,7 +113109,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
@@ -113040,7 +113126,7 @@ function transformDeclarations(context) {
             input,
             ensureModifiers(input),
             input.name,
-            updateAccessorParamsList(input, hasEffectiveModifier(input, 8 /* Private */)),
+            updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
             /*body*/
             void 0
           ));
@@ -113197,7 +113283,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)) {
@@ -113256,10 +113342,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) {
@@ -113409,10 +113495,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,
@@ -113504,7 +113590,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 */) {
@@ -113733,11 +113819,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);
@@ -113779,13 +113865,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;
 }
@@ -113798,7 +113884,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;
@@ -122622,7 +122708,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)) {
@@ -131560,7 +131646,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 */:
@@ -132464,19 +132550,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 */);
@@ -133890,7 +133976,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) => {
@@ -135499,7 +135585,7 @@ var DocumentHighlights;
       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;
@@ -135513,12 +135599,12 @@ var DocumentHighlights;
       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;
@@ -137981,7 +138067,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);
@@ -138131,7 +138217,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>";
@@ -138278,15 +138364,15 @@ function getInfo2(context, considerPartialSpans = true) {
   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) };
@@ -138783,26 +138869,50 @@ function getRangeToExtract(context, considerEmptySpans = true) {
   const current = getTokenAtPosition(file, startPosition);
   const range = createTextRangeFromSpan(getRefactorContextSpan(context));
   const cursorRequest = range.pos === range.end && considerEmptySpans;
-  const selection = findAncestor(current, (node) => node.parent && isTypeNode(node) && !rangeContainsSkipTrivia(range, node.parent, file) && (cursorRequest || nodeOverlapsWithStartEnd(current, file, range.pos, range.end)));
-  if (!selection || !isTypeNode(selection))
+  const overlappingRange = nodeOverlapsWithStartEnd(current, file, range.pos, range.end);
+  const firstType = findAncestor(current, (node) => node.parent && isTypeNode(node) && !rangeContainsSkipTrivia(range, node.parent, file) && (cursorRequest || overlappingRange));
+  if (!firstType || !isTypeNode(firstType))
     return { error: getLocaleSpecificMessage(Diagnostics.Selection_is_not_a_valid_type_node) };
   const checker = context.program.getTypeChecker();
-  const enclosingNode = getEnclosingNode(selection, isJS);
+  const enclosingNode = getEnclosingNode(firstType, isJS);
   if (enclosingNode === void 0)
     return { error: getLocaleSpecificMessage(Diagnostics.No_type_could_be_extracted_from_this_type_node) };
+  const expandedFirstType = getExpandedSelectionNode(firstType, enclosingNode);
+  if (!isTypeNode(expandedFirstType))
+    return { error: getLocaleSpecificMessage(Diagnostics.Selection_is_not_a_valid_type_node) };
+  const typeList = [];
+  if ((isUnionTypeNode(expandedFirstType.parent) || isIntersectionTypeNode(expandedFirstType.parent)) && range.end > firstType.end) {
+    addRange(
+      typeList,
+      expandedFirstType.parent.types.filter((type) => {
+        return nodeOverlapsWithStartEnd(type, file, range.pos, range.end);
+      })
+    );
+  }
+  const selection = typeList.length > 1 ? typeList : expandedFirstType;
   const typeParameters = collectTypeParameters(checker, selection, enclosingNode, file);
   if (!typeParameters)
     return { error: getLocaleSpecificMessage(Diagnostics.No_type_could_be_extracted_from_this_type_node) };
   const typeElements = flattenTypeLiteralNodeReference(checker, selection);
   return { isJS, selection, enclosingNode, typeParameters, typeElements };
 }
-function flattenTypeLiteralNodeReference(checker, node) {
-  if (!node)
+function flattenTypeLiteralNodeReference(checker, selection) {
+  if (!selection)
     return void 0;
-  if (isIntersectionTypeNode(node)) {
+  if (isArray(selection)) {
+    const result = [];
+    for (const type of selection) {
+      const flattenedTypeMembers = flattenTypeLiteralNodeReference(checker, type);
+      if (!flattenedTypeMembers)
+        return void 0;
+      addRange(result, flattenedTypeMembers);
+    }
+    return result;
+  }
+  if (isIntersectionTypeNode(selection)) {
     const result = [];
     const seen = /* @__PURE__ */ new Map();
-    for (const type of node.types) {
+    for (const type of selection.types) {
       const flattenedTypeMembers = flattenTypeLiteralNodeReference(checker, type);
       if (!flattenedTypeMembers || !flattenedTypeMembers.every((type2) => type2.name && addToSeen(seen, getNameFromPropertyName(type2.name)))) {
         return void 0;
@@ -138810,10 +138920,10 @@ function flattenTypeLiteralNodeReference(checker, node) {
       addRange(result, flattenedTypeMembers);
     }
     return result;
-  } else if (isParenthesizedTypeNode(node)) {
-    return flattenTypeLiteralNodeReference(checker, node.type);
-  } else if (isTypeLiteralNode(node)) {
-    return node.members;
+  } else if (isParenthesizedTypeNode(selection)) {
+    return flattenTypeLiteralNodeReference(checker, selection.type);
+  } else if (isTypeLiteralNode(selection)) {
+    return selection.members;
   }
   return void 0;
 }
@@ -138822,7 +138932,13 @@ function rangeContainsSkipTrivia(r1, node, file) {
 }
 function collectTypeParameters(checker, selection, enclosingNode, file) {
   const result = [];
-  return visitor(selection) ? void 0 : result;
+  const selectionArray = toArray(selection);
+  const selectionRange = { pos: selectionArray[0].pos, end: selectionArray[selectionArray.length - 1].end };
+  for (const t of selectionArray) {
+    if (visitor(t))
+      return void 0;
+  }
+  return result;
   function visitor(node) {
     if (isTypeReferenceNode(node)) {
       if (isIdentifier(node.typeName)) {
@@ -138836,10 +138952,10 @@ function collectTypeParameters(checker, selection, enclosingNode, file) {
         );
         for (const decl of (symbol == null ? void 0 : symbol.declarations) || emptyArray) {
           if (isTypeParameterDeclaration(decl) && decl.getSourceFile() === file) {
-            if (decl.name.escapedText === typeName.escapedText && rangeContainsSkipTrivia(decl, selection, file)) {
+            if (decl.name.escapedText === typeName.escapedText && rangeContainsSkipTrivia(decl, selectionRange, file)) {
               return true;
             }
-            if (rangeContainsSkipTrivia(enclosingNode, decl, file) && !rangeContainsSkipTrivia(selection, decl, file)) {
+            if (rangeContainsSkipTrivia(enclosingNode, decl, file) && !rangeContainsSkipTrivia(selectionRange, decl, file)) {
               pushIfUnique(result, decl);
               break;
             }
@@ -138848,12 +138964,12 @@ function collectTypeParameters(checker, selection, enclosingNode, file) {
       }
     } else if (isInferTypeNode(node)) {
       const conditionalTypeNode = findAncestor(node, (n) => isConditionalTypeNode(n) && rangeContainsSkipTrivia(n.extendsType, node, file));
-      if (!conditionalTypeNode || !rangeContainsSkipTrivia(selection, conditionalTypeNode, file)) {
+      if (!conditionalTypeNode || !rangeContainsSkipTrivia(selectionRange, conditionalTypeNode, file)) {
         return true;
       }
     } else if (isTypePredicateNode(node) || isThisTypeNode(node)) {
       const functionLikeNode = findAncestor(node.parent, isFunctionLike);
-      if (functionLikeNode && functionLikeNode.type && rangeContainsSkipTrivia(functionLikeNode.type, node, file) && !rangeContainsSkipTrivia(selection, functionLikeNode, file)) {
+      if (functionLikeNode && functionLikeNode.type && rangeContainsSkipTrivia(functionLikeNode.type, node, file) && !rangeContainsSkipTrivia(selectionRange, functionLikeNode, file)) {
         return true;
       }
     } else if (isTypeQueryNode(node)) {
@@ -138865,11 +138981,11 @@ function collectTypeParameters(checker, selection, enclosingNode, file) {
           /*excludeGlobals*/
           false
         );
-        if ((symbol == null ? void 0 : symbol.valueDeclaration) && rangeContainsSkipTrivia(enclosingNode, symbol.valueDeclaration, file) && !rangeContainsSkipTrivia(selection, symbol.valueDeclaration, file)) {
+        if ((symbol == null ? void 0 : symbol.valueDeclaration) && rangeContainsSkipTrivia(enclosingNode, symbol.valueDeclaration, file) && !rangeContainsSkipTrivia(selectionRange, symbol.valueDeclaration, file)) {
           return true;
         }
       } else {
-        if (isThisIdentifier(node.exprName.left) && !rangeContainsSkipTrivia(selection, node.parent, file)) {
+        if (isThisIdentifier(node.exprName.left) && !rangeContainsSkipTrivia(selectionRange, node.parent, file)) {
           return true;
         }
       }
@@ -138881,8 +138997,9 @@ function collectTypeParameters(checker, selection, enclosingNode, file) {
   }
 }
 function doTypeAliasChange(changes, file, name, info) {
-  const { enclosingNode, selection, typeParameters } = info;
-  const newTypeNode = factory.createTypeAliasDeclaration(
+  const { enclosingNode, typeParameters } = info;
+  const { firstTypeNode, lastTypeNode, newTypeNode } = getNodesToEdit(info);
+  const newTypeDeclaration = factory.createTypeAliasDeclaration(
     /*modifiers*/
     void 0,
     name,
@@ -138894,16 +139011,16 @@ function doTypeAliasChange(changes, file, name, info) {
       /*defaultType*/
       void 0
     )),
-    selection
+    newTypeNode
   );
   changes.insertNodeBefore(
     file,
     enclosingNode,
-    ignoreSourceNewlines(newTypeNode),
+    ignoreSourceNewlines(newTypeDeclaration),
     /*blankLineBetween*/
     true
   );
-  changes.replaceNode(file, selection, factory.createTypeReferenceNode(name, typeParameters.map((id) => factory.createTypeReferenceNode(
+  changes.replaceNodeRange(file, firstTypeNode, lastTypeNode, factory.createTypeReferenceNode(name, typeParameters.map((id) => factory.createTypeReferenceNode(
     id.name,
     /*typeArguments*/
     void 0
@@ -138911,7 +139028,7 @@ function doTypeAliasChange(changes, file, name, info) {
 }
 function doInterfaceChange(changes, file, name, info) {
   var _a;
-  const { enclosingNode, selection, typeParameters, typeElements } = info;
+  const { enclosingNode, typeParameters, typeElements } = info;
   const newTypeNode = factory.createInterfaceDeclaration(
     /*modifiers*/
     void 0,
@@ -138929,7 +139046,8 @@ function doInterfaceChange(changes, file, name, info) {
     /*blankLineBetween*/
     true
   );
-  changes.replaceNode(file, selection, factory.createTypeReferenceNode(name, typeParameters.map((id) => factory.createTypeReferenceNode(
+  const { firstTypeNode, lastTypeNode } = getNodesToEdit(info);
+  changes.replaceNodeRange(file, firstTypeNode, lastTypeNode, factory.createTypeReferenceNode(name, typeParameters.map((id) => factory.createTypeReferenceNode(
     id.name,
     /*typeArguments*/
     void 0
@@ -138937,11 +139055,14 @@ function doInterfaceChange(changes, file, name, info) {
 }
 function doTypedefChange(changes, context, file, name, info) {
   var _a;
-  const { enclosingNode, selection, typeParameters } = info;
-  setEmitFlags(selection, 3072 /* NoComments */ | 4096 /* NoNestedComments */);
+  toArray(info.selection).forEach((typeNode) => {
+    setEmitFlags(typeNode, 3072 /* NoComments */ | 4096 /* NoNestedComments */);
+  });
+  const { enclosingNode, typeParameters } = info;
+  const { firstTypeNode, lastTypeNode, newTypeNode } = getNodesToEdit(info);
   const node = factory.createJSDocTypedefTag(
     factory.createIdentifier("typedef"),
-    factory.createJSDocTypeExpression(selection),
+    factory.createJSDocTypeExpression(newTypeNode),
     factory.createIdentifier(name)
   );
   const templates = [];
@@ -138979,15 +139100,39 @@ function doTypedefChange(changes, context, file, name, info) {
       true
     );
   }
-  changes.replaceNode(file, selection, factory.createTypeReferenceNode(name, typeParameters.map((id) => factory.createTypeReferenceNode(
+  changes.replaceNodeRange(file, firstTypeNode, lastTypeNode, factory.createTypeReferenceNode(name, typeParameters.map((id) => factory.createTypeReferenceNode(
     id.name,
     /*typeArguments*/
     void 0
   ))));
 }
+function getNodesToEdit(info) {
+  if (isArray(info.selection)) {
+    return {
+      firstTypeNode: info.selection[0],
+      lastTypeNode: info.selection[info.selection.length - 1],
+      newTypeNode: isUnionTypeNode(info.selection[0].parent) ? factory.createUnionTypeNode(info.selection) : factory.createIntersectionTypeNode(info.selection)
+    };
+  }
+  return {
+    firstTypeNode: info.selection,
+    lastTypeNode: info.selection,
+    newTypeNode: info.selection
+  };
+}
 function getEnclosingNode(node, isJS) {
   return findAncestor(node, isStatement) || (isJS ? findAncestor(node, isJSDoc) : void 0);
 }
+function getExpandedSelectionNode(firstType, enclosingNode) {
+  return findAncestor(firstType, (node) => {
+    if (node === enclosingNode)
+      return "quit";
+    if (isUnionTypeNode(node.parent) || isIntersectionTypeNode(node.parent)) {
+      return true;
+    }
+    return false;
+  }) ?? firstType;
+}
 
 // src/services/refactors/helpers.ts
 function isRefactorErrorInfo(info) {
@@ -139240,7 +139385,7 @@ function getNewFileImportsAndAddExportInOldFile(oldFile, importsToCopy, newFileI
       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);
@@ -139295,14 +139440,13 @@ function error(notApplicableReason) {
 }
 function doChange4(context, oldFile, targetFile, program, toMove, changes, host, preferences) {
   const checker = program.getTypeChecker();
-  const usage = getUsageInfo(oldFile, toMove.all, checker);
   if (!host.fileExists(targetFile)) {
-    changes.createNewFile(oldFile, targetFile, getNewStatementsAndRemoveFromOldFile2(oldFile, targetFile, usage, changes, toMove, program, host, preferences));
+    changes.createNewFile(oldFile, targetFile, getNewStatementsAndRemoveFromOldFile2(oldFile, targetFile, getUsageInfo(oldFile, toMove.all, checker), changes, toMove, program, host, preferences));
     addNewFileToTsconfig(program, changes, oldFile.fileName, targetFile, hostGetCanonicalFileName(host));
   } else {
     const targetSourceFile = Debug.checkDefined(program.getSourceFile(targetFile));
     const importAdder = ts_codefix_exports.createImportAdder(targetSourceFile, context.program, context.preferences, context.host);
-    getNewStatementsAndRemoveFromOldFile2(oldFile, targetSourceFile, usage, changes, toMove, program, host, preferences, importAdder);
+    getNewStatementsAndRemoveFromOldFile2(oldFile, targetSourceFile, getUsageInfo(oldFile, toMove.all, checker, getExistingImports(targetSourceFile, checker)), changes, toMove, program, host, preferences, importAdder);
   }
 }
 function getNewStatementsAndRemoveFromOldFile2(oldFile, targetFile, usage, changes, toMove, program, host, preferences, importAdder) {
@@ -139422,7 +139566,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);
@@ -139662,7 +139806,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)));
 }
@@ -139957,7 +140101,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,
@@ -139968,7 +140112,7 @@ function isPureImport(node) {
       return false;
   }
 }
-function getUsageInfo(oldFile, toMove, checker) {
+function getUsageInfo(oldFile, toMove, checker, existingTargetImports = /* @__PURE__ */ new Set()) {
   const movedSymbols = /* @__PURE__ */ new Set();
   const oldImportsNeededByTargetFile = /* @__PURE__ */ new Map();
   const targetFileImportsFromOldFile = /* @__PURE__ */ new Set();
@@ -139982,10 +140126,16 @@ function getUsageInfo(oldFile, toMove, checker) {
       movedSymbols.add(Debug.checkDefined(isExpressionStatement(decl) ? checker.getSymbolAtLocation(decl.expression.left) : decl.symbol, "Need a symbol here"));
     });
   }
+  const unusedImportsFromOldFile = /* @__PURE__ */ new Set();
   for (const statement of toMove) {
     forEachReference(statement, checker, (symbol, isValidTypeOnlyUseSite) => {
-      if (!symbol.declarations)
+      if (!symbol.declarations) {
+        return;
+      }
+      if (existingTargetImports.has(skipAlias(symbol, checker))) {
+        unusedImportsFromOldFile.add(symbol);
         return;
+      }
       for (const decl of symbol.declarations) {
         if (isInImport(decl)) {
           const prevIsTypeOnly = oldImportsNeededByTargetFile.get(symbol);
@@ -139996,7 +140146,9 @@ function getUsageInfo(oldFile, toMove, checker) {
       }
     });
   }
-  const unusedImportsFromOldFile = new Set(oldImportsNeededByTargetFile.keys());
+  for (const unusedImport of oldImportsNeededByTargetFile.keys()) {
+    unusedImportsFromOldFile.add(unusedImport);
+  }
   const oldFileImportsFromTargetFile = /* @__PURE__ */ new Set();
   for (const statement of oldFile.statements) {
     if (contains(toMove, statement))
@@ -140128,7 +140280,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;
@@ -140182,6 +140334,29 @@ function getOverloadRangeToMove(sourceFile, statement) {
   }
   return void 0;
 }
+function getExistingImports(sourceFile, checker) {
+  const imports = /* @__PURE__ */ new Set();
+  for (const moduleSpecifier of sourceFile.imports) {
+    const declaration = importFromModuleSpecifier(moduleSpecifier);
+    if (isImportDeclaration(declaration) && declaration.importClause && declaration.importClause.namedBindings && isNamedImports(declaration.importClause.namedBindings)) {
+      for (const e of declaration.importClause.namedBindings.elements) {
+        const symbol = checker.getSymbolAtLocation(e.propertyName || e.name);
+        if (symbol) {
+          imports.add(skipAlias(symbol, checker));
+        }
+      }
+    }
+    if (isVariableDeclarationInitializedToRequire(declaration.parent) && isObjectBindingPattern(declaration.parent.name)) {
+      for (const e of declaration.parent.name.elements) {
+        const symbol = checker.getSymbolAtLocation(e.propertyName || e.name);
+        if (symbol) {
+          imports.add(skipAlias(symbol, checker));
+        }
+      }
+    }
+  }
+  return imports;
+}
 
 // src/services/_namespaces/ts.refactor.addOrRemoveBracesToArrowFunction.ts
 var ts_refactor_addOrRemoveBracesToArrowFunction_exports = {};
@@ -140724,7 +140899,7 @@ function getEditInfoForConvertToNamedFunction(context, func, variableInfo) {
   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) {
@@ -142081,7 +142256,7 @@ function getRangeToExtract2(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;
         }
@@ -143089,7 +143264,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;
         }
       }
@@ -143573,14 +143748,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 */;
               }
             }
@@ -144298,7 +144473,7 @@ var SourceFileObject = class extends NodeObject {
           forEachChild(node, visit);
           break;
         case 169 /* Parameter */:
-          if (!hasSyntacticModifier(node, 16476 /* ParameterPropertyModifier */)) {
+          if (!hasSyntacticModifier(node, 31 /* ParameterPropertyModifier */)) {
             break;
           }
         case 260 /* VariableDeclaration */:
@@ -146151,7 +146326,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) {
@@ -146159,7 +146334,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)) {
@@ -146178,7 +146353,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) {
@@ -146740,7 +146915,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);
   }
 }
@@ -147072,7 +147247,7 @@ function makeChange2(changeTracker, sourceFile, insertionSite, fixedDeclarations
       /*includeTrivia*/
       true
     ),
-    factory.createNodeArray(factory.createModifiersFromModifierFlags(getSyntacticModifierFlags(insertionSite) | 512 /* Async */))
+    factory.createNodeArray(factory.createModifiersFromModifierFlags(getSyntacticModifierFlags(insertionSite) | 1024 /* Async */))
   );
   changeTracker.replaceNode(
     sourceFile,
@@ -147197,7 +147372,7 @@ function findAwaitableInitializers(expression, sourceFile, cancellationToken, pr
     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;
     }
@@ -149841,7 +150016,7 @@ function getClass(sourceFile, pos) {
   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();
@@ -151814,7 +151989,7 @@ function getInfo8(sourceFile, pos, context, errorCode) {
     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;
@@ -151988,7 +152163,7 @@ function checkFixedAssignableTo(checker, declaration, exprType, type, isFunction
   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(
@@ -152202,13 +152377,13 @@ registerCodeFix({
             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 */);
             }
           }
         }
@@ -152289,13 +152464,13 @@ function getInfo10(sourceFile, tokenPos, errorCode, checker, program) {
     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);
@@ -152307,7 +152482,7 @@ function getInfo10(sourceFile, tokenPos, errorCode, checker, program) {
     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 };
@@ -152325,11 +152500,11 @@ function createActionForAddMissingMemberInJavascriptFile(context, { parentDeclar
   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) {
@@ -152373,15 +152548,15 @@ function initializePropertyToUndefined(obj, propertyName) {
 }
 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;
@@ -152468,9 +152643,9 @@ function getActionsForMissingMethodDeclaration(context, info) {
   }
   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;
 }
@@ -152886,7 +153061,7 @@ function addMissingMembers(classDeclaration, sourceFile, context, changeTracker,
 }
 function symbolPointsToNonPrivateAndAbstractMember(symbol) {
   const flags = getSyntacticModifierFlags(first(symbol.getDeclarations()));
-  return !(flags & 8 /* Private */) && !!(flags & 256 /* Abstract */);
+  return !(flags & 2 /* Private */) && !!(flags & 64 /* Abstract */);
 }
 
 // src/services/codefixes/fixClassSuperMustPrecedeThisAccess.ts
@@ -155220,10 +155395,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));
@@ -155889,24 +156064,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)
@@ -155917,7 +156092,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)
     };
@@ -156287,7 +156462,7 @@ function getDefaultValueFromType(checker, type) {
     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)
@@ -158004,7 +158179,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,
@@ -158023,10 +158198,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;
@@ -158040,21 +158215,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));
@@ -158091,7 +158266,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);
   }
@@ -159264,57 +159439,109 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
   function addPropertySymbol(symbol, insertAwait, insertQuestionDot) {
     var _a;
     const computedPropertyName = firstDefined(symbol.declarations, (decl) => tryCast(getNameOfDeclaration(decl), isComputedPropertyName));
-    if (computedPropertyName) {
-      const leftMostName = getLeftMostName(computedPropertyName.expression);
-      const nameSymbol = leftMostName && typeChecker.getSymbolAtLocation(leftMostName);
-      const firstAccessibleSymbol = nameSymbol && getFirstSymbolInChain(nameSymbol, contextToken, typeChecker);
-      const firstAccessibleSymbolId = firstAccessibleSymbol && getSymbolId(firstAccessibleSymbol);
-      if (firstAccessibleSymbolId && addToSeen(seenPropertySymbols, firstAccessibleSymbolId)) {
-        const index = symbols.length;
-        symbols.push(firstAccessibleSymbol);
-        const moduleSymbol = firstAccessibleSymbol.parent;
-        if (!moduleSymbol || !isExternalModuleSymbol(moduleSymbol) || typeChecker.tryGetMemberInModuleExportsAndProperties(firstAccessibleSymbol.name, moduleSymbol) !== firstAccessibleSymbol) {
-          symbolToOriginInfoMap[index] = { kind: getNullableSymbolOriginInfoKind(2 /* SymbolMemberNoExport */) };
+    if (!computedPropertyName) {
+      addLiteralSymbol();
+      return;
+    }
+    const computedPropertyNameExpression = computedPropertyName.expression;
+    const name = isEntityName(computedPropertyNameExpression) ? computedPropertyNameExpression : isPropertyAccessExpression(computedPropertyNameExpression) ? computedPropertyNameExpression.name : void 0;
+    const nameSymbol = name && typeChecker.getSymbolAtLocation(name);
+    const nameSymbolId = nameSymbol && getSymbolId(nameSymbol);
+    if (!nameSymbolId) {
+      addLiteralSymbol();
+      return;
+    }
+    if (addToSeen(seenPropertySymbols, nameSymbolId)) {
+      const leftMostName = getLeftMostName(computedPropertyNameExpression);
+      const leftMostNameSymbol = leftMostName && typeChecker.getSymbolAtLocation(leftMostName);
+      const firstAccessibleSymbol = leftMostNameSymbol && getFirstSymbolInChain(leftMostNameSymbol, contextToken, typeChecker);
+      if (!firstAccessibleSymbol) {
+        addLiteralSymbol();
+        return;
+      }
+      const index = symbols.length;
+      symbols.push(nameSymbol);
+      const moduleSymbol = firstAccessibleSymbol.parent;
+      if (!moduleSymbol || !isExternalModuleSymbol(moduleSymbol) || typeChecker.tryGetMemberInModuleExportsAndProperties(firstAccessibleSymbol.name, moduleSymbol) !== firstAccessibleSymbol) {
+        const node2 = preferences.includeCompletionsWithInsertText ? createComputedPropertyAccess(nameSymbol, leftMostNameSymbol, computedPropertyNameExpression) : void 0;
+        if (!node2) {
+          symbols[index] = symbol;
         } else {
-          const fileName = isExternalModuleNameRelative(stripQuotes(moduleSymbol.name)) ? (_a = getSourceFileOfModule(moduleSymbol)) == null ? void 0 : _a.fileName : void 0;
-          const { moduleSpecifier } = (importSpecifierResolver || (importSpecifierResolver = ts_codefix_exports.createImportSpecifierResolver(sourceFile, program, host, preferences))).getModuleSpecifierForBestExportInfo(
-            [{
-              exportKind: 0 /* Named */,
-              moduleFileName: fileName,
-              isFromPackageJson: false,
-              moduleSymbol,
-              symbol: firstAccessibleSymbol,
-              targetFlags: skipAlias(firstAccessibleSymbol, typeChecker).flags
-            }],
-            position,
-            isValidTypeOnlyAliasUseSite(location)
-          ) || {};
-          if (moduleSpecifier) {
-            const origin = {
-              kind: getNullableSymbolOriginInfoKind(6 /* SymbolMemberExport */),
-              moduleSymbol,
-              isDefaultExport: false,
-              symbolName: firstAccessibleSymbol.name,
-              exportName: firstAccessibleSymbol.name,
-              fileName,
-              moduleSpecifier
-            };
-            symbolToOriginInfoMap[index] = origin;
-          }
+          const printer = createPrinter({
+            removeComments: true,
+            module: compilerOptions.module,
+            target: compilerOptions.target,
+            omitTrailingSemicolon: true
+          });
+          const origin = {
+            kind: getNullableSymbolOriginInfoKind(2 /* SymbolMemberNoExport */) | 512 /* ComputedPropertyName */,
+            symbolName: printer.printNode(4 /* Unspecified */, node2, contextToken.getSourceFile())
+          };
+          symbolToOriginInfoMap[index] = origin;
         }
-      } else if (preferences.includeCompletionsWithInsertText) {
-        if (firstAccessibleSymbolId && seenPropertySymbols.has(firstAccessibleSymbolId)) {
-          return;
+      } else {
+        const fileName = isExternalModuleNameRelative(stripQuotes(moduleSymbol.name)) ? (_a = getSourceFileOfModule(moduleSymbol)) == null ? void 0 : _a.fileName : void 0;
+        const { moduleSpecifier } = (importSpecifierResolver || (importSpecifierResolver = ts_codefix_exports.createImportSpecifierResolver(sourceFile, program, host, preferences))).getModuleSpecifierForBestExportInfo(
+          [{
+            exportKind: 0 /* Named */,
+            moduleFileName: fileName,
+            isFromPackageJson: false,
+            moduleSymbol,
+            symbol: firstAccessibleSymbol,
+            targetFlags: skipAlias(firstAccessibleSymbol, typeChecker).flags
+          }],
+          position,
+          isValidTypeOnlyAliasUseSite(location)
+        ) || {};
+        if (moduleSpecifier) {
+          const origin = {
+            kind: getNullableSymbolOriginInfoKind(6 /* SymbolMemberExport */),
+            moduleSymbol,
+            isDefaultExport: false,
+            symbolName: firstAccessibleSymbol.name,
+            exportName: firstAccessibleSymbol.name,
+            fileName,
+            moduleSpecifier
+          };
+          symbolToOriginInfoMap[index] = origin;
         }
-        addSymbolOriginInfo(symbol);
-        addSymbolSortInfo(symbol);
-        symbols.push(symbol);
       }
-    } else {
+    }
+    function addLiteralSymbol() {
       addSymbolOriginInfo(symbol);
       addSymbolSortInfo(symbol);
       symbols.push(symbol);
     }
+    function createComputedPropertyAccess(nameSymbol2, leftMostNameSymbol, computedPropertyNameExpression2) {
+      let node2;
+      if (!isTransientSymbol(nameSymbol2)) {
+        node2 = typeChecker.symbolToEntityName(
+          nameSymbol2,
+          /*meaning*/
+          void 0,
+          contextToken,
+          16384 /* UseAliasDefinedOutsideCurrentScope */
+        );
+      } else {
+        let createPropertyAccess2 = function(n) {
+          if (isIdentifier(n)) {
+            Debug.assertNode(leftMostNodeAccessExpression, isExpression);
+            return leftMostNodeAccessExpression;
+          }
+          return factory.createPropertyAccessExpression(createPropertyAccess2(n.expression), n.name);
+        };
+        var createPropertyAccess = createPropertyAccess2;
+        const leftMostNodeAccessExpression = typeChecker.symbolToNode(
+          leftMostNameSymbol,
+          /*meaning*/
+          void 0,
+          contextToken,
+          16384 /* UseAliasDefinedOutsideCurrentScope */
+        );
+        node2 = createPropertyAccess2(computedPropertyNameExpression2);
+      }
+      return node2;
+    }
     function addSymbolSortInfo(symbol2) {
       if (isStaticProperty(symbol2)) {
         symbolToSortTextMap[getSymbolId(symbol2)] = SortText.LocalDeclarationPriority;
@@ -159841,24 +160068,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) => {
@@ -160161,10 +160388,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);
@@ -160173,7 +160400,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) {
@@ -160285,7 +160512,7 @@ function getCompletionEntryDisplayNameForSymbol(symbol, target, origin, kind, js
       return { name: JSON.stringify(name), needsConvertPropertyAccess: false };
     case 2 /* PropertyAccess */:
     case 1 /* Global */:
-      return name.charCodeAt(0) === 32 /* space */ ? void 0 : { name, needsConvertPropertyAccess: true };
+      return name.charCodeAt(0) === 32 /* space */ ? void 0 : { name, needsConvertPropertyAccess: !originIsComputedPropertyName(origin) };
     case 5 /* None */:
     case 4 /* String */:
       return validNameResult;
@@ -160435,7 +160662,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");
@@ -160595,7 +160822,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);
@@ -161395,7 +161622,7 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, c
               }
               const keys = getOwnKeys(exports);
               const fragmentSubpath = components.join("/") + (components.length && hasTrailingDirectorySeparator(fragment) ? "/" : "");
-              const conditions = getConditions(compilerOptions, mode === 99 /* ESNext */);
+              const conditions = getConditions(compilerOptions, mode);
               addCompletionEntriesFromPathsOrExports(
                 result,
                 fragmentSubpath,
@@ -161728,7 +161955,7 @@ function getImportersForExport(sourceFiles, sourceFilesSet, allDirectImports, {
             handleNamespaceImport(
               direct,
               direct.name,
-              hasSyntacticModifier(direct, 1 /* Export */),
+              hasSyntacticModifier(direct, 32 /* Export */),
               /*alreadyAddedDirect*/
               false
             );
@@ -162043,7 +162270,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;
@@ -162120,7 +162347,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) {
@@ -162263,7 +162490,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;
@@ -163224,7 +163451,7 @@ var Core;
       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 */);
       }
@@ -163734,7 +163961,7 @@ var Core;
     if (!searchSpaceNode) {
       return void 0;
     }
-    let staticFlag = 32 /* Static */;
+    let staticFlag = 256 /* Static */;
     switch (searchSpaceNode.kind) {
       case 172 /* PropertyDeclaration */:
       case 171 /* PropertySignature */:
@@ -163774,7 +164001,7 @@ var Core;
       /*includeClassComputedPropertyName*/
       false
     );
-    let staticFlag = 32 /* Static */;
+    let staticFlag = 256 /* Static */;
     switch (searchSpaceNode.kind) {
       case 174 /* MethodDeclaration */:
       case 173 /* MethodSignature */:
@@ -164016,7 +164243,7 @@ var Core;
     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;
@@ -164566,7 +164793,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 */:
@@ -165387,6 +165614,10 @@ function getCommentHavingNodes(declaration) {
     case 345 /* JSDocCallbackTag */:
     case 353 /* JSDocTypedefTag */:
       return [declaration, declaration.parent];
+    case 330 /* JSDocSignature */:
+      if (isJSDocOverloadTag(declaration.parent)) {
+        return [declaration.parent.parent];
+      }
     default:
       return getJSDocCommentsAndTags(declaration);
   }
@@ -167642,7 +167873,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(",");
@@ -167918,7 +168149,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,