typescript 4.6.0-dev.20220109 → 4.6.0-dev.20220113

package/lib/tsserver.js

@@ -100,7 +100,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220109";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220113";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -19791,16 +19791,6 @@ var ts;
                     (symlinkedDirectories || (symlinkedDirectories = new ts.Map())).set(symlinkPath, real);
                 }
             },
-            setSymlinkedDirectoryFromSymlinkedFile: function (symlink, real) {
-                this.setSymlinkedFile(ts.toPath(symlink, cwd, getCanonicalFileName), real);
-                var _a = guessDirectorySymlink(real, symlink, cwd, getCanonicalFileName) || ts.emptyArray, commonResolved = _a[0], commonOriginal = _a[1];
-                if (commonResolved && commonOriginal) {
-                    this.setSymlinkedDirectory(commonOriginal, {
-                        real: commonResolved,
-                        realPath: ts.toPath(commonResolved, cwd, getCanonicalFileName),
-                    });
-                }
-            },
             setSymlinksFromResolutions: function (files, typeReferenceDirectives) {
                 var _this = this;
                 var _a;
@@ -41509,9 +41499,7 @@ var ts;
             }
         }
         var failedLookupLocations = [];
-        var features = ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12 ? NodeResolutionFeatures.Node12Default :
-            ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext ? NodeResolutionFeatures.NodeNextDefault :
-                NodeResolutionFeatures.None;
+        var features = getDefaultNodeResolutionFeatures(options);
         var moduleResolutionState = { compilerOptions: options, host: host, traceEnabled: traceEnabled, failedLookupLocations: failedLookupLocations, packageJsonInfoCache: cache, features: features, conditions: ["node", "require", "types"] };
         var resolved = primaryLookup();
         var primary = true;
@@ -41596,6 +41584,34 @@ var ts;
         }
     }
     ts.resolveTypeReferenceDirective = resolveTypeReferenceDirective;
+    function getDefaultNodeResolutionFeatures(options) {
+        return ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12 ? NodeResolutionFeatures.Node12Default :
+            ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext ? NodeResolutionFeatures.NodeNextDefault :
+                NodeResolutionFeatures.None;
+    }
+    /**
+     * @internal
+     * Does not try `@types/${packageName}` - use a second pass if needed.
+     */
+    function resolvePackageNameToPackageJson(packageName, containingDirectory, options, host, cache) {
+        var moduleResolutionState = {
+            compilerOptions: options,
+            host: host,
+            traceEnabled: isTraceEnabled(options, host),
+            failedLookupLocations: [],
+            packageJsonInfoCache: cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(),
+            conditions: ts.emptyArray,
+            features: NodeResolutionFeatures.None,
+        };
+        return ts.forEachAncestorDirectory(containingDirectory, function (ancestorDirectory) {
+            if (ts.getBaseFileName(ancestorDirectory) !== "node_modules") {
+                var nodeModulesFolder = ts.combinePaths(ancestorDirectory, "node_modules");
+                var candidate = ts.combinePaths(nodeModulesFolder, packageName);
+                return getPackageJsonInfo(candidate, /*onlyRecordFailures*/ false, moduleResolutionState);
+            }
+        });
+    }
+    ts.resolvePackageNameToPackageJson = resolvePackageNameToPackageJson;
     /**
      * Given a set of options, returns the set of type directive names
      *   that should be included for this program automatically.
@@ -42169,11 +42185,6 @@ var ts;
     }
     ts.resolveJSModule = resolveJSModule;
     /* @internal */
-    function tryResolveJSModule(moduleName, initialDir, host) {
-        return tryResolveJSModuleWorker(moduleName, initialDir, host).resolvedModule;
-    }
-    ts.tryResolveJSModule = tryResolveJSModule;
-    /* @internal */
     var NodeResolutionFeatures;
     (function (NodeResolutionFeatures) {
         NodeResolutionFeatures[NodeResolutionFeatures["None"] = 0] = "None";
@@ -42481,6 +42492,97 @@ var ts;
         var versionPaths = packageInfo && packageInfo.versionPaths;
         return withPackageId(packageInfo, loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageJsonContent, versionPaths));
     }
+    /* @internal */
+    function getEntrypointsFromPackageJsonInfo(packageJsonInfo, options, host, cache, resolveJs) {
+        if (!resolveJs && packageJsonInfo.resolvedEntrypoints !== undefined) {
+            // Cached value excludes resolutions to JS files - those could be
+            // cached separately, but they're used rarely.
+            return packageJsonInfo.resolvedEntrypoints;
+        }
+        var entrypoints;
+        var extensions = resolveJs ? Extensions.JavaScript : Extensions.TypeScript;
+        var features = getDefaultNodeResolutionFeatures(options);
+        var requireState = {
+            compilerOptions: options,
+            host: host,
+            traceEnabled: isTraceEnabled(options, host),
+            failedLookupLocations: [],
+            packageJsonInfoCache: cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(),
+            conditions: ["node", "require", "types"],
+            features: features,
+        };
+        var requireResolution = loadNodeModuleFromDirectoryWorker(extensions, packageJsonInfo.packageDirectory, 
+        /*onlyRecordFailures*/ false, requireState, packageJsonInfo.packageJsonContent, packageJsonInfo.versionPaths);
+        entrypoints = ts.append(entrypoints, requireResolution === null || requireResolution === void 0 ? void 0 : requireResolution.path);
+        if (features & NodeResolutionFeatures.Exports && packageJsonInfo.packageJsonContent.exports) {
+            for (var _i = 0, _a = [["node", "import", "types"], ["node", "require", "types"]]; _i < _a.length; _i++) {
+                var conditions = _a[_i];
+                var exportState = __assign(__assign({}, requireState), { failedLookupLocations: [], conditions: conditions });
+                var exportResolutions = loadEntrypointsFromExportMap(packageJsonInfo, packageJsonInfo.packageJsonContent.exports, exportState, extensions);
+                if (exportResolutions) {
+                    for (var _b = 0, exportResolutions_1 = exportResolutions; _b < exportResolutions_1.length; _b++) {
+                        var resolution = exportResolutions_1[_b];
+                        entrypoints = ts.appendIfUnique(entrypoints, resolution.path);
+                    }
+                }
+            }
+        }
+        return packageJsonInfo.resolvedEntrypoints = entrypoints || false;
+    }
+    ts.getEntrypointsFromPackageJsonInfo = getEntrypointsFromPackageJsonInfo;
+    function loadEntrypointsFromExportMap(scope, exports, state, extensions) {
+        var entrypoints;
+        if (ts.isArray(exports)) {
+            for (var _i = 0, exports_1 = exports; _i < exports_1.length; _i++) {
+                var target = exports_1[_i];
+                loadEntrypointsFromTargetExports(target);
+            }
+        }
+        // eslint-disable-next-line no-null/no-null
+        else if (typeof exports === "object" && exports !== null && allKeysStartWithDot(exports)) {
+            for (var key in exports) {
+                loadEntrypointsFromTargetExports(exports[key]);
+            }
+        }
+        else {
+            loadEntrypointsFromTargetExports(exports);
+        }
+        return entrypoints;
+        function loadEntrypointsFromTargetExports(target) {
+            var _a, _b;
+            if (typeof target === "string" && ts.startsWith(target, "./") && target.indexOf("*") === -1) {
+                var partsAfterFirst = ts.getPathComponents(target).slice(2);
+                if (partsAfterFirst.indexOf("..") >= 0 || partsAfterFirst.indexOf(".") >= 0 || partsAfterFirst.indexOf("node_modules") >= 0) {
+                    return false;
+                }
+                var resolvedTarget = ts.combinePaths(scope.packageDirectory, target);
+                var finalPath = ts.getNormalizedAbsolutePath(resolvedTarget, (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a));
+                var result = loadJSOrExactTSFileName(extensions, finalPath, /*recordOnlyFailures*/ false, state);
+                if (result) {
+                    entrypoints = ts.appendIfUnique(entrypoints, result, function (a, b) { return a.path === b.path; });
+                    return true;
+                }
+            }
+            else if (Array.isArray(target)) {
+                for (var _i = 0, target_1 = target; _i < target_1.length; _i++) {
+                    var t = target_1[_i];
+                    var success = loadEntrypointsFromTargetExports(t);
+                    if (success) {
+                        return true;
+                    }
+                }
+            }
+            // eslint-disable-next-line no-null/no-null
+            else if (typeof target === "object" && target !== null) {
+                return ts.forEach(ts.getOwnKeys(target), function (key) {
+                    if (key === "default" || ts.contains(state.conditions, key) || isApplicableVersionedTypesKey(state.conditions, key)) {
+                        loadEntrypointsFromTargetExports(target[key]);
+                        return true;
+                    }
+                });
+            }
+        }
+    }
     /**
      * A function for locating the package.json scope for a given path
      */
@@ -42537,7 +42639,7 @@ var ts;
                 trace(host, ts.Diagnostics.Found_package_json_at_0, packageJsonPath);
             }
             var versionPaths = readPackageJsonTypesVersionPaths(packageJsonContent, state);
-            var result = { packageDirectory: packageDirectory, packageJsonContent: packageJsonContent, versionPaths: versionPaths };
+            var result = { packageDirectory: packageDirectory, packageJsonContent: packageJsonContent, versionPaths: versionPaths, resolvedEntrypoints: undefined };
             (_b = state.packageJsonInfoCache) === null || _b === void 0 ? void 0 : _b.setPackageJsonInfo(packageJsonPath, result);
             return result;
         }
@@ -42834,8 +42936,8 @@ var ts;
                         }
                         return toSearchResult(/*value*/ undefined);
                     }
-                    for (var _d = 0, target_1 = target; _d < target_1.length; _d++) {
-                        var elem = target_1[_d];
+                    for (var _d = 0, target_2 = target; _d < target_2.length; _d++) {
+                        var elem = target_2[_d];
                         var result = loadModuleFromTargetImportOrExport(elem, subpath, pattern);
                         if (result) {
                             return result;
@@ -49864,7 +49966,7 @@ var ts;
                         if (!sigs || !sigs.length) {
                             sigs = getSignaturesOfStructuredType(type, 1 /* Construct */);
                         }
-                        if ((sigs && sigs.length) || getPropertyOfType(type, "default" /* Default */)) {
+                        if ((sigs && sigs.length) || getPropertyOfType(type, "default" /* Default */, /*skipObjectFunctionPropertyAugment*/ true)) {
                             var moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol, reference);
                             return cloneTypeAsModuleType(symbol, moduleType, referenceParent);
                         }
@@ -52068,8 +52170,8 @@ var ts;
                     }
                     else {
                         if (parent && getExportsOfSymbol(parent)) {
-                            var exports_1 = getExportsOfSymbol(parent);
-                            ts.forEachEntry(exports_1, function (ex, name) {
+                            var exports_2 = getExportsOfSymbol(parent);
+                            ts.forEachEntry(exports_2, function (ex, name) {
                                 if (getSymbolIfSameReference(ex, symbol) && !isLateBoundName(name) && name !== "export=" /* ExportEquals */) {
                                     symbolName = ts.unescapeLeadingUnderscores(name);
                                     return true;
@@ -57180,6 +57282,11 @@ var ts;
             return simplified !== type ? simplified : getConstraintOfType(type);
         }
         function getConstraintFromIndexedAccess(type) {
+            if (isMappedTypeGenericIndexedAccess(type)) {
+                // For indexed access types of the form { [P in K]: E }[X], where K is non-generic and X is generic,
+                // we substitute an instantiation of E where P is replaced with X.
+                return substituteIndexedMappedType(type.objectType, type.indexType);
+            }
             var indexConstraint = getSimplifiedTypeOrConstraint(type.indexType);
             if (indexConstraint && indexConstraint !== type.indexType) {
                 var indexedAccess = getIndexedAccessTypeOrUndefined(type.objectType, indexConstraint, type.accessFlags);
@@ -57384,6 +57491,11 @@ var ts;
                     return constraint ? getStringMappingType(t.symbol, constraint) : stringType;
                 }
                 if (t.flags & 8388608 /* IndexedAccess */) {
+                    if (isMappedTypeGenericIndexedAccess(t)) {
+                        // For indexed access types of the form { [P in K]: E }[X], where K is non-generic and X is generic,
+                        // we substitute an instantiation of E where P is replaced with X.
+                        return getBaseConstraint(substituteIndexedMappedType(t.objectType, t.indexType));
+                    }
                     var baseObjectType = getBaseConstraint(t.objectType);
                     var baseIndexType = getBaseConstraint(t.indexType);
                     var baseIndexedAccess = baseObjectType && baseIndexType && getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType, t.accessFlags);
@@ -57468,13 +57580,7 @@ var ts;
          * type itself.
          */
         function getApparentType(type) {
-            // We obtain the base constraint for all instantiable types, except indexed access types of the form
-            // { [P in K]: E }[X], where K is non-generic and X is generic. For those types, we instead substitute an
-            // instantiation of E where P is replaced with X. We do this because getBaseConstraintOfType directly
-            // lowers to an instantiation where X's constraint is substituted for X, which isn't always desirable.
-            var t = !(type.flags & 465829888 /* Instantiable */) ? type :
-                isMappedTypeGenericIndexedAccess(type) ? substituteIndexedMappedType(type.objectType, type.indexType) :
-                    getBaseConstraintOfType(type) || unknownType;
+            var t = !(type.flags & 465829888 /* Instantiable */) ? type : getBaseConstraintOfType(type) || unknownType;
             return ts.getObjectFlags(t) & 32 /* Mapped */ ? getApparentTypeOfMappedType(t) :
                 t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t) :
                     t.flags & 402653316 /* StringLike */ ? globalStringType :
@@ -64138,6 +64244,17 @@ var ts;
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
+                        if (isMappedTypeGenericIndexedAccess(source)) {
+                            // For an indexed access type { [P in K]: E}[X], above we have already explored an instantiation of E with X
+                            // substituted for P. We also want to explore type { [P in K]: E }[C], where C is the constraint of X.
+                            var indexConstraint = getConstraintOfType(source.indexType);
+                            if (indexConstraint) {
+                                if (result = isRelatedTo(getIndexedAccessType(source.objectType, indexConstraint), target, 1 /* Source */, reportErrors)) {
+                                    resetErrorInfo(saveErrorInfo);
+                                    return result;
+                                }
+                            }
+                        }
                     }
                 }
                 else if (source.flags & 4194304 /* Index */) {
@@ -83256,9 +83373,9 @@ var ts;
                     }
                 }
                 // Checks for export * conflicts
-                var exports_2 = getExportsOfModule(moduleSymbol);
-                if (exports_2) {
-                    exports_2.forEach(function (_a, id) {
+                var exports_3 = getExportsOfModule(moduleSymbol);
+                if (exports_3) {
+                    exports_3.forEach(function (_a, id) {
                         var declarations = _a.declarations, flags = _a.flags;
                         if (id === "__export") {
                             return;
@@ -90482,6 +90599,7 @@ var ts;
                 case 176 /* TypePredicate */:
                 case 133 /* BooleanKeyword */:
                     return factory.createIdentifier("Boolean");
+                case 197 /* TemplateLiteralType */:
                 case 149 /* StringKeyword */:
                     return factory.createIdentifier("String");
                 case 147 /* ObjectKeyword */:
@@ -92814,6 +92932,11 @@ var ts;
                 ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property));
                 ts.setCommentRange(statement, property);
                 ts.setOriginalNode(statement, property);
+                // `setOriginalNode` *copies* the `emitNode` from `property`, so now both
+                // `statement` and `expression` have a copy of the synthesized comments.
+                // Drop the comments from expression to avoid printing them twice.
+                ts.setSyntheticLeadingComments(expression, undefined);
+                ts.setSyntheticTrailingComments(expression, undefined);
                 statements.push(statement);
             }
         }
@@ -119154,28 +119277,37 @@ var ts;
                 useCaseSensitiveFileNames: (_a = host.useCaseSensitiveFileNames) === null || _a === void 0 ? void 0 : _a.call(host),
             };
         }
-        function updateModuleSpecifier(compilerOptions, importingSourceFileName, toFileName, host, oldImportSpecifier) {
-            var res = getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, getPreferencesForUpdate(compilerOptions, oldImportSpecifier, importingSourceFileName, host), {});
+        // `importingSourceFile` and `importingSourceFileName`? Why not just use `importingSourceFile.path`?
+        // Because when this is called by the file renamer, `importingSourceFile` is the file being renamed,
+        // while `importingSourceFileName` its *new* name. We need a source file just to get its
+        // `impliedNodeFormat` and to detect certain preferences from existing import module specifiers.
+        function updateModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, oldImportSpecifier) {
+            var res = getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, getPreferencesForUpdate(compilerOptions, oldImportSpecifier, importingSourceFileName, host), {});
             if (res === oldImportSpecifier)
                 return undefined;
             return res;
         }
         moduleSpecifiers_1.updateModuleSpecifier = updateModuleSpecifier;
-        // Note: importingSourceFile is just for usesJsExtensionOnImports
+        // `importingSourceFile` and `importingSourceFileName`? Why not just use `importingSourceFile.path`?
+        // Because when this is called by the declaration emitter, `importingSourceFile` is the implementation
+        // file, but `importingSourceFileName` and `toFileName` refer to declaration files (the former to the
+        // one currently being produced; the latter to the one being imported). We need an implementation file
+        // just to get its `impliedNodeFormat` and to detect certain preferences from existing import module
+        // specifiers.
         function getModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host) {
-            return getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, getPreferences(host, {}, compilerOptions, importingSourceFile), {});
+            return getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, getPreferences(host, {}, compilerOptions, importingSourceFile), {});
         }
         moduleSpecifiers_1.getModuleSpecifier = getModuleSpecifier;
-        function getNodeModulesPackageName(compilerOptions, importingSourceFileName, nodeModulesFileName, host, preferences) {
-            var info = getInfo(importingSourceFileName, host);
-            var modulePaths = getAllModulePaths(importingSourceFileName, nodeModulesFileName, host, preferences);
-            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, host, compilerOptions, /*packageNameOnly*/ true); });
+        function getNodeModulesPackageName(compilerOptions, importingSourceFile, nodeModulesFileName, host, preferences) {
+            var info = getInfo(importingSourceFile.path, host);
+            var modulePaths = getAllModulePaths(importingSourceFile.path, nodeModulesFileName, host, preferences);
+            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, /*packageNameOnly*/ true); });
         }
         moduleSpecifiers_1.getNodeModulesPackageName = getNodeModulesPackageName;
-        function getModuleSpecifierWorker(compilerOptions, importingSourceFileName, toFileName, host, preferences, userPreferences) {
+        function getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, preferences, userPreferences) {
             var info = getInfo(importingSourceFileName, host);
             var modulePaths = getAllModulePaths(importingSourceFileName, toFileName, host, userPreferences);
-            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, host, compilerOptions); }) ||
+            return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions); }) ||
                 getLocalModuleSpecifier(toFileName, info, compilerOptions, host, preferences);
         }
         function tryGetModuleSpecifiersFromCache(moduleSymbol, importingSourceFile, host, userPreferences) {
@@ -119242,7 +119374,7 @@ var ts;
             var relativeSpecifiers;
             for (var _i = 0, modulePaths_1 = modulePaths; _i < modulePaths_1.length; _i++) {
                 var modulePath = modulePaths_1[_i];
-                var specifier = tryGetModuleNameAsNodeModule(modulePath, info, host, compilerOptions);
+                var specifier = tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions);
                 nodeModulesSpecifiers = ts.append(nodeModulesSpecifiers, specifier);
                 if (specifier && modulePath.isRedirect) {
                     // If we got a specifier for a redirect, it was a bare package specifier (e.g. "@foo/bar",
@@ -119634,7 +119766,7 @@ var ts;
                 ? removeExtensionAndIndexPostFix(relativePath, ending, compilerOptions)
                 : ts.removeFileExtension(relativePath);
         }
-        function tryGetModuleNameAsNodeModule(_a, _b, host, options, packageNameOnly) {
+        function tryGetModuleNameAsNodeModule(_a, _b, importingSourceFile, host, options, packageNameOnly) {
             var path = _a.path, isRedirect = _a.isRedirect;
             var getCanonicalFileName = _b.getCanonicalFileName, sourceDirectory = _b.sourceDirectory;
             if (!host.fileExists || !host.readFile) {
@@ -119697,11 +119829,19 @@ var ts;
                 var moduleFileToTry = path;
                 if (host.fileExists(packageJsonPath)) {
                     var packageJsonContent = JSON.parse(host.readFile(packageJsonPath));
-                    // TODO: Inject `require` or `import` condition based on the intended import mode
                     if (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12 || ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext) {
-                        var fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string" ? tryGetModuleNameFromExports(options, path, packageRootPath, packageJsonContent.name, packageJsonContent.exports, ["node", "types"]) : undefined;
+                        // `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", importingSourceFile.impliedNodeFormat === 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;
                         if (fromExports) {
-                            var withJsExtension = !ts.hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: ts.removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
+                            var withJsExtension = !ts.hasTSFileExtension(fromExports.moduleFileToTry)
+                                ? fromExports
+                                : { moduleFileToTry: ts.removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
                             return __assign(__assign({}, withJsExtension), { verbatimFromExports: true });
                         }
                         if (packageJsonContent.exports) {
@@ -119807,8 +119947,8 @@ var ts;
         }
         function getPathRelativeToRootDirs(path, rootDirs, getCanonicalFileName) {
             return ts.firstDefined(rootDirs, function (rootDir) {
-                var relativePath = getRelativePathIfInDirectory(path, rootDir, getCanonicalFileName); // TODO: GH#18217
-                return isPathRelativeToParent(relativePath) ? undefined : relativePath;
+                var relativePath = getRelativePathIfInDirectory(path, rootDir, getCanonicalFileName);
+                return relativePath !== undefined && isPathRelativeToParent(relativePath) ? undefined : relativePath;
             });
         }
         function removeExtensionAndIndexPostFix(fileName, ending, options) {
@@ -126020,7 +126160,7 @@ var ts;
             if (!ts.stringContains(importedFileName, "node_modules")) {
                 return undefined;
             }
-            var specifier = ts.moduleSpecifiers.getNodeModulesPackageName(host.getCompilationSettings(), fromFile.path, importedFileName, moduleSpecifierResolutionHost, preferences);
+            var specifier = ts.moduleSpecifiers.getNodeModulesPackageName(host.getCompilationSettings(), fromFile, importedFileName, moduleSpecifierResolutionHost, preferences);
             if (!specifier) {
                 return undefined;
             }
@@ -135666,7 +135806,7 @@ var ts;
                     : getSourceFileToImport(importedModuleSymbol, importLiteral, sourceFile, program, host, oldToNew);
                 // Need an update if the imported file moved, or the importing file moved and was using a relative path.
                 return toImport !== undefined && (toImport.updated || (importingSourceFileMoved && ts.pathIsRelative(importLiteral.text)))
-                    ? ts.moduleSpecifiers.updateModuleSpecifier(program.getCompilerOptions(), getCanonicalFileName(newImportFromPath), toImport.newFileName, ts.createModuleSpecifierResolutionHost(program, host), importLiteral.text)
+                    ? ts.moduleSpecifiers.updateModuleSpecifier(program.getCompilerOptions(), sourceFile, getCanonicalFileName(newImportFromPath), toImport.newFileName, ts.createModuleSpecifierResolutionHost(program, host), importLiteral.text)
                     : undefined;
             });
         };
@@ -137311,6 +137451,9 @@ var ts;
         // We use 1 NavNode to represent 'A.B.C', but there are multiple source nodes.
         // Only merge module nodes that have the same chain. Don't merge 'A.B.C' with 'A'!
         function areSameModule(a, b) {
+            if (!a.body || !b.body) {
+                return a.body === b.body;
+            }
             return a.body.kind === b.body.kind && (a.body.kind !== 260 /* ModuleDeclaration */ || areSameModule(a.body, b.body));
         }
         /** Merge source into target. Source should be thrown away after this is called. */
@@ -154525,7 +154668,7 @@ var ts;
                 defaultToNamedAction.kind,
                 namedToDefaultAction.kind
             ],
-            getAvailableActions: function (context) {
+            getAvailableActions: function getRefactorActionsToConvertBetweenNamedAndDefaultExports(context) {
                 var info = getInfo(context, context.triggerReason === "invoked");
                 if (!info)
                     return ts.emptyArray;
@@ -154543,7 +154686,7 @@ var ts;
                 }
                 return ts.emptyArray;
             },
-            getEditsForAction: function (context, actionName) {
+            getEditsForAction: function getRefactorEditsToConvertBetweenNamedAndDefaultExports(context, actionName) {
                 ts.Debug.assert(actionName === defaultToNamedAction.name || actionName === namedToDefaultAction.name, "Unexpected action name");
                 var info = getInfo(context);
                 ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info");
@@ -154771,7 +154914,7 @@ var ts;
                 namespaceToNamedAction.kind,
                 namedToNamespaceAction.kind
             ],
-            getAvailableActions: function (context) {
+            getAvailableActions: function getRefactorActionsToConvertBetweenNamedAndNamespacedImports(context) {
                 var info = getImportToConvert(context, context.triggerReason === "invoked");
                 if (!info)
                     return ts.emptyArray;
@@ -154790,7 +154933,7 @@ var ts;
                 }
                 return ts.emptyArray;
             },
-            getEditsForAction: function (context, actionName) {
+            getEditsForAction: function getRefactorEditsToConvertBetweenNamedAndNamespacedImports(context, actionName) {
                 ts.Debug.assert(actionName === namespaceToNamedAction.name || actionName === namedToNamespaceAction.name, "Unexpected action name");
                 var info = getImportToConvert(context);
                 ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info");
@@ -154956,10 +155099,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [toOptionalChainAction.kind],
-                getAvailableActions: getAvailableActions,
-                getEditsForAction: getEditsForAction
+                getEditsForAction: getRefactorEditsToConvertToOptionalChain,
+                getAvailableActions: getRefactorActionsToConvertToOptionalChain,
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToConvertToOptionalChain(context) {
                 var info = getInfo(context, context.triggerReason === "invoked");
                 if (!info)
                     return ts.emptyArray;
@@ -154979,7 +155122,7 @@ var ts;
                 }
                 return ts.emptyArray;
             }
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToConvertToOptionalChain(context, actionName) {
                 var info = getInfo(context);
                 ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info");
                 var edits = ts.textChanges.ChangeTracker.with(context, function (t) {
@@ -155222,10 +155365,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [functionOverloadAction.kind],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToConvertOverloadsToOneSignature,
+                getAvailableActions: getRefactorActionsToConvertOverloadsToOneSignature
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToConvertOverloadsToOneSignature(context) {
                 var file = context.file, startPosition = context.startPosition, program = context.program;
                 var info = getConvertableOverloadListAtPosition(file, startPosition, program);
                 if (!info)
@@ -155236,7 +155379,7 @@ var ts;
                         actions: [functionOverloadAction]
                     }];
             }
-            function getEditsForAction(context) {
+            function getRefactorEditsToConvertOverloadsToOneSignature(context) {
                 var file = context.file, startPosition = context.startPosition, program = context.program;
                 var signatureDecls = getConvertableOverloadListAtPosition(file, startPosition, program);
                 if (!signatureDecls)
@@ -155392,14 +155535,14 @@ var ts;
                     extractConstantAction.kind,
                     extractFunctionAction.kind
                 ],
-                getAvailableActions: getAvailableActions,
-                getEditsForAction: getEditsForAction
+                getEditsForAction: getRefactorEditsToExtractSymbol,
+                getAvailableActions: getRefactorActionsToExtractSymbol,
             });
             /**
              * Compute the associated code actions
              * Exported for tests.
              */
-            function getAvailableActions(context) {
+            function getRefactorActionsToExtractSymbol(context) {
                 var requestedRefactor = context.kind;
                 var rangeToExtract = getRangeToExtract(context.file, ts.getRefactorContextSpan(context), context.triggerReason === "invoked");
                 var targetRange = rangeToExtract.targetRange;
@@ -155528,9 +155671,9 @@ var ts;
                     return error;
                 }
             }
-            extractSymbol.getAvailableActions = getAvailableActions;
+            extractSymbol.getRefactorActionsToExtractSymbol = getRefactorActionsToExtractSymbol;
             /* Exported for tests */
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToExtractSymbol(context, actionName) {
                 var rangeToExtract = getRangeToExtract(context.file, ts.getRefactorContextSpan(context));
                 var targetRange = rangeToExtract.targetRange; // TODO:GH#18217
                 var parsedFunctionIndexMatch = /^function_scope_(\d+)$/.exec(actionName);
@@ -155547,7 +155690,7 @@ var ts;
                 }
                 ts.Debug.fail("Unrecognized action name");
             }
-            extractSymbol.getEditsForAction = getEditsForAction;
+            extractSymbol.getRefactorEditsToExtractSymbol = getRefactorEditsToExtractSymbol;
             // Move these into diagnostic messages if they become user-facing
             var Messages;
             (function (Messages) {
@@ -157098,7 +157241,7 @@ var ts;
                 extractToInterfaceAction.kind,
                 extractToTypeDefAction.kind
             ],
-            getAvailableActions: function (context) {
+            getAvailableActions: function getRefactorActionsToExtractType(context) {
                 var info = getRangeToExtract(context, context.triggerReason === "invoked");
                 if (!info)
                     return ts.emptyArray;
@@ -157123,7 +157266,7 @@ var ts;
                 }
                 return ts.emptyArray;
             },
-            getEditsForAction: function (context, actionName) {
+            getEditsForAction: function getRefactorEditsToExtractType(context, actionName) {
                 var file = context.file;
                 var info = getRangeToExtract(context);
                 ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected to find a range to extract");
@@ -157291,7 +157434,7 @@ var ts;
             };
             refactor.registerRefactor(actionName, {
                 kinds: [generateGetSetAction.kind],
-                getEditsForAction: function (context, actionName) {
+                getEditsForAction: function getRefactorActionsToGenerateGetAndSetAccessors(context, actionName) {
                     if (!context.endPosition)
                         return undefined;
                     var info = ts.codefix.getAccessorConvertiblePropertyAtPosition(context.file, context.program, context.startPosition, context.endPosition);
@@ -157370,7 +157513,7 @@ var ts;
         };
         refactor.registerRefactor(refactorName, {
             kinds: [moveToNewFileAction.kind],
-            getAvailableActions: function (context) {
+            getAvailableActions: function getRefactorActionsToMoveToNewFile(context) {
                 var statements = getStatementsToMove(context);
                 if (context.preferences.allowTextChangesInNewFiles && statements) {
                     return [{ name: refactorName, description: description, actions: [moveToNewFileAction] }];
@@ -157381,7 +157524,7 @@ var ts;
                 }
                 return ts.emptyArray;
             },
-            getEditsForAction: function (context, actionName) {
+            getEditsForAction: function getRefactorEditsToMoveToNewFile(context, actionName) {
                 ts.Debug.assert(actionName === refactorName, "Wrong refactor invoked");
                 var statements = ts.Debug.checkDefined(getStatementsToMove(context));
                 var edits = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(context.file, context.program, statements, t, context.host, context.preferences); });
@@ -158112,10 +158255,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [removeBracesAction.kind],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToRemoveFunctionBraces,
+                getAvailableActions: getRefactorActionsToRemoveFunctionBraces
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToRemoveFunctionBraces(context) {
                 var file = context.file, startPosition = context.startPosition, triggerReason = context.triggerReason;
                 var info = getConvertibleArrowFunctionAtPosition(file, startPosition, triggerReason === "invoked");
                 if (!info)
@@ -158141,7 +158284,7 @@ var ts;
                 }
                 return ts.emptyArray;
             }
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToRemoveFunctionBraces(context, actionName) {
                 var file = context.file, startPosition = context.startPosition;
                 var info = getConvertibleArrowFunctionAtPosition(file, startPosition);
                 ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info");
@@ -158215,10 +158358,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [toDestructuredAction.kind],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToConvertParametersToDestructuredObject,
+                getAvailableActions: getRefactorActionsToConvertParametersToDestructuredObject
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToConvertParametersToDestructuredObject(context) {
                 var file = context.file, startPosition = context.startPosition;
                 var isJSFile = ts.isSourceFileJS(file);
                 if (isJSFile)
@@ -158232,7 +158375,7 @@ var ts;
                         actions: [toDestructuredAction]
                     }];
             }
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToConvertParametersToDestructuredObject(context, actionName) {
                 ts.Debug.assert(actionName === refactorName, "Unexpected action name");
                 var file = context.file, startPosition = context.startPosition, program = context.program, cancellationToken = context.cancellationToken, host = context.host;
                 var functionDeclaration = getFunctionDeclarationAtPosition(file, startPosition, program.getTypeChecker());
@@ -158742,10 +158885,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [convertStringAction.kind],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToConvertToTemplateString,
+                getAvailableActions: getRefactorActionsToConvertToTemplateString
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToConvertToTemplateString(context) {
                 var file = context.file, startPosition = context.startPosition;
                 var node = getNodeOrParentOfParentheses(file, startPosition);
                 var maybeBinary = getParentBinaryExpression(node);
@@ -158771,7 +158914,7 @@ var ts;
                 }
                 return node;
             }
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToConvertToTemplateString(context, actionName) {
                 var file = context.file, startPosition = context.startPosition;
                 var node = getNodeOrParentOfParentheses(file, startPosition);
                 switch (actionName) {
@@ -158985,10 +159128,10 @@ var ts;
                     toNamedFunctionAction.kind,
                     toArrowFunctionAction.kind
                 ],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToConvertFunctionExpressions,
+                getAvailableActions: getRefactorActionsToConvertFunctionExpressions
             });
-            function getAvailableActions(context) {
+            function getRefactorActionsToConvertFunctionExpressions(context) {
                 var file = context.file, startPosition = context.startPosition, program = context.program, kind = context.kind;
                 var info = getFunctionInfo(file, startPosition, program);
                 if (!info)
@@ -159032,7 +159175,7 @@ var ts;
                             errors : possibleActions
                     }];
             }
-            function getEditsForAction(context, actionName) {
+            function getRefactorEditsToConvertFunctionExpressions(context, actionName) {
                 var file = context.file, startPosition = context.startPosition, program = context.program;
                 var info = getFunctionInfo(file, startPosition, program);
                 if (!info)
@@ -159192,10 +159335,10 @@ var ts;
             };
             refactor.registerRefactor(refactorName, {
                 kinds: [inferReturnTypeAction.kind],
-                getEditsForAction: getEditsForAction,
-                getAvailableActions: getAvailableActions
+                getEditsForAction: getRefactorEditsToInferReturnType,
+                getAvailableActions: getRefactorActionsToInferReturnType
             });
-            function getEditsForAction(context) {
+            function getRefactorEditsToInferReturnType(context) {
                 var info = getInfo(context);
                 if (info && !refactor.isRefactorErrorInfo(info)) {
                     var edits = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(context.file, t, info.declaration, info.returnTypeNode); });
@@ -159203,7 +159346,7 @@ var ts;
                 }
                 return undefined;
             }
-            function getAvailableActions(context) {
+            function getRefactorActionsToInferReturnType(context) {
                 var info = getInfo(context);
                 if (!info)
                     return ts.emptyArray;
@@ -166303,30 +166446,43 @@ var ts;
                     (_b = packageJson.peerDependencies) === null || _b === void 0 ? void 0 : _b.forEach(function (_, dependencyName) { return addDependency(dependencyName); });
                 }
                 if (dependencyNames) {
-                    var resolutions = ts.mapDefined(ts.arrayFrom(dependencyNames.keys()), function (name) {
-                        var types = ts.resolveTypeReferenceDirective(name, rootFileName, compilerOptions, moduleResolutionHost);
-                        if (types.resolvedTypeReferenceDirective) {
-                            return types.resolvedTypeReferenceDirective;
-                        }
-                        if (compilerOptions.allowJs && compilerOptions.maxNodeModuleJsDepth) {
-                            return ts.tryResolveJSModule(name, hostProject.currentDirectory, moduleResolutionHost);
-                        }
-                    });
+                    var dependenciesAdded = 0;
                     var symlinkCache = hostProject.getSymlinkCache();
-                    for (var _c = 0, resolutions_1 = resolutions; _c < resolutions_1.length; _c++) {
-                        var resolution = resolutions_1[_c];
-                        if (!resolution.resolvedFileName)
+                    for (var _c = 0, _d = ts.arrayFrom(dependencyNames.keys()); _c < _d.length; _c++) {
+                        var name = _d[_c];
+                        // Avoid creating a large project that would significantly slow down time to editor interactivity
+                        if (dependencySelection === 2 /* Auto */ && dependenciesAdded > this.maxDependencies) {
+                            hostProject.log("Auto-import provider attempted to add more than " + this.maxDependencies + " dependencies.");
+                            return ts.emptyArray;
+                        }
+                        // 1. Try to load from the implementation package. For many dependencies, the
+                        //    package.json will exist, but the package will not contain any typings,
+                        //    so `entrypoints` will be undefined. In that case, or if the dependency
+                        //    is missing altogether, we will move on to trying the @types package (2).
+                        var packageJson = ts.resolvePackageNameToPackageJson(name, hostProject.currentDirectory, compilerOptions, moduleResolutionHost, program.getModuleResolutionCache());
+                        if (packageJson) {
+                            var entrypoints = getRootNamesFromPackageJson(packageJson, program, symlinkCache);
+                            if (entrypoints) {
+                                rootNames = ts.concatenate(rootNames, entrypoints);
+                                dependenciesAdded += entrypoints.length ? 1 : 0;
+                                continue;
+                            }
+                        }
+                        // 2. Try to load from the @types package.
+                        var typesPackageJson = ts.resolvePackageNameToPackageJson("@types/" + name, hostProject.currentDirectory, compilerOptions, moduleResolutionHost, program.getModuleResolutionCache());
+                        if (typesPackageJson) {
+                            var entrypoints = getRootNamesFromPackageJson(typesPackageJson, program, symlinkCache);
+                            rootNames = ts.concatenate(rootNames, entrypoints);
+                            dependenciesAdded += (entrypoints === null || entrypoints === void 0 ? void 0 : entrypoints.length) ? 1 : 0;
                             continue;
-                        var resolvedFileName = resolution.resolvedFileName, originalPath = resolution.originalPath;
-                        if (originalPath) {
-                            symlinkCache.setSymlinkedDirectoryFromSymlinkedFile(originalPath, resolvedFileName);
                         }
-                        if (!program.getSourceFile(resolvedFileName) && (!originalPath || !program.getSourceFile(originalPath))) {
-                            rootNames = ts.append(rootNames, resolvedFileName);
-                            // Avoid creating a large project that would significantly slow down time to editor interactivity
-                            if (dependencySelection === 2 /* Auto */ && rootNames.length > this.maxDependencies) {
-                                return ts.emptyArray;
-                            }
+                        // 3. If the @types package did not exist and the user has settings that
+                        //    allow processing JS from node_modules, go back to the implementation
+                        //    package and load the JS.
+                        if (packageJson && compilerOptions.allowJs && compilerOptions.maxNodeModuleJsDepth) {
+                            var entrypoints = getRootNamesFromPackageJson(packageJson, program, symlinkCache, /*allowJs*/ true);
+                            rootNames = ts.concatenate(rootNames, entrypoints);
+                            dependenciesAdded += (entrypoints === null || entrypoints === void 0 ? void 0 : entrypoints.length) ? 1 : 0;
                         }
                     }
                 }
@@ -166336,6 +166492,26 @@ var ts;
                         (dependencyNames || (dependencyNames = new ts.Set())).add(dependency);
                     }
                 }
+                function getRootNamesFromPackageJson(packageJson, program, symlinkCache, resolveJs) {
+                    var _a;
+                    var entrypoints = ts.getEntrypointsFromPackageJsonInfo(packageJson, compilerOptions, moduleResolutionHost, program.getModuleResolutionCache(), resolveJs);
+                    if (entrypoints) {
+                        var real_1 = (_a = moduleResolutionHost.realpath) === null || _a === void 0 ? void 0 : _a.call(moduleResolutionHost, packageJson.packageDirectory);
+                        var isSymlink_1 = real_1 && real_1 !== packageJson.packageDirectory;
+                        if (isSymlink_1) {
+                            symlinkCache.setSymlinkedDirectory(packageJson.packageDirectory, {
+                                real: real_1,
+                                realPath: hostProject.toPath(real_1),
+                            });
+                        }
+                        return ts.mapDefined(entrypoints, function (entrypoint) {
+                            var resolvedFileName = isSymlink_1 ? entrypoint.replace(packageJson.packageDirectory, real_1) : entrypoint;
+                            if (!program.getSourceFile(resolvedFileName) && !(isSymlink_1 && program.getSourceFile(entrypoint))) {
+                                return resolvedFileName;
+                            }
+                        });
+                    }
+                }
             };
             /*@internal*/
             AutoImportProviderProject.create = function (dependencySelection, hostProject, moduleResolutionHost, documentRegistry) {