@typescript-deploys/pr-build 5.4.0-pr-57293-15 → 5.4.0-pr-57341-6

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-insiders.20240205`;
+var version = `${versionMajorMinor}.0-insiders.20240208`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -1746,8 +1746,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 & 2048 /* ReverseMapped */ ? "ReverseMappedType" : this.objectFlags & 512 /* EvolvingArray */ ? "EvolvingArrayType" : "ObjectType" : "Type";
-          const remainingObjectFlags = this.flags & 524288 /* Object */ ? this.objectFlags & ~2623 /* ObjectTypeKindMask */ : 0;
+          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;
           return `${typeHeader}${this.symbol ? ` '${symbolName(this.symbol)}'` : ""}${remainingObjectFlags ? ` (${formatObjectFlags(remainingObjectFlags)})` : ""}`;
         }
       },
@@ -2926,7 +2926,7 @@ var tracingEnabled;
         };
       }
       let reverseMappedProperties = {};
-      if (objectFlags & 2048 /* ReverseMapped */) {
+      if (objectFlags & 1024 /* ReverseMapped */) {
         const reverseMappedType = type;
         reverseMappedProperties = {
           reverseMappedSourceType: (_l = reverseMappedType.source) == null ? void 0 : _l.id,
@@ -2935,7 +2935,7 @@ var tracingEnabled;
         };
       }
       let evolvingArrayProperties = {};
-      if (objectFlags & 512 /* EvolvingArray */) {
+      if (objectFlags & 256 /* EvolvingArray */) {
         const evolvingArrayType = type;
         evolvingArrayProperties = {
           evolvingArrayElementType: evolvingArrayType.elementType.id,
@@ -3685,43 +3685,42 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
   ObjectFlags3[ObjectFlags3["Tuple"] = 8] = "Tuple";
   ObjectFlags3[ObjectFlags3["Anonymous"] = 16] = "Anonymous";
   ObjectFlags3[ObjectFlags3["Mapped"] = 32] = "Mapped";
-  ObjectFlags3[ObjectFlags3["TypeAliasInstantiation"] = 64] = "TypeAliasInstantiation";
-  ObjectFlags3[ObjectFlags3["Instantiated"] = 128] = "Instantiated";
-  ObjectFlags3[ObjectFlags3["ObjectLiteral"] = 256] = "ObjectLiteral";
-  ObjectFlags3[ObjectFlags3["EvolvingArray"] = 512] = "EvolvingArray";
-  ObjectFlags3[ObjectFlags3["ObjectLiteralPatternWithComputedProperties"] = 1024] = "ObjectLiteralPatternWithComputedProperties";
-  ObjectFlags3[ObjectFlags3["ReverseMapped"] = 2048] = "ReverseMapped";
-  ObjectFlags3[ObjectFlags3["JsxAttributes"] = 4096] = "JsxAttributes";
-  ObjectFlags3[ObjectFlags3["JSLiteral"] = 8192] = "JSLiteral";
-  ObjectFlags3[ObjectFlags3["FreshLiteral"] = 16384] = "FreshLiteral";
-  ObjectFlags3[ObjectFlags3["ArrayLiteral"] = 32768] = "ArrayLiteral";
-  ObjectFlags3[ObjectFlags3["PrimitiveUnion"] = 65536] = "PrimitiveUnion";
-  ObjectFlags3[ObjectFlags3["ContainsWideningType"] = 131072] = "ContainsWideningType";
-  ObjectFlags3[ObjectFlags3["ContainsObjectOrArrayLiteral"] = 262144] = "ContainsObjectOrArrayLiteral";
-  ObjectFlags3[ObjectFlags3["NonInferrableType"] = 524288] = "NonInferrableType";
-  ObjectFlags3[ObjectFlags3["CouldContainTypeVariablesComputed"] = 1048576] = "CouldContainTypeVariablesComputed";
-  ObjectFlags3[ObjectFlags3["CouldContainTypeVariables"] = 2097152] = "CouldContainTypeVariables";
+  ObjectFlags3[ObjectFlags3["Instantiated"] = 64] = "Instantiated";
+  ObjectFlags3[ObjectFlags3["ObjectLiteral"] = 128] = "ObjectLiteral";
+  ObjectFlags3[ObjectFlags3["EvolvingArray"] = 256] = "EvolvingArray";
+  ObjectFlags3[ObjectFlags3["ObjectLiteralPatternWithComputedProperties"] = 512] = "ObjectLiteralPatternWithComputedProperties";
+  ObjectFlags3[ObjectFlags3["ReverseMapped"] = 1024] = "ReverseMapped";
+  ObjectFlags3[ObjectFlags3["JsxAttributes"] = 2048] = "JsxAttributes";
+  ObjectFlags3[ObjectFlags3["JSLiteral"] = 4096] = "JSLiteral";
+  ObjectFlags3[ObjectFlags3["FreshLiteral"] = 8192] = "FreshLiteral";
+  ObjectFlags3[ObjectFlags3["ArrayLiteral"] = 16384] = "ArrayLiteral";
+  ObjectFlags3[ObjectFlags3["PrimitiveUnion"] = 32768] = "PrimitiveUnion";
+  ObjectFlags3[ObjectFlags3["ContainsWideningType"] = 65536] = "ContainsWideningType";
+  ObjectFlags3[ObjectFlags3["ContainsObjectOrArrayLiteral"] = 131072] = "ContainsObjectOrArrayLiteral";
+  ObjectFlags3[ObjectFlags3["NonInferrableType"] = 262144] = "NonInferrableType";
+  ObjectFlags3[ObjectFlags3["CouldContainTypeVariablesComputed"] = 524288] = "CouldContainTypeVariablesComputed";
+  ObjectFlags3[ObjectFlags3["CouldContainTypeVariables"] = 1048576] = "CouldContainTypeVariables";
   ObjectFlags3[ObjectFlags3["ClassOrInterface"] = 3] = "ClassOrInterface";
-  ObjectFlags3[ObjectFlags3["RequiresWidening"] = 393216] = "RequiresWidening";
-  ObjectFlags3[ObjectFlags3["PropagatingFlags"] = 917504] = "PropagatingFlags";
-  ObjectFlags3[ObjectFlags3["InstantiatedMapped"] = 160] = "InstantiatedMapped";
-  ObjectFlags3[ObjectFlags3["ObjectTypeKindMask"] = 2623] = "ObjectTypeKindMask";
-  ObjectFlags3[ObjectFlags3["ContainsSpread"] = 4194304] = "ContainsSpread";
-  ObjectFlags3[ObjectFlags3["ObjectRestType"] = 8388608] = "ObjectRestType";
-  ObjectFlags3[ObjectFlags3["InstantiationExpressionType"] = 16777216] = "InstantiationExpressionType";
-  ObjectFlags3[ObjectFlags3["IsClassInstanceClone"] = 33554432] = "IsClassInstanceClone";
-  ObjectFlags3[ObjectFlags3["IdenticalBaseTypeCalculated"] = 67108864] = "IdenticalBaseTypeCalculated";
-  ObjectFlags3[ObjectFlags3["IdenticalBaseTypeExists"] = 134217728] = "IdenticalBaseTypeExists";
-  ObjectFlags3[ObjectFlags3["IsGenericTypeComputed"] = 4194304] = "IsGenericTypeComputed";
-  ObjectFlags3[ObjectFlags3["IsGenericObjectType"] = 8388608] = "IsGenericObjectType";
-  ObjectFlags3[ObjectFlags3["IsGenericIndexType"] = 16777216] = "IsGenericIndexType";
-  ObjectFlags3[ObjectFlags3["IsGenericType"] = 25165824] = "IsGenericType";
-  ObjectFlags3[ObjectFlags3["ContainsIntersections"] = 33554432] = "ContainsIntersections";
-  ObjectFlags3[ObjectFlags3["IsUnknownLikeUnionComputed"] = 67108864] = "IsUnknownLikeUnionComputed";
-  ObjectFlags3[ObjectFlags3["IsUnknownLikeUnion"] = 134217728] = "IsUnknownLikeUnion";
-  ObjectFlags3[ObjectFlags3["IsNeverIntersectionComputed"] = 33554432] = "IsNeverIntersectionComputed";
-  ObjectFlags3[ObjectFlags3["IsNeverIntersection"] = 67108864] = "IsNeverIntersection";
-  ObjectFlags3[ObjectFlags3["IsConstrainedTypeVariable"] = 134217728] = "IsConstrainedTypeVariable";
+  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["IsClassInstanceClone"] = 16777216] = "IsClassInstanceClone";
+  ObjectFlags3[ObjectFlags3["IdenticalBaseTypeCalculated"] = 33554432] = "IdenticalBaseTypeCalculated";
+  ObjectFlags3[ObjectFlags3["IdenticalBaseTypeExists"] = 67108864] = "IdenticalBaseTypeExists";
+  ObjectFlags3[ObjectFlags3["IsGenericTypeComputed"] = 2097152] = "IsGenericTypeComputed";
+  ObjectFlags3[ObjectFlags3["IsGenericObjectType"] = 4194304] = "IsGenericObjectType";
+  ObjectFlags3[ObjectFlags3["IsGenericIndexType"] = 8388608] = "IsGenericIndexType";
+  ObjectFlags3[ObjectFlags3["IsGenericType"] = 12582912] = "IsGenericType";
+  ObjectFlags3[ObjectFlags3["ContainsIntersections"] = 16777216] = "ContainsIntersections";
+  ObjectFlags3[ObjectFlags3["IsUnknownLikeUnionComputed"] = 33554432] = "IsUnknownLikeUnionComputed";
+  ObjectFlags3[ObjectFlags3["IsUnknownLikeUnion"] = 67108864] = "IsUnknownLikeUnion";
+  ObjectFlags3[ObjectFlags3["IsNeverIntersectionComputed"] = 16777216] = "IsNeverIntersectionComputed";
+  ObjectFlags3[ObjectFlags3["IsNeverIntersection"] = 33554432] = "IsNeverIntersection";
+  ObjectFlags3[ObjectFlags3["IsConstrainedTypeVariable"] = 67108864] = "IsConstrainedTypeVariable";
   return ObjectFlags3;
 })(ObjectFlags || {});
 var SignatureFlags = /* @__PURE__ */ ((SignatureFlags4) => {
@@ -12930,6 +12929,9 @@ function isObjectLiteralOrClassExpressionMethodOrAccessor(node) {
 function isIdentifierTypePredicate(predicate) {
   return predicate && predicate.kind === 1 /* Identifier */;
 }
+function isThisTypePredicate(predicate) {
+  return predicate && predicate.kind === 0 /* This */;
+}
 function forEachPropertyAssignment(objectLiteral, key, callback, key2) {
   return forEach(objectLiteral == null ? void 0 : objectLiteral.properties, (property) => {
     if (!isPropertyAssignment(property))
@@ -17042,7 +17044,8 @@ function usesExtensionsOnImports({ imports }, hasExtension2 = or(hasJSFileExtens
 }
 function getModuleSpecifierEndingPreference(preference, resolutionMode, compilerOptions, sourceFile) {
   const moduleResolution = getEmitModuleResolutionKind(compilerOptions);
-  if (preference === "js" || resolutionMode === 99 /* ESNext */ && 3 /* Node16 */ <= moduleResolution && moduleResolution <= 99 /* NodeNext */) {
+  const moduleResolutionIsNodeNext = 3 /* Node16 */ <= moduleResolution && moduleResolution <= 99 /* NodeNext */;
+  if (preference === "js" || resolutionMode === 99 /* ESNext */ && moduleResolutionIsNodeNext) {
     if (!shouldAllowImportingTsExtension(compilerOptions)) {
       return 2 /* JsExtension */;
     }
@@ -17060,16 +17063,19 @@ function getModuleSpecifierEndingPreference(preference, resolutionMode, compiler
   return inferPreference();
   function inferPreference() {
     let usesJsExtensions = false;
-    const specifiers = sourceFile.imports.length ? sourceFile.imports.map((i) => i.text) : isSourceFileJS(sourceFile) ? getRequiresAtTopOfFile(sourceFile).map((r) => r.arguments[0].text) : emptyArray;
+    const specifiers = sourceFile.imports.length ? sourceFile.imports : isSourceFileJS(sourceFile) ? getRequiresAtTopOfFile(sourceFile).map((r) => r.arguments[0]) : emptyArray;
     for (const specifier of specifiers) {
-      if (pathIsRelative(specifier)) {
-        if (fileExtensionIsOneOf(specifier, extensionsNotSupportingExtensionlessResolution)) {
+      if (pathIsRelative(specifier.text)) {
+        if (moduleResolutionIsNodeNext && resolutionMode === 1 /* CommonJS */ && getModeForUsageLocation(sourceFile, specifier, compilerOptions) === 99 /* ESNext */) {
+          continue;
+        }
+        if (fileExtensionIsOneOf(specifier.text, extensionsNotSupportingExtensionlessResolution)) {
           continue;
         }
-        if (hasTSFileExtension(specifier)) {
+        if (hasTSFileExtension(specifier.text)) {
           return 3 /* TsExtension */;
         }
-        if (hasJSFileExtension(specifier)) {
+        if (hasJSFileExtension(specifier.text)) {
           usesJsExtensions = true;
         }
       }
@@ -42626,11 +42632,12 @@ function createGetSymbolWalker(getRestTypeOfSignature, getTypePredicateOfSignatu
 }
 
 // src/compiler/moduleSpecifiers.ts
-function getPreferences({ importModuleSpecifierPreference, importModuleSpecifierEnding }, compilerOptions, importingSourceFile, oldImportSpecifier) {
-  const preferredEnding = getPreferredEnding();
+function getModuleSpecifierPreferences({ importModuleSpecifierPreference, importModuleSpecifierEnding }, compilerOptions, importingSourceFile, oldImportSpecifier) {
+  const filePreferredEnding = getPreferredEnding();
   return {
     relativePreference: oldImportSpecifier !== void 0 ? isExternalModuleNameRelative(oldImportSpecifier) ? 0 /* Relative */ : 1 /* NonRelative */ : importModuleSpecifierPreference === "relative" ? 0 /* Relative */ : importModuleSpecifierPreference === "non-relative" ? 1 /* NonRelative */ : importModuleSpecifierPreference === "project-relative" ? 3 /* ExternalNonRelative */ : 2 /* Shortest */,
     getAllowedEndingsInPreferredOrder: (syntaxImpliedNodeFormat) => {
+      const preferredEnding = syntaxImpliedNodeFormat !== importingSourceFile.impliedNodeFormat ? getPreferredEnding(syntaxImpliedNodeFormat) : filePreferredEnding;
       if ((syntaxImpliedNodeFormat ?? importingSourceFile.impliedNodeFormat) === 99 /* ESNext */) {
         if (shouldAllowImportingTsExtension(compilerOptions, importingSourceFile.fileName)) {
           return [3 /* TsExtension */, 2 /* JsExtension */];
@@ -42655,7 +42662,7 @@ function getPreferences({ importModuleSpecifierPreference, importModuleSpecifier
       }
     }
   };
-  function getPreferredEnding() {
+  function getPreferredEnding(resolutionMode) {
     if (oldImportSpecifier !== void 0) {
       if (hasJSFileExtension(oldImportSpecifier))
         return 2 /* JsExtension */;
@@ -42664,14 +42671,14 @@ function getPreferences({ importModuleSpecifierPreference, importModuleSpecifier
     }
     return getModuleSpecifierEndingPreference(
       importModuleSpecifierEnding,
-      importingSourceFile.impliedNodeFormat,
+      resolutionMode ?? importingSourceFile.impliedNodeFormat,
       compilerOptions,
       importingSourceFile
     );
   }
 }
 function getModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, options = {}) {
-  return getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, getPreferences({}, compilerOptions, importingSourceFile), {}, options);
+  return getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, getModuleSpecifierPreferences({}, compilerOptions, importingSourceFile), {}, options);
 }
 function getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, preferences, userPreferences, options = {}) {
   const info = getInfo(importingSourceFileName, host);
@@ -42743,7 +42750,7 @@ function getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions
 }
 function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFile, host, userPreferences, options = {}, forAutoImport) {
   const info = getInfo(importingSourceFile.fileName, host);
-  const preferences = getPreferences(userPreferences, compilerOptions, importingSourceFile);
+  const preferences = getModuleSpecifierPreferences(userPreferences, compilerOptions, importingSourceFile);
   const existingSpecifier = forEach(modulePaths, (modulePath) => forEach(
     host.getFileIncludeReasons().get(toPath(modulePath.path, host.getCurrentDirectory(), info.getCanonicalFileName)),
     (reason) => {
@@ -43253,7 +43260,7 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa
   if (!parts) {
     return void 0;
   }
-  const preferences = getPreferences(userPreferences, options, importingSourceFile);
+  const preferences = getModuleSpecifierPreferences(userPreferences, options, importingSourceFile);
   const allowedEndings = preferences.getAllowedEndingsInPreferredOrder();
   let moduleSpecifier = path;
   let isPackageRootPath = false;
@@ -43644,7 +43651,7 @@ function createTypeChecker(host) {
   var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
   var keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
   var defaultIndexFlags = keyofStringsOnly ? 1 /* StringsOnly */ : 0 /* None */;
-  var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 16384 /* FreshLiteral */;
+  var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 8192 /* FreshLiteral */;
   var exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes;
   var checkBinaryExpression = createCheckBinaryExpression();
   var emitResolver = createResolver();
@@ -44147,7 +44154,7 @@ function createTypeChecker(host) {
   var errorTypes = /* @__PURE__ */ new Map();
   var seenIntrinsicNames = /* @__PURE__ */ new Set();
   var anyType = createIntrinsicType(1 /* Any */, "any");
-  var autoType = createIntrinsicType(1 /* Any */, "any", 524288 /* NonInferrableType */, "auto");
+  var autoType = createIntrinsicType(1 /* Any */, "any", 262144 /* NonInferrableType */, "auto");
   var wildcardType = createIntrinsicType(
     1 /* Any */,
     "any",
@@ -44164,7 +44171,7 @@ function createTypeChecker(host) {
   );
   var errorType = createIntrinsicType(1 /* Any */, "error");
   var unresolvedType = createIntrinsicType(1 /* Any */, "unresolved");
-  var nonInferrableAnyType = createIntrinsicType(1 /* Any */, "any", 131072 /* ContainsWideningType */, "non-inferrable");
+  var nonInferrableAnyType = createIntrinsicType(1 /* Any */, "any", 65536 /* ContainsWideningType */, "non-inferrable");
   var intrinsicMarkerType = createIntrinsicType(1 /* Any */, "intrinsic");
   var unknownType = createIntrinsicType(2 /* Unknown */, "unknown");
   var nonNullUnknownType = createIntrinsicType(
@@ -44175,7 +44182,7 @@ function createTypeChecker(host) {
     "non-null"
   );
   var undefinedType = createIntrinsicType(32768 /* Undefined */, "undefined");
-  var undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(32768 /* Undefined */, "undefined", 131072 /* ContainsWideningType */, "widening");
+  var undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(32768 /* Undefined */, "undefined", 65536 /* ContainsWideningType */, "widening");
   var missingType = createIntrinsicType(
     32768 /* Undefined */,
     "undefined",
@@ -44192,7 +44199,7 @@ function createTypeChecker(host) {
     "optional"
   );
   var nullType = createIntrinsicType(65536 /* Null */, "null");
-  var nullWideningType = strictNullChecks ? nullType : createIntrinsicType(65536 /* Null */, "null", 131072 /* ContainsWideningType */, "widening");
+  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");
@@ -44224,7 +44231,7 @@ function createTypeChecker(host) {
   var esSymbolType = createIntrinsicType(4096 /* ESSymbol */, "symbol");
   var voidType = createIntrinsicType(16384 /* Void */, "void");
   var neverType = createIntrinsicType(131072 /* Never */, "never");
-  var silentNeverType = createIntrinsicType(131072 /* Never */, "never", 524288 /* NonInferrableType */, "silent");
+  var silentNeverType = createIntrinsicType(131072 /* Never */, "never", 262144 /* NonInferrableType */, "silent");
   var implicitNeverType = createIntrinsicType(
     131072 /* Never */,
     "never",
@@ -44291,7 +44298,7 @@ function createTypeChecker(host) {
     emptyArray,
     emptyArray
   );
-  emptyJsxObjectType.objectFlags |= 4096 /* JsxAttributes */;
+  emptyJsxObjectType.objectFlags |= 2048 /* JsxAttributes */;
   var emptyTypeLiteralSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* Type */);
   emptyTypeLiteralSymbol.members = createSymbolTable();
   var emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, emptyArray, emptyArray, emptyArray);
@@ -44321,7 +44328,7 @@ function createTypeChecker(host) {
     emptyArray,
     emptyArray
   );
-  anyFunctionType.objectFlags |= 524288 /* NonInferrableType */;
+  anyFunctionType.objectFlags |= 262144 /* NonInferrableType */;
   var noConstraintType = createAnonymousType(
     /*symbol*/
     void 0,
@@ -47559,7 +47566,7 @@ function createTypeChecker(host) {
     const type = createType(kind);
     type.intrinsicName = intrinsicName;
     type.debugIntrinsicName = debugIntrinsicName;
-    type.objectFlags = objectFlags | 1048576 /* CouldContainTypeVariablesComputed */ | 4194304 /* IsGenericTypeComputed */ | 67108864 /* IsUnknownLikeUnionComputed */ | 33554432 /* IsNeverIntersectionComputed */;
+    type.objectFlags = objectFlags | 524288 /* CouldContainTypeVariablesComputed */ | 2097152 /* IsGenericTypeComputed */ | 33554432 /* IsUnknownLikeUnionComputed */ | 16777216 /* IsNeverIntersectionComputed */;
     return type;
   }
   function checkIntrinsicName(name, debug) {
@@ -48148,7 +48155,7 @@ function createTypeChecker(host) {
     return flags & 848330095 /* NodeBuilderFlagsMask */;
   }
   function isClassInstanceSide(type) {
-    return !!type.symbol && !!(type.symbol.flags & 32 /* Class */) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || !!(type.flags & 524288 /* Object */) && !!(getObjectFlags(type) & 33554432 /* IsClassInstanceClone */));
+    return !!type.symbol && !!(type.symbol.flags & 32 /* Class */) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || !!(type.flags & 524288 /* Object */) && !!(getObjectFlags(type) & 16777216 /* IsClassInstanceClone */));
   }
   function createNodeBuilder() {
     return {
@@ -48237,7 +48244,9 @@ function createTypeChecker(host) {
         context.approximateLength += 3;
         return factory.createKeywordTypeNode(133 /* AnyKeyword */);
       }
-      type = context.flags & 536870912 /* NoTypeReduction */ ? getResolvedType(type) : getReducedType(type);
+      if (!(context.flags & 536870912 /* NoTypeReduction */)) {
+        type = getReducedType(type);
+      }
       if (type.flags & 1 /* Any */) {
         if (type.aliasSymbol) {
           return factory.createTypeReferenceNode(symbolToEntityNameNode(type.aliasSymbol), mapToTypeNodes(type.aliasTypeArguments, context));
@@ -48609,7 +48618,7 @@ function createTypeChecker(host) {
         const typeId = type2.id;
         const symbol = type2.symbol;
         if (symbol) {
-          const isInstantiationExpressionType = !!(getObjectFlags(type2) & 16777216 /* InstantiationExpressionType */);
+          const isInstantiationExpressionType = !!(getObjectFlags(type2) & 8388608 /* InstantiationExpressionType */);
           if (isInstantiationExpressionType) {
             const instantiationExpressionType = type2;
             const existing = instantiationExpressionType.node;
@@ -48947,7 +48956,7 @@ function createTypeChecker(host) {
           typeElements.push(signatureToSignatureDeclarationHelper(signature, 180 /* ConstructSignature */, context));
         }
         for (const info of resolvedType.indexInfos) {
-          typeElements.push(indexInfoToIndexSignatureDeclarationHelper(info, context, resolvedType.objectFlags & 2048 /* ReverseMapped */ ? createElidedInformationPlaceholder(context) : void 0));
+          typeElements.push(indexInfoToIndexSignatureDeclarationHelper(info, context, resolvedType.objectFlags & 1024 /* ReverseMapped */ ? createElidedInformationPlaceholder(context) : void 0));
         }
         const properties = resolvedType.properties;
         if (!properties) {
@@ -52191,7 +52200,7 @@ function createTypeChecker(host) {
       ));
     }
     const result = createAnonymousType(symbol, members, emptyArray, emptyArray, getIndexInfosOfType(source));
-    result.objectFlags |= 8388608 /* ObjectRestType */;
+    result.objectFlags |= 4194304 /* ObjectRestType */;
     return result;
   }
   function isGenericTypeWithUndefinedConstraint(type) {
@@ -52621,7 +52630,7 @@ function createTypeChecker(host) {
       mergeSymbolTable(exports2, s.exports);
     }
     const type = createAnonymousType(symbol, exports2, emptyArray, emptyArray, emptyArray);
-    type.objectFlags |= 8192 /* JSLiteral */;
+    type.objectFlags |= 4096 /* JSLiteral */;
     return type;
   }
   function getAnnotatedTypeForAssignmentDeclaration(declaredType, expression, symbol, declaration) {
@@ -52742,9 +52751,9 @@ function createTypeChecker(host) {
           result.aliasTypeArguments = length(args) ? args : void 0;
         }
       }
-      result.objectFlags |= getObjectFlags(type) & 8192 /* JSLiteral */;
+      result.objectFlags |= getObjectFlags(type) & 4096 /* JSLiteral */;
       if (result.symbol && result.symbol.flags & 32 /* Class */ && type === getDeclaredTypeOfClassOrInterface(result.symbol)) {
-        result.objectFlags |= 33554432 /* IsClassInstanceClone */;
+        result.objectFlags |= 16777216 /* IsClassInstanceClone */;
       }
       return result;
     }
@@ -52797,7 +52806,7 @@ function createTypeChecker(host) {
   function getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors2) {
     const members = createSymbolTable();
     let stringIndexInfo;
-    let objectFlags = 256 /* ObjectLiteral */ | 262144 /* ContainsObjectOrArrayLiteral */;
+    let objectFlags = 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
     forEach(pattern.elements, (e) => {
       const name = e.propertyName || e.name;
       if (e.dotDotDotToken) {
@@ -52811,7 +52820,7 @@ function createTypeChecker(host) {
       }
       const exprType = getLiteralTypeFromPropertyName(name);
       if (!isTypeUsableAsPropertyName(exprType)) {
-        objectFlags |= 1024 /* ObjectLiteralPatternWithComputedProperties */;
+        objectFlags |= 512 /* ObjectLiteralPatternWithComputedProperties */;
         return;
       }
       const text = getPropertyNameFromType(exprType);
@@ -52832,7 +52841,7 @@ function createTypeChecker(host) {
     result.objectFlags |= objectFlags;
     if (includePatternInType) {
       result.pattern = pattern;
-      result.objectFlags |= 262144 /* ContainsObjectOrArrayLiteral */;
+      result.objectFlags |= 131072 /* ContainsObjectOrArrayLiteral */;
     }
     return result;
   }
@@ -52850,7 +52859,7 @@ function createTypeChecker(host) {
     if (includePatternInType) {
       result = cloneTypeReference(result);
       result.pattern = pattern;
-      result.objectFlags |= 262144 /* ContainsObjectOrArrayLiteral */;
+      result.objectFlags |= 131072 /* ContainsObjectOrArrayLiteral */;
     }
     return result;
   }
@@ -52878,7 +52887,7 @@ function createTypeChecker(host) {
         members.set(member.escapedName, member);
       });
       const type = createAnonymousType(symbol, members, emptyArray, emptyArray, emptyArray);
-      type.objectFlags |= 256 /* ObjectLiteral */ | 524288 /* NonInferrableType */;
+      type.objectFlags |= 128 /* ObjectLiteral */ | 262144 /* NonInferrableType */;
       links.resolvedType = type;
     }
     return links.resolvedType;
@@ -54666,14 +54675,6 @@ function createTypeChecker(host) {
       type.constructSignatures = constructSignatures;
     }
   }
-  function resolveTypeAliasInstantiationMembers(type) {
-    const resolved = resolveStructuredTypeMembers(getResolvedTypeAliasInstantiation(type));
-    type.members = resolved.members;
-    type.properties = resolved.properties;
-    type.callSignatures = resolved.callSignatures;
-    type.constructSignatures = resolved.constructSignatures;
-    type.indexInfos = resolved.indexInfos;
-  }
   function replaceIndexedAccess(instantiable, type, replacement) {
     return instantiateType(instantiable, createTypeMapper([type.indexType, type.objectType], [getNumberLiteralType(0), createTupleType([replacement])]));
   }
@@ -54940,14 +54941,12 @@ function createTypeChecker(host) {
           resolveTypeReferenceMembers(type);
         } else if (type.objectFlags & 3 /* ClassOrInterface */) {
           resolveClassOrInterfaceMembers(type);
-        } else if (type.objectFlags & 2048 /* ReverseMapped */) {
+        } else if (type.objectFlags & 1024 /* ReverseMapped */) {
           resolveReverseMappedTypeMembers(type);
         } else if (type.objectFlags & 16 /* Anonymous */) {
           resolveAnonymousTypeMembers(type);
         } else if (type.objectFlags & 32 /* Mapped */) {
           resolveMappedTypeMembers(type);
-        } else if (type.objectFlags & 64 /* TypeAliasInstantiation */) {
-          resolveTypeAliasInstantiationMembers(type);
         } else {
           Debug.fail("Unhandled object type " + Debug.formatObjectFlags(type.objectFlags));
         }
@@ -55393,7 +55392,7 @@ function createTypeChecker(host) {
           if (indexInfo) {
             checkFlags |= 32 /* WritePartial */ | (indexInfo.isReadonly ? 8 /* Readonly */ : 0);
             indexTypes = append(indexTypes, isTupleType(type) ? getRestTypeOfTupleType(type) || undefinedType : indexInfo.type);
-          } else if (isObjectLiteralType(type) && !(getObjectFlags(type) & 4194304 /* ContainsSpread */)) {
+          } else if (isObjectLiteralType(type) && !(getObjectFlags(type) & 2097152 /* ContainsSpread */)) {
             checkFlags |= 32 /* WritePartial */;
             indexTypes = append(indexTypes, undefinedType);
           } else {
@@ -55519,22 +55518,22 @@ function createTypeChecker(host) {
     return property && !(getCheckFlags(property) & 16 /* ReadPartial */) ? property : void 0;
   }
   function getReducedType(type) {
-    if (type.flags & 1048576 /* Union */ && type.objectFlags & 33554432 /* ContainsIntersections */) {
+    if (type.flags & 1048576 /* Union */ && type.objectFlags & 16777216 /* ContainsIntersections */) {
       return type.resolvedReducedType || (type.resolvedReducedType = getReducedUnionType(type));
     } else if (type.flags & 2097152 /* Intersection */) {
-      if (!(type.objectFlags & 33554432 /* IsNeverIntersectionComputed */)) {
-        type.objectFlags |= 33554432 /* IsNeverIntersectionComputed */ | (some(getPropertiesOfUnionOrIntersectionType(type), isNeverReducedProperty) ? 67108864 /* IsNeverIntersection */ : 0);
+      if (!(type.objectFlags & 16777216 /* IsNeverIntersectionComputed */)) {
+        type.objectFlags |= 16777216 /* IsNeverIntersectionComputed */ | (some(getPropertiesOfUnionOrIntersectionType(type), isNeverReducedProperty) ? 33554432 /* IsNeverIntersection */ : 0);
       }
-      return type.objectFlags & 67108864 /* IsNeverIntersection */ ? neverType : type;
+      return type.objectFlags & 33554432 /* IsNeverIntersection */ ? neverType : type;
     }
-    return getResolvedType(type);
+    return type;
   }
   function getReducedUnionType(unionType) {
     const reducedTypes = sameMap(unionType.types, getReducedType);
     if (reducedTypes === unionType.types) {
       return unionType;
     }
-    const reduced = getResolvedType(getUnionType(reducedTypes));
+    const reduced = getUnionType(reducedTypes);
     if (reduced.flags & 1048576 /* Union */) {
       reduced.resolvedReducedType = reduced;
     }
@@ -55550,14 +55549,14 @@ function createTypeChecker(host) {
     return !prop.valueDeclaration && !!(getCheckFlags(prop) & 1024 /* ContainsPrivate */);
   }
   function isGenericReducibleType(type) {
-    return !!(type.flags & 1048576 /* Union */ && type.objectFlags & 33554432 /* ContainsIntersections */ && some(type.types, isGenericReducibleType) || type.flags & 2097152 /* Intersection */ && isReducibleIntersection(type));
+    return !!(type.flags & 1048576 /* Union */ && type.objectFlags & 16777216 /* ContainsIntersections */ && some(type.types, isGenericReducibleType) || type.flags & 2097152 /* Intersection */ && isReducibleIntersection(type));
   }
   function isReducibleIntersection(type) {
     const uniqueFilled = type.uniqueLiteralFilledInstantiation || (type.uniqueLiteralFilledInstantiation = instantiateType(type, uniqueLiteralMapper));
     return getReducedType(uniqueFilled) !== uniqueFilled;
   }
   function elaborateNeverIntersection(errorInfo, type) {
-    if (type.flags & 2097152 /* Intersection */ && getObjectFlags(type) & 67108864 /* IsNeverIntersection */) {
+    if (type.flags & 2097152 /* Intersection */ && getObjectFlags(type) & 33554432 /* IsNeverIntersection */) {
       const neverProp = find(getPropertiesOfUnionOrIntersectionType(type), isDiscriminantWithNeverType);
       if (neverProp) {
         return chainDiagnosticMessages(errorInfo, Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents, typeToString(
@@ -56343,7 +56342,7 @@ function createTypeChecker(host) {
         result |= getObjectFlags(type);
       }
     }
-    return result & 917504 /* PropagatingFlags */;
+    return result & 458752 /* PropagatingFlags */;
   }
   function tryCreateTypeReference(target, typeArguments) {
     if (some(typeArguments) && target === emptyGenericType) {
@@ -56430,7 +56429,7 @@ function createTypeChecker(host) {
           return errorType;
         }
       }
-      if (node.kind === 183 /* TypeReference */ && (getAliasSymbolForTypeNode(node) || isDeferredTypeReferenceNode(node, length(node.typeArguments) !== typeParameters.length))) {
+      if (node.kind === 183 /* TypeReference */ && isDeferredTypeReferenceNode(node, length(node.typeArguments) !== typeParameters.length)) {
         return createDeferredTypeReference(
           type,
           node,
@@ -56443,6 +56442,23 @@ function createTypeChecker(host) {
     }
     return checkNoTypeArguments(node, symbol) ? type : errorType;
   }
+  function getTypeAliasInstantiation(symbol, typeArguments, aliasSymbol, aliasTypeArguments) {
+    const type = getDeclaredTypeOfSymbol(symbol);
+    if (type === intrinsicMarkerType) {
+      const typeKind = intrinsicTypeKinds.get(symbol.escapedName);
+      if (typeKind !== void 0 && typeArguments && typeArguments.length === 1) {
+        return typeKind === 4 /* NoInfer */ ? getNoInferType(typeArguments[0]) : getStringMappingType(symbol, typeArguments[0]);
+      }
+    }
+    const links = getSymbolLinks(symbol);
+    const typeParameters = links.typeParameters;
+    const id = getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments);
+    let instantiation = links.instantiations.get(id);
+    if (!instantiation) {
+      links.instantiations.set(id, instantiation = instantiateTypeWithAlias(type, createTypeMapper(typeParameters, fillMissingTypeArguments(typeArguments, typeParameters, getMinTypeArgumentCount(typeParameters), isInJSFile(symbol.valueDeclaration))), aliasSymbol, aliasTypeArguments));
+    }
+    return instantiation;
+  }
   function getTypeFromTypeAliasReference(node, symbol) {
     if (getCheckFlags(symbol) & 1048576 /* Unresolved */) {
       const typeArguments = typeArgumentsFromTypeReferenceNode(node);
@@ -56493,13 +56509,10 @@ function createTypeChecker(host) {
           const resolved = resolveAlias(aliasSymbol2);
           if (resolved && resolved.flags & 524288 /* TypeAlias */) {
             newAliasSymbol = resolved;
-            aliasTypeArguments = typeArgumentsFromTypeReferenceNode(node) ?? [];
+            aliasTypeArguments = typeArgumentsFromTypeReferenceNode(node) || (typeParameters ? [] : void 0);
           }
         }
       }
-      if (getObjectFlags(type) & (4 /* Reference */ | 16 /* Anonymous */ | 32 /* Mapped */) && node.kind === 183 /* TypeReference */ && isDeferredTypeReferenceNode(node, length(node.typeArguments) !== typeParameters.length)) {
-        return createDeferredTypeAliasInstantiation(symbol, node, newAliasSymbol, aliasTypeArguments);
-      }
       return getTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node), newAliasSymbol, aliasTypeArguments);
     }
     return checkNoTypeArguments(node, symbol) ? type : errorType;
@@ -56509,43 +56522,6 @@ function createTypeChecker(host) {
     const declaration = (_a = symbol.declarations) == null ? void 0 : _a.find(isTypeAlias);
     return !!(declaration && getContainingFunction(declaration));
   }
-  function getTypeAliasInstantiation(symbol, typeArguments, aliasSymbol, aliasTypeArguments) {
-    const type = getDeclaredTypeOfSymbol(symbol);
-    if (type === intrinsicMarkerType) {
-      const typeKind = intrinsicTypeKinds.get(symbol.escapedName);
-      if (typeKind !== void 0 && typeArguments && typeArguments.length === 1) {
-        return typeKind === 4 /* NoInfer */ ? getNoInferType(typeArguments[0]) : getStringMappingType(symbol, typeArguments[0]);
-      }
-    }
-    const links = getSymbolLinks(symbol);
-    const typeParameters = links.typeParameters;
-    const id = getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments);
-    let instantiation = links.instantiations.get(id);
-    if (!instantiation) {
-      links.instantiations.set(id, instantiation = instantiateTypeWithAlias(type, createTypeMapper(typeParameters, fillMissingTypeArguments(typeArguments, typeParameters, getMinTypeArgumentCount(typeParameters), isInJSFile(symbol.valueDeclaration))), aliasSymbol, aliasTypeArguments));
-    }
-    return instantiation;
-  }
-  function createDeferredTypeAliasInstantiation(typeAlias, node, aliasSymbol, aliasTypeArguments) {
-    const type = getDeclaredTypeOfSymbol(typeAlias);
-    const result = createObjectType(64 /* TypeAliasInstantiation */, type.symbol);
-    result.typeAlias = typeAlias;
-    result.node = node;
-    result.aliasSymbol = aliasSymbol;
-    result.aliasTypeArguments = aliasTypeArguments;
-    return result;
-  }
-  function getResolvedType(type) {
-    return type.flags & 524288 /* Object */ && type.objectFlags & 64 /* TypeAliasInstantiation */ ? getResolvedTypeAliasInstantiation(type) : type;
-  }
-  function getResolvedTypeAliasInstantiation(type) {
-    if (!type.resolvedType) {
-      const typeArguments = typeArgumentsFromTypeReferenceNode(type.node);
-      const mappedTypeArguments = type.mapper ? instantiateTypes(typeArguments, type.mapper) : typeArguments;
-      type.resolvedType = getTypeAliasInstantiation(type.typeAlias, mappedTypeArguments, type.aliasSymbol, type.aliasTypeArguments);
-    }
-    return type.resolvedType;
-  }
   function getTypeReferenceName(node) {
     switch (node.kind) {
       case 183 /* TypeReference */:
@@ -57237,7 +57213,7 @@ function createTypeChecker(host) {
     return isNamedTupleMember(member) || isParameter(member) ? member : void 0;
   }
   function isDeferredTypeReferenceNode(node, hasDefaultTypeArguments) {
-    return isResolvedByTypeAlias(node) && (node.kind === 188 /* ArrayType */ ? mayResolveTypeAlias(node.elementType) : node.kind === 189 /* TupleType */ ? some(node.elements, mayResolveTypeAlias) : hasDefaultTypeArguments || some(node.typeArguments, mayResolveTypeAlias));
+    return !!getAliasSymbolForTypeNode(node) || isResolvedByTypeAlias(node) && (node.kind === 188 /* ArrayType */ ? mayResolveTypeAlias(node.elementType) : node.kind === 189 /* TupleType */ ? some(node.elements, mayResolveTypeAlias) : hasDefaultTypeArguments || some(node.typeArguments, mayResolveTypeAlias));
   }
   function isResolvedByTypeAlias(node) {
     const parent = node.parent;
@@ -57292,7 +57268,7 @@ function createTypeChecker(host) {
       const target = getArrayOrTupleTargetType(node);
       if (target === emptyGenericType) {
         links.resolvedType = emptyObjectType;
-      } else if (!(node.kind === 189 /* TupleType */ && some(node.elements, (e) => !!(getTupleElementFlags(e) & 8 /* Variadic */))) && (getAliasSymbolForTypeNode(node) || isDeferredTypeReferenceNode(node))) {
+      } else if (!(node.kind === 189 /* TupleType */ && some(node.elements, (e) => !!(getTupleElementFlags(e) & 8 /* Variadic */))) && isDeferredTypeReferenceNode(node)) {
         links.resolvedType = node.kind === 189 /* TupleType */ && node.elements.length === 0 ? target : createDeferredTypeReference(
           target,
           node,
@@ -57512,12 +57488,12 @@ function createTypeChecker(host) {
       includes |= flags & 473694207 /* IncludesMask */;
       if (flags & 465829888 /* Instantiable */)
         includes |= 33554432 /* IncludesInstantiable */;
-      if (flags & 2097152 /* Intersection */ && getObjectFlags(type) & 134217728 /* IsConstrainedTypeVariable */)
+      if (flags & 2097152 /* Intersection */ && getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */)
         includes |= 536870912 /* IncludesConstrainedTypeVariable */;
       if (type === wildcardType)
         includes |= 8388608 /* IncludesWildcard */;
       if (!strictNullChecks && flags & 98304 /* Nullable */) {
-        if (!(getObjectFlags(type) & 131072 /* ContainsWideningType */))
+        if (!(getObjectFlags(type) & 65536 /* ContainsWideningType */))
           includes |= 4194304 /* IncludesNonWideningType */;
       } else {
         const len = typeSet.length;
@@ -57624,7 +57600,7 @@ function createTypeChecker(host) {
   function removeConstrainedTypeVariables(types) {
     const typeVariables = [];
     for (const type of types) {
-      if (type.flags & 2097152 /* Intersection */ && getObjectFlags(type) & 134217728 /* IsConstrainedTypeVariable */) {
+      if (type.flags & 2097152 /* Intersection */ && getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */) {
         const index = type.types[0].flags & 8650752 /* TypeVariable */ ? 0 : 1;
         pushIfUnique(typeVariables, type.types[index]);
       }
@@ -57632,7 +57608,7 @@ function createTypeChecker(host) {
     for (const typeVariable of typeVariables) {
       const primitives = [];
       for (const type of types) {
-        if (type.flags & 2097152 /* Intersection */ && getObjectFlags(type) & 134217728 /* IsConstrainedTypeVariable */) {
+        if (type.flags & 2097152 /* Intersection */ && getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */) {
           const index = type.types[0].flags & 8650752 /* TypeVariable */ ? 0 : 1;
           if (type.types[index] === typeVariable) {
             insertType(primitives, type.types[1 - index]);
@@ -57645,7 +57621,7 @@ function createTypeChecker(host) {
         while (i > 0) {
           i--;
           const type = types[i];
-          if (type.flags & 2097152 /* Intersection */ && getObjectFlags(type) & 134217728 /* IsConstrainedTypeVariable */) {
+          if (type.flags & 2097152 /* Intersection */ && getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */) {
             const index = type.types[0].flags & 8650752 /* TypeVariable */ ? 0 : 1;
             if (type.types[index] === typeVariable && containsType(primitives, type.types[1 - index])) {
               orderedRemoveItemAt(types, i);
@@ -57754,7 +57730,7 @@ function createTypeChecker(host) {
         origin = createOriginUnionOrIntersectionType(1048576 /* Union */, reducedTypes);
       }
     }
-    const objectFlags = (includes & 36323331 /* NotPrimitiveUnion */ ? 0 : 65536 /* PrimitiveUnion */) | (includes & 2097152 /* Intersection */ ? 33554432 /* ContainsIntersections */ : 0);
+    const objectFlags = (includes & 36323331 /* NotPrimitiveUnion */ ? 0 : 32768 /* PrimitiveUnion */) | (includes & 2097152 /* Intersection */ ? 16777216 /* ContainsIntersections */ : 0);
     return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments, origin);
   }
   function getUnionOrIntersectionTypePredicate(signatures, kind) {
@@ -57905,14 +57881,14 @@ function createTypeChecker(host) {
   }
   function intersectUnionsOfPrimitiveTypes(types) {
     let unionTypes2;
-    const index = findIndex(types, (t) => !!(getObjectFlags(t) & 65536 /* PrimitiveUnion */));
+    const index = findIndex(types, (t) => !!(getObjectFlags(t) & 32768 /* PrimitiveUnion */));
     if (index < 0) {
       return false;
     }
     let i = index + 1;
     while (i < types.length) {
       const t = types[i];
-      if (getObjectFlags(t) & 65536 /* PrimitiveUnion */) {
+      if (getObjectFlags(t) & 32768 /* PrimitiveUnion */) {
         (unionTypes2 || (unionTypes2 = [types[index]])).push(t);
         orderedRemoveItemAt(types, i);
       } else {
@@ -57933,7 +57909,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    types[index] = getUnionTypeFromSortedList(result, 65536 /* PrimitiveUnion */);
+    types[index] = getUnionTypeFromSortedList(result, 32768 /* PrimitiveUnion */);
     return true;
   }
   function createIntersectionType(types, objectFlags, aliasSymbol, aliasTypeArguments) {
@@ -57996,7 +57972,7 @@ function createTypeChecker(host) {
               return neverType;
             }
           }
-          objectFlags = 134217728 /* IsConstrainedTypeVariable */;
+          objectFlags = 67108864 /* IsConstrainedTypeVariable */;
         }
       }
     }
@@ -58349,7 +58325,7 @@ function createTypeChecker(host) {
     if (noImplicitAny) {
       return false;
     }
-    if (getObjectFlags(type) & 8192 /* JSLiteral */) {
+    if (getObjectFlags(type) & 4096 /* JSLiteral */) {
       return true;
     }
     if (type.flags & 1048576 /* Union */) {
@@ -58597,28 +58573,28 @@ function createTypeChecker(host) {
     return !!getGenericObjectFlags(type);
   }
   function isGenericObjectType(type) {
-    return !!(getGenericObjectFlags(type) & 8388608 /* IsGenericObjectType */);
+    return !!(getGenericObjectFlags(type) & 4194304 /* IsGenericObjectType */);
   }
   function isGenericIndexType(type) {
-    return !!(getGenericObjectFlags(type) & 16777216 /* IsGenericIndexType */);
+    return !!(getGenericObjectFlags(type) & 8388608 /* IsGenericIndexType */);
   }
   function getGenericObjectFlags(type) {
     if (type.flags & 3145728 /* UnionOrIntersection */) {
-      if (!(type.objectFlags & 4194304 /* IsGenericTypeComputed */)) {
-        type.objectFlags |= 4194304 /* IsGenericTypeComputed */ | reduceLeft(type.types, (flags, t) => flags | getGenericObjectFlags(t), 0);
+      if (!(type.objectFlags & 2097152 /* IsGenericTypeComputed */)) {
+        type.objectFlags |= 2097152 /* IsGenericTypeComputed */ | reduceLeft(type.types, (flags, t) => flags | getGenericObjectFlags(t), 0);
       }
-      return type.objectFlags & 25165824 /* IsGenericType */;
+      return type.objectFlags & 12582912 /* IsGenericType */;
     }
     if (type.flags & 33554432 /* Substitution */) {
-      if (!(type.objectFlags & 4194304 /* IsGenericTypeComputed */)) {
-        type.objectFlags |= 4194304 /* IsGenericTypeComputed */ | getGenericObjectFlags(type.baseType) | getGenericObjectFlags(type.constraint);
+      if (!(type.objectFlags & 2097152 /* IsGenericTypeComputed */)) {
+        type.objectFlags |= 2097152 /* IsGenericTypeComputed */ | getGenericObjectFlags(type.baseType) | getGenericObjectFlags(type.constraint);
       }
-      return type.objectFlags & 25165824 /* IsGenericType */;
+      return type.objectFlags & 12582912 /* IsGenericType */;
     }
-    return (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(getResolvedType(type)) || isGenericTupleType(type) ? 8388608 /* IsGenericObjectType */ : 0) | (type.flags & (58982400 /* InstantiableNonPrimitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && !isPatternLiteralType(type) ? 16777216 /* IsGenericIndexType */ : 0);
+    return (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type) || isGenericTupleType(type) ? 4194304 /* IsGenericObjectType */ : 0) | (type.flags & (58982400 /* InstantiableNonPrimitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && !isPatternLiteralType(type) ? 8388608 /* IsGenericIndexType */ : 0);
   }
   function getSimplifiedType(type, writing) {
-    return type.flags & 8388608 /* IndexedAccess */ ? getSimplifiedIndexedAccessType(type, writing) : type.flags & 16777216 /* Conditional */ ? getSimplifiedConditionalType(type, writing) : getResolvedType(type);
+    return type.flags & 8388608 /* IndexedAccess */ ? getSimplifiedIndexedAccessType(type, writing) : type.flags & 16777216 /* Conditional */ ? getSimplifiedConditionalType(type, writing) : type;
   }
   function distributeIndexOverObjectType(objectType, indexType, writing) {
     if (objectType.flags & 1048576 /* Union */ || objectType.flags & 2097152 /* Intersection */ && !shouldDeferIndexType(objectType)) {
@@ -59118,7 +59094,7 @@ function createTypeChecker(host) {
         }
       }
       const spread = createAnonymousType(type2.symbol, members, emptyArray, emptyArray, getIndexInfosOfType(type2));
-      spread.objectFlags |= 256 /* ObjectLiteral */ | 262144 /* ContainsObjectOrArrayLiteral */;
+      spread.objectFlags |= 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
       return spread;
     }
   }
@@ -59195,7 +59171,7 @@ function createTypeChecker(host) {
       }
     }
     const spread = createAnonymousType(symbol, members, emptyArray, emptyArray, sameMap(indexInfos, (info) => getIndexInfoWithReadonly(info, readonly)));
-    spread.objectFlags |= 256 /* ObjectLiteral */ | 262144 /* ContainsObjectOrArrayLiteral */ | 4194304 /* ContainsSpread */ | objectFlags;
+    spread.objectFlags |= 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */ | 2097152 /* ContainsSpread */ | objectFlags;
     return spread;
   }
   function isSpreadableProperty(prop) {
@@ -59616,9 +59592,9 @@ function createTypeChecker(host) {
     return result;
   }
   function getObjectTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) {
-    const declaration = type.objectFlags & 4 /* Reference */ ? type.node : type.objectFlags & 16777216 /* InstantiationExpressionType */ ? type.node : type.objectFlags & 64 /* TypeAliasInstantiation */ ? type.node : type.symbol.declarations[0];
+    const declaration = type.objectFlags & 4 /* Reference */ ? type.node : type.objectFlags & 8388608 /* InstantiationExpressionType */ ? type.node : type.symbol.declarations[0];
     const links = getNodeLinks(declaration);
-    const target = type.objectFlags & 4 /* Reference */ ? links.resolvedType : type.objectFlags & 128 /* Instantiated */ ? type.target : type;
+    const target = type.objectFlags & 4 /* Reference */ ? links.resolvedType : type.objectFlags & 64 /* Instantiated */ ? type.target : type;
     let typeParameters = links.outerTypeParameters;
     if (!typeParameters) {
       let outerTypeParameters = getOuterTypeParameters(
@@ -59631,8 +59607,8 @@ function createTypeChecker(host) {
         outerTypeParameters = addRange(outerTypeParameters, templateTagParameters);
       }
       typeParameters = outerTypeParameters || emptyArray;
-      const allDeclarations = type.objectFlags & (4 /* Reference */ | 16777216 /* InstantiationExpressionType */ | 64 /* TypeAliasInstantiation */) ? [declaration] : type.symbol.declarations;
-      typeParameters = (target.objectFlags & (4 /* Reference */ | 16777216 /* InstantiationExpressionType */ | 64 /* TypeAliasInstantiation */) || target.symbol.flags & 8192 /* Method */ || target.symbol.flags & 2048 /* TypeLiteral */) && !target.aliasTypeArguments ? filter(typeParameters, (tp) => some(allDeclarations, (d) => isTypeParameterPossiblyReferenced(tp, d))) : typeParameters;
+      const allDeclarations = type.objectFlags & (4 /* Reference */ | 8388608 /* InstantiationExpressionType */) ? [declaration] : type.symbol.declarations;
+      typeParameters = (target.objectFlags & (4 /* Reference */ | 8388608 /* InstantiationExpressionType */) || target.symbol.flags & 8192 /* Method */ || target.symbol.flags & 2048 /* TypeLiteral */) && !target.aliasTypeArguments ? filter(typeParameters, (tp) => some(allDeclarations, (d) => isTypeParameterPossiblyReferenced(tp, d))) : typeParameters;
       links.outerTypeParameters = typeParameters;
     }
     if (typeParameters.length) {
@@ -59651,13 +59627,13 @@ 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 & 1048576 /* CouldContainTypeVariablesComputed */)) {
+        if (result.flags & 3899393 /* ObjectFlagsType */ && !(resultObjectFlags & 524288 /* CouldContainTypeVariablesComputed */)) {
           const resultCouldContainTypeVariables = some(typeArguments, couldContainTypeVariables);
-          if (!(getObjectFlags(result) & 1048576 /* CouldContainTypeVariablesComputed */)) {
+          if (!(getObjectFlags(result) & 524288 /* CouldContainTypeVariablesComputed */)) {
             if (resultObjectFlags & (32 /* Mapped */ | 16 /* Anonymous */ | 4 /* Reference */)) {
-              result.objectFlags |= 1048576 /* CouldContainTypeVariablesComputed */ | (resultCouldContainTypeVariables ? 2097152 /* CouldContainTypeVariables */ : 0);
+              result.objectFlags |= 524288 /* CouldContainTypeVariablesComputed */ | (resultCouldContainTypeVariables ? 1048576 /* CouldContainTypeVariables */ : 0);
             } else {
-              result.objectFlags |= !resultCouldContainTypeVariables ? 1048576 /* CouldContainTypeVariablesComputed */ : 0;
+              result.objectFlags |= !resultCouldContainTypeVariables ? 524288 /* CouldContainTypeVariablesComputed */ : 0;
             }
           }
         }
@@ -59787,7 +59763,8 @@ function createTypeChecker(host) {
     ) : strictNullChecks && modifiers & 8 /* ExcludeOptional */ && isOptional ? getTypeWithFacts(propType, 524288 /* NEUndefined */) : propType;
   }
   function instantiateAnonymousType(type, mapper, aliasSymbol, aliasTypeArguments) {
-    const result = createObjectType(type.objectFlags & ~(1048576 /* CouldContainTypeVariablesComputed */ | 2097152 /* CouldContainTypeVariables */) | 128 /* Instantiated */, type.symbol);
+    Debug.assert(type.symbol, "anonymous type must have symbol to be instantiated");
+    const result = createObjectType(type.objectFlags & ~(524288 /* CouldContainTypeVariablesComputed */ | 1048576 /* CouldContainTypeVariables */) | 64 /* Instantiated */, type.symbol);
     if (type.objectFlags & 32 /* Mapped */) {
       result.declaration = type.declaration;
       const origTypeParameter = getTypeParameterFromMappedType(type);
@@ -59795,10 +59772,8 @@ function createTypeChecker(host) {
       result.typeParameter = freshTypeParameter;
       mapper = combineTypeMappers(makeUnaryTypeMapper(origTypeParameter, freshTypeParameter), mapper);
       freshTypeParameter.mapper = mapper;
-    } else if (type.objectFlags & 16777216 /* InstantiationExpressionType */) {
-      result.node = type.node;
-    } else if (type.objectFlags & 64 /* TypeAliasInstantiation */) {
-      result.typeAlias = type.typeAlias;
+    }
+    if (type.objectFlags & 8388608 /* InstantiationExpressionType */) {
       result.node = type.node;
     }
     result.target = type;
@@ -59859,13 +59834,13 @@ function createTypeChecker(host) {
     }
     if (flags & 524288 /* Object */) {
       const objectFlags = type.objectFlags;
-      if (objectFlags & (4 /* Reference */ | 16 /* Anonymous */ | 32 /* Mapped */ | 64 /* TypeAliasInstantiation */)) {
+      if (objectFlags & (4 /* Reference */ | 16 /* Anonymous */ | 32 /* Mapped */)) {
         if (objectFlags & 4 /* Reference */ && !type.node) {
           const resolvedTypeArguments = type.resolvedTypeArguments;
           const newTypeArguments = instantiateTypes(resolvedTypeArguments, mapper);
           return newTypeArguments !== resolvedTypeArguments ? createNormalizedTypeReference(type.target, newTypeArguments) : type;
         }
-        if (objectFlags & 2048 /* ReverseMapped */) {
+        if (objectFlags & 1024 /* ReverseMapped */) {
           return instantiateReverseMappedType(type, mapper);
         }
         return getObjectTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments);
@@ -60737,6 +60712,8 @@ function createTypeChecker(host) {
             errorReporter(Diagnostics.Signature_0_must_be_a_type_predicate, signatureToString(source));
           }
           return 0 /* False */;
+        } else if (isThisTypePredicate(targetTypePredicate)) {
+          result &= compareTypes(sourceReturnType, targetReturnType, reportErrors2);
         }
       } else {
         result &= checkMode & 1 /* BivariantCallback */ && compareTypes(
@@ -60801,11 +60778,11 @@ function createTypeChecker(host) {
   }
   function isUnknownLikeUnionType(type) {
     if (strictNullChecks && type.flags & 1048576 /* Union */) {
-      if (!(type.objectFlags & 67108864 /* IsUnknownLikeUnionComputed */)) {
+      if (!(type.objectFlags & 33554432 /* IsUnknownLikeUnionComputed */)) {
         const types = type.types;
-        type.objectFlags |= 67108864 /* IsUnknownLikeUnionComputed */ | (types.length >= 3 && types[0].flags & 32768 /* Undefined */ && types[1].flags & 65536 /* Null */ && some(types, isEmptyAnonymousObjectType) ? 134217728 /* IsUnknownLikeUnion */ : 0);
+        type.objectFlags |= 33554432 /* IsUnknownLikeUnionComputed */ | (types.length >= 3 && types[0].flags & 32768 /* Undefined */ && types[1].flags & 65536 /* Null */ && some(types, isEmptyAnonymousObjectType) ? 67108864 /* IsUnknownLikeUnion */ : 0);
       }
-      return !!(type.objectFlags & 134217728 /* IsUnknownLikeUnion */);
+      return !!(type.objectFlags & 67108864 /* IsUnknownLikeUnion */);
     }
     return false;
   }
@@ -60916,7 +60893,7 @@ function createTypeChecker(host) {
       return true;
     if (s & 65536 /* Null */ && (!strictNullChecks && !(t & 3145728 /* UnionOrIntersection */) || t & 65536 /* Null */))
       return true;
-    if (s & 524288 /* Object */ && t & 67108864 /* NonPrimitive */ && !(relation === strictSubtypeRelation && isEmptyAnonymousObjectType(source) && !(getObjectFlags(source) & 16384 /* FreshLiteral */)))
+    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 */)
@@ -60975,11 +60952,11 @@ function createTypeChecker(host) {
     return false;
   }
   function isIgnoredJsxProperty(source, sourceProp) {
-    return getObjectFlags(source) & 4096 /* JsxAttributes */ && isHyphenatedJsxName(sourceProp.escapedName);
+    return getObjectFlags(source) & 2048 /* JsxAttributes */ && isHyphenatedJsxName(sourceProp.escapedName);
   }
   function getNormalizedType(type, writing) {
     while (true) {
-      const t = isFreshLiteralType(type) ? type.regularType : isGenericTupleType(type) ? getNormalizedTupleType(type, writing) : getObjectFlags(type) & 4 /* Reference */ ? type.node ? createTypeReference(type.target, getTypeArguments(type)) : getSingleBaseForNonAugmentingSubtype(type) || type : getObjectFlags(type) & 64 /* TypeAliasInstantiation */ ? getResolvedTypeAliasInstantiation(type) : type.flags & 3145728 /* UnionOrIntersection */ ? getNormalizedUnionOrIntersectionType(type, writing) : type.flags & 33554432 /* Substitution */ ? writing ? type.baseType : getSubstitutionIntersection(type) : type.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(type, writing) : type;
+      const t = isFreshLiteralType(type) ? type.regularType : isGenericTupleType(type) ? getNormalizedTupleType(type, writing) : getObjectFlags(type) & 4 /* Reference */ ? type.node ? createTypeReference(type.target, getTypeArguments(type)) : getSingleBaseForNonAugmentingSubtype(type) || type : type.flags & 3145728 /* UnionOrIntersection */ ? getNormalizedUnionOrIntersectionType(type, writing) : type.flags & 33554432 /* Substitution */ ? writing ? type.baseType : getSubstitutionIntersection(type) : type.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(type, writing) : type;
       if (t === type)
         return t;
       type = t;
@@ -61369,7 +61346,7 @@ function createTypeChecker(host) {
       if (relation === comparableRelation && !(target2.flags & 131072 /* Never */) && isSimpleTypeRelatedTo(target2, source2, relation) || isSimpleTypeRelatedTo(source2, target2, relation, reportErrors2 ? reportError : void 0))
         return -1 /* True */;
       if (source2.flags & 469499904 /* StructuredOrInstantiable */ || target2.flags & 469499904 /* StructuredOrInstantiable */) {
-        const isPerformingExcessPropertyChecks = !(intersectionState & 2 /* Target */) && (isObjectLiteralType(source2) && getObjectFlags(source2) & 16384 /* FreshLiteral */);
+        const isPerformingExcessPropertyChecks = !(intersectionState & 2 /* Target */) && (isObjectLiteralType(source2) && getObjectFlags(source2) & 8192 /* FreshLiteral */);
         if (isPerformingExcessPropertyChecks) {
           if (hasExcessProperties(source2, target2, reportErrors2)) {
             if (reportErrors2) {
@@ -61379,7 +61356,7 @@ function createTypeChecker(host) {
           }
         }
         const isPerformingCommonPropertyChecks = (relation !== comparableRelation || isUnitType(source2)) && !(intersectionState & 2 /* Target */) && source2.flags & (402784252 /* Primitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && source2 !== globalObjectType && target2.flags & (524288 /* Object */ | 2097152 /* Intersection */) && isWeakType(target2) && (getPropertiesOfType(source2).length > 0 || typeHasCallOrConstructSignatures(source2));
-        const isComparingJsxAttributes = !!(getObjectFlags(source2) & 4096 /* JsxAttributes */);
+        const isComparingJsxAttributes = !!(getObjectFlags(source2) & 2048 /* JsxAttributes */);
         if (isPerformingCommonPropertyChecks && !hasCommonProperties(source2, target2, isComparingJsxAttributes)) {
           if (reportErrors2) {
             const sourceString = typeToString(originalSource.aliasSymbol ? originalSource : source2);
@@ -61444,7 +61421,7 @@ function createTypeChecker(host) {
         tryElaborateErrorsForPrimitivesAndObjects(source2, target2);
       } else if (source2.symbol && source2.flags & 524288 /* Object */ && globalObjectType === source2) {
         reportError(Diagnostics.The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead);
-      } else if (getObjectFlags(source2) & 4096 /* JsxAttributes */ && target2.flags & 2097152 /* Intersection */) {
+      } else if (getObjectFlags(source2) & 2048 /* JsxAttributes */ && target2.flags & 2097152 /* Intersection */) {
         const targetTypes = target2.types;
         const intrinsicAttributes = getJsxType(JsxNames.IntrinsicAttributes, errorNode);
         const intrinsicClassAttributes = getJsxType(JsxNames.IntrinsicClassAttributes, errorNode);
@@ -61475,7 +61452,7 @@ function createTypeChecker(host) {
       if (source2.flags & 3145728 /* UnionOrIntersection */ && target2.flags & 3145728 /* UnionOrIntersection */) {
         const sourceUnionOrIntersection = source2;
         const targetUnionOrIntersection = target2;
-        if (sourceUnionOrIntersection.objectFlags & targetUnionOrIntersection.objectFlags & 65536 /* PrimitiveUnion */) {
+        if (sourceUnionOrIntersection.objectFlags & targetUnionOrIntersection.objectFlags & 32768 /* PrimitiveUnion */) {
           return;
         }
         const sourceSize = sourceUnionOrIntersection.types.length;
@@ -61509,10 +61486,10 @@ function createTypeChecker(host) {
     }
     function hasExcessProperties(source2, target2, reportErrors2) {
       var _a2;
-      if (!isExcessPropertyCheckTarget(target2) || !noImplicitAny && getObjectFlags(target2) & 8192 /* JSLiteral */) {
+      if (!isExcessPropertyCheckTarget(target2) || !noImplicitAny && getObjectFlags(target2) & 4096 /* JSLiteral */) {
         return false;
       }
-      const isComparingJsxAttributes = !!(getObjectFlags(source2) & 4096 /* JsxAttributes */);
+      const isComparingJsxAttributes = !!(getObjectFlags(source2) & 2048 /* JsxAttributes */);
       if ((relation === assignableRelation || relation === comparableRelation) && (isTypeSubsetOf(globalObjectType, target2) || !isComparingJsxAttributes && isEmptyObjectType(target2))) {
         return false;
       }
@@ -61651,7 +61628,7 @@ function createTypeChecker(host) {
         if (containsType(targetTypes, source2)) {
           return -1 /* True */;
         }
-        if (relation !== comparableRelation && getObjectFlags(target2) & 65536 /* 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 & 1024 /* EnumLiteral */) && (source2.flags & (128 /* StringLiteral */ | 512 /* BooleanLiteral */ | 2048 /* BigIntLiteral */) || (relation === subtypeRelation || relation === strictSubtypeRelation) && source2.flags & 256 /* 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;
           return primitive && containsType(targetTypes, primitive) || alternateForm && containsType(targetTypes, alternateForm) ? -1 /* True */ : 0 /* False */;
@@ -62055,7 +62032,7 @@ function createTypeChecker(host) {
             false,
             0 /* None */
           );
-          if (result2 && isObjectLiteralType(source2) && getObjectFlags(source2) & 16384 /* FreshLiteral */) {
+          if (result2 && isObjectLiteralType(source2) && getObjectFlags(source2) & 8192 /* FreshLiteral */) {
             result2 &= indexSignaturesRelatedTo(
               source2,
               target2,
@@ -62065,7 +62042,7 @@ function createTypeChecker(host) {
               0 /* None */
             );
           }
-        } else if (result2 && isNonGenericObjectType(target2) && !isArrayOrTupleType(target2) && source2.flags & 2097152 /* Intersection */ && getApparentType(source2).flags & 3670016 /* StructuredType */ && !some(source2.types, (t) => t === target2 || !!(getObjectFlags(t) & 524288 /* NonInferrableType */))) {
+        } else if (result2 && isNonGenericObjectType(target2) && !isArrayOrTupleType(target2) && source2.flags & 2097152 /* Intersection */ && getApparentType(source2).flags & 3670016 /* StructuredType */ && !some(source2.types, (t) => t === target2 || !!(getObjectFlags(t) & 262144 /* NonInferrableType */))) {
           result2 &= propertiesRelatedTo(
             source2,
             target2,
@@ -62566,7 +62543,7 @@ function createTypeChecker(host) {
           if (constraint !== source2) {
             return isRelatedTo(constraint, target2, 1 /* Source */, reportErrors2);
           }
-        } else if ((relation === subtypeRelation || relation === strictSubtypeRelation) && isEmptyObjectType(target2) && getObjectFlags(target2) & 16384 /* FreshLiteral */ && !isEmptyObjectType(source2)) {
+        } else if ((relation === subtypeRelation || relation === strictSubtypeRelation) && isEmptyObjectType(target2) && getObjectFlags(target2) & 8192 /* FreshLiteral */ && !isEmptyObjectType(source2)) {
           return 0 /* False */;
         }
         if (sourceFlags & (524288 /* Object */ | 2097152 /* Intersection */) && targetFlags & 524288 /* Object */) {
@@ -63098,7 +63075,7 @@ function createTypeChecker(host) {
       const incompatibleReporter = kind === 1 /* Construct */ ? reportIncompatibleConstructSignatureReturn : reportIncompatibleCallSignatureReturn;
       const sourceObjectFlags = getObjectFlags(source2);
       const targetObjectFlags = getObjectFlags(target2);
-      if (sourceObjectFlags & 128 /* Instantiated */ && targetObjectFlags & 128 /* Instantiated */ && source2.symbol === target2.symbol || sourceObjectFlags & 4 /* Reference */ && targetObjectFlags & 4 /* Reference */ && source2.target === target2.target) {
+      if (sourceObjectFlags & 64 /* Instantiated */ && targetObjectFlags & 64 /* Instantiated */ && source2.symbol === target2.symbol || sourceObjectFlags & 4 /* Reference */ && targetObjectFlags & 4 /* Reference */ && source2.target === target2.target) {
         Debug.assertEqual(sourceSignatures.length, targetSignatures.length);
         for (let i = 0; i < targetSignatures.length; i++) {
           const related = signatureRelatedTo(
@@ -63314,7 +63291,7 @@ function createTypeChecker(host) {
       if (sourceInfo) {
         return indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors2, intersectionState);
       }
-      if (!(intersectionState & 1 /* Source */) && (relation !== strictSubtypeRelation || getObjectFlags(source2) & 16384 /* FreshLiteral */) && isObjectTypeWithInferableIndex(source2)) {
+      if (!(intersectionState & 1 /* Source */) && (relation !== strictSubtypeRelation || getObjectFlags(source2) & 8192 /* FreshLiteral */) && isObjectTypeWithInferableIndex(source2)) {
         return membersRelatedToIndexInfo(source2, targetInfo, reportErrors2, intersectionState);
       }
       if (reportErrors2) {
@@ -63588,11 +63565,11 @@ function createTypeChecker(host) {
   }
   function isDeeplyNestedType(type, stack, depth, maxDepth = 3) {
     if (depth >= maxDepth) {
-      if ((getObjectFlags(type) & 160 /* InstantiatedMapped */) === 160 /* InstantiatedMapped */) {
+      if ((getObjectFlags(type) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */) {
         type = getMappedTargetWithSymbol(type);
       }
       if (type.flags & 2097152 /* Intersection */) {
-        return some(type.types, (t) => isDeeplyNestedType(getResolvedType(t), stack, depth, maxDepth));
+        return some(type.types, (t) => isDeeplyNestedType(t, stack, depth, maxDepth));
       }
       const identity2 = getRecursionIdentity(type);
       let count = 0;
@@ -63614,17 +63591,17 @@ function createTypeChecker(host) {
   }
   function getMappedTargetWithSymbol(type) {
     let target;
-    while ((getObjectFlags(type) & 160 /* InstantiatedMapped */) === 160 /* InstantiatedMapped */ && (target = getModifiersTypeFromMappedType(type)) && (target.symbol || target.flags & 2097152 /* Intersection */ && some(target.types, (t) => !!t.symbol))) {
+    while ((getObjectFlags(type) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */ && (target = getModifiersTypeFromMappedType(type)) && (target.symbol || target.flags & 2097152 /* Intersection */ && some(target.types, (t) => !!t.symbol))) {
       type = target;
     }
     return type;
   }
   function hasMatchingRecursionIdentity(type, identity2) {
-    if ((getObjectFlags(type) & 160 /* InstantiatedMapped */) === 160 /* InstantiatedMapped */) {
+    if ((getObjectFlags(type) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */) {
       type = getMappedTargetWithSymbol(type);
     }
     if (type.flags & 2097152 /* Intersection */) {
-      return some(type.types, (t) => hasMatchingRecursionIdentity(getResolvedType(t), identity2));
+      return some(type.types, (t) => hasMatchingRecursionIdentity(t, identity2));
     }
     return getRecursionIdentity(type) === identity2;
   }
@@ -63807,10 +63784,10 @@ function createTypeChecker(host) {
     if (!(getObjectFlags(type) & 4 /* Reference */) || !(getObjectFlags(type.target) & 3 /* ClassOrInterface */)) {
       return void 0;
     }
-    if (getObjectFlags(type) & 67108864 /* IdenticalBaseTypeCalculated */) {
-      return getObjectFlags(type) & 134217728 /* IdenticalBaseTypeExists */ ? type.cachedEquivalentBaseType : void 0;
+    if (getObjectFlags(type) & 33554432 /* IdenticalBaseTypeCalculated */) {
+      return getObjectFlags(type) & 67108864 /* IdenticalBaseTypeExists */ ? type.cachedEquivalentBaseType : void 0;
     }
-    type.objectFlags |= 67108864 /* IdenticalBaseTypeCalculated */;
+    type.objectFlags |= 33554432 /* IdenticalBaseTypeCalculated */;
     const target = type.target;
     if (getObjectFlags(target) & 1 /* Class */) {
       const baseTypeNode = getBaseTypeNodeOfClass(target);
@@ -63829,7 +63806,7 @@ function createTypeChecker(host) {
     if (length(getTypeArguments(type)) > length(target.typeParameters)) {
       instantiatedBase = getTypeWithThisArgument(instantiatedBase, last(getTypeArguments(type)));
     }
-    type.objectFlags |= 134217728 /* IdenticalBaseTypeExists */;
+    type.objectFlags |= 67108864 /* IdenticalBaseTypeExists */;
     return type.cachedEquivalentBaseType = instantiatedBase;
   }
   function isEmptyLiteralType(type) {
@@ -64014,7 +63991,7 @@ function createTypeChecker(host) {
   }
   function isObjectTypeWithInferableIndex(type) {
     const objectFlags = getObjectFlags(type);
-    return type.flags & 2097152 /* Intersection */ ? every(type.types, isObjectTypeWithInferableIndex) : !!(type.symbol && (type.symbol.flags & (4096 /* ObjectLiteral */ | 2048 /* TypeLiteral */ | 384 /* Enum */ | 512 /* ValueModule */)) !== 0 && !(type.symbol.flags & 32 /* Class */) && !typeHasCallOrConstructSignatures(type)) || !!(objectFlags & 8388608 /* ObjectRestType */) || !!(objectFlags & 2048 /* ReverseMapped */ && isObjectTypeWithInferableIndex(type.source));
+    return type.flags & 2097152 /* Intersection */ ? every(type.types, isObjectTypeWithInferableIndex) : !!(type.symbol && (type.symbol.flags & (4096 /* ObjectLiteral */ | 2048 /* TypeLiteral */ | 384 /* Enum */ | 512 /* ValueModule */)) !== 0 && !(type.symbol.flags & 32 /* Class */) && !typeHasCallOrConstructSignatures(type)) || !!(objectFlags & 4194304 /* ObjectRestType */) || !!(objectFlags & 1024 /* ReverseMapped */ && isObjectTypeWithInferableIndex(type.source));
   }
   function createSymbolWithType(source, type) {
     const symbol = createSymbol(source.flags, source.escapedName, getCheckFlags(source) & 8 /* Readonly */);
@@ -64041,7 +64018,7 @@ function createTypeChecker(host) {
     return members;
   }
   function getRegularTypeOfObjectLiteral(type) {
-    if (!(isObjectLiteralType(type) && getObjectFlags(type) & 16384 /* FreshLiteral */)) {
+    if (!(isObjectLiteralType(type) && getObjectFlags(type) & 8192 /* FreshLiteral */)) {
       return type;
     }
     const regularType = type.regularType;
@@ -64052,7 +64029,7 @@ function createTypeChecker(host) {
     const members = transformTypeOfMembers(type, getRegularTypeOfObjectLiteral);
     const regularNew = createAnonymousType(resolved.symbol, members, resolved.callSignatures, resolved.constructSignatures, resolved.indexInfos);
     regularNew.flags = resolved.flags;
-    regularNew.objectFlags |= resolved.objectFlags & ~16384 /* FreshLiteral */;
+    regularNew.objectFlags |= resolved.objectFlags & ~8192 /* FreshLiteral */;
     type.regularType = regularNew;
     return regularNew;
   }
@@ -64080,7 +64057,7 @@ function createTypeChecker(host) {
     if (!context.resolvedProperties) {
       const names = /* @__PURE__ */ new Map();
       for (const t of getSiblingsOfContext(context)) {
-        if (isObjectLiteralType(t) && !(getObjectFlags(t) & 4194304 /* ContainsSpread */)) {
+        if (isObjectLiteralType(t) && !(getObjectFlags(t) & 2097152 /* ContainsSpread */)) {
           for (const prop of getPropertiesOfType(t)) {
             names.set(prop.escapedName, prop);
           }
@@ -64127,7 +64104,7 @@ function createTypeChecker(host) {
       }
     }
     const result = createAnonymousType(type.symbol, members, emptyArray, emptyArray, sameMap(getIndexInfosOfType(type), (info) => createIndexInfo(info.keyType, getWidenedType(info.type), info.isReadonly)));
-    result.objectFlags |= getObjectFlags(type) & (8192 /* JSLiteral */ | 524288 /* NonInferrableType */);
+    result.objectFlags |= getObjectFlags(type) & (4096 /* JSLiteral */ | 262144 /* NonInferrableType */);
     return result;
   }
   function getWidenedType(type) {
@@ -64138,7 +64115,7 @@ function createTypeChecker(host) {
     );
   }
   function getWidenedTypeWithContext(type, context) {
-    if (getObjectFlags(type) & 393216 /* RequiresWidening */) {
+    if (getObjectFlags(type) & 196608 /* RequiresWidening */) {
       if (context === void 0 && type.widened) {
         return type.widened;
       }
@@ -64171,7 +64148,7 @@ function createTypeChecker(host) {
   }
   function reportWideningErrorsInType(type) {
     let errorReported = false;
-    if (getObjectFlags(type) & 131072 /* ContainsWideningType */) {
+    if (getObjectFlags(type) & 65536 /* ContainsWideningType */) {
       if (type.flags & 1048576 /* Union */) {
         if (some(type.types, isEmptyObjectType)) {
           errorReported = true;
@@ -64193,7 +64170,7 @@ function createTypeChecker(host) {
       if (isObjectLiteralType(type)) {
         for (const p of getPropertiesOfObjectType(type)) {
           const t = getTypeOfSymbol(p);
-          if (getObjectFlags(t) & 131072 /* ContainsWideningType */) {
+          if (getObjectFlags(t) & 65536 /* ContainsWideningType */) {
             if (!reportWideningErrorsInType(t)) {
               error(p.valueDeclaration, Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, symbolToString(p), typeToString(getWidenedType(t)));
             }
@@ -64281,7 +64258,7 @@ function createTypeChecker(host) {
   }
   function reportErrorsFromWidening(declaration, type, wideningKind) {
     addLazyDiagnostic(() => {
-      if (noImplicitAny && getObjectFlags(type) & 131072 /* ContainsWideningType */ && (!wideningKind || !getContextualSignatureForFunctionLikeDeclaration(declaration))) {
+      if (noImplicitAny && getObjectFlags(type) & 65536 /* ContainsWideningType */ && (!wideningKind || !getContextualSignatureForFunctionLikeDeclaration(declaration))) {
         if (!reportWideningErrorsInType(type)) {
           reportImplicitAny(declaration, type, wideningKind);
         }
@@ -64418,12 +64395,12 @@ function createTypeChecker(host) {
   }
   function couldContainTypeVariables(type) {
     const objectFlags = getObjectFlags(type);
-    if (objectFlags & 1048576 /* CouldContainTypeVariablesComputed */) {
-      return !!(objectFlags & 2097152 /* CouldContainTypeVariables */);
+    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 & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 2048 /* ReverseMapped */ | 8388608 /* ObjectRestType */ | 16777216 /* InstantiationExpressionType */ | 64 /* TypeAliasInstantiation */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
+    const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || 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 */) {
-      type.objectFlags |= 1048576 /* CouldContainTypeVariablesComputed */ | (result ? 2097152 /* CouldContainTypeVariables */ : 0);
+      type.objectFlags |= 524288 /* CouldContainTypeVariablesComputed */ | (result ? 1048576 /* CouldContainTypeVariables */ : 0);
     }
     return result;
   }
@@ -64487,7 +64464,7 @@ function createTypeChecker(host) {
     return type;
   }
   function isPartiallyInferableType(type) {
-    return !(getObjectFlags(type) & 524288 /* NonInferrableType */) || isObjectLiteralType(type) && some(getPropertiesOfType(type), (prop) => isPartiallyInferableType(getTypeOfSymbol(prop))) || isTupleType(type) && some(getElementTypes(type), isPartiallyInferableType);
+    return !(getObjectFlags(type) & 262144 /* NonInferrableType */) || isObjectLiteralType(type) && some(getPropertiesOfType(type), (prop) => isPartiallyInferableType(getTypeOfSymbol(prop))) || isTupleType(type) && some(getElementTypes(type), isPartiallyInferableType);
   }
   function createReverseMappedType(source, target, constraint) {
     if (!(getIndexInfoOfType(source, stringType) || getPropertiesOfType(source).length !== 0 && isPartiallyInferableType(source))) {
@@ -64502,7 +64479,7 @@ function createTypeChecker(host) {
       return createTupleType(elementTypes, elementFlags, source.target.readonly, source.target.labeledElementDeclarations);
     }
     const reversed = createObjectType(
-      2048 /* ReverseMapped */ | 16 /* Anonymous */,
+      1024 /* ReverseMapped */ | 16 /* Anonymous */,
       /*symbol*/
       void 0
     );
@@ -64723,8 +64700,6 @@ function createTypeChecker(host) {
         propagationType = savePropagationType;
         return;
       }
-      source = getResolvedType(source);
-      target = getResolvedType(target);
       if (source.aliasSymbol && source.aliasSymbol === target.aliasSymbol) {
         if (source.aliasTypeArguments) {
           const params = getSymbolLinks(source.aliasSymbol).typeParameters;
@@ -64775,7 +64750,7 @@ function createTypeChecker(host) {
         }
         const inference = getInferenceInfoForType(target);
         if (inference) {
-          if (getObjectFlags(source) & 524288 /* NonInferrableType */ || source === nonInferrableAnyType) {
+          if (getObjectFlags(source) & 262144 /* NonInferrableType */ || source === nonInferrableAnyType) {
             return;
           }
           if (!inference.isFixed) {
@@ -65059,7 +65034,7 @@ function createTypeChecker(host) {
             inferWithPriority(
               inferredType,
               inference.typeParameter,
-              getObjectFlags(source) & 524288 /* NonInferrableType */ ? 16 /* PartialHomomorphicMappedType */ : 8 /* HomomorphicMappedType */
+              getObjectFlags(source) & 262144 /* NonInferrableType */ ? 16 /* PartialHomomorphicMappedType */ : 8 /* HomomorphicMappedType */
             );
           }
         }
@@ -65314,10 +65289,10 @@ function createTypeChecker(host) {
     return !!constraint && maybeTypeOfKind(constraint.flags & 16777216 /* Conditional */ ? getDefaultConstraintOfConditionalType(constraint) : constraint, 402784252 /* Primitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */);
   }
   function isObjectLiteralType(type) {
-    return !!(getObjectFlags(type) & 256 /* ObjectLiteral */);
+    return !!(getObjectFlags(type) & 128 /* ObjectLiteral */);
   }
   function isObjectOrArrayLiteralType(type) {
-    return !!(getObjectFlags(type) & (256 /* ObjectLiteral */ | 32768 /* ArrayLiteral */));
+    return !!(getObjectFlags(type) & (128 /* ObjectLiteral */ | 16384 /* ArrayLiteral */));
   }
   function unionObjectAndArrayLiteralCandidates(candidates) {
     if (candidates.length > 1) {
@@ -65645,7 +65620,7 @@ function createTypeChecker(host) {
   }
   function getKeyPropertyName(unionType) {
     const types = unionType.types;
-    if (types.length < 10 || getObjectFlags(unionType) & 65536 /* PrimitiveUnion */ || countWhere(types, (t) => !!(t.flags & (524288 /* Object */ | 58982400 /* InstantiableNonPrimitive */))) < 10) {
+    if (types.length < 10 || getObjectFlags(unionType) & 32768 /* PrimitiveUnion */ || countWhere(types, (t) => !!(t.flags & (524288 /* Object */ | 58982400 /* InstantiableNonPrimitive */))) < 10) {
       return void 0;
     }
     if (unionType.keyPropertyName === void 0) {
@@ -66034,7 +66009,7 @@ function createTypeChecker(host) {
       }
       return getUnionTypeFromSortedList(
         filtered,
-        type.objectFlags & (65536 /* PrimitiveUnion */ | 33554432 /* ContainsIntersections */),
+        type.objectFlags & (32768 /* PrimitiveUnion */ | 16777216 /* ContainsIntersections */),
         /*aliasSymbol*/
         void 0,
         /*aliasTypeArguments*/
@@ -66096,7 +66071,7 @@ function createTypeChecker(host) {
     return incomplete ? { flags: 0, type: type.flags & 131072 /* Never */ ? silentNeverType : type } : type;
   }
   function createEvolvingArrayType(elementType) {
-    const result = createObjectType(512 /* EvolvingArray */);
+    const result = createObjectType(256 /* EvolvingArray */);
     result.elementType = elementType;
     return result;
   }
@@ -66116,16 +66091,16 @@ function createTypeChecker(host) {
     return evolvingArrayType.finalArrayType || (evolvingArrayType.finalArrayType = createFinalArrayType(evolvingArrayType.elementType));
   }
   function finalizeEvolvingArrayType(type) {
-    return getObjectFlags(type) & 512 /* EvolvingArray */ ? getFinalArrayType(type) : type;
+    return getObjectFlags(type) & 256 /* EvolvingArray */ ? getFinalArrayType(type) : type;
   }
   function getElementTypeOfEvolvingArrayType(type) {
-    return getObjectFlags(type) & 512 /* EvolvingArray */ ? type.elementType : neverType;
+    return getObjectFlags(type) & 256 /* EvolvingArray */ ? type.elementType : neverType;
   }
   function isEvolvingArrayTypeList(types) {
     let hasEvolvingArrayType = false;
     for (const t of types) {
       if (!(t.flags & 131072 /* Never */)) {
-        if (!(getObjectFlags(t) & 512 /* EvolvingArray */)) {
+        if (!(getObjectFlags(t) & 256 /* EvolvingArray */)) {
           return false;
         }
         hasEvolvingArrayType = true;
@@ -66429,7 +66404,7 @@ function createTypeChecker(host) {
     const sharedFlowStart = sharedFlowCount;
     const evolvedType = getTypeFromFlowType(getTypeAtFlowNode(flowNode));
     sharedFlowCount = sharedFlowStart;
-    const resultType = getObjectFlags(evolvedType) & 512 /* EvolvingArray */ && isEvolvingArrayOperationTarget(reference) ? autoArrayType : finalizeEvolvingArrayType(evolvedType);
+    const resultType = getObjectFlags(evolvedType) & 256 /* EvolvingArray */ && isEvolvingArrayOperationTarget(reference) ? autoArrayType : finalizeEvolvingArrayType(evolvedType);
     if (resultType === unreachableNeverType || reference.parent && reference.parent.kind === 235 /* NonNullExpression */ && !(resultType.flags & 131072 /* Never */) && getTypeWithFacts(resultType, 2097152 /* NEUndefinedOrNull */).flags & 131072 /* Never */) {
       return declaredType;
     }
@@ -66616,7 +66591,7 @@ function createTypeChecker(host) {
         if (isMatchingReference(reference, getReferenceCandidate(expr))) {
           const flowType = getTypeAtFlowNode(flow.antecedent);
           const type = getTypeFromFlowType(flowType);
-          if (getObjectFlags(type) & 512 /* EvolvingArray */) {
+          if (getObjectFlags(type) & 256 /* EvolvingArray */) {
             let evolvedType2 = type;
             if (node.kind === 213 /* CallExpression */) {
               for (const arg of node.arguments) {
@@ -67469,7 +67444,7 @@ function createTypeChecker(host) {
         location = location.parent;
       }
       if (isExpressionNode(location) && (!isAssignmentTarget(location) || isWriteAccess(location))) {
-        const type = getResolvedType(removeOptionalTypeMarker(
+        const type = removeOptionalTypeMarker(
           isWriteAccess(location) && location.kind === 211 /* PropertyAccessExpression */ ? checkPropertyAccessExpression(
             location,
             /*checkMode*/
@@ -67477,7 +67452,7 @@ function createTypeChecker(host) {
             /*writeOnly*/
             true
           ) : getTypeOfExpression(location)
-        ));
+        );
         if (getExportSymbolOfValueSymbolIfExported(getNodeLinks(location).resolvedSymbol) === symbol) {
           return type;
         }
@@ -69525,7 +69500,7 @@ function createTypeChecker(host) {
     let literalType = type.literalType;
     if (!literalType) {
       literalType = type.literalType = cloneTypeReference(type);
-      literalType.objectFlags |= 32768 /* ArrayLiteral */ | 262144 /* ContainsObjectOrArrayLiteral */;
+      literalType.objectFlags |= 16384 /* ArrayLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
     }
     return literalType;
   }
@@ -69653,7 +69628,7 @@ function createTypeChecker(host) {
             checkTypeAssignableTo(type, getTypeFromTypeNode(enumTag.typeExpression), memberDecl);
           }
         }
-        objectFlags |= getObjectFlags(type) & 917504 /* PropagatingFlags */;
+        objectFlags |= getObjectFlags(type) & 458752 /* PropagatingFlags */;
         const nameType = computedNameType && isTypeUsableAsPropertyName(computedNameType) ? computedNameType : void 0;
         const prop = nameType ? createSymbol(4 /* Property */ | member.flags, getPropertyNameFromType(nameType), checkFlags | 4096 /* Late */) : createSymbol(4 /* Property */ | member.flags, member.escapedName, checkFlags);
         if (nameType) {
@@ -69664,7 +69639,7 @@ function createTypeChecker(host) {
           if (isOptional) {
             prop.flags |= 16777216 /* Optional */;
           }
-        } else if (contextualTypeHasPattern && !(getObjectFlags(contextualType) & 1024 /* ObjectLiteralPatternWithComputedProperties */)) {
+        } else if (contextualTypeHasPattern && !(getObjectFlags(contextualType) & 512 /* ObjectLiteralPatternWithComputedProperties */)) {
           const impliedProp = getPropertyOfType(contextualType, member.escapedName);
           if (impliedProp) {
             prop.flags |= impliedProp.flags & 16777216 /* Optional */;
@@ -69776,12 +69751,12 @@ function createTypeChecker(host) {
       if (hasComputedSymbolProperty)
         indexInfos.push(getObjectLiteralIndexInfo(node, offset, propertiesArray, esSymbolType));
       const result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, indexInfos);
-      result.objectFlags |= objectFlags | 256 /* ObjectLiteral */ | 262144 /* ContainsObjectOrArrayLiteral */;
+      result.objectFlags |= objectFlags | 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
       if (isJSObjectLiteral) {
-        result.objectFlags |= 8192 /* JSLiteral */;
+        result.objectFlags |= 4096 /* JSLiteral */;
       }
       if (patternWithComputedProperties) {
-        result.objectFlags |= 1024 /* ObjectLiteralPatternWithComputedProperties */;
+        result.objectFlags |= 512 /* ObjectLiteralPatternWithComputedProperties */;
       }
       if (inDestructuringPattern) {
         result.pattern = node;
@@ -69843,13 +69818,13 @@ function createTypeChecker(host) {
     let hasSpreadAnyType = false;
     let typeToIntersect;
     let explicitlySpecifyChildrenAttribute = false;
-    let objectFlags = 4096 /* JsxAttributes */;
+    let objectFlags = 2048 /* JsxAttributes */;
     const jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(openingLikeElement));
     for (const attributeDecl of attributes.properties) {
       const member = attributeDecl.symbol;
       if (isJsxAttribute(attributeDecl)) {
         const exprType = checkJsxAttribute(attributeDecl, checkMode);
-        objectFlags |= getObjectFlags(exprType) & 917504 /* PropagatingFlags */;
+        objectFlags |= getObjectFlags(exprType) & 458752 /* PropagatingFlags */;
         const attributeSymbol = createSymbol(4 /* Property */ | member.flags, member.escapedName);
         attributeSymbol.declarations = member.declarations;
         attributeSymbol.parent = member.parent;
@@ -69970,7 +69945,7 @@ function createTypeChecker(host) {
     function createJsxAttributesType() {
       objectFlags |= freshObjectLiteralFlag;
       const result = createAnonymousType(attributes.symbol, attributesTable, emptyArray, emptyArray, emptyArray);
-      result.objectFlags |= objectFlags | 256 /* ObjectLiteral */ | 262144 /* ContainsObjectOrArrayLiteral */;
+      result.objectFlags |= objectFlags | 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
       return result;
     }
   }
@@ -70363,7 +70338,7 @@ function createTypeChecker(host) {
     return false;
   }
   function isExcessPropertyCheckTarget(type) {
-    return !!(type.flags & 524288 /* Object */ && !(getObjectFlags(type) & 1024 /* ObjectLiteralPatternWithComputedProperties */) || type.flags & 67108864 /* NonPrimitive */ || type.flags & 1048576 /* Union */ && some(type.types, isExcessPropertyCheckTarget) || type.flags & 2097152 /* Intersection */ && every(type.types, isExcessPropertyCheckTarget));
+    return !!(type.flags & 524288 /* Object */ && !(getObjectFlags(type) & 512 /* ObjectLiteralPatternWithComputedProperties */) || type.flags & 67108864 /* NonPrimitive */ || type.flags & 1048576 /* Union */ && some(type.types, isExcessPropertyCheckTarget) || type.flags & 2097152 /* Intersection */ && every(type.types, isExcessPropertyCheckTarget));
   }
   function checkJsxExpression(node, checkMode) {
     checkGrammarJsxExpression(node);
@@ -73131,7 +73106,7 @@ function createTypeChecker(host) {
       );
       if ((_c = jsSymbol == null ? void 0 : jsSymbol.exports) == null ? void 0 : _c.size) {
         const jsAssignmentType = createAnonymousType(jsSymbol, jsSymbol.exports, emptyArray, emptyArray, emptyArray);
-        jsAssignmentType.objectFlags |= 8192 /* JSLiteral */;
+        jsAssignmentType.objectFlags |= 4096 /* JSLiteral */;
         return getIntersectionType([returnType, jsAssignmentType]);
       }
     }
@@ -73477,7 +73452,7 @@ function createTypeChecker(host) {
           hasApplicableSignature || (hasApplicableSignature = callSignatures.length !== 0 || constructSignatures.length !== 0);
           if (callSignatures !== resolved.callSignatures || constructSignatures !== resolved.constructSignatures) {
             const result3 = createAnonymousType(createSymbol(0 /* None */, "__instantiationExpression" /* InstantiationExpression */), resolved.members, callSignatures, constructSignatures, resolved.indexInfos);
-            result3.objectFlags |= 16777216 /* InstantiationExpressionType */;
+            result3.objectFlags |= 8388608 /* InstantiationExpressionType */;
             result3.node = node;
             return result3;
           }
@@ -74518,7 +74493,7 @@ function createTypeChecker(host) {
             64 /* IsNonInferrable */
           );
           const returnOnlyType = createAnonymousType(node.symbol, emptySymbols, [returnOnlySignature], emptyArray, emptyArray);
-          returnOnlyType.objectFlags |= 524288 /* NonInferrableType */;
+          returnOnlyType.objectFlags |= 262144 /* NonInferrableType */;
           return links.contextFreeType = returnOnlyType;
         }
       }
@@ -85294,7 +85269,7 @@ function createTypeChecker(host) {
     }
   }
   function findBestTypeForObjectLiteral(source, unionTarget) {
-    if (getObjectFlags(source) & 256 /* ObjectLiteral */ && someType(unionTarget, isArrayLikeType)) {
+    if (getObjectFlags(source) & 128 /* ObjectLiteral */ && someType(unionTarget, isArrayLikeType)) {
       return find(unionTarget.types, (t) => !isArrayLikeType(t));
     }
   }