typescript 4.8.0-dev.20220802 → 4.8.0-dev.20220805

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.20220802";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220805";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8556,7 +8556,7 @@ var ts;
         File_is_CommonJS_module_because_0_does_not_have_field_type: diag(1460, ts.DiagnosticCategory.Message, "File_is_CommonJS_module_because_0_does_not_have_field_type_1460", "File is CommonJS module because '{0}' does not have field \"type\""),
         File_is_CommonJS_module_because_package_json_was_not_found: diag(1461, ts.DiagnosticCategory.Message, "File_is_CommonJS_module_because_package_json_was_not_found_1461", "File is CommonJS module because 'package.json' was not found"),
         The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output: diag(1470, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output_1470", "The 'import.meta' meta-property is not allowed in files which will build into CommonJS output."),
-        Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_synchronously_Use_dynamic_import_instead: diag(1471, ts.DiagnosticCategory.Error, "Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_c_1471", "Module '{0}' cannot be imported using this construct. The specifier only resolves to an ES module, which cannot be imported synchronously. Use dynamic import instead."),
+        Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_with_require_Use_an_ECMAScript_import_instead: diag(1471, ts.DiagnosticCategory.Error, "Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_c_1471", "Module '{0}' cannot be imported using this construct. The specifier only resolves to an ES module, which cannot be imported with 'require'. Use an ECMAScript import instead."),
         catch_or_finally_expected: diag(1472, ts.DiagnosticCategory.Error, "catch_or_finally_expected_1472", "'catch' or 'finally' expected."),
         An_import_declaration_can_only_be_used_at_the_top_level_of_a_module: diag(1473, ts.DiagnosticCategory.Error, "An_import_declaration_can_only_be_used_at_the_top_level_of_a_module_1473", "An import declaration can only be used at the top level of a module."),
         An_export_declaration_can_only_be_used_at_the_top_level_of_a_module: diag(1474, ts.DiagnosticCategory.Error, "An_export_declaration_can_only_be_used_at_the_top_level_of_a_module_1474", "An export declaration can only be used at the top level of a module."),
@@ -8564,6 +8564,11 @@ var ts;
         auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node16_as_modules: diag(1476, ts.DiagnosticCategory.Message, "auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_w_1476", "\"auto\": Treat files with imports, exports, import.meta, jsx (with jsx: react-jsx), or esm format (with module: node16+) as modules."),
         An_instantiation_expression_cannot_be_followed_by_a_property_access: diag(1477, ts.DiagnosticCategory.Error, "An_instantiation_expression_cannot_be_followed_by_a_property_access_1477", "An instantiation expression cannot be followed by a property access."),
         Identifier_or_string_literal_expected: diag(1478, ts.DiagnosticCategory.Error, "Identifier_or_string_literal_expected_1478", "Identifier or string literal expected."),
+        The_current_file_is_a_CommonJS_module_whose_imports_will_produce_require_calls_however_the_referenced_file_is_an_ECMAScript_module_and_cannot_be_imported_with_require_Consider_writing_a_dynamic_import_0_call_instead: diag(1479, ts.DiagnosticCategory.Error, "The_current_file_is_a_CommonJS_module_whose_imports_will_produce_require_calls_however_the_reference_1479", "The current file is a CommonJS module whose imports will produce 'require' calls; however, the referenced file is an ECMAScript module and cannot be imported with 'require'. Consider writing a dynamic 'import(\"{0}\")' call instead."),
+        To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_create_a_local_package_json_file_with_type_Colon_module: diag(1480, ts.DiagnosticCategory.Message, "To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_create_a_local_packag_1480", "To convert this file to an ECMAScript module, change its file extension to '{0}' or create a local package.json file with `{ \"type\": \"module\" }`."),
+        To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_add_the_field_type_Colon_module_to_1: diag(1481, ts.DiagnosticCategory.Message, "To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_add_the_field_type_Co_1481", "To convert this file to an ECMAScript module, change its file extension to '{0}', or add the field `\"type\": \"module\"` to '{1}'."),
+        To_convert_this_file_to_an_ECMAScript_module_add_the_field_type_Colon_module_to_0: diag(1482, ts.DiagnosticCategory.Message, "To_convert_this_file_to_an_ECMAScript_module_add_the_field_type_Colon_module_to_0_1482", "To convert this file to an ECMAScript module, add the field `\"type\": \"module\"` to '{0}'."),
+        To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module: diag(1483, ts.DiagnosticCategory.Message, "To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module_1483", "To convert this file to an ECMAScript module, create a local package.json file with `{ \"type\": \"module\" }`."),
         The_types_of_0_are_incompatible_between_these_types: diag(2200, ts.DiagnosticCategory.Error, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."),
         The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, ts.DiagnosticCategory.Error, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."),
         Call_signature_return_types_0_and_1_are_incompatible: diag(2202, ts.DiagnosticCategory.Error, "Call_signature_return_types_0_and_1_are_incompatible_2202", "Call signature return types '{0}' and '{1}' are incompatible.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
@@ -21858,7 +21863,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 +21872,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 +23280,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 +24081,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 +24111,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 +24137,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 +24165,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 +24189,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 +24222,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 +24277,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 +24715,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 +24751,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 +24770,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 +26974,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 +27003,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 };
         }
@@ -51672,7 +51678,40 @@ var ts;
                         // An override clause will take effect for type-only imports and import types, and allows importing the types across formats, regardless of
                         // normal mode restrictions
                         if (isSyncImport && sourceFile.impliedNodeFormat === ts.ModuleKind.ESNext && !ts.getResolutionModeOverrideForClause(overrideClause)) {
-                            error(errorNode, ts.Diagnostics.Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_synchronously_Use_dynamic_import_instead, moduleReference);
+                            if (ts.findAncestor(location, ts.isImportEqualsDeclaration)) {
+                                // ImportEquals in a ESM file resolving to another ESM file
+                                error(errorNode, ts.Diagnostics.Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_with_require_Use_an_ECMAScript_import_instead, moduleReference);
+                            }
+                            else {
+                                // CJS file resolving to an ESM file
+                                var diagnosticDetails = void 0;
+                                var ext = ts.tryGetExtensionFromPath(currentSourceFile.fileName);
+                                if (ext === ".ts" /* Ts */ || ext === ".js" /* Js */ || ext === ".tsx" /* Tsx */ || ext === ".jsx" /* Jsx */) {
+                                    var scope = currentSourceFile.packageJsonScope;
+                                    var targetExt = ext === ".ts" /* Ts */ ? ".mts" /* Mts */ : ext === ".js" /* Js */ ? ".mjs" /* Mjs */ : undefined;
+                                    if (scope && !scope.packageJsonContent.type) {
+                                        if (targetExt) {
+                                            diagnosticDetails = ts.chainDiagnosticMessages(
+                                            /*details*/ undefined, ts.Diagnostics.To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_add_the_field_type_Colon_module_to_1, targetExt, ts.combinePaths(scope.packageDirectory, "package.json"));
+                                        }
+                                        else {
+                                            diagnosticDetails = ts.chainDiagnosticMessages(
+                                            /*details*/ undefined, ts.Diagnostics.To_convert_this_file_to_an_ECMAScript_module_add_the_field_type_Colon_module_to_0, ts.combinePaths(scope.packageDirectory, "package.json"));
+                                        }
+                                    }
+                                    else {
+                                        if (targetExt) {
+                                            diagnosticDetails = ts.chainDiagnosticMessages(
+                                            /*details*/ undefined, ts.Diagnostics.To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_create_a_local_package_json_file_with_type_Colon_module, targetExt);
+                                        }
+                                        else {
+                                            diagnosticDetails = ts.chainDiagnosticMessages(
+                                            /*details*/ undefined, ts.Diagnostics.To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module);
+                                        }
+                                    }
+                                }
+                                diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(errorNode, ts.chainDiagnosticMessages(diagnosticDetails, ts.Diagnostics.The_current_file_is_a_CommonJS_module_whose_imports_will_produce_require_calls_however_the_referenced_file_is_an_ECMAScript_module_and_cannot_be_imported_with_require_Consider_writing_a_dynamic_import_0_call_instead, moduleReference)));
+                            }
                         }
                     }
                     // merged symbol is module declaration symbol combined with all augmentations
@@ -66178,6 +66217,26 @@ var ts;
             function structuredTypeRelatedTo(source, target, reportErrors, intersectionState) {
                 var saveErrorInfo = captureErrorCalculationState();
                 var result = structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState, saveErrorInfo);
+                if (!result && (source.flags & 2097152 /* Intersection */ || source.flags & 262144 /* TypeParameter */ && target.flags & 1048576 /* Union */)) {
+                    // The combined constraint of an intersection type is the intersection of the constraints of
+                    // the constituents. When an intersection type contains instantiable types with union type
+                    // constraints, there are situations where we need to examine the combined constraint. One is
+                    // when the target is a union type. Another is when the intersection contains types belonging
+                    // to one of the disjoint domains. For example, given type variables T and U, each with the
+                    // constraint 'string | number', the combined constraint of 'T & U' is 'string | number' and
+                    // we need to check this constraint against a union on the target side. Also, given a type
+                    // variable V constrained to 'string | number', 'V & number' has a combined constraint of
+                    // 'string & number | number & number' which reduces to just 'number'.
+                    // This also handles type parameters, as a type parameter with a union constraint compared against a union
+                    // needs to have its constraint hoisted into an intersection with said type parameter, this way
+                    // the type param can be compared with itself in the target (with the influence of its constraint to match other parts)
+                    // For example, if `T extends 1 | 2` and `U extends 2 | 3` and we compare `T & U` to `T & U & (1 | 2 | 3)`
+                    var constraint = getEffectiveConstraintOfIntersection(source.flags & 2097152 /* Intersection */ ? source.types : [source], !!(target.flags & 1048576 /* Union */));
+                    if (constraint && everyType(constraint, function (c) { return c !== source; })) { // Skip comparison if expansion contains the source itself
+                        // TODO: Stack errors so we get a pyramid for the "normal" comparison above, _and_ a second for this
+                        result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState);
+                    }
+                }
                 if (result) {
                     resetErrorInfo(saveErrorInfo);
                 }
@@ -66235,28 +66294,6 @@ var ts;
                     if (result = unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState)) {
                         return result;
                     }
-                    if (source.flags & 2097152 /* Intersection */ || source.flags & 262144 /* TypeParameter */ && target.flags & 1048576 /* Union */) {
-                        // The combined constraint of an intersection type is the intersection of the constraints of
-                        // the constituents. When an intersection type contains instantiable types with union type
-                        // constraints, there are situations where we need to examine the combined constraint. One is
-                        // when the target is a union type. Another is when the intersection contains types belonging
-                        // to one of the disjoint domains. For example, given type variables T and U, each with the
-                        // constraint 'string | number', the combined constraint of 'T & U' is 'string | number' and
-                        // we need to check this constraint against a union on the target side. Also, given a type
-                        // variable V constrained to 'string | number', 'V & number' has a combined constraint of
-                        // 'string & number | number & number' which reduces to just 'number'.
-                        // This also handles type parameters, as a type parameter with a union constraint compared against a union
-                        // needs to have its constraint hoisted into an intersection with said type parameter, this way
-                        // the type param can be compared with itself in the target (with the influence of its constraint to match other parts)
-                        // For example, if `T extends 1 | 2` and `U extends 2 | 3` and we compare `T & U` to `T & U & (1 | 2 | 3)`
-                        var constraint = getEffectiveConstraintOfIntersection(source.flags & 2097152 /* Intersection */ ? source.types : [source], !!(target.flags & 1048576 /* Union */));
-                        if (constraint && everyType(constraint, function (c) { return c !== source; })) { // Skip comparison if expansion contains the source itself
-                            // TODO: Stack errors so we get a pyramid for the "normal" comparison above, _and_ a second for this
-                            if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
-                                return result;
-                            }
-                        }
-                    }
                     // The ordered decomposition above doesn't handle all cases. Specifically, we also need to handle:
                     // Source is instantiable (e.g. source has union or intersection constraint).
                     // Source is an object, target is a union (e.g. { a, b: boolean } <=> { a, b: true } | { a, b: false }).
@@ -83991,17 +84028,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";
@@ -84009,19 +84057,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);
@@ -84049,47 +84105,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;
@@ -84110,7 +84181,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;
         }
         /**
@@ -84164,26 +84235,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.
@@ -84191,13 +84262,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;
         }
         /**
@@ -84235,7 +84322,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));
             }
@@ -84305,8 +84392,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") {
@@ -84326,9 +84413,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`
@@ -84340,8 +84433,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;
@@ -84381,7 +84474,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);
@@ -84402,13 +84501,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,
@@ -84429,7 +84528,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
@@ -122726,8 +122825,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;
@@ -123073,20 +123170,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,
@@ -123500,7 +123604,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 = {}; }
@@ -123583,7 +123687,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);
                     }
@@ -123611,7 +123715,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;
@@ -123625,9 +123729,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;
             }
@@ -123862,28 +123965,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) {
@@ -123979,10 +124156,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) {
@@ -124031,15 +124208,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;
@@ -124058,16 +124233,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 };
                         }
                     }