@typescript-deploys/pr-build 4.7.0-pr-47657-5 → 4.7.0-pr-48264-3

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-insiders.20220311";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220315";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -1468,6 +1468,159 @@ var ts;
         return createMultiMap();
     }
     ts.createUnderscoreEscapedMultiMap = createUnderscoreEscapedMultiMap;
+    /**
+     * Creates a Set with custom equality and hash code functionality.  This is useful when you
+     * want to use something looser than object identity - e.g. "has the same span".
+     *
+     * If `equals(a, b)`, it must be the case that `getHashCode(a) === getHashCode(b)`.
+     * The converse is not required.
+     *
+     * To facilitate a perf optimization (lazy allocation of bucket arrays), `TElement` is
+     * assumed not to be an array type.
+     */
+    function createSet(getHashCode, equals) {
+        var multiMap = new ts.Map();
+        var size = 0;
+        function getElementIterator() {
+            var valueIt = multiMap.values();
+            var arrayIt;
+            return {
+                next: function () {
+                    while (true) {
+                        if (arrayIt) {
+                            var n = arrayIt.next();
+                            if (!n.done) {
+                                return { value: n.value };
+                            }
+                            arrayIt = undefined;
+                        }
+                        else {
+                            var n = valueIt.next();
+                            if (n.done) {
+                                return { value: undefined, done: true };
+                            }
+                            if (!isArray(n.value)) {
+                                return { value: n.value };
+                            }
+                            arrayIt = arrayIterator(n.value);
+                        }
+                    }
+                }
+            };
+        }
+        var set = {
+            has: function (element) {
+                var hash = getHashCode(element);
+                if (!multiMap.has(hash))
+                    return false;
+                var candidates = multiMap.get(hash);
+                if (!isArray(candidates))
+                    return equals(candidates, element);
+                for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) {
+                    var candidate = candidates_1[_i];
+                    if (equals(candidate, element)) {
+                        return true;
+                    }
+                }
+                return false;
+            },
+            add: function (element) {
+                var hash = getHashCode(element);
+                if (multiMap.has(hash)) {
+                    var values = multiMap.get(hash);
+                    if (isArray(values)) {
+                        if (!contains(values, element, equals)) {
+                            values.push(element);
+                            size++;
+                        }
+                    }
+                    else {
+                        var value = values;
+                        if (!equals(value, element)) {
+                            multiMap.set(hash, [value, element]);
+                            size++;
+                        }
+                    }
+                }
+                else {
+                    multiMap.set(hash, element);
+                    size++;
+                }
+                return this;
+            },
+            delete: function (element) {
+                var hash = getHashCode(element);
+                if (!multiMap.has(hash))
+                    return false;
+                var candidates = multiMap.get(hash);
+                if (isArray(candidates)) {
+                    for (var i = 0; i < candidates.length; i++) {
+                        if (equals(candidates[i], element)) {
+                            if (candidates.length === 1) {
+                                multiMap.delete(hash);
+                            }
+                            else if (candidates.length === 2) {
+                                multiMap.set(hash, candidates[1 - i]);
+                            }
+                            else {
+                                unorderedRemoveItemAt(candidates, i);
+                            }
+                            size--;
+                            return true;
+                        }
+                    }
+                }
+                else {
+                    var candidate = candidates;
+                    if (equals(candidate, element)) {
+                        multiMap.delete(hash);
+                        size--;
+                        return true;
+                    }
+                }
+                return false;
+            },
+            clear: function () {
+                multiMap.clear();
+                size = 0;
+            },
+            get size() {
+                return size;
+            },
+            forEach: function (action) {
+                for (var _i = 0, _a = arrayFrom(multiMap.values()); _i < _a.length; _i++) {
+                    var elements = _a[_i];
+                    if (isArray(elements)) {
+                        for (var _b = 0, elements_1 = elements; _b < elements_1.length; _b++) {
+                            var element = elements_1[_b];
+                            action(element, element);
+                        }
+                    }
+                    else {
+                        var element = elements;
+                        action(element, element);
+                    }
+                }
+            },
+            keys: function () {
+                return getElementIterator();
+            },
+            values: function () {
+                return getElementIterator();
+            },
+            entries: function () {
+                var it = getElementIterator();
+                return {
+                    next: function () {
+                        var n = it.next();
+                        return n.done ? n : { value: [n.value, n.value] };
+                    }
+                };
+            },
+        };
+        return set;
+    }
+    ts.createSet = createSet;
     /**
      * Tests whether a value is an array.
      */
@@ -1861,8 +2014,8 @@ var ts;
         var maximumLengthDifference = Math.min(2, Math.floor(name.length * 0.34));
         var bestDistance = Math.floor(name.length * 0.4) + 1; // If the best result is worse than this, don't bother.
         var bestCandidate;
-        for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) {
-            var candidate = candidates_1[_i];
+        for (var _i = 0, candidates_2 = candidates; _i < candidates_2.length; _i++) {
+            var candidate = candidates_2[_i];
             var candidateName = getName(candidate);
             if (candidateName !== undefined && Math.abs(candidateName.length - name.length) <= maximumLengthDifference) {
                 if (candidateName === name) {
@@ -14797,6 +14950,10 @@ var ts;
         }
     }
     ts.isAnyImportSyntax = isAnyImportSyntax;
+    function isAnyImportOrBareOrAccessedRequire(node) {
+        return isAnyImportSyntax(node) || isVariableDeclarationInitializedToBareOrAccessedRequire(node);
+    }
+    ts.isAnyImportOrBareOrAccessedRequire = isAnyImportOrBareOrAccessedRequire;
     function isLateVisibilityPaintedStatement(node) {
         switch (node.kind) {
             case 265 /* ImportDeclaration */:
@@ -16375,14 +16532,14 @@ var ts;
     }
     ts.isFunctionSymbol = isFunctionSymbol;
     function tryGetModuleSpecifierFromDeclaration(node) {
-        var _a, _b, _c;
+        var _a, _b;
         switch (node.kind) {
             case 253 /* VariableDeclaration */:
-                return node.initializer.arguments[0].text;
+                return (_a = ts.findAncestor(node.initializer, function (node) { return isRequireCall(node, /*requireStringLiteralLikeArgument*/ true); })) === null || _a === void 0 ? void 0 : _a.arguments[0];
             case 265 /* ImportDeclaration */:
-                return (_a = ts.tryCast(node.moduleSpecifier, ts.isStringLiteralLike)) === null || _a === void 0 ? void 0 : _a.text;
+                return ts.tryCast(node.moduleSpecifier, ts.isStringLiteralLike);
             case 264 /* ImportEqualsDeclaration */:
-                return (_c = ts.tryCast((_b = ts.tryCast(node.moduleReference, ts.isExternalModuleReference)) === null || _b === void 0 ? void 0 : _b.expression, ts.isStringLiteralLike)) === null || _c === void 0 ? void 0 : _c.text;
+                return ts.tryCast((_b = ts.tryCast(node.moduleReference, ts.isExternalModuleReference)) === null || _b === void 0 ? void 0 : _b.expression, ts.isStringLiteralLike);
             default:
                 ts.Debug.assertNever(node);
         }
@@ -16909,21 +17066,28 @@ var ts;
     // export = <EntityNameExpression>
     // export default <EntityNameExpression>
     // module.exports = <EntityNameExpression>
-    // {<Identifier>}
-    // {name: <EntityNameExpression>}
+    // module.exports.x = <EntityNameExpression>
+    // const x = require("...")
+    // const { x } = require("...")
+    // const x = require("...").y
+    // const { x } = require("...").y
     function isAliasSymbolDeclaration(node) {
-        return node.kind === 264 /* ImportEqualsDeclaration */ ||
+        if (node.kind === 264 /* ImportEqualsDeclaration */ ||
             node.kind === 263 /* NamespaceExportDeclaration */ ||
             node.kind === 266 /* ImportClause */ && !!node.name ||
             node.kind === 267 /* NamespaceImport */ ||
             node.kind === 273 /* NamespaceExport */ ||
             node.kind === 269 /* ImportSpecifier */ ||
             node.kind === 274 /* ExportSpecifier */ ||
-            node.kind === 270 /* ExportAssignment */ && exportAssignmentIsAlias(node) ||
-            ts.isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 2 /* ModuleExports */ && exportAssignmentIsAlias(node) ||
-            ts.isPropertyAccessExpression(node) && ts.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 63 /* EqualsToken */ && isAliasableExpression(node.parent.right) ||
-            node.kind === 296 /* ShorthandPropertyAssignment */ ||
-            node.kind === 295 /* PropertyAssignment */ && isAliasableExpression(node.initializer);
+            node.kind === 270 /* ExportAssignment */ && exportAssignmentIsAlias(node)) {
+            return true;
+        }
+        return isInJSFile(node) && (ts.isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 2 /* ModuleExports */ && exportAssignmentIsAlias(node) ||
+            ts.isPropertyAccessExpression(node)
+                && ts.isBinaryExpression(node.parent)
+                && node.parent.left === node
+                && node.parent.operatorToken.kind === 63 /* EqualsToken */
+                && isAliasableExpression(node.parent.right));
     }
     ts.isAliasSymbolDeclaration = isAliasSymbolDeclaration;
     function getAliasDeclarationFromName(node) {
@@ -16934,6 +17098,7 @@ var ts;
             case 274 /* ExportSpecifier */:
             case 270 /* ExportAssignment */:
             case 264 /* ImportEqualsDeclaration */:
+            case 273 /* NamespaceExport */:
                 return node.parent;
             case 160 /* QualifiedName */:
                 do {
@@ -39281,6 +39446,13 @@ var ts;
             description: ts.Diagnostics.Allow_accessing_UMD_globals_from_modules,
             defaultValueDescription: false,
         },
+        {
+            name: "noDtsResolution",
+            type: "boolean",
+            affectsModuleResolution: true,
+            category: ts.Diagnostics.Modules,
+            defaultValueDescription: false,
+        },
         // Source Maps
         {
             name: "sourceRoot",
@@ -41660,7 +41832,8 @@ var ts;
         Extensions[Extensions["JavaScript"] = 1] = "JavaScript";
         Extensions[Extensions["Json"] = 2] = "Json";
         Extensions[Extensions["TSConfig"] = 3] = "TSConfig";
-        Extensions[Extensions["DtsOnly"] = 4] = "DtsOnly"; /** Only '.d.ts' */
+        Extensions[Extensions["DtsOnly"] = 4] = "DtsOnly";
+        Extensions[Extensions["TypeScriptButNotDts"] = 5] = "TypeScriptButNotDts";
     })(Extensions || (Extensions = {}));
     /** Used with `Extensions.DtsOnly` to extract the path from TypeScript results. */
     function resolvedTypeScriptOnly(resolved) {
@@ -42605,7 +42778,21 @@ var ts;
         return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, initialDir, { moduleResolution: ts.ModuleResolutionKind.NodeJs, allowJs: true }, host, /*cache*/ undefined, jsOnlyExtensions, /*redirectedReferences*/ undefined);
     }
     function nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, lookupConfig) {
-        return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, ts.getDirectoryPath(containingFile), compilerOptions, host, cache, lookupConfig ? tsconfigExtensions : (compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions), redirectedReference);
+        var extensions;
+        if (lookupConfig) {
+            extensions = tsconfigExtensions;
+        }
+        else if (compilerOptions.noDtsResolution) {
+            extensions = [Extensions.TypeScriptButNotDts];
+            if (compilerOptions.allowJs)
+                extensions.push(Extensions.JavaScript);
+            if (compilerOptions.resolveJsonModule)
+                extensions.push(Extensions.Json);
+        }
+        else {
+            extensions = compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions;
+        }
+        return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, ts.getDirectoryPath(containingFile), compilerOptions, host, cache, extensions, redirectedReference);
     }
     ts.nodeModuleNameResolver = nodeModuleNameResolver;
     function nodeModuleNameResolverWorker(features, moduleName, containingDirectory, compilerOptions, host, cache, extensions, redirectedReference) {
@@ -42614,6 +42801,10 @@ var ts;
         var failedLookupLocations = [];
         // conditions are only used by the node12/nodenext resolver - there's no priority order in the list,
         //it's essentially a set (priority is determined by object insertion order in the object we look at).
+        var conditions = features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"];
+        if (compilerOptions.noDtsResolution) {
+            conditions.pop();
+        }
         var state = {
             compilerOptions: compilerOptions,
             host: host,
@@ -42621,7 +42812,7 @@ var ts;
             failedLookupLocations: failedLookupLocations,
             packageJsonInfoCache: cache,
             features: features,
-            conditions: features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"]
+            conditions: conditions,
         };
         var result = ts.forEach(extensions, function (ext) { return tryResolve(ext); });
         return createResolvedModuleWithFailedLookupLocations((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, state.resultFromCache);
@@ -42829,20 +43020,22 @@ var ts;
                     default: return tryExtension(".d.ts" /* Dts */);
                 }
             case Extensions.TypeScript:
+            case Extensions.TypeScriptButNotDts:
+                var useDts = extensions === Extensions.TypeScript;
                 switch (originalExtension) {
                     case ".mjs" /* Mjs */:
                     case ".mts" /* Mts */:
                     case ".d.mts" /* Dmts */:
-                        return tryExtension(".mts" /* Mts */) || tryExtension(".d.mts" /* Dmts */);
+                        return tryExtension(".mts" /* Mts */) || (useDts ? tryExtension(".d.mts" /* Dmts */) : undefined);
                     case ".cjs" /* Cjs */:
                     case ".cts" /* Cts */:
                     case ".d.cts" /* Dcts */:
-                        return tryExtension(".cts" /* Cts */) || tryExtension(".d.cts" /* Dcts */);
+                        return tryExtension(".cts" /* Cts */) || (useDts ? tryExtension(".d.cts" /* Dcts */) : undefined);
                     case ".json" /* Json */:
                         candidate += ".json" /* Json */;
-                        return tryExtension(".d.ts" /* Dts */);
+                        return useDts ? tryExtension(".d.ts" /* Dts */) : undefined;
                     default:
-                        return tryExtension(".ts" /* Ts */) || tryExtension(".tsx" /* Tsx */) || tryExtension(".d.ts" /* Dts */);
+                        return tryExtension(".ts" /* Ts */) || tryExtension(".tsx" /* Tsx */) || (useDts ? tryExtension(".d.ts" /* Dts */) : undefined);
                 }
             case Extensions.JavaScript:
                 switch (originalExtension) {
@@ -43060,6 +43253,7 @@ var ts;
             switch (extensions) {
                 case Extensions.JavaScript:
                 case Extensions.Json:
+                case Extensions.TypeScriptButNotDts:
                     packageFile = readPackageJsonMainField(jsonContent, candidate, state);
                     break;
                 case Extensions.TypeScript:
@@ -43138,6 +43332,8 @@ var ts;
                 return extension === ".json" /* Json */;
             case Extensions.TypeScript:
                 return extension === ".ts" /* Ts */ || extension === ".tsx" /* Tsx */ || extension === ".d.ts" /* Dts */;
+            case Extensions.TypeScriptButNotDts:
+                return extension === ".ts" /* Ts */ || extension === ".tsx" /* Tsx */;
             case Extensions.DtsOnly:
                 return extension === ".d.ts" /* Dts */;
         }
@@ -44607,7 +44803,6 @@ var ts;
                 node = node.parent;
             }
             return !isStatementCondition(node) &&
-                !isLogicalAssignmentExpression(node.parent) &&
                 !isLogicalExpression(node.parent) &&
                 !(ts.isOptionalChain(node.parent) && node.parent.expression === node);
         }
@@ -46637,7 +46832,7 @@ var ts;
                 checkStrictModeEvalOrArguments(node, node.name);
             }
             if (!ts.isBindingPattern(node.name)) {
-                if (ts.isInJSFile(node) && ts.isVariableDeclarationInitializedToBareOrAccessedRequire(node) && !ts.getJSDocTypeTag(node)) {
+                if (ts.isInJSFile(node) && ts.isVariableDeclarationInitializedToBareOrAccessedRequire(node) && !ts.getJSDocTypeTag(node) && !(ts.getCombinedModifierFlags(node) & 1 /* Export */)) {
                     declareSymbolAndAddToSymbolTable(node, 2097152 /* Alias */, 2097152 /* AliasExcludes */);
                 }
                 else if (ts.isBlockOrCatchScoped(node)) {
@@ -55207,7 +55402,7 @@ var ts;
                         }
                     }
                     var sourceTypes = ts.some(constructorTypes, function (t) { return !!(t.flags & ~98304 /* Nullable */); }) ? constructorTypes : types; // TODO: GH#18217
-                    type = getUnionType(sourceTypes, 2 /* Subtype */);
+                    type = getUnionType(sourceTypes);
                 }
             }
             var widened = getWidenedType(addOptionality(type, /*isProperty*/ false, definedInMethod && !definedInConstructor));
@@ -87541,8 +87736,8 @@ var ts;
             }
             else {
                 var elements = name.elements;
-                for (var _i = 0, elements_1 = elements; _i < elements_1.length; _i++) {
-                    var element = elements_1[_i];
+                for (var _i = 0, elements_2 = elements; _i < elements_2.length; _i++) {
+                    var element = elements_2[_i];
                     if (!ts.isOmittedExpression(element)) {
                         return checkESModuleMarker(element.name);
                     }
@@ -87558,8 +87753,8 @@ var ts;
             }
             else {
                 var elements = name.elements;
-                for (var _i = 0, elements_2 = elements; _i < elements_2.length; _i++) {
-                    var element = elements_2[_i];
+                for (var _i = 0, elements_3 = elements; _i < elements_3.length; _i++) {
+                    var element = elements_3[_i];
                     if (!ts.isOmittedExpression(element)) {
                         checkGrammarNameInLetOrConstDeclarations(element.name);
                     }
@@ -89813,8 +90008,8 @@ var ts;
     }
     function bindingOrAssignmentPatternAssignsToName(pattern, escapedName) {
         var elements = ts.getElementsOfBindingOrAssignmentPattern(pattern);
-        for (var _i = 0, elements_3 = elements; _i < elements_3.length; _i++) {
-            var element = elements_3[_i];
+        for (var _i = 0, elements_4 = elements; _i < elements_4.length; _i++) {
+            var element = elements_4[_i];
             if (bindingOrAssignmentElementAssignsToName(element, escapedName)) {
                 return true;
             }
@@ -95432,8 +95627,8 @@ var ts;
         function chunkObjectLiteralElements(elements) {
             var chunkObject;
             var objects = [];
-            for (var _i = 0, elements_4 = elements; _i < elements_4.length; _i++) {
-                var e = elements_4[_i];
+            for (var _i = 0, elements_5 = elements; _i < elements_5.length; _i++) {
+                var e = elements_5[_i];
                 if (e.kind === 297 /* SpreadAssignment */) {
                     if (chunkObject) {
                         objects.push(factory.createObjectLiteralExpression(chunkObject));
@@ -126834,6 +127029,20 @@ var ts;
         return !!location.parent && ts.isImportOrExportSpecifier(location.parent) && location.parent.propertyName === location;
     }
     ts.isImportOrExportSpecifierName = isImportOrExportSpecifierName;
+    /**
+     * Returns true if `node` is the declaration of `n` in:
+     * - `import n from "m"`
+     * - `import * as n from "m"`
+     * - `import n = require("m")`
+     * - `const n = require("m")`
+     */
+    function isFreelyNameableImport(node) {
+        return node.kind === 266 /* ImportClause */
+            || node.kind === 267 /* NamespaceImport */
+            || ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference)
+            || ts.isVariableDeclarationInitializedToRequire(node);
+    }
+    ts.isFreelyNameableImport = isFreelyNameableImport;
     function getScriptKind(fileName, host) {
         // First check to see if the script kind was specified by the host. Chances are the host
         // may override the default script kind for the file extension.
@@ -135848,6 +136057,29 @@ var ts;
                 }
             }
             Core.eachSymbolReferenceInFile = eachSymbolReferenceInFile;
+            function getTopMostDeclarationNamesInFile(declarationName, sourceFile) {
+                var candidates = ts.filter(getPossibleSymbolReferenceNodes(sourceFile, declarationName), function (name) { return !!ts.getDeclarationFromName(name); });
+                return candidates.reduce(function (topMost, decl) {
+                    var depth = getDepth(decl);
+                    if (!ts.some(topMost.declarationNames) || depth === topMost.depth) {
+                        topMost.declarationNames.push(decl);
+                    }
+                    else if (depth < topMost.depth) {
+                        topMost.declarationNames = [decl];
+                    }
+                    topMost.depth = depth;
+                    return topMost;
+                }, { depth: Infinity, declarationNames: [] }).declarationNames;
+                function getDepth(declaration) {
+                    var depth = 0;
+                    while (declaration) {
+                        declaration = ts.getContainerNode(declaration);
+                        depth++;
+                    }
+                    return depth;
+                }
+            }
+            Core.getTopMostDeclarationNamesInFile = getTopMostDeclarationNamesInFile;
             function someSignatureUsage(signature, sourceFiles, checker, cb) {
                 if (!signature.name || !ts.isIdentifier(signature.name))
                     return false;
@@ -137480,7 +137712,9 @@ var ts;
 (function (ts) {
     var GoToDefinition;
     (function (GoToDefinition) {
-        function getDefinitionAtPosition(program, sourceFile, position) {
+        function getDefinitionAtPosition(program, sourceFile, position, aliasesOnly) {
+            var _a;
+            var _b;
             var resolvedRef = getReferenceAtPosition(sourceFile, position, program);
             var fileReferenceDefinition = resolvedRef && [getDefinitionInfoForFileReference(resolvedRef.reference.fileName, resolvedRef.fileName, resolvedRef.unverified)] || ts.emptyArray;
             if (resolvedRef === null || resolvedRef === void 0 ? void 0 : resolvedRef.file) {
@@ -137503,17 +137737,50 @@ var ts;
             }
             if (ts.isStaticModifier(node) && ts.isClassStaticBlockDeclaration(node.parent)) {
                 var classDecl = node.parent.parent;
-                var symbol_1 = getSymbol(classDecl, typeChecker);
+                var _c = getSymbol(classDecl, typeChecker), symbol_1 = _c.symbol, isAliasTarget_1 = _c.isAliasTarget, failedAliasResolution_1 = _c.failedAliasResolution;
+                if (aliasesOnly && !isAliasTarget_1)
+                    return undefined;
                 var staticBlocks = ts.filter(classDecl.members, ts.isClassStaticBlockDeclaration);
                 var containerName_1 = symbol_1 ? typeChecker.symbolToString(symbol_1, classDecl) : "";
                 var sourceFile_1 = node.getSourceFile();
                 return ts.map(staticBlocks, function (staticBlock) {
                     var pos = ts.moveRangePastModifiers(staticBlock).pos;
                     pos = ts.skipTrivia(sourceFile_1.text, pos);
-                    return createDefinitionInfoFromName(typeChecker, staticBlock, "constructor" /* constructorImplementationElement */, "static {}", containerName_1, { start: pos, length: "static".length });
+                    return createDefinitionInfoFromName(typeChecker, staticBlock, "constructor" /* constructorImplementationElement */, "static {}", containerName_1, isAliasTarget_1, failedAliasResolution_1, { start: pos, length: "static".length });
                 });
             }
-            var symbol = getSymbol(node, typeChecker);
+            var _d = getSymbol(node, typeChecker), symbol = _d.symbol, isAliasTarget = _d.isAliasTarget, failedAliasResolution = _d.failedAliasResolution;
+            var fallbackNode = node;
+            if (aliasesOnly && failedAliasResolution) {
+                // We couldn't resolve the specific import, try on the module specifier.
+                var importDeclaration = ts.findAncestor(node, ts.isAnyImportOrBareOrAccessedRequire);
+                var moduleSpecifier = importDeclaration && ts.tryGetModuleSpecifierFromDeclaration(importDeclaration);
+                if (moduleSpecifier) {
+                    (_a = getSymbol(moduleSpecifier, typeChecker), symbol = _a.symbol, isAliasTarget = _a.isAliasTarget, failedAliasResolution = _a.failedAliasResolution);
+                    fallbackNode = moduleSpecifier;
+                }
+            }
+            if (!symbol && ts.isModuleSpecifierLike(fallbackNode)) {
+                // We couldn't resolve the module specifier as an external module, but it could
+                // be that module resolution succeeded but the target was not a module.
+                var ref = (_b = sourceFile.resolvedModules) === null || _b === void 0 ? void 0 : _b.get(fallbackNode.text, ts.getModeForUsageLocation(sourceFile, fallbackNode));
+                if (ref) {
+                    return [{
+                            name: fallbackNode.text,
+                            fileName: ref.resolvedFileName,
+                            containerName: undefined,
+                            containerKind: undefined,
+                            kind: "script" /* scriptElement */,
+                            textSpan: ts.createTextSpan(0, 0),
+                            isAliasTarget: true,
+                            failedAliasResolution: failedAliasResolution,
+                            isAmbient: ts.isDeclarationFileName(ref.resolvedFileName),
+                            unverified: fallbackNode !== node,
+                        }];
+                }
+            }
+            if (aliasesOnly && !isAliasTarget)
+                return undefined;
             // Could not find a symbol e.g. node is string or number keyword,
             // or the symbol was an internal symbol and does not have a declaration e.g. undefined symbol
             if (!symbol) {
@@ -137522,14 +137789,14 @@ var ts;
             var calledDeclaration = tryGetSignatureDeclaration(typeChecker, node);
             // Don't go to the component constructor definition for a JSX element, just go to the component definition.
             if (calledDeclaration && !(ts.isJsxOpeningLikeElement(node.parent) && isConstructorLike(calledDeclaration))) {
-                var sigInfo = createDefinitionFromSignatureDeclaration(typeChecker, calledDeclaration);
+                var sigInfo = createDefinitionFromSignatureDeclaration(typeChecker, calledDeclaration, isAliasTarget, failedAliasResolution);
                 // For a function, if this is the original function definition, return just sigInfo.
                 // If this is the original constructor definition, parent is the class.
                 if (typeChecker.getRootSymbols(symbol).some(function (s) { return symbolMatchesSignature(s, calledDeclaration); })) {
                     return [sigInfo];
                 }
                 else {
-                    var defs = getDefinitionFromSymbol(typeChecker, symbol, node, calledDeclaration) || ts.emptyArray;
+                    var defs = getDefinitionFromSymbol(typeChecker, symbol, node, isAliasTarget, failedAliasResolution, calledDeclaration) || ts.emptyArray;
                     // For a 'super()' call, put the signature first, else put the variable first.
                     return node.kind === 106 /* SuperKeyword */ ? __spreadArray([sigInfo], defs, true) : __spreadArray(__spreadArray([], defs, true), [sigInfo], false);
                 }
@@ -137541,7 +137808,7 @@ var ts;
             // assignment. This case and others are handled by the following code.
             if (node.parent.kind === 296 /* ShorthandPropertyAssignment */) {
                 var shorthandSymbol_1 = typeChecker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration);
-                var definitions = (shorthandSymbol_1 === null || shorthandSymbol_1 === void 0 ? void 0 : shorthandSymbol_1.declarations) ? shorthandSymbol_1.declarations.map(function (decl) { return createDefinitionInfo(decl, typeChecker, shorthandSymbol_1, node); }) : ts.emptyArray;
+                var definitions = (shorthandSymbol_1 === null || shorthandSymbol_1 === void 0 ? void 0 : shorthandSymbol_1.declarations) ? shorthandSymbol_1.declarations.map(function (decl) { return createDefinitionInfo(decl, typeChecker, shorthandSymbol_1, node, isAliasTarget, failedAliasResolution); }) : ts.emptyArray;
                 return ts.concatenate(definitions, getDefinitionFromObjectLiteralElement(typeChecker, node) || ts.emptyArray);
             }
             // If the node is the name of a BindingElement within an ObjectBindingPattern instead of just returning the
@@ -137564,7 +137831,7 @@ var ts;
                     return prop && getDefinitionFromSymbol(typeChecker, prop, node);
                 });
             }
-            return ts.concatenate(fileReferenceDefinition, getDefinitionFromObjectLiteralElement(typeChecker, node) || getDefinitionFromSymbol(typeChecker, symbol, node));
+            return ts.concatenate(fileReferenceDefinition, getDefinitionFromObjectLiteralElement(typeChecker, node) || getDefinitionFromSymbol(typeChecker, symbol, node, isAliasTarget, failedAliasResolution));
         }
         GoToDefinition.getDefinitionAtPosition = getDefinitionAtPosition;
         /**
@@ -137662,24 +137929,24 @@ var ts;
                 return undefined;
             }
             if (ts.isImportMeta(node.parent) && node.parent.name === node) {
-                return definitionFromType(typeChecker.getTypeAtLocation(node.parent), typeChecker, node.parent);
+                return definitionFromType(typeChecker.getTypeAtLocation(node.parent), typeChecker, node.parent, /*isAliasTarget*/ false, /*failedAliasResolution*/ false);
             }
-            var symbol = getSymbol(node, typeChecker);
+            var _a = getSymbol(node, typeChecker), symbol = _a.symbol, isAliasTarget = _a.isAliasTarget, failedAliasResolution = _a.failedAliasResolution;
             if (!symbol)
                 return undefined;
             var typeAtLocation = typeChecker.getTypeOfSymbolAtLocation(symbol, node);
             var returnType = tryGetReturnTypeOfFunction(symbol, typeAtLocation, typeChecker);
-            var fromReturnType = returnType && definitionFromType(returnType, typeChecker, node);
+            var fromReturnType = returnType && definitionFromType(returnType, typeChecker, node, isAliasTarget, failedAliasResolution);
             // If a function returns 'void' or some other type with no definition, just return the function definition.
-            var typeDefinitions = fromReturnType && fromReturnType.length !== 0 ? fromReturnType : definitionFromType(typeAtLocation, typeChecker, node);
+            var typeDefinitions = fromReturnType && fromReturnType.length !== 0 ? fromReturnType : definitionFromType(typeAtLocation, typeChecker, node, isAliasTarget, failedAliasResolution);
             return typeDefinitions.length ? typeDefinitions
-                : !(symbol.flags & 111551 /* Value */) && symbol.flags & 788968 /* Type */ ? getDefinitionFromSymbol(typeChecker, ts.skipAlias(symbol, typeChecker), node)
+                : !(symbol.flags & 111551 /* Value */) && symbol.flags & 788968 /* Type */ ? getDefinitionFromSymbol(typeChecker, ts.skipAlias(symbol, typeChecker), node, isAliasTarget, failedAliasResolution)
                     : undefined;
         }
         GoToDefinition.getTypeDefinitionAtPosition = getTypeDefinitionAtPosition;
-        function definitionFromType(type, checker, node) {
+        function definitionFromType(type, checker, node, isAliasTarget, failedAliasResolution) {
             return ts.flatMap(type.isUnion() && !(type.flags & 32 /* Enum */) ? type.types : [type], function (t) {
-                return t.symbol && getDefinitionFromSymbol(checker, t.symbol, node);
+                return t.symbol && getDefinitionFromSymbol(checker, t.symbol, node, isAliasTarget, failedAliasResolution);
             });
         }
         function tryGetReturnTypeOfFunction(symbol, type, checker) {
@@ -137694,8 +137961,8 @@ var ts;
             }
             return undefined;
         }
-        function getDefinitionAndBoundSpan(program, sourceFile, position) {
-            var definitions = getDefinitionAtPosition(program, sourceFile, position);
+        function getDefinitionAndBoundSpan(program, sourceFile, position, aliasesOnly) {
+            var definitions = getDefinitionAtPosition(program, sourceFile, position, aliasesOnly);
             if (!definitions || definitions.length === 0) {
                 return undefined;
             }
@@ -137721,13 +137988,17 @@ var ts;
             // get the aliased symbol instead. This allows for goto def on an import e.g.
             //   import {A, B} from "mod";
             // to jump to the implementation directly.
+            var failedAliasResolution = false;
             if ((symbol === null || symbol === void 0 ? void 0 : symbol.declarations) && symbol.flags & 2097152 /* Alias */ && shouldSkipAlias(node, symbol.declarations[0])) {
                 var aliased = checker.getAliasedSymbol(symbol);
                 if (aliased.declarations) {
-                    return aliased;
+                    return { symbol: aliased, isAliasTarget: true };
+                }
+                else {
+                    failedAliasResolution = true;
                 }
             }
-            return symbol;
+            return { symbol: symbol, isAliasTarget: !!(symbol && ts.isExternalModuleSymbol(symbol)), failedAliasResolution: failedAliasResolution };
         }
         // Go to the original declaration for cases:
         //
@@ -137741,26 +138012,45 @@ var ts;
             if (node.parent === declaration) {
                 return true;
             }
-            switch (declaration.kind) {
-                case 266 /* ImportClause */:
-                case 264 /* ImportEqualsDeclaration */:
-                    return true;
-                case 269 /* ImportSpecifier */:
-                    return declaration.parent.kind === 268 /* NamedImports */;
-                case 202 /* BindingElement */:
-                case 253 /* VariableDeclaration */:
-                    return ts.isInJSFile(declaration) && ts.isVariableDeclarationInitializedToBareOrAccessedRequire(declaration);
-                default:
-                    return false;
+            if (declaration.kind === 267 /* NamespaceImport */) {
+                return false;
             }
+            return true;
+        }
+        /**
+         * ```ts
+         * function f() {}
+         * f.foo = 0;
+         * ```
+         *
+         * Here, `f` has two declarations: the function declaration, and the identifier in the next line.
+         * The latter is a declaration for `f` because it gives `f` the `SymbolFlags.Namespace` meaning so
+         * it can contain `foo`. However, that declaration is pretty uninteresting and not intuitively a
+         * "definition" for `f`. Ideally, the question we'd like to answer is "what SymbolFlags does this
+         * declaration contribute to the symbol for `f`?" If the answer is just `Namespace` and the
+         * declaration looks like an assignment, that declaration is in no sense a definition for `f`.
+         * But that information is totally lost during binding and/or symbol merging, so we need to do
+         * our best to reconstruct it or use other heuristics. This function (and the logic around its
+         * calling) covers our tests but feels like a hack, and it would be great if someone could come
+         * up with a more precise definition of what counts as a definition.
+         */
+        function isExpandoDeclaration(node) {
+            if (!ts.isAssignmentDeclaration(node))
+                return false;
+            var containingAssignment = ts.findAncestor(node, function (p) {
+                if (ts.isAssignmentExpression(p))
+                    return true;
+                if (!ts.isAssignmentDeclaration(p))
+                    return "quit";
+                return false;
+            });
+            return !!containingAssignment && ts.getAssignmentDeclarationKind(containingAssignment) === 5 /* Property */;
         }
-        function getDefinitionFromSymbol(typeChecker, symbol, node, declarationNode) {
-            // There are cases when you extend a function by adding properties to it afterwards,
-            // we want to strip those extra properties.
-            // For deduping purposes, we also want to exclude any declarationNodes if provided.
-            var filteredDeclarations = ts.filter(symbol.declarations, function (d) { return d !== declarationNode && (!ts.isAssignmentDeclaration(d) || d === symbol.valueDeclaration); })
-                || undefined;
-            return getConstructSignatureDefinition() || getCallSignatureDefinition() || ts.map(filteredDeclarations, function (declaration) { return createDefinitionInfo(declaration, typeChecker, symbol, node); });
+        function getDefinitionFromSymbol(typeChecker, symbol, node, isAliasTarget, failedAliasResolution, excludeDeclaration) {
+            var filteredDeclarations = ts.filter(symbol.declarations, function (d) { return d !== excludeDeclaration; });
+            var withoutExpandos = ts.filter(filteredDeclarations, function (d) { return !isExpandoDeclaration(d); });
+            var results = ts.some(withoutExpandos) ? withoutExpandos : filteredDeclarations;
+            return getConstructSignatureDefinition() || getCallSignatureDefinition() || ts.map(results, function (declaration) { return createDefinitionInfo(declaration, typeChecker, symbol, node, isAliasTarget, failedAliasResolution); });
             function getConstructSignatureDefinition() {
                 // Applicable only if we are in a new expression, or we are on a constructor declaration
                 // and in either case the symbol has a construct signature definition, i.e. class
@@ -137784,26 +138074,27 @@ var ts;
                 return declarations.length
                     ? declarationsWithBody.length !== 0
                         ? declarationsWithBody.map(function (x) { return createDefinitionInfo(x, typeChecker, symbol, node); })
-                        : [createDefinitionInfo(ts.last(declarations), typeChecker, symbol, node)]
+                        : [createDefinitionInfo(ts.last(declarations), typeChecker, symbol, node, isAliasTarget, failedAliasResolution)]
                     : undefined;
             }
         }
         /** Creates a DefinitionInfo from a Declaration, using the declaration's name if possible. */
-        function createDefinitionInfo(declaration, checker, symbol, node) {
+        function createDefinitionInfo(declaration, checker, symbol, node, isAliasTarget, failedAliasResolution) {
             var symbolName = checker.symbolToString(symbol); // Do not get scoped name, just the name of the symbol
             var symbolKind = ts.SymbolDisplay.getSymbolKind(checker, symbol, node);
             var containerName = symbol.parent ? checker.symbolToString(symbol.parent, node) : "";
-            return createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName, containerName);
+            return createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName, containerName, isAliasTarget, failedAliasResolution);
         }
+        GoToDefinition.createDefinitionInfo = createDefinitionInfo;
         /** Creates a DefinitionInfo directly from the name of a declaration. */
-        function createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName, containerName, textSpan) {
+        function createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName, containerName, isAliasTarget, failedAliasResolution, textSpan) {
             var sourceFile = declaration.getSourceFile();
             if (!textSpan) {
                 var name = ts.getNameOfDeclaration(declaration) || declaration;
                 textSpan = ts.createTextSpanFromNode(name, sourceFile);
             }
             return __assign(__assign({ fileName: sourceFile.fileName, textSpan: textSpan, kind: symbolKind, name: symbolName, containerKind: undefined, // TODO: GH#18217
-                containerName: containerName }, ts.FindAllReferences.toContextSpan(textSpan, sourceFile, ts.FindAllReferences.getContextNode(declaration))), { isLocal: !isDefinitionVisible(checker, declaration) });
+                containerName: containerName }, ts.FindAllReferences.toContextSpan(textSpan, sourceFile, ts.FindAllReferences.getContextNode(declaration))), { isLocal: !isDefinitionVisible(checker, declaration), isAmbient: !!(declaration.flags & 8388608 /* Ambient */), isAliasTarget: isAliasTarget, failedAliasResolution: failedAliasResolution });
         }
         function isDefinitionVisible(checker, declaration) {
             if (checker.isDeclarationVisible(declaration))
@@ -137836,8 +138127,8 @@ var ts;
                     return false;
             }
         }
-        function createDefinitionFromSignatureDeclaration(typeChecker, decl) {
-            return createDefinitionInfo(decl, typeChecker, decl.symbol, decl);
+        function createDefinitionFromSignatureDeclaration(typeChecker, decl, isAliasTarget, failedAliasResolution) {
+            return createDefinitionInfo(decl, typeChecker, decl.symbol, decl, isAliasTarget, failedAliasResolution);
         }
         function findReferenceInPosition(refs, pos) {
             return ts.find(refs, function (ref) { return ts.textRangeContainsPositionInclusive(ref, pos); });
@@ -137852,6 +138143,7 @@ var ts;
                 containerName: undefined,
                 containerKind: undefined,
                 unverified: unverified,
+                isAliasTarget: true,
             };
         }
         /** Returns a CallLikeExpression where `node` is the target being invoked. */
@@ -140905,41 +141197,6 @@ var ts;
                 if (ts.scanner.getToken() === 1 /* EndOfFileToken */) {
                     break;
                 }
-                if (ts.scanner.getToken() === 15 /* TemplateHead */) {
-                    var stack = [ts.scanner.getToken()];
-                    var token = ts.scanner.scan();
-                    loop: while (ts.length(stack)) {
-                        switch (token) {
-                            case 1 /* EndOfFileToken */:
-                                break loop;
-                            case 100 /* ImportKeyword */:
-                                tryConsumeImport();
-                                break;
-                            case 15 /* TemplateHead */:
-                                stack.push(token);
-                                break;
-                            case 18 /* OpenBraceToken */:
-                                if (ts.length(stack)) {
-                                    stack.push(token);
-                                }
-                                break;
-                            case 19 /* CloseBraceToken */:
-                                if (ts.length(stack)) {
-                                    if (ts.lastOrUndefined(stack) === 15 /* TemplateHead */) {
-                                        if (ts.scanner.reScanTemplateToken(/* isTaggedTemplate */ false) === 17 /* TemplateTail */) {
-                                            stack.pop();
-                                        }
-                                    }
-                                    else {
-                                        stack.pop();
-                                    }
-                                }
-                                break;
-                        }
-                        token = ts.scanner.scan();
-                    }
-                    nextToken();
-                }
                 // check if at least one of alternative have moved scanner forward
                 if (tryConsumeDeclare() ||
                     tryConsumeImport() ||
@@ -150885,9 +151142,10 @@ var ts;
             //     2. add "member3" to the second import statement's import list
             // and it is up to the user to decide which one fits best.
             return ts.firstDefined(existingImports, function (_a) {
+                var _b;
                 var declaration = _a.declaration;
                 var namespacePrefix = getNamespaceLikeImportText(declaration);
-                var moduleSpecifier = ts.tryGetModuleSpecifierFromDeclaration(declaration);
+                var moduleSpecifier = (_b = ts.tryGetModuleSpecifierFromDeclaration(declaration)) === null || _b === void 0 ? void 0 : _b.text;
                 if (namespacePrefix && moduleSpecifier) {
                     var moduleSymbol = getTargetModuleFromNamespaceLikeImport(declaration, checker);
                     if (moduleSymbol && moduleSymbol.exports.has(ts.escapeLeadingUnderscores(symbolName))) {
@@ -151063,8 +151321,9 @@ var ts;
             return existingDeclaration ? [existingDeclaration] : getNewImportFixes(program, sourceFile, position, isValidTypeOnlyUseSite, useRequire, exportInfos, host, preferences).fixes;
         }
         function newImportInfoFromExistingSpecifier(_a, isValidTypeOnlyUseSite, useRequire, checker, compilerOptions) {
+            var _b;
             var declaration = _a.declaration, importKind = _a.importKind, symbol = _a.symbol, targetFlags = _a.targetFlags;
-            var moduleSpecifier = ts.tryGetModuleSpecifierFromDeclaration(declaration);
+            var moduleSpecifier = (_b = ts.tryGetModuleSpecifierFromDeclaration(declaration)) === null || _b === void 0 ? void 0 : _b.text;
             if (moduleSpecifier) {
                 var addAsTypeOnly = useRequire
                     ? 4 /* NotAllowed */
@@ -162873,9 +163132,9 @@ var ts;
             synchronizeHostData();
             return ts.GoToDefinition.getDefinitionAtPosition(program, getValidSourceFile(fileName), position);
         }
-        function getDefinitionAndBoundSpan(fileName, position) {
+        function getDefinitionAndBoundSpan(fileName, position, aliasesOnly) {
             synchronizeHostData();
-            return ts.GoToDefinition.getDefinitionAndBoundSpan(program, getValidSourceFile(fileName), position);
+            return ts.GoToDefinition.getDefinitionAndBoundSpan(program, getValidSourceFile(fileName), position, aliasesOnly);
         }
         function getTypeDefinitionAtPosition(fileName, position) {
             synchronizeHostData();
@@ -166044,6 +166303,9 @@ var ts;
                 CommandTypes["SignatureHelp"] = "signatureHelp";
                 /* @internal */
                 CommandTypes["SignatureHelpFull"] = "signatureHelp-full";
+                CommandTypes["SourceDefinitionAndBoundSpan"] = "sourceDefinitionAndBoundSpan";
+                /* @internal */
+                CommandTypes["SourceDefinitionAndBoundSpanFull"] = "sourceDefinitionAndBoundSpan-full";
                 CommandTypes["Status"] = "status";
                 CommandTypes["TypeDefinition"] = "typeDefinition";
                 CommandTypes["ProjectInfo"] = "projectInfo";
@@ -166913,6 +167175,7 @@ var ts;
             ProjectKind[ProjectKind["Configured"] = 1] = "Configured";
             ProjectKind[ProjectKind["External"] = 2] = "External";
             ProjectKind[ProjectKind["AutoImportProvider"] = 3] = "AutoImportProvider";
+            ProjectKind[ProjectKind["Auxiliary"] = 4] = "Auxiliary";
         })(ProjectKind = server.ProjectKind || (server.ProjectKind = {}));
         /* @internal */
         function countEachFileTypes(infos, includeSizes) {
@@ -168358,6 +168621,17 @@ var ts;
             Project.prototype.getIncompleteCompletionsCache = function () {
                 return this.projectService.getIncompleteCompletionsCache();
             };
+            Project.prototype.withAuxiliaryProjectForFiles = function (fileNames, cb) {
+                var options = __assign(__assign({}, this.getCompilerOptions()), { noDtsResolution: true, allowJs: true, maxNodeModuleJsDepth: 3, diagnostics: false, skipLibCheck: true, sourceMap: false, types: ts.emptyArray, lib: ts.emptyArray, noLib: true });
+                var project = new AuxiliaryProject(this.projectService, this.documentRegistry, options);
+                for (var _i = 0, fileNames_1 = fileNames; _i < fileNames_1.length; _i++) {
+                    var fileName = fileNames_1[_i];
+                    project.addRoot(this.getScriptInfo(fileName));
+                }
+                project.updateGraph();
+                cb(project);
+                project.close();
+            };
             return Project;
         }());
         server.Project = Project;
@@ -168469,6 +168743,22 @@ var ts;
             return InferredProject;
         }(Project));
         server.InferredProject = InferredProject;
+        var AuxiliaryProject = /** @class */ (function (_super) {
+            __extends(AuxiliaryProject, _super);
+            function AuxiliaryProject(projectService, documentRegistry, parentCompilerOptions) {
+                var _this = this;
+                var options = __assign(__assign({}, parentCompilerOptions), { resolveJsOnly: true, allowJs: true, maxNodeModuleJsDepth: 3, diagnostics: false, skipLibCheck: true, sourceMap: false, types: ts.emptyArray, lib: ts.emptyArray, noLib: true });
+                _this = _super.call(this, "js-analysis", ProjectKind.Auxiliary, projectService, documentRegistry, 
+                /*hasExplicitListOfFiles*/ false, 
+                /*lastFileExceededProgramSize*/ undefined, options, 
+                /*compileOnSaveEnabled*/ false, 
+                /*watchOptions*/ undefined, projectService.host, 
+                /*currentDirectory*/ undefined) || this;
+                return _this;
+            }
+            return AuxiliaryProject;
+        }(Project));
+        server.AuxiliaryProject = AuxiliaryProject;
         var AutoImportProviderProject = /** @class */ (function (_super) {
             __extends(AutoImportProviderProject, _super);
             /*@internal*/
@@ -170357,8 +170647,8 @@ var ts;
                 this.projectToSizeMap.set(name, 0);
                 this.projectToSizeMap.forEach(function (val) { return (availableSpace -= (val || 0)); });
                 var totalNonTsFileSize = 0;
-                for (var _i = 0, fileNames_1 = fileNames; _i < fileNames_1.length; _i++) {
-                    var f = fileNames_1[_i];
+                for (var _i = 0, fileNames_2 = fileNames; _i < fileNames_2.length; _i++) {
+                    var f = fileNames_2[_i];
                     var fileName = propertyReader.getFileName(f);
                     if (ts.hasTSFileExtension(fileName)) {
                         continue;
@@ -172714,15 +173004,23 @@ var ts;
             return ts.deduplicate(outputs, ts.equateValues);
         }
         ;
+        function createDocumentSpanSet() {
+            return ts.createSet(function (_a) {
+                var textSpan = _a.textSpan;
+                return textSpan.start + 100003 * textSpan.length;
+            }, ts.documentSpansEqual);
+        }
         function combineProjectOutputForRenameLocations(projects, defaultProject, initialLocation, findInStrings, findInComments, _a) {
             var providePrefixAndSuffixTextForRename = _a.providePrefixAndSuffixTextForRename;
             var outputs = [];
+            var seen = createDocumentSpanSet();
             combineProjectOutputWorker(projects, defaultProject, initialLocation, function (project, location, tryAddToTodo) {
                 var projectOutputs = project.getLanguageService().findRenameLocations(location.fileName, location.pos, findInStrings, findInComments, providePrefixAndSuffixTextForRename);
                 if (projectOutputs) {
                     for (var _i = 0, projectOutputs_1 = projectOutputs; _i < projectOutputs_1.length; _i++) {
                         var output = projectOutputs_1[_i];
-                        if (!ts.contains(outputs, output, ts.documentSpansEqual) && !tryAddToTodo(project, documentSpanLocation(output))) {
+                        if (!seen.has(output) && !tryAddToTodo(project, documentSpanLocation(output))) {
+                            seen.add(output);
                             outputs.push(output);
                         }
                     }
@@ -173063,6 +173361,12 @@ var ts;
                     _a[server.CommandNames.DefinitionAndBoundSpanFull] = function (request) {
                         return _this.requiredResponse(_this.getDefinitionAndBoundSpan(request.arguments, /*simplifiedResult*/ false));
                     },
+                    // [CommandNames.SourceDefinitionAndBoundSpan]: (request: protocol.SourceDefinitionAndBoundSpanRequest) => {
+                    //     return this.requiredResponse(this.getSourceDefinitionAndBoundSpan(request.arguments, /*simplifiedResult*/ true));
+                    // },
+                    // [CommandNames.SourceDefinitionAndBoundSpanFull]: (request: protocol.SourceDefinitionAndBoundSpanRequest) => {
+                    //     return this.requiredResponse(this.getSourceDefinitionAndBoundSpan(request.arguments, /*simplifiedResult*/ false));
+                    // },
                     _a[server.CommandNames.EmitOutput] = function (request) {
                         return _this.requiredResponse(_this.getEmitOutput(request.arguments));
                     },
@@ -173799,10 +174103,34 @@ var ts;
             Session.prototype.mapDefinitionInfoLocations = function (definitions, project) {
                 return definitions.map(function (info) {
                     var newDocumentSpan = getMappedDocumentSpan(info, project);
-                    return !newDocumentSpan ? info : __assign(__assign(__assign({}, newDocumentSpan), { containerKind: info.containerKind, containerName: info.containerName, kind: info.kind, name: info.name }), info.unverified && { unverified: info.unverified });
+                    return !newDocumentSpan ? info : __assign(__assign(__assign({}, newDocumentSpan), { containerKind: info.containerKind, containerName: info.containerName, kind: info.kind, name: info.name, isAliasTarget: info.isAliasTarget, failedAliasResolution: info.failedAliasResolution }), info.unverified && { unverified: info.unverified });
                 });
             };
             Session.prototype.getDefinitionAndBoundSpan = function (args, simplifiedResult) {
+                //     const { file, project } = this.getFileAndProject(args);
+                //     const position = this.getPositionInFile(args, file);
+                //     const scriptInfo = Debug.checkDefined(project.getScriptInfo(file));
+                //     const unmappedDefinitionAndBoundSpan = project.getLanguageService().getDefinitionAndBoundSpan(file, position);
+                //     if (!unmappedDefinitionAndBoundSpan || !unmappedDefinitionAndBoundSpan.definitions) {
+                //         return {
+                //             definitions: emptyArray,
+                //             textSpan: undefined! // TODO: GH#18217
+                //         };
+                //     }
+                //     const definitions = this.mapDefinitionInfoLocations(unmappedDefinitionAndBoundSpan.definitions, project);
+                //     const { textSpan } = unmappedDefinitionAndBoundSpan;
+                //     if (simplifiedResult) {
+                //         return {
+                //             definitions: this.mapDefinitionInfo(definitions, project),
+                //             textSpan: toProtocolTextSpan(textSpan, scriptInfo)
+                //         };
+                //     }
+                //     return {
+                //         definitions: definitions.map(Session.mapToOriginalLocation),
+                //         textSpan,
+                //     };
+                // }
+                // private getSourceDefinitionAndBoundSpan(args: protocol.FileLocationRequestArgs, simplifiedResult: boolean): protocol.DefinitionInfoAndBoundSpan | DefinitionInfoAndBoundSpan {
                 var _a = this.getFileAndProject(args), file = _a.file, project = _a.project;
                 var position = this.getPositionInFile(args, file);
                 var scriptInfo = ts.Debug.checkDefined(project.getScriptInfo(file));
@@ -173813,7 +174141,31 @@ var ts;
                         textSpan: undefined // TODO: GH#18217
                     };
                 }
-                var definitions = this.mapDefinitionInfoLocations(unmappedDefinitionAndBoundSpan.definitions, project);
+                var definitions = this.mapDefinitionInfoLocations(unmappedDefinitionAndBoundSpan.definitions, project).slice();
+                var needsJsResolution = !ts.some(definitions, function (d) { return !!d.isAliasTarget && !d.isAmbient; }) || ts.some(definitions, function (d) { return !!d.failedAliasResolution; });
+                if (needsJsResolution) {
+                    project.withAuxiliaryProjectForFiles([file], function (auxiliaryProject) {
+                        var ls = auxiliaryProject.getLanguageService();
+                        var jsDefinitions = ls.getDefinitionAndBoundSpan(file, position, /*aliasesOnly*/ true);
+                        if (ts.some(jsDefinitions === null || jsDefinitions === void 0 ? void 0 : jsDefinitions.definitions)) {
+                            for (var _i = 0, _a = jsDefinitions.definitions; _i < _a.length; _i++) {
+                                var jsDefinition = _a[_i];
+                                if (jsDefinition.unverified) {
+                                    var refined = tryRefineDefinition(jsDefinition, project.getLanguageService().getProgram(), ls.getProgram());
+                                    if (ts.some(refined)) {
+                                        for (var _b = 0, _c = refined || server.emptyArray; _b < _c.length; _b++) {
+                                            var def = _c[_b];
+                                            ts.pushIfUnique(definitions, def, ts.documentSpansEqual);
+                                        }
+                                        continue;
+                                    }
+                                }
+                                ts.pushIfUnique(definitions, jsDefinition, ts.documentSpansEqual);
+                            }
+                        }
+                    });
+                }
+                definitions = definitions.filter(function (d) { return !d.isAmbient && !d.failedAliasResolution; });
                 var textSpan = unmappedDefinitionAndBoundSpan.textSpan;
                 if (simplifiedResult) {
                     return {
@@ -173825,6 +174177,32 @@ var ts;
                     definitions: definitions.map(Session.mapToOriginalLocation),
                     textSpan: textSpan,
                 };
+                function tryRefineDefinition(definition, program, auxiliaryProgram) {
+                    var _a, _b;
+                    var fileToSearch = auxiliaryProgram.getSourceFile(definition.fileName);
+                    if (!fileToSearch) {
+                        return undefined;
+                    }
+                    var initialNode = ts.getTouchingPropertyName(program.getSourceFile(file), position);
+                    var symbol = program.getTypeChecker().getSymbolAtLocation(initialNode);
+                    if (!symbol || !symbol.declarations || ts.some(symbol.declarations, ts.isFreelyNameableImport)) {
+                        return undefined;
+                    }
+                    var nameToSearch = ((_b = (_a = ts.find(symbol.declarations, ts.isImportSpecifier)) === null || _a === void 0 ? void 0 : _a.propertyName) === null || _b === void 0 ? void 0 : _b.text) || symbol.name;
+                    return searchForDeclaration(nameToSearch, fileToSearch, auxiliaryProgram);
+                }
+                function searchForDeclaration(declarationName, fileToSearch, auxiliaryProgram) {
+                    var matches = ts.FindAllReferences.Core.getTopMostDeclarationNamesInFile(declarationName, fileToSearch);
+                    return ts.mapDefined(matches, function (match) {
+                        var symbol = auxiliaryProgram.getTypeChecker().getSymbolAtLocation(match);
+                        var decl = ts.getDeclarationFromName(match);
+                        if (symbol && decl) {
+                            // I think the last argument to this is supposed to be the start node, but it doesn't seem important.
+                            // Callers internal to GoToDefinition already get confused about this.
+                            return ts.GoToDefinition.createDefinitionInfo(decl, auxiliaryProgram.getTypeChecker(), symbol, decl);
+                        }
+                    });
+                }
             };
             Session.prototype.getEmitOutput = function (args) {
                 var _a = this.getFileAndProject(args), file = _a.file, project = _a.project;
@@ -174106,6 +174484,7 @@ var ts;
                 var projects = this.getProjects(args);
                 var fileName = args.file;
                 var references = [];
+                var seen = createDocumentSpanSet();
                 forEachProjectInProjects(projects, /*path*/ undefined, function (project) {
                     if (project.getCancellationToken().isCancellationRequested())
                         return;
@@ -174113,8 +174492,9 @@ var ts;
                     if (projectOutputs) {
                         for (var _i = 0, projectOutputs_3 = projectOutputs; _i < projectOutputs_3.length; _i++) {
                             var referenceEntry = projectOutputs_3[_i];
-                            if (!ts.contains(references, referenceEntry, ts.documentSpansEqual)) {
+                            if (!seen.has(referenceEntry)) {
                                 references.push(referenceEntry);
+                                seen.add(referenceEntry);
                             }
                         }
                     }