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

package/lib/typescript.js

@@ -294,7 +294,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) {
@@ -19985,16 +19985,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;
@@ -41703,9 +41693,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;
@@ -41790,6 +41778,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.
@@ -42363,11 +42379,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";
@@ -42675,6 +42686,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
      */
@@ -42731,7 +42833,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;
         }
@@ -43028,8 +43130,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;
@@ -50058,7 +50160,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);
                         }
@@ -52262,8 +52364,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;
@@ -57374,6 +57476,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);
@@ -57578,6 +57685,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);
@@ -57662,13 +57774,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 :
@@ -64332,6 +64438,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 */) {
@@ -83450,9 +83567,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;
@@ -90676,6 +90793,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 */:
@@ -93008,6 +93126,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);
             }
         }
@@ -119348,28 +119471,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) {
@@ -119436,7 +119568,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",
@@ -119828,7 +119960,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) {
@@ -119891,11 +120023,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) {
@@ -120001,8 +120141,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) {
@@ -126631,7 +126771,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;
             }
@@ -136277,7 +136417,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;
             });
         };
@@ -137922,6 +138062,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. */
@@ -155136,7 +155279,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;
@@ -155154,7 +155297,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");
@@ -155382,7 +155525,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;
@@ -155401,7 +155544,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");
@@ -155567,10 +155710,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;
@@ -155590,7 +155733,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) {
@@ -155833,10 +155976,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)
@@ -155847,7 +155990,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)
@@ -156003,14 +156146,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;
@@ -156139,9 +156282,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);
@@ -156158,7 +156301,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) {
@@ -157709,7 +157852,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;
@@ -157734,7 +157877,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");
@@ -157902,7 +158045,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);
@@ -157981,7 +158124,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] }];
@@ -157992,7 +158135,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); });
@@ -158723,10 +158866,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)
@@ -158752,7 +158895,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");
@@ -158826,10 +158969,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)
@@ -158843,7 +158986,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());
@@ -159353,10 +159496,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);
@@ -159382,7 +159525,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) {
@@ -159596,10 +159739,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)
@@ -159643,7 +159786,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)
@@ -159803,10 +159946,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); });
@@ -159814,7 +159957,7 @@ var ts;
                 }
                 return undefined;
             }
-            function getAvailableActions(context) {
+            function getRefactorActionsToInferReturnType(context) {
                 var info = getInfo(context);
                 if (!info)
                     return ts.emptyArray;