@typescript-deploys/pr-build 4.7.0-pr-48264-3 → 4.7.0-pr-48294-7

package/lib/typescriptServices.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-insiders.20220315";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220316";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8228,7 +8228,7 @@ var ts;
         Identifier_expected: diag(1003, ts.DiagnosticCategory.Error, "Identifier_expected_1003", "Identifier expected."),
         _0_expected: diag(1005, ts.DiagnosticCategory.Error, "_0_expected_1005", "'{0}' expected."),
         A_file_cannot_have_a_reference_to_itself: diag(1006, ts.DiagnosticCategory.Error, "A_file_cannot_have_a_reference_to_itself_1006", "A file cannot have a reference to itself."),
-        The_parser_expected_to_find_a_to_match_the_token_here: diag(1007, ts.DiagnosticCategory.Error, "The_parser_expected_to_find_a_to_match_the_token_here_1007", "The parser expected to find a '}' to match the '{' token here."),
+        The_parser_expected_to_find_a_1_to_match_the_0_token_here: diag(1007, ts.DiagnosticCategory.Error, "The_parser_expected_to_find_a_1_to_match_the_0_token_here_1007", "The parser expected to find a '{1}' to match the '{0}' token here."),
         Trailing_comma_not_allowed: diag(1009, ts.DiagnosticCategory.Error, "Trailing_comma_not_allowed_1009", "Trailing comma not allowed."),
         Asterisk_Slash_expected: diag(1010, ts.DiagnosticCategory.Error, "Asterisk_Slash_expected_1010", "'*/' expected."),
         An_element_access_expression_should_take_an_argument: diag(1011, ts.DiagnosticCategory.Error, "An_element_access_expression_should_take_an_argument_1011", "An element access expression should take an argument."),
@@ -15144,10 +15144,6 @@ 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 */:
@@ -16726,14 +16722,14 @@ var ts;
     }
     ts.isFunctionSymbol = isFunctionSymbol;
     function tryGetModuleSpecifierFromDeclaration(node) {
-        var _a, _b;
+        var _a, _b, _c;
         switch (node.kind) {
             case 253 /* VariableDeclaration */:
-                return (_a = ts.findAncestor(node.initializer, function (node) { return isRequireCall(node, /*requireStringLiteralLikeArgument*/ true); })) === null || _a === void 0 ? void 0 : _a.arguments[0];
+                return node.initializer.arguments[0].text;
             case 265 /* ImportDeclaration */:
-                return ts.tryCast(node.moduleSpecifier, ts.isStringLiteralLike);
+                return (_a = ts.tryCast(node.moduleSpecifier, ts.isStringLiteralLike)) === null || _a === void 0 ? void 0 : _a.text;
             case 264 /* ImportEqualsDeclaration */:
-                return ts.tryCast((_b = ts.tryCast(node.moduleReference, ts.isExternalModuleReference)) === null || _b === void 0 ? void 0 : _b.expression, ts.isStringLiteralLike);
+                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;
             default:
                 ts.Debug.assertNever(node);
         }
@@ -17260,28 +17256,21 @@ var ts;
     // export = <EntityNameExpression>
     // export default <EntityNameExpression>
     // module.exports = <EntityNameExpression>
-    // module.exports.x = <EntityNameExpression>
-    // const x = require("...")
-    // const { x } = require("...")
-    // const x = require("...").y
-    // const { x } = require("...").y
+    // {<Identifier>}
+    // {name: <EntityNameExpression>}
     function isAliasSymbolDeclaration(node) {
-        if (node.kind === 264 /* ImportEqualsDeclaration */ ||
+        return 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)) {
-            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));
+            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);
     }
     ts.isAliasSymbolDeclaration = isAliasSymbolDeclaration;
     function getAliasDeclarationFromName(node) {
@@ -17292,7 +17281,6 @@ var ts;
             case 274 /* ExportSpecifier */:
             case 270 /* ExportAssignment */:
             case 264 /* ImportEqualsDeclaration */:
-            case 273 /* NamespaceExport */:
                 return node.parent;
             case 160 /* QualifiedName */:
                 do {
@@ -31632,20 +31620,23 @@ var ts;
             return inContext(32768 /* AwaitContext */);
         }
         function parseErrorAtCurrentToken(message, arg0) {
-            parseErrorAt(scanner.getTokenPos(), scanner.getTextPos(), message, arg0);
+            return parseErrorAt(scanner.getTokenPos(), scanner.getTextPos(), message, arg0);
         }
         function parseErrorAtPosition(start, length, message, arg0) {
             // Don't report another error if it would just be at the same position as the last error.
             var lastError = ts.lastOrUndefined(parseDiagnostics);
+            var result;
             if (!lastError || start !== lastError.start) {
-                parseDiagnostics.push(ts.createDetachedDiagnostic(fileName, start, length, message, arg0));
+                result = ts.createDetachedDiagnostic(fileName, start, length, message, arg0);
+                parseDiagnostics.push(result);
             }
             // Mark that we've encountered an error.  We'll set an appropriate bit on the next
             // node we finish so that it can't be reused incrementally.
             parseErrorBeforeNextFinishedNode = true;
+            return result;
         }
         function parseErrorAt(start, end, message, arg0) {
-            parseErrorAtPosition(start, end - start, message, arg0);
+            return parseErrorAtPosition(start, end - start, message, arg0);
         }
         function parseErrorAtRange(range, message, arg0) {
             parseErrorAt(range.pos, range.end, message, arg0);
@@ -31918,6 +31909,19 @@ var ts;
             parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(kind));
             return false;
         }
+        function parseExpectedMatchingBrackets(openKind, closeKind, openParsed, openPosition) {
+            if (token() === closeKind) {
+                nextToken();
+                return;
+            }
+            var lastError = parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(closeKind));
+            if (!openParsed) {
+                return;
+            }
+            if (lastError) {
+                ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, openPosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_1_to_match_the_0_token_here, ts.tokenToString(openKind), ts.tokenToString(closeKind)));
+            }
+        }
         function parseOptional(t) {
             if (token() === t) {
                 nextToken();
@@ -33566,7 +33570,7 @@ var ts;
             if (!parseExpected(19 /* CloseBraceToken */)) {
                 var lastError = ts.lastOrUndefined(parseDiagnostics);
                 if (lastError && lastError.code === ts.Diagnostics._0_expected.code) {
-                    ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, openBracePosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_to_match_the_token_here));
+                    ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, openBracePosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_1_to_match_the_0_token_here, "{", "}"));
                 }
             }
             return finishNode(factory.createImportTypeAssertionContainer(clause, multiLine), pos);
@@ -35376,10 +35380,11 @@ var ts;
         }
         function parseArrayLiteralExpression() {
             var pos = getNodePos();
-            parseExpected(22 /* OpenBracketToken */);
+            var openBracketPosition = scanner.getTokenPos();
+            var openBracketParsed = parseExpected(22 /* OpenBracketToken */);
             var multiLine = scanner.hasPrecedingLineBreak();
             var elements = parseDelimitedList(15 /* ArrayLiteralMembers */, parseArgumentOrArrayLiteralElement);
-            parseExpected(23 /* CloseBracketToken */);
+            parseExpectedMatchingBrackets(22 /* OpenBracketToken */, 23 /* CloseBracketToken */, openBracketParsed, openBracketPosition);
             return finishNode(factory.createArrayLiteralExpression(elements, multiLine), pos);
         }
         function parseObjectLiteralElement() {
@@ -35436,15 +35441,10 @@ var ts;
         function parseObjectLiteralExpression() {
             var pos = getNodePos();
             var openBracePosition = scanner.getTokenPos();
-            parseExpected(18 /* OpenBraceToken */);
+            var openBraceParsed = parseExpected(18 /* OpenBraceToken */);
             var multiLine = scanner.hasPrecedingLineBreak();
             var properties = parseDelimitedList(12 /* ObjectLiteralMembers */, parseObjectLiteralElement, /*considerSemicolonAsDelimiter*/ true);
-            if (!parseExpected(19 /* CloseBraceToken */)) {
-                var lastError = ts.lastOrUndefined(parseDiagnostics);
-                if (lastError && lastError.code === ts.Diagnostics._0_expected.code) {
-                    ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, openBracePosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_to_match_the_token_here));
-                }
-            }
+            parseExpectedMatchingBrackets(18 /* OpenBraceToken */, 19 /* CloseBraceToken */, openBraceParsed, openBracePosition);
             return finishNode(factory.createObjectLiteralExpression(properties, multiLine), pos);
         }
         function parseFunctionExpression() {
@@ -35500,15 +35500,11 @@ var ts;
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             var openBracePosition = scanner.getTokenPos();
-            if (parseExpected(18 /* OpenBraceToken */, diagnosticMessage) || ignoreMissingOpenBrace) {
+            var openBraceParsed = parseExpected(18 /* OpenBraceToken */, diagnosticMessage);
+            if (openBraceParsed || ignoreMissingOpenBrace) {
                 var multiLine = scanner.hasPrecedingLineBreak();
                 var statements = parseList(1 /* BlockStatements */, parseStatement);
-                if (!parseExpected(19 /* CloseBraceToken */)) {
-                    var lastError = ts.lastOrUndefined(parseDiagnostics);
-                    if (lastError && lastError.code === ts.Diagnostics._0_expected.code) {
-                        ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, openBracePosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_to_match_the_token_here));
-                    }
-                }
+                parseExpectedMatchingBrackets(18 /* OpenBraceToken */, 19 /* CloseBraceToken */, openBraceParsed, openBracePosition);
                 var result = withJSDoc(finishNode(factory.createBlock(statements, multiLine), pos), hasJSDoc);
                 if (token() === 63 /* EqualsToken */) {
                     parseErrorAtCurrentToken(ts.Diagnostics.Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_the_whole_assignment_in_parentheses);
@@ -35553,9 +35549,10 @@ var ts;
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             parseExpected(99 /* IfKeyword */);
-            parseExpected(20 /* OpenParenToken */);
+            var openParenPosition = scanner.getTokenPos();
+            var openParenParsed = parseExpected(20 /* OpenParenToken */);
             var expression = allowInAnd(parseExpression);
-            parseExpected(21 /* CloseParenToken */);
+            parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenParsed, openParenPosition);
             var thenStatement = parseStatement();
             var elseStatement = parseOptional(91 /* ElseKeyword */) ? parseStatement() : undefined;
             return withJSDoc(finishNode(factory.createIfStatement(expression, thenStatement, elseStatement), pos), hasJSDoc);
@@ -35566,9 +35563,10 @@ var ts;
             parseExpected(90 /* DoKeyword */);
             var statement = parseStatement();
             parseExpected(115 /* WhileKeyword */);
-            parseExpected(20 /* OpenParenToken */);
+            var openParenPosition = scanner.getTokenPos();
+            var openParenParsed = parseExpected(20 /* OpenParenToken */);
             var expression = allowInAnd(parseExpression);
-            parseExpected(21 /* CloseParenToken */);
+            parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenParsed, openParenPosition);
             // From: https://mail.mozilla.org/pipermail/es-discuss/2011-August/016188.html
             // 157 min --- All allen at wirfs-brock.com CONF --- "do{;}while(false)false" prohibited in
             // spec but allowed in consensus reality. Approved -- this is the de-facto standard whereby
@@ -35580,9 +35578,10 @@ var ts;
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             parseExpected(115 /* WhileKeyword */);
-            parseExpected(20 /* OpenParenToken */);
+            var openParenPosition = scanner.getTokenPos();
+            var openParenParsed = parseExpected(20 /* OpenParenToken */);
             var expression = allowInAnd(parseExpression);
-            parseExpected(21 /* CloseParenToken */);
+            parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenParsed, openParenPosition);
             var statement = parseStatement();
             return withJSDoc(finishNode(factory.createWhileStatement(expression, statement), pos), hasJSDoc);
         }
@@ -35649,9 +35648,10 @@ var ts;
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             parseExpected(116 /* WithKeyword */);
-            parseExpected(20 /* OpenParenToken */);
+            var openParenPosition = scanner.getTokenPos();
+            var openParenParsed = parseExpected(20 /* OpenParenToken */);
             var expression = allowInAnd(parseExpression);
-            parseExpected(21 /* CloseParenToken */);
+            parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenParsed, openParenPosition);
             var statement = doInsideOfContext(16777216 /* InWithStatement */, parseStatement);
             return withJSDoc(finishNode(factory.createWithStatement(expression, statement), pos), hasJSDoc);
         }
@@ -36785,7 +36785,7 @@ var ts;
                 if (!parseExpected(19 /* CloseBraceToken */)) {
                     var lastError = ts.lastOrUndefined(parseDiagnostics);
                     if (lastError && lastError.code === ts.Diagnostics._0_expected.code) {
-                        ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, openBracePosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_to_match_the_token_here));
+                        ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, openBracePosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_1_to_match_the_0_token_here, "{", "}"));
                     }
                 }
                 return finishNode(factory.createAssertClause(elements, multiLine), pos);
@@ -37761,8 +37761,7 @@ var ts;
                             hasChildren = true;
                             if (child.kind === 342 /* JSDocTypeTag */) {
                                 if (childTypeTag) {
-                                    parseErrorAtCurrentToken(ts.Diagnostics.A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags);
-                                    var lastError = ts.lastOrUndefined(parseDiagnostics);
+                                    var lastError = parseErrorAtCurrentToken(ts.Diagnostics.A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags);
                                     if (lastError) {
                                         ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, 0, 0, ts.Diagnostics.The_tag_was_first_specified_here));
                                     }
@@ -39640,13 +39639,6 @@ 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",
@@ -42026,8 +42018,7 @@ var ts;
         Extensions[Extensions["JavaScript"] = 1] = "JavaScript";
         Extensions[Extensions["Json"] = 2] = "Json";
         Extensions[Extensions["TSConfig"] = 3] = "TSConfig";
-        Extensions[Extensions["DtsOnly"] = 4] = "DtsOnly";
-        Extensions[Extensions["TypeScriptButNotDts"] = 5] = "TypeScriptButNotDts";
+        Extensions[Extensions["DtsOnly"] = 4] = "DtsOnly"; /** Only '.d.ts' */
     })(Extensions || (Extensions = {}));
     /** Used with `Extensions.DtsOnly` to extract the path from TypeScript results. */
     function resolvedTypeScriptOnly(resolved) {
@@ -42972,21 +42963,7 @@ 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) {
-        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);
+        return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, ts.getDirectoryPath(containingFile), compilerOptions, host, cache, lookupConfig ? tsconfigExtensions : (compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions), redirectedReference);
     }
     ts.nodeModuleNameResolver = nodeModuleNameResolver;
     function nodeModuleNameResolverWorker(features, moduleName, containingDirectory, compilerOptions, host, cache, extensions, redirectedReference) {
@@ -42995,10 +42972,6 @@ 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,
@@ -43006,7 +42979,7 @@ var ts;
             failedLookupLocations: failedLookupLocations,
             packageJsonInfoCache: cache,
             features: features,
-            conditions: conditions,
+            conditions: features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"]
         };
         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);
@@ -43214,22 +43187,20 @@ 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 */) || (useDts ? tryExtension(".d.mts" /* Dmts */) : undefined);
+                        return tryExtension(".mts" /* Mts */) || tryExtension(".d.mts" /* Dmts */);
                     case ".cjs" /* Cjs */:
                     case ".cts" /* Cts */:
                     case ".d.cts" /* Dcts */:
-                        return tryExtension(".cts" /* Cts */) || (useDts ? tryExtension(".d.cts" /* Dcts */) : undefined);
+                        return tryExtension(".cts" /* Cts */) || tryExtension(".d.cts" /* Dcts */);
                     case ".json" /* Json */:
                         candidate += ".json" /* Json */;
-                        return useDts ? tryExtension(".d.ts" /* Dts */) : undefined;
+                        return tryExtension(".d.ts" /* Dts */);
                     default:
-                        return tryExtension(".ts" /* Ts */) || tryExtension(".tsx" /* Tsx */) || (useDts ? tryExtension(".d.ts" /* Dts */) : undefined);
+                        return tryExtension(".ts" /* Ts */) || tryExtension(".tsx" /* Tsx */) || tryExtension(".d.ts" /* Dts */);
                 }
             case Extensions.JavaScript:
                 switch (originalExtension) {
@@ -43447,7 +43418,6 @@ var ts;
             switch (extensions) {
                 case Extensions.JavaScript:
                 case Extensions.Json:
-                case Extensions.TypeScriptButNotDts:
                     packageFile = readPackageJsonMainField(jsonContent, candidate, state);
                     break;
                 case Extensions.TypeScript:
@@ -43526,8 +43496,6 @@ 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 */;
         }
@@ -55144,7 +55112,7 @@ var ts;
                 if (!omitTypeAlias) {
                     return errorType;
                 }
-                return getTypeAliasInstantiation(omitTypeAlias, [source, omitKeyType]);
+                return getGlobalTypeAliasInstantiation(omitTypeAlias, [source, omitKeyType]);
             }
             var members = ts.createSymbolTable();
             for (var _b = 0, spreadableProperties_1 = spreadableProperties; _b < spreadableProperties_1.length; _b++) {
@@ -55596,7 +55564,7 @@ var ts;
                         }
                     }
                     var sourceTypes = ts.some(constructorTypes, function (t) { return !!(t.flags & ~98304 /* Nullable */); }) ? constructorTypes : types; // TODO: GH#18217
-                    type = getUnionType(sourceTypes);
+                    type = getUnionType(sourceTypes, 2 /* Subtype */);
                 }
             }
             var widened = getWidenedType(addOptionality(type, /*isProperty*/ false, definedInMethod && !definedInConstructor));
@@ -56911,7 +56879,7 @@ var ts;
                     }
                 }
                 if (memberTypeList.length) {
-                    var enumType_1 = getUnionType(memberTypeList, 1 /* Literal */, symbol, /*aliasTypeArguments*/ undefined);
+                    var enumType_1 = getUnionType(memberTypeList, 1 /* Literal */, symbol, /*aliasTypeArguments*/ undefined, /*aliasMapper*/ undefined);
                     if (enumType_1.flags & 1048576 /* Union */) {
                         enumType_1.flags |= 1024 /* EnumLiteral */;
                         enumType_1.symbol = symbol;
@@ -58531,8 +58499,10 @@ var ts;
             return type;
         }
         function isMappedTypeGenericIndexedAccess(type) {
-            return type.flags & 8388608 /* IndexedAccess */ && ts.getObjectFlags(type.objectType) & 32 /* Mapped */ &&
-                !isGenericMappedType(type.objectType) && isGenericIndexType(type.indexType);
+            var objectType;
+            return !!(type.flags & 8388608 /* IndexedAccess */ && ts.getObjectFlags(objectType = type.objectType) & 32 /* Mapped */ &&
+                !isGenericMappedType(objectType) && isGenericIndexType(type.indexType) &&
+                !objectType.declaration.questionToken && !objectType.declaration.nameType);
         }
         /**
          * For a type parameter, return the base constraint of the type parameter. For the string, number,
@@ -59120,7 +59090,19 @@ var ts;
                 return p.typeExpression && ts.isJSDocVariadicType(p.typeExpression.type) ? p.typeExpression.type : undefined;
             });
             var syntheticArgsSymbol = createSymbol(3 /* Variable */, "args", 32768 /* RestParameter */);
-            syntheticArgsSymbol.type = lastParamVariadicType ? createArrayType(getTypeFromTypeNode(lastParamVariadicType.type)) : anyArrayType;
+            if (lastParamVariadicType) {
+                // Parameter has effective annotation, lock in type
+                syntheticArgsSymbol.type = createArrayType(getTypeFromTypeNode(lastParamVariadicType.type));
+            }
+            else {
+                // Parameter has no annotation
+                // By using a `DeferredType` symbol, we allow the type of this rest arg to be overriden by contextual type assignment so long as its type hasn't been
+                // cached by `getTypeOfSymbol` yet.
+                syntheticArgsSymbol.checkFlags |= 65536 /* DeferredType */;
+                syntheticArgsSymbol.deferralParent = neverType;
+                syntheticArgsSymbol.deferralConstituents = [anyArrayType];
+                syntheticArgsSymbol.deferralWriteConstituents = [anyArrayType];
+            }
             if (lastParamVariadicType) {
                 // Replace the last parameter with a rest parameter.
                 parameters.pop();
@@ -59620,7 +59602,7 @@ var ts;
             type.resolvedTypeArguments = source.resolvedTypeArguments;
             return type;
         }
-        function createDeferredTypeReference(target, node, mapper, aliasSymbol, aliasTypeArguments) {
+        function createDeferredTypeReference(target, node, mapper, aliasSymbol, aliasTypeArguments, aliasMapper) {
             if (!aliasSymbol) {
                 aliasSymbol = getAliasSymbolForTypeNode(node);
                 var localAliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
@@ -59632,6 +59614,7 @@ var ts;
             type.mapper = mapper;
             type.aliasSymbol = aliasSymbol;
             type.aliasTypeArguments = aliasTypeArguments;
+            type.aliasMapper = aliasMapper;
             return type;
         }
         function getTypeArguments(type) {
@@ -59696,7 +59679,7 @@ var ts;
             }
             return checkNoTypeArguments(node, symbol) ? type : errorType;
         }
-        function getTypeAliasInstantiation(symbol, typeArguments, aliasSymbol, aliasTypeArguments) {
+        function getGlobalTypeAliasInstantiation(symbol, typeArguments, aliasSymbol, aliasTypeArguments) {
             var type = getDeclaredTypeOfSymbol(symbol);
             if (type === intrinsicMarkerType && intrinsicTypeKinds.has(symbol.escapedName) && typeArguments && typeArguments.length === 1) {
                 return getStringMappingType(symbol, typeArguments[0]);
@@ -59710,6 +59693,33 @@ var ts;
             }
             return instantiation;
         }
+        function getLocalTypeAliasInstantiation(symbol, typeArguments, outerTypeParameterMapper, aliasSymbol, aliasTypeArguments) {
+            var type = getDeclaredTypeOfSymbol(symbol);
+            if (type === intrinsicMarkerType && intrinsicTypeKinds.has(symbol.escapedName) && typeArguments && typeArguments.length === 1) {
+                return getStringMappingType(symbol, typeArguments[0]);
+            }
+            var links = getSymbolLinks(symbol);
+            var outerTypeParameters = getOuterTypeParametersOfAlias(symbol);
+            var mappedOuterParams = outerTypeParameterMapper && outerTypeParameters && instantiateTypes(outerTypeParameters, outerTypeParameterMapper);
+            var typeParameters = links.typeParameters;
+            var id = getTypeListId(ts.concatenate(mappedOuterParams, typeArguments)) + getAliasId(aliasSymbol, aliasTypeArguments);
+            var instantiation = links.instantiations.get(id);
+            if (!instantiation) {
+                var outerTypeArgumentMapper = outerTypeParameters && mappedOuterParams && createTypeMapper(outerTypeParameters, mappedOuterParams);
+                var argumentMapper = createTypeMapper(typeParameters, fillMissingTypeArguments(typeArguments, typeParameters, getMinTypeArgumentCount(typeParameters), ts.isInJSFile(symbol.valueDeclaration)));
+                var combinedMapper = outerTypeArgumentMapper ? combineTypeMappers(argumentMapper, outerTypeArgumentMapper) : argumentMapper;
+                links.instantiations.set(id, instantiation = instantiateTypeWithAlias(type, combinedMapper, aliasSymbol, aliasTypeArguments));
+            }
+            return instantiation;
+        }
+        function getOuterTypeParametersOfAlias(symbol) {
+            var _a;
+            var links = getSymbolLinks(symbol);
+            if (!links.outerTypeParameters) {
+                links.outerTypeParameters = ((_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a[0]) && getOuterTypeParameters(symbol.declarations[0], /*includeThisTypes*/ true);
+            }
+            return links.outerTypeParameters;
+        }
         /**
          * Get type from reference to type alias. When a type alias is generic, the declared type of the type alias may include
          * references to the type parameters of the alias. We replace those with the actual type arguments by instantiating the
@@ -59745,7 +59755,7 @@ var ts;
                 // a .d.ts file. See #43622 for an example.
                 var aliasSymbol = getAliasSymbolForTypeNode(node);
                 var newAliasSymbol = aliasSymbol && (isLocalTypeAlias(symbol) || !isLocalTypeAlias(aliasSymbol)) ? aliasSymbol : undefined;
-                return getTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node), newAliasSymbol, getTypeArgumentsForAliasSymbol(newAliasSymbol));
+                return getGlobalTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node), newAliasSymbol, getTypeArgumentsForAliasSymbol(newAliasSymbol));
             }
             return checkNoTypeArguments(node, symbol) ? type : errorType;
         }
@@ -60660,14 +60670,7 @@ var ts;
             result.types = types;
             return result;
         }
-        // We sort and deduplicate the constituent types based on object identity. If the subtypeReduction
-        // flag is specified we also reduce the constituent type set to only include types that aren't subtypes
-        // of other types. Subtype reduction is expensive for large union types and is possible only when union
-        // types are known not to circularly reference themselves (as is the case with union types created by
-        // expression constructs such as array literals and the || and ?: operators). Named types can
-        // circularly reference themselves and therefore cannot be subtype reduced during their declaration.
-        // For example, "type Item = string | (() => Item" is a named type that circularly references itself.
-        function getUnionType(types, unionReduction, aliasSymbol, aliasTypeArguments, origin) {
+        function getUnionType(types, unionReduction, aliasSymbol, aliasTypeArguments, aliasMapper, origin) {
             if (unionReduction === void 0) { unionReduction = 1 /* Literal */; }
             if (types.length === 0) {
                 return neverType;
@@ -60736,7 +60739,7 @@ var ts;
             }
             var objectFlags = (includes & 36323363 /* NotPrimitiveUnion */ ? 0 : 65536 /* PrimitiveUnion */) |
                 (includes & 2097152 /* Intersection */ ? 33554432 /* ContainsIntersections */ : 0);
-            return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments, origin);
+            return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments, aliasMapper, origin);
         }
         function getUnionOrIntersectionTypePredicate(signatures, kind) {
             var first;
@@ -60774,7 +60777,7 @@ var ts;
             return a.kind === b.kind && a.parameterIndex === b.parameterIndex;
         }
         // This function assumes the constituent type list is sorted and deduplicated.
-        function getUnionTypeFromSortedList(types, objectFlags, aliasSymbol, aliasTypeArguments, origin) {
+        function getUnionTypeFromSortedList(types, objectFlags, aliasSymbol, aliasTypeArguments, aliasMapper, origin) {
             if (types.length === 0) {
                 return neverType;
             }
@@ -60794,6 +60797,7 @@ var ts;
                 type.origin = origin;
                 type.aliasSymbol = aliasSymbol;
                 type.aliasTypeArguments = aliasTypeArguments;
+                type.aliasMapper = aliasMapper;
                 if (types.length === 2 && types[0].flags & 512 /* BooleanLiteral */ && types[1].flags & 512 /* BooleanLiteral */) {
                     type.flags |= 16 /* Boolean */;
                     type.intrinsicName = "boolean";
@@ -60806,7 +60810,7 @@ var ts;
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
                 var aliasSymbol = getAliasSymbolForTypeNode(node);
-                links.resolvedType = getUnionType(ts.map(node.types, getTypeFromTypeNode), 1 /* Literal */, aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol));
+                links.resolvedType = getUnionType(ts.map(node.types, getTypeFromTypeNode), 1 /* Literal */, aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol), /*aliasMapper*/ undefined);
             }
             return links.resolvedType;
         }
@@ -60965,25 +60969,16 @@ var ts;
             types[index] = getUnionTypeFromSortedList(result, 65536 /* PrimitiveUnion */);
             return true;
         }
-        function createIntersectionType(types, aliasSymbol, aliasTypeArguments) {
+        function createIntersectionType(types, aliasSymbol, aliasTypeArguments, aliasMapper) {
             var result = createType(2097152 /* Intersection */);
             result.objectFlags = getPropagatingFlagsOfTypes(types, /*excludeKinds*/ 98304 /* Nullable */);
             result.types = types;
             result.aliasSymbol = aliasSymbol;
             result.aliasTypeArguments = aliasTypeArguments;
+            result.aliasMapper = aliasMapper;
             return result;
         }
-        // We normalize combinations of intersection and union types based on the distributive property of the '&'
-        // operator. Specifically, because X & (A | B) is equivalent to X & A | X & B, we can transform intersection
-        // types with union type constituents into equivalent union types with intersection type constituents and
-        // effectively ensure that union types are always at the top level in type representations.
-        //
-        // We do not perform structural deduplication on intersection types. Intersection types are created only by the &
-        // type operator and we can't reduce those because we want to support recursive intersection types. For example,
-        // a type alias of the form "type List<T> = T & { next: List<T> }" cannot be reduced during its declaration.
-        // Also, unlike union types, the order of the constituent types is preserved in order that overload resolution
-        // for intersections of types with signatures can be deterministic.
-        function getIntersectionType(types, aliasSymbol, aliasTypeArguments) {
+        function getIntersectionType(types, aliasSymbol, aliasTypeArguments, aliasMapper) {
             var typeMembershipMap = new ts.Map();
             var includes = addTypesToIntersection(typeMembershipMap, 0, types);
             var typeSet = ts.arrayFrom(typeMembershipMap.values());
@@ -61043,16 +61038,16 @@ var ts;
                         // When the intersection creates a reduced set (which might mean that *all* union types have
                         // disappeared), we restart the operation to get a new set of combined flags. Once we have
                         // reduced we'll never reduce again, so this occurs at most once.
-                        result = getIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
+                        result = getIntersectionType(typeSet, aliasSymbol, aliasTypeArguments, aliasMapper);
                     }
                     else if (eachIsUnionContaining(typeSet, 32768 /* Undefined */)) {
                         var undefinedOrMissingType = exactOptionalPropertyTypes && ts.some(typeSet, function (t) { return containsType(t.types, missingType); }) ? missingType : undefinedType;
                         removeFromEach(typeSet, 32768 /* Undefined */);
-                        result = getUnionType([getIntersectionType(typeSet), undefinedOrMissingType], 1 /* Literal */, aliasSymbol, aliasTypeArguments);
+                        result = getUnionType([getIntersectionType(typeSet), undefinedOrMissingType], 1 /* Literal */, aliasSymbol, aliasTypeArguments, aliasMapper);
                     }
                     else if (eachIsUnionContaining(typeSet, 65536 /* Null */)) {
                         removeFromEach(typeSet, 65536 /* Null */);
-                        result = getUnionType([getIntersectionType(typeSet), nullType], 1 /* Literal */, aliasSymbol, aliasTypeArguments);
+                        result = getUnionType([getIntersectionType(typeSet), nullType], 1 /* Literal */, aliasSymbol, aliasTypeArguments, aliasMapper);
                     }
                     else {
                         // We are attempting to construct a type of the form X & (A | B) & (C | D). Transform this into a type of
@@ -61065,7 +61060,7 @@ var ts;
                         // We attach a denormalized origin type when at least one constituent of the cross-product union is an
                         // intersection (i.e. when the intersection didn't just reduce one or more unions to smaller unions).
                         var origin = ts.some(constituents, function (t) { return !!(t.flags & 2097152 /* Intersection */); }) ? createOriginUnionOrIntersectionType(2097152 /* Intersection */, typeSet) : undefined;
-                        result = getUnionType(constituents, 1 /* Literal */, aliasSymbol, aliasTypeArguments, origin);
+                        result = getUnionType(constituents, 1 /* Literal */, aliasSymbol, aliasTypeArguments, aliasMapper, origin);
                     }
                 }
                 else {
@@ -61111,7 +61106,7 @@ var ts;
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
                 var aliasSymbol = getAliasSymbolForTypeNode(node);
-                links.resolvedType = getIntersectionType(ts.map(node.types, getTypeFromTypeNode), aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol));
+                links.resolvedType = getIntersectionType(ts.map(node.types, getTypeFromTypeNode), aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol), /*aliasMapper*/ undefined);
             }
             return links.resolvedType;
         }
@@ -61230,7 +61225,7 @@ var ts;
             var indexKeyTypes = ts.map(getIndexInfosOfType(type), function (info) { return info !== enumNumberIndexInfo && isKeyTypeIncluded(info.keyType, include) ?
                 info.keyType === stringType && include & 8 /* Number */ ? stringOrNumberType : info.keyType : neverType; });
             return getUnionType(ts.concatenate(propertyTypes, indexKeyTypes), 1 /* Literal */, 
-            /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, origin);
+            /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, /*aliasMapper*/ undefined, origin);
         }
         /**
          * A union type which is reducible upon instantiation (meaning some members are removed under certain instantiations)
@@ -61263,7 +61258,7 @@ var ts;
                 return type;
             }
             var extractTypeAlias = getGlobalExtractSymbol();
-            return extractTypeAlias ? getTypeAliasInstantiation(extractTypeAlias, [type, stringType]) : stringType;
+            return extractTypeAlias ? getGlobalTypeAliasInstantiation(extractTypeAlias, [type, stringType]) : stringType;
         }
         function getIndexTypeOrString(type) {
             var indexType = getExtractStringType(getIndexType(type));
@@ -61393,13 +61388,14 @@ var ts;
             result.type = type;
             return result;
         }
-        function createIndexedAccessType(objectType, indexType, accessFlags, aliasSymbol, aliasTypeArguments) {
+        function createIndexedAccessType(objectType, indexType, accessFlags, aliasSymbol, aliasTypeArguments, aliasMapper) {
             var type = createType(8388608 /* IndexedAccess */);
             type.objectType = objectType;
             type.indexType = indexType;
             type.accessFlags = accessFlags;
             type.aliasSymbol = aliasSymbol;
             type.aliasTypeArguments = aliasTypeArguments;
+            type.aliasMapper = aliasMapper;
             return type;
         }
         /**
@@ -61717,7 +61713,7 @@ var ts;
             // If the object type is a mapped type { [P in K]: E }, where K is generic, instantiate E using a mapper
             // that substitutes the index type for P. For example, for an index access { [P in K]: Box<T[P]> }[X], we
             // construct the type Box<T[X]>.
-            if (isGenericMappedType(objectType)) {
+            if (isGenericMappedType(objectType) && !objectType.declaration.nameType) {
                 return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
             }
             return type[cache] = type;
@@ -61757,9 +61753,9 @@ var ts;
             var templateMapper = combineTypeMappers(objectType.mapper, mapper);
             return instantiateType(getTemplateTypeFromMappedType(objectType), templateMapper);
         }
-        function getIndexedAccessType(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) {
+        function getIndexedAccessType(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments, aliasMapper) {
             if (accessFlags === void 0) { accessFlags = 0 /* None */; }
-            return getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) || (accessNode ? errorType : unknownType);
+            return getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments, aliasMapper) || (accessNode ? errorType : unknownType);
         }
         function indexTypeLessThan(indexType, limit) {
             return everyType(indexType, function (t) {
@@ -61773,7 +61769,7 @@ var ts;
                 return false;
             });
         }
-        function getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) {
+        function getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments, aliasMapper) {
             if (accessFlags === void 0) { accessFlags = 0 /* None */; }
             if (objectType === wildcardType || indexType === wildcardType) {
                 return wildcardType;
@@ -61804,7 +61800,7 @@ var ts;
                 var id = objectType.id + "," + indexType.id + "," + persistentAccessFlags + getAliasId(aliasSymbol, aliasTypeArguments);
                 var type = indexedAccessTypes.get(id);
                 if (!type) {
-                    indexedAccessTypes.set(id, type = createIndexedAccessType(objectType, indexType, persistentAccessFlags, aliasSymbol, aliasTypeArguments));
+                    indexedAccessTypes.set(id, type = createIndexedAccessType(objectType, indexType, persistentAccessFlags, aliasSymbol, aliasTypeArguments, aliasMapper));
                 }
                 return type;
             }
@@ -61834,8 +61830,8 @@ var ts;
                     return undefined;
                 }
                 return accessFlags & 4 /* Writing */
-                    ? getIntersectionType(propTypes, aliasSymbol, aliasTypeArguments)
-                    : getUnionType(propTypes, 1 /* Literal */, aliasSymbol, aliasTypeArguments);
+                    ? getIntersectionType(propTypes, aliasSymbol, aliasTypeArguments, aliasMapper)
+                    : getUnionType(propTypes, 1 /* Literal */, aliasSymbol, aliasTypeArguments, aliasMapper);
             }
             return getPropertyTypeForIndexType(objectType, apparentObjectType, indexType, indexType, accessNode, accessFlags | 8 /* CacheSymbol */ | 64 /* ReportDeprecated */);
         }
@@ -61845,7 +61841,7 @@ var ts;
                 var objectType = getTypeFromTypeNode(node.objectType);
                 var indexType = getTypeFromTypeNode(node.indexType);
                 var potentialAlias = getAliasSymbolForTypeNode(node);
-                var resolved = getIndexedAccessType(objectType, indexType, 0 /* None */, node, potentialAlias, getTypeArgumentsForAliasSymbol(potentialAlias));
+                var resolved = getIndexedAccessType(objectType, indexType, 0 /* None */, node, potentialAlias, getTypeArgumentsForAliasSymbol(potentialAlias), /*aliasMapper*/ undefined);
                 links.resolvedType = resolved.flags & 8388608 /* IndexedAccess */ &&
                     resolved.objectType === objectType &&
                     resolved.indexType === indexType ?
@@ -62012,6 +62008,7 @@ var ts;
                 result.combinedMapper = combinedMapper;
                 result.aliasSymbol = aliasSymbol || root.aliasSymbol;
                 result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(root.aliasTypeArguments, mapper); // TODO: GH#18217
+                result.aliasMapper = result.aliasSymbol ? mapper : undefined;
                 return "break";
             };
             // We loop here for an immediately nested conditional type in the false position, effectively treating
@@ -62807,7 +62804,7 @@ var ts;
                 var result = target.instantiations.get(id);
                 if (!result) {
                     var newMapper = createTypeMapper(typeParameters, typeArguments);
-                    result = target.objectFlags & 4 /* Reference */ ? createDeferredTypeReference(type.target, type.node, newMapper, newAliasSymbol, newAliasTypeArguments) :
+                    result = target.objectFlags & 4 /* Reference */ ? createDeferredTypeReference(type.target, type.node, newMapper, newAliasSymbol, newAliasTypeArguments, mapper) :
                         target.objectFlags & 32 /* Mapped */ ? instantiateMappedType(target, newMapper, newAliasSymbol, newAliasTypeArguments) :
                             instantiateAnonymousType(target, newMapper, newAliasSymbol, newAliasTypeArguments);
                     target.instantiations.set(id, result);
@@ -62896,7 +62893,7 @@ var ts;
                             return instantiateAnonymousType(type, prependTypeMapping(typeVariable, t, mapper));
                         }
                         return t;
-                    }, aliasSymbol, aliasTypeArguments);
+                    }, aliasSymbol, aliasTypeArguments, mapper);
                 }
             }
             // If the constraint type of the instantiation is the wildcard type, return the wildcard type.
@@ -62965,6 +62962,7 @@ var ts;
             result.mapper = mapper;
             result.aliasSymbol = aliasSymbol || type.aliasSymbol;
             result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper);
+            result.aliasMapper = mapper;
             return result;
         }
         function getConditionalTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) {
@@ -62984,7 +62982,7 @@ var ts;
                     // distributive conditional type T extends U ? X : Y is instantiated with A | B for T, the
                     // result is (A extends U ? X : Y) | (B extends U ? X : Y).
                     result = distributionType && checkType_1 !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */) ?
-                        mapTypeWithAlias(getReducedType(distributionType), function (t) { return getConditionalType(root, prependTypeMapping(checkType_1, t, newMapper_1)); }, aliasSymbol, aliasTypeArguments) :
+                        mapTypeWithAlias(getReducedType(distributionType), function (t) { return getConditionalType(root, prependTypeMapping(checkType_1, t, newMapper_1)); }, aliasSymbol, aliasTypeArguments, mapper) :
                         getConditionalType(root, newMapper_1, aliasSymbol, aliasTypeArguments);
                     root.instantiations.set(id, result);
                 }
@@ -63044,8 +63042,8 @@ var ts;
                 var newAliasSymbol = aliasSymbol || type.aliasSymbol;
                 var newAliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper);
                 return flags & 2097152 /* Intersection */ || origin && origin.flags & 2097152 /* Intersection */ ?
-                    getIntersectionType(newTypes, newAliasSymbol, newAliasTypeArguments) :
-                    getUnionType(newTypes, 1 /* Literal */, newAliasSymbol, newAliasTypeArguments);
+                    getIntersectionType(newTypes, newAliasSymbol, newAliasTypeArguments, mapper) :
+                    getUnionType(newTypes, 1 /* Literal */, newAliasSymbol, newAliasTypeArguments, mapper);
             }
             if (flags & 4194304 /* Index */) {
                 return getIndexType(instantiateType(type.type, mapper));
@@ -63059,7 +63057,7 @@ var ts;
             if (flags & 8388608 /* IndexedAccess */) {
                 var newAliasSymbol = aliasSymbol || type.aliasSymbol;
                 var newAliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper);
-                return getIndexedAccessType(instantiateType(type.objectType, mapper), instantiateType(type.indexType, mapper), type.accessFlags, /*accessNode*/ undefined, newAliasSymbol, newAliasTypeArguments);
+                return getIndexedAccessType(instantiateType(type.objectType, mapper), instantiateType(type.indexType, mapper), type.accessFlags, /*accessNode*/ undefined, newAliasSymbol, newAliasTypeArguments, mapper);
             }
             if (flags & 16777216 /* Conditional */) {
                 return getConditionalTypeInstantiation(type, combineTypeMappers(type.mapper, mapper), aliasSymbol, aliasTypeArguments);
@@ -63790,7 +63788,7 @@ var ts;
                 var targetReturnType = isResolvingReturnTypeOfSignature(target) ? anyType
                     : target.declaration && isJSConstructor(target.declaration) ? getDeclaredTypeOfClassOrInterface(getMergedSymbol(target.declaration.symbol))
                         : getReturnTypeOfSignature(target);
-                if (targetReturnType === voidType) {
+                if (targetReturnType === voidType || targetReturnType === anyType) {
                     return result;
                 }
                 var sourceReturnType = isResolvingReturnTypeOfSignature(source) ? anyType
@@ -65053,7 +65051,10 @@ var ts;
                     if (variances === ts.emptyArray) {
                         return 1 /* Unknown */;
                     }
-                    var varianceResult = relateVariances(source.aliasTypeArguments, target.aliasTypeArguments, variances, intersectionState);
+                    var outerTypeParameters = getOuterTypeParametersOfAlias(source.aliasSymbol);
+                    var sourceArgs = outerTypeParameters && source.aliasMapper ? ts.concatenate(source.aliasTypeArguments, instantiateTypes(outerTypeParameters, source.aliasMapper)) : source.aliasTypeArguments;
+                    var targetArgs = outerTypeParameters && target.aliasMapper ? ts.concatenate(target.aliasTypeArguments, instantiateTypes(outerTypeParameters, target.aliasMapper)) : target.aliasTypeArguments;
+                    var varianceResult = relateVariances(sourceArgs, targetArgs, variances, intersectionState);
                     if (varianceResult !== undefined) {
                         return varianceResult;
                     }
@@ -66342,8 +66343,11 @@ var ts;
         }
         function getAliasVariances(symbol) {
             var links = getSymbolLinks(symbol);
-            return getVariancesWorker(links.typeParameters, links, function (_links, param, marker) {
-                var type = getTypeAliasInstantiation(symbol, instantiateTypes(links.typeParameters, makeUnaryTypeMapper(param, marker)));
+            // outer type parameter aliases are last so they can be easily ignored by, eg, inference
+            var params = ts.concatenate(links.typeParameters, getOuterTypeParametersOfAlias(symbol));
+            return getVariancesWorker(params, links, function (_links, param, marker) {
+                var mapper = makeUnaryTypeMapper(param, marker);
+                var type = getLocalTypeAliasInstantiation(symbol, instantiateTypes(links.typeParameters, mapper), mapper);
                 type.aliasTypeArgumentsContainsMarker = true;
                 return type;
             });
@@ -67000,7 +67004,7 @@ var ts;
             }
             // If the NonNullable<T> type is available, return an instantiation. Otherwise just return the reduced type.
             return deferredGlobalNonNullableTypeAlias !== unknownSymbol ?
-                getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [reducedType]) :
+                getGlobalTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [reducedType]) :
                 reducedType;
         }
         function getNonNullableType(type) {
@@ -69226,7 +69230,7 @@ var ts;
                         newOrigin = createOriginUnionOrIntersectionType(1048576 /* Union */, originFiltered);
                     }
                 }
-                return getUnionTypeFromSortedList(filtered, type.objectFlags, /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, newOrigin);
+                return getUnionTypeFromSortedList(filtered, type.objectFlags, /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, /*aliasMapper*/ undefined, newOrigin);
             }
             return type.flags & 131072 /* Never */ || f(type) ? type : neverType;
         }
@@ -69262,9 +69266,9 @@ var ts;
             }
             return changed ? mappedTypes && getUnionType(mappedTypes, noReductions ? 0 /* None */ : 1 /* Literal */) : type;
         }
-        function mapTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) {
+        function mapTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments, aliasMapper) {
             return type.flags & 1048576 /* Union */ && aliasSymbol ?
-                getUnionType(ts.map(type.types, mapper), 1 /* Literal */, aliasSymbol, aliasTypeArguments) :
+                getUnionType(ts.map(type.types, mapper), 1 /* Literal */, aliasSymbol, aliasTypeArguments, aliasMapper) :
                 mapType(type, mapper);
         }
         function extractTypesOfKind(type, kind) {
@@ -72079,7 +72083,7 @@ var ts;
         function getTypeOfPropertyOfContextualType(type, name, nameType) {
             return mapType(type, function (t) {
                 var _a;
-                if (isGenericMappedType(t)) {
+                if (isGenericMappedType(t) && !t.declaration.nameType) {
                     var constraint = getConstraintTypeFromMappedType(t);
                     var constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
                     var propertyNameType = nameType || getStringLiteralType(ts.unescapeLeadingUnderscores(name));
@@ -72449,7 +72453,7 @@ var ts;
                     var params = getSymbolLinks(managedSym).typeParameters;
                     if (ts.length(params) >= 2) {
                         var args = fillMissingTypeArguments([ctorType, attributesType], params, 2, ts.isInJSFile(context));
-                        return getTypeAliasInstantiation(managedSym, args);
+                        return getGlobalTypeAliasInstantiation(managedSym, args);
                     }
                 }
                 if (ts.length(declaredManagedType.typeParameters) >= 2) {
@@ -77007,7 +77011,11 @@ var ts;
             if (signatureHasRestParameter(signature)) {
                 // parameter might be a transient symbol generated by use of `arguments` in the function body.
                 var parameter = ts.last(signature.parameters);
-                if (ts.isTransientSymbol(parameter) || !ts.getEffectiveTypeAnnotationNode(parameter.valueDeclaration)) {
+                if (parameter.valueDeclaration
+                    ? !ts.getEffectiveTypeAnnotationNode(parameter.valueDeclaration)
+                    // a declarationless parameter may still have a `.type` already set by its construction logic
+                    // (which may pull a type from a jsdoc) - only allow fixing on `DeferredType` parameters with a fallback type
+                    : !!(ts.getCheckFlags(parameter) & 65536 /* DeferredType */)) {
                     var contextualParameterType = getRestTypeAtPosition(context, len);
                     assignParameterType(parameter, contextualParameterType);
                 }
@@ -77026,8 +77034,8 @@ var ts;
             var links = getSymbolLinks(parameter);
             if (!links.type) {
                 var declaration = parameter.valueDeclaration;
-                links.type = type || getWidenedTypeForVariableLikeDeclaration(declaration, /*reportErrors*/ true);
-                if (declaration.name.kind !== 79 /* Identifier */) {
+                links.type = type || (declaration ? getWidenedTypeForVariableLikeDeclaration(declaration, /*reportErrors*/ true) : getTypeOfSymbol(parameter));
+                if (declaration && declaration.name.kind !== 79 /* Identifier */) {
                     // if inference didn't come up with anything but unknown, fall back to the binding pattern if present.
                     if (links.type === unknownType) {
                         links.type = getTypeFromBindingPattern(declaration.name);
@@ -80589,7 +80597,7 @@ var ts;
                     if (awaitedSymbol) {
                         // Unwrap unions that may contain `Awaited<T>`, otherwise its possible to manufacture an `Awaited<Awaited<T> | U>` where
                         // an `Awaited<T | U>` would suffice.
-                        return getTypeAliasInstantiation(awaitedSymbol, [unwrapAwaitedType(type)]);
+                        return getGlobalTypeAliasInstantiation(awaitedSymbol, [unwrapAwaitedType(type)]);
                     }
                 }
             }
@@ -127640,20 +127648,6 @@ 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.
@@ -136668,29 +136662,6 @@ 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;
@@ -138323,9 +138294,7 @@ var ts;
 (function (ts) {
     var GoToDefinition;
     (function (GoToDefinition) {
-        function getDefinitionAtPosition(program, sourceFile, position, aliasesOnly) {
-            var _a;
-            var _b;
+        function getDefinitionAtPosition(program, sourceFile, position) {
             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) {
@@ -138348,50 +138317,17 @@ var ts;
             }
             if (ts.isStaticModifier(node) && ts.isClassStaticBlockDeclaration(node.parent)) {
                 var classDecl = node.parent.parent;
-                var _c = getSymbol(classDecl, typeChecker), symbol_1 = _c.symbol, isAliasTarget_1 = _c.isAliasTarget, failedAliasResolution_1 = _c.failedAliasResolution;
-                if (aliasesOnly && !isAliasTarget_1)
-                    return undefined;
+                var symbol_1 = getSymbol(classDecl, typeChecker);
                 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, isAliasTarget_1, failedAliasResolution_1, { start: pos, length: "static".length });
+                    return createDefinitionInfoFromName(typeChecker, staticBlock, "constructor" /* constructorImplementationElement */, "static {}", containerName_1, { start: pos, length: "static".length });
                 });
             }
-            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;
+            var symbol = getSymbol(node, typeChecker);
             // 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) {
@@ -138400,14 +138336,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, isAliasTarget, failedAliasResolution);
+                var sigInfo = createDefinitionFromSignatureDeclaration(typeChecker, calledDeclaration);
                 // 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, isAliasTarget, failedAliasResolution, calledDeclaration) || ts.emptyArray;
+                    var defs = getDefinitionFromSymbol(typeChecker, symbol, node, 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);
                 }
@@ -138419,7 +138355,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, isAliasTarget, failedAliasResolution); }) : 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); }) : 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
@@ -138442,7 +138378,7 @@ var ts;
                     return prop && getDefinitionFromSymbol(typeChecker, prop, node);
                 });
             }
-            return ts.concatenate(fileReferenceDefinition, getDefinitionFromObjectLiteralElement(typeChecker, node) || getDefinitionFromSymbol(typeChecker, symbol, node, isAliasTarget, failedAliasResolution));
+            return ts.concatenate(fileReferenceDefinition, getDefinitionFromObjectLiteralElement(typeChecker, node) || getDefinitionFromSymbol(typeChecker, symbol, node));
         }
         GoToDefinition.getDefinitionAtPosition = getDefinitionAtPosition;
         /**
@@ -138540,24 +138476,24 @@ var ts;
                 return undefined;
             }
             if (ts.isImportMeta(node.parent) && node.parent.name === node) {
-                return definitionFromType(typeChecker.getTypeAtLocation(node.parent), typeChecker, node.parent, /*isAliasTarget*/ false, /*failedAliasResolution*/ false);
+                return definitionFromType(typeChecker.getTypeAtLocation(node.parent), typeChecker, node.parent);
             }
-            var _a = getSymbol(node, typeChecker), symbol = _a.symbol, isAliasTarget = _a.isAliasTarget, failedAliasResolution = _a.failedAliasResolution;
+            var symbol = getSymbol(node, typeChecker);
             if (!symbol)
                 return undefined;
             var typeAtLocation = typeChecker.getTypeOfSymbolAtLocation(symbol, node);
             var returnType = tryGetReturnTypeOfFunction(symbol, typeAtLocation, typeChecker);
-            var fromReturnType = returnType && definitionFromType(returnType, typeChecker, node, isAliasTarget, failedAliasResolution);
+            var fromReturnType = returnType && definitionFromType(returnType, typeChecker, node);
             // 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, isAliasTarget, failedAliasResolution);
+            var typeDefinitions = fromReturnType && fromReturnType.length !== 0 ? fromReturnType : definitionFromType(typeAtLocation, typeChecker, node);
             return typeDefinitions.length ? typeDefinitions
-                : !(symbol.flags & 111551 /* Value */) && symbol.flags & 788968 /* Type */ ? getDefinitionFromSymbol(typeChecker, ts.skipAlias(symbol, typeChecker), node, isAliasTarget, failedAliasResolution)
+                : !(symbol.flags & 111551 /* Value */) && symbol.flags & 788968 /* Type */ ? getDefinitionFromSymbol(typeChecker, ts.skipAlias(symbol, typeChecker), node)
                     : undefined;
         }
         GoToDefinition.getTypeDefinitionAtPosition = getTypeDefinitionAtPosition;
-        function definitionFromType(type, checker, node, isAliasTarget, failedAliasResolution) {
+        function definitionFromType(type, checker, node) {
             return ts.flatMap(type.isUnion() && !(type.flags & 32 /* Enum */) ? type.types : [type], function (t) {
-                return t.symbol && getDefinitionFromSymbol(checker, t.symbol, node, isAliasTarget, failedAliasResolution);
+                return t.symbol && getDefinitionFromSymbol(checker, t.symbol, node);
             });
         }
         function tryGetReturnTypeOfFunction(symbol, type, checker) {
@@ -138572,8 +138508,8 @@ var ts;
             }
             return undefined;
         }
-        function getDefinitionAndBoundSpan(program, sourceFile, position, aliasesOnly) {
-            var definitions = getDefinitionAtPosition(program, sourceFile, position, aliasesOnly);
+        function getDefinitionAndBoundSpan(program, sourceFile, position) {
+            var definitions = getDefinitionAtPosition(program, sourceFile, position);
             if (!definitions || definitions.length === 0) {
                 return undefined;
             }
@@ -138599,17 +138535,13 @@ 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 { symbol: aliased, isAliasTarget: true };
-                }
-                else {
-                    failedAliasResolution = true;
+                    return aliased;
                 }
             }
-            return { symbol: symbol, isAliasTarget: !!(symbol && ts.isExternalModuleSymbol(symbol)), failedAliasResolution: failedAliasResolution };
+            return symbol;
         }
         // Go to the original declaration for cases:
         //
@@ -138623,45 +138555,26 @@ var ts;
             if (node.parent === declaration) {
                 return true;
             }
-            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))
+            switch (declaration.kind) {
+                case 266 /* ImportClause */:
+                case 264 /* ImportEqualsDeclaration */:
                     return true;
-                if (!ts.isAssignmentDeclaration(p))
-                    return "quit";
-                return false;
-            });
-            return !!containingAssignment && ts.getAssignmentDeclarationKind(containingAssignment) === 5 /* Property */;
+                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;
+            }
         }
-        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 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 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
@@ -138685,27 +138598,26 @@ 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, isAliasTarget, failedAliasResolution)]
+                        : [createDefinitionInfo(ts.last(declarations), typeChecker, symbol, node)]
                     : undefined;
             }
         }
         /** Creates a DefinitionInfo from a Declaration, using the declaration's name if possible. */
-        function createDefinitionInfo(declaration, checker, symbol, node, isAliasTarget, failedAliasResolution) {
+        function createDefinitionInfo(declaration, checker, symbol, node) {
             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, isAliasTarget, failedAliasResolution);
+            return createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName, containerName);
         }
-        GoToDefinition.createDefinitionInfo = createDefinitionInfo;
         /** Creates a DefinitionInfo directly from the name of a declaration. */
-        function createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName, containerName, isAliasTarget, failedAliasResolution, textSpan) {
+        function createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName, containerName, 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), isAmbient: !!(declaration.flags & 8388608 /* Ambient */), isAliasTarget: isAliasTarget, failedAliasResolution: failedAliasResolution });
+                containerName: containerName }, ts.FindAllReferences.toContextSpan(textSpan, sourceFile, ts.FindAllReferences.getContextNode(declaration))), { isLocal: !isDefinitionVisible(checker, declaration) });
         }
         function isDefinitionVisible(checker, declaration) {
             if (checker.isDeclarationVisible(declaration))
@@ -138738,8 +138650,8 @@ var ts;
                     return false;
             }
         }
-        function createDefinitionFromSignatureDeclaration(typeChecker, decl, isAliasTarget, failedAliasResolution) {
-            return createDefinitionInfo(decl, typeChecker, decl.symbol, decl, isAliasTarget, failedAliasResolution);
+        function createDefinitionFromSignatureDeclaration(typeChecker, decl) {
+            return createDefinitionInfo(decl, typeChecker, decl.symbol, decl);
         }
         function findReferenceInPosition(refs, pos) {
             return ts.find(refs, function (ref) { return ts.textRangeContainsPositionInclusive(ref, pos); });
@@ -138754,7 +138666,6 @@ var ts;
                 containerName: undefined,
                 containerKind: undefined,
                 unverified: unverified,
-                isAliasTarget: true,
             };
         }
         /** Returns a CallLikeExpression where `node` is the target being invoked. */
@@ -141808,6 +141719,41 @@ 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() ||
@@ -143101,7 +143047,7 @@ var ts;
                     if (!typeDisplayString) {
                         continue;
                     }
-                    addTypeHints(typeDisplayString, param.name.end);
+                    addTypeHints(typeDisplayString, param.questionToken ? param.questionToken.end : param.name.end);
                 }
             }
             function getParameterDeclarationTypeDisplayString(symbol) {
@@ -151753,10 +151699,9 @@ 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 = (_b = ts.tryGetModuleSpecifierFromDeclaration(declaration)) === null || _b === void 0 ? void 0 : _b.text;
+                var moduleSpecifier = ts.tryGetModuleSpecifierFromDeclaration(declaration);
                 if (namespacePrefix && moduleSpecifier) {
                     var moduleSymbol = getTargetModuleFromNamespaceLikeImport(declaration, checker);
                     if (moduleSymbol && moduleSymbol.exports.has(ts.escapeLeadingUnderscores(symbolName))) {
@@ -151932,9 +151877,8 @@ 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 = (_b = ts.tryGetModuleSpecifierFromDeclaration(declaration)) === null || _b === void 0 ? void 0 : _b.text;
+            var moduleSpecifier = ts.tryGetModuleSpecifierFromDeclaration(declaration);
             if (moduleSpecifier) {
                 var addAsTypeOnly = useRequire
                     ? 4 /* NotAllowed */
@@ -163743,9 +163687,9 @@ var ts;
             synchronizeHostData();
             return ts.GoToDefinition.getDefinitionAtPosition(program, getValidSourceFile(fileName), position);
         }
-        function getDefinitionAndBoundSpan(fileName, position, aliasesOnly) {
+        function getDefinitionAndBoundSpan(fileName, position) {
             synchronizeHostData();
-            return ts.GoToDefinition.getDefinitionAndBoundSpan(program, getValidSourceFile(fileName), position, aliasesOnly);
+            return ts.GoToDefinition.getDefinitionAndBoundSpan(program, getValidSourceFile(fileName), position);
         }
         function getTypeDefinitionAtPosition(fileName, position) {
             synchronizeHostData();