typescript 4.6.0-dev.20220105 → 4.6.0-dev.20220109

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.20220105";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220109";
     /* @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);
     }
@@ -46831,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)
@@ -52186,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) {
@@ -52194,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
@@ -53727,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;
@@ -57773,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 */) {
@@ -60339,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)) {
@@ -60624,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;
                     }
@@ -64166,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);
@@ -64712,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);
@@ -64785,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
@@ -65820,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 */);
@@ -70792,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;
                         }
                     }
@@ -71433,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;
             }
@@ -71446,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) {
@@ -71505,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;
@@ -82443,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);
                 }
             }
@@ -119908,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 ?
@@ -119969,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; });
@@ -119984,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 "";
@@ -120006,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;
     }
@@ -120424,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;
@@ -122898,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);
@@ -122954,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"
@@ -122989,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;

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "4.6.0-dev.20220105",
+    "version": "4.6.0-dev.20220109",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [