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

package/lib/typingsInstaller.js

@@ -89,7 +89,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.20220121";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220127";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -100,13 +100,18 @@ var ts;
     /* @internal */
     var NativeCollections;
     (function (NativeCollections) {
+        var globals = typeof globalThis !== "undefined" ? globalThis :
+            typeof global !== "undefined" ? global :
+                typeof self !== "undefined" ? self :
+                    undefined;
         /**
          * Returns the native Map implementation if it is available and compatible (i.e. supports iteration).
          */
         function tryGetNativeMap() {
             // Internet Explorer's Map doesn't support iteration, so don't use it.
+            var gMap = globals === null || globals === void 0 ? void 0 : globals.Map;
             // eslint-disable-next-line no-in-operator
-            return typeof Map !== "undefined" && "entries" in Map.prototype && new Map([[0, 0]]).size === 1 ? Map : undefined;
+            return typeof gMap !== "undefined" && "entries" in gMap.prototype && new gMap([[0, 0]]).size === 1 ? gMap : undefined;
         }
         NativeCollections.tryGetNativeMap = tryGetNativeMap;
         /**
@@ -114,8 +119,9 @@ var ts;
          */
         function tryGetNativeSet() {
             // Internet Explorer's Set doesn't support iteration, so don't use it.
+            var gSet = globals === null || globals === void 0 ? void 0 : globals.Set;
             // eslint-disable-next-line no-in-operator
-            return typeof Set !== "undefined" && "entries" in Set.prototype && new Set([0]).size === 1 ? Set : undefined;
+            return typeof gSet !== "undefined" && "entries" in gSet.prototype && new gSet([0]).size === 1 ? gSet : undefined;
         }
         NativeCollections.tryGetNativeSet = tryGetNativeSet;
     })(NativeCollections || (NativeCollections = {}));
@@ -4901,13 +4907,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";
@@ -8513,6 +8520,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."),
@@ -9456,6 +9464,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}"),
@@ -13396,6 +13406,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;
@@ -14046,10 +14057,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) {
@@ -14882,6 +14896,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,
@@ -15050,7 +15073,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 '/**/'
@@ -15084,7 +15108,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
@@ -15121,7 +15145,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 */:
@@ -15824,7 +15848,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:
@@ -22758,16 +22782,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
@@ -29883,7 +29909,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 */:
@@ -32416,7 +32443,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();
@@ -33355,7 +33384,7 @@ var ts;
         function parseInitializer() {
             return parseOptional(63 /* EqualsToken */) ? parseAssignmentExpressionOrHigher() : undefined;
         }
-        function parseAssignmentExpressionOrHigher(parsingConditionalTrueSide) {
+        function parseAssignmentExpressionOrHigher() {
             //  AssignmentExpression[in,yield]:
             //      1) ConditionalExpression[?in,?yield]
             //      2) LeftHandSideExpression = AssignmentExpression[?in,?yield]
@@ -33381,7 +33410,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(parsingConditionalTrueSide) || tryParseAsyncSimpleArrowFunctionExpression();
+            var arrowExpression = tryParseParenthesizedArrowFunctionExpression() || tryParseAsyncSimpleArrowFunctionExpression();
             if (arrowExpression) {
                 return arrowExpression;
             }
@@ -33400,7 +33429,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, parsingConditionalTrueSide);
+                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
@@ -33460,7 +33489,7 @@ var ts;
                 return finishNode(factory.createYieldExpression(/*asteriskToken*/ undefined, /*expression*/ undefined), pos);
             }
         }
-        function parseSimpleArrowFunctionExpression(pos, identifier, asyncModifier, parsingConditionalTrueSide) {
+        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, 
@@ -33472,11 +33501,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, parsingConditionalTrueSide);
+            var body = parseArrowFunctionExpressionBody(/*isAsync*/ !!asyncModifier);
             var node = factory.createArrowFunction(asyncModifier, /*typeParameters*/ undefined, parameters, /*type*/ undefined, equalsGreaterThanToken, body);
             return addJSDocComment(finishNode(node, pos));
         }
-        function tryParseParenthesizedArrowFunctionExpression(parsingConditionalTrueSide) {
+        function tryParseParenthesizedArrowFunctionExpression() {
             var triState = isParenthesizedArrowFunctionExpression();
             if (triState === 0 /* False */) {
                 // It's definitely not a parenthesized arrow function expression.
@@ -33487,8 +33516,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, parsingConditionalTrueSide) :
-                tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(parsingConditionalTrueSide); });
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true) :
+                tryParse(parsePossibleParenthesizedArrowFunctionExpression);
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
         //  False       -> There *cannot* be a parenthesized arrow function here.
@@ -33618,25 +33647,25 @@ var ts;
                 return 2 /* Unknown */;
             }
         }
-        function parsePossibleParenthesizedArrowFunctionExpression(parsingConditionalTrueSide) {
+        function parsePossibleParenthesizedArrowFunctionExpression() {
             var tokenPos = scanner.getTokenPos();
             if (notParenthesizedArrow === null || notParenthesizedArrow === void 0 ? void 0 : notParenthesizedArrow.has(tokenPos)) {
                 return undefined;
             }
-            var result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false, parsingConditionalTrueSide);
+            var result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false);
             if (!result) {
                 (notParenthesizedArrow || (notParenthesizedArrow = new ts.Set())).add(tokenPos);
             }
             return result;
         }
-        function tryParseAsyncSimpleArrowFunctionExpression(parsingConditionalTrueSide) {
+        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, parsingConditionalTrueSide);
+                    return parseSimpleArrowFunctionExpression(pos, expr, asyncModifier);
                 }
             }
             return undefined;
@@ -33660,7 +33689,7 @@ var ts;
             }
             return 0 /* False */;
         }
-        function parseParenthesizedArrowFunctionExpression(allowAmbiguity, parsingConditionalTrueSide) {
+        function parseParenthesizedArrowFunctionExpression(allowAmbiguity) {
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             var modifiers = parseModifiersForArrowFunction();
@@ -33686,18 +33715,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 (parsingConditionalTrueSide && token() === 58 /* ColonToken */) {
-                ts.Debug.assert(!allowAmbiguity);
-                return undefined;
-            }
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -33731,7 +33748,7 @@ var ts;
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
-        function parseArrowFunctionExpressionBody(isAsync, parsingConditionalTrueSide) {
+        function parseArrowFunctionExpressionBody(isAsync) {
             if (token() === 18 /* OpenBraceToken */) {
                 return parseFunctionBlock(isAsync ? 2 /* Await */ : 0 /* None */);
             }
@@ -33759,8 +33776,8 @@ var ts;
             var savedTopLevel = topLevel;
             topLevel = false;
             var node = isAsync
-                ? doInAwaitContext(function () { return parseAssignmentExpressionOrHigher(parsingConditionalTrueSide); })
-                : doOutsideOfAwaitContext(function () { return parseAssignmentExpressionOrHigher(parsingConditionalTrueSide); });
+                ? doInAwaitContext(parseAssignmentExpressionOrHigher)
+                : doOutsideOfAwaitContext(parseAssignmentExpressionOrHigher);
             topLevel = savedTopLevel;
             return node;
         }
@@ -33773,8 +33790,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(/*parsingConditionalTrueSide*/ true); }), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
-                ? parseAssignmentExpressionOrHigher(/*parsingConditionalTrueSide*/ false)
+            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) {
@@ -34545,12 +34562,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 */) {
@@ -34590,20 +34611,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>]
@@ -34622,20 +34646,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()) {
@@ -34816,17 +34830,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 */) {
@@ -35923,6 +35932,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);
         }
@@ -36213,7 +36225,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 */);
@@ -43418,14 +43431,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() {
@@ -43485,7 +43496,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();
@@ -47752,6 +47765,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);
@@ -50847,7 +50863,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 */;
@@ -50958,7 +50974,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 {
@@ -52522,7 +52538,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 */) };
                     }
@@ -54885,7 +54902,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;
             }
@@ -56895,87 +56912,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) {
@@ -57967,8 +57984,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;
                 }
@@ -58532,14 +58549,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));
                                 }
                             });
                         }
@@ -58549,7 +58566,7 @@ var ts;
                     var declaration = _a[_i];
                     _loop_14(declaration);
                 }
-                return indexInfos_2;
+                return indexInfos_4;
             }
             return ts.emptyArray;
         }
@@ -59097,7 +59114,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;
@@ -60538,7 +60555,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);
                     }
@@ -61801,7 +61818,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;
@@ -61817,8 +61836,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;
@@ -61990,6 +62009,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;
@@ -65164,8 +65186,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);
@@ -65772,10 +65794,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);
@@ -65796,7 +65818,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) {
@@ -66460,7 +66482,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);
@@ -67377,8 +67399,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];
@@ -67398,8 +67420,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);
@@ -69941,9 +69963,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 */) {
@@ -72955,7 +72977,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);
@@ -74414,7 +74436,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);
@@ -75569,6 +75591,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 */) {
@@ -78078,6 +78160,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 */:
@@ -79283,12 +79367,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 */:
@@ -81875,8 +81959,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);
                 }
             }
@@ -81902,8 +81986,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);
             }
         }
@@ -81925,8 +82009,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);
             }
         }
@@ -82793,16 +82877,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);
                             }
@@ -82830,6 +82913,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) &&
@@ -83124,7 +83211,6 @@ var ts;
             return true;
         }
         function checkAliasSymbol(node) {
-            var _a;
             var symbol = getSymbolOfNode(node);
             var target = resolveAlias(symbol);
             if (target !== unknownSymbol) {
@@ -83180,11 +83266,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);
@@ -87485,7 +87606,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));
@@ -90377,8 +90498,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) {
@@ -95579,8 +95700,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;
@@ -109209,6 +109330,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 */:
@@ -109653,6 +109776,7 @@ var ts;
             writeKeyword("typeof");
             writeSpace();
             emit(node.exprName);
+            emitTypeArguments(node, node.typeArguments);
         }
         function emitTypeLiteral(node) {
             writePunctuation("{");
@@ -114612,15 +114736,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
@@ -115842,14 +115966,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);
@@ -119728,9 +119852,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);
@@ -119750,10 +119874,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;
                     }
                 });
             });