typescript 4.5.0-dev.20211020 → 4.5.0-dev.20211024

package/lib/tsserver.js

@@ -100,7 +100,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20211020";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211024";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8141,6 +8141,7 @@ var ts;
         Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type: diag(1387, ts.DiagnosticCategory.Error, "Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type_1387", "Function type notation must be parenthesized when used in an intersection type."),
         Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type: diag(1388, ts.DiagnosticCategory.Error, "Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type_1388", "Constructor type notation must be parenthesized when used in an intersection type."),
         _0_is_not_allowed_as_a_variable_declaration_name: diag(1389, ts.DiagnosticCategory.Error, "_0_is_not_allowed_as_a_variable_declaration_name_1389", "'{0}' is not allowed as a variable declaration name."),
+        _0_is_not_allowed_as_a_parameter_name: diag(1390, ts.DiagnosticCategory.Error, "_0_is_not_allowed_as_a_parameter_name_1390", "'{0}' is not allowed as a parameter name."),
         An_import_alias_cannot_use_import_type: diag(1392, ts.DiagnosticCategory.Error, "An_import_alias_cannot_use_import_type_1392", "An import alias cannot use 'import type'"),
         Imported_via_0_from_file_1: diag(1393, ts.DiagnosticCategory.Message, "Imported_via_0_from_file_1_1393", "Imported via {0} from file '{1}'"),
         Imported_via_0_from_file_1_with_packageId_2: diag(1394, ts.DiagnosticCategory.Message, "Imported_via_0_from_file_1_with_packageId_2_1394", "Imported via {0} from file '{1}' with packageId '{2}'"),
@@ -19993,7 +19994,7 @@ var ts;
             includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
             includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
             excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
-            basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames)
+            basePaths: getBasePaths(absolutePath, includes, useCaseSensitiveFileNames)
         };
     }
     ts.getFileMatcherPatterns = getFileMatcherPatterns;
@@ -20015,20 +20016,20 @@ var ts;
         var visited = new ts.Map();
         var toCanonical = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
         for (var _i = 0, _a = patterns.basePaths; _i < _a.length; _i++) {
-            var basePath = _a[_i];
-            if (directoryExists(basePath)) {
-                visitDirectory(basePath, ts.combinePaths(currentDirectory, basePath), depth);
+            var absoluteBasePath = _a[_i];
+            if (directoryExists(absoluteBasePath)) {
+                visitDirectory(absoluteBasePath, depth);
             }
         }
         return ts.flatten(results);
-        function visitDirectory(path, absolutePath, depth) {
+        function visitDirectory(absolutePath, depth) {
             var canonicalPath = toCanonical(realpath(absolutePath));
             if (visited.has(canonicalPath))
                 return;
             visited.set(canonicalPath, true);
-            var _a = getFileSystemEntries(path), files = _a.files, directories = _a.directories;
+            var _a = getFileSystemEntries(absolutePath), files = _a.files, directories = _a.directories;
             var _loop_1 = function (current) {
-                var name = ts.combinePaths(path, current);
+                var name = ts.combinePaths(absolutePath, current);
                 var absoluteName = ts.combinePaths(absolutePath, current);
                 if (extensions && !ts.fileExtensionIsOneOf(name, extensions))
                     return "continue";
@@ -20056,11 +20057,10 @@ var ts;
             }
             for (var _c = 0, _d = ts.sort(directories, ts.compareStringsCaseSensitive); _c < _d.length; _c++) {
                 var current = _d[_c];
-                var name = ts.combinePaths(path, current);
                 var absoluteName = ts.combinePaths(absolutePath, current);
                 if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
                     (!excludeRegex || !excludeRegex.test(absoluteName))) {
-                    visitDirectory(name, absoluteName, depth);
+                    visitDirectory(absoluteName, depth);
                 }
             }
         }
@@ -20068,10 +20068,11 @@ var ts;
     ts.matchFiles = matchFiles;
     /**
      * Computes the unique non-wildcard base paths amongst the provided include patterns.
+     * @returns Absolute directory paths
      */
-    function getBasePaths(path, includes, useCaseSensitiveFileNames) {
+    function getBasePaths(absoluteTsconfigPath, includes, useCaseSensitiveFileNames) {
         // Storage for our results in the form of literal paths (e.g. the paths as written by the user).
-        var basePaths = [path];
+        var basePaths = [absoluteTsconfigPath];
         if (includes) {
             // Storage for literal base paths amongst the include patterns.
             var includeBasePaths = [];
@@ -20079,14 +20080,14 @@ var ts;
                 var include = includes_1[_i];
                 // We also need to check the relative paths by converting them to absolute and normalizing
                 // in case they escape the base path (e.g "..\somedirectory")
-                var absolute = ts.isRootedDiskPath(include) ? include : ts.normalizePath(ts.combinePaths(path, include));
+                var absoluteIncludePath = ts.isRootedDiskPath(include) ? include : ts.normalizePath(ts.combinePaths(absoluteTsconfigPath, include));
                 // Append the literal and canonical candidate base paths.
-                includeBasePaths.push(getIncludeBasePath(absolute));
+                includeBasePaths.push(getIncludeBasePath(absoluteIncludePath));
             }
             // Sort the offsets array using either the literal or canonical path representations.
             includeBasePaths.sort(ts.getStringComparer(!useCaseSensitiveFileNames));
             var _loop_2 = function (includeBasePath) {
-                if (ts.every(basePaths, function (basePath) { return !ts.containsPath(basePath, includeBasePath, path, !useCaseSensitiveFileNames); })) {
+                if (ts.every(basePaths, function (basePath) { return !ts.containsPath(basePath, includeBasePath, absoluteTsconfigPath, !useCaseSensitiveFileNames); })) {
                     basePaths.push(includeBasePath);
                 }
             };
@@ -31933,7 +31934,10 @@ var ts;
                 case 12 /* ObjectLiteralMembers */: return parseErrorAtCurrentToken(ts.Diagnostics.Property_assignment_expected);
                 case 15 /* ArrayLiteralMembers */: return parseErrorAtCurrentToken(ts.Diagnostics.Expression_or_comma_expected);
                 case 17 /* JSDocParameters */: return parseErrorAtCurrentToken(ts.Diagnostics.Parameter_declaration_expected);
-                case 16 /* Parameters */: return parseErrorAtCurrentToken(ts.Diagnostics.Parameter_declaration_expected);
+                case 16 /* Parameters */:
+                    return ts.isKeyword(token())
+                        ? parseErrorAtCurrentToken(ts.Diagnostics._0_is_not_allowed_as_a_parameter_name, ts.tokenToString(token()))
+                        : parseErrorAtCurrentToken(ts.Diagnostics.Parameter_declaration_expected);
                 case 19 /* TypeParameters */: return parseErrorAtCurrentToken(ts.Diagnostics.Type_parameter_declaration_expected);
                 case 20 /* TypeArguments */: return parseErrorAtCurrentToken(ts.Diagnostics.Type_argument_expected);
                 case 21 /* TupleElementTypes */: return parseErrorAtCurrentToken(ts.Diagnostics.Type_expected);
@@ -45693,6 +45697,7 @@ var ts;
                 case 168 /* MethodDeclaration */:
                 case 171 /* GetAccessor */:
                 case 172 /* SetAccessor */:
+                case 169 /* ClassStaticBlockDeclaration */:
                     // this.foo assignment in a JavaScript class
                     // Bind this property to the containing class
                     var containingClass = thisContainer.parent;
@@ -49753,8 +49758,8 @@ var ts;
             if (exportEquals !== moduleSymbol) {
                 var type = getTypeOfSymbol(exportEquals);
                 if (shouldTreatPropertiesOfExternalModuleAsExports(type)) {
-                    getPropertiesOfType(type).forEach(function (symbol) {
-                        cb(symbol, symbol.escapedName);
+                    forEachPropertyOfType(type, function (symbol, escapedName) {
+                        cb(symbol, escapedName);
                     });
                 }
             }
@@ -50086,12 +50091,15 @@ var ts;
         function getNamedMembers(members) {
             var result;
             members.forEach(function (symbol, id) {
-                if (!isReservedMemberName(id) && symbolIsValue(symbol)) {
+                if (isNamedMember(symbol, id)) {
                     (result || (result = [])).push(symbol);
                 }
             });
             return result || ts.emptyArray;
         }
+        function isNamedMember(member, escapedName) {
+            return !isReservedMemberName(escapedName) && symbolIsValue(member);
+        }
         function getNamedOrIndexSignatureMembers(members) {
             var result = getNamedMembers(members);
             var index = getIndexSymbolFromSymbolTable(members);
@@ -56924,6 +56932,16 @@ var ts;
                 getPropertiesOfUnionOrIntersectionType(type) :
                 getPropertiesOfObjectType(type);
         }
+        function forEachPropertyOfType(type, action) {
+            type = getReducedApparentType(type);
+            if (type.flags & 3670016 /* StructuredType */) {
+                resolveStructuredTypeMembers(type).members.forEach(function (symbol, escapedName) {
+                    if (isNamedMember(symbol, escapedName)) {
+                        action(symbol, escapedName);
+                    }
+                });
+            }
+        }
         function isTypeInvalidDueToUnionDiscriminant(contextualType, obj) {
             var list = obj.properties;
             return list.some(function (property) {
@@ -60399,12 +60417,6 @@ var ts;
             }
             return type[cache] = type;
         }
-        function isConditionalTypeAlwaysTrueDisregardingInferTypes(type) {
-            var extendsInferParamMapper = type.root.inferTypeParameters && createTypeMapper(type.root.inferTypeParameters, ts.map(type.root.inferTypeParameters, function () { return wildcardType; }));
-            var checkType = type.checkType;
-            var extendsType = type.extendsType;
-            return isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(instantiateType(extendsType, extendsInferParamMapper)));
-        }
         function getSimplifiedConditionalType(type, writing) {
             var checkType = type.checkType;
             var extendsType = type.extendsType;
@@ -60713,6 +60725,10 @@ var ts;
             }
             return result;
         }
+        function isDistributionDependent(root) {
+            return root.isDistributive && (isTypeParameterPossiblyReferenced(root.checkType, root.node.trueType) ||
+                isTypeParameterPossiblyReferenced(root.checkType, root.node.falseType));
+        }
         function getTypeFromConditionalTypeNode(node) {
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
@@ -63869,31 +63885,21 @@ var ts;
                         return 3 /* Maybe */;
                     }
                     var c = target;
-                    // Check if the conditional is always true or always false but still deferred for distribution purposes
-                    var skipTrue = !isTypeAssignableTo(getPermissiveInstantiation(c.checkType), getPermissiveInstantiation(c.extendsType));
-                    var skipFalse = !skipTrue && isConditionalTypeAlwaysTrueDisregardingInferTypes(c);
-                    // Instantiate with a replacement mapper if the conditional is distributive, replacing the check type with a clone of itself,
-                    // this way {x: string | number, y: string | number} -> (T extends T ? { x: T, y: T } : never) appropriately _fails_ when
-                    // T = string | number (since that will end up distributing and producing `{x: string, y: string} | {x: number, y: number}`,
-                    // to which `{x: string | number, y: string | number}` isn't assignable)
-                    var distributionMapper = void 0;
-                    var checkVar = getActualTypeVariable(c.root.checkType);
-                    if (c.root.isDistributive && checkVar.flags & 262144 /* TypeParameter */) {
-                        var newParam = cloneTypeParameter(checkVar);
-                        distributionMapper = prependTypeMapping(checkVar, newParam, c.mapper);
-                        newParam.mapper = distributionMapper;
-                    }
-                    // TODO: Find a nice way to include potential conditional type breakdowns in error output, if they seem good (they usually don't)
-                    var expanding = isDeeplyNestedType(target, targetStack, targetDepth);
-                    var localResult = expanding ? 3 /* Maybe */ : undefined;
-                    if (skipTrue || expanding || (localResult = isRelatedTo(source, distributionMapper ? instantiateType(getTypeFromTypeNode(c.root.node.trueType), distributionMapper) : getTrueTypeFromConditionalType(c), 2 /* Target */, /*reportErrors*/ false))) {
-                        if (!skipFalse && !expanding) {
-                            localResult = (localResult || 3 /* Maybe */) & isRelatedTo(source, distributionMapper ? instantiateType(getTypeFromTypeNode(c.root.node.falseType), distributionMapper) : getFalseTypeFromConditionalType(c), 2 /* Target */, /*reportErrors*/ false);
-                        }
-                    }
-                    if (localResult) {
-                        resetErrorInfo(saveErrorInfo);
-                        return localResult;
+                    // We check for a relationship to a conditional type target only when the conditional type has no
+                    // 'infer' positions and is not distributive or is distributive but doesn't reference the check type
+                    // parameter in either of the result types.
+                    if (!c.root.inferTypeParameters && !isDistributionDependent(c.root)) {
+                        // Check if the conditional is always true or always false but still deferred for distribution purposes.
+                        var skipTrue = !isTypeAssignableTo(getPermissiveInstantiation(c.checkType), getPermissiveInstantiation(c.extendsType));
+                        var skipFalse = !skipTrue && isTypeAssignableTo(getRestrictiveInstantiation(c.checkType), getRestrictiveInstantiation(c.extendsType));
+                        // TODO: Find a nice way to include potential conditional type breakdowns in error output, if they seem good (they usually don't)
+                        if (result = skipTrue ? -1 /* True */ : isRelatedTo(source, getTrueTypeFromConditionalType(c), 2 /* Target */, /*reportErrors*/ false)) {
+                            result &= skipFalse ? -1 /* True */ : isRelatedTo(source, getFalseTypeFromConditionalType(c), 2 /* Target */, /*reportErrors*/ false);
+                            if (result) {
+                                resetErrorInfo(saveErrorInfo);
+                                return result;
+                            }
+                        }
                     }
                 }
                 else if (target.flags & 134217728 /* TemplateLiteral */) {
@@ -124611,9 +124617,9 @@ var ts;
         return displayPart(text, ts.SymbolDisplayPartKind.linkText);
     }
     ts.linkTextPart = linkTextPart;
-    function linkNamePart(name, target) {
+    function linkNamePart(text, target) {
         return {
-            text: ts.getTextOfNode(name),
+            text: text,
             kind: ts.SymbolDisplayPartKind[ts.SymbolDisplayPartKind.linkName],
             target: {
                 fileName: ts.getSourceFileOfNode(target).fileName,
@@ -124638,20 +124644,41 @@ var ts;
         }
         else {
             var symbol = checker === null || checker === void 0 ? void 0 : checker.getSymbolAtLocation(link.name);
+            var suffix = findLinkNameEnd(link.text);
+            var name = ts.getTextOfNode(link.name) + link.text.slice(0, suffix);
+            var text = link.text.slice(suffix);
             var decl = (symbol === null || symbol === void 0 ? void 0 : symbol.valueDeclaration) || ((_a = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) === null || _a === void 0 ? void 0 : _a[0]);
             if (decl) {
-                parts.push(linkNamePart(link.name, decl));
-                if (link.text)
-                    parts.push(linkTextPart(link.text));
+                parts.push(linkNamePart(name, decl));
+                if (text)
+                    parts.push(linkTextPart(text));
             }
             else {
-                parts.push(linkTextPart(ts.getTextOfNode(link.name) + " " + link.text));
+                parts.push(linkTextPart(name + (suffix ? "" : " ") + text));
             }
         }
         parts.push(linkPart("}"));
         return parts;
     }
     ts.buildLinkParts = buildLinkParts;
+    function findLinkNameEnd(text) {
+        if (text.indexOf("()") === 0)
+            return 2;
+        if (text[0] !== "<")
+            return 0;
+        var brackets = 0;
+        var i = 0;
+        while (i < text.length) {
+            if (text[i] === "<")
+                brackets++;
+            if (text[i] === ">")
+                brackets--;
+            i++;
+            if (!brackets)
+                return i;
+        }
+        return 0;
+    }
     var carriageReturnLineFeed = "\r\n";
     /**
      * The default is CRLF.
@@ -125555,10 +125582,14 @@ var ts;
                 }
                 var isDefault = exportKind === 1 /* Default */;
                 var namedSymbol = isDefault && ts.getLocalSymbolForExportDefault(symbol) || symbol;
-                // A re-export merged with an export from a module augmentation can result in `symbol`
-                // being an external module symbol; the name it is re-exported by will be `symbolTableKey`
-                // (which comes from the keys of `moduleSymbol.exports`.)
-                var importedName = ts.isExternalModuleSymbol(namedSymbol)
+                // 1. A named export must be imported by its key in `moduleSymbol.exports` or `moduleSymbol.members`.
+                // 2. A re-export merged with an export from a module augmentation can result in `symbol`
+                //    being an external module symbol; the name it is re-exported by will be `symbolTableKey`
+                //    (which comes from the keys of `moduleSymbol.exports`.)
+                // 3. Otherwise, we have a default/namespace import that can be imported by any name, and
+                //    `symbolTableKey` will be something undesirable like `export=` or `default`, so we try to
+                //    get a better name.
+                var importedName = exportKind === 0 /* Named */ || ts.isExternalModuleSymbol(namedSymbol)
                     ? ts.unescapeLeadingUnderscores(symbolTableKey)
                     : ts.getNameForExportedSymbol(namedSymbol, scriptTarget);
                 var moduleName = ts.stripQuotes(moduleSymbol.name);
@@ -125789,7 +125820,7 @@ var ts;
                 cache.add(importingFile.path, defaultInfo.symbol, defaultInfo.exportKind === 1 /* Default */ ? "default" /* Default */ : "export=" /* ExportEquals */, moduleSymbol, moduleFile, defaultInfo.exportKind, isFromPackageJson, scriptTarget, checker);
             }
             checker.forEachExportAndPropertyOfModule(moduleSymbol, function (exported, key) {
-                if (exported !== (defaultInfo === null || defaultInfo === void 0 ? void 0 : defaultInfo.symbol) && isImportableSymbol(exported, checker) && ts.addToSeen(seenExports, exported)) {
+                if (exported !== (defaultInfo === null || defaultInfo === void 0 ? void 0 : defaultInfo.symbol) && isImportableSymbol(exported, checker) && ts.addToSeen(seenExports, key)) {
                     cache.add(importingFile.path, exported, key, moduleSymbol, moduleFile, 0 /* Named */, isFromPackageJson, scriptTarget, checker);
                 }
             });
@@ -128644,8 +128675,8 @@ var ts;
             }
             var checker = origin.isFromPackageJson ? host.getPackageJsonAutoImportProvider().getTypeChecker() : program.getTypeChecker();
             var moduleSymbol = origin.moduleSymbol;
-            var exportedSymbol = checker.getMergedSymbol(ts.skipAlias(symbol.exportSymbol || symbol, checker));
-            var _b = ts.codefix.getImportCompletionAction(exportedSymbol, moduleSymbol, sourceFile, ts.getNameForExportedSymbol(symbol, ts.getEmitScriptTarget(compilerOptions)), host, program, formatContext, previousToken && ts.isIdentifier(previousToken) ? previousToken.getStart(sourceFile) : position, preferences), moduleSpecifier = _b.moduleSpecifier, codeAction = _b.codeAction;
+            var targetSymbol = checker.getMergedSymbol(ts.skipAlias(symbol.exportSymbol || symbol, checker));
+            var _b = ts.codefix.getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, ts.getNameForExportedSymbol(symbol, ts.getEmitScriptTarget(compilerOptions)), host, program, formatContext, previousToken && ts.isIdentifier(previousToken) ? previousToken.getStart(sourceFile) : position, preferences), moduleSpecifier = _b.moduleSpecifier, codeAction = _b.codeAction;
             ts.Debug.assert(!(data === null || data === void 0 ? void 0 : data.moduleSpecifier) || moduleSpecifier === data.moduleSpecifier);
             return { sourceDisplay: [ts.textPart(moduleSpecifier)], codeActions: [codeAction] };
         }
@@ -129540,8 +129571,9 @@ var ts;
             function isNewIdentifierDefinitionLocation() {
                 if (contextToken) {
                     var containingNodeKind = contextToken.parent.kind;
+                    var tokenKind = keywordForNode(contextToken);
                     // Previous token may have been a keyword that was converted to an identifier.
-                    switch (keywordForNode(contextToken)) {
+                    switch (tokenKind) {
                         case 27 /* CommaToken */:
                             return containingNodeKind === 207 /* CallExpression */ // func( a, |
                                 || containingNodeKind === 170 /* Constructor */ // constructor( a, |   /* public, protected, private keywords are allowed here, so show completion */
@@ -129576,10 +129608,12 @@ var ts;
                             return containingNodeKind === 222 /* TemplateExpression */; // `aa ${|
                         case 16 /* TemplateMiddle */:
                             return containingNodeKind === 232 /* TemplateSpan */; // `aa ${10} dd ${|
-                        case 123 /* PublicKeyword */:
-                        case 121 /* PrivateKeyword */:
-                        case 122 /* ProtectedKeyword */:
-                            return containingNodeKind === 166 /* PropertyDeclaration */; // class A{ public |
+                        case 131 /* AsyncKeyword */:
+                            return containingNodeKind === 168 /* MethodDeclaration */ // const obj = { async c|()
+                                || containingNodeKind === 295 /* ShorthandPropertyAssignment */; // const obj = { async c|
+                    }
+                    if (isClassMemberCompletionKeyword(tokenKind)) {
+                        return true;
                     }
                 }
                 return false;
@@ -147884,11 +147918,11 @@ var ts;
             AddAsTypeOnly[AddAsTypeOnly["Required"] = 2] = "Required";
             AddAsTypeOnly[AddAsTypeOnly["NotAllowed"] = 4] = "NotAllowed";
         })(AddAsTypeOnly || (AddAsTypeOnly = {}));
-        function getImportCompletionAction(exportedSymbol, moduleSymbol, sourceFile, symbolName, host, program, formatContext, position, preferences) {
+        function getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, symbolName, host, program, formatContext, position, preferences) {
             var compilerOptions = program.getCompilerOptions();
             var exportInfos = ts.pathIsBareSpecifier(ts.stripQuotes(moduleSymbol.name))
-                ? [getSymbolExportInfoForSymbol(exportedSymbol, moduleSymbol, program, host)]
-                : getAllReExportingModules(sourceFile, exportedSymbol, moduleSymbol, symbolName, host, program, preferences, /*useAutoImportProvider*/ true);
+                ? [getSymbolExportInfoForSymbol(targetSymbol, moduleSymbol, program, host)]
+                : getAllReExportingModules(sourceFile, targetSymbol, moduleSymbol, symbolName, host, program, preferences, /*useAutoImportProvider*/ true);
             var useRequire = shouldUseRequire(sourceFile, program);
             var isValidTypeOnlyUseSite = ts.isValidTypeOnlyAliasUseSite(ts.getTokenAtPosition(sourceFile, position));
             var fix = ts.Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences));
@@ -147926,7 +147960,7 @@ var ts;
                 }
             }
         }
-        function getAllReExportingModules(importingFile, exportedSymbol, exportingModuleSymbol, symbolName, host, program, preferences, useAutoImportProvider) {
+        function getAllReExportingModules(importingFile, targetSymbol, exportingModuleSymbol, symbolName, host, program, preferences, useAutoImportProvider) {
             var result = [];
             var compilerOptions = program.getCompilerOptions();
             var getModuleSpecifierResolutionHost = ts.memoizeOne(function (isFromPackageJson) {
@@ -147939,12 +147973,12 @@ var ts;
                     return;
                 }
                 var defaultInfo = ts.getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions);
-                if (defaultInfo && (defaultInfo.name === symbolName || moduleSymbolToValidIdentifier(moduleSymbol, ts.getEmitScriptTarget(compilerOptions)) === symbolName) && ts.skipAlias(defaultInfo.symbol, checker) === exportedSymbol && isImportable(program, moduleFile, isFromPackageJson)) {
+                if (defaultInfo && (defaultInfo.name === symbolName || moduleSymbolToValidIdentifier(moduleSymbol, ts.getEmitScriptTarget(compilerOptions)) === symbolName) && ts.skipAlias(defaultInfo.symbol, checker) === targetSymbol && isImportable(program, moduleFile, isFromPackageJson)) {
                     result.push({ symbol: defaultInfo.symbol, moduleSymbol: moduleSymbol, moduleFileName: moduleFile === null || moduleFile === void 0 ? void 0 : moduleFile.fileName, exportKind: defaultInfo.exportKind, targetFlags: ts.skipAlias(defaultInfo.symbol, checker).flags, isFromPackageJson: isFromPackageJson });
                 }
                 for (var _i = 0, _a = checker.getExportsAndPropertiesOfModule(moduleSymbol); _i < _a.length; _i++) {
                     var exported = _a[_i];
-                    if (exported.name === symbolName && ts.skipAlias(exported, checker) === exportedSymbol && isImportable(program, moduleFile, isFromPackageJson)) {
+                    if (exported.name === symbolName && checker.getMergedSymbol(ts.skipAlias(exported, checker)) === targetSymbol && isImportable(program, moduleFile, isFromPackageJson)) {
                         result.push({ symbol: exported, moduleSymbol: moduleSymbol, moduleFileName: moduleFile === null || moduleFile === void 0 ? void 0 : moduleFile.fileName, exportKind: 0 /* Named */, targetFlags: ts.skipAlias(exported, checker).flags, isFromPackageJson: isFromPackageJson });
                     }
                 }
@@ -148195,12 +148229,14 @@ var ts;
             }
             var allowsImportingSpecifier = ts.createPackageJsonImportFilter(sourceFile, preferences, host).allowsImportingSpecifier;
             return fixes.reduce(function (best, fix) {
+                // Takes true branch of conditional if `fix` is better than `best`
                 return compareModuleSpecifiers(fix, best, sourceFile, program, allowsImportingSpecifier) === -1 /* LessThan */ ? fix : best;
             });
         }
+        /** @returns `Comparison.LessThan` if `a` is better than `b`. */
         function compareModuleSpecifiers(a, b, importingFile, program, allowsImportingSpecifier) {
             if (a.kind !== 0 /* UseNamespace */ && b.kind !== 0 /* UseNamespace */) {
-                return ts.compareBooleans(allowsImportingSpecifier(a.moduleSpecifier), allowsImportingSpecifier(b.moduleSpecifier))
+                return ts.compareBooleans(allowsImportingSpecifier(b.moduleSpecifier), allowsImportingSpecifier(a.moduleSpecifier))
                     || compareNodeCoreModuleSpecifiers(a.moduleSpecifier, b.moduleSpecifier, importingFile, program)
                     || ts.compareNumberOfDirectorySeparators(a.moduleSpecifier, b.moduleSpecifier);
             }
@@ -150852,7 +150888,8 @@ var ts;
                     insertBefore = ts.findChildOfKind(containingFunction, 98 /* FunctionKeyword */, sourceFile);
                     break;
                 case 213 /* ArrowFunction */:
-                    insertBefore = ts.findChildOfKind(containingFunction, 20 /* OpenParenToken */, sourceFile) || ts.first(containingFunction.parameters);
+                    var kind = containingFunction.typeParameters ? 29 /* LessThanToken */ : 20 /* OpenParenToken */;
+                    insertBefore = ts.findChildOfKind(containingFunction, kind, sourceFile) || ts.first(containingFunction.parameters);
                     break;
                 default:
                     return;