typescript 5.0.0-dev.20221116 → 5.0.0-dev.20221117

package/lib/tsserver.js

@@ -2648,7 +2648,7 @@ var ts = (() => {
 
   // src/compiler/corePublic.ts
   var versionMajorMinor = "5.0";
-  var version = `${versionMajorMinor}.0-dev.20221116`;
+  var version = `${versionMajorMinor}.0-dev.20221117`;
   var Comparison = /* @__PURE__ */ ((Comparison3) => {
     Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
     Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6868,6 +6868,7 @@ ${lanes.join("\n")}
     return EnumKind2;
   })(EnumKind || {});
   var CheckFlags = /* @__PURE__ */ ((CheckFlags2) => {
+    CheckFlags2[CheckFlags2["None"] = 0] = "None";
     CheckFlags2[CheckFlags2["Instantiated"] = 1] = "Instantiated";
     CheckFlags2[CheckFlags2["SyntheticProperty"] = 2] = "SyntheticProperty";
     CheckFlags2[CheckFlags2["SyntheticMethod"] = 4] = "SyntheticMethod";
@@ -6915,31 +6916,32 @@ ${lanes.join("\n")}
     return InternalSymbolName2;
   })(InternalSymbolName || {});
   var NodeCheckFlags = /* @__PURE__ */ ((NodeCheckFlags2) => {
+    NodeCheckFlags2[NodeCheckFlags2["None"] = 0] = "None";
     NodeCheckFlags2[NodeCheckFlags2["TypeChecked"] = 1] = "TypeChecked";
     NodeCheckFlags2[NodeCheckFlags2["LexicalThis"] = 2] = "LexicalThis";
     NodeCheckFlags2[NodeCheckFlags2["CaptureThis"] = 4] = "CaptureThis";
     NodeCheckFlags2[NodeCheckFlags2["CaptureNewTarget"] = 8] = "CaptureNewTarget";
-    NodeCheckFlags2[NodeCheckFlags2["SuperInstance"] = 256] = "SuperInstance";
-    NodeCheckFlags2[NodeCheckFlags2["SuperStatic"] = 512] = "SuperStatic";
-    NodeCheckFlags2[NodeCheckFlags2["ContextChecked"] = 1024] = "ContextChecked";
-    NodeCheckFlags2[NodeCheckFlags2["MethodWithSuperPropertyAccessInAsync"] = 2048] = "MethodWithSuperPropertyAccessInAsync";
-    NodeCheckFlags2[NodeCheckFlags2["MethodWithSuperPropertyAssignmentInAsync"] = 4096] = "MethodWithSuperPropertyAssignmentInAsync";
-    NodeCheckFlags2[NodeCheckFlags2["CaptureArguments"] = 8192] = "CaptureArguments";
-    NodeCheckFlags2[NodeCheckFlags2["EnumValuesComputed"] = 16384] = "EnumValuesComputed";
-    NodeCheckFlags2[NodeCheckFlags2["LexicalModuleMergesWithClass"] = 32768] = "LexicalModuleMergesWithClass";
-    NodeCheckFlags2[NodeCheckFlags2["LoopWithCapturedBlockScopedBinding"] = 65536] = "LoopWithCapturedBlockScopedBinding";
-    NodeCheckFlags2[NodeCheckFlags2["ContainsCapturedBlockScopeBinding"] = 131072] = "ContainsCapturedBlockScopeBinding";
-    NodeCheckFlags2[NodeCheckFlags2["CapturedBlockScopedBinding"] = 262144] = "CapturedBlockScopedBinding";
-    NodeCheckFlags2[NodeCheckFlags2["BlockScopedBindingInLoop"] = 524288] = "BlockScopedBindingInLoop";
-    NodeCheckFlags2[NodeCheckFlags2["ClassWithBodyScopedClassBinding"] = 1048576] = "ClassWithBodyScopedClassBinding";
-    NodeCheckFlags2[NodeCheckFlags2["BodyScopedClassBinding"] = 2097152] = "BodyScopedClassBinding";
-    NodeCheckFlags2[NodeCheckFlags2["NeedsLoopOutParameter"] = 4194304] = "NeedsLoopOutParameter";
-    NodeCheckFlags2[NodeCheckFlags2["AssignmentsMarked"] = 8388608] = "AssignmentsMarked";
-    NodeCheckFlags2[NodeCheckFlags2["ClassWithConstructorReference"] = 16777216] = "ClassWithConstructorReference";
-    NodeCheckFlags2[NodeCheckFlags2["ConstructorReferenceInClass"] = 33554432] = "ConstructorReferenceInClass";
-    NodeCheckFlags2[NodeCheckFlags2["ContainsClassWithPrivateIdentifiers"] = 67108864] = "ContainsClassWithPrivateIdentifiers";
-    NodeCheckFlags2[NodeCheckFlags2["ContainsSuperPropertyInStaticInitializer"] = 134217728] = "ContainsSuperPropertyInStaticInitializer";
-    NodeCheckFlags2[NodeCheckFlags2["InCheckIdentifier"] = 268435456] = "InCheckIdentifier";
+    NodeCheckFlags2[NodeCheckFlags2["SuperInstance"] = 16] = "SuperInstance";
+    NodeCheckFlags2[NodeCheckFlags2["SuperStatic"] = 32] = "SuperStatic";
+    NodeCheckFlags2[NodeCheckFlags2["ContextChecked"] = 64] = "ContextChecked";
+    NodeCheckFlags2[NodeCheckFlags2["MethodWithSuperPropertyAccessInAsync"] = 128] = "MethodWithSuperPropertyAccessInAsync";
+    NodeCheckFlags2[NodeCheckFlags2["MethodWithSuperPropertyAssignmentInAsync"] = 256] = "MethodWithSuperPropertyAssignmentInAsync";
+    NodeCheckFlags2[NodeCheckFlags2["CaptureArguments"] = 512] = "CaptureArguments";
+    NodeCheckFlags2[NodeCheckFlags2["EnumValuesComputed"] = 1024] = "EnumValuesComputed";
+    NodeCheckFlags2[NodeCheckFlags2["LexicalModuleMergesWithClass"] = 2048] = "LexicalModuleMergesWithClass";
+    NodeCheckFlags2[NodeCheckFlags2["LoopWithCapturedBlockScopedBinding"] = 4096] = "LoopWithCapturedBlockScopedBinding";
+    NodeCheckFlags2[NodeCheckFlags2["ContainsCapturedBlockScopeBinding"] = 8192] = "ContainsCapturedBlockScopeBinding";
+    NodeCheckFlags2[NodeCheckFlags2["CapturedBlockScopedBinding"] = 16384] = "CapturedBlockScopedBinding";
+    NodeCheckFlags2[NodeCheckFlags2["BlockScopedBindingInLoop"] = 32768] = "BlockScopedBindingInLoop";
+    NodeCheckFlags2[NodeCheckFlags2["ClassWithBodyScopedClassBinding"] = 65536] = "ClassWithBodyScopedClassBinding";
+    NodeCheckFlags2[NodeCheckFlags2["BodyScopedClassBinding"] = 131072] = "BodyScopedClassBinding";
+    NodeCheckFlags2[NodeCheckFlags2["NeedsLoopOutParameter"] = 262144] = "NeedsLoopOutParameter";
+    NodeCheckFlags2[NodeCheckFlags2["AssignmentsMarked"] = 524288] = "AssignmentsMarked";
+    NodeCheckFlags2[NodeCheckFlags2["ClassWithConstructorReference"] = 1048576] = "ClassWithConstructorReference";
+    NodeCheckFlags2[NodeCheckFlags2["ConstructorReferenceInClass"] = 2097152] = "ConstructorReferenceInClass";
+    NodeCheckFlags2[NodeCheckFlags2["ContainsClassWithPrivateIdentifiers"] = 4194304] = "ContainsClassWithPrivateIdentifiers";
+    NodeCheckFlags2[NodeCheckFlags2["ContainsSuperPropertyInStaticInitializer"] = 8388608] = "ContainsSuperPropertyInStaticInitializer";
+    NodeCheckFlags2[NodeCheckFlags2["InCheckIdentifier"] = 16777216] = "InCheckIdentifier";
     return NodeCheckFlags2;
   })(NodeCheckFlags || {});
   var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
@@ -7012,6 +7014,7 @@ ${lanes.join("\n")}
     return TypeFlags2;
   })(TypeFlags || {});
   var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
+    ObjectFlags3[ObjectFlags3["None"] = 0] = "None";
     ObjectFlags3[ObjectFlags3["Class"] = 1] = "Class";
     ObjectFlags3[ObjectFlags3["Interface"] = 2] = "Interface";
     ObjectFlags3[ObjectFlags3["Reference"] = 4] = "Reference";
@@ -7129,6 +7132,7 @@ ${lanes.join("\n")}
     return TypeMapKind2;
   })(TypeMapKind || {});
   var InferencePriority = /* @__PURE__ */ ((InferencePriority2) => {
+    InferencePriority2[InferencePriority2["None"] = 0] = "None";
     InferencePriority2[InferencePriority2["NakedTypeVariable"] = 1] = "NakedTypeVariable";
     InferencePriority2[InferencePriority2["SpeculativeTuple"] = 2] = "SpeculativeTuple";
     InferencePriority2[InferencePriority2["SubstituteSource"] = 4] = "SubstituteSource";
@@ -42900,6 +42904,7 @@ ${lanes.join("\n")}
     return CheckMode3;
   })(CheckMode || {});
   var SignatureCheckMode = /* @__PURE__ */ ((SignatureCheckMode3) => {
+    SignatureCheckMode3[SignatureCheckMode3["None"] = 0] = "None";
     SignatureCheckMode3[SignatureCheckMode3["BivariantCallback"] = 1] = "BivariantCallback";
     SignatureCheckMode3[SignatureCheckMode3["StrictCallback"] = 2] = "StrictCallback";
     SignatureCheckMode3[SignatureCheckMode3["IgnoreReturnTypes"] = 4] = "IgnoreReturnTypes";
@@ -42917,7 +42922,7 @@ ${lanes.join("\n")}
   function SymbolLinks() {
   }
   function NodeLinks() {
-    this.flags = 0;
+    this.flags = 0 /* None */;
   }
   function getNodeId(node) {
     if (!node.id) {
@@ -43762,7 +43767,7 @@ ${lanes.join("\n")}
     function createSymbol(flags, name, checkFlags) {
       symbolCount++;
       const symbol = new Symbol46(flags | 33554432 /* Transient */, name);
-      symbol.checkFlags = checkFlags || 0;
+      symbol.checkFlags = checkFlags || 0 /* None */;
       return symbol;
     }
     function getExcludedSymbolFlags(flags) {
@@ -46073,7 +46078,7 @@ ${lanes.join("\n")}
     function createOriginType(flags) {
       return new Type27(checker, flags);
     }
-    function createIntrinsicType(kind, intrinsicName, objectFlags = 0) {
+    function createIntrinsicType(kind, intrinsicName, objectFlags = 0 /* None */) {
       const type = createType(kind);
       type.intrinsicName = intrinsicName;
       type.objectFlags = objectFlags;
@@ -52914,7 +52919,7 @@ ${lanes.join("\n")}
     function containsArgumentsReference(declaration) {
       const links = getNodeLinks(declaration);
       if (links.containsArgumentsReference === void 0) {
-        if (links.flags & 8192 /* CaptureArguments */) {
+        if (links.flags & 512 /* CaptureArguments */) {
           links.containsArgumentsReference = true;
         } else {
           links.containsArgumentsReference = traverse(declaration.body);
@@ -56814,7 +56819,7 @@ ${lanes.join("\n")}
       return compareSignaturesRelated(
         source,
         target,
-        ignoreReturnTypes ? 4 /* IgnoreReturnTypes */ : 0,
+        ignoreReturnTypes ? 4 /* IgnoreReturnTypes */ : 0 /* None */,
         false,
         void 0,
         void 0,
@@ -57048,7 +57053,9 @@ ${lanes.join("\n")}
       if (relation === assignableRelation || relation === comparableRelation) {
         if (s & 1 /* Any */)
           return true;
-        if (s & (8 /* Number */ | 256 /* NumberLiteral */) && !(s & 1024 /* EnumLiteral */) && (t & 32 /* Enum */ || relation === assignableRelation && t & 256 /* NumberLiteral */ && t & 1024 /* EnumLiteral */))
+        if (s & 8 /* Number */ && (t & 32 /* Enum */ || t & 256 /* NumberLiteral */ && t & 1024 /* EnumLiteral */))
+          return true;
+        if (s & 256 /* NumberLiteral */ && !(s & 1024 /* EnumLiteral */) && (t & 32 /* Enum */ || t & 256 /* NumberLiteral */ && t & 1024 /* EnumLiteral */ && source.value === target.value))
           return true;
         if (isUnknownLikeUnionType(target))
           return true;
@@ -60111,7 +60118,7 @@ ${lanes.join("\n")}
         pos = p;
       }
     }
-    function inferTypes(inferences, originalSource, originalTarget, priority = 0, contravariant = false) {
+    function inferTypes(inferences, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
       let bivariant = false;
       let propagationType;
       let inferencePriority = 2048 /* MaxValue */;
@@ -62553,8 +62560,8 @@ ${lanes.join("\n")}
       }
       const parent2 = getRootDeclaration(symbol.valueDeclaration).parent;
       const links = getNodeLinks(parent2);
-      if (!(links.flags & 8388608 /* AssignmentsMarked */)) {
-        links.flags |= 8388608 /* AssignmentsMarked */;
+      if (!(links.flags & 524288 /* AssignmentsMarked */)) {
+        links.flags |= 524288 /* AssignmentsMarked */;
         if (!hasParentWithAssignmentsMarked(parent2)) {
           markNodeAssignments(parent2);
         }
@@ -62562,7 +62569,7 @@ ${lanes.join("\n")}
       return symbol.isAssigned || false;
     }
     function hasParentWithAssignmentsMarked(node) {
-      return !!findAncestor(node.parent, (node2) => (isFunctionLike(node2) || isCatchClause(node2)) && !!(getNodeLinks(node2).flags & 8388608 /* AssignmentsMarked */));
+      return !!findAncestor(node.parent, (node2) => (isFunctionLike(node2) || isCatchClause(node2)) && !!(getNodeLinks(node2).flags & 524288 /* AssignmentsMarked */));
     }
     function markNodeAssignments(node) {
       if (node.kind === 79 /* Identifier */) {
@@ -62641,11 +62648,11 @@ ${lanes.join("\n")}
           const parent2 = declaration.parent.parent;
           if (parent2.kind === 257 /* VariableDeclaration */ && getCombinedNodeFlags(declaration) & 2 /* Const */ || parent2.kind === 166 /* Parameter */) {
             const links = getNodeLinks(parent2);
-            if (!(links.flags & 268435456 /* InCheckIdentifier */)) {
-              links.flags |= 268435456 /* InCheckIdentifier */;
+            if (!(links.flags & 16777216 /* InCheckIdentifier */)) {
+              links.flags |= 16777216 /* InCheckIdentifier */;
               const parentType = getTypeForBindingElementParent(parent2, 0 /* Normal */);
               const parentTypeConstraint = parentType && mapType(parentType, getBaseConstraintOrType);
-              links.flags &= ~268435456 /* InCheckIdentifier */;
+              links.flags &= ~16777216 /* InCheckIdentifier */;
               if (parentTypeConstraint && parentTypeConstraint.flags & 1048576 /* Union */ && !(parent2.kind === 166 /* Parameter */ && isSymbolAssigned(symbol))) {
                 const pattern = declaration.parent;
                 const narrowedType = getFlowTypeOfReference(pattern, parentTypeConstraint, parentTypeConstraint, void 0, location2.flowNode);
@@ -62695,7 +62702,7 @@ ${lanes.join("\n")}
             error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_using_a_standard_function_or_method);
           }
         }
-        getNodeLinks(container).flags |= 8192 /* CaptureArguments */;
+        getNodeLinks(container).flags |= 512 /* CaptureArguments */;
         return getTypeOfSymbol(symbol);
       }
       if (shouldMarkIdentifierAliasReferenced(node)) {
@@ -62712,8 +62719,8 @@ ${lanes.join("\n")}
           let container = getContainingClass(node);
           while (container !== void 0) {
             if (container === declaration && container.name !== node) {
-              getNodeLinks(declaration).flags |= 16777216 /* ClassWithConstructorReference */;
-              getNodeLinks(node).flags |= 33554432 /* ConstructorReferenceInClass */;
+              getNodeLinks(declaration).flags |= 1048576 /* ClassWithConstructorReference */;
+              getNodeLinks(node).flags |= 2097152 /* ConstructorReferenceInClass */;
               break;
             }
             container = getContainingClass(container);
@@ -62723,8 +62730,8 @@ ${lanes.join("\n")}
           while (container.kind !== 308 /* SourceFile */) {
             if (container.parent === declaration) {
               if (isPropertyDeclaration(container) && isStatic(container) || isClassStaticBlockDeclaration(container)) {
-                getNodeLinks(declaration).flags |= 16777216 /* ClassWithConstructorReference */;
-                getNodeLinks(node).flags |= 33554432 /* ConstructorReferenceInClass */;
+                getNodeLinks(declaration).flags |= 1048576 /* ClassWithConstructorReference */;
+                getNodeLinks(node).flags |= 2097152 /* ConstructorReferenceInClass */;
               }
               break;
             }
@@ -62838,7 +62845,7 @@ ${lanes.join("\n")}
               const part = getPartOfForStatementContainingNode(node.parent, container);
               if (part) {
                 const links = getNodeLinks(part);
-                links.flags |= 131072 /* ContainsCapturedBlockScopeBinding */;
+                links.flags |= 8192 /* ContainsCapturedBlockScopeBinding */;
                 const capturedBindings = links.capturedBlockScopeBindings || (links.capturedBlockScopeBindings = []);
                 pushIfUnique(capturedBindings, symbol);
                 if (part === container.initializer) {
@@ -62848,19 +62855,19 @@ ${lanes.join("\n")}
             }
           }
           if (capturesBlockScopeBindingInLoopBody) {
-            getNodeLinks(enclosingIterationStatement).flags |= 65536 /* LoopWithCapturedBlockScopedBinding */;
+            getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
           }
         }
         if (isForStatement(container)) {
           const varDeclList = getAncestor(symbol.valueDeclaration, 258 /* VariableDeclarationList */);
           if (varDeclList && varDeclList.parent === container && isAssignedInBodyOfForStatement(node, container)) {
-            getNodeLinks(symbol.valueDeclaration).flags |= 4194304 /* NeedsLoopOutParameter */;
+            getNodeLinks(symbol.valueDeclaration).flags |= 262144 /* NeedsLoopOutParameter */;
           }
         }
-        getNodeLinks(symbol.valueDeclaration).flags |= 524288 /* BlockScopedBindingInLoop */;
+        getNodeLinks(symbol.valueDeclaration).flags |= 32768 /* BlockScopedBindingInLoop */;
       }
       if (isCaptured) {
-        getNodeLinks(symbol.valueDeclaration).flags |= 262144 /* CapturedBlockScopedBinding */;
+        getNodeLinks(symbol.valueDeclaration).flags |= 16384 /* CapturedBlockScopedBinding */;
       }
     }
     function isBindingCapturedByNode(node, decl) {
@@ -63077,23 +63084,23 @@ ${lanes.join("\n")}
         checkThisBeforeSuper(node, container, Diagnostics.super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class);
       }
       if (isStatic(container) || isCallExpression2) {
-        nodeCheckFlag = 512 /* SuperStatic */;
+        nodeCheckFlag = 32 /* SuperStatic */;
         if (!isCallExpression2 && languageVersion >= 2 /* ES2015 */ && languageVersion <= 8 /* ES2021 */ && (isPropertyDeclaration(container) || isClassStaticBlockDeclaration(container))) {
           forEachEnclosingBlockScopeContainer(node.parent, (current) => {
             if (!isSourceFile(current) || isExternalOrCommonJsModule(current)) {
-              getNodeLinks(current).flags |= 134217728 /* ContainsSuperPropertyInStaticInitializer */;
+              getNodeLinks(current).flags |= 8388608 /* ContainsSuperPropertyInStaticInitializer */;
             }
           });
         }
       } else {
-        nodeCheckFlag = 256 /* SuperInstance */;
+        nodeCheckFlag = 16 /* SuperInstance */;
       }
       getNodeLinks(node).flags |= nodeCheckFlag;
       if (container.kind === 171 /* MethodDeclaration */ && inAsyncFunction) {
         if (isSuperProperty(node.parent) && isAssignmentTarget(node.parent)) {
-          getNodeLinks(container).flags |= 4096 /* MethodWithSuperPropertyAssignmentInAsync */;
+          getNodeLinks(container).flags |= 256 /* MethodWithSuperPropertyAssignmentInAsync */;
         } else {
-          getNodeLinks(container).flags |= 2048 /* MethodWithSuperPropertyAccessInAsync */;
+          getNodeLinks(container).flags |= 128 /* MethodWithSuperPropertyAccessInAsync */;
         }
       }
       if (needToCaptureLexicalThis) {
@@ -63121,7 +63128,7 @@ ${lanes.join("\n")}
         error(node, Diagnostics.super_cannot_be_referenced_in_constructor_arguments);
         return errorType;
       }
-      return nodeCheckFlag === 512 /* SuperStatic */ ? getBaseConstructorTypeOfClass(classType) : getTypeWithThisArgument(baseClassType, classType.thisType);
+      return nodeCheckFlag === 32 /* SuperStatic */ ? getBaseConstructorTypeOfClass(classType) : getTypeWithThisArgument(baseClassType, classType.thisType);
       function isLegalUsageOfSuperExpression(container2) {
         if (!container2) {
           return false;
@@ -64136,9 +64143,9 @@ ${lanes.join("\n")}
           const container = getEnclosingBlockScopeContainer(node.parent.parent);
           const enclosingIterationStatement = getEnclosingIterationStatement(container);
           if (enclosingIterationStatement) {
-            getNodeLinks(enclosingIterationStatement).flags |= 65536 /* LoopWithCapturedBlockScopedBinding */;
-            getNodeLinks(node).flags |= 524288 /* BlockScopedBindingInLoop */;
-            getNodeLinks(node.parent.parent).flags |= 524288 /* BlockScopedBindingInLoop */;
+            getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
+            getNodeLinks(node).flags |= 32768 /* BlockScopedBindingInLoop */;
+            getNodeLinks(node.parent.parent).flags |= 32768 /* BlockScopedBindingInLoop */;
           }
         }
         if (links.resolvedType.flags & 98304 /* Nullable */ || !isTypeAssignableToKind(links.resolvedType, 402653316 /* StringLike */ | 296 /* NumberLike */ | 12288 /* ESSymbolLike */) && !isTypeAssignableTo(links.resolvedType, stringNumberSymbolType)) {
@@ -68125,10 +68132,10 @@ ${lanes.join("\n")}
     }
     function contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, checkMode) {
       const links = getNodeLinks(node);
-      if (!(links.flags & 1024 /* ContextChecked */)) {
+      if (!(links.flags & 64 /* ContextChecked */)) {
         const contextualSignature = getContextualSignature(node);
-        if (!(links.flags & 1024 /* ContextChecked */)) {
-          links.flags |= 1024 /* ContextChecked */;
+        if (!(links.flags & 64 /* ContextChecked */)) {
+          links.flags |= 64 /* ContextChecked */;
           const signature = firstOrUndefined(getSignaturesOfType(getTypeOfSymbol(getSymbolOfNode(node)), 0 /* Call */));
           if (!signature) {
             return;
@@ -70118,13 +70125,13 @@ ${lanes.join("\n")}
     function setNodeLinksForPrivateIdentifierScope(node) {
       if (isPrivateIdentifier(node.name) && languageVersion < 99 /* ESNext */) {
         for (let lexicalScope = getEnclosingBlockScopeContainer(node); !!lexicalScope; lexicalScope = getEnclosingBlockScopeContainer(lexicalScope)) {
-          getNodeLinks(lexicalScope).flags |= 67108864 /* ContainsClassWithPrivateIdentifiers */;
+          getNodeLinks(lexicalScope).flags |= 4194304 /* ContainsClassWithPrivateIdentifiers */;
         }
         if (isClassExpression(node.parent)) {
           const enclosingIterationStatement = getEnclosingIterationStatement(node.parent);
           if (enclosingIterationStatement) {
-            getNodeLinks(node.name).flags |= 524288 /* BlockScopedBindingInLoop */;
-            getNodeLinks(enclosingIterationStatement).flags |= 65536 /* LoopWithCapturedBlockScopedBinding */;
+            getNodeLinks(node.name).flags |= 32768 /* BlockScopedBindingInLoop */;
+            getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
           }
         }
       }
@@ -71719,7 +71726,7 @@ ${lanes.join("\n")}
     }
     function checkWeakMapSetCollision(node) {
       const enclosingBlockScope = getEnclosingBlockScopeContainer(node);
-      if (getNodeCheckFlags(enclosingBlockScope) & 67108864 /* ContainsClassWithPrivateIdentifiers */) {
+      if (getNodeCheckFlags(enclosingBlockScope) & 4194304 /* ContainsClassWithPrivateIdentifiers */) {
         Debug.assert(isNamedDeclaration(node) && isIdentifier(node.name) && typeof node.name.escapedText === "string", "The target of a WeakMap/WeakSet collision check should be an identifier");
         errorSkippedOn("noEmit", node, Diagnostics.Compiler_reserves_name_0_when_emitting_private_identifier_downlevel, node.name.escapedText);
       }
@@ -71733,18 +71740,18 @@ ${lanes.join("\n")}
       let hasCollision = false;
       if (isClassExpression(node)) {
         for (const member of node.members) {
-          if (getNodeCheckFlags(member) & 134217728 /* ContainsSuperPropertyInStaticInitializer */) {
+          if (getNodeCheckFlags(member) & 8388608 /* ContainsSuperPropertyInStaticInitializer */) {
             hasCollision = true;
             break;
           }
         }
       } else if (isFunctionExpression(node)) {
-        if (getNodeCheckFlags(node) & 134217728 /* ContainsSuperPropertyInStaticInitializer */) {
+        if (getNodeCheckFlags(node) & 8388608 /* ContainsSuperPropertyInStaticInitializer */) {
           hasCollision = true;
         }
       } else {
         const container = getEnclosingBlockScopeContainer(node);
-        if (container && getNodeCheckFlags(container) & 134217728 /* ContainsSuperPropertyInStaticInitializer */) {
+        if (container && getNodeCheckFlags(container) & 8388608 /* ContainsSuperPropertyInStaticInitializer */) {
           hasCollision = true;
         }
       }
@@ -73629,8 +73636,8 @@ ${lanes.join("\n")}
     }
     function computeEnumMemberValues(node) {
       const nodeLinks2 = getNodeLinks(node);
-      if (!(nodeLinks2.flags & 16384 /* EnumValuesComputed */)) {
-        nodeLinks2.flags |= 16384 /* EnumValuesComputed */;
+      if (!(nodeLinks2.flags & 1024 /* EnumValuesComputed */)) {
+        nodeLinks2.flags |= 1024 /* EnumValuesComputed */;
         let autoValue = 0;
         for (const member of node.members) {
           const value = computeMemberValue(member, autoValue);
@@ -73906,7 +73913,7 @@ ${lanes.join("\n")}
           }
           const mergedClass = getDeclarationOfKind(symbol, 260 /* ClassDeclaration */);
           if (mergedClass && inSameLexicalScope(node, mergedClass)) {
-            getNodeLinks(node).flags |= 32768 /* LexicalModuleMergesWithClass */;
+            getNodeLinks(node).flags |= 2048 /* LexicalModuleMergesWithClass */;
           }
         }
         if (isAmbientExternalModule) {
@@ -75537,8 +75544,8 @@ ${lanes.join("\n")}
             const nodeLinks2 = getNodeLinks(symbol.valueDeclaration);
             if (resolveName(container.parent, symbol.escapedName, 111551 /* Value */, void 0, void 0, false)) {
               links.isDeclarationWithCollidingName = true;
-            } else if (nodeLinks2.flags & 262144 /* CapturedBlockScopedBinding */) {
-              const isDeclaredInLoop = nodeLinks2.flags & 524288 /* BlockScopedBindingInLoop */;
+            } else if (nodeLinks2.flags & 16384 /* CapturedBlockScopedBinding */) {
+              const isDeclaredInLoop = nodeLinks2.flags & 32768 /* BlockScopedBindingInLoop */;
               const inLoopInitializer = isIterationStatement(container, false);
               const inLoopBodyBlock = container.kind === 238 /* Block */ && isIterationStatement(container.parent, false);
               links.isDeclarationWithCollidingName = !isBlockScopedContainerTopLevel(container) && (!isDeclaredInLoop || !inLoopInitializer && !inLoopBodyBlock);
@@ -82678,12 +82685,12 @@ ${lanes.join("\n")}
     function visitClassExpressionInNewClassLexicalEnvironment(node, facts) {
       const isDecoratedClassDeclaration = !!(facts & 1 /* ClassWasDecorated */);
       const staticPropertiesOrClassStaticBlocks = getStaticPropertiesAndClassStaticBlock(node);
-      const isClassWithConstructorReference = resolver.getNodeCheckFlags(node) & 16777216 /* ClassWithConstructorReference */;
+      const isClassWithConstructorReference = resolver.getNodeCheckFlags(node) & 1048576 /* ClassWithConstructorReference */;
       let temp;
       function createClassTempVar() {
         const classCheckFlags = resolver.getNodeCheckFlags(node);
-        const isClassWithConstructorReference2 = classCheckFlags & 16777216 /* ClassWithConstructorReference */;
-        const requiresBlockScopedVar = classCheckFlags & 524288 /* BlockScopedBindingInLoop */;
+        const isClassWithConstructorReference2 = classCheckFlags & 1048576 /* ClassWithConstructorReference */;
+        const requiresBlockScopedVar = classCheckFlags & 32768 /* BlockScopedBindingInLoop */;
         return factory2.createTempVariable(requiresBlockScopedVar ? addBlockScopedVariable : hoistVariableDeclaration, !!isClassWithConstructorReference2);
       }
       if (facts & 2 /* NeedsClassConstructorReference */) {
@@ -83196,7 +83203,7 @@ ${lanes.join("\n")}
     }
     function trySubstituteClassAlias(node) {
       if (enabledSubstitutions & 1 /* ClassAliases */) {
-        if (resolver.getNodeCheckFlags(node) & 33554432 /* ConstructorReferenceInClass */) {
+        if (resolver.getNodeCheckFlags(node) & 2097152 /* ConstructorReferenceInClass */) {
           const declaration = resolver.getReferencedValueDeclaration(node);
           if (declaration) {
             const classAlias = classAliases[declaration.id];
@@ -83219,7 +83226,7 @@ ${lanes.join("\n")}
         const alreadyTransformed = isAssignmentExpression(innerExpression) && isGeneratedIdentifier(innerExpression.left);
         if (!alreadyTransformed && !inlinable && shouldHoist) {
           const generatedName = factory2.getGeneratedNameForNode(name);
-          if (resolver.getNodeCheckFlags(name) & 524288 /* BlockScopedBindingInLoop */) {
+          if (resolver.getNodeCheckFlags(name) & 32768 /* BlockScopedBindingInLoop */) {
             addBlockScopedVariable(generatedName);
           } else {
             hoistVariableDeclaration(generatedName);
@@ -83368,7 +83375,7 @@ ${lanes.join("\n")}
       const { className } = getPrivateIdentifierEnvironment();
       const prefix = className ? { prefix: "_", node: className, suffix: "_" } : "_";
       const identifier = typeof name === "object" ? factory2.getGeneratedNameForNode(name, 16 /* Optimistic */ | 8 /* ReservedInNestedScopes */, prefix, suffix) : typeof name === "string" ? factory2.createUniqueName(name, 16 /* Optimistic */, prefix, suffix) : factory2.createTempVariable(void 0, true, prefix, suffix);
-      if (resolver.getNodeCheckFlags(node) & 524288 /* BlockScopedBindingInLoop */) {
+      if (resolver.getNodeCheckFlags(node) & 32768 /* BlockScopedBindingInLoop */) {
         addBlockScopedVariable(identifier);
       } else {
         hoistVariableDeclaration(identifier);
@@ -84233,7 +84240,7 @@ ${lanes.join("\n")}
       }
     }
     function getClassAliasIfNeeded(node) {
-      if (resolver.getNodeCheckFlags(node) & 16777216 /* ClassWithConstructorReference */) {
+      if (resolver.getNodeCheckFlags(node) & 1048576 /* ClassWithConstructorReference */) {
         enableSubstitutionForClassAliases();
         const classAlias = factory2.createUniqueName(node.name && !isGeneratedIdentifier(node.name) ? idText(node.name) : "default");
         classAliases[getOriginalNodeId(node)] = classAlias;
@@ -84267,7 +84274,7 @@ ${lanes.join("\n")}
     }
     function trySubstituteClassAlias(node) {
       if (classAliases) {
-        if (resolver.getNodeCheckFlags(node) & 33554432 /* ConstructorReferenceInClass */) {
+        if (resolver.getNodeCheckFlags(node) & 2097152 /* ConstructorReferenceInClass */) {
           const declaration = resolver.getReferencedValueDeclaration(node);
           if (declaration) {
             const classAlias = classAliases[declaration.id];
@@ -84302,7 +84309,7 @@ ${lanes.join("\n")}
     let capturedSuperProperties;
     let hasSuperElementAccess;
     const substitutedSuperAccessors = [];
-    let contextFlags = 0;
+    let contextFlags = 0 /* None */;
     const previousOnEmitNode = context.onEmitNode;
     const previousOnSubstituteNode = context.onSubstituteNode;
     context.onEmitNode = onEmitNode;
@@ -84629,7 +84636,7 @@ ${lanes.join("\n")}
       hasSuperElementAccess = false;
       let updated = visitFunctionBody(node.body, visitor, context);
       const originalMethod = getOriginalNode(node, isFunctionLikeDeclaration);
-      const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* MethodWithSuperPropertyAccessInAsync */) && (getFunctionFlags(originalMethod) & 3 /* AsyncGenerator */) !== 3 /* AsyncGenerator */;
+      const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */) && (getFunctionFlags(originalMethod) & 3 /* AsyncGenerator */) !== 3 /* AsyncGenerator */;
       if (emitSuperHelpers) {
         enableSubstitutionForAsyncMethodsWithSuper();
         if (capturedSuperProperties.size) {
@@ -84640,9 +84647,9 @@ ${lanes.join("\n")}
           updated = factory2.updateBlock(updated, statements);
         }
         if (hasSuperElementAccess) {
-          if (resolver.getNodeCheckFlags(node) & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+          if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
             addEmitHelper(updated, advancedAsyncSuperHelper);
-          } else if (resolver.getNodeCheckFlags(node) & 2048 /* MethodWithSuperPropertyAccessInAsync */) {
+          } else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
             addEmitHelper(updated, asyncSuperHelper);
           }
         }
@@ -84657,7 +84664,7 @@ ${lanes.join("\n")}
       const nodeType = original.type;
       const promiseConstructor = languageVersion < 2 /* ES2015 */ ? getPromiseConstructor(nodeType) : void 0;
       const isArrowFunction2 = node.kind === 216 /* ArrowFunction */;
-      const hasLexicalArguments = (resolver.getNodeCheckFlags(node) & 8192 /* CaptureArguments */) !== 0;
+      const hasLexicalArguments = (resolver.getNodeCheckFlags(node) & 512 /* CaptureArguments */) !== 0;
       const savedEnclosingFunctionParameterNames = enclosingFunctionParameterNames;
       enclosingFunctionParameterNames = /* @__PURE__ */ new Set();
       for (const parameter of node.parameters) {
@@ -84684,7 +84691,7 @@ ${lanes.join("\n")}
           )
         );
         insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
-        const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* MethodWithSuperPropertyAccessInAsync */);
+        const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */);
         if (emitSuperHelpers) {
           enableSubstitutionForAsyncMethodsWithSuper();
           if (capturedSuperProperties.size) {
@@ -84696,9 +84703,9 @@ ${lanes.join("\n")}
         const block = factory2.createBlock(statements, true);
         setTextRange(block, node.body);
         if (emitSuperHelpers && hasSuperElementAccess) {
-          if (resolver.getNodeCheckFlags(node) & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+          if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
             addEmitHelper(block, advancedAsyncSuperHelper);
-          } else if (resolver.getNodeCheckFlags(node) & 2048 /* MethodWithSuperPropertyAccessInAsync */) {
+          } else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
             addEmitHelper(block, asyncSuperHelper);
           }
         }
@@ -84758,7 +84765,7 @@ ${lanes.join("\n")}
     }
     function onEmitNode(hint, node, emitCallback) {
       if (enabledSubstitutions & 1 /* AsyncMethodsWithSuper */ && isSuperContainer(node)) {
-        const superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* MethodWithSuperPropertyAccessInAsync */ | 4096 /* MethodWithSuperPropertyAssignmentInAsync */);
+        const superContainerFlags = resolver.getNodeCheckFlags(node) & (128 /* MethodWithSuperPropertyAccessInAsync */ | 256 /* MethodWithSuperPropertyAssignmentInAsync */);
         if (superContainerFlags !== enclosingSuperContainerFlags) {
           const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
           enclosingSuperContainerFlags = superContainerFlags;
@@ -84834,7 +84841,7 @@ ${lanes.join("\n")}
       return kind === 260 /* ClassDeclaration */ || kind === 173 /* Constructor */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
     }
     function createSuperElementAccessInAsyncMethod(argumentExpression, location2) {
-      if (enclosingSuperContainerFlags & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+      if (enclosingSuperContainerFlags & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
         return setTextRange(
           factory2.createPropertyAccessExpression(
             factory2.createCallExpression(
@@ -84859,7 +84866,7 @@ ${lanes.join("\n")}
     }
   }
   function createSuperAccessVariableStatement(factory2, resolver, node, names) {
-    const hasBinding = (resolver.getNodeCheckFlags(node) & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) !== 0;
+    const hasBinding = (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) !== 0;
     const accessors = [];
     names.forEach((_, key) => {
       const name = unescapeLeadingUnderscores(key);
@@ -85797,7 +85804,7 @@ ${lanes.join("\n")}
           !!(hierarchyFacts & 1 /* HasLexicalThis */)
         )
       );
-      const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* MethodWithSuperPropertyAccessInAsync */);
+      const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */);
       if (emitSuperHelpers) {
         enableSubstitutionForAsyncMethodsWithSuper();
         const variableStatement = createSuperAccessVariableStatement(factory2, resolver, node, capturedSuperProperties);
@@ -85808,9 +85815,9 @@ ${lanes.join("\n")}
       insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
       const block = factory2.updateBlock(node.body, statements);
       if (emitSuperHelpers && hasSuperElementAccess) {
-        if (resolver.getNodeCheckFlags(node) & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+        if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
           addEmitHelper(block, advancedAsyncSuperHelper);
-        } else if (resolver.getNodeCheckFlags(node) & 2048 /* MethodWithSuperPropertyAccessInAsync */) {
+        } else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
           addEmitHelper(block, asyncSuperHelper);
         }
       }
@@ -85920,7 +85927,7 @@ ${lanes.join("\n")}
     }
     function onEmitNode(hint, node, emitCallback) {
       if (enabledSubstitutions & 1 /* AsyncMethodsWithSuper */ && isSuperContainer(node)) {
-        const superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* MethodWithSuperPropertyAccessInAsync */ | 4096 /* MethodWithSuperPropertyAssignmentInAsync */);
+        const superContainerFlags = resolver.getNodeCheckFlags(node) & (128 /* MethodWithSuperPropertyAccessInAsync */ | 256 /* MethodWithSuperPropertyAssignmentInAsync */);
         if (superContainerFlags !== enclosingSuperContainerFlags) {
           const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
           enclosingSuperContainerFlags = superContainerFlags;
@@ -85996,7 +86003,7 @@ ${lanes.join("\n")}
       return kind === 260 /* ClassDeclaration */ || kind === 173 /* Constructor */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
     }
     function createSuperElementAccessInAsyncMethod(argumentExpression, location2) {
-      if (enclosingSuperContainerFlags & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+      if (enclosingSuperContainerFlags & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
         return setTextRange(
           factory2.createPropertyAccessExpression(
             factory2.createCallExpression(
@@ -88352,8 +88359,8 @@ ${lanes.join("\n")}
     }
     function shouldEmitExplicitInitializerForLetDeclaration(node) {
       const flags = resolver.getNodeCheckFlags(node);
-      const isCapturedInFunction = flags & 262144 /* CapturedBlockScopedBinding */;
-      const isDeclaredInLoop = flags & 524288 /* BlockScopedBindingInLoop */;
+      const isCapturedInFunction = flags & 16384 /* CapturedBlockScopedBinding */;
+      const isDeclaredInLoop = flags & 32768 /* BlockScopedBindingInLoop */;
       const emittedAsTopLevel = (hierarchyFacts & 64 /* TopLevel */) !== 0 || isCapturedInFunction && isDeclaredInLoop && (hierarchyFacts & 512 /* IterationStatementBlock */) !== 0;
       const emitExplicitInitializer = !emittedAsTopLevel && (hierarchyFacts & 4096 /* ForInOrForOfStatement */) === 0 && (!resolver.isDeclarationWithCollidingName(node) || isDeclaredInLoop && !isCapturedInFunction && (hierarchyFacts & (2048 /* ForStatement */ | 4096 /* ForInOrForOfStatement */)) === 0);
       return emitExplicitInitializer;
@@ -88714,7 +88721,7 @@ ${lanes.join("\n")}
       return factory2.inlineExpressions(expressions);
     }
     function shouldConvertPartOfIterationStatement(node) {
-      return (resolver.getNodeCheckFlags(node) & 131072 /* ContainsCapturedBlockScopeBinding */) !== 0;
+      return (resolver.getNodeCheckFlags(node) & 8192 /* ContainsCapturedBlockScopeBinding */) !== 0;
     }
     function shouldConvertInitializerOfForStatement(node) {
       return isForStatement(node) && !!node.initializer && shouldConvertPartOfIterationStatement(node.initializer);
@@ -88729,7 +88736,7 @@ ${lanes.join("\n")}
       return shouldConvertBodyOfIterationStatement(node) || shouldConvertInitializerOfForStatement(node);
     }
     function shouldConvertBodyOfIterationStatement(node) {
-      return (resolver.getNodeCheckFlags(node) & 65536 /* LoopWithCapturedBlockScopedBinding */) !== 0;
+      return (resolver.getNodeCheckFlags(node) & 4096 /* LoopWithCapturedBlockScopedBinding */) !== 0;
     }
     function hoistVariableDeclarationDeclaredInConvertedLoop(state, node) {
       if (!state.hoistedLocalVariables) {
@@ -89190,10 +89197,10 @@ ${lanes.join("\n")}
       } else {
         loopParameters.push(factory2.createParameterDeclaration(void 0, void 0, name));
         const checkFlags = resolver.getNodeCheckFlags(decl);
-        if (checkFlags & 4194304 /* NeedsLoopOutParameter */ || hasCapturedBindingsInForHead) {
+        if (checkFlags & 262144 /* NeedsLoopOutParameter */ || hasCapturedBindingsInForHead) {
           const outParamName = factory2.createUniqueName("out_" + idText(name));
-          let flags = 0;
-          if (checkFlags & 4194304 /* NeedsLoopOutParameter */) {
+          let flags = 0 /* None */;
+          if (checkFlags & 262144 /* NeedsLoopOutParameter */) {
             flags |= 1 /* Body */;
           }
           if (isForStatement(container)) {
@@ -148071,6 +148078,7 @@ ${options.prefix}` : "\n" : options.prefix
   // src/services/formatting/rule.ts
   var anyContext = emptyArray;
   var RuleAction = /* @__PURE__ */ ((RuleAction2) => {
+    RuleAction2[RuleAction2["None"] = 0] = "None";
     RuleAction2[RuleAction2["StopProcessingSpaceActions"] = 1] = "StopProcessingSpaceActions";
     RuleAction2[RuleAction2["StopProcessingTokenActions"] = 2] = "StopProcessingTokenActions";
     RuleAction2[RuleAction2["InsertSpace"] = 4] = "InsertSpace";
@@ -148718,7 +148726,7 @@ ${options.prefix}` : "\n" : options.prefix
     return rulesMapCache;
   }
   function getRuleActionExclusion(ruleAction) {
-    let mask2 = 0;
+    let mask2 = 0 /* None */;
     if (ruleAction & 1 /* StopProcessingSpaceActions */) {
       mask2 |= 28 /* ModifySpaceAction */;
     }