@@ -2,7 +2,6 @@ const fetch = require('npm-registry-fetch')

const localeCompare = require('@isaacs/string-locale-compare')('en')

const npa = require('npm-package-arg')

const pacote = require('pacote')

const pMap = require('p-map')

const tufClient = require('@sigstore/tuf')

const { log, output } = require('proc-log')

@@ -26,6 +25,7 @@ class VerifySignatures {

async run () {

const start = process.hrtime.bigint()

const { default: pMap } = await import('p-map')

// Find all deps in tree

const { edges, registries } = this.getEdgesOut(this.tree.inventory.values(), this.filterSet)

@@ -61,7 +61,6 @@

!/cacache/node_modules/chownr

!/cacache/node_modules/minizlib

!/cacache/node_modules/mkdirp

!/cacache/node_modules/p-map

!/cacache/node_modules/tar

!/cacache/node_modules/yallist

!/chalk

@@ -160,6 +159,7 @@

!/node-gyp/node_modules/make-fetch-happen

!/node-gyp/node_modules/minipass-fetch

!/node-gyp/node_modules/nopt

!/node-gyp/node_modules/p-map

!/node-gyp/node_modules/proc-log

!/node-gyp/node_modules/ssri

!/node-gyp/node_modules/unique-filename

@@ -0,0 +1,81 @@

'use strict';

const AggregateError = require('aggregate-error');

module.exports = async (

iterable,

mapper,

{

concurrency = Infinity,

stopOnError = true

} = {}

) => {

return new Promise((resolve, reject) => {

if (typeof mapper !== 'function') {

throw new TypeError('Mapper function is required');

}

if (!((Number.isSafeInteger(concurrency) || concurrency === Infinity) && concurrency >= 1)) {

throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);

}

const result = [];

const errors = [];

const iterator = iterable[Symbol.iterator]();

let isRejected = false;

let isIterableDone = false;

let resolvingCount = 0;

let currentIndex = 0;

const next = () => {

if (isRejected) {

return;

}

const nextItem = iterator.next();

const index = currentIndex;

currentIndex++;

if (nextItem.done) {

isIterableDone = true;

if (resolvingCount === 0) {

if (!stopOnError && errors.length !== 0) {

reject(new AggregateError(errors));

} else {

resolve(result);

}

}

return;

}

resolvingCount++;

(async () => {

try {

const element = await nextItem.value;

result[index] = await mapper(element, index);

resolvingCount--;

next();

} catch (error) {

if (stopOnError) {

isRejected = true;

reject(error);

} else {

errors.push(error);

resolvingCount--;

next();

}

}

})();

};

for (let i = 0; i < concurrency; i++) {

next();

if (isIterableDone) {

break;

}

}

});

};