typescript 4.7.0-dev.20220309 → 4.7.0-dev.20220310

package/lib/tsserver.js

@@ -100,7 +100,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.20220309";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220310";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -4164,6 +4164,7 @@ var ts;
         SyntaxKind[SyntaxKind["JSDocFunctionType"] = 316] = "JSDocFunctionType";
         SyntaxKind[SyntaxKind["JSDocVariadicType"] = 317] = "JSDocVariadicType";
         SyntaxKind[SyntaxKind["JSDocNamepathType"] = 318] = "JSDocNamepathType";
+        /** @deprecated Use SyntaxKind.JSDoc */
         SyntaxKind[SyntaxKind["JSDocComment"] = 319] = "JSDocComment";
         SyntaxKind[SyntaxKind["JSDocText"] = 320] = "JSDocText";
         SyntaxKind[SyntaxKind["JSDocTypeLiteral"] = 321] = "JSDocTypeLiteral";
@@ -4237,6 +4238,7 @@ var ts;
         SyntaxKind[SyntaxKind["LastJSDocTagNode"] = 346] = "LastJSDocTagNode";
         /* @internal */ SyntaxKind[SyntaxKind["FirstContextualKeyword"] = 126] = "FirstContextualKeyword";
         /* @internal */ SyntaxKind[SyntaxKind["LastContextualKeyword"] = 159] = "LastContextualKeyword";
+        SyntaxKind[SyntaxKind["JSDoc"] = 319] = "JSDoc";
     })(SyntaxKind = ts.SyntaxKind || (ts.SyntaxKind = {}));
     var NodeFlags;
     (function (NodeFlags) {
@@ -12833,7 +12835,7 @@ var ts;
             return ts.emptyArray;
         }
         if (ts.isJSDocTypeAlias(node)) {
-            ts.Debug.assert(node.parent.kind === 319 /* JSDocComment */);
+            ts.Debug.assert(node.parent.kind === 319 /* JSDoc */);
             return ts.flatMap(node.parent.tags, function (tag) { return ts.isJSDocTemplateTag(tag) ? tag.typeParameters : undefined; });
         }
         if (node.typeParameters) {
@@ -13780,7 +13782,7 @@ var ts;
     ts.isJSDocNode = isJSDocNode;
     /** True if node is of a kind that may contain comment text. */
     function isJSDocCommentContainingNode(node) {
-        return node.kind === 319 /* JSDocComment */
+        return node.kind === 319 /* JSDoc */
             || node.kind === 318 /* JSDocNamepathType */
             || node.kind === 320 /* JSDocText */
             || isJSDocLinkLike(node)
@@ -15345,10 +15347,23 @@ var ts;
             && node.parent.parent.kind === 236 /* VariableStatement */;
     }
     ts.isVariableDeclarationInVariableStatement = isVariableDeclarationInVariableStatement;
+    function isCommonJsExportedExpression(node) {
+        if (!isInJSFile(node))
+            return false;
+        return (ts.isObjectLiteralExpression(node.parent) && ts.isBinaryExpression(node.parent.parent) && getAssignmentDeclarationKind(node.parent.parent) === 2 /* ModuleExports */) ||
+            isCommonJsExportPropertyAssignment(node.parent);
+    }
+    ts.isCommonJsExportedExpression = isCommonJsExportedExpression;
+    function isCommonJsExportPropertyAssignment(node) {
+        if (!isInJSFile(node))
+            return false;
+        return (ts.isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 1 /* ExportsProperty */);
+    }
+    ts.isCommonJsExportPropertyAssignment = isCommonJsExportPropertyAssignment;
     function isValidESSymbolDeclaration(node) {
-        return ts.isVariableDeclaration(node) ? isVarConst(node) && ts.isIdentifier(node.name) && isVariableDeclarationInVariableStatement(node) :
+        return (ts.isVariableDeclaration(node) ? isVarConst(node) && ts.isIdentifier(node.name) && isVariableDeclarationInVariableStatement(node) :
             ts.isPropertyDeclaration(node) ? hasEffectiveReadonlyModifier(node) && hasStaticModifier(node) :
-                ts.isPropertySignature(node) && hasEffectiveReadonlyModifier(node);
+                ts.isPropertySignature(node) && hasEffectiveReadonlyModifier(node)) || isCommonJsExportPropertyAssignment(node);
     }
     ts.isValidESSymbolDeclaration = isValidESSymbolDeclaration;
     function introducesArgumentsExoticObject(node) {
@@ -18242,7 +18257,7 @@ var ts;
     ts.getJSDocTypeParameterDeclarations = getJSDocTypeParameterDeclarations;
     /** template tags are only available when a typedef isn't already using them */
     function isNonTypeAliasTemplate(tag) {
-        return ts.isJSDocTemplateTag(tag) && !(tag.parent.kind === 319 /* JSDocComment */ && tag.parent.tags.some(isJSDocTypeAlias));
+        return ts.isJSDocTemplateTag(tag) && !(tag.parent.kind === 319 /* JSDoc */ && tag.parent.tags.some(isJSDocTypeAlias));
     }
     /**
      * Gets the effective type annotation of the value parameter of a set accessor. If the node
@@ -25219,7 +25234,7 @@ var ts;
         }
         // @api
         function createJSDocComment(comment, tags) {
-            var node = createBaseNode(319 /* JSDocComment */);
+            var node = createBaseNode(319 /* JSDoc */);
             node.comment = comment;
             node.tags = asNodeArray(tags);
             return node;
@@ -28728,7 +28743,7 @@ var ts;
     }
     ts.isJSDocNamepathType = isJSDocNamepathType;
     function isJSDoc(node) {
-        return node.kind === 319 /* JSDocComment */;
+        return node.kind === 319 /* JSDoc */;
     }
     ts.isJSDoc = isJSDoc;
     function isJSDocTypeLiteral(node) {
@@ -30353,7 +30368,7 @@ var ts;
             case 316 /* JSDocFunctionType */:
                 return visitNodes(cbNode, cbNodes, node.parameters) ||
                     visitNode(cbNode, node.type);
-            case 319 /* JSDocComment */:
+            case 319 /* JSDoc */:
                 return (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment))
                     || visitNodes(cbNode, cbNodes, node.tags);
             case 345 /* JSDocSeeTag */:
@@ -47667,6 +47682,8 @@ var ts;
         var templateConstraintType = getUnionType([stringType, numberType, booleanType, bigintType, nullType, undefinedType]);
         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 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 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 */;
@@ -48605,7 +48622,7 @@ var ts;
                             // - parameters are only in the scope of function body
                             // This restriction does not apply to JSDoc comment types because they are parented
                             // at a higher level than type parameters would normally be
-                            if (meaning & result.flags & 788968 /* Type */ && lastLocation.kind !== 319 /* JSDocComment */) {
+                            if (meaning & result.flags & 788968 /* Type */ && lastLocation.kind !== 319 /* JSDoc */) {
                                 useResult = result.flags & 262144 /* TypeParameter */
                                     // type parameters are visible in parameter list, return type and type parameter list
                                     ? lastLocation === location.type ||
@@ -51571,10 +51588,16 @@ var ts;
                     var readonlyToken = type.declaration.readonlyToken ? ts.factory.createToken(type.declaration.readonlyToken.kind) : undefined;
                     var questionToken = type.declaration.questionToken ? ts.factory.createToken(type.declaration.questionToken.kind) : undefined;
                     var appropriateConstraintTypeNode;
+                    var newTypeVariable;
                     if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
                         // We have a { [P in keyof T]: X }
                         // We do this to ensure we retain the toplevel keyof-ness of the type which may be lost due to keyof distribution during `getConstraintTypeFromMappedType`
-                        appropriateConstraintTypeNode = ts.factory.createTypeOperatorNode(140 /* KeyOfKeyword */, typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context));
+                        if (!(getModifiersTypeFromMappedType(type).flags & 262144 /* TypeParameter */) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
+                            var newParam = createTypeParameter(createSymbol(262144 /* TypeParameter */, "T"));
+                            var name = typeParameterToName(newParam, context);
+                            newTypeVariable = ts.factory.createTypeReferenceNode(name);
+                        }
+                        appropriateConstraintTypeNode = ts.factory.createTypeOperatorNode(140 /* KeyOfKeyword */, newTypeVariable || typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context));
                     }
                     else {
                         appropriateConstraintTypeNode = typeToTypeNodeHelper(getConstraintTypeFromMappedType(type), context);
@@ -51584,7 +51607,14 @@ var ts;
                     var templateTypeNode = typeToTypeNodeHelper(removeMissingType(getTemplateTypeFromMappedType(type), !!(getMappedTypeModifiers(type) & 4 /* IncludeOptional */)), context);
                     var mappedTypeNode = ts.factory.createMappedTypeNode(readonlyToken, typeParameterNode, nameTypeNode, questionToken, templateTypeNode, /*members*/ undefined);
                     context.approximateLength += 10;
-                    return ts.setEmitFlags(mappedTypeNode, 1 /* SingleLine */);
+                    var result = ts.setEmitFlags(mappedTypeNode, 1 /* SingleLine */);
+                    if (isMappedTypeWithKeyofConstraintDeclaration(type) && !(getModifiersTypeFromMappedType(type).flags & 262144 /* TypeParameter */) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
+                        // homomorphic mapped type with a non-homomorphic naive inlining
+                        // wrap it with a conditional like `SomeModifiersType extends infer U ? {..the mapped type...} : never` to ensure the resulting
+                        // type stays homomorphic
+                        return ts.factory.createConditionalTypeNode(typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context), ts.factory.createInferTypeNode(ts.factory.createTypeParameterDeclaration(ts.factory.cloneNode(newTypeVariable.typeName))), result, ts.factory.createKeywordTypeNode(143 /* NeverKeyword */));
+                    }
+                    return result;
                 }
                 function createAnonymousTypeNode(type) {
                     var _a;
@@ -53205,7 +53235,7 @@ var ts;
                 // If it's a class/interface/function: emit a class/interface/function with a `default` modifier
                 // These forms can merge, eg (`export default 12; export default interface A {}`)
                 function serializeSymbolWorker(symbol, isPrivate, propertyAsAlias) {
-                    var _a, _b;
+                    var _a, _b, _c, _d;
                     var symbolName = ts.unescapeLeadingUnderscores(symbol.escapedName);
                     var isDefault = symbol.escapedName === "default" /* Default */;
                     if (isPrivate && !(context.flags & 131072 /* AllowAnonymousIdentifier */) && ts.isStringANonContextualKeyword(symbolName) && !isDefault) {
@@ -53256,17 +53286,21 @@ var ts;
                             else {
                                 // A Class + Property merge is made for a `module.exports.Member = class {}`, and it doesn't serialize well as either a class _or_ a property symbol - in fact, _it behaves like an alias!_
                                 // `var` is `FunctionScopedVariable`, `const` and `let` are `BlockScopedVariable`, and `module.exports.thing =` is `Property`
-                                var flags = !(symbol.flags & 2 /* BlockScopedVariable */) ? undefined
-                                    : isConstVariable(symbol) ? 2 /* Const */
+                                var flags = !(symbol.flags & 2 /* BlockScopedVariable */)
+                                    ? ((_a = symbol.parent) === null || _a === void 0 ? void 0 : _a.valueDeclaration) && ts.isSourceFile((_b = symbol.parent) === null || _b === void 0 ? void 0 : _b.valueDeclaration)
+                                        ? 2 /* Const */
+                                        : undefined
+                                    : isConstVariable(symbol)
+                                        ? 2 /* Const */
                                         : 1 /* Let */;
                                 var name = (needsPostExportDefault || !(symbol.flags & 4 /* Property */)) ? localName : getUnusedName(localName, symbol);
                                 var textRange = symbol.declarations && ts.find(symbol.declarations, function (d) { return ts.isVariableDeclaration(d); });
                                 if (textRange && ts.isVariableDeclarationList(textRange.parent) && textRange.parent.declarations.length === 1) {
                                     textRange = textRange.parent.parent;
                                 }
-                                var propertyAccessRequire = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isPropertyAccessExpression);
+                                var propertyAccessRequire = (_c = symbol.declarations) === null || _c === void 0 ? void 0 : _c.find(ts.isPropertyAccessExpression);
                                 if (propertyAccessRequire && ts.isBinaryExpression(propertyAccessRequire.parent) && ts.isIdentifier(propertyAccessRequire.parent.right)
-                                    && ((_b = type.symbol) === null || _b === void 0 ? void 0 : _b.valueDeclaration) && ts.isSourceFile(type.symbol.valueDeclaration)) {
+                                    && ((_d = type.symbol) === null || _d === void 0 ? void 0 : _d.valueDeclaration) && ts.isSourceFile(type.symbol.valueDeclaration)) {
                                     var alias = localName === propertyAccessRequire.parent.right.escapedText ? undefined : propertyAccessRequire.parent.right;
                                     addResult(ts.factory.createExportDeclaration(
                                     /*decorators*/ undefined, 
@@ -53346,8 +53380,8 @@ var ts;
                         // synthesize export * from "moduleReference"
                         // Straightforward - only one thing to do - make an export declaration
                         if (symbol.declarations) {
-                            for (var _i = 0, _c = symbol.declarations; _i < _c.length; _i++) {
-                                var node = _c[_i];
+                            for (var _i = 0, _e = symbol.declarations; _i < _e.length; _i++) {
+                                var node = _e[_i];
                                 var resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier);
                                 if (!resolvedModule)
                                     continue;
@@ -55153,7 +55187,10 @@ var ts;
             if (containsSameNamedThisProperty(expression.left, expression.right)) {
                 return anyType;
             }
-            var type = resolvedSymbol ? getTypeOfSymbol(resolvedSymbol) : getWidenedLiteralType(checkExpressionCached(expression.right));
+            var isDirectExport = kind === 1 /* ExportsProperty */ && (ts.isPropertyAccessExpression(expression.left) || ts.isElementAccessExpression(expression.left)) && (ts.isModuleExportsAccessExpression(expression.left.expression) || (ts.isIdentifier(expression.left.expression) && ts.isExportsIdentifier(expression.left.expression)));
+            var type = resolvedSymbol ? getTypeOfSymbol(resolvedSymbol)
+                : isDirectExport ? getRegularTypeOfLiteralType(checkExpressionCached(expression.right))
+                    : getWidenedLiteralType(checkExpressionCached(expression.right));
             if (type.flags & 524288 /* Object */ &&
                 kind === 2 /* ModuleExports */ &&
                 symbol.escapedName === "export=" /* ExportEquals */) {
@@ -55897,7 +55934,7 @@ var ts;
                             node = paramSymbol.valueDeclaration;
                         }
                         break;
-                    case 319 /* JSDocComment */: {
+                    case 319 /* JSDoc */: {
                         var outerTypeParameters = getOuterTypeParameters(node, includeThisTypes);
                         return node.tags
                             ? appendTypeParameters(outerTypeParameters, ts.flatMap(node.tags, function (t) { return ts.isJSDocTemplateTag(t) ? t.typeParameters : undefined; }))
@@ -58158,10 +58195,10 @@ var ts;
                 else if (type !== firstType) {
                     checkFlags |= 64 /* HasNonUniformType */;
                 }
-                if (isLiteralType(type) || isPatternLiteralType(type)) {
+                if (isLiteralType(type) || isPatternLiteralType(type) || type === uniqueLiteralType) {
                     checkFlags |= 128 /* HasLiteralType */;
                 }
-                if (type.flags & 131072 /* Never */) {
+                if (type.flags & 131072 /* Never */ && type !== uniqueLiteralType) {
                     checkFlags |= 131072 /* HasNeverType */;
                 }
                 propTypes.push(type);
@@ -59346,7 +59383,7 @@ var ts;
         function getConditionalFlowTypeOfType(type, node) {
             var constraints;
             var covariant = true;
-            while (node && !ts.isStatement(node) && node.kind !== 319 /* JSDocComment */) {
+            while (node && !ts.isStatement(node) && node.kind !== 319 /* JSDoc */) {
                 var parent = node.parent;
                 // only consider variance flipped by parameter locations - `keyof` types would usually be considered variance inverting, but
                 // often get used in indexed accesses where they behave sortof invariantly, but our checking is lax
@@ -60702,10 +60739,24 @@ var ts;
             return getUnionType(ts.concatenate(propertyTypes, indexKeyTypes), 1 /* Literal */, 
             /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, origin);
         }
+        /**
+         * A union type which is reducible upon instantiation (meaning some members are removed under certain instantiations)
+         * must be kept generic, as that instantiation information needs to flow through the type system. By replacing all
+         * type parameters in the union with a special never type that is treated as a literal in `getReducedType`, we can cause the `getReducedType` logic
+         * to reduce the resulting type if possible (since only intersections with conflicting literal-typed properties are reducible).
+         */
+        function isPossiblyReducibleByInstantiation(type) {
+            return ts.some(type.types, function (t) {
+                var uniqueFilled = getUniqueLiteralFilledInstantiation(t);
+                return getReducedType(uniqueFilled) !== uniqueFilled;
+            });
+        }
         function getIndexType(type, stringsOnly, noIndexSignatures) {
             if (stringsOnly === void 0) { stringsOnly = keyofStringsOnly; }
             type = getReducedType(type);
-            return type.flags & 1048576 /* Union */ ? getIntersectionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
+            return type.flags & 1048576 /* Union */ ? isPossiblyReducibleByInstantiation(type)
+                ? getIndexTypeForGenericType(type, stringsOnly)
+                : getIntersectionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
                 type.flags & 2097152 /* Intersection */ ? getUnionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
                     type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && !hasDistributiveNameType(type) ? getIndexTypeForGenericType(type, stringsOnly) :
                         ts.getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) :
@@ -61333,6 +61384,10 @@ var ts;
             }
             return type;
         }
+        function maybeCloneTypeParameter(p) {
+            var constraint = getConstraintOfTypeParameter(p);
+            return constraint && (isGenericObjectType(constraint) || isGenericIndexType(constraint)) ? cloneTypeParameter(p) : p;
+        }
         function isTypicalNondistributiveConditional(root) {
             return !root.isDistributive && isSingletonTupleType(root.node.checkType) && isSingletonTupleType(root.node.extendsType);
         }
@@ -61351,37 +61406,65 @@ var ts;
             var result;
             var extraTypes;
             var tailCount = 0;
-            // We loop here for an immediately nested conditional type in the false position, effectively treating
-            // types of the form 'A extends B ? X : C extends D ? Y : E extends F ? Z : ...' as a single construct for
-            // purposes of resolution. We also loop here when resolution of a conditional type ends in resolution of
-            // 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 _loop_18 = function () {
                 if (tailCount === 1000) {
                     error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
                     result = errorType;
-                    break;
+                    return "break";
                 }
                 var isUnwrapped = isTypicalNondistributiveConditional(root);
                 var checkType = instantiateType(unwrapNondistributiveConditionalTuple(root, getActualTypeVariable(root.checkType)), mapper);
                 var checkTypeInstantiable = isGenericType(checkType);
                 var extendsType = instantiateType(unwrapNondistributiveConditionalTuple(root, root.extendsType), mapper);
                 if (checkType === wildcardType || extendsType === wildcardType) {
-                    return wildcardType;
+                    return { value: wildcardType };
                 }
                 var combinedMapper = void 0;
                 if (root.inferTypeParameters) {
-                    var context = createInferenceContext(root.inferTypeParameters, /*signature*/ undefined, 0 /* None */);
-                    if (!checkTypeInstantiable) {
+                    // When we're looking at making an inference for an infer type, when we get its constraint, it'll automagically be
+                    // instantiated with the context, so it doesn't need the mapper for the inference contex - however the constraint
+                    // may refer to another _root_, _uncloned_ `infer` type parameter [1], or to something mapped by `mapper` [2].
+                    // [1] Eg, if we have `Foo<T, U extends T>` and `Foo<number, infer B>` - `B` is constrained to `T`, which, in turn, has been instantiated
+                    // as `number`
+                    // Conversely, if we have `Foo<infer A, infer B>`, `B` is still constrained to `T` and `T` is instantiated as `A`
+                    // [2] Eg, if we have `Foo<T, U extends T>` and `Foo<Q, infer B>` where `Q` is mapped by `mapper` into `number` - `B` is constrained to `T`
+                    // which is in turn instantiated as `Q`, which is in turn instantiated as `number`.
+                    // So we need to:
+                    //    * Clone the type parameters so their constraints can be instantiated in the context of `mapper` (otherwise theyd only get inference context information)
+                    //    * Set the clones to both map the conditional's enclosing `mapper` and the original params
+                    //    * instantiate the extends type with the clones
+                    //    * incorporate all of the component mappers into the combined mapper for the true and false members
+                    // This means we have three mappers that need applying:
+                    //    * The original `mapper` used to create this conditional
+                    //    * The mapper that maps the old root type parameter to the clone (`freshMapper`)
+                    //    * The mapper that maps the clone to its inference result (`context.mapper`)
+                    var freshParams = ts.sameMap(root.inferTypeParameters, maybeCloneTypeParameter);
+                    var freshMapper = freshParams !== root.inferTypeParameters ? createTypeMapper(root.inferTypeParameters, freshParams) : undefined;
+                    var context = createInferenceContext(freshParams, /*signature*/ undefined, 0 /* None */);
+                    if (freshMapper) {
+                        var freshCombinedMapper = combineTypeMappers(mapper, freshMapper);
+                        for (var _i = 0, freshParams_1 = freshParams; _i < freshParams_1.length; _i++) {
+                            var p = freshParams_1[_i];
+                            if (root.inferTypeParameters.indexOf(p) === -1) {
+                                p.mapper = freshCombinedMapper;
+                            }
+                        }
+                    }
+                    // We skip inference of the possible `infer` types unles the `extendsType` _is_ an infer type
+                    // if it was, it's trivial to say that extendsType = checkType, however such a pattern is used to
+                    // "reset" the type being build up during constraint calculation and avoid making an apparently "infinite" constraint
+                    // so in those cases we refain from performing inference and retain the uninfered type parameter
+                    if (!checkTypeInstantiable || !ts.some(root.inferTypeParameters, function (t) { return t === extendsType; })) {
                         // We don't want inferences from constraints as they may cause us to eagerly resolve the
                         // conditional type instead of deferring resolution. Also, we always want strict function
                         // types rules (i.e. proper contravariance) for inferences.
-                        inferTypes(context.inferences, checkType, extendsType, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
+                        inferTypes(context.inferences, checkType, instantiateType(extendsType, freshMapper), 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
                     }
+                    var innerMapper = combineTypeMappers(freshMapper, context.mapper);
                     // It's possible for 'infer T' type paramteters to be given uninstantiated constraints when the
                     // those type parameters are used in type references (see getInferredTypeParameterConstraint). For
                     // that reason we need context.mapper to be first in the combined mapper. See #42636 for examples.
-                    combinedMapper = mapper ? combineTypeMappers(context.mapper, mapper) : context.mapper;
+                    combinedMapper = mapper ? combineTypeMappers(innerMapper, mapper) : innerMapper;
                 }
                 // Instantiate the extends type including inferences for 'infer T' type parameters
                 var inferredExtendsType = combinedMapper ? instantiateType(unwrapNondistributiveConditionalTuple(root, root.extendsType), combinedMapper) : extendsType;
@@ -61403,14 +61486,14 @@ var ts;
                             var newRoot = falseType_1.root;
                             if (newRoot.node.parent === root.node && (!newRoot.isDistributive || newRoot.checkType === root.checkType)) {
                                 root = newRoot;
-                                continue;
+                                return "continue";
                             }
                             if (canTailRecurse(falseType_1, mapper)) {
-                                continue;
+                                return "continue";
                             }
                         }
                         result = instantiateType(falseType_1, mapper);
-                        break;
+                        return "break";
                     }
                     // Return trueType for a definitely true extends check. We check instantiations of the two
                     // types with type parameters mapped to their restrictive form, i.e. a form of the type parameter
@@ -61421,10 +61504,10 @@ var ts;
                         var trueType_1 = getTypeFromTypeNode(root.node.trueType);
                         var trueMapper = combinedMapper || mapper;
                         if (canTailRecurse(trueType_1, trueMapper)) {
-                            continue;
+                            return "continue";
                         }
                         result = instantiateType(trueType_1, trueMapper);
-                        break;
+                        return "break";
                     }
                 }
                 // Return a deferred type for a check that is neither definitely true nor definitely false
@@ -61436,7 +61519,19 @@ var ts;
                 result.combinedMapper = combinedMapper;
                 result.aliasSymbol = aliasSymbol || root.aliasSymbol;
                 result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(root.aliasTypeArguments, mapper); // TODO: GH#18217
-                break;
+                return "break";
+            };
+            // We loop here for an immediately nested conditional type in the false position, effectively treating
+            // types of the form 'A extends B ? X : C extends D ? Y : E extends F ? Z : ...' as a single construct for
+            // purposes of resolution. We also loop here when resolution of a conditional type ends in resolution of
+            // 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();
+                if (typeof state_5 === "object")
+                    return state_5.value;
+                if (state_5 === "break")
+                    break;
             }
             return extraTypes ? getUnionType(ts.append(extraTypes, result)) : result;
             // We tail-recurse for generic conditional types that (a) have not already been evaluated and cached, and
@@ -61858,9 +61953,11 @@ var ts;
         }
         function getESSymbolLikeTypeForNode(node) {
             if (ts.isValidESSymbolDeclaration(node)) {
-                var symbol = getSymbolOfNode(node);
-                var links = getSymbolLinks(symbol);
-                return links.uniqueESSymbolType || (links.uniqueESSymbolType = createUniqueESSymbolType(symbol));
+                var symbol = ts.isCommonJsExportPropertyAssignment(node) ? getSymbolOfNode(node.left) : getSymbolOfNode(node);
+                if (symbol) {
+                    var links = getSymbolLinks(symbol);
+                    return links.uniqueESSymbolType || (links.uniqueESSymbolType = createUniqueESSymbolType(symbol));
+                }
             }
             return esSymbolType;
         }
@@ -62504,6 +62601,10 @@ var ts;
             }
             return type; // Nested invocation of `inferTypeForHomomorphicMappedType` or the `source` instantiated into something unmappable
         }
+        function getUniqueLiteralFilledInstantiation(type) {
+            return type.flags & (131068 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type :
+                type.uniqueLiteralFilledInstantiation || (type.uniqueLiteralFilledInstantiation = instantiateType(type, uniqueLiteralMapper));
+        }
         function getPermissiveInstantiation(type) {
             return type.flags & (131068 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type :
                 type.permissiveInstantiation || (type.permissiveInstantiation = instantiateType(type, permissiveMapper));
@@ -63963,7 +64064,7 @@ var ts;
                     reducedTarget = findMatchingDiscriminantType(source, target, isRelatedTo) || filterPrimitivesIfContainsNonPrimitive(target);
                     checkTypes = reducedTarget.flags & 1048576 /* Union */ ? reducedTarget.types : [reducedTarget];
                 }
-                var _loop_18 = function (prop) {
+                var _loop_19 = function (prop) {
                     if (shouldCheckAsExcessProperty(prop, source.symbol) && !isIgnoredJsxProperty(source, prop)) {
                         if (!isKnownProperty(reducedTarget, prop.escapedName, isComparingJsxAttributes)) {
                             if (reportErrors) {
@@ -64026,9 +64127,9 @@ var ts;
                 };
                 for (var _i = 0, _b = getPropertiesOfType(source); _i < _b.length; _i++) {
                     var prop = _b[_i];
-                    var state_5 = _loop_18(prop);
-                    if (typeof state_5 === "object")
-                        return state_5.value;
+                    var state_6 = _loop_19(prop);
+                    if (typeof state_6 === "object")
+                        return state_6.value;
                 }
                 return false;
             }
@@ -65018,11 +65119,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_19 = function (combination) {
+                var _loop_20 = function (combination) {
                     var hasMatch = false;
                     outer: for (var _c = 0, _d = target.types; _c < _d.length; _c++) {
                         var type = _d[_c];
-                        var _loop_20 = function (i) {
+                        var _loop_21 = function (i) {
                             var sourceProperty = sourcePropertiesFiltered[i];
                             var targetProperty = getPropertyOfType(type, sourceProperty.escapedName);
                             if (!targetProperty)
@@ -65038,8 +65139,8 @@ var ts;
                             }
                         };
                         for (var i = 0; i < sourcePropertiesFiltered.length; i++) {
-                            var state_7 = _loop_20(i);
-                            switch (state_7) {
+                            var state_8 = _loop_21(i);
+                            switch (state_8) {
                                 case "continue-outer": continue outer;
                             }
                         }
@@ -65052,9 +65153,9 @@ var ts;
                 };
                 for (var _a = 0, discriminantCombinations_1 = discriminantCombinations; _a < discriminantCombinations_1.length; _a++) {
                     var combination = discriminantCombinations_1[_a];
-                    var state_6 = _loop_19(combination);
-                    if (typeof state_6 === "object")
-                        return state_6.value;
+                    var state_7 = _loop_20(combination);
+                    if (typeof state_7 === "object")
+                        return state_7.value;
                 }
                 // Compare the remaining non-discriminant properties of each match.
                 var result = -1 /* True */;
@@ -65767,7 +65868,7 @@ var ts;
                 // The emptyArray singleton is used to signal a recursive invocation.
                 cache.variances = ts.emptyArray;
                 variances = [];
-                var _loop_21 = function (tp) {
+                var _loop_22 = function (tp) {
                     var unmeasurable = false;
                     var unreliable = false;
                     var oldHandler = outofbandVarianceMarkerHandler;
@@ -65799,7 +65900,7 @@ var ts;
                 };
                 for (var _i = 0, typeParameters_1 = typeParameters; _i < typeParameters_1.length; _i++) {
                     var tp = typeParameters_1[_i];
-                    _loop_21(tp);
+                    _loop_22(tp);
                 }
                 cache.variances = variances;
                 ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
@@ -68170,7 +68271,7 @@ var ts;
         function mapTypesByKeyProperty(types, name) {
             var map = new ts.Map();
             var count = 0;
-            var _loop_22 = function (type) {
+            var _loop_23 = function (type) {
                 if (type.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 58982400 /* InstantiableNonPrimitive */)) {
                     var discriminant = getTypeOfPropertyOfType(type, name);
                     if (discriminant) {
@@ -68196,9 +68297,9 @@ var ts;
             };
             for (var _i = 0, types_16 = types; _i < types_16.length; _i++) {
                 var type = types_16[_i];
-                var state_8 = _loop_22(type);
-                if (typeof state_8 === "object")
-                    return state_8.value;
+                var state_9 = _loop_23(type);
+                if (typeof state_9 === "object")
+                    return state_9.value;
             }
             return count >= 10 && count * 2 >= types.length ? map : undefined;
         }
@@ -74529,7 +74630,7 @@ var ts;
             if (spreadIndex >= 0) {
                 // Create synthetic arguments from spreads of tuple types.
                 var effectiveArgs_1 = args.slice(0, spreadIndex);
-                var _loop_23 = function (i) {
+                var _loop_24 = function (i) {
                     var arg = args[i];
                     // We can call checkExpressionCached because spread expressions never have a contextual type.
                     var spreadType = arg.kind === 224 /* SpreadElement */ && (flowLoopCount ? checkExpression(arg.expression) : checkExpressionCached(arg.expression));
@@ -74546,7 +74647,7 @@ var ts;
                     }
                 };
                 for (var i = spreadIndex; i < args.length; i++) {
-                    _loop_23(i);
+                    _loop_24(i);
                 }
                 return effectiveArgs_1;
             }
@@ -74859,7 +74960,7 @@ var ts;
                         var min_3 = Number.MAX_VALUE;
                         var minIndex = 0;
                         var i_1 = 0;
-                        var _loop_24 = function (c) {
+                        var _loop_25 = 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) {
@@ -74877,7 +74978,7 @@ var ts;
                         };
                         for (var _a = 0, candidatesForArgumentError_1 = candidatesForArgumentError; _a < candidatesForArgumentError_1.length; _a++) {
                             var c = candidatesForArgumentError_1[_a];
-                            _loop_24(c);
+                            _loop_25(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");
@@ -75035,7 +75136,7 @@ var ts;
             }
             var _a = ts.minAndMax(candidates, getNumNonRestParameters), minArgumentCount = _a.min, maxNonRestParam = _a.max;
             var parameters = [];
-            var _loop_25 = function (i) {
+            var _loop_26 = 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; });
@@ -75043,7 +75144,7 @@ var ts;
                 parameters.push(createCombinedSymbolFromTypes(symbols, ts.mapDefined(candidates, function (candidate) { return tryGetTypeAtPosition(candidate, i); })));
             };
             for (var i = 0; i < maxNonRestParam; i++) {
-                _loop_25(i);
+                _loop_26(i);
             }
             var restParameterSymbols = ts.mapDefined(candidates, function (c) { return signatureHasRestParameter(c) ? ts.last(c.parameters) : undefined; });
             var flags = 0 /* None */;
@@ -78270,7 +78371,7 @@ var ts;
         }
         function checkExpressionForMutableLocation(node, checkMode, contextualType, forceTuple) {
             var type = checkExpression(node, checkMode, forceTuple);
-            return isConstContext(node) ? getRegularTypeOfLiteralType(type) :
+            return isConstContext(node) || ts.isCommonJsExportedExpression(node) ? getRegularTypeOfLiteralType(type) :
                 isTypeAssertion(node) ? type :
                     getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType(node) : contextualType, node));
         }
@@ -79039,7 +79140,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_26 = function (declaration) {
+                var _loop_27 = 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));
@@ -79054,7 +79155,7 @@ var ts;
                 };
                 for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) {
                     var declaration = _a[_i];
-                    _loop_26(declaration);
+                    _loop_27(declaration);
                 }
                 indexSignatureMap_1.forEach(function (entry) {
                     if (entry.declarations.length > 1) {
@@ -82433,7 +82534,7 @@ var ts;
             var interfaceDeclaration = ts.getObjectFlags(type) & 2 /* Interface */ ? ts.getDeclarationOfKind(type.symbol, 257 /* InterfaceDeclaration */) : undefined;
             var localPropDeclaration = declaration && declaration.kind === 220 /* BinaryExpression */ ||
                 name && name.kind === 161 /* ComputedPropertyName */ || getParentOfSymbol(prop) === type.symbol ? declaration : undefined;
-            var _loop_27 = function (info) {
+            var _loop_28 = 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
@@ -82446,7 +82547,7 @@ var ts;
             };
             for (var _i = 0, indexInfos_9 = indexInfos; _i < indexInfos_9.length; _i++) {
                 var info = indexInfos_9[_i];
-                _loop_27(info);
+                _loop_28(info);
             }
         }
         function checkIndexConstraintForIndexSignature(type, checkInfo) {
@@ -82454,7 +82555,7 @@ var ts;
             var indexInfos = getApplicableIndexInfos(type, checkInfo.keyType);
             var interfaceDeclaration = ts.getObjectFlags(type) & 2 /* Interface */ ? ts.getDeclarationOfKind(type.symbol, 257 /* InterfaceDeclaration */) : undefined;
             var localCheckDeclaration = declaration && getParentOfSymbol(getSymbolOfNode(declaration)) === type.symbol ? declaration : undefined;
-            var _loop_28 = function (info) {
+            var _loop_29 = function (info) {
                 if (info === checkInfo)
                     return "continue";
                 var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined;
@@ -82469,7 +82570,7 @@ var ts;
             };
             for (var _i = 0, indexInfos_10 = indexInfos; _i < indexInfos_10.length; _i++) {
                 var info = indexInfos_10[_i];
-                _loop_28(info);
+                _loop_29(info);
             }
         }
         function checkTypeNameIsReserved(name, message) {
@@ -82780,7 +82881,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_29 = function (member) {
+            var _loop_30 = function (member) {
                 if (ts.hasAmbientModifier(member)) {
                     return "continue";
                 }
@@ -82797,7 +82898,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_29(member);
+                _loop_30(member);
             }
         }
         /**
@@ -82885,7 +82986,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_30 = function (member) {
+            var _loop_31 = function (member) {
                 if (ts.isStatic(member)) {
                     return "continue";
                 }
@@ -82904,7 +83005,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_30(member);
+                _loop_31(member);
             }
             if (!issuedMemberError) {
                 // check again with diagnostics to generate a less-specific error
@@ -109869,7 +109970,7 @@ var ts;
                         return emitRestOrJSDocVariadicType(node);
                     case 318 /* JSDocNamepathType */:
                         return;
-                    case 319 /* JSDocComment */:
+                    case 319 /* JSDoc */:
                         return emitJSDoc(node);
                     case 321 /* JSDocTypeLiteral */:
                         return emitJSDocTypeLiteral(node);
@@ -120691,7 +120792,7 @@ var ts;
             });
             // Sort by paths closest to importing file Name directory
             var sortedPaths = [];
-            var _loop_31 = function (directory) {
+            var _loop_32 = function (directory) {
                 var directoryStart = ts.ensureTrailingDirectorySeparator(directory);
                 var pathsInDirectory;
                 allFileNames.forEach(function (_a, fileName) {
@@ -120715,9 +120816,9 @@ var ts;
             };
             var out_directory_1;
             for (var directory = ts.getDirectoryPath(importingFileName); allFileNames.size !== 0;) {
-                var state_9 = _loop_31(directory);
+                var state_10 = _loop_32(directory);
                 directory = out_directory_1;
-                if (state_9 === "break")
+                if (state_10 === "break")
                     break;
             }
             if (allFileNames.size) {