typescript 5.0.0-dev.20221116 → 5.0.0-dev.20221118

package/lib/typescript.js

@@ -42,7 +42,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-dev.20221116`;
+      version = `${versionMajorMinor}.0-dev.20221118`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -4320,6 +4320,7 @@ ${lanes.join("\n")}
         return EnumKind2;
       })(EnumKind || {});
       CheckFlags = /* @__PURE__ */ ((CheckFlags2) => {
+        CheckFlags2[CheckFlags2["None"] = 0] = "None";
         CheckFlags2[CheckFlags2["Instantiated"] = 1] = "Instantiated";
         CheckFlags2[CheckFlags2["SyntheticProperty"] = 2] = "SyntheticProperty";
         CheckFlags2[CheckFlags2["SyntheticMethod"] = 4] = "SyntheticMethod";
@@ -4367,31 +4368,32 @@ ${lanes.join("\n")}
         return InternalSymbolName2;
       })(InternalSymbolName || {});
       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 || {});
       TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
@@ -4464,6 +4466,7 @@ ${lanes.join("\n")}
         return TypeFlags2;
       })(TypeFlags || {});
       ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
+        ObjectFlags3[ObjectFlags3["None"] = 0] = "None";
         ObjectFlags3[ObjectFlags3["Class"] = 1] = "Class";
         ObjectFlags3[ObjectFlags3["Interface"] = 2] = "Interface";
         ObjectFlags3[ObjectFlags3["Reference"] = 4] = "Reference";
@@ -4581,6 +4584,7 @@ ${lanes.join("\n")}
         return TypeMapKind2;
       })(TypeMapKind || {});
       InferencePriority = /* @__PURE__ */ ((InferencePriority2) => {
+        InferencePriority2[InferencePriority2["None"] = 0] = "None";
         InferencePriority2[InferencePriority2["NakedTypeVariable"] = 1] = "NakedTypeVariable";
         InferencePriority2[InferencePriority2["SpeculativeTuple"] = 2] = "SpeculativeTuple";
         InferencePriority2[InferencePriority2["SubstituteSource"] = 4] = "SubstituteSource";
@@ -40376,7 +40380,7 @@ ${lanes.join("\n")}
   function SymbolLinks() {
   }
   function NodeLinks() {
-    this.flags = 0;
+    this.flags = 0 /* None */;
   }
   function getNodeId(node) {
     if (!node.id) {
@@ -41221,7 +41225,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) {
@@ -43532,7 +43536,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;
@@ -50373,7 +50377,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);
@@ -50895,8 +50899,21 @@ ${lanes.join("\n")}
           return errorType;
         }
         const aliasSymbol = getAliasSymbolForTypeNode(node);
-        const newAliasSymbol = aliasSymbol && (isLocalTypeAlias(symbol) || !isLocalTypeAlias(aliasSymbol)) ? aliasSymbol : void 0;
-        return getTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node), newAliasSymbol, getTypeArgumentsForAliasSymbol(newAliasSymbol));
+        let newAliasSymbol = aliasSymbol && (isLocalTypeAlias(symbol) || !isLocalTypeAlias(aliasSymbol)) ? aliasSymbol : void 0;
+        let aliasTypeArguments;
+        if (newAliasSymbol) {
+          aliasTypeArguments = getTypeArgumentsForAliasSymbol(newAliasSymbol);
+        } else if (isTypeReferenceType(node)) {
+          const aliasSymbol2 = resolveTypeReferenceName(node, 2097152 /* Alias */, true);
+          if (aliasSymbol2 && aliasSymbol2 !== unknownSymbol) {
+            const resolved = resolveAlias(aliasSymbol2);
+            if (resolved && resolved.flags & 524288 /* TypeAlias */) {
+              newAliasSymbol = resolved;
+              aliasTypeArguments = typeArgumentsFromTypeReferenceNode(node);
+            }
+          }
+        }
+        return getTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node), newAliasSymbol, aliasTypeArguments);
       }
       return checkNoTypeArguments(node, symbol) ? type : errorType;
     }
@@ -54273,7 +54290,7 @@ ${lanes.join("\n")}
       return compareSignaturesRelated(
         source,
         target,
-        ignoreReturnTypes ? 4 /* IgnoreReturnTypes */ : 0,
+        ignoreReturnTypes ? 4 /* IgnoreReturnTypes */ : 0 /* None */,
         false,
         void 0,
         void 0,
@@ -54507,7 +54524,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;
@@ -57570,7 +57589,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 */;
@@ -60012,8 +60031,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);
         }
@@ -60021,7 +60040,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 */) {
@@ -60100,11 +60119,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, location.flowNode);
@@ -60154,7 +60173,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)) {
@@ -60171,8 +60190,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);
@@ -60182,8 +60201,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;
             }
@@ -60297,7 +60316,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) {
@@ -60307,19 +60326,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) {
@@ -60536,23 +60555,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) {
@@ -60580,7 +60599,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;
@@ -61595,9 +61614,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)) {
@@ -65584,10 +65603,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;
@@ -67577,13 +67596,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 */;
           }
         }
       }
@@ -69178,7 +69197,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);
       }
@@ -69192,18 +69211,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;
         }
       }
@@ -71088,8 +71107,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);
@@ -71365,7 +71384,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) {
@@ -72996,8 +73015,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);
@@ -75299,6 +75318,7 @@ ${lanes.join("\n")}
         return CheckMode3;
       })(CheckMode || {});
       SignatureCheckMode = /* @__PURE__ */ ((SignatureCheckMode3) => {
+        SignatureCheckMode3[SignatureCheckMode3["None"] = 0] = "None";
         SignatureCheckMode3[SignatureCheckMode3["BivariantCallback"] = 1] = "BivariantCallback";
         SignatureCheckMode3[SignatureCheckMode3["StrictCallback"] = 2] = "StrictCallback";
         SignatureCheckMode3[SignatureCheckMode3["IgnoreReturnTypes"] = 4] = "IgnoreReturnTypes";
@@ -80303,12 +80323,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 */) {
@@ -80821,7 +80841,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];
@@ -80844,7 +80864,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);
@@ -80993,7 +81013,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);
@@ -81877,7 +81897,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;
@@ -81911,7 +81931,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];
@@ -81952,7 +81972,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;
@@ -82279,7 +82299,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) {
@@ -82290,9 +82310,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);
           }
         }
@@ -82307,7 +82327,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) {
@@ -82334,7 +82354,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) {
@@ -82346,9 +82366,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);
           }
         }
@@ -82408,7 +82428,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;
@@ -82484,7 +82504,7 @@ ${lanes.join("\n")}
       return kind === 260 /* ClassDeclaration */ || kind === 173 /* Constructor */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
     }
     function createSuperElementAccessInAsyncMethod(argumentExpression, location) {
-      if (enclosingSuperContainerFlags & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+      if (enclosingSuperContainerFlags & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
         return setTextRange(
           factory2.createPropertyAccessExpression(
             factory2.createCallExpression(
@@ -82509,7 +82529,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);
@@ -83453,7 +83473,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);
@@ -83464,9 +83484,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);
         }
       }
@@ -83576,7 +83596,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;
@@ -83652,7 +83672,7 @@ ${lanes.join("\n")}
       return kind === 260 /* ClassDeclaration */ || kind === 173 /* Constructor */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
     }
     function createSuperElementAccessInAsyncMethod(argumentExpression, location) {
-      if (enclosingSuperContainerFlags & 4096 /* MethodWithSuperPropertyAssignmentInAsync */) {
+      if (enclosingSuperContainerFlags & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
         return setTextRange(
           factory2.createPropertyAccessExpression(
             factory2.createCallExpression(
@@ -86051,8 +86071,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;
@@ -86413,7 +86433,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);
@@ -86428,7 +86448,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) {
@@ -86889,10 +86909,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)) {
@@ -144609,6 +144629,7 @@ ${options.prefix}` : "\n" : options.prefix
       init_ts4();
       anyContext = emptyArray;
       RuleAction = /* @__PURE__ */ ((RuleAction2) => {
+        RuleAction2[RuleAction2["None"] = 0] = "None";
         RuleAction2[RuleAction2["StopProcessingSpaceActions"] = 1] = "StopProcessingSpaceActions";
         RuleAction2[RuleAction2["StopProcessingTokenActions"] = 2] = "StopProcessingTokenActions";
         RuleAction2[RuleAction2["InsertSpace"] = 4] = "InsertSpace";
@@ -145264,7 +145285,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 */;
     }