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

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20221116`;
+var version = `${versionMajorMinor}.0-dev.20221118`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -3660,6 +3660,7 @@ var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
   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";
@@ -38060,6 +38061,7 @@ var CheckMode = /* @__PURE__ */ ((CheckMode3) => {
   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";
@@ -38077,7 +38079,7 @@ var intrinsicTypeKinds = new Map(getEntries({
 function SymbolLinks() {
 }
 function NodeLinks() {
-  this.flags = 0;
+  this.flags = 0 /* None */;
 }
 function getNodeId(node) {
   if (!node.id) {
@@ -38922,7 +38924,7 @@ function createTypeChecker(host) {
   function createSymbol(flags, name, checkFlags) {
     symbolCount++;
     const symbol = new Symbol12(flags | 33554432 /* Transient */, name);
-    symbol.checkFlags = checkFlags || 0;
+    symbol.checkFlags = checkFlags || 0 /* None */;
     return symbol;
   }
   function getExcludedSymbolFlags(flags) {
@@ -41233,7 +41235,7 @@ function createTypeChecker(host) {
   function createOriginType(flags) {
     return new Type7(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;
@@ -48074,7 +48076,7 @@ function createTypeChecker(host) {
   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);
@@ -48596,8 +48598,21 @@ function createTypeChecker(host) {
         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;
   }
@@ -51974,7 +51989,7 @@ function createTypeChecker(host) {
     return compareSignaturesRelated(
       source,
       target,
-      ignoreReturnTypes ? 4 /* IgnoreReturnTypes */ : 0,
+      ignoreReturnTypes ? 4 /* IgnoreReturnTypes */ : 0 /* None */,
       false,
       void 0,
       void 0,
@@ -52208,7 +52223,9 @@ function createTypeChecker(host) {
     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;
@@ -55271,7 +55288,7 @@ function createTypeChecker(host) {
       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 */;
@@ -57713,8 +57730,8 @@ function createTypeChecker(host) {
     }
     const parent = getRootDeclaration(symbol.valueDeclaration).parent;
     const links = getNodeLinks(parent);
-    if (!(links.flags & 8388608 /* AssignmentsMarked */)) {
-      links.flags |= 8388608 /* AssignmentsMarked */;
+    if (!(links.flags & 524288 /* AssignmentsMarked */)) {
+      links.flags |= 524288 /* AssignmentsMarked */;
       if (!hasParentWithAssignmentsMarked(parent)) {
         markNodeAssignments(parent);
       }
@@ -57722,7 +57739,7 @@ function createTypeChecker(host) {
     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 */) {
@@ -57801,11 +57818,11 @@ function createTypeChecker(host) {
         const parent = declaration.parent.parent;
         if (parent.kind === 257 /* VariableDeclaration */ && getCombinedNodeFlags(declaration) & 2 /* Const */ || parent.kind === 166 /* Parameter */) {
           const links = getNodeLinks(parent);
-          if (!(links.flags & 268435456 /* InCheckIdentifier */)) {
-            links.flags |= 268435456 /* InCheckIdentifier */;
+          if (!(links.flags & 16777216 /* InCheckIdentifier */)) {
+            links.flags |= 16777216 /* InCheckIdentifier */;
             const parentType = getTypeForBindingElementParent(parent, 0 /* Normal */);
             const parentTypeConstraint = parentType && mapType(parentType, getBaseConstraintOrType);
-            links.flags &= ~268435456 /* InCheckIdentifier */;
+            links.flags &= ~16777216 /* InCheckIdentifier */;
             if (parentTypeConstraint && parentTypeConstraint.flags & 1048576 /* Union */ && !(parent.kind === 166 /* Parameter */ && isSymbolAssigned(symbol))) {
               const pattern = declaration.parent;
               const narrowedType = getFlowTypeOfReference(pattern, parentTypeConstraint, parentTypeConstraint, void 0, location.flowNode);
@@ -57855,7 +57872,7 @@ function createTypeChecker(host) {
           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)) {
@@ -57872,8 +57889,8 @@ function createTypeChecker(host) {
         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);
@@ -57883,8 +57900,8 @@ function createTypeChecker(host) {
         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;
           }
@@ -57998,7 +58015,7 @@ function createTypeChecker(host) {
             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) {
@@ -58008,19 +58025,19 @@ function createTypeChecker(host) {
           }
         }
         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) {
@@ -58237,23 +58254,23 @@ function createTypeChecker(host) {
       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) {
@@ -58281,7 +58298,7 @@ function createTypeChecker(host) {
       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;
@@ -59296,9 +59313,9 @@ function createTypeChecker(host) {
         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)) {
@@ -63285,10 +63302,10 @@ function createTypeChecker(host) {
   }
   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;
@@ -65278,13 +65295,13 @@ function createTypeChecker(host) {
   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 */;
         }
       }
     }
@@ -66879,7 +66896,7 @@ function createTypeChecker(host) {
   }
   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);
     }
@@ -66893,18 +66910,18 @@ function createTypeChecker(host) {
     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;
       }
     }
@@ -68789,8 +68806,8 @@ function createTypeChecker(host) {
   }
   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);
@@ -69066,7 +69083,7 @@ function createTypeChecker(host) {
         }
         const mergedClass = getDeclarationOfKind(symbol, 260 /* ClassDeclaration */);
         if (mergedClass && inSameLexicalScope(node, mergedClass)) {
-          getNodeLinks(node).flags |= 32768 /* LexicalModuleMergesWithClass */;
+          getNodeLinks(node).flags |= 2048 /* LexicalModuleMergesWithClass */;
         }
       }
       if (isAmbientExternalModule) {
@@ -70697,8 +70714,8 @@ function createTypeChecker(host) {
           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);
@@ -77673,12 +77690,12 @@ function transformClassFields(context) {
   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 */) {
@@ -78191,7 +78208,7 @@ function transformClassFields(context) {
   }
   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];
@@ -78214,7 +78231,7 @@ function transformClassFields(context) {
       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);
@@ -78363,7 +78380,7 @@ function transformClassFields(context) {
     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);
@@ -79228,7 +79245,7 @@ function transformLegacyDecorators(context) {
     }
   }
   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;
@@ -79262,7 +79279,7 @@ function transformLegacyDecorators(context) {
   }
   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];
@@ -79297,7 +79314,7 @@ function transformES2017(context) {
   let capturedSuperProperties;
   let hasSuperElementAccess;
   const substitutedSuperAccessors = [];
-  let contextFlags = 0;
+  let contextFlags = 0 /* None */;
   const previousOnEmitNode = context.onEmitNode;
   const previousOnSubstituteNode = context.onSubstituteNode;
   context.onEmitNode = onEmitNode;
@@ -79624,7 +79641,7 @@ function transformES2017(context) {
     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) {
@@ -79635,9 +79652,9 @@ function transformES2017(context) {
         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);
         }
       }
@@ -79652,7 +79669,7 @@ function transformES2017(context) {
     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) {
@@ -79679,7 +79696,7 @@ function transformES2017(context) {
         )
       );
       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) {
@@ -79691,9 +79708,9 @@ function transformES2017(context) {
       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);
         }
       }
@@ -79753,7 +79770,7 @@ function transformES2017(context) {
   }
   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;
@@ -79829,7 +79846,7 @@ function transformES2017(context) {
     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(
@@ -79854,7 +79871,7 @@ function transformES2017(context) {
   }
 }
 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);
@@ -80792,7 +80809,7 @@ function transformES2018(context) {
         !!(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);
@@ -80803,9 +80820,9 @@ function transformES2018(context) {
     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);
       }
     }
@@ -80915,7 +80932,7 @@ function transformES2018(context) {
   }
   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;
@@ -80991,7 +81008,7 @@ function transformES2018(context) {
     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(
@@ -83347,8 +83364,8 @@ function transformES2015(context) {
   }
   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;
@@ -83709,7 +83726,7 @@ function transformES2015(context) {
     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);
@@ -83724,7 +83741,7 @@ function transformES2015(context) {
     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) {
@@ -84185,10 +84202,10 @@ function transformES2015(context) {
     } 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)) {