@typescript-deploys/pr-build 5.9.0-pr-61342-2 → 5.9.0-pr-61399-3

package/lib/_tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.9";
-var version = `${versionMajorMinor}.0-insiders.20250304`;
+var version = `${versionMajorMinor}.0-insiders.20250311`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -635,7 +635,7 @@ function binarySearchKey(array, key, keySelector, keyComparer, offset) {
   while (low <= high) {
     const middle = low + (high - low >> 1);
     const midKey = keySelector(array[middle], middle);
-    switch (keyComparer(midKey, key)) {
+    switch (Math.sign(keyComparer(midKey, key))) {
       case -1 /* LessThan */:
         low = middle + 1;
         break;
@@ -1735,8 +1735,8 @@ Node ${formatSyntaxKind(node.kind)} was unexpected.`,
       // for use with vscode-js-debug's new customDescriptionGenerator in launch.json
       __tsDebuggerDisplay: {
         value() {
-          const typeHeader = this.flags & 67359327 /* Intrinsic */ ? `IntrinsicType ${this.intrinsicName}${this.debugIntrinsicName ? ` (${this.debugIntrinsicName})` : ""}` : this.flags & 98304 /* Nullable */ ? "NullableType" : this.flags & 384 /* StringOrNumberLiteral */ ? `LiteralType ${JSON.stringify(this.value)}` : this.flags & 2048 /* BigIntLiteral */ ? `LiteralType ${this.value.negative ? "-" : ""}${this.value.base10Value}n` : this.flags & 8192 /* UniqueESSymbol */ ? "UniqueESSymbolType" : this.flags & 32 /* Enum */ ? "EnumType" : this.flags & 1048576 /* Union */ ? "UnionType" : this.flags & 2097152 /* Intersection */ ? "IntersectionType" : this.flags & 4194304 /* Index */ ? "IndexType" : this.flags & 8388608 /* IndexedAccess */ ? "IndexedAccessType" : this.flags & 16777216 /* Conditional */ ? "ConditionalType" : this.flags & 33554432 /* Substitution */ ? "SubstitutionType" : this.flags & 262144 /* TypeParameter */ ? "TypeParameter" : this.flags & 524288 /* Object */ ? this.objectFlags & 3 /* ClassOrInterface */ ? "InterfaceType" : this.objectFlags & 4 /* Reference */ ? "TypeReference" : this.objectFlags & 8 /* Tuple */ ? "TupleType" : this.objectFlags & 16 /* Anonymous */ ? "AnonymousType" : this.objectFlags & 32 /* Mapped */ ? "MappedType" : this.objectFlags & 1024 /* ReverseMapped */ ? "ReverseMappedType" : this.objectFlags & 256 /* EvolvingArray */ ? "EvolvingArrayType" : "ObjectType" : "Type";
-          const remainingObjectFlags = this.flags & 524288 /* Object */ ? this.objectFlags & ~1343 /* ObjectTypeKindMask */ : 0;
+          const typeHeader = this.flags & 67245055 /* Intrinsic */ ? `IntrinsicType ${this.intrinsicName}${this.debugIntrinsicName ? ` (${this.debugIntrinsicName})` : ""}` : this.flags & 12 /* Nullable */ ? "NullableType" : this.flags & 3072 /* StringOrNumberLiteral */ ? `LiteralType ${JSON.stringify(this.value)}` : this.flags & 8192 /* BigIntLiteral */ ? `LiteralType ${this.value.negative ? "-" : ""}${this.value.base10Value}n` : this.flags & 16384 /* UniqueESSymbol */ ? "UniqueESSymbolType" : this.flags & 65536 /* Enum */ ? "EnumType" : this.flags & 1048576 /* Union */ ? "UnionType" : this.flags & 2097152 /* Intersection */ ? "IntersectionType" : this.flags & 4194304 /* Index */ ? "IndexType" : this.flags & 8388608 /* IndexedAccess */ ? "IndexedAccessType" : this.flags & 16777216 /* Conditional */ ? "ConditionalType" : this.flags & 33554432 /* Substitution */ ? "SubstitutionType" : this.flags & 262144 /* TypeParameter */ ? "TypeParameter" : this.flags & 524288 /* Object */ ? this.objectFlags & 3 /* ClassOrInterface */ ? "InterfaceType" : this.objectFlags & 4 /* Reference */ ? "TypeReference" : this.objectFlags & 8 /* Tuple */ ? "TupleType" : this.objectFlags & 16 /* Anonymous */ ? "AnonymousType" : this.objectFlags & 32 /* Mapped */ ? "MappedType" : this.objectFlags & 1024 /* ReverseMapped */ ? "ReverseMappedType" : this.objectFlags & 256 /* EvolvingArray */ ? "EvolvingArrayType" : "ObjectType" : "Type";
+          const remainingObjectFlags = this.flags & 524288 /* Object */ ? this.objectFlags & ~142607679 /* ObjectTypeKindMask */ : 0;
           return `${typeHeader}${this.symbol ? ` '${symbolName(this.symbol)}'` : ""}${remainingObjectFlags ? ` (${formatObjectFlags(remainingObjectFlags)})` : ""}`;
         }
       },
@@ -2819,7 +2819,7 @@ var tracingEnabled;
       const objectFlags = type.objectFlags;
       const symbol = type.aliasSymbol ?? type.symbol;
       let display;
-      if (objectFlags & 16 /* Anonymous */ | type.flags & 2944 /* Literal */) {
+      if (objectFlags & 16 /* Anonymous */ | type.flags & 15360 /* Literal */) {
         try {
           display = (_a = type.checker) == null ? void 0 : _a.typeToString(type);
         } catch {
@@ -3570,21 +3570,21 @@ var NodeCheckFlags = /* @__PURE__ */ ((NodeCheckFlags3) => {
 var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
   TypeFlags2[TypeFlags2["Any"] = 1] = "Any";
   TypeFlags2[TypeFlags2["Unknown"] = 2] = "Unknown";
-  TypeFlags2[TypeFlags2["String"] = 4] = "String";
-  TypeFlags2[TypeFlags2["Number"] = 8] = "Number";
-  TypeFlags2[TypeFlags2["Boolean"] = 16] = "Boolean";
-  TypeFlags2[TypeFlags2["Enum"] = 32] = "Enum";
-  TypeFlags2[TypeFlags2["BigInt"] = 64] = "BigInt";
-  TypeFlags2[TypeFlags2["StringLiteral"] = 128] = "StringLiteral";
-  TypeFlags2[TypeFlags2["NumberLiteral"] = 256] = "NumberLiteral";
-  TypeFlags2[TypeFlags2["BooleanLiteral"] = 512] = "BooleanLiteral";
-  TypeFlags2[TypeFlags2["EnumLiteral"] = 1024] = "EnumLiteral";
-  TypeFlags2[TypeFlags2["BigIntLiteral"] = 2048] = "BigIntLiteral";
-  TypeFlags2[TypeFlags2["ESSymbol"] = 4096] = "ESSymbol";
-  TypeFlags2[TypeFlags2["UniqueESSymbol"] = 8192] = "UniqueESSymbol";
-  TypeFlags2[TypeFlags2["Void"] = 16384] = "Void";
-  TypeFlags2[TypeFlags2["Undefined"] = 32768] = "Undefined";
-  TypeFlags2[TypeFlags2["Null"] = 65536] = "Null";
+  TypeFlags2[TypeFlags2["Undefined"] = 4] = "Undefined";
+  TypeFlags2[TypeFlags2["Null"] = 8] = "Null";
+  TypeFlags2[TypeFlags2["Void"] = 16] = "Void";
+  TypeFlags2[TypeFlags2["String"] = 32] = "String";
+  TypeFlags2[TypeFlags2["Number"] = 64] = "Number";
+  TypeFlags2[TypeFlags2["BigInt"] = 128] = "BigInt";
+  TypeFlags2[TypeFlags2["Boolean"] = 256] = "Boolean";
+  TypeFlags2[TypeFlags2["ESSymbol"] = 512] = "ESSymbol";
+  TypeFlags2[TypeFlags2["StringLiteral"] = 1024] = "StringLiteral";
+  TypeFlags2[TypeFlags2["NumberLiteral"] = 2048] = "NumberLiteral";
+  TypeFlags2[TypeFlags2["BooleanLiteral"] = 4096] = "BooleanLiteral";
+  TypeFlags2[TypeFlags2["BigIntLiteral"] = 8192] = "BigIntLiteral";
+  TypeFlags2[TypeFlags2["UniqueESSymbol"] = 16384] = "UniqueESSymbol";
+  TypeFlags2[TypeFlags2["EnumLiteral"] = 32768] = "EnumLiteral";
+  TypeFlags2[TypeFlags2["Enum"] = 65536] = "Enum";
   TypeFlags2[TypeFlags2["Never"] = 131072] = "Never";
   TypeFlags2[TypeFlags2["TypeParameter"] = 262144] = "TypeParameter";
   TypeFlags2[TypeFlags2["Object"] = 524288] = "Object";
@@ -3600,25 +3600,25 @@ var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
   TypeFlags2[TypeFlags2["Reserved1"] = 536870912] = "Reserved1";
   TypeFlags2[TypeFlags2["Reserved2"] = 1073741824] = "Reserved2";
   TypeFlags2[TypeFlags2["AnyOrUnknown"] = 3] = "AnyOrUnknown";
-  TypeFlags2[TypeFlags2["Nullable"] = 98304] = "Nullable";
-  TypeFlags2[TypeFlags2["Literal"] = 2944] = "Literal";
-  TypeFlags2[TypeFlags2["Unit"] = 109472] = "Unit";
-  TypeFlags2[TypeFlags2["Freshable"] = 2976] = "Freshable";
-  TypeFlags2[TypeFlags2["StringOrNumberLiteral"] = 384] = "StringOrNumberLiteral";
-  TypeFlags2[TypeFlags2["StringOrNumberLiteralOrUnique"] = 8576] = "StringOrNumberLiteralOrUnique";
-  TypeFlags2[TypeFlags2["DefinitelyFalsy"] = 117632] = "DefinitelyFalsy";
-  TypeFlags2[TypeFlags2["PossiblyFalsy"] = 117724] = "PossiblyFalsy";
-  TypeFlags2[TypeFlags2["Intrinsic"] = 67359327] = "Intrinsic";
-  TypeFlags2[TypeFlags2["StringLike"] = 402653316] = "StringLike";
-  TypeFlags2[TypeFlags2["NumberLike"] = 296] = "NumberLike";
-  TypeFlags2[TypeFlags2["BigIntLike"] = 2112] = "BigIntLike";
-  TypeFlags2[TypeFlags2["BooleanLike"] = 528] = "BooleanLike";
-  TypeFlags2[TypeFlags2["EnumLike"] = 1056] = "EnumLike";
-  TypeFlags2[TypeFlags2["ESSymbolLike"] = 12288] = "ESSymbolLike";
-  TypeFlags2[TypeFlags2["VoidLike"] = 49152] = "VoidLike";
+  TypeFlags2[TypeFlags2["Nullable"] = 12] = "Nullable";
+  TypeFlags2[TypeFlags2["Literal"] = 15360] = "Literal";
+  TypeFlags2[TypeFlags2["Unit"] = 97292] = "Unit";
+  TypeFlags2[TypeFlags2["Freshable"] = 80896] = "Freshable";
+  TypeFlags2[TypeFlags2["StringOrNumberLiteral"] = 3072] = "StringOrNumberLiteral";
+  TypeFlags2[TypeFlags2["StringOrNumberLiteralOrUnique"] = 19456] = "StringOrNumberLiteralOrUnique";
+  TypeFlags2[TypeFlags2["DefinitelyFalsy"] = 15388] = "DefinitelyFalsy";
+  TypeFlags2[TypeFlags2["PossiblyFalsy"] = 15868] = "PossiblyFalsy";
+  TypeFlags2[TypeFlags2["Intrinsic"] = 67245055] = "Intrinsic";
+  TypeFlags2[TypeFlags2["StringLike"] = 402654240] = "StringLike";
+  TypeFlags2[TypeFlags2["NumberLike"] = 67648] = "NumberLike";
+  TypeFlags2[TypeFlags2["BigIntLike"] = 8320] = "BigIntLike";
+  TypeFlags2[TypeFlags2["BooleanLike"] = 4352] = "BooleanLike";
+  TypeFlags2[TypeFlags2["EnumLike"] = 98304] = "EnumLike";
+  TypeFlags2[TypeFlags2["ESSymbolLike"] = 16896] = "ESSymbolLike";
+  TypeFlags2[TypeFlags2["VoidLike"] = 20] = "VoidLike";
   TypeFlags2[TypeFlags2["Primitive"] = 402784252] = "Primitive";
-  TypeFlags2[TypeFlags2["DefinitelyNonNullable"] = 470302716] = "DefinitelyNonNullable";
-  TypeFlags2[TypeFlags2["DisjointDomains"] = 469892092] = "DisjointDomains";
+  TypeFlags2[TypeFlags2["DefinitelyNonNullable"] = 470417376] = "DefinitelyNonNullable";
+  TypeFlags2[TypeFlags2["DisjointDomains"] = 469860348] = "DisjointDomains";
   TypeFlags2[TypeFlags2["UnionOrIntersection"] = 3145728] = "UnionOrIntersection";
   TypeFlags2[TypeFlags2["StructuredType"] = 3670016] = "StructuredType";
   TypeFlags2[TypeFlags2["TypeVariable"] = 8650752] = "TypeVariable";
@@ -3626,10 +3626,10 @@ var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
   TypeFlags2[TypeFlags2["InstantiablePrimitive"] = 406847488] = "InstantiablePrimitive";
   TypeFlags2[TypeFlags2["Instantiable"] = 465829888] = "Instantiable";
   TypeFlags2[TypeFlags2["StructuredOrInstantiable"] = 469499904] = "StructuredOrInstantiable";
-  TypeFlags2[TypeFlags2["ObjectFlagsType"] = 3899393] = "ObjectFlagsType";
+  TypeFlags2[TypeFlags2["ObjectFlagsType"] = 3801101] = "ObjectFlagsType";
   TypeFlags2[TypeFlags2["Simplifiable"] = 25165824] = "Simplifiable";
-  TypeFlags2[TypeFlags2["Singleton"] = 67358815] = "Singleton";
-  TypeFlags2[TypeFlags2["Narrowable"] = 536624127] = "Narrowable";
+  TypeFlags2[TypeFlags2["Singleton"] = 67240959] = "Singleton";
+  TypeFlags2[TypeFlags2["Narrowable"] = 536707043] = "Narrowable";
   TypeFlags2[TypeFlags2["IncludesMask"] = 473694207] = "IncludesMask";
   TypeFlags2[TypeFlags2["IncludesMissingType"] = 262144 /* TypeParameter */] = "IncludesMissingType";
   TypeFlags2[TypeFlags2["IncludesNonWideningType"] = 4194304 /* Index */] = "IncludesNonWideningType";
@@ -3638,7 +3638,7 @@ var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
   TypeFlags2[TypeFlags2["IncludesInstantiable"] = 33554432 /* Substitution */] = "IncludesInstantiable";
   TypeFlags2[TypeFlags2["IncludesConstrainedTypeVariable"] = 536870912 /* Reserved1 */] = "IncludesConstrainedTypeVariable";
   TypeFlags2[TypeFlags2["IncludesError"] = 1073741824 /* Reserved2 */] = "IncludesError";
-  TypeFlags2[TypeFlags2["NotPrimitiveUnion"] = 36323331] = "NotPrimitiveUnion";
+  TypeFlags2[TypeFlags2["NotPrimitiveUnion"] = 36306963] = "NotPrimitiveUnion";
   return TypeFlags2;
 })(TypeFlags || {});
 var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
@@ -3668,11 +3668,11 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
   ObjectFlags3[ObjectFlags3["RequiresWidening"] = 196608] = "RequiresWidening";
   ObjectFlags3[ObjectFlags3["PropagatingFlags"] = 458752] = "PropagatingFlags";
   ObjectFlags3[ObjectFlags3["InstantiatedMapped"] = 96] = "InstantiatedMapped";
-  ObjectFlags3[ObjectFlags3["ObjectTypeKindMask"] = 1343] = "ObjectTypeKindMask";
   ObjectFlags3[ObjectFlags3["ContainsSpread"] = 2097152] = "ContainsSpread";
   ObjectFlags3[ObjectFlags3["ObjectRestType"] = 4194304] = "ObjectRestType";
   ObjectFlags3[ObjectFlags3["InstantiationExpressionType"] = 8388608] = "InstantiationExpressionType";
   ObjectFlags3[ObjectFlags3["SingleSignatureType"] = 134217728] = "SingleSignatureType";
+  ObjectFlags3[ObjectFlags3["ObjectTypeKindMask"] = 142607679] = "ObjectTypeKindMask";
   ObjectFlags3[ObjectFlags3["IsClassInstanceClone"] = 16777216] = "IsClassInstanceClone";
   ObjectFlags3[ObjectFlags3["IdenticalBaseTypeCalculated"] = 33554432] = "IdenticalBaseTypeCalculated";
   ObjectFlags3[ObjectFlags3["IdenticalBaseTypeExists"] = 67108864] = "IdenticalBaseTypeExists";
@@ -17456,7 +17456,7 @@ function getClassLikeDeclarationOfSymbol(symbol) {
   return (_a = symbol.declarations) == null ? void 0 : _a.find(isClassLike);
 }
 function getObjectFlags(type) {
-  return type.flags & 3899393 /* ObjectFlagsType */ ? type.objectFlags : 0;
+  return type.flags & 3801101 /* ObjectFlagsType */ ? type.objectFlags : 0;
 }
 function isUMDExportSymbol(symbol) {
   return !!symbol && !!symbol.declarations && !!symbol.declarations[0] && isNamespaceExportDeclaration(symbol.declarations[0]);
@@ -19248,13 +19248,13 @@ function intrinsicTagNameToString(node) {
   return isIdentifier(node) ? idText(node) : getTextOfJsxNamespacedName(node);
 }
 function isTypeUsableAsPropertyName(type) {
-  return !!(type.flags & 8576 /* StringOrNumberLiteralOrUnique */);
+  return !!(type.flags & 19456 /* StringOrNumberLiteralOrUnique */);
 }
 function getPropertyNameFromType(type) {
-  if (type.flags & 8192 /* UniqueESSymbol */) {
+  if (type.flags & 16384 /* UniqueESSymbol */) {
     return type.escapedName;
   }
-  if (type.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */)) {
+  if (type.flags & (1024 /* StringLiteral */ | 2048 /* NumberLiteral */)) {
     return escapeLeadingUnderscores("" + type.value);
   }
   return Debug.fail();
@@ -46163,6 +46163,7 @@ function createTypeChecker(host) {
   };
   var cancellationToken;
   var scanner;
+  var fileIndexMap = new Map(host.getSourceFiles().map((file, i) => [file, i]));
   var Symbol13 = objectAllocator.getSymbolConstructor();
   var Type7 = objectAllocator.getTypeConstructor();
   var Signature5 = objectAllocator.getSignatureConstructor();
@@ -46744,10 +46745,10 @@ function createTypeChecker(host) {
   var nonInferrableAnyType = createIntrinsicType(1 /* Any */, "any", 65536 /* ContainsWideningType */, "non-inferrable");
   var intrinsicMarkerType = createIntrinsicType(1 /* Any */, "intrinsic");
   var unknownType = createIntrinsicType(2 /* Unknown */, "unknown");
-  var undefinedType = createIntrinsicType(32768 /* Undefined */, "undefined");
-  var undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(32768 /* Undefined */, "undefined", 65536 /* ContainsWideningType */, "widening");
+  var undefinedType = createIntrinsicType(4 /* Undefined */, "undefined");
+  var undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(4 /* Undefined */, "undefined", 65536 /* ContainsWideningType */, "widening");
   var missingType = createIntrinsicType(
-    32768 /* Undefined */,
+    4 /* Undefined */,
     "undefined",
     /*objectFlags*/
     void 0,
@@ -46755,33 +46756,33 @@ function createTypeChecker(host) {
   );
   var undefinedOrMissingType = exactOptionalPropertyTypes ? missingType : undefinedType;
   var optionalType = createIntrinsicType(
-    32768 /* Undefined */,
+    4 /* Undefined */,
     "undefined",
     /*objectFlags*/
     void 0,
     "optional"
   );
-  var nullType = createIntrinsicType(65536 /* Null */, "null");
-  var nullWideningType = strictNullChecks ? nullType : createIntrinsicType(65536 /* Null */, "null", 65536 /* ContainsWideningType */, "widening");
-  var stringType = createIntrinsicType(4 /* String */, "string");
-  var numberType = createIntrinsicType(8 /* Number */, "number");
-  var bigintType = createIntrinsicType(64 /* BigInt */, "bigint");
+  var nullType = createIntrinsicType(8 /* Null */, "null");
+  var nullWideningType = strictNullChecks ? nullType : createIntrinsicType(8 /* Null */, "null", 65536 /* ContainsWideningType */, "widening");
+  var stringType = createIntrinsicType(32 /* String */, "string");
+  var numberType = createIntrinsicType(64 /* Number */, "number");
+  var bigintType = createIntrinsicType(128 /* BigInt */, "bigint");
   var falseType = createIntrinsicType(
-    512 /* BooleanLiteral */,
+    4096 /* BooleanLiteral */,
     "false",
     /*objectFlags*/
     void 0,
     "fresh"
   );
-  var regularFalseType = createIntrinsicType(512 /* BooleanLiteral */, "false");
+  var regularFalseType = createIntrinsicType(4096 /* BooleanLiteral */, "false");
   var trueType = createIntrinsicType(
-    512 /* BooleanLiteral */,
+    4096 /* BooleanLiteral */,
     "true",
     /*objectFlags*/
     void 0,
     "fresh"
   );
-  var regularTrueType = createIntrinsicType(512 /* BooleanLiteral */, "true");
+  var regularTrueType = createIntrinsicType(4096 /* BooleanLiteral */, "true");
   trueType.regularType = regularTrueType;
   trueType.freshType = trueType;
   regularTrueType.regularType = regularTrueType;
@@ -46791,8 +46792,8 @@ function createTypeChecker(host) {
   regularFalseType.regularType = regularFalseType;
   regularFalseType.freshType = falseType;
   var booleanType = getUnionType([regularFalseType, regularTrueType]);
-  var esSymbolType = createIntrinsicType(4096 /* ESSymbol */, "symbol");
-  var voidType = createIntrinsicType(16384 /* Void */, "void");
+  var esSymbolType = createIntrinsicType(512 /* ESSymbol */, "symbol");
+  var voidType = createIntrinsicType(16 /* Void */, "void");
   var neverType = createIntrinsicType(131072 /* Never */, "never");
   var silentNeverType = createIntrinsicType(131072 /* Never */, "never", 262144 /* NonInferrableType */, "silent");
   var implicitNeverType = createIntrinsicType(
@@ -48079,7 +48080,7 @@ function createTypeChecker(host) {
       const type = getDeclaredTypeOfSymbol(symbol);
       return !!(type.flags & 1048576 /* Union */) && allTypesAssignableToKind(
         type,
-        384 /* StringOrNumberLiteral */,
+        3072 /* StringOrNumberLiteral */,
         /*strict*/
         true
       );
@@ -49786,7 +49787,7 @@ function createTypeChecker(host) {
     return type;
   }
   function createTypeofType() {
-    return getUnionType(arrayFrom(typeofNEFacts.keys(), getStringLiteralType));
+    return getUnionType(map([...typeofNEFacts.keys()].sort(), getStringLiteralType));
   }
   function createTypeParameter(symbol) {
     return createTypeWithSymbol(262144 /* TypeParameter */, symbol);
@@ -50607,7 +50608,7 @@ function createTypeChecker(host) {
           if (name && isComputedPropertyName(name)) return name;
         }
         const nameType = getSymbolLinks(symbol).nameType;
-        if (nameType && nameType.flags & (1024 /* EnumLiteral */ | 8192 /* UniqueESSymbol */)) {
+        if (nameType && nameType.flags & (32768 /* EnumLiteral */ | 16384 /* UniqueESSymbol */)) {
           context.enclosingDeclaration = nameType.symbol.valueDeclaration;
           return factory.createComputedPropertyName(symbolToExpression(nameType.symbol, context, meaning));
         }
@@ -50715,23 +50716,23 @@ function createTypeChecker(host) {
       if (type.flags & 2 /* Unknown */) {
         return factory.createKeywordTypeNode(159 /* UnknownKeyword */);
       }
-      if (type.flags & 4 /* String */) {
+      if (type.flags & 32 /* String */) {
         context.approximateLength += 6;
         return factory.createKeywordTypeNode(154 /* StringKeyword */);
       }
-      if (type.flags & 8 /* Number */) {
+      if (type.flags & 64 /* Number */) {
         context.approximateLength += 6;
         return factory.createKeywordTypeNode(150 /* NumberKeyword */);
       }
-      if (type.flags & 64 /* BigInt */) {
+      if (type.flags & 128 /* BigInt */) {
         context.approximateLength += 6;
         return factory.createKeywordTypeNode(163 /* BigIntKeyword */);
       }
-      if (type.flags & 16 /* Boolean */ && !type.aliasSymbol) {
+      if (type.flags & 256 /* Boolean */ && !type.aliasSymbol) {
         context.approximateLength += 7;
         return factory.createKeywordTypeNode(136 /* BooleanKeyword */);
       }
-      if (type.flags & 1056 /* EnumLike */) {
+      if (type.flags & 98304 /* EnumLike */) {
         if (type.symbol.flags & 8 /* EnumMember */) {
           const parentSymbol = getParentOfSymbol(type.symbol);
           const parentName = symbolToTypeNode(parentSymbol, context, 788968 /* Type */);
@@ -50760,24 +50761,24 @@ function createTypeChecker(host) {
         }
         return symbolToTypeNode(type.symbol, context, 788968 /* Type */);
       }
-      if (type.flags & 128 /* StringLiteral */) {
+      if (type.flags & 1024 /* StringLiteral */) {
         context.approximateLength += type.value.length + 2;
         return factory.createLiteralTypeNode(setEmitFlags(factory.createStringLiteral(type.value, !!(context.flags & 268435456 /* UseSingleQuotesForStringLiteralType */)), 16777216 /* NoAsciiEscaping */));
       }
-      if (type.flags & 256 /* NumberLiteral */) {
+      if (type.flags & 2048 /* NumberLiteral */) {
         const value = type.value;
         context.approximateLength += ("" + value).length;
         return factory.createLiteralTypeNode(value < 0 ? factory.createPrefixUnaryExpression(41 /* MinusToken */, factory.createNumericLiteral(-value)) : factory.createNumericLiteral(value));
       }
-      if (type.flags & 2048 /* BigIntLiteral */) {
+      if (type.flags & 8192 /* BigIntLiteral */) {
         context.approximateLength += pseudoBigIntToString(type.value).length + 1;
         return factory.createLiteralTypeNode(factory.createBigIntLiteral(type.value));
       }
-      if (type.flags & 512 /* BooleanLiteral */) {
+      if (type.flags & 4096 /* BooleanLiteral */) {
         context.approximateLength += type.intrinsicName.length;
         return factory.createLiteralTypeNode(type.intrinsicName === "true" ? factory.createTrue() : factory.createFalse());
       }
-      if (type.flags & 8192 /* UniqueESSymbol */) {
+      if (type.flags & 16384 /* UniqueESSymbol */) {
         if (!(context.flags & 1048576 /* AllowUniqueESSymbolType */)) {
           if (isValueSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
             context.approximateLength += 6;
@@ -50790,15 +50791,15 @@ function createTypeChecker(host) {
         context.approximateLength += 13;
         return factory.createTypeOperatorNode(158 /* UniqueKeyword */, factory.createKeywordTypeNode(155 /* SymbolKeyword */));
       }
-      if (type.flags & 16384 /* Void */) {
+      if (type.flags & 16 /* Void */) {
         context.approximateLength += 4;
         return factory.createKeywordTypeNode(116 /* VoidKeyword */);
       }
-      if (type.flags & 32768 /* Undefined */) {
+      if (type.flags & 4 /* Undefined */) {
         context.approximateLength += 9;
         return factory.createKeywordTypeNode(157 /* UndefinedKeyword */);
       }
-      if (type.flags & 65536 /* Null */) {
+      if (type.flags & 8 /* Null */) {
         context.approximateLength += 4;
         return factory.createLiteralTypeNode(factory.createNull());
       }
@@ -50806,7 +50807,7 @@ function createTypeChecker(host) {
         context.approximateLength += 5;
         return factory.createKeywordTypeNode(146 /* NeverKeyword */);
       }
-      if (type.flags & 4096 /* ESSymbol */) {
+      if (type.flags & 512 /* ESSymbol */) {
         context.approximateLength += 6;
         return factory.createKeywordTypeNode(155 /* SymbolKeyword */);
       }
@@ -51595,7 +51596,7 @@ function createTypeChecker(host) {
       }
       const optionalToken = propertySymbol.flags & 16777216 /* Optional */ ? factory.createToken(58 /* QuestionToken */) : void 0;
       if (propertySymbol.flags & (16 /* Function */ | 8192 /* Method */) && !getPropertiesOfObjectType(propertyType).length && !isReadonlySymbol(propertySymbol)) {
-        const signatures = getSignaturesOfType(filterType(propertyType, (t) => !(t.flags & 32768 /* Undefined */)), 0 /* Call */);
+        const signatures = getSignaturesOfType(filterType(propertyType, (t) => !(t.flags & 4 /* Undefined */)), 0 /* Call */);
         for (const signature of signatures) {
           const methodDeclaration = signatureToSignatureDeclarationHelper(signature, 173 /* MethodSignature */, context, { name: propertyName, questionToken: optionalToken });
           typeElements.push(preserveCommentsOn(methodDeclaration, signature.declaration || propertySymbol.valueDeclaration));
@@ -52635,11 +52636,11 @@ function createTypeChecker(host) {
       }
       if (isComputedPropertyName(name)) {
         const type = checkExpression(name.expression);
-        return !!(type.flags & 402653316 /* StringLike */);
+        return !!(type.flags & 402654240 /* StringLike */);
       }
       if (isElementAccessExpression(name)) {
         const type = checkExpression(name.argumentExpression);
-        return !!(type.flags & 402653316 /* StringLike */);
+        return !!(type.flags & 402654240 /* StringLike */);
       }
       return isStringLiteral(name);
     }
@@ -52665,7 +52666,7 @@ function createTypeChecker(host) {
     function getPropertyNameNodeForSymbolFromNameType(symbol, context, singleQuote, stringNamed, isMethod) {
       const nameType = getSymbolLinks(symbol).nameType;
       if (nameType) {
-        if (nameType.flags & 384 /* StringOrNumberLiteral */) {
+        if (nameType.flags & 3072 /* StringOrNumberLiteral */) {
           const name = "" + nameType.value;
           if (!isIdentifierText(name, getEmitScriptTarget(compilerOptions)) && (stringNamed || !isNumericLiteralName(name))) {
             return factory.createStringLiteral(name, !!singleQuote);
@@ -52675,7 +52676,7 @@ function createTypeChecker(host) {
           }
           return createPropertyNameNodeForIdentifierOrLiteral(name, getEmitScriptTarget(compilerOptions), singleQuote, stringNamed, isMethod);
         }
-        if (nameType.flags & 8192 /* UniqueESSymbol */) {
+        if (nameType.flags & 16384 /* UniqueESSymbol */) {
           return factory.createComputedPropertyName(symbolToExpression(nameType.symbol, context, 111551 /* Value */));
         }
       }
@@ -52717,7 +52718,7 @@ function createTypeChecker(host) {
       return enclosingDeclaration;
     }
     function serializeInferredTypeForDeclaration(symbol, context, type) {
-      if (type.flags & 8192 /* UniqueESSymbol */ && type.symbol === symbol && (!context.enclosingDeclaration || some(symbol.declarations, (d) => getSourceFileOfNode(d) === context.enclosingFile))) {
+      if (type.flags & 16384 /* UniqueESSymbol */ && type.symbol === symbol && (!context.enclosingDeclaration || some(symbol.declarations, (d) => getSourceFileOfNode(d) === context.enclosingFile))) {
         context.flags |= 1048576 /* AllowUniqueESSymbolType */;
       }
       const result = typeToTypeNodeHelper(type, context);
@@ -52950,7 +52951,7 @@ function createTypeChecker(host) {
     }
     function serializeExistingTypeNode(context, typeNode, addUndefined) {
       const type = getTypeFromTypeNode2(context, typeNode);
-      if (addUndefined && !someType(type, (t) => !!(t.flags & 32768 /* Undefined */)) && canReuseTypeNode(context, typeNode)) {
+      if (addUndefined && !someType(type, (t) => !!(t.flags & 4 /* Undefined */)) && canReuseTypeNode(context, typeNode)) {
         const clone = syntacticNodeBuilder.tryReuseExistingTypeNode(context, typeNode);
         if (clone) {
           return factory.createUnionTypeNode([clone, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
@@ -54489,9 +54490,9 @@ function createTypeChecker(host) {
     for (let i = 0; i < types.length; i++) {
       const t = types[i];
       flags |= t.flags;
-      if (!(t.flags & 98304 /* Nullable */)) {
-        if (t.flags & (512 /* BooleanLiteral */ | 1056 /* EnumLike */)) {
-          const baseType = t.flags & 512 /* BooleanLiteral */ ? booleanType : getBaseTypeOfEnumLikeType(t);
+      if (!(t.flags & 12 /* Nullable */)) {
+        if (t.flags & (4096 /* BooleanLiteral */ | 98304 /* EnumLike */)) {
+          const baseType = t.flags & 4096 /* BooleanLiteral */ ? booleanType : getBaseTypeOfEnumLikeType(t);
           if (baseType.flags & 1048576 /* Union */) {
             const count = baseType.types.length;
             if (i + count <= types.length && getRegularTypeOfLiteralType(types[i + count - 1]) === getRegularTypeOfLiteralType(baseType.types[count - 1])) {
@@ -54504,8 +54505,8 @@ function createTypeChecker(host) {
         result.push(t);
       }
     }
-    if (flags & 65536 /* Null */) result.push(nullType);
-    if (flags & 32768 /* Undefined */) result.push(undefinedType);
+    if (flags & 8 /* Null */) result.push(nullType);
+    if (flags & 4 /* Undefined */) result.push(undefinedType);
     return result || types;
   }
   function visibilityToString(flags) {
@@ -54535,7 +54536,7 @@ function createTypeChecker(host) {
   function getNameOfSymbolFromNameType(symbol, context) {
     const nameType = getSymbolLinks(symbol).nameType;
     if (nameType) {
-      if (nameType.flags & 384 /* StringOrNumberLiteral */) {
+      if (nameType.flags & 3072 /* StringOrNumberLiteral */) {
         const name = "" + nameType.value;
         if (!isIdentifierText(name, getEmitScriptTarget(compilerOptions)) && !isNumericLiteralName(name)) {
           return `"${escapeString(name, 34 /* doubleQuote */)}"`;
@@ -54545,7 +54546,7 @@ function createTypeChecker(host) {
         }
         return name;
       }
-      if (nameType.flags & 8192 /* UniqueESSymbol */) {
+      if (nameType.flags & 16384 /* UniqueESSymbol */) {
         return `[${getNameOfSymbolAsWritten(nameType.symbol, context)}]`;
       }
     }
@@ -54570,7 +54571,7 @@ function createTypeChecker(host) {
         }
         if (isComputedPropertyName(name2) && !(getCheckFlags(symbol) & 4096 /* Late */)) {
           const nameType = getSymbolLinks(symbol).nameType;
-          if (nameType && nameType.flags & 384 /* StringOrNumberLiteral */) {
+          if (nameType && nameType.flags & 3072 /* StringOrNumberLiteral */) {
             const result = getNameOfSymbolFromNameType(symbol, context);
             if (result !== void 0) {
               return result;
@@ -54851,7 +54852,7 @@ function createTypeChecker(host) {
     );
   }
   function getRestType(source, properties, symbol) {
-    source = filterType(source, (t) => !(t.flags & 98304 /* Nullable */));
+    source = filterType(source, (t) => !(t.flags & 12 /* Nullable */));
     if (source.flags & 131072 /* Never */) {
       return emptyObjectType;
     }
@@ -54862,7 +54863,7 @@ function createTypeChecker(host) {
     const spreadableProperties = [];
     const unspreadableToRestKeys = [];
     for (const prop of getPropertiesOfType(source)) {
-      const literalTypeFromProperty = getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */);
+      const literalTypeFromProperty = getLiteralTypeFromProperty(prop, 19456 /* StringOrNumberLiteralOrUnique */);
       if (!isTypeAssignableTo(literalTypeFromProperty, omitKeyType) && !(getDeclarationModifierFlagsFromSymbol(prop) & (2 /* Private */ | 4 /* Protected */)) && isSpreadableProperty(prop)) {
         spreadableProperties.push(prop);
       } else {
@@ -54895,7 +54896,7 @@ function createTypeChecker(host) {
     return result;
   }
   function isGenericTypeWithUndefinedConstraint(type) {
-    return !!(type.flags & 465829888 /* Instantiable */) && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 32768 /* Undefined */);
+    return !!(type.flags & 465829888 /* Instantiable */) && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 4 /* Undefined */);
   }
   function getNonUndefinedType(type) {
     const typeOrConstraint = someType(type, isGenericTypeWithUndefinedConstraint) ? mapType(type, (t) => t.flags & 465829888 /* Instantiable */ ? getBaseConstraintOrType(t) : t) : type;
@@ -54949,7 +54950,7 @@ function createTypeChecker(host) {
   }
   function getLiteralPropertyNameText(name) {
     const type = getLiteralTypeFromPropertyName(name);
-    return type.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */) ? "" + type.value : void 0;
+    return type.flags & (1024 /* StringLiteral */ | 2048 /* NumberLiteral */) ? "" + type.value : void 0;
   }
   function getTypeForBindingElement(declaration) {
     const checkMode = declaration.dotDotDotToken ? 32 /* RestBindingElement */ : 0 /* Normal */;
@@ -55289,7 +55290,7 @@ function createTypeChecker(host) {
             definedInConstructor = true;
           }
         }
-        const sourceTypes = some(constructorTypes, (t) => !!(t.flags & ~98304 /* Nullable */)) ? constructorTypes : types;
+        const sourceTypes = some(constructorTypes, (t) => !!(t.flags & ~12 /* Nullable */)) ? constructorTypes : types;
         type = getUnionType(sourceTypes);
       }
     }
@@ -55299,7 +55300,7 @@ function createTypeChecker(host) {
       false,
       definedInMethod && !definedInConstructor
     ));
-    if (symbol.valueDeclaration && isInJSFile(symbol.valueDeclaration) && filterType(widened, (t) => !!(t.flags & ~98304 /* Nullable */)) === neverType) {
+    if (symbol.valueDeclaration && isInJSFile(symbol.valueDeclaration) && filterType(widened, (t) => !!(t.flags & ~12 /* Nullable */)) === neverType) {
       reportImplicitAny(symbol.valueDeclaration, anyType);
       return anyType;
     }
@@ -55597,13 +55598,13 @@ function createTypeChecker(host) {
   }
   function widenTypeForVariableLikeDeclaration(type, declaration, reportErrors2) {
     if (type) {
-      if (type.flags & 4096 /* ESSymbol */ && isGlobalSymbolConstructor(declaration.parent)) {
+      if (type.flags & 512 /* ESSymbol */ && isGlobalSymbolConstructor(declaration.parent)) {
         type = getESSymbolLikeTypeForNode(declaration);
       }
       if (reportErrors2) {
         reportErrorsFromWidening(declaration, type);
       }
-      if (type.flags & 8192 /* UniqueESSymbol */ && (isBindingElement(declaration) || !tryGetTypeFromEffectiveTypeNode(declaration)) && type.symbol !== getSymbolOfDeclaration(declaration)) {
+      if (type.flags & 16384 /* UniqueESSymbol */ && (isBindingElement(declaration) || !tryGetTypeFromEffectiveTypeNode(declaration)) && type.symbol !== getSymbolOfDeclaration(declaration)) {
         type = esSymbolType;
       }
       return getWidenedType(type);
@@ -56440,7 +56441,7 @@ function createTypeChecker(host) {
     return links.declaredType;
   }
   function getBaseTypeOfEnumLikeType(type) {
-    return type.flags & 1056 /* EnumLike */ && type.symbol.flags & 8 /* EnumMember */ ? getDeclaredTypeOfSymbol(getParentOfSymbol(type.symbol)) : type;
+    return type.flags & 98304 /* EnumLike */ && type.symbol.flags & 8 /* EnumMember */ ? getDeclaredTypeOfSymbol(getParentOfSymbol(type.symbol)) : type;
   }
   function getDeclaredTypeOfEnum(symbol) {
     const links = getSymbolLinks(symbol);
@@ -56471,7 +56472,7 @@ function createTypeChecker(host) {
         void 0
       ) : createComputedEnumType(symbol);
       if (enumType.flags & 1048576 /* Union */) {
-        enumType.flags |= 1024 /* EnumLiteral */;
+        enumType.flags |= 32768 /* EnumLiteral */;
         enumType.symbol = symbol;
       }
       links.declaredType = enumType;
@@ -56479,8 +56480,8 @@ function createTypeChecker(host) {
     return links.declaredType;
   }
   function createComputedEnumType(symbol) {
-    const regularType = createTypeWithSymbol(32 /* Enum */, symbol);
-    const freshType = createTypeWithSymbol(32 /* Enum */, symbol);
+    const regularType = createTypeWithSymbol(65536 /* Enum */, symbol);
+    const freshType = createTypeWithSymbol(65536 /* Enum */, symbol);
     regularType.regularType = regularType;
     regularType.freshType = freshType;
     freshType.regularType = regularType;
@@ -56682,7 +56683,7 @@ function createTypeChecker(host) {
         const earlySymbol = earlySymbols && earlySymbols.get(memberName);
         if (!(parent.flags & 32 /* Class */) && lateSymbol.flags & getExcludedSymbolFlags(symbolFlags)) {
           const declarations = earlySymbol ? concatenate(earlySymbol.declarations, lateSymbol.declarations) : lateSymbol.declarations;
-          const name = !(type.flags & 8192 /* UniqueESSymbol */) && unescapeLeadingUnderscores(memberName) || declarationNameToString(declName);
+          const name = !(type.flags & 16384 /* UniqueESSymbol */) && unescapeLeadingUnderscores(memberName) || declarationNameToString(declName);
           forEach(declarations, (declaration) => error(getNameOfDeclaration(declaration) || declaration, Diagnostics.Property_0_was_also_declared_here, name));
           error(declName || decl, Diagnostics.Duplicate_property_0, name);
           lateSymbol = createSymbol(0 /* None */, memberName, 4096 /* Late */);
@@ -57377,7 +57378,7 @@ function createTypeChecker(host) {
       if (baseConstructorIndexInfo) {
         indexInfos = append(indexInfos, baseConstructorIndexInfo);
       }
-      if (symbol.flags & 384 /* Enum */ && (getDeclaredTypeOfSymbol(symbol).flags & 32 /* Enum */ || some(type.properties, (prop) => !!(getTypeOfSymbol(prop).flags & 296 /* NumberLike */)))) {
+      if (symbol.flags & 384 /* Enum */ && (getDeclaredTypeOfSymbol(symbol).flags & 65536 /* Enum */ || some(type.properties, (prop) => !!(getTypeOfSymbol(prop).flags & 67648 /* NumberLike */)))) {
         indexInfos = append(indexInfos, enumNumberIndexInfo);
       }
     }
@@ -57438,7 +57439,7 @@ function createTypeChecker(host) {
     const limitedConstraint = getLimitedConstraint(type);
     for (const prop of getPropertiesOfType(type.source)) {
       if (limitedConstraint) {
-        const propertyNameType = getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */);
+        const propertyNameType = getLiteralTypeFromProperty(prop, 19456 /* StringOrNumberLiteralOrUnique */);
         if (!isTypeAssignableTo(propertyNameType, limitedConstraint)) {
           continue;
         }
@@ -57491,7 +57492,7 @@ function createTypeChecker(host) {
     }
     if (type.flags & 2097152 /* Intersection */) {
       const types = type.types;
-      if (types.length === 2 && !!(types[0].flags & (4 /* String */ | 8 /* Number */ | 64 /* BigInt */)) && types[1] === emptyTypeLiteralType) {
+      if (types.length === 2 && !!(types[0].flags & (32 /* String */ | 64 /* Number */ | 128 /* BigInt */)) && types[1] === emptyTypeLiteralType) {
         return type;
       }
       return getIntersectionType(sameMap(type.types, getLowerBoundOfKeyType));
@@ -57509,7 +57510,7 @@ function createTypeChecker(host) {
       cb(stringType);
     } else {
       for (const info of getIndexInfosOfType(type)) {
-        if (!stringsOnly || info.keyType.flags & (4 /* String */ | 134217728 /* TemplateLiteral */)) {
+        if (!stringsOnly || info.keyType.flags & (32 /* String */ | 134217728 /* TemplateLiteral */)) {
           cb(info.keyType);
         }
       }
@@ -57527,7 +57528,7 @@ function createTypeChecker(host) {
     const templateType = getTemplateTypeFromMappedType(mappedType);
     const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
     const templateModifiers = getMappedTypeModifiers(type);
-    const include = 8576 /* StringOrNumberLiteralOrUnique */;
+    const include = 19456 /* StringOrNumberLiteralOrUnique */;
     if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
       forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(
         modifiersType,
@@ -57567,8 +57568,8 @@ function createTypeChecker(host) {
           }
           members.set(propName, prop);
         }
-      } else if (isValidIndexKeyType(propNameType) || propNameType.flags & (1 /* Any */ | 32 /* Enum */)) {
-        const indexKeyType = propNameType.flags & (1 /* Any */ | 4 /* String */) ? stringType : propNameType.flags & (8 /* Number */ | 32 /* Enum */) ? numberType : propNameType;
+      } else if (isValidIndexKeyType(propNameType) || propNameType.flags & (1 /* Any */ | 65536 /* Enum */)) {
+        const indexKeyType = propNameType.flags & (1 /* Any */ | 32 /* String */) ? stringType : propNameType.flags & (64 /* Number */ | 65536 /* Enum */) ? numberType : propNameType;
         const propType = instantiateType(templateType, appendTypeMapping(type.mapper, typeParameter, keyType));
         const modifiersIndexInfo = getApplicableIndexInfo(modifiersType, propNameType);
         const isReadonly = !!(templateModifiers & 1 /* IncludeReadonly */ || !(templateModifiers & 2 /* ExcludeReadonly */) && (modifiersIndexInfo == null ? void 0 : modifiersIndexInfo.isReadonly));
@@ -57593,7 +57594,7 @@ function createTypeChecker(host) {
       const templateType = getTemplateTypeFromMappedType(mappedType.target || mappedType);
       const mapper = appendTypeMapping(mappedType.mapper, getTypeParameterFromMappedType(mappedType), symbol.links.keyType);
       const propType = instantiateType(templateType, mapper);
-      let type = strictNullChecks && symbol.flags & 16777216 /* Optional */ && !maybeTypeOfKind(propType, 32768 /* Undefined */ | 16384 /* Void */) ? getOptionalType(
+      let type = strictNullChecks && symbol.flags & 16777216 /* Optional */ && !maybeTypeOfKind(propType, 4 /* Undefined */ | 16 /* Void */) ? getOptionalType(
         propType,
         /*isProperty*/
         true
@@ -57887,14 +57888,14 @@ function createTypeChecker(host) {
             constraints = append(constraints, t);
           }
         }
-      } else if (t.flags & 469892092 /* DisjointDomains */ || isEmptyAnonymousObjectType(t)) {
+      } else if (t.flags & 469860348 /* DisjointDomains */ || isEmptyAnonymousObjectType(t)) {
         hasDisjointDomainType = true;
       }
     }
     if (constraints && (targetIsUnion || hasDisjointDomainType)) {
       if (hasDisjointDomainType) {
         for (const t of types) {
-          if (t.flags & 469892092 /* DisjointDomains */ || isEmptyAnonymousObjectType(t)) {
+          if (t.flags & 469860348 /* DisjointDomains */ || isEmptyAnonymousObjectType(t)) {
             constraints = append(constraints, t);
           }
         }
@@ -58095,7 +58096,7 @@ function createTypeChecker(host) {
   function getApparentType(type) {
     const t = type.flags & 465829888 /* Instantiable */ ? getBaseConstraintOfType(type) || unknownType : type;
     const objectFlags = getObjectFlags(t);
-    return objectFlags & 32 /* Mapped */ ? getApparentTypeOfMappedType(t) : objectFlags & 4 /* Reference */ && t !== type ? getTypeWithThisArgument(t, type) : t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t, type) : t.flags & 402653316 /* StringLike */ ? globalStringType : t.flags & 296 /* NumberLike */ ? globalNumberType : t.flags & 2112 /* BigIntLike */ ? getGlobalBigIntType() : t.flags & 528 /* BooleanLike */ ? globalBooleanType : t.flags & 12288 /* ESSymbolLike */ ? getGlobalESSymbolType() : t.flags & 67108864 /* NonPrimitive */ ? emptyObjectType : t.flags & 4194304 /* Index */ ? stringNumberSymbolType : t.flags & 2 /* Unknown */ && !strictNullChecks ? emptyObjectType : t;
+    return objectFlags & 32 /* Mapped */ ? getApparentTypeOfMappedType(t) : objectFlags & 4 /* Reference */ && t !== type ? getTypeWithThisArgument(t, type) : t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t, type) : t.flags & 402654240 /* StringLike */ ? globalStringType : t.flags & 67648 /* NumberLike */ ? globalNumberType : t.flags & 8320 /* BigIntLike */ ? getGlobalBigIntType() : t.flags & 4352 /* BooleanLike */ ? globalBooleanType : t.flags & 16896 /* ESSymbolLike */ ? getGlobalESSymbolType() : t.flags & 67108864 /* NonPrimitive */ ? emptyObjectType : t.flags & 4194304 /* Index */ ? stringNumberSymbolType : t.flags & 2 /* Unknown */ && !strictNullChecks ? emptyObjectType : t;
   }
   function getReducedApparentType(type) {
     return getReducedType(getApparentType(getReducedType(type)));
@@ -58447,7 +58448,7 @@ function createTypeChecker(host) {
     )) : applicableInfo ? applicableInfo : stringIndexInfo && isApplicableIndexType(keyType, stringType) ? stringIndexInfo : void 0;
   }
   function isApplicableIndexType(source, target) {
-    return isTypeAssignableTo(source, target) || target === stringType && isTypeAssignableTo(source, numberType) || target === numberType && (source === numericStringType || !!(source.flags & 128 /* StringLiteral */) && isNumericLiteralName(source.value));
+    return isTypeAssignableTo(source, target) || target === stringType && isTypeAssignableTo(source, numberType) || target === numberType && (source === numericStringType || !!(source.flags & 1024 /* StringLiteral */) && isNumericLiteralName(source.value));
   }
   function getIndexInfosOfStructuredType(type) {
     if (type.flags & 3670016 /* StructuredType */) {
@@ -58776,7 +58777,7 @@ function createTypeChecker(host) {
         }
         if (type || jsdocPredicate) {
           signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
-        } else if (signature.declaration && isFunctionLikeDeclaration(signature.declaration) && (!signature.resolvedReturnType || signature.resolvedReturnType.flags & 16 /* Boolean */) && getParameterCount(signature) > 0) {
+        } else if (signature.declaration && isFunctionLikeDeclaration(signature.declaration) && (!signature.resolvedReturnType || signature.resolvedReturnType.flags & 256 /* Boolean */) && getParameterCount(signature) > 0) {
           const { declaration } = signature;
           signature.resolvedTypePredicate = noTypePredicate;
           signature.resolvedTypePredicate = getTypePredicateFromBody(declaration) || noTypePredicate;
@@ -59061,7 +59062,7 @@ function createTypeChecker(host) {
     return emptyArray;
   }
   function isValidIndexKeyType(type) {
-    return !!(type.flags & (4 /* String */ | 8 /* Number */ | 4096 /* ESSymbol */)) || isPatternLiteralType(type) || !!(type.flags & 2097152 /* Intersection */) && !isGenericType(type) && some(type.types, isValidIndexKeyType);
+    return !!(type.flags & (32 /* String */ | 64 /* Number */ | 512 /* ESSymbol */)) || isPatternLiteralType(type) || !!(type.flags & 2097152 /* Intersection */) && !isGenericType(type) && some(type.types, isValidIndexKeyType);
   }
   function getConstraintDeclaration(type) {
     return mapDefined(filter(type.symbol && type.symbol.declarations, isTypeParameterDeclaration), getEffectiveConstraintOfTypeParameter)[0];
@@ -59562,7 +59563,7 @@ function createTypeChecker(host) {
   }
   function getTypeFromJSDocNullableTypeNode(node) {
     const type = getTypeFromTypeNode(node.type);
-    return strictNullChecks ? getNullableType(type, 65536 /* Null */) : type;
+    return strictNullChecks ? getNullableType(type, 8 /* Null */) : type;
   }
   function getTypeFromTypeReference(node) {
     const links = getNodeLinks(node);
@@ -60335,10 +60336,10 @@ function createTypeChecker(host) {
     return type.id;
   }
   function containsType(types, type) {
-    return binarySearch(types, type, getTypeId, compareValues) >= 0;
+    return binarySearch(types, type, identity, compareTypes) >= 0;
   }
   function insertType(types, type) {
-    const index = binarySearch(types, type, getTypeId, compareValues);
+    const index = binarySearch(types, type, identity, compareTypes);
     if (index < 0) {
       types.splice(~index, 0, type);
       return true;
@@ -60353,11 +60354,10 @@ function createTypeChecker(host) {
       if (flags & 2097152 /* Intersection */ && getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */) includes |= 536870912 /* IncludesConstrainedTypeVariable */;
       if (type === wildcardType) includes |= 8388608 /* IncludesWildcard */;
       if (isErrorType(type)) includes |= 1073741824 /* IncludesError */;
-      if (!strictNullChecks && flags & 98304 /* Nullable */) {
+      if (!strictNullChecks && flags & 12 /* Nullable */) {
         if (!(getObjectFlags(type) & 65536 /* ContainsWideningType */)) includes |= 4194304 /* IncludesNonWideningType */;
       } else {
-        const len = typeSet.length;
-        const index = len && type.id > typeSet[len - 1].id ? ~len : binarySearch(typeSet, type, getTypeId, compareValues);
+        const index = binarySearch(typeSet, type, identity, compareTypes);
         if (index < 0) {
           typeSet.splice(~index, 0, type);
         }
@@ -60435,7 +60435,7 @@ function createTypeChecker(host) {
       i--;
       const t = types[i];
       const flags = t.flags;
-      const remove = flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && includes & 4 /* String */ || flags & 256 /* NumberLiteral */ && includes & 8 /* Number */ || flags & 2048 /* BigIntLiteral */ && includes & 64 /* BigInt */ || flags & 8192 /* UniqueESSymbol */ && includes & 4096 /* ESSymbol */ || reduceVoidUndefined && flags & 32768 /* Undefined */ && includes & 16384 /* Void */ || isFreshLiteralType(t) && containsType(types, t.regularType);
+      const remove = flags & (1024 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && includes & 32 /* String */ || flags & 2048 /* NumberLiteral */ && includes & 64 /* Number */ || flags & 8192 /* BigIntLiteral */ && includes & 128 /* BigInt */ || flags & 16384 /* UniqueESSymbol */ && includes & 512 /* ESSymbol */ || reduceVoidUndefined && flags & 4 /* Undefined */ && includes & 16 /* Void */ || isFreshLiteralType(t) && containsType(types, t.regularType);
       if (remove) {
         orderedRemoveItemAt(types, i);
       }
@@ -60448,7 +60448,7 @@ function createTypeChecker(host) {
       while (i > 0) {
         i--;
         const t = types[i];
-        if (t.flags & 128 /* StringLiteral */ && some(templates, (template) => isTypeMatchedByTemplateLiteralOrStringMapping(t, template))) {
+        if (t.flags & 1024 /* StringLiteral */ && some(templates, (template) => isTypeMatchedByTemplateLiteralOrStringMapping(t, template))) {
           orderedRemoveItemAt(types, i);
         }
       }
@@ -60546,15 +60546,15 @@ function createTypeChecker(host) {
       if (includes & 3 /* AnyOrUnknown */) {
         return includes & 1 /* Any */ ? includes & 8388608 /* IncludesWildcard */ ? wildcardType : includes & 1073741824 /* IncludesError */ ? errorType : anyType : unknownType;
       }
-      if (includes & 32768 /* Undefined */) {
+      if (includes & 4 /* Undefined */) {
         if (typeSet.length >= 2 && typeSet[0] === undefinedType && typeSet[1] === missingType) {
           orderedRemoveItemAt(typeSet, 1);
         }
       }
-      if (includes & (32 /* Enum */ | 2944 /* Literal */ | 8192 /* UniqueESSymbol */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) || includes & 16384 /* Void */ && includes & 32768 /* Undefined */) {
+      if (includes & (65536 /* Enum */ | 15360 /* Literal */ | 16384 /* UniqueESSymbol */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) || includes & 16 /* Void */ && includes & 4 /* Undefined */) {
         removeRedundantLiteralTypes(typeSet, includes, !!(unionReduction & 2 /* Subtype */));
       }
-      if (includes & 128 /* StringLiteral */ && includes & (134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */)) {
+      if (includes & 1024 /* StringLiteral */ && includes & (134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */)) {
         removeStringLiteralsMatchedByTemplateLiterals(typeSet);
       }
       if (includes & 536870912 /* IncludesConstrainedTypeVariable */) {
@@ -60567,7 +60567,7 @@ function createTypeChecker(host) {
         }
       }
       if (typeSet.length === 0) {
-        return includes & 65536 /* Null */ ? includes & 4194304 /* IncludesNonWideningType */ ? nullType : nullWideningType : includes & 32768 /* Undefined */ ? includes & 4194304 /* IncludesNonWideningType */ ? undefinedType : undefinedWideningType : neverType;
+        return includes & 8 /* Null */ ? includes & 4194304 /* IncludesNonWideningType */ ? nullType : nullWideningType : includes & 4 /* Undefined */ ? includes & 4194304 /* IncludesNonWideningType */ ? undefinedType : undefinedWideningType : neverType;
       }
     }
     if (!origin && includes & 1048576 /* Union */) {
@@ -60590,7 +60590,7 @@ function createTypeChecker(host) {
         origin = createOriginUnionOrIntersectionType(1048576 /* Union */, reducedTypes);
       }
     }
-    const objectFlags = (includes & 36323331 /* NotPrimitiveUnion */ ? 0 : 32768 /* PrimitiveUnion */) | (includes & 2097152 /* Intersection */ ? 16777216 /* ContainsIntersections */ : 0);
+    const objectFlags = (includes & 36306963 /* NotPrimitiveUnion */ ? 0 : 32768 /* PrimitiveUnion */) | (includes & 2097152 /* Intersection */ ? 16777216 /* ContainsIntersections */ : 0);
     return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments, origin);
   }
   function getUnionOrIntersectionTypePredicate(signatures, kind) {
@@ -60635,14 +60635,14 @@ function createTypeChecker(host) {
       type.objectFlags = precomputedObjectFlags | getPropagatingFlagsOfTypes(
         types,
         /*excludeKinds*/
-        98304 /* Nullable */
+        12 /* Nullable */
       );
       type.types = types;
       type.origin = origin;
       type.aliasSymbol = aliasSymbol;
       type.aliasTypeArguments = aliasTypeArguments;
-      if (types.length === 2 && types[0].flags & 512 /* BooleanLiteral */ && types[1].flags & 512 /* BooleanLiteral */) {
-        type.flags |= 16 /* Boolean */;
+      if (types.length === 2 && types[0].flags & 4096 /* BooleanLiteral */ && types[1].flags & 4096 /* BooleanLiteral */) {
+        type.flags |= 256 /* Boolean */;
         type.intrinsicName = "boolean";
       }
       unionTypes.set(id, type);
@@ -60671,13 +60671,13 @@ function createTypeChecker(host) {
       if (flags & 3 /* AnyOrUnknown */) {
         if (type === wildcardType) includes |= 8388608 /* IncludesWildcard */;
         if (isErrorType(type)) includes |= 1073741824 /* IncludesError */;
-      } else if (strictNullChecks || !(flags & 98304 /* Nullable */)) {
+      } else if (strictNullChecks || !(flags & 12 /* Nullable */)) {
         if (type === missingType) {
           includes |= 262144 /* IncludesMissingType */;
           type = undefinedType;
         }
         if (!typeSet.has(type.id.toString())) {
-          if (type.flags & 109472 /* Unit */ && includes & 109472 /* Unit */) {
+          if (type.flags & 97292 /* Unit */ && includes & 97292 /* Unit */) {
             includes |= 67108864 /* NonPrimitive */;
           }
           typeSet.set(type.id.toString(), type);
@@ -60698,7 +60698,7 @@ function createTypeChecker(host) {
     while (i > 0) {
       i--;
       const t = types[i];
-      const remove = t.flags & 4 /* String */ && includes & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) || t.flags & 8 /* Number */ && includes & 256 /* NumberLiteral */ || t.flags & 64 /* BigInt */ && includes & 2048 /* BigIntLiteral */ || t.flags & 4096 /* ESSymbol */ && includes & 8192 /* UniqueESSymbol */ || t.flags & 16384 /* Void */ && includes & 32768 /* Undefined */ || isEmptyAnonymousObjectType(t) && includes & 470302716 /* DefinitelyNonNullable */;
+      const remove = t.flags & 32 /* String */ && includes & (1024 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) || t.flags & 64 /* Number */ && includes & 2048 /* NumberLiteral */ || t.flags & 128 /* BigInt */ && includes & 8192 /* BigIntLiteral */ || t.flags & 512 /* ESSymbol */ && includes & 16384 /* UniqueESSymbol */ || t.flags & 16 /* Void */ && includes & 4 /* Undefined */ || isEmptyAnonymousObjectType(t) && includes & 470417376 /* DefinitelyNonNullable */;
       if (remove) {
         orderedRemoveItemAt(types, i);
       }
@@ -60713,7 +60713,7 @@ function createTypeChecker(host) {
         if (type === undefinedType) {
           return containsType(u.types, missingType);
         }
-        const primitive = type.flags & 128 /* StringLiteral */ ? stringType : type.flags & (32 /* Enum */ | 256 /* NumberLiteral */) ? numberType : type.flags & 2048 /* BigIntLiteral */ ? bigintType : type.flags & 8192 /* UniqueESSymbol */ ? esSymbolType : void 0;
+        const primitive = type.flags & 1024 /* StringLiteral */ ? stringType : type.flags & (65536 /* Enum */ | 2048 /* NumberLiteral */) ? numberType : type.flags & 8192 /* BigIntLiteral */ ? bigintType : type.flags & 16384 /* UniqueESSymbol */ ? esSymbolType : void 0;
         if (!primitive || !containsType(u.types, primitive)) {
           return false;
         }
@@ -60723,7 +60723,7 @@ function createTypeChecker(host) {
   }
   function extractRedundantTemplateLiterals(types) {
     let i = types.length;
-    const literals = filter(types, (t) => !!(t.flags & 128 /* StringLiteral */));
+    const literals = filter(types, (t) => !!(t.flags & 1024 /* StringLiteral */));
     while (i > 0) {
       i--;
       const t = types[i];
@@ -60789,7 +60789,7 @@ function createTypeChecker(host) {
     result.objectFlags = objectFlags | getPropagatingFlagsOfTypes(
       types,
       /*excludeKinds*/
-      98304 /* Nullable */
+      12 /* Nullable */
     );
     result.types = types;
     result.aliasSymbol = aliasSymbol;
@@ -60804,19 +60804,19 @@ function createTypeChecker(host) {
     if (includes & 131072 /* Never */) {
       return contains(typeSet, silentNeverType) ? silentNeverType : neverType;
     }
-    if (strictNullChecks && includes & 98304 /* Nullable */ && includes & (524288 /* Object */ | 67108864 /* NonPrimitive */ | 16777216 /* IncludesEmptyObject */) || includes & 67108864 /* NonPrimitive */ && includes & (469892092 /* DisjointDomains */ & ~67108864 /* NonPrimitive */) || includes & 402653316 /* StringLike */ && includes & (469892092 /* DisjointDomains */ & ~402653316 /* StringLike */) || includes & 296 /* NumberLike */ && includes & (469892092 /* DisjointDomains */ & ~296 /* NumberLike */) || includes & 2112 /* BigIntLike */ && includes & (469892092 /* DisjointDomains */ & ~2112 /* BigIntLike */) || includes & 12288 /* ESSymbolLike */ && includes & (469892092 /* DisjointDomains */ & ~12288 /* ESSymbolLike */) || includes & 49152 /* VoidLike */ && includes & (469892092 /* DisjointDomains */ & ~49152 /* VoidLike */)) {
+    if (strictNullChecks && includes & 12 /* Nullable */ && includes & (524288 /* Object */ | 67108864 /* NonPrimitive */ | 16777216 /* IncludesEmptyObject */) || includes & 67108864 /* NonPrimitive */ && includes & (469860348 /* DisjointDomains */ & ~67108864 /* NonPrimitive */) || includes & 402654240 /* StringLike */ && includes & (469860348 /* DisjointDomains */ & ~402654240 /* StringLike */) || includes & 67648 /* NumberLike */ && includes & (469860348 /* DisjointDomains */ & ~67648 /* NumberLike */) || includes & 8320 /* BigIntLike */ && includes & (469860348 /* DisjointDomains */ & ~8320 /* BigIntLike */) || includes & 16896 /* ESSymbolLike */ && includes & (469860348 /* DisjointDomains */ & ~16896 /* ESSymbolLike */) || includes & 20 /* VoidLike */ && includes & (469860348 /* DisjointDomains */ & ~20 /* VoidLike */)) {
       return neverType;
     }
-    if (includes & (134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && includes & 128 /* StringLiteral */ && extractRedundantTemplateLiterals(typeSet)) {
+    if (includes & (134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && includes & 1024 /* StringLiteral */ && extractRedundantTemplateLiterals(typeSet)) {
       return neverType;
     }
     if (includes & 1 /* Any */) {
       return includes & 8388608 /* IncludesWildcard */ ? wildcardType : includes & 1073741824 /* IncludesError */ ? errorType : anyType;
     }
-    if (!strictNullChecks && includes & 98304 /* Nullable */) {
-      return includes & 16777216 /* IncludesEmptyObject */ ? neverType : includes & 32768 /* Undefined */ ? undefinedType : nullType;
+    if (!strictNullChecks && includes & 12 /* Nullable */) {
+      return includes & 16777216 /* IncludesEmptyObject */ ? neverType : includes & 4 /* Undefined */ ? undefinedType : nullType;
     }
-    if (includes & 4 /* String */ && includes & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) || includes & 8 /* Number */ && includes & 256 /* NumberLiteral */ || includes & 64 /* BigInt */ && includes & 2048 /* BigIntLiteral */ || includes & 4096 /* ESSymbol */ && includes & 8192 /* UniqueESSymbol */ || includes & 16384 /* Void */ && includes & 32768 /* Undefined */ || includes & 16777216 /* IncludesEmptyObject */ && includes & 470302716 /* DefinitelyNonNullable */) {
+    if (includes & 32 /* String */ && includes & (1024 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) || includes & 64 /* Number */ && includes & 2048 /* NumberLiteral */ || includes & 128 /* BigInt */ && includes & 8192 /* BigIntLiteral */ || includes & 512 /* ESSymbol */ && includes & 16384 /* UniqueESSymbol */ || includes & 16 /* Void */ && includes & 4 /* Undefined */ || includes & 16777216 /* IncludesEmptyObject */ && includes & 470417376 /* DefinitelyNonNullable */) {
       if (!(flags & 1 /* NoSupertypeReduction */)) removeRedundantSupertypes(typeSet, includes);
     }
     if (includes & 262144 /* IncludesMissingType */) {
@@ -60853,12 +60853,12 @@ function createTypeChecker(host) {
       if (includes & 1048576 /* Union */) {
         if (intersectUnionsOfPrimitiveTypes(typeSet)) {
           result = getIntersectionType(typeSet, flags, aliasSymbol, aliasTypeArguments);
-        } else if (every(typeSet, (t) => !!(t.flags & 1048576 /* Union */ && t.types[0].flags & 32768 /* Undefined */))) {
+        } else if (every(typeSet, (t) => !!(t.flags & 1048576 /* Union */ && t.types[0].flags & 4 /* Undefined */))) {
           const containedUndefinedType = some(typeSet, containsMissingType) ? missingType : undefinedType;
-          removeFromEach(typeSet, 32768 /* Undefined */);
+          removeFromEach(typeSet, 4 /* Undefined */);
           result = getUnionType([getIntersectionType(typeSet, flags), containedUndefinedType], 1 /* Literal */, aliasSymbol, aliasTypeArguments);
-        } else if (every(typeSet, (t) => !!(t.flags & 1048576 /* Union */ && (t.types[0].flags & 65536 /* Null */ || t.types[1].flags & 65536 /* Null */)))) {
-          removeFromEach(typeSet, 65536 /* Null */);
+        } else if (every(typeSet, (t) => !!(t.flags & 1048576 /* Union */ && (t.types[0].flags & 8 /* Null */ || t.types[1].flags & 8 /* Null */)))) {
+          removeFromEach(typeSet, 8 /* Null */);
           result = getUnionType([getIntersectionType(typeSet, flags), nullType], 1 /* Literal */, aliasSymbol, aliasTypeArguments);
         } else if (typeSet.length >= 3 && types.length > 2) {
           const middle = Math.floor(typeSet.length / 2);
@@ -60923,7 +60923,7 @@ function createTypeChecker(host) {
       const types = map(node.types, getTypeFromTypeNode);
       const emptyIndex = types.length === 2 ? types.indexOf(emptyTypeLiteralType) : -1;
       const t = emptyIndex >= 0 ? types[1 - emptyIndex] : unknownType;
-      const noSupertypeReduction = !!(t.flags & (4 /* String */ | 8 /* Number */ | 64 /* BigInt */) || t.flags & 134217728 /* TemplateLiteral */ && isPatternLiteralType(t));
+      const noSupertypeReduction = !!(t.flags & (32 /* String */ | 64 /* Number */ | 128 /* BigInt */) || t.flags & 134217728 /* TemplateLiteral */ && isPatternLiteralType(t));
       links.resolvedType = getIntersectionType(types, noSupertypeReduction ? 1 /* NoSupertypeReduction */ : 0, aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol));
     }
     return links.resolvedType;
@@ -60957,11 +60957,11 @@ function createTypeChecker(host) {
       forEachType(constraintType, addMemberForKeyType);
     } else if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
       const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
-      forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, !!(indexFlags & 1 /* StringsOnly */), addMemberForKeyType);
+      forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 19456 /* StringOrNumberLiteralOrUnique */, !!(indexFlags & 1 /* StringsOnly */), addMemberForKeyType);
     } else {
       forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
     }
-    const result = indexFlags & 2 /* NoIndexSignatures */ ? filterType(getUnionType(keyTypes), (t) => !(t.flags & (1 /* Any */ | 4 /* String */))) : getUnionType(keyTypes);
+    const result = indexFlags & 2 /* NoIndexSignatures */ ? filterType(getUnionType(keyTypes), (t) => !(t.flags & (1 /* Any */ | 32 /* String */))) : getUnionType(keyTypes);
     if (result.flags & 1048576 /* Union */ && constraintType.flags & 1048576 /* Union */ && getTypeListId(result.types) === getTypeListId(constraintType.types)) {
       return constraintType;
     }
@@ -61016,7 +61016,7 @@ function createTypeChecker(host) {
   function getLiteralTypeFromProperties(type, include, includeOrigin) {
     const origin = includeOrigin && (getObjectFlags(type) & (3 /* ClassOrInterface */ | 4 /* Reference */) || type.aliasSymbol) ? createOriginIndexType(type) : void 0;
     const propertyTypes = map(getPropertiesOfType(type), (prop) => getLiteralTypeFromProperty(prop, include));
-    const indexKeyTypes = map(getIndexInfosOfType(type), (info) => info !== enumNumberIndexInfo && isKeyTypeIncluded(info.keyType, include) ? info.keyType === stringType && include & 8 /* Number */ ? stringOrNumberType : info.keyType : neverType);
+    const indexKeyTypes = map(getIndexInfosOfType(type), (info) => info !== enumNumberIndexInfo && isKeyTypeIncluded(info.keyType, include) ? info.keyType === stringType && include & 64 /* Number */ ? stringOrNumberType : info.keyType : neverType);
     return getUnionType(
       concatenate(propertyTypes, indexKeyTypes),
       1 /* Literal */,
@@ -61032,7 +61032,7 @@ function createTypeChecker(host) {
   }
   function getIndexType(type, indexFlags = 0 /* None */) {
     type = getReducedType(type);
-    return isNoInferType(type) ? getNoInferType(getIndexType(type.baseType, indexFlags)) : shouldDeferIndexType(type, indexFlags) ? getIndexTypeForGenericType(type, indexFlags) : type.flags & 1048576 /* Union */ ? getIntersectionType(map(type.types, (t) => getIndexType(t, indexFlags))) : type.flags & 2097152 /* Intersection */ ? getUnionType(map(type.types, (t) => getIndexType(t, indexFlags))) : getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, indexFlags) : type === wildcardType ? wildcardType : type.flags & 2 /* Unknown */ ? neverType : type.flags & (1 /* Any */ | 131072 /* Never */) ? stringNumberSymbolType : getLiteralTypeFromProperties(type, (indexFlags & 2 /* NoIndexSignatures */ ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (indexFlags & 1 /* StringsOnly */ ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */), indexFlags === 0 /* None */);
+    return isNoInferType(type) ? getNoInferType(getIndexType(type.baseType, indexFlags)) : shouldDeferIndexType(type, indexFlags) ? getIndexTypeForGenericType(type, indexFlags) : type.flags & 1048576 /* Union */ ? getIntersectionType(map(type.types, (t) => getIndexType(t, indexFlags))) : type.flags & 2097152 /* Intersection */ ? getUnionType(map(type.types, (t) => getIndexType(t, indexFlags))) : getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, indexFlags) : type === wildcardType ? wildcardType : type.flags & 2 /* Unknown */ ? neverType : type.flags & (1 /* Any */ | 131072 /* Never */) ? stringNumberSymbolType : getLiteralTypeFromProperties(type, (indexFlags & 2 /* NoIndexSignatures */ ? 1024 /* StringLiteral */ : 402654240 /* StringLike */) | (indexFlags & 1 /* StringsOnly */ ? 0 : 67648 /* NumberLike */ | 16896 /* ESSymbolLike */), indexFlags === 0 /* None */);
   }
   function getExtractStringType(type) {
     const extractTypeAlias = getGlobalExtractSymbol();
@@ -61090,7 +61090,7 @@ function createTypeChecker(host) {
     }
     newTexts.push(text);
     if (every(newTexts, (t) => t === "")) {
-      if (every(newTypes, (t) => !!(t.flags & 4 /* String */))) {
+      if (every(newTypes, (t) => !!(t.flags & 32 /* String */))) {
         return stringType;
       }
       if (newTypes.length === 1 && isPatternLiteralType(newTypes[0])) {
@@ -61106,7 +61106,7 @@ function createTypeChecker(host) {
     function addSpans(texts2, types2) {
       for (let i = 0; i < types2.length; i++) {
         const t = types2[i];
-        if (t.flags & (2944 /* Literal */ | 65536 /* Null */ | 32768 /* Undefined */)) {
+        if (t.flags & (15360 /* Literal */ | 8 /* Null */ | 4 /* Undefined */)) {
           text += getTemplateStringForType(t) || "";
           text += texts2[i + 1];
         } else if (t.flags & 134217728 /* TemplateLiteral */) {
@@ -61125,7 +61125,7 @@ function createTypeChecker(host) {
     }
   }
   function getTemplateStringForType(type) {
-    return type.flags & 128 /* StringLiteral */ ? type.value : type.flags & 256 /* NumberLiteral */ ? "" + type.value : type.flags & 2048 /* BigIntLiteral */ ? pseudoBigIntToString(type.value) : type.flags & (512 /* BooleanLiteral */ | 98304 /* Nullable */) ? type.intrinsicName : void 0;
+    return type.flags & 1024 /* StringLiteral */ ? type.value : type.flags & 2048 /* NumberLiteral */ ? "" + type.value : type.flags & 8192 /* BigIntLiteral */ ? pseudoBigIntToString(type.value) : type.flags & (4096 /* BooleanLiteral */ | 12 /* Nullable */) ? type.intrinsicName : void 0;
   }
   function createTemplateLiteralType(texts, types) {
     const type = createType(134217728 /* TemplateLiteral */);
@@ -61134,9 +61134,9 @@ function createTypeChecker(host) {
     return type;
   }
   function getStringMappingType(symbol, type) {
-    return type.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapType(type, (t) => getStringMappingType(symbol, t)) : type.flags & 128 /* StringLiteral */ ? getStringLiteralType(applyStringMapping(symbol, type.value)) : type.flags & 134217728 /* TemplateLiteral */ ? getTemplateLiteralType(...applyTemplateStringMapping(symbol, type.texts, type.types)) : (
+    return type.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapType(type, (t) => getStringMappingType(symbol, t)) : type.flags & 1024 /* StringLiteral */ ? getStringLiteralType(applyStringMapping(symbol, type.value)) : type.flags & 134217728 /* TemplateLiteral */ ? getTemplateLiteralType(...applyTemplateStringMapping(symbol, type.texts, type.types)) : (
       // Mapping<Mapping<T>> === Mapping<T>
-      type.flags & 268435456 /* StringMapping */ && symbol === type.symbol ? type : type.flags & (1 /* Any */ | 4 /* String */ | 268435456 /* StringMapping */) || isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) : (
+      type.flags & 268435456 /* StringMapping */ && symbol === type.symbol ? type : type.flags & (1 /* Any */ | 32 /* String */ | 268435456 /* StringMapping */) || isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) : (
         // This handles Mapping<`${number}`> and Mapping<`${bigint}`>
         isPatternLiteralPlaceholderType(type) ? getStringMappingTypeForGenericType(symbol, getTemplateLiteralType(["", ""], [type])) : type
       )
@@ -61274,7 +61274,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    if (!(indexType.flags & 98304 /* Nullable */) && isTypeAssignableToKind(indexType, 402653316 /* StringLike */ | 296 /* NumberLike */ | 12288 /* ESSymbolLike */)) {
+    if (!(indexType.flags & 12 /* Nullable */) && isTypeAssignableToKind(indexType, 402654240 /* StringLike */ | 67648 /* NumberLike */ | 16896 /* ESSymbolLike */)) {
       if (objectType.flags & (1 /* Any */ | 131072 /* Never */)) {
         return objectType;
       }
@@ -61290,13 +61290,13 @@ function createTypeChecker(host) {
           }
           return void 0;
         }
-        if (accessNode && indexInfo.keyType === stringType && !isTypeAssignableToKind(indexType, 4 /* String */ | 8 /* Number */)) {
+        if (accessNode && indexInfo.keyType === stringType && !isTypeAssignableToKind(indexType, 32 /* String */ | 64 /* Number */)) {
           const indexNode = getIndexNodeForAccessExpression(accessNode);
           error(indexNode, Diagnostics.Type_0_cannot_be_used_as_an_index_type, typeToString(indexType));
           return accessFlags & 1 /* IncludeUndefined */ ? getUnionType([indexInfo.type, missingType]) : indexInfo.type;
         }
         errorIfWritingToReadonlyIndex(indexInfo);
-        if (accessFlags & 1 /* IncludeUndefined */ && !(objectType.symbol && objectType.symbol.flags & (256 /* RegularEnum */ | 128 /* ConstEnum */) && (indexType.symbol && indexType.flags & 1024 /* EnumLiteral */ && getParentOfSymbol(indexType.symbol) === objectType.symbol))) {
+        if (accessFlags & 1 /* IncludeUndefined */ && !(objectType.symbol && objectType.symbol.flags & (256 /* RegularEnum */ | 128 /* ConstEnum */) && (indexType.symbol && indexType.flags & 32768 /* EnumLiteral */ && getParentOfSymbol(indexType.symbol) === objectType.symbol))) {
           return getUnionType([indexInfo.type, missingType]);
         }
         return indexInfo.type;
@@ -61309,10 +61309,10 @@ function createTypeChecker(host) {
       }
       if (accessExpression && !isConstEnumObjectType(objectType)) {
         if (isObjectLiteralType(objectType)) {
-          if (noImplicitAny && indexType.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */)) {
+          if (noImplicitAny && indexType.flags & (1024 /* StringLiteral */ | 2048 /* NumberLiteral */)) {
             diagnostics.add(createDiagnosticForNode(accessExpression, Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType)));
             return undefinedType;
-          } else if (indexType.flags & (8 /* Number */ | 4 /* String */)) {
+          } else if (indexType.flags & (64 /* Number */ | 32 /* String */)) {
             const types = map(objectType.properties, (property) => {
               return getTypeOfSymbol(property);
             });
@@ -61339,7 +61339,7 @@ function createTypeChecker(host) {
                 error(accessExpression, Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1, typeToString(objectType), suggestion2);
               } else {
                 let errorInfo;
-                if (indexType.flags & 1024 /* EnumLiteral */) {
+                if (indexType.flags & 32768 /* EnumLiteral */) {
                   errorInfo = chainDiagnosticMessages(
                     /*details*/
                     void 0,
@@ -61347,7 +61347,7 @@ function createTypeChecker(host) {
                     "[" + typeToString(indexType) + "]",
                     typeToString(objectType)
                   );
-                } else if (indexType.flags & 8192 /* UniqueESSymbol */) {
+                } else if (indexType.flags & 16384 /* UniqueESSymbol */) {
                   const symbolName2 = getFullyQualifiedName(indexType.symbol, accessExpression);
                   errorInfo = chainDiagnosticMessages(
                     /*details*/
@@ -61356,7 +61356,7 @@ function createTypeChecker(host) {
                     "[" + symbolName2 + "]",
                     typeToString(objectType)
                   );
-                } else if (indexType.flags & 128 /* StringLiteral */) {
+                } else if (indexType.flags & 1024 /* StringLiteral */) {
                   errorInfo = chainDiagnosticMessages(
                     /*details*/
                     void 0,
@@ -61364,7 +61364,7 @@ function createTypeChecker(host) {
                     indexType.value,
                     typeToString(objectType)
                   );
-                } else if (indexType.flags & 256 /* NumberLiteral */) {
+                } else if (indexType.flags & 2048 /* NumberLiteral */) {
                   errorInfo = chainDiagnosticMessages(
                     /*details*/
                     void 0,
@@ -61372,7 +61372,7 @@ function createTypeChecker(host) {
                     indexType.value,
                     typeToString(objectType)
                   );
-                } else if (indexType.flags & (8 /* Number */ | 4 /* String */)) {
+                } else if (indexType.flags & (64 /* Number */ | 32 /* String */)) {
                   errorInfo = chainDiagnosticMessages(
                     /*details*/
                     void 0,
@@ -61403,9 +61403,9 @@ function createTypeChecker(host) {
     }
     if (accessNode) {
       const indexNode = getIndexNodeForAccessExpression(accessNode);
-      if (indexNode.kind !== 10 /* BigIntLiteral */ && indexType.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */)) {
+      if (indexNode.kind !== 10 /* BigIntLiteral */ && indexType.flags & (1024 /* StringLiteral */ | 2048 /* NumberLiteral */)) {
         error(indexNode, Diagnostics.Property_0_does_not_exist_on_type_1, "" + indexType.value, typeToString(objectType));
-      } else if (indexType.flags & (4 /* String */ | 8 /* Number */)) {
+      } else if (indexType.flags & (32 /* String */ | 64 /* Number */)) {
         error(indexNode, Diagnostics.Type_0_has_no_matching_index_signature_for_type_1, typeToString(objectType), typeToString(indexType));
       } else {
         const typeString = indexNode.kind === 10 /* BigIntLiteral */ ? "bigint" : typeToString(indexType);
@@ -61429,7 +61429,7 @@ function createTypeChecker(host) {
     if (type.flags & 2097152 /* Intersection */) {
       let seenPlaceholder = false;
       for (const t of type.types) {
-        if (t.flags & (2944 /* Literal */ | 98304 /* Nullable */) || isPatternLiteralPlaceholderType(t)) {
+        if (t.flags & (15360 /* Literal */ | 12 /* Nullable */) || isPatternLiteralPlaceholderType(t)) {
           seenPlaceholder = true;
         } else if (!(t.flags & 524288 /* Object */)) {
           return false;
@@ -61437,7 +61437,7 @@ function createTypeChecker(host) {
       }
       return seenPlaceholder;
     }
-    return !!(type.flags & (1 /* Any */ | 4 /* String */ | 8 /* Number */ | 64 /* BigInt */)) || isPatternLiteralType(type);
+    return !!(type.flags & (1 /* Any */ | 32 /* String */ | 64 /* Number */ | 128 /* BigInt */)) || isPatternLiteralType(type);
   }
   function isPatternLiteralType(type) {
     return !!(type.flags & 134217728 /* TemplateLiteral */) && every(type.types, isPatternLiteralPlaceholderType) || !!(type.flags & 268435456 /* StringMapping */) && isPatternLiteralPlaceholderType(type.type);
@@ -61502,10 +61502,10 @@ function createTypeChecker(host) {
         return type[cache] = distributedOverObject;
       }
     }
-    if (isGenericTupleType(objectType) && indexType.flags & 296 /* NumberLike */) {
+    if (isGenericTupleType(objectType) && indexType.flags & 67648 /* NumberLike */) {
       const elementType = getElementTypeOfSliceOfTupleType(
         objectType,
-        indexType.flags & 8 /* Number */ ? 0 : objectType.target.fixedLength,
+        indexType.flags & 64 /* Number */ ? 0 : objectType.target.fixedLength,
         /*endSkipCount*/
         0,
         writing
@@ -61558,14 +61558,14 @@ function createTypeChecker(host) {
   }
   function couldAccessOptionalProperty(objectType, indexType) {
     const indexConstraint = getBaseConstraintOfType(indexType);
-    return !!indexConstraint && some(getPropertiesOfType(objectType), (p) => !!(p.flags & 16777216 /* Optional */) && isTypeAssignableTo(getLiteralTypeFromProperty(p, 8576 /* StringOrNumberLiteralOrUnique */), indexConstraint));
+    return !!indexConstraint && some(getPropertiesOfType(objectType), (p) => !!(p.flags & 16777216 /* Optional */) && isTypeAssignableTo(getLiteralTypeFromProperty(p, 19456 /* StringOrNumberLiteralOrUnique */), indexConstraint));
   }
   function getIndexedAccessType(objectType, indexType, accessFlags = 0 /* None */, accessNode, aliasSymbol, aliasTypeArguments) {
     return getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) || (accessNode ? errorType : unknownType);
   }
   function indexTypeLessThan(indexType, limit) {
     return everyType(indexType, (t) => {
-      if (t.flags & 384 /* StringOrNumberLiteral */) {
+      if (t.flags & 3072 /* StringOrNumberLiteral */) {
         const propName = getPropertyNameFromType(t);
         if (isNumericLiteralName(propName)) {
           const index = +propName;
@@ -61580,7 +61580,7 @@ function createTypeChecker(host) {
       return wildcardType;
     }
     objectType = getReducedType(objectType);
-    if (isStringIndexSignatureOnlyType(objectType) && !(indexType.flags & 98304 /* Nullable */) && isTypeAssignableToKind(indexType, 4 /* String */ | 8 /* Number */)) {
+    if (isStringIndexSignatureOnlyType(objectType) && !(indexType.flags & 12 /* Nullable */) && isTypeAssignableToKind(indexType, 32 /* String */ | 64 /* Number */)) {
       indexType = stringType;
     }
     if (compilerOptions.noUncheckedIndexedAccess && accessFlags & 32 /* ExpressionPosition */) accessFlags |= 1 /* IncludeUndefined */;
@@ -61597,7 +61597,7 @@ function createTypeChecker(host) {
       return type;
     }
     const apparentObjectType = getReducedApparentType(objectType);
-    if (indexType.flags & 1048576 /* Union */ && !(indexType.flags & 16 /* Boolean */)) {
+    if (indexType.flags & 1048576 /* Union */ && !(indexType.flags & 256 /* Boolean */)) {
       const propTypes = [];
       let wasMissingProp = false;
       for (const t of indexType.types) {
@@ -61930,7 +61930,7 @@ function createTypeChecker(host) {
     return !!(type.flags & 524288 /* Object */) && !isGenericMappedType(type);
   }
   function isEmptyObjectTypeOrSpreadsIntoEmptyObject(type) {
-    return isEmptyObjectType(type) || !!(type.flags & (65536 /* Null */ | 32768 /* Undefined */ | 528 /* BooleanLike */ | 296 /* NumberLike */ | 2112 /* BigIntLike */ | 402653316 /* StringLike */ | 1056 /* EnumLike */ | 67108864 /* NonPrimitive */ | 4194304 /* Index */));
+    return isEmptyObjectType(type) || !!(type.flags & (8 /* Null */ | 4 /* Undefined */ | 4352 /* BooleanLike */ | 67648 /* NumberLike */ | 8320 /* BigIntLike */ | 402654240 /* StringLike */ | 98304 /* EnumLike */ | 67108864 /* NonPrimitive */ | 4194304 /* Index */));
   }
   function tryMergeUnionOfObjectTypeAndEmptyObject(type, readonly) {
     if (!(type.flags & 1048576 /* Union */)) {
@@ -61993,7 +61993,7 @@ function createTypeChecker(host) {
     if (right.flags & 1048576 /* Union */) {
       return checkCrossProductUnion([left, right]) ? mapType(right, (t) => getSpreadType(left, t, symbol, objectFlags, readonly)) : errorType;
     }
-    if (right.flags & (528 /* BooleanLike */ | 296 /* NumberLike */ | 2112 /* BigIntLike */ | 402653316 /* StringLike */ | 1056 /* EnumLike */ | 67108864 /* NonPrimitive */ | 4194304 /* Index */)) {
+    if (right.flags & (4352 /* BooleanLike */ | 67648 /* NumberLike */ | 8320 /* BigIntLike */ | 402654240 /* StringLike */ | 98304 /* EnumLike */ | 67108864 /* NonPrimitive */ | 4194304 /* Index */)) {
       return left;
     }
     if (isGenericObjectType(left) || isGenericObjectType(right)) {
@@ -62075,7 +62075,7 @@ function createTypeChecker(host) {
     return type;
   }
   function getFreshTypeOfLiteralType(type) {
-    if (type.flags & 2976 /* Freshable */) {
+    if (type.flags & 80896 /* Freshable */) {
       if (!type.freshType) {
         const freshType = createLiteralType(type.flags, type.value, type.symbol, type);
         freshType.freshType = freshType;
@@ -62086,28 +62086,28 @@ function createTypeChecker(host) {
     return type;
   }
   function getRegularTypeOfLiteralType(type) {
-    return type.flags & 2976 /* Freshable */ ? type.regularType : type.flags & 1048576 /* Union */ ? type.regularType || (type.regularType = mapType(type, getRegularTypeOfLiteralType)) : type;
+    return type.flags & 80896 /* Freshable */ ? type.regularType : type.flags & 1048576 /* Union */ ? type.regularType || (type.regularType = mapType(type, getRegularTypeOfLiteralType)) : type;
   }
   function isFreshLiteralType(type) {
-    return !!(type.flags & 2976 /* Freshable */) && type.freshType === type;
+    return !!(type.flags & 80896 /* Freshable */) && type.freshType === type;
   }
   function getStringLiteralType(value) {
     let type;
-    return stringLiteralTypes.get(value) || (stringLiteralTypes.set(value, type = createLiteralType(128 /* StringLiteral */, value)), type);
+    return stringLiteralTypes.get(value) || (stringLiteralTypes.set(value, type = createLiteralType(1024 /* StringLiteral */, value)), type);
   }
   function getNumberLiteralType(value) {
     let type;
-    return numberLiteralTypes.get(value) || (numberLiteralTypes.set(value, type = createLiteralType(256 /* NumberLiteral */, value)), type);
+    return numberLiteralTypes.get(value) || (numberLiteralTypes.set(value, type = createLiteralType(2048 /* NumberLiteral */, value)), type);
   }
   function getBigIntLiteralType(value) {
     let type;
     const key = pseudoBigIntToString(value);
-    return bigIntLiteralTypes.get(key) || (bigIntLiteralTypes.set(key, type = createLiteralType(2048 /* BigIntLiteral */, value)), type);
+    return bigIntLiteralTypes.get(key) || (bigIntLiteralTypes.set(key, type = createLiteralType(8192 /* BigIntLiteral */, value)), type);
   }
   function getEnumLiteralType(value, enumId, symbol) {
     let type;
     const key = `${enumId}${typeof value === "string" ? "@" : "#"}${value}`;
-    const flags = 1024 /* EnumLiteral */ | (typeof value === "string" ? 128 /* StringLiteral */ : 256 /* NumberLiteral */);
+    const flags = 32768 /* EnumLiteral */ | (typeof value === "string" ? 1024 /* StringLiteral */ : 2048 /* NumberLiteral */);
     return enumLiteralTypes.get(key) || (enumLiteralTypes.set(key, type = createLiteralType(flags, value, symbol)), type);
   }
   function getTypeFromLiteralTypeNode(node) {
@@ -62121,7 +62121,7 @@ function createTypeChecker(host) {
     return links.resolvedType;
   }
   function createUniqueESSymbolType(symbol) {
-    const type = createTypeWithSymbol(8192 /* UniqueESSymbol */, symbol);
+    const type = createTypeWithSymbol(16384 /* UniqueESSymbol */, symbol);
     type.escapedName = `__@${type.symbol.escapedName}@${getSymbolId(type.symbol)}`;
     return type;
   }
@@ -62509,7 +62509,7 @@ function createTypeChecker(host) {
         result = target.objectFlags & 4 /* Reference */ ? createDeferredTypeReference(type.target, type.node, newMapper, newAliasSymbol, newAliasTypeArguments) : target.objectFlags & 32 /* Mapped */ ? instantiateMappedType(target, newMapper, newAliasSymbol, newAliasTypeArguments) : instantiateAnonymousType(target, newMapper, newAliasSymbol, newAliasTypeArguments);
         target.instantiations.set(id, result);
         const resultObjectFlags = getObjectFlags(result);
-        if (result.flags & 3899393 /* ObjectFlagsType */ && !(resultObjectFlags & 524288 /* CouldContainTypeVariablesComputed */)) {
+        if (result.flags & 3801101 /* ObjectFlagsType */ && !(resultObjectFlags & 524288 /* CouldContainTypeVariablesComputed */)) {
           const resultCouldContainTypeVariables = some(typeArguments, couldContainTypeVariables);
           if (!(getObjectFlags(result) & 524288 /* CouldContainTypeVariablesComputed */)) {
             if (resultObjectFlags & (32 /* Mapped */ | 16 /* Anonymous */ | 4 /* Reference */)) {
@@ -62638,7 +62638,7 @@ function createTypeChecker(host) {
     const templateMapper = appendTypeMapping(mapper, getTypeParameterFromMappedType(type), key);
     const propType = instantiateType(getTemplateTypeFromMappedType(type.target || type), templateMapper);
     const modifiers = getMappedTypeModifiers(type);
-    return strictNullChecks && modifiers & 4 /* IncludeOptional */ && !maybeTypeOfKind(propType, 32768 /* Undefined */ | 16384 /* Void */) ? getOptionalType(
+    return strictNullChecks && modifiers & 4 /* IncludeOptional */ && !maybeTypeOfKind(propType, 4 /* Undefined */ | 16 /* Void */) ? getOptionalType(
       propType,
       /*isProperty*/
       true
@@ -63185,7 +63185,7 @@ function createTypeChecker(host) {
                   createDiagnosticForNode(
                     targetNode,
                     Diagnostics.The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1,
-                    propertyName && !(nameType.flags & 8192 /* UniqueESSymbol */) ? unescapeLeadingUnderscores(propertyName) : typeToString(nameType),
+                    propertyName && !(nameType.flags & 16384 /* UniqueESSymbol */) ? unescapeLeadingUnderscores(propertyName) : typeToString(nameType),
                     typeToString(target)
                   )
                 );
@@ -63428,7 +63428,7 @@ function createTypeChecker(host) {
     if (!length(node.properties)) return;
     for (const prop of node.properties) {
       if (isSpreadAssignment(prop)) continue;
-      const type = getLiteralTypeFromProperty(getSymbolOfDeclaration(prop), 8576 /* StringOrNumberLiteralOrUnique */);
+      const type = getLiteralTypeFromProperty(getSymbolOfDeclaration(prop), 19456 /* StringOrNumberLiteralOrUnique */);
       if (!type || type.flags & 131072 /* Never */) {
         continue;
       }
@@ -63478,7 +63478,7 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function compareSignaturesRelated(source, target, checkMode, reportErrors2, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) {
+  function compareSignaturesRelated(source, target, checkMode, reportErrors2, errorReporter, incompatibleErrorReporter, compareTypes2, reportUnreliableMarkers) {
     if (source === target) {
       return -1 /* True */;
     }
@@ -63503,7 +63503,7 @@ function createTypeChecker(host) {
         target,
         /*inferenceContext*/
         void 0,
-        compareTypes
+        compareTypes2
       );
     }
     const sourceCount = getParameterCount(source);
@@ -63519,12 +63519,12 @@ function createTypeChecker(host) {
     if (sourceThisType && sourceThisType !== voidType) {
       const targetThisType = getThisTypeOfSignature(target);
       if (targetThisType) {
-        const related = !strictVariance && compareTypes(
+        const related = !strictVariance && compareTypes2(
           sourceThisType,
           targetThisType,
           /*reportErrors*/
           false
-        ) || compareTypes(targetThisType, sourceThisType, reportErrors2);
+        ) || compareTypes2(targetThisType, sourceThisType, reportErrors2);
         if (!related) {
           if (reportErrors2) {
             errorReporter(Diagnostics.The_this_types_of_each_signature_are_incompatible);
@@ -63543,13 +63543,13 @@ function createTypeChecker(host) {
         const sourceSig = checkMode & 3 /* Callback */ || isInstantiatedGenericParameter(source, i) ? void 0 : getSingleCallSignature(getNonNullableType(sourceType));
         const targetSig = checkMode & 3 /* Callback */ || isInstantiatedGenericParameter(target, i) ? void 0 : getSingleCallSignature(getNonNullableType(targetType));
         const callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) && getTypeFacts(sourceType, 50331648 /* IsUndefinedOrNull */) === getTypeFacts(targetType, 50331648 /* IsUndefinedOrNull */);
-        let related = callbacks ? compareSignaturesRelated(targetSig, sourceSig, checkMode & 8 /* StrictArity */ | (strictVariance ? 2 /* StrictCallback */ : 1 /* BivariantCallback */), reportErrors2, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) : !(checkMode & 3 /* Callback */) && !strictVariance && compareTypes(
+        let related = callbacks ? compareSignaturesRelated(targetSig, sourceSig, checkMode & 8 /* StrictArity */ | (strictVariance ? 2 /* StrictCallback */ : 1 /* BivariantCallback */), reportErrors2, errorReporter, incompatibleErrorReporter, compareTypes2, reportUnreliableMarkers) : !(checkMode & 3 /* Callback */) && !strictVariance && compareTypes2(
           sourceType,
           targetType,
           /*reportErrors*/
           false
-        ) || compareTypes(targetType, sourceType, reportErrors2);
-        if (related && checkMode & 8 /* StrictArity */ && i >= getMinArgumentCount(source) && i < getMinArgumentCount(target) && compareTypes(
+        ) || compareTypes2(targetType, sourceType, reportErrors2);
+        if (related && checkMode & 8 /* StrictArity */ && i >= getMinArgumentCount(source) && i < getMinArgumentCount(target) && compareTypes2(
           sourceType,
           targetType,
           /*reportErrors*/
@@ -63576,7 +63576,7 @@ function createTypeChecker(host) {
       if (targetTypePredicate) {
         const sourceTypePredicate = getTypePredicateOfSignature(source);
         if (sourceTypePredicate) {
-          result &= compareTypePredicateRelatedTo(sourceTypePredicate, targetTypePredicate, reportErrors2, errorReporter, compareTypes);
+          result &= compareTypePredicateRelatedTo(sourceTypePredicate, targetTypePredicate, reportErrors2, errorReporter, compareTypes2);
         } else if (isIdentifierTypePredicate(targetTypePredicate) || isThisTypePredicate(targetTypePredicate)) {
           if (reportErrors2) {
             errorReporter(Diagnostics.Signature_0_must_be_a_type_predicate, signatureToString(source));
@@ -63584,12 +63584,12 @@ function createTypeChecker(host) {
           return 0 /* False */;
         }
       } else {
-        result &= checkMode & 1 /* BivariantCallback */ && compareTypes(
+        result &= checkMode & 1 /* BivariantCallback */ && compareTypes2(
           targetReturnType,
           sourceReturnType,
           /*reportErrors*/
           false
-        ) || compareTypes(sourceReturnType, targetReturnType, reportErrors2);
+        ) || compareTypes2(sourceReturnType, targetReturnType, reportErrors2);
         if (!result && reportErrors2 && incompatibleErrorReporter) {
           incompatibleErrorReporter(sourceReturnType, targetReturnType);
         }
@@ -63597,7 +63597,7 @@ function createTypeChecker(host) {
     }
     return result;
   }
-  function compareTypePredicateRelatedTo(source, target, reportErrors2, errorReporter, compareTypes) {
+  function compareTypePredicateRelatedTo(source, target, reportErrors2, errorReporter, compareTypes2) {
     if (source.kind !== target.kind) {
       if (reportErrors2) {
         errorReporter(Diagnostics.A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard);
@@ -63614,7 +63614,7 @@ function createTypeChecker(host) {
         return 0 /* False */;
       }
     }
-    const related = source.type === target.type ? -1 /* True */ : source.type && target.type ? compareTypes(source.type, target.type, reportErrors2) : 0 /* False */;
+    const related = source.type === target.type ? -1 /* True */ : source.type && target.type ? compareTypes2(source.type, target.type, reportErrors2) : 0 /* False */;
     if (related === 0 /* False */ && reportErrors2) {
       errorReporter(Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
     }
@@ -63648,18 +63648,18 @@ function createTypeChecker(host) {
     if (strictNullChecks && type.flags & 1048576 /* Union */) {
       if (!(type.objectFlags & 33554432 /* IsUnknownLikeUnionComputed */)) {
         const types = type.types;
-        type.objectFlags |= 33554432 /* IsUnknownLikeUnionComputed */ | (types.length >= 3 && types[0].flags & 32768 /* Undefined */ && types[1].flags & 65536 /* Null */ && some(types, isEmptyAnonymousObjectType) ? 67108864 /* IsUnknownLikeUnion */ : 0);
+        type.objectFlags |= 33554432 /* IsUnknownLikeUnionComputed */ | (types.length >= 3 && types[0].flags & 4 /* Undefined */ && types[1].flags & 8 /* Null */ && some(types, isEmptyAnonymousObjectType) ? 67108864 /* IsUnknownLikeUnion */ : 0);
       }
       return !!(type.objectFlags & 67108864 /* IsUnknownLikeUnion */);
     }
     return false;
   }
   function containsUndefinedType(type) {
-    return !!((type.flags & 1048576 /* Union */ ? type.types[0] : type).flags & 32768 /* Undefined */);
+    return !!((type.flags & 1048576 /* Union */ ? type.types[0] : type).flags & 4 /* Undefined */);
   }
   function containsNonMissingUndefinedType(type) {
     const candidate = type.flags & 1048576 /* Union */ ? type.types[0] : type;
-    return !!(candidate.flags & 32768 /* Undefined */) && candidate !== missingType;
+    return !!(candidate.flags & 4 /* Undefined */) && candidate !== missingType;
   }
   function isStringIndexSignatureOnlyType(type) {
     return type.flags & 524288 /* Object */ && !isGenericMappedType(type) && getPropertiesOfType(type).length === 0 && getIndexInfosOfType(type).length === 1 && !!getIndexInfoOfType(type, stringType) || type.flags & 3145728 /* UnionOrIntersection */ && every(type.types, isStringIndexSignatureOnlyType) || false;
@@ -63730,25 +63730,25 @@ function createTypeChecker(host) {
     if (t & 1 /* Any */ || s & 131072 /* Never */ || source === wildcardType) return true;
     if (t & 2 /* Unknown */ && !(relation === strictSubtypeRelation && s & 1 /* Any */)) return true;
     if (t & 131072 /* Never */) return false;
-    if (s & 402653316 /* StringLike */ && t & 4 /* String */) return true;
-    if (s & 128 /* StringLiteral */ && s & 1024 /* EnumLiteral */ && t & 128 /* StringLiteral */ && !(t & 1024 /* EnumLiteral */) && source.value === target.value) return true;
-    if (s & 296 /* NumberLike */ && t & 8 /* Number */) return true;
-    if (s & 256 /* NumberLiteral */ && s & 1024 /* EnumLiteral */ && t & 256 /* NumberLiteral */ && !(t & 1024 /* EnumLiteral */) && source.value === target.value) return true;
-    if (s & 2112 /* BigIntLike */ && t & 64 /* BigInt */) return true;
-    if (s & 528 /* BooleanLike */ && t & 16 /* Boolean */) return true;
-    if (s & 12288 /* ESSymbolLike */ && t & 4096 /* ESSymbol */) return true;
-    if (s & 32 /* Enum */ && t & 32 /* Enum */ && source.symbol.escapedName === target.symbol.escapedName && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter)) return true;
-    if (s & 1024 /* EnumLiteral */ && t & 1024 /* EnumLiteral */) {
+    if (s & 402654240 /* StringLike */ && t & 32 /* String */) return true;
+    if (s & 1024 /* StringLiteral */ && s & 32768 /* EnumLiteral */ && t & 1024 /* StringLiteral */ && !(t & 32768 /* EnumLiteral */) && source.value === target.value) return true;
+    if (s & 67648 /* NumberLike */ && t & 64 /* Number */) return true;
+    if (s & 2048 /* NumberLiteral */ && s & 32768 /* EnumLiteral */ && t & 2048 /* NumberLiteral */ && !(t & 32768 /* EnumLiteral */) && source.value === target.value) return true;
+    if (s & 8320 /* BigIntLike */ && t & 128 /* BigInt */) return true;
+    if (s & 4352 /* BooleanLike */ && t & 256 /* Boolean */) return true;
+    if (s & 16896 /* ESSymbolLike */ && t & 512 /* ESSymbol */) return true;
+    if (s & 65536 /* Enum */ && t & 65536 /* Enum */ && source.symbol.escapedName === target.symbol.escapedName && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter)) return true;
+    if (s & 32768 /* EnumLiteral */ && t & 32768 /* EnumLiteral */) {
       if (s & 1048576 /* Union */ && t & 1048576 /* Union */ && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter)) return true;
-      if (s & 2944 /* Literal */ && t & 2944 /* Literal */ && source.value === target.value && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter)) return true;
+      if (s & 15360 /* Literal */ && t & 15360 /* Literal */ && source.value === target.value && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter)) return true;
     }
-    if (s & 32768 /* Undefined */ && (!strictNullChecks && !(t & 3145728 /* UnionOrIntersection */) || t & (32768 /* Undefined */ | 16384 /* Void */))) return true;
-    if (s & 65536 /* Null */ && (!strictNullChecks && !(t & 3145728 /* UnionOrIntersection */) || t & 65536 /* Null */)) return true;
+    if (s & 4 /* Undefined */ && (!strictNullChecks && !(t & 3145728 /* UnionOrIntersection */) || t & (4 /* Undefined */ | 16 /* Void */))) return true;
+    if (s & 8 /* Null */ && (!strictNullChecks && !(t & 3145728 /* UnionOrIntersection */) || t & 8 /* Null */)) return true;
     if (s & 524288 /* Object */ && t & 67108864 /* NonPrimitive */ && !(relation === strictSubtypeRelation && isEmptyAnonymousObjectType(source) && !(getObjectFlags(source) & 8192 /* FreshLiteral */))) return true;
     if (relation === assignableRelation || relation === comparableRelation) {
       if (s & 1 /* Any */) return true;
-      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 (s & 64 /* Number */ && (t & 65536 /* Enum */ || t & 2048 /* NumberLiteral */ && t & 32768 /* EnumLiteral */)) return true;
+      if (s & 2048 /* NumberLiteral */ && !(s & 32768 /* EnumLiteral */) && (t & 65536 /* Enum */ || t & 2048 /* NumberLiteral */ && t & 32768 /* EnumLiteral */ && source.value === target.value)) return true;
       if (isUnknownLikeUnionType(target)) return true;
     }
     return false;
@@ -63769,7 +63769,7 @@ function createTypeChecker(host) {
       }
     } else if (!((source.flags | target.flags) & (3145728 /* UnionOrIntersection */ | 8388608 /* IndexedAccess */ | 16777216 /* Conditional */ | 33554432 /* Substitution */))) {
       if (source.flags !== target.flags) return false;
-      if (source.flags & 67358815 /* Singleton */) return true;
+      if (source.flags & 67240959 /* Singleton */) return true;
     }
     if (source.flags & 524288 /* Object */ && target.flags & 524288 /* Object */) {
       const related = relation.get(getRelationKey(
@@ -63823,7 +63823,7 @@ function createTypeChecker(host) {
     let hasNullableOrEmpty = false;
     for (const t of type.types) {
       hasInstantiable || (hasInstantiable = !!(t.flags & 465829888 /* Instantiable */));
-      hasNullableOrEmpty || (hasNullableOrEmpty = !!(t.flags & 98304 /* Nullable */) || isEmptyAnonymousObjectType(t));
+      hasNullableOrEmpty || (hasNullableOrEmpty = !!(t.flags & 12 /* Nullable */) || isEmptyAnonymousObjectType(t));
       if (hasInstantiable && hasNullableOrEmpty) return true;
     }
     return false;
@@ -64093,7 +64093,7 @@ function createTypeChecker(host) {
         } else if (exactOptionalPropertyTypes && getExactOptionalUnassignableProperties(source2, target2).length) {
           message = Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties;
         } else {
-          if (source2.flags & 128 /* StringLiteral */ && target2.flags & 1048576 /* Union */) {
+          if (source2.flags & 1024 /* StringLiteral */ && target2.flags & 1048576 /* Union */) {
             const suggestedType = getSuggestedTypeForNonexistentStringLiteralType(source2, target2);
             if (suggestedType) {
               reportError(Diagnostics.Type_0_is_not_assignable_to_type_1_Did_you_mean_2, generalizedSourceType, targetType, typeToString(suggestedType));
@@ -64162,7 +64162,7 @@ function createTypeChecker(host) {
       if (source2 === target2) return -1 /* True */;
       if (relation === identityRelation) {
         if (source2.flags !== target2.flags) return 0 /* False */;
-        if (source2.flags & 67358815 /* Singleton */) return -1 /* True */;
+        if (source2.flags & 67240959 /* Singleton */) return -1 /* True */;
         traceUnionsOrIntersectionsTooLarge(source2, target2);
         return recursiveTypeRelatedTo(
           source2,
@@ -64176,10 +64176,10 @@ function createTypeChecker(host) {
       if (source2.flags & 262144 /* TypeParameter */ && getConstraintOfType(source2) === target2) {
         return -1 /* True */;
       }
-      if (source2.flags & 470302716 /* DefinitelyNonNullable */ && target2.flags & 1048576 /* Union */) {
+      if (source2.flags & 470417376 /* DefinitelyNonNullable */ && target2.flags & 1048576 /* Union */) {
         const types = target2.types;
-        const candidate = types.length === 2 && types[0].flags & 98304 /* Nullable */ ? types[1] : types.length === 3 && types[0].flags & 98304 /* Nullable */ && types[1].flags & 98304 /* Nullable */ ? types[2] : void 0;
-        if (candidate && !(candidate.flags & 98304 /* Nullable */)) {
+        const candidate = types.length === 2 && types[0].flags & 12 /* Nullable */ ? types[1] : types.length === 3 && types[0].flags & 12 /* Nullable */ && types[1].flags & 12 /* Nullable */ ? types[2] : void 0;
+        if (candidate && !(candidate.flags & 12 /* Nullable */)) {
           target2 = getNormalizedType(
             candidate,
             /*writing*/
@@ -64481,9 +64481,9 @@ function createTypeChecker(host) {
         if (containsType(targetTypes, source2)) {
           return -1 /* True */;
         }
-        if (relation !== comparableRelation && getObjectFlags(target2) & 32768 /* PrimitiveUnion */ && !(source2.flags & 1024 /* EnumLiteral */) && (source2.flags & (128 /* StringLiteral */ | 512 /* BooleanLiteral */ | 2048 /* BigIntLiteral */) || (relation === subtypeRelation || relation === strictSubtypeRelation) && source2.flags & 256 /* NumberLiteral */)) {
+        if (relation !== comparableRelation && getObjectFlags(target2) & 32768 /* PrimitiveUnion */ && !(source2.flags & 32768 /* EnumLiteral */) && (source2.flags & (1024 /* StringLiteral */ | 4096 /* BooleanLiteral */ | 8192 /* BigIntLiteral */) || (relation === subtypeRelation || relation === strictSubtypeRelation) && source2.flags & 2048 /* NumberLiteral */)) {
           const alternateForm = source2 === source2.regularType ? source2.freshType : source2.regularType;
-          const primitive = source2.flags & 128 /* StringLiteral */ ? stringType : source2.flags & 256 /* NumberLiteral */ ? numberType : source2.flags & 2048 /* BigIntLiteral */ ? bigintType : void 0;
+          const primitive = source2.flags & 1024 /* StringLiteral */ ? stringType : source2.flags & 2048 /* NumberLiteral */ ? numberType : source2.flags & 8192 /* BigIntLiteral */ ? bigintType : void 0;
           return primitive && containsType(targetTypes, primitive) || alternateForm && containsType(targetTypes, alternateForm) ? -1 /* True */ : 0 /* False */;
         }
         const match = getMatchingUnionConstituentForType(target2, source2);
@@ -64578,8 +64578,8 @@ function createTypeChecker(host) {
       return 0 /* False */;
     }
     function getUndefinedStrippedTargetIfNeeded(source2, target2) {
-      if (source2.flags & 1048576 /* Union */ && target2.flags & 1048576 /* Union */ && !(source2.types[0].flags & 32768 /* Undefined */) && target2.types[0].flags & 32768 /* Undefined */) {
-        return extractTypesOfKind(target2, ~32768 /* Undefined */);
+      if (source2.flags & 1048576 /* Union */ && target2.flags & 1048576 /* Union */ && !(source2.types[0].flags & 4 /* Undefined */) && target2.types[0].flags & 4 /* Undefined */) {
+        return extractTypesOfKind(target2, ~4 /* Undefined */);
       }
       return target2;
     }
@@ -64921,7 +64921,7 @@ function createTypeChecker(host) {
       const mappedKeys = [];
       forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(
         modifiersType,
-        8576 /* StringOrNumberLiteralOrUnique */,
+        19456 /* StringOrNumberLiteralOrUnique */,
         /*stringsOnly*/
         false,
         (t) => void mappedKeys.push(instantiateType(nameType, appendTypeMapping(targetType.mapper, getTypeParameterFromMappedType(targetType), t)))
@@ -65180,7 +65180,7 @@ function createTypeChecker(host) {
             if (includeOptional ? !(filteredByApplicability.flags & 131072 /* Never */) : isRelatedTo(targetKeys, sourceKeys, 3 /* Both */)) {
               const templateType2 = getTemplateTypeFromMappedType(target2);
               const typeParameter = getTypeParameterFromMappedType(target2);
-              const nonNullComponent = extractTypesOfKind(templateType2, ~98304 /* Nullable */);
+              const nonNullComponent = extractTypesOfKind(templateType2, ~12 /* Nullable */);
               if (!keysRemapped && nonNullComponent.flags & 8388608 /* IndexedAccess */ && nonNullComponent.indexType === typeParameter) {
                 if (result2 = isRelatedTo(source2, nonNullComponent.objectType, 2 /* Target */, reportErrors2)) {
                   return result2;
@@ -65841,7 +65841,7 @@ function createTypeChecker(host) {
         for (const sourceProp of excludeProperties(getPropertiesOfType(source2), excludedProperties)) {
           if (!getPropertyOfObjectType(target2, sourceProp.escapedName)) {
             const sourceType = getTypeOfSymbol(sourceProp);
-            if (!(sourceType.flags & 32768 /* Undefined */)) {
+            if (!(sourceType.flags & 4 /* Undefined */)) {
               if (reportErrors2) {
                 reportError(Diagnostics.Property_0_does_not_exist_on_type_1, symbolToString(sourceProp), typeToString(target2));
               }
@@ -66069,9 +66069,9 @@ function createTypeChecker(host) {
         if (isIgnoredJsxProperty(source2, prop)) {
           continue;
         }
-        if (isApplicableIndexType(getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */), keyType)) {
+        if (isApplicableIndexType(getLiteralTypeFromProperty(prop, 19456 /* StringOrNumberLiteralOrUnique */), keyType)) {
           const propType = getNonMissingTypeOfSymbol(prop);
-          const type = exactOptionalPropertyTypes || propType.flags & 32768 /* Undefined */ || keyType === numberType || !(prop.flags & 16777216 /* Optional */) ? propType : getTypeWithFacts(propType, 524288 /* NEUndefined */);
+          const type = exactOptionalPropertyTypes || propType.flags & 4 /* Undefined */ || keyType === numberType || !(prop.flags & 16777216 /* Optional */) ? propType : getTypeWithFacts(propType, 524288 /* NEUndefined */);
           const related = isRelatedTo(
             type,
             targetInfo.type,
@@ -66185,7 +66185,7 @@ function createTypeChecker(host) {
     }
   }
   function typeCouldHaveTopLevelSingletonTypes(type) {
-    if (type.flags & 16 /* Boolean */) {
+    if (type.flags & 256 /* Boolean */) {
       return false;
     }
     if (type.flags & 3145728 /* UnionOrIntersection */) {
@@ -66204,7 +66204,7 @@ function createTypeChecker(host) {
     return getPropertiesOfType(target).filter((targetProp) => isExactOptionalPropertyMismatch(getTypeOfPropertyOfType(source, targetProp.escapedName), getTypeOfSymbol(targetProp)));
   }
   function isExactOptionalPropertyMismatch(source, target) {
-    return !!source && !!target && maybeTypeOfKind(source, 32768 /* Undefined */) && !!containsMissingType(target);
+    return !!source && !!target && maybeTypeOfKind(source, 4 /* Undefined */) && !!containsMissingType(target);
   }
   function getExactOptionalProperties(type) {
     return getPropertiesOfType(type).filter((targetProp) => containsMissingType(getTypeOfSymbol(targetProp)));
@@ -66330,7 +66330,7 @@ function createTypeChecker(host) {
   }
   function hasCovariantVoidArgument(typeArguments, variances) {
     for (let i = 0; i < variances.length; i++) {
-      if ((variances[i] & 7 /* VarianceMask */) === 1 /* Covariant */ && typeArguments[i].flags & 16384 /* Void */) {
+      if ((variances[i] & 7 /* VarianceMask */) === 1 /* Covariant */ && typeArguments[i].flags & 16 /* Void */) {
         return true;
       }
     }
@@ -66487,7 +66487,7 @@ function createTypeChecker(host) {
   function isPropertyIdenticalTo(sourceProp, targetProp) {
     return compareProperties(sourceProp, targetProp, compareTypesIdentical) !== 0 /* False */;
   }
-  function compareProperties(sourceProp, targetProp, compareTypes) {
+  function compareProperties(sourceProp, targetProp, compareTypes2) {
     if (sourceProp === targetProp) {
       return -1 /* True */;
     }
@@ -66508,7 +66508,7 @@ function createTypeChecker(host) {
     if (isReadonlySymbol(sourceProp) !== isReadonlySymbol(targetProp)) {
       return 0 /* False */;
     }
-    return compareTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
+    return compareTypes2(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
   }
   function isMatchingSignature(source, target, partialMatch) {
     const sourceParameterCount = getParameterCount(source);
@@ -66525,7 +66525,7 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function compareSignaturesIdentical(source, target, partialMatch, ignoreThisTypes, ignoreReturnTypes, compareTypes) {
+  function compareSignaturesIdentical(source, target, partialMatch, ignoreThisTypes, ignoreReturnTypes, compareTypes2) {
     if (source === target) {
       return -1 /* True */;
     }
@@ -66540,7 +66540,7 @@ function createTypeChecker(host) {
       for (let i = 0; i < target.typeParameters.length; i++) {
         const s = source.typeParameters[i];
         const t = target.typeParameters[i];
-        if (!(s === t || compareTypes(instantiateType(getConstraintFromTypeParameter(s), mapper) || unknownType, getConstraintFromTypeParameter(t) || unknownType) && compareTypes(instantiateType(getDefaultFromTypeParameter(s), mapper) || unknownType, getDefaultFromTypeParameter(t) || unknownType))) {
+        if (!(s === t || compareTypes2(instantiateType(getConstraintFromTypeParameter(s), mapper) || unknownType, getConstraintFromTypeParameter(t) || unknownType) && compareTypes2(instantiateType(getDefaultFromTypeParameter(s), mapper) || unknownType, getDefaultFromTypeParameter(t) || unknownType))) {
           return 0 /* False */;
         }
       }
@@ -66557,7 +66557,7 @@ function createTypeChecker(host) {
       if (sourceThisType) {
         const targetThisType = getThisTypeOfSignature(target);
         if (targetThisType) {
-          const related = compareTypes(sourceThisType, targetThisType);
+          const related = compareTypes2(sourceThisType, targetThisType);
           if (!related) {
             return 0 /* False */;
           }
@@ -66569,7 +66569,7 @@ function createTypeChecker(host) {
     for (let i = 0; i < targetLen; i++) {
       const s = getTypeAtPosition(source, i);
       const t = getTypeAtPosition(target, i);
-      const related = compareTypes(t, s);
+      const related = compareTypes2(t, s);
       if (!related) {
         return 0 /* False */;
       }
@@ -66578,12 +66578,12 @@ function createTypeChecker(host) {
     if (!ignoreReturnTypes) {
       const sourceTypePredicate = getTypePredicateOfSignature(source);
       const targetTypePredicate = getTypePredicateOfSignature(target);
-      result &= sourceTypePredicate || targetTypePredicate ? compareTypePredicatesIdentical(sourceTypePredicate, targetTypePredicate, compareTypes) : compareTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target));
+      result &= sourceTypePredicate || targetTypePredicate ? compareTypePredicatesIdentical(sourceTypePredicate, targetTypePredicate, compareTypes2) : compareTypes2(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target));
     }
     return result;
   }
-  function compareTypePredicatesIdentical(source, target, compareTypes) {
-    return !(source && target && typePredicateKindsMatch(source, target)) ? 0 /* False */ : source.type === target.type ? -1 /* True */ : source.type && target.type ? compareTypes(source.type, target.type) : 0 /* False */;
+  function compareTypePredicatesIdentical(source, target, compareTypes2) {
+    return !(source && target && typePredicateKindsMatch(source, target)) ? 0 /* False */ : source.type === target.type ? -1 /* True */ : source.type && target.type ? compareTypes2(source.type, target.type) : 0 /* False */;
   }
   function literalTypesWithSameBaseType(types) {
     let commonBaseType;
@@ -66605,9 +66605,9 @@ function createTypeChecker(host) {
     if (types.length === 1) {
       return types[0];
     }
-    const primaryTypes = strictNullChecks ? sameMap(types, (t) => filterType(t, (u) => !(u.flags & 98304 /* Nullable */))) : types;
+    const primaryTypes = strictNullChecks ? sameMap(types, (t) => filterType(t, (u) => !(u.flags & 12 /* Nullable */))) : types;
     const superTypeOrUnion = literalTypesWithSameBaseType(primaryTypes) ? getUnionType(primaryTypes) : reduceLeft(primaryTypes, (s, t) => isTypeSubtypeOf(s, t) ? t : s);
-    return primaryTypes === types ? superTypeOrUnion : getNullableType(superTypeOrUnion, getCombinedTypeFlags(types) & 98304 /* Nullable */);
+    return primaryTypes === types ? superTypeOrUnion : getNullableType(superTypeOrUnion, getCombinedTypeFlags(types) & 12 /* Nullable */);
   }
   function getCommonSubtype(types) {
     return reduceLeft(types, (s, t) => isTypeSubtypeOf(t, s) ? t : s);
@@ -66628,10 +66628,10 @@ function createTypeChecker(host) {
     return isArrayType(type) ? getTypeArguments(type)[0] : void 0;
   }
   function isArrayLikeType(type) {
-    return isArrayType(type) || !(type.flags & 98304 /* Nullable */) && isTypeAssignableTo(type, anyReadonlyArrayType);
+    return isArrayType(type) || !(type.flags & 12 /* Nullable */) && isTypeAssignableTo(type, anyReadonlyArrayType);
   }
   function isMutableArrayLikeType(type) {
-    return isMutableArrayOrTuple(type) || !(type.flags & (1 /* Any */ | 98304 /* Nullable */)) && isTypeAssignableTo(type, anyArrayType);
+    return isMutableArrayOrTuple(type) || !(type.flags & (1 /* Any */ | 12 /* Nullable */)) && isTypeAssignableTo(type, anyArrayType);
   }
   function getSingleBaseForNonAugmentingSubtype(type) {
     if (!(getObjectFlags(type) & 4 /* Reference */) || !(getObjectFlags(type.target) & 3 /* ClassOrInterface */)) {
@@ -66671,7 +66671,7 @@ function createTypeChecker(host) {
   }
   function isTupleLikeType(type) {
     let lengthType;
-    return isTupleType(type) || !!getPropertyOfType(type, "0") || isArrayLikeType(type) && !!(lengthType = getTypeOfPropertyOfType(type, "length")) && everyType(lengthType, (t) => !!(t.flags & 256 /* NumberLiteral */));
+    return isTupleType(type) || !!getPropertyOfType(type, "0") || isArrayLikeType(type) && !!(lengthType = getTypeOfPropertyOfType(type, "length")) && everyType(lengthType, (t) => !!(t.flags & 2048 /* NumberLiteral */));
   }
   function isArrayOrTupleLikeType(type) {
     return isArrayLikeType(type) || isTupleLikeType(type);
@@ -66687,10 +66687,10 @@ function createTypeChecker(host) {
     return void 0;
   }
   function isNeitherUnitTypeNorNever(type) {
-    return !(type.flags & (109472 /* Unit */ | 131072 /* Never */));
+    return !(type.flags & (97292 /* Unit */ | 131072 /* Never */));
   }
   function isUnitType(type) {
-    return !!(type.flags & 109472 /* Unit */);
+    return !!(type.flags & 97292 /* Unit */);
   }
   function isUnitLikeType(type) {
     const t = getBaseConstraintOrType(type);
@@ -66700,23 +66700,23 @@ function createTypeChecker(host) {
     return type.flags & 2097152 /* Intersection */ ? find(type.types, isUnitType) || type : type;
   }
   function isLiteralType(type) {
-    return type.flags & 16 /* Boolean */ ? true : type.flags & 1048576 /* Union */ ? type.flags & 1024 /* EnumLiteral */ ? true : every(type.types, isUnitType) : isUnitType(type);
+    return type.flags & 256 /* Boolean */ ? true : type.flags & 1048576 /* Union */ ? type.flags & 32768 /* EnumLiteral */ ? true : every(type.types, isUnitType) : isUnitType(type);
   }
   function getBaseTypeOfLiteralType(type) {
-    return type.flags & 1056 /* EnumLike */ ? getBaseTypeOfEnumLikeType(type) : type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ? stringType : type.flags & 256 /* NumberLiteral */ ? numberType : type.flags & 2048 /* BigIntLiteral */ ? bigintType : type.flags & 512 /* BooleanLiteral */ ? booleanType : type.flags & 1048576 /* Union */ ? getBaseTypeOfLiteralTypeUnion(type) : type;
+    return type.flags & 98304 /* EnumLike */ ? getBaseTypeOfEnumLikeType(type) : type.flags & (1024 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ? stringType : type.flags & 2048 /* NumberLiteral */ ? numberType : type.flags & 8192 /* BigIntLiteral */ ? bigintType : type.flags & 4096 /* BooleanLiteral */ ? booleanType : type.flags & 1048576 /* Union */ ? getBaseTypeOfLiteralTypeUnion(type) : type;
   }
   function getBaseTypeOfLiteralTypeUnion(type) {
     const key = `B${getTypeId(type)}`;
     return getCachedType(key) ?? setCachedType(key, mapType(type, getBaseTypeOfLiteralType));
   }
   function getBaseTypeOfLiteralTypeForComparison(type) {
-    return type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ? stringType : type.flags & (256 /* NumberLiteral */ | 32 /* Enum */) ? numberType : type.flags & 2048 /* BigIntLiteral */ ? bigintType : type.flags & 512 /* BooleanLiteral */ ? booleanType : type.flags & 1048576 /* Union */ ? mapType(type, getBaseTypeOfLiteralTypeForComparison) : type;
+    return type.flags & (1024 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ? stringType : type.flags & (2048 /* NumberLiteral */ | 65536 /* Enum */) ? numberType : type.flags & 8192 /* BigIntLiteral */ ? bigintType : type.flags & 4096 /* BooleanLiteral */ ? booleanType : type.flags & 1048576 /* Union */ ? mapType(type, getBaseTypeOfLiteralTypeForComparison) : type;
   }
   function getWidenedLiteralType(type) {
-    return type.flags & 1056 /* EnumLike */ && isFreshLiteralType(type) ? getBaseTypeOfEnumLikeType(type) : type.flags & 128 /* StringLiteral */ && isFreshLiteralType(type) ? stringType : type.flags & 256 /* NumberLiteral */ && isFreshLiteralType(type) ? numberType : type.flags & 2048 /* BigIntLiteral */ && isFreshLiteralType(type) ? bigintType : type.flags & 512 /* BooleanLiteral */ && isFreshLiteralType(type) ? booleanType : type.flags & 1048576 /* Union */ ? mapType(type, getWidenedLiteralType) : type;
+    return type.flags & 98304 /* EnumLike */ && isFreshLiteralType(type) ? getBaseTypeOfEnumLikeType(type) : type.flags & 1024 /* StringLiteral */ && isFreshLiteralType(type) ? stringType : type.flags & 2048 /* NumberLiteral */ && isFreshLiteralType(type) ? numberType : type.flags & 8192 /* BigIntLiteral */ && isFreshLiteralType(type) ? bigintType : type.flags & 4096 /* BooleanLiteral */ && isFreshLiteralType(type) ? booleanType : type.flags & 1048576 /* Union */ ? mapType(type, getWidenedLiteralType) : type;
   }
   function getWidenedUniqueESSymbolType(type) {
-    return type.flags & 8192 /* UniqueESSymbol */ ? esSymbolType : type.flags & 1048576 /* Union */ ? mapType(type, getWidenedUniqueESSymbolType) : type;
+    return type.flags & 16384 /* UniqueESSymbol */ ? esSymbolType : type.flags & 1048576 /* Union */ ? mapType(type, getWidenedUniqueESSymbolType) : type;
   }
   function getWidenedLiteralLikeTypeForContextualType(type, contextualType) {
     if (!isLiteralOfContextualType(type, contextualType)) {
@@ -66793,11 +66793,11 @@ function createTypeChecker(host) {
     return mapType(type, getDefinitelyFalsyPartOfType);
   }
   function getDefinitelyFalsyPartOfType(type) {
-    return type.flags & 4 /* String */ ? emptyStringType : type.flags & 8 /* Number */ ? zeroType : type.flags & 64 /* BigInt */ ? zeroBigIntType : type === regularFalseType || type === falseType || type.flags & (16384 /* Void */ | 32768 /* Undefined */ | 65536 /* Null */ | 3 /* AnyOrUnknown */) || type.flags & 128 /* StringLiteral */ && type.value === "" || type.flags & 256 /* NumberLiteral */ && type.value === 0 || type.flags & 2048 /* BigIntLiteral */ && isZeroBigInt(type) ? type : neverType;
+    return type.flags & 32 /* String */ ? emptyStringType : type.flags & 64 /* Number */ ? zeroType : type.flags & 128 /* BigInt */ ? zeroBigIntType : type === regularFalseType || type === falseType || type.flags & (16 /* Void */ | 4 /* Undefined */ | 8 /* Null */ | 3 /* AnyOrUnknown */) || type.flags & 1024 /* StringLiteral */ && type.value === "" || type.flags & 2048 /* NumberLiteral */ && type.value === 0 || type.flags & 8192 /* BigIntLiteral */ && isZeroBigInt(type) ? type : neverType;
   }
   function getNullableType(type, flags) {
-    const missing = flags & ~type.flags & (32768 /* Undefined */ | 65536 /* Null */);
-    return missing === 0 ? type : missing === 32768 /* Undefined */ ? getUnionType([type, undefinedType]) : missing === 65536 /* Null */ ? getUnionType([type, nullType]) : getUnionType([type, undefinedType, nullType]);
+    const missing = flags & ~type.flags & (4 /* Undefined */ | 8 /* Null */);
+    return missing === 0 ? type : missing === 4 /* Undefined */ ? getUnionType([type, undefinedType]) : missing === 8 /* Null */ ? getUnionType([type, nullType]) : getUnionType([type, undefinedType, nullType]);
   }
   function getOptionalType(type, isProperty = false) {
     Debug.assert(strictNullChecks);
@@ -66840,7 +66840,7 @@ function createTypeChecker(host) {
     return exactOptionalPropertyTypes ? removeType(type, missingType) : getTypeWithFacts(type, 524288 /* NEUndefined */);
   }
   function isCoercibleUnderDoubleEquals(source, target) {
-    return (source.flags & (8 /* Number */ | 4 /* String */ | 512 /* BooleanLiteral */)) !== 0 && (target.flags & (8 /* Number */ | 4 /* String */ | 16 /* Boolean */)) !== 0;
+    return (source.flags & (64 /* Number */ | 32 /* String */ | 4096 /* BooleanLiteral */)) !== 0 && (target.flags & (64 /* Number */ | 32 /* String */ | 256 /* Boolean */)) !== 0;
   }
   function isObjectTypeWithInferableIndex(type) {
     const objectFlags = getObjectFlags(type);
@@ -66973,7 +66973,7 @@ function createTypeChecker(host) {
         return type.widened;
       }
       let result;
-      if (type.flags & (1 /* Any */ | 98304 /* Nullable */)) {
+      if (type.flags & (1 /* Any */ | 12 /* Nullable */)) {
         result = anyType;
       } else if (isObjectLiteralType(type)) {
         result = getWidenedTypeOfObjectLiteral(type, context);
@@ -66985,7 +66985,7 @@ function createTypeChecker(host) {
           void 0,
           type.types
         );
-        const widenedTypes = sameMap(type.types, (t) => t.flags & 98304 /* Nullable */ ? t : getWidenedTypeWithContext(t, unionContext));
+        const widenedTypes = sameMap(type.types, (t) => t.flags & 12 /* Nullable */ ? t : getWidenedTypeWithContext(t, unionContext));
         result = getUnionType(widenedTypes, some(widenedTypes, isEmptyObjectType) ? 2 /* Subtype */ : 1 /* Literal */);
       } else if (type.flags & 2097152 /* Intersection */) {
         result = getIntersectionType(sameMap(type.types, getWidenedType));
@@ -67185,18 +67185,18 @@ function createTypeChecker(host) {
       callback(getReturnTypeOfSignature(source), targetReturnType);
     }
   }
-  function createInferenceContext(typeParameters, signature, flags, compareTypes) {
-    return createInferenceContextWorker(typeParameters.map(createInferenceInfo), signature, flags, compareTypes || compareTypesAssignable);
+  function createInferenceContext(typeParameters, signature, flags, compareTypes2) {
+    return createInferenceContextWorker(typeParameters.map(createInferenceInfo), signature, flags, compareTypes2 || compareTypesAssignable);
   }
   function cloneInferenceContext(context, extraFlags = 0) {
     return context && createInferenceContextWorker(map(context.inferences, cloneInferenceInfo), context.signature, context.flags | extraFlags, context.compareTypes);
   }
-  function createInferenceContextWorker(inferences, signature, flags, compareTypes) {
+  function createInferenceContextWorker(inferences, signature, flags, compareTypes2) {
     const context = {
       inferences,
       signature,
       flags,
-      compareTypes,
+      compareTypes: compareTypes2,
       mapper: reportUnmeasurableMapper,
       // initialize to a noop mapper so the context object is available, but the underlying object shape is right upon construction
       nonFixingMapper: reportUnmeasurableMapper
@@ -67283,8 +67283,8 @@ function createTypeChecker(host) {
     if (objectFlags & 524288 /* CouldContainTypeVariablesComputed */) {
       return !!(objectFlags & 1048576 /* CouldContainTypeVariables */);
     }
-    const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 134217728 /* SingleSignatureType */ && !!length(type.outerTypeParameters) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
-    if (type.flags & 3899393 /* ObjectFlagsType */) {
+    const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 134217728 /* SingleSignatureType */ && !!length(type.outerTypeParameters) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 32768 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
+    if (type.flags & 3801101 /* ObjectFlagsType */) {
       type.objectFlags |= 524288 /* CouldContainTypeVariablesComputed */ | (result ? 1048576 /* CouldContainTypeVariables */ : 0);
     }
     return result;
@@ -67306,7 +67306,7 @@ function createTypeChecker(host) {
   function createEmptyObjectTypeFromStringLiteral(type) {
     const members = createSymbolTable();
     forEachType(type, (t) => {
-      if (!(t.flags & 128 /* StringLiteral */)) {
+      if (!(t.flags & 1024 /* StringLiteral */)) {
         return;
       }
       const name = escapeLeadingUnderscores(t.value);
@@ -67318,7 +67318,7 @@ function createTypeChecker(host) {
       }
       members.set(name, literalProp);
     });
-    const indexInfos = type.flags & 4 /* String */ ? [createIndexInfo(
+    const indexInfos = type.flags & 32 /* String */ ? [createIndexInfo(
       stringType,
       emptyObjectType,
       /*isReadonly*/
@@ -67420,7 +67420,7 @@ function createTypeChecker(host) {
           yield targetProp;
         } else if (matchDiscriminantProperties) {
           const targetType = getTypeOfSymbol(targetProp);
-          if (targetType.flags & 109472 /* Unit */) {
+          if (targetType.flags & 97292 /* Unit */) {
             const sourceType = getTypeOfSymbol(sourceProp);
             if (!(sourceType.flags & 1 /* Any */ || getRegularTypeOfLiteralType(sourceType) === getRegularTypeOfLiteralType(targetType))) {
               yield targetProp;
@@ -67483,7 +67483,7 @@ function createTypeChecker(host) {
     if (target.flags & 1 /* Any */) {
       return true;
     }
-    if (target.flags & (4 /* String */ | 134217728 /* TemplateLiteral */)) {
+    if (target.flags & (32 /* String */ | 134217728 /* TemplateLiteral */)) {
       return isTypeAssignableTo(source, target);
     }
     if (target.flags & 268435456 /* StringMapping */) {
@@ -67501,20 +67501,20 @@ function createTypeChecker(host) {
     if (target.flags & 2097152 /* Intersection */) {
       return every(target.types, (t) => t === emptyTypeLiteralType || isValidTypeForTemplateLiteralPlaceholder(source, t));
     }
-    if (target.flags & 4 /* String */ || isTypeAssignableTo(source, target)) {
+    if (target.flags & 32 /* String */ || isTypeAssignableTo(source, target)) {
       return true;
     }
-    if (source.flags & 128 /* StringLiteral */) {
+    if (source.flags & 1024 /* StringLiteral */) {
       const value = source.value;
-      return !!(target.flags & 8 /* Number */ && isValidNumberString(
+      return !!(target.flags & 64 /* Number */ && isValidNumberString(
         value,
         /*roundTripOnly*/
         false
-      ) || target.flags & 64 /* BigInt */ && isValidBigIntString(
+      ) || target.flags & 128 /* BigInt */ && isValidBigIntString(
         value,
         /*roundTripOnly*/
         false
-      ) || target.flags & (512 /* BooleanLiteral */ | 98304 /* Nullable */) && value === target.intrinsicName || target.flags & 268435456 /* StringMapping */ && isMemberOfStringMapping(source, target) || target.flags & 134217728 /* TemplateLiteral */ && isTypeMatchedByTemplateLiteralType(source, target));
+      ) || target.flags & (4096 /* BooleanLiteral */ | 12 /* Nullable */) && value === target.intrinsicName || target.flags & 268435456 /* StringMapping */ && isMemberOfStringMapping(source, target) || target.flags & 134217728 /* TemplateLiteral */ && isTypeMatchedByTemplateLiteralType(source, target));
     }
     if (source.flags & 134217728 /* TemplateLiteral */) {
       const texts = source.texts;
@@ -67523,7 +67523,7 @@ function createTypeChecker(host) {
     return false;
   }
   function inferTypesFromTemplateLiteralType(source, target) {
-    return source.flags & 128 /* StringLiteral */ ? inferFromLiteralPartsToTemplateLiteral([source.value], emptyArray, target) : source.flags & 134217728 /* TemplateLiteral */ ? arrayIsEqualTo(source.texts, target.texts) ? map(source.types, (s, i) => {
+    return source.flags & 1024 /* StringLiteral */ ? inferFromLiteralPartsToTemplateLiteral([source.value], emptyArray, target) : source.flags & 134217728 /* TemplateLiteral */ ? arrayIsEqualTo(source.texts, target.texts) ? map(source.types, (s, i) => {
       return isTypeAssignableTo(getBaseConstraintOrType(s), getBaseConstraintOrType(target.types[i])) ? s : getStringLikeTypeForType(s);
     }) : inferFromLiteralPartsToTemplateLiteral(source.texts, source.types, target) : void 0;
   }
@@ -67532,7 +67532,7 @@ function createTypeChecker(host) {
     return !!inferences && every(inferences, (r, i) => isValidTypeForTemplateLiteralPlaceholder(r, target.types[i]));
   }
   function getStringLikeTypeForType(type) {
-    return type.flags & (1 /* Any */ | 402653316 /* StringLike */) ? type : getTemplateLiteralType(["", ""], [type]);
+    return type.flags & (1 /* Any */ | 402654240 /* StringLike */) ? type : getTemplateLiteralType(["", ""], [type]);
   }
   function inferFromLiteralPartsToTemplateLiteral(sourceTexts, sourceTypes, target) {
     const lastSourceIndex = sourceTexts.length - 1;
@@ -67727,7 +67727,7 @@ function createTypeChecker(host) {
         inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target));
       } else if (source.flags & 4194304 /* Index */ && target.flags & 4194304 /* Index */) {
         inferFromContravariantTypes(source.type, target.type);
-      } else if ((isLiteralType(source) || source.flags & 4 /* String */) && target.flags & 4194304 /* Index */) {
+      } else if ((isLiteralType(source) || source.flags & 32 /* String */) && target.flags & 4194304 /* Index */) {
         const empty = createEmptyObjectTypeFromStringLiteral(source);
         inferFromContravariantTypesWithPriority(empty, target.type, 256 /* LiteralKeyof */);
       } else if (source.flags & 8388608 /* IndexedAccess */ && target.flags & 8388608 /* IndexedAccess */) {
@@ -67982,29 +67982,29 @@ function createTypeChecker(host) {
         for (let i = 0; i < types.length; i++) {
           const source2 = matches ? matches[i] : neverType;
           const target2 = types[i];
-          if (source2.flags & 128 /* StringLiteral */ && target2.flags & 8650752 /* TypeVariable */) {
+          if (source2.flags & 1024 /* StringLiteral */ && target2.flags & 8650752 /* TypeVariable */) {
             const inferenceContext = getInferenceInfoForType(target2);
             const constraint = inferenceContext ? getBaseConstraintOfType(inferenceContext.typeParameter) : void 0;
             if (constraint && !isTypeAny(constraint)) {
               const constraintTypes = constraint.flags & 1048576 /* Union */ ? constraint.types : [constraint];
               let allTypeFlags = reduceLeft(constraintTypes, (flags, t) => flags | t.flags, 0);
-              if (!(allTypeFlags & 4 /* String */)) {
+              if (!(allTypeFlags & 32 /* String */)) {
                 const str = source2.value;
-                if (allTypeFlags & 296 /* NumberLike */ && !isValidNumberString(
+                if (allTypeFlags & 67648 /* NumberLike */ && !isValidNumberString(
                   str,
                   /*roundTripOnly*/
                   true
                 )) {
-                  allTypeFlags &= ~296 /* NumberLike */;
+                  allTypeFlags &= ~67648 /* NumberLike */;
                 }
-                if (allTypeFlags & 2112 /* BigIntLike */ && !isValidBigIntString(
+                if (allTypeFlags & 8320 /* BigIntLike */ && !isValidBigIntString(
                   str,
                   /*roundTripOnly*/
                   true
                 )) {
-                  allTypeFlags &= ~2112 /* BigIntLike */;
+                  allTypeFlags &= ~8320 /* BigIntLike */;
                 }
-                const matchingType = reduceLeft(constraintTypes, (left, right) => !(right.flags & allTypeFlags) ? left : left.flags & 4 /* String */ ? left : right.flags & 4 /* String */ ? source2 : left.flags & 134217728 /* TemplateLiteral */ ? left : right.flags & 134217728 /* TemplateLiteral */ && isTypeMatchedByTemplateLiteralType(source2, right) ? source2 : left.flags & 268435456 /* StringMapping */ ? left : right.flags & 268435456 /* StringMapping */ && str === applyStringMapping(right.symbol, str) ? source2 : left.flags & 128 /* StringLiteral */ ? left : right.flags & 128 /* StringLiteral */ && right.value === str ? right : left.flags & 8 /* Number */ ? left : right.flags & 8 /* Number */ ? getNumberLiteralType(+str) : left.flags & 32 /* Enum */ ? left : right.flags & 32 /* Enum */ ? getNumberLiteralType(+str) : left.flags & 256 /* NumberLiteral */ ? left : right.flags & 256 /* NumberLiteral */ && right.value === +str ? right : left.flags & 64 /* BigInt */ ? left : right.flags & 64 /* BigInt */ ? parseBigIntLiteralType(str) : left.flags & 2048 /* BigIntLiteral */ ? left : right.flags & 2048 /* BigIntLiteral */ && pseudoBigIntToString(right.value) === str ? right : left.flags & 16 /* Boolean */ ? left : right.flags & 16 /* Boolean */ ? str === "true" ? trueType : str === "false" ? falseType : booleanType : left.flags & 512 /* BooleanLiteral */ ? left : right.flags & 512 /* BooleanLiteral */ && right.intrinsicName === str ? right : left.flags & 32768 /* Undefined */ ? left : right.flags & 32768 /* Undefined */ && right.intrinsicName === str ? right : left.flags & 65536 /* Null */ ? left : right.flags & 65536 /* Null */ && right.intrinsicName === str ? right : left, neverType);
+                const matchingType = reduceLeft(constraintTypes, (left, right) => !(right.flags & allTypeFlags) ? left : left.flags & 32 /* String */ ? left : right.flags & 32 /* String */ ? source2 : left.flags & 134217728 /* TemplateLiteral */ ? left : right.flags & 134217728 /* TemplateLiteral */ && isTypeMatchedByTemplateLiteralType(source2, right) ? source2 : left.flags & 268435456 /* StringMapping */ ? left : right.flags & 268435456 /* StringMapping */ && str === applyStringMapping(right.symbol, str) ? source2 : left.flags & 1024 /* StringLiteral */ ? left : right.flags & 1024 /* StringLiteral */ && right.value === str ? right : left.flags & 64 /* Number */ ? left : right.flags & 64 /* Number */ ? getNumberLiteralType(+str) : left.flags & 65536 /* Enum */ ? left : right.flags & 65536 /* Enum */ ? getNumberLiteralType(+str) : left.flags & 2048 /* NumberLiteral */ ? left : right.flags & 2048 /* NumberLiteral */ && right.value === +str ? right : left.flags & 128 /* BigInt */ ? left : right.flags & 128 /* BigInt */ ? parseBigIntLiteralType(str) : left.flags & 8192 /* BigIntLiteral */ ? left : right.flags & 8192 /* BigIntLiteral */ && pseudoBigIntToString(right.value) === str ? right : left.flags & 256 /* Boolean */ ? left : right.flags & 256 /* Boolean */ ? str === "true" ? trueType : str === "false" ? falseType : booleanType : left.flags & 4096 /* BooleanLiteral */ ? left : right.flags & 4096 /* BooleanLiteral */ && right.intrinsicName === str ? right : left.flags & 4 /* Undefined */ ? left : right.flags & 4 /* Undefined */ && right.intrinsicName === str ? right : left.flags & 8 /* Null */ ? left : right.flags & 8 /* Null */ && right.intrinsicName === str ? right : left, neverType);
                 if (!(matchingType.flags & 131072 /* Never */)) {
                   inferFromTypes(matchingType, target2);
                   continue;
@@ -68164,7 +68164,7 @@ function createTypeChecker(host) {
         for (const targetInfo of indexInfos) {
           const propTypes = [];
           for (const prop of getPropertiesOfType(source)) {
-            if (isApplicableIndexType(getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */), targetInfo.keyType)) {
+            if (isApplicableIndexType(getLiteralTypeFromProperty(prop, 19456 /* StringOrNumberLiteralOrUnique */), targetInfo.keyType)) {
               const propType = getTypeOfSymbol(prop);
               propTypes.push(prop.flags & 16777216 /* Optional */ ? removeMissingOrUndefinedType(propType) : propType);
             }
@@ -68188,7 +68188,7 @@ function createTypeChecker(host) {
     }
   }
   function isTypeOrBaseIdenticalTo(s, t) {
-    return t === missingType ? s === t : isTypeIdenticalTo(s, t) || !!(t.flags & 4 /* String */ && s.flags & 128 /* StringLiteral */ || t.flags & 8 /* Number */ && s.flags & 256 /* NumberLiteral */);
+    return t === missingType ? s === t : isTypeIdenticalTo(s, t) || !!(t.flags & 32 /* String */ && s.flags & 1024 /* StringLiteral */ || t.flags & 64 /* Number */ && s.flags & 2048 /* NumberLiteral */);
   }
   function isTypeCloselyMatchedBy(s, t) {
     return !!(s.flags & 524288 /* Object */ && t.flags & 524288 /* Object */ && s.symbol && s.symbol === t.symbol || s.aliasSymbol && s.aliasTypeArguments && s.aliasSymbol === t.aliasSymbol);
@@ -68440,7 +68440,7 @@ function createTypeChecker(host) {
     return void 0;
   }
   function tryGetNameFromType(type) {
-    return type.flags & 8192 /* UniqueESSymbol */ ? type.escapedName : type.flags & 384 /* StringOrNumberLiteral */ ? escapeLeadingUnderscores("" + type.value) : void 0;
+    return type.flags & 16384 /* UniqueESSymbol */ ? type.escapedName : type.flags & 3072 /* StringOrNumberLiteral */ ? escapeLeadingUnderscores("" + type.value) : void 0;
   }
   function tryGetElementAccessExpressionName(node) {
     return isStringOrNumericLiteralLike(node.argumentExpression) ? escapeLeadingUnderscores(node.argumentExpression.text) : isEntityNameExpression(node.argumentExpression) ? tryGetNameFromEntityNameExpression(node.argumentExpression) : void 0;
@@ -68619,7 +68619,7 @@ function createTypeChecker(host) {
   }
   function getAssignmentReducedTypeWorker(declaredType, assignedType) {
     const filteredType = filterType(declaredType, (t) => typeMaybeAssignableTo(assignedType, t));
-    const reducedType = assignedType.flags & 512 /* BooleanLiteral */ && isFreshLiteralType(assignedType) ? mapType(filteredType, getFreshTypeOfLiteralType) : filteredType;
+    const reducedType = assignedType.flags & 4096 /* BooleanLiteral */ && isFreshLiteralType(assignedType) ? mapType(filteredType, getFreshTypeOfLiteralType) : filteredType;
     return isTypeAssignableTo(assignedType, reducedType) ? reducedType : declaredType;
   }
   function isFunctionObjectType(type) {
@@ -68640,31 +68640,31 @@ function createTypeChecker(host) {
       type = getBaseConstraintOfType(type) || unknownType;
     }
     const flags = type.flags;
-    if (flags & (4 /* String */ | 268435456 /* StringMapping */)) {
+    if (flags & (32 /* String */ | 268435456 /* StringMapping */)) {
       return strictNullChecks ? 16317953 /* StringStrictFacts */ : 16776705 /* StringFacts */;
     }
-    if (flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */)) {
-      const isEmpty = flags & 128 /* StringLiteral */ && type.value === "";
+    if (flags & (1024 /* StringLiteral */ | 134217728 /* TemplateLiteral */)) {
+      const isEmpty = flags & 1024 /* StringLiteral */ && type.value === "";
       return strictNullChecks ? isEmpty ? 12123649 /* EmptyStringStrictFacts */ : 7929345 /* NonEmptyStringStrictFacts */ : isEmpty ? 12582401 /* EmptyStringFacts */ : 16776705 /* NonEmptyStringFacts */;
     }
-    if (flags & (8 /* Number */ | 32 /* Enum */)) {
+    if (flags & (64 /* Number */ | 65536 /* Enum */)) {
       return strictNullChecks ? 16317698 /* NumberStrictFacts */ : 16776450 /* NumberFacts */;
     }
-    if (flags & 256 /* NumberLiteral */) {
+    if (flags & 2048 /* NumberLiteral */) {
       const isZero = type.value === 0;
       return strictNullChecks ? isZero ? 12123394 /* ZeroNumberStrictFacts */ : 7929090 /* NonZeroNumberStrictFacts */ : isZero ? 12582146 /* ZeroNumberFacts */ : 16776450 /* NonZeroNumberFacts */;
     }
-    if (flags & 64 /* BigInt */) {
+    if (flags & 128 /* BigInt */) {
       return strictNullChecks ? 16317188 /* BigIntStrictFacts */ : 16775940 /* BigIntFacts */;
     }
-    if (flags & 2048 /* BigIntLiteral */) {
+    if (flags & 8192 /* BigIntLiteral */) {
       const isZero = isZeroBigInt(type);
       return strictNullChecks ? isZero ? 12122884 /* ZeroBigIntStrictFacts */ : 7928580 /* NonZeroBigIntStrictFacts */ : isZero ? 12581636 /* ZeroBigIntFacts */ : 16775940 /* NonZeroBigIntFacts */;
     }
-    if (flags & 16 /* Boolean */) {
+    if (flags & 256 /* Boolean */) {
       return strictNullChecks ? 16316168 /* BooleanStrictFacts */ : 16774920 /* BooleanFacts */;
     }
-    if (flags & 528 /* BooleanLike */) {
+    if (flags & 4352 /* BooleanLike */) {
       return strictNullChecks ? type === falseType || type === regularFalseType ? 12121864 /* FalseStrictFacts */ : 7927560 /* TrueStrictFacts */ : type === falseType || type === regularFalseType ? 12580616 /* FalseFacts */ : 16774920 /* TrueFacts */;
     }
     if (flags & 524288 /* Object */) {
@@ -68674,16 +68674,16 @@ function createTypeChecker(host) {
       }
       return getObjectFlags(type) & 16 /* Anonymous */ && isEmptyObjectType(type) ? strictNullChecks ? 83427327 /* EmptyObjectStrictFacts */ : 83886079 /* EmptyObjectFacts */ : isFunctionObjectType(type) ? strictNullChecks ? 7880640 /* FunctionStrictFacts */ : 16728e3 /* FunctionFacts */ : strictNullChecks ? 7888800 /* ObjectStrictFacts */ : 16736160 /* ObjectFacts */;
     }
-    if (flags & 16384 /* Void */) {
+    if (flags & 16 /* Void */) {
       return 9830144 /* VoidFacts */;
     }
-    if (flags & 32768 /* Undefined */) {
+    if (flags & 4 /* Undefined */) {
       return 26607360 /* UndefinedFacts */;
     }
-    if (flags & 65536 /* Null */) {
+    if (flags & 8 /* Null */) {
       return 42917664 /* NullFacts */;
     }
-    if (flags & 12288 /* ESSymbolLike */) {
+    if (flags & 16896 /* ESSymbolLike */) {
       return strictNullChecks ? 7925520 /* SymbolStrictFacts */ : 16772880 /* SymbolFacts */;
     }
     if (flags & 67108864 /* NonPrimitive */) {
@@ -68906,7 +68906,7 @@ function createTypeChecker(host) {
       }
       return true;
     }
-    if (source.flags & 1056 /* EnumLike */ && getBaseTypeOfEnumLikeType(source) === target) {
+    if (source.flags & 98304 /* EnumLike */ && getBaseTypeOfEnumLikeType(source) === target) {
       return true;
     }
     return containsType(target.types, source);
@@ -68991,8 +68991,8 @@ function createTypeChecker(host) {
     return filterType(type, (t) => (t.flags & kind) !== 0);
   }
   function replacePrimitivesWithLiterals(typeWithPrimitives, typeWithLiterals) {
-    if (maybeTypeOfKind(typeWithPrimitives, 4 /* String */ | 134217728 /* TemplateLiteral */ | 8 /* Number */ | 64 /* BigInt */) && maybeTypeOfKind(typeWithLiterals, 128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */ | 256 /* NumberLiteral */ | 2048 /* BigIntLiteral */)) {
-      return mapType(typeWithPrimitives, (t) => t.flags & 4 /* String */ ? extractTypesOfKind(typeWithLiterals, 4 /* String */ | 128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) : isPatternLiteralType(t) && !maybeTypeOfKind(typeWithLiterals, 4 /* String */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ? extractTypesOfKind(typeWithLiterals, 128 /* StringLiteral */) : t.flags & 8 /* Number */ ? extractTypesOfKind(typeWithLiterals, 8 /* Number */ | 256 /* NumberLiteral */) : t.flags & 64 /* BigInt */ ? extractTypesOfKind(typeWithLiterals, 64 /* BigInt */ | 2048 /* BigIntLiteral */) : t);
+    if (maybeTypeOfKind(typeWithPrimitives, 32 /* String */ | 134217728 /* TemplateLiteral */ | 64 /* Number */ | 128 /* BigInt */) && maybeTypeOfKind(typeWithLiterals, 1024 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */ | 2048 /* NumberLiteral */ | 8192 /* BigIntLiteral */)) {
+      return mapType(typeWithPrimitives, (t) => t.flags & 32 /* String */ ? extractTypesOfKind(typeWithLiterals, 32 /* String */ | 1024 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) : isPatternLiteralType(t) && !maybeTypeOfKind(typeWithLiterals, 32 /* String */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ? extractTypesOfKind(typeWithLiterals, 1024 /* StringLiteral */) : t.flags & 64 /* Number */ ? extractTypesOfKind(typeWithLiterals, 64 /* Number */ | 2048 /* NumberLiteral */) : t.flags & 128 /* BigInt */ ? extractTypesOfKind(typeWithLiterals, 128 /* BigInt */ | 8192 /* BigIntLiteral */) : t);
     }
     return typeWithPrimitives;
   }
@@ -69047,7 +69047,7 @@ function createTypeChecker(host) {
     const root = getReferenceRoot(node);
     const parent = root.parent;
     const isLengthPushOrUnshift = isPropertyAccessExpression(parent) && (parent.name.escapedText === "length" || parent.parent.kind === 213 /* CallExpression */ && isIdentifier(parent.name) && isPushOrUnshiftIdentifier(parent.name));
-    const isElementAssignment = parent.kind === 212 /* ElementAccessExpression */ && parent.expression === root && parent.parent.kind === 226 /* BinaryExpression */ && parent.parent.operatorToken.kind === 64 /* EqualsToken */ && parent.parent.left === parent && !isAssignmentTarget(parent.parent) && isTypeAssignableToKind(getTypeOfExpression(parent.argumentExpression), 296 /* NumberLike */);
+    const isElementAssignment = parent.kind === 212 /* ElementAccessExpression */ && parent.expression === root && parent.parent.kind === 226 /* BinaryExpression */ && parent.parent.operatorToken.kind === 64 /* EqualsToken */ && parent.parent.left === parent && !isAssignmentTarget(parent.parent) && isTypeAssignableToKind(getTypeOfExpression(parent.argumentExpression), 67648 /* NumberLike */);
     return isLengthPushOrUnshift || isElementAssignment;
   }
   function isDeclarationWithExplicitTypeAnnotation(node) {
@@ -69535,7 +69535,7 @@ function createTypeChecker(host) {
               }
             } else {
               const indexType = getContextFreeTypeOfExpression(node.left.argumentExpression);
-              if (isTypeAssignableToKind(indexType, 296 /* NumberLike */)) {
+              if (isTypeAssignableToKind(indexType, 67648 /* NumberLike */)) {
                 evolvedType2 = addEvolvingArrayElementType(evolvedType2, node.right);
               }
             }
@@ -69573,9 +69573,9 @@ function createTypeChecker(host) {
       } else {
         if (strictNullChecks) {
           if (optionalChainContainsReference(expr, reference)) {
-            type = narrowTypeBySwitchOptionalChainContainment(type, flow.node, (t) => !(t.flags & (32768 /* Undefined */ | 131072 /* Never */)));
+            type = narrowTypeBySwitchOptionalChainContainment(type, flow.node, (t) => !(t.flags & (4 /* Undefined */ | 131072 /* Never */)));
           } else if (expr.kind === 221 /* TypeOfExpression */ && optionalChainContainsReference(expr.expression, reference)) {
-            type = narrowTypeBySwitchOptionalChainContainment(type, flow.node, (t) => !(t.flags & 131072 /* Never */ || t.flags & 128 /* StringLiteral */ && t.value === "undefined"));
+            type = narrowTypeBySwitchOptionalChainContainment(type, flow.node, (t) => !(t.flags & 131072 /* Never */ || t.flags & 1024 /* StringLiteral */ && t.value === "undefined"));
           }
         }
         const access = getDiscriminantPropertyAccess(expr, type);
@@ -69749,7 +69749,7 @@ function createTypeChecker(host) {
         return type;
       }
       const optionalChain = isOptionalChain(access);
-      const removeNullable = strictNullChecks && (optionalChain || isNonNullAccess(access)) && maybeTypeOfKind(type, 98304 /* Nullable */);
+      const removeNullable = strictNullChecks && (optionalChain || isNonNullAccess(access)) && maybeTypeOfKind(type, 12 /* Nullable */);
       let propType = getTypeOfPropertyOfType(removeNullable ? getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type, propName);
       if (!propType) {
         return type;
@@ -69971,7 +69971,7 @@ function createTypeChecker(host) {
     }
     function narrowTypeByOptionalChainContainment(type, operator, value, assumeTrue) {
       const equalsOperator = operator === 35 /* EqualsEqualsToken */ || operator === 37 /* EqualsEqualsEqualsToken */;
-      const nullableFlags = operator === 35 /* EqualsEqualsToken */ || operator === 36 /* ExclamationEqualsToken */ ? 98304 /* Nullable */ : 32768 /* Undefined */;
+      const nullableFlags = operator === 35 /* EqualsEqualsToken */ || operator === 36 /* ExclamationEqualsToken */ ? 12 /* Nullable */ : 4 /* Undefined */;
       const valueType = getTypeOfExpression(value);
       const removeNullable = equalsOperator !== assumeTrue && everyType(valueType, (t) => !!(t.flags & nullableFlags)) || equalsOperator === assumeTrue && everyType(valueType, (t) => !(t.flags & (3 /* AnyOrUnknown */ | nullableFlags)));
       return removeNullable ? getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type;
@@ -69985,11 +69985,11 @@ function createTypeChecker(host) {
       }
       const valueType = getTypeOfExpression(value);
       const doubleEquals = operator === 35 /* EqualsEqualsToken */ || operator === 36 /* ExclamationEqualsToken */;
-      if (valueType.flags & 98304 /* Nullable */) {
+      if (valueType.flags & 12 /* Nullable */) {
         if (!strictNullChecks) {
           return type;
         }
-        const facts = doubleEquals ? assumeTrue ? 262144 /* EQUndefinedOrNull */ : 2097152 /* NEUndefinedOrNull */ : valueType.flags & 65536 /* Null */ ? assumeTrue ? 131072 /* EQNull */ : 1048576 /* NENull */ : assumeTrue ? 65536 /* EQUndefined */ : 524288 /* NEUndefined */;
+        const facts = doubleEquals ? assumeTrue ? 262144 /* EQUndefinedOrNull */ : 2097152 /* NEUndefinedOrNull */ : valueType.flags & 8 /* Null */ ? assumeTrue ? 131072 /* EQNull */ : 1048576 /* NENull */ : assumeTrue ? 65536 /* EQUndefined */ : 524288 /* NEUndefined */;
         return getAdjustedTypeWithFacts(type, facts);
       }
       if (assumeTrue) {
@@ -70064,7 +70064,7 @@ function createTypeChecker(host) {
       if (!hasDefaultClause) {
         return caseType;
       }
-      const defaultType = filterType(type, (t) => !(isUnitLikeType(t) && contains(switchTypes, t.flags & 32768 /* Undefined */ ? undefinedType : getRegularTypeOfLiteralType(extractUnitType(t)))));
+      const defaultType = filterType(type, (t) => !(isUnitLikeType(t) && contains(switchTypes, t.flags & 4 /* Undefined */ ? undefinedType : getRegularTypeOfLiteralType(extractUnitType(t)))));
       return caseType.flags & 131072 /* Never */ ? defaultType : getUnionType([caseType, defaultType]);
     }
     function narrowTypeByTypeName(type, typeName) {
@@ -70555,10 +70555,10 @@ function createTypeChecker(host) {
     return parent.kind === 211 /* PropertyAccessExpression */ || parent.kind === 166 /* QualifiedName */ || parent.kind === 213 /* CallExpression */ && parent.expression === node || parent.kind === 214 /* NewExpression */ && parent.expression === node || parent.kind === 212 /* ElementAccessExpression */ && parent.expression === node && !(someType(type, isGenericTypeWithoutNullableConstraint) && isGenericIndexType(getTypeOfExpression(parent.argumentExpression)));
   }
   function isGenericTypeWithUnionConstraint(type) {
-    return type.flags & 2097152 /* Intersection */ ? some(type.types, isGenericTypeWithUnionConstraint) : !!(type.flags & 465829888 /* Instantiable */ && getBaseConstraintOrType(type).flags & (98304 /* Nullable */ | 1048576 /* Union */));
+    return type.flags & 2097152 /* Intersection */ ? some(type.types, isGenericTypeWithUnionConstraint) : !!(type.flags & 465829888 /* Instantiable */ && getBaseConstraintOrType(type).flags & (12 /* Nullable */ | 1048576 /* Union */));
   }
   function isGenericTypeWithoutNullableConstraint(type) {
-    return type.flags & 2097152 /* Intersection */ ? some(type.types, isGenericTypeWithoutNullableConstraint) : !!(type.flags & 465829888 /* Instantiable */ && !maybeTypeOfKind(getBaseConstraintOrType(type), 98304 /* Nullable */));
+    return type.flags & 2097152 /* Intersection */ ? some(type.types, isGenericTypeWithoutNullableConstraint) : !!(type.flags & 465829888 /* Instantiable */ && !maybeTypeOfKind(getBaseConstraintOrType(type), 12 /* Nullable */));
   }
   function hasContextualTypeWithNoGenericTypes(node, checkMode) {
     const contextualType = (isIdentifier(node) || isPropertyAccessExpression(node) || isElementAccessExpression(node)) && !((isJsxOpeningElement(node.parent) || isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) && (checkMode && checkMode & 32 /* RestBindingElement */ ? getContextualType(node, 8 /* SkipBindingPatterns */) : getContextualType(
@@ -71117,7 +71117,7 @@ function createTypeChecker(host) {
       flowContainer = getControlFlowContainer(flowContainer);
     }
     const isNeverInitialized = immediateDeclaration && isVariableDeclaration(immediateDeclaration) && !immediateDeclaration.initializer && !immediateDeclaration.exclamationToken && isMutableLocalVariableDeclaration(immediateDeclaration) && !isSymbolAssignedDefinitely(symbol);
-    const assumeInitialized = isParameter2 || isAlias || isOuterVariable && !isNeverInitialized || isSpreadDestructuringAssignmentTarget || isModuleExports || isSameScopedBindingElement(node, declaration) || type !== autoType && type !== autoArrayType && (!strictNullChecks || (type.flags & (3 /* AnyOrUnknown */ | 16384 /* Void */)) !== 0 || isInTypeQuery(node) || isInAmbientOrTypeNode(node) || node.parent.kind === 281 /* ExportSpecifier */) || node.parent.kind === 235 /* NonNullExpression */ || declaration.kind === 260 /* VariableDeclaration */ && declaration.exclamationToken || declaration.flags & 33554432 /* Ambient */;
+    const assumeInitialized = isParameter2 || isAlias || isOuterVariable && !isNeverInitialized || isSpreadDestructuringAssignmentTarget || isModuleExports || isSameScopedBindingElement(node, declaration) || type !== autoType && type !== autoArrayType && (!strictNullChecks || (type.flags & (3 /* AnyOrUnknown */ | 16 /* Void */)) !== 0 || isInTypeQuery(node) || isInAmbientOrTypeNode(node) || node.parent.kind === 281 /* ExportSpecifier */) || node.parent.kind === 235 /* NonNullExpression */ || declaration.kind === 260 /* VariableDeclaration */ && declaration.exclamationToken || declaration.flags & 33554432 /* Ambient */;
     const initialType = isAutomaticTypeInNonNull ? undefinedType : assumeInitialized ? isParameter2 ? removeOptionalityFromDeclaredType(type, declaration) : type : typeIsAutomatic ? undefinedType : getOptionalType(type);
     const flowType = isAutomaticTypeInNonNull ? getNonNullableType(getFlowTypeOfReference(node, type, initialType, flowContainer)) : getFlowTypeOfReference(node, type, initialType, flowContainer);
     if (!isEvolvingArrayOperationTarget(node) && (type === autoType || type === autoArrayType)) {
@@ -71805,7 +71805,7 @@ function createTypeChecker(host) {
       const functionFlags = getFunctionFlags(functionDecl);
       if (functionFlags & 1 /* Generator */) {
         return filterType(returnType2, (t) => {
-          return !!(t.flags & (3 /* AnyOrUnknown */ | 16384 /* Void */ | 58982400 /* InstantiableNonPrimitive */)) || checkGeneratorInstantiationAssignabilityToReturnType(
+          return !!(t.flags & (3 /* AnyOrUnknown */ | 16 /* Void */ | 58982400 /* InstantiableNonPrimitive */)) || checkGeneratorInstantiationAssignabilityToReturnType(
             t,
             functionFlags,
             /*errorNode*/
@@ -71815,7 +71815,7 @@ function createTypeChecker(host) {
       }
       if (functionFlags & 2 /* Async */) {
         return filterType(returnType2, (t) => {
-          return !!(t.flags & (3 /* AnyOrUnknown */ | 16384 /* Void */ | 58982400 /* InstantiableNonPrimitive */)) || !!getAwaitedTypeOfPromise(t);
+          return !!(t.flags & (3 /* AnyOrUnknown */ | 16 /* Void */ | 58982400 /* InstantiableNonPrimitive */)) || !!getAwaitedTypeOfPromise(t);
         });
       }
       return returnType2;
@@ -72574,7 +72574,7 @@ function createTypeChecker(host) {
       return getOrCreateTypeFromSignature(fakeSignature);
     }
     const tagType = checkExpressionCached(context.tagName);
-    if (tagType.flags & 128 /* StringLiteral */) {
+    if (tagType.flags & 1024 /* StringLiteral */) {
       const result = getIntrinsicAttributesTypeFromStringLiteralType(tagType, context);
       if (!result) {
         return errorType;
@@ -72946,7 +72946,7 @@ function createTypeChecker(host) {
     }
   }
   function isNumericComputedName(name) {
-    return isTypeAssignableToKind(checkComputedPropertyName(name), 296 /* NumberLike */);
+    return isTypeAssignableToKind(checkComputedPropertyName(name), 67648 /* NumberLike */);
   }
   function checkComputedPropertyName(node) {
     const links = getNodeLinks(node.expression);
@@ -72964,7 +72964,7 @@ function createTypeChecker(host) {
           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)) {
+      if (links.resolvedType.flags & 12 /* Nullable */ || !isTypeAssignableToKind(links.resolvedType, 402654240 /* StringLike */ | 67648 /* NumberLike */ | 16896 /* ESSymbolLike */) && !isTypeAssignableTo(links.resolvedType, stringNumberSymbolType)) {
         error(node, Diagnostics.A_computed_property_name_must_be_of_type_string_number_symbol_or_any);
       }
     }
@@ -72978,7 +72978,7 @@ function createTypeChecker(host) {
   function isSymbolWithSymbolName(symbol) {
     var _a;
     const firstDecl = (_a = symbol.declarations) == null ? void 0 : _a[0];
-    return isKnownSymbol(symbol) || firstDecl && isNamedDeclaration(firstDecl) && isComputedPropertyName(firstDecl.name) && isTypeAssignableToKind(checkComputedPropertyName(firstDecl.name), 4096 /* ESSymbol */);
+    return isKnownSymbol(symbol) || firstDecl && isNamedDeclaration(firstDecl) && isComputedPropertyName(firstDecl.name) && isTypeAssignableToKind(checkComputedPropertyName(firstDecl.name), 512 /* ESSymbol */);
   }
   function isSymbolWithComputedName(symbol) {
     var _a;
@@ -73134,7 +73134,7 @@ function createTypeChecker(host) {
         Debug.assert(memberDecl.kind === 177 /* GetAccessor */ || memberDecl.kind === 178 /* SetAccessor */);
         checkNodeDeferred(memberDecl);
       }
-      if (computedNameType && !(computedNameType.flags & 8576 /* StringOrNumberLiteralOrUnique */)) {
+      if (computedNameType && !(computedNameType.flags & 19456 /* StringOrNumberLiteralOrUnique */)) {
         if (isTypeAssignableTo(computedNameType, stringNumberSymbolType)) {
           if (isTypeAssignableTo(computedNameType, numberType)) {
             hasComputedNumberProperty = true;
@@ -73547,9 +73547,9 @@ function createTypeChecker(host) {
     return getNameFromJsxElementAttributesContainer(JsxNames.ElementChildrenAttributeNameContainer, jsxNamespace);
   }
   function getUninstantiatedJsxSignaturesOfType(elementType, caller) {
-    if (elementType.flags & 4 /* String */) {
+    if (elementType.flags & 32 /* String */) {
       return [anySignature];
-    } else if (elementType.flags & 128 /* StringLiteral */) {
+    } else if (elementType.flags & 1024 /* StringLiteral */) {
       const intrinsicType = getIntrinsicAttributesTypeFromStringLiteralType(elementType, caller);
       if (!intrinsicType) {
         error(caller, Diagnostics.Property_0_does_not_exist_on_type_1, elementType.value, "JSX." + JsxNames.IntrinsicElements);
@@ -73931,7 +73931,7 @@ function createTypeChecker(host) {
     if (facts & 50331648 /* IsUndefinedOrNull */) {
       reportError(node, facts);
       const t = getNonNullableType(type);
-      return t.flags & (98304 /* Nullable */ | 131072 /* Never */) ? errorType : t;
+      return t.flags & (12 /* Nullable */ | 131072 /* Never */) ? errorType : t;
     }
     return type;
   }
@@ -73940,7 +73940,7 @@ function createTypeChecker(host) {
   }
   function checkNonNullNonVoidType(type, node) {
     const nonNullType = checkNonNullType(type, node);
-    if (nonNullType.flags & 16384 /* Void */) {
+    if (nonNullType.flags & 16 /* Void */) {
       if (isEntityNameExpression(node)) {
         const nodeText = entityNameToString(node);
         if (isIdentifier(node) && nodeText === "undefined") {
@@ -74487,7 +74487,7 @@ function createTypeChecker(host) {
     return suggestion;
   }
   function getSuggestedTypeForNonexistentStringLiteralType(source, target) {
-    const candidates = target.types.filter((type) => !!(type.flags & 128 /* StringLiteral */));
+    const candidates = target.types.filter((type) => !!(type.flags & 1024 /* StringLiteral */));
     return getSpellingSuggestion(source.value, candidates, (type) => type.value);
   }
   function getSpellingSuggestionForName(name, symbols, meaning) {
@@ -74719,10 +74719,10 @@ function createTypeChecker(host) {
     return findIndex(args, isSpreadArgument);
   }
   function acceptsVoid(t) {
-    return !!(t.flags & 16384 /* Void */);
+    return !!(t.flags & 16 /* Void */);
   }
   function acceptsVoidUndefinedUnknownOrAny(t) {
-    return !!(t.flags & (16384 /* Void */ | 32768 /* Undefined */ | 2 /* Unknown */ | 1 /* Any */));
+    return !!(t.flags & (16 /* Void */ | 4 /* Undefined */ | 2 /* Unknown */ | 1 /* Any */));
   }
   function hasCorrectArity(node, args, signature, signatureHelpTrailingComma = false) {
     if (isJsxOpeningFragment(node)) return true;
@@ -74821,8 +74821,8 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function instantiateSignatureInContextOf(signature, contextualSignature, inferenceContext, compareTypes) {
-    const context = createInferenceContext(getTypeParametersForMapper(signature), signature, 0 /* None */, compareTypes);
+  function instantiateSignatureInContextOf(signature, contextualSignature, inferenceContext, compareTypes2) {
+    const context = createInferenceContext(getTypeParametersForMapper(signature), signature, 0 /* None */, compareTypes2);
     const restType = getEffectiveRestType(contextualSignature);
     const mapper = inferenceContext && (restType && restType.flags & 262144 /* TypeParameter */ ? inferenceContext.nonFixingMapper : inferenceContext.mapper);
     const sourceSignature = mapper ? instantiateSignature(contextualSignature, mapper) : contextualSignature;
@@ -76557,10 +76557,10 @@ function createTypeChecker(host) {
       return resolveExternalModuleTypeByLiteral(node.arguments[0]);
     }
     const returnType = getReturnTypeOfSignature(signature);
-    if (returnType.flags & 12288 /* ESSymbolLike */ && isSymbolOrSymbolForCall(node)) {
+    if (returnType.flags & 16896 /* ESSymbolLike */ && isSymbolOrSymbolForCall(node)) {
       return getESSymbolLikeTypeForNode(walkUpParenthesizedExpressions(node.parent));
     }
-    if (node.kind === 213 /* CallExpression */ && !node.questionDotToken && node.parent.kind === 244 /* ExpressionStatement */ && returnType.flags & 16384 /* Void */ && getTypePredicateOfSignature(signature)) {
+    if (node.kind === 213 /* CallExpression */ && !node.questionDotToken && node.parent.kind === 244 /* ExpressionStatement */ && returnType.flags & 16 /* Void */ && getTypePredicateOfSignature(signature)) {
       if (!isDottedName(node.expression)) {
         error(node.expression, Diagnostics.Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name);
       } else if (!getEffectsSignature(node)) {
@@ -76650,7 +76650,7 @@ function createTypeChecker(host) {
     for (let i = 2; i < node.arguments.length; ++i) {
       checkExpressionCached(node.arguments[i]);
     }
-    if (specifierType.flags & 32768 /* Undefined */ || specifierType.flags & 65536 /* Null */ || !isTypeAssignableTo(specifierType, stringType)) {
+    if (specifierType.flags & 4 /* Undefined */ || specifierType.flags & 8 /* Null */ || !isTypeAssignableTo(specifierType, stringType)) {
       error(specifier, Diagnostics.Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0, typeToString(specifierType));
     }
     if (optionsType) {
@@ -76659,7 +76659,7 @@ function createTypeChecker(host) {
         true
       );
       if (importCallOptionsType !== emptyObjectType) {
-        checkTypeAssignableTo(optionsType, getNullableType(importCallOptionsType, 32768 /* Undefined */), node.arguments[1]);
+        checkTypeAssignableTo(optionsType, getNullableType(importCallOptionsType, 4 /* Undefined */), node.arguments[1]);
       }
     }
     const moduleSymbol = resolveExternalModuleName(node, specifier);
@@ -77705,7 +77705,7 @@ function createTypeChecker(host) {
           /*contextFlags*/
           void 0
         );
-        const returnType2 = contextualReturnType && (unwrapReturnType(contextualReturnType, functionFlags) || voidType).flags & 32768 /* Undefined */ ? undefinedType : voidType;
+        const returnType2 = contextualReturnType && (unwrapReturnType(contextualReturnType, functionFlags) || voidType).flags & 4 /* Undefined */ ? undefinedType : voidType;
         return functionFlags & 2 /* Async */ ? createPromiseReturnType(func, returnType2) : (
           // Async function
           returnType2
@@ -77951,10 +77951,10 @@ function createTypeChecker(host) {
       true
     );
     const returnType = checkExpressionCached(expr);
-    if (!(returnType.flags & 16 /* Boolean */)) return void 0;
+    if (!(returnType.flags & 256 /* Boolean */)) return void 0;
     return forEach(func.parameters, (param, i) => {
       const initType = getTypeOfSymbol(param.symbol);
-      if (!initType || initType.flags & 16 /* Boolean */ || !isIdentifier(param.name) || isSymbolAssigned(param.symbol) || isRestParameter(param)) {
+      if (!initType || initType.flags & 256 /* Boolean */ || !isIdentifier(param.name) || isSymbolAssigned(param.symbol) || isRestParameter(param)) {
         return;
       }
       const trueType2 = checkIfExpressionRefinesParameter(func, expr, param, initType);
@@ -77984,7 +77984,7 @@ function createTypeChecker(host) {
     function checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics() {
       const functionFlags = getFunctionFlags(func);
       const type = returnType && unwrapReturnType(returnType, functionFlags);
-      if (type && (maybeTypeOfKind(type, 16384 /* Void */) || type.flags & (1 /* Any */ | 32768 /* Undefined */))) {
+      if (type && (maybeTypeOfKind(type, 16 /* Void */) || type.flags & (1 /* Any */ | 4 /* Undefined */))) {
         return;
       }
       if (func.kind === 173 /* MethodSignature */ || nodeIsMissing(func.body) || func.body.kind !== 241 /* Block */ || !functionHasImplicitReturn(func)) {
@@ -78356,11 +78356,11 @@ function createTypeChecker(host) {
       case 41 /* MinusToken */:
       case 55 /* TildeToken */:
         checkNonNullType(operandType, node.operand);
-        if (maybeTypeOfKindConsideringBaseConstraint(operandType, 12288 /* ESSymbolLike */)) {
+        if (maybeTypeOfKindConsideringBaseConstraint(operandType, 16896 /* ESSymbolLike */)) {
           error(node.operand, Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, tokenToString(node.operator));
         }
         if (node.operator === 40 /* PlusToken */) {
-          if (maybeTypeOfKindConsideringBaseConstraint(operandType, 2112 /* BigIntLike */)) {
+          if (maybeTypeOfKindConsideringBaseConstraint(operandType, 8320 /* BigIntLike */)) {
             error(node.operand, Diagnostics.Operator_0_cannot_be_applied_to_type_1, tokenToString(node.operator), typeToString(getBaseTypeOfLiteralType(operandType)));
           }
           return numberType;
@@ -78404,8 +78404,8 @@ function createTypeChecker(host) {
     return getUnaryResultType(operandType);
   }
   function getUnaryResultType(operandType) {
-    if (maybeTypeOfKind(operandType, 2112 /* BigIntLike */)) {
-      return isTypeAssignableToKind(operandType, 3 /* AnyOrUnknown */) || maybeTypeOfKind(operandType, 296 /* NumberLike */) ? numberOrBigIntType : bigintType;
+    if (maybeTypeOfKind(operandType, 8320 /* BigIntLike */)) {
+      return isTypeAssignableToKind(operandType, 3 /* AnyOrUnknown */) || maybeTypeOfKind(operandType, 67648 /* NumberLike */) ? numberOrBigIntType : bigintType;
     }
     return numberType;
   }
@@ -78434,10 +78434,10 @@ function createTypeChecker(host) {
     if (source.flags & kind) {
       return true;
     }
-    if (strict && source.flags & (3 /* AnyOrUnknown */ | 16384 /* Void */ | 32768 /* Undefined */ | 65536 /* Null */)) {
+    if (strict && source.flags & (3 /* AnyOrUnknown */ | 16 /* Void */ | 4 /* Undefined */ | 8 /* Null */)) {
       return false;
     }
-    return !!(kind & 296 /* NumberLike */) && isTypeAssignableTo(source, numberType) || !!(kind & 2112 /* BigIntLike */) && isTypeAssignableTo(source, bigintType) || !!(kind & 402653316 /* StringLike */) && isTypeAssignableTo(source, stringType) || !!(kind & 528 /* BooleanLike */) && isTypeAssignableTo(source, booleanType) || !!(kind & 16384 /* Void */) && isTypeAssignableTo(source, voidType) || !!(kind & 131072 /* Never */) && isTypeAssignableTo(source, neverType) || !!(kind & 65536 /* Null */) && isTypeAssignableTo(source, nullType) || !!(kind & 32768 /* Undefined */) && isTypeAssignableTo(source, undefinedType) || !!(kind & 4096 /* ESSymbol */) && isTypeAssignableTo(source, esSymbolType) || !!(kind & 67108864 /* NonPrimitive */) && isTypeAssignableTo(source, nonPrimitiveType);
+    return !!(kind & 67648 /* NumberLike */) && isTypeAssignableTo(source, numberType) || !!(kind & 8320 /* BigIntLike */) && isTypeAssignableTo(source, bigintType) || !!(kind & 402654240 /* StringLike */) && isTypeAssignableTo(source, stringType) || !!(kind & 4352 /* BooleanLike */) && isTypeAssignableTo(source, booleanType) || !!(kind & 16 /* Void */) && isTypeAssignableTo(source, voidType) || !!(kind & 131072 /* Never */) && isTypeAssignableTo(source, neverType) || !!(kind & 8 /* Null */) && isTypeAssignableTo(source, nullType) || !!(kind & 4 /* Undefined */) && isTypeAssignableTo(source, undefinedType) || !!(kind & 512 /* ESSymbol */) && isTypeAssignableTo(source, esSymbolType) || !!(kind & 67108864 /* NonPrimitive */) && isTypeAssignableTo(source, nonPrimitiveType);
   }
   function allTypesAssignableToKind(source, kind, strict) {
     return source.flags & 1048576 /* Union */ ? every(source.types, (subType) => allTypesAssignableToKind(subType, kind, strict)) : isTypeAssignableToKind(source, kind, strict);
@@ -78710,7 +78710,7 @@ function createTypeChecker(host) {
     }
   }
   function isTypeEqualityComparableTo(source, target) {
-    return (target.flags & 98304 /* Nullable */) !== 0 || isTypeComparableTo(source, target);
+    return (target.flags & 12 /* Nullable */) !== 0 || isTypeComparableTo(source, target);
   }
   function createCheckBinaryExpression() {
     const trampoline = createBinaryExpressionTrampoline(onEnter, onLeft, onOperator, onRight, onExit, foldState);
@@ -78961,7 +78961,7 @@ function createTypeChecker(host) {
         leftType = checkNonNullType(leftType, left);
         rightType = checkNonNullType(rightType, right);
         let suggestedOperator;
-        if (leftType.flags & 528 /* BooleanLike */ && rightType.flags & 528 /* BooleanLike */ && (suggestedOperator = getSuggestedBooleanOperator(operatorToken.kind)) !== void 0) {
+        if (leftType.flags & 4352 /* BooleanLike */ && rightType.flags & 4352 /* BooleanLike */ && (suggestedOperator = getSuggestedBooleanOperator(operatorToken.kind)) !== void 0) {
           error(errorNode || operatorToken, Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, tokenToString(operatorToken.kind), tokenToString(suggestedOperator));
           return numberType;
         } else {
@@ -78981,7 +78981,7 @@ function createTypeChecker(host) {
           );
           let resultType2;
           if (isTypeAssignableToKind(leftType, 3 /* AnyOrUnknown */) && isTypeAssignableToKind(rightType, 3 /* AnyOrUnknown */) || // Or, if neither could be bigint, implicit coercion results in a number result
-          !(maybeTypeOfKind(leftType, 2112 /* BigIntLike */) || maybeTypeOfKind(rightType, 2112 /* BigIntLike */))) {
+          !(maybeTypeOfKind(leftType, 8320 /* BigIntLike */) || maybeTypeOfKind(rightType, 8320 /* BigIntLike */))) {
             resultType2 = numberType;
           } else if (bothAreBigIntLike(leftType, rightType)) {
             switch (operator) {
@@ -79033,43 +79033,43 @@ function createTypeChecker(host) {
         if (leftType === silentNeverType || rightType === silentNeverType) {
           return silentNeverType;
         }
-        if (!isTypeAssignableToKind(leftType, 402653316 /* StringLike */) && !isTypeAssignableToKind(rightType, 402653316 /* StringLike */)) {
+        if (!isTypeAssignableToKind(leftType, 402654240 /* StringLike */) && !isTypeAssignableToKind(rightType, 402654240 /* StringLike */)) {
           leftType = checkNonNullType(leftType, left);
           rightType = checkNonNullType(rightType, right);
         }
         let resultType;
         if (isTypeAssignableToKind(
           leftType,
-          296 /* NumberLike */,
+          67648 /* NumberLike */,
           /*strict*/
           true
         ) && isTypeAssignableToKind(
           rightType,
-          296 /* NumberLike */,
+          67648 /* NumberLike */,
           /*strict*/
           true
         )) {
           resultType = numberType;
         } else if (isTypeAssignableToKind(
           leftType,
-          2112 /* BigIntLike */,
+          8320 /* BigIntLike */,
           /*strict*/
           true
         ) && isTypeAssignableToKind(
           rightType,
-          2112 /* BigIntLike */,
+          8320 /* BigIntLike */,
           /*strict*/
           true
         )) {
           resultType = bigintType;
         } else if (isTypeAssignableToKind(
           leftType,
-          402653316 /* StringLike */,
+          402654240 /* StringLike */,
           /*strict*/
           true
         ) || isTypeAssignableToKind(
           rightType,
-          402653316 /* StringLike */,
+          402654240 /* StringLike */,
           /*strict*/
           true
         )) {
@@ -79081,7 +79081,7 @@ function createTypeChecker(host) {
           return resultType;
         }
         if (!resultType) {
-          const closeEnoughKind = 296 /* NumberLike */ | 2112 /* BigIntLike */ | 402653316 /* StringLike */ | 3 /* AnyOrUnknown */;
+          const closeEnoughKind = 67648 /* NumberLike */ | 8320 /* BigIntLike */ | 402654240 /* StringLike */ | 3 /* AnyOrUnknown */;
           reportOperatorError(
             (left2, right2) => isTypeAssignableToKind(left2, closeEnoughKind) && isTypeAssignableToKind(right2, closeEnoughKind)
           );
@@ -79178,7 +79178,7 @@ function createTypeChecker(host) {
         return Debug.fail();
     }
     function bothAreBigIntLike(left2, right2) {
-      return isTypeAssignableToKind(left2, 2112 /* BigIntLike */) && isTypeAssignableToKind(right2, 2112 /* BigIntLike */);
+      return isTypeAssignableToKind(left2, 8320 /* BigIntLike */) && isTypeAssignableToKind(right2, 8320 /* BigIntLike */);
     }
     function checkAssignmentDeclaration(kind, rightType2) {
       if (kind === 2 /* ModuleExports */) {
@@ -79208,7 +79208,7 @@ function createTypeChecker(host) {
       (isAccessExpression(node.right) || isIdentifier(node.right) && node.right.escapedText === "eval");
     }
     function checkForDisallowedESSymbolOperand(operator2) {
-      const offendingSymbolOperand = maybeTypeOfKindConsideringBaseConstraint(leftType, 12288 /* ESSymbolLike */) ? left : maybeTypeOfKindConsideringBaseConstraint(rightType, 12288 /* ESSymbolLike */) ? right : void 0;
+      const offendingSymbolOperand = maybeTypeOfKindConsideringBaseConstraint(leftType, 16896 /* ESSymbolLike */) ? left : maybeTypeOfKindConsideringBaseConstraint(rightType, 16896 /* ESSymbolLike */) ? right : void 0;
       if (offendingSymbolOperand) {
         error(offendingSymbolOperand, Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, tokenToString(operator2));
         return false;
@@ -79247,7 +79247,7 @@ function createTypeChecker(host) {
         }
         if (checkReferenceExpression(left, Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access, Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access)) {
           let headMessage;
-          if (exactOptionalPropertyTypes && isPropertyAccessExpression(left) && maybeTypeOfKind(valueType, 32768 /* Undefined */)) {
+          if (exactOptionalPropertyTypes && isPropertyAccessExpression(left) && maybeTypeOfKind(valueType, 4 /* Undefined */)) {
             const target = getTypeOfPropertyOfType(getTypeOfExpression(left.expression), left.name.escapedText);
             if (isExactOptionalPropertyMismatch(valueType, target)) {
               headMessage = Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target;
@@ -79436,7 +79436,7 @@ function createTypeChecker(host) {
     const types = [];
     for (const span of node.templateSpans) {
       const type = checkExpression(span.expression);
-      if (maybeTypeOfKindConsideringBaseConstraint(type, 12288 /* ESSymbolLike */)) {
+      if (maybeTypeOfKindConsideringBaseConstraint(type, 16896 /* ESSymbolLike */)) {
         error(span.expression, Diagnostics.Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String);
       }
       texts.push(span.literal.text);
@@ -79456,7 +79456,7 @@ function createTypeChecker(host) {
     return stringType;
   }
   function isTemplateLiteralContextualType(type) {
-    return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* StringLike */));
+    return !!(type.flags & (1024 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402654240 /* StringLike */));
   }
   function getContextNode(node) {
     if (isJsxAttributes(node) && !isJsxSelfClosingElement(node.parent)) {
@@ -79477,7 +79477,7 @@ function createTypeChecker(host) {
     if (inferenceContext && inferenceContext.intraExpressionInferenceSites) {
       inferenceContext.intraExpressionInferenceSites = void 0;
     }
-    const result = maybeTypeOfKind(type, 2944 /* Literal */) && isLiteralOfContextualType(type, instantiateContextualType(
+    const result = maybeTypeOfKind(type, 15360 /* Literal */) && isLiteralOfContextualType(type, instantiateContextualType(
       contextualType,
       node,
       /*contextFlags*/
@@ -79621,9 +79621,9 @@ function createTypeChecker(host) {
       }
       if (contextualType.flags & 58982400 /* InstantiableNonPrimitive */) {
         const constraint = getBaseConstraintOfType(contextualType) || unknownType;
-        return maybeTypeOfKind(constraint, 4 /* String */) && maybeTypeOfKind(candidateType, 128 /* StringLiteral */) || maybeTypeOfKind(constraint, 8 /* Number */) && maybeTypeOfKind(candidateType, 256 /* NumberLiteral */) || maybeTypeOfKind(constraint, 64 /* BigInt */) && maybeTypeOfKind(candidateType, 2048 /* BigIntLiteral */) || maybeTypeOfKind(constraint, 4096 /* ESSymbol */) && maybeTypeOfKind(candidateType, 8192 /* UniqueESSymbol */) || isLiteralOfContextualType(candidateType, constraint);
+        return maybeTypeOfKind(constraint, 32 /* String */) && maybeTypeOfKind(candidateType, 1024 /* StringLiteral */) || maybeTypeOfKind(constraint, 64 /* Number */) && maybeTypeOfKind(candidateType, 2048 /* NumberLiteral */) || maybeTypeOfKind(constraint, 128 /* BigInt */) && maybeTypeOfKind(candidateType, 8192 /* BigIntLiteral */) || maybeTypeOfKind(constraint, 512 /* ESSymbol */) && maybeTypeOfKind(candidateType, 16384 /* UniqueESSymbol */) || isLiteralOfContextualType(candidateType, constraint);
       }
-      return !!(contextualType.flags & (128 /* StringLiteral */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && maybeTypeOfKind(candidateType, 128 /* StringLiteral */) || contextualType.flags & 256 /* NumberLiteral */ && maybeTypeOfKind(candidateType, 256 /* NumberLiteral */) || contextualType.flags & 2048 /* BigIntLiteral */ && maybeTypeOfKind(candidateType, 2048 /* BigIntLiteral */) || contextualType.flags & 512 /* BooleanLiteral */ && maybeTypeOfKind(candidateType, 512 /* BooleanLiteral */) || contextualType.flags & 8192 /* UniqueESSymbol */ && maybeTypeOfKind(candidateType, 8192 /* UniqueESSymbol */));
+      return !!(contextualType.flags & (1024 /* StringLiteral */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && maybeTypeOfKind(candidateType, 1024 /* StringLiteral */) || contextualType.flags & 2048 /* NumberLiteral */ && maybeTypeOfKind(candidateType, 2048 /* NumberLiteral */) || contextualType.flags & 8192 /* BigIntLiteral */ && maybeTypeOfKind(candidateType, 8192 /* BigIntLiteral */) || contextualType.flags & 4096 /* BooleanLiteral */ && maybeTypeOfKind(candidateType, 4096 /* BooleanLiteral */) || contextualType.flags & 16384 /* UniqueESSymbol */ && maybeTypeOfKind(candidateType, 16384 /* UniqueESSymbol */));
     }
     return false;
   }
@@ -82484,7 +82484,7 @@ function createTypeChecker(host) {
         return;
       }
       const type = location === condExpr2 ? condType : checkExpression(location);
-      if (type.flags & 1024 /* EnumLiteral */ && isPropertyAccessExpression(location) && (getNodeLinks(location.expression).resolvedSymbol ?? unknownSymbol).flags & 384 /* Enum */) {
+      if (type.flags & 32768 /* EnumLiteral */ && isPropertyAccessExpression(location) && (getNodeLinks(location.expression).resolvedSymbol ?? unknownSymbol).flags & 384 /* Enum */) {
         error(location, Diagnostics.This_condition_will_always_return_0, !!type.value ? "true" : "false");
         return;
       }
@@ -82576,7 +82576,7 @@ function createTypeChecker(host) {
     checkSourceElement(node.statement);
   }
   function checkTruthinessOfType(type, node) {
-    if (type.flags & 16384 /* Void */) {
+    if (type.flags & 16 /* Void */) {
       error(node, Diagnostics.An_expression_of_type_void_cannot_be_tested_for_truthiness);
     } else {
       const semantics = getSyntacticTruthySemantics(node);
@@ -82764,11 +82764,11 @@ function createTypeChecker(host) {
     if (use & 4 /* AllowsStringInputFlag */) {
       if (arrayType.flags & 1048576 /* Union */) {
         const arrayTypes = inputType.types;
-        const filteredTypes = filter(arrayTypes, (t) => !(t.flags & 402653316 /* StringLike */));
+        const filteredTypes = filter(arrayTypes, (t) => !(t.flags & 402654240 /* StringLike */));
         if (filteredTypes !== arrayTypes) {
           arrayType = getUnionType(filteredTypes, 2 /* Subtype */);
         }
-      } else if (arrayType.flags & 402653316 /* StringLike */) {
+      } else if (arrayType.flags & 402654240 /* StringLike */) {
         arrayType = neverType;
       }
       hasStringConstituent = arrayType !== inputType;
@@ -82793,7 +82793,7 @@ function createTypeChecker(host) {
     }
     const arrayElementType = getIndexTypeOfType(arrayType, numberType);
     if (hasStringConstituent && arrayElementType) {
-      if (arrayElementType.flags & 402653316 /* StringLike */ && !compilerOptions.noUncheckedIndexedAccess) {
+      if (arrayElementType.flags & 402654240 /* StringLike */ && !compilerOptions.noUncheckedIndexedAccess) {
         return stringType;
       }
       return getUnionType(possibleOutOfBounds ? [arrayElementType, stringType, undefinedType] : [arrayElementType, stringType], 2 /* Subtype */);
@@ -82844,7 +82844,7 @@ function createTypeChecker(host) {
     return iterationTypes && iterationTypes[getIterationTypesKeyFromIterationTypeKind(typeKind)];
   }
   function createIterationTypes(yieldType = neverType, returnType = neverType, nextType = unknownType) {
-    if (yieldType.flags & 67359327 /* Intrinsic */ && returnType.flags & (1 /* Any */ | 131072 /* Never */ | 2 /* Unknown */ | 16384 /* Void */ | 32768 /* Undefined */) && nextType.flags & (1 /* Any */ | 131072 /* Never */ | 2 /* Unknown */ | 16384 /* Void */ | 32768 /* Undefined */)) {
+    if (yieldType.flags & 67245055 /* Intrinsic */ && returnType.flags & (1 /* Any */ | 131072 /* Never */ | 2 /* Unknown */ | 16 /* Void */ | 4 /* Undefined */) && nextType.flags & (1 /* Any */ | 131072 /* Never */ | 2 /* Unknown */ | 16 /* Void */ | 4 /* Undefined */)) {
       const id = getTypeListId([yieldType, returnType, nextType]);
       let iterationTypes = iterationTypesCache.get(id);
       if (!iterationTypes) {
@@ -83340,7 +83340,7 @@ function createTypeChecker(host) {
   }
   function isUnwrappedReturnTypeUndefinedVoidOrAny(func, returnType) {
     const type = unwrapReturnType(returnType, getFunctionFlags(func));
-    return !!(type && (maybeTypeOfKind(type, 16384 /* Void */) || type.flags & (1 /* Any */ | 32768 /* Undefined */)));
+    return !!(type && (maybeTypeOfKind(type, 16 /* Void */) || type.flags & (1 /* Any */ | 4 /* Undefined */)));
   }
   function checkReturnStatement(node) {
     if (checkGrammarStatementInAmbientContext(node)) {
@@ -83537,7 +83537,7 @@ function createTypeChecker(host) {
       if (!(isStaticIndex && prop.flags & 4194304 /* Prototype */)) {
         checkIndexConstraintForProperty(type, prop, getLiteralTypeFromProperty(
           prop,
-          8576 /* StringOrNumberLiteralOrUnique */,
+          19456 /* StringOrNumberLiteralOrUnique */,
           /*includeNonPublic*/
           true
         ), getNonMissingTypeOfSymbol(prop));
@@ -85008,7 +85008,7 @@ function createTypeChecker(host) {
         true
       );
       if (importAttributesType !== emptyObjectType) {
-        checkTypeAssignableTo(getTypeFromImportAttributes(node), getNullableType(importAttributesType, 32768 /* Undefined */), node);
+        checkTypeAssignableTo(getTypeFromImportAttributes(node), getNullableType(importAttributesType, 4 /* Undefined */), node);
       }
       const validForTypeAttributes = isExclusivelyTypeOnlyImportOrExport(declaration);
       const override = getResolutionModeOverride(node, validForTypeAttributes ? grammarErrorOnNode : void 0);
@@ -86560,7 +86560,7 @@ function createTypeChecker(host) {
         return getStringLiteralType(name.text);
       case 167 /* ComputedPropertyName */:
         const nameType = checkComputedPropertyName(name);
-        return isTypeAssignableToKind(nameType, 12288 /* ESSymbolLike */) ? nameType : stringType;
+        return isTypeAssignableToKind(nameType, 16896 /* ESSymbolLike */) ? nameType : stringType;
       default:
         return Debug.fail("Unsupported property name.");
     }
@@ -87081,19 +87081,19 @@ function createTypeChecker(host) {
       return isTypeOnly ? 11 /* ObjectType */ : 0 /* Unknown */;
     } else if (type.flags & 3 /* AnyOrUnknown */) {
       return 11 /* ObjectType */;
-    } else if (isTypeAssignableToKind(type, 16384 /* Void */ | 98304 /* Nullable */ | 131072 /* Never */)) {
+    } else if (isTypeAssignableToKind(type, 16 /* Void */ | 12 /* Nullable */ | 131072 /* Never */)) {
       return 2 /* VoidNullableOrNeverType */;
-    } else if (isTypeAssignableToKind(type, 528 /* BooleanLike */)) {
+    } else if (isTypeAssignableToKind(type, 4352 /* BooleanLike */)) {
       return 6 /* BooleanType */;
-    } else if (isTypeAssignableToKind(type, 296 /* NumberLike */)) {
+    } else if (isTypeAssignableToKind(type, 67648 /* NumberLike */)) {
       return 3 /* NumberLikeType */;
-    } else if (isTypeAssignableToKind(type, 2112 /* BigIntLike */)) {
+    } else if (isTypeAssignableToKind(type, 8320 /* BigIntLike */)) {
       return 4 /* BigIntLikeType */;
-    } else if (isTypeAssignableToKind(type, 402653316 /* StringLike */)) {
+    } else if (isTypeAssignableToKind(type, 402654240 /* StringLike */)) {
       return 5 /* StringLikeType */;
     } else if (isTupleType(type)) {
       return 7 /* ArrayLikeType */;
-    } else if (isTypeAssignableToKind(type, 12288 /* ESSymbolLike */)) {
+    } else if (isTypeAssignableToKind(type, 16896 /* ESSymbolLike */)) {
       return 8 /* ESSymbolType */;
     } else if (isFunctionType(type)) {
       return 10 /* TypeWithCallSignature */;
@@ -87236,7 +87236,7 @@ function createTypeChecker(host) {
     return false;
   }
   function literalTypeToNode(type, enclosing, tracker) {
-    const enumResult = type.flags & 1056 /* EnumLike */ ? nodeBuilder.symbolToExpression(
+    const enumResult = type.flags & 98304 /* EnumLike */ ? nodeBuilder.symbolToExpression(
       type.symbol,
       111551 /* Value */,
       enclosing,
@@ -88255,7 +88255,7 @@ function createTypeChecker(host) {
       return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_must_have_a_type_annotation);
     }
     const type = getTypeFromTypeNode(parameter.type);
-    if (someType(type, (t) => !!(t.flags & 8576 /* StringOrNumberLiteralOrUnique */)) || isGenericType(type)) {
+    if (someType(type, (t) => !!(t.flags & 19456 /* StringOrNumberLiteralOrUnique */)) || isGenericType(type)) {
       return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead);
     }
     if (!everyType(type, isValidIndexKeyType)) {
@@ -88786,7 +88786,7 @@ function createTypeChecker(host) {
   }
   function isSimpleLiteralEnumReference(expr) {
     if ((isPropertyAccessExpression(expr) || isElementAccessExpression(expr) && isStringOrNumberLiteralExpression(expr.argumentExpression)) && isEntityNameExpression(expr.expression)) {
-      return !!(checkExpressionCached(expr).flags & 1056 /* EnumLike */);
+      return !!(checkExpressionCached(expr).flags & 98304 /* EnumLike */);
     }
   }
   function checkAmbientInitializer(node) {
@@ -89276,6 +89276,319 @@ function createTypeChecker(host) {
     Debug.assert(specifier && nodeIsSynthesized(specifier) && specifier.text === "tslib", `Expected sourceFile.imports[0] to be the synthesized tslib import`);
     return specifier;
   }
+  function compareSymbols(s1, s2) {
+    if (s1 === s2) return 0;
+    if (s1 === void 0) return 1;
+    if (s2 === void 0) return -1;
+    if (length(s1.declarations) !== 0 && length(s2.declarations) !== 0) {
+      const r2 = compareNodes(s1.declarations[0], s2.declarations[0]);
+      if (r2 !== 0) return r2;
+    } else if (length(s1.declarations) !== 0) {
+      return -1;
+    } else if (length(s2.declarations) !== 0) {
+      return 1;
+    }
+    const r = compareComparableValues(s1.escapedName, s2.escapedName);
+    if (r !== 0) return r;
+    return getSymbolId(s1) - getSymbolId(s2);
+  }
+  function compareNodes(n1, n2) {
+    if (n1 === n2) return 0;
+    if (n1 === void 0) return 1;
+    if (n2 === void 0) return -1;
+    const f1 = fileIndexMap.get(getSourceFileOfNode(n1));
+    const f2 = fileIndexMap.get(getSourceFileOfNode(n2));
+    if (f1 !== f2) {
+      return f1 - f2;
+    }
+    return n1.pos - n2.pos;
+  }
+  function compareTypes(t1, t2) {
+    if (t1 === t2) return 0;
+    if (t1 === void 0) return 1;
+    if (t2 === void 0) return -1;
+    let c = getSortOrderFlags(t1) - getSortOrderFlags(t2);
+    if (c !== 0) return c;
+    c = compareTypeNames(t1, t2);
+    if (c !== 0) return c;
+    if (t1.flags & (1 /* Any */ | 2 /* Unknown */ | 32 /* String */ | 64 /* Number */ | 256 /* Boolean */ | 128 /* BigInt */ | 512 /* ESSymbol */ | 16 /* Void */ | 4 /* Undefined */ | 8 /* Null */ | 131072 /* Never */ | 67108864 /* NonPrimitive */)) {
+    } else if (t1.flags & 524288 /* Object */) {
+      const c2 = compareSymbols(t1.symbol, t2.symbol);
+      if (c2 !== 0) return c2;
+      if (getObjectFlags(t1) & 4 /* Reference */ && getObjectFlags(t2) & 4 /* Reference */) {
+        const r1 = t1;
+        const r2 = t2;
+        if (getObjectFlags(r1.target) & 8 /* Tuple */ && getObjectFlags(r2.target) & 8 /* Tuple */) {
+          const c3 = compareTupleTypes(r1.target, r2.target);
+          if (c3 !== 0) {
+            return c3;
+          }
+        }
+        if (r1.node === void 0 && r2.node === void 0) {
+          const c3 = compareTypeLists(t1.resolvedTypeArguments, t2.resolvedTypeArguments);
+          if (c3 !== 0) {
+            return c3;
+          }
+        } else {
+          let c3 = compareNodes(r1.node, r2.node);
+          if (c3 !== 0) {
+            return c3;
+          }
+          c3 = compareTypeMappers(t1.mapper, t2.mapper);
+          if (c3 !== 0) {
+            return c3;
+          }
+        }
+      } else if (getObjectFlags(t1) & 4 /* Reference */) {
+        return -1;
+      } else if (getObjectFlags(t2) & 4 /* Reference */) {
+        return 1;
+      } else {
+        let c3 = getObjectFlags(t1) & 142607679 /* ObjectTypeKindMask */ - getObjectFlags(t2) & 142607679 /* ObjectTypeKindMask */;
+        if (c3 !== 0) {
+          return c3;
+        }
+        c3 = compareTypeMappers(t1.mapper, t2.mapper);
+        if (c3 !== 0) {
+          return c3;
+        }
+      }
+    } else if (t1.flags & 1048576 /* Union */) {
+      const o1 = t1.origin;
+      const o2 = t2.origin;
+      if (o1 === void 0 && o2 === void 0) {
+        const c2 = compareTypeLists(t1.types, t2.types);
+        if (c2 !== 0) {
+          return c2;
+        }
+      } else if (o1 === void 0) {
+        return 1;
+      } else if (o2 === void 0) {
+        return -1;
+      } else {
+        const c2 = compareTypes(o1, o2);
+        if (c2 !== 0) {
+          return c2;
+        }
+      }
+    } else if (t1.flags & 2097152 /* Intersection */) {
+      const c2 = compareTypeLists(t1.types, t2.types);
+      if (c2 !== 0) {
+        return c2;
+      }
+    } else if (t1.flags & (32768 /* EnumLiteral */ | 16384 /* UniqueESSymbol */)) {
+      const c2 = compareSymbols(t1.symbol, t2.symbol);
+      if (c2 !== 0) {
+        return c2;
+      }
+    } else if (t1.flags & 1024 /* StringLiteral */) {
+      const c2 = compareComparableValues(t1.value, t2.value);
+      if (c2 !== 0) {
+        return c2;
+      }
+    } else if (t1.flags & 2048 /* NumberLiteral */) {
+      const c2 = compareComparableValues(t1.value, t2.value);
+      if (c2 !== 0) {
+        return c2;
+      }
+    } else if (t1.flags & 4096 /* BooleanLiteral */) {
+      const b1 = t1.intrinsicName === "true";
+      const b2 = t2.intrinsicName === "true";
+      if (b1 !== b2) {
+        if (b1) {
+          return 1;
+        }
+        return -1;
+      }
+    } else if (t1.flags & 262144 /* TypeParameter */) {
+      const c2 = compareSymbols(t1.symbol, t2.symbol);
+      if (c2 !== 0) {
+        return c2;
+      }
+    } else if (t1.flags & 4194304 /* Index */) {
+      let c2 = compareTypes(t1.type, t2.type);
+      if (c2 !== 0) {
+        return c2;
+      }
+      c2 = t1.flags - t2.flags;
+      if (c2 !== 0) {
+        return c2;
+      }
+    } else if (t1.flags & 8388608 /* IndexedAccess */) {
+      let c2 = compareTypes(t1.objectType, t2.objectType);
+      if (c2 !== 0) {
+        return c2;
+      }
+      c2 = compareTypes(t1.indexType, t2.indexType);
+      if (c2 !== 0) {
+        return c2;
+      }
+    } else if (t1.flags & 16777216 /* Conditional */) {
+      let c2 = compareNodes(t1.root.node, t2.root.node);
+      if (c2 !== 0) {
+        return c2;
+      }
+      c2 = compareTypeMappers(t1.mapper, t2.mapper);
+      if (c2 !== 0) {
+        return c2;
+      }
+    } else if (t1.flags & 33554432 /* Substitution */) {
+      let c2 = compareTypes(t1.baseType, t2.baseType);
+      if (c2 !== 0) {
+        return c2;
+      }
+      c2 = compareTypes(t1.constraint, t2.constraint);
+      if (c2 !== 0) {
+        return c2;
+      }
+    } else if (t1.flags & 134217728 /* TemplateLiteral */) {
+      let c2 = slicesCompareString(t1.texts, t2.texts);
+      if (c2 !== 0) {
+        return c2;
+      }
+      c2 = compareTypeLists(t1.types, t2.types);
+      if (c2 !== 0) {
+        return c2;
+      }
+    } else if (t1.flags & 268435456 /* StringMapping */) {
+      const c2 = compareTypes(t1.type, t2.type);
+      if (c2 !== 0) {
+        return c2;
+      }
+    }
+    return t1.id - t2.id;
+    function slicesCompareString(s1, s2) {
+      for (let i = 0; i < s1.length; i++) {
+        if (i > s2.length) {
+          return 1;
+        }
+        const v1 = s1[i];
+        const v2 = s2[i];
+        const c2 = compareComparableValues(v1, v2);
+        if (c2 !== 0) return c2;
+      }
+      if (s1.length < s2.length) {
+        return -1;
+      }
+      return 0;
+    }
+  }
+  function getSortOrderFlags(t) {
+    return (t.flags & 65536 /* Enum */) >> 1 | t.flags & ~65536 /* Enum */;
+  }
+  function compareTypeNames(t1, t2) {
+    const s1 = getTypeNameSymbol(t1);
+    const s2 = getTypeNameSymbol(t2);
+    if (s1 === s2) {
+      if (t1.aliasTypeArguments !== void 0) {
+        return compareTypeLists(t1.aliasTypeArguments, t2.aliasTypeArguments);
+      }
+      return 0;
+    }
+    if (s1 === void 0) {
+      return 1;
+    }
+    if (s2 === void 0) {
+      return -1;
+    }
+    return compareComparableValues(s1.escapedName, s2.escapedName);
+  }
+  function getTypeNameSymbol(t) {
+    if (t.aliasSymbol !== void 0) {
+      return t.aliasSymbol;
+    }
+    if (t.flags & (262144 /* TypeParameter */ | 268435456 /* StringMapping */) || getObjectFlags(t) & (3 /* ClassOrInterface */ | 4 /* Reference */)) {
+      return t.symbol;
+    }
+    return void 0;
+  }
+  function compareTupleTypes(t1, t2) {
+    var _a;
+    if (t1 === t2) {
+      return 0;
+    }
+    if (t1.readonly === t2.readonly) {
+      return t1.readonly ? 1 : -1;
+    }
+    if (t1.elementFlags.length !== t2.elementFlags.length) {
+      return t1.elementFlags.length - t2.elementFlags.length;
+    }
+    for (let i = 0; i < t1.elementFlags.length; i++) {
+      const c = t1.elementFlags[i] - t2.elementFlags[i];
+      if (c !== 0) {
+        return c;
+      }
+    }
+    for (let i = 0; i < (((_a = t1.labeledElementDeclarations) == null ? void 0 : _a.length) ?? 0); i++) {
+      const c = compareElementLabels(t1.labeledElementDeclarations[i], t2.labeledElementDeclarations[i]);
+      if (c !== 0) {
+        return c;
+      }
+    }
+    return 0;
+  }
+  function compareElementLabels(n1, n2) {
+    if (n1 === n2) {
+      return 0;
+    }
+    if (n1 === void 0) {
+      return -1;
+    }
+    if (n2 === void 0) {
+      return 1;
+    }
+    return compareComparableValues(n1.name.escapedText, n2.name.escapedText);
+  }
+  function compareTypeLists(s1, s2) {
+    if (length(s1) !== length(s2)) {
+      return length(s1) - length(s2);
+    }
+    for (let i = 0; i < length(s1); i++) {
+      const c = compareTypes(s1[i], s2 == null ? void 0 : s2[i]);
+      if (c !== 0) return c;
+    }
+    return 0;
+  }
+  function compareTypeMappers(m1, m2) {
+    if (m1 === m2) {
+      return 0;
+    }
+    if (m1 === void 0) {
+      return 1;
+    }
+    if (m2 === void 0) {
+      return -1;
+    }
+    const kind1 = m1.kind;
+    const kind2 = m2.kind;
+    if (kind1 !== kind2) {
+      return kind1 - kind2;
+    }
+    switch (kind1) {
+      case 0 /* Simple */: {
+        const c = compareTypes(m1.source, m2.source);
+        if (c !== 0) {
+          return c;
+        }
+        return compareTypes(m1.target, m2.target);
+      }
+      case 1 /* Array */: {
+        const c = compareTypeLists(m1.sources, m2.sources);
+        if (c !== 0) {
+          return c;
+        }
+        return compareTypeLists(m1.targets, m2.targets);
+      }
+      case 5 /* Merged */: {
+        const c = compareTypeMappers(m1.mapper1, m2.mapper1);
+        if (c !== 0) {
+          return c;
+        }
+        return compareTypeMappers(m1.mapper2, m2.mapper2);
+      }
+    }
+    return 0;
+  }
 }
 function isNotAccessor(declaration) {
   return !isAccessor(declaration);