@typescript-deploys/pr-build 5.5.0-pr-57973-2 → 5.5.0-pr-57989-9

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-insiders.20240327`;
+var version = `${versionMajorMinor}.0-insiders.20240328`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -42682,17 +42682,23 @@ function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, im
     if (sourceIsInternal && !targetIsInternal || !sourceIsInternal && targetIsInternal) {
       return maybeNonRelative;
     }
-    let nearestTargetPackageJson = getNearestAncestorDirectoryWithPackageJson(host, getDirectoryPath(modulePath));
-    let nearestSourcePackageJson = getNearestAncestorDirectoryWithPackageJson(host, sourceDirectory);
-    nearestTargetPackageJson && (nearestTargetPackageJson = toPath(nearestTargetPackageJson, projectDirectory, getCanonicalFileName));
-    nearestSourcePackageJson && (nearestSourcePackageJson = toPath(nearestSourcePackageJson, projectDirectory, getCanonicalFileName));
-    if (nearestSourcePackageJson !== nearestTargetPackageJson) {
+    const nearestTargetPackageJson = getNearestAncestorDirectoryWithPackageJson(host, getDirectoryPath(modulePath));
+    const nearestSourcePackageJson = getNearestAncestorDirectoryWithPackageJson(host, sourceDirectory);
+    const ignoreCase = !hostUsesCaseSensitiveFileNames(host);
+    if (!packageJsonPathsAreEqual(nearestTargetPackageJson, nearestSourcePackageJson, ignoreCase)) {
       return maybeNonRelative;
     }
     return relativePath;
   }
   return isPathRelativeToParent(maybeNonRelative) || countPathComponents(relativePath) < countPathComponents(maybeNonRelative) ? relativePath : maybeNonRelative;
 }
+function packageJsonPathsAreEqual(a, b, ignoreCase) {
+  if (a === b)
+    return true;
+  if (a === void 0 || b === void 0)
+    return false;
+  return comparePaths(a, b, ignoreCase) === 0 /* EqualTo */;
+}
 function countPathComponents(path) {
   let count = 0;
   for (let i = startsWith(path, "./") ? 2 : 0; i < path.length; i++) {
@@ -47971,6 +47977,7 @@ function createTypeChecker(host) {
         void 0,
         addUndefined
       )),
+      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeReturnTypeForSignature(context, signature)),
       indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
         indexInfo,
         context,
@@ -49055,9 +49062,8 @@ function createTypeChecker(host) {
     }
     function signatureToSignatureDeclarationHelper(signature, kind, context, options) {
       var _a;
-      const suppressAny = context.flags & 256 /* SuppressAnyReturnType */;
-      if (suppressAny)
-        context.flags &= ~256 /* SuppressAnyReturnType */;
+      const flags = context.flags;
+      context.flags &= ~256 /* SuppressAnyReturnType */;
       context.approximateLength += 3;
       let typeParameters;
       let typeArguments;
@@ -49138,22 +49144,12 @@ function createTypeChecker(host) {
       if (thisParameter) {
         parameters.unshift(thisParameter);
       }
-      let returnTypeNode;
-      const typePredicate = getTypePredicateOfSignature(signature);
-      if (typePredicate) {
-        returnTypeNode = typePredicateToTypePredicateNodeHelper(typePredicate, context);
-      } else {
-        const returnType = getReturnTypeOfSignature(signature);
-        if (returnType && !(suppressAny && isTypeAny(returnType))) {
-          returnTypeNode = serializeReturnTypeForSignature(context, returnType, signature, options == null ? void 0 : options.privateSymbolVisitor, options == null ? void 0 : options.bundledImports);
-        } else if (!suppressAny) {
-          returnTypeNode = factory.createKeywordTypeNode(133 /* AnyKeyword */);
-        }
-      }
+      context.flags = flags;
+      const returnTypeNode = serializeReturnTypeForSignature(context, signature, options == null ? void 0 : options.privateSymbolVisitor, options == null ? void 0 : options.bundledImports);
       let modifiers = options == null ? void 0 : options.modifiers;
       if (kind === 185 /* ConstructorType */ && signature.flags & 4 /* Abstract */) {
-        const flags = modifiersToFlags(modifiers);
-        modifiers = factory.createModifiersFromModifierFlags(flags | 64 /* Abstract */);
+        const flags2 = modifiersToFlags(modifiers);
+        modifiers = factory.createModifiersFromModifierFlags(flags2 | 64 /* Abstract */);
       }
       const node = kind === 179 /* CallSignature */ ? factory.createCallSignature(typeParameters, parameters, returnTypeNode) : kind === 180 /* ConstructSignature */ ? factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : kind === 173 /* MethodSignature */ ? factory.createMethodSignature(modifiers, (options == null ? void 0 : options.name) ?? factory.createIdentifier(""), options == null ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : kind === 174 /* MethodDeclaration */ ? factory.createMethodDeclaration(
         modifiers,
@@ -49897,7 +49893,24 @@ function createTypeChecker(host) {
       }
       return false;
     }
-    function serializeReturnTypeForSignature(context, type, signature, includePrivateSymbol, bundled) {
+    function serializeReturnTypeForSignature(context, signature, includePrivateSymbol, bundled) {
+      const suppressAny = context.flags & 256 /* SuppressAnyReturnType */;
+      const flags = context.flags;
+      if (suppressAny)
+        context.flags &= ~256 /* SuppressAnyReturnType */;
+      let returnTypeNode;
+      const returnType = getReturnTypeOfSignature(signature);
+      if (returnType && !(suppressAny && isTypeAny(returnType))) {
+        returnTypeNode = serializeReturnTypeForSignatureWorker(context, signature, includePrivateSymbol, bundled);
+      } else if (!suppressAny) {
+        returnTypeNode = factory.createKeywordTypeNode(133 /* AnyKeyword */);
+      }
+      context.flags = flags;
+      return returnTypeNode;
+    }
+    function serializeReturnTypeForSignatureWorker(context, signature, includePrivateSymbol, bundled) {
+      const typePredicate = getTypePredicateOfSignature(signature);
+      const type = getReturnTypeOfSignature(signature);
       if (!isErrorType(type) && context.enclosingDeclaration) {
         const annotation = signature.declaration && getEffectiveReturnTypeNode(signature.declaration);
         const enclosingDeclarationIgnoringFakeScope = getEnclosingDeclarationIgnoringFakeScope(context.enclosingDeclaration);
@@ -49910,7 +49923,11 @@ function createTypeChecker(host) {
           }
         }
       }
-      return typeToTypeNodeHelper(type, context);
+      if (typePredicate) {
+        return typePredicateToTypePredicateNodeHelper(typePredicate, context);
+      }
+      const expr = signature.declaration && getPossibleTypeNodeReuseExpression(signature.declaration);
+      return expressionOrTypeToTypeNode(context, expr, type);
     }
     function trackExistingEntityName(node, context, includePrivateSymbol) {
       let introducesError = false;
@@ -50075,30 +50092,24 @@ function createTypeChecker(host) {
             node.isTypeOf
           );
         }
-        if (isParameter(node)) {
-          if (!node.type && !node.initializer) {
-            return factory.updateParameterDeclaration(
-              node,
-              /*modifiers*/
-              void 0,
-              node.dotDotDotToken,
-              visitEachChild(
-                node.name,
-                visitExistingNodeTreeSymbols,
-                /*context*/
-                void 0
-              ),
-              node.questionToken,
-              factory.createKeywordTypeNode(133 /* AnyKeyword */),
-              /*initializer*/
-              void 0
-            );
-          }
+        if (isNamedDeclaration(node) && node.name.kind === 167 /* ComputedPropertyName */ && !isLateBindableName(node.name)) {
+          return void 0;
         }
-        if (isPropertySignature(node)) {
-          if (!node.type && !node.initializer) {
-            return factory.updatePropertySignature(node, node.modifiers, node.name, node.questionToken, factory.createKeywordTypeNode(133 /* AnyKeyword */));
+        if (isFunctionLike(node) && !node.type || isPropertyDeclaration(node) && !node.type && !node.initializer || isPropertySignature(node) && !node.type && !node.initializer || isParameter(node) && !node.type && !node.initializer) {
+          let visited = visitEachChild(
+            node,
+            visitExistingNodeTreeSymbols,
+            /*context*/
+            void 0
+          );
+          if (visited === node) {
+            visited = setTextRange(factory.cloneNode(node), node);
           }
+          visited.type = factory.createKeywordTypeNode(133 /* AnyKeyword */);
+          if (isParameter(node)) {
+            visited.modifiers = void 0;
+          }
+          return visited;
         }
         if (isEntityName(node) || isEntityNameExpression(node)) {
           const { introducesError, node: result } = trackExistingEntityName(node, context, includePrivateSymbol);
@@ -54797,11 +54808,15 @@ function createTypeChecker(host) {
     const modifiers = getMappedTypeModifiers(type);
     return modifiers & 8 /* ExcludeOptional */ ? -1 : modifiers & 4 /* IncludeOptional */ ? 1 : 0;
   }
-  function getModifiersTypeOptionality(type) {
-    return type.flags & 2097152 /* Intersection */ ? Math.max(...map(type.types, getModifiersTypeOptionality)) : getObjectFlags(type) & 32 /* Mapped */ ? getCombinedMappedTypeOptionality(type) : 0;
-  }
   function getCombinedMappedTypeOptionality(type) {
-    return getMappedTypeOptionality(type) || getModifiersTypeOptionality(getModifiersTypeFromMappedType(type));
+    if (getObjectFlags(type) & 32 /* Mapped */) {
+      return getMappedTypeOptionality(type) || getCombinedMappedTypeOptionality(getModifiersTypeFromMappedType(type));
+    }
+    if (type.flags & 2097152 /* Intersection */) {
+      const optionality = getCombinedMappedTypeOptionality(type.types[0]);
+      return every(type.types, (t, i) => i === 0 || getCombinedMappedTypeOptionality(t) === optionality) ? optionality : 0;
+    }
+    return 0;
   }
   function isPartialMappedType(type) {
     return !!(getObjectFlags(type) & 32 /* Mapped */ && getMappedTypeModifiers(type) & 4 /* IncludeOptional */);
@@ -58610,13 +58625,18 @@ function createTypeChecker(host) {
     const mapper = createTypeMapper([getTypeParameterFromMappedType(objectType)], [index]);
     const templateMapper = combineTypeMappers(objectType.mapper, mapper);
     const instantiatedTemplateType = instantiateType(getTemplateTypeFromMappedType(objectType.target || objectType), templateMapper);
+    const isOptional = getMappedTypeOptionality(objectType) > 0 || (isGenericType(objectType) ? getCombinedMappedTypeOptionality(getModifiersTypeFromMappedType(objectType)) > 0 : couldAccessOptionalProperty(objectType, index));
     return addOptionality(
       instantiatedTemplateType,
       /*isProperty*/
       true,
-      getCombinedMappedTypeOptionality(objectType) > 0
+      isOptional
     );
   }
+  function couldAccessOptionalProperty(objectType, indexType) {
+    const indexConstraint = getBaseConstraintOfType(indexType);
+    return !!indexConstraint && some(getPropertiesOfType(objectType), (p) => !!(p.flags & 16777216 /* Optional */) && isTypeAssignableTo(getLiteralTypeFromProperty(p, 8576 /* StringOrNumberLiteralOrUnique */), indexConstraint));
+  }
   function getIndexedAccessType(objectType, indexType, accessFlags = 0 /* None */, accessNode, aliasSymbol, aliasTypeArguments) {
     return getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) || (accessNode ? errorType : unknownType);
   }
@@ -60945,6 +60965,7 @@ function createTypeChecker(host) {
     const result = isRelatedTo(
       source,
       target,
+      0 /* None */,
       3 /* Both */,
       /*reportErrors*/
       !!errorNode,
@@ -61228,10 +61249,7 @@ function createTypeChecker(host) {
       }
       return true;
     }
-    function isRelatedToWorker(source2, target2, reportErrors2) {
-      return isRelatedTo(source2, target2, 3 /* Both */, reportErrors2);
-    }
-    function isRelatedTo(originalSource, originalTarget, recursionFlags = 3 /* Both */, reportErrors2 = false, headMessage2, intersectionState = 0 /* None */) {
+    function isRelatedTo(originalSource, originalTarget, intersectionState, recursionFlags = 3 /* Both */, reportErrors2 = false, headMessage2) {
       if (originalSource === originalTarget)
         return -1 /* True */;
       if (originalSource.flags & 524288 /* Object */ && originalTarget.flags & 402784252 /* Primitive */) {
@@ -61291,7 +61309,7 @@ function createTypeChecker(host) {
       if (source2.flags & 469499904 /* StructuredOrInstantiable */ || target2.flags & 469499904 /* StructuredOrInstantiable */) {
         const isPerformingExcessPropertyChecks = !(intersectionState & 2 /* Target */) && (isObjectLiteralType(source2) && getObjectFlags(source2) & 8192 /* FreshLiteral */);
         if (isPerformingExcessPropertyChecks) {
-          if (hasExcessProperties(source2, target2, reportErrors2)) {
+          if (hasExcessProperties(source2, target2, reportErrors2, intersectionState)) {
             if (reportErrors2) {
               reportRelationError(headMessage2, source2, originalTarget.aliasSymbol ? originalTarget : target2);
             }
@@ -61309,12 +61327,14 @@ function createTypeChecker(host) {
             if (calls.length > 0 && isRelatedTo(
               getReturnTypeOfSignature(calls[0]),
               target2,
+              intersectionState,
               1 /* Source */,
               /*reportErrors*/
               false
             ) || constructs.length > 0 && isRelatedTo(
               getReturnTypeOfSignature(constructs[0]),
               target2,
+              intersectionState,
               1 /* Source */,
               /*reportErrors*/
               false
@@ -61427,7 +61447,7 @@ function createTypeChecker(host) {
         void 0
       ) || emptyArray);
     }
-    function hasExcessProperties(source2, target2, reportErrors2) {
+    function hasExcessProperties(source2, target2, reportErrors2, intersectionState) {
       var _a2;
       if (!isExcessPropertyCheckTarget(target2) || !noImplicitAny && getObjectFlags(target2) & 4096 /* JSLiteral */) {
         return false;
@@ -61439,7 +61459,11 @@ function createTypeChecker(host) {
       let reducedTarget = target2;
       let checkTypes;
       if (target2.flags & 1048576 /* Union */) {
-        reducedTarget = findMatchingDiscriminantType(source2, target2, isRelatedTo) || filterPrimitivesIfContainsNonPrimitive(target2);
+        let isRelatedToWorker2 = function(source3, target3) {
+          return isRelatedTo(source3, target3, intersectionState);
+        };
+        var isRelatedToWorker = isRelatedToWorker2;
+        reducedTarget = findMatchingDiscriminantType(source2, target2, isRelatedToWorker2) || filterPrimitivesIfContainsNonPrimitive(target2);
         checkTypes = reducedTarget.flags & 1048576 /* Union */ ? reducedTarget.types : [reducedTarget];
       }
       for (const prop of getPropertiesOfType(source2)) {
@@ -61482,7 +61506,7 @@ function createTypeChecker(host) {
             }
             return true;
           }
-          if (checkTypes && !isRelatedTo(getTypeOfSymbol(prop), getTypeOfPropertyInTypes(checkTypes, prop.escapedName), 3 /* Both */, reportErrors2)) {
+          if (checkTypes && !isRelatedTo(getTypeOfSymbol(prop), getTypeOfPropertyInTypes(checkTypes, prop.escapedName), intersectionState, 3 /* Both */, reportErrors2)) {
             if (reportErrors2) {
               reportIncompatibleError(Diagnostics.Types_of_property_0_are_incompatible, symbolToString(prop));
             }
@@ -61526,12 +61550,14 @@ function createTypeChecker(host) {
             return isRelatedTo(
               source2,
               target2,
+              intersectionState,
               1 /* Source */,
               /*reportErrors*/
               false
             ) || isRelatedTo(
               target2,
               source2,
+              intersectionState,
               1 /* Source */,
               /*reportErrors*/
               false
@@ -61547,7 +61573,7 @@ function createTypeChecker(host) {
         1 /* Source */
       );
     }
-    function eachTypeRelatedToSomeType(source2, target2) {
+    function eachTypeRelatedToSomeType(source2, target2, intersectionState) {
       let result2 = -1 /* True */;
       const sourceTypes = source2.types;
       for (const sourceType of sourceTypes) {
@@ -61556,7 +61582,7 @@ function createTypeChecker(host) {
           target2,
           /*reportErrors*/
           false,
-          0 /* None */
+          intersectionState
         );
         if (!related) {
           return 0 /* False */;
@@ -61581,12 +61607,12 @@ function createTypeChecker(host) {
           const related = isRelatedTo(
             source2,
             match,
+            intersectionState,
             2 /* Target */,
             /*reportErrors*/
             false,
             /*headMessage*/
-            void 0,
-            intersectionState
+            void 0
           );
           if (related) {
             return related;
@@ -61597,29 +61623,31 @@ function createTypeChecker(host) {
         const related = isRelatedTo(
           source2,
           type,
+          intersectionState,
           2 /* Target */,
           /*reportErrors*/
           false,
           /*headMessage*/
-          void 0,
-          intersectionState
+          void 0
         );
         if (related) {
           return related;
         }
       }
       if (reportErrors2) {
-        const bestMatchingType = getBestMatchingType(source2, target2, isRelatedTo);
+        let isRelatedToWorker2 = function(source3, target3) {
+          return isRelatedTo(source3, target3, intersectionState);
+        };
+        var isRelatedToWorker = isRelatedToWorker2;
+        const bestMatchingType = getBestMatchingType(source2, target2, isRelatedToWorker2);
         if (bestMatchingType) {
           isRelatedTo(
             source2,
             bestMatchingType,
+            intersectionState,
             2 /* Target */,
             /*reportErrors*/
-            true,
-            /*headMessage*/
-            void 0,
-            intersectionState
+            true
           );
         }
       }
@@ -61632,11 +61660,11 @@ function createTypeChecker(host) {
         const related = isRelatedTo(
           source2,
           targetType,
+          intersectionState,
           2 /* Target */,
           reportErrors2,
           /*headMessage*/
-          void 0,
-          intersectionState
+          void 0
         );
         if (!related) {
           return 0 /* False */;
@@ -61655,11 +61683,11 @@ function createTypeChecker(host) {
         const related = isRelatedTo(
           sourceTypes[i],
           target2,
+          intersectionState,
           1 /* Source */,
           reportErrors2 && i === len - 1,
           /*headMessage*/
-          void 0,
-          intersectionState
+          void 0
         );
         if (related) {
           return related;
@@ -61683,12 +61711,12 @@ function createTypeChecker(host) {
           const related2 = isRelatedTo(
             sourceType,
             undefinedStrippedTarget.types[i % undefinedStrippedTarget.types.length],
+            intersectionState,
             3 /* Both */,
             /*reportErrors*/
             false,
             /*headMessage*/
-            void 0,
-            intersectionState
+            void 0
           );
           if (related2) {
             result2 &= related2;
@@ -61698,11 +61726,11 @@ function createTypeChecker(host) {
         const related = isRelatedTo(
           sourceType,
           target2,
+          intersectionState,
           1 /* Source */,
           reportErrors2,
           /*headMessage*/
-          void 0,
-          intersectionState
+          void 0
         );
         if (!related) {
           return 0 /* False */;
@@ -61728,6 +61756,7 @@ function createTypeChecker(host) {
             related = relation === identityRelation ? isRelatedTo(
               s,
               t,
+              intersectionState,
               3 /* Both */,
               /*reportErrors*/
               false
@@ -61736,26 +61765,27 @@ function createTypeChecker(host) {
             related = isRelatedTo(
               s,
               t,
+              intersectionState,
               3 /* Both */,
               reportErrors2,
               /*headMessage*/
-              void 0,
-              intersectionState
+              void 0
             );
           } else if (variance === 2 /* Contravariant */) {
             related = isRelatedTo(
               t,
               s,
+              intersectionState,
               3 /* Both */,
               reportErrors2,
               /*headMessage*/
-              void 0,
-              intersectionState
+              void 0
             );
           } else if (variance === 3 /* Bivariant */) {
             related = isRelatedTo(
               t,
               s,
+              intersectionState,
               3 /* Both */,
               /*reportErrors*/
               false
@@ -61764,32 +61794,32 @@ function createTypeChecker(host) {
               related = isRelatedTo(
                 s,
                 t,
+                intersectionState,
                 3 /* Both */,
                 reportErrors2,
                 /*headMessage*/
-                void 0,
-                intersectionState
+                void 0
               );
             }
           } else {
             related = isRelatedTo(
               s,
               t,
+              intersectionState,
               3 /* Both */,
               reportErrors2,
               /*headMessage*/
-              void 0,
-              intersectionState
+              void 0
             );
             if (related) {
               related &= isRelatedTo(
                 t,
                 s,
+                intersectionState,
                 3 /* Both */,
                 reportErrors2,
                 /*headMessage*/
-                void 0,
-                intersectionState
+                void 0
               );
             }
           }
@@ -61955,12 +61985,12 @@ function createTypeChecker(host) {
             result2 = isRelatedTo(
               constraint,
               target2,
+              intersectionState,
               1 /* Source */,
               /*reportErrors*/
               false,
               /*headMessage*/
-              void 0,
-              intersectionState
+              void 0
             );
           }
         }
@@ -62023,9 +62053,9 @@ function createTypeChecker(host) {
       const targetFlags = target2.flags;
       if (relation === identityRelation) {
         if (sourceFlags & 3145728 /* UnionOrIntersection */) {
-          let result3 = eachTypeRelatedToSomeType(source2, target2);
+          let result3 = eachTypeRelatedToSomeType(source2, target2, intersectionState);
           if (result3) {
-            result3 &= eachTypeRelatedToSomeType(target2, source2);
+            result3 &= eachTypeRelatedToSomeType(target2, source2, intersectionState);
           }
           return result3;
         }
@@ -62033,6 +62063,7 @@ function createTypeChecker(host) {
           return isRelatedTo(
             source2.type,
             target2.type,
+            intersectionState,
             3 /* Both */,
             /*reportErrors*/
             false
@@ -62042,6 +62073,7 @@ function createTypeChecker(host) {
           if (result2 = isRelatedTo(
             source2.objectType,
             target2.objectType,
+            intersectionState,
             3 /* Both */,
             /*reportErrors*/
             false
@@ -62049,6 +62081,7 @@ function createTypeChecker(host) {
             if (result2 &= isRelatedTo(
               source2.indexType,
               target2.indexType,
+              intersectionState,
               3 /* Both */,
               /*reportErrors*/
               false
@@ -62062,6 +62095,7 @@ function createTypeChecker(host) {
             if (result2 = isRelatedTo(
               source2.checkType,
               target2.checkType,
+              intersectionState,
               3 /* Both */,
               /*reportErrors*/
               false
@@ -62069,6 +62103,7 @@ function createTypeChecker(host) {
               if (result2 &= isRelatedTo(
                 source2.extendsType,
                 target2.extendsType,
+                intersectionState,
                 3 /* Both */,
                 /*reportErrors*/
                 false
@@ -62076,6 +62111,7 @@ function createTypeChecker(host) {
                 if (result2 &= isRelatedTo(
                   getTrueTypeFromConditionalType(source2),
                   getTrueTypeFromConditionalType(target2),
+                  intersectionState,
                   3 /* Both */,
                   /*reportErrors*/
                   false
@@ -62083,6 +62119,7 @@ function createTypeChecker(host) {
                   if (result2 &= isRelatedTo(
                     getFalseTypeFromConditionalType(source2),
                     getFalseTypeFromConditionalType(target2),
+                    intersectionState,
                     3 /* Both */,
                     /*reportErrors*/
                     false
@@ -62098,6 +62135,7 @@ function createTypeChecker(host) {
           if (result2 = isRelatedTo(
             source2.baseType,
             target2.baseType,
+            intersectionState,
             3 /* Both */,
             /*reportErrors*/
             false
@@ -62105,6 +62143,7 @@ function createTypeChecker(host) {
             if (result2 &= isRelatedTo(
               source2.constraint,
               target2.constraint,
+              intersectionState,
               3 /* Both */,
               /*reportErrors*/
               false
@@ -62138,15 +62177,15 @@ function createTypeChecker(host) {
           return varianceResult;
         }
       }
-      if (isSingleElementGenericTupleType(source2) && !source2.target.readonly && (result2 = isRelatedTo(getTypeArguments(source2)[0], target2, 1 /* Source */)) || isSingleElementGenericTupleType(target2) && (target2.target.readonly || isMutableArrayOrTuple(getBaseConstraintOfType(source2) || source2)) && (result2 = isRelatedTo(source2, getTypeArguments(target2)[0], 2 /* Target */))) {
+      if (isSingleElementGenericTupleType(source2) && !source2.target.readonly && (result2 = isRelatedTo(getTypeArguments(source2)[0], target2, intersectionState, 1 /* Source */)) || isSingleElementGenericTupleType(target2) && (target2.target.readonly || isMutableArrayOrTuple(getBaseConstraintOfType(source2) || source2)) && (result2 = isRelatedTo(source2, getTypeArguments(target2)[0], intersectionState, 2 /* Target */))) {
         return result2;
       }
       if (targetFlags & 262144 /* TypeParameter */) {
-        if (getObjectFlags(source2) & 32 /* Mapped */ && !source2.declaration.nameType && isRelatedTo(getIndexType(target2), getConstraintTypeFromMappedType(source2), 3 /* Both */)) {
+        if (getObjectFlags(source2) & 32 /* Mapped */ && !source2.declaration.nameType && isRelatedTo(getIndexType(target2), getConstraintTypeFromMappedType(source2), intersectionState, 3 /* Both */)) {
           if (!(getMappedTypeModifiers(source2) & 4 /* IncludeOptional */)) {
             const templateType = getTemplateTypeFromMappedType(source2);
             const indexedAccessType = getIndexedAccessType(target2, getTypeParameterFromMappedType(source2));
-            if (result2 = isRelatedTo(templateType, indexedAccessType, 3 /* Both */, reportErrors2)) {
+            if (result2 = isRelatedTo(templateType, indexedAccessType, intersectionState, 3 /* Both */, reportErrors2)) {
               return result2;
             }
           }
@@ -62158,6 +62197,7 @@ function createTypeChecker(host) {
               if (result2 = isRelatedTo(
                 constraint,
                 target2,
+                intersectionState,
                 1 /* Source */,
                 /*reportErrors*/
                 false
@@ -62175,6 +62215,7 @@ function createTypeChecker(host) {
           if (result2 = isRelatedTo(
             targetType,
             source2.type,
+            intersectionState,
             3 /* Both */,
             /*reportErrors*/
             false
@@ -62183,13 +62224,13 @@ function createTypeChecker(host) {
           }
         }
         if (isTupleType(targetType)) {
-          if (result2 = isRelatedTo(source2, getKnownKeysOfTupleType(targetType), 2 /* Target */, reportErrors2)) {
+          if (result2 = isRelatedTo(source2, getKnownKeysOfTupleType(targetType), intersectionState, 2 /* Target */, reportErrors2)) {
             return result2;
           }
         } else {
           const constraint = getSimplifiedTypeOrConstraint(targetType);
           if (constraint) {
-            if (isRelatedTo(source2, getIndexType(constraint, target2.indexFlags | 4 /* NoReducibleCheck */), 2 /* Target */, reportErrors2) === -1 /* True */) {
+            if (isRelatedTo(source2, getIndexType(constraint, target2.indexFlags | 4 /* NoReducibleCheck */), intersectionState, 2 /* Target */, reportErrors2) === -1 /* True */) {
               return -1 /* True */;
             }
           } else if (isGenericMappedType(targetType)) {
@@ -62202,15 +62243,15 @@ function createTypeChecker(host) {
             } else {
               targetKeys = nameType || constraintType;
             }
-            if (isRelatedTo(source2, targetKeys, 2 /* Target */, reportErrors2) === -1 /* True */) {
+            if (isRelatedTo(source2, targetKeys, intersectionState, 2 /* Target */, reportErrors2) === -1 /* True */) {
               return -1 /* True */;
             }
           }
         }
       } else if (targetFlags & 8388608 /* IndexedAccess */) {
         if (sourceFlags & 8388608 /* IndexedAccess */) {
-          if (result2 = isRelatedTo(source2.objectType, target2.objectType, 3 /* Both */, reportErrors2)) {
-            result2 &= isRelatedTo(source2.indexType, target2.indexType, 3 /* Both */, reportErrors2);
+          if (result2 = isRelatedTo(source2.objectType, target2.objectType, intersectionState, 3 /* Both */, reportErrors2)) {
+            result2 &= isRelatedTo(source2.indexType, target2.indexType, intersectionState, 3 /* Both */, reportErrors2);
           }
           if (result2) {
             return result2;
@@ -62234,11 +62275,11 @@ function createTypeChecker(host) {
               if (result2 = isRelatedTo(
                 source2,
                 constraint,
+                intersectionState,
                 2 /* Target */,
                 reportErrors2,
                 /*headMessage*/
-                void 0,
-                intersectionState
+                void 0
               )) {
                 return result2;
               }
@@ -62264,18 +62305,18 @@ function createTypeChecker(host) {
             const sourceKeys = getIndexType(source2, 2 /* NoIndexSignatures */);
             const includeOptional = modifiers & 4 /* IncludeOptional */;
             const filteredByApplicability = includeOptional ? intersectTypes(targetKeys, sourceKeys) : void 0;
-            if (includeOptional ? !(filteredByApplicability.flags & 131072 /* Never */) : isRelatedTo(targetKeys, sourceKeys, 3 /* Both */)) {
+            if (includeOptional ? !(filteredByApplicability.flags & 131072 /* Never */) : isRelatedTo(targetKeys, sourceKeys, intersectionState, 3 /* Both */)) {
               const templateType2 = getTemplateTypeFromMappedType(target2);
               const typeParameter = getTypeParameterFromMappedType(target2);
               const nonNullComponent = extractTypesOfKind(templateType2, ~98304 /* Nullable */);
               if (!keysRemapped && nonNullComponent.flags & 8388608 /* IndexedAccess */ && nonNullComponent.indexType === typeParameter) {
-                if (result2 = isRelatedTo(source2, nonNullComponent.objectType, 2 /* Target */, reportErrors2)) {
+                if (result2 = isRelatedTo(source2, nonNullComponent.objectType, intersectionState, 2 /* Target */, reportErrors2)) {
                   return result2;
                 }
               } else {
                 const indexingType = keysRemapped ? filteredByApplicability || targetKeys : filteredByApplicability ? getIntersectionType([filteredByApplicability, typeParameter]) : typeParameter;
                 const indexedAccessType = getIndexedAccessType(source2, indexingType);
-                if (result2 = isRelatedTo(indexedAccessType, templateType2, 3 /* Both */, reportErrors2)) {
+                if (result2 = isRelatedTo(indexedAccessType, templateType2, intersectionState, 3 /* Both */, reportErrors2)) {
                   return result2;
                 }
               }
@@ -62295,22 +62336,22 @@ function createTypeChecker(host) {
           if (result2 = skipTrue ? -1 /* True */ : isRelatedTo(
             source2,
             getTrueTypeFromConditionalType(c),
+            intersectionState,
             2 /* Target */,
             /*reportErrors*/
             false,
             /*headMessage*/
-            void 0,
-            intersectionState
+            void 0
           )) {
             result2 &= skipFalse ? -1 /* True */ : isRelatedTo(
               source2,
               getFalseTypeFromConditionalType(c),
+              intersectionState,
               2 /* Target */,
               /*reportErrors*/
               false,
               /*headMessage*/
-              void 0,
-              intersectionState
+              void 0
             );
             if (result2) {
               return result2;
@@ -62340,29 +62381,29 @@ function createTypeChecker(host) {
           if (result2 = isRelatedTo(
             constraint,
             target2,
+            intersectionState,
             1 /* Source */,
             /*reportErrors*/
             false,
             /*headMessage*/
-            void 0,
-            intersectionState
+            void 0
           )) {
             return result2;
           } else if (result2 = isRelatedTo(
             getTypeWithThisArgument(constraint, source2),
             target2,
+            intersectionState,
             1 /* Source */,
             reportErrors2 && constraint !== unknownType && !(targetFlags & sourceFlags & 262144 /* TypeParameter */),
             /*headMessage*/
-            void 0,
-            intersectionState
+            void 0
           )) {
             return result2;
           }
           if (isMappedTypeGenericIndexedAccess(source2)) {
             const indexConstraint = getConstraintOfType(source2.indexType);
             if (indexConstraint) {
-              if (result2 = isRelatedTo(getIndexedAccessType(source2.objectType, indexConstraint), target2, 1 /* Source */, reportErrors2)) {
+              if (result2 = isRelatedTo(getIndexedAccessType(source2.objectType, indexConstraint), target2, intersectionState, 1 /* Source */, reportErrors2)) {
                 return result2;
               }
             }
@@ -62370,21 +62411,21 @@ function createTypeChecker(host) {
         }
       } else if (sourceFlags & 4194304 /* Index */) {
         const isDeferredMappedIndex = shouldDeferIndexType(source2.type, source2.indexFlags) && getObjectFlags(source2.type) & 32 /* Mapped */;
-        if (result2 = isRelatedTo(stringNumberSymbolType, target2, 1 /* Source */, reportErrors2 && !isDeferredMappedIndex)) {
+        if (result2 = isRelatedTo(stringNumberSymbolType, target2, intersectionState, 1 /* Source */, reportErrors2 && !isDeferredMappedIndex)) {
           return result2;
         }
         if (isDeferredMappedIndex) {
           const mappedType = source2.type;
           const nameType = getNameTypeFromMappedType(mappedType);
           const sourceMappedKeys = nameType && isMappedTypeWithKeyofConstraintDeclaration(mappedType) ? getApparentMappedTypeKeys(nameType, mappedType) : nameType || getConstraintTypeFromMappedType(mappedType);
-          if (result2 = isRelatedTo(sourceMappedKeys, target2, 1 /* Source */, reportErrors2)) {
+          if (result2 = isRelatedTo(sourceMappedKeys, target2, intersectionState, 1 /* Source */, reportErrors2)) {
             return result2;
           }
         }
       } else if (sourceFlags & 134217728 /* TemplateLiteral */ && !(targetFlags & 524288 /* Object */)) {
         if (!(targetFlags & 134217728 /* TemplateLiteral */)) {
           const constraint = getBaseConstraintOfType(source2);
-          if (constraint && constraint !== source2 && (result2 = isRelatedTo(constraint, target2, 1 /* Source */, reportErrors2))) {
+          if (constraint && constraint !== source2 && (result2 = isRelatedTo(constraint, target2, intersectionState, 1 /* Source */, reportErrors2))) {
             return result2;
           }
         }
@@ -62393,12 +62434,12 @@ function createTypeChecker(host) {
           if (source2.symbol !== target2.symbol) {
             return 0 /* False */;
           }
-          if (result2 = isRelatedTo(source2.type, target2.type, 3 /* Both */, reportErrors2)) {
+          if (result2 = isRelatedTo(source2.type, target2.type, intersectionState, 3 /* Both */, reportErrors2)) {
             return result2;
           }
         } else {
           const constraint = getBaseConstraintOfType(source2);
-          if (constraint && (result2 = isRelatedTo(constraint, target2, 1 /* Source */, reportErrors2))) {
+          if (constraint && (result2 = isRelatedTo(constraint, target2, intersectionState, 1 /* Source */, reportErrors2))) {
             return result2;
           }
         }
@@ -62411,20 +62452,24 @@ function createTypeChecker(host) {
           let sourceExtends = source2.extendsType;
           let mapper;
           if (sourceParams) {
+            let isRelatedToWorker2 = function(source3, target3, reportErrors3) {
+              return isRelatedTo(source3, target3, 0 /* None */, 3 /* Both */, reportErrors3);
+            };
+            var isRelatedToWorker = isRelatedToWorker2;
             const ctx = createInferenceContext(
               sourceParams,
               /*signature*/
               void 0,
               0 /* None */,
-              isRelatedToWorker
+              isRelatedToWorker2
             );
             inferTypes(ctx.inferences, target2.extendsType, sourceExtends, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
             sourceExtends = instantiateType(sourceExtends, ctx.mapper);
             mapper = ctx.mapper;
           }
-          if (isTypeIdenticalTo(sourceExtends, target2.extendsType) && (isRelatedTo(source2.checkType, target2.checkType, 3 /* Both */) || isRelatedTo(target2.checkType, source2.checkType, 3 /* Both */))) {
-            if (result2 = isRelatedTo(instantiateType(getTrueTypeFromConditionalType(source2), mapper), getTrueTypeFromConditionalType(target2), 3 /* Both */, reportErrors2)) {
-              result2 &= isRelatedTo(getFalseTypeFromConditionalType(source2), getFalseTypeFromConditionalType(target2), 3 /* Both */, reportErrors2);
+          if (isTypeIdenticalTo(sourceExtends, target2.extendsType) && (isRelatedTo(source2.checkType, target2.checkType, intersectionState, 3 /* Both */) || isRelatedTo(target2.checkType, source2.checkType, intersectionState, 3 /* Both */))) {
+            if (result2 = isRelatedTo(instantiateType(getTrueTypeFromConditionalType(source2), mapper), getTrueTypeFromConditionalType(target2), intersectionState, 3 /* Both */, reportErrors2)) {
+              result2 &= isRelatedTo(getFalseTypeFromConditionalType(source2), getFalseTypeFromConditionalType(target2), intersectionState, 3 /* Both */, reportErrors2);
             }
             if (result2) {
               return result2;
@@ -62433,14 +62478,14 @@ function createTypeChecker(host) {
         }
         const defaultConstraint = getDefaultConstraintOfConditionalType(source2);
         if (defaultConstraint) {
-          if (result2 = isRelatedTo(defaultConstraint, target2, 1 /* Source */, reportErrors2)) {
+          if (result2 = isRelatedTo(defaultConstraint, target2, intersectionState, 1 /* Source */, reportErrors2)) {
             return result2;
           }
         }
         const distributiveConstraint = !(targetFlags & 16777216 /* Conditional */) && hasNonCircularBaseConstraint(source2) ? getConstraintOfDistributiveConditionalType(source2) : void 0;
         if (distributiveConstraint) {
           resetErrorInfo(saveErrorInfo);
-          if (result2 = isRelatedTo(distributiveConstraint, target2, 1 /* Source */, reportErrors2)) {
+          if (result2 = isRelatedTo(distributiveConstraint, target2, intersectionState, 1 /* Source */, reportErrors2)) {
             return result2;
           }
         }
@@ -62450,7 +62495,7 @@ function createTypeChecker(host) {
         }
         if (isGenericMappedType(target2)) {
           if (isGenericMappedType(source2)) {
-            if (result2 = mappedTypeRelatedTo(source2, target2, reportErrors2)) {
+            if (result2 = mappedTypeRelatedTo(source2, target2, reportErrors2, intersectionState)) {
               return result2;
             }
           }
@@ -62477,14 +62522,14 @@ function createTypeChecker(host) {
           }
         } else if (isReadonlyArrayType(target2) ? everyType(source2, isArrayOrTupleType) : isArrayType(target2) && everyType(source2, (t) => isTupleType(t) && !t.target.readonly)) {
           if (relation !== identityRelation) {
-            return isRelatedTo(getIndexTypeOfType(source2, numberType) || anyType, getIndexTypeOfType(target2, numberType) || anyType, 3 /* Both */, reportErrors2);
+            return isRelatedTo(getIndexTypeOfType(source2, numberType) || anyType, getIndexTypeOfType(target2, numberType) || anyType, intersectionState, 3 /* Both */, reportErrors2);
           } else {
             return 0 /* False */;
           }
         } else if (isGenericTupleType(source2) && isTupleType(target2) && !isGenericTupleType(target2)) {
           const constraint = getBaseConstraintOrType(source2);
           if (constraint !== source2) {
-            return isRelatedTo(constraint, target2, 1 /* Source */, reportErrors2);
+            return isRelatedTo(constraint, target2, intersectionState, 1 /* Source */, reportErrors2);
           }
         } else if ((relation === subtypeRelation || relation === strictSubtypeRelation) && isEmptyObjectType(target2) && getObjectFlags(target2) & 8192 /* FreshLiteral */ && !isEmptyObjectType(source2)) {
           return 0 /* False */;
@@ -62552,16 +62597,16 @@ function createTypeChecker(host) {
         }
       }
     }
-    function mappedTypeRelatedTo(source2, target2, reportErrors2) {
+    function mappedTypeRelatedTo(source2, target2, reportErrors2, intersectionState) {
       const modifiersRelated = relation === comparableRelation || (relation === identityRelation ? getMappedTypeModifiers(source2) === getMappedTypeModifiers(target2) : getCombinedMappedTypeOptionality(source2) <= getCombinedMappedTypeOptionality(target2));
       if (modifiersRelated) {
         let result2;
         const targetConstraint = getConstraintTypeFromMappedType(target2);
         const sourceConstraint = instantiateType(getConstraintTypeFromMappedType(source2), getCombinedMappedTypeOptionality(source2) < 0 ? reportUnmeasurableMapper : reportUnreliableMapper);
-        if (result2 = isRelatedTo(targetConstraint, sourceConstraint, 3 /* Both */, reportErrors2)) {
+        if (result2 = isRelatedTo(targetConstraint, sourceConstraint, intersectionState, 3 /* Both */, reportErrors2)) {
           const mapper = createTypeMapper([getTypeParameterFromMappedType(source2)], [getTypeParameterFromMappedType(target2)]);
           if (instantiateType(getNameTypeFromMappedType(source2), mapper) === instantiateType(getNameTypeFromMappedType(target2), mapper)) {
-            return result2 & isRelatedTo(instantiateType(getTemplateTypeFromMappedType(source2), mapper), getTemplateTypeFromMappedType(target2), 3 /* Both */, reportErrors2);
+            return result2 & isRelatedTo(instantiateType(getTemplateTypeFromMappedType(source2), mapper), getTemplateTypeFromMappedType(target2), intersectionState, 3 /* Both */, reportErrors2);
           }
         }
       }
@@ -62701,11 +62746,11 @@ function createTypeChecker(host) {
       return isRelatedTo(
         effectiveSource,
         effectiveTarget,
+        intersectionState,
         3 /* Both */,
         reportErrors2,
         /*headMessage*/
-        void 0,
-        intersectionState
+        void 0
       );
     }
     function propertyRelatedTo(source2, target2, sourceProp, targetProp, getTypeOfSourceProperty, reportErrors2, intersectionState, skipOptional) {
@@ -62813,7 +62858,7 @@ function createTypeChecker(host) {
     }
     function propertiesRelatedTo(source2, target2, reportErrors2, excludedProperties, optionalsOnly, intersectionState) {
       if (relation === identityRelation) {
-        return propertiesIdenticalTo(source2, target2, excludedProperties);
+        return propertiesIdenticalTo(source2, target2, excludedProperties, intersectionState);
       }
       let result2 = -1 /* True */;
       if (isTupleType(target2)) {
@@ -62892,11 +62937,11 @@ function createTypeChecker(host) {
             const related = isRelatedTo(
               sourceType,
               targetCheckType,
+              intersectionState,
               3 /* Both */,
               reportErrors2,
               /*headMessage*/
-              void 0,
-              intersectionState
+              void 0
             );
             if (!related) {
               if (reportErrors2 && (targetArity > 1 || sourceArity > 1)) {
@@ -62960,7 +63005,7 @@ function createTypeChecker(host) {
       }
       return result2;
     }
-    function propertiesIdenticalTo(source2, target2, excludedProperties) {
+    function propertiesIdenticalTo(source2, target2, excludedProperties, intersectionState) {
       if (!(source2.flags & 524288 /* Object */ && target2.flags & 524288 /* Object */)) {
         return 0 /* False */;
       }
@@ -62975,18 +63020,21 @@ function createTypeChecker(host) {
         if (!targetProp) {
           return 0 /* False */;
         }
-        const related = compareProperties(sourceProp, targetProp, isRelatedTo);
+        const related = compareProperties(sourceProp, targetProp, isRelatedToWorker);
         if (!related) {
           return 0 /* False */;
         }
         result2 &= related;
       }
       return result2;
+      function isRelatedToWorker(source3, target3) {
+        return isRelatedTo(source3, target3, intersectionState);
+      }
     }
     function signaturesRelatedTo(source2, target2, kind, reportErrors2, intersectionState) {
       var _a2, _b;
       if (relation === identityRelation) {
-        return signaturesIdenticalTo(source2, target2, kind);
+        return signaturesIdenticalTo(source2, target2, kind, intersectionState);
       }
       if (target2 === anyFunctionType || source2 === anyFunctionType) {
         return -1 /* True */;
@@ -63115,20 +63163,20 @@ function createTypeChecker(host) {
     }
     function signatureRelatedTo(source2, target2, erase, reportErrors2, intersectionState, incompatibleReporter) {
       const checkMode = relation === subtypeRelation ? 16 /* StrictTopSignature */ : relation === strictSubtypeRelation ? 16 /* StrictTopSignature */ | 8 /* StrictArity */ : 0 /* None */;
-      return compareSignaturesRelated(erase ? getErasedSignature(source2) : source2, erase ? getErasedSignature(target2) : target2, checkMode, reportErrors2, reportError, incompatibleReporter, isRelatedToWorker2, reportUnreliableMapper);
-      function isRelatedToWorker2(source3, target3, reportErrors3) {
+      return compareSignaturesRelated(erase ? getErasedSignature(source2) : source2, erase ? getErasedSignature(target2) : target2, checkMode, reportErrors2, reportError, incompatibleReporter, isRelatedToWorker, reportUnreliableMapper);
+      function isRelatedToWorker(source3, target3, reportErrors3) {
         return isRelatedTo(
           source3,
           target3,
+          intersectionState,
           3 /* Both */,
           reportErrors3,
           /*headMessage*/
-          void 0,
-          intersectionState
+          void 0
         );
       }
     }
-    function signaturesIdenticalTo(source2, target2, kind) {
+    function signaturesIdenticalTo(source2, target2, kind, intersectionState) {
       const sourceSignatures = getSignaturesOfType(source2, kind);
       const targetSignatures = getSignaturesOfType(target2, kind);
       if (sourceSignatures.length !== targetSignatures.length) {
@@ -63145,7 +63193,7 @@ function createTypeChecker(host) {
           false,
           /*ignoreReturnTypes*/
           false,
-          isRelatedTo
+          isRelatedToWorker
         );
         if (!related) {
           return 0 /* False */;
@@ -63153,6 +63201,9 @@ function createTypeChecker(host) {
         result2 &= related;
       }
       return result2;
+      function isRelatedToWorker(source3, target3) {
+        return isRelatedTo(source3, target3, intersectionState);
+      }
     }
     function membersRelatedToIndexInfo(source2, targetInfo, reportErrors2, intersectionState) {
       let result2 = -1 /* True */;
@@ -63168,11 +63219,11 @@ function createTypeChecker(host) {
           const related = isRelatedTo(
             type,
             targetInfo.type,
+            intersectionState,
             3 /* Both */,
             reportErrors2,
             /*headMessage*/
-            void 0,
-            intersectionState
+            void 0
           );
           if (!related) {
             if (reportErrors2) {
@@ -63198,11 +63249,11 @@ function createTypeChecker(host) {
       const related = isRelatedTo(
         sourceInfo.type,
         targetInfo.type,
+        intersectionState,
         3 /* Both */,
         reportErrors2,
         /*headMessage*/
-        void 0,
-        intersectionState
+        void 0
       );
       if (!related && reportErrors2) {
         if (sourceInfo.keyType === targetInfo.keyType) {
@@ -63215,13 +63266,13 @@ function createTypeChecker(host) {
     }
     function indexSignaturesRelatedTo(source2, target2, sourceIsPrimitive, reportErrors2, intersectionState) {
       if (relation === identityRelation) {
-        return indexSignaturesIdenticalTo(source2, target2);
+        return indexSignaturesIdenticalTo(source2, target2, intersectionState);
       }
       const indexInfos = getIndexInfosOfType(target2);
       const targetHasStringIndex = some(indexInfos, (info) => info.keyType === stringType);
       let result2 = -1 /* True */;
       for (const targetInfo of indexInfos) {
-        const related = relation !== strictSubtypeRelation && !sourceIsPrimitive && targetHasStringIndex && targetInfo.type.flags & 1 /* Any */ ? -1 /* True */ : isGenericMappedType(source2) && targetHasStringIndex ? isRelatedTo(getTemplateTypeFromMappedType(source2), targetInfo.type, 3 /* Both */, reportErrors2) : typeRelatedToIndexInfo(source2, targetInfo, reportErrors2, intersectionState);
+        const related = relation !== strictSubtypeRelation && !sourceIsPrimitive && targetHasStringIndex && targetInfo.type.flags & 1 /* Any */ ? -1 /* True */ : isGenericMappedType(source2) && targetHasStringIndex ? isRelatedTo(getTemplateTypeFromMappedType(source2), targetInfo.type, intersectionState, 3 /* Both */, reportErrors2) : typeRelatedToIndexInfo(source2, targetInfo, reportErrors2, intersectionState);
         if (!related) {
           return 0 /* False */;
         }
@@ -63242,7 +63293,7 @@ function createTypeChecker(host) {
       }
       return 0 /* False */;
     }
-    function indexSignaturesIdenticalTo(source2, target2) {
+    function indexSignaturesIdenticalTo(source2, target2, intersectionState) {
       const sourceInfos = getIndexInfosOfType(source2);
       const targetInfos = getIndexInfosOfType(target2);
       if (sourceInfos.length !== targetInfos.length) {
@@ -63250,7 +63301,7 @@ function createTypeChecker(host) {
       }
       for (const targetInfo of targetInfos) {
         const sourceInfo = getIndexInfoOfType(source2, targetInfo.keyType);
-        if (!(sourceInfo && isRelatedTo(sourceInfo.type, targetInfo.type, 3 /* Both */) && sourceInfo.isReadonly === targetInfo.isReadonly)) {
+        if (!(sourceInfo && isRelatedTo(sourceInfo.type, targetInfo.type, intersectionState, 3 /* Both */) && sourceInfo.isReadonly === targetInfo.isReadonly)) {
           return 0 /* False */;
         }
       }
@@ -83188,20 +83239,7 @@ function createTypeChecker(host) {
     if (!signatureDeclaration) {
       return factory.createToken(133 /* AnyKeyword */);
     }
-    const signature = getSignatureFromDeclaration(signatureDeclaration);
-    const typePredicate = getTypePredicateOfSignature(signature);
-    if (typePredicate) {
-      return nodeBuilder.typePredicateToTypePredicateNode(typePredicate, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
-    }
-    return nodeBuilder.expressionOrTypeToTypeNode(
-      getPossibleTypeNodeReuseExpression(signatureDeclaration),
-      getReturnTypeOfSignature(signature),
-      /*addUndefined*/
-      void 0,
-      enclosingDeclaration,
-      flags | 1024 /* MultilineObjectLiterals */,
-      tracker
-    );
+    return nodeBuilder.serializeReturnTypeForSignature(getSignatureFromDeclaration(signatureDeclaration), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
   }
   function createTypeOfExpression(exprIn, enclosingDeclaration, flags, tracker) {
     const expr = getParseTreeNode(exprIn, isExpression);
@@ -121951,7 +121989,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
           impliedFormatPackageJsons.delete(newFile.resolvedPath);
       });
       impliedFormatPackageJsons.forEach((existing, path) => {
-        if (!(newProgram == null ? void 0 : newProgram.getSourceFileByPath(path))) {
+        const newFile = newProgram == null ? void 0 : newProgram.getSourceFileByPath(path);
+        if (!newFile || newFile.resolvedPath !== path) {
           existing.forEach((location) => fileWatchesOfAffectingLocations.get(location).files--);
           impliedFormatPackageJsons.delete(path);
         }