typescript 4.8.0-dev.20220801 → 4.8.0-dev.20220804

package/lib/tsserver.js

@@ -109,7 +109,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.20220801";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220804";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8571,6 +8571,10 @@ var ts;
         resolution_mode_is_the_only_valid_key_for_type_import_assertions: diag(1455, ts.DiagnosticCategory.Error, "resolution_mode_is_the_only_valid_key_for_type_import_assertions_1455", "`resolution-mode` is the only valid key for type import assertions."),
         Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require: diag(1456, ts.DiagnosticCategory.Error, "Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require_1456", "Type import assertions should have exactly one key - `resolution-mode` - with value `import` or `require`."),
         Matched_by_default_include_pattern_Asterisk_Asterisk_Slash_Asterisk: diag(1457, ts.DiagnosticCategory.Message, "Matched_by_default_include_pattern_Asterisk_Asterisk_Slash_Asterisk_1457", "Matched by default include pattern '**/*'"),
+        File_is_ECMAScript_module_because_0_has_field_type_with_value_module: diag(1458, ts.DiagnosticCategory.Message, "File_is_ECMAScript_module_because_0_has_field_type_with_value_module_1458", "File is ECMAScript module because '{0}' has field \"type\" with value \"module\""),
+        File_is_CommonJS_module_because_0_has_field_type_whose_value_is_not_module: diag(1459, ts.DiagnosticCategory.Message, "File_is_CommonJS_module_because_0_has_field_type_whose_value_is_not_module_1459", "File is CommonJS module because '{0}' has field \"type\" whose value is not \"module\""),
+        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."),
         catch_or_finally_expected: diag(1472, ts.DiagnosticCategory.Error, "catch_or_finally_expected_1472", "'catch' or 'finally' expected."),
@@ -21874,7 +21878,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:
             //
@@ -21883,7 +21887,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;
             }
@@ -23290,7 +23295,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 */ |
@@ -24091,7 +24096,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) |
@@ -24121,7 +24126,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 |=
@@ -24147,7 +24152,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) |
@@ -24175,7 +24180,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 |=
@@ -24199,7 +24204,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 |=
@@ -24232,7 +24237,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));
@@ -24287,7 +24292,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 |=
@@ -24725,7 +24730,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) |
@@ -24761,7 +24766,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 */;
@@ -24780,7 +24785,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 */;
@@ -26984,7 +26989,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)) {
@@ -27013,7 +27018,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 };
         }
@@ -43248,7 +43253,7 @@ var ts;
     ts.createCacheWithRedirects = createCacheWithRedirects;
     function createPackageJsonInfoCache(currentDirectory, getCanonicalFileName) {
         var cache;
-        return { getPackageJsonInfo: getPackageJsonInfo, setPackageJsonInfo: setPackageJsonInfo, clear: clear, entries: entries };
+        return { getPackageJsonInfo: getPackageJsonInfo, setPackageJsonInfo: setPackageJsonInfo, clear: clear, entries: entries, getInternalMap: getInternalMap };
         function getPackageJsonInfo(packageJsonPath) {
             return cache === null || cache === void 0 ? void 0 : cache.get(ts.toPath(packageJsonPath, currentDirectory, getCanonicalFileName));
         }
@@ -43262,6 +43267,9 @@ var ts;
             var iter = cache === null || cache === void 0 ? void 0 : cache.entries();
             return iter ? ts.arrayFrom(iter) : [];
         }
+        function getInternalMap() {
+            return cache;
+        }
     }
     function getOrCreateCache(cacheWithRedirects, redirectedReference, key, create) {
         var cache = cacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference);
@@ -43365,15 +43373,18 @@ var ts;
     }
     ts.zipToModeAwareCache = zipToModeAwareCache;
     function createModuleResolutionCache(currentDirectory, getCanonicalFileName, options, directoryToModuleNameMap, moduleNameToDirectoryMap) {
-        var preDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap || (directoryToModuleNameMap = createCacheWithRedirects(options)));
+        var perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap || (directoryToModuleNameMap = createCacheWithRedirects(options)));
         moduleNameToDirectoryMap || (moduleNameToDirectoryMap = createCacheWithRedirects(options));
         var packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName);
-        return __assign(__assign(__assign({}, packageJsonInfoCache), preDirectoryResolutionCache), { getOrCreateCacheForModuleName: getOrCreateCacheForModuleName, clear: clear, update: update, getPackageJsonInfoCache: function () { return packageJsonInfoCache; } });
+        return __assign(__assign(__assign({}, packageJsonInfoCache), perDirectoryResolutionCache), { getOrCreateCacheForModuleName: getOrCreateCacheForModuleName, clear: clear, update: update, getPackageJsonInfoCache: function () { return packageJsonInfoCache; }, clearAllExceptPackageJsonInfoCache: clearAllExceptPackageJsonInfoCache });
         function clear() {
-            preDirectoryResolutionCache.clear();
-            moduleNameToDirectoryMap.clear();
+            clearAllExceptPackageJsonInfoCache();
             packageJsonInfoCache.clear();
         }
+        function clearAllExceptPackageJsonInfoCache() {
+            perDirectoryResolutionCache.clear();
+            moduleNameToDirectoryMap.clear();
+        }
         function update(options) {
             updateRedirectsMap(options, directoryToModuleNameMap, moduleNameToDirectoryMap);
         }
@@ -43449,13 +43460,16 @@ var ts;
     }
     ts.createModuleResolutionCache = createModuleResolutionCache;
     function createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache, directoryToModuleNameMap) {
-        var preDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap || (directoryToModuleNameMap = createCacheWithRedirects(options)));
+        var perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap || (directoryToModuleNameMap = createCacheWithRedirects(options)));
         packageJsonInfoCache || (packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName));
-        return __assign(__assign(__assign({}, packageJsonInfoCache), preDirectoryResolutionCache), { clear: clear });
+        return __assign(__assign(__assign({}, packageJsonInfoCache), perDirectoryResolutionCache), { clear: clear, clearAllExceptPackageJsonInfoCache: clearAllExceptPackageJsonInfoCache });
         function clear() {
-            preDirectoryResolutionCache.clear();
+            clearAllExceptPackageJsonInfoCache();
             packageJsonInfoCache.clear();
         }
+        function clearAllExceptPackageJsonInfoCache() {
+            perDirectoryResolutionCache.clear();
+        }
     }
     ts.createTypeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache;
     function resolveModuleNameFromCache(moduleName, containingFile, cache, mode) {
@@ -51243,10 +51257,6 @@ var ts;
             checkExpressionCached(expression);
             return getNodeLinks(expression).resolvedSymbol;
         }
-        function getTargetOfPropertyAssignment(node, dontRecursivelyResolve) {
-            var expression = node.initializer;
-            return getTargetOfAliasLikeExpression(expression, dontRecursivelyResolve);
-        }
         function getTargetOfAccessExpression(node, dontRecursivelyResolve) {
             if (!(ts.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 63 /* EqualsToken */)) {
                 return undefined;
@@ -51278,7 +51288,7 @@ var ts;
                 case 297 /* ShorthandPropertyAssignment */:
                     return resolveEntityName(node.name, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */, /*ignoreErrors*/ true, dontRecursivelyResolve);
                 case 296 /* PropertyAssignment */:
-                    return getTargetOfPropertyAssignment(node, dontRecursivelyResolve);
+                    return getTargetOfAliasLikeExpression(node.initializer, dontRecursivelyResolve);
                 case 207 /* ElementAccessExpression */:
                 case 206 /* PropertyAccessExpression */:
                     return getTargetOfAccessExpression(node, dontRecursivelyResolve);
@@ -56803,7 +56813,7 @@ var ts;
                 (resolvedSymbol || symbol).exports.forEach(function (s, name) {
                     var _a;
                     var exportedMember = members_4.get(name);
-                    if (exportedMember && exportedMember !== s) {
+                    if (exportedMember && exportedMember !== s && !(s.flags & 2097152 /* Alias */)) {
                         if (s.flags & 111551 /* Value */ && exportedMember.flags & 111551 /* Value */) {
                             // If the member has an additional value-like declaration, union the types from the two declarations,
                             // but issue an error if they occurred in two different files. The purpose is to support a JS file with
@@ -63295,6 +63305,7 @@ var ts;
             }
         }
         function getTypeFromImportTypeNode(node) {
+            var _a;
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
                 if (node.isTypeOf && node.typeArguments) { // Only the non-typeof form can make use of type arguments
@@ -63314,6 +63325,7 @@ var ts;
                     links.resolvedSymbol = unknownSymbol;
                     return links.resolvedType = errorType;
                 }
+                var isExportEquals = !!((_a = innerModuleSymbol.exports) === null || _a === void 0 ? void 0 : _a.get("export=" /* ExportEquals */));
                 var moduleSymbol = resolveExternalModuleSymbol(innerModuleSymbol, /*dontResolveAlias*/ false);
                 if (!ts.nodeIsMissing(node.qualifier)) {
                     var nameStack = getIdentifierChain(node.qualifier);
@@ -63325,9 +63337,11 @@ var ts;
                         // That, in turn, ultimately uses `getPropertyOfType` on the type of the symbol, which differs slightly from
                         // the `exports` lookup process that only looks up namespace members which is used for most type references
                         var mergedResolvedSymbol = getMergedSymbol(resolveSymbol(currentNamespace));
-                        var next = node.isTypeOf
+                        var symbolFromVariable = node.isTypeOf || ts.isInJSFile(node) && isExportEquals
                             ? getPropertyOfType(getTypeOfSymbol(mergedResolvedSymbol), current.escapedText, /*skipObjectFunctionPropertyAugment*/ false, /*includeTypeOnlyMembers*/ true)
-                            : getSymbol(getExportsOfSymbol(mergedResolvedSymbol), current.escapedText, meaning);
+                            : undefined;
+                        var symbolFromModule = node.isTypeOf ? undefined : getSymbol(getExportsOfSymbol(mergedResolvedSymbol), current.escapedText, meaning);
+                        var next = symbolFromModule !== null && symbolFromModule !== void 0 ? symbolFromModule : symbolFromVariable;
                         if (!next) {
                             error(current, ts.Diagnostics.Namespace_0_has_no_exported_member_1, getFullyQualifiedName(currentNamespace), ts.declarationNameToString(current));
                             return links.resolvedType = errorType;
@@ -66185,6 +66199,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);
                 }
@@ -66242,28 +66276,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 }).
@@ -82117,9 +82129,11 @@ var ts;
             // We only need `Awaited<T>` if `T` contains possibly non-primitive types.
             if (isGenericObjectType(type)) {
                 var baseConstraint = getBaseConstraintOfType(type);
-                // We only need `Awaited<T>` if `T` has no base constraint, or the base constraint of `T` is `any`, `unknown`, `{}`, `object`,
+                // We only need `Awaited<T>` if `T` is a type variable that has no base constraint, or the base constraint of `T` is `any`, `unknown`, `{}`, `object`,
                 // or is promise-like.
-                if (!baseConstraint || (baseConstraint.flags & 3 /* AnyOrUnknown */) || isEmptyObjectType(baseConstraint) || isThenableType(baseConstraint)) {
+                if (baseConstraint ?
+                    baseConstraint.flags & 3 /* AnyOrUnknown */ || isEmptyObjectType(baseConstraint) || isThenableType(baseConstraint) :
+                    maybeTypeOfKind(type, 8650752 /* TypeVariable */)) {
                     return true;
                 }
             }
@@ -83996,17 +84010,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";
@@ -84014,19 +84039,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);
@@ -84054,47 +84087,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;
@@ -84115,7 +84163,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;
         }
         /**
@@ -84169,26 +84217,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.
@@ -84196,13 +84244,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;
         }
         /**
@@ -84240,7 +84304,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));
             }
@@ -84310,8 +84374,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") {
@@ -84331,9 +84395,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`
@@ -84345,8 +84415,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;
@@ -84386,7 +84456,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);
@@ -84407,13 +84483,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,
@@ -84434,7 +84510,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
@@ -94891,10 +94967,11 @@ var ts;
         }
         function visitPreOrPostfixUnaryExpression(node, valueIsDiscarded) {
             if (node.operator === 45 /* PlusPlusToken */ || node.operator === 46 /* MinusMinusToken */) {
-                if (shouldTransformPrivateElementsOrClassStaticBlocks && ts.isPrivateIdentifierPropertyAccessExpression(node.operand)) {
+                var operand = ts.skipParentheses(node.operand);
+                if (shouldTransformPrivateElementsOrClassStaticBlocks && ts.isPrivateIdentifierPropertyAccessExpression(operand)) {
                     var info = void 0;
-                    if (info = accessPrivateIdentifier(node.operand.name)) {
-                        var receiver = ts.visitNode(node.operand.expression, visitor, ts.isExpression);
+                    if (info = accessPrivateIdentifier(operand.name)) {
+                        var receiver = ts.visitNode(operand.expression, visitor, ts.isExpression);
                         var _a = createCopiableReceiverExpr(receiver), readExpression = _a.readExpression, initializeExpression = _a.initializeExpression;
                         var expression = createPrivateIdentifierAccess(info, readExpression);
                         var temp = ts.isPrefixUnaryExpression(node) || valueIsDiscarded ? undefined : factory.createTempVariable(hoistVariableDeclaration);
@@ -94910,7 +94987,7 @@ var ts;
                     }
                 }
                 else if (shouldTransformSuperInStaticInitializers &&
-                    ts.isSuperProperty(node.operand) &&
+                    ts.isSuperProperty(operand) &&
                     currentStaticPropertyDeclarationOrStaticBlock &&
                     currentClassLexicalEnvironment) {
                     // converts `++super.a` into `(Reflect.set(_baseTemp, "a", (_a = Reflect.get(_baseTemp, "a", _classTemp), _b = ++_a), _classTemp), _b)`
@@ -94923,31 +95000,31 @@ var ts;
                     // converts `super[f()]--` into `(Reflect.set(_baseTemp, _a = f(), (_b = Reflect.get(_baseTemp, _a, _classTemp), _c = _b--), _classTemp), _c)`
                     var classConstructor = currentClassLexicalEnvironment.classConstructor, superClassReference = currentClassLexicalEnvironment.superClassReference, facts = currentClassLexicalEnvironment.facts;
                     if (facts & 1 /* ClassWasDecorated */) {
-                        var operand = visitInvalidSuperProperty(node.operand);
+                        var expression = visitInvalidSuperProperty(operand);
                         return ts.isPrefixUnaryExpression(node) ?
-                            factory.updatePrefixUnaryExpression(node, operand) :
-                            factory.updatePostfixUnaryExpression(node, operand);
+                            factory.updatePrefixUnaryExpression(node, expression) :
+                            factory.updatePostfixUnaryExpression(node, expression);
                     }
                     if (classConstructor && superClassReference) {
                         var setterName = void 0;
                         var getterName = void 0;
-                        if (ts.isPropertyAccessExpression(node.operand)) {
-                            if (ts.isIdentifier(node.operand.name)) {
-                                getterName = setterName = factory.createStringLiteralFromNode(node.operand.name);
+                        if (ts.isPropertyAccessExpression(operand)) {
+                            if (ts.isIdentifier(operand.name)) {
+                                getterName = setterName = factory.createStringLiteralFromNode(operand.name);
                             }
                         }
                         else {
-                            if (ts.isSimpleInlineableExpression(node.operand.argumentExpression)) {
-                                getterName = setterName = node.operand.argumentExpression;
+                            if (ts.isSimpleInlineableExpression(operand.argumentExpression)) {
+                                getterName = setterName = operand.argumentExpression;
                             }
                             else {
                                 getterName = factory.createTempVariable(hoistVariableDeclaration);
-                                setterName = factory.createAssignment(getterName, ts.visitNode(node.operand.argumentExpression, visitor, ts.isExpression));
+                                setterName = factory.createAssignment(getterName, ts.visitNode(operand.argumentExpression, visitor, ts.isExpression));
                             }
                         }
                         if (setterName && getterName) {
                             var expression = factory.createReflectGetCall(superClassReference, getterName, classConstructor);
-                            ts.setTextRange(expression, node.operand);
+                            ts.setTextRange(expression, operand);
                             var temp = valueIsDiscarded ? undefined : factory.createTempVariable(hoistVariableDeclaration);
                             expression = ts.expandPreOrPostfixIncrementOrDecrementExpression(factory, node, expression, hoistVariableDeclaration, temp);
                             expression = factory.createReflectSetCall(superClassReference, setterName, expression, classConstructor);
@@ -117702,6 +117779,12 @@ var ts;
      * @returns `undefined` if the path has no relevant implied format, `ModuleKind.ESNext` for esm format, and `ModuleKind.CommonJS` for cjs format
      */
     function getImpliedNodeFormatForFile(fileName, packageJsonInfoCache, host, options) {
+        var result = getImpliedNodeFormatForFileWorker(fileName, packageJsonInfoCache, host, options);
+        return typeof result === "object" ? result.impliedNodeFormat : result;
+    }
+    ts.getImpliedNodeFormatForFile = getImpliedNodeFormatForFile;
+    /*@internal*/
+    function getImpliedNodeFormatForFileWorker(fileName, packageJsonInfoCache, host, options) {
         switch (ts.getEmitModuleResolutionKind(options)) {
             case ts.ModuleResolutionKind.Node16:
             case ts.ModuleResolutionKind.NodeNext:
@@ -117713,11 +117796,16 @@ var ts;
                 return undefined;
         }
         function lookupFromPackageJson() {
-            var scope = ts.getPackageScopeForPath(fileName, ts.getTemporaryModuleResolutionState(packageJsonInfoCache, host, options));
-            return (scope === null || scope === void 0 ? void 0 : scope.packageJsonContent.type) === "module" ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS;
+            var state = ts.getTemporaryModuleResolutionState(packageJsonInfoCache, host, options);
+            var packageJsonLocations = [];
+            state.failedLookupLocations = packageJsonLocations;
+            state.affectingLocations = packageJsonLocations;
+            var packageJsonScope = ts.getPackageScopeForPath(fileName, state);
+            var impliedNodeFormat = (packageJsonScope === null || packageJsonScope === void 0 ? void 0 : packageJsonScope.packageJsonContent.type) === "module" ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS;
+            return { impliedNodeFormat: impliedNodeFormat, packageJsonLocations: packageJsonLocations, packageJsonScope: packageJsonScope };
         }
     }
-    ts.getImpliedNodeFormatForFile = getImpliedNodeFormatForFile;
+    ts.getImpliedNodeFormatForFileWorker = getImpliedNodeFormatForFileWorker;
     /** @internal */
     ts.plainJSErrors = new ts.Set([
         // binder errors
@@ -118042,7 +118130,7 @@ var ts;
             for (var _i = 0, oldSourceFiles_1 = oldSourceFiles; _i < oldSourceFiles_1.length; _i++) {
                 var oldSourceFile = oldSourceFiles_1[_i];
                 var newFile = getSourceFileByPath(oldSourceFile.resolvedPath);
-                if (shouldCreateNewSourceFile || !newFile ||
+                if (shouldCreateNewSourceFile || !newFile || newFile.impliedNodeFormat !== oldSourceFile.impliedNodeFormat ||
                     // old file wasn't redirect but new file is
                     (oldSourceFile.resolvedPath === oldSourceFile.path && newFile.resolvedPath !== oldSourceFile.path)) {
                     host.onReleaseOldSourceFile(oldSourceFile, oldProgram.getCompilerOptions(), !!getSourceFileByPath(oldSourceFile.path));
@@ -118435,7 +118523,7 @@ var ts;
             });
         }
         function tryReuseStructureFromOldProgram() {
-            var _a;
+            var _a, _b;
             if (!oldProgram) {
                 return 0 /* Not */;
             }
@@ -118476,12 +118564,15 @@ var ts;
             var seenPackageNames = new ts.Map();
             for (var _i = 0, oldSourceFiles_2 = oldSourceFiles; _i < oldSourceFiles_2.length; _i++) {
                 var oldSourceFile = oldSourceFiles_2[_i];
+                var sourceFileOptions = getCreateSourceFileOptions(oldSourceFile.fileName, moduleResolutionCache, host, options);
                 var newSourceFile = host.getSourceFileByPath
-                    ? host.getSourceFileByPath(oldSourceFile.fileName, oldSourceFile.resolvedPath, getCreateSourceFileOptions(oldSourceFile.fileName, moduleResolutionCache, host, options), /*onError*/ undefined, shouldCreateNewSourceFile)
-                    : host.getSourceFile(oldSourceFile.fileName, getCreateSourceFileOptions(oldSourceFile.fileName, moduleResolutionCache, host, options), /*onError*/ undefined, shouldCreateNewSourceFile); // TODO: GH#18217
+                    ? host.getSourceFileByPath(oldSourceFile.fileName, oldSourceFile.resolvedPath, sourceFileOptions, /*onError*/ undefined, shouldCreateNewSourceFile || sourceFileOptions.impliedNodeFormat !== oldSourceFile.impliedNodeFormat)
+                    : host.getSourceFile(oldSourceFile.fileName, sourceFileOptions, /*onError*/ undefined, shouldCreateNewSourceFile || sourceFileOptions.impliedNodeFormat !== oldSourceFile.impliedNodeFormat); // TODO: GH#18217
                 if (!newSourceFile) {
                     return 0 /* Not */;
                 }
+                newSourceFile.packageJsonLocations = ((_a = sourceFileOptions.packageJsonLocations) === null || _a === void 0 ? void 0 : _a.length) ? sourceFileOptions.packageJsonLocations : undefined;
+                newSourceFile.packageJsonScope = sourceFileOptions.packageJsonScope;
                 ts.Debug.assert(!newSourceFile.redirectInfo, "Host should not return a redirect source file from `getSourceFile`");
                 var fileChanged = void 0;
                 if (oldSourceFile.redirectInfo) {
@@ -118521,38 +118612,43 @@ var ts;
                     seenPackageNames.set(packageName, newKind);
                 }
                 if (fileChanged) {
+                    if (oldSourceFile.impliedNodeFormat !== newSourceFile.impliedNodeFormat) {
+                        structureIsReused = 1 /* SafeModules */;
+                    }
                     // The `newSourceFile` object was created for the new program.
-                    if (!ts.arrayIsEqualTo(oldSourceFile.libReferenceDirectives, newSourceFile.libReferenceDirectives, fileReferenceIsEqualTo)) {
+                    else if (!ts.arrayIsEqualTo(oldSourceFile.libReferenceDirectives, newSourceFile.libReferenceDirectives, fileReferenceIsEqualTo)) {
                         // 'lib' references has changed. Matches behavior in changesAffectModuleResolution
                         structureIsReused = 1 /* SafeModules */;
                     }
-                    if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) {
+                    else if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) {
                         // value of no-default-lib has changed
                         // this will affect if default library is injected into the list of files
                         structureIsReused = 1 /* SafeModules */;
                     }
                     // check tripleslash references
-                    if (!ts.arrayIsEqualTo(oldSourceFile.referencedFiles, newSourceFile.referencedFiles, fileReferenceIsEqualTo)) {
+                    else if (!ts.arrayIsEqualTo(oldSourceFile.referencedFiles, newSourceFile.referencedFiles, fileReferenceIsEqualTo)) {
                         // tripleslash references has changed
                         structureIsReused = 1 /* SafeModules */;
                     }
-                    // check imports and module augmentations
-                    collectExternalModuleReferences(newSourceFile);
-                    if (!ts.arrayIsEqualTo(oldSourceFile.imports, newSourceFile.imports, moduleNameIsEqualTo)) {
-                        // imports has changed
-                        structureIsReused = 1 /* SafeModules */;
-                    }
-                    if (!ts.arrayIsEqualTo(oldSourceFile.moduleAugmentations, newSourceFile.moduleAugmentations, moduleNameIsEqualTo)) {
-                        // moduleAugmentations has changed
-                        structureIsReused = 1 /* SafeModules */;
-                    }
-                    if ((oldSourceFile.flags & 6291456 /* PermanentlySetIncrementalFlags */) !== (newSourceFile.flags & 6291456 /* PermanentlySetIncrementalFlags */)) {
-                        // dynamicImport has changed
-                        structureIsReused = 1 /* SafeModules */;
-                    }
-                    if (!ts.arrayIsEqualTo(oldSourceFile.typeReferenceDirectives, newSourceFile.typeReferenceDirectives, fileReferenceIsEqualTo)) {
-                        // 'types' references has changed
-                        structureIsReused = 1 /* SafeModules */;
+                    else {
+                        // check imports and module augmentations
+                        collectExternalModuleReferences(newSourceFile);
+                        if (!ts.arrayIsEqualTo(oldSourceFile.imports, newSourceFile.imports, moduleNameIsEqualTo)) {
+                            // imports has changed
+                            structureIsReused = 1 /* SafeModules */;
+                        }
+                        else if (!ts.arrayIsEqualTo(oldSourceFile.moduleAugmentations, newSourceFile.moduleAugmentations, moduleNameIsEqualTo)) {
+                            // moduleAugmentations has changed
+                            structureIsReused = 1 /* SafeModules */;
+                        }
+                        else if ((oldSourceFile.flags & 6291456 /* PermanentlySetIncrementalFlags */) !== (newSourceFile.flags & 6291456 /* PermanentlySetIncrementalFlags */)) {
+                            // dynamicImport has changed
+                            structureIsReused = 1 /* SafeModules */;
+                        }
+                        else if (!ts.arrayIsEqualTo(oldSourceFile.typeReferenceDirectives, newSourceFile.typeReferenceDirectives, fileReferenceIsEqualTo)) {
+                            // 'types' references has changed
+                            structureIsReused = 1 /* SafeModules */;
+                        }
                     }
                     // tentatively approve the file
                     modifiedSourceFiles.push({ oldFile: oldSourceFile, newFile: newSourceFile });
@@ -118570,18 +118666,18 @@ var ts;
                 return structureIsReused;
             }
             var modifiedFiles = modifiedSourceFiles.map(function (f) { return f.oldFile; });
-            for (var _b = 0, oldSourceFiles_3 = oldSourceFiles; _b < oldSourceFiles_3.length; _b++) {
-                var oldFile = oldSourceFiles_3[_b];
+            for (var _c = 0, oldSourceFiles_3 = oldSourceFiles; _c < oldSourceFiles_3.length; _c++) {
+                var oldFile = oldSourceFiles_3[_c];
                 if (!ts.contains(modifiedFiles, oldFile)) {
-                    for (var _c = 0, _d = oldFile.ambientModuleNames; _c < _d.length; _c++) {
-                        var moduleName = _d[_c];
+                    for (var _d = 0, _e = oldFile.ambientModuleNames; _d < _e.length; _d++) {
+                        var moduleName = _e[_d];
                         ambientModuleNameToUnmodifiedFileName.set(moduleName, oldFile.fileName);
                     }
                 }
             }
             // try to verify results of module resolution
-            for (var _e = 0, modifiedSourceFiles_1 = modifiedSourceFiles; _e < modifiedSourceFiles_1.length; _e++) {
-                var _f = modifiedSourceFiles_1[_e], oldSourceFile = _f.oldFile, newSourceFile = _f.newFile;
+            for (var _f = 0, modifiedSourceFiles_1 = modifiedSourceFiles; _f < modifiedSourceFiles_1.length; _f++) {
+                var _g = modifiedSourceFiles_1[_f], oldSourceFile = _g.oldFile, newSourceFile = _g.newFile;
                 var moduleNames = getModuleNames(newSourceFile);
                 var resolutions = resolveModuleNamesReusingOldState(moduleNames, newSourceFile);
                 // ensure that module resolution results are still correct
@@ -118608,14 +118704,14 @@ var ts;
             if (structureIsReused !== 2 /* Completely */) {
                 return structureIsReused;
             }
-            if (ts.changesAffectingProgramStructure(oldOptions, options) || ((_a = host.hasChangedAutomaticTypeDirectiveNames) === null || _a === void 0 ? void 0 : _a.call(host))) {
+            if (ts.changesAffectingProgramStructure(oldOptions, options) || ((_b = host.hasChangedAutomaticTypeDirectiveNames) === null || _b === void 0 ? void 0 : _b.call(host))) {
                 return 1 /* SafeModules */;
             }
             missingFilePaths = oldProgram.getMissingFilePaths();
             // update fileName -> file mapping
             ts.Debug.assert(newSourceFiles.length === oldProgram.getSourceFiles().length);
-            for (var _g = 0, newSourceFiles_1 = newSourceFiles; _g < newSourceFiles_1.length; _g++) {
-                var newSourceFile = newSourceFiles_1[_g];
+            for (var _h = 0, newSourceFiles_1 = newSourceFiles; _h < newSourceFiles_1.length; _h++) {
+                var newSourceFile = newSourceFiles_1[_h];
                 filesByName.set(newSourceFile.path, newSourceFile);
             }
             var oldFilesByNameMap = oldProgram.getFilesByNameMap();
@@ -119398,13 +119494,16 @@ var ts;
                 addFilePreprocessingFileExplainingDiagnostic(existingFile, reason, ts.Diagnostics.File_name_0_differs_from_already_included_file_name_1_only_in_casing, [fileName, existingFile.fileName]);
             }
         }
-        function createRedirectSourceFile(redirectTarget, unredirected, fileName, path, resolvedPath, originalFileName) {
+        function createRedirectSourceFile(redirectTarget, unredirected, fileName, path, resolvedPath, originalFileName, sourceFileOptions) {
+            var _a;
             var redirect = Object.create(redirectTarget);
             redirect.fileName = fileName;
             redirect.path = path;
             redirect.resolvedPath = resolvedPath;
             redirect.originalFileName = originalFileName;
             redirect.redirectInfo = { redirectTarget: redirectTarget, unredirected: unredirected };
+            redirect.packageJsonLocations = ((_a = sourceFileOptions.packageJsonLocations) === null || _a === void 0 ? void 0 : _a.length) ? sourceFileOptions.packageJsonLocations : undefined;
+            redirect.packageJsonScope = sourceFileOptions.packageJsonScope;
             sourceFilesFoundSearchingNodeModules.set(path, currentNodeModulesDepth > 0);
             Object.defineProperties(redirect, {
                 id: {
@@ -119433,14 +119532,14 @@ var ts;
             // It's a _little odd_ that we can't set `impliedNodeFormat` until the program step - but it's the first and only time we have a resolution cache
             // and a freshly made source file node on hand at the same time, and we need both to set the field. Persisting the resolution cache all the way
             // to the check and emit steps would be bad - so we much prefer detecting and storing the format information on the source file node upfront.
-            var impliedNodeFormat = getImpliedNodeFormatForFile(toPath(fileName), moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.getPackageJsonInfoCache(), host, options);
-            return {
-                languageVersion: ts.getEmitScriptTarget(options),
-                impliedNodeFormat: impliedNodeFormat,
-                setExternalModuleIndicator: ts.getSetExternalModuleIndicator(options)
-            };
+            var result = getImpliedNodeFormatForFileWorker(toPath(fileName), moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.getPackageJsonInfoCache(), host, options);
+            var languageVersion = ts.getEmitScriptTarget(options);
+            var setExternalModuleIndicator = ts.getSetExternalModuleIndicator(options);
+            return typeof result === "object" ? __assign(__assign({}, result), { languageVersion: languageVersion, setExternalModuleIndicator: setExternalModuleIndicator }) :
+                { languageVersion: languageVersion, impliedNodeFormat: result, setExternalModuleIndicator: setExternalModuleIndicator };
         }
         function findSourceFileWorker(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId) {
+            var _a, _b;
             var path = toPath(fileName);
             if (useSourceOfProjectReferenceRedirect) {
                 var source = getSourceOfProjectReferenceRedirect(path);
@@ -119527,14 +119626,15 @@ var ts;
                 }
             }
             // We haven't looked for this file, do so now and cache result
-            var file = host.getSourceFile(fileName, getCreateSourceFileOptions(fileName, moduleResolutionCache, host, options), function (hostErrorMessage) { return addFilePreprocessingFileExplainingDiagnostic(/*file*/ undefined, reason, ts.Diagnostics.Cannot_read_file_0_Colon_1, [fileName, hostErrorMessage]); }, shouldCreateNewSourceFile);
+            var sourceFileOptions = getCreateSourceFileOptions(fileName, moduleResolutionCache, host, options);
+            var file = host.getSourceFile(fileName, sourceFileOptions, function (hostErrorMessage) { return addFilePreprocessingFileExplainingDiagnostic(/*file*/ undefined, reason, ts.Diagnostics.Cannot_read_file_0_Colon_1, [fileName, hostErrorMessage]); }, shouldCreateNewSourceFile || (((_a = oldProgram === null || oldProgram === void 0 ? void 0 : oldProgram.getSourceFileByPath(toPath(fileName))) === null || _a === void 0 ? void 0 : _a.impliedNodeFormat) !== sourceFileOptions.impliedNodeFormat));
             if (packageId) {
                 var packageIdKey = ts.packageIdToString(packageId);
                 var fileFromPackageId = packageIdToSourceFile.get(packageIdKey);
                 if (fileFromPackageId) {
                     // Some other SourceFile already exists with this package name and version.
                     // Instead of creating a duplicate, just redirect to the existing one.
-                    var dupFile = createRedirectSourceFile(fileFromPackageId, file, fileName, path, toPath(fileName), originalFileName); // TODO: GH#18217
+                    var dupFile = createRedirectSourceFile(fileFromPackageId, file, fileName, path, toPath(fileName), originalFileName, sourceFileOptions);
                     redirectTargetsMap.add(fileFromPackageId.path, fileName);
                     addFileToFilesByName(dupFile, path, redirectedPath);
                     addFileIncludeReason(dupFile, reason);
@@ -119555,6 +119655,8 @@ var ts;
                 file.path = path;
                 file.resolvedPath = toPath(fileName);
                 file.originalFileName = originalFileName;
+                file.packageJsonLocations = ((_b = sourceFileOptions.packageJsonLocations) === null || _b === void 0 ? void 0 : _b.length) ? sourceFileOptions.packageJsonLocations : undefined;
+                file.packageJsonScope = sourceFileOptions.packageJsonScope;
                 addFileIncludeReason(file, reason);
                 if (host.useCaseSensitiveFileNames()) {
                     var pathLowerCase = ts.toFileNameLowerCase(path);
@@ -120185,7 +120287,7 @@ var ts;
                 fileIncludeReasons = undefined;
             var location = locationReason && getReferencedFileLocation(getSourceFileByPath, locationReason);
             var fileIncludeReasonDetails = fileIncludeReasons && ts.chainDiagnosticMessages(fileIncludeReasons, ts.Diagnostics.The_file_is_in_the_program_because_Colon);
-            var redirectInfo = file && ts.explainIfFileIsRedirect(file);
+            var redirectInfo = file && ts.explainIfFileIsRedirectAndImpliedFormat(file);
             var chain = ts.chainDiagnosticMessages.apply(void 0, __spreadArray([redirectInfo ? fileIncludeReasonDetails ? __spreadArray([fileIncludeReasonDetails], redirectInfo, true) : redirectInfo : fileIncludeReasonDetails, diagnostic], args || ts.emptyArray, false));
             return location && isReferenceFileLocation(location) ?
                 ts.createFileDiagnosticFromMessageChain(location.file, location.pos, location.end - location.pos, chain, relatedInfo) :
@@ -122490,7 +122592,7 @@ var ts;
      * "c:/", "c:/users", "c:/users/username", "c:/users/username/folderAtRoot", "c:/folderAtRoot"
      * @param dirPath
      */
-    function canWatchDirectory(dirPath) {
+    function canWatchDirectoryOrFile(dirPath) {
         var rootLength = ts.getRootLength(dirPath);
         if (dirPath.length === rootLength) {
             // Ignore "/", "c:/"
@@ -122527,7 +122629,7 @@ var ts;
         }
         return true;
     }
-    ts.canWatchDirectory = canWatchDirectory;
+    ts.canWatchDirectoryOrFile = canWatchDirectoryOrFile;
     function createResolutionCache(resolutionHost, rootDirForResolution, logChangesWhenResolvingModule) {
         var filesWithChangedSetOfUnresolvedImports;
         var filesWithInvalidatedResolutions;
@@ -122536,7 +122638,9 @@ var ts;
         var resolutionsWithFailedLookups = [];
         var resolutionsWithOnlyAffectingLocations = [];
         var resolvedFileToResolution = ts.createMultiMap();
+        var impliedFormatPackageJsons = new ts.Map();
         var hasChangedAutomaticTypeDirectiveNames = false;
+        var affectingPathChecksForFile;
         var affectingPathChecks;
         var failedLookupChecks;
         var startsWithPathChecks;
@@ -122576,7 +122680,7 @@ var ts;
             finishRecordingFilesWithChangedResolutions: finishRecordingFilesWithChangedResolutions,
             // perDirectoryResolvedModuleNames and perDirectoryResolvedTypeReferenceDirectives could be non empty if there was exception during program update
             // (between startCachingPerDirectoryResolution and finishCachingPerDirectoryResolution)
-            startCachingPerDirectoryResolution: clearPerDirectoryResolutions,
+            startCachingPerDirectoryResolution: startCachingPerDirectoryResolution,
             finishCachingPerDirectoryResolution: finishCachingPerDirectoryResolution,
             resolveModuleNames: resolveModuleNames,
             getResolvedModuleWithFailedLookupLocationsFromCache: getResolvedModuleWithFailedLookupLocationsFromCache,
@@ -122620,9 +122724,10 @@ var ts;
             startsWithPathChecks = undefined;
             isInDirectoryChecks = undefined;
             affectingPathChecks = undefined;
-            // perDirectoryResolvedModuleNames and perDirectoryResolvedTypeReferenceDirectives could be non empty if there was exception during program update
-            // (between startCachingPerDirectoryResolution and finishCachingPerDirectoryResolution)
-            clearPerDirectoryResolutions();
+            affectingPathChecksForFile = undefined;
+            moduleResolutionCache.clear();
+            typeReferenceDirectiveResolutionCache.clear();
+            impliedFormatPackageJsons.clear();
             hasChangedAutomaticTypeDirectiveNames = false;
         }
         function startRecordingFilesWithChangedResolutions() {
@@ -122654,15 +122759,44 @@ var ts;
             return function (path) { return (!!collected && collected.has(path)) ||
                 isFileWithInvalidatedNonRelativeUnresolvedImports(path); };
         }
-        function clearPerDirectoryResolutions() {
-            moduleResolutionCache.clear();
-            typeReferenceDirectiveResolutionCache.clear();
+        function startCachingPerDirectoryResolution() {
+            moduleResolutionCache.clearAllExceptPackageJsonInfoCache();
+            typeReferenceDirectiveResolutionCache.clearAllExceptPackageJsonInfoCache();
+            // perDirectoryResolvedModuleNames and perDirectoryResolvedTypeReferenceDirectives could be non empty if there was exception during program update
+            // (between startCachingPerDirectoryResolution and finishCachingPerDirectoryResolution)
             nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);
             nonRelativeExternalModuleResolutions.clear();
         }
-        function finishCachingPerDirectoryResolution() {
+        function finishCachingPerDirectoryResolution(newProgram, oldProgram) {
             filesWithInvalidatedNonRelativeUnresolvedImports = undefined;
-            clearPerDirectoryResolutions();
+            nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);
+            nonRelativeExternalModuleResolutions.clear();
+            // Update file watches
+            if (newProgram !== oldProgram) {
+                newProgram === null || newProgram === void 0 ? void 0 : newProgram.getSourceFiles().forEach(function (newFile) {
+                    var _a, _b, _c;
+                    var expected = ts.isExternalOrCommonJsModule(newFile) ? (_b = (_a = newFile.packageJsonLocations) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0 : 0;
+                    var existing = (_c = impliedFormatPackageJsons.get(newFile.path)) !== null && _c !== void 0 ? _c : ts.emptyArray;
+                    for (var i = existing.length; i < expected; i++) {
+                        createFileWatcherOfAffectingLocation(newFile.packageJsonLocations[i], /*forResolution*/ false);
+                    }
+                    if (existing.length > expected) {
+                        for (var i = expected; i < existing.length; i++) {
+                            fileWatchesOfAffectingLocations.get(existing[i]).files--;
+                        }
+                    }
+                    if (expected)
+                        impliedFormatPackageJsons.set(newFile.path, newFile.packageJsonLocations);
+                    else
+                        impliedFormatPackageJsons.delete(newFile.path);
+                });
+                impliedFormatPackageJsons.forEach(function (existing, path) {
+                    if (!(newProgram === null || newProgram === void 0 ? void 0 : newProgram.getSourceFileByPath(path))) {
+                        existing.forEach(function (location) { return fileWatchesOfAffectingLocations.get(location).files--; });
+                        impliedFormatPackageJsons.delete(path);
+                    }
+                });
+            }
             directoryWatchesOfFailedLookups.forEach(function (watcher, path) {
                 if (watcher.refCount === 0) {
                     directoryWatchesOfFailedLookups.delete(path);
@@ -122670,11 +122804,9 @@ var ts;
                 }
             });
             fileWatchesOfAffectingLocations.forEach(function (watcher, path) {
-                if (watcher.refCount === 0) {
+                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;
@@ -122901,7 +123033,7 @@ var ts;
             }
             // If the directory is node_modules use it to watch, always watch it recursively
             if (ts.isNodeModulesDirectory(dirPath)) {
-                return canWatchDirectory(ts.getDirectoryPath(dirPath)) ? { dir: dir, dirPath: dirPath } : undefined;
+                return canWatchDirectoryOrFile(ts.getDirectoryPath(dirPath)) ? { dir: dir, dirPath: dirPath } : undefined;
             }
             var nonRecursive = true;
             // Use some ancestor of the root directory
@@ -122919,7 +123051,7 @@ var ts;
                     dir = ts.getDirectoryPath(dir);
                 }
             }
-            return canWatchDirectory(dirPath) ? { dir: subDirectory || dir, dirPath: subDirectoryPath || dirPath, nonRecursive: nonRecursive } : undefined;
+            return canWatchDirectoryOrFile(dirPath) ? { dir: subDirectory || dir, dirPath: subDirectoryPath || dirPath, nonRecursive: nonRecursive } : undefined;
         }
         function isPathWithDefaultFailedLookupExtension(path) {
             return ts.fileExtensionIsOneOf(path, failedLookupDefaultExtensions);
@@ -122990,46 +123122,65 @@ var ts;
             // Watch package json
             for (var _i = 0, affectingLocations_1 = affectingLocations; _i < affectingLocations_1.length; _i++) {
                 var affectingLocation = affectingLocations_1[_i];
-                createFileWatcherOfAffectingLocation(affectingLocation);
+                createFileWatcherOfAffectingLocation(affectingLocation, /*forResolution*/ true);
             }
         }
-        function createFileWatcherOfAffectingLocation(affectingLocation) {
-            var path = resolutionHost.toPath(affectingLocation);
-            var fileWatcher = fileWatchesOfAffectingLocations.get(path);
+        function createFileWatcherOfAffectingLocation(affectingLocation, forResolution) {
+            var fileWatcher = fileWatchesOfAffectingLocations.get(affectingLocation);
             if (fileWatcher) {
-                fileWatcher.refCount++;
+                if (forResolution)
+                    fileWatcher.resolutions++;
+                else
+                    fileWatcher.files++;
                 return;
             }
             var locationToWatch = affectingLocation;
-            var locationToWatchPath = path;
             if (resolutionHost.realpath) {
                 locationToWatch = resolutionHost.realpath(affectingLocation);
-                locationToWatchPath = resolutionHost.toPath(locationToWatch);
-                if (path !== locationToWatchPath) {
-                    var fileWatcher_1 = fileWatchesOfAffectingLocations.get(locationToWatchPath);
+                if (affectingLocation !== locationToWatch) {
+                    var fileWatcher_1 = fileWatchesOfAffectingLocations.get(locationToWatch);
                     if (fileWatcher_1) {
-                        fileWatcher_1.refCount++;
-                        fileWatcher_1.paths.add(path);
-                        fileWatchesOfAffectingLocations.set(path, fileWatcher_1);
+                        if (forResolution)
+                            fileWatcher_1.resolutions++;
+                        else
+                            fileWatcher_1.files++;
+                        fileWatcher_1.paths.add(affectingLocation);
+                        fileWatchesOfAffectingLocations.set(affectingLocation, fileWatcher_1);
                         return;
                     }
                 }
             }
             var paths = new ts.Set();
-            paths.add(locationToWatchPath);
-            var watcher = {
-                watcher: resolutionHost.watchAffectingFileLocation(locationToWatch, function (fileName, eventKind) {
-                    cachedDirectoryStructureHost === null || cachedDirectoryStructureHost === void 0 ? void 0 : cachedDirectoryStructureHost.addOrDeleteFile(fileName, path, eventKind);
-                    paths.forEach(function (path) { return (affectingPathChecks || (affectingPathChecks = new ts.Set())).add(path); });
+            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();
-                }),
-                refCount: 1,
+                }) : ts.noopFileWatcher;
+            var watcher = {
+                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,
             };
-            fileWatchesOfAffectingLocations.set(locationToWatchPath, watcher);
-            if (path !== locationToWatchPath) {
-                fileWatchesOfAffectingLocations.set(path, watcher);
-                paths.add(path);
+            fileWatchesOfAffectingLocations.set(locationToWatch, watcher);
+            if (affectingLocation !== locationToWatch) {
+                fileWatchesOfAffectingLocations.set(affectingLocation, watcher);
+                paths.add(affectingLocation);
             }
         }
         function watchFailedLookupLocationOfNonRelativeModuleResolutions(resolutions, name) {
@@ -123097,8 +123248,8 @@ var ts;
             }
             for (var _a = 0, affectingLocations_2 = affectingLocations; _a < affectingLocations_2.length; _a++) {
                 var affectingLocation = affectingLocations_2[_a];
-                var watcher = fileWatchesOfAffectingLocations.get(resolutionHost.toPath(affectingLocation));
-                watcher.refCount--;
+                var watcher = fileWatchesOfAffectingLocations.get(affectingLocation);
+                watcher.resolutions--;
             }
         }
         function removeDirectoryWatcher(dirPath) {
@@ -123152,7 +123303,7 @@ var ts;
                 resolution.isInvalidated = invalidated = true;
                 for (var _a = 0, _b = ts.Debug.checkDefined(resolution.files); _a < _b.length; _a++) {
                     var containingFilePath = _b[_a];
-                    (filesWithInvalidatedResolutions || (filesWithInvalidatedResolutions = new ts.Set())).add(containingFilePath);
+                    (filesWithInvalidatedResolutions !== null && filesWithInvalidatedResolutions !== void 0 ? filesWithInvalidatedResolutions : (filesWithInvalidatedResolutions = new ts.Set())).add(containingFilePath);
                     // When its a file with inferred types resolution, invalidate type reference directive resolution
                     hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames || ts.endsWith(containingFilePath, ts.inferredTypesContainingFile);
                 }
@@ -123219,10 +123370,25 @@ var ts;
             resolutionHost.scheduleInvalidateResolutionsOfFailedLookupLocations();
         }
         function invalidateResolutionsOfFailedLookupLocations() {
+            var _a;
+            var invalidated = false;
+            if (affectingPathChecksForFile) {
+                (_a = resolutionHost.getCurrentProgram()) === null || _a === void 0 ? void 0 : _a.getSourceFiles().forEach(function (f) {
+                    if (ts.some(f.packageJsonLocations, function (location) { return affectingPathChecksForFile.has(location); })) {
+                        (filesWithInvalidatedResolutions !== null && filesWithInvalidatedResolutions !== void 0 ? filesWithInvalidatedResolutions : (filesWithInvalidatedResolutions = new ts.Set())).add(f.path);
+                        invalidated = true;
+                    }
+                });
+                affectingPathChecksForFile = undefined;
+            }
             if (!failedLookupChecks && !startsWithPathChecks && !isInDirectoryChecks && !affectingPathChecks) {
-                return false;
+                return invalidated;
+            }
+            invalidated = invalidateResolutions(resolutionsWithFailedLookups, canInvalidateFailedLookupResolution) || invalidated;
+            var packageJsonMap = moduleResolutionCache.getPackageJsonInfoCache().getInternalMap();
+            if (packageJsonMap && (failedLookupChecks || startsWithPathChecks || isInDirectoryChecks)) {
+                packageJsonMap.forEach(function (_value, path) { return isInvalidatedFailedLookup(path) ? packageJsonMap.delete(path) : undefined; });
             }
-            var invalidated = invalidateResolutions(resolutionsWithFailedLookups, canInvalidateFailedLookupResolution);
             failedLookupChecks = undefined;
             startsWithPathChecks = undefined;
             isInDirectoryChecks = undefined;
@@ -123235,17 +123401,15 @@ var ts;
                 return true;
             if (!failedLookupChecks && !startsWithPathChecks && !isInDirectoryChecks)
                 return false;
-            return resolution.failedLookupLocations.some(function (location) {
-                var locationPath = resolutionHost.toPath(location);
-                return (failedLookupChecks === null || failedLookupChecks === void 0 ? void 0 : failedLookupChecks.has(locationPath)) ||
-                    ts.firstDefinedIterator((startsWithPathChecks === null || startsWithPathChecks === void 0 ? void 0 : startsWithPathChecks.keys()) || ts.emptyIterator, function (fileOrDirectoryPath) { return ts.startsWith(locationPath, fileOrDirectoryPath) ? true : undefined; }) ||
-                    ts.firstDefinedIterator((isInDirectoryChecks === null || isInDirectoryChecks === void 0 ? void 0 : isInDirectoryChecks.keys()) || ts.emptyIterator, function (fileOrDirectoryPath) { return isInDirectoryPath(fileOrDirectoryPath, locationPath) ? true : undefined; });
-            });
+            return resolution.failedLookupLocations.some(function (location) { return isInvalidatedFailedLookup(resolutionHost.toPath(location)); });
+        }
+        function isInvalidatedFailedLookup(locationPath) {
+            return (failedLookupChecks === null || failedLookupChecks === void 0 ? void 0 : failedLookupChecks.has(locationPath)) ||
+                ts.firstDefinedIterator((startsWithPathChecks === null || startsWithPathChecks === void 0 ? void 0 : startsWithPathChecks.keys()) || ts.emptyIterator, function (fileOrDirectoryPath) { return ts.startsWith(locationPath, fileOrDirectoryPath) ? true : undefined; }) ||
+                ts.firstDefinedIterator((isInDirectoryChecks === null || isInDirectoryChecks === void 0 ? void 0 : isInDirectoryChecks.keys()) || ts.emptyIterator, function (fileOrDirectoryPath) { return isInDirectoryPath(fileOrDirectoryPath, locationPath) ? true : undefined; });
         }
         function canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution) {
-            return !!affectingPathChecks && resolution.affectingLocations.some(function (location) {
-                return affectingPathChecks.has(resolutionHost.toPath(location));
-            });
+            return !!affectingPathChecks && resolution.affectingLocations.some(function (location) { return affectingPathChecks.has(location); });
         }
         function closeTypeRootsWatch() {
             ts.clearMap(typeRootsWatches, ts.closeFileWatcher);
@@ -123311,7 +123475,7 @@ var ts;
         function directoryExistsForTypeRootWatch(nodeTypesDirectory) {
             var dir = ts.getDirectoryPath(ts.getDirectoryPath(nodeTypesDirectory));
             var dirPath = resolutionHost.toPath(dir);
-            return dirPath === rootPath || canWatchDirectory(dirPath);
+            return dirPath === rootPath || canWatchDirectoryOrFile(dirPath);
         }
     }
     ts.createResolutionCache = createResolutionCache;
@@ -123422,7 +123586,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 = {}; }
@@ -123505,7 +123669,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);
                     }
@@ -123533,7 +123697,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;
@@ -123547,9 +123711,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;
             }
@@ -123784,28 +123947,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) {
@@ -123901,10 +124138,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) {
@@ -123953,15 +124190,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;
@@ -123980,16 +124215,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 };
                         }
                     }
@@ -124284,23 +124529,46 @@ var ts;
             var file = _c[_i];
             write("" + toFileName(file, relativeFileName));
             (_a = reasons.get(file.path)) === null || _a === void 0 ? void 0 : _a.forEach(function (reason) { return write("  " + fileIncludeReasonToDiagnostics(program, reason, relativeFileName).messageText); });
-            (_b = explainIfFileIsRedirect(file, relativeFileName)) === null || _b === void 0 ? void 0 : _b.forEach(function (d) { return write("  " + d.messageText); });
+            (_b = explainIfFileIsRedirectAndImpliedFormat(file, relativeFileName)) === null || _b === void 0 ? void 0 : _b.forEach(function (d) { return write("  " + d.messageText); });
         }
     }
     ts.explainFiles = explainFiles;
-    function explainIfFileIsRedirect(file, fileNameConvertor) {
+    function explainIfFileIsRedirectAndImpliedFormat(file, fileNameConvertor) {
+        var _a;
         var result;
         if (file.path !== file.resolvedPath) {
-            (result || (result = [])).push(ts.chainDiagnosticMessages(
+            (result !== null && result !== void 0 ? result : (result = [])).push(ts.chainDiagnosticMessages(
             /*details*/ undefined, ts.Diagnostics.File_is_output_of_project_reference_source_0, toFileName(file.originalFileName, fileNameConvertor)));
         }
         if (file.redirectInfo) {
-            (result || (result = [])).push(ts.chainDiagnosticMessages(
+            (result !== null && result !== void 0 ? result : (result = [])).push(ts.chainDiagnosticMessages(
             /*details*/ undefined, ts.Diagnostics.File_redirects_to_file_0, toFileName(file.redirectInfo.redirectTarget, fileNameConvertor)));
         }
+        if (ts.isExternalOrCommonJsModule(file)) {
+            switch (file.impliedNodeFormat) {
+                case ts.ModuleKind.ESNext:
+                    if (file.packageJsonScope) {
+                        (result !== null && result !== void 0 ? result : (result = [])).push(ts.chainDiagnosticMessages(
+                        /*details*/ undefined, ts.Diagnostics.File_is_ECMAScript_module_because_0_has_field_type_with_value_module, toFileName(ts.last(file.packageJsonLocations), fileNameConvertor)));
+                    }
+                    break;
+                case ts.ModuleKind.CommonJS:
+                    if (file.packageJsonScope) {
+                        (result !== null && result !== void 0 ? result : (result = [])).push(ts.chainDiagnosticMessages(
+                        /*details*/ undefined, file.packageJsonScope.packageJsonContent.type ?
+                            ts.Diagnostics.File_is_CommonJS_module_because_0_has_field_type_whose_value_is_not_module :
+                            ts.Diagnostics.File_is_CommonJS_module_because_0_does_not_have_field_type, toFileName(ts.last(file.packageJsonLocations), fileNameConvertor)));
+                    }
+                    else if ((_a = file.packageJsonLocations) === null || _a === void 0 ? void 0 : _a.length) {
+                        (result !== null && result !== void 0 ? result : (result = [])).push(ts.chainDiagnosticMessages(
+                        /*details*/ undefined, ts.Diagnostics.File_is_CommonJS_module_because_package_json_was_not_found));
+                    }
+                    break;
+            }
+        }
         return result;
     }
-    ts.explainIfFileIsRedirect = explainIfFileIsRedirect;
+    ts.explainIfFileIsRedirectAndImpliedFormat = explainIfFileIsRedirectAndImpliedFormat;
     function getMatchedFileSpec(program, fileName) {
         var _a;
         var configFile = program.getCompilerOptions().configFile;
@@ -124510,6 +124778,7 @@ var ts;
         MissingFile: "Missing file",
         WildcardDirectory: "Wild card directory",
         FailedLookupLocations: "Failed Lookup Locations",
+        AffectingFileLocation: "File location affecting resolution",
         TypeRoots: "Type roots",
         ConfigFileOfReferencedProject: "Config file of referened project",
         ExtendedConfigOfReferencedProject: "Extended config file of referenced project",
@@ -124833,7 +125102,7 @@ var ts;
         compilerHost.getCompilationSettings = function () { return compilerOptions; };
         compilerHost.useSourceOfProjectReferenceRedirect = ts.maybeBind(host, host.useSourceOfProjectReferenceRedirect);
         compilerHost.watchDirectoryOfFailedLookupLocation = function (dir, cb, flags) { return watchDirectory(dir, cb, flags, watchOptions, ts.WatchType.FailedLookupLocations); };
-        compilerHost.watchAffectingFileLocation = function (file, cb) { return watchFile(file, cb, ts.PollingInterval.High, watchOptions, ts.WatchType.PackageJson); };
+        compilerHost.watchAffectingFileLocation = function (file, cb) { return watchFile(file, cb, ts.PollingInterval.High, watchOptions, ts.WatchType.AffectingFileLocation); };
         compilerHost.watchTypeRootsDirectory = function (dir, cb, flags) { return watchDirectory(dir, cb, flags, watchOptions, ts.WatchType.TypeRoots); };
         compilerHost.getCachedDirectoryStructureHost = function () { return cachedDirectoryStructureHost; };
         compilerHost.scheduleInvalidateResolutionsOfFailedLookupLocations = scheduleInvalidateResolutionsOfFailedLookupLocations;
@@ -124867,6 +125136,9 @@ var ts;
                 return host.resolveTypeReferenceDirectives.apply(host, args);
             }) :
             (function (typeDirectiveNames, containingFile, redirectedReference, _options, containingFileMode) { return resolutionCache.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode); });
+        compilerHost.getModuleResolutionCache = host.resolveModuleNames ?
+            ts.maybeBind(host, host.getModuleResolutionCache) :
+            (function () { return resolutionCache.getModuleResolutionCache(); });
         var userProvidedResolution = !!host.resolveModuleNames || !!host.resolveTypeReferenceDirectives;
         builderProgram = readBuilderProgram(compilerOptions, compilerHost);
         synchronizeProgram();
@@ -124969,8 +125241,9 @@ var ts;
             resolutionCache.startCachingPerDirectoryResolution();
             compilerHost.hasInvalidatedResolution = hasInvalidatedResolution;
             compilerHost.hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames;
+            var oldProgram = getCurrentProgram();
             builderProgram = createProgram(rootFileNames, compilerOptions, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences);
-            resolutionCache.finishCachingPerDirectoryResolution();
+            resolutionCache.finishCachingPerDirectoryResolution(builderProgram.getProgram(), oldProgram);
             // Update watches
             ts.updateMissingFilePathsWatch(builderProgram.getProgram(), missingFilesMap || (missingFilesMap = new ts.Map()), watchMissingFilePath);
             if (needsUpdateInTypeRootWatch) {
@@ -125052,9 +125325,6 @@ var ts;
                         sourceFilesCache.set(path, false);
                     }
                 }
-                if (sourceFile) {
-                    sourceFile.impliedNodeFormat = ts.getImpliedNodeFormatForFile(path, resolutionCache.getModuleResolutionCache().getPackageJsonInfoCache(), compilerHost, compilerHost.getCompilationSettings());
-                }
                 return sourceFile;
             }
             return hostSourceFile.sourceFile;
@@ -125570,6 +125840,7 @@ var ts;
         compilerHost.getParsedCommandLine = function (fileName) { return parseConfigFile(state, fileName, toResolvedConfigFilePath(state, fileName)); };
         compilerHost.resolveModuleNames = ts.maybeBind(host, host.resolveModuleNames);
         compilerHost.resolveTypeReferenceDirectives = ts.maybeBind(host, host.resolveTypeReferenceDirectives);
+        compilerHost.getModuleResolutionCache = ts.maybeBind(host, host.getModuleResolutionCache);
         var moduleResolutionCache = !compilerHost.resolveModuleNames ? ts.createModuleResolutionCache(currentDirectory, getCanonicalFileName) : undefined;
         var typeReferenceDirectiveResolutionCache = !compilerHost.resolveTypeReferenceDirectives ? ts.createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, /*options*/ undefined, moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.getPackageJsonInfoCache()) : undefined;
         if (!compilerHost.resolveModuleNames) {
@@ -137369,60 +137640,64 @@ var ts;
             }
             return settingsOrHost;
         }
-        function acquireDocument(fileName, compilationSettings, scriptSnapshot, version, scriptKind) {
+        function acquireDocument(fileName, compilationSettings, scriptSnapshot, version, scriptKind, languageVersionOrOptions) {
             var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName);
             var key = getKeyForCompilationSettings(getCompilationSettings(compilationSettings));
-            return acquireDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind);
+            return acquireDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind, languageVersionOrOptions);
         }
-        function acquireDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind) {
-            return acquireOrUpdateDocument(fileName, path, compilationSettings, key, scriptSnapshot, version, /*acquiring*/ true, scriptKind);
+        function acquireDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind, languageVersionOrOptions) {
+            return acquireOrUpdateDocument(fileName, path, compilationSettings, key, scriptSnapshot, version, /*acquiring*/ true, scriptKind, languageVersionOrOptions);
         }
-        function updateDocument(fileName, compilationSettings, scriptSnapshot, version, scriptKind) {
+        function updateDocument(fileName, compilationSettings, scriptSnapshot, version, scriptKind, languageVersionOrOptions) {
             var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName);
             var key = getKeyForCompilationSettings(getCompilationSettings(compilationSettings));
-            return updateDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind);
+            return updateDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind, languageVersionOrOptions);
         }
-        function updateDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind) {
-            return acquireOrUpdateDocument(fileName, path, getCompilationSettings(compilationSettings), key, scriptSnapshot, version, /*acquiring*/ false, scriptKind);
+        function updateDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind, languageVersionOrOptions) {
+            return acquireOrUpdateDocument(fileName, path, getCompilationSettings(compilationSettings), key, scriptSnapshot, version, /*acquiring*/ false, scriptKind, languageVersionOrOptions);
         }
         function getDocumentRegistryEntry(bucketEntry, scriptKind) {
             var entry = isDocumentRegistryEntry(bucketEntry) ? bucketEntry : bucketEntry.get(ts.Debug.checkDefined(scriptKind, "If there are more than one scriptKind's for same document the scriptKind should be provided"));
             ts.Debug.assert(scriptKind === undefined || !entry || entry.sourceFile.scriptKind === scriptKind, "Script kind should match provided ScriptKind:" + scriptKind + " and sourceFile.scriptKind: " + (entry === null || entry === void 0 ? void 0 : entry.sourceFile.scriptKind) + ", !entry: " + !entry);
             return entry;
         }
-        function acquireOrUpdateDocument(fileName, path, compilationSettingsOrHost, key, scriptSnapshot, version, acquiring, scriptKind) {
+        function acquireOrUpdateDocument(fileName, path, compilationSettingsOrHost, key, scriptSnapshot, version, acquiring, scriptKind, languageVersionOrOptions) {
             var _a, _b, _c, _d;
             scriptKind = ts.ensureScriptKind(fileName, scriptKind);
             var compilationSettings = getCompilationSettings(compilationSettingsOrHost);
             var host = compilationSettingsOrHost === compilationSettings ? undefined : compilationSettingsOrHost;
             var scriptTarget = scriptKind === 6 /* JSON */ ? 100 /* JSON */ : ts.getEmitScriptTarget(compilationSettings);
-            var sourceFileOptions = {
-                languageVersion: scriptTarget,
-                impliedNodeFormat: host && ts.getImpliedNodeFormatForFile(path, (_d = (_c = (_b = (_a = host.getCompilerHost) === null || _a === void 0 ? void 0 : _a.call(host)) === null || _b === void 0 ? void 0 : _b.getModuleResolutionCache) === null || _c === void 0 ? void 0 : _c.call(_b)) === null || _d === void 0 ? void 0 : _d.getPackageJsonInfoCache(), host, compilationSettings),
-                setExternalModuleIndicator: ts.getSetExternalModuleIndicator(compilationSettings)
-            };
+            var sourceFileOptions = typeof languageVersionOrOptions === "object" ?
+                languageVersionOrOptions :
+                {
+                    languageVersion: scriptTarget,
+                    impliedNodeFormat: host && ts.getImpliedNodeFormatForFile(path, (_d = (_c = (_b = (_a = host.getCompilerHost) === null || _a === void 0 ? void 0 : _a.call(host)) === null || _b === void 0 ? void 0 : _b.getModuleResolutionCache) === null || _c === void 0 ? void 0 : _c.call(_b)) === null || _d === void 0 ? void 0 : _d.getPackageJsonInfoCache(), host, compilationSettings),
+                    setExternalModuleIndicator: ts.getSetExternalModuleIndicator(compilationSettings)
+                };
+            sourceFileOptions.languageVersion = scriptTarget;
             var oldBucketCount = buckets.size;
-            var bucket = ts.getOrUpdate(buckets, key, function () { return new ts.Map(); });
+            var keyWithMode = getDocumentRegistryBucketKeyWithMode(key, sourceFileOptions.impliedNodeFormat);
+            var bucket = ts.getOrUpdate(buckets, keyWithMode, function () { return new ts.Map(); });
             if (ts.tracing) {
                 if (buckets.size > oldBucketCount) {
                     // It is interesting, but not definitively problematic if a build requires multiple document registry buckets -
                     // perhaps they are for two projects that don't have any overlap.
                     // Bonus: these events can help us interpret the more interesting event below.
-                    ts.tracing.instant("session" /* Session */, "createdDocumentRegistryBucket", { configFilePath: compilationSettings.configFilePath, key: key });
+                    ts.tracing.instant("session" /* Session */, "createdDocumentRegistryBucket", { configFilePath: compilationSettings.configFilePath, key: keyWithMode });
                 }
                 // It is fairly suspicious to have one path in two buckets - you'd expect dependencies to have similar configurations.
                 // If this occurs unexpectedly, the fix is likely to synchronize the project settings.
                 // Skip .d.ts files to reduce noise (should also cover most of node_modules).
                 var otherBucketKey = !ts.isDeclarationFileName(path) &&
-                    ts.forEachEntry(buckets, function (bucket, bucketKey) { return bucketKey !== key && bucket.has(path) && bucketKey; });
+                    ts.forEachEntry(buckets, function (bucket, bucketKey) { return bucketKey !== keyWithMode && bucket.has(path) && bucketKey; });
                 if (otherBucketKey) {
-                    ts.tracing.instant("session" /* Session */, "documentRegistryBucketOverlap", { path: path, key1: otherBucketKey, key2: key });
+                    ts.tracing.instant("session" /* Session */, "documentRegistryBucketOverlap", { path: path, key1: otherBucketKey, key2: keyWithMode });
                 }
             }
             var bucketEntry = bucket.get(path);
             var entry = bucketEntry && getDocumentRegistryEntry(bucketEntry, scriptKind);
             if (!entry && externalCache) {
-                var sourceFile = externalCache.getDocument(key, path);
+                var sourceFile = externalCache.getDocument(keyWithMode, path);
                 if (sourceFile) {
                     ts.Debug.assert(acquiring);
                     entry = {
@@ -137436,7 +137711,7 @@ var ts;
                 // Have never seen this file with these settings.  Create a new source file for it.
                 var sourceFile = ts.createLanguageServiceSourceFile(fileName, scriptSnapshot, sourceFileOptions, version, /*setNodeParents*/ false, scriptKind);
                 if (externalCache) {
-                    externalCache.setDocument(key, path, sourceFile);
+                    externalCache.setDocument(keyWithMode, path, sourceFile);
                 }
                 entry = {
                     sourceFile: sourceFile,
@@ -137451,7 +137726,7 @@ var ts;
                 if (entry.sourceFile.version !== version) {
                     entry.sourceFile = ts.updateLanguageServiceSourceFile(entry.sourceFile, scriptSnapshot, version, scriptSnapshot.getChangeRange(entry.sourceFile.scriptSnapshot)); // TODO: GH#18217
                     if (externalCache) {
-                        externalCache.setDocument(key, path, entry.sourceFile);
+                        externalCache.setDocument(keyWithMode, path, entry.sourceFile);
                     }
                 }
                 // If we're acquiring, then this is the first time this LS is asking for this document.
@@ -137480,13 +137755,13 @@ var ts;
                 }
             }
         }
-        function releaseDocument(fileName, compilationSettings, scriptKind) {
+        function releaseDocument(fileName, compilationSettings, scriptKind, impliedNodeFormat) {
             var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName);
             var key = getKeyForCompilationSettings(compilationSettings);
-            return releaseDocumentWithKey(path, key, scriptKind);
+            return releaseDocumentWithKey(path, key, scriptKind, impliedNodeFormat);
         }
-        function releaseDocumentWithKey(path, key, scriptKind) {
-            var bucket = ts.Debug.checkDefined(buckets.get(key));
+        function releaseDocumentWithKey(path, key, scriptKind, impliedNodeFormat) {
+            var bucket = ts.Debug.checkDefined(buckets.get(getDocumentRegistryBucketKeyWithMode(key, impliedNodeFormat)));
             var bucketEntry = bucket.get(path);
             var entry = getDocumentRegistryEntry(bucketEntry, scriptKind);
             entry.languageServiceRefCount--;
@@ -137543,6 +137818,9 @@ var ts;
     function getKeyForCompilationSettings(settings) {
         return ts.sourceFileAffectingCompilerOptions.map(function (option) { return compilerOptionValueToString(ts.getCompilerOptionValue(settings, option)); }).join("|") + (settings.pathsBasePath ? "|" + settings.pathsBasePath : undefined);
     }
+    function getDocumentRegistryBucketKeyWithMode(key, mode) {
+        return (mode ? key + "|" + mode : key);
+    }
 })(ts || (ts = {}));
 /* Code for finding imports of an exported symbol. Used only by FindAllReferences. */
 /* @internal */
@@ -161602,6 +161880,9 @@ var ts;
                 if (!containingDecl) {
                     return;
                 }
+                if (ts.isFunctionLikeDeclaration(containingDecl) && containingDecl.body && ts.rangeContainsPosition(containingDecl.body, startPosition)) {
+                    return;
+                }
                 var checker = program.getTypeChecker();
                 var signatureSymbol = containingDecl.symbol;
                 if (!signatureSymbol) {
@@ -166786,12 +167067,12 @@ var ts;
             // not part of the new program.
             function onReleaseOldSourceFile(oldSourceFile, oldOptions) {
                 var oldSettingsKey = documentRegistry.getKeyForCompilationSettings(oldOptions);
-                documentRegistry.releaseDocumentWithKey(oldSourceFile.resolvedPath, oldSettingsKey, oldSourceFile.scriptKind);
+                documentRegistry.releaseDocumentWithKey(oldSourceFile.resolvedPath, oldSettingsKey, oldSourceFile.scriptKind, oldSourceFile.impliedNodeFormat);
             }
-            function getOrCreateSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile) {
-                return getOrCreateSourceFileByPath(fileName, ts.toPath(fileName, currentDirectory, getCanonicalFileName), languageVersion, onError, shouldCreateNewSourceFile);
+            function getOrCreateSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
+                return getOrCreateSourceFileByPath(fileName, ts.toPath(fileName, currentDirectory, getCanonicalFileName), languageVersionOrOptions, onError, shouldCreateNewSourceFile);
             }
-            function getOrCreateSourceFileByPath(fileName, path, _languageVersion, _onError, shouldCreateNewSourceFile) {
+            function getOrCreateSourceFileByPath(fileName, path, languageVersionOrOptions, _onError, shouldCreateNewSourceFile) {
                 ts.Debug.assert(compilerHost, "getOrCreateSourceFileByPath called after typical CompilerHost lifetime, check the callstack something with a reference to an old host.");
                 // The program is asking for this file, check first if the host can locate it.
                 // If the host can not locate the file, then it does not exist. return undefined
@@ -166834,17 +167115,17 @@ var ts;
                         // file's script kind, i.e. in one project some file is treated as ".ts"
                         // and in another as ".js"
                         if (scriptKind === oldSourceFile.scriptKind) {
-                            return documentRegistry.updateDocumentWithKey(fileName, path, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind);
+                            return documentRegistry.updateDocumentWithKey(fileName, path, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
                         }
                         else {
                             // Release old source file and fall through to aquire new file with new script kind
-                            documentRegistry.releaseDocumentWithKey(oldSourceFile.resolvedPath, documentRegistry.getKeyForCompilationSettings(program.getCompilerOptions()), oldSourceFile.scriptKind);
+                            documentRegistry.releaseDocumentWithKey(oldSourceFile.resolvedPath, documentRegistry.getKeyForCompilationSettings(program.getCompilerOptions()), oldSourceFile.scriptKind, oldSourceFile.impliedNodeFormat);
                         }
                     }
                     // We didn't already have the file.  Fall through and acquire it from the registry.
                 }
                 // Could not find this file in the old program, create a new SourceFile for it.
-                return documentRegistry.acquireDocumentWithKey(fileName, path, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind);
+                return documentRegistry.acquireDocumentWithKey(fileName, path, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
             }
         }
         // TODO: GH#18217 frequently asserted as defined
@@ -166923,7 +167204,7 @@ var ts;
                 // Use paths to ensure we are using correct key and paths as document registry could be created with different current directory than host
                 var key_1 = documentRegistry.getKeyForCompilationSettings(program.getCompilerOptions());
                 ts.forEach(program.getSourceFiles(), function (f) {
-                    return documentRegistry.releaseDocumentWithKey(f.resolvedPath, key_1, f.scriptKind);
+                    return documentRegistry.releaseDocumentWithKey(f.resolvedPath, key_1, f.scriptKind, f.impliedNodeFormat);
                 });
                 program = undefined; // TODO: GH#18217
             }
@@ -167840,6 +168121,7 @@ var ts;
             getEmitOutput: getEmitOutput,
             getNonBoundSourceFile: getNonBoundSourceFile,
             getProgram: getProgram,
+            getCurrentProgram: function () { return program; },
             getAutoImportProvider: getAutoImportProvider,
             updateIsDefinitionOfReferencedSymbols: updateIsDefinitionOfReferencedSymbols,
             getApplicableRefactors: getApplicableRefactors,
@@ -171476,7 +171758,7 @@ var ts;
             };
             /*@internal*/
             Project.prototype.watchAffectingFileLocation = function (file, cb) {
-                return this.projectService.watchFactory.watchFile(file, cb, ts.PollingInterval.High, this.projectService.getWatchOptions(this), ts.WatchType.PackageJson, this);
+                return this.projectService.watchFactory.watchFile(file, cb, ts.PollingInterval.High, this.projectService.getWatchOptions(this), ts.WatchType.AffectingFileLocation, this);
             };
             /*@internal*/
             Project.prototype.clearInvalidateResolutionOfFailedLookupTimer = function () {
@@ -172013,7 +172295,7 @@ var ts;
             };
             Project.prototype.updateGraphWorker = function () {
                 var _this = this;
-                var oldProgram = this.program;
+                var oldProgram = this.languageService.getCurrentProgram();
                 ts.Debug.assert(!this.isClosed(), "Called update graph worker of closed project");
                 this.writeLog("Starting updateGraphWorker: Project: " + this.getProjectName());
                 var start = ts.timestamp();
@@ -172022,7 +172304,7 @@ var ts;
                 this.program = this.languageService.getProgram(); // TODO: GH#18217
                 this.dirty = false;
                 ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("session" /* Session */, "finishCachingPerDirectoryResolution");
-                this.resolutionCache.finishCachingPerDirectoryResolution();
+                this.resolutionCache.finishCachingPerDirectoryResolution(this.program, oldProgram);
                 ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
                 ts.Debug.assert(oldProgram === undefined || this.program !== undefined);
                 // bump up the version if
@@ -174480,7 +174762,7 @@ var ts;
                     // created when any of the script infos are added as root of inferred project
                     if (this.configFileExistenceImpactsRootOfInferredProject(configFileExistenceInfo)) {
                         // If we cannot watch config file existence without configured project, close the configured file watcher
-                        if (!ts.canWatchDirectory(ts.getDirectoryPath(canonicalConfigFilePath))) {
+                        if (!ts.canWatchDirectoryOrFile(ts.getDirectoryPath(canonicalConfigFilePath))) {
                             configFileExistenceInfo.watcher.close();
                             configFileExistenceInfo.watcher = noopConfigFileWatcher;
                         }
@@ -174560,7 +174842,7 @@ var ts;
                     // Set this file as the root of inferred project
                     (configFileExistenceInfo.openFilesImpactedByConfigFile || (configFileExistenceInfo.openFilesImpactedByConfigFile = new ts.Map())).set(info.path, true);
                     // If there is no configured project for this config file, add the file watcher
-                    configFileExistenceInfo.watcher || (configFileExistenceInfo.watcher = ts.canWatchDirectory(ts.getDirectoryPath(canonicalConfigFilePath)) ?
+                    configFileExistenceInfo.watcher || (configFileExistenceInfo.watcher = ts.canWatchDirectoryOrFile(ts.getDirectoryPath(canonicalConfigFilePath)) ?
                         _this.watchFactory.watchFile(configFileName, function (_filename, eventKind) { return _this.onConfigFileChanged(canonicalConfigFilePath, eventKind); }, ts.PollingInterval.High, _this.hostConfiguration.watchOptions, ts.WatchType.ConfigFileForInferredRoot) :
                         noopConfigFileWatcher);
                 });