typescript 4.6.0-dev.20220104 → 4.6.0-dev.20220108

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-dev.20220104";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220108";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -14445,7 +14445,8 @@ var ts;
                 Float64Array: ["at"],
                 BigInt64Array: ["at"],
                 BigUint64Array: ["at"],
-                ObjectConstructor: ["hasOwn"]
+                ObjectConstructor: ["hasOwn"],
+                Error: ["cause"]
             }
         };
     }
@@ -20756,9 +20757,40 @@ var ts;
     }
     ts.isFunctionExpressionOrArrowFunction = isFunctionExpressionOrArrowFunction;
     function escapeSnippetText(text) {
-        return text.replace(/\$/gm, "\\$");
+        return text.replace(/\$/gm, function () { return "\\$"; });
     }
     ts.escapeSnippetText = escapeSnippetText;
+    function isNumericLiteralName(name) {
+        // The intent of numeric names is that
+        //     - they are names with text in a numeric form, and that
+        //     - setting properties/indexing with them is always equivalent to doing so with the numeric literal 'numLit',
+        //         acquired by applying the abstract 'ToNumber' operation on the name's text.
+        //
+        // The subtlety is in the latter portion, as we cannot reliably say that anything that looks like a numeric literal is a numeric name.
+        // In fact, it is the case that the text of the name must be equal to 'ToString(numLit)' for this to hold.
+        //
+        // Consider the property name '"0xF00D"'. When one indexes with '0xF00D', they are actually indexing with the value of 'ToString(0xF00D)'
+        // according to the ECMAScript specification, so it is actually as if the user indexed with the string '"61453"'.
+        // Thus, the text of all numeric literals equivalent to '61543' such as '0xF00D', '0xf00D', '0170015', etc. are not valid numeric names
+        // because their 'ToString' representation is not equal to their original text.
+        // This is motivated by ECMA-262 sections 9.3.1, 9.8.1, 11.1.5, and 11.2.1.
+        //
+        // Here, we test whether 'ToString(ToNumber(name))' is exactly equal to 'name'.
+        // The '+' prefix operator is equivalent here to applying the abstract ToNumber operation.
+        // Applying the 'toString()' method on a number gives us the abstract ToString operation on a number.
+        //
+        // Note that this accepts the values 'Infinity', '-Infinity', and 'NaN', and that this is intentional.
+        // This is desired behavior, because when indexing with them as numeric entities, you are indexing
+        // with the strings '"Infinity"', '"-Infinity"', and '"NaN"' respectively.
+        return (+name).toString() === name;
+    }
+    ts.isNumericLiteralName = isNumericLiteralName;
+    function createPropertyNameNodeForIdentifierOrLiteral(name, target, singleQuote, stringNamed) {
+        return ts.isIdentifierText(name, target) ? ts.factory.createIdentifier(name) :
+            !stringNamed && isNumericLiteralName(name) && +name >= 0 ? ts.factory.createNumericLiteral(+name) :
+                ts.factory.createStringLiteral(name, !!singleQuote);
+    }
+    ts.createPropertyNameNodeForIdentifierOrLiteral = createPropertyNameNodeForIdentifierOrLiteral;
     function isThisTypeParameter(type) {
         return !!(type.flags & 262144 /* TypeParameter */ && type.isThisType);
     }
@@ -22231,7 +22263,7 @@ var ts;
                 result.push(createModifier(144 /* ReadonlyKeyword */));
             if (flags & 256 /* Async */)
                 result.push(createModifier(131 /* AsyncKeyword */));
-            return result;
+            return result.length ? result : undefined;
         }
         //
         // Names
@@ -26188,32 +26220,36 @@ var ts;
         }
         function updateModifiers(node, modifiers) {
             var _a;
+            var modifierArray;
             if (typeof modifiers === "number") {
-                modifiers = createModifiersFromModifierFlags(modifiers);
-            }
-            return ts.isParameter(node) ? updateParameterDeclaration(node, node.decorators, modifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer) :
-                ts.isPropertySignature(node) ? updatePropertySignature(node, modifiers, node.name, node.questionToken, node.type) :
-                    ts.isPropertyDeclaration(node) ? updatePropertyDeclaration(node, node.decorators, modifiers, node.name, (_a = node.questionToken) !== null && _a !== void 0 ? _a : node.exclamationToken, node.type, node.initializer) :
-                        ts.isMethodSignature(node) ? updateMethodSignature(node, modifiers, node.name, node.questionToken, node.typeParameters, node.parameters, node.type) :
-                            ts.isMethodDeclaration(node) ? updateMethodDeclaration(node, node.decorators, modifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body) :
-                                ts.isConstructorDeclaration(node) ? updateConstructorDeclaration(node, node.decorators, modifiers, node.parameters, node.body) :
-                                    ts.isGetAccessorDeclaration(node) ? updateGetAccessorDeclaration(node, node.decorators, modifiers, node.name, node.parameters, node.type, node.body) :
-                                        ts.isSetAccessorDeclaration(node) ? updateSetAccessorDeclaration(node, node.decorators, modifiers, node.name, node.parameters, node.body) :
-                                            ts.isIndexSignatureDeclaration(node) ? updateIndexSignature(node, node.decorators, modifiers, node.parameters, node.type) :
-                                                ts.isFunctionExpression(node) ? updateFunctionExpression(node, modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) :
-                                                    ts.isArrowFunction(node) ? updateArrowFunction(node, modifiers, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, node.body) :
-                                                        ts.isClassExpression(node) ? updateClassExpression(node, node.decorators, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members) :
-                                                            ts.isVariableStatement(node) ? updateVariableStatement(node, modifiers, node.declarationList) :
-                                                                ts.isFunctionDeclaration(node) ? updateFunctionDeclaration(node, node.decorators, modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) :
-                                                                    ts.isClassDeclaration(node) ? updateClassDeclaration(node, node.decorators, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members) :
-                                                                        ts.isInterfaceDeclaration(node) ? updateInterfaceDeclaration(node, node.decorators, modifiers, node.name, node.typeParameters, node.heritageClauses, node.members) :
-                                                                            ts.isTypeAliasDeclaration(node) ? updateTypeAliasDeclaration(node, node.decorators, modifiers, node.name, node.typeParameters, node.type) :
-                                                                                ts.isEnumDeclaration(node) ? updateEnumDeclaration(node, node.decorators, modifiers, node.name, node.members) :
-                                                                                    ts.isModuleDeclaration(node) ? updateModuleDeclaration(node, node.decorators, modifiers, node.name, node.body) :
-                                                                                        ts.isImportEqualsDeclaration(node) ? updateImportEqualsDeclaration(node, node.decorators, modifiers, node.isTypeOnly, node.name, node.moduleReference) :
-                                                                                            ts.isImportDeclaration(node) ? updateImportDeclaration(node, node.decorators, modifiers, node.importClause, node.moduleSpecifier, node.assertClause) :
-                                                                                                ts.isExportAssignment(node) ? updateExportAssignment(node, node.decorators, modifiers, node.expression) :
-                                                                                                    ts.isExportDeclaration(node) ? updateExportDeclaration(node, node.decorators, modifiers, node.isTypeOnly, node.exportClause, node.moduleSpecifier, node.assertClause) :
+                modifierArray = createModifiersFromModifierFlags(modifiers);
+            }
+            else {
+                modifierArray = modifiers;
+            }
+            return ts.isParameter(node) ? updateParameterDeclaration(node, node.decorators, modifierArray, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer) :
+                ts.isPropertySignature(node) ? updatePropertySignature(node, modifierArray, node.name, node.questionToken, node.type) :
+                    ts.isPropertyDeclaration(node) ? updatePropertyDeclaration(node, node.decorators, modifierArray, node.name, (_a = node.questionToken) !== null && _a !== void 0 ? _a : node.exclamationToken, node.type, node.initializer) :
+                        ts.isMethodSignature(node) ? updateMethodSignature(node, modifierArray, node.name, node.questionToken, node.typeParameters, node.parameters, node.type) :
+                            ts.isMethodDeclaration(node) ? updateMethodDeclaration(node, node.decorators, modifierArray, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body) :
+                                ts.isConstructorDeclaration(node) ? updateConstructorDeclaration(node, node.decorators, modifierArray, node.parameters, node.body) :
+                                    ts.isGetAccessorDeclaration(node) ? updateGetAccessorDeclaration(node, node.decorators, modifierArray, node.name, node.parameters, node.type, node.body) :
+                                        ts.isSetAccessorDeclaration(node) ? updateSetAccessorDeclaration(node, node.decorators, modifierArray, node.name, node.parameters, node.body) :
+                                            ts.isIndexSignatureDeclaration(node) ? updateIndexSignature(node, node.decorators, modifierArray, node.parameters, node.type) :
+                                                ts.isFunctionExpression(node) ? updateFunctionExpression(node, modifierArray, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) :
+                                                    ts.isArrowFunction(node) ? updateArrowFunction(node, modifierArray, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, node.body) :
+                                                        ts.isClassExpression(node) ? updateClassExpression(node, node.decorators, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) :
+                                                            ts.isVariableStatement(node) ? updateVariableStatement(node, modifierArray, node.declarationList) :
+                                                                ts.isFunctionDeclaration(node) ? updateFunctionDeclaration(node, node.decorators, modifierArray, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) :
+                                                                    ts.isClassDeclaration(node) ? updateClassDeclaration(node, node.decorators, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) :
+                                                                        ts.isInterfaceDeclaration(node) ? updateInterfaceDeclaration(node, node.decorators, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) :
+                                                                            ts.isTypeAliasDeclaration(node) ? updateTypeAliasDeclaration(node, node.decorators, modifierArray, node.name, node.typeParameters, node.type) :
+                                                                                ts.isEnumDeclaration(node) ? updateEnumDeclaration(node, node.decorators, modifierArray, node.name, node.members) :
+                                                                                    ts.isModuleDeclaration(node) ? updateModuleDeclaration(node, node.decorators, modifierArray, node.name, node.body) :
+                                                                                        ts.isImportEqualsDeclaration(node) ? updateImportEqualsDeclaration(node, node.decorators, modifierArray, node.isTypeOnly, node.name, node.moduleReference) :
+                                                                                            ts.isImportDeclaration(node) ? updateImportDeclaration(node, node.decorators, modifierArray, node.importClause, node.moduleSpecifier, node.assertClause) :
+                                                                                                ts.isExportAssignment(node) ? updateExportAssignment(node, node.decorators, modifierArray, node.expression) :
+                                                                                                    ts.isExportDeclaration(node) ? updateExportDeclaration(node, node.decorators, modifierArray, node.isTypeOnly, node.exportClause, node.moduleSpecifier, node.assertClause) :
                                                                                                         ts.Debug.assertNever(node);
         }
         function asNodeArray(array) {
@@ -46827,6 +46863,7 @@ var ts;
                 var location = ts.getParseTreeNode(locationIn);
                 return location ? getTypeOfSymbolAtLocation(symbol, location) : errorType;
             },
+            getTypeOfSymbol: getTypeOfSymbol,
             getSymbolsOfParameterPropertyDeclaration: function (parameterIn, parameterName) {
                 var parameter = ts.getParseTreeNode(parameterIn, ts.isParameter);
                 if (parameter === undefined)
@@ -52182,7 +52219,7 @@ var ts;
                 }
                 var rawName = ts.unescapeLeadingUnderscores(symbol.escapedName);
                 var stringNamed = !!ts.length(symbol.declarations) && ts.every(symbol.declarations, isStringNamed);
-                return createPropertyNameNodeForIdentifierOrLiteral(rawName, stringNamed, singleQuote);
+                return ts.createPropertyNameNodeForIdentifierOrLiteral(rawName, ts.getEmitScriptTarget(compilerOptions), singleQuote, stringNamed);
             }
             // See getNameForSymbolFromNameType for a stringy equivalent
             function getPropertyNameNodeForSymbolFromNameType(symbol, context, singleQuote) {
@@ -52190,24 +52227,19 @@ var ts;
                 if (nameType) {
                     if (nameType.flags & 384 /* StringOrNumberLiteral */) {
                         var name = "" + nameType.value;
-                        if (!ts.isIdentifierText(name, ts.getEmitScriptTarget(compilerOptions)) && !isNumericLiteralName(name)) {
+                        if (!ts.isIdentifierText(name, ts.getEmitScriptTarget(compilerOptions)) && !ts.isNumericLiteralName(name)) {
                             return ts.factory.createStringLiteral(name, !!singleQuote);
                         }
-                        if (isNumericLiteralName(name) && ts.startsWith(name, "-")) {
+                        if (ts.isNumericLiteralName(name) && ts.startsWith(name, "-")) {
                             return ts.factory.createComputedPropertyName(ts.factory.createNumericLiteral(+name));
                         }
-                        return createPropertyNameNodeForIdentifierOrLiteral(name);
+                        return ts.createPropertyNameNodeForIdentifierOrLiteral(name, ts.getEmitScriptTarget(compilerOptions));
                     }
                     if (nameType.flags & 8192 /* UniqueESSymbol */) {
                         return ts.factory.createComputedPropertyName(symbolToExpression(nameType.symbol, context, 111551 /* Value */));
                     }
                 }
             }
-            function createPropertyNameNodeForIdentifierOrLiteral(name, stringNamed, singleQuote) {
-                return ts.isIdentifierText(name, ts.getEmitScriptTarget(compilerOptions)) ? ts.factory.createIdentifier(name) :
-                    !stringNamed && isNumericLiteralName(name) && +name >= 0 ? ts.factory.createNumericLiteral(+name) :
-                        ts.factory.createStringLiteral(name, !!singleQuote);
-            }
             function cloneNodeBuilderContext(context) {
                 var initial = __assign({}, context);
                 // Make type parameters created within this context not consume the name outside this context
@@ -53723,10 +53755,10 @@ var ts;
             if (nameType) {
                 if (nameType.flags & 384 /* StringOrNumberLiteral */) {
                     var name = "" + nameType.value;
-                    if (!ts.isIdentifierText(name, ts.getEmitScriptTarget(compilerOptions)) && !isNumericLiteralName(name)) {
+                    if (!ts.isIdentifierText(name, ts.getEmitScriptTarget(compilerOptions)) && !ts.isNumericLiteralName(name)) {
                         return "\"" + ts.escapeString(name, 34 /* doubleQuote */) + "\"";
                     }
-                    if (isNumericLiteralName(name) && ts.startsWith(name, "-")) {
+                    if (ts.isNumericLiteralName(name) && ts.startsWith(name, "-")) {
                         return "[" + name + "]";
                     }
                     return name;
@@ -57769,7 +57801,7 @@ var ts;
             // signature applies to types assignable to 'number' and numeric string literal types.
             return isTypeAssignableTo(source, target) ||
                 target === stringType && isTypeAssignableTo(source, numberType) ||
-                target === numberType && !!(source.flags & 128 /* StringLiteral */) && isNumericLiteralName(source.value);
+                target === numberType && !!(source.flags & 128 /* StringLiteral */) && ts.isNumericLiteralName(source.value);
         }
         function getIndexInfosOfStructuredType(type) {
             if (type.flags & 3670016 /* StructuredType */) {
@@ -60335,7 +60367,7 @@ var ts;
                         getFlowTypeOfReference(accessExpression, propType) :
                         propType;
                 }
-                if (everyType(objectType, isTupleType) && isNumericLiteralName(propName) && +propName >= 0) {
+                if (everyType(objectType, isTupleType) && ts.isNumericLiteralName(propName) && +propName >= 0) {
                     if (accessNode && everyType(objectType, function (t) { return !t.target.hasRestElement; }) && !(accessFlags & 16 /* NoTupleBoundsCheck */)) {
                         var indexNode = getIndexNodeForAccessExpression(accessNode);
                         if (isTupleType(objectType)) {
@@ -60620,7 +60652,7 @@ var ts;
             return everyType(indexType, function (t) {
                 if (t.flags & 384 /* StringOrNumberLiteral */) {
                     var propName = getPropertyNameFromType(t);
-                    if (isNumericLiteralName(propName)) {
+                    if (ts.isNumericLiteralName(propName)) {
                         var index = +propName;
                         return index >= 0 && index < limit;
                     }
@@ -64162,7 +64194,7 @@ var ts;
                     else {
                         // conditionals aren't related to one another via distributive constraint as it is much too inaccurate and allows way
                         // more assignments than are desirable (since it maps the source check type to its constraint, it loses information)
-                        var distributiveConstraint = getConstraintOfDistributiveConditionalType(source);
+                        var distributiveConstraint = hasNonCircularBaseConstraint(source) ? getConstraintOfDistributiveConditionalType(source) : undefined;
                         if (distributiveConstraint) {
                             if (result = isRelatedTo(distributiveConstraint, target, 1 /* Source */, reportErrors)) {
                                 resetErrorInfo(saveErrorInfo);
@@ -64708,7 +64740,7 @@ var ts;
                 for (var _b = 0, _c = excludeProperties(properties, excludedProperties); _b < _c.length; _b++) {
                     var targetProp = _c[_b];
                     var name = targetProp.escapedName;
-                    if (!(targetProp.flags & 4194304 /* Prototype */) && (!numericNamesOnly || isNumericLiteralName(name) || name === "length")) {
+                    if (!(targetProp.flags & 4194304 /* Prototype */) && (!numericNamesOnly || ts.isNumericLiteralName(name) || name === "length")) {
                         var sourceProp = getPropertyOfType(source, name);
                         if (sourceProp && sourceProp !== targetProp) {
                             var related = propertyRelatedTo(source, target, sourceProp, targetProp, getNonMissingTypeOfSymbol, reportErrors, intersectionState, relation === comparableRelation);
@@ -64781,7 +64813,8 @@ var ts;
                 var incompatibleReporter = kind === 1 /* Construct */ ? reportIncompatibleConstructSignatureReturn : reportIncompatibleCallSignatureReturn;
                 var sourceObjectFlags = ts.getObjectFlags(source);
                 var targetObjectFlags = ts.getObjectFlags(target);
-                if (sourceObjectFlags & 64 /* Instantiated */ && targetObjectFlags & 64 /* Instantiated */ && source.symbol === target.symbol) {
+                if (sourceObjectFlags & 64 /* Instantiated */ && targetObjectFlags & 64 /* Instantiated */ && source.symbol === target.symbol ||
+                    sourceObjectFlags & 4 /* Reference */ && targetObjectFlags & 4 /* Reference */ && source.target === target.target) {
                     // We have instantiations of the same anonymous type (which typically will be the type of a
                     // method). Simply do a pairwise comparison of the signatures in the two signature lists instead
                     // of the much more expensive N * M comparison matrix we explore below. We erase type parameters
@@ -65816,9 +65849,12 @@ var ts;
          * with no call or construct signatures.
          */
         function isObjectTypeWithInferableIndex(type) {
-            return type.flags & 2097152 /* Intersection */ ? ts.every(type.types, isObjectTypeWithInferableIndex) :
-                !!(type.symbol && (type.symbol.flags & (4096 /* ObjectLiteral */ | 2048 /* TypeLiteral */ | 384 /* Enum */ | 512 /* ValueModule */)) !== 0 &&
-                    !typeHasCallOrConstructSignatures(type)) || !!(ts.getObjectFlags(type) & 1024 /* ReverseMapped */ && isObjectTypeWithInferableIndex(type.source));
+            return type.flags & 2097152 /* Intersection */
+                ? ts.every(type.types, isObjectTypeWithInferableIndex)
+                : !!(type.symbol
+                    && (type.symbol.flags & (4096 /* ObjectLiteral */ | 2048 /* TypeLiteral */ | 384 /* Enum */ | 512 /* ValueModule */)) !== 0
+                    && !(type.symbol.flags & 32 /* Class */)
+                    && !typeHasCallOrConstructSignatures(type)) || !!(ts.getObjectFlags(type) & 1024 /* ReverseMapped */ && isObjectTypeWithInferableIndex(type.source));
         }
         function createSymbolWithType(source, type) {
             var symbol = createSymbol(source.flags, source.escapedName, ts.getCheckFlags(source) & 8 /* Readonly */);
@@ -67426,7 +67462,8 @@ var ts;
             return access.kind === 205 /* PropertyAccessExpression */ ? access.name.escapedText :
                 access.kind === 206 /* ElementAccessExpression */ && ts.isStringOrNumericLiteralLike(access.argumentExpression) ? ts.escapeLeadingUnderscores(access.argumentExpression.text) :
                     access.kind === 202 /* BindingElement */ && (propertyName = getDestructuringPropertyName(access)) ? ts.escapeLeadingUnderscores(propertyName) :
-                        undefined;
+                        access.kind === 163 /* Parameter */ ? ("" + access.parent.parameters.indexOf(access)) :
+                            undefined;
         }
         function containsMatchingReference(source, target) {
             while (ts.isAccessExpression(source)) {
@@ -68766,13 +68803,14 @@ var ts;
                 return result;
             }
             function getCandidateDiscriminantPropertyAccess(expr) {
-                if (ts.isBindingPattern(reference)) {
-                    // When the reference is a binding pattern, we are narrowing a pesudo-reference in getNarrowedTypeOfSymbol.
-                    // An identifier for a destructuring variable declared in the same binding pattern is a candidate.
+                if (ts.isBindingPattern(reference) || ts.isFunctionExpressionOrArrowFunction(reference)) {
+                    // When the reference is a binding pattern or function or arrow expression, we are narrowing a pesudo-reference in
+                    // getNarrowedTypeOfSymbol. An identifier for a destructuring variable declared in the same binding pattern or
+                    // parameter declared in the same parameter list is a candidate.
                     if (ts.isIdentifier(expr)) {
                         var symbol = getResolvedSymbol(expr);
                         var declaration = symbol.valueDeclaration;
-                        if (declaration && ts.isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && reference === declaration.parent) {
+                        if (declaration && (ts.isBindingElement(declaration) || ts.isParameter(declaration)) && reference === declaration.parent && !declaration.initializer && !declaration.dotDotDotToken) {
                             return declaration;
                         }
                     }
@@ -69574,42 +69612,78 @@ var ts;
             }
         }
         function getNarrowedTypeOfSymbol(symbol, location) {
-            // If we have a non-rest binding element with no initializer declared as a const variable or a const-like
-            // parameter (a parameter for which there are no assignments in the function body), and if the parent type
-            // for the destructuring is a union type, one or more of the binding elements may represent discriminant
-            // properties, and we want the effects of conditional checks on such discriminants to affect the types of
-            // other binding elements from the same destructuring. Consider:
-            //
-            //   type Action =
-            //       | { kind: 'A', payload: number }
-            //       | { kind: 'B', payload: string };
-            //
-            //   function f1({ kind, payload }: Action) {
-            //       if (kind === 'A') {
-            //           payload.toFixed();
-            //       }
-            //       if (kind === 'B') {
-            //           payload.toUpperCase();
-            //       }
-            //   }
-            //
-            // Above, we want the conditional checks on 'kind' to affect the type of 'payload'. To facilitate this, we use
-            // the binding pattern AST instance for '{ kind, payload }' as a pseudo-reference and narrow this reference
-            // as if it occurred in the specified location. We then recompute the narrowed binding element type by
-            // destructuring from the narrowed parent type.
             var declaration = symbol.valueDeclaration;
-            if (declaration && ts.isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {
-                var parent = declaration.parent.parent;
-                if (parent.kind === 253 /* VariableDeclaration */ && ts.getCombinedNodeFlags(declaration) & 2 /* Const */ || parent.kind === 163 /* Parameter */) {
-                    var links = getNodeLinks(location);
-                    if (!(links.flags & 268435456 /* InCheckIdentifier */)) {
-                        links.flags |= 268435456 /* InCheckIdentifier */;
-                        var parentType = getTypeForBindingElementParent(parent);
-                        links.flags &= ~268435456 /* InCheckIdentifier */;
-                        if (parentType && parentType.flags & 1048576 /* Union */ && !(parent.kind === 163 /* Parameter */ && isSymbolAssigned(symbol))) {
-                            var pattern = declaration.parent;
-                            var narrowedType = getFlowTypeOfReference(pattern, parentType, parentType, /*flowContainer*/ undefined, location.flowNode);
-                            return getBindingElementTypeFromParentType(declaration, narrowedType);
+            if (declaration) {
+                // If we have a non-rest binding element with no initializer declared as a const variable or a const-like
+                // parameter (a parameter for which there are no assignments in the function body), and if the parent type
+                // for the destructuring is a union type, one or more of the binding elements may represent discriminant
+                // properties, and we want the effects of conditional checks on such discriminants to affect the types of
+                // other binding elements from the same destructuring. Consider:
+                //
+                //   type Action =
+                //       | { kind: 'A', payload: number }
+                //       | { kind: 'B', payload: string };
+                //
+                //   function f({ kind, payload }: Action) {
+                //       if (kind === 'A') {
+                //           payload.toFixed();
+                //       }
+                //       if (kind === 'B') {
+                //           payload.toUpperCase();
+                //       }
+                //   }
+                //
+                // Above, we want the conditional checks on 'kind' to affect the type of 'payload'. To facilitate this, we use
+                // the binding pattern AST instance for '{ kind, payload }' as a pseudo-reference and narrow this reference
+                // as if it occurred in the specified location. We then recompute the narrowed binding element type by
+                // destructuring from the narrowed parent type.
+                if (ts.isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {
+                    var parent = declaration.parent.parent;
+                    if (parent.kind === 253 /* VariableDeclaration */ && ts.getCombinedNodeFlags(declaration) & 2 /* Const */ || parent.kind === 163 /* Parameter */) {
+                        var links = getNodeLinks(location);
+                        if (!(links.flags & 268435456 /* InCheckIdentifier */)) {
+                            links.flags |= 268435456 /* InCheckIdentifier */;
+                            var parentType = getTypeForBindingElementParent(parent);
+                            links.flags &= ~268435456 /* InCheckIdentifier */;
+                            if (parentType && parentType.flags & 1048576 /* Union */ && !(parent.kind === 163 /* Parameter */ && isSymbolAssigned(symbol))) {
+                                var pattern = declaration.parent;
+                                var narrowedType = getFlowTypeOfReference(pattern, parentType, parentType, /*flowContainer*/ undefined, location.flowNode);
+                                return getBindingElementTypeFromParentType(declaration, narrowedType);
+                            }
+                        }
+                    }
+                }
+                // If we have a const-like parameter with no type annotation or initializer, and if the parameter is contextually
+                // typed by a signature with a single rest parameter of a union of tuple types, one or more of the parameters may
+                // represent discriminant tuple elements, and we want the effects of conditional checks on such discriminants to
+                // affect the types of other parameters in the same parameter list. Consider:
+                //
+                //   type Action = [kind: 'A', payload: number] | [kind: 'B', payload: string];
+                //
+                //   const f: (...args: Action) => void = (kind, payload) => {
+                //       if (kind === 'A') {
+                //           payload.toFixed();
+                //       }
+                //       if (kind === 'B') {
+                //           payload.toUpperCase();
+                //       }
+                //   }
+                //
+                // Above, we want the conditional checks on 'kind' to affect the type of 'payload'. To facilitate this, we use
+                // the arrow function AST node for '(kind, payload) => ...' as a pseudo-reference and narrow this reference as
+                // if it occurred in the specified location. We then recompute the narrowed parameter type by indexing into the
+                // narrowed tuple type.
+                if (ts.isParameter(declaration) && !declaration.type && !declaration.initializer && !declaration.dotDotDotToken) {
+                    var func = declaration.parent;
+                    if (func.parameters.length >= 2 && isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
+                        var contextualSignature = getContextualSignature(func);
+                        if (contextualSignature && contextualSignature.parameters.length === 1 && signatureHasRestParameter(contextualSignature)) {
+                            var restType = getTypeOfSymbol(contextualSignature.parameters[0]);
+                            if (restType.flags & 1048576 /* Union */ && everyType(restType, isTupleType) && !isSymbolAssigned(symbol)) {
+                                var narrowedType = getFlowTypeOfReference(func, restType, restType, /*flowContainer*/ undefined, location.flowNode);
+                                var index = func.parameters.indexOf(declaration) - (ts.getThisParameter(func) ? 1 : 0);
+                                return getIndexedAccessType(narrowedType, getNumberLiteralType(index));
+                            }
                         }
                     }
                 }
@@ -70750,7 +70824,7 @@ var ts;
                     }
                     if (isTupleType(t)) {
                         var restType = getRestTypeOfTupleType(t);
-                        if (restType && isNumericLiteralName(name) && +name >= 0) {
+                        if (restType && ts.isNumericLiteralName(name) && +name >= 0) {
                             return restType;
                         }
                     }
@@ -71391,10 +71465,10 @@ var ts;
                 case 161 /* ComputedPropertyName */:
                     return isNumericComputedName(name);
                 case 79 /* Identifier */:
-                    return isNumericLiteralName(name.escapedText);
+                    return ts.isNumericLiteralName(name.escapedText);
                 case 8 /* NumericLiteral */:
                 case 10 /* StringLiteral */:
-                    return isNumericLiteralName(name.text);
+                    return ts.isNumericLiteralName(name.text);
                 default:
                     return false;
             }
@@ -71404,30 +71478,6 @@ var ts;
             // but this behavior is consistent with checkIndexedAccess
             return isTypeAssignableToKind(checkComputedPropertyName(name), 296 /* NumberLike */);
         }
-        function isNumericLiteralName(name) {
-            // The intent of numeric names is that
-            //     - they are names with text in a numeric form, and that
-            //     - setting properties/indexing with them is always equivalent to doing so with the numeric literal 'numLit',
-            //         acquired by applying the abstract 'ToNumber' operation on the name's text.
-            //
-            // The subtlety is in the latter portion, as we cannot reliably say that anything that looks like a numeric literal is a numeric name.
-            // In fact, it is the case that the text of the name must be equal to 'ToString(numLit)' for this to hold.
-            //
-            // Consider the property name '"0xF00D"'. When one indexes with '0xF00D', they are actually indexing with the value of 'ToString(0xF00D)'
-            // according to the ECMAScript specification, so it is actually as if the user indexed with the string '"61453"'.
-            // Thus, the text of all numeric literals equivalent to '61543' such as '0xF00D', '0xf00D', '0170015', etc. are not valid numeric names
-            // because their 'ToString' representation is not equal to their original text.
-            // This is motivated by ECMA-262 sections 9.3.1, 9.8.1, 11.1.5, and 11.2.1.
-            //
-            // Here, we test whether 'ToString(ToNumber(name))' is exactly equal to 'name'.
-            // The '+' prefix operator is equivalent here to applying the abstract ToNumber operation.
-            // Applying the 'toString()' method on a number gives us the abstract ToString operation on a number.
-            //
-            // Note that this accepts the values 'Infinity', '-Infinity', and 'NaN', and that this is intentional.
-            // This is desired behavior, because when indexing with them as numeric entities, you are indexing
-            // with the strings '"Infinity"', '"-Infinity"', and '"NaN"' respectively.
-            return (+name).toString() === name;
-        }
         function checkComputedPropertyName(node) {
             var links = getNodeLinks(node.expression);
             if (!links.resolvedType) {
@@ -71463,7 +71513,7 @@ var ts;
         function isSymbolWithNumericName(symbol) {
             var _a;
             var firstDecl = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a[0];
-            return isNumericLiteralName(symbol.escapedName) || (firstDecl && ts.isNamedDeclaration(firstDecl) && isNumericName(firstDecl.name));
+            return ts.isNumericLiteralName(symbol.escapedName) || (firstDecl && ts.isNamedDeclaration(firstDecl) && isNumericName(firstDecl.name));
         }
         function isSymbolWithSymbolName(symbol) {
             var _a;
@@ -82401,7 +82451,7 @@ var ts;
             }
             else {
                 var text = ts.getTextOfPropertyName(member.name);
-                if (isNumericLiteralName(text) && !ts.isInfinityOrNaNString(text)) {
+                if (ts.isNumericLiteralName(text) && !ts.isInfinityOrNaNString(text)) {
                     error(member.name, ts.Diagnostics.An_enum_member_cannot_have_a_numeric_name);
                 }
             }
@@ -109007,7 +109057,7 @@ var ts;
                     emitPlaceholder(hint, node, snippet);
                     break;
                 case 0 /* TabStop */:
-                    emitTabStop(snippet);
+                    emitTabStop(hint, node, snippet);
                     break;
             }
         }
@@ -109017,7 +109067,10 @@ var ts;
             nonEscapingWrite("}"); // `}`
             // `${2:...}`
         }
-        function emitTabStop(snippet) {
+        function emitTabStop(hint, node, snippet) {
+            // A tab stop should only be attached to an empty node, i.e. a node that doesn't emit any text.
+            ts.Debug.assert(node.kind === 235 /* EmptyStatement */, "A tab stop cannot be attached to a node of kind " + ts.Debug.formatSyntaxKind(node.kind) + ".");
+            ts.Debug.assert(hint !== 5 /* EmbeddedStatement */, "A tab stop cannot be attached to an embedded statement.");
             nonEscapingWrite("$" + snippet.order);
         }
         //
@@ -119863,7 +119916,7 @@ var ts;
     }
     ts.getLocaleTimeString = getLocaleTimeString;
     /**
-     * Create a function that reports watch status by writing to the system and handles the formating of the diagnostic
+     * Create a function that reports watch status by writing to the system and handles the formatting of the diagnostic
      */
     function createWatchStatusReporter(system, pretty) {
         return pretty ?
@@ -119924,7 +119977,7 @@ var ts;
             ts.Diagnostics.Found_0_errors_Watching_for_file_changes;
     }
     ts.getWatchErrorSummaryDiagnosticMessage = getWatchErrorSummaryDiagnosticMessage;
-    function getErrorSummaryText(errorCount, filesInError, newLine) {
+    function getErrorSummaryText(errorCount, filesInError, newLine, host) {
         if (errorCount === 0)
             return "";
         var nonNilFiles = filesInError.filter(function (fileInError) { return fileInError !== undefined; });
@@ -119939,10 +119992,10 @@ var ts;
                 distinctFileNamesWithLines.length === 1 ?
                     ts.Diagnostics.Found_0_errors_in_1_file :
                     ts.Diagnostics.Found_0_errors_in_1_files, errorCount, distinctFileNamesWithLines.length);
-        return "" + newLine + ts.flattenDiagnosticMessageText(d.messageText, newLine) + newLine + newLine + (errorCount > 1 ? createTabularErrorsDisplay(nonNilFiles) : "");
+        return "" + newLine + ts.flattenDiagnosticMessageText(d.messageText, newLine) + newLine + newLine + (errorCount > 1 ? createTabularErrorsDisplay(nonNilFiles, host) : "");
     }
     ts.getErrorSummaryText = getErrorSummaryText;
-    function createTabularErrorsDisplay(filesInError) {
+    function createTabularErrorsDisplay(filesInError, host) {
         var distinctFiles = filesInError.filter(function (value, index, self) { return index === self.findIndex(function (file) { return (file === null || file === void 0 ? void 0 : file.fileName) === (value === null || value === void 0 ? void 0 : value.fileName); }); });
         if (distinctFiles.length === 0)
             return "";
@@ -119961,7 +120014,8 @@ var ts;
             var leftPadding = errorCountDigitsLength < leftPaddingGoal ?
                 " ".repeat(leftPaddingGoal - errorCountDigitsLength)
                 : "";
-            tabularData += "" + leftPadding + errorCount + "  " + file.fileName + ":" + file.line + "\n";
+            var relativePath = ts.getRelativePathFromDirectory(host.getCurrentDirectory(), file.fileName, /* ignoreCase */ false);
+            tabularData += "" + leftPadding + errorCount + "  " + relativePath + ":" + file.line + "\n";
         });
         return tabularData;
     }
@@ -120379,7 +120433,7 @@ var ts;
         var system = input.system || ts.sys;
         var host = input.host || (input.host = ts.createIncrementalCompilerHost(input.options, system));
         var builderProgram = ts.createIncrementalProgram(input);
-        var exitStatus = emitFilesAndReportErrorsAndGetExitStatus(builderProgram, input.reportDiagnostic || createDiagnosticReporter(system), function (s) { return host.trace && host.trace(s); }, input.reportErrorSummary || input.options.pretty ? function (errorCount, filesInError) { return system.write(getErrorSummaryText(errorCount, filesInError, system.newLine)); } : undefined);
+        var exitStatus = emitFilesAndReportErrorsAndGetExitStatus(builderProgram, input.reportDiagnostic || createDiagnosticReporter(system), function (s) { return host.trace && host.trace(s); }, input.reportErrorSummary || input.options.pretty ? function (errorCount, filesInError) { return system.write(getErrorSummaryText(errorCount, filesInError, system.newLine, host)); } : undefined);
         if (input.afterProgramEmitAndDiagnostics)
             input.afterProgramEmitAndDiagnostics(builderProgram);
         return exitStatus;
@@ -122853,14 +122907,8 @@ var ts;
             var possibleSearchDirs = new ts.Set(fileNames.map(ts.getDirectoryPath));
             possibleSearchDirs.add(projectRootPath);
             possibleSearchDirs.forEach(function (searchDir) {
-                var packageJsonPath = ts.combinePaths(searchDir, "package.json");
-                getTypingNamesFromJson(packageJsonPath, filesToWatch);
-                var bowerJsonPath = ts.combinePaths(searchDir, "bower.json");
-                getTypingNamesFromJson(bowerJsonPath, filesToWatch);
-                var bowerComponentsPath = ts.combinePaths(searchDir, "bower_components");
-                getTypingNamesFromPackagesFolder(bowerComponentsPath, filesToWatch);
-                var nodeModulesPath = ts.combinePaths(searchDir, "node_modules");
-                getTypingNamesFromPackagesFolder(nodeModulesPath, filesToWatch);
+                getTypingNames(searchDir, "bower.json", "bower_components", filesToWatch);
+                getTypingNames(searchDir, "package.json", "node_modules", filesToWatch);
             });
             if (!typeAcquisition.disableFilenameBasedTypeAcquisition) {
                 getTypingNamesFromSourceFileNames(fileNames);
@@ -122909,16 +122957,100 @@ var ts;
                 ts.forEach(typingNames, addInferredTyping);
             }
             /**
-             * Get the typing info from common package manager json files like package.json or bower.json
+             * Adds inferred typings from manifest/module pairs (think package.json + node_modules)
+             *
+             * @param projectRootPath is the path to the directory where to look for package.json, bower.json and other typing information
+             * @param manifestName is the name of the manifest (package.json or bower.json)
+             * @param modulesDirName is the directory name for modules (node_modules or bower_components). Should be lowercase!
+             * @param filesToWatch are the files to watch for changes. We will push things into this array.
              */
-            function getTypingNamesFromJson(jsonPath, filesToWatch) {
-                if (!host.fileExists(jsonPath)) {
+            function getTypingNames(projectRootPath, manifestName, modulesDirName, filesToWatch) {
+                // First, we check the manifests themselves. They're not
+                // _required_, but they allow us to do some filtering when dealing
+                // with big flat dep directories.
+                var manifestPath = ts.combinePaths(projectRootPath, manifestName);
+                var manifest;
+                var manifestTypingNames;
+                if (host.fileExists(manifestPath)) {
+                    filesToWatch.push(manifestPath);
+                    manifest = ts.readConfigFile(manifestPath, function (path) { return host.readFile(path); }).config;
+                    manifestTypingNames = ts.flatMap([manifest.dependencies, manifest.devDependencies, manifest.optionalDependencies, manifest.peerDependencies], ts.getOwnKeys);
+                    addInferredTypings(manifestTypingNames, "Typing names in '" + manifestPath + "' dependencies");
+                }
+                // Now we scan the directories for typing information in
+                // already-installed dependencies (if present). Note that this
+                // step happens regardless of whether a manifest was present,
+                // which is certainly a valid configuration, if an unusual one.
+                var packagesFolderPath = ts.combinePaths(projectRootPath, modulesDirName);
+                filesToWatch.push(packagesFolderPath);
+                if (!host.directoryExists(packagesFolderPath)) {
                     return;
                 }
-                filesToWatch.push(jsonPath);
-                var jsonConfig = ts.readConfigFile(jsonPath, function (path) { return host.readFile(path); }).config;
-                var jsonTypingNames = ts.flatMap([jsonConfig.dependencies, jsonConfig.devDependencies, jsonConfig.optionalDependencies, jsonConfig.peerDependencies], ts.getOwnKeys);
-                addInferredTypings(jsonTypingNames, "Typing names in '" + jsonPath + "' dependencies");
+                // There's two cases we have to take into account here:
+                // 1. If manifest is undefined, then we're not using a manifest.
+                //    That means that we should scan _all_ dependencies at the top
+                //    level of the modulesDir.
+                // 2. If manifest is defined, then we can do some special
+                //    filtering to reduce the amount of scanning we need to do.
+                //
+                // Previous versions of this algorithm checked for a `_requiredBy`
+                // field in the package.json, but that field is only present in
+                // `npm@>=3 <7`.
+                // Package names that do **not** provide their own typings, so
+                // we'll look them up.
+                var packageNames = [];
+                var dependencyManifestNames = manifestTypingNames
+                    // This is #1 described above.
+                    ? manifestTypingNames.map(function (typingName) { return ts.combinePaths(packagesFolderPath, typingName, manifestName); })
+                    // And #2. Depth = 3 because scoped packages look like `node_modules/@foo/bar/package.json`
+                    : host.readDirectory(packagesFolderPath, [".json" /* Json */], /*excludes*/ undefined, /*includes*/ undefined, /*depth*/ 3)
+                        .filter(function (manifestPath) {
+                        if (ts.getBaseFileName(manifestPath) !== manifestName) {
+                            return false;
+                        }
+                        // It's ok to treat
+                        // `node_modules/@foo/bar/package.json` as a manifest,
+                        // but not `node_modules/jquery/nested/package.json`.
+                        // We only assume depth 3 is ok for formally scoped
+                        // packages. So that needs this dance here.
+                        var pathComponents = ts.getPathComponents(ts.normalizePath(manifestPath));
+                        var isScoped = pathComponents[pathComponents.length - 3][0] === "@";
+                        return isScoped && pathComponents[pathComponents.length - 4].toLowerCase() === modulesDirName || // `node_modules/@foo/bar`
+                            !isScoped && pathComponents[pathComponents.length - 3].toLowerCase() === modulesDirName; // `node_modules/foo`
+                    });
+                if (log)
+                    log("Searching for typing names in " + packagesFolderPath + "; all files: " + JSON.stringify(dependencyManifestNames));
+                // Once we have the names of things to look up, we iterate over
+                // and either collect their included typings, or add them to the
+                // list of typings we need to look up separately.
+                for (var _i = 0, dependencyManifestNames_1 = dependencyManifestNames; _i < dependencyManifestNames_1.length; _i++) {
+                    var manifestPath_1 = dependencyManifestNames_1[_i];
+                    var normalizedFileName = ts.normalizePath(manifestPath_1);
+                    var result_1 = ts.readConfigFile(normalizedFileName, function (path) { return host.readFile(path); });
+                    var manifest_1 = result_1.config;
+                    // If the package has its own d.ts typings, those will take precedence. Otherwise the package name will be used
+                    // to download d.ts files from DefinitelyTyped
+                    if (!manifest_1.name) {
+                        continue;
+                    }
+                    var ownTypes = manifest_1.types || manifest_1.typings;
+                    if (ownTypes) {
+                        var absolutePath = ts.getNormalizedAbsolutePath(ownTypes, ts.getDirectoryPath(normalizedFileName));
+                        if (host.fileExists(absolutePath)) {
+                            if (log)
+                                log("    Package '" + manifest_1.name + "' provides its own types.");
+                            inferredTypings.set(manifest_1.name, absolutePath);
+                        }
+                        else {
+                            if (log)
+                                log("    Package '" + manifest_1.name + "' provides its own types but they are missing.");
+                        }
+                    }
+                    else {
+                        packageNames.push(manifest_1.name);
+                    }
+                }
+                addInferredTypings(packageNames, "    Found package names");
             }
             /**
              * Infer typing names from given file names. For example, the file name "jquery-min.2.3.4.js"
@@ -122944,55 +123076,6 @@ var ts;
                     addInferredTyping("react");
                 }
             }
-            /**
-             * Infer typing names from packages folder (ex: node_module, bower_components)
-             * @param packagesFolderPath is the path to the packages folder
-             */
-            function getTypingNamesFromPackagesFolder(packagesFolderPath, filesToWatch) {
-                filesToWatch.push(packagesFolderPath);
-                // Todo: add support for ModuleResolutionHost too
-                if (!host.directoryExists(packagesFolderPath)) {
-                    return;
-                }
-                // depth of 2, so we access `node_modules/foo` but not `node_modules/foo/bar`
-                var fileNames = host.readDirectory(packagesFolderPath, [".json" /* Json */], /*excludes*/ undefined, /*includes*/ undefined, /*depth*/ 2);
-                if (log)
-                    log("Searching for typing names in " + packagesFolderPath + "; all files: " + JSON.stringify(fileNames));
-                var packageNames = [];
-                for (var _i = 0, fileNames_1 = fileNames; _i < fileNames_1.length; _i++) {
-                    var fileName = fileNames_1[_i];
-                    var normalizedFileName = ts.normalizePath(fileName);
-                    var baseFileName = ts.getBaseFileName(normalizedFileName);
-                    if (baseFileName !== "package.json" && baseFileName !== "bower.json") {
-                        continue;
-                    }
-                    var result_1 = ts.readConfigFile(normalizedFileName, function (path) { return host.readFile(path); });
-                    var packageJson = result_1.config;
-                    // npm 3's package.json contains a "_requiredBy" field
-                    // we should include all the top level module names for npm 2, and only module names whose
-                    // "_requiredBy" field starts with "#" or equals "/" for npm 3.
-                    if (baseFileName === "package.json" && packageJson._requiredBy &&
-                        ts.filter(packageJson._requiredBy, function (r) { return r[0] === "#" || r === "/"; }).length === 0) {
-                        continue;
-                    }
-                    // If the package has its own d.ts typings, those will take precedence. Otherwise the package name will be used
-                    // to download d.ts files from DefinitelyTyped
-                    if (!packageJson.name) {
-                        continue;
-                    }
-                    var ownTypes = packageJson.types || packageJson.typings;
-                    if (ownTypes) {
-                        var absolutePath = ts.getNormalizedAbsolutePath(ownTypes, ts.getDirectoryPath(normalizedFileName));
-                        if (log)
-                            log("    Package '" + packageJson.name + "' provides its own types.");
-                        inferredTypings.set(packageJson.name, absolutePath);
-                    }
-                    else {
-                        packageNames.push(packageJson.name);
-                    }
-                }
-                addInferredTypings(packageNames, "    Found package names");
-            }
         }
         JsTyping.discoverTypings = discoverTypings;
         var NameValidationResult;