typescript 4.8.0-dev.20220803 → 4.8.0-dev.20220804

package/lib/typingsInstaller.js

@@ -89,7 +89,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.20220803";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220804";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -21858,7 +21858,7 @@ var ts;
          * Wraps an expression in parentheses if it is needed in order to use the expression for
          * property or element access.
          */
-        function parenthesizeLeftSideOfAccess(expression) {
+        function parenthesizeLeftSideOfAccess(expression, optionalChain) {
             // isLeftHandSideExpression is almost the correct criterion for when it is not necessary
             // to parenthesize the expression before a dot. The known exception is:
             //
@@ -21867,7 +21867,8 @@ var ts;
             //
             var emittedExpression = ts.skipPartiallyEmittedExpressions(expression);
             if (ts.isLeftHandSideExpression(emittedExpression)
-                && (emittedExpression.kind !== 209 /* NewExpression */ || emittedExpression.arguments)) {
+                && (emittedExpression.kind !== 209 /* NewExpression */ || emittedExpression.arguments)
+                && (optionalChain || !ts.isOptionalChain(emittedExpression))) {
                 // TODO(rbuckton): Verify whether this assertion holds.
                 return expression;
             }
@@ -23274,7 +23275,7 @@ var ts;
         // @api
         function createDecorator(expression) {
             var node = createBaseNode(165 /* Decorator */);
-            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ false);
             node.transformFlags |=
                 propagateChildFlags(node.expression) |
                     1 /* ContainsTypeScript */ |
@@ -24075,7 +24076,7 @@ var ts;
         // @api
         function createPropertyAccessExpression(expression, name) {
             var node = createBaseExpression(206 /* PropertyAccessExpression */);
-            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ false);
             node.name = asName(name);
             node.transformFlags =
                 propagateChildFlags(node.expression) |
@@ -24105,7 +24106,7 @@ var ts;
         function createPropertyAccessChain(expression, questionDotToken, name) {
             var node = createBaseExpression(206 /* PropertyAccessExpression */);
             node.flags |= 32 /* OptionalChain */;
-            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ true);
             node.questionDotToken = questionDotToken;
             node.name = asName(name);
             node.transformFlags |=
@@ -24131,7 +24132,7 @@ var ts;
         // @api
         function createElementAccessExpression(expression, index) {
             var node = createBaseExpression(207 /* ElementAccessExpression */);
-            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ false);
             node.argumentExpression = asExpression(index);
             node.transformFlags |=
                 propagateChildFlags(node.expression) |
@@ -24159,7 +24160,7 @@ var ts;
         function createElementAccessChain(expression, questionDotToken, index) {
             var node = createBaseExpression(207 /* ElementAccessExpression */);
             node.flags |= 32 /* OptionalChain */;
-            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ true);
             node.questionDotToken = questionDotToken;
             node.argumentExpression = asExpression(index);
             node.transformFlags |=
@@ -24183,7 +24184,7 @@ var ts;
         // @api
         function createCallExpression(expression, typeArguments, argumentsArray) {
             var node = createBaseExpression(208 /* CallExpression */);
-            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ false);
             node.typeArguments = asNodeArray(typeArguments);
             node.arguments = parenthesizerRules().parenthesizeExpressionsOfCommaDelimitedList(createNodeArray(argumentsArray));
             node.transformFlags |=
@@ -24216,7 +24217,7 @@ var ts;
         function createCallChain(expression, questionDotToken, typeArguments, argumentsArray) {
             var node = createBaseExpression(208 /* CallExpression */);
             node.flags |= 32 /* OptionalChain */;
-            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ true);
             node.questionDotToken = questionDotToken;
             node.typeArguments = asNodeArray(typeArguments);
             node.arguments = parenthesizerRules().parenthesizeExpressionsOfCommaDelimitedList(createNodeArray(argumentsArray));
@@ -24271,7 +24272,7 @@ var ts;
         // @api
         function createTaggedTemplateExpression(tag, typeArguments, template) {
             var node = createBaseExpression(210 /* TaggedTemplateExpression */);
-            node.tag = parenthesizerRules().parenthesizeLeftSideOfAccess(tag);
+            node.tag = parenthesizerRules().parenthesizeLeftSideOfAccess(tag, /*optionalChain*/ false);
             node.typeArguments = asNodeArray(typeArguments);
             node.template = template;
             node.transformFlags |=
@@ -24709,7 +24710,7 @@ var ts;
         // @api
         function createExpressionWithTypeArguments(expression, typeArguments) {
             var node = createBaseNode(228 /* ExpressionWithTypeArguments */);
-            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ false);
             node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(typeArguments);
             node.transformFlags |=
                 propagateChildFlags(node.expression) |
@@ -24745,7 +24746,7 @@ var ts;
         // @api
         function createNonNullExpression(expression) {
             var node = createBaseExpression(230 /* NonNullExpression */);
-            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ false);
             node.transformFlags |=
                 propagateChildFlags(node.expression) |
                     1 /* ContainsTypeScript */;
@@ -24764,7 +24765,7 @@ var ts;
         function createNonNullChain(expression) {
             var node = createBaseExpression(230 /* NonNullExpression */);
             node.flags |= 32 /* OptionalChain */;
-            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+            node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ true);
             node.transformFlags |=
                 propagateChildFlags(node.expression) |
                     1 /* ContainsTypeScript */;
@@ -26968,7 +26969,7 @@ var ts;
             }
             else if (ts.getEmitFlags(callee) & 4096 /* HelperName */) {
                 thisArg = createVoidZero();
-                target = parenthesizerRules().parenthesizeLeftSideOfAccess(callee);
+                target = parenthesizerRules().parenthesizeLeftSideOfAccess(callee, /*optionalChain*/ false);
             }
             else if (ts.isPropertyAccessExpression(callee)) {
                 if (shouldBeCapturedInTempVariable(callee.expression, cacheIdentifiers)) {
@@ -26997,7 +26998,7 @@ var ts;
             else {
                 // for `a()` target is `a` and thisArg is `void 0`
                 thisArg = createVoidZero();
-                target = parenthesizerRules().parenthesizeLeftSideOfAccess(expression);
+                target = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ false);
             }
             return { target: target, thisArg: thisArg };
         }
@@ -83989,17 +83990,28 @@ var ts;
          * the `[Symbol.asyncIterator]()` method first, and then the `[Symbol.iterator]()` method.
          */
         function getIterationTypesOfIterable(type, use, errorNode) {
+            var _a, _b;
             if (isTypeAny(type)) {
                 return anyIterationTypes;
             }
             if (!(type.flags & 1048576 /* Union */)) {
-                var iterationTypes_1 = getIterationTypesOfIterableWorker(type, use, errorNode);
+                var errorOutputContainer = errorNode ? { errors: undefined } : undefined;
+                var iterationTypes_1 = getIterationTypesOfIterableWorker(type, use, errorNode, errorOutputContainer);
                 if (iterationTypes_1 === noIterationTypes) {
                     if (errorNode) {
-                        reportTypeNotIterableError(errorNode, type, !!(use & 2 /* AllowsAsyncIterablesFlag */));
+                        var rootDiag = reportTypeNotIterableError(errorNode, type, !!(use & 2 /* AllowsAsyncIterablesFlag */));
+                        if (errorOutputContainer === null || errorOutputContainer === void 0 ? void 0 : errorOutputContainer.errors) {
+                            ts.addRelatedInfo.apply(void 0, __spreadArray([rootDiag], errorOutputContainer.errors, false));
+                        }
                     }
                     return undefined;
                 }
+                else if ((_a = errorOutputContainer === null || errorOutputContainer === void 0 ? void 0 : errorOutputContainer.errors) === null || _a === void 0 ? void 0 : _a.length) {
+                    for (var _i = 0, _c = errorOutputContainer.errors; _i < _c.length; _i++) {
+                        var diag = _c[_i];
+                        diagnostics.add(diag);
+                    }
+                }
                 return iterationTypes_1;
             }
             var cacheKey = use & 2 /* AllowsAsyncIterablesFlag */ ? "iterationTypesOfAsyncIterable" : "iterationTypesOfIterable";
@@ -84007,19 +84019,27 @@ var ts;
             if (cachedTypes)
                 return cachedTypes === noIterationTypes ? undefined : cachedTypes;
             var allIterationTypes;
-            for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
-                var constituent = _a[_i];
-                var iterationTypes_2 = getIterationTypesOfIterableWorker(constituent, use, errorNode);
+            for (var _d = 0, _e = type.types; _d < _e.length; _d++) {
+                var constituent = _e[_d];
+                var errorOutputContainer = errorNode ? { errors: undefined } : undefined;
+                var iterationTypes_2 = getIterationTypesOfIterableWorker(constituent, use, errorNode, errorOutputContainer);
                 if (iterationTypes_2 === noIterationTypes) {
                     if (errorNode) {
-                        reportTypeNotIterableError(errorNode, type, !!(use & 2 /* AllowsAsyncIterablesFlag */));
+                        var rootDiag = reportTypeNotIterableError(errorNode, type, !!(use & 2 /* AllowsAsyncIterablesFlag */));
+                        if (errorOutputContainer === null || errorOutputContainer === void 0 ? void 0 : errorOutputContainer.errors) {
+                            ts.addRelatedInfo.apply(void 0, __spreadArray([rootDiag], errorOutputContainer.errors, false));
+                        }
                     }
                     setCachedIterationTypes(type, cacheKey, noIterationTypes);
                     return undefined;
                 }
-                else {
-                    allIterationTypes = ts.append(allIterationTypes, iterationTypes_2);
+                else if ((_b = errorOutputContainer === null || errorOutputContainer === void 0 ? void 0 : errorOutputContainer.errors) === null || _b === void 0 ? void 0 : _b.length) {
+                    for (var _f = 0, _g = errorOutputContainer.errors; _f < _g.length; _f++) {
+                        var diag = _g[_f];
+                        diagnostics.add(diag);
+                    }
                 }
+                allIterationTypes = ts.append(allIterationTypes, iterationTypes_2);
             }
             var iterationTypes = allIterationTypes ? combineIterationTypes(allIterationTypes) : noIterationTypes;
             setCachedIterationTypes(type, cacheKey, iterationTypes);
@@ -84047,47 +84067,62 @@ var ts;
          * NOTE: You probably don't want to call this directly and should be calling
          * `getIterationTypesOfIterable` instead.
          */
-        function getIterationTypesOfIterableWorker(type, use, errorNode) {
+        function getIterationTypesOfIterableWorker(type, use, errorNode, errorOutputContainer) {
             if (isTypeAny(type)) {
                 return anyIterationTypes;
             }
+            // If we are reporting errors and encounter a cached `noIterationTypes`, we should ignore the cached value and continue as if nothing was cached.
+            // In addition, we should not cache any new results for this call.
+            var noCache = false;
             if (use & 2 /* AllowsAsyncIterablesFlag */) {
                 var iterationTypes = getIterationTypesOfIterableCached(type, asyncIterationTypesResolver) ||
                     getIterationTypesOfIterableFast(type, asyncIterationTypesResolver);
                 if (iterationTypes) {
-                    return use & 8 /* ForOfFlag */ ?
-                        getAsyncFromSyncIterationTypes(iterationTypes, errorNode) :
-                        iterationTypes;
+                    if (iterationTypes === noIterationTypes && errorNode) {
+                        // ignore the cached value
+                        noCache = true;
+                    }
+                    else {
+                        return use & 8 /* ForOfFlag */ ?
+                            getAsyncFromSyncIterationTypes(iterationTypes, errorNode) :
+                            iterationTypes;
+                    }
                 }
             }
             if (use & 1 /* AllowsSyncIterablesFlag */) {
                 var iterationTypes = getIterationTypesOfIterableCached(type, syncIterationTypesResolver) ||
                     getIterationTypesOfIterableFast(type, syncIterationTypesResolver);
                 if (iterationTypes) {
-                    if (use & 2 /* AllowsAsyncIterablesFlag */) {
-                        // for a sync iterable in an async context, only use the cached types if they are valid.
-                        if (iterationTypes !== noIterationTypes) {
-                            return setCachedIterationTypes(type, "iterationTypesOfAsyncIterable", getAsyncFromSyncIterationTypes(iterationTypes, errorNode));
-                        }
+                    if (iterationTypes === noIterationTypes && errorNode) {
+                        // ignore the cached value
+                        noCache = true;
                     }
                     else {
-                        return iterationTypes;
+                        if (use & 2 /* AllowsAsyncIterablesFlag */) {
+                            // for a sync iterable in an async context, only use the cached types if they are valid.
+                            if (iterationTypes !== noIterationTypes) {
+                                iterationTypes = getAsyncFromSyncIterationTypes(iterationTypes, errorNode);
+                                return noCache ? iterationTypes : setCachedIterationTypes(type, "iterationTypesOfAsyncIterable", iterationTypes);
+                            }
+                        }
+                        else {
+                            return iterationTypes;
+                        }
                     }
                 }
             }
             if (use & 2 /* AllowsAsyncIterablesFlag */) {
-                var iterationTypes = getIterationTypesOfIterableSlow(type, asyncIterationTypesResolver, errorNode);
+                var iterationTypes = getIterationTypesOfIterableSlow(type, asyncIterationTypesResolver, errorNode, errorOutputContainer, noCache);
                 if (iterationTypes !== noIterationTypes) {
                     return iterationTypes;
                 }
             }
             if (use & 1 /* AllowsSyncIterablesFlag */) {
-                var iterationTypes = getIterationTypesOfIterableSlow(type, syncIterationTypesResolver, errorNode);
+                var iterationTypes = getIterationTypesOfIterableSlow(type, syncIterationTypesResolver, errorNode, errorOutputContainer, noCache);
                 if (iterationTypes !== noIterationTypes) {
                     if (use & 2 /* AllowsAsyncIterablesFlag */) {
-                        return setCachedIterationTypes(type, "iterationTypesOfAsyncIterable", iterationTypes
-                            ? getAsyncFromSyncIterationTypes(iterationTypes, errorNode)
-                            : noIterationTypes);
+                        iterationTypes = getAsyncFromSyncIterationTypes(iterationTypes, errorNode);
+                        return noCache ? iterationTypes : setCachedIterationTypes(type, "iterationTypesOfAsyncIterable", iterationTypes);
                     }
                     else {
                         return iterationTypes;
@@ -84108,7 +84143,7 @@ var ts;
         }
         function getIterationTypesOfGlobalIterableType(globalType, resolver) {
             var globalIterationTypes = getIterationTypesOfIterableCached(globalType, resolver) ||
-                getIterationTypesOfIterableSlow(globalType, resolver, /*errorNode*/ undefined);
+                getIterationTypesOfIterableSlow(globalType, resolver, /*errorNode*/ undefined, /*errorOutputContainer*/ undefined, /*noCache*/ false);
             return globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes;
         }
         /**
@@ -84162,26 +84197,26 @@ var ts;
          * NOTE: You probably don't want to call this directly and should be calling
          * `getIterationTypesOfIterable` instead.
          */
-        function getIterationTypesOfIterableSlow(type, resolver, errorNode) {
+        function getIterationTypesOfIterableSlow(type, resolver, errorNode, errorOutputContainer, noCache) {
             var _a;
             var method = getPropertyOfType(type, getPropertyNameForKnownSymbolName(resolver.iteratorSymbolName));
             var methodType = method && !(method.flags & 16777216 /* Optional */) ? getTypeOfSymbol(method) : undefined;
             if (isTypeAny(methodType)) {
-                return setCachedIterationTypes(type, resolver.iterableCacheKey, anyIterationTypes);
+                return noCache ? anyIterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, anyIterationTypes);
             }
             var signatures = methodType ? getSignaturesOfType(methodType, 0 /* Call */) : undefined;
             if (!ts.some(signatures)) {
-                return setCachedIterationTypes(type, resolver.iterableCacheKey, noIterationTypes);
+                return noCache ? noIterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, noIterationTypes);
             }
             var iteratorType = getIntersectionType(ts.map(signatures, getReturnTypeOfSignature));
-            var iterationTypes = (_a = getIterationTypesOfIterator(iteratorType, resolver, errorNode)) !== null && _a !== void 0 ? _a : noIterationTypes;
-            return setCachedIterationTypes(type, resolver.iterableCacheKey, iterationTypes);
+            var iterationTypes = (_a = getIterationTypesOfIteratorWorker(iteratorType, resolver, errorNode, errorOutputContainer, noCache)) !== null && _a !== void 0 ? _a : noIterationTypes;
+            return noCache ? iterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, iterationTypes);
         }
         function reportTypeNotIterableError(errorNode, type, allowAsyncIterables) {
             var message = allowAsyncIterables
                 ? ts.Diagnostics.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator
                 : ts.Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator;
-            errorAndMaybeSuggestAwait(errorNode, !!getAwaitedTypeOfPromise(type), message, typeToString(type));
+            return errorAndMaybeSuggestAwait(errorNode, !!getAwaitedTypeOfPromise(type), message, typeToString(type));
         }
         /**
          * Gets the *yield*, *return*, and *next* types from an `Iterator`-like or `AsyncIterator`-like type.
@@ -84189,13 +84224,29 @@ var ts;
          * If we successfully found the *yield*, *return*, and *next* types, an `IterationTypes`
          * record is returned. Otherwise, `undefined` is returned.
          */
-        function getIterationTypesOfIterator(type, resolver, errorNode) {
+        function getIterationTypesOfIterator(type, resolver, errorNode, errorOutputContainer) {
+            return getIterationTypesOfIteratorWorker(type, resolver, errorNode, errorOutputContainer, /*noCache*/ false);
+        }
+        /**
+         * Gets the *yield*, *return*, and *next* types from an `Iterator`-like or `AsyncIterator`-like type.
+         *
+         * If we successfully found the *yield*, *return*, and *next* types, an `IterationTypes`
+         * record is returned. Otherwise, `undefined` is returned.
+         *
+         * NOTE: You probably don't want to call this directly and should be calling
+         * `getIterationTypesOfIterator` instead.
+         */
+        function getIterationTypesOfIteratorWorker(type, resolver, errorNode, errorOutputContainer, noCache) {
             if (isTypeAny(type)) {
                 return anyIterationTypes;
             }
             var iterationTypes = getIterationTypesOfIteratorCached(type, resolver) ||
-                getIterationTypesOfIteratorFast(type, resolver) ||
-                getIterationTypesOfIteratorSlow(type, resolver, errorNode);
+                getIterationTypesOfIteratorFast(type, resolver);
+            if (iterationTypes === noIterationTypes && errorNode) {
+                iterationTypes = undefined;
+                noCache = true;
+            }
+            iterationTypes !== null && iterationTypes !== void 0 ? iterationTypes : (iterationTypes = getIterationTypesOfIteratorSlow(type, resolver, errorNode, errorOutputContainer, noCache));
             return iterationTypes === noIterationTypes ? undefined : iterationTypes;
         }
         /**
@@ -84233,7 +84284,7 @@ var ts;
                 // iteration types of their `next`, `return`, and `throw` methods. While we define these as `any`
                 // and `undefined` in our libs by default, a custom lib *could* use different definitions.
                 var globalIterationTypes = getIterationTypesOfIteratorCached(globalType, resolver) ||
-                    getIterationTypesOfIteratorSlow(globalType, resolver, /*errorNode*/ undefined);
+                    getIterationTypesOfIteratorSlow(globalType, resolver, /*errorNode*/ undefined, /*errorOutputContainer*/ undefined, /*noCache*/ false);
                 var _a = globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes, returnType = _a.returnType, nextType = _a.nextType;
                 return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
             }
@@ -84303,8 +84354,8 @@ var ts;
          * If we successfully found the *yield*, *return*, and *next* types, an `IterationTypes`
          * record is returned. Otherwise, we return `undefined`.
          */
-        function getIterationTypesOfMethod(type, resolver, methodName, errorNode) {
-            var _a, _b, _c, _d;
+        function getIterationTypesOfMethod(type, resolver, methodName, errorNode, errorOutputContainer) {
+            var _a, _b, _c, _d, _e, _f;
             var method = getPropertyOfType(type, methodName);
             // Ignore 'return' or 'throw' if they are missing.
             if (!method && methodName !== "next") {
@@ -84324,9 +84375,15 @@ var ts;
                     var diagnostic = methodName === "next"
                         ? resolver.mustHaveANextMethodDiagnostic
                         : resolver.mustBeAMethodDiagnostic;
-                    error(errorNode, diagnostic, methodName);
+                    if (errorOutputContainer) {
+                        (_a = errorOutputContainer.errors) !== null && _a !== void 0 ? _a : (errorOutputContainer.errors = []);
+                        errorOutputContainer.errors.push(ts.createDiagnosticForNode(errorNode, diagnostic, methodName));
+                    }
+                    else {
+                        error(errorNode, diagnostic, methodName);
+                    }
                 }
-                return methodName === "next" ? anyIterationTypes : undefined;
+                return methodName === "next" ? noIterationTypes : undefined;
             }
             // If the method signature comes exclusively from the global iterator or generator type,
             // create iteration types from its type arguments like `getIterationTypesOfIteratorFast`
@@ -84338,8 +84395,8 @@ var ts;
             if ((methodType === null || methodType === void 0 ? void 0 : methodType.symbol) && methodSignatures.length === 1) {
                 var globalGeneratorType = resolver.getGlobalGeneratorType(/*reportErrors*/ false);
                 var globalIteratorType = resolver.getGlobalIteratorType(/*reportErrors*/ false);
-                var isGeneratorMethod = ((_b = (_a = globalGeneratorType.symbol) === null || _a === void 0 ? void 0 : _a.members) === null || _b === void 0 ? void 0 : _b.get(methodName)) === methodType.symbol;
-                var isIteratorMethod = !isGeneratorMethod && ((_d = (_c = globalIteratorType.symbol) === null || _c === void 0 ? void 0 : _c.members) === null || _d === void 0 ? void 0 : _d.get(methodName)) === methodType.symbol;
+                var isGeneratorMethod = ((_c = (_b = globalGeneratorType.symbol) === null || _b === void 0 ? void 0 : _b.members) === null || _c === void 0 ? void 0 : _c.get(methodName)) === methodType.symbol;
+                var isIteratorMethod = !isGeneratorMethod && ((_e = (_d = globalIteratorType.symbol) === null || _d === void 0 ? void 0 : _d.members) === null || _e === void 0 ? void 0 : _e.get(methodName)) === methodType.symbol;
                 if (isGeneratorMethod || isIteratorMethod) {
                     var globalType = isGeneratorMethod ? globalGeneratorType : globalIteratorType;
                     var mapper = methodType.mapper;
@@ -84379,7 +84436,13 @@ var ts;
             var iterationTypes = getIterationTypesOfIteratorResult(resolvedMethodReturnType);
             if (iterationTypes === noIterationTypes) {
                 if (errorNode) {
-                    error(errorNode, resolver.mustHaveAValueDiagnostic, methodName);
+                    if (errorOutputContainer) {
+                        (_f = errorOutputContainer.errors) !== null && _f !== void 0 ? _f : (errorOutputContainer.errors = []);
+                        errorOutputContainer.errors.push(ts.createDiagnosticForNode(errorNode, resolver.mustHaveAValueDiagnostic, methodName));
+                    }
+                    else {
+                        error(errorNode, resolver.mustHaveAValueDiagnostic, methodName);
+                    }
                 }
                 yieldType = anyType;
                 returnTypes = ts.append(returnTypes, anyType);
@@ -84400,13 +84463,13 @@ var ts;
          * NOTE: You probably don't want to call this directly and should be calling
          * `getIterationTypesOfIterator` instead.
          */
-        function getIterationTypesOfIteratorSlow(type, resolver, errorNode) {
+        function getIterationTypesOfIteratorSlow(type, resolver, errorNode, errorOutputContainer, noCache) {
             var iterationTypes = combineIterationTypes([
-                getIterationTypesOfMethod(type, resolver, "next", errorNode),
-                getIterationTypesOfMethod(type, resolver, "return", errorNode),
-                getIterationTypesOfMethod(type, resolver, "throw", errorNode),
+                getIterationTypesOfMethod(type, resolver, "next", errorNode, errorOutputContainer),
+                getIterationTypesOfMethod(type, resolver, "return", errorNode, errorOutputContainer),
+                getIterationTypesOfMethod(type, resolver, "throw", errorNode, errorOutputContainer),
             ]);
-            return setCachedIterationTypes(type, resolver.iteratorCacheKey, iterationTypes);
+            return noCache ? iterationTypes : setCachedIterationTypes(type, resolver.iteratorCacheKey, iterationTypes);
         }
         /**
          * Gets the requested "iteration type" from a type that is either `Iterable`-like, `Iterator`-like,
@@ -84427,7 +84490,7 @@ var ts;
             var use = isAsyncGenerator ? 2 /* AsyncGeneratorReturnType */ : 1 /* GeneratorReturnType */;
             var resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver;
             return getIterationTypesOfIterable(type, use, /*errorNode*/ undefined) ||
-                getIterationTypesOfIterator(type, resolver, /*errorNode*/ undefined);
+                getIterationTypesOfIterator(type, resolver, /*errorNode*/ undefined, /*errorOutputContainer*/ undefined);
         }
         function checkBreakOrContinueStatement(node) {
             // Grammar checking
@@ -122724,8 +122787,6 @@ var ts;
                 if (watcher.files === 0 && watcher.resolutions === 0) {
                     fileWatchesOfAffectingLocations.delete(path);
                     watcher.watcher.close();
-                    // Ensure when watching symlinked package.json, we can close the actual file watcher only once
-                    watcher.watcher = ts.noopFileWatcher;
                 }
             });
             hasChangedAutomaticTypeDirectiveNames = false;
@@ -123071,20 +123132,27 @@ var ts;
             }
             var paths = new ts.Set();
             paths.add(locationToWatch);
+            var actualWatcher = canWatchDirectoryOrFile(resolutionHost.toPath(locationToWatch)) ?
+                resolutionHost.watchAffectingFileLocation(locationToWatch, function (fileName, eventKind) {
+                    cachedDirectoryStructureHost === null || cachedDirectoryStructureHost === void 0 ? void 0 : cachedDirectoryStructureHost.addOrDeleteFile(fileName, resolutionHost.toPath(locationToWatch), eventKind);
+                    var packageJsonMap = moduleResolutionCache.getPackageJsonInfoCache().getInternalMap();
+                    paths.forEach(function (path) {
+                        if (watcher.resolutions)
+                            (affectingPathChecks !== null && affectingPathChecks !== void 0 ? affectingPathChecks : (affectingPathChecks = new ts.Set())).add(path);
+                        if (watcher.files)
+                            (affectingPathChecksForFile !== null && affectingPathChecksForFile !== void 0 ? affectingPathChecksForFile : (affectingPathChecksForFile = new ts.Set())).add(path);
+                        packageJsonMap === null || packageJsonMap === void 0 ? void 0 : packageJsonMap.delete(resolutionHost.toPath(path));
+                    });
+                    resolutionHost.scheduleInvalidateResolutionsOfFailedLookupLocations();
+                }) : ts.noopFileWatcher;
             var watcher = {
-                watcher: canWatchDirectoryOrFile(resolutionHost.toPath(locationToWatch)) ?
-                    resolutionHost.watchAffectingFileLocation(locationToWatch, function (fileName, eventKind) {
-                        cachedDirectoryStructureHost === null || cachedDirectoryStructureHost === void 0 ? void 0 : cachedDirectoryStructureHost.addOrDeleteFile(fileName, resolutionHost.toPath(locationToWatch), eventKind);
-                        paths.forEach(function (path) {
-                            var _a;
-                            if (watcher.resolutions)
-                                (affectingPathChecks !== null && affectingPathChecks !== void 0 ? affectingPathChecks : (affectingPathChecks = new ts.Set())).add(path);
-                            if (watcher.files)
-                                (affectingPathChecksForFile !== null && affectingPathChecksForFile !== void 0 ? affectingPathChecksForFile : (affectingPathChecksForFile = new ts.Set())).add(path);
-                            (_a = moduleResolutionCache.getPackageJsonInfoCache().getInternalMap()) === null || _a === void 0 ? void 0 : _a.delete(resolutionHost.toPath(path));
-                        });
-                        resolutionHost.scheduleInvalidateResolutionsOfFailedLookupLocations();
-                    }) : ts.noopFileWatcher,
+                watcher: actualWatcher !== ts.noopFileWatcher ? {
+                    close: function () {
+                        actualWatcher.close();
+                        // Ensure when watching symlinked package.json, we can close the actual file watcher only once
+                        actualWatcher = ts.noopFileWatcher;
+                    }
+                } : actualWatcher,
                 resolutions: forResolution ? 1 : 0,
                 files: forResolution ? 0 : 1,
                 paths: paths,
@@ -123498,7 +123566,7 @@ var ts;
             var info = getInfo(importingSourceFileName, host);
             var modulePaths = getAllModulePaths(importingSourceFileName, toFileName, host, userPreferences, options);
             return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, userPreferences, /*packageNameOnly*/ undefined, options.overrideImportMode); }) ||
-                getLocalModuleSpecifier(toFileName, info, compilerOptions, host, preferences);
+                getLocalModuleSpecifier(toFileName, info, compilerOptions, host, options.overrideImportMode || importingSourceFile.impliedNodeFormat, preferences);
         }
         function tryGetModuleSpecifiersFromCache(moduleSymbol, importingSourceFile, host, userPreferences, options) {
             if (options === void 0) { options = {}; }
@@ -123581,7 +123649,7 @@ var ts;
                     return nodeModulesSpecifiers;
                 }
                 if (!specifier && !modulePath.isRedirect) {
-                    var local = getLocalModuleSpecifier(modulePath.path, info, compilerOptions, host, preferences);
+                    var local = getLocalModuleSpecifier(modulePath.path, info, compilerOptions, host, options.overrideImportMode || importingSourceFile.impliedNodeFormat, preferences);
                     if (ts.pathIsBareSpecifier(local)) {
                         pathsSpecifiers = ts.append(pathsSpecifiers, local);
                     }
@@ -123609,7 +123677,7 @@ var ts;
             var sourceDirectory = ts.getDirectoryPath(importingSourceFileName);
             return { getCanonicalFileName: getCanonicalFileName, importingSourceFileName: importingSourceFileName, sourceDirectory: sourceDirectory };
         }
-        function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, _a) {
+        function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, importMode, _a) {
             var ending = _a.ending, relativePreference = _a.relativePreference;
             var baseUrl = compilerOptions.baseUrl, paths = compilerOptions.paths, rootDirs = compilerOptions.rootDirs;
             var sourceDirectory = info.sourceDirectory, getCanonicalFileName = info.getCanonicalFileName;
@@ -123623,9 +123691,8 @@ var ts;
             if (!relativeToBaseUrl) {
                 return relativePath;
             }
-            var importRelativeToBaseUrl = removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions);
-            var fromPaths = paths && tryGetModuleNameFromPaths(ts.removeFileExtension(relativeToBaseUrl), importRelativeToBaseUrl, paths);
-            var nonRelative = fromPaths === undefined && baseUrl !== undefined ? importRelativeToBaseUrl : fromPaths;
+            var fromPaths = paths && tryGetModuleNameFromPaths(relativeToBaseUrl, paths, getAllowedEndings(ending, compilerOptions, importMode), host, compilerOptions);
+            var nonRelative = fromPaths === undefined && baseUrl !== undefined ? removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions) : fromPaths;
             if (!nonRelative) {
                 return relativePath;
             }
@@ -123860,28 +123927,102 @@ var ts;
                 return ambientModuleDeclare.name.text;
             }
         }
-        function tryGetModuleNameFromPaths(relativeToBaseUrlWithIndex, relativeToBaseUrl, paths) {
+        function getAllowedEndings(preferredEnding, compilerOptions, importMode) {
+            if (ts.getEmitModuleResolutionKind(compilerOptions) >= ts.ModuleResolutionKind.Node16 && importMode === ts.ModuleKind.ESNext) {
+                return [2 /* JsExtension */];
+            }
+            switch (preferredEnding) {
+                case 2 /* JsExtension */: return [2 /* JsExtension */, 0 /* Minimal */, 1 /* Index */];
+                case 1 /* Index */: return [1 /* Index */, 0 /* Minimal */, 2 /* JsExtension */];
+                case 0 /* Minimal */: return [0 /* Minimal */, 1 /* Index */, 2 /* JsExtension */];
+                default: ts.Debug.assertNever(preferredEnding);
+            }
+        }
+        function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions) {
             for (var key in paths) {
-                for (var _i = 0, _a = paths[key]; _i < _a.length; _i++) {
-                    var patternText_1 = _a[_i];
-                    var pattern = ts.removeFileExtension(ts.normalizePath(patternText_1));
+                var _loop_36 = function (patternText_1) {
+                    var pattern = ts.normalizePath(patternText_1);
                     var indexOfStar = pattern.indexOf("*");
+                    // In module resolution, if `pattern` itself has an extension, a file with that extension is looked up directly,
+                    // meaning a '.ts' or '.d.ts' extension is allowed to resolve. This is distinct from the case where a '*' substitution
+                    // causes a module specifier to have an extension, i.e. the extension comes from the module specifier in a JS/TS file
+                    // and matches the '*'. For example:
+                    //
+                    // Module Specifier      | Path Mapping (key: [pattern]) | Interpolation       | Resolution Action
+                    // ---------------------->------------------------------->--------------------->---------------------------------------------------------------
+                    // import "@app/foo"    -> "@app/*": ["./src/app/*.ts"] -> "./src/app/foo.ts" -> tryFile("./src/app/foo.ts") || [continue resolution algorithm]
+                    // import "@app/foo.ts" -> "@app/*": ["./src/app/*"]    -> "./src/app/foo.ts" -> [continue resolution algorithm]
+                    //
+                    // (https://github.com/microsoft/TypeScript/blob/ad4ded80e1d58f0bf36ac16bea71bc10d9f09895/src/compiler/moduleNameResolver.ts#L2509-L2516)
+                    //
+                    // The interpolation produced by both scenarios is identical, but only in the former, where the extension is encoded in
+                    // the path mapping rather than in the module specifier, will we prioritize a file lookup on the interpolation result.
+                    // (In fact, currently, the latter scenario will necessarily fail since no resolution mode recognizes '.ts' as a valid
+                    // extension for a module specifier.)
+                    //
+                    // Here, this means we need to be careful about whether we generate a match from the target filename (typically with a
+                    // .ts extension) or the possible relative module specifiers representing that file:
+                    //
+                    // Filename            | Relative Module Specifier Candidates         | Path Mapping                 | Filename Result    | Module Specifier Results
+                    // --------------------<----------------------------------------------<------------------------------<-------------------||----------------------------
+                    // dist/haha.d.ts      <- dist/haha, dist/haha.js                     <- "@app/*": ["./dist/*.d.ts"] <- @app/haha        || (none)
+                    // dist/haha.d.ts      <- dist/haha, dist/haha.js                     <- "@app/*": ["./dist/*"]      <- (none)           || @app/haha, @app/haha.js
+                    // dist/foo/index.d.ts <- dist/foo, dist/foo/index, dist/foo/index.js <- "@app/*": ["./dist/*.d.ts"] <- @app/foo/index   || (none)
+                    // dist/foo/index.d.ts <- dist/foo, dist/foo/index, dist/foo/index.js <- "@app/*": ["./dist/*"]      <- (none)           || @app/foo, @app/foo/index, @app/foo/index.js
+                    // dist/wow.js.js      <- dist/wow.js, dist/wow.js.js                 <- "@app/*": ["./dist/*.js"]   <- @app/wow.js      || @app/wow, @app/wow.js
+                    //
+                    // The "Filename Result" can be generated only if `pattern` has an extension. Care must be taken that the list of
+                    // relative module specifiers to run the interpolation (a) is actually valid for the module resolution mode, (b) takes
+                    // into account the existence of other files (e.g. 'dist/wow.js' cannot refer to 'dist/wow.js.js' if 'dist/wow.js'
+                    // exists) and (c) that they are ordered by preference. The last row shows that the filename result and module
+                    // specifier results are not mutually exclusive. Note that the filename result is a higher priority in module
+                    // resolution, but as long criteria (b) above is met, I don't think its result needs to be the highest priority result
+                    // in module specifier generation. I have included it last, as it's difficult to tell exactly where it should be
+                    // sorted among the others for a particular value of `importModuleSpecifierEnding`.
+                    var candidates = allowedEndings.map(function (ending) { return ({
+                        ending: ending,
+                        value: removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions)
+                    }); });
+                    if (ts.tryGetExtensionFromPath(pattern)) {
+                        candidates.push({ ending: undefined, value: relativeToBaseUrl });
+                    }
                     if (indexOfStar !== -1) {
-                        var prefix = pattern.substr(0, indexOfStar);
-                        var suffix = pattern.substr(indexOfStar + 1);
-                        if (relativeToBaseUrl.length >= prefix.length + suffix.length &&
-                            ts.startsWith(relativeToBaseUrl, prefix) &&
-                            ts.endsWith(relativeToBaseUrl, suffix) ||
-                            !suffix && relativeToBaseUrl === ts.removeTrailingDirectorySeparator(prefix)) {
-                            var matchedStar = relativeToBaseUrl.substr(prefix.length, relativeToBaseUrl.length - suffix.length - prefix.length);
-                            return key.replace("*", matchedStar);
+                        var prefix = pattern.substring(0, indexOfStar);
+                        var suffix = pattern.substring(indexOfStar + 1);
+                        for (var _b = 0, candidates_3 = candidates; _b < candidates_3.length; _b++) {
+                            var _c = candidates_3[_b], ending = _c.ending, value = _c.value;
+                            if (value.length >= prefix.length + suffix.length &&
+                                ts.startsWith(value, prefix) &&
+                                ts.endsWith(value, suffix) &&
+                                validateEnding({ ending: ending, value: value })) {
+                                var matchedStar = value.substring(prefix.length, value.length - suffix.length);
+                                return { value: key.replace("*", matchedStar) };
+                            }
                         }
                     }
-                    else if (pattern === relativeToBaseUrl || pattern === relativeToBaseUrlWithIndex) {
-                        return key;
+                    else if (ts.some(candidates, function (c) { return c.ending !== 0 /* Minimal */ && pattern === c.value; }) ||
+                        ts.some(candidates, function (c) { return c.ending === 0 /* Minimal */ && pattern === c.value && validateEnding(c); })) {
+                        return { value: key };
                     }
+                };
+                for (var _i = 0, _a = paths[key]; _i < _a.length; _i++) {
+                    var patternText_1 = _a[_i];
+                    var state_12 = _loop_36(patternText_1);
+                    if (typeof state_12 === "object")
+                        return state_12.value;
                 }
             }
+            function validateEnding(_a) {
+                var ending = _a.ending, value = _a.value;
+                // Optimization: `removeExtensionAndIndexPostFix` can query the file system (a good bit) if `ending` is `Minimal`, the basename
+                // is 'index', and a `host` is provided. To avoid that until it's unavoidable, we ran the function with no `host` above. Only
+                // here, after we've checked that the minimal ending is indeed a match (via the length and prefix/suffix checks / `some` calls),
+                // do we check that the host-validated result is consistent with the answer we got before. If it's not, it falls back to the
+                // `Ending.Index` result, which should already be in the list of candidates if `Minimal` was. (Note: the assumption here is
+                // that every module resolution mode that supports dropping extensions also supports dropping `/index`. Like literally
+                // everything else in this file, this logic needs to be updated if that's not true in some future module resolution mode.)
+                return ending !== 0 /* Minimal */ || value === removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions, host);
+            }
         }
         var MatchingMode;
         (function (MatchingMode) {
@@ -123977,10 +124118,10 @@ var ts;
                 return undefined;
             }
             // Simplify the full file path to something that can be resolved by Node.
+            var preferences = getPreferences(host, userPreferences, options, importingSourceFile);
             var moduleSpecifier = path;
             var isPackageRootPath = false;
             if (!packageNameOnly) {
-                var preferences = getPreferences(host, userPreferences, options, importingSourceFile);
                 var packageRootIndex = parts.packageRootIndex;
                 var moduleFileName = void 0;
                 while (true) {
@@ -124029,15 +124170,13 @@ var ts;
                 var packageRootPath = path.substring(0, packageRootIndex);
                 var packageJsonPath = ts.combinePaths(packageRootPath, "package.json");
                 var moduleFileToTry = path;
+                var maybeBlockedByTypesVersions = false;
                 var cachedPackageJson = (_b = (_a = host.getPackageJsonInfoCache) === null || _a === void 0 ? void 0 : _a.call(host)) === null || _b === void 0 ? void 0 : _b.getPackageJsonInfo(packageJsonPath);
                 if (typeof cachedPackageJson === "object" || cachedPackageJson === undefined && host.fileExists(packageJsonPath)) {
                     var packageJsonContent = (cachedPackageJson === null || cachedPackageJson === void 0 ? void 0 : cachedPackageJson.packageJsonContent) || JSON.parse(host.readFile(packageJsonPath));
+                    var importMode = overrideMode || importingSourceFile.impliedNodeFormat;
                     if (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node16 || ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext) {
-                        // `conditions` *could* be made to go against `importingSourceFile.impliedNodeFormat` if something wanted to generate
-                        // an ImportEqualsDeclaration in an ESM-implied file or an ImportCall in a CJS-implied file. But since this function is
-                        // usually called to conjure an import out of thin air, we don't have an existing usage to call `getModeForUsageAtIndex`
-                        // with, so for now we just stick with the mode of the file.
-                        var conditions = ["node", overrideMode || importingSourceFile.impliedNodeFormat === ts.ModuleKind.ESNext ? "import" : "require", "types"];
+                        var conditions = ["node", importMode === ts.ModuleKind.ESNext ? "import" : "require", "types"];
                         var fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string"
                             ? tryGetModuleNameFromExports(options, path, packageRootPath, ts.getPackageNameFromTypesPackageName(packageJsonContent.name), packageJsonContent.exports, conditions)
                             : undefined;
@@ -124056,16 +124195,26 @@ var ts;
                         : undefined;
                     if (versionPaths) {
                         var subModuleName = path.slice(packageRootPath.length + 1);
-                        var fromPaths = tryGetModuleNameFromPaths(ts.removeFileExtension(subModuleName), removeExtensionAndIndexPostFix(subModuleName, 0 /* Minimal */, options), versionPaths.paths);
-                        if (fromPaths !== undefined) {
+                        var fromPaths = tryGetModuleNameFromPaths(subModuleName, versionPaths.paths, getAllowedEndings(preferences.ending, options, importMode), host, options);
+                        if (fromPaths === undefined) {
+                            maybeBlockedByTypesVersions = true;
+                        }
+                        else {
                             moduleFileToTry = ts.combinePaths(packageRootPath, fromPaths);
                         }
                     }
                     // If the file is the main module, it can be imported by the package name
                     var mainFileRelative = packageJsonContent.typings || packageJsonContent.types || packageJsonContent.main || "index.js";
-                    if (ts.isString(mainFileRelative)) {
+                    if (ts.isString(mainFileRelative) && !(maybeBlockedByTypesVersions && ts.matchPatternOrExact(ts.tryParsePatterns(versionPaths.paths), mainFileRelative))) {
+                        // The 'main' file is also subject to mapping through typesVersions, and we couldn't come up with a path
+                        // explicitly through typesVersions, so if it matches a key in typesVersions now, it's not reachable.
+                        // (The only way this can happen is if some file in a package that's not resolvable from outside the
+                        // package got pulled into the program anyway, e.g. transitively through a file that *is* reachable. It
+                        // happens very easily in fourslash tests though, since every test file listed gets included. See
+                        // importNameCodeFix_typesVersions.ts for an example.)
                         var mainExportFile = ts.toPath(mainFileRelative, packageRootPath, getCanonicalFileName);
                         if (ts.removeFileExtension(mainExportFile) === ts.removeFileExtension(getCanonicalFileName(moduleFileToTry))) {
+                            // ^ An arbitrary removal of file extension for this comparison is almost certainly wrong
                             return { packageRootPath: packageRootPath, moduleFileToTry: moduleFileToTry };
                         }
                     }