@typescript-deploys/pr-build 4.6.0-pr-47550-8 → 4.6.0-pr-47607-13

package/lib/tsserver.js

@@ -100,7 +100,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-insiders.20220124";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220127";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -4918,13 +4918,14 @@ var ts;
         // Flags that require TypeFlags.Object
         ObjectFlags[ObjectFlags["ContainsSpread"] = 4194304] = "ContainsSpread";
         ObjectFlags[ObjectFlags["ObjectRestType"] = 8388608] = "ObjectRestType";
+        ObjectFlags[ObjectFlags["InstantiationExpressionType"] = 16777216] = "InstantiationExpressionType";
         /* @internal */
-        ObjectFlags[ObjectFlags["IsClassInstanceClone"] = 16777216] = "IsClassInstanceClone";
+        ObjectFlags[ObjectFlags["IsClassInstanceClone"] = 33554432] = "IsClassInstanceClone";
         // Flags that require TypeFlags.Object and ObjectFlags.Reference
         /* @internal */
-        ObjectFlags[ObjectFlags["IdenticalBaseTypeCalculated"] = 33554432] = "IdenticalBaseTypeCalculated";
+        ObjectFlags[ObjectFlags["IdenticalBaseTypeCalculated"] = 67108864] = "IdenticalBaseTypeCalculated";
         /* @internal */
-        ObjectFlags[ObjectFlags["IdenticalBaseTypeExists"] = 67108864] = "IdenticalBaseTypeExists";
+        ObjectFlags[ObjectFlags["IdenticalBaseTypeExists"] = 134217728] = "IdenticalBaseTypeExists";
         // Flags that require TypeFlags.UnionOrIntersection or TypeFlags.Substitution
         /* @internal */
         ObjectFlags[ObjectFlags["IsGenericTypeComputed"] = 4194304] = "IsGenericTypeComputed";
@@ -8530,6 +8531,7 @@ var ts;
         Cannot_assign_to_0_because_it_is_an_import: diag(2632, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_an_import_2632", "Cannot assign to '{0}' because it is an import."),
         JSX_property_access_expressions_cannot_include_JSX_namespace_names: diag(2633, ts.DiagnosticCategory.Error, "JSX_property_access_expressions_cannot_include_JSX_namespace_names_2633", "JSX property access expressions cannot include JSX namespace names"),
         _0_index_signatures_are_incompatible: diag(2634, ts.DiagnosticCategory.Error, "_0_index_signatures_are_incompatible_2634", "'{0}' index signatures are incompatible."),
+        Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable: diag(2635, ts.DiagnosticCategory.Error, "Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable_2635", "Type '{0}' has no signatures for which the type argument list is applicable."),
         Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity: diag(2649, ts.DiagnosticCategory.Error, "Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity_2649", "Cannot augment module '{0}' with value exports because it resolves to a non-module entity."),
         A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums: diag(2651, ts.DiagnosticCategory.Error, "A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_memb_2651", "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums."),
         Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead: diag(2652, ts.DiagnosticCategory.Error, "Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_d_2652", "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead."),
@@ -9473,6 +9475,8 @@ var ts;
         Remove_unused_declarations_for_Colon_0: diag(90041, ts.DiagnosticCategory.Message, "Remove_unused_declarations_for_Colon_0_90041", "Remove unused declarations for: '{0}'"),
         Declare_a_private_field_named_0: diag(90053, ts.DiagnosticCategory.Message, "Declare_a_private_field_named_0_90053", "Declare a private field named '{0}'."),
         Includes_imports_of_types_referenced_by_0: diag(90054, ts.DiagnosticCategory.Message, "Includes_imports_of_types_referenced_by_0_90054", "Includes imports of types referenced by '{0}'"),
+        Remove_type_from_import_declaration_from_0: diag(90055, ts.DiagnosticCategory.Message, "Remove_type_from_import_declaration_from_0_90055", "Remove 'type' from import declaration from \"{0}\""),
+        Remove_type_from_import_of_0_from_1: diag(90056, ts.DiagnosticCategory.Message, "Remove_type_from_import_of_0_from_1_90056", "Remove 'type' from import of '{0}' from \"{1}\""),
         Convert_function_to_an_ES2015_class: diag(95001, ts.DiagnosticCategory.Message, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"),
         Convert_0_to_1_in_0: diag(95003, ts.DiagnosticCategory.Message, "Convert_0_to_1_in_0_95003", "Convert '{0}' to '{1} in {0}'"),
         Extract_to_0_in_1: diag(95004, ts.DiagnosticCategory.Message, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"),
@@ -13413,6 +13417,7 @@ var ts;
             case 110 /* TrueKeyword */:
             case 106 /* SuperKeyword */:
             case 229 /* NonNullExpression */:
+            case 227 /* ExpressionWithTypeArguments */:
             case 230 /* MetaProperty */:
             case 100 /* ImportKeyword */: // technically this is only an Expression if it's in a CallExpression
                 return true;
@@ -14063,10 +14068,13 @@ var ts;
     function packageIdIsEqual(a, b) {
         return a === b || !!a && !!b && a.name === b.name && a.subModuleName === b.subModuleName && a.version === b.version;
     }
-    function packageIdToString(_a) {
-        var name = _a.name, subModuleName = _a.subModuleName, version = _a.version;
-        var fullName = subModuleName ? name + "/" + subModuleName : name;
-        return fullName + "@" + version;
+    function packageIdToPackageName(_a) {
+        var name = _a.name, subModuleName = _a.subModuleName;
+        return subModuleName ? name + "/" + subModuleName : name;
+    }
+    ts.packageIdToPackageName = packageIdToPackageName;
+    function packageIdToString(packageId) {
+        return packageIdToPackageName(packageId) + "@" + packageId.version;
     }
     ts.packageIdToString = packageIdToString;
     function typeDirectiveIsEqualTo(oldResolution, newResolution) {
@@ -14899,6 +14907,15 @@ var ts;
         };
     }
     ts.createDiagnosticForFileFromMessageChain = createDiagnosticForFileFromMessageChain;
+    function createDiagnosticMessageChainFromDiagnostic(diagnostic) {
+        return typeof diagnostic.messageText === "string" ? {
+            code: diagnostic.code,
+            category: diagnostic.category,
+            messageText: diagnostic.messageText,
+            next: diagnostic.next,
+        } : diagnostic.messageText;
+    }
+    ts.createDiagnosticMessageChainFromDiagnostic = createDiagnosticMessageChainFromDiagnostic;
     function createDiagnosticForRange(sourceFile, range, message) {
         return {
             file: sourceFile,
@@ -15067,7 +15084,8 @@ var ts;
             node.kind === 212 /* FunctionExpression */ ||
             node.kind === 213 /* ArrowFunction */ ||
             node.kind === 211 /* ParenthesizedExpression */ ||
-            node.kind === 253 /* VariableDeclaration */) ?
+            node.kind === 253 /* VariableDeclaration */ ||
+            node.kind === 274 /* ExportSpecifier */) ?
             ts.concatenate(ts.getTrailingCommentRanges(text, node.pos), ts.getLeadingCommentRanges(text, node.pos)) :
             ts.getLeadingCommentRanges(text, node.pos);
         // True if the comment starts with '/**' but not if it is '/**/'
@@ -15101,7 +15119,7 @@ var ts;
             case 114 /* VoidKeyword */:
                 return node.parent.kind !== 216 /* VoidExpression */;
             case 227 /* ExpressionWithTypeArguments */:
-                return !isExpressionWithTypeArgumentsInClassExtendsClause(node);
+                return ts.isHeritageClause(node.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(node);
             case 162 /* TypeParameter */:
                 return node.parent.kind === 194 /* MappedType */ || node.parent.kind === 189 /* InferType */;
             // Identifiers and qualified names may be type nodes, depending on their context. Climb
@@ -15138,7 +15156,7 @@ var ts;
                 }
                 switch (parent.kind) {
                     case 227 /* ExpressionWithTypeArguments */:
-                        return !isExpressionWithTypeArgumentsInClassExtendsClause(parent);
+                        return ts.isHeritageClause(parent.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(parent);
                     case 162 /* TypeParameter */:
                         return node === parent.constraint;
                     case 342 /* JSDocTemplateTag */:
@@ -15841,7 +15859,7 @@ var ts;
             case 296 /* SpreadAssignment */:
                 return true;
             case 227 /* ExpressionWithTypeArguments */:
-                return parent.expression === node && isExpressionWithTypeArgumentsInClassExtendsClause(parent);
+                return parent.expression === node && !isPartOfTypeNode(parent);
             case 295 /* ShorthandPropertyAssignment */:
                 return parent.objectAssignmentInitializer === node;
             default:
@@ -22775,16 +22793,18 @@ var ts;
             return updateConstructorTypeNode1(node, node.modifiers, typeParameters, parameters, type);
         }
         // @api
-        function createTypeQueryNode(exprName) {
+        function createTypeQueryNode(exprName, typeArguments) {
             var node = createBaseNode(180 /* TypeQuery */);
             node.exprName = exprName;
+            node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(typeArguments);
             node.transformFlags = 1 /* ContainsTypeScript */;
             return node;
         }
         // @api
-        function updateTypeQueryNode(node, exprName) {
+        function updateTypeQueryNode(node, exprName, typeArguments) {
             return node.exprName !== exprName
-                ? update(createTypeQueryNode(exprName), node)
+                || node.typeArguments !== typeArguments
+                ? update(createTypeQueryNode(exprName, typeArguments), node)
                 : node;
         }
         // @api
@@ -29900,7 +29920,8 @@ var ts;
                     visitNode(cbNode, node.parameterName) ||
                     visitNode(cbNode, node.type);
             case 180 /* TypeQuery */:
-                return visitNode(cbNode, node.exprName);
+                return visitNode(cbNode, node.exprName) ||
+                    visitNodes(cbNode, cbNodes, node.typeArguments);
             case 181 /* TypeLiteral */:
                 return visitNodes(cbNode, cbNodes, node.members);
             case 182 /* ArrayType */:
@@ -32433,7 +32454,9 @@ var ts;
         function parseTypeQuery() {
             var pos = getNodePos();
             parseExpected(112 /* TypeOfKeyword */);
-            return finishNode(factory.createTypeQueryNode(parseEntityName(/*allowReservedWords*/ true)), pos);
+            var entityName = parseEntityName(/*allowReservedWords*/ true);
+            var typeArguments = tryParseTypeArguments();
+            return finishNode(factory.createTypeQueryNode(entityName, typeArguments), pos);
         }
         function parseTypeParameter() {
             var pos = getNodePos();
@@ -33372,7 +33395,7 @@ var ts;
         function parseInitializer() {
             return parseOptional(63 /* EqualsToken */) ? parseAssignmentExpressionOrHigher() : undefined;
         }
-        function parseAssignmentExpressionOrHigher(parsingConditionalExpression) {
+        function parseAssignmentExpressionOrHigher() {
             //  AssignmentExpression[in,yield]:
             //      1) ConditionalExpression[?in,?yield]
             //      2) LeftHandSideExpression = AssignmentExpression[?in,?yield]
@@ -33398,7 +33421,7 @@ var ts;
             // If we do successfully parse arrow-function, we must *not* recurse for productions 1, 2 or 3. An ArrowFunction is
             // not a LeftHandSideExpression, nor does it start a ConditionalExpression.  So we are done
             // with AssignmentExpression if we see one.
-            var arrowExpression = tryParseParenthesizedArrowFunctionExpression(parsingConditionalExpression) || tryParseAsyncSimpleArrowFunctionExpression();
+            var arrowExpression = tryParseParenthesizedArrowFunctionExpression() || tryParseAsyncSimpleArrowFunctionExpression();
             if (arrowExpression) {
                 return arrowExpression;
             }
@@ -33417,7 +33440,7 @@ var ts;
             // parameter ('x => ...') above. We handle it here by checking if the parsed expression was a single
             // identifier and the current token is an arrow.
             if (expr.kind === 79 /* Identifier */ && token() === 38 /* EqualsGreaterThanToken */) {
-                return parseSimpleArrowFunctionExpression(pos, expr, /*asyncModifier*/ undefined, parsingConditionalExpression);
+                return parseSimpleArrowFunctionExpression(pos, expr, /*asyncModifier*/ undefined);
             }
             // Now see if we might be in cases '2' or '3'.
             // If the expression was a LHS expression, and we have an assignment operator, then
@@ -33477,7 +33500,7 @@ var ts;
                 return finishNode(factory.createYieldExpression(/*asteriskToken*/ undefined, /*expression*/ undefined), pos);
             }
         }
-        function parseSimpleArrowFunctionExpression(pos, identifier, asyncModifier, parsingConditionalExpression) {
+        function parseSimpleArrowFunctionExpression(pos, identifier, asyncModifier) {
             ts.Debug.assert(token() === 38 /* EqualsGreaterThanToken */, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
             var parameter = factory.createParameterDeclaration(
             /*decorators*/ undefined, 
@@ -33489,11 +33512,11 @@ var ts;
             finishNode(parameter, identifier.pos);
             var parameters = createNodeArray([parameter], parameter.pos, parameter.end);
             var equalsGreaterThanToken = parseExpectedToken(38 /* EqualsGreaterThanToken */);
-            var body = parseArrowFunctionExpressionBody(/*isAsync*/ !!asyncModifier, parsingConditionalExpression);
+            var body = parseArrowFunctionExpressionBody(/*isAsync*/ !!asyncModifier);
             var node = factory.createArrowFunction(asyncModifier, /*typeParameters*/ undefined, parameters, /*type*/ undefined, equalsGreaterThanToken, body);
             return addJSDocComment(finishNode(node, pos));
         }
-        function tryParseParenthesizedArrowFunctionExpression(parsingConditionalExpression) {
+        function tryParseParenthesizedArrowFunctionExpression() {
             var triState = isParenthesizedArrowFunctionExpression();
             if (triState === 0 /* False */) {
                 // It's definitely not a parenthesized arrow function expression.
@@ -33504,8 +33527,8 @@ var ts;
             // it out, but don't allow any ambiguity, and return 'undefined' if this could be an
             // expression instead.
             return triState === 1 /* True */ ?
-                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, parsingConditionalExpression) :
-                tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(parsingConditionalExpression); });
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true) :
+                tryParse(parsePossibleParenthesizedArrowFunctionExpression);
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
         //  False       -> There *cannot* be a parenthesized arrow function here.
@@ -33635,25 +33658,25 @@ var ts;
                 return 2 /* Unknown */;
             }
         }
-        function parsePossibleParenthesizedArrowFunctionExpression(parsingConditionalExpression) {
+        function parsePossibleParenthesizedArrowFunctionExpression() {
             var tokenPos = scanner.getTokenPos();
             if (notParenthesizedArrow === null || notParenthesizedArrow === void 0 ? void 0 : notParenthesizedArrow.has(tokenPos)) {
                 return undefined;
             }
-            var result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false, parsingConditionalExpression);
+            var result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false);
             if (!result) {
                 (notParenthesizedArrow || (notParenthesizedArrow = new ts.Set())).add(tokenPos);
             }
             return result;
         }
-        function tryParseAsyncSimpleArrowFunctionExpression(parsingConditionalExpression) {
+        function tryParseAsyncSimpleArrowFunctionExpression() {
             // We do a check here so that we won't be doing unnecessarily call to "lookAhead"
             if (token() === 131 /* AsyncKeyword */) {
                 if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === 1 /* True */) {
                     var pos = getNodePos();
                     var asyncModifier = parseModifiersForArrowFunction();
                     var expr = parseBinaryExpressionOrHigher(0 /* Lowest */);
-                    return parseSimpleArrowFunctionExpression(pos, expr, asyncModifier, parsingConditionalExpression);
+                    return parseSimpleArrowFunctionExpression(pos, expr, asyncModifier);
                 }
             }
             return undefined;
@@ -33677,7 +33700,7 @@ var ts;
             }
             return 0 /* False */;
         }
-        function parseParenthesizedArrowFunctionExpression(allowAmbiguity, parsingConditionalExpression) {
+        function parseParenthesizedArrowFunctionExpression(allowAmbiguity) {
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             var modifiers = parseModifiersForArrowFunction();
@@ -33703,20 +33726,6 @@ var ts;
                     return undefined;
                 }
             }
-            // Given:
-            //     x ? y => ({ y }) : z => ({ z })
-            // We try to parse the body of the first arrow function by looking at:
-            //     ({ y }) : z => ({ z })
-            // This is a valid arrow function with "z" as the return type.
-            //
-            // But, if we're in the true side of a conditional expression, this colon
-            // terminates the true side, so cannot be the return type. If we are in the
-            // false side, we may still be within the true side of a parent conditional
-            // expression, so don't allow it to be a return type either.
-            if (parsingConditionalExpression && token() === 58 /* ColonToken */) {
-                ts.Debug.assert(!allowAmbiguity);
-                return undefined;
-            }
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -33750,7 +33759,7 @@ var ts;
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
-        function parseArrowFunctionExpressionBody(isAsync, parsingConditionalExpression) {
+        function parseArrowFunctionExpressionBody(isAsync) {
             if (token() === 18 /* OpenBraceToken */) {
                 return parseFunctionBlock(isAsync ? 2 /* Await */ : 0 /* None */);
             }
@@ -33778,8 +33787,8 @@ var ts;
             var savedTopLevel = topLevel;
             topLevel = false;
             var node = isAsync
-                ? doInAwaitContext(function () { return parseAssignmentExpressionOrHigher(parsingConditionalExpression); })
-                : doOutsideOfAwaitContext(function () { return parseAssignmentExpressionOrHigher(parsingConditionalExpression); });
+                ? doInAwaitContext(parseAssignmentExpressionOrHigher)
+                : doOutsideOfAwaitContext(parseAssignmentExpressionOrHigher);
             topLevel = savedTopLevel;
             return node;
         }
@@ -33792,8 +33801,8 @@ var ts;
             // Note: we explicitly 'allowIn' in the whenTrue part of the condition expression, and
             // we do not that for the 'whenFalse' part.
             var colonToken;
-            return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, function () { return parseAssignmentExpressionOrHigher(/*parsingConditionalExpression*/ true); }), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
-                ? parseAssignmentExpressionOrHigher(/*parsingConditionalExpression*/ true)
+            return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
+                ? parseAssignmentExpressionOrHigher()
                 : createMissingNode(79 /* Identifier */, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, ts.tokenToString(58 /* ColonToken */))), pos);
         }
         function parseBinaryExpressionOrHigher(precedence) {
@@ -34564,12 +34573,16 @@ var ts;
                             expression = parseTaggedTemplateRest(pos, expression, questionDotToken, typeArguments);
                             continue;
                         }
-                        var argumentList = parseArgumentList();
-                        var callExpr = questionDotToken || tryReparseOptionalChain(expression) ?
-                            factory.createCallChain(expression, questionDotToken, typeArguments, argumentList) :
-                            factory.createCallExpression(expression, typeArguments, argumentList);
-                        expression = finishNode(callExpr, pos);
-                        continue;
+                        if (questionDotToken || token() === 20 /* OpenParenToken */) {
+                            var argumentList = parseArgumentList();
+                            var callExpr = questionDotToken || tryReparseOptionalChain(expression) ?
+                                factory.createCallChain(expression, questionDotToken, typeArguments, argumentList) :
+                                factory.createCallExpression(expression, typeArguments, argumentList);
+                            expression = finishNode(callExpr, pos);
+                            continue;
+                        }
+                        expression = finishNode(factory.createExpressionWithTypeArguments(expression, typeArguments), pos);
+                        break;
                     }
                 }
                 else if (token() === 20 /* OpenParenToken */) {
@@ -34609,20 +34622,23 @@ var ts;
                 // If it doesn't have the closing `>` then it's definitely not an type argument list.
                 return undefined;
             }
-            // If we have a '<', then only parse this as a argument list if the type arguments
-            // are complete and we have an open paren.  if we don't, rewind and return nothing.
-            return typeArguments && canFollowTypeArgumentsInExpression()
-                ? typeArguments
-                : undefined;
+            // We successfully parsed a type argument list. The next token determines whether we want to
+            // treat it as such. If the type argument list is followed by `(` or a template literal, as in
+            // `f<number>(42)`, we favor the type argument interpretation even though JavaScript would view
+            // it as a relational expression.
+            return typeArguments && canFollowTypeArgumentsInExpression() ? typeArguments : undefined;
         }
         function canFollowTypeArgumentsInExpression() {
             switch (token()) {
+                // These tokens can follow a type argument list in a call expression.
                 case 20 /* OpenParenToken */: // foo<x>(
                 case 14 /* NoSubstitutionTemplateLiteral */: // foo<T> `...`
                 case 15 /* TemplateHead */: // foo<T> `...${100}...`
-                // these are the only tokens can legally follow a type argument
-                // list. So we definitely want to treat them as type arg lists.
+                // These tokens can't follow in a call expression, nor can they start an
+                // expression. So, consider the type argument list part of an instantiation
+                // expression.
                 // falls through
+                case 27 /* CommaToken */: // foo<x>,
                 case 24 /* DotToken */: // foo<x>.
                 case 21 /* CloseParenToken */: // foo<x>)
                 case 23 /* CloseBracketToken */: // foo<x>]
@@ -34641,20 +34657,10 @@ var ts;
                 case 51 /* BarToken */: // foo<x> |
                 case 19 /* CloseBraceToken */: // foo<x> }
                 case 1 /* EndOfFileToken */: // foo<x>
-                    // these cases can't legally follow a type arg list.  However, they're not legal
-                    // expressions either.  The user is probably in the middle of a generic type. So
-                    // treat it as such.
                     return true;
-                case 27 /* CommaToken */: // foo<x>,
-                case 18 /* OpenBraceToken */: // foo<x> {
-                // We don't want to treat these as type arguments.  Otherwise we'll parse this
-                // as an invocation expression.  Instead, we want to parse out the expression
-                // in isolation from the type arguments.
-                // falls through
-                default:
-                    // Anything else treat as an expression.
-                    return false;
             }
+            // Treat anything else as an expression.
+            return false;
         }
         function parsePrimaryExpression() {
             switch (token()) {
@@ -34835,17 +34841,12 @@ var ts;
                 return finishNode(factory.createMetaProperty(103 /* NewKeyword */, name), pos);
             }
             var expressionPos = getNodePos();
-            var expression = parsePrimaryExpression();
-            var typeArguments;
-            while (true) {
-                expression = parseMemberExpressionRest(expressionPos, expression, /*allowOptionalChain*/ false);
-                typeArguments = tryParse(parseTypeArgumentsInExpression);
-                if (isTemplateStartOfTaggedTemplate()) {
-                    ts.Debug.assert(!!typeArguments, "Expected a type argument list; all plain tagged template starts should be consumed in 'parseMemberExpressionRest'");
-                    expression = parseTaggedTemplateRest(expressionPos, expression, /*optionalChain*/ undefined, typeArguments);
-                    typeArguments = undefined;
-                }
-                break;
+            var expression = parseMemberExpressionRest(expressionPos, parsePrimaryExpression(), /*allowOptionalChain*/ false);
+            var typeArguments = tryParse(parseTypeArgumentsInExpression);
+            if (isTemplateStartOfTaggedTemplate()) {
+                ts.Debug.assert(!!typeArguments, "Expected a type argument list; all plain tagged template starts should be consumed in 'parseMemberExpressionRest'");
+                expression = parseTaggedTemplateRest(expressionPos, expression, /*optionalChain*/ undefined, typeArguments);
+                typeArguments = undefined;
             }
             var argumentsArray;
             if (token() === 20 /* OpenParenToken */) {
@@ -35942,6 +35943,9 @@ var ts;
         function parseExpressionWithTypeArguments() {
             var pos = getNodePos();
             var expression = parseLeftHandSideExpressionOrHigher();
+            if (expression.kind === 227 /* ExpressionWithTypeArguments */) {
+                return expression;
+            }
             var typeArguments = tryParseTypeArguments();
             return finishNode(factory.createExpressionWithTypeArguments(expression, typeArguments), pos);
         }
@@ -36232,7 +36236,8 @@ var ts;
             return finishNode(node, pos);
         }
         function parseExportSpecifier() {
-            return parseImportOrExportSpecifier(274 /* ExportSpecifier */);
+            var hasJSDoc = hasPrecedingJSDocComment();
+            return withJSDoc(parseImportOrExportSpecifier(274 /* ExportSpecifier */), hasJSDoc);
         }
         function parseImportSpecifier() {
             return parseImportOrExportSpecifier(269 /* ImportSpecifier */);
@@ -43437,14 +43442,12 @@ var ts;
     }
     var binder = createBinder();
     function bindSourceFile(file, options) {
-        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("bind" /* Bind */, "bindSourceFile", { path: file.path }, /*separateBeginAndEnd*/ true);
         ts.performance.mark("beforeBind");
         ts.perfLogger.logStartBindFile("" + file.fileName);
         binder(file, options);
         ts.perfLogger.logStopBindFile();
         ts.performance.mark("afterBind");
         ts.performance.measure("Bind", "beforeBind", "afterBind");
-        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
     }
     ts.bindSourceFile = bindSourceFile;
     function createBinder() {
@@ -43504,7 +43507,9 @@ var ts;
             ts.Debug.attachFlowNodeDebugInfo(unreachableFlow);
             ts.Debug.attachFlowNodeDebugInfo(reportedUnreachableFlow);
             if (!file.locals) {
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("bind" /* Bind */, "bindSourceFile", { path: file.path }, /*separateBeginAndEnd*/ true);
                 bind(file);
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
                 file.symbolCount = symbolCount;
                 file.classifiableNames = classifiableNames;
                 delayedBindJSDocTypedefTag();
@@ -47771,6 +47776,9 @@ var ts;
             suggestionDiagnostics.add(diagnostic);
             return diagnostic;
         }
+        function isDeprecatedSymbol(symbol) {
+            return !!(getDeclarationNodeFlagsFromSymbol(symbol) & 134217728 /* Deprecated */);
+        }
         function addDeprecatedSuggestion(location, declarations, deprecatedEntity) {
             var diagnostic = ts.createDiagnosticForNode(location, ts.Diagnostics._0_is_deprecated, deprecatedEntity);
             return addDeprecatedSuggestionWorker(declarations, diagnostic);
@@ -50866,7 +50874,7 @@ var ts;
             // get symbol of the first identifier of the entityName
             var meaning;
             if (entityName.parent.kind === 180 /* TypeQuery */ ||
-                ts.isExpressionWithTypeArgumentsInClassExtendsClause(entityName.parent) ||
+                entityName.parent.kind === 227 /* ExpressionWithTypeArguments */ && !ts.isPartOfTypeNode(entityName.parent) ||
                 entityName.parent.kind === 161 /* ComputedPropertyName */) {
                 // Typeof value
                 meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
@@ -50977,7 +50985,7 @@ var ts;
             return flags & 814775659 /* NodeBuilderFlagsMask */;
         }
         function isClassInstanceSide(type) {
-            return !!type.symbol && !!(type.symbol.flags & 32 /* Class */) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || (!!(type.flags & 524288 /* Object */) && !!(ts.getObjectFlags(type) & 16777216 /* IsClassInstanceClone */)));
+            return !!type.symbol && !!(type.symbol.flags & 32 /* Class */) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || (!!(type.flags & 524288 /* Object */) && !!(ts.getObjectFlags(type) & 33554432 /* IsClassInstanceClone */)));
         }
         function createNodeBuilder() {
             return {
@@ -52541,7 +52549,8 @@ var ts;
                         includePrivateSymbol === null || includePrivateSymbol === void 0 ? void 0 : includePrivateSymbol(sym);
                     }
                     if (ts.isIdentifier(node)) {
-                        var name = sym.flags & 262144 /* TypeParameter */ ? typeParameterToName(getDeclaredTypeOfSymbol(sym), context) : ts.factory.cloneNode(node);
+                        var type = getDeclaredTypeOfSymbol(sym);
+                        var name = sym.flags & 262144 /* TypeParameter */ && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration) ? typeParameterToName(type, context) : ts.factory.cloneNode(node);
                         name.symbol = sym; // for quickinfo, which uses identifier symbol information
                         return { introducesError: introducesError, node: ts.setEmitFlags(ts.setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */) };
                     }
@@ -54904,7 +54913,7 @@ var ts;
                 members_4, exportedType.callSignatures, exportedType.constructSignatures, exportedType.indexInfos);
                 result.objectFlags |= (ts.getObjectFlags(type) & 8192 /* JSLiteral */); // Propagate JSLiteral flag
                 if (result.symbol && result.symbol.flags & 32 /* Class */ && type === getDeclaredTypeOfClassOrInterface(result.symbol)) {
-                    result.objectFlags |= 16777216 /* IsClassInstanceClone */; // Propagate the knowledge that this type is equivalent to the symbol's class instance type
+                    result.objectFlags |= 33554432 /* IsClassInstanceClone */; // Propagate the knowledge that this type is equivalent to the symbol's class instance type
                 }
                 return result;
             }
@@ -56914,87 +56923,87 @@ var ts;
          * Converts an AnonymousType to a ResolvedType.
          */
         function resolveAnonymousTypeMembers(type) {
-            var symbol = getMergedSymbol(type.symbol);
             if (type.target) {
                 setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
-                var members = createInstantiatedSymbolTable(getPropertiesOfObjectType(type.target), type.mapper, /*mappingThisOnly*/ false);
+                var members_6 = createInstantiatedSymbolTable(getPropertiesOfObjectType(type.target), type.mapper, /*mappingThisOnly*/ false);
                 var callSignatures = instantiateSignatures(getSignaturesOfType(type.target, 0 /* Call */), type.mapper);
                 var constructSignatures = instantiateSignatures(getSignaturesOfType(type.target, 1 /* Construct */), type.mapper);
-                var indexInfos = instantiateIndexInfos(getIndexInfosOfType(type.target), type.mapper);
-                setStructuredTypeMembers(type, members, callSignatures, constructSignatures, indexInfos);
+                var indexInfos_1 = instantiateIndexInfos(getIndexInfosOfType(type.target), type.mapper);
+                setStructuredTypeMembers(type, members_6, callSignatures, constructSignatures, indexInfos_1);
+                return;
             }
-            else if (symbol.flags & 2048 /* TypeLiteral */) {
+            var symbol = getMergedSymbol(type.symbol);
+            if (symbol.flags & 2048 /* TypeLiteral */) {
                 setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
-                var members = getMembersOfSymbol(symbol);
-                var callSignatures = getSignaturesOfSymbol(members.get("__call" /* Call */));
-                var constructSignatures = getSignaturesOfSymbol(members.get("__new" /* New */));
-                var indexInfos = getIndexInfosOfSymbol(symbol);
-                setStructuredTypeMembers(type, members, callSignatures, constructSignatures, indexInfos);
+                var members_7 = getMembersOfSymbol(symbol);
+                var callSignatures = getSignaturesOfSymbol(members_7.get("__call" /* Call */));
+                var constructSignatures = getSignaturesOfSymbol(members_7.get("__new" /* New */));
+                var indexInfos_2 = getIndexInfosOfSymbol(symbol);
+                setStructuredTypeMembers(type, members_7, callSignatures, constructSignatures, indexInfos_2);
+                return;
             }
-            else {
-                // Combinations of function, class, enum and module
-                var members = emptySymbols;
-                var indexInfos = void 0;
-                if (symbol.exports) {
-                    members = getExportsOfSymbol(symbol);
-                    if (symbol === globalThisSymbol) {
-                        var varsOnly_1 = new ts.Map();
-                        members.forEach(function (p) {
-                            if (!(p.flags & 418 /* BlockScoped */)) {
-                                varsOnly_1.set(p.escapedName, p);
-                            }
-                        });
-                        members = varsOnly_1;
-                    }
+            // Combinations of function, class, enum and module
+            var members = emptySymbols;
+            var indexInfos;
+            if (symbol.exports) {
+                members = getExportsOfSymbol(symbol);
+                if (symbol === globalThisSymbol) {
+                    var varsOnly_1 = new ts.Map();
+                    members.forEach(function (p) {
+                        if (!(p.flags & 418 /* BlockScoped */)) {
+                            varsOnly_1.set(p.escapedName, p);
+                        }
+                    });
+                    members = varsOnly_1;
                 }
-                var baseConstructorIndexInfo = void 0;
-                setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, ts.emptyArray);
-                if (symbol.flags & 32 /* Class */) {
-                    var classType = getDeclaredTypeOfClassOrInterface(symbol);
-                    var baseConstructorType = getBaseConstructorTypeOfClass(classType);
-                    if (baseConstructorType.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 8650752 /* TypeVariable */)) {
-                        members = ts.createSymbolTable(getNamedOrIndexSignatureMembers(members));
-                        addInheritedMembers(members, getPropertiesOfType(baseConstructorType));
-                    }
-                    else if (baseConstructorType === anyType) {
-                        baseConstructorIndexInfo = createIndexInfo(stringType, anyType, /*isReadonly*/ false);
-                    }
+            }
+            var baseConstructorIndexInfo;
+            setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, ts.emptyArray);
+            if (symbol.flags & 32 /* Class */) {
+                var classType = getDeclaredTypeOfClassOrInterface(symbol);
+                var baseConstructorType = getBaseConstructorTypeOfClass(classType);
+                if (baseConstructorType.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 8650752 /* TypeVariable */)) {
+                    members = ts.createSymbolTable(getNamedOrIndexSignatureMembers(members));
+                    addInheritedMembers(members, getPropertiesOfType(baseConstructorType));
                 }
-                var indexSymbol = getIndexSymbolFromSymbolTable(members);
-                if (indexSymbol) {
-                    indexInfos = getIndexInfosOfIndexSymbol(indexSymbol);
+                else if (baseConstructorType === anyType) {
+                    baseConstructorIndexInfo = createIndexInfo(stringType, anyType, /*isReadonly*/ false);
                 }
-                else {
-                    if (baseConstructorIndexInfo) {
-                        indexInfos = ts.append(indexInfos, baseConstructorIndexInfo);
-                    }
-                    if (symbol.flags & 384 /* Enum */ && (getDeclaredTypeOfSymbol(symbol).flags & 32 /* Enum */ ||
-                        ts.some(type.properties, function (prop) { return !!(getTypeOfSymbol(prop).flags & 296 /* NumberLike */); }))) {
-                        indexInfos = ts.append(indexInfos, enumNumberIndexInfo);
-                    }
+            }
+            var indexSymbol = getIndexSymbolFromSymbolTable(members);
+            if (indexSymbol) {
+                indexInfos = getIndexInfosOfIndexSymbol(indexSymbol);
+            }
+            else {
+                if (baseConstructorIndexInfo) {
+                    indexInfos = ts.append(indexInfos, baseConstructorIndexInfo);
                 }
-                setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, indexInfos || ts.emptyArray);
-                // We resolve the members before computing the signatures because a signature may use
-                // typeof with a qualified name expression that circularly references the type we are
-                // in the process of resolving (see issue #6072). The temporarily empty signature list
-                // will never be observed because a qualified name can't reference signatures.
-                if (symbol.flags & (16 /* Function */ | 8192 /* Method */)) {
-                    type.callSignatures = getSignaturesOfSymbol(symbol);
+                if (symbol.flags & 384 /* Enum */ && (getDeclaredTypeOfSymbol(symbol).flags & 32 /* Enum */ ||
+                    ts.some(type.properties, function (prop) { return !!(getTypeOfSymbol(prop).flags & 296 /* NumberLike */); }))) {
+                    indexInfos = ts.append(indexInfos, enumNumberIndexInfo);
                 }
-                // And likewise for construct signatures for classes
-                if (symbol.flags & 32 /* Class */) {
-                    var classType_1 = getDeclaredTypeOfClassOrInterface(symbol);
-                    var constructSignatures = symbol.members ? getSignaturesOfSymbol(symbol.members.get("__constructor" /* Constructor */)) : ts.emptyArray;
-                    if (symbol.flags & 16 /* Function */) {
-                        constructSignatures = ts.addRange(constructSignatures.slice(), ts.mapDefined(type.callSignatures, function (sig) { return isJSConstructor(sig.declaration) ?
-                            createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, classType_1, /*resolvedTypePredicate*/ undefined, sig.minArgumentCount, sig.flags & 39 /* PropagatingFlags */) :
-                            undefined; }));
-                    }
-                    if (!constructSignatures.length) {
-                        constructSignatures = getDefaultConstructSignatures(classType_1);
-                    }
-                    type.constructSignatures = constructSignatures;
+            }
+            setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, indexInfos || ts.emptyArray);
+            // We resolve the members before computing the signatures because a signature may use
+            // typeof with a qualified name expression that circularly references the type we are
+            // in the process of resolving (see issue #6072). The temporarily empty signature list
+            // will never be observed because a qualified name can't reference signatures.
+            if (symbol.flags & (16 /* Function */ | 8192 /* Method */)) {
+                type.callSignatures = getSignaturesOfSymbol(symbol);
+            }
+            // And likewise for construct signatures for classes
+            if (symbol.flags & 32 /* Class */) {
+                var classType_1 = getDeclaredTypeOfClassOrInterface(symbol);
+                var constructSignatures = symbol.members ? getSignaturesOfSymbol(symbol.members.get("__constructor" /* Constructor */)) : ts.emptyArray;
+                if (symbol.flags & 16 /* Function */) {
+                    constructSignatures = ts.addRange(constructSignatures.slice(), ts.mapDefined(type.callSignatures, function (sig) { return isJSConstructor(sig.declaration) ?
+                        createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, classType_1, /*resolvedTypePredicate*/ undefined, sig.minArgumentCount, sig.flags & 39 /* PropagatingFlags */) :
+                        undefined; }));
                 }
+                if (!constructSignatures.length) {
+                    constructSignatures = getDefaultConstructSignatures(classType_1);
+                }
+                type.constructSignatures = constructSignatures;
             }
         }
         function replaceIndexedAccess(instantiable, type, replacement) {
@@ -57986,8 +57995,8 @@ var ts;
             var stringIndexInfo;
             var applicableInfo;
             var applicableInfos;
-            for (var _i = 0, indexInfos_1 = indexInfos; _i < indexInfos_1.length; _i++) {
-                var info = indexInfos_1[_i];
+            for (var _i = 0, indexInfos_3 = indexInfos; _i < indexInfos_3.length; _i++) {
+                var info = indexInfos_3[_i];
                 if (info.keyType === stringType) {
                     stringIndexInfo = info;
                 }
@@ -58551,14 +58560,14 @@ var ts;
         }
         function getIndexInfosOfIndexSymbol(indexSymbol) {
             if (indexSymbol.declarations) {
-                var indexInfos_2 = [];
+                var indexInfos_4 = [];
                 var _loop_14 = function (declaration) {
                     if (declaration.parameters.length === 1) {
                         var parameter = declaration.parameters[0];
                         if (parameter.type) {
                             forEachType(getTypeFromTypeNode(parameter.type), function (keyType) {
-                                if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos_2, keyType)) {
-                                    indexInfos_2.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, ts.hasEffectiveModifier(declaration, 64 /* Readonly */), declaration));
+                                if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos_4, keyType)) {
+                                    indexInfos_4.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, ts.hasEffectiveModifier(declaration, 64 /* Readonly */), declaration));
                                 }
                             });
                         }
@@ -58568,7 +58577,7 @@ var ts;
                     var declaration = _a[_i];
                     _loop_14(declaration);
                 }
-                return indexInfos_2;
+                return indexInfos_4;
             }
             return ts.emptyArray;
         }
@@ -59116,7 +59125,7 @@ var ts;
                 // The expression is processed as an identifier expression (section 4.3)
                 // or property access expression(section 4.10),
                 // the widened type(section 3.9) of which becomes the result.
-                var type = ts.isThisIdentifier(node.exprName) ? checkThisExpression(node.exprName) : checkExpression(node.exprName);
+                var type = checkExpressionWithTypeArguments(node);
                 links.resolvedType = getRegularTypeOfLiteralType(getWidenedType(type));
             }
             return links.resolvedType;
@@ -60557,7 +60566,7 @@ var ts;
                 }
                 var prop = getPropertyOfType(objectType, propName);
                 if (prop) {
-                    if (accessFlags & 64 /* ReportDeprecated */ && accessNode && prop.declarations && getDeclarationNodeFlagsFromSymbol(prop) & 134217728 /* Deprecated */ && isUncalledFunctionReference(accessNode, prop)) {
+                    if (accessFlags & 64 /* ReportDeprecated */ && accessNode && prop.declarations && isDeprecatedSymbol(prop) && isUncalledFunctionReference(accessNode, prop)) {
                         var deprecatedNode = (_a = accessExpression === null || accessExpression === void 0 ? void 0 : accessExpression.argumentExpression) !== null && _a !== void 0 ? _a : (ts.isIndexedAccessTypeNode(accessNode) ? accessNode.indexType : accessNode);
                         addDeprecatedSuggestion(deprecatedNode, prop.declarations, propName);
                     }
@@ -61820,7 +61829,9 @@ var ts;
             return result;
         }
         function getObjectTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) {
-            var declaration = type.objectFlags & 4 /* Reference */ ? type.node : type.symbol.declarations[0];
+            var declaration = type.objectFlags & 4 /* Reference */ ? type.node :
+                type.objectFlags & 16777216 /* InstantiationExpressionType */ ? type.node :
+                    type.symbol.declarations[0];
             var links = getNodeLinks(declaration);
             var target = type.objectFlags & 4 /* Reference */ ? links.resolvedType :
                 type.objectFlags & 64 /* Instantiated */ ? type.target : type;
@@ -61836,8 +61847,8 @@ var ts;
                     outerTypeParameters = ts.addRange(outerTypeParameters, templateTagParameters);
                 }
                 typeParameters = outerTypeParameters || ts.emptyArray;
-                var allDeclarations_1 = type.objectFlags & 4 /* Reference */ ? [declaration] : type.symbol.declarations;
-                typeParameters = (target.objectFlags & 4 /* Reference */ || target.symbol.flags & 8192 /* Method */ || target.symbol.flags & 2048 /* TypeLiteral */) && !target.aliasTypeArguments ?
+                var allDeclarations_1 = type.objectFlags & (4 /* Reference */ | 16777216 /* InstantiationExpressionType */) ? [declaration] : type.symbol.declarations;
+                typeParameters = (target.objectFlags & (4 /* Reference */ | 16777216 /* InstantiationExpressionType */) || target.symbol.flags & 8192 /* Method */ || target.symbol.flags & 2048 /* TypeLiteral */) && !target.aliasTypeArguments ?
                     ts.filter(typeParameters, function (tp) { return ts.some(allDeclarations_1, function (d) { return isTypeParameterPossiblyReferenced(tp, d); }); }) :
                     typeParameters;
                 links.outerTypeParameters = typeParameters;
@@ -62009,6 +62020,9 @@ var ts;
                 mapper = combineTypeMappers(makeUnaryTypeMapper(origTypeParameter, freshTypeParameter), mapper);
                 freshTypeParameter.mapper = mapper;
             }
+            if (type.objectFlags & 16777216 /* InstantiationExpressionType */) {
+                result.node = type.node;
+            }
             result.target = type;
             result.mapper = mapper;
             result.aliasSymbol = aliasSymbol || type.aliasSymbol;
@@ -65183,8 +65197,8 @@ var ts;
                 var indexInfos = getIndexInfosOfType(target);
                 var targetHasStringIndex = ts.some(indexInfos, function (info) { return info.keyType === stringType; });
                 var result = -1 /* True */;
-                for (var _i = 0, indexInfos_3 = indexInfos; _i < indexInfos_3.length; _i++) {
-                    var targetInfo = indexInfos_3[_i];
+                for (var _i = 0, indexInfos_5 = indexInfos; _i < indexInfos_5.length; _i++) {
+                    var targetInfo = indexInfos_5[_i];
                     var related = !sourceIsPrimitive && targetHasStringIndex && targetInfo.type.flags & 1 /* Any */ ? -1 /* True */ :
                         isGenericMappedType(source) && targetHasStringIndex ? isRelatedTo(getTemplateTypeFromMappedType(source), targetInfo.type, 3 /* Both */, reportErrors) :
                             typeRelatedToIndexInfo(source, targetInfo, reportErrors, intersectionState);
@@ -65791,10 +65805,10 @@ var ts;
             if (!(ts.getObjectFlags(type) & 4 /* Reference */) || !(ts.getObjectFlags(type.target) & 3 /* ClassOrInterface */)) {
                 return undefined;
             }
-            if (ts.getObjectFlags(type) & 33554432 /* IdenticalBaseTypeCalculated */) {
-                return ts.getObjectFlags(type) & 67108864 /* IdenticalBaseTypeExists */ ? type.cachedEquivalentBaseType : undefined;
+            if (ts.getObjectFlags(type) & 67108864 /* IdenticalBaseTypeCalculated */) {
+                return ts.getObjectFlags(type) & 134217728 /* IdenticalBaseTypeExists */ ? type.cachedEquivalentBaseType : undefined;
             }
-            type.objectFlags |= 33554432 /* IdenticalBaseTypeCalculated */;
+            type.objectFlags |= 67108864 /* IdenticalBaseTypeCalculated */;
             var target = type.target;
             if (ts.getObjectFlags(target) & 1 /* Class */) {
                 var baseTypeNode = getBaseTypeNodeOfClass(target);
@@ -65815,7 +65829,7 @@ var ts;
             if (ts.length(getTypeArguments(type)) > ts.length(target.typeParameters)) {
                 instantiatedBase = getTypeWithThisArgument(instantiatedBase, ts.last(getTypeArguments(type)));
             }
-            type.objectFlags |= 67108864 /* IdenticalBaseTypeExists */;
+            type.objectFlags |= 134217728 /* IdenticalBaseTypeExists */;
             return type.cachedEquivalentBaseType = instantiatedBase;
         }
         function isEmptyLiteralType(type) {
@@ -66479,7 +66493,7 @@ var ts;
             var result = !!(type.flags & 465829888 /* Instantiable */ ||
                 type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || ts.forEach(getTypeArguments(type), couldContainTypeVariables)) ||
                     objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations ||
-                    objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 8388608 /* ObjectRestType */)) ||
+                    objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 8388608 /* ObjectRestType */ | 16777216 /* InstantiationExpressionType */)) ||
                 type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && ts.some(type.types, couldContainTypeVariables));
             if (type.flags & 3899393 /* ObjectFlagsType */) {
                 type.objectFlags |= 1048576 /* CouldContainTypeVariablesComputed */ | (result ? 2097152 /* CouldContainTypeVariables */ : 0);
@@ -67396,8 +67410,8 @@ var ts;
                 var priority = (ts.getObjectFlags(source) & ts.getObjectFlags(target) & 32 /* Mapped */) ? 8 /* HomomorphicMappedType */ : 0;
                 var indexInfos = getIndexInfosOfType(target);
                 if (isObjectTypeWithInferableIndex(source)) {
-                    for (var _i = 0, indexInfos_4 = indexInfos; _i < indexInfos_4.length; _i++) {
-                        var targetInfo = indexInfos_4[_i];
+                    for (var _i = 0, indexInfos_6 = indexInfos; _i < indexInfos_6.length; _i++) {
+                        var targetInfo = indexInfos_6[_i];
                         var propTypes = [];
                         for (var _a = 0, _b = getPropertiesOfType(source); _a < _b.length; _a++) {
                             var prop = _b[_a];
@@ -67417,8 +67431,8 @@ var ts;
                         }
                     }
                 }
-                for (var _e = 0, indexInfos_5 = indexInfos; _e < indexInfos_5.length; _e++) {
-                    var targetInfo = indexInfos_5[_e];
+                for (var _e = 0, indexInfos_7 = indexInfos; _e < indexInfos_7.length; _e++) {
+                    var targetInfo = indexInfos_7[_e];
                     var sourceInfo = getApplicableIndexInfo(source, targetInfo.keyType);
                     if (sourceInfo) {
                         inferWithPriority(sourceInfo.type, targetInfo.type, priority);
@@ -69960,9 +69974,9 @@ var ts;
                 markAliasReferenced(symbol, node);
             }
             var localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol);
-            var sourceSymbol = localOrExportSymbol.flags & 2097152 /* Alias */ ? resolveAlias(localOrExportSymbol) : localOrExportSymbol;
-            if (sourceSymbol.declarations && getDeclarationNodeFlagsFromSymbol(sourceSymbol) & 134217728 /* Deprecated */ && isUncalledFunctionReference(node, sourceSymbol)) {
-                addDeprecatedSuggestion(node, sourceSymbol.declarations, node.escapedText);
+            var targetSymbol = checkDeprecatedAliasedSymbol(localOrExportSymbol, node);
+            if (isDeprecatedSymbol(targetSymbol) && isUncalledFunctionReference(node, targetSymbol) && targetSymbol.declarations) {
+                addDeprecatedSuggestion(node, targetSymbol.declarations, node.escapedText);
             }
             var declaration = localOrExportSymbol.valueDeclaration;
             if (declaration && localOrExportSymbol.flags & 32 /* Class */) {
@@ -72974,7 +72988,7 @@ var ts;
                 }
             }
             else {
-                if (prop.declarations && getDeclarationNodeFlagsFromSymbol(prop) & 134217728 /* Deprecated */ && isUncalledFunctionReference(node, prop)) {
+                if (isDeprecatedSymbol(prop) && isUncalledFunctionReference(node, prop) && prop.declarations) {
                     addDeprecatedSuggestion(right, prop.declarations, right.escapedText);
                 }
                 checkPropertyNotUsedBeforeDeclaration(prop, node, right);
@@ -74433,7 +74447,7 @@ var ts;
                         }
                         var diags_3 = max > 1 ? allDiagnostics[minIndex] : ts.flatten(allDiagnostics);
                         ts.Debug.assert(diags_3.length > 0, "No errors reported for 3 or fewer overload signatures");
-                        var chain = ts.chainDiagnosticMessages(ts.map(diags_3, function (d) { return typeof d.messageText === "string" ? d : d.messageText; }), ts.Diagnostics.No_overload_matches_this_call);
+                        var chain = ts.chainDiagnosticMessages(ts.map(diags_3, ts.createDiagnosticMessageChainFromDiagnostic), ts.Diagnostics.No_overload_matches_this_call);
                         // The below is a spread to guarantee we get a new (mutable) array - our `flatMap` helper tries to do "smart" optimizations where it reuses input
                         // arrays and the emptyArray singleton where possible, which is decidedly not what we want while we're still constructing this diagnostic
                         var related = __spreadArray([], ts.flatMap(diags_3, function (d) { return d.relatedInformation; }), true);
@@ -75588,6 +75602,66 @@ var ts;
             return node.flags & 32 /* OptionalChain */ ? checkNonNullChain(node) :
                 getNonNullableType(checkExpression(node.expression));
         }
+        function checkExpressionWithTypeArguments(node) {
+            checkGrammarExpressionWithTypeArguments(node);
+            var exprType = node.kind === 227 /* ExpressionWithTypeArguments */ ? checkExpression(node.expression) :
+                ts.isThisIdentifier(node.exprName) ? checkThisExpression(node.exprName) :
+                    checkExpression(node.exprName);
+            var typeArguments = node.typeArguments;
+            if (!ts.some(typeArguments)) {
+                return exprType;
+            }
+            var funcType = getApparentType(exprType);
+            if (funcType === silentNeverType || isErrorType(funcType)) {
+                return funcType;
+            }
+            var hasSomeApplicableSignature = false;
+            var nonApplicableType;
+            var hasSignatures;
+            var hasApplicableSignature;
+            var result = mapType(funcType, getInstantiatedType);
+            var errorType = hasSomeApplicableSignature ? nonApplicableType : funcType;
+            if (errorType) {
+                diagnostics.add(ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable, typeToString(errorType)));
+            }
+            return result;
+            function getInstantiatedType(type) {
+                hasSignatures = false;
+                hasApplicableSignature = false;
+                var result = getInstantiatedTypeWorker(type);
+                hasSomeApplicableSignature || (hasSomeApplicableSignature = hasApplicableSignature);
+                if (hasSignatures && !hasApplicableSignature) {
+                    nonApplicableType !== null && nonApplicableType !== void 0 ? nonApplicableType : (nonApplicableType = type);
+                }
+                return result;
+            }
+            function getInstantiatedTypeWorker(type) {
+                if (type.flags & 524288 /* Object */) {
+                    var resolved = resolveStructuredTypeMembers(type);
+                    var callSignatures = getInstantiatedSignatures(resolved.callSignatures);
+                    var constructSignatures = getInstantiatedSignatures(resolved.constructSignatures);
+                    hasSignatures || (hasSignatures = resolved.callSignatures.length !== 0 || resolved.constructSignatures.length !== 0);
+                    hasApplicableSignature || (hasApplicableSignature = callSignatures.length !== 0 || constructSignatures.length !== 0);
+                    if (callSignatures !== resolved.callSignatures || constructSignatures !== resolved.constructSignatures) {
+                        var result_11 = createAnonymousType(undefined, resolved.members, callSignatures, constructSignatures, resolved.indexInfos);
+                        result_11.objectFlags |= 16777216 /* InstantiationExpressionType */;
+                        result_11.node = node;
+                        return result_11;
+                    }
+                }
+                else if (type.flags & 2097152 /* Intersection */) {
+                    return getIntersectionType(ts.sameMap(type.types, getInstantiatedTypeWorker));
+                }
+                return type;
+            }
+            function getInstantiatedSignatures(signatures) {
+                var applicableSignatures = ts.filter(signatures, function (sig) { return !!sig.typeParameters && hasCorrectTypeArgumentArity(sig, typeArguments); });
+                return ts.sameMap(applicableSignatures, function (sig) {
+                    var typeArgumentTypes = checkTypeArguments(sig, typeArguments, /*reportErrors*/ true);
+                    return typeArgumentTypes ? getSignatureInstantiation(sig, typeArgumentTypes, ts.isInJSFile(sig.declaration)) : sig;
+                });
+            }
+        }
         function checkMetaProperty(node) {
             checkGrammarMetaProperty(node);
             if (node.keywordToken === 103 /* NewKeyword */) {
@@ -78097,6 +78171,8 @@ var ts;
                     return checkAssertion(node);
                 case 229 /* NonNullExpression */:
                     return checkNonNullAssertion(node);
+                case 227 /* ExpressionWithTypeArguments */:
+                    return checkExpressionWithTypeArguments(node);
                 case 230 /* MetaProperty */:
                     return checkMetaProperty(node);
                 case 214 /* DeleteExpression */:
@@ -79302,12 +79378,12 @@ var ts;
                     case 264 /* ImportEqualsDeclaration */:
                     case 267 /* NamespaceImport */:
                     case 266 /* ImportClause */:
-                        var result_11 = 0 /* None */;
+                        var result_12 = 0 /* None */;
                         var target = resolveAlias(getSymbolOfNode(d));
                         ts.forEach(target.declarations, function (d) {
-                            result_11 |= getDeclarationSpaces(d);
+                            result_12 |= getDeclarationSpaces(d);
                         });
-                        return result_11;
+                        return result_12;
                     case 253 /* VariableDeclaration */:
                     case 202 /* BindingElement */:
                     case 255 /* FunctionDeclaration */:
@@ -81894,8 +81970,8 @@ var ts;
                 }
             }
             if (indexInfos.length > 1) {
-                for (var _d = 0, indexInfos_6 = indexInfos; _d < indexInfos_6.length; _d++) {
-                    var info = indexInfos_6[_d];
+                for (var _d = 0, indexInfos_8 = indexInfos; _d < indexInfos_8.length; _d++) {
+                    var info = indexInfos_8[_d];
                     checkIndexConstraintForIndexSignature(type, info);
                 }
             }
@@ -81921,8 +81997,8 @@ var ts;
                     error(errorNode, ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_2_index_type_3, symbolToString(prop), typeToString(propType), typeToString(info.keyType), typeToString(info.type));
                 }
             };
-            for (var _i = 0, indexInfos_7 = indexInfos; _i < indexInfos_7.length; _i++) {
-                var info = indexInfos_7[_i];
+            for (var _i = 0, indexInfos_9 = indexInfos; _i < indexInfos_9.length; _i++) {
+                var info = indexInfos_9[_i];
                 _loop_27(info);
             }
         }
@@ -81944,8 +82020,8 @@ var ts;
                     error(errorNode, ts.Diagnostics._0_index_type_1_is_not_assignable_to_2_index_type_3, typeToString(checkInfo.keyType), typeToString(checkInfo.type), typeToString(info.keyType), typeToString(info.type));
                 }
             };
-            for (var _i = 0, indexInfos_8 = indexInfos; _i < indexInfos_8.length; _i++) {
-                var info = indexInfos_8[_i];
+            for (var _i = 0, indexInfos_10 = indexInfos; _i < indexInfos_10.length; _i++) {
+                var info = indexInfos_10[_i];
                 _loop_28(info);
             }
         }
@@ -82812,16 +82888,15 @@ var ts;
                         return ts.nodeIsMissing(expr) ? 0 : evaluateEnumMember(expr, getSymbolOfNode(member.parent), identifier.escapedText);
                     case 206 /* ElementAccessExpression */:
                     case 205 /* PropertyAccessExpression */:
-                        var ex = expr;
-                        if (isConstantMemberAccess(ex)) {
-                            var type = getTypeOfExpression(ex.expression);
+                        if (isConstantMemberAccess(expr)) {
+                            var type = getTypeOfExpression(expr.expression);
                             if (type.symbol && type.symbol.flags & 384 /* Enum */) {
                                 var name = void 0;
-                                if (ex.kind === 205 /* PropertyAccessExpression */) {
-                                    name = ex.name.escapedText;
+                                if (expr.kind === 205 /* PropertyAccessExpression */) {
+                                    name = expr.name.escapedText;
                                 }
                                 else {
-                                    name = ts.escapeLeadingUnderscores(ts.cast(ex.argumentExpression, ts.isLiteralExpression).text);
+                                    name = ts.escapeLeadingUnderscores(ts.cast(expr.argumentExpression, ts.isLiteralExpression).text);
                                 }
                                 return evaluateEnumMember(expr, type.symbol, name);
                             }
@@ -82849,6 +82924,10 @@ var ts;
             }
         }
         function isConstantMemberAccess(node) {
+            var type = getTypeOfExpression(node);
+            if (type === errorType) {
+                return false;
+            }
             return node.kind === 79 /* Identifier */ ||
                 node.kind === 205 /* PropertyAccessExpression */ && isConstantMemberAccess(node.expression) ||
                 node.kind === 206 /* ElementAccessExpression */ && isConstantMemberAccess(node.expression) &&
@@ -83143,7 +83222,6 @@ var ts;
             return true;
         }
         function checkAliasSymbol(node) {
-            var _a;
             var symbol = getSymbolOfNode(node);
             var target = resolveAlias(symbol);
             if (target !== unknownSymbol) {
@@ -83199,11 +83277,46 @@ var ts;
                         }
                     }
                 }
-                if (ts.isImportSpecifier(node) && ((_a = target.declarations) === null || _a === void 0 ? void 0 : _a.every(function (d) { return !!(ts.getCombinedNodeFlags(d) & 134217728 /* Deprecated */); }))) {
-                    addDeprecatedSuggestion(node.name, target.declarations, symbol.escapedName);
+                if (ts.isImportSpecifier(node)) {
+                    var targetSymbol = checkDeprecatedAliasedSymbol(symbol, node);
+                    if (isDeprecatedAliasedSymbol(targetSymbol) && targetSymbol.declarations) {
+                        addDeprecatedSuggestion(node, targetSymbol.declarations, targetSymbol.escapedName);
+                    }
                 }
             }
         }
+        function isDeprecatedAliasedSymbol(symbol) {
+            return !!symbol.declarations && ts.every(symbol.declarations, function (d) { return !!(ts.getCombinedNodeFlags(d) & 134217728 /* Deprecated */); });
+        }
+        function checkDeprecatedAliasedSymbol(symbol, location) {
+            if (!(symbol.flags & 2097152 /* Alias */))
+                return symbol;
+            var targetSymbol = resolveAlias(symbol);
+            if (targetSymbol === unknownSymbol)
+                return targetSymbol;
+            while (symbol.flags & 2097152 /* Alias */) {
+                var target = getImmediateAliasedSymbol(symbol);
+                if (target) {
+                    if (target === targetSymbol)
+                        break;
+                    if (target.declarations && ts.length(target.declarations)) {
+                        if (isDeprecatedAliasedSymbol(target)) {
+                            addDeprecatedSuggestion(location, target.declarations, target.escapedName);
+                            break;
+                        }
+                        else {
+                            if (symbol === targetSymbol)
+                                break;
+                            symbol = target;
+                        }
+                    }
+                }
+                else {
+                    break;
+                }
+            }
+            return targetSymbol;
+        }
         function checkImportBinding(node) {
             checkCollisionsForDeclarationName(node, node.name);
             checkAliasSymbol(node);
@@ -87504,7 +87617,7 @@ var ts;
                 return factory.updateConstructorTypeNode(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
             case 180 /* TypeQuery */:
                 ts.Debug.type(node);
-                return factory.updateTypeQueryNode(node, nodeVisitor(node.exprName, visitor, ts.isEntityName));
+                return factory.updateTypeQueryNode(node, nodeVisitor(node.exprName, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode));
             case 181 /* TypeLiteral */:
                 ts.Debug.type(node);
                 return factory.updateTypeLiteralNode(node, nodesVisitor(node.members, visitor, ts.isTypeElement));
@@ -90396,8 +90509,8 @@ var ts;
         function generateClassElementDecorationExpressions(node, isStatic) {
             var members = getDecoratedClassElements(node, isStatic);
             var expressions;
-            for (var _i = 0, members_6 = members; _i < members_6.length; _i++) {
-                var member = members_6[_i];
+            for (var _i = 0, members_8 = members; _i < members_8.length; _i++) {
+                var member = members_8[_i];
                 var expression = generateClassElementDecorationExpression(node, member);
                 if (expression) {
                     if (!expressions) {
@@ -95598,8 +95711,8 @@ var ts;
         function convertJsxChildrenToChildrenPropAssignment(children) {
             var nonWhitespaceChildren = ts.getSemanticJsxChildren(children);
             if (ts.length(nonWhitespaceChildren) === 1 && !nonWhitespaceChildren[0].dotDotDotToken) {
-                var result_12 = transformJsxChildToExpression(nonWhitespaceChildren[0]);
-                return result_12 && factory.createPropertyAssignment("children", result_12);
+                var result_13 = transformJsxChildToExpression(nonWhitespaceChildren[0]);
+                return result_13 && factory.createPropertyAssignment("children", result_13);
             }
             var result = ts.mapDefined(children, transformJsxChildToExpression);
             return ts.length(result) ? factory.createPropertyAssignment("children", factory.createArrayLiteralExpression(result)) : undefined;
@@ -109228,6 +109341,8 @@ var ts;
                         return emitAsExpression(node);
                     case 229 /* NonNullExpression */:
                         return emitNonNullExpression(node);
+                    case 227 /* ExpressionWithTypeArguments */:
+                        return emitExpressionWithTypeArguments(node);
                     case 230 /* MetaProperty */:
                         return emitMetaProperty(node);
                     case 231 /* SyntheticExpression */:
@@ -109672,6 +109787,7 @@ var ts;
             writeKeyword("typeof");
             writeSpace();
             emit(node.exprName);
+            emitTypeArguments(node, node.typeArguments);
         }
         function emitTypeLiteral(node) {
             writePunctuation("{");
@@ -114631,15 +114747,15 @@ var ts;
                 // which per above occurred during the current program creation.
                 // Since we assume the filesystem does not change during program creation,
                 // it is safe to reuse resolutions from the earlier call.
-                var result_13 = [];
+                var result_14 = [];
                 var i = 0;
                 for (var _i = 0, moduleNames_1 = moduleNames; _i < moduleNames_1.length; _i++) {
                     var moduleName = moduleNames_1[_i];
                     var resolvedModule = file.resolvedModules.get(moduleName, getModeForResolutionAtIndex(file, i));
                     i++;
-                    result_13.push(resolvedModule);
+                    result_14.push(resolvedModule);
                 }
-                return result_13;
+                return result_14;
             }
             // At this point, we know at least one of the following hold:
             // - file has local declarations for ambient modules
@@ -115861,14 +115977,14 @@ var ts;
                     redirectTargetsMap.add(fileFromPackageId.path, fileName);
                     addFileToFilesByName(dupFile, path, redirectedPath);
                     addFileIncludeReason(dupFile, reason);
-                    sourceFileToPackageName.set(path, packageId.name);
+                    sourceFileToPackageName.set(path, ts.packageIdToPackageName(packageId));
                     processingOtherFiles.push(dupFile);
                     return dupFile;
                 }
                 else if (file) {
                     // This is the first source file to have this packageId.
                     packageIdToSourceFile.set(packageIdKey, file);
-                    sourceFileToPackageName.set(path, packageId.name);
+                    sourceFileToPackageName.set(path, ts.packageIdToPackageName(packageId));
                 }
             }
             addFileToFilesByName(file, path, redirectedPath);
@@ -119747,9 +119863,9 @@ var ts;
             if (!preferSymlinks) {
                 // Symlinks inside ignored paths are already filtered out of the symlink cache,
                 // so we only need to remove them from the realpath filenames.
-                var result_14 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
-                if (result_14)
-                    return result_14;
+                var result_15 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
+                if (result_15)
+                    return result_15;
             }
             var symlinkedDirectories = (_a = host.getSymlinkCache) === null || _a === void 0 ? void 0 : _a.call(host).getSymlinkedDirectoriesByRealpath();
             var fullImportedFileName = ts.getNormalizedAbsolutePath(importedFileName, cwd);
@@ -119769,10 +119885,10 @@ var ts;
                     for (var _i = 0, symlinkDirectories_1 = symlinkDirectories; _i < symlinkDirectories_1.length; _i++) {
                         var symlinkDirectory = symlinkDirectories_1[_i];
                         var option = ts.resolvePath(symlinkDirectory, relative);
-                        var result_15 = cb(option, target === referenceRedirect);
+                        var result_16 = cb(option, target === referenceRedirect);
                         shouldFilterIgnoredPaths = true; // We found a non-ignored path in symlinks, so we can reject ignored-path realpaths
-                        if (result_15)
-                            return result_15;
+                        if (result_16)
+                            return result_16;
                     }
                 });
             });
@@ -123665,7 +123781,7 @@ var ts;
             case 199 /* ImportType */:
                 return !node.parent.isTypeOf;
             case 227 /* ExpressionWithTypeArguments */:
-                return !ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent);
+                return ts.isPartOfTypeNode(node.parent);
         }
         return false;
     }
@@ -126528,11 +126644,11 @@ var ts;
         return ts.isArray(valueOrArray) ? ts.first(valueOrArray) : valueOrArray;
     }
     ts.firstOrOnly = firstOrOnly;
-    function getNameForExportedSymbol(symbol, scriptTarget) {
+    function getNameForExportedSymbol(symbol, scriptTarget, preferCapitalized) {
         if (!(symbol.flags & 33554432 /* Transient */) && (symbol.escapedName === "export=" /* ExportEquals */ || symbol.escapedName === "default" /* Default */)) {
             // Name of "export default foo;" is "foo". Name of "export default 0" is the filename converted to camelCase.
             return ts.firstDefined(symbol.declarations, function (d) { var _a; return ts.isExportAssignment(d) ? (_a = ts.tryCast(ts.skipOuterExpressions(d.expression), ts.isIdentifier)) === null || _a === void 0 ? void 0 : _a.text : undefined; })
-                || ts.codefix.moduleSymbolToValidIdentifier(getSymbolParentOrFail(symbol), scriptTarget);
+                || ts.codefix.moduleSymbolToValidIdentifier(getSymbolParentOrFail(symbol), scriptTarget, !!preferCapitalized);
         }
         return symbol.name;
     }
@@ -126660,7 +126776,7 @@ var ts;
                 symbols.clear();
                 usableByFileName = undefined;
             },
-            add: function (importingFile, symbol, symbolTableKey, moduleSymbol, moduleFile, exportKind, isFromPackageJson, scriptTarget, checker) {
+            add: function (importingFile, symbol, symbolTableKey, moduleSymbol, moduleFile, exportKind, isFromPackageJson, checker) {
                 if (importingFile !== usableByFileName) {
                     cache.clear();
                     usableByFileName = importingFile;
@@ -126676,7 +126792,7 @@ var ts;
                 //    get a better name.
                 var importedName = exportKind === 0 /* Named */ || ts.isExternalModuleSymbol(namedSymbol)
                     ? ts.unescapeLeadingUnderscores(symbolTableKey)
-                    : ts.getNameForExportedSymbol(namedSymbol, scriptTarget);
+                    : ts.getNameForExportedSymbol(namedSymbol, /*scriptTarget*/ undefined);
                 var moduleName = ts.stripQuotes(moduleSymbol.name);
                 var id = exportInfoId++;
                 var target = ts.skipAlias(symbol, checker);
@@ -126709,7 +126825,14 @@ var ts;
                     return;
                 exportInfo.forEach(function (info, key) {
                     var _a = parseKey(key), symbolName = _a.symbolName, ambientModuleName = _a.ambientModuleName;
-                    action(info.map(rehydrateCachedInfo), symbolName, !!ambientModuleName, key);
+                    var rehydrated = info.map(rehydrateCachedInfo);
+                    action(rehydrated, function (preferCapitalized) {
+                        var _a = rehydrated[0], symbol = _a.symbol, exportKind = _a.exportKind;
+                        var namedSymbol = exportKind === 1 /* Default */ && ts.getLocalSymbolForExportDefault(symbol) || symbol;
+                        return preferCapitalized
+                            ? ts.getNameForExportedSymbol(namedSymbol, /*scriptTarget*/ undefined, /*preferCapitalized*/ true)
+                            : symbolName;
+                    }, !!ambientModuleName, key);
                 });
             },
             releaseSymbols: function () {
@@ -126891,7 +127014,6 @@ var ts;
         }
         (_d = host.log) === null || _d === void 0 ? void 0 : _d.call(host, "getExportInfoMap: cache miss or empty; calculating new results");
         var compilerOptions = program.getCompilerOptions();
-        var scriptTarget = ts.getEmitScriptTarget(compilerOptions);
         var moduleCount = 0;
         forEachExternalModuleToImportFrom(program, host, /*useAutoImportProvider*/ true, function (moduleSymbol, moduleFile, program, isFromPackageJson) {
             if (++moduleCount % 100 === 0)
@@ -126902,11 +127024,11 @@ var ts;
             // Note: I think we shouldn't actually see resolved module symbols here, but weird merges
             // can cause it to happen: see 'completionsImport_mergedReExport.ts'
             if (defaultInfo && isImportableSymbol(defaultInfo.symbol, checker)) {
-                cache.add(importingFile.path, defaultInfo.symbol, defaultInfo.exportKind === 1 /* Default */ ? "default" /* Default */ : "export=" /* ExportEquals */, moduleSymbol, moduleFile, defaultInfo.exportKind, isFromPackageJson, scriptTarget, checker);
+                cache.add(importingFile.path, defaultInfo.symbol, defaultInfo.exportKind === 1 /* Default */ ? "default" /* Default */ : "export=" /* ExportEquals */, moduleSymbol, moduleFile, defaultInfo.exportKind, isFromPackageJson, checker);
             }
             checker.forEachExportAndPropertyOfModule(moduleSymbol, function (exported, key) {
                 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);
+                    cache.add(importingFile.path, exported, key, moduleSymbol, moduleFile, 0 /* Named */, isFromPackageJson, checker);
                 }
             });
         });
@@ -128980,6 +129102,8 @@ var ts;
             CompletionSource["ThisProperty"] = "ThisProperty/";
             /** Auto-import that comes attached to a class member snippet */
             CompletionSource["ClassMemberSnippet"] = "ClassMemberSnippet/";
+            /** A type-only import that needs to be promoted in order to be used at the completion location */
+            CompletionSource["TypeOnlyAlias"] = "TypeOnlyAlias/";
         })(CompletionSource = Completions.CompletionSource || (Completions.CompletionSource = {}));
         var SymbolOriginInfoKind;
         (function (SymbolOriginInfoKind) {
@@ -128989,6 +129113,7 @@ var ts;
             SymbolOriginInfoKind[SymbolOriginInfoKind["Promise"] = 8] = "Promise";
             SymbolOriginInfoKind[SymbolOriginInfoKind["Nullable"] = 16] = "Nullable";
             SymbolOriginInfoKind[SymbolOriginInfoKind["ResolvedExport"] = 32] = "ResolvedExport";
+            SymbolOriginInfoKind[SymbolOriginInfoKind["TypeOnlyAlias"] = 64] = "TypeOnlyAlias";
             SymbolOriginInfoKind[SymbolOriginInfoKind["SymbolMemberNoExport"] = 2] = "SymbolMemberNoExport";
             SymbolOriginInfoKind[SymbolOriginInfoKind["SymbolMemberExport"] = 6] = "SymbolMemberExport";
         })(SymbolOriginInfoKind || (SymbolOriginInfoKind = {}));
@@ -129016,6 +129141,9 @@ var ts;
         function originIsNullableMember(origin) {
             return !!(origin.kind & 16 /* Nullable */);
         }
+        function originIsTypeOnlyAlias(origin) {
+            return !!(origin && origin.kind & 64 /* TypeOnlyAlias */);
+        }
         var KeywordCompletionFilters;
         (function (KeywordCompletionFilters) {
             KeywordCompletionFilters[KeywordCompletionFilters["None"] = 0] = "None";
@@ -129420,6 +129548,9 @@ var ts;
                     isSnippet = preferences.includeCompletionsWithSnippetText ? true : undefined;
                 }
             }
+            if ((origin === null || origin === void 0 ? void 0 : origin.kind) === 64 /* TypeOnlyAlias */) {
+                hasAction = true;
+            }
             if (preferences.includeCompletionsWithClassMemberSnippets &&
                 preferences.includeCompletionsWithInsertText &&
                 completionKind === 3 /* MemberLike */ &&
@@ -129764,6 +129895,9 @@ var ts;
             if ((origin === null || origin === void 0 ? void 0 : origin.kind) === 1 /* ThisType */) {
                 return CompletionSource.ThisProperty;
             }
+            if ((origin === null || origin === void 0 ? void 0 : origin.kind) === 64 /* TypeOnlyAlias */) {
+                return CompletionSource.TypeOnlyAlias;
+            }
         }
         function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, sourceFile, host, program, target, log, kind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap, isJsxIdentifierExpected, isRightOfOpenTag) {
             var _a;
@@ -129791,7 +129925,7 @@ var ts;
                     continue;
                 }
                 /** True for locals; false for globals, module exports from other files, `this.` completions. */
-                var shouldShadowLaterSymbols = !origin && !(symbol.parent === undefined && !ts.some(symbol.declarations, function (d) { return d.getSourceFile() === location.getSourceFile(); }));
+                var shouldShadowLaterSymbols = (!origin || originIsTypeOnlyAlias(origin)) && !(symbol.parent === undefined && !ts.some(symbol.declarations, function (d) { return d.getSourceFile() === location.getSourceFile(); }));
                 uniques.set(name, shouldShadowLaterSymbols);
                 ts.insertSorted(entries, entry, compareCompletionEntries, /*allowDuplicates*/ true);
             }
@@ -129804,6 +129938,7 @@ var ts;
                 add: function (name) { return uniques.set(name, true); },
             };
             function shouldIncludeSymbol(symbol, symbolToSortTextIdMap) {
+                var allFlags = symbol.flags;
                 if (!ts.isSourceFile(location)) {
                     // export = /**/ here we want to get all meanings, so any symbol is ok
                     if (ts.isExportAssignment(location.parent)) {
@@ -129829,11 +129964,10 @@ var ts;
                             || symbolToSortTextIdMap[ts.getSymbolId(symbolOrigin)] === 11 /* LocationPriority */)) {
                         return false;
                     }
-                    // Continue with origin symbol
-                    symbol = symbolOrigin;
+                    allFlags |= ts.getCombinedLocalAndExportSymbolFlags(symbolOrigin);
                     // import m = /**/ <-- It can only access namespace (if typing import = x. this would get member symbols and not namespace)
                     if (ts.isInRightSideOfInternalImportEqualsDeclaration(location)) {
-                        return !!(symbol.flags & 1920 /* Namespace */);
+                        return !!(allFlags & 1920 /* Namespace */);
                     }
                     if (isTypeOnlyLocation) {
                         // It's a type, but you can reach it by namespace.type as well
@@ -129841,7 +129975,7 @@ var ts;
                     }
                 }
                 // expressions are value space (which includes the value namespaces)
-                return !!(ts.getCombinedLocalAndExportSymbolFlags(symbol) & 111551 /* Value */);
+                return !!(allFlags & 111551 /* Value */);
             }
         }
         Completions.getCompletionEntriesFromSymbols = getCompletionEntriesFromSymbols;
@@ -129975,8 +130109,7 @@ var ts;
         Completions.createCompletionDetails = createCompletionDetails;
         function getCompletionEntryCodeActionsAndSourceDisplay(name, location, contextToken, origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken, formatContext, preferences, data, source) {
             if (data === null || data === void 0 ? void 0 : data.moduleSpecifier) {
-                var _a = getRelevantTokens(position, sourceFile), contextToken_3 = _a.contextToken, previousToken_2 = _a.previousToken;
-                if (previousToken_2 && getImportStatementCompletionInfo(contextToken_3 || previousToken_2).replacementNode) {
+                if (previousToken && getImportStatementCompletionInfo(contextToken || previousToken).replacementNode) {
                     // Import statement completion: 'import c|'
                     return { codeActions: undefined, sourceDisplay: [ts.textPart(data.moduleSpecifier)] };
                 }
@@ -129994,13 +130127,19 @@ var ts;
                     };
                 }
             }
+            if (originIsTypeOnlyAlias(origin)) {
+                var codeAction_1 = ts.codefix.getPromoteTypeOnlyCompletionAction(sourceFile, origin.declaration.name, program, host, formatContext, preferences);
+                ts.Debug.assertIsDefined(codeAction_1, "Expected to have a code action for promoting type-only alias");
+                return { codeActions: [codeAction_1], sourceDisplay: undefined };
+            }
             if (!origin || !(originIsExport(origin) || originIsResolvedExport(origin))) {
                 return { codeActions: undefined, sourceDisplay: undefined };
             }
             var checker = origin.isFromPackageJson ? host.getPackageJsonAutoImportProvider().getTypeChecker() : program.getTypeChecker();
             var moduleSymbol = origin.moduleSymbol;
             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;
+            var isJsxOpeningTagName = (contextToken === null || contextToken === void 0 ? void 0 : contextToken.kind) === 29 /* LessThanToken */ && ts.isJsxOpeningLikeElement(contextToken.parent);
+            var _a = ts.codefix.getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, ts.getNameForExportedSymbol(symbol, ts.getEmitScriptTarget(compilerOptions), isJsxOpeningTagName), isJsxOpeningTagName, host, program, formatContext, previousToken && ts.isIdentifier(previousToken) ? previousToken.getStart(sourceFile) : position, preferences), moduleSpecifier = _a.moduleSpecifier, codeAction = _a.codeAction;
             ts.Debug.assert(!(data === null || data === void 0 ? void 0 : data.moduleSpecifier) || moduleSpecifier === data.moduleSpecifier);
             return { sourceDisplay: [ts.textPart(moduleSpecifier)], codeActions: [codeAction] };
         }
@@ -130670,21 +130809,29 @@ var ts;
                 var scopeNode = getScopeNode(contextToken, adjustedPosition, sourceFile) || sourceFile;
                 isInSnippetScope = isSnippetScope(scopeNode);
                 var symbolMeanings = (isTypeOnlyLocation ? 0 /* None */ : 111551 /* Value */) | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */;
+                var typeOnlyAliasNeedsPromotion = previousToken && !ts.isValidTypeOnlyAliasUseSite(previousToken);
                 symbols = ts.concatenate(symbols, typeChecker.getSymbolsInScope(scopeNode, symbolMeanings));
                 ts.Debug.assertEachIsDefined(symbols, "getSymbolsInScope() should all be defined");
-                for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {
-                    var symbol = symbols_1[_i];
+                for (var i = 0; i < symbols.length; i++) {
+                    var symbol = symbols[i];
                     if (!typeChecker.isArgumentsSymbol(symbol) &&
                         !ts.some(symbol.declarations, function (d) { return d.getSourceFile() === sourceFile; })) {
                         symbolToSortTextIdMap[ts.getSymbolId(symbol)] = 15 /* GlobalsOrKeywords */;
                     }
+                    if (typeOnlyAliasNeedsPromotion && !(symbol.flags & 111551 /* Value */)) {
+                        var typeOnlyAliasDeclaration = symbol.declarations && ts.find(symbol.declarations, ts.isTypeOnlyImportOrExportDeclaration);
+                        if (typeOnlyAliasDeclaration) {
+                            var origin = { kind: 64 /* TypeOnlyAlias */, declaration: typeOnlyAliasDeclaration };
+                            symbolToOriginInfoMap[i] = origin;
+                        }
+                    }
                 }
                 // Need to insert 'this.' before properties of `this` type, so only do that if `includeInsertTextCompletions`
                 if (preferences.includeCompletionsWithInsertText && scopeNode.kind !== 303 /* SourceFile */) {
                     var thisType = typeChecker.tryGetThisTypeAt(scopeNode, /*includeGlobalThis*/ false);
                     if (thisType && !isProbablyGlobalType(thisType, sourceFile, typeChecker)) {
-                        for (var _a = 0, _b = getPropertiesForCompletion(thisType, typeChecker); _a < _b.length; _a++) {
-                            var symbol = _b[_a];
+                        for (var _i = 0, _a = getPropertiesForCompletion(thisType, typeChecker); _i < _a.length; _i++) {
+                            var symbol = _a[_i];
                             symbolToOriginInfoMap[symbols.length] = { kind: 1 /* ThisType */ };
                             symbols.push(symbol);
                             symbolToSortTextIdMap[ts.getSymbolId(symbol)] = 14 /* SuggestedClassMembers */;
@@ -130787,7 +130934,8 @@ var ts;
                 var packageJsonAutoImportProvider = (_b = host.getPackageJsonAutoImportProvider) === null || _b === void 0 ? void 0 : _b.call(host);
                 var packageJsonFilter = detailsEntryId ? undefined : ts.createPackageJsonImportFilter(sourceFile, preferences, host);
                 resolvingModuleSpecifiers("collectAutoImports", host, program, sourceFile, preferences, !!importCompletionNode, function (context) {
-                    exportInfo.forEach(sourceFile.path, function (info, symbolName, isFromAmbientModule, exportMapKey) {
+                    exportInfo.forEach(sourceFile.path, function (info, getSymbolName, isFromAmbientModule, exportMapKey) {
+                        var symbolName = getSymbolName(/*preferCapitalized*/ isRightOfOpenTag);
                         if (!ts.isIdentifierText(symbolName, ts.getEmitScriptTarget(host.getCompilationSettings())))
                             return;
                         if (!detailsEntryId && ts.isStringANonContextualKeyword(symbolName))
@@ -130797,6 +130945,10 @@ var ts;
                             return;
                         if (isTypeOnlyLocation && !(info[0].targetFlags & (1536 /* Module */ | 788968 /* Type */)))
                             return;
+                        // Do not try to auto-import something with a lowercase first letter for a JSX tag
+                        var firstChar = symbolName.charCodeAt(0);
+                        if (isRightOfOpenTag && (firstChar < 65 /* A */ || firstChar > 90 /* Z */))
+                            return;
                         var isCompletionDetailsMatch = detailsEntryId && ts.some(info, function (i) { return detailsEntryId.source === ts.stripQuotes(i.moduleSymbol.name); });
                         if (isCompletionDetailsMatch || !detailsEntryId && charactersFuzzyMatchInString(symbolName, lowerCaseTokenText)) {
                             var defaultExportInfo = ts.find(info, isImportableExportInfo);
@@ -130873,16 +131025,19 @@ var ts;
                     return true;
                 }
                 if (contextToken.kind === 31 /* GreaterThanToken */ && contextToken.parent) {
+                    // <Component<string> /**/ />
+                    // <Component<string> /**/ ><Component>
+                    // - contextToken: GreaterThanToken (before cursor)
+                    // - location: JsxSelfClosingElement or JsxOpeningElement
+                    // - contextToken.parent === location
+                    if (location === contextToken.parent && (location.kind === 279 /* JsxOpeningElement */ || location.kind === 278 /* JsxSelfClosingElement */)) {
+                        return false;
+                    }
                     if (contextToken.parent.kind === 279 /* JsxOpeningElement */) {
-                        // Two possibilities:
-                        //   1. <div>/**/
-                        //      - contextToken: GreaterThanToken (before cursor)
-                        //      - location: JSXElement
-                        //      - different parents (JSXOpeningElement, JSXElement)
-                        //   2. <Component<string> /**/>
-                        //      - contextToken: GreaterThanToken (before cursor)
-                        //      - location: GreaterThanToken (after cursor)
-                        //      - same parent (JSXOpeningElement)
+                        // <div>/**/
+                        // - contextToken: GreaterThanToken (before cursor)
+                        // - location: JSXElement
+                        // - different parents (JSXOpeningElement, JSXElement)
                         return location.parent.kind !== 279 /* JsxOpeningElement */;
                     }
                     if (contextToken.parent.kind === 280 /* JsxClosingElement */ || contextToken.parent.kind === 278 /* JsxSelfClosingElement */) {
@@ -132083,10 +132238,14 @@ var ts;
         /** True if symbol is a type or a module containing at least one type. */
         function symbolCanBeReferencedAtTypeLocation(symbol, checker, seenModules) {
             if (seenModules === void 0) { seenModules = new ts.Map(); }
-            var sym = ts.skipAlias(symbol.exportSymbol || symbol, checker);
-            return !!(sym.flags & 788968 /* Type */) || checker.isUnknownSymbol(sym) ||
-                !!(sym.flags & 1536 /* Module */) && ts.addToSeen(seenModules, ts.getSymbolId(sym)) &&
-                    checker.getExportsOfModule(sym).some(function (e) { return symbolCanBeReferencedAtTypeLocation(e, checker, seenModules); });
+            // Since an alias can be merged with a local declaration, we need to test both the alias and its target.
+            // This code used to just test the result of `skipAlias`, but that would ignore any locally introduced meanings.
+            return nonAliasCanBeReferencedAtTypeLocation(symbol) || nonAliasCanBeReferencedAtTypeLocation(ts.skipAlias(symbol.exportSymbol || symbol, checker));
+            function nonAliasCanBeReferencedAtTypeLocation(symbol) {
+                return !!(symbol.flags & 788968 /* Type */) || checker.isUnknownSymbol(symbol) ||
+                    !!(symbol.flags & 1536 /* Module */) && ts.addToSeen(seenModules, ts.getSymbolId(symbol)) &&
+                        checker.getExportsOfModule(symbol).some(function (e) { return symbolCanBeReferencedAtTypeLocation(e, checker, seenModules); });
+            }
         }
         function isDeprecated(symbol, checker) {
             var declarations = ts.skipAlias(symbol, checker).declarations;
@@ -134340,8 +134499,8 @@ var ts;
                     var sourceId = ts.getNodeId(sourceFile);
                     var seenSymbols = this.sourceFileToSeenSymbols[sourceId] || (this.sourceFileToSeenSymbols[sourceId] = new ts.Set());
                     var anyNewSymbols = false;
-                    for (var _i = 0, symbols_2 = symbols; _i < symbols_2.length; _i++) {
-                        var sym = symbols_2[_i];
+                    for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {
+                        var sym = symbols_1[_i];
                         anyNewSymbols = ts.tryAddToSet(seenSymbols, ts.getSymbolId(sym)) || anyNewSymbols;
                     }
                     return anyNewSymbols;
@@ -141301,6 +141460,8 @@ var ts;
             }
             if (flags & 16 /* Function */)
                 return isLocalVariableOrFunction(symbol) ? "local function" /* localFunctionElement */ : "function" /* functionElement */;
+            // FIXME: getter and setter use the same symbol. And it is rare to use only setter without getter, so in most cases the symbol always has getter flag.
+            // So, even when the location is just on the declaration of setter, this function returns getter.
             if (flags & 32768 /* GetAccessor */)
                 return "getter" /* memberGetAccessorElement */;
             if (flags & 65536 /* SetAccessor */)
@@ -141387,9 +141548,24 @@ var ts;
             }
             // Class at constructor site need to be shown as constructor apart from property,method, vars
             if (symbolKind !== "" /* unknown */ || symbolFlags & 32 /* Class */ || symbolFlags & 2097152 /* Alias */) {
-                // If it is accessor they are allowed only if location is at name of the accessor
+                // If symbol is accessor, they are allowed only if location is at declaration identifier of the accessor
                 if (symbolKind === "getter" /* memberGetAccessorElement */ || symbolKind === "setter" /* memberSetAccessorElement */) {
-                    symbolKind = "property" /* memberVariableElement */;
+                    var declaration = ts.find(symbol.declarations, function (declaration) { return declaration.name === location; });
+                    if (declaration) {
+                        switch (declaration.kind) {
+                            case 171 /* GetAccessor */:
+                                symbolKind = "getter" /* memberGetAccessorElement */;
+                                break;
+                            case 172 /* SetAccessor */:
+                                symbolKind = "setter" /* memberSetAccessorElement */;
+                                break;
+                            default:
+                                ts.Debug.assertNever(declaration);
+                        }
+                    }
+                    else {
+                        symbolKind = "property" /* memberVariableElement */;
+                    }
                 }
                 var signature = void 0;
                 type = isThisExpression ? typeChecker.getTypeAtLocation(location) : typeChecker.getTypeOfSymbolAtLocation(symbol, location);
@@ -141703,6 +141879,8 @@ var ts;
                         }
                         // For properties, variables and local vars: show the type
                         if (symbolKind === "property" /* memberVariableElement */ ||
+                            symbolKind === "getter" /* memberGetAccessorElement */ ||
+                            symbolKind === "setter" /* memberSetAccessorElement */ ||
                             symbolKind === "JSX attribute" /* jsxAttribute */ ||
                             symbolFlags & 3 /* Variable */ ||
                             symbolKind === "local var" /* localVariableElement */ ||
@@ -141773,7 +141951,7 @@ var ts;
                 }
             }
             if (tags.length === 0 && !hasMultipleSignatures) {
-                tags = symbol.getJsDocTags(typeChecker);
+                tags = symbol.getContextualJsDocTags(enclosingDeclaration, typeChecker);
             }
             if (documentation.length === 0 && documentationFromAlias) {
                 documentation = documentationFromAlias;
@@ -145193,6 +145371,7 @@ var ts;
             ChangeTracker.prototype.delete = function (sourceFile, node) {
                 this.deletedNodes.push({ sourceFile: sourceFile, node: node });
             };
+            /** Stop! Consider using `delete` instead, which has logic for deleting nodes from delimited lists. */
             ChangeTracker.prototype.deleteNode = function (sourceFile, node, options) {
                 if (options === void 0) { options = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }; }
                 this.deleteRange(sourceFile, getAdjustedRange(sourceFile, node, node, options));
@@ -145596,6 +145775,15 @@ var ts;
             ChangeTracker.prototype.insertExportModifier = function (sourceFile, node) {
                 this.insertText(sourceFile, node.getStart(sourceFile), "export ");
             };
+            ChangeTracker.prototype.insertImportSpecifierAtIndex = function (sourceFile, importSpecifier, namedImports, index) {
+                var prevSpecifier = namedImports.elements[index - 1];
+                if (prevSpecifier) {
+                    this.insertNodeInListAfter(sourceFile, prevSpecifier, importSpecifier);
+                }
+                else {
+                    this.insertNodeBefore(sourceFile, namedImports.elements[0], importSpecifier, !ts.positionsAreOnSameLine(namedImports.elements[0].getStart(), namedImports.parent.parent.getStart(), sourceFile));
+                }
+            };
             /**
              * This function should be used to insert nodes in lists when nodes don't carry separators as the part of the node range,
              * i.e. arguments in arguments lists, parameters in parameter lists etc.
@@ -149098,7 +149286,8 @@ var ts;
             ts.Diagnostics.Cannot_find_namespace_0.code,
             ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code,
             ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here.code,
-            ts.Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer.code
+            ts.Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer.code,
+            ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type.code,
         ];
         codefix.registerCodeFix({
             errorCodes: errorCodes,
@@ -149144,7 +149333,7 @@ var ts;
                 var symbolName = ts.getNameForExportedSymbol(exportedSymbol, ts.getEmitScriptTarget(compilerOptions));
                 var checker = program.getTypeChecker();
                 var symbol = checker.getMergedSymbol(ts.skipAlias(exportedSymbol, checker));
-                var exportInfos = getAllReExportingModules(sourceFile, symbol, moduleSymbol, symbolName, host, program, preferences, useAutoImportProvider);
+                var exportInfos = getAllReExportingModules(sourceFile, symbol, moduleSymbol, symbolName, /*isJsxTagName*/ false, host, program, preferences, useAutoImportProvider);
                 var useRequire = shouldUseRequire(sourceFile, program);
                 var fix = getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, /*position*/ undefined, !!isValidTypeOnlyUseSite, useRequire, host, preferences);
                 if (fix) {
@@ -149203,6 +149392,9 @@ var ts;
                         }
                         break;
                     }
+                    case 4 /* PromoteTypeOnly */:
+                        // Excluding from fix-all
+                        break;
                     default:
                         ts.Debug.assertNever(fix, "fix wasn't never - got kind " + fix.kind);
                 }
@@ -149294,6 +149486,7 @@ var ts;
             ImportFixKind[ImportFixKind["JsdocTypeImport"] = 1] = "JsdocTypeImport";
             ImportFixKind[ImportFixKind["AddToExisting"] = 2] = "AddToExisting";
             ImportFixKind[ImportFixKind["AddNew"] = 3] = "AddNew";
+            ImportFixKind[ImportFixKind["PromoteTypeOnly"] = 4] = "PromoteTypeOnly";
         })(ImportFixKind || (ImportFixKind = {}));
         // These should not be combined as bitflags, but are given powers of 2 values to
         // easily detect conflicts between `NotAllowed` and `Required` by giving them a unique sum.
@@ -149305,11 +149498,11 @@ var ts;
             AddAsTypeOnly[AddAsTypeOnly["Required"] = 2] = "Required";
             AddAsTypeOnly[AddAsTypeOnly["NotAllowed"] = 4] = "NotAllowed";
         })(AddAsTypeOnly || (AddAsTypeOnly = {}));
-        function getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, symbolName, host, program, formatContext, position, preferences) {
+        function getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, symbolName, isJsxTagName, host, program, formatContext, position, preferences) {
             var compilerOptions = program.getCompilerOptions();
             var exportInfos = ts.pathIsBareSpecifier(ts.stripQuotes(moduleSymbol.name))
                 ? [getSymbolExportInfoForSymbol(targetSymbol, moduleSymbol, program, host)]
-                : getAllReExportingModules(sourceFile, targetSymbol, moduleSymbol, symbolName, host, program, preferences, /*useAutoImportProvider*/ true);
+                : getAllReExportingModules(sourceFile, targetSymbol, moduleSymbol, symbolName, isJsxTagName, 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));
@@ -149319,6 +149512,13 @@ var ts;
             };
         }
         codefix.getImportCompletionAction = getImportCompletionAction;
+        function getPromoteTypeOnlyCompletionAction(sourceFile, symbolToken, program, host, formatContext, preferences) {
+            var compilerOptions = program.getCompilerOptions();
+            var symbolName = getSymbolName(sourceFile, program.getTypeChecker(), symbolToken, compilerOptions);
+            var fix = getTypeOnlyPromotionFix(sourceFile, symbolToken, symbolName, program);
+            return fix && codeFixActionToCodeAction(codeActionForFix({ host: host, formatContext: formatContext, preferences: preferences }, sourceFile, symbolName, fix, 1 /* Double */, compilerOptions));
+        }
+        codefix.getPromoteTypeOnlyCompletionAction = getPromoteTypeOnlyCompletionAction;
         function getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences) {
             ts.Debug.assert(exportInfos.some(function (info) { return info.moduleSymbol === moduleSymbol || info.symbol.parent === moduleSymbol; }), "Some exportInfo should match the specified moduleSymbol");
             var packageJsonImportFilter = ts.createPackageJsonImportFilter(sourceFile, preferences, host);
@@ -149348,7 +149548,7 @@ var ts;
                 }
             }
         }
-        function getAllReExportingModules(importingFile, targetSymbol, exportingModuleSymbol, symbolName, host, program, preferences, useAutoImportProvider) {
+        function getAllReExportingModules(importingFile, targetSymbol, exportingModuleSymbol, symbolName, isJsxTagName, host, program, preferences, useAutoImportProvider) {
             var result = [];
             var compilerOptions = program.getCompilerOptions();
             var getModuleSpecifierResolutionHost = ts.memoizeOne(function (isFromPackageJson) {
@@ -149361,7 +149561,7 @@ 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) === targetSymbol && isImportable(program, moduleFile, isFromPackageJson)) {
+                if (defaultInfo && (defaultInfo.name === symbolName || moduleSymbolToValidIdentifier(moduleSymbol, ts.getEmitScriptTarget(compilerOptions), isJsxTagName) === 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++) {
@@ -149599,9 +149799,21 @@ var ts;
         }
         function getFixesInfo(context, errorCode, pos, useAutoImportProvider) {
             var symbolToken = ts.getTokenAtPosition(context.sourceFile, pos);
-            var info = errorCode === ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code
-                ? getFixesInfoForUMDImport(context, symbolToken)
-                : ts.isIdentifier(symbolToken) ? getFixesInfoForNonUMDImport(context, symbolToken, useAutoImportProvider) : undefined;
+            var info;
+            if (errorCode === ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code) {
+                info = getFixesInfoForUMDImport(context, symbolToken);
+            }
+            else if (!ts.isIdentifier(symbolToken)) {
+                return undefined;
+            }
+            else if (errorCode === ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type.code) {
+                var symbolName_1 = getSymbolName(context.sourceFile, context.program.getTypeChecker(), symbolToken, context.program.getCompilerOptions());
+                var fix = getTypeOnlyPromotionFix(context.sourceFile, symbolToken, symbolName_1, context.program);
+                return fix && { fixes: [fix], symbolName: symbolName_1 };
+            }
+            else {
+                info = getFixesInfoForNonUMDImport(context, symbolToken, useAutoImportProvider);
+            }
             var packageJsonImportFilter = ts.createPackageJsonImportFilter(context.sourceFile, context.preferences, context.host);
             return info && __assign(__assign({}, info), { fixes: sortFixes(info.fixes, context.sourceFile, context.program, packageJsonImportFilter) });
         }
@@ -149718,13 +149930,23 @@ var ts;
             ts.Debug.assert(symbolName !== "default" /* Default */, "'default' isn't a legal identifier and couldn't occur here");
             var isValidTypeOnlyUseSite = ts.isValidTypeOnlyAliasUseSite(symbolToken);
             var useRequire = shouldUseRequire(sourceFile, program);
-            var exportInfos = getExportInfos(symbolName, ts.getMeaningFromLocation(symbolToken), cancellationToken, sourceFile, program, useAutoImportProvider, host, preferences);
+            var exportInfos = getExportInfos(symbolName, ts.isJSXTagName(symbolToken), ts.getMeaningFromLocation(symbolToken), cancellationToken, sourceFile, program, useAutoImportProvider, host, preferences);
             var fixes = ts.arrayFrom(ts.flatMapIterator(exportInfos.entries(), function (_a) {
                 var _ = _a[0], exportInfos = _a[1];
                 return getImportFixes(exportInfos, symbolName, symbolToken.getStart(sourceFile), isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences);
             }));
             return { fixes: fixes, symbolName: symbolName };
         }
+        function getTypeOnlyPromotionFix(sourceFile, symbolToken, symbolName, program) {
+            var checker = program.getTypeChecker();
+            var symbol = checker.resolveName(symbolName, symbolToken, 111551 /* Value */, /*excludeGlobals*/ true);
+            if (!symbol)
+                return undefined;
+            var typeOnlyAliasDeclaration = checker.getTypeOnlyAliasDeclaration(symbol);
+            if (!typeOnlyAliasDeclaration || ts.getSourceFileOfNode(typeOnlyAliasDeclaration) !== sourceFile)
+                return undefined;
+            return { kind: 4 /* PromoteTypeOnly */, typeOnlyAliasDeclaration: typeOnlyAliasDeclaration };
+        }
         function jsxModeNeedsExplicitImport(jsx) {
             return jsx === 2 /* React */ || jsx === 3 /* ReactNative */;
         }
@@ -149732,14 +149954,20 @@ var ts;
             var parent = symbolToken.parent;
             if ((ts.isJsxOpeningLikeElement(parent) || ts.isJsxClosingElement(parent)) && parent.tagName === symbolToken && jsxModeNeedsExplicitImport(compilerOptions.jsx)) {
                 var jsxNamespace = checker.getJsxNamespace(sourceFile);
-                if (ts.isIntrinsicJsxName(symbolToken.text) || !checker.resolveName(jsxNamespace, parent, 111551 /* Value */, /*excludeGlobals*/ true)) {
+                if (needsJsxNamespaceFix(jsxNamespace, symbolToken, checker)) {
                     return jsxNamespace;
                 }
             }
             return symbolToken.text;
         }
+        function needsJsxNamespaceFix(jsxNamespace, symbolToken, checker) {
+            if (ts.isIntrinsicJsxName(symbolToken.text))
+                return true; // If we were triggered by a matching error code on an intrinsic, the error must have been about missing the JSX factory
+            var namespaceSymbol = checker.resolveName(jsxNamespace, symbolToken, 111551 /* Value */, /*excludeGlobals*/ true);
+            return !namespaceSymbol || ts.some(namespaceSymbol.declarations, ts.isTypeOnlyImportOrExportDeclaration) && !(namespaceSymbol.flags & 111551 /* Value */);
+        }
         // Returns a map from an exported symbol's ID to a list of every way it's (re-)exported.
-        function getExportInfos(symbolName, currentTokenMeaning, cancellationToken, fromFile, program, useAutoImportProvider, host, preferences) {
+        function getExportInfos(symbolName, isJsxTagName, currentTokenMeaning, cancellationToken, fromFile, program, useAutoImportProvider, host, preferences) {
             var _a;
             // For each original symbol, keep all re-exports of that symbol together so we can call `getCodeActionsForImport` on the whole group at once.
             // Maps symbol id to info for modules providing that symbol (original export + re-exports).
@@ -149762,7 +149990,7 @@ var ts;
                 cancellationToken.throwIfCancellationRequested();
                 var compilerOptions = program.getCompilerOptions();
                 var defaultInfo = ts.getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions);
-                if (defaultInfo && (defaultInfo.name === symbolName || moduleSymbolToValidIdentifier(moduleSymbol, ts.getEmitScriptTarget(compilerOptions)) === symbolName) && symbolHasMeaning(defaultInfo.symbolForMeaning, currentTokenMeaning)) {
+                if (defaultInfo && (defaultInfo.name === symbolName || moduleSymbolToValidIdentifier(moduleSymbol, ts.getEmitScriptTarget(compilerOptions), isJsxTagName) === symbolName) && symbolHasMeaning(defaultInfo.symbolForMeaning, currentTokenMeaning)) {
                     addSymbol(moduleSymbol, sourceFile, defaultInfo.symbol, defaultInfo.exportKind, program, isFromPackageJson);
                 }
                 // check exports with the same name
@@ -149836,10 +150064,80 @@ var ts;
                     ts.insertImports(changes, sourceFile, getDeclarations(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport), /*blankLineBetween*/ true);
                     return [importKind === 1 /* Default */ ? ts.Diagnostics.Import_default_0_from_module_1 : ts.Diagnostics.Import_0_from_module_1, symbolName, moduleSpecifier];
                 }
+                case 4 /* PromoteTypeOnly */: {
+                    var typeOnlyAliasDeclaration = fix.typeOnlyAliasDeclaration;
+                    var promotedDeclaration = promoteFromTypeOnly(changes, typeOnlyAliasDeclaration, compilerOptions, sourceFile);
+                    return promotedDeclaration.kind === 269 /* ImportSpecifier */
+                        ? [ts.Diagnostics.Remove_type_from_import_of_0_from_1, symbolName, getModuleSpecifierText(promotedDeclaration.parent.parent)]
+                        : [ts.Diagnostics.Remove_type_from_import_declaration_from_0, getModuleSpecifierText(promotedDeclaration)];
+                }
                 default:
                     return ts.Debug.assertNever(fix, "Unexpected fix kind " + fix.kind);
             }
         }
+        function getModuleSpecifierText(promotedDeclaration) {
+            var _a, _b;
+            return promotedDeclaration.kind === 264 /* ImportEqualsDeclaration */
+                ? ((_b = ts.tryCast((_a = ts.tryCast(promotedDeclaration.moduleReference, ts.isExternalModuleReference)) === null || _a === void 0 ? void 0 : _a.expression, ts.isStringLiteralLike)) === null || _b === void 0 ? void 0 : _b.text) || promotedDeclaration.moduleReference.getText()
+                : ts.cast(promotedDeclaration.parent.moduleSpecifier, ts.isStringLiteral).text;
+        }
+        function promoteFromTypeOnly(changes, aliasDeclaration, compilerOptions, sourceFile) {
+            // See comment in `doAddExistingFix` on constant with the same name.
+            var convertExistingToTypeOnly = compilerOptions.preserveValueImports && compilerOptions.isolatedModules;
+            switch (aliasDeclaration.kind) {
+                case 269 /* ImportSpecifier */:
+                    if (aliasDeclaration.isTypeOnly) {
+                        if (aliasDeclaration.parent.elements.length > 1 && ts.OrganizeImports.importSpecifiersAreSorted(aliasDeclaration.parent.elements)) {
+                            changes.delete(sourceFile, aliasDeclaration);
+                            var newSpecifier = ts.factory.updateImportSpecifier(aliasDeclaration, /*isTypeOnly*/ false, aliasDeclaration.propertyName, aliasDeclaration.name);
+                            var insertionIndex = ts.OrganizeImports.getImportSpecifierInsertionIndex(aliasDeclaration.parent.elements, newSpecifier);
+                            changes.insertImportSpecifierAtIndex(sourceFile, newSpecifier, aliasDeclaration.parent, insertionIndex);
+                        }
+                        else {
+                            changes.deleteRange(sourceFile, aliasDeclaration.getFirstToken());
+                        }
+                        return aliasDeclaration;
+                    }
+                    else {
+                        ts.Debug.assert(aliasDeclaration.parent.parent.isTypeOnly);
+                        promoteImportClause(aliasDeclaration.parent.parent);
+                        return aliasDeclaration.parent.parent;
+                    }
+                case 266 /* ImportClause */:
+                    promoteImportClause(aliasDeclaration);
+                    return aliasDeclaration;
+                case 267 /* NamespaceImport */:
+                    promoteImportClause(aliasDeclaration.parent);
+                    return aliasDeclaration.parent;
+                case 264 /* ImportEqualsDeclaration */:
+                    changes.deleteRange(sourceFile, aliasDeclaration.getChildAt(1));
+                    return aliasDeclaration;
+                default:
+                    ts.Debug.failBadSyntaxKind(aliasDeclaration);
+            }
+            function promoteImportClause(importClause) {
+                changes.delete(sourceFile, ts.getTypeKeywordOfTypeOnlyImport(importClause, sourceFile));
+                if (convertExistingToTypeOnly) {
+                    var namedImports = ts.tryCast(importClause.namedBindings, ts.isNamedImports);
+                    if (namedImports && namedImports.elements.length > 1) {
+                        if (ts.OrganizeImports.importSpecifiersAreSorted(namedImports.elements) &&
+                            aliasDeclaration.kind === 269 /* ImportSpecifier */ &&
+                            namedImports.elements.indexOf(aliasDeclaration) !== 0) {
+                            // The import specifier being promoted will be the only non-type-only,
+                            //  import in the NamedImports, so it should be moved to the front.
+                            changes.delete(sourceFile, aliasDeclaration);
+                            changes.insertImportSpecifierAtIndex(sourceFile, aliasDeclaration, namedImports, 0);
+                        }
+                        for (var _i = 0, _a = namedImports.elements; _i < _a.length; _i++) {
+                            var element = _a[_i];
+                            if (element !== aliasDeclaration && !element.isTypeOnly) {
+                                changes.insertModifierBefore(sourceFile, 151 /* TypeKeyword */, element);
+                            }
+                        }
+                    }
+                }
+            }
+        }
         function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImports, compilerOptions) {
             var _a;
             if (clause.kind === 200 /* ObjectBindingPattern */) {
@@ -149877,13 +150175,7 @@ var ts;
                         var insertionIndex = convertExistingToTypeOnly && !spec.isTypeOnly
                             ? 0
                             : ts.OrganizeImports.getImportSpecifierInsertionIndex(existingSpecifiers, spec);
-                        var prevSpecifier = clause.namedBindings.elements[insertionIndex - 1];
-                        if (prevSpecifier) {
-                            changes.insertNodeInListAfter(sourceFile, prevSpecifier, spec);
-                        }
-                        else {
-                            changes.insertNodeBefore(sourceFile, existingSpecifiers[0], spec, !ts.positionsAreOnSameLine(existingSpecifiers[0].getStart(), clause.parent.getStart(), sourceFile));
-                        }
+                        changes.insertImportSpecifierAtIndex(sourceFile, spec, clause.namedBindings, insertionIndex);
                     }
                 }
                 else if (existingSpecifiers === null || existingSpecifiers === void 0 ? void 0 : existingSpecifiers.length) {
@@ -149998,17 +150290,20 @@ var ts;
             var declarations = _a.declarations;
             return ts.some(declarations, function (decl) { return !!(ts.getMeaningFromDeclaration(decl) & meaning); });
         }
-        function moduleSymbolToValidIdentifier(moduleSymbol, target) {
-            return moduleSpecifierToValidIdentifier(ts.removeFileExtension(ts.stripQuotes(moduleSymbol.name)), target);
+        function moduleSymbolToValidIdentifier(moduleSymbol, target, forceCapitalize) {
+            return moduleSpecifierToValidIdentifier(ts.removeFileExtension(ts.stripQuotes(moduleSymbol.name)), target, forceCapitalize);
         }
         codefix.moduleSymbolToValidIdentifier = moduleSymbolToValidIdentifier;
-        function moduleSpecifierToValidIdentifier(moduleSpecifier, target) {
+        function moduleSpecifierToValidIdentifier(moduleSpecifier, target, forceCapitalize) {
             var baseName = ts.getBaseFileName(ts.removeSuffix(moduleSpecifier, "/index"));
             var res = "";
             var lastCharWasValid = true;
             var firstCharCode = baseName.charCodeAt(0);
             if (ts.isIdentifierStart(firstCharCode, target)) {
                 res += String.fromCharCode(firstCharCode);
+                if (forceCapitalize) {
+                    res = res.toUpperCase();
+                }
             }
             else {
                 lastCharWasValid = false;
@@ -159977,13 +160272,11 @@ var ts;
             switch (context === null || context === void 0 ? void 0 : context.kind) {
                 case 171 /* GetAccessor */:
                     if (!this.contextualGetAccessorDocumentationComment) {
-                        this.contextualGetAccessorDocumentationComment = ts.emptyArray;
                         this.contextualGetAccessorDocumentationComment = getDocumentationComment(ts.filter(this.declarations, ts.isGetAccessor), checker);
                     }
                     return this.contextualGetAccessorDocumentationComment;
                 case 172 /* SetAccessor */:
                     if (!this.contextualSetAccessorDocumentationComment) {
-                        this.contextualSetAccessorDocumentationComment = ts.emptyArray;
                         this.contextualSetAccessorDocumentationComment = getDocumentationComment(ts.filter(this.declarations, ts.isSetAccessor), checker);
                     }
                     return this.contextualSetAccessorDocumentationComment;
@@ -159993,10 +160286,26 @@ var ts;
         };
         SymbolObject.prototype.getJsDocTags = function (checker) {
             if (this.tags === undefined) {
-                this.tags = ts.JsDoc.getJsDocTagsFromDeclarations(this.declarations, checker);
+                this.tags = getJsDocTagsOfDeclarations(this.declarations, checker);
             }
             return this.tags;
         };
+        SymbolObject.prototype.getContextualJsDocTags = function (context, checker) {
+            switch (context === null || context === void 0 ? void 0 : context.kind) {
+                case 171 /* GetAccessor */:
+                    if (!this.contextualGetAccessorTags) {
+                        this.contextualGetAccessorTags = getJsDocTagsOfDeclarations(ts.filter(this.declarations, ts.isGetAccessor), checker);
+                    }
+                    return this.contextualGetAccessorTags;
+                case 172 /* SetAccessor */:
+                    if (!this.contextualSetAccessorTags) {
+                        this.contextualSetAccessorTags = getJsDocTagsOfDeclarations(ts.filter(this.declarations, ts.isSetAccessor), checker);
+                    }
+                    return this.contextualSetAccessorTags;
+                default:
+                    return this.getJsDocTags(checker);
+            }
+        };
         return SymbolObject;
     }());
     var TokenObject = /** @class */ (function (_super) {
@@ -160166,10 +160475,7 @@ var ts;
             return this.documentationComment || (this.documentationComment = getDocumentationComment(ts.singleElementArray(this.declaration), this.checker));
         };
         SignatureObject.prototype.getJsDocTags = function () {
-            if (this.jsDocTags === undefined) {
-                this.jsDocTags = this.declaration ? getJsDocTagsOfSignature(this.declaration, this.checker) : [];
-            }
-            return this.jsDocTags;
+            return this.jsDocTags || (this.jsDocTags = getJsDocTagsOfDeclarations(ts.singleElementArray(this.declaration), this.checker));
         };
         return SignatureObject;
     }());
@@ -160181,12 +160487,30 @@ var ts;
     function hasJSDocInheritDocTag(node) {
         return ts.getJSDocTags(node).some(function (tag) { return tag.tagName.text === "inheritDoc"; });
     }
-    function getJsDocTagsOfSignature(declaration, checker) {
-        var tags = ts.JsDoc.getJsDocTagsFromDeclarations([declaration], checker);
-        if (tags.length === 0 || hasJSDocInheritDocTag(declaration)) {
-            var inheritedTags = findBaseOfDeclaration(checker, declaration, function (symbol) { var _a; return ((_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.length) === 1 ? symbol.getJsDocTags() : undefined; });
-            if (inheritedTags) {
-                tags = __spreadArray(__spreadArray([], inheritedTags, true), tags, true);
+    function getJsDocTagsOfDeclarations(declarations, checker) {
+        if (!declarations)
+            return ts.emptyArray;
+        var tags = ts.JsDoc.getJsDocTagsFromDeclarations(declarations, checker);
+        if (checker && (tags.length === 0 || declarations.some(hasJSDocInheritDocTag))) {
+            var seenSymbols_1 = new ts.Set();
+            var _loop_22 = function (declaration) {
+                var inheritedTags = findBaseOfDeclaration(checker, declaration, function (symbol) {
+                    var _a;
+                    if (!seenSymbols_1.has(symbol)) {
+                        seenSymbols_1.add(symbol);
+                        if (declaration.kind === 171 /* GetAccessor */ || declaration.kind === 172 /* SetAccessor */) {
+                            return symbol.getContextualJsDocTags(declaration, checker);
+                        }
+                        return ((_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.length) === 1 ? symbol.getJsDocTags() : undefined;
+                    }
+                });
+                if (inheritedTags) {
+                    tags = __spreadArray(__spreadArray([], inheritedTags, true), tags, true);
+                }
+            };
+            for (var _i = 0, declarations_6 = declarations; _i < declarations_6.length; _i++) {
+                var declaration = declarations_6[_i];
+                _loop_22(declaration);
             }
         }
         return tags;
@@ -160196,18 +160520,24 @@ var ts;
             return ts.emptyArray;
         var doc = ts.JsDoc.getJsDocCommentsFromDeclarations(declarations, checker);
         if (checker && (doc.length === 0 || declarations.some(hasJSDocInheritDocTag))) {
-            var seenSymbols_1 = new ts.Set();
-            for (var _i = 0, declarations_6 = declarations; _i < declarations_6.length; _i++) {
-                var declaration = declarations_6[_i];
+            var seenSymbols_2 = new ts.Set();
+            var _loop_23 = function (declaration) {
                 var inheritedDocs = findBaseOfDeclaration(checker, declaration, function (symbol) {
-                    if (!seenSymbols_1.has(symbol)) {
-                        seenSymbols_1.add(symbol);
+                    if (!seenSymbols_2.has(symbol)) {
+                        seenSymbols_2.add(symbol);
+                        if (declaration.kind === 171 /* GetAccessor */ || declaration.kind === 172 /* SetAccessor */) {
+                            return symbol.getContextualDocumentationComment(declaration, checker);
+                        }
                         return symbol.getDocumentationComment(checker);
                     }
                 });
                 // TODO: GH#16312 Return a ReadonlyArray, avoid copying inheritedDocs
                 if (inheritedDocs)
                     doc = doc.length === 0 ? inheritedDocs.slice() : inheritedDocs.concat(ts.lineBreakPart(), doc);
+            };
+            for (var _i = 0, declarations_7 = declarations; _i < declarations_7.length; _i++) {
+                var declaration = declarations_7[_i];
+                _loop_23(declaration);
             }
         }
         return doc;