typescript 4.8.0-dev.20220630 → 4.8.0-dev.20220704

package/lib/typescript.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220630";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220704";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -5461,9 +5461,10 @@ var ts;
     (function (TypeMapKind) {
         TypeMapKind[TypeMapKind["Simple"] = 0] = "Simple";
         TypeMapKind[TypeMapKind["Array"] = 1] = "Array";
-        TypeMapKind[TypeMapKind["Function"] = 2] = "Function";
-        TypeMapKind[TypeMapKind["Composite"] = 3] = "Composite";
-        TypeMapKind[TypeMapKind["Merged"] = 4] = "Merged";
+        TypeMapKind[TypeMapKind["Deferred"] = 2] = "Deferred";
+        TypeMapKind[TypeMapKind["Function"] = 3] = "Function";
+        TypeMapKind[TypeMapKind["Composite"] = 4] = "Composite";
+        TypeMapKind[TypeMapKind["Merged"] = 5] = "Merged";
     })(TypeMapKind = ts.TypeMapKind || (ts.TypeMapKind = {}));
     var InferencePriority;
     (function (InferencePriority) {
@@ -48866,6 +48867,24 @@ var ts;
         var Symbol = ts.objectAllocator.getSymbolConstructor();
         var Type = ts.objectAllocator.getTypeConstructor();
         var Signature = ts.objectAllocator.getSignatureConstructor();
+        var DebugTypeMapper = /** @class */ (function () {
+            function DebugTypeMapper() {
+            }
+            DebugTypeMapper.prototype.__debugToString = function () {
+                var _a;
+                ts.Debug.type(this);
+                switch (this.kind) {
+                    case 3 /* Function */: return ((_a = this.debugInfo) === null || _a === void 0 ? void 0 : _a.call(this)) || "(function mapper)";
+                    case 0 /* Simple */: return this.source.__debugTypeToString() + " -> " + this.target.__debugTypeToString();
+                    case 1 /* Array */: return ts.zipWith(this.sources, this.targets || ts.map(this.sources, function () { return anyType; }), function (s, t) { return s.__debugTypeToString() + " -> " + t.__debugTypeToString(); }).join(", ");
+                    case 2 /* Deferred */: return ts.zipWith(this.sources, this.targets, function (s, t) { return s.__debugTypeToString() + " -> " + t().__debugTypeToString(); }).join(", ");
+                    case 5 /* Merged */:
+                    case 4 /* Composite */: return "m1: " + this.mapper1.__debugToString().split("\n").join("\n    ") + "\nm2: " + this.mapper2.__debugToString().split("\n").join("\n    ");
+                    default: return ts.Debug.assertNever(this);
+                }
+            };
+            return DebugTypeMapper;
+        }());
         var typeCount = 0;
         var symbolCount = 0;
         var enumCount = 0;
@@ -49326,10 +49345,23 @@ var ts;
         var numberOrBigIntType = getUnionType([numberType, bigintType]);
         var templateConstraintType = getUnionType([stringType, numberType, booleanType, bigintType, nullType, undefinedType]);
         var numericStringType = getTemplateLiteralType(["", ""], [numberType]); // The `${number}` type
-        var restrictiveMapper = makeFunctionTypeMapper(function (t) { return t.flags & 262144 /* TypeParameter */ ? getRestrictiveTypeParameter(t) : t; });
-        var permissiveMapper = makeFunctionTypeMapper(function (t) { return t.flags & 262144 /* TypeParameter */ ? wildcardType : t; });
+        var restrictiveMapper = makeFunctionTypeMapper(function (t) { return t.flags & 262144 /* TypeParameter */ ? getRestrictiveTypeParameter(t) : t; }, function () { return "(restrictive mapper)"; });
+        var permissiveMapper = makeFunctionTypeMapper(function (t) { return t.flags & 262144 /* TypeParameter */ ? wildcardType : t; }, function () { return "(permissive mapper)"; });
         var uniqueLiteralType = createIntrinsicType(131072 /* Never */, "never"); // `uniqueLiteralType` is a special `never` flagged by union reduction to behave as a literal
-        var uniqueLiteralMapper = makeFunctionTypeMapper(function (t) { return t.flags & 262144 /* TypeParameter */ ? uniqueLiteralType : t; }); // replace all type parameters with the unique literal type (disregarding constraints)
+        var uniqueLiteralMapper = makeFunctionTypeMapper(function (t) { return t.flags & 262144 /* TypeParameter */ ? uniqueLiteralType : t; }, function () { return "(unique literal mapper)"; }); // replace all type parameters with the unique literal type (disregarding constraints)
+        var outofbandVarianceMarkerHandler;
+        var reportUnreliableMapper = makeFunctionTypeMapper(function (t) {
+            if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) {
+                outofbandVarianceMarkerHandler(/*onlyUnreliable*/ true);
+            }
+            return t;
+        }, function () { return "(unmeasurable reporter)"; });
+        var reportUnmeasurableMapper = makeFunctionTypeMapper(function (t) {
+            if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) {
+                outofbandVarianceMarkerHandler(/*onlyUnreliable*/ false);
+            }
+            return t;
+        }, function () { return "(unreliable reporter)"; });
         var emptyObjectType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
         var emptyJsxObjectType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
         emptyJsxObjectType.objectFlags |= 2048 /* JsxAttributes */;
@@ -49489,7 +49521,6 @@ var ts;
         var typeofType = createTypeofType();
         var _jsxNamespace;
         var _jsxFactoryEntity;
-        var outofbandVarianceMarkerHandler;
         var subtypeRelation = new ts.Map();
         var strictSubtypeRelation = new ts.Map();
         var assignableRelation = new ts.Map();
@@ -53256,7 +53287,7 @@ var ts;
                         var name = typeParameterToName(newParam, context);
                         var newTypeVariable = ts.factory.createTypeReferenceNode(name);
                         context.approximateLength += 37; // 15 each for two added conditionals, 7 for an added infer type
-                        var newMapper = prependTypeMapping(type.root.checkType, newParam, type.combinedMapper || type.mapper);
+                        var newMapper = prependTypeMapping(type.root.checkType, newParam, type.mapper);
                         var saveInferTypeParameters_1 = context.inferTypeParameters;
                         context.inferTypeParameters = type.root.inferTypeParameters;
                         var extendsTypeNode_1 = typeToTypeNodeHelper(instantiateType(type.root.extendsType, newMapper), context);
@@ -60667,8 +60698,7 @@ var ts;
             var _a;
             var inferences;
             if ((_a = typeParameter.symbol) === null || _a === void 0 ? void 0 : _a.declarations) {
-                for (var _i = 0, _b = typeParameter.symbol.declarations; _i < _b.length; _i++) {
-                    var declaration = _b[_i];
+                var _loop_15 = function (declaration) {
                     if (declaration.parent.kind === 190 /* InferType */) {
                         // When an 'infer T' declaration is immediately contained in a type reference node
                         // (such as 'Foo<infer T>'), T's constraint is inferred from the constraint of the
@@ -60676,12 +60706,12 @@ var ts;
                         // present, we form an intersection of the inferred constraint types.
                         var _c = ts.walkUpParenthesizedTypesAndGetParentAndChild(declaration.parent.parent), _d = _c[0], childTypeParameter = _d === void 0 ? declaration.parent : _d, grandParent = _c[1];
                         if (grandParent.kind === 178 /* TypeReference */ && !omitTypeReferences) {
-                            var typeReference = grandParent;
-                            var typeParameters = getTypeParametersForTypeReference(typeReference);
-                            if (typeParameters) {
-                                var index = typeReference.typeArguments.indexOf(childTypeParameter);
-                                if (index < typeParameters.length) {
-                                    var declaredConstraint = getConstraintOfTypeParameter(typeParameters[index]);
+                            var typeReference_1 = grandParent;
+                            var typeParameters_1 = getTypeParametersForTypeReference(typeReference_1);
+                            if (typeParameters_1) {
+                                var index = typeReference_1.typeArguments.indexOf(childTypeParameter);
+                                if (index < typeParameters_1.length) {
+                                    var declaredConstraint = getConstraintOfTypeParameter(typeParameters_1[index]);
                                     if (declaredConstraint) {
                                         // Type parameter constraints can reference other type parameters so
                                         // constraints need to be instantiated. If instantiation produces the
@@ -60689,7 +60719,9 @@ var ts;
                                         //   type Foo<T extends string, U extends T> = [T, U];
                                         //   type Bar<T> = T extends Foo<infer X, infer X> ? Foo<X, X> : T;
                                         // the instantiated constraint for U is X, so we discard that inference.
-                                        var mapper = createTypeMapper(typeParameters, getEffectiveTypeArguments(typeReference, typeParameters));
+                                        var mapper = makeDeferredTypeMapper(typeParameters_1, typeParameters_1.map(function (_, index) { return function () {
+                                            return getEffectiveTypeArgumentAtIndex(typeReference_1, typeParameters_1, index);
+                                        }; }));
                                         var constraint = instantiateType(declaredConstraint, mapper);
                                         if (constraint !== typeParameter) {
                                             inferences = ts.append(inferences, constraint);
@@ -60727,6 +60759,10 @@ var ts;
                             inferences = ts.append(inferences, instantiateType(nodeType, makeUnaryTypeMapper(getDeclaredTypeOfTypeParameter(getSymbolOfNode(checkMappedType_1.typeParameter)), checkMappedType_1.typeParameter.constraint ? getTypeFromTypeNode(checkMappedType_1.typeParameter.constraint) : keyofConstraintType)));
                         }
                     }
+                };
+                for (var _i = 0, _b = typeParameter.symbol.declarations; _i < _b.length; _i++) {
+                    var declaration = _b[_i];
+                    _loop_15(declaration);
                 }
             }
             return inferences && getIntersectionType(inferences);
@@ -61615,7 +61651,7 @@ var ts;
             var lastRequiredIndex = -1;
             var firstRestIndex = -1;
             var lastOptionalOrRestIndex = -1;
-            var _loop_15 = function (i) {
+            var _loop_16 = function (i) {
                 var type = elementTypes[i];
                 var flags = target.elementFlags[i];
                 if (flags & 8 /* Variadic */) {
@@ -61645,7 +61681,7 @@ var ts;
                 }
             };
             for (var i = 0; i < elementTypes.length; i++) {
-                var state_4 = _loop_15(i);
+                var state_4 = _loop_16(i);
                 if (typeof state_4 === "object")
                     return state_4.value;
             }
@@ -61841,7 +61877,7 @@ var ts;
             var templates = ts.filter(types, isPatternLiteralType);
             if (templates.length) {
                 var i = types.length;
-                var _loop_16 = function () {
+                var _loop_17 = function () {
                     i--;
                     var t = types[i];
                     if (t.flags & 128 /* StringLiteral */ && ts.some(templates, function (template) { return isTypeMatchedByTemplateLiteralType(t, template); })) {
@@ -61849,7 +61885,7 @@ var ts;
                     }
                 };
                 while (i > 0) {
-                    _loop_16();
+                    _loop_17();
                 }
             }
         }
@@ -61926,14 +61962,14 @@ var ts;
                 var namedUnions = [];
                 addNamedUnions(namedUnions, types);
                 var reducedTypes = [];
-                var _loop_17 = function (t) {
+                var _loop_18 = function (t) {
                     if (!ts.some(namedUnions, function (union) { return containsType(union.types, t); })) {
                         reducedTypes.push(t);
                     }
                 };
                 for (var _i = 0, typeSet_1 = typeSet; _i < typeSet_1.length; _i++) {
                     var t = typeSet_1[_i];
-                    _loop_17(t);
+                    _loop_18(t);
                 }
                 if (!aliasSymbol && namedUnions.length === 1 && reducedTypes.length === 0) {
                     return namedUnions[0];
@@ -63157,7 +63193,7 @@ var ts;
             var result;
             var extraTypes;
             var tailCount = 0;
-            var _loop_18 = function () {
+            var _loop_19 = function () {
                 if (tailCount === 1000) {
                     error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
                     result = errorType;
@@ -63278,7 +63314,7 @@ var ts;
             // another (or, through recursion, possibly the same) conditional type. In the potentially tail-recursive
             // cases we increment the tail recursion counter and stop after 1000 iterations.
             while (true) {
-                var state_5 = _loop_18();
+                var state_5 = _loop_19();
                 if (typeof state_5 === "object")
                     return state_5.value;
                 if (state_5 === "break")
@@ -63908,7 +63944,7 @@ var ts;
             switch (mapper.kind) {
                 case 0 /* Simple */:
                     return type === mapper.source ? mapper.target : type;
-                case 1 /* Array */:
+                case 1 /* Array */: {
                     var sources = mapper.sources;
                     var targets = mapper.targets;
                     for (var i = 0; i < sources.length; i++) {
@@ -63917,25 +63953,45 @@ var ts;
                         }
                     }
                     return type;
-                case 2 /* Function */:
+                }
+                case 2 /* Deferred */: {
+                    var sources = mapper.sources;
+                    var targets = mapper.targets;
+                    for (var i = 0; i < sources.length; i++) {
+                        if (type === sources[i]) {
+                            return targets[i]();
+                        }
+                    }
+                    return type;
+                }
+                case 3 /* Function */:
                     return mapper.func(type);
-                case 3 /* Composite */:
-                case 4 /* Merged */:
+                case 4 /* Composite */:
+                case 5 /* Merged */:
                     var t1 = getMappedType(type, mapper.mapper1);
-                    return t1 !== type && mapper.kind === 3 /* Composite */ ? instantiateType(t1, mapper.mapper2) : getMappedType(t1, mapper.mapper2);
+                    return t1 !== type && mapper.kind === 4 /* Composite */ ? instantiateType(t1, mapper.mapper2) : getMappedType(t1, mapper.mapper2);
+            }
+        }
+        function attachDebugPrototypeIfDebug(mapper) {
+            if (ts.Debug.isDebugging) {
+                return Object.setPrototypeOf(mapper, DebugTypeMapper.prototype);
             }
+            return mapper;
         }
         function makeUnaryTypeMapper(source, target) {
-            return { kind: 0 /* Simple */, source: source, target: target };
+            return attachDebugPrototypeIfDebug({ kind: 0 /* Simple */, source: source, target: target });
         }
         function makeArrayTypeMapper(sources, targets) {
-            return { kind: 1 /* Array */, sources: sources, targets: targets };
+            return attachDebugPrototypeIfDebug({ kind: 1 /* Array */, sources: sources, targets: targets });
+        }
+        function makeFunctionTypeMapper(func, debugInfo) {
+            return attachDebugPrototypeIfDebug({ kind: 3 /* Function */, func: func, debugInfo: ts.Debug.isDebugging ? debugInfo : undefined });
         }
-        function makeFunctionTypeMapper(func) {
-            return { kind: 2 /* Function */, func: func };
+        function makeDeferredTypeMapper(sources, targets) {
+            return attachDebugPrototypeIfDebug({ kind: 2 /* Deferred */, sources: sources, targets: targets });
         }
         function makeCompositeTypeMapper(kind, mapper1, mapper2) {
-            return { kind: kind, mapper1: mapper1, mapper2: mapper2 };
+            return attachDebugPrototypeIfDebug({ kind: kind, mapper1: mapper1, mapper2: mapper2 });
         }
         function createTypeEraser(sources) {
             return createTypeMapper(sources, /*targets*/ undefined);
@@ -63945,19 +64001,20 @@ var ts;
          * This is used during inference when instantiating type parameter defaults.
          */
         function createBackreferenceMapper(context, index) {
-            return makeFunctionTypeMapper(function (t) { return ts.findIndex(context.inferences, function (info) { return info.typeParameter === t; }) >= index ? unknownType : t; });
+            var forwardInferences = context.inferences.slice(index);
+            return createTypeMapper(ts.map(forwardInferences, function (i) { return i.typeParameter; }), ts.map(forwardInferences, function () { return unknownType; }));
         }
         function combineTypeMappers(mapper1, mapper2) {
-            return mapper1 ? makeCompositeTypeMapper(3 /* Composite */, mapper1, mapper2) : mapper2;
+            return mapper1 ? makeCompositeTypeMapper(4 /* Composite */, mapper1, mapper2) : mapper2;
         }
         function mergeTypeMappers(mapper1, mapper2) {
-            return mapper1 ? makeCompositeTypeMapper(4 /* Merged */, mapper1, mapper2) : mapper2;
+            return mapper1 ? makeCompositeTypeMapper(5 /* Merged */, mapper1, mapper2) : mapper2;
         }
         function prependTypeMapping(source, target, mapper) {
-            return !mapper ? makeUnaryTypeMapper(source, target) : makeCompositeTypeMapper(4 /* Merged */, makeUnaryTypeMapper(source, target), mapper);
+            return !mapper ? makeUnaryTypeMapper(source, target) : makeCompositeTypeMapper(5 /* Merged */, makeUnaryTypeMapper(source, target), mapper);
         }
         function appendTypeMapping(mapper, source, target) {
-            return !mapper ? makeUnaryTypeMapper(source, target) : makeCompositeTypeMapper(4 /* Merged */, mapper, makeUnaryTypeMapper(source, target));
+            return !mapper ? makeUnaryTypeMapper(source, target) : makeCompositeTypeMapper(5 /* Merged */, mapper, makeUnaryTypeMapper(source, target));
         }
         function getRestrictiveTypeParameter(tp) {
             return tp.constraint === unknownType ? tp : tp.restrictiveInstantiation || (tp.restrictiveInstantiation = createTypeParameter(tp.symbol),
@@ -65853,7 +65910,7 @@ var ts;
                     reducedTarget = findMatchingDiscriminantType(source, target, isRelatedTo) || filterPrimitivesIfContainsNonPrimitive(target);
                     checkTypes = reducedTarget.flags & 1048576 /* Union */ ? reducedTarget.types : [reducedTarget];
                 }
-                var _loop_19 = function (prop) {
+                var _loop_20 = function (prop) {
                     if (shouldCheckAsExcessProperty(prop, source.symbol) && !isIgnoredJsxProperty(source, prop)) {
                         if (!isKnownProperty(reducedTarget, prop.escapedName, isComparingJsxAttributes)) {
                             if (reportErrors) {
@@ -65916,7 +65973,7 @@ var ts;
                 };
                 for (var _i = 0, _b = getPropertiesOfType(source); _i < _b.length; _i++) {
                     var prop = _b[_i];
-                    var state_6 = _loop_19(prop);
+                    var state_6 = _loop_20(prop);
                     if (typeof state_6 === "object")
                         return state_6.value;
                 }
@@ -66148,10 +66205,10 @@ var ts;
                             // We're in the middle of variance checking - integrate any unmeasurable/unreliable flags from this cached component
                             var saved = entry & 24 /* ReportsMask */;
                             if (saved & 8 /* ReportsUnmeasurable */) {
-                                instantiateType(source, makeFunctionTypeMapper(reportUnmeasurableMarkers));
+                                instantiateType(source, reportUnmeasurableMapper);
                             }
                             if (saved & 16 /* ReportsUnreliable */) {
-                                instantiateType(source, makeFunctionTypeMapper(reportUnreliableMarkers));
+                                instantiateType(source, reportUnreliableMapper);
                             }
                         }
                         return entry & 1 /* Succeeded */ ? -1 /* True */ : 0 /* False */;
@@ -66577,7 +66634,7 @@ var ts;
                         }
                         // Report unreliable variance for type variables referenced in template literal type placeholders.
                         // For example, `foo-${number}` is related to `foo-${string}` even though number isn't related to string.
-                        instantiateType(source, makeFunctionTypeMapper(reportUnreliableMarkers));
+                        instantiateType(source, reportUnreliableMapper);
                     }
                     if (isTypeMatchedByTemplateLiteralType(source, target)) {
                         return -1 /* True */;
@@ -66849,18 +66906,6 @@ var ts;
                     }
                 }
             }
-            function reportUnmeasurableMarkers(p) {
-                if (outofbandVarianceMarkerHandler && (p === markerSuperType || p === markerSubType || p === markerOtherType)) {
-                    outofbandVarianceMarkerHandler(/*onlyUnreliable*/ false);
-                }
-                return p;
-            }
-            function reportUnreliableMarkers(p) {
-                if (outofbandVarianceMarkerHandler && (p === markerSuperType || p === markerSubType || p === markerOtherType)) {
-                    outofbandVarianceMarkerHandler(/*onlyUnreliable*/ true);
-                }
-                return p;
-            }
             // A type [P in S]: X is related to a type [Q in T]: Y if T is related to S and X' is
             // related to Y, where X' is an instantiation of X in which P is replaced with Q. Notice
             // that S and T are contra-variant whereas X and Y are co-variant.
@@ -66870,7 +66915,7 @@ var ts;
                 if (modifiersRelated) {
                     var result_10;
                     var targetConstraint = getConstraintTypeFromMappedType(target);
-                    var sourceConstraint = instantiateType(getConstraintTypeFromMappedType(source), makeFunctionTypeMapper(getCombinedMappedTypeOptionality(source) < 0 ? reportUnmeasurableMarkers : reportUnreliableMarkers));
+                    var sourceConstraint = instantiateType(getConstraintTypeFromMappedType(source), getCombinedMappedTypeOptionality(source) < 0 ? reportUnmeasurableMapper : reportUnreliableMapper);
                     if (result_10 = isRelatedTo(targetConstraint, sourceConstraint, 3 /* Both */, reportErrors)) {
                         var mapper = createTypeMapper([getTypeParameterFromMappedType(source)], [getTypeParameterFromMappedType(target)]);
                         if (instantiateType(getNameTypeFromMappedType(source), mapper) === instantiateType(getNameTypeFromMappedType(target), mapper)) {
@@ -66924,11 +66969,11 @@ var ts;
                 // constituents of 'target'. If any combination does not have a match then 'source' is not relatable.
                 var discriminantCombinations = ts.cartesianProduct(sourceDiscriminantTypes);
                 var matchingTypes = [];
-                var _loop_20 = function (combination) {
+                var _loop_21 = function (combination) {
                     var hasMatch = false;
                     outer: for (var _c = 0, _d = target.types; _c < _d.length; _c++) {
                         var type = _d[_c];
-                        var _loop_21 = function (i) {
+                        var _loop_22 = function (i) {
                             var sourceProperty = sourcePropertiesFiltered[i];
                             var targetProperty = getPropertyOfType(type, sourceProperty.escapedName);
                             if (!targetProperty)
@@ -66944,7 +66989,7 @@ var ts;
                             }
                         };
                         for (var i = 0; i < sourcePropertiesFiltered.length; i++) {
-                            var state_8 = _loop_21(i);
+                            var state_8 = _loop_22(i);
                             switch (state_8) {
                                 case "continue-outer": continue outer;
                             }
@@ -66958,7 +67003,7 @@ var ts;
                 };
                 for (var _a = 0, discriminantCombinations_1 = discriminantCombinations; _a < discriminantCombinations_1.length; _a++) {
                     var combination = discriminantCombinations_1[_a];
-                    var state_7 = _loop_20(combination);
+                    var state_7 = _loop_21(combination);
                     if (typeof state_7 === "object")
                         return state_7.value;
                 }
@@ -67406,7 +67451,7 @@ var ts;
              * See signatureAssignableTo, compareSignaturesIdentical
              */
             function signatureRelatedTo(source, target, erase, reportErrors, incompatibleReporter) {
-                return compareSignaturesRelated(erase ? getErasedSignature(source) : source, erase ? getErasedSignature(target) : target, relation === strictSubtypeRelation ? 8 /* StrictArity */ : 0, reportErrors, reportError, incompatibleReporter, isRelatedToWorker, makeFunctionTypeMapper(reportUnreliableMarkers));
+                return compareSignaturesRelated(erase ? getErasedSignature(source) : source, erase ? getErasedSignature(target) : target, relation === strictSubtypeRelation ? 8 /* StrictArity */ : 0, reportErrors, reportError, incompatibleReporter, isRelatedToWorker, reportUnreliableMapper);
             }
             function signaturesIdenticalTo(source, target, kind) {
                 var sourceSignatures = getSignaturesOfType(source, kind);
@@ -67665,7 +67710,7 @@ var ts;
                 ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("checkTypes" /* CheckTypes */, "getVariancesWorker", { arity: typeParameters.length, id: getTypeId(getDeclaredTypeOfSymbol(symbol)) });
                 links.variances = ts.emptyArray;
                 var variances = [];
-                var _loop_22 = function (tp) {
+                var _loop_23 = function (tp) {
                     var modifiers = getVarianceModifiers(tp);
                     var variance = modifiers & 65536 /* Out */ ?
                         modifiers & 32768 /* In */ ? 0 /* Invariant */ : 1 /* Covariant */ :
@@ -67701,9 +67746,9 @@ var ts;
                     }
                     variances.push(variance);
                 };
-                for (var _i = 0, typeParameters_1 = typeParameters; _i < typeParameters_1.length; _i++) {
-                    var tp = typeParameters_1[_i];
-                    _loop_22(tp);
+                for (var _i = 0, typeParameters_2 = typeParameters; _i < typeParameters_2.length; _i++) {
+                    var tp = typeParameters_2[_i];
+                    _loop_23(tp);
                 }
                 links.variances = variances;
                 ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop({ variances: variances.map(ts.Debug.formatVariance) });
@@ -68698,27 +68743,29 @@ var ts;
                 signature: signature,
                 flags: flags,
                 compareTypes: compareTypes,
-                mapper: makeFunctionTypeMapper(function (t) { return mapToInferredType(context, t, /*fix*/ true); }),
-                nonFixingMapper: makeFunctionTypeMapper(function (t) { return mapToInferredType(context, t, /*fix*/ false); }),
+                mapper: reportUnmeasurableMapper,
+                nonFixingMapper: reportUnmeasurableMapper,
             };
+            context.mapper = makeFixingMapperForContext(context);
+            context.nonFixingMapper = makeNonFixingMapperForContext(context);
             return context;
         }
-        function mapToInferredType(context, t, fix) {
-            var inferences = context.inferences;
-            for (var i = 0; i < inferences.length; i++) {
-                var inference = inferences[i];
-                if (t === inference.typeParameter) {
-                    if (fix && !inference.isFixed) {
-                        // Before we commit to a particular inference (and thus lock out any further inferences),
-                        // we infer from any intra-expression inference sites we have collected.
-                        inferFromIntraExpressionSites(context);
-                        clearCachedInferences(inferences);
-                        inference.isFixed = true;
-                    }
-                    return getInferredType(context, i);
+        function makeFixingMapperForContext(context) {
+            return makeDeferredTypeMapper(ts.map(context.inferences, function (i) { return i.typeParameter; }), ts.map(context.inferences, function (inference, i) { return function () {
+                if (!inference.isFixed) {
+                    // Before we commit to a particular inference (and thus lock out any further inferences),
+                    // we infer from any intra-expression inference sites we have collected.
+                    inferFromIntraExpressionSites(context);
+                    clearCachedInferences(context.inferences);
+                    inference.isFixed = true;
                 }
-            }
-            return t;
+                return getInferredType(context, i);
+            }; }));
+        }
+        function makeNonFixingMapperForContext(context) {
+            return makeDeferredTypeMapper(ts.map(context.inferences, function (i) { return i.typeParameter; }), ts.map(context.inferences, function (_, i) { return function () {
+                return getInferredType(context, i);
+            }; }));
         }
         function clearCachedInferences(inferences) {
             for (var _i = 0, inferences_1 = inferences; _i < inferences_1.length; _i++) {
@@ -69638,7 +69685,7 @@ var ts;
                 // upon instantiation, would collapse all the placeholders to just 'string', and an assignment check might
                 // succeed. That would be a pointless and confusing outcome.
                 if (matches || ts.every(target.texts, function (s) { return s.length === 0; })) {
-                    var _loop_23 = function (i) {
+                    var _loop_24 = function (i) {
                         var source_1 = matches ? matches[i] : neverType;
                         var target_3 = types[i];
                         // If we are inferring from a string literal type to a type variable whose constraint includes one of the
@@ -69688,7 +69735,7 @@ var ts;
                         inferFromTypes(source_1, target_3);
                     };
                     for (var i = 0; i < types.length; i++) {
-                        _loop_23(i);
+                        _loop_24(i);
                     }
                 }
             }
@@ -70206,7 +70253,7 @@ var ts;
         function mapTypesByKeyProperty(types, name) {
             var map = new ts.Map();
             var count = 0;
-            var _loop_24 = function (type) {
+            var _loop_25 = function (type) {
                 if (type.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 58982400 /* InstantiableNonPrimitive */)) {
                     var discriminant = getTypeOfPropertyOfType(type, name);
                     if (discriminant) {
@@ -70232,7 +70279,7 @@ var ts;
             };
             for (var _i = 0, types_15 = types; _i < types_15.length; _i++) {
                 var type = types_15[_i];
-                var state_9 = _loop_24(type);
+                var state_9 = _loop_25(type);
                 if (typeof state_9 === "object")
                     return state_9.value;
             }
@@ -76581,7 +76628,7 @@ var ts;
             if (spreadIndex >= 0) {
                 // Create synthetic arguments from spreads of tuple types.
                 var effectiveArgs_1 = args.slice(0, spreadIndex);
-                var _loop_25 = function (i) {
+                var _loop_26 = function (i) {
                     var arg = args[i];
                     // We can call checkExpressionCached because spread expressions never have a contextual type.
                     var spreadType = arg.kind === 225 /* SpreadElement */ && (flowLoopCount ? checkExpression(arg.expression) : checkExpressionCached(arg.expression));
@@ -76598,7 +76645,7 @@ var ts;
                     }
                 };
                 for (var i = spreadIndex; i < args.length; i++) {
-                    _loop_25(i);
+                    _loop_26(i);
                 }
                 return effectiveArgs_1;
             }
@@ -76927,7 +76974,7 @@ var ts;
                         var min_3 = Number.MAX_VALUE;
                         var minIndex = 0;
                         var i_1 = 0;
-                        var _loop_26 = function (c) {
+                        var _loop_27 = function (c) {
                             var chain_2 = function () { return ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Overload_0_of_1_2_gave_the_following_error, i_1 + 1, candidates.length, signatureToString(c)); };
                             var diags_2 = getSignatureApplicabilityError(node, args, c, assignableRelation, 0 /* Normal */, /*reportErrors*/ true, chain_2);
                             if (diags_2) {
@@ -76945,7 +76992,7 @@ var ts;
                         };
                         for (var _a = 0, candidatesForArgumentError_1 = candidatesForArgumentError; _a < candidatesForArgumentError_1.length; _a++) {
                             var c = candidatesForArgumentError_1[_a];
-                            _loop_26(c);
+                            _loop_27(c);
                         }
                         var diags_3 = max > 1 ? allDiagnostics[minIndex] : ts.flatten(allDiagnostics);
                         ts.Debug.assert(diags_3.length > 0, "No errors reported for 3 or fewer overload signatures");
@@ -77103,7 +77150,7 @@ var ts;
             }
             var _a = ts.minAndMax(candidates, getNumNonRestParameters), minArgumentCount = _a.min, maxNonRestParam = _a.max;
             var parameters = [];
-            var _loop_27 = function (i) {
+            var _loop_28 = function (i) {
                 var symbols = ts.mapDefined(candidates, function (s) { return signatureHasRestParameter(s) ?
                     i < s.parameters.length - 1 ? s.parameters[i] : ts.last(s.parameters) :
                     i < s.parameters.length ? s.parameters[i] : undefined; });
@@ -77111,7 +77158,7 @@ var ts;
                 parameters.push(createCombinedSymbolFromTypes(symbols, ts.mapDefined(candidates, function (candidate) { return tryGetTypeAtPosition(candidate, i); })));
             };
             for (var i = 0; i < maxNonRestParam; i++) {
-                _loop_27(i);
+                _loop_28(i);
             }
             var restParameterSymbols = ts.mapDefined(candidates, function (c) { return signatureHasRestParameter(c) ? ts.last(c.parameters) : undefined; });
             var flags = 0 /* None */;
@@ -80464,8 +80511,8 @@ var ts;
             var result = [];
             var oldTypeParameters;
             var newTypeParameters;
-            for (var _i = 0, typeParameters_2 = typeParameters; _i < typeParameters_2.length; _i++) {
-                var tp = typeParameters_2[_i];
+            for (var _i = 0, typeParameters_3 = typeParameters; _i < typeParameters_3.length; _i++) {
+                var tp = typeParameters_3[_i];
                 var name = tp.symbol.escapedName;
                 if (hasTypeParameterByName(context.inferredTypeParameters, name) || hasTypeParameterByName(result, name)) {
                     var newName = getUniqueTypeParameterName(ts.concatenate(context.inferredTypeParameters, result), name);
@@ -81144,7 +81191,7 @@ var ts;
             var indexSymbol = getIndexSymbol(getSymbolOfNode(node));
             if (indexSymbol === null || indexSymbol === void 0 ? void 0 : indexSymbol.declarations) {
                 var indexSignatureMap_1 = new ts.Map();
-                var _loop_28 = function (declaration) {
+                var _loop_29 = function (declaration) {
                     if (declaration.parameters.length === 1 && declaration.parameters[0].type) {
                         forEachType(getTypeFromTypeNode(declaration.parameters[0].type), function (type) {
                             var entry = indexSignatureMap_1.get(getTypeId(type));
@@ -81159,7 +81206,7 @@ var ts;
                 };
                 for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) {
                     var declaration = _a[_i];
-                    _loop_28(declaration);
+                    _loop_29(declaration);
                 }
                 indexSignatureMap_1.forEach(function (entry) {
                     if (entry.declarations.length > 1) {
@@ -81382,6 +81429,12 @@ var ts;
         function checkMissingDeclaration(node) {
             checkDecorators(node);
         }
+        function getEffectiveTypeArgumentAtIndex(node, typeParameters, index) {
+            if (index < typeParameters.length) {
+                return getTypeFromTypeNode(node.typeArguments[index]);
+            }
+            return getEffectiveTypeArguments(node, typeParameters)[index];
+        }
         function getEffectiveTypeArguments(node, typeParameters) {
             return fillMissingTypeArguments(ts.map(node.typeArguments, getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), ts.isInJSFile(node));
         }
@@ -82123,6 +82176,32 @@ var ts;
                 isAwaitedTypeInstantiation(type) ? type.aliasTypeArguments[0] :
                     type;
         }
+        function isAwaitedTypeNeeded(type) {
+            // If this is already an `Awaited<T>`, we shouldn't wrap it. This helps to avoid `Awaited<Awaited<T>>` in higher-order.
+            if (isTypeAny(type) || isAwaitedTypeInstantiation(type)) {
+                return false;
+            }
+            // We only need `Awaited<T>` if `T` contains possibly non-primitive types.
+            if (isGenericObjectType(type)) {
+                var baseConstraint = getBaseConstraintOfType(type);
+                // We only need `Awaited<T>` if `T` has no base constraint, or the base constraint of `T` is `any`, `unknown`, `{}`, `object`,
+                // or is promise-like.
+                if (!baseConstraint || (baseConstraint.flags & 3 /* AnyOrUnknown */) || isEmptyObjectType(baseConstraint) || isThenableType(baseConstraint)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function tryCreateAwaitedType(type) {
+            // Nothing to do if `Awaited<T>` doesn't exist
+            var awaitedSymbol = getGlobalAwaitedSymbol(/*reportErrors*/ true);
+            if (awaitedSymbol) {
+                // Unwrap unions that may contain `Awaited<T>`, otherwise its possible to manufacture an `Awaited<Awaited<T> | U>` where
+                // an `Awaited<T | U>` would suffice.
+                return getTypeAliasInstantiation(awaitedSymbol, [unwrapAwaitedType(type)]);
+            }
+            return undefined;
+        }
         function createAwaitedTypeIfNeeded(type) {
             // We wrap type `T` in `Awaited<T>` based on the following conditions:
             // - `T` is not already an `Awaited<U>`, and
@@ -82131,26 +82210,10 @@ var ts;
             //   - `T` has no base constraint, or
             //   - The base constraint of `T` is `any`, `unknown`, `object`, or `{}`, or
             //   - The base constraint of `T` is an object type with a callable `then` method.
-            if (isTypeAny(type)) {
-                return type;
-            }
-            // If this is already an `Awaited<T>`, just return it. This helps to avoid `Awaited<Awaited<T>>` in higher-order.
-            if (isAwaitedTypeInstantiation(type)) {
-                return type;
-            }
-            // Only instantiate `Awaited<T>` if `T` contains possibly non-primitive types.
-            if (isGenericObjectType(type)) {
-                var baseConstraint = getBaseConstraintOfType(type);
-                // Only instantiate `Awaited<T>` if `T` has no base constraint, or the base constraint of `T` is `any`, `unknown`, `{}`, `object`,
-                // or is promise-like.
-                if (!baseConstraint || (baseConstraint.flags & 3 /* AnyOrUnknown */) || isEmptyObjectType(baseConstraint) || isThenableType(baseConstraint)) {
-                    // Nothing to do if `Awaited<T>` doesn't exist
-                    var awaitedSymbol = getGlobalAwaitedSymbol(/*reportErrors*/ true);
-                    if (awaitedSymbol) {
-                        // Unwrap unions that may contain `Awaited<T>`, otherwise its possible to manufacture an `Awaited<Awaited<T> | U>` where
-                        // an `Awaited<T | U>` would suffice.
-                        return getTypeAliasInstantiation(awaitedSymbol, [unwrapAwaitedType(type)]);
-                    }
+            if (isAwaitedTypeNeeded(type)) {
+                var awaitedType = tryCreateAwaitedType(type);
+                if (awaitedType) {
+                    return awaitedType;
                 }
             }
             ts.Debug.assert(getPromisedTypeOfPromise(type) === undefined, "type provided should not be a non-generic 'promise'-like.");
@@ -82202,6 +82265,10 @@ var ts;
                 awaitedTypeStack.pop();
                 return typeAsAwaitable.awaitedTypeOfType = mapped;
             }
+            // If `type` is generic and should be wrapped in `Awaited<T>`, return it.
+            if (isAwaitedTypeNeeded(type)) {
+                return typeAsAwaitable.awaitedTypeOfType = type;
+            }
             var thisTypeForErrorOut = { value: undefined };
             var promisedType = getPromisedTypeOfPromise(type, /*errorNode*/ undefined, thisTypeForErrorOut);
             if (promisedType) {
@@ -82849,8 +82916,8 @@ var ts;
                 return;
             var typeParameters = ts.getEffectiveTypeParameterDeclarations(node);
             var seenParentsWithEveryUnused = new ts.Set();
-            for (var _i = 0, typeParameters_3 = typeParameters; _i < typeParameters_3.length; _i++) {
-                var typeParameter = typeParameters_3[_i];
+            for (var _i = 0, typeParameters_4 = typeParameters; _i < typeParameters_4.length; _i++) {
+                var typeParameter = typeParameters_4[_i];
                 if (!isTypeParameterUnused(typeParameter))
                     continue;
                 var name = ts.idText(typeParameter.name);
@@ -84669,7 +84736,7 @@ var ts;
             var interfaceDeclaration = ts.getObjectFlags(type) & 2 /* Interface */ ? ts.getDeclarationOfKind(type.symbol, 258 /* InterfaceDeclaration */) : undefined;
             var localPropDeclaration = declaration && declaration.kind === 221 /* BinaryExpression */ ||
                 name && name.kind === 162 /* ComputedPropertyName */ || getParentOfSymbol(prop) === type.symbol ? declaration : undefined;
-            var _loop_29 = function (info) {
+            var _loop_30 = function (info) {
                 var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined;
                 // We check only when (a) the property is declared in the containing type, or (b) the applicable index signature is declared
                 // in the containing type, or (c) the containing type is an interface and no base interface contains both the property and
@@ -84682,7 +84749,7 @@ var ts;
             };
             for (var _i = 0, indexInfos_9 = indexInfos; _i < indexInfos_9.length; _i++) {
                 var info = indexInfos_9[_i];
-                _loop_29(info);
+                _loop_30(info);
             }
         }
         function checkIndexConstraintForIndexSignature(type, checkInfo) {
@@ -84690,7 +84757,7 @@ var ts;
             var indexInfos = getApplicableIndexInfos(type, checkInfo.keyType);
             var interfaceDeclaration = ts.getObjectFlags(type) & 2 /* Interface */ ? ts.getDeclarationOfKind(type.symbol, 258 /* InterfaceDeclaration */) : undefined;
             var localCheckDeclaration = declaration && getParentOfSymbol(getSymbolOfNode(declaration)) === type.symbol ? declaration : undefined;
-            var _loop_30 = function (info) {
+            var _loop_31 = function (info) {
                 if (info === checkInfo)
                     return "continue";
                 var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined;
@@ -84705,7 +84772,7 @@ var ts;
             };
             for (var _i = 0, indexInfos_10 = indexInfos; _i < indexInfos_10.length; _i++) {
                 var info = indexInfos_10[_i];
-                _loop_30(info);
+                _loop_31(info);
             }
         }
         function checkTypeNameIsReserved(name, message) {
@@ -85025,7 +85092,7 @@ var ts;
             var baseTypes = baseTypeNode && getBaseTypes(type);
             var baseWithThis = (baseTypes === null || baseTypes === void 0 ? void 0 : baseTypes.length) ? getTypeWithThisArgument(ts.first(baseTypes), type.thisType) : undefined;
             var baseStaticType = getBaseConstructorTypeOfClass(type);
-            var _loop_31 = function (member) {
+            var _loop_32 = function (member) {
                 if (ts.hasAmbientModifier(member)) {
                     return "continue";
                 }
@@ -85042,7 +85109,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_31(member);
+                _loop_32(member);
             }
         }
         /**
@@ -85130,7 +85197,7 @@ var ts;
         function issueMemberSpecificError(node, typeWithThis, baseWithThis, broadDiag) {
             // iterate over all implemented properties and issue errors on each one which isn't compatible, rather than the class as a whole, if possible
             var issuedMemberError = false;
-            var _loop_32 = function (member) {
+            var _loop_33 = function (member) {
                 if (ts.isStatic(member)) {
                     return "continue";
                 }
@@ -85149,7 +85216,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_32(member);
+                _loop_33(member);
             }
             if (!issuedMemberError) {
                 // check again with diagnostics to generate a less-specific error
@@ -85220,7 +85287,7 @@ var ts;
             var _a, _b, _c, _d;
             // NOTE: assignability is checked in checkClassDeclaration
             var baseProperties = getPropertiesOfType(baseType);
-            var _loop_33 = function (baseProperty) {
+            var _loop_34 = function (baseProperty) {
                 var base = getTargetSymbol(baseProperty);
                 if (base.flags & 4194304 /* Prototype */) {
                     return "continue";
@@ -85330,7 +85397,7 @@ var ts;
             };
             basePropertyCheck: for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) {
                 var baseProperty = baseProperties_1[_i];
-                var state_10 = _loop_33(baseProperty);
+                var state_10 = _loop_34(baseProperty);
                 switch (state_10) {
                     case "continue-basePropertyCheck": continue basePropertyCheck;
                 }
@@ -111845,7 +111912,6 @@ var ts;
                         if (newBuildInfo.program && changedDtsText !== undefined && config.options.composite) {
                             // Update the output signature
                             newBuildInfo.program.outSignature = ts.computeSignature(changedDtsText, createHash, changedDtsData);
-                            newBuildInfo.program.dtsChangeTime = ts.getCurrentTime(host).getTime();
                         }
                         // Update sourceFileInfo
                         var _a = buildInfo.bundle, js = _a.js, dts = _a.dts, sourceFiles = _a.sourceFiles;
@@ -121232,7 +121298,7 @@ var ts;
             state.outSignature = oldState === null || oldState === void 0 ? void 0 : oldState.outSignature;
         }
         state.changedFilesSet = new ts.Set();
-        state.dtsChangeTime = compilerOptions.composite ? oldState === null || oldState === void 0 ? void 0 : oldState.dtsChangeTime : undefined;
+        state.latestChangedDtsFile = compilerOptions.composite ? oldState === null || oldState === void 0 ? void 0 : oldState.latestChangedDtsFile : undefined;
         var useOldState = ts.BuilderState.canReuseOldState(state.referencedMap, oldState);
         var oldCompilerOptions = useOldState ? oldState.compilerOptions : undefined;
         var canCopySemanticDiagnostics = useOldState && oldState.semanticDiagnosticsPerFile && !!state.semanticDiagnosticsPerFile &&
@@ -121356,7 +121422,7 @@ var ts;
             programEmitComplete: state.programEmitComplete,
             emitSignatures: state.emitSignatures && new ts.Map(state.emitSignatures),
             outSignature: state.outSignature,
-            dtsChangeTime: state.dtsChangeTime,
+            latestChangedDtsFile: state.latestChangedDtsFile,
             hasChangedEmitSignature: state.hasChangedEmitSignature,
             changedFilesSet: outFilePath ? new ts.Set(state.changedFilesSet) : undefined,
         };
@@ -121369,7 +121435,7 @@ var ts;
         state.programEmitComplete = savedEmitState.programEmitComplete;
         state.emitSignatures = savedEmitState.emitSignatures;
         state.outSignature = savedEmitState.outSignature;
-        state.dtsChangeTime = savedEmitState.dtsChangeTime;
+        state.latestChangedDtsFile = savedEmitState.latestChangedDtsFile;
         state.hasChangedEmitSignature = savedEmitState.hasChangedEmitSignature;
         if (savedEmitState.changedFilesSet)
             state.changedFilesSet = savedEmitState.changedFilesSet;
@@ -121683,14 +121749,14 @@ var ts;
     /**
      * Gets the program information to be emitted in buildInfo so that we can use it to create new program
      */
-    function getProgramBuildInfo(state, getCanonicalFileName, host) {
+    function getProgramBuildInfo(state, getCanonicalFileName) {
         var outFilePath = ts.outFile(state.compilerOptions);
         if (outFilePath && !state.compilerOptions.composite)
             return;
         var currentDirectory = ts.Debug.checkDefined(state.program).getCurrentDirectory();
         var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(ts.getTsBuildInfoEmitOutputFilePath(state.compilerOptions), currentDirectory));
-        // Update the dtsChange time in buildInfo
-        state.dtsChangeTime = state.hasChangedEmitSignature ? ts.getCurrentTime(host).getTime() : state.dtsChangeTime;
+        // Convert the file name to Path here if we set the fileName instead to optimize multiple d.ts file emits and having to compute Canonical path
+        var latestChangedDtsFile = state.latestChangedDtsFile ? relativeToBuildInfoEnsuringAbsolutePath(state.latestChangedDtsFile) : undefined;
         if (outFilePath) {
             var fileNames_1 = [];
             var fileInfos_1 = [];
@@ -121706,7 +121772,7 @@ var ts;
                 fileInfos: fileInfos_1,
                 options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsBundleEmitBuildInfo"),
                 outSignature: state.outSignature,
-                dtsChangeTime: state.dtsChangeTime,
+                latestChangedDtsFile: latestChangedDtsFile,
             };
             return result_15;
         }
@@ -121808,7 +121874,7 @@ var ts;
             affectedFilesPendingEmit: affectedFilesPendingEmit,
             changeFileSet: changeFileSet,
             emitSignatures: emitSignatures,
-            dtsChangeTime: state.dtsChangeTime,
+            latestChangedDtsFile: latestChangedDtsFile,
         };
         return result;
         function relativeToBuildInfoEnsuringAbsolutePath(path) {
@@ -121976,7 +122042,7 @@ var ts;
          */
         var computeHash = ts.maybeBind(host, host.createHash);
         var state = createBuilderProgramState(newProgram, getCanonicalFileName, oldState, host.disableUseFileVersionAsSignature);
-        newProgram.getProgramBuildInfo = function () { return getProgramBuildInfo(state, getCanonicalFileName, host); };
+        newProgram.getProgramBuildInfo = function () { return getProgramBuildInfo(state, getCanonicalFileName); };
         // To ensure that we arent storing any references to old program or new program without state
         newProgram = undefined; // TODO: GH#18217
         oldProgram = undefined;
@@ -121986,6 +122052,7 @@ var ts;
         builderProgram.getState = getState;
         builderProgram.saveEmitState = function () { return backupBuilderProgramEmitState(state); };
         builderProgram.restoreEmitState = function (saved) { return restoreBuilderProgramEmitState(state, saved); };
+        builderProgram.hasChangedEmitSignature = function () { return !!state.hasChangedEmitSignature; };
         builderProgram.getAllDependencies = function (sourceFile) { return ts.BuilderState.getAllDependencies(state, ts.Debug.checkDefined(state.program), sourceFile); };
         builderProgram.getSemanticDiagnostics = getSemanticDiagnostics;
         builderProgram.emit = emit;
@@ -122093,18 +122160,22 @@ var ts;
                             var filePath = sourceFiles[0].resolvedPath;
                             var oldSignature = (_f = state.emitSignatures) === null || _f === void 0 ? void 0 : _f.get(filePath);
                             emitSignature !== null && emitSignature !== void 0 ? emitSignature : (emitSignature = computeSignature(text, computeHash, data));
-                            if (emitSignature !== oldSignature) {
-                                ((_g = state.emitSignatures) !== null && _g !== void 0 ? _g : (state.emitSignatures = new ts.Map())).set(filePath, emitSignature);
-                                state.hasChangedEmitSignature = true;
-                            }
+                            // Dont write dts files if they didn't change
+                            if (emitSignature === oldSignature)
+                                return;
+                            ((_g = state.emitSignatures) !== null && _g !== void 0 ? _g : (state.emitSignatures = new ts.Map())).set(filePath, emitSignature);
+                            state.hasChangedEmitSignature = true;
+                            state.latestChangedDtsFile = fileName;
                         }
                     }
                     else if (state.compilerOptions.composite) {
                         var newSignature = computeSignature(text, computeHash, data);
-                        if (newSignature !== state.outSignature) {
-                            state.outSignature = newSignature;
-                            state.hasChangedEmitSignature = true;
-                        }
+                        // Dont write dts files if they didn't change
+                        if (newSignature === state.outSignature)
+                            return;
+                        state.outSignature = newSignature;
+                        state.hasChangedEmitSignature = true;
+                        state.latestChangedDtsFile = fileName;
                     }
                 }
                 if (writeFile)
@@ -122267,11 +122338,12 @@ var ts;
         var state;
         var filePaths;
         var filePathsSetList;
+        var latestChangedDtsFile = program.latestChangedDtsFile ? toAbsolutePath(program.latestChangedDtsFile) : undefined;
         if (isProgramBundleEmitBuildInfo(program)) {
             state = {
                 fileInfos: new ts.Map(),
                 compilerOptions: program.options ? ts.convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
-                dtsChangeTime: program.dtsChangeTime,
+                latestChangedDtsFile: latestChangedDtsFile,
                 outSignature: program.outSignature,
             };
         }
@@ -122304,7 +122376,7 @@ var ts;
                 affectedFilesPendingEmitKind: program.affectedFilesPendingEmit && ts.arrayToMap(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }, function (value) { return value[1]; }),
                 affectedFilesPendingEmitIndex: program.affectedFilesPendingEmit && 0,
                 changedFilesSet: new ts.Set(ts.map(program.changeFileSet, toFilePath)),
-                dtsChangeTime: program.dtsChangeTime,
+                latestChangedDtsFile: latestChangedDtsFile,
                 emitSignatures: (emitSignatures_1 === null || emitSignatures_1 === void 0 ? void 0 : emitSignatures_1.size) ? emitSignatures_1 : undefined,
             };
         }
@@ -122331,6 +122403,7 @@ var ts;
             getSemanticDiagnosticsOfNextAffectedFile: ts.notImplemented,
             emitBuildInfo: ts.notImplemented,
             close: ts.noop,
+            hasChangedEmitSignature: ts.returnFalse,
         };
         function toPath(path) {
             return ts.toPath(path, buildInfoDirectory, getCanonicalFileName);
@@ -123645,7 +123718,7 @@ var ts;
             });
             // Sort by paths closest to importing file Name directory
             var sortedPaths = [];
-            var _loop_34 = function (directory) {
+            var _loop_35 = function (directory) {
                 var directoryStart = ts.ensureTrailingDirectorySeparator(directory);
                 var pathsInDirectory;
                 allFileNames.forEach(function (_a, fileName) {
@@ -123669,7 +123742,7 @@ var ts;
             };
             var out_directory_1;
             for (var directory = ts.getDirectoryPath(importingFileName); allFileNames.size !== 0;) {
-                var state_11 = _loop_34(directory);
+                var state_11 = _loop_35(directory);
                 directory = out_directory_1;
                 if (state_11 === "break")
                     break;
@@ -124513,7 +124586,6 @@ var ts;
             readDirectory: ts.maybeBind(host, host.readDirectory),
             disableUseFileVersionAsSignature: host.disableUseFileVersionAsSignature,
             storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit,
-            now: ts.maybeBind(host, host.now),
         };
         function writeFile(fileName, text, writeByteOrderMark, onError) {
             try {
@@ -124671,7 +124743,6 @@ var ts;
         host.createHash = ts.maybeBind(system, system.createHash);
         host.disableUseFileVersionAsSignature = system.disableUseFileVersionAsSignature;
         host.storeFilesChangingSignatureDuringEmit = system.storeFilesChangingSignatureDuringEmit;
-        host.now = ts.maybeBind(system, system.now);
         ts.setGetSourceFileAsHashVersioned(host, system);
         ts.changeCompilerHostLikeToUseCache(host, function (fileName) { return ts.toPath(fileName, host.getCurrentDirectory(), host.getCanonicalFileName); });
         return host;
@@ -125999,8 +126070,7 @@ var ts;
             }
             // Actual Emit
             var host = state.host, compilerHost = state.compilerHost;
-            var resultFlags = BuildResultFlags.DeclarationOutputUnchanged;
-            var existingBuildInfo = ((_d = state.buildInfoCache.get(projectPath)) === null || _d === void 0 ? void 0 : _d.buildInfo) || undefined;
+            var resultFlags = ((_d = program.hasChangedEmitSignature) === null || _d === void 0 ? void 0 : _d.call(program)) ? BuildResultFlags.None : BuildResultFlags.DeclarationOutputUnchanged;
             var emitterDiagnostics = ts.createDiagnosticCollection();
             var emittedOutputs = new ts.Map();
             var options = program.getCompilerOptions();
@@ -126008,17 +126078,11 @@ var ts;
             var outputTimeStampMap;
             var now;
             outputFiles.forEach(function (_a) {
-                var _b, _c;
                 var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark, buildInfo = _a.buildInfo;
                 var path = toPath(state, name);
                 emittedOutputs.set(toPath(state, name), name);
-                if (buildInfo) {
-                    setBuildInfo(state, buildInfo, projectPath, options);
-                    // Buildinfo has information on when last dts change time
-                    if (((_b = buildInfo.program) === null || _b === void 0 ? void 0 : _b.dtsChangeTime) !== ((_c = existingBuildInfo === null || existingBuildInfo === void 0 ? void 0 : existingBuildInfo.program) === null || _c === void 0 ? void 0 : _c.dtsChangeTime)) {
-                        resultFlags &= ~BuildResultFlags.DeclarationOutputUnchanged;
-                    }
-                }
+                if (buildInfo)
+                    setBuildInfo(state, buildInfo, projectPath, options, resultFlags);
                 ts.writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
                 if (!isIncremental && state.watch) {
                     (outputTimeStampMap || (outputTimeStampMap = getOutputTimeStampMap(state, projectPath))).set(path, now || (now = getCurrentTime(state.host)));
@@ -126032,7 +126096,7 @@ var ts;
             ts.Debug.assert(step === BuildStep.EmitBuildInfo);
             var emitResult = program.emitBuildInfo(function (name, text, writeByteOrderMark, onError, sourceFiles, data) {
                 if (data === null || data === void 0 ? void 0 : data.buildInfo)
-                    setBuildInfo(state, data.buildInfo, projectPath, program.getCompilerOptions());
+                    setBuildInfo(state, data.buildInfo, projectPath, program.getCompilerOptions(), BuildResultFlags.DeclarationOutputUnchanged);
                 if (writeFileCallback)
                     writeFileCallback(name, text, writeByteOrderMark, onError, sourceFiles, data);
                 else
@@ -126065,7 +126129,6 @@ var ts;
             state.diagnostics.delete(projectPath);
             state.projectStatus.set(projectPath, {
                 type: ts.UpToDateStatusType.UpToDate,
-                newestDeclarationFileContentChangedTime: getDtsChangeTime(state, config.options, projectPath),
                 oldestOutputFileName: oldestOutputFileName
             });
             afterProgramDone(state, program, config);
@@ -126107,10 +126170,10 @@ var ts;
                 var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark, buildInfo = _a.buildInfo;
                 emittedOutputs.set(toPath(state, name), name);
                 if (buildInfo) {
-                    setBuildInfo(state, buildInfo, projectPath, config.options);
-                    if (((_b = buildInfo.program) === null || _b === void 0 ? void 0 : _b.dtsChangeTime) !== ((_c = existingBuildInfo.program) === null || _c === void 0 ? void 0 : _c.dtsChangeTime)) {
+                    if (((_b = buildInfo.program) === null || _b === void 0 ? void 0 : _b.outSignature) !== ((_c = existingBuildInfo.program) === null || _c === void 0 ? void 0 : _c.outSignature)) {
                         resultFlags &= ~BuildResultFlags.DeclarationOutputUnchanged;
                     }
+                    setBuildInfo(state, buildInfo, projectPath, config.options, resultFlags);
                 }
                 ts.writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
             });
@@ -126369,15 +126432,23 @@ var ts;
             state.outputTimeStamps.set(resolvedConfigFilePath, result = new ts.Map());
         return result;
     }
-    function setBuildInfo(state, buildInfo, resolvedConfigPath, options) {
+    function setBuildInfo(state, buildInfo, resolvedConfigPath, options, resultFlags) {
         var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(options);
         var existing = getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath);
+        var modifiedTime = getCurrentTime(state.host);
         if (existing) {
             existing.buildInfo = buildInfo;
-            existing.modifiedTime = getCurrentTime(state.host);
+            existing.modifiedTime = modifiedTime;
+            if (!(resultFlags & BuildResultFlags.DeclarationOutputUnchanged))
+                existing.latestChangedDtsTime = modifiedTime;
         }
         else {
-            state.buildInfoCache.set(resolvedConfigPath, { path: toPath(state, buildInfoPath), buildInfo: buildInfo, modifiedTime: getCurrentTime(state.host) });
+            state.buildInfoCache.set(resolvedConfigPath, {
+                path: toPath(state, buildInfoPath),
+                buildInfo: buildInfo,
+                modifiedTime: modifiedTime,
+                latestChangedDtsTime: resultFlags & BuildResultFlags.DeclarationOutputUnchanged ? undefined : modifiedTime,
+            });
         }
     }
     function getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath) {
@@ -126409,7 +126480,7 @@ var ts;
         }
     }
     function getUpToDateStatusWorker(state, project, resolvedPath) {
-        var _a, _b, _c;
+        var _a, _b;
         // Container if no files are specified in the project
         if (!project.fileNames.length && !ts.canJsonReportNoInputFiles(project.raw)) {
             return {
@@ -126421,8 +126492,8 @@ var ts;
         var force = !!state.options.force;
         if (project.projectReferences) {
             state.projectStatus.set(resolvedPath, { type: ts.UpToDateStatusType.ComputingUpstream });
-            for (var _i = 0, _d = project.projectReferences; _i < _d.length; _i++) {
-                var ref = _d[_i];
+            for (var _i = 0, _c = project.projectReferences; _i < _c.length; _i++) {
+                var ref = _c[_i];
                 var resolvedRef = ts.resolveProjectReferencePath(ref);
                 var resolvedRefPath = toResolvedConfigFilePath(state, resolvedRef);
                 var resolvedConfig = parseConfigFile(state, resolvedRef, resolvedRefPath);
@@ -126462,7 +126533,6 @@ var ts;
         var buildInfoTime;
         var buildInfoProgram;
         var buildInfoVersionMap;
-        var newestDeclarationFileContentChangedTime;
         if (buildInfoPath) {
             var buildInfoCacheEntry_1 = getBuildInfoCacheEntry(state, buildInfoPath, resolvedPath);
             buildInfoTime = (buildInfoCacheEntry_1 === null || buildInfoCacheEntry_1 === void 0 ? void 0 : buildInfoCacheEntry_1.modifiedTime) || ts.getModifiedTime(host, buildInfoPath);
@@ -126499,8 +126569,6 @@ var ts;
             }
             oldestOutputFileTime = buildInfoTime;
             oldestOutputFileName = buildInfoPath;
-            // Get the last dtsChange time from build info
-            newestDeclarationFileContentChangedTime = ((_c = buildInfo.program) === null || _c === void 0 ? void 0 : _c.dtsChangeTime) ? new Date(buildInfo.program.dtsChangeTime) : undefined;
         }
         // Check input files
         var newestInputFileName = undefined;
@@ -126508,8 +126576,8 @@ var ts;
         /** True if input file has changed timestamp but text is not changed, we can then do only timestamp updates on output to make it look up-to-date later */
         var pseudoInputUpToDate = false;
         // Get timestamps of input files
-        for (var _e = 0, _f = project.fileNames; _e < _f.length; _e++) {
-            var inputFile = _f[_e];
+        for (var _d = 0, _e = project.fileNames; _d < _e.length; _d++) {
+            var inputFile = _e[_d];
             var inputTime = getModifiedTime(state, inputFile);
             if (inputTime === ts.missingFileModifiedTime) {
                 return {
@@ -126550,8 +126618,8 @@ var ts;
             // Collect the expected outputs of this project
             var outputs = ts.getAllProjectOutputs(project, !host.useCaseSensitiveFileNames());
             var outputTimeStampMap = getOutputTimeStampMap(state, resolvedPath);
-            for (var _g = 0, outputs_1 = outputs; _g < outputs_1.length; _g++) {
-                var output = outputs_1[_g];
+            for (var _f = 0, outputs_1 = outputs; _f < outputs_1.length; _f++) {
+                var output = outputs_1[_f];
                 var path = toPath(state, output);
                 // Output is missing; can stop checking
                 var outputTime = outputTimeStampMap === null || outputTimeStampMap === void 0 ? void 0 : outputTimeStampMap.get(path);
@@ -126589,8 +126657,8 @@ var ts;
         var usesPrepend = false;
         var upstreamChangedProject;
         if (referenceStatuses) {
-            for (var _h = 0, referenceStatuses_1 = referenceStatuses; _h < referenceStatuses_1.length; _h++) {
-                var _j = referenceStatuses_1[_h], ref = _j.ref, refStatus = _j.refStatus, resolvedConfig = _j.resolvedConfig, resolvedRefPath = _j.resolvedRefPath;
+            for (var _g = 0, referenceStatuses_1 = referenceStatuses; _g < referenceStatuses_1.length; _g++) {
+                var _h = referenceStatuses_1[_g], ref = _h.ref, refStatus = _h.refStatus, resolvedConfig = _h.resolvedConfig, resolvedRefPath = _h.resolvedRefPath;
                 usesPrepend = usesPrepend || !!(ref.prepend);
                 // If the upstream project's newest file is older than our oldest output, we
                 // can't be out of date because of it
@@ -126607,7 +126675,8 @@ var ts;
                 }
                 // If the upstream project has only change .d.ts files, and we've built
                 // *after* those files, then we're "psuedo up to date" and eligible for a fast rebuild
-                if (refStatus.newestDeclarationFileContentChangedTime && refStatus.newestDeclarationFileContentChangedTime <= oldestOutputFileTime) {
+                var newestDeclarationFileContentChangedTime = getLatestChangedDtsTime(state, resolvedConfig.options, resolvedRefPath);
+                if (newestDeclarationFileContentChangedTime && newestDeclarationFileContentChangedTime <= oldestOutputFileTime) {
                     pseudoUpToDate = true;
                     upstreamChangedProject = ref.path;
                     continue;
@@ -126650,7 +126719,6 @@ var ts;
                 pseudoInputUpToDate ?
                     ts.UpToDateStatusType.UpToDateWithInputFileText :
                     ts.UpToDateStatusType.UpToDate,
-            newestDeclarationFileContentChangedTime: newestDeclarationFileContentChangedTime,
             newestInputFileTime: newestInputFileTime,
             newestInputFileName: newestInputFileName,
             oldestOutputFileName: oldestOutputFileName
@@ -126734,13 +126802,17 @@ var ts;
                 outputTimeStampMap.delete(key);
         });
     }
-    function getDtsChangeTime(state, options, resolvedConfigPath) {
-        var _a;
+    function getLatestChangedDtsTime(state, options, resolvedConfigPath) {
         if (!options.composite)
             return undefined;
-        var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(options);
-        var buildInfo = getBuildInfo(state, buildInfoPath, resolvedConfigPath, /*modifiedTime*/ undefined);
-        return ((_a = buildInfo === null || buildInfo === void 0 ? void 0 : buildInfo.program) === null || _a === void 0 ? void 0 : _a.dtsChangeTime) ? new Date(buildInfo.program.dtsChangeTime) : undefined;
+        var entry = ts.Debug.checkDefined(state.buildInfoCache.get(resolvedConfigPath));
+        if (entry.latestChangedDtsTime !== undefined)
+            return entry.latestChangedDtsTime || undefined;
+        var latestChangedDtsTime = entry.buildInfo && entry.buildInfo.program && entry.buildInfo.program.latestChangedDtsFile ?
+            state.host.getModifiedTime(ts.getNormalizedAbsolutePath(entry.buildInfo.program.latestChangedDtsFile, ts.getDirectoryPath(entry.path))) :
+            undefined;
+        entry.latestChangedDtsTime = latestChangedDtsTime || false;
+        return latestChangedDtsTime;
     }
     function updateOutputTimestamps(state, proj, resolvedPath) {
         if (state.options.dry) {
@@ -126749,7 +126821,6 @@ var ts;
         updateOutputTimestampsWorker(state, proj, resolvedPath, ts.Diagnostics.Updating_output_timestamps_of_project_0);
         state.projectStatus.set(resolvedPath, {
             type: ts.UpToDateStatusType.UpToDate,
-            newestDeclarationFileContentChangedTime: getDtsChangeTime(state, proj.options, resolvedPath),
             oldestOutputFileName: ts.getFirstProjectOutput(proj, !state.host.useCaseSensitiveFileNames())
         });
     }