{"ast":null,"code":"/**\n * Creates a continuation function with some arguments already applied.\n *\n * Useful as a shorthand when combined with other control flow functions. Any\n * arguments passed to the returned function are added to the arguments\n * originally passed to apply.\n *\n * @name apply\n * @static\n * @memberOf module:Utils\n * @method\n * @category Util\n * @param {Function} fn - The function you want to eventually apply all\n * arguments to. Invokes with (arguments...).\n * @param {...*} arguments... - Any number of arguments to automatically apply\n * when the continuation is called.\n * @returns {Function} the partially-applied function\n * @example\n *\n * // using apply\n * async.parallel([\n * async.apply(fs.writeFile, 'testfile1', 'test1'),\n * async.apply(fs.writeFile, 'testfile2', 'test2')\n * ]);\n *\n *\n * // the same process without using apply\n * async.parallel([\n * function(callback) {\n * fs.writeFile('testfile1', 'test1', callback);\n * },\n * function(callback) {\n * fs.writeFile('testfile2', 'test2', callback);\n * }\n * ]);\n *\n * // It's possible to pass any number of additional arguments when calling the\n * // continuation:\n *\n * node> var fn = async.apply(sys.puts, 'one');\n * node> fn('two', 'three');\n * one\n * two\n * three\n */\nfunction apply(fn, ...args) {\n return (...callArgs) => fn(...args, ...callArgs);\n}\n\nfunction initialParams(fn) {\n return function (...args\n /*, callback*/\n ) {\n var callback = args.pop();\n return fn.call(this, args, callback);\n };\n}\n/* istanbul ignore file */\n\n\nvar hasQueueMicrotask = typeof queueMicrotask === 'function' && queueMicrotask;\nvar hasSetImmediate = typeof setImmediate === 'function' && setImmediate;\nvar hasNextTick = typeof process === 'object' && typeof process.nextTick === 'function';\n\nfunction fallback(fn) {\n setTimeout(fn, 0);\n}\n\nfunction wrap(defer) {\n return (fn, ...args) => defer(() => fn(...args));\n}\n\nvar _defer;\n\nif (hasQueueMicrotask) {\n _defer = queueMicrotask;\n} else if (hasSetImmediate) {\n _defer = setImmediate;\n} else if (hasNextTick) {\n _defer = process.nextTick;\n} else {\n _defer = fallback;\n}\n\nvar setImmediate$1 = wrap(_defer);\n/**\n * Take a sync function and make it async, passing its return value to a\n * callback. This is useful for plugging sync functions into a waterfall,\n * series, or other async functions. Any arguments passed to the generated\n * function will be passed to the wrapped function (except for the final\n * callback argument). Errors thrown will be passed to the callback.\n *\n * If the function passed to `asyncify` returns a Promise, that promises's\n * resolved/rejected state will be used to call the callback, rather than simply\n * the synchronous return value.\n *\n * This also means you can asyncify ES2017 `async` functions.\n *\n * @name asyncify\n * @static\n * @memberOf module:Utils\n * @method\n * @alias wrapSync\n * @category Util\n * @param {Function} func - The synchronous function, or Promise-returning\n * function to convert to an {@link AsyncFunction}.\n * @returns {AsyncFunction} An asynchronous wrapper of the `func`. To be\n * invoked with `(args..., callback)`.\n * @example\n *\n * // passing a regular synchronous function\n * async.waterfall([\n * async.apply(fs.readFile, filename, \"utf8\"),\n * async.asyncify(JSON.parse),\n * function (data, next) {\n * // data is the result of parsing the text.\n * // If there was a parsing error, it would have been caught.\n * }\n * ], callback);\n *\n * // passing a function returning a promise\n * async.waterfall([\n * async.apply(fs.readFile, filename, \"utf8\"),\n * async.asyncify(function (contents) {\n * return db.model.create(contents);\n * }),\n * function (model, next) {\n * // `model` is the instantiated model object.\n * // If there was an error, this function would be skipped.\n * }\n * ], callback);\n *\n * // es2017 example, though `asyncify` is not needed if your JS environment\n * // supports async functions out of the box\n * var q = async.queue(async.asyncify(async function(file) {\n * var intermediateStep = await processFile(file);\n * return await somePromise(intermediateStep)\n * }));\n *\n * q.push(files);\n */\n\nfunction asyncify(func) {\n if (isAsync(func)) {\n return function (...args\n /*, callback*/\n ) {\n const callback = args.pop();\n const promise = func.apply(this, args);\n return handlePromise(promise, callback);\n };\n }\n\n return initialParams(function (args, callback) {\n var result;\n\n try {\n result = func.apply(this, args);\n } catch (e) {\n return callback(e);\n } // if result is Promise object\n\n\n if (result && typeof result.then === 'function') {\n return handlePromise(result, callback);\n } else {\n callback(null, result);\n }\n });\n}\n\nfunction handlePromise(promise, callback) {\n return promise.then(value => {\n invokeCallback(callback, null, value);\n }, err => {\n invokeCallback(callback, err && err.message ? err : new Error(err));\n });\n}\n\nfunction invokeCallback(callback, error, value) {\n try {\n callback(error, value);\n } catch (err) {\n setImmediate$1(e => {\n throw e;\n }, err);\n }\n}\n\nfunction isAsync(fn) {\n return fn[Symbol.toStringTag] === 'AsyncFunction';\n}\n\nfunction isAsyncGenerator(fn) {\n return fn[Symbol.toStringTag] === 'AsyncGenerator';\n}\n\nfunction isAsyncIterable(obj) {\n return typeof obj[Symbol.asyncIterator] === 'function';\n}\n\nfunction wrapAsync(asyncFn) {\n if (typeof asyncFn !== 'function') throw new Error('expected a function');\n return isAsync(asyncFn) ? asyncify(asyncFn) : asyncFn;\n} // conditionally promisify a function.\n// only return a promise if a callback is omitted\n\n\nfunction awaitify(asyncFn, arity = asyncFn.length) {\n if (!arity) throw new Error('arity is undefined');\n\n function awaitable(...args) {\n if (typeof args[arity - 1] === 'function') {\n return asyncFn.apply(this, args);\n }\n\n return new Promise((resolve, reject) => {\n args[arity - 1] = (err, ...cbArgs) => {\n if (err) return reject(err);\n resolve(cbArgs.length > 1 ? cbArgs : cbArgs[0]);\n };\n\n asyncFn.apply(this, args);\n });\n }\n\n return awaitable;\n}\n\nfunction applyEach(eachfn) {\n return function applyEach(fns, ...callArgs) {\n const go = awaitify(function (callback) {\n var that = this;\n return eachfn(fns, (fn, cb) => {\n wrapAsync(fn).apply(that, callArgs.concat(cb));\n }, callback);\n });\n return go;\n };\n}\n\nfunction _asyncMap(eachfn, arr, iteratee, callback) {\n arr = arr || [];\n var results = [];\n var counter = 0;\n\n var _iteratee = wrapAsync(iteratee);\n\n return eachfn(arr, (value, _, iterCb) => {\n var index = counter++;\n\n _iteratee(value, (err, v) => {\n results[index] = v;\n iterCb(err);\n });\n }, err => {\n callback(err, results);\n });\n}\n\nfunction isArrayLike(value) {\n return value && typeof value.length === 'number' && value.length >= 0 && value.length % 1 === 0;\n} // A temporary value used to identify if the loop should be broken.\n// See #1064, #1293\n\n\nconst breakLoop = {};\n\nfunction once(fn) {\n function wrapper(...args) {\n if (fn === null) return;\n var callFn = fn;\n fn = null;\n callFn.apply(this, args);\n }\n\n Object.assign(wrapper, fn);\n return wrapper;\n}\n\nfunction getIterator(coll) {\n return coll[Symbol.iterator] && coll[Symbol.iterator]();\n}\n\nfunction createArrayIterator(coll) {\n var i = -1;\n var len = coll.length;\n return function next() {\n return ++i < len ? {\n value: coll[i],\n key: i\n } : null;\n };\n}\n\nfunction createES2015Iterator(iterator) {\n var i = -1;\n return function next() {\n var item = iterator.next();\n if (item.done) return null;\n i++;\n return {\n value: item.value,\n key: i\n };\n };\n}\n\nfunction createObjectIterator(obj) {\n var okeys = obj ? Object.keys(obj) : [];\n var i = -1;\n var len = okeys.length;\n return function next() {\n var key = okeys[++i];\n return i < len ? {\n value: obj[key],\n key\n } : null;\n };\n}\n\nfunction createIterator(coll) {\n if (isArrayLike(coll)) {\n return createArrayIterator(coll);\n }\n\n var iterator = getIterator(coll);\n return iterator ? createES2015Iterator(iterator) : createObjectIterator(coll);\n}\n\nfunction onlyOnce(fn) {\n return function (...args) {\n if (fn === null) throw new Error(\"Callback was already called.\");\n var callFn = fn;\n fn = null;\n callFn.apply(this, args);\n };\n} // for async generators\n\n\nfunction asyncEachOfLimit(generator, limit, iteratee, callback) {\n let done = false;\n let canceled = false;\n let awaiting = false;\n let running = 0;\n let idx = 0;\n\n function replenish() {\n //console.log('replenish')\n if (running >= limit || awaiting || done) return; //console.log('replenish awaiting')\n\n awaiting = true;\n generator.next().then(({\n value,\n done: iterDone\n }) => {\n //console.log('got value', value)\n if (canceled || done) return;\n awaiting = false;\n\n if (iterDone) {\n done = true;\n\n if (running <= 0) {\n //console.log('done nextCb')\n callback(null);\n }\n\n return;\n }\n\n running++;\n iteratee(value, idx, iterateeCallback);\n idx++;\n replenish();\n }).catch(handleError);\n }\n\n function iterateeCallback(err, result) {\n //console.log('iterateeCallback')\n running -= 1;\n if (canceled) return;\n if (err) return handleError(err);\n\n if (err === false) {\n done = true;\n canceled = true;\n return;\n }\n\n if (result === breakLoop || done && running <= 0) {\n done = true; //console.log('done iterCb')\n\n return callback(null);\n }\n\n replenish();\n }\n\n function handleError(err) {\n if (canceled) return;\n awaiting = false;\n done = true;\n callback(err);\n }\n\n replenish();\n}\n\nvar eachOfLimit = limit => {\n return (obj, iteratee, callback) => {\n callback = once(callback);\n\n if (limit <= 0) {\n throw new RangeError('concurrency limit cannot be less than 1');\n }\n\n if (!obj) {\n return callback(null);\n }\n\n if (isAsyncGenerator(obj)) {\n return asyncEachOfLimit(obj, limit, iteratee, callback);\n }\n\n if (isAsyncIterable(obj)) {\n return asyncEachOfLimit(obj[Symbol.asyncIterator](), limit, iteratee, callback);\n }\n\n var nextElem = createIterator(obj);\n var done = false;\n var canceled = false;\n var running = 0;\n var looping = false;\n\n function iterateeCallback(err, value) {\n if (canceled) return;\n running -= 1;\n\n if (err) {\n done = true;\n callback(err);\n } else if (err === false) {\n done = true;\n canceled = true;\n } else if (value === breakLoop || done && running <= 0) {\n done = true;\n return callback(null);\n } else if (!looping) {\n replenish();\n }\n }\n\n function replenish() {\n looping = true;\n\n while (running < limit && !done) {\n var elem = nextElem();\n\n if (elem === null) {\n done = true;\n\n if (running <= 0) {\n callback(null);\n }\n\n return;\n }\n\n running += 1;\n iteratee(elem.value, elem.key, onlyOnce(iterateeCallback));\n }\n\n looping = false;\n }\n\n replenish();\n };\n};\n/**\n * The same as [`eachOf`]{@link module:Collections.eachOf} but runs a maximum of `limit` async operations at a\n * time.\n *\n * @name eachOfLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.eachOf]{@link module:Collections.eachOf}\n * @alias forEachOfLimit\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - An async function to apply to each\n * item in `coll`. The `key` is the item's key, or index in the case of an\n * array.\n * Invoked with (item, key, callback).\n * @param {Function} [callback] - A callback which is called when all\n * `iteratee` functions have finished, or an error occurs. Invoked with (err).\n * @returns {Promise} a promise, if a callback is omitted\n */\n\n\nfunction eachOfLimit$1(coll, limit, iteratee, callback) {\n return eachOfLimit(limit)(coll, wrapAsync(iteratee), callback);\n}\n\nvar eachOfLimit$2 = awaitify(eachOfLimit$1, 4); // eachOf implementation optimized for array-likes\n\nfunction eachOfArrayLike(coll, iteratee, callback) {\n callback = once(callback);\n var index = 0,\n completed = 0,\n {\n length\n } = coll,\n canceled = false;\n\n if (length === 0) {\n callback(null);\n }\n\n function iteratorCallback(err, value) {\n if (err === false) {\n canceled = true;\n }\n\n if (canceled === true) return;\n\n if (err) {\n callback(err);\n } else if (++completed === length || value === breakLoop) {\n callback(null);\n }\n }\n\n for (; index < length; index++) {\n iteratee(coll[index], index, onlyOnce(iteratorCallback));\n }\n} // a generic version of eachOf which can handle array, object, and iterator cases.\n\n\nfunction eachOfGeneric(coll, iteratee, callback) {\n return eachOfLimit$2(coll, Infinity, iteratee, callback);\n}\n/**\n * Like [`each`]{@link module:Collections.each}, except that it passes the key (or index) as the second argument\n * to the iteratee.\n *\n * @name eachOf\n * @static\n * @memberOf module:Collections\n * @method\n * @alias forEachOf\n * @category Collection\n * @see [async.each]{@link module:Collections.each}\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - A function to apply to each\n * item in `coll`.\n * The `key` is the item's key, or index in the case of an array.\n * Invoked with (item, key, callback).\n * @param {Function} [callback] - A callback which is called when all\n * `iteratee` functions have finished, or an error occurs. Invoked with (err).\n * @returns {Promise} a promise, if a callback is omitted\n * @example\n *\n * // dev.json is a file containing a valid json object config for dev environment\n * // dev.json is a file containing a valid json object config for test environment\n * // prod.json is a file containing a valid json object config for prod environment\n * // invalid.json is a file with a malformed json object\n *\n * let configs = {}; //global variable\n * let validConfigFileMap = {dev: 'dev.json', test: 'test.json', prod: 'prod.json'};\n * let invalidConfigFileMap = {dev: 'dev.json', test: 'test.json', invalid: 'invalid.json'};\n *\n * // asynchronous function that reads a json file and parses the contents as json object\n * function parseFile(file, key, callback) {\n * fs.readFile(file, \"utf8\", function(err, data) {\n * if (err) return calback(err);\n * try {\n * configs[key] = JSON.parse(data);\n * } catch (e) {\n * return callback(e);\n * }\n * callback();\n * });\n * }\n *\n * // Using callbacks\n * async.forEachOf(validConfigFileMap, parseFile, function (err) {\n * if (err) {\n * console.error(err);\n * } else {\n * console.log(configs);\n * // configs is now a map of JSON data, e.g.\n * // { dev: //parsed dev.json, test: //parsed test.json, prod: //parsed prod.json}\n * }\n * });\n *\n * //Error handing\n * async.forEachOf(invalidConfigFileMap, parseFile, function (err) {\n * if (err) {\n * console.error(err);\n * // JSON parse error exception\n * } else {\n * console.log(configs);\n * }\n * });\n *\n * // Using Promises\n * async.forEachOf(validConfigFileMap, parseFile)\n * .then( () => {\n * console.log(configs);\n * // configs is now a map of JSON data, e.g.\n * // { dev: //parsed dev.json, test: //parsed test.json, prod: //parsed prod.json}\n * }).catch( err => {\n * console.error(err);\n * });\n *\n * //Error handing\n * async.forEachOf(invalidConfigFileMap, parseFile)\n * .then( () => {\n * console.log(configs);\n * }).catch( err => {\n * console.error(err);\n * // JSON parse error exception\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let result = await async.forEachOf(validConfigFileMap, parseFile);\n * console.log(configs);\n * // configs is now a map of JSON data, e.g.\n * // { dev: //parsed dev.json, test: //parsed test.json, prod: //parsed prod.json}\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * //Error handing\n * async () => {\n * try {\n * let result = await async.forEachOf(invalidConfigFileMap, parseFile);\n * console.log(configs);\n * }\n * catch (err) {\n * console.log(err);\n * // JSON parse error exception\n * }\n * }\n *\n */\n\n\nfunction eachOf(coll, iteratee, callback) {\n var eachOfImplementation = isArrayLike(coll) ? eachOfArrayLike : eachOfGeneric;\n return eachOfImplementation(coll, wrapAsync(iteratee), callback);\n}\n\nvar eachOf$1 = awaitify(eachOf, 3);\n/**\n * Produces a new collection of values by mapping each value in `coll` through\n * the `iteratee` function. The `iteratee` is called with an item from `coll`\n * and a callback for when it has finished processing. Each of these callback\n * takes 2 arguments: an `error`, and the transformed item from `coll`. If\n * `iteratee` passes an error to its callback, the main `callback` (for the\n * `map` function) is immediately called with the error.\n *\n * Note, that since this function applies the `iteratee` to each item in\n * parallel, there is no guarantee that the `iteratee` functions will complete\n * in order. However, the results array will be in the same order as the\n * original `coll`.\n *\n * If `map` is passed an Object, the results will be an Array. The results\n * will roughly be in the order of the original Objects' keys (but this can\n * vary across JavaScript engines).\n *\n * @name map\n * @static\n * @memberOf module:Collections\n * @method\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * The iteratee should complete with the transformed item.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. Results is an Array of the\n * transformed items from the `coll`. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback is passed\n * @example\n *\n * // file1.txt is a file that is 1000 bytes in size\n * // file2.txt is a file that is 2000 bytes in size\n * // file3.txt is a file that is 3000 bytes in size\n * // file4.txt does not exist\n *\n * const fileList = ['file1.txt','file2.txt','file3.txt'];\n * const withMissingFileList = ['file1.txt','file2.txt','file4.txt'];\n *\n * // asynchronous function that returns the file size in bytes\n * function getFileSizeInBytes(file, callback) {\n * fs.stat(file, function(err, stat) {\n * if (err) {\n * return callback(err);\n * }\n * callback(null, stat.size);\n * });\n * }\n *\n * // Using callbacks\n * async.map(fileList, getFileSizeInBytes, function(err, results) {\n * if (err) {\n * console.log(err);\n * } else {\n * console.log(results);\n * // results is now an array of the file size in bytes for each file, e.g.\n * // [ 1000, 2000, 3000]\n * }\n * });\n *\n * // Error Handling\n * async.map(withMissingFileList, getFileSizeInBytes, function(err, results) {\n * if (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * } else {\n * console.log(results);\n * }\n * });\n *\n * // Using Promises\n * async.map(fileList, getFileSizeInBytes)\n * .then( results => {\n * console.log(results);\n * // results is now an array of the file size in bytes for each file, e.g.\n * // [ 1000, 2000, 3000]\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * // Error Handling\n * async.map(withMissingFileList, getFileSizeInBytes)\n * .then( results => {\n * console.log(results);\n * }).catch( err => {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let results = await async.map(fileList, getFileSizeInBytes);\n * console.log(results);\n * // results is now an array of the file size in bytes for each file, e.g.\n * // [ 1000, 2000, 3000]\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * // Error Handling\n * async () => {\n * try {\n * let results = await async.map(withMissingFileList, getFileSizeInBytes);\n * console.log(results);\n * }\n * catch (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * }\n * }\n *\n */\n\nfunction map(coll, iteratee, callback) {\n return _asyncMap(eachOf$1, coll, iteratee, callback);\n}\n\nvar map$1 = awaitify(map, 3);\n/**\n * Applies the provided arguments to each function in the array, calling\n * `callback` after all functions have completed. If you only provide the first\n * argument, `fns`, then it will return a function which lets you pass in the\n * arguments as if it were a single function call. If more arguments are\n * provided, `callback` is required while `args` is still optional. The results\n * for each of the applied async functions are passed to the final callback\n * as an array.\n *\n * @name applyEach\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {Array|Iterable|AsyncIterable|Object} fns - A collection of {@link AsyncFunction}s\n * to all call with the same arguments\n * @param {...*} [args] - any number of separate arguments to pass to the\n * function.\n * @param {Function} [callback] - the final argument should be the callback,\n * called when all functions have completed processing.\n * @returns {AsyncFunction} - Returns a function that takes no args other than\n * an optional callback, that is the result of applying the `args` to each\n * of the functions.\n * @example\n *\n * const appliedFn = async.applyEach([enableSearch, updateSchema], 'bucket')\n *\n * appliedFn((err, results) => {\n * // results[0] is the results for `enableSearch`\n * // results[1] is the results for `updateSchema`\n * });\n *\n * // partial application example:\n * async.each(\n * buckets,\n * async (bucket) => async.applyEach([enableSearch, updateSchema], bucket)(),\n * callback\n * );\n */\n\nvar applyEach$1 = applyEach(map$1);\n/**\n * The same as [`eachOf`]{@link module:Collections.eachOf} but runs only a single async operation at a time.\n *\n * @name eachOfSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.eachOf]{@link module:Collections.eachOf}\n * @alias forEachOfSeries\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * Invoked with (item, key, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. Invoked with (err).\n * @returns {Promise} a promise, if a callback is omitted\n */\n\nfunction eachOfSeries(coll, iteratee, callback) {\n return eachOfLimit$2(coll, 1, iteratee, callback);\n}\n\nvar eachOfSeries$1 = awaitify(eachOfSeries, 3);\n/**\n * The same as [`map`]{@link module:Collections.map} but runs only a single async operation at a time.\n *\n * @name mapSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.map]{@link module:Collections.map}\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * The iteratee should complete with the transformed item.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. Results is an array of the\n * transformed items from the `coll`. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback is passed\n */\n\nfunction mapSeries(coll, iteratee, callback) {\n return _asyncMap(eachOfSeries$1, coll, iteratee, callback);\n}\n\nvar mapSeries$1 = awaitify(mapSeries, 3);\n/**\n * The same as [`applyEach`]{@link module:ControlFlow.applyEach} but runs only a single async operation at a time.\n *\n * @name applyEachSeries\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.applyEach]{@link module:ControlFlow.applyEach}\n * @category Control Flow\n * @param {Array|Iterable|AsyncIterable|Object} fns - A collection of {@link AsyncFunction}s to all\n * call with the same arguments\n * @param {...*} [args] - any number of separate arguments to pass to the\n * function.\n * @param {Function} [callback] - the final argument should be the callback,\n * called when all functions have completed processing.\n * @returns {AsyncFunction} - A function, that when called, is the result of\n * appling the `args` to the list of functions. It takes no args, other than\n * a callback.\n */\n\nvar applyEachSeries = applyEach(mapSeries$1);\nconst PROMISE_SYMBOL = Symbol('promiseCallback');\n\nfunction promiseCallback() {\n let resolve, reject;\n\n function callback(err, ...args) {\n if (err) return reject(err);\n resolve(args.length > 1 ? args : args[0]);\n }\n\n callback[PROMISE_SYMBOL] = new Promise((res, rej) => {\n resolve = res, reject = rej;\n });\n return callback;\n}\n/**\n * Determines the best order for running the {@link AsyncFunction}s in `tasks`, based on\n * their requirements. Each function can optionally depend on other functions\n * being completed first, and each function is run as soon as its requirements\n * are satisfied.\n *\n * If any of the {@link AsyncFunction}s pass an error to their callback, the `auto` sequence\n * will stop. Further tasks will not execute (so any other functions depending\n * on it will not run), and the main `callback` is immediately called with the\n * error.\n *\n * {@link AsyncFunction}s also receive an object containing the results of functions which\n * have completed so far as the first argument, if they have dependencies. If a\n * task function has no dependencies, it will only be passed a callback.\n *\n * @name auto\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {Object} tasks - An object. Each of its properties is either a\n * function or an array of requirements, with the {@link AsyncFunction} itself the last item\n * in the array. The object's key of a property serves as the name of the task\n * defined by that property, i.e. can be used when specifying requirements for\n * other tasks. The function receives one or two arguments:\n * * a `results` object, containing the results of the previously executed\n * functions, only passed if the task has any dependencies,\n * * a `callback(err, result)` function, which must be called when finished,\n * passing an `error` (which can be `null`) and the result of the function's\n * execution.\n * @param {number} [concurrency=Infinity] - An optional `integer` for\n * determining the maximum number of tasks that can be run in parallel. By\n * default, as many as possible.\n * @param {Function} [callback] - An optional callback which is called when all\n * the tasks have been completed. It receives the `err` argument if any `tasks`\n * pass an error to their callback. Results are always returned; however, if an\n * error occurs, no further `tasks` will be performed, and the results object\n * will only contain partial results. Invoked with (err, results).\n * @returns {Promise} a promise, if a callback is not passed\n * @example\n *\n * //Using Callbacks\n * async.auto({\n * get_data: function(callback) {\n * // async code to get some data\n * callback(null, 'data', 'converted to array');\n * },\n * make_folder: function(callback) {\n * // async code to create a directory to store a file in\n * // this is run at the same time as getting the data\n * callback(null, 'folder');\n * },\n * write_file: ['get_data', 'make_folder', function(results, callback) {\n * // once there is some data and the directory exists,\n * // write the data to a file in the directory\n * callback(null, 'filename');\n * }],\n * email_link: ['write_file', function(results, callback) {\n * // once the file is written let's email a link to it...\n * callback(null, {'file':results.write_file, 'email':'user@example.com'});\n * }]\n * }, function(err, results) {\n * if (err) {\n * console.log('err = ', err);\n * }\n * console.log('results = ', results);\n * // results = {\n * // get_data: ['data', 'converted to array']\n * // make_folder; 'folder',\n * // write_file: 'filename'\n * // email_link: { file: 'filename', email: 'user@example.com' }\n * // }\n * });\n *\n * //Using Promises\n * async.auto({\n * get_data: function(callback) {\n * console.log('in get_data');\n * // async code to get some data\n * callback(null, 'data', 'converted to array');\n * },\n * make_folder: function(callback) {\n * console.log('in make_folder');\n * // async code to create a directory to store a file in\n * // this is run at the same time as getting the data\n * callback(null, 'folder');\n * },\n * write_file: ['get_data', 'make_folder', function(results, callback) {\n * // once there is some data and the directory exists,\n * // write the data to a file in the directory\n * callback(null, 'filename');\n * }],\n * email_link: ['write_file', function(results, callback) {\n * // once the file is written let's email a link to it...\n * callback(null, {'file':results.write_file, 'email':'user@example.com'});\n * }]\n * }).then(results => {\n * console.log('results = ', results);\n * // results = {\n * // get_data: ['data', 'converted to array']\n * // make_folder; 'folder',\n * // write_file: 'filename'\n * // email_link: { file: 'filename', email: 'user@example.com' }\n * // }\n * }).catch(err => {\n * console.log('err = ', err);\n * });\n *\n * //Using async/await\n * async () => {\n * try {\n * let results = await async.auto({\n * get_data: function(callback) {\n * // async code to get some data\n * callback(null, 'data', 'converted to array');\n * },\n * make_folder: function(callback) {\n * // async code to create a directory to store a file in\n * // this is run at the same time as getting the data\n * callback(null, 'folder');\n * },\n * write_file: ['get_data', 'make_folder', function(results, callback) {\n * // once there is some data and the directory exists,\n * // write the data to a file in the directory\n * callback(null, 'filename');\n * }],\n * email_link: ['write_file', function(results, callback) {\n * // once the file is written let's email a link to it...\n * callback(null, {'file':results.write_file, 'email':'user@example.com'});\n * }]\n * });\n * console.log('results = ', results);\n * // results = {\n * // get_data: ['data', 'converted to array']\n * // make_folder; 'folder',\n * // write_file: 'filename'\n * // email_link: { file: 'filename', email: 'user@example.com' }\n * // }\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\n\n\nfunction auto(tasks, concurrency, callback) {\n if (typeof concurrency !== 'number') {\n // concurrency is optional, shift the args.\n callback = concurrency;\n concurrency = null;\n }\n\n callback = once(callback || promiseCallback());\n var numTasks = Object.keys(tasks).length;\n\n if (!numTasks) {\n return callback(null);\n }\n\n if (!concurrency) {\n concurrency = numTasks;\n }\n\n var results = {};\n var runningTasks = 0;\n var canceled = false;\n var hasError = false;\n var listeners = Object.create(null);\n var readyTasks = []; // for cycle detection:\n\n var readyToCheck = []; // tasks that have been identified as reachable\n // without the possibility of returning to an ancestor task\n\n var uncheckedDependencies = {};\n Object.keys(tasks).forEach(key => {\n var task = tasks[key];\n\n if (!Array.isArray(task)) {\n // no dependencies\n enqueueTask(key, [task]);\n readyToCheck.push(key);\n return;\n }\n\n var dependencies = task.slice(0, task.length - 1);\n var remainingDependencies = dependencies.length;\n\n if (remainingDependencies === 0) {\n enqueueTask(key, task);\n readyToCheck.push(key);\n return;\n }\n\n uncheckedDependencies[key] = remainingDependencies;\n dependencies.forEach(dependencyName => {\n if (!tasks[dependencyName]) {\n throw new Error('async.auto task `' + key + '` has a non-existent dependency `' + dependencyName + '` in ' + dependencies.join(', '));\n }\n\n addListener(dependencyName, () => {\n remainingDependencies--;\n\n if (remainingDependencies === 0) {\n enqueueTask(key, task);\n }\n });\n });\n });\n checkForDeadlocks();\n processQueue();\n\n function enqueueTask(key, task) {\n readyTasks.push(() => runTask(key, task));\n }\n\n function processQueue() {\n if (canceled) return;\n\n if (readyTasks.length === 0 && runningTasks === 0) {\n return callback(null, results);\n }\n\n while (readyTasks.length && runningTasks < concurrency) {\n var run = readyTasks.shift();\n run();\n }\n }\n\n function addListener(taskName, fn) {\n var taskListeners = listeners[taskName];\n\n if (!taskListeners) {\n taskListeners = listeners[taskName] = [];\n }\n\n taskListeners.push(fn);\n }\n\n function taskComplete(taskName) {\n var taskListeners = listeners[taskName] || [];\n taskListeners.forEach(fn => fn());\n processQueue();\n }\n\n function runTask(key, task) {\n if (hasError) return;\n var taskCallback = onlyOnce((err, ...result) => {\n runningTasks--;\n\n if (err === false) {\n canceled = true;\n return;\n }\n\n if (result.length < 2) {\n [result] = result;\n }\n\n if (err) {\n var safeResults = {};\n Object.keys(results).forEach(rkey => {\n safeResults[rkey] = results[rkey];\n });\n safeResults[key] = result;\n hasError = true;\n listeners = Object.create(null);\n if (canceled) return;\n callback(err, safeResults);\n } else {\n results[key] = result;\n taskComplete(key);\n }\n });\n runningTasks++;\n var taskFn = wrapAsync(task[task.length - 1]);\n\n if (task.length > 1) {\n taskFn(results, taskCallback);\n } else {\n taskFn(taskCallback);\n }\n }\n\n function checkForDeadlocks() {\n // Kahn's algorithm\n // https://en.wikipedia.org/wiki/Topological_sorting#Kahn.27s_algorithm\n // http://connalle.blogspot.com/2013/10/topological-sortingkahn-algorithm.html\n var currentTask;\n var counter = 0;\n\n while (readyToCheck.length) {\n currentTask = readyToCheck.pop();\n counter++;\n getDependents(currentTask).forEach(dependent => {\n if (--uncheckedDependencies[dependent] === 0) {\n readyToCheck.push(dependent);\n }\n });\n }\n\n if (counter !== numTasks) {\n throw new Error('async.auto cannot execute tasks due to a recursive dependency');\n }\n }\n\n function getDependents(taskName) {\n var result = [];\n Object.keys(tasks).forEach(key => {\n const task = tasks[key];\n\n if (Array.isArray(task) && task.indexOf(taskName) >= 0) {\n result.push(key);\n }\n });\n return result;\n }\n\n return callback[PROMISE_SYMBOL];\n}\n\nvar FN_ARGS = /^(?:async\\s+)?(?:function)?\\s*\\w*\\s*\\(\\s*([^)]+)\\s*\\)(?:\\s*{)/;\nvar ARROW_FN_ARGS = /^(?:async\\s+)?\\(?\\s*([^)=]+)\\s*\\)?(?:\\s*=>)/;\nvar FN_ARG_SPLIT = /,/;\nvar FN_ARG = /(=.+)?(\\s*)$/;\nvar STRIP_COMMENTS = /((\\/\\/.*$)|(\\/\\*[\\s\\S]*?\\*\\/))/mg;\n\nfunction parseParams(func) {\n const src = func.toString().replace(STRIP_COMMENTS, '');\n let match = src.match(FN_ARGS);\n\n if (!match) {\n match = src.match(ARROW_FN_ARGS);\n }\n\n if (!match) throw new Error('could not parse args in autoInject\\nSource:\\n' + src);\n let [, args] = match;\n return args.replace(/\\s/g, '').split(FN_ARG_SPLIT).map(arg => arg.replace(FN_ARG, '').trim());\n}\n/**\n * A dependency-injected version of the [async.auto]{@link module:ControlFlow.auto} function. Dependent\n * tasks are specified as parameters to the function, after the usual callback\n * parameter, with the parameter names matching the names of the tasks it\n * depends on. This can provide even more readable task graphs which can be\n * easier to maintain.\n *\n * If a final callback is specified, the task results are similarly injected,\n * specified as named parameters after the initial error parameter.\n *\n * The autoInject function is purely syntactic sugar and its semantics are\n * otherwise equivalent to [async.auto]{@link module:ControlFlow.auto}.\n *\n * @name autoInject\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.auto]{@link module:ControlFlow.auto}\n * @category Control Flow\n * @param {Object} tasks - An object, each of whose properties is an {@link AsyncFunction} of\n * the form 'func([dependencies...], callback). The object's key of a property\n * serves as the name of the task defined by that property, i.e. can be used\n * when specifying requirements for other tasks.\n * * The `callback` parameter is a `callback(err, result)` which must be called\n * when finished, passing an `error` (which can be `null`) and the result of\n * the function's execution. The remaining parameters name other tasks on\n * which the task is dependent, and the results from those tasks are the\n * arguments of those parameters.\n * @param {Function} [callback] - An optional callback which is called when all\n * the tasks have been completed. It receives the `err` argument if any `tasks`\n * pass an error to their callback, and a `results` object with any completed\n * task results, similar to `auto`.\n * @returns {Promise} a promise, if no callback is passed\n * @example\n *\n * // The example from `auto` can be rewritten as follows:\n * async.autoInject({\n * get_data: function(callback) {\n * // async code to get some data\n * callback(null, 'data', 'converted to array');\n * },\n * make_folder: function(callback) {\n * // async code to create a directory to store a file in\n * // this is run at the same time as getting the data\n * callback(null, 'folder');\n * },\n * write_file: function(get_data, make_folder, callback) {\n * // once there is some data and the directory exists,\n * // write the data to a file in the directory\n * callback(null, 'filename');\n * },\n * email_link: function(write_file, callback) {\n * // once the file is written let's email a link to it...\n * // write_file contains the filename returned by write_file.\n * callback(null, {'file':write_file, 'email':'user@example.com'});\n * }\n * }, function(err, results) {\n * console.log('err = ', err);\n * console.log('email_link = ', results.email_link);\n * });\n *\n * // If you are using a JS minifier that mangles parameter names, `autoInject`\n * // will not work with plain functions, since the parameter names will be\n * // collapsed to a single letter identifier. To work around this, you can\n * // explicitly specify the names of the parameters your task function needs\n * // in an array, similar to Angular.js dependency injection.\n *\n * // This still has an advantage over plain `auto`, since the results a task\n * // depends on are still spread into arguments.\n * async.autoInject({\n * //...\n * write_file: ['get_data', 'make_folder', function(get_data, make_folder, callback) {\n * callback(null, 'filename');\n * }],\n * email_link: ['write_file', function(write_file, callback) {\n * callback(null, {'file':write_file, 'email':'user@example.com'});\n * }]\n * //...\n * }, function(err, results) {\n * console.log('err = ', err);\n * console.log('email_link = ', results.email_link);\n * });\n */\n\n\nfunction autoInject(tasks, callback) {\n var newTasks = {};\n Object.keys(tasks).forEach(key => {\n var taskFn = tasks[key];\n var params;\n var fnIsAsync = isAsync(taskFn);\n var hasNoDeps = !fnIsAsync && taskFn.length === 1 || fnIsAsync && taskFn.length === 0;\n\n if (Array.isArray(taskFn)) {\n params = [...taskFn];\n taskFn = params.pop();\n newTasks[key] = params.concat(params.length > 0 ? newTask : taskFn);\n } else if (hasNoDeps) {\n // no dependencies, use the function as-is\n newTasks[key] = taskFn;\n } else {\n params = parseParams(taskFn);\n\n if (taskFn.length === 0 && !fnIsAsync && params.length === 0) {\n throw new Error(\"autoInject task functions require explicit parameters.\");\n } // remove callback param\n\n\n if (!fnIsAsync) params.pop();\n newTasks[key] = params.concat(newTask);\n }\n\n function newTask(results, taskCb) {\n var newArgs = params.map(name => results[name]);\n newArgs.push(taskCb);\n wrapAsync(taskFn)(...newArgs);\n }\n });\n return auto(newTasks, callback);\n} // Simple doubly linked list (https://en.wikipedia.org/wiki/Doubly_linked_list) implementation\n// used for queues. This implementation assumes that the node provided by the user can be modified\n// to adjust the next and last properties. We implement only the minimal functionality\n// for queue support.\n\n\nclass DLL {\n constructor() {\n this.head = this.tail = null;\n this.length = 0;\n }\n\n removeLink(node) {\n if (node.prev) node.prev.next = node.next;else this.head = node.next;\n if (node.next) node.next.prev = node.prev;else this.tail = node.prev;\n node.prev = node.next = null;\n this.length -= 1;\n return node;\n }\n\n empty() {\n while (this.head) this.shift();\n\n return this;\n }\n\n insertAfter(node, newNode) {\n newNode.prev = node;\n newNode.next = node.next;\n if (node.next) node.next.prev = newNode;else this.tail = newNode;\n node.next = newNode;\n this.length += 1;\n }\n\n insertBefore(node, newNode) {\n newNode.prev = node.prev;\n newNode.next = node;\n if (node.prev) node.prev.next = newNode;else this.head = newNode;\n node.prev = newNode;\n this.length += 1;\n }\n\n unshift(node) {\n if (this.head) this.insertBefore(this.head, node);else setInitial(this, node);\n }\n\n push(node) {\n if (this.tail) this.insertAfter(this.tail, node);else setInitial(this, node);\n }\n\n shift() {\n return this.head && this.removeLink(this.head);\n }\n\n pop() {\n return this.tail && this.removeLink(this.tail);\n }\n\n toArray() {\n return [...this];\n }\n\n *[Symbol.iterator]() {\n var cur = this.head;\n\n while (cur) {\n yield cur.data;\n cur = cur.next;\n }\n }\n\n remove(testFn) {\n var curr = this.head;\n\n while (curr) {\n var {\n next\n } = curr;\n\n if (testFn(curr)) {\n this.removeLink(curr);\n }\n\n curr = next;\n }\n\n return this;\n }\n\n}\n\nfunction setInitial(dll, node) {\n dll.length = 1;\n dll.head = dll.tail = node;\n}\n\nfunction queue(worker, concurrency, payload) {\n if (concurrency == null) {\n concurrency = 1;\n } else if (concurrency === 0) {\n throw new RangeError('Concurrency must not be zero');\n }\n\n var _worker = wrapAsync(worker);\n\n var numRunning = 0;\n var workersList = [];\n const events = {\n error: [],\n drain: [],\n saturated: [],\n unsaturated: [],\n empty: []\n };\n\n function on(event, handler) {\n events[event].push(handler);\n }\n\n function once(event, handler) {\n const handleAndRemove = (...args) => {\n off(event, handleAndRemove);\n handler(...args);\n };\n\n events[event].push(handleAndRemove);\n }\n\n function off(event, handler) {\n if (!event) return Object.keys(events).forEach(ev => events[ev] = []);\n if (!handler) return events[event] = [];\n events[event] = events[event].filter(ev => ev !== handler);\n }\n\n function trigger(event, ...args) {\n events[event].forEach(handler => handler(...args));\n }\n\n var processingScheduled = false;\n\n function _insert(data, insertAtFront, rejectOnError, callback) {\n if (callback != null && typeof callback !== 'function') {\n throw new Error('task callback must be a function');\n }\n\n q.started = true;\n var res, rej;\n\n function promiseCallback(err, ...args) {\n // we don't care about the error, let the global error handler\n // deal with it\n if (err) return rejectOnError ? rej(err) : res();\n if (args.length <= 1) return res(args[0]);\n res(args);\n }\n\n var item = {\n data,\n callback: rejectOnError ? promiseCallback : callback || promiseCallback\n };\n\n if (insertAtFront) {\n q._tasks.unshift(item);\n } else {\n q._tasks.push(item);\n }\n\n if (!processingScheduled) {\n processingScheduled = true;\n setImmediate$1(() => {\n processingScheduled = false;\n q.process();\n });\n }\n\n if (rejectOnError || !callback) {\n return new Promise((resolve, reject) => {\n res = resolve;\n rej = reject;\n });\n }\n }\n\n function _createCB(tasks) {\n return function (err, ...args) {\n numRunning -= 1;\n\n for (var i = 0, l = tasks.length; i < l; i++) {\n var task = tasks[i];\n var index = workersList.indexOf(task);\n\n if (index === 0) {\n workersList.shift();\n } else if (index > 0) {\n workersList.splice(index, 1);\n }\n\n task.callback(err, ...args);\n\n if (err != null) {\n trigger('error', err, task.data);\n }\n }\n\n if (numRunning <= q.concurrency - q.buffer) {\n trigger('unsaturated');\n }\n\n if (q.idle()) {\n trigger('drain');\n }\n\n q.process();\n };\n }\n\n function _maybeDrain(data) {\n if (data.length === 0 && q.idle()) {\n // call drain immediately if there are no tasks\n setImmediate$1(() => trigger('drain'));\n return true;\n }\n\n return false;\n }\n\n const eventMethod = name => handler => {\n if (!handler) {\n return new Promise((resolve, reject) => {\n once(name, (err, data) => {\n if (err) return reject(err);\n resolve(data);\n });\n });\n }\n\n off(name);\n on(name, handler);\n };\n\n var isProcessing = false;\n var q = {\n _tasks: new DLL(),\n\n *[Symbol.iterator]() {\n yield* q._tasks[Symbol.iterator]();\n },\n\n concurrency,\n payload,\n buffer: concurrency / 4,\n started: false,\n paused: false,\n\n push(data, callback) {\n if (Array.isArray(data)) {\n if (_maybeDrain(data)) return;\n return data.map(datum => _insert(datum, false, false, callback));\n }\n\n return _insert(data, false, false, callback);\n },\n\n pushAsync(data, callback) {\n if (Array.isArray(data)) {\n if (_maybeDrain(data)) return;\n return data.map(datum => _insert(datum, false, true, callback));\n }\n\n return _insert(data, false, true, callback);\n },\n\n kill() {\n off();\n\n q._tasks.empty();\n },\n\n unshift(data, callback) {\n if (Array.isArray(data)) {\n if (_maybeDrain(data)) return;\n return data.map(datum => _insert(datum, true, false, callback));\n }\n\n return _insert(data, true, false, callback);\n },\n\n unshiftAsync(data, callback) {\n if (Array.isArray(data)) {\n if (_maybeDrain(data)) return;\n return data.map(datum => _insert(datum, true, true, callback));\n }\n\n return _insert(data, true, true, callback);\n },\n\n remove(testFn) {\n q._tasks.remove(testFn);\n },\n\n process() {\n // Avoid trying to start too many processing operations. This can occur\n // when callbacks resolve synchronously (#1267).\n if (isProcessing) {\n return;\n }\n\n isProcessing = true;\n\n while (!q.paused && numRunning < q.concurrency && q._tasks.length) {\n var tasks = [],\n data = [];\n var l = q._tasks.length;\n if (q.payload) l = Math.min(l, q.payload);\n\n for (var i = 0; i < l; i++) {\n var node = q._tasks.shift();\n\n tasks.push(node);\n workersList.push(node);\n data.push(node.data);\n }\n\n numRunning += 1;\n\n if (q._tasks.length === 0) {\n trigger('empty');\n }\n\n if (numRunning === q.concurrency) {\n trigger('saturated');\n }\n\n var cb = onlyOnce(_createCB(tasks));\n\n _worker(data, cb);\n }\n\n isProcessing = false;\n },\n\n length() {\n return q._tasks.length;\n },\n\n running() {\n return numRunning;\n },\n\n workersList() {\n return workersList;\n },\n\n idle() {\n return q._tasks.length + numRunning === 0;\n },\n\n pause() {\n q.paused = true;\n },\n\n resume() {\n if (q.paused === false) {\n return;\n }\n\n q.paused = false;\n setImmediate$1(q.process);\n }\n\n }; // define these as fixed properties, so people get useful errors when updating\n\n Object.defineProperties(q, {\n saturated: {\n writable: false,\n value: eventMethod('saturated')\n },\n unsaturated: {\n writable: false,\n value: eventMethod('unsaturated')\n },\n empty: {\n writable: false,\n value: eventMethod('empty')\n },\n drain: {\n writable: false,\n value: eventMethod('drain')\n },\n error: {\n writable: false,\n value: eventMethod('error')\n }\n });\n return q;\n}\n/**\n * Creates a `cargo` object with the specified payload. Tasks added to the\n * cargo will be processed altogether (up to the `payload` limit). If the\n * `worker` is in progress, the task is queued until it becomes available. Once\n * the `worker` has completed some tasks, each callback of those tasks is\n * called. Check out [these](https://camo.githubusercontent.com/6bbd36f4cf5b35a0f11a96dcd2e97711ffc2fb37/68747470733a2f2f662e636c6f75642e6769746875622e636f6d2f6173736574732f313637363837312f36383130382f62626330636662302d356632392d313165322d393734662d3333393763363464633835382e676966) [animations](https://camo.githubusercontent.com/f4810e00e1c5f5f8addbe3e9f49064fd5d102699/68747470733a2f2f662e636c6f75642e6769746875622e636f6d2f6173736574732f313637363837312f36383130312f38346339323036362d356632392d313165322d383134662d3964336430323431336266642e676966)\n * for how `cargo` and `queue` work.\n *\n * While [`queue`]{@link module:ControlFlow.queue} passes only one task to one of a group of workers\n * at a time, cargo passes an array of tasks to a single worker, repeating\n * when the worker is finished.\n *\n * @name cargo\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.queue]{@link module:ControlFlow.queue}\n * @category Control Flow\n * @param {AsyncFunction} worker - An asynchronous function for processing an array\n * of queued tasks. Invoked with `(tasks, callback)`.\n * @param {number} [payload=Infinity] - An optional `integer` for determining\n * how many tasks should be processed per round; if omitted, the default is\n * unlimited.\n * @returns {module:ControlFlow.QueueObject} A cargo object to manage the tasks. Callbacks can\n * attached as certain properties to listen for specific events during the\n * lifecycle of the cargo and inner queue.\n * @example\n *\n * // create a cargo object with payload 2\n * var cargo = async.cargo(function(tasks, callback) {\n * for (var i=0; i {\n * console.log(result);\n * // 6000\n * // which is the sum of the file sizes of the three files\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * // Error Handling\n * async.reduce(withMissingFileList, 0, getFileSizeInBytes)\n * .then( result => {\n * console.log(result);\n * }).catch( err => {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let result = await async.reduce(fileList, 0, getFileSizeInBytes);\n * console.log(result);\n * // 6000\n * // which is the sum of the file sizes of the three files\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * // Error Handling\n * async () => {\n * try {\n * let result = await async.reduce(withMissingFileList, 0, getFileSizeInBytes);\n * console.log(result);\n * }\n * catch (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * }\n * }\n *\n */\n\n\nfunction reduce(coll, memo, iteratee, callback) {\n callback = once(callback);\n\n var _iteratee = wrapAsync(iteratee);\n\n return eachOfSeries$1(coll, (x, i, iterCb) => {\n _iteratee(memo, x, (err, v) => {\n memo = v;\n iterCb(err);\n });\n }, err => callback(err, memo));\n}\n\nvar reduce$1 = awaitify(reduce, 4);\n/**\n * Version of the compose function that is more natural to read. Each function\n * consumes the return value of the previous function. It is the equivalent of\n * [compose]{@link module:ControlFlow.compose} with the arguments reversed.\n *\n * Each function is executed with the `this` binding of the composed function.\n *\n * @name seq\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.compose]{@link module:ControlFlow.compose}\n * @category Control Flow\n * @param {...AsyncFunction} functions - the asynchronous functions to compose\n * @returns {Function} a function that composes the `functions` in order\n * @example\n *\n * // Requires lodash (or underscore), express3 and dresende's orm2.\n * // Part of an app, that fetches cats of the logged user.\n * // This example uses `seq` function to avoid overnesting and error\n * // handling clutter.\n * app.get('/cats', function(request, response) {\n * var User = request.models.User;\n * async.seq(\n * _.bind(User.get, User), // 'User.get' has signature (id, callback(err, data))\n * function(user, fn) {\n * user.getCats(fn); // 'getCats' has signature (callback(err, data))\n * }\n * )(req.session.user_id, function (err, cats) {\n * if (err) {\n * console.error(err);\n * response.json({ status: 'error', message: err.message });\n * } else {\n * response.json({ status: 'ok', message: 'Cats found', data: cats });\n * }\n * });\n * });\n */\n\nfunction seq(...functions) {\n var _functions = functions.map(wrapAsync);\n\n return function (...args) {\n var that = this;\n var cb = args[args.length - 1];\n\n if (typeof cb == 'function') {\n args.pop();\n } else {\n cb = promiseCallback();\n }\n\n reduce$1(_functions, args, (newargs, fn, iterCb) => {\n fn.apply(that, newargs.concat((err, ...nextargs) => {\n iterCb(err, nextargs);\n }));\n }, (err, results) => cb(err, ...results));\n return cb[PROMISE_SYMBOL];\n };\n}\n/**\n * Creates a function which is a composition of the passed asynchronous\n * functions. Each function consumes the return value of the function that\n * follows. Composing functions `f()`, `g()`, and `h()` would produce the result\n * of `f(g(h()))`, only this version uses callbacks to obtain the return values.\n *\n * If the last argument to the composed function is not a function, a promise\n * is returned when you call it.\n *\n * Each function is executed with the `this` binding of the composed function.\n *\n * @name compose\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {...AsyncFunction} functions - the asynchronous functions to compose\n * @returns {Function} an asynchronous function that is the composed\n * asynchronous `functions`\n * @example\n *\n * function add1(n, callback) {\n * setTimeout(function () {\n * callback(null, n + 1);\n * }, 10);\n * }\n *\n * function mul3(n, callback) {\n * setTimeout(function () {\n * callback(null, n * 3);\n * }, 10);\n * }\n *\n * var add1mul3 = async.compose(mul3, add1);\n * add1mul3(4, function (err, result) {\n * // result now equals 15\n * });\n */\n\n\nfunction compose(...args) {\n return seq(...args.reverse());\n}\n/**\n * The same as [`map`]{@link module:Collections.map} but runs a maximum of `limit` async operations at a time.\n *\n * @name mapLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.map]{@link module:Collections.map}\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * The iteratee should complete with the transformed item.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. Results is an array of the\n * transformed items from the `coll`. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback is passed\n */\n\n\nfunction mapLimit(coll, limit, iteratee, callback) {\n return _asyncMap(eachOfLimit(limit), coll, iteratee, callback);\n}\n\nvar mapLimit$1 = awaitify(mapLimit, 4);\n/**\n * The same as [`concat`]{@link module:Collections.concat} but runs a maximum of `limit` async operations at a time.\n *\n * @name concatLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.concat]{@link module:Collections.concat}\n * @category Collection\n * @alias flatMapLimit\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - A function to apply to each item in `coll`,\n * which should use an array as its result. Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished, or an error occurs. Results is an array\n * containing the concatenated results of the `iteratee` function. Invoked with\n * (err, results).\n * @returns A Promise, if no callback is passed\n */\n\nfunction concatLimit(coll, limit, iteratee, callback) {\n var _iteratee = wrapAsync(iteratee);\n\n return mapLimit$1(coll, limit, (val, iterCb) => {\n _iteratee(val, (err, ...args) => {\n if (err) return iterCb(err);\n return iterCb(err, args);\n });\n }, (err, mapResults) => {\n var result = [];\n\n for (var i = 0; i < mapResults.length; i++) {\n if (mapResults[i]) {\n result = result.concat(...mapResults[i]);\n }\n }\n\n return callback(err, result);\n });\n}\n\nvar concatLimit$1 = awaitify(concatLimit, 4);\n/**\n * Applies `iteratee` to each item in `coll`, concatenating the results. Returns\n * the concatenated list. The `iteratee`s are called in parallel, and the\n * results are concatenated as they return. The results array will be returned in\n * the original order of `coll` passed to the `iteratee` function.\n *\n * @name concat\n * @static\n * @memberOf module:Collections\n * @method\n * @category Collection\n * @alias flatMap\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - A function to apply to each item in `coll`,\n * which should use an array as its result. Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished, or an error occurs. Results is an array\n * containing the concatenated results of the `iteratee` function. Invoked with\n * (err, results).\n * @returns A Promise, if no callback is passed\n * @example\n *\n * // dir1 is a directory that contains file1.txt, file2.txt\n * // dir2 is a directory that contains file3.txt, file4.txt\n * // dir3 is a directory that contains file5.txt\n * // dir4 does not exist\n *\n * let directoryList = ['dir1','dir2','dir3'];\n * let withMissingDirectoryList = ['dir1','dir2','dir3', 'dir4'];\n *\n * // Using callbacks\n * async.concat(directoryList, fs.readdir, function(err, results) {\n * if (err) {\n * console.log(err);\n * } else {\n * console.log(results);\n * // [ 'file1.txt', 'file2.txt', 'file3.txt', 'file4.txt', file5.txt ]\n * }\n * });\n *\n * // Error Handling\n * async.concat(withMissingDirectoryList, fs.readdir, function(err, results) {\n * if (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * // since dir4 does not exist\n * } else {\n * console.log(results);\n * }\n * });\n *\n * // Using Promises\n * async.concat(directoryList, fs.readdir)\n * .then(results => {\n * console.log(results);\n * // [ 'file1.txt', 'file2.txt', 'file3.txt', 'file4.txt', file5.txt ]\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * // Error Handling\n * async.concat(withMissingDirectoryList, fs.readdir)\n * .then(results => {\n * console.log(results);\n * }).catch(err => {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * // since dir4 does not exist\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let results = await async.concat(directoryList, fs.readdir);\n * console.log(results);\n * // [ 'file1.txt', 'file2.txt', 'file3.txt', 'file4.txt', file5.txt ]\n * } catch (err) {\n * console.log(err);\n * }\n * }\n *\n * // Error Handling\n * async () => {\n * try {\n * let results = await async.concat(withMissingDirectoryList, fs.readdir);\n * console.log(results);\n * } catch (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * // since dir4 does not exist\n * }\n * }\n *\n */\n\nfunction concat(coll, iteratee, callback) {\n return concatLimit$1(coll, Infinity, iteratee, callback);\n}\n\nvar concat$1 = awaitify(concat, 3);\n/**\n * The same as [`concat`]{@link module:Collections.concat} but runs only a single async operation at a time.\n *\n * @name concatSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.concat]{@link module:Collections.concat}\n * @category Collection\n * @alias flatMapSeries\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - A function to apply to each item in `coll`.\n * The iteratee should complete with an array an array of results.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished, or an error occurs. Results is an array\n * containing the concatenated results of the `iteratee` function. Invoked with\n * (err, results).\n * @returns A Promise, if no callback is passed\n */\n\nfunction concatSeries(coll, iteratee, callback) {\n return concatLimit$1(coll, 1, iteratee, callback);\n}\n\nvar concatSeries$1 = awaitify(concatSeries, 3);\n/**\n * Returns a function that when called, calls-back with the values provided.\n * Useful as the first function in a [`waterfall`]{@link module:ControlFlow.waterfall}, or for plugging values in to\n * [`auto`]{@link module:ControlFlow.auto}.\n *\n * @name constant\n * @static\n * @memberOf module:Utils\n * @method\n * @category Util\n * @param {...*} arguments... - Any number of arguments to automatically invoke\n * callback with.\n * @returns {AsyncFunction} Returns a function that when invoked, automatically\n * invokes the callback with the previous given arguments.\n * @example\n *\n * async.waterfall([\n * async.constant(42),\n * function (value, next) {\n * // value === 42\n * },\n * //...\n * ], callback);\n *\n * async.waterfall([\n * async.constant(filename, \"utf8\"),\n * fs.readFile,\n * function (fileData, next) {\n * //...\n * }\n * //...\n * ], callback);\n *\n * async.auto({\n * hostname: async.constant(\"https://server.net/\"),\n * port: findFreePort,\n * launchServer: [\"hostname\", \"port\", function (options, cb) {\n * startServer(options, cb);\n * }],\n * //...\n * }, callback);\n */\n\nfunction constant(...args) {\n return function (...ignoredArgs\n /*, callback*/\n ) {\n var callback = ignoredArgs.pop();\n return callback(null, ...args);\n };\n}\n\nfunction _createTester(check, getResult) {\n return (eachfn, arr, _iteratee, cb) => {\n var testPassed = false;\n var testResult;\n const iteratee = wrapAsync(_iteratee);\n eachfn(arr, (value, _, callback) => {\n iteratee(value, (err, result) => {\n if (err || err === false) return callback(err);\n\n if (check(result) && !testResult) {\n testPassed = true;\n testResult = getResult(true, value);\n return callback(null, breakLoop);\n }\n\n callback();\n });\n }, err => {\n if (err) return cb(err);\n cb(null, testPassed ? testResult : getResult(false));\n });\n };\n}\n/**\n * Returns the first value in `coll` that passes an async truth test. The\n * `iteratee` is applied in parallel, meaning the first iteratee to return\n * `true` will fire the detect `callback` with that result. That means the\n * result might not be the first item in the original `coll` (in terms of order)\n * that passes the test.\n\n * If order within the original `coll` is important, then look at\n * [`detectSeries`]{@link module:Collections.detectSeries}.\n *\n * @name detect\n * @static\n * @memberOf module:Collections\n * @method\n * @alias find\n * @category Collections\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - A truth test to apply to each item in `coll`.\n * The iteratee must complete with a boolean value as its result.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called as soon as any\n * iteratee returns `true`, or after all the `iteratee` functions have finished.\n * Result will be the first item in the array that passes the truth test\n * (iteratee) or the value `undefined` if none passed. Invoked with\n * (err, result).\n * @returns A Promise, if no callback is passed\n * @example\n *\n * // dir1 is a directory that contains file1.txt, file2.txt\n * // dir2 is a directory that contains file3.txt, file4.txt\n * // dir3 is a directory that contains file5.txt\n *\n * // asynchronous function that checks if a file exists\n * function fileExists(file, callback) {\n * fs.access(file, fs.constants.F_OK, (err) => {\n * callback(null, !err);\n * });\n * }\n *\n * async.detect(['file3.txt','file2.txt','dir1/file1.txt'], fileExists,\n * function(err, result) {\n * console.log(result);\n * // dir1/file1.txt\n * // result now equals the first file in the list that exists\n * }\n *);\n *\n * // Using Promises\n * async.detect(['file3.txt','file2.txt','dir1/file1.txt'], fileExists)\n * .then(result => {\n * console.log(result);\n * // dir1/file1.txt\n * // result now equals the first file in the list that exists\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let result = await async.detect(['file3.txt','file2.txt','dir1/file1.txt'], fileExists);\n * console.log(result);\n * // dir1/file1.txt\n * // result now equals the file in the list that exists\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\n\n\nfunction detect(coll, iteratee, callback) {\n return _createTester(bool => bool, (res, item) => item)(eachOf$1, coll, iteratee, callback);\n}\n\nvar detect$1 = awaitify(detect, 3);\n/**\n * The same as [`detect`]{@link module:Collections.detect} but runs a maximum of `limit` async operations at a\n * time.\n *\n * @name detectLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.detect]{@link module:Collections.detect}\n * @alias findLimit\n * @category Collections\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - A truth test to apply to each item in `coll`.\n * The iteratee must complete with a boolean value as its result.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called as soon as any\n * iteratee returns `true`, or after all the `iteratee` functions have finished.\n * Result will be the first item in the array that passes the truth test\n * (iteratee) or the value `undefined` if none passed. Invoked with\n * (err, result).\n * @returns a Promise if no callback is passed\n */\n\nfunction detectLimit(coll, limit, iteratee, callback) {\n return _createTester(bool => bool, (res, item) => item)(eachOfLimit(limit), coll, iteratee, callback);\n}\n\nvar detectLimit$1 = awaitify(detectLimit, 4);\n/**\n * The same as [`detect`]{@link module:Collections.detect} but runs only a single async operation at a time.\n *\n * @name detectSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.detect]{@link module:Collections.detect}\n * @alias findSeries\n * @category Collections\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - A truth test to apply to each item in `coll`.\n * The iteratee must complete with a boolean value as its result.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called as soon as any\n * iteratee returns `true`, or after all the `iteratee` functions have finished.\n * Result will be the first item in the array that passes the truth test\n * (iteratee) or the value `undefined` if none passed. Invoked with\n * (err, result).\n * @returns a Promise if no callback is passed\n */\n\nfunction detectSeries(coll, iteratee, callback) {\n return _createTester(bool => bool, (res, item) => item)(eachOfLimit(1), coll, iteratee, callback);\n}\n\nvar detectSeries$1 = awaitify(detectSeries, 3);\n\nfunction consoleFunc(name) {\n return (fn, ...args) => wrapAsync(fn)(...args, (err, ...resultArgs) => {\n /* istanbul ignore else */\n if (typeof console === 'object') {\n /* istanbul ignore else */\n if (err) {\n /* istanbul ignore else */\n if (console.error) {\n console.error(err);\n }\n } else if (console[name]) {\n /* istanbul ignore else */\n resultArgs.forEach(x => console[name](x));\n }\n }\n });\n}\n/**\n * Logs the result of an [`async` function]{@link AsyncFunction} to the\n * `console` using `console.dir` to display the properties of the resulting object.\n * Only works in Node.js or in browsers that support `console.dir` and\n * `console.error` (such as FF and Chrome).\n * If multiple arguments are returned from the async function,\n * `console.dir` is called on each argument in order.\n *\n * @name dir\n * @static\n * @memberOf module:Utils\n * @method\n * @category Util\n * @param {AsyncFunction} function - The function you want to eventually apply\n * all arguments to.\n * @param {...*} arguments... - Any number of arguments to apply to the function.\n * @example\n *\n * // in a module\n * var hello = function(name, callback) {\n * setTimeout(function() {\n * callback(null, {hello: name});\n * }, 1000);\n * };\n *\n * // in the node repl\n * node> async.dir(hello, 'world');\n * {hello: 'world'}\n */\n\n\nvar dir = consoleFunc('dir');\n/**\n * The post-check version of [`whilst`]{@link module:ControlFlow.whilst}. To reflect the difference in\n * the order of operations, the arguments `test` and `iteratee` are switched.\n *\n * `doWhilst` is to `whilst` as `do while` is to `while` in plain JavaScript.\n *\n * @name doWhilst\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.whilst]{@link module:ControlFlow.whilst}\n * @category Control Flow\n * @param {AsyncFunction} iteratee - A function which is called each time `test`\n * passes. Invoked with (callback).\n * @param {AsyncFunction} test - asynchronous truth test to perform after each\n * execution of `iteratee`. Invoked with (...args, callback), where `...args` are the\n * non-error args from the previous callback of `iteratee`.\n * @param {Function} [callback] - A callback which is called after the test\n * function has failed and repeated execution of `iteratee` has stopped.\n * `callback` will be passed an error and any arguments passed to the final\n * `iteratee`'s callback. Invoked with (err, [results]);\n * @returns {Promise} a promise, if no callback is passed\n */\n\nfunction doWhilst(iteratee, test, callback) {\n callback = onlyOnce(callback);\n\n var _fn = wrapAsync(iteratee);\n\n var _test = wrapAsync(test);\n\n var results;\n\n function next(err, ...args) {\n if (err) return callback(err);\n if (err === false) return;\n results = args;\n\n _test(...args, check);\n }\n\n function check(err, truth) {\n if (err) return callback(err);\n if (err === false) return;\n if (!truth) return callback(null, ...results);\n\n _fn(next);\n }\n\n return check(null, true);\n}\n\nvar doWhilst$1 = awaitify(doWhilst, 3);\n/**\n * Like ['doWhilst']{@link module:ControlFlow.doWhilst}, except the `test` is inverted. Note the\n * argument ordering differs from `until`.\n *\n * @name doUntil\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.doWhilst]{@link module:ControlFlow.doWhilst}\n * @category Control Flow\n * @param {AsyncFunction} iteratee - An async function which is called each time\n * `test` fails. Invoked with (callback).\n * @param {AsyncFunction} test - asynchronous truth test to perform after each\n * execution of `iteratee`. Invoked with (...args, callback), where `...args` are the\n * non-error args from the previous callback of `iteratee`\n * @param {Function} [callback] - A callback which is called after the test\n * function has passed and repeated execution of `iteratee` has stopped. `callback`\n * will be passed an error and any arguments passed to the final `iteratee`'s\n * callback. Invoked with (err, [results]);\n * @returns {Promise} a promise, if no callback is passed\n */\n\nfunction doUntil(iteratee, test, callback) {\n const _test = wrapAsync(test);\n\n return doWhilst$1(iteratee, (...args) => {\n const cb = args.pop();\n\n _test(...args, (err, truth) => cb(err, !truth));\n }, callback);\n}\n\nfunction _withoutIndex(iteratee) {\n return (value, index, callback) => iteratee(value, callback);\n}\n/**\n * Applies the function `iteratee` to each item in `coll`, in parallel.\n * The `iteratee` is called with an item from the list, and a callback for when\n * it has finished. If the `iteratee` passes an error to its `callback`, the\n * main `callback` (for the `each` function) is immediately called with the\n * error.\n *\n * Note, that since this function applies `iteratee` to each item in parallel,\n * there is no guarantee that the iteratee functions will complete in order.\n *\n * @name each\n * @static\n * @memberOf module:Collections\n * @method\n * @alias forEach\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async function to apply to\n * each item in `coll`. Invoked with (item, callback).\n * The array index is not passed to the iteratee.\n * If you need the index, use `eachOf`.\n * @param {Function} [callback] - A callback which is called when all\n * `iteratee` functions have finished, or an error occurs. Invoked with (err).\n * @returns {Promise} a promise, if a callback is omitted\n * @example\n *\n * // dir1 is a directory that contains file1.txt, file2.txt\n * // dir2 is a directory that contains file3.txt, file4.txt\n * // dir3 is a directory that contains file5.txt\n * // dir4 does not exist\n *\n * const fileList = [ 'dir1/file2.txt', 'dir2/file3.txt', 'dir/file5.txt'];\n * const withMissingFileList = ['dir1/file1.txt', 'dir4/file2.txt'];\n *\n * // asynchronous function that deletes a file\n * const deleteFile = function(file, callback) {\n * fs.unlink(file, callback);\n * };\n *\n * // Using callbacks\n * async.each(fileList, deleteFile, function(err) {\n * if( err ) {\n * console.log(err);\n * } else {\n * console.log('All files have been deleted successfully');\n * }\n * });\n *\n * // Error Handling\n * async.each(withMissingFileList, deleteFile, function(err){\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * // since dir4/file2.txt does not exist\n * // dir1/file1.txt could have been deleted\n * });\n *\n * // Using Promises\n * async.each(fileList, deleteFile)\n * .then( () => {\n * console.log('All files have been deleted successfully');\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * // Error Handling\n * async.each(fileList, deleteFile)\n * .then( () => {\n * console.log('All files have been deleted successfully');\n * }).catch( err => {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * // since dir4/file2.txt does not exist\n * // dir1/file1.txt could have been deleted\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * await async.each(files, deleteFile);\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * // Error Handling\n * async () => {\n * try {\n * await async.each(withMissingFileList, deleteFile);\n * }\n * catch (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * // since dir4/file2.txt does not exist\n * // dir1/file1.txt could have been deleted\n * }\n * }\n *\n */\n\n\nfunction eachLimit(coll, iteratee, callback) {\n return eachOf$1(coll, _withoutIndex(wrapAsync(iteratee)), callback);\n}\n\nvar each = awaitify(eachLimit, 3);\n/**\n * The same as [`each`]{@link module:Collections.each} but runs a maximum of `limit` async operations at a time.\n *\n * @name eachLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.each]{@link module:Collections.each}\n * @alias forEachLimit\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * The array index is not passed to the iteratee.\n * If you need the index, use `eachOfLimit`.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called when all\n * `iteratee` functions have finished, or an error occurs. Invoked with (err).\n * @returns {Promise} a promise, if a callback is omitted\n */\n\nfunction eachLimit$1(coll, limit, iteratee, callback) {\n return eachOfLimit(limit)(coll, _withoutIndex(wrapAsync(iteratee)), callback);\n}\n\nvar eachLimit$2 = awaitify(eachLimit$1, 4);\n/**\n * The same as [`each`]{@link module:Collections.each} but runs only a single async operation at a time.\n *\n * Note, that unlike [`each`]{@link module:Collections.each}, this function applies iteratee to each item\n * in series and therefore the iteratee functions will complete in order.\n\n * @name eachSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.each]{@link module:Collections.each}\n * @alias forEachSeries\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async function to apply to each\n * item in `coll`.\n * The array index is not passed to the iteratee.\n * If you need the index, use `eachOfSeries`.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called when all\n * `iteratee` functions have finished, or an error occurs. Invoked with (err).\n * @returns {Promise} a promise, if a callback is omitted\n */\n\nfunction eachSeries(coll, iteratee, callback) {\n return eachLimit$2(coll, 1, iteratee, callback);\n}\n\nvar eachSeries$1 = awaitify(eachSeries, 3);\n/**\n * Wrap an async function and ensure it calls its callback on a later tick of\n * the event loop. If the function already calls its callback on a next tick,\n * no extra deferral is added. This is useful for preventing stack overflows\n * (`RangeError: Maximum call stack size exceeded`) and generally keeping\n * [Zalgo](http://blog.izs.me/post/59142742143/designing-apis-for-asynchrony)\n * contained. ES2017 `async` functions are returned as-is -- they are immune\n * to Zalgo's corrupting influences, as they always resolve on a later tick.\n *\n * @name ensureAsync\n * @static\n * @memberOf module:Utils\n * @method\n * @category Util\n * @param {AsyncFunction} fn - an async function, one that expects a node-style\n * callback as its last argument.\n * @returns {AsyncFunction} Returns a wrapped function with the exact same call\n * signature as the function passed in.\n * @example\n *\n * function sometimesAsync(arg, callback) {\n * if (cache[arg]) {\n * return callback(null, cache[arg]); // this would be synchronous!!\n * } else {\n * doSomeIO(arg, callback); // this IO would be asynchronous\n * }\n * }\n *\n * // this has a risk of stack overflows if many results are cached in a row\n * async.mapSeries(args, sometimesAsync, done);\n *\n * // this will defer sometimesAsync's callback if necessary,\n * // preventing stack overflows\n * async.mapSeries(args, async.ensureAsync(sometimesAsync), done);\n */\n\nfunction ensureAsync(fn) {\n if (isAsync(fn)) return fn;\n return function (...args\n /*, callback*/\n ) {\n var callback = args.pop();\n var sync = true;\n args.push((...innerArgs) => {\n if (sync) {\n setImmediate$1(() => callback(...innerArgs));\n } else {\n callback(...innerArgs);\n }\n });\n fn.apply(this, args);\n sync = false;\n };\n}\n/**\n * Returns `true` if every element in `coll` satisfies an async test. If any\n * iteratee call returns `false`, the main `callback` is immediately called.\n *\n * @name every\n * @static\n * @memberOf module:Collections\n * @method\n * @alias all\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async truth test to apply to each item\n * in the collection in parallel.\n * The iteratee must complete with a boolean result value.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Result will be either `true` or `false`\n * depending on the values of the async tests. Invoked with (err, result).\n * @returns {Promise} a promise, if no callback provided\n * @example\n *\n * // dir1 is a directory that contains file1.txt, file2.txt\n * // dir2 is a directory that contains file3.txt, file4.txt\n * // dir3 is a directory that contains file5.txt\n * // dir4 does not exist\n *\n * const fileList = ['dir1/file1.txt','dir2/file3.txt','dir3/file5.txt'];\n * const withMissingFileList = ['file1.txt','file2.txt','file4.txt'];\n *\n * // asynchronous function that checks if a file exists\n * function fileExists(file, callback) {\n * fs.access(file, fs.constants.F_OK, (err) => {\n * callback(null, !err);\n * });\n * }\n *\n * // Using callbacks\n * async.every(fileList, fileExists, function(err, result) {\n * console.log(result);\n * // true\n * // result is true since every file exists\n * });\n *\n * async.every(withMissingFileList, fileExists, function(err, result) {\n * console.log(result);\n * // false\n * // result is false since NOT every file exists\n * });\n *\n * // Using Promises\n * async.every(fileList, fileExists)\n * .then( result => {\n * console.log(result);\n * // true\n * // result is true since every file exists\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * async.every(withMissingFileList, fileExists)\n * .then( result => {\n * console.log(result);\n * // false\n * // result is false since NOT every file exists\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let result = await async.every(fileList, fileExists);\n * console.log(result);\n * // true\n * // result is true since every file exists\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * async () => {\n * try {\n * let result = await async.every(withMissingFileList, fileExists);\n * console.log(result);\n * // false\n * // result is false since NOT every file exists\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\n\n\nfunction every(coll, iteratee, callback) {\n return _createTester(bool => !bool, res => !res)(eachOf$1, coll, iteratee, callback);\n}\n\nvar every$1 = awaitify(every, 3);\n/**\n * The same as [`every`]{@link module:Collections.every} but runs a maximum of `limit` async operations at a time.\n *\n * @name everyLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.every]{@link module:Collections.every}\n * @alias allLimit\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - An async truth test to apply to each item\n * in the collection in parallel.\n * The iteratee must complete with a boolean result value.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Result will be either `true` or `false`\n * depending on the values of the async tests. Invoked with (err, result).\n * @returns {Promise} a promise, if no callback provided\n */\n\nfunction everyLimit(coll, limit, iteratee, callback) {\n return _createTester(bool => !bool, res => !res)(eachOfLimit(limit), coll, iteratee, callback);\n}\n\nvar everyLimit$1 = awaitify(everyLimit, 4);\n/**\n * The same as [`every`]{@link module:Collections.every} but runs only a single async operation at a time.\n *\n * @name everySeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.every]{@link module:Collections.every}\n * @alias allSeries\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async truth test to apply to each item\n * in the collection in series.\n * The iteratee must complete with a boolean result value.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Result will be either `true` or `false`\n * depending on the values of the async tests. Invoked with (err, result).\n * @returns {Promise} a promise, if no callback provided\n */\n\nfunction everySeries(coll, iteratee, callback) {\n return _createTester(bool => !bool, res => !res)(eachOfSeries$1, coll, iteratee, callback);\n}\n\nvar everySeries$1 = awaitify(everySeries, 3);\n\nfunction filterArray(eachfn, arr, iteratee, callback) {\n var truthValues = new Array(arr.length);\n eachfn(arr, (x, index, iterCb) => {\n iteratee(x, (err, v) => {\n truthValues[index] = !!v;\n iterCb(err);\n });\n }, err => {\n if (err) return callback(err);\n var results = [];\n\n for (var i = 0; i < arr.length; i++) {\n if (truthValues[i]) results.push(arr[i]);\n }\n\n callback(null, results);\n });\n}\n\nfunction filterGeneric(eachfn, coll, iteratee, callback) {\n var results = [];\n eachfn(coll, (x, index, iterCb) => {\n iteratee(x, (err, v) => {\n if (err) return iterCb(err);\n\n if (v) {\n results.push({\n index,\n value: x\n });\n }\n\n iterCb(err);\n });\n }, err => {\n if (err) return callback(err);\n callback(null, results.sort((a, b) => a.index - b.index).map(v => v.value));\n });\n}\n\nfunction _filter(eachfn, coll, iteratee, callback) {\n var filter = isArrayLike(coll) ? filterArray : filterGeneric;\n return filter(eachfn, coll, wrapAsync(iteratee), callback);\n}\n/**\n * Returns a new array of all the values in `coll` which pass an async truth\n * test. This operation is performed in parallel, but the results array will be\n * in the same order as the original.\n *\n * @name filter\n * @static\n * @memberOf module:Collections\n * @method\n * @alias select\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {Function} iteratee - A truth test to apply to each item in `coll`.\n * The `iteratee` is passed a `callback(err, truthValue)`, which must be called\n * with a boolean argument once it has completed. Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback provided\n * @example\n *\n * // dir1 is a directory that contains file1.txt, file2.txt\n * // dir2 is a directory that contains file3.txt, file4.txt\n * // dir3 is a directory that contains file5.txt\n *\n * const files = ['dir1/file1.txt','dir2/file3.txt','dir3/file6.txt'];\n *\n * // asynchronous function that checks if a file exists\n * function fileExists(file, callback) {\n * fs.access(file, fs.constants.F_OK, (err) => {\n * callback(null, !err);\n * });\n * }\n *\n * // Using callbacks\n * async.filter(files, fileExists, function(err, results) {\n * if(err) {\n * console.log(err);\n * } else {\n * console.log(results);\n * // [ 'dir1/file1.txt', 'dir2/file3.txt' ]\n * // results is now an array of the existing files\n * }\n * });\n *\n * // Using Promises\n * async.filter(files, fileExists)\n * .then(results => {\n * console.log(results);\n * // [ 'dir1/file1.txt', 'dir2/file3.txt' ]\n * // results is now an array of the existing files\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let results = await async.filter(files, fileExists);\n * console.log(results);\n * // [ 'dir1/file1.txt', 'dir2/file3.txt' ]\n * // results is now an array of the existing files\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\n\n\nfunction filter(coll, iteratee, callback) {\n return _filter(eachOf$1, coll, iteratee, callback);\n}\n\nvar filter$1 = awaitify(filter, 3);\n/**\n * The same as [`filter`]{@link module:Collections.filter} but runs a maximum of `limit` async operations at a\n * time.\n *\n * @name filterLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.filter]{@link module:Collections.filter}\n * @alias selectLimit\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {Function} iteratee - A truth test to apply to each item in `coll`.\n * The `iteratee` is passed a `callback(err, truthValue)`, which must be called\n * with a boolean argument once it has completed. Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback provided\n */\n\nfunction filterLimit(coll, limit, iteratee, callback) {\n return _filter(eachOfLimit(limit), coll, iteratee, callback);\n}\n\nvar filterLimit$1 = awaitify(filterLimit, 4);\n/**\n * The same as [`filter`]{@link module:Collections.filter} but runs only a single async operation at a time.\n *\n * @name filterSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.filter]{@link module:Collections.filter}\n * @alias selectSeries\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {Function} iteratee - A truth test to apply to each item in `coll`.\n * The `iteratee` is passed a `callback(err, truthValue)`, which must be called\n * with a boolean argument once it has completed. Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Invoked with (err, results)\n * @returns {Promise} a promise, if no callback provided\n */\n\nfunction filterSeries(coll, iteratee, callback) {\n return _filter(eachOfSeries$1, coll, iteratee, callback);\n}\n\nvar filterSeries$1 = awaitify(filterSeries, 3);\n/**\n * Calls the asynchronous function `fn` with a callback parameter that allows it\n * to call itself again, in series, indefinitely.\n\n * If an error is passed to the callback then `errback` is called with the\n * error, and execution stops, otherwise it will never be called.\n *\n * @name forever\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {AsyncFunction} fn - an async function to call repeatedly.\n * Invoked with (next).\n * @param {Function} [errback] - when `fn` passes an error to it's callback,\n * this function will be called, and execution stops. Invoked with (err).\n * @returns {Promise} a promise that rejects if an error occurs and an errback\n * is not passed\n * @example\n *\n * async.forever(\n * function(next) {\n * // next is suitable for passing to things that need a callback(err [, whatever]);\n * // it will result in this function being called again.\n * },\n * function(err) {\n * // if next is called with a value in its first parameter, it will appear\n * // in here as 'err', and execution will stop.\n * }\n * );\n */\n\nfunction forever(fn, errback) {\n var done = onlyOnce(errback);\n var task = wrapAsync(ensureAsync(fn));\n\n function next(err) {\n if (err) return done(err);\n if (err === false) return;\n task(next);\n }\n\n return next();\n}\n\nvar forever$1 = awaitify(forever, 2);\n/**\n * The same as [`groupBy`]{@link module:Collections.groupBy} but runs a maximum of `limit` async operations at a time.\n *\n * @name groupByLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.groupBy]{@link module:Collections.groupBy}\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * The iteratee should complete with a `key` to group the value under.\n * Invoked with (value, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. Result is an `Object` whoses\n * properties are arrays of values which returned the corresponding key.\n * @returns {Promise} a promise, if no callback is passed\n */\n\nfunction groupByLimit(coll, limit, iteratee, callback) {\n var _iteratee = wrapAsync(iteratee);\n\n return mapLimit$1(coll, limit, (val, iterCb) => {\n _iteratee(val, (err, key) => {\n if (err) return iterCb(err);\n return iterCb(err, {\n key,\n val\n });\n });\n }, (err, mapResults) => {\n var result = {}; // from MDN, handle object having an `hasOwnProperty` prop\n\n var {\n hasOwnProperty\n } = Object.prototype;\n\n for (var i = 0; i < mapResults.length; i++) {\n if (mapResults[i]) {\n var {\n key\n } = mapResults[i];\n var {\n val\n } = mapResults[i];\n\n if (hasOwnProperty.call(result, key)) {\n result[key].push(val);\n } else {\n result[key] = [val];\n }\n }\n }\n\n return callback(err, result);\n });\n}\n\nvar groupByLimit$1 = awaitify(groupByLimit, 4);\n/**\n * Returns a new object, where each value corresponds to an array of items, from\n * `coll`, that returned the corresponding key. That is, the keys of the object\n * correspond to the values passed to the `iteratee` callback.\n *\n * Note: Since this function applies the `iteratee` to each item in parallel,\n * there is no guarantee that the `iteratee` functions will complete in order.\n * However, the values for each key in the `result` will be in the same order as\n * the original `coll`. For Objects, the values will roughly be in the order of\n * the original Objects' keys (but this can vary across JavaScript engines).\n *\n * @name groupBy\n * @static\n * @memberOf module:Collections\n * @method\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * The iteratee should complete with a `key` to group the value under.\n * Invoked with (value, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. Result is an `Object` whoses\n * properties are arrays of values which returned the corresponding key.\n * @returns {Promise} a promise, if no callback is passed\n * @example\n *\n * // dir1 is a directory that contains file1.txt, file2.txt\n * // dir2 is a directory that contains file3.txt, file4.txt\n * // dir3 is a directory that contains file5.txt\n * // dir4 does not exist\n *\n * const files = ['dir1/file1.txt','dir2','dir4']\n *\n * // asynchronous function that detects file type as none, file, or directory\n * function detectFile(file, callback) {\n * fs.stat(file, function(err, stat) {\n * if (err) {\n * return callback(null, 'none');\n * }\n * callback(null, stat.isDirectory() ? 'directory' : 'file');\n * });\n * }\n *\n * //Using callbacks\n * async.groupBy(files, detectFile, function(err, result) {\n * if(err) {\n * console.log(err);\n * } else {\n *\t console.log(result);\n * // {\n * // file: [ 'dir1/file1.txt' ],\n * // none: [ 'dir4' ],\n * // directory: [ 'dir2']\n * // }\n * // result is object containing the files grouped by type\n * }\n * });\n *\n * // Using Promises\n * async.groupBy(files, detectFile)\n * .then( result => {\n * console.log(result);\n * // {\n * // file: [ 'dir1/file1.txt' ],\n * // none: [ 'dir4' ],\n * // directory: [ 'dir2']\n * // }\n * // result is object containing the files grouped by type\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let result = await async.groupBy(files, detectFile);\n * console.log(result);\n * // {\n * // file: [ 'dir1/file1.txt' ],\n * // none: [ 'dir4' ],\n * // directory: [ 'dir2']\n * // }\n * // result is object containing the files grouped by type\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\n\nfunction groupBy(coll, iteratee, callback) {\n return groupByLimit$1(coll, Infinity, iteratee, callback);\n}\n/**\n * The same as [`groupBy`]{@link module:Collections.groupBy} but runs only a single async operation at a time.\n *\n * @name groupBySeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.groupBy]{@link module:Collections.groupBy}\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * The iteratee should complete with a `key` to group the value under.\n * Invoked with (value, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. Result is an `Object` whose\n * properties are arrays of values which returned the corresponding key.\n * @returns {Promise} a promise, if no callback is passed\n */\n\n\nfunction groupBySeries(coll, iteratee, callback) {\n return groupByLimit$1(coll, 1, iteratee, callback);\n}\n/**\n * Logs the result of an `async` function to the `console`. Only works in\n * Node.js or in browsers that support `console.log` and `console.error` (such\n * as FF and Chrome). If multiple arguments are returned from the async\n * function, `console.log` is called on each argument in order.\n *\n * @name log\n * @static\n * @memberOf module:Utils\n * @method\n * @category Util\n * @param {AsyncFunction} function - The function you want to eventually apply\n * all arguments to.\n * @param {...*} arguments... - Any number of arguments to apply to the function.\n * @example\n *\n * // in a module\n * var hello = function(name, callback) {\n * setTimeout(function() {\n * callback(null, 'hello ' + name);\n * }, 1000);\n * };\n *\n * // in the node repl\n * node> async.log(hello, 'world');\n * 'hello world'\n */\n\n\nvar log = consoleFunc('log');\n/**\n * The same as [`mapValues`]{@link module:Collections.mapValues} but runs a maximum of `limit` async operations at a\n * time.\n *\n * @name mapValuesLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.mapValues]{@link module:Collections.mapValues}\n * @category Collection\n * @param {Object} obj - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - A function to apply to each value and key\n * in `coll`.\n * The iteratee should complete with the transformed value as its result.\n * Invoked with (value, key, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. `result` is a new object consisting\n * of each key from `obj`, with each transformed value on the right-hand side.\n * Invoked with (err, result).\n * @returns {Promise} a promise, if no callback is passed\n */\n\nfunction mapValuesLimit(obj, limit, iteratee, callback) {\n callback = once(callback);\n var newObj = {};\n\n var _iteratee = wrapAsync(iteratee);\n\n return eachOfLimit(limit)(obj, (val, key, next) => {\n _iteratee(val, key, (err, result) => {\n if (err) return next(err);\n newObj[key] = result;\n next(err);\n });\n }, err => callback(err, newObj));\n}\n\nvar mapValuesLimit$1 = awaitify(mapValuesLimit, 4);\n/**\n * A relative of [`map`]{@link module:Collections.map}, designed for use with objects.\n *\n * Produces a new Object by mapping each value of `obj` through the `iteratee`\n * function. The `iteratee` is called each `value` and `key` from `obj` and a\n * callback for when it has finished processing. Each of these callbacks takes\n * two arguments: an `error`, and the transformed item from `obj`. If `iteratee`\n * passes an error to its callback, the main `callback` (for the `mapValues`\n * function) is immediately called with the error.\n *\n * Note, the order of the keys in the result is not guaranteed. The keys will\n * be roughly in the order they complete, (but this is very engine-specific)\n *\n * @name mapValues\n * @static\n * @memberOf module:Collections\n * @method\n * @category Collection\n * @param {Object} obj - A collection to iterate over.\n * @param {AsyncFunction} iteratee - A function to apply to each value and key\n * in `coll`.\n * The iteratee should complete with the transformed value as its result.\n * Invoked with (value, key, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. `result` is a new object consisting\n * of each key from `obj`, with each transformed value on the right-hand side.\n * Invoked with (err, result).\n * @returns {Promise} a promise, if no callback is passed\n * @example\n *\n * // file1.txt is a file that is 1000 bytes in size\n * // file2.txt is a file that is 2000 bytes in size\n * // file3.txt is a file that is 3000 bytes in size\n * // file4.txt does not exist\n *\n * const fileMap = {\n * f1: 'file1.txt',\n * f2: 'file2.txt',\n * f3: 'file3.txt'\n * };\n *\n * const withMissingFileMap = {\n * f1: 'file1.txt',\n * f2: 'file2.txt',\n * f3: 'file4.txt'\n * };\n *\n * // asynchronous function that returns the file size in bytes\n * function getFileSizeInBytes(file, key, callback) {\n * fs.stat(file, function(err, stat) {\n * if (err) {\n * return callback(err);\n * }\n * callback(null, stat.size);\n * });\n * }\n *\n * // Using callbacks\n * async.mapValues(fileMap, getFileSizeInBytes, function(err, result) {\n * if (err) {\n * console.log(err);\n * } else {\n * console.log(result);\n * // result is now a map of file size in bytes for each file, e.g.\n * // {\n * // f1: 1000,\n * // f2: 2000,\n * // f3: 3000\n * // }\n * }\n * });\n *\n * // Error handling\n * async.mapValues(withMissingFileMap, getFileSizeInBytes, function(err, result) {\n * if (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * } else {\n * console.log(result);\n * }\n * });\n *\n * // Using Promises\n * async.mapValues(fileMap, getFileSizeInBytes)\n * .then( result => {\n * console.log(result);\n * // result is now a map of file size in bytes for each file, e.g.\n * // {\n * // f1: 1000,\n * // f2: 2000,\n * // f3: 3000\n * // }\n * }).catch (err => {\n * console.log(err);\n * });\n *\n * // Error Handling\n * async.mapValues(withMissingFileMap, getFileSizeInBytes)\n * .then( result => {\n * console.log(result);\n * }).catch (err => {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let result = await async.mapValues(fileMap, getFileSizeInBytes);\n * console.log(result);\n * // result is now a map of file size in bytes for each file, e.g.\n * // {\n * // f1: 1000,\n * // f2: 2000,\n * // f3: 3000\n * // }\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * // Error Handling\n * async () => {\n * try {\n * let result = await async.mapValues(withMissingFileMap, getFileSizeInBytes);\n * console.log(result);\n * }\n * catch (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * }\n * }\n *\n */\n\nfunction mapValues(obj, iteratee, callback) {\n return mapValuesLimit$1(obj, Infinity, iteratee, callback);\n}\n/**\n * The same as [`mapValues`]{@link module:Collections.mapValues} but runs only a single async operation at a time.\n *\n * @name mapValuesSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.mapValues]{@link module:Collections.mapValues}\n * @category Collection\n * @param {Object} obj - A collection to iterate over.\n * @param {AsyncFunction} iteratee - A function to apply to each value and key\n * in `coll`.\n * The iteratee should complete with the transformed value as its result.\n * Invoked with (value, key, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. `result` is a new object consisting\n * of each key from `obj`, with each transformed value on the right-hand side.\n * Invoked with (err, result).\n * @returns {Promise} a promise, if no callback is passed\n */\n\n\nfunction mapValuesSeries(obj, iteratee, callback) {\n return mapValuesLimit$1(obj, 1, iteratee, callback);\n}\n/**\n * Caches the results of an async function. When creating a hash to store\n * function results against, the callback is omitted from the hash and an\n * optional hash function can be used.\n *\n * **Note: if the async function errs, the result will not be cached and\n * subsequent calls will call the wrapped function.**\n *\n * If no hash function is specified, the first argument is used as a hash key,\n * which may work reasonably if it is a string or a data type that converts to a\n * distinct string. Note that objects and arrays will not behave reasonably.\n * Neither will cases where the other arguments are significant. In such cases,\n * specify your own hash function.\n *\n * The cache of results is exposed as the `memo` property of the function\n * returned by `memoize`.\n *\n * @name memoize\n * @static\n * @memberOf module:Utils\n * @method\n * @category Util\n * @param {AsyncFunction} fn - The async function to proxy and cache results from.\n * @param {Function} hasher - An optional function for generating a custom hash\n * for storing results. It has all the arguments applied to it apart from the\n * callback, and must be synchronous.\n * @returns {AsyncFunction} a memoized version of `fn`\n * @example\n *\n * var slow_fn = function(name, callback) {\n * // do something\n * callback(null, result);\n * };\n * var fn = async.memoize(slow_fn);\n *\n * // fn can now be used as if it were slow_fn\n * fn('some name', function() {\n * // callback\n * });\n */\n\n\nfunction memoize(fn, hasher = v => v) {\n var memo = Object.create(null);\n var queues = Object.create(null);\n\n var _fn = wrapAsync(fn);\n\n var memoized = initialParams((args, callback) => {\n var key = hasher(...args);\n\n if (key in memo) {\n setImmediate$1(() => callback(null, ...memo[key]));\n } else if (key in queues) {\n queues[key].push(callback);\n } else {\n queues[key] = [callback];\n\n _fn(...args, (err, ...resultArgs) => {\n // #1465 don't memoize if an error occurred\n if (!err) {\n memo[key] = resultArgs;\n }\n\n var q = queues[key];\n delete queues[key];\n\n for (var i = 0, l = q.length; i < l; i++) {\n q[i](err, ...resultArgs);\n }\n });\n }\n });\n memoized.memo = memo;\n memoized.unmemoized = fn;\n return memoized;\n}\n/**\n * Calls `callback` on a later loop around the event loop. In Node.js this just\n * calls `process.nextTick`. In the browser it will use `setImmediate` if\n * available, otherwise `setTimeout(callback, 0)`, which means other higher\n * priority events may precede the execution of `callback`.\n *\n * This is used internally for browser-compatibility purposes.\n *\n * @name nextTick\n * @static\n * @memberOf module:Utils\n * @method\n * @see [async.setImmediate]{@link module:Utils.setImmediate}\n * @category Util\n * @param {Function} callback - The function to call on a later loop around\n * the event loop. Invoked with (args...).\n * @param {...*} args... - any number of additional arguments to pass to the\n * callback on the next tick.\n * @example\n *\n * var call_order = [];\n * async.nextTick(function() {\n * call_order.push('two');\n * // call_order now equals ['one','two']\n * });\n * call_order.push('one');\n *\n * async.setImmediate(function (a, b, c) {\n * // a, b, and c equal 1, 2, and 3\n * }, 1, 2, 3);\n */\n\n\nvar _defer$1;\n\nif (hasNextTick) {\n _defer$1 = process.nextTick;\n} else if (hasSetImmediate) {\n _defer$1 = setImmediate;\n} else {\n _defer$1 = fallback;\n}\n\nvar nextTick = wrap(_defer$1);\n\nvar _parallel = awaitify((eachfn, tasks, callback) => {\n var results = isArrayLike(tasks) ? [] : {};\n eachfn(tasks, (task, key, taskCb) => {\n wrapAsync(task)((err, ...result) => {\n if (result.length < 2) {\n [result] = result;\n }\n\n results[key] = result;\n taskCb(err);\n });\n }, err => callback(err, results));\n}, 3);\n/**\n * Run the `tasks` collection of functions in parallel, without waiting until\n * the previous function has completed. If any of the functions pass an error to\n * its callback, the main `callback` is immediately called with the value of the\n * error. Once the `tasks` have completed, the results are passed to the final\n * `callback` as an array.\n *\n * **Note:** `parallel` is about kicking-off I/O tasks in parallel, not about\n * parallel execution of code. If your tasks do not use any timers or perform\n * any I/O, they will actually be executed in series. Any synchronous setup\n * sections for each task will happen one after the other. JavaScript remains\n * single-threaded.\n *\n * **Hint:** Use [`reflect`]{@link module:Utils.reflect} to continue the\n * execution of other tasks when a task fails.\n *\n * It is also possible to use an object instead of an array. Each property will\n * be run as a function and the results will be passed to the final `callback`\n * as an object instead of an array. This can be a more readable way of handling\n * results from {@link async.parallel}.\n *\n * @name parallel\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {Array|Iterable|AsyncIterable|Object} tasks - A collection of\n * [async functions]{@link AsyncFunction} to run.\n * Each async function can complete with any number of optional `result` values.\n * @param {Function} [callback] - An optional callback to run once all the\n * functions have completed successfully. This function gets a results array\n * (or object) containing all the result arguments passed to the task callbacks.\n * Invoked with (err, results).\n * @returns {Promise} a promise, if a callback is not passed\n *\n * @example\n *\n * //Using Callbacks\n * async.parallel([\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'one');\n * }, 200);\n * },\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'two');\n * }, 100);\n * }\n * ], function(err, results) {\n * console.log(results);\n * // results is equal to ['one','two'] even though\n * // the second function had a shorter timeout.\n * });\n *\n * // an example using an object instead of an array\n * async.parallel({\n * one: function(callback) {\n * setTimeout(function() {\n * callback(null, 1);\n * }, 200);\n * },\n * two: function(callback) {\n * setTimeout(function() {\n * callback(null, 2);\n * }, 100);\n * }\n * }, function(err, results) {\n * console.log(results);\n * // results is equal to: { one: 1, two: 2 }\n * });\n *\n * //Using Promises\n * async.parallel([\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'one');\n * }, 200);\n * },\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'two');\n * }, 100);\n * }\n * ]).then(results => {\n * console.log(results);\n * // results is equal to ['one','two'] even though\n * // the second function had a shorter timeout.\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * // an example using an object instead of an array\n * async.parallel({\n * one: function(callback) {\n * setTimeout(function() {\n * callback(null, 1);\n * }, 200);\n * },\n * two: function(callback) {\n * setTimeout(function() {\n * callback(null, 2);\n * }, 100);\n * }\n * }).then(results => {\n * console.log(results);\n * // results is equal to: { one: 1, two: 2 }\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * //Using async/await\n * async () => {\n * try {\n * let results = await async.parallel([\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'one');\n * }, 200);\n * },\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'two');\n * }, 100);\n * }\n * ]);\n * console.log(results);\n * // results is equal to ['one','two'] even though\n * // the second function had a shorter timeout.\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * // an example using an object instead of an array\n * async () => {\n * try {\n * let results = await async.parallel({\n * one: function(callback) {\n * setTimeout(function() {\n * callback(null, 1);\n * }, 200);\n * },\n * two: function(callback) {\n * setTimeout(function() {\n * callback(null, 2);\n * }, 100);\n * }\n * });\n * console.log(results);\n * // results is equal to: { one: 1, two: 2 }\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\n\n\nfunction parallel(tasks, callback) {\n return _parallel(eachOf$1, tasks, callback);\n}\n/**\n * The same as [`parallel`]{@link module:ControlFlow.parallel} but runs a maximum of `limit` async operations at a\n * time.\n *\n * @name parallelLimit\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.parallel]{@link module:ControlFlow.parallel}\n * @category Control Flow\n * @param {Array|Iterable|AsyncIterable|Object} tasks - A collection of\n * [async functions]{@link AsyncFunction} to run.\n * Each async function can complete with any number of optional `result` values.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {Function} [callback] - An optional callback to run once all the\n * functions have completed successfully. This function gets a results array\n * (or object) containing all the result arguments passed to the task callbacks.\n * Invoked with (err, results).\n * @returns {Promise} a promise, if a callback is not passed\n */\n\n\nfunction parallelLimit(tasks, limit, callback) {\n return _parallel(eachOfLimit(limit), tasks, callback);\n}\n/**\n * A queue of tasks for the worker function to complete.\n * @typedef {Iterable} QueueObject\n * @memberOf module:ControlFlow\n * @property {Function} length - a function returning the number of items\n * waiting to be processed. Invoke with `queue.length()`.\n * @property {boolean} started - a boolean indicating whether or not any\n * items have been pushed and processed by the queue.\n * @property {Function} running - a function returning the number of items\n * currently being processed. Invoke with `queue.running()`.\n * @property {Function} workersList - a function returning the array of items\n * currently being processed. Invoke with `queue.workersList()`.\n * @property {Function} idle - a function returning false if there are items\n * waiting or being processed, or true if not. Invoke with `queue.idle()`.\n * @property {number} concurrency - an integer for determining how many `worker`\n * functions should be run in parallel. This property can be changed after a\n * `queue` is created to alter the concurrency on-the-fly.\n * @property {number} payload - an integer that specifies how many items are\n * passed to the worker function at a time. only applies if this is a\n * [cargo]{@link module:ControlFlow.cargo} object\n * @property {AsyncFunction} push - add a new task to the `queue`. Calls `callback`\n * once the `worker` has finished processing the task. Instead of a single task,\n * a `tasks` array can be submitted. The respective callback is used for every\n * task in the list. Invoke with `queue.push(task, [callback])`,\n * @property {AsyncFunction} unshift - add a new task to the front of the `queue`.\n * Invoke with `queue.unshift(task, [callback])`.\n * @property {AsyncFunction} pushAsync - the same as `q.push`, except this returns\n * a promise that rejects if an error occurs.\n * @property {AsyncFunction} unshiftAsync - the same as `q.unshift`, except this returns\n * a promise that rejects if an error occurs.\n * @property {Function} remove - remove items from the queue that match a test\n * function. The test function will be passed an object with a `data` property,\n * and a `priority` property, if this is a\n * [priorityQueue]{@link module:ControlFlow.priorityQueue} object.\n * Invoked with `queue.remove(testFn)`, where `testFn` is of the form\n * `function ({data, priority}) {}` and returns a Boolean.\n * @property {Function} saturated - a function that sets a callback that is\n * called when the number of running workers hits the `concurrency` limit, and\n * further tasks will be queued. If the callback is omitted, `q.saturated()`\n * returns a promise for the next occurrence.\n * @property {Function} unsaturated - a function that sets a callback that is\n * called when the number of running workers is less than the `concurrency` &\n * `buffer` limits, and further tasks will not be queued. If the callback is\n * omitted, `q.unsaturated()` returns a promise for the next occurrence.\n * @property {number} buffer - A minimum threshold buffer in order to say that\n * the `queue` is `unsaturated`.\n * @property {Function} empty - a function that sets a callback that is called\n * when the last item from the `queue` is given to a `worker`. If the callback\n * is omitted, `q.empty()` returns a promise for the next occurrence.\n * @property {Function} drain - a function that sets a callback that is called\n * when the last item from the `queue` has returned from the `worker`. If the\n * callback is omitted, `q.drain()` returns a promise for the next occurrence.\n * @property {Function} error - a function that sets a callback that is called\n * when a task errors. Has the signature `function(error, task)`. If the\n * callback is omitted, `error()` returns a promise that rejects on the next\n * error.\n * @property {boolean} paused - a boolean for determining whether the queue is\n * in a paused state.\n * @property {Function} pause - a function that pauses the processing of tasks\n * until `resume()` is called. Invoke with `queue.pause()`.\n * @property {Function} resume - a function that resumes the processing of\n * queued tasks when the queue is paused. Invoke with `queue.resume()`.\n * @property {Function} kill - a function that removes the `drain` callback and\n * empties remaining tasks from the queue forcing it to go idle. No more tasks\n * should be pushed to the queue after calling this function. Invoke with `queue.kill()`.\n *\n * @example\n * const q = async.queue(worker, 2)\n * q.push(item1)\n * q.push(item2)\n * q.push(item3)\n * // queues are iterable, spread into an array to inspect\n * const items = [...q] // [item1, item2, item3]\n * // or use for of\n * for (let item of q) {\n * console.log(item)\n * }\n *\n * q.drain(() => {\n * console.log('all done')\n * })\n * // or\n * await q.drain()\n */\n\n/**\n * Creates a `queue` object with the specified `concurrency`. Tasks added to the\n * `queue` are processed in parallel (up to the `concurrency` limit). If all\n * `worker`s are in progress, the task is queued until one becomes available.\n * Once a `worker` completes a `task`, that `task`'s callback is called.\n *\n * @name queue\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {AsyncFunction} worker - An async function for processing a queued task.\n * If you want to handle errors from an individual task, pass a callback to\n * `q.push()`. Invoked with (task, callback).\n * @param {number} [concurrency=1] - An `integer` for determining how many\n * `worker` functions should be run in parallel. If omitted, the concurrency\n * defaults to `1`. If the concurrency is `0`, an error is thrown.\n * @returns {module:ControlFlow.QueueObject} A queue object to manage the tasks. Callbacks can be\n * attached as certain properties to listen for specific events during the\n * lifecycle of the queue.\n * @example\n *\n * // create a queue object with concurrency 2\n * var q = async.queue(function(task, callback) {\n * console.log('hello ' + task.name);\n * callback();\n * }, 2);\n *\n * // assign a callback\n * q.drain(function() {\n * console.log('all items have been processed');\n * });\n * // or await the end\n * await q.drain()\n *\n * // assign an error callback\n * q.error(function(err, task) {\n * console.error('task experienced an error');\n * });\n *\n * // add some items to the queue\n * q.push({name: 'foo'}, function(err) {\n * console.log('finished processing foo');\n * });\n * // callback is optional\n * q.push({name: 'bar'});\n *\n * // add some items to the queue (batch-wise)\n * q.push([{name: 'baz'},{name: 'bay'},{name: 'bax'}], function(err) {\n * console.log('finished processing item');\n * });\n *\n * // add some items to the front of the queue\n * q.unshift({name: 'bar'}, function (err) {\n * console.log('finished processing bar');\n * });\n */\n\n\nfunction queue$1(worker, concurrency) {\n var _worker = wrapAsync(worker);\n\n return queue((items, cb) => {\n _worker(items[0], cb);\n }, concurrency, 1);\n} // Binary min-heap implementation used for priority queue.\n// Implementation is stable, i.e. push time is considered for equal priorities\n\n\nclass Heap {\n constructor() {\n this.heap = [];\n this.pushCount = Number.MIN_SAFE_INTEGER;\n }\n\n get length() {\n return this.heap.length;\n }\n\n empty() {\n this.heap = [];\n return this;\n }\n\n percUp(index) {\n let p;\n\n while (index > 0 && smaller(this.heap[index], this.heap[p = parent(index)])) {\n let t = this.heap[index];\n this.heap[index] = this.heap[p];\n this.heap[p] = t;\n index = p;\n }\n }\n\n percDown(index) {\n let l;\n\n while ((l = leftChi(index)) < this.heap.length) {\n if (l + 1 < this.heap.length && smaller(this.heap[l + 1], this.heap[l])) {\n l = l + 1;\n }\n\n if (smaller(this.heap[index], this.heap[l])) {\n break;\n }\n\n let t = this.heap[index];\n this.heap[index] = this.heap[l];\n this.heap[l] = t;\n index = l;\n }\n }\n\n push(node) {\n node.pushCount = ++this.pushCount;\n this.heap.push(node);\n this.percUp(this.heap.length - 1);\n }\n\n unshift(node) {\n return this.heap.push(node);\n }\n\n shift() {\n let [top] = this.heap;\n this.heap[0] = this.heap[this.heap.length - 1];\n this.heap.pop();\n this.percDown(0);\n return top;\n }\n\n toArray() {\n return [...this];\n }\n\n *[Symbol.iterator]() {\n for (let i = 0; i < this.heap.length; i++) {\n yield this.heap[i].data;\n }\n }\n\n remove(testFn) {\n let j = 0;\n\n for (let i = 0; i < this.heap.length; i++) {\n if (!testFn(this.heap[i])) {\n this.heap[j] = this.heap[i];\n j++;\n }\n }\n\n this.heap.splice(j);\n\n for (let i = parent(this.heap.length - 1); i >= 0; i--) {\n this.percDown(i);\n }\n\n return this;\n }\n\n}\n\nfunction leftChi(i) {\n return (i << 1) + 1;\n}\n\nfunction parent(i) {\n return (i + 1 >> 1) - 1;\n}\n\nfunction smaller(x, y) {\n if (x.priority !== y.priority) {\n return x.priority < y.priority;\n } else {\n return x.pushCount < y.pushCount;\n }\n}\n/**\n * The same as [async.queue]{@link module:ControlFlow.queue} only tasks are assigned a priority and\n * completed in ascending priority order.\n *\n * @name priorityQueue\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.queue]{@link module:ControlFlow.queue}\n * @category Control Flow\n * @param {AsyncFunction} worker - An async function for processing a queued task.\n * If you want to handle errors from an individual task, pass a callback to\n * `q.push()`.\n * Invoked with (task, callback).\n * @param {number} concurrency - An `integer` for determining how many `worker`\n * functions should be run in parallel. If omitted, the concurrency defaults to\n * `1`. If the concurrency is `0`, an error is thrown.\n * @returns {module:ControlFlow.QueueObject} A priorityQueue object to manage the tasks. There are two\n * differences between `queue` and `priorityQueue` objects:\n * * `push(task, priority, [callback])` - `priority` should be a number. If an\n * array of `tasks` is given, all tasks will be assigned the same priority.\n * * The `unshift` method was removed.\n */\n\n\nfunction priorityQueue(worker, concurrency) {\n // Start with a normal queue\n var q = queue$1(worker, concurrency);\n var processingScheduled = false;\n q._tasks = new Heap(); // Override push to accept second parameter representing priority\n\n q.push = function (data, priority = 0, callback = () => {}) {\n if (typeof callback !== 'function') {\n throw new Error('task callback must be a function');\n }\n\n q.started = true;\n\n if (!Array.isArray(data)) {\n data = [data];\n }\n\n if (data.length === 0 && q.idle()) {\n // call drain immediately if there are no tasks\n return setImmediate$1(() => q.drain());\n }\n\n for (var i = 0, l = data.length; i < l; i++) {\n var item = {\n data: data[i],\n priority,\n callback\n };\n\n q._tasks.push(item);\n }\n\n if (!processingScheduled) {\n processingScheduled = true;\n setImmediate$1(() => {\n processingScheduled = false;\n q.process();\n });\n }\n }; // Remove unshift function\n\n\n delete q.unshift;\n return q;\n}\n/**\n * Runs the `tasks` array of functions in parallel, without waiting until the\n * previous function has completed. Once any of the `tasks` complete or pass an\n * error to its callback, the main `callback` is immediately called. It's\n * equivalent to `Promise.race()`.\n *\n * @name race\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {Array} tasks - An array containing [async functions]{@link AsyncFunction}\n * to run. Each function can complete with an optional `result` value.\n * @param {Function} callback - A callback to run once any of the functions have\n * completed. This function gets an error or result from the first function that\n * completed. Invoked with (err, result).\n * @returns undefined\n * @example\n *\n * async.race([\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'one');\n * }, 200);\n * },\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'two');\n * }, 100);\n * }\n * ],\n * // main callback\n * function(err, result) {\n * // the result will be equal to 'two' as it finishes earlier\n * });\n */\n\n\nfunction race(tasks, callback) {\n callback = once(callback);\n if (!Array.isArray(tasks)) return callback(new TypeError('First argument to race must be an array of functions'));\n if (!tasks.length) return callback();\n\n for (var i = 0, l = tasks.length; i < l; i++) {\n wrapAsync(tasks[i])(callback);\n }\n}\n\nvar race$1 = awaitify(race, 2);\n/**\n * Same as [`reduce`]{@link module:Collections.reduce}, only operates on `array` in reverse order.\n *\n * @name reduceRight\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.reduce]{@link module:Collections.reduce}\n * @alias foldr\n * @category Collection\n * @param {Array} array - A collection to iterate over.\n * @param {*} memo - The initial state of the reduction.\n * @param {AsyncFunction} iteratee - A function applied to each item in the\n * array to produce the next step in the reduction.\n * The `iteratee` should complete with the next state of the reduction.\n * If the iteratee completes with an error, the reduction is stopped and the\n * main `callback` is immediately called with the error.\n * Invoked with (memo, item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Result is the reduced value. Invoked with\n * (err, result).\n * @returns {Promise} a promise, if no callback is passed\n */\n\nfunction reduceRight(array, memo, iteratee, callback) {\n var reversed = [...array].reverse();\n return reduce$1(reversed, memo, iteratee, callback);\n}\n/**\n * Wraps the async function in another function that always completes with a\n * result object, even when it errors.\n *\n * The result object has either the property `error` or `value`.\n *\n * @name reflect\n * @static\n * @memberOf module:Utils\n * @method\n * @category Util\n * @param {AsyncFunction} fn - The async function you want to wrap\n * @returns {Function} - A function that always passes null to it's callback as\n * the error. The second argument to the callback will be an `object` with\n * either an `error` or a `value` property.\n * @example\n *\n * async.parallel([\n * async.reflect(function(callback) {\n * // do some stuff ...\n * callback(null, 'one');\n * }),\n * async.reflect(function(callback) {\n * // do some more stuff but error ...\n * callback('bad stuff happened');\n * }),\n * async.reflect(function(callback) {\n * // do some more stuff ...\n * callback(null, 'two');\n * })\n * ],\n * // optional callback\n * function(err, results) {\n * // values\n * // results[0].value = 'one'\n * // results[1].error = 'bad stuff happened'\n * // results[2].value = 'two'\n * });\n */\n\n\nfunction reflect(fn) {\n var _fn = wrapAsync(fn);\n\n return initialParams(function reflectOn(args, reflectCallback) {\n args.push((error, ...cbArgs) => {\n let retVal = {};\n\n if (error) {\n retVal.error = error;\n }\n\n if (cbArgs.length > 0) {\n var value = cbArgs;\n\n if (cbArgs.length <= 1) {\n [value] = cbArgs;\n }\n\n retVal.value = value;\n }\n\n reflectCallback(null, retVal);\n });\n return _fn.apply(this, args);\n });\n}\n/**\n * A helper function that wraps an array or an object of functions with `reflect`.\n *\n * @name reflectAll\n * @static\n * @memberOf module:Utils\n * @method\n * @see [async.reflect]{@link module:Utils.reflect}\n * @category Util\n * @param {Array|Object|Iterable} tasks - The collection of\n * [async functions]{@link AsyncFunction} to wrap in `async.reflect`.\n * @returns {Array} Returns an array of async functions, each wrapped in\n * `async.reflect`\n * @example\n *\n * let tasks = [\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'one');\n * }, 200);\n * },\n * function(callback) {\n * // do some more stuff but error ...\n * callback(new Error('bad stuff happened'));\n * },\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'two');\n * }, 100);\n * }\n * ];\n *\n * async.parallel(async.reflectAll(tasks),\n * // optional callback\n * function(err, results) {\n * // values\n * // results[0].value = 'one'\n * // results[1].error = Error('bad stuff happened')\n * // results[2].value = 'two'\n * });\n *\n * // an example using an object instead of an array\n * let tasks = {\n * one: function(callback) {\n * setTimeout(function() {\n * callback(null, 'one');\n * }, 200);\n * },\n * two: function(callback) {\n * callback('two');\n * },\n * three: function(callback) {\n * setTimeout(function() {\n * callback(null, 'three');\n * }, 100);\n * }\n * };\n *\n * async.parallel(async.reflectAll(tasks),\n * // optional callback\n * function(err, results) {\n * // values\n * // results.one.value = 'one'\n * // results.two.error = 'two'\n * // results.three.value = 'three'\n * });\n */\n\n\nfunction reflectAll(tasks) {\n var results;\n\n if (Array.isArray(tasks)) {\n results = tasks.map(reflect);\n } else {\n results = {};\n Object.keys(tasks).forEach(key => {\n results[key] = reflect.call(this, tasks[key]);\n });\n }\n\n return results;\n}\n\nfunction reject(eachfn, arr, _iteratee, callback) {\n const iteratee = wrapAsync(_iteratee);\n return _filter(eachfn, arr, (value, cb) => {\n iteratee(value, (err, v) => {\n cb(err, !v);\n });\n }, callback);\n}\n/**\n * The opposite of [`filter`]{@link module:Collections.filter}. Removes values that pass an `async` truth test.\n *\n * @name reject\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.filter]{@link module:Collections.filter}\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {Function} iteratee - An async truth test to apply to each item in\n * `coll`.\n * The should complete with a boolean value as its `result`.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback is passed\n * @example\n *\n * // dir1 is a directory that contains file1.txt, file2.txt\n * // dir2 is a directory that contains file3.txt, file4.txt\n * // dir3 is a directory that contains file5.txt\n *\n * const fileList = ['dir1/file1.txt','dir2/file3.txt','dir3/file6.txt'];\n *\n * // asynchronous function that checks if a file exists\n * function fileExists(file, callback) {\n * fs.access(file, fs.constants.F_OK, (err) => {\n * callback(null, !err);\n * });\n * }\n *\n * // Using callbacks\n * async.reject(fileList, fileExists, function(err, results) {\n * // [ 'dir3/file6.txt' ]\n * // results now equals an array of the non-existing files\n * });\n *\n * // Using Promises\n * async.reject(fileList, fileExists)\n * .then( results => {\n * console.log(results);\n * // [ 'dir3/file6.txt' ]\n * // results now equals an array of the non-existing files\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let results = await async.reject(fileList, fileExists);\n * console.log(results);\n * // [ 'dir3/file6.txt' ]\n * // results now equals an array of the non-existing files\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\n\n\nfunction reject$1(coll, iteratee, callback) {\n return reject(eachOf$1, coll, iteratee, callback);\n}\n\nvar reject$2 = awaitify(reject$1, 3);\n/**\n * The same as [`reject`]{@link module:Collections.reject} but runs a maximum of `limit` async operations at a\n * time.\n *\n * @name rejectLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.reject]{@link module:Collections.reject}\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {Function} iteratee - An async truth test to apply to each item in\n * `coll`.\n * The should complete with a boolean value as its `result`.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback is passed\n */\n\nfunction rejectLimit(coll, limit, iteratee, callback) {\n return reject(eachOfLimit(limit), coll, iteratee, callback);\n}\n\nvar rejectLimit$1 = awaitify(rejectLimit, 4);\n/**\n * The same as [`reject`]{@link module:Collections.reject} but runs only a single async operation at a time.\n *\n * @name rejectSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.reject]{@link module:Collections.reject}\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {Function} iteratee - An async truth test to apply to each item in\n * `coll`.\n * The should complete with a boolean value as its `result`.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback is passed\n */\n\nfunction rejectSeries(coll, iteratee, callback) {\n return reject(eachOfSeries$1, coll, iteratee, callback);\n}\n\nvar rejectSeries$1 = awaitify(rejectSeries, 3);\n\nfunction constant$1(value) {\n return function () {\n return value;\n };\n}\n/**\n * Attempts to get a successful response from `task` no more than `times` times\n * before returning an error. If the task is successful, the `callback` will be\n * passed the result of the successful task. If all attempts fail, the callback\n * will be passed the error and result (if any) of the final attempt.\n *\n * @name retry\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @see [async.retryable]{@link module:ControlFlow.retryable}\n * @param {Object|number} [opts = {times: 5, interval: 0}| 5] - Can be either an\n * object with `times` and `interval` or a number.\n * * `times` - The number of attempts to make before giving up. The default\n * is `5`.\n * * `interval` - The time to wait between retries, in milliseconds. The\n * default is `0`. The interval may also be specified as a function of the\n * retry count (see example).\n * * `errorFilter` - An optional synchronous function that is invoked on\n * erroneous result. If it returns `true` the retry attempts will continue;\n * if the function returns `false` the retry flow is aborted with the current\n * attempt's error and result being returned to the final callback.\n * Invoked with (err).\n * * If `opts` is a number, the number specifies the number of times to retry,\n * with the default interval of `0`.\n * @param {AsyncFunction} task - An async function to retry.\n * Invoked with (callback).\n * @param {Function} [callback] - An optional callback which is called when the\n * task has succeeded, or after the final failed attempt. It receives the `err`\n * and `result` arguments of the last attempt at completing the `task`. Invoked\n * with (err, results).\n * @returns {Promise} a promise if no callback provided\n *\n * @example\n *\n * // The `retry` function can be used as a stand-alone control flow by passing\n * // a callback, as shown below:\n *\n * // try calling apiMethod 3 times\n * async.retry(3, apiMethod, function(err, result) {\n * // do something with the result\n * });\n *\n * // try calling apiMethod 3 times, waiting 200 ms between each retry\n * async.retry({times: 3, interval: 200}, apiMethod, function(err, result) {\n * // do something with the result\n * });\n *\n * // try calling apiMethod 10 times with exponential backoff\n * // (i.e. intervals of 100, 200, 400, 800, 1600, ... milliseconds)\n * async.retry({\n * times: 10,\n * interval: function(retryCount) {\n * return 50 * Math.pow(2, retryCount);\n * }\n * }, apiMethod, function(err, result) {\n * // do something with the result\n * });\n *\n * // try calling apiMethod the default 5 times no delay between each retry\n * async.retry(apiMethod, function(err, result) {\n * // do something with the result\n * });\n *\n * // try calling apiMethod only when error condition satisfies, all other\n * // errors will abort the retry control flow and return to final callback\n * async.retry({\n * errorFilter: function(err) {\n * return err.message === 'Temporary error'; // only retry on a specific error\n * }\n * }, apiMethod, function(err, result) {\n * // do something with the result\n * });\n *\n * // to retry individual methods that are not as reliable within other\n * // control flow functions, use the `retryable` wrapper:\n * async.auto({\n * users: api.getUsers.bind(api),\n * payments: async.retryable(3, api.getPayments.bind(api))\n * }, function(err, results) {\n * // do something with the results\n * });\n *\n */\n\n\nconst DEFAULT_TIMES = 5;\nconst DEFAULT_INTERVAL = 0;\n\nfunction retry(opts, task, callback) {\n var options = {\n times: DEFAULT_TIMES,\n intervalFunc: constant$1(DEFAULT_INTERVAL)\n };\n\n if (arguments.length < 3 && typeof opts === 'function') {\n callback = task || promiseCallback();\n task = opts;\n } else {\n parseTimes(options, opts);\n callback = callback || promiseCallback();\n }\n\n if (typeof task !== 'function') {\n throw new Error(\"Invalid arguments for async.retry\");\n }\n\n var _task = wrapAsync(task);\n\n var attempt = 1;\n\n function retryAttempt() {\n _task((err, ...args) => {\n if (err === false) return;\n\n if (err && attempt++ < options.times && (typeof options.errorFilter != 'function' || options.errorFilter(err))) {\n setTimeout(retryAttempt, options.intervalFunc(attempt - 1));\n } else {\n callback(err, ...args);\n }\n });\n }\n\n retryAttempt();\n return callback[PROMISE_SYMBOL];\n}\n\nfunction parseTimes(acc, t) {\n if (typeof t === 'object') {\n acc.times = +t.times || DEFAULT_TIMES;\n acc.intervalFunc = typeof t.interval === 'function' ? t.interval : constant$1(+t.interval || DEFAULT_INTERVAL);\n acc.errorFilter = t.errorFilter;\n } else if (typeof t === 'number' || typeof t === 'string') {\n acc.times = +t || DEFAULT_TIMES;\n } else {\n throw new Error(\"Invalid arguments for async.retry\");\n }\n}\n/**\n * A close relative of [`retry`]{@link module:ControlFlow.retry}. This method\n * wraps a task and makes it retryable, rather than immediately calling it\n * with retries.\n *\n * @name retryable\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.retry]{@link module:ControlFlow.retry}\n * @category Control Flow\n * @param {Object|number} [opts = {times: 5, interval: 0}| 5] - optional\n * options, exactly the same as from `retry`, except for a `opts.arity` that\n * is the arity of the `task` function, defaulting to `task.length`\n * @param {AsyncFunction} task - the asynchronous function to wrap.\n * This function will be passed any arguments passed to the returned wrapper.\n * Invoked with (...args, callback).\n * @returns {AsyncFunction} The wrapped function, which when invoked, will\n * retry on an error, based on the parameters specified in `opts`.\n * This function will accept the same parameters as `task`.\n * @example\n *\n * async.auto({\n * dep1: async.retryable(3, getFromFlakyService),\n * process: [\"dep1\", async.retryable(3, function (results, cb) {\n * maybeProcessData(results.dep1, cb);\n * })]\n * }, callback);\n */\n\n\nfunction retryable(opts, task) {\n if (!task) {\n task = opts;\n opts = null;\n }\n\n let arity = opts && opts.arity || task.length;\n\n if (isAsync(task)) {\n arity += 1;\n }\n\n var _task = wrapAsync(task);\n\n return initialParams((args, callback) => {\n if (args.length < arity - 1 || callback == null) {\n args.push(callback);\n callback = promiseCallback();\n }\n\n function taskFn(cb) {\n _task(...args, cb);\n }\n\n if (opts) retry(opts, taskFn, callback);else retry(taskFn, callback);\n return callback[PROMISE_SYMBOL];\n });\n}\n/**\n * Run the functions in the `tasks` collection in series, each one running once\n * the previous function has completed. If any functions in the series pass an\n * error to its callback, no more functions are run, and `callback` is\n * immediately called with the value of the error. Otherwise, `callback`\n * receives an array of results when `tasks` have completed.\n *\n * It is also possible to use an object instead of an array. Each property will\n * be run as a function, and the results will be passed to the final `callback`\n * as an object instead of an array. This can be a more readable way of handling\n * results from {@link async.series}.\n *\n * **Note** that while many implementations preserve the order of object\n * properties, the [ECMAScript Language Specification](http://www.ecma-international.org/ecma-262/5.1/#sec-8.6)\n * explicitly states that\n *\n * > The mechanics and order of enumerating the properties is not specified.\n *\n * So if you rely on the order in which your series of functions are executed,\n * and want this to work on all platforms, consider using an array.\n *\n * @name series\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {Array|Iterable|AsyncIterable|Object} tasks - A collection containing\n * [async functions]{@link AsyncFunction} to run in series.\n * Each function can complete with any number of optional `result` values.\n * @param {Function} [callback] - An optional callback to run once all the\n * functions have completed. This function gets a results array (or object)\n * containing all the result arguments passed to the `task` callbacks. Invoked\n * with (err, result).\n * @return {Promise} a promise, if no callback is passed\n * @example\n *\n * //Using Callbacks\n * async.series([\n * function(callback) {\n * setTimeout(function() {\n * // do some async task\n * callback(null, 'one');\n * }, 200);\n * },\n * function(callback) {\n * setTimeout(function() {\n * // then do another async task\n * callback(null, 'two');\n * }, 100);\n * }\n * ], function(err, results) {\n * console.log(results);\n * // results is equal to ['one','two']\n * });\n *\n * // an example using objects instead of arrays\n * async.series({\n * one: function(callback) {\n * setTimeout(function() {\n * // do some async task\n * callback(null, 1);\n * }, 200);\n * },\n * two: function(callback) {\n * setTimeout(function() {\n * // then do another async task\n * callback(null, 2);\n * }, 100);\n * }\n * }, function(err, results) {\n * console.log(results);\n * // results is equal to: { one: 1, two: 2 }\n * });\n *\n * //Using Promises\n * async.series([\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'one');\n * }, 200);\n * },\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'two');\n * }, 100);\n * }\n * ]).then(results => {\n * console.log(results);\n * // results is equal to ['one','two']\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * // an example using an object instead of an array\n * async.series({\n * one: function(callback) {\n * setTimeout(function() {\n * // do some async task\n * callback(null, 1);\n * }, 200);\n * },\n * two: function(callback) {\n * setTimeout(function() {\n * // then do another async task\n * callback(null, 2);\n * }, 100);\n * }\n * }).then(results => {\n * console.log(results);\n * // results is equal to: { one: 1, two: 2 }\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * //Using async/await\n * async () => {\n * try {\n * let results = await async.series([\n * function(callback) {\n * setTimeout(function() {\n * // do some async task\n * callback(null, 'one');\n * }, 200);\n * },\n * function(callback) {\n * setTimeout(function() {\n * // then do another async task\n * callback(null, 'two');\n * }, 100);\n * }\n * ]);\n * console.log(results);\n * // results is equal to ['one','two']\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * // an example using an object instead of an array\n * async () => {\n * try {\n * let results = await async.parallel({\n * one: function(callback) {\n * setTimeout(function() {\n * // do some async task\n * callback(null, 1);\n * }, 200);\n * },\n * two: function(callback) {\n * setTimeout(function() {\n * // then do another async task\n * callback(null, 2);\n * }, 100);\n * }\n * });\n * console.log(results);\n * // results is equal to: { one: 1, two: 2 }\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\n\n\nfunction series(tasks, callback) {\n return _parallel(eachOfSeries$1, tasks, callback);\n}\n/**\n * Returns `true` if at least one element in the `coll` satisfies an async test.\n * If any iteratee call returns `true`, the main `callback` is immediately\n * called.\n *\n * @name some\n * @static\n * @memberOf module:Collections\n * @method\n * @alias any\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async truth test to apply to each item\n * in the collections in parallel.\n * The iteratee should complete with a boolean `result` value.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called as soon as any\n * iteratee returns `true`, or after all the iteratee functions have finished.\n * Result will be either `true` or `false` depending on the values of the async\n * tests. Invoked with (err, result).\n * @returns {Promise} a promise, if no callback provided\n * @example\n *\n * // dir1 is a directory that contains file1.txt, file2.txt\n * // dir2 is a directory that contains file3.txt, file4.txt\n * // dir3 is a directory that contains file5.txt\n * // dir4 does not exist\n *\n * // asynchronous function that checks if a file exists\n * function fileExists(file, callback) {\n * fs.access(file, fs.constants.F_OK, (err) => {\n * callback(null, !err);\n * });\n * }\n *\n * // Using callbacks\n * async.some(['dir1/missing.txt','dir2/missing.txt','dir3/file5.txt'], fileExists,\n * function(err, result) {\n * console.log(result);\n * // true\n * // result is true since some file in the list exists\n * }\n *);\n *\n * async.some(['dir1/missing.txt','dir2/missing.txt','dir4/missing.txt'], fileExists,\n * function(err, result) {\n * console.log(result);\n * // false\n * // result is false since none of the files exists\n * }\n *);\n *\n * // Using Promises\n * async.some(['dir1/missing.txt','dir2/missing.txt','dir3/file5.txt'], fileExists)\n * .then( result => {\n * console.log(result);\n * // true\n * // result is true since some file in the list exists\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * async.some(['dir1/missing.txt','dir2/missing.txt','dir4/missing.txt'], fileExists)\n * .then( result => {\n * console.log(result);\n * // false\n * // result is false since none of the files exists\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let result = await async.some(['dir1/missing.txt','dir2/missing.txt','dir3/file5.txt'], fileExists);\n * console.log(result);\n * // true\n * // result is true since some file in the list exists\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * async () => {\n * try {\n * let result = await async.some(['dir1/missing.txt','dir2/missing.txt','dir4/missing.txt'], fileExists);\n * console.log(result);\n * // false\n * // result is false since none of the files exists\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\n\n\nfunction some(coll, iteratee, callback) {\n return _createTester(Boolean, res => res)(eachOf$1, coll, iteratee, callback);\n}\n\nvar some$1 = awaitify(some, 3);\n/**\n * The same as [`some`]{@link module:Collections.some} but runs a maximum of `limit` async operations at a time.\n *\n * @name someLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.some]{@link module:Collections.some}\n * @alias anyLimit\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - An async truth test to apply to each item\n * in the collections in parallel.\n * The iteratee should complete with a boolean `result` value.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called as soon as any\n * iteratee returns `true`, or after all the iteratee functions have finished.\n * Result will be either `true` or `false` depending on the values of the async\n * tests. Invoked with (err, result).\n * @returns {Promise} a promise, if no callback provided\n */\n\nfunction someLimit(coll, limit, iteratee, callback) {\n return _createTester(Boolean, res => res)(eachOfLimit(limit), coll, iteratee, callback);\n}\n\nvar someLimit$1 = awaitify(someLimit, 4);\n/**\n * The same as [`some`]{@link module:Collections.some} but runs only a single async operation at a time.\n *\n * @name someSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.some]{@link module:Collections.some}\n * @alias anySeries\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async truth test to apply to each item\n * in the collections in series.\n * The iteratee should complete with a boolean `result` value.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called as soon as any\n * iteratee returns `true`, or after all the iteratee functions have finished.\n * Result will be either `true` or `false` depending on the values of the async\n * tests. Invoked with (err, result).\n * @returns {Promise} a promise, if no callback provided\n */\n\nfunction someSeries(coll, iteratee, callback) {\n return _createTester(Boolean, res => res)(eachOfSeries$1, coll, iteratee, callback);\n}\n\nvar someSeries$1 = awaitify(someSeries, 3);\n/**\n * Sorts a list by the results of running each `coll` value through an async\n * `iteratee`.\n *\n * @name sortBy\n * @static\n * @memberOf module:Collections\n * @method\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * The iteratee should complete with a value to use as the sort criteria as\n * its `result`.\n * Invoked with (item, callback).\n * @param {Function} callback - A callback which is called after all the\n * `iteratee` functions have finished, or an error occurs. Results is the items\n * from the original `coll` sorted by the values returned by the `iteratee`\n * calls. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback passed\n * @example\n *\n * // bigfile.txt is a file that is 251100 bytes in size\n * // mediumfile.txt is a file that is 11000 bytes in size\n * // smallfile.txt is a file that is 121 bytes in size\n *\n * // asynchronous function that returns the file size in bytes\n * function getFileSizeInBytes(file, callback) {\n * fs.stat(file, function(err, stat) {\n * if (err) {\n * return callback(err);\n * }\n * callback(null, stat.size);\n * });\n * }\n *\n * // Using callbacks\n * async.sortBy(['mediumfile.txt','smallfile.txt','bigfile.txt'], getFileSizeInBytes,\n * function(err, results) {\n * if (err) {\n * console.log(err);\n * } else {\n * console.log(results);\n * // results is now the original array of files sorted by\n * // file size (ascending by default), e.g.\n * // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']\n * }\n * }\n * );\n *\n * // By modifying the callback parameter the\n * // sorting order can be influenced:\n *\n * // ascending order\n * async.sortBy(['mediumfile.txt','smallfile.txt','bigfile.txt'], function(file, callback) {\n * getFileSizeInBytes(file, function(getFileSizeErr, fileSize) {\n * if (getFileSizeErr) return callback(getFileSizeErr);\n * callback(null, fileSize);\n * });\n * }, function(err, results) {\n * if (err) {\n * console.log(err);\n * } else {\n * console.log(results);\n * // results is now the original array of files sorted by\n * // file size (ascending by default), e.g.\n * // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']\n * }\n * }\n * );\n *\n * // descending order\n * async.sortBy(['bigfile.txt','mediumfile.txt','smallfile.txt'], function(file, callback) {\n * getFileSizeInBytes(file, function(getFileSizeErr, fileSize) {\n * if (getFileSizeErr) {\n * return callback(getFileSizeErr);\n * }\n * callback(null, fileSize * -1);\n * });\n * }, function(err, results) {\n * if (err) {\n * console.log(err);\n * } else {\n * console.log(results);\n * // results is now the original array of files sorted by\n * // file size (ascending by default), e.g.\n * // [ 'bigfile.txt', 'mediumfile.txt', 'smallfile.txt']\n * }\n * }\n * );\n *\n * // Error handling\n * async.sortBy(['mediumfile.txt','smallfile.txt','missingfile.txt'], getFileSizeInBytes,\n * function(err, results) {\n * if (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * } else {\n * console.log(results);\n * }\n * }\n * );\n *\n * // Using Promises\n * async.sortBy(['mediumfile.txt','smallfile.txt','bigfile.txt'], getFileSizeInBytes)\n * .then( results => {\n * console.log(results);\n * // results is now the original array of files sorted by\n * // file size (ascending by default), e.g.\n * // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * // Error handling\n * async.sortBy(['mediumfile.txt','smallfile.txt','missingfile.txt'], getFileSizeInBytes)\n * .then( results => {\n * console.log(results);\n * }).catch( err => {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * });\n *\n * // Using async/await\n * (async () => {\n * try {\n * let results = await async.sortBy(['bigfile.txt','mediumfile.txt','smallfile.txt'], getFileSizeInBytes);\n * console.log(results);\n * // results is now the original array of files sorted by\n * // file size (ascending by default), e.g.\n * // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']\n * }\n * catch (err) {\n * console.log(err);\n * }\n * })();\n *\n * // Error handling\n * async () => {\n * try {\n * let results = await async.sortBy(['missingfile.txt','mediumfile.txt','smallfile.txt'], getFileSizeInBytes);\n * console.log(results);\n * }\n * catch (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * }\n * }\n *\n */\n\nfunction sortBy(coll, iteratee, callback) {\n var _iteratee = wrapAsync(iteratee);\n\n return map$1(coll, (x, iterCb) => {\n _iteratee(x, (err, criteria) => {\n if (err) return iterCb(err);\n iterCb(err, {\n value: x,\n criteria\n });\n });\n }, (err, results) => {\n if (err) return callback(err);\n callback(null, results.sort(comparator).map(v => v.value));\n });\n\n function comparator(left, right) {\n var a = left.criteria,\n b = right.criteria;\n return a < b ? -1 : a > b ? 1 : 0;\n }\n}\n\nvar sortBy$1 = awaitify(sortBy, 3);\n/**\n * Sets a time limit on an asynchronous function. If the function does not call\n * its callback within the specified milliseconds, it will be called with a\n * timeout error. The code property for the error object will be `'ETIMEDOUT'`.\n *\n * @name timeout\n * @static\n * @memberOf module:Utils\n * @method\n * @category Util\n * @param {AsyncFunction} asyncFn - The async function to limit in time.\n * @param {number} milliseconds - The specified time limit.\n * @param {*} [info] - Any variable you want attached (`string`, `object`, etc)\n * to timeout Error for more information..\n * @returns {AsyncFunction} Returns a wrapped function that can be used with any\n * of the control flow functions.\n * Invoke this function with the same parameters as you would `asyncFunc`.\n * @example\n *\n * function myFunction(foo, callback) {\n * doAsyncTask(foo, function(err, data) {\n * // handle errors\n * if (err) return callback(err);\n *\n * // do some stuff ...\n *\n * // return processed data\n * return callback(null, data);\n * });\n * }\n *\n * var wrapped = async.timeout(myFunction, 1000);\n *\n * // call `wrapped` as you would `myFunction`\n * wrapped({ bar: 'bar' }, function(err, data) {\n * // if `myFunction` takes < 1000 ms to execute, `err`\n * // and `data` will have their expected values\n *\n * // else `err` will be an Error with the code 'ETIMEDOUT'\n * });\n */\n\nfunction timeout(asyncFn, milliseconds, info) {\n var fn = wrapAsync(asyncFn);\n return initialParams((args, callback) => {\n var timedOut = false;\n var timer;\n\n function timeoutCallback() {\n var name = asyncFn.name || 'anonymous';\n var error = new Error('Callback function \"' + name + '\" timed out.');\n error.code = 'ETIMEDOUT';\n\n if (info) {\n error.info = info;\n }\n\n timedOut = true;\n callback(error);\n }\n\n args.push((...cbArgs) => {\n if (!timedOut) {\n callback(...cbArgs);\n clearTimeout(timer);\n }\n }); // setup timer and call original function\n\n timer = setTimeout(timeoutCallback, milliseconds);\n fn(...args);\n });\n}\n\nfunction range(size) {\n var result = Array(size);\n\n while (size--) {\n result[size] = size;\n }\n\n return result;\n}\n/**\n * The same as [times]{@link module:ControlFlow.times} but runs a maximum of `limit` async operations at a\n * time.\n *\n * @name timesLimit\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.times]{@link module:ControlFlow.times}\n * @category Control Flow\n * @param {number} count - The number of times to run the function.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - The async function to call `n` times.\n * Invoked with the iteration index and a callback: (n, next).\n * @param {Function} callback - see [async.map]{@link module:Collections.map}.\n * @returns {Promise} a promise, if no callback is provided\n */\n\n\nfunction timesLimit(count, limit, iteratee, callback) {\n var _iteratee = wrapAsync(iteratee);\n\n return mapLimit$1(range(count), limit, _iteratee, callback);\n}\n/**\n * Calls the `iteratee` function `n` times, and accumulates results in the same\n * manner you would use with [map]{@link module:Collections.map}.\n *\n * @name times\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.map]{@link module:Collections.map}\n * @category Control Flow\n * @param {number} n - The number of times to run the function.\n * @param {AsyncFunction} iteratee - The async function to call `n` times.\n * Invoked with the iteration index and a callback: (n, next).\n * @param {Function} callback - see {@link module:Collections.map}.\n * @returns {Promise} a promise, if no callback is provided\n * @example\n *\n * // Pretend this is some complicated async factory\n * var createUser = function(id, callback) {\n * callback(null, {\n * id: 'user' + id\n * });\n * };\n *\n * // generate 5 users\n * async.times(5, function(n, next) {\n * createUser(n, function(err, user) {\n * next(err, user);\n * });\n * }, function(err, users) {\n * // we should now have 5 users\n * });\n */\n\n\nfunction times(n, iteratee, callback) {\n return timesLimit(n, Infinity, iteratee, callback);\n}\n/**\n * The same as [times]{@link module:ControlFlow.times} but runs only a single async operation at a time.\n *\n * @name timesSeries\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.times]{@link module:ControlFlow.times}\n * @category Control Flow\n * @param {number} n - The number of times to run the function.\n * @param {AsyncFunction} iteratee - The async function to call `n` times.\n * Invoked with the iteration index and a callback: (n, next).\n * @param {Function} callback - see {@link module:Collections.map}.\n * @returns {Promise} a promise, if no callback is provided\n */\n\n\nfunction timesSeries(n, iteratee, callback) {\n return timesLimit(n, 1, iteratee, callback);\n}\n/**\n * A relative of `reduce`. Takes an Object or Array, and iterates over each\n * element in parallel, each step potentially mutating an `accumulator` value.\n * The type of the accumulator defaults to the type of collection passed in.\n *\n * @name transform\n * @static\n * @memberOf module:Collections\n * @method\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {*} [accumulator] - The initial state of the transform. If omitted,\n * it will default to an empty Object or Array, depending on the type of `coll`\n * @param {AsyncFunction} iteratee - A function applied to each item in the\n * collection that potentially modifies the accumulator.\n * Invoked with (accumulator, item, key, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Result is the transformed accumulator.\n * Invoked with (err, result).\n * @returns {Promise} a promise, if no callback provided\n * @example\n *\n * // file1.txt is a file that is 1000 bytes in size\n * // file2.txt is a file that is 2000 bytes in size\n * // file3.txt is a file that is 3000 bytes in size\n *\n * // helper function that returns human-readable size format from bytes\n * function formatBytes(bytes, decimals = 2) {\n * // implementation not included for brevity\n * return humanReadbleFilesize;\n * }\n *\n * const fileList = ['file1.txt','file2.txt','file3.txt'];\n *\n * // asynchronous function that returns the file size, transformed to human-readable format\n * // e.g. 1024 bytes = 1KB, 1234 bytes = 1.21 KB, 1048576 bytes = 1MB, etc.\n * function transformFileSize(acc, value, key, callback) {\n * fs.stat(value, function(err, stat) {\n * if (err) {\n * return callback(err);\n * }\n * acc[key] = formatBytes(stat.size);\n * callback(null);\n * });\n * }\n *\n * // Using callbacks\n * async.transform(fileList, transformFileSize, function(err, result) {\n * if(err) {\n * console.log(err);\n * } else {\n * console.log(result);\n * // [ '1000 Bytes', '1.95 KB', '2.93 KB' ]\n * }\n * });\n *\n * // Using Promises\n * async.transform(fileList, transformFileSize)\n * .then(result => {\n * console.log(result);\n * // [ '1000 Bytes', '1.95 KB', '2.93 KB' ]\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * // Using async/await\n * (async () => {\n * try {\n * let result = await async.transform(fileList, transformFileSize);\n * console.log(result);\n * // [ '1000 Bytes', '1.95 KB', '2.93 KB' ]\n * }\n * catch (err) {\n * console.log(err);\n * }\n * })();\n *\n * @example\n *\n * // file1.txt is a file that is 1000 bytes in size\n * // file2.txt is a file that is 2000 bytes in size\n * // file3.txt is a file that is 3000 bytes in size\n *\n * // helper function that returns human-readable size format from bytes\n * function formatBytes(bytes, decimals = 2) {\n * // implementation not included for brevity\n * return humanReadbleFilesize;\n * }\n *\n * const fileMap = { f1: 'file1.txt', f2: 'file2.txt', f3: 'file3.txt' };\n *\n * // asynchronous function that returns the file size, transformed to human-readable format\n * // e.g. 1024 bytes = 1KB, 1234 bytes = 1.21 KB, 1048576 bytes = 1MB, etc.\n * function transformFileSize(acc, value, key, callback) {\n * fs.stat(value, function(err, stat) {\n * if (err) {\n * return callback(err);\n * }\n * acc[key] = formatBytes(stat.size);\n * callback(null);\n * });\n * }\n *\n * // Using callbacks\n * async.transform(fileMap, transformFileSize, function(err, result) {\n * if(err) {\n * console.log(err);\n * } else {\n * console.log(result);\n * // { f1: '1000 Bytes', f2: '1.95 KB', f3: '2.93 KB' }\n * }\n * });\n *\n * // Using Promises\n * async.transform(fileMap, transformFileSize)\n * .then(result => {\n * console.log(result);\n * // { f1: '1000 Bytes', f2: '1.95 KB', f3: '2.93 KB' }\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let result = await async.transform(fileMap, transformFileSize);\n * console.log(result);\n * // { f1: '1000 Bytes', f2: '1.95 KB', f3: '2.93 KB' }\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\n\n\nfunction transform(coll, accumulator, iteratee, callback) {\n if (arguments.length <= 3 && typeof accumulator === 'function') {\n callback = iteratee;\n iteratee = accumulator;\n accumulator = Array.isArray(coll) ? [] : {};\n }\n\n callback = once(callback || promiseCallback());\n\n var _iteratee = wrapAsync(iteratee);\n\n eachOf$1(coll, (v, k, cb) => {\n _iteratee(accumulator, v, k, cb);\n }, err => callback(err, accumulator));\n return callback[PROMISE_SYMBOL];\n}\n/**\n * It runs each task in series but stops whenever any of the functions were\n * successful. If one of the tasks were successful, the `callback` will be\n * passed the result of the successful task. If all tasks fail, the callback\n * will be passed the error and result (if any) of the final attempt.\n *\n * @name tryEach\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {Array|Iterable|AsyncIterable|Object} tasks - A collection containing functions to\n * run, each function is passed a `callback(err, result)` it must call on\n * completion with an error `err` (which can be `null`) and an optional `result`\n * value.\n * @param {Function} [callback] - An optional callback which is called when one\n * of the tasks has succeeded, or all have failed. It receives the `err` and\n * `result` arguments of the last attempt at completing the `task`. Invoked with\n * (err, results).\n * @returns {Promise} a promise, if no callback is passed\n * @example\n * async.tryEach([\n * function getDataFromFirstWebsite(callback) {\n * // Try getting the data from the first website\n * callback(err, data);\n * },\n * function getDataFromSecondWebsite(callback) {\n * // First website failed,\n * // Try getting the data from the backup website\n * callback(err, data);\n * }\n * ],\n * // optional callback\n * function(err, results) {\n * Now do something with the data.\n * });\n *\n */\n\n\nfunction tryEach(tasks, callback) {\n var error = null;\n var result;\n return eachSeries$1(tasks, (task, taskCb) => {\n wrapAsync(task)((err, ...args) => {\n if (err === false) return taskCb(err);\n\n if (args.length < 2) {\n [result] = args;\n } else {\n result = args;\n }\n\n error = err;\n taskCb(err ? null : {});\n });\n }, () => callback(error, result));\n}\n\nvar tryEach$1 = awaitify(tryEach);\n/**\n * Undoes a [memoize]{@link module:Utils.memoize}d function, reverting it to the original,\n * unmemoized form. Handy for testing.\n *\n * @name unmemoize\n * @static\n * @memberOf module:Utils\n * @method\n * @see [async.memoize]{@link module:Utils.memoize}\n * @category Util\n * @param {AsyncFunction} fn - the memoized function\n * @returns {AsyncFunction} a function that calls the original unmemoized function\n */\n\nfunction unmemoize(fn) {\n return (...args) => {\n return (fn.unmemoized || fn)(...args);\n };\n}\n/**\n * Repeatedly call `iteratee`, while `test` returns `true`. Calls `callback` when\n * stopped, or an error occurs.\n *\n * @name whilst\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {AsyncFunction} test - asynchronous truth test to perform before each\n * execution of `iteratee`. Invoked with ().\n * @param {AsyncFunction} iteratee - An async function which is called each time\n * `test` passes. Invoked with (callback).\n * @param {Function} [callback] - A callback which is called after the test\n * function has failed and repeated execution of `iteratee` has stopped. `callback`\n * will be passed an error and any arguments passed to the final `iteratee`'s\n * callback. Invoked with (err, [results]);\n * @returns {Promise} a promise, if no callback is passed\n * @example\n *\n * var count = 0;\n * async.whilst(\n * function test(cb) { cb(null, count < 5); },\n * function iter(callback) {\n * count++;\n * setTimeout(function() {\n * callback(null, count);\n * }, 1000);\n * },\n * function (err, n) {\n * // 5 seconds have passed, n = 5\n * }\n * );\n */\n\n\nfunction whilst(test, iteratee, callback) {\n callback = onlyOnce(callback);\n\n var _fn = wrapAsync(iteratee);\n\n var _test = wrapAsync(test);\n\n var results = [];\n\n function next(err, ...rest) {\n if (err) return callback(err);\n results = rest;\n if (err === false) return;\n\n _test(check);\n }\n\n function check(err, truth) {\n if (err) return callback(err);\n if (err === false) return;\n if (!truth) return callback(null, ...results);\n\n _fn(next);\n }\n\n return _test(check);\n}\n\nvar whilst$1 = awaitify(whilst, 3);\n/**\n * Repeatedly call `iteratee` until `test` returns `true`. Calls `callback` when\n * stopped, or an error occurs. `callback` will be passed an error and any\n * arguments passed to the final `iteratee`'s callback.\n *\n * The inverse of [whilst]{@link module:ControlFlow.whilst}.\n *\n * @name until\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.whilst]{@link module:ControlFlow.whilst}\n * @category Control Flow\n * @param {AsyncFunction} test - asynchronous truth test to perform before each\n * execution of `iteratee`. Invoked with (callback).\n * @param {AsyncFunction} iteratee - An async function which is called each time\n * `test` fails. Invoked with (callback).\n * @param {Function} [callback] - A callback which is called after the test\n * function has passed and repeated execution of `iteratee` has stopped. `callback`\n * will be passed an error and any arguments passed to the final `iteratee`'s\n * callback. Invoked with (err, [results]);\n * @returns {Promise} a promise, if a callback is not passed\n *\n * @example\n * const results = []\n * let finished = false\n * async.until(function test(cb) {\n * cb(null, finished)\n * }, function iter(next) {\n * fetchPage(url, (err, body) => {\n * if (err) return next(err)\n * results = results.concat(body.objects)\n * finished = !!body.next\n * next(err)\n * })\n * }, function done (err) {\n * // all pages have been fetched\n * })\n */\n\nfunction until(test, iteratee, callback) {\n const _test = wrapAsync(test);\n\n return whilst$1(cb => _test((err, truth) => cb(err, !truth)), iteratee, callback);\n}\n/**\n * Runs the `tasks` array of functions in series, each passing their results to\n * the next in the array. However, if any of the `tasks` pass an error to their\n * own callback, the next function is not executed, and the main `callback` is\n * immediately called with the error.\n *\n * @name waterfall\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {Array} tasks - An array of [async functions]{@link AsyncFunction}\n * to run.\n * Each function should complete with any number of `result` values.\n * The `result` values will be passed as arguments, in order, to the next task.\n * @param {Function} [callback] - An optional callback to run once all the\n * functions have completed. This will be passed the results of the last task's\n * callback. Invoked with (err, [results]).\n * @returns undefined\n * @example\n *\n * async.waterfall([\n * function(callback) {\n * callback(null, 'one', 'two');\n * },\n * function(arg1, arg2, callback) {\n * // arg1 now equals 'one' and arg2 now equals 'two'\n * callback(null, 'three');\n * },\n * function(arg1, callback) {\n * // arg1 now equals 'three'\n * callback(null, 'done');\n * }\n * ], function (err, result) {\n * // result now equals 'done'\n * });\n *\n * // Or, with named functions:\n * async.waterfall([\n * myFirstFunction,\n * mySecondFunction,\n * myLastFunction,\n * ], function (err, result) {\n * // result now equals 'done'\n * });\n * function myFirstFunction(callback) {\n * callback(null, 'one', 'two');\n * }\n * function mySecondFunction(arg1, arg2, callback) {\n * // arg1 now equals 'one' and arg2 now equals 'two'\n * callback(null, 'three');\n * }\n * function myLastFunction(arg1, callback) {\n * // arg1 now equals 'three'\n * callback(null, 'done');\n * }\n */\n\n\nfunction waterfall(tasks, callback) {\n callback = once(callback);\n if (!Array.isArray(tasks)) return callback(new Error('First argument to waterfall must be an array of functions'));\n if (!tasks.length) return callback();\n var taskIndex = 0;\n\n function nextTask(args) {\n var task = wrapAsync(tasks[taskIndex++]);\n task(...args, onlyOnce(next));\n }\n\n function next(err, ...args) {\n if (err === false) return;\n\n if (err || taskIndex === tasks.length) {\n return callback(err, ...args);\n }\n\n nextTask(args);\n }\n\n nextTask([]);\n}\n\nvar waterfall$1 = awaitify(waterfall);\n/**\n * An \"async function\" in the context of Async is an asynchronous function with\n * a variable number of parameters, with the final parameter being a callback.\n * (`function (arg1, arg2, ..., callback) {}`)\n * The final callback is of the form `callback(err, results...)`, which must be\n * called once the function is completed. The callback should be called with a\n * Error as its first argument to signal that an error occurred.\n * Otherwise, if no error occurred, it should be called with `null` as the first\n * argument, and any additional `result` arguments that may apply, to signal\n * successful completion.\n * The callback must be called exactly once, ideally on a later tick of the\n * JavaScript event loop.\n *\n * This type of function is also referred to as a \"Node-style async function\",\n * or a \"continuation passing-style function\" (CPS). Most of the methods of this\n * library are themselves CPS/Node-style async functions, or functions that\n * return CPS/Node-style async functions.\n *\n * Wherever we accept a Node-style async function, we also directly accept an\n * [ES2017 `async` function]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function}.\n * In this case, the `async` function will not be passed a final callback\n * argument, and any thrown error will be used as the `err` argument of the\n * implicit callback, and the return value will be used as the `result` value.\n * (i.e. a `rejected` of the returned Promise becomes the `err` callback\n * argument, and a `resolved` value becomes the `result`.)\n *\n * Note, due to JavaScript limitations, we can only detect native `async`\n * functions and not transpilied implementations.\n * Your environment must have `async`/`await` support for this to work.\n * (e.g. Node > v7.6, or a recent version of a modern browser).\n * If you are using `async` functions through a transpiler (e.g. Babel), you\n * must still wrap the function with [asyncify]{@link module:Utils.asyncify},\n * because the `async function` will be compiled to an ordinary function that\n * returns a promise.\n *\n * @typedef {Function} AsyncFunction\n * @static\n */\n\nvar index = {\n apply,\n applyEach: applyEach$1,\n applyEachSeries,\n asyncify,\n auto,\n autoInject,\n cargo,\n cargoQueue: cargo$1,\n compose,\n concat: concat$1,\n concatLimit: concatLimit$1,\n concatSeries: concatSeries$1,\n constant,\n detect: detect$1,\n detectLimit: detectLimit$1,\n detectSeries: detectSeries$1,\n dir,\n doUntil,\n doWhilst: doWhilst$1,\n each,\n eachLimit: eachLimit$2,\n eachOf: eachOf$1,\n eachOfLimit: eachOfLimit$2,\n eachOfSeries: eachOfSeries$1,\n eachSeries: eachSeries$1,\n ensureAsync,\n every: every$1,\n everyLimit: everyLimit$1,\n everySeries: everySeries$1,\n filter: filter$1,\n filterLimit: filterLimit$1,\n filterSeries: filterSeries$1,\n forever: forever$1,\n groupBy,\n groupByLimit: groupByLimit$1,\n groupBySeries,\n log,\n map: map$1,\n mapLimit: mapLimit$1,\n mapSeries: mapSeries$1,\n mapValues,\n mapValuesLimit: mapValuesLimit$1,\n mapValuesSeries,\n memoize,\n nextTick,\n parallel,\n parallelLimit,\n priorityQueue,\n queue: queue$1,\n race: race$1,\n reduce: reduce$1,\n reduceRight,\n reflect,\n reflectAll,\n reject: reject$2,\n rejectLimit: rejectLimit$1,\n rejectSeries: rejectSeries$1,\n retry,\n retryable,\n seq,\n series,\n setImmediate: setImmediate$1,\n some: some$1,\n someLimit: someLimit$1,\n someSeries: someSeries$1,\n sortBy: sortBy$1,\n timeout,\n times,\n timesLimit,\n timesSeries,\n transform,\n tryEach: tryEach$1,\n unmemoize,\n until,\n waterfall: waterfall$1,\n whilst: whilst$1,\n // aliases\n all: every$1,\n allLimit: everyLimit$1,\n allSeries: everySeries$1,\n any: some$1,\n anyLimit: someLimit$1,\n anySeries: someSeries$1,\n find: detect$1,\n findLimit: detectLimit$1,\n findSeries: detectSeries$1,\n flatMap: concat$1,\n flatMapLimit: concatLimit$1,\n flatMapSeries: concatSeries$1,\n forEach: each,\n forEachSeries: eachSeries$1,\n forEachLimit: eachLimit$2,\n forEachOf: eachOf$1,\n forEachOfSeries: eachOfSeries$1,\n forEachOfLimit: eachOfLimit$2,\n inject: reduce$1,\n foldl: reduce$1,\n foldr: reduceRight,\n select: filter$1,\n selectLimit: filterLimit$1,\n selectSeries: filterSeries$1,\n wrapSync: asyncify,\n during: whilst$1,\n doDuring: doWhilst$1\n};\nexport default index;\nexport { apply, applyEach$1 as applyEach, applyEachSeries, asyncify, auto, autoInject, cargo, cargo$1 as cargoQueue, compose, concat$1 as concat, concatLimit$1 as concatLimit, concatSeries$1 as concatSeries, constant, detect$1 as detect, detectLimit$1 as detectLimit, detectSeries$1 as detectSeries, dir, doUntil, doWhilst$1 as doWhilst, each, eachLimit$2 as eachLimit, eachOf$1 as eachOf, eachOfLimit$2 as eachOfLimit, eachOfSeries$1 as eachOfSeries, eachSeries$1 as eachSeries, ensureAsync, every$1 as every, everyLimit$1 as everyLimit, everySeries$1 as everySeries, filter$1 as filter, filterLimit$1 as filterLimit, filterSeries$1 as filterSeries, forever$1 as forever, groupBy, groupByLimit$1 as groupByLimit, groupBySeries, log, map$1 as map, mapLimit$1 as mapLimit, mapSeries$1 as mapSeries, mapValues, mapValuesLimit$1 as mapValuesLimit, mapValuesSeries, memoize, nextTick, parallel, parallelLimit, priorityQueue, queue$1 as queue, race$1 as race, reduce$1 as reduce, reduceRight, reflect, reflectAll, reject$2 as reject, rejectLimit$1 as rejectLimit, rejectSeries$1 as rejectSeries, retry, retryable, seq, series, setImmediate$1 as setImmediate, some$1 as some, someLimit$1 as someLimit, someSeries$1 as someSeries, sortBy$1 as sortBy, timeout, times, timesLimit, timesSeries, transform, tryEach$1 as tryEach, unmemoize, until, waterfall$1 as waterfall, whilst$1 as whilst, every$1 as all, everyLimit$1 as allLimit, everySeries$1 as allSeries, some$1 as any, someLimit$1 as anyLimit, someSeries$1 as anySeries, detect$1 as find, detectLimit$1 as findLimit, detectSeries$1 as findSeries, concat$1 as flatMap, concatLimit$1 as flatMapLimit, concatSeries$1 as flatMapSeries, each as forEach, eachSeries$1 as forEachSeries, eachLimit$2 as forEachLimit, eachOf$1 as forEachOf, eachOfSeries$1 as forEachOfSeries, eachOfLimit$2 as forEachOfLimit, reduce$1 as inject, reduce$1 as foldl, reduceRight as foldr, filter$1 as select, filterLimit$1 as selectLimit, filterSeries$1 as selectSeries, asyncify as wrapSync, whilst$1 as during, doWhilst$1 as doDuring };","map":{"version":3,"sources":["D:/Development/Work/CENOS/cenos-ui/node_modules/async/dist/async.mjs"],"names":["apply","fn","args","callArgs","initialParams","callback","pop","call","hasQueueMicrotask","queueMicrotask","hasSetImmediate","setImmediate","hasNextTick","process","nextTick","fallback","setTimeout","wrap","defer","_defer","setImmediate$1","asyncify","func","isAsync","promise","handlePromise","result","e","then","value","invokeCallback","err","message","Error","error","Symbol","toStringTag","isAsyncGenerator","isAsyncIterable","obj","asyncIterator","wrapAsync","asyncFn","awaitify","arity","length","awaitable","Promise","resolve","reject","cbArgs","applyEach","eachfn","fns","go","that","cb","concat","_asyncMap","arr","iteratee","results","counter","_iteratee","_","iterCb","index","v","isArrayLike","breakLoop","once","wrapper","callFn","Object","assign","getIterator","coll","iterator","createArrayIterator","i","len","next","key","createES2015Iterator","item","done","createObjectIterator","okeys","keys","createIterator","onlyOnce","asyncEachOfLimit","generator","limit","canceled","awaiting","running","idx","replenish","iterDone","iterateeCallback","catch","handleError","eachOfLimit","RangeError","nextElem","looping","elem","eachOfLimit$1","eachOfLimit$2","eachOfArrayLike","completed","iteratorCallback","eachOfGeneric","Infinity","eachOf","eachOfImplementation","eachOf$1","map","map$1","applyEach$1","eachOfSeries","eachOfSeries$1","mapSeries","mapSeries$1","applyEachSeries","PROMISE_SYMBOL","promiseCallback","res","rej","auto","tasks","concurrency","numTasks","runningTasks","hasError","listeners","create","readyTasks","readyToCheck","uncheckedDependencies","forEach","task","Array","isArray","enqueueTask","push","dependencies","slice","remainingDependencies","dependencyName","join","addListener","checkForDeadlocks","processQueue","runTask","run","shift","taskName","taskListeners","taskComplete","taskCallback","safeResults","rkey","taskFn","currentTask","getDependents","dependent","indexOf","FN_ARGS","ARROW_FN_ARGS","FN_ARG_SPLIT","FN_ARG","STRIP_COMMENTS","parseParams","src","toString","replace","match","split","arg","trim","autoInject","newTasks","params","fnIsAsync","hasNoDeps","newTask","taskCb","newArgs","name","DLL","constructor","head","tail","removeLink","node","prev","empty","insertAfter","newNode","insertBefore","unshift","setInitial","toArray","cur","data","remove","testFn","curr","dll","queue","worker","payload","_worker","numRunning","workersList","events","drain","saturated","unsaturated","on","event","handler","handleAndRemove","off","ev","filter","trigger","processingScheduled","_insert","insertAtFront","rejectOnError","q","started","_tasks","_createCB","l","splice","buffer","idle","_maybeDrain","eventMethod","isProcessing","paused","datum","pushAsync","kill","unshiftAsync","Math","min","pause","resume","defineProperties","writable","cargo","cargo$1","reduce","memo","x","reduce$1","seq","functions","_functions","newargs","nextargs","compose","reverse","mapLimit","mapLimit$1","concatLimit","val","mapResults","concatLimit$1","concat$1","concatSeries","concatSeries$1","constant","ignoredArgs","_createTester","check","getResult","testPassed","testResult","detect","bool","detect$1","detectLimit","detectLimit$1","detectSeries","detectSeries$1","consoleFunc","resultArgs","console","dir","doWhilst","test","_fn","_test","truth","doWhilst$1","doUntil","_withoutIndex","eachLimit","each","eachLimit$1","eachLimit$2","eachSeries","eachSeries$1","ensureAsync","sync","innerArgs","every","every$1","everyLimit","everyLimit$1","everySeries","everySeries$1","filterArray","truthValues","filterGeneric","sort","a","b","_filter","filter$1","filterLimit","filterLimit$1","filterSeries","filterSeries$1","forever","errback","forever$1","groupByLimit","hasOwnProperty","prototype","groupByLimit$1","groupBy","groupBySeries","log","mapValuesLimit","newObj","mapValuesLimit$1","mapValues","mapValuesSeries","memoize","hasher","queues","memoized","unmemoized","_defer$1","_parallel","parallel","parallelLimit","queue$1","items","Heap","heap","pushCount","Number","MIN_SAFE_INTEGER","percUp","p","smaller","parent","t","percDown","leftChi","top","j","y","priority","priorityQueue","race","TypeError","race$1","reduceRight","array","reversed","reflect","reflectOn","reflectCallback","retVal","reflectAll","reject$1","reject$2","rejectLimit","rejectLimit$1","rejectSeries","rejectSeries$1","constant$1","DEFAULT_TIMES","DEFAULT_INTERVAL","retry","opts","options","times","intervalFunc","arguments","parseTimes","_task","attempt","retryAttempt","errorFilter","acc","interval","retryable","series","some","Boolean","some$1","someLimit","someLimit$1","someSeries","someSeries$1","sortBy","criteria","comparator","left","right","sortBy$1","timeout","milliseconds","info","timedOut","timer","timeoutCallback","code","clearTimeout","range","size","timesLimit","count","n","timesSeries","transform","accumulator","k","tryEach","tryEach$1","unmemoize","whilst","rest","whilst$1","until","waterfall","taskIndex","nextTask","waterfall$1","cargoQueue","all","allLimit","allSeries","any","anyLimit","anySeries","find","findLimit","findSeries","flatMap","flatMapLimit","flatMapSeries","forEachSeries","forEachLimit","forEachOf","forEachOfSeries","forEachOfLimit","inject","foldl","foldr","select","selectLimit","selectSeries","wrapSync","during","doDuring"],"mappings":"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CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,SAAS8G,MAAT,CAAgBvC,IAAhB,EAAsBhB,QAAtB,EAAgCvD,QAAhC,EAA0C;AACtC,MAAI+G,oBAAoB,GAAGhD,WAAW,CAACQ,IAAD,CAAX,GAAoBkC,eAApB,GAAsCG,aAAjE;AACA,SAAOG,oBAAoB,CAACxC,IAAD,EAAOnC,SAAS,CAACmB,QAAD,CAAhB,EAA4BvD,QAA5B,CAA3B;AACH;;AAED,IAAIgH,QAAQ,GAAG1E,QAAQ,CAACwE,MAAD,EAAS,CAAT,CAAvB;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASG,GAAT,CAAc1C,IAAd,EAAoBhB,QAApB,EAA8BvD,QAA9B,EAAwC;AACpC,SAAOqD,SAAS,CAAC2D,QAAD,EAAWzC,IAAX,EAAiBhB,QAAjB,EAA2BvD,QAA3B,CAAhB;AACH;;AACD,IAAIkH,KAAK,GAAG5E,QAAQ,CAAC2E,GAAD,EAAM,CAAN,CAApB;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,IAAIE,WAAW,GAAGrE,SAAS,CAACoE,KAAD,CAA3B;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASE,YAAT,CAAsB7C,IAAtB,EAA4BhB,QAA5B,EAAsCvD,QAAtC,EAAgD;AAC5C,SAAOwG,aAAa,CAACjC,IAAD,EAAO,CAAP,EAAUhB,QAAV,EAAoBvD,QAApB,CAApB;AACH;;AACD,IAAIqH,cAAc,GAAG/E,QAAQ,CAAC8E,YAAD,EAAe,CAAf,CAA7B;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASE,SAAT,CAAoB/C,IAApB,EAA0BhB,QAA1B,EAAoCvD,QAApC,EAA8C;AAC1C,SAAOqD,SAAS,CAACgE,cAAD,EAAiB9C,IAAjB,EAAuBhB,QAAvB,EAAiCvD,QAAjC,CAAhB;AACH;;AACD,IAAIuH,WAAW,GAAGjF,QAAQ,CAACgF,SAAD,EAAY,CAAZ,CAA1B;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,IAAIE,eAAe,GAAG1E,SAAS,CAACyE,WAAD,CAA/B;AAEA,MAAME,cAAc,GAAG3F,MAAM,CAAC,iBAAD,CAA7B;;AAEA,SAAS4F,eAAT,GAA4B;AACxB,MAAI/E,OAAJ,EAAaC,MAAb;;AACA,WAAS5C,QAAT,CAAmB0B,GAAnB,EAAwB,GAAG7B,IAA3B,EAAiC;AAC7B,QAAI6B,GAAJ,EAAS,OAAOkB,MAAM,CAAClB,GAAD,CAAb;AACTiB,IAAAA,OAAO,CAAC9C,IAAI,CAAC2C,MAAL,GAAc,CAAd,GAAkB3C,IAAlB,GAAyBA,IAAI,CAAC,CAAD,CAA9B,CAAP;AACH;;AAEDG,EAAAA,QAAQ,CAACyH,cAAD,CAAR,GAA2B,IAAI/E,OAAJ,CAAY,CAACiF,GAAD,EAAMC,GAAN,KAAc;AACjDjF,IAAAA,OAAO,GAAGgF,GAAV,EACA/E,MAAM,GAAGgF,GADT;AAEH,GAH0B,CAA3B;AAKA,SAAO5H,QAAP;AACH;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,SAAS6H,IAAT,CAAcC,KAAd,EAAqBC,WAArB,EAAkC/H,QAAlC,EAA4C;AACxC,MAAI,OAAO+H,WAAP,KAAuB,QAA3B,EAAqC;AACjC;AACA/H,IAAAA,QAAQ,GAAG+H,WAAX;AACAA,IAAAA,WAAW,GAAG,IAAd;AACH;;AACD/H,EAAAA,QAAQ,GAA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AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,SAAS2C,OAAT,CAAiB5C,MAAjB,EAAyBhF,WAAzB,EAAsCiF,OAAtC,EAA+C;AAC3C,SAAOF,KAAK,CAACC,MAAD,EAAShF,WAAT,EAAsBiF,OAAtB,CAAZ;AACH;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,SAAS4C,MAAT,CAAgBrL,IAAhB,EAAsBsL,IAAtB,EAA4BtM,QAA5B,EAAsCvD,QAAtC,EAAgD;AAC5CA,EAAAA,QAAQ,GAAGiE,IAAI,CAACjE,QAAD,CAAf;;AACA,MAAI0D,SAAS,GAAGtB,SAAS,CAACmB,QAAD,CAAzB;;AACA,SAAO8D,cAAc,CAAC9C,IAAD,EAAO,CAACuL,CAAD,EAAIpL,CAAJ,EAAOd,MAAP,KAAkB;AAC1CF,IAAAA,SAAS,CAACmM,IAAD,EAAOC,CAAP,EAAU,CAACpO,GAAD,EAAMoC,CAAN,KAAY;AAC3B+L,MAAAA,IAAI,GAAG/L,CAAP;AACAF,MAAAA,MAAM,CAAClC,GAAD,CAAN;AACH,KAHQ,CAAT;AAIH,GALoB,EAKlBA,GAAG,IAAI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AAM,CAAC+B,MAAP,CAAc,GAAGuN,UAAU,CAACjM,CAAD,CAA3B,CAAT;AACH;AACJ;;AAED,WAAO1E,QAAQ,CAAC0B,GAAD,EAAML,MAAN,CAAf;AACH,GAdgB,CAAjB;AAeH;;AACD,IAAIuP,aAAa,GAAGtO,QAAQ,CAACmO,WAAD,EAAc,CAAd,CAA5B;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASrN,MAAT,CAAgBmB,IAAhB,EAAsBhB,QAAtB,EAAgCvD,QAAhC,EAA0C;AACtC,SAAO4Q,aAAa,CAACrM,IAAD,EAAOsC,QAAP,EAAiBtD,QAAjB,EAA2BvD,QAA3B,CAApB;AACH;;AACD,IAAI6Q,QAAQ,GAAGvO,QAAQ,CAACc,MAAD,EAAS,CAAT,CAAvB;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAAS0N,YAAT,CAAsBvM,IAAtB,EAA4BhB,QAA5B,EAAsCvD,QAAtC,EAAgD;AAC5C,SAAO4Q,aAAa,CAACrM,IAAD,EAAO,CAAP,EAAUhB,QAAV,EAAoBvD,QAApB,CAApB;AACH;;AACD,IAAI+Q,cAAc,GAAGzO,QAAQ,CAACwO,YAAD,EAAe,CAAf,CAA7B;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASE,QAAT,CAAkB,GAAGnR,IAArB,EAA2B;AACvB,SAAO,UAAU,GAAGoR;AAAW;AAAxB,IAAwC;AAC3C,QAAIjR,QAAQ,GAAGiR,WAAW,CAAChR,GAAZ,EAAf;AACA,WAAOD,QAAQ,CAAC,IAAD,EAAO,GAAGH,IAAV,CAAf;AACH,GAHD;AAIH;;AAED,SAASqR,aAAT,CAAuBC,KAAvB,EAA8BC,SAA9B,EAAyC;AACrC,SAAO,CAACrO,MAAD,EAASO,GAAT,EAAcI,SAAd,EAAyBP,EAAzB,KAAgC;AACnC,QAAIkO,UAAU,GAAG,KAAjB;AACA,QAAIC,UAAJ;AACA,UAAM/N,QAAQ,GAAGnB,SAAS,CAACsB,SAAD,CAA1B;AACAX,IAAAA,MAAM,CAACO,GAAD,EAAM,CAAC9B,KAAD,EAAQmC,CAAR,EAAW3D,QAAX,KAAwB;AAChCuD,MAAAA,QAAQ,CAAC/B,KAAD,EAAQ,CAACE,GAAD,EAAML,MAAN,KAAiB;AAC7B,YAAIK,GAAG,IAAIA,GAAG,KAAK,KAAnB,EAA0B,OAAO1B,QAAQ,CAAC0B,GAAD,CAAf;;AAE1B,YAAIyP,KAAK,CAAC9P,MAAD,CAAL,IAAiB,CAACiQ,UAAtB,EAAkC;AAC9BD,UAAAA,UAAU,GAAG,IAAb;AACAC,UAAAA,UAAU,GAAGF,SAAS,CAAC,IAAD,EAAO5P,KAAP,CAAtB;AACA,iBAAOxB,QAAQ,CAAC,IAAD,EAAOgE,SAAP,CAAf;AACH;;AACDhE,QAAAA,QAAQ;AACX,OATO,CAAR;AAUH,KAXK,EAWH0B,GAAG,IAAI;AACN,UAAIA,GAAJ,EAAS,OAAOyB,EAAE,CAACzB,GAAD,CAAT;AACTyB,MAAAA,EAAE,CAAC,IAAD,EAAOkO,UAAU,GAAGC,UAAH,GAAgBF,SAAS,CAAC,KAAD,CAA1C,CAAF;AACH,KAdK,CAAN;AAeH,GAnBD;AAoBH;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,SAASG,MAAT,CAAgBhN,IAAhB,EAAsBhB,QAAtB,EAAgCvD,QAAhC,EAA0C;AACtC,SAAOkR,aAAa,CAACM,IAAI,IAAIA,IAAT,EAAe,CAAC7J,GAAD,EAAM5C,IAAN,KAAeA,IAA9B,CAAb,CAAiDiC,QAAjD,EAA2DzC,IAA3D,EAAiEhB,QAAjE,EAA2EvD,QAA3E,CAAP;AACH;;AACD,IAAIyR,QAAQ,GAAGnP,QAAQ,CAACiP,MAAD,EAAS,CAAT,CAAvB;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASG,WAAT,CAAqBnN,IAArB,EAA2BiB,KAA3B,EAAkCjC,QAAlC,EAA4CvD,QAA5C,EAAsD;AAClD,SAAOkR,aAAa,CAACM,IAAI,IAAIA,IAAT,EAAe,CAAC7J,GAAD,EAAM5C,IAAN,KAAeA,IAA9B,CAAb,CAAiDmB,WAAW,CAACV,KAAD,CAA5D,EAAqEjB,IAArE,EAA2EhB,QAA3E,EAAqFvD,QAArF,CAAP;AACH;;AACD,IAAI2R,aAAa,GAAGrP,QAAQ,CAACoP,WAAD,EAAc,CAAd,CAA5B;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASE,YAAT,CAAsBrN,IAAtB,EAA4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D,EAAQqC,KAAR,EAAe7D,QAAf,KAA4BuD,QAAQ,CAAC/B,KAAD,EAAQxB,QAAR,CAA3C;AACH;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,SAAS0S,SAAT,CAAmBnO,IAAnB,EAAyBhB,QAAzB,EAAmCvD,QAAnC,EAA6C;AACzC,SAAOgH,QAAQ,CAACzC,IAAD,EAAOkO,aAAa,CAACrQ,SAAS,CAACmB,QAAD,CAAV,CAApB,EAA2CvD,QAA3C,CAAf;AACH;;AAED,IAAI2S,IAAI,GAAGrQ,QAAQ,CAACoQ,SAAD,EAAY,CAAZ,CAAnB;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASE,WAAT,CAAqBrO,IAArB,EAA2BiB,KAA3B,EAAkCjC,QAAlC,EAA4CvD,QAA5C,EAAsD;AAClD,SAAOkG,WAAW,CAACV,KAAD,CAAX,CAAmBjB,IAAnB,EAAyBkO,aAAa,CAACrQ,SAAS,CAACmB,QAAD,CAAV,CAAtC,EAA6DvD,QAA7D,CAAP;AACH;;AACD,IAAI6S,WAAW,GAAGvQ,QAAQ,CAACsQ,WAAD,EAAc,CAAd,CAA1B;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASE,UAAT,CAAoBvO,IAApB,EAA0BhB,QAA1B,EAAoCvD,QAApC,EAA8C;AAC1C,SAAO6S,WAAW,CAACtO,IAAD,EAAO,CAAP,EAAUhB,QAAV,EAAoBvD,QAApB,CAAlB;AACH;;AACD,IAAI+S,YAAY,GAAGzQ,QAAQ,CAACwQ,UAAD,EAAa,CAAb,CAA3B;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASE,WAAT,CAAqBpT,EAArB,EAAyB;AACrB,MAAIsB,OAAO,CAACtB,EAAD,CAAX,EAAiB,OAAOA,EAAP;AACjB,SAAO,UAAU,GAAGC;AAAI;AAAjB,IAAiC;AACpC,QAAIG,QAAQ,GAAGH,IAAI,CAACI,GAAL,EAAf;AACA,QAAIgT,IAAI,GAAG,IAAX;AACApT,IAAAA,IAAI,CAACgJ,IAAL,CAAU,CAAC,GAAGqK,SAAJ,KAAkB;AACxB,UAAID,IAAJ,EAAU;AACNlS,QAAAA,cAAc,CAAC,MAAMf,QAAQ,CAAC,GAAGkT,SAAJ,CAAf,CAAd;AACH,OAFD,MAEO;AACHlT,QAAAA,QAAQ,CAAC,GAAGkT,SAAJ,CAAR;AACH;AACJ,KAND;AAOAtT,IAAAA,EAAE,CAACD,KAAH,CAAS,IAAT,EAAeE,IAAf;AACAoT,IAAAA,IAAI,GAAG,KAAP;AACH,GAZD;AAaH;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASI,OAAT,CAAkBrQ,IAAlB,EAAwBhB,QAAxB,EAAkCvD,QAAlC,EAA4C;AACxC,SAAO2U,cAAc,CAACpQ,IAAD,EAAOsC,QAAP,EAAiBtD,QAAjB,EAA2BvD,QAA3B,CAArB;AACH;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,SAAS6U,aAAT,CAAwBtQ,IAAxB,EAA8BhB,QAA9B,EAAwCvD,QAAxC,EAAkD;AAC9C,SAAO2U,cAAc,CAACpQ,IAAD,EAAO,CAAP,EAAUhB,QAAV,EAAoBvD,QAApB,CAArB;AACH;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,IAAI8U,GAAG,GAAGhD,WAAW,CAAC,KAAD,CAArB;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASiD,cAAT,CAAwB7S,GAAxB,EAA6BsD,KAA7B,EAAoCjC,QAApC,EAA8CvD,QAA9C,EAAwD;AACpDA,EAAAA,QAAQ,GAAGiE,IAAI,CAACjE,QAAD,CAAf;AACA,MAAIgV,MAAM,GAAG,EAAb;;AACA,MAAItR,SAAS,GAAGtB,SAAS,CAACmB,QAAD,CAAzB;;AACA,SAAO2C,WAAW,CAACV,KAAD,CAAX,CAAmBtD,GAAnB,EAAwB,CAACwO,GAAD,EAAM7L,GAAN,EAAWD,IAAX,KAAoB;AAC/ClB,IAAAA,SAAS,CAACgN,GAAD,EAAM7L,GAAN,EAAW,CAACnD,GAAD,EAAML,MAAN,KAAiB;AACjC,UAAIK,GAAJ,EAAS,OAAOkD,IAAI,CAAClD,GAAD,CAAX;AACTsT,MAAAA,MAAM,CAACnQ,GAAD,CAAN,GAAcxD,MAAd;AACAuD,MAAAA,IAAI,CAAClD,GAAD,CAAJ;AACH,KAJQ,CAAT;AAKH,GANM,EAMJA,GAAG,IAAI1B,QAAQ,CAAC0B,GAAD,EAAMsT,MAAN,CANX,CAAP;AAOH;;AAED,IAAIC,gBAAgB,GAAG3S,QAAQ,CAACyS,cAAD,EAAiB,CAAjB,CAA/B;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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qB,EAArB,GAA0B,EAAxC;AAEA/E,EAAAA,MAAM,CAAC+E,KAAD,EAAQ,CAACW,IAAD,EAAO5D,GAAP,EAAY0G,MAAZ,KAAuB;AACjCnJ,IAAAA,SAAS,CAACqG,IAAD,CAAT,CAAgB,CAAC/G,GAAD,EAAM,GAAGL,MAAT,KAAoB;AAChC,UAAIA,MAAM,CAACmB,MAAP,GAAgB,CAApB,EAAuB;AACnB,SAACnB,MAAD,IAAWA,MAAX;AACH;;AACDmC,MAAAA,OAAO,CAACqB,GAAD,CAAP,GAAexD,MAAf;AACAkK,MAAAA,MAAM,CAAC7J,GAAD,CAAN;AACH,KAND;AAOH,GARK,EAQHA,GAAG,IAAI1B,QAAQ,CAAC0B,GAAD,EAAM8B,OAAN,CARZ,CAAN;AASH,CAZuB,EAYrB,CAZqB,CAAxB;AAcA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,SAASmS,QAAT,CAAkB7N,KAAlB,EAAyB9H,QAAzB,EAAmC;AAC/B,SAAO0V,SAAS,CAAC1O,QAAD,EAAWc,KAAX,EAAkB9H,QAAlB,CAAhB;AACH;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,SAAS4V,aAAT,CAAuB9N,KAAvB,EAA8BtC,KAA9B,EAAqCxF,QAArC,EAA+C;AAC3C,SAAO0V,SAAS,CAACxP,WAAW,CAACV,KAAD,CAAZ,EAAqBsC,KAArB,EAA4B9H,QAA5B,CAAhB;AACH;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,SAAS6V,OAAT,CAAkB9I,MAAlB,EAA0BhF,WAA1B,EAAuC;AACnC,MAAIkF,OAAO,GAAG7K,SAAS,CA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c,CAAd,CAA5B;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASE,YAAT,CAAuBxT,IAAvB,EAA6BhB,QAA7B,EAAuCvD,QAAvC,EAAiD;AAC7C,SAAO4C,MAAM,CAACyE,cAAD,EAAiB9C,IAAjB,EAAuBhB,QAAvB,EAAiCvD,QAAjC,CAAb;AACH;;AACD,IAAIgY,cAAc,GAAG1V,QAAQ,CAACyV,YAAD,EAAe,CAAf,CAA7B;;AAEA,SAASE,UAAT,CAAoBzW,KAApB,EAA2B;AACvB,SAAO,YAAY;AACf,WAAOA,KAAP;AACH,GAFD;AAGH;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,MAAM0W,aAAa,GAAG,CAAtB;AACA,MAAMC,gBAAgB,GAAG,CAAzB;;AAEA,SAASC,KAAT,CAAeC,IAAf,EAAqB5P,IAArB,EAA2BzI,QAA3B,EAAqC;AACjC,MAAIsY,OAAO,GAAG;AACVC,IAAAA,KAAK,EAAEL,aADG;AAEVM,IAAAA,YAAY,EAAEP,UAAU,CAACE,gBAAD;AAFd,GAAd;;AAKA,MAAIM,SAAS,CAACjW,MAAV,GAAmB,CAAnB,IAAwB,OAAO6V,IAAP,KAAgB,UAA5C,EAAwD;AACpDrY,IAAAA,QAAQ,GAAGyI,IAAI,IAAIf,eAAe,EAAlC;AACAe,IAAAA,IAAI,GAAG4P,IAAP;AACH,GA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AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,SAASyR,MAAT,CAAgBpR,KAAhB,EAAuB9H,QAAvB,EAAiC;AAC7B,SAAO0V,SAAS,CAACrO,cAAD,EAAiBS,KAAjB,EAAwB9H,QAAxB,CAAhB;AACH;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,SAASmZ,IAAT,CAAc5U,IAAd,EAAoBhB,QAApB,EAA8BvD,QAA9B,EAAwC;AACpC,SAAOkR,aAAa,CAACkI,OAAD,EAAUzR,GAAG,IAAIA,GAAjB,CAAb,CAAmCX,QAAnC,EAA6CzC,IAA7C,EAAmDhB,QAAnD,EAA6DvD,QAA7D,CAAP;AACH;;AACD,IAAIqZ,MAAM,GAAG/W,QAAQ,CAAC6W,IAAD,EAAO,CAAP,CAArB;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASG,SAAT,CAAmB/U,IAAnB,EAAyBiB,KAAzB,EAAgCjC,QAAhC,EAA0CvD,QAA1C,EAAoD;AAChD,SAAOkR,aAAa,CAACkI,OAAD,EAAUzR,GAAG,IAAIA,GAAjB,CAAb,CAAmCzB,WAAW,CAACV,KAAD,CAA9C,EAAuDjB,IAAvD,EAA6DhB,QAA7D,EAAuEvD,QAAvE,CAAP;AACH;;AACD,IAAIuZ,WAAW,GAAGjX,QAAQ,CAACgX,SAAD,EAAY,CAAZ,CAA1B;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASE,UAAT,CAAoBjV,IAApB,EAA0BhB,QAA1B,EAAoCvD,QAApC,EAA8C;AAC1C,SAAOkR,aAAa,CAACkI,OAAD,EAAUzR,GAAG,IAAIA,GAAjB,CAAb,CAAmCN,cAAnC,EAAmD9C,IAAnD,EAAyDhB,QAAzD,EAAmEvD,QAAnE,CAAP;AACH;;AACD,IAAIyZ,YAAY,GAAGnX,QAAQ,CAACkX,UAAD,EAAa,CAAb,CAA3B;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,SAASE,MAAT,CAAiBnV,IAAjB,EAAuBhB,QAAvB,EAAiCvD,QAAjC,EAA2C;AACvC,MAAI0D,SAAS,GAAGtB,SAAS,CAACmB,QAAD,CAAzB;;AACA,SAAO2D,KAAK,CAAC3C,IAAD,EAAO,CAACuL,CAAD,EAAIlM,MAAJ,KAAe;AAC9BF,IAAAA,SAAS,CAACoM,CAAD,EAAI,CAACpO,GAAD,EAAMiY,QAAN,KAAmB;AAC5B,UAAIjY,GAAJ,EAAS,OAAOkC,MAAM,CAAClC,GAAD,CAAb;AACTkC,MAAAA,MAAM,CAAClC,GAAD,EAAM;AAACF,QAAAA,KAAK,EAAEsO,CAAR;AAAW6J,QAAAA;AAAX,OAAN,CAAN;AACH,KAHQ,CAAT;AAIH,GALW,EAKT,CAACjY,GAAD,EAAM8B,OAAN,KAAkB;AACjB,QAAI9B,GAAJ,EAAS,OAAO1B,QAAQ,CAAC0B,GAAD,CAAf;AACT1B,IAAAA,QAAQ,CAAC,IAAD,EAAOwD,OAAO,CAAC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D,EAAI,CAAJ,EAAOrX,QAAP,EAAiBvD,QAAjB,CAAjB;AACH;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,SAAS8a,SAAT,CAAoBvW,IAApB,EAA0BwW,WAA1B,EAAuCxX,QAAvC,EAAiDvD,QAAjD,EAA2D;AACvD,MAAIyY,SAAS,CAACjW,MAAV,IAAoB,CAApB,IAAyB,OAAOuY,WAAP,KAAuB,UAApD,EAAgE;AAC5D/a,IAAAA,QAAQ,GAAGuD,QAAX;AACAA,IAAAA,QAAQ,GAAGwX,WAAX;AACAA,IAAAA,WAAW,GAAGrS,KAAK,CAACC,OAAN,CAAcpE,IAAd,IAAsB,EAAtB,GAA2B,EAAzC;AACH;;AACDvE,EAAAA,QAAQ,GAAGiE,IAAI,CAACjE,QAAQ,IAAI0H,eAAe,EAA5B,CAAf;;AACA,MAAIhE,SAAS,GAAGtB,SAAS,CAACmB,QAAD,CAAzB;;AAEAyD,EAAAA,QAAQ,CAACzC,IAAD,EAAO,CAACT,CAAD,EAAIkX,CAAJ,EAA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","sourcesContent":["/**\n * Creates a continuation function with some arguments already applied.\n *\n * Useful as a shorthand when combined with other control flow functions. Any\n * arguments passed to the returned function are added to the arguments\n * originally passed to apply.\n *\n * @name apply\n * @static\n * @memberOf module:Utils\n * @method\n * @category Util\n * @param {Function} fn - The function you want to eventually apply all\n * arguments to. Invokes with (arguments...).\n * @param {...*} arguments... - Any number of arguments to automatically apply\n * when the continuation is called.\n * @returns {Function} the partially-applied function\n * @example\n *\n * // using apply\n * async.parallel([\n * async.apply(fs.writeFile, 'testfile1', 'test1'),\n * async.apply(fs.writeFile, 'testfile2', 'test2')\n * ]);\n *\n *\n * // the same process without using apply\n * async.parallel([\n * function(callback) {\n * fs.writeFile('testfile1', 'test1', callback);\n * },\n * function(callback) {\n * fs.writeFile('testfile2', 'test2', callback);\n * }\n * ]);\n *\n * // It's possible to pass any number of additional arguments when calling the\n * // continuation:\n *\n * node> var fn = async.apply(sys.puts, 'one');\n * node> fn('two', 'three');\n * one\n * two\n * three\n */\nfunction apply(fn, ...args) {\n return (...callArgs) => fn(...args,...callArgs);\n}\n\nfunction initialParams (fn) {\n return function (...args/*, callback*/) {\n var callback = args.pop();\n return fn.call(this, args, callback);\n };\n}\n\n/* istanbul ignore file */\n\nvar hasQueueMicrotask = typeof queueMicrotask === 'function' && queueMicrotask;\nvar hasSetImmediate = typeof setImmediate === 'function' && setImmediate;\nvar hasNextTick = typeof process === 'object' && typeof process.nextTick === 'function';\n\nfunction fallback(fn) {\n setTimeout(fn, 0);\n}\n\nfunction wrap(defer) {\n return (fn, ...args) => defer(() => fn(...args));\n}\n\nvar _defer;\n\nif (hasQueueMicrotask) {\n _defer = queueMicrotask;\n} else if (hasSetImmediate) {\n _defer = setImmediate;\n} else if (hasNextTick) {\n _defer = process.nextTick;\n} else {\n _defer = fallback;\n}\n\nvar setImmediate$1 = wrap(_defer);\n\n/**\n * Take a sync function and make it async, passing its return value to a\n * callback. This is useful for plugging sync functions into a waterfall,\n * series, or other async functions. Any arguments passed to the generated\n * function will be passed to the wrapped function (except for the final\n * callback argument). Errors thrown will be passed to the callback.\n *\n * If the function passed to `asyncify` returns a Promise, that promises's\n * resolved/rejected state will be used to call the callback, rather than simply\n * the synchronous return value.\n *\n * This also means you can asyncify ES2017 `async` functions.\n *\n * @name asyncify\n * @static\n * @memberOf module:Utils\n * @method\n * @alias wrapSync\n * @category Util\n * @param {Function} func - The synchronous function, or Promise-returning\n * function to convert to an {@link AsyncFunction}.\n * @returns {AsyncFunction} An asynchronous wrapper of the `func`. To be\n * invoked with `(args..., callback)`.\n * @example\n *\n * // passing a regular synchronous function\n * async.waterfall([\n * async.apply(fs.readFile, filename, \"utf8\"),\n * async.asyncify(JSON.parse),\n * function (data, next) {\n * // data is the result of parsing the text.\n * // If there was a parsing error, it would have been caught.\n * }\n * ], callback);\n *\n * // passing a function returning a promise\n * async.waterfall([\n * async.apply(fs.readFile, filename, \"utf8\"),\n * async.asyncify(function (contents) {\n * return db.model.create(contents);\n * }),\n * function (model, next) {\n * // `model` is the instantiated model object.\n * // If there was an error, this function would be skipped.\n * }\n * ], callback);\n *\n * // es2017 example, though `asyncify` is not needed if your JS environment\n * // supports async functions out of the box\n * var q = async.queue(async.asyncify(async function(file) {\n * var intermediateStep = await processFile(file);\n * return await somePromise(intermediateStep)\n * }));\n *\n * q.push(files);\n */\nfunction asyncify(func) {\n if (isAsync(func)) {\n return function (...args/*, callback*/) {\n const callback = args.pop();\n const promise = func.apply(this, args);\n return handlePromise(promise, callback)\n }\n }\n\n return initialParams(function (args, callback) {\n var result;\n try {\n result = func.apply(this, args);\n } catch (e) {\n return callback(e);\n }\n // if result is Promise object\n if (result && typeof result.then === 'function') {\n return handlePromise(result, callback)\n } else {\n callback(null, result);\n }\n });\n}\n\nfunction handlePromise(promise, callback) {\n return promise.then(value => {\n invokeCallback(callback, null, value);\n }, err => {\n invokeCallback(callback, err && err.message ? err : new Error(err));\n });\n}\n\nfunction invokeCallback(callback, error, value) {\n try {\n callback(error, value);\n } catch (err) {\n setImmediate$1(e => { throw e }, err);\n }\n}\n\nfunction isAsync(fn) {\n return fn[Symbol.toStringTag] === 'AsyncFunction';\n}\n\nfunction isAsyncGenerator(fn) {\n return fn[Symbol.toStringTag] === 'AsyncGenerator';\n}\n\nfunction isAsyncIterable(obj) {\n return typeof obj[Symbol.asyncIterator] === 'function';\n}\n\nfunction wrapAsync(asyncFn) {\n if (typeof asyncFn !== 'function') throw new Error('expected a function')\n return isAsync(asyncFn) ? asyncify(asyncFn) : asyncFn;\n}\n\n// conditionally promisify a function.\n// only return a promise if a callback is omitted\nfunction awaitify (asyncFn, arity = asyncFn.length) {\n if (!arity) throw new Error('arity is undefined')\n function awaitable (...args) {\n if (typeof args[arity - 1] === 'function') {\n return asyncFn.apply(this, args)\n }\n\n return new Promise((resolve, reject) => {\n args[arity - 1] = (err, ...cbArgs) => {\n if (err) return reject(err)\n resolve(cbArgs.length > 1 ? cbArgs : cbArgs[0]);\n };\n asyncFn.apply(this, args);\n })\n }\n\n return awaitable\n}\n\nfunction applyEach (eachfn) {\n return function applyEach(fns, ...callArgs) {\n const go = awaitify(function (callback) {\n var that = this;\n return eachfn(fns, (fn, cb) => {\n wrapAsync(fn).apply(that, callArgs.concat(cb));\n }, callback);\n });\n return go;\n };\n}\n\nfunction _asyncMap(eachfn, arr, iteratee, callback) {\n arr = arr || [];\n var results = [];\n var counter = 0;\n var _iteratee = wrapAsync(iteratee);\n\n return eachfn(arr, (value, _, iterCb) => {\n var index = counter++;\n _iteratee(value, (err, v) => {\n results[index] = v;\n iterCb(err);\n });\n }, err => {\n callback(err, results);\n });\n}\n\nfunction isArrayLike(value) {\n return value &&\n typeof value.length === 'number' &&\n value.length >= 0 &&\n value.length % 1 === 0;\n}\n\n// A temporary value used to identify if the loop should be broken.\n// See #1064, #1293\nconst breakLoop = {};\n\nfunction once(fn) {\n function wrapper (...args) {\n if (fn === null) return;\n var callFn = fn;\n fn = null;\n callFn.apply(this, args);\n }\n Object.assign(wrapper, fn);\n return wrapper\n}\n\nfunction getIterator (coll) {\n return coll[Symbol.iterator] && coll[Symbol.iterator]();\n}\n\nfunction createArrayIterator(coll) {\n var i = -1;\n var len = coll.length;\n return function next() {\n return ++i < len ? {value: coll[i], key: i} : null;\n }\n}\n\nfunction createES2015Iterator(iterator) {\n var i = -1;\n return function next() {\n var item = iterator.next();\n if (item.done)\n return null;\n i++;\n return {value: item.value, key: i};\n }\n}\n\nfunction createObjectIterator(obj) {\n var okeys = obj ? Object.keys(obj) : [];\n var i = -1;\n var len = okeys.length;\n return function next() {\n var key = okeys[++i];\n return i < len ? {value: obj[key], key} : null;\n };\n}\n\nfunction createIterator(coll) {\n if (isArrayLike(coll)) {\n return createArrayIterator(coll);\n }\n\n var iterator = getIterator(coll);\n return iterator ? createES2015Iterator(iterator) : createObjectIterator(coll);\n}\n\nfunction onlyOnce(fn) {\n return function (...args) {\n if (fn === null) throw new Error(\"Callback was already called.\");\n var callFn = fn;\n fn = null;\n callFn.apply(this, args);\n };\n}\n\n// for async generators\nfunction asyncEachOfLimit(generator, limit, iteratee, callback) {\n let done = false;\n let canceled = false;\n let awaiting = false;\n let running = 0;\n let idx = 0;\n\n function replenish() {\n //console.log('replenish')\n if (running >= limit || awaiting || done) return\n //console.log('replenish awaiting')\n awaiting = true;\n generator.next().then(({value, done: iterDone}) => {\n //console.log('got value', value)\n if (canceled || done) return\n awaiting = false;\n if (iterDone) {\n done = true;\n if (running <= 0) {\n //console.log('done nextCb')\n callback(null);\n }\n return;\n }\n running++;\n iteratee(value, idx, iterateeCallback);\n idx++;\n replenish();\n }).catch(handleError);\n }\n\n function iterateeCallback(err, result) {\n //console.log('iterateeCallback')\n running -= 1;\n if (canceled) return\n if (err) return handleError(err)\n\n if (err === false) {\n done = true;\n canceled = true;\n return\n }\n\n if (result === breakLoop || (done && running <= 0)) {\n done = true;\n //console.log('done iterCb')\n return callback(null);\n }\n replenish();\n }\n\n function handleError(err) {\n if (canceled) return\n awaiting = false;\n done = true;\n callback(err);\n }\n\n replenish();\n}\n\nvar eachOfLimit = (limit) => {\n return (obj, iteratee, callback) => {\n callback = once(callback);\n if (limit <= 0) {\n throw new RangeError('concurrency limit cannot be less than 1')\n }\n if (!obj) {\n return callback(null);\n }\n if (isAsyncGenerator(obj)) {\n return asyncEachOfLimit(obj, limit, iteratee, callback)\n }\n if (isAsyncIterable(obj)) {\n return asyncEachOfLimit(obj[Symbol.asyncIterator](), limit, iteratee, callback)\n }\n var nextElem = createIterator(obj);\n var done = false;\n var canceled = false;\n var running = 0;\n var looping = false;\n\n function iterateeCallback(err, value) {\n if (canceled) return\n running -= 1;\n if (err) {\n done = true;\n callback(err);\n }\n else if (err === false) {\n done = true;\n canceled = true;\n }\n else if (value === breakLoop || (done && running <= 0)) {\n done = true;\n return callback(null);\n }\n else if (!looping) {\n replenish();\n }\n }\n\n function replenish () {\n looping = true;\n while (running < limit && !done) {\n var elem = nextElem();\n if (elem === null) {\n done = true;\n if (running <= 0) {\n callback(null);\n }\n return;\n }\n running += 1;\n iteratee(elem.value, elem.key, onlyOnce(iterateeCallback));\n }\n looping = false;\n }\n\n replenish();\n };\n};\n\n/**\n * The same as [`eachOf`]{@link module:Collections.eachOf} but runs a maximum of `limit` async operations at a\n * time.\n *\n * @name eachOfLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.eachOf]{@link module:Collections.eachOf}\n * @alias forEachOfLimit\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - An async function to apply to each\n * item in `coll`. The `key` is the item's key, or index in the case of an\n * array.\n * Invoked with (item, key, callback).\n * @param {Function} [callback] - A callback which is called when all\n * `iteratee` functions have finished, or an error occurs. Invoked with (err).\n * @returns {Promise} a promise, if a callback is omitted\n */\nfunction eachOfLimit$1(coll, limit, iteratee, callback) {\n return eachOfLimit(limit)(coll, wrapAsync(iteratee), callback);\n}\n\nvar eachOfLimit$2 = awaitify(eachOfLimit$1, 4);\n\n// eachOf implementation optimized for array-likes\nfunction eachOfArrayLike(coll, iteratee, callback) {\n callback = once(callback);\n var index = 0,\n completed = 0,\n {length} = coll,\n canceled = false;\n if (length === 0) {\n callback(null);\n }\n\n function iteratorCallback(err, value) {\n if (err === false) {\n canceled = true;\n }\n if (canceled === true) return\n if (err) {\n callback(err);\n } else if ((++completed === length) || value === breakLoop) {\n callback(null);\n }\n }\n\n for (; index < length; index++) {\n iteratee(coll[index], index, onlyOnce(iteratorCallback));\n }\n}\n\n// a generic version of eachOf which can handle array, object, and iterator cases.\nfunction eachOfGeneric (coll, iteratee, callback) {\n return eachOfLimit$2(coll, Infinity, iteratee, callback);\n}\n\n/**\n * Like [`each`]{@link module:Collections.each}, except that it passes the key (or index) as the second argument\n * to the iteratee.\n *\n * @name eachOf\n * @static\n * @memberOf module:Collections\n * @method\n * @alias forEachOf\n * @category Collection\n * @see [async.each]{@link module:Collections.each}\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - A function to apply to each\n * item in `coll`.\n * The `key` is the item's key, or index in the case of an array.\n * Invoked with (item, key, callback).\n * @param {Function} [callback] - A callback which is called when all\n * `iteratee` functions have finished, or an error occurs. Invoked with (err).\n * @returns {Promise} a promise, if a callback is omitted\n * @example\n *\n * // dev.json is a file containing a valid json object config for dev environment\n * // dev.json is a file containing a valid json object config for test environment\n * // prod.json is a file containing a valid json object config for prod environment\n * // invalid.json is a file with a malformed json object\n *\n * let configs = {}; //global variable\n * let validConfigFileMap = {dev: 'dev.json', test: 'test.json', prod: 'prod.json'};\n * let invalidConfigFileMap = {dev: 'dev.json', test: 'test.json', invalid: 'invalid.json'};\n *\n * // asynchronous function that reads a json file and parses the contents as json object\n * function parseFile(file, key, callback) {\n * fs.readFile(file, \"utf8\", function(err, data) {\n * if (err) return calback(err);\n * try {\n * configs[key] = JSON.parse(data);\n * } catch (e) {\n * return callback(e);\n * }\n * callback();\n * });\n * }\n *\n * // Using callbacks\n * async.forEachOf(validConfigFileMap, parseFile, function (err) {\n * if (err) {\n * console.error(err);\n * } else {\n * console.log(configs);\n * // configs is now a map of JSON data, e.g.\n * // { dev: //parsed dev.json, test: //parsed test.json, prod: //parsed prod.json}\n * }\n * });\n *\n * //Error handing\n * async.forEachOf(invalidConfigFileMap, parseFile, function (err) {\n * if (err) {\n * console.error(err);\n * // JSON parse error exception\n * } else {\n * console.log(configs);\n * }\n * });\n *\n * // Using Promises\n * async.forEachOf(validConfigFileMap, parseFile)\n * .then( () => {\n * console.log(configs);\n * // configs is now a map of JSON data, e.g.\n * // { dev: //parsed dev.json, test: //parsed test.json, prod: //parsed prod.json}\n * }).catch( err => {\n * console.error(err);\n * });\n *\n * //Error handing\n * async.forEachOf(invalidConfigFileMap, parseFile)\n * .then( () => {\n * console.log(configs);\n * }).catch( err => {\n * console.error(err);\n * // JSON parse error exception\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let result = await async.forEachOf(validConfigFileMap, parseFile);\n * console.log(configs);\n * // configs is now a map of JSON data, e.g.\n * // { dev: //parsed dev.json, test: //parsed test.json, prod: //parsed prod.json}\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * //Error handing\n * async () => {\n * try {\n * let result = await async.forEachOf(invalidConfigFileMap, parseFile);\n * console.log(configs);\n * }\n * catch (err) {\n * console.log(err);\n * // JSON parse error exception\n * }\n * }\n *\n */\nfunction eachOf(coll, iteratee, callback) {\n var eachOfImplementation = isArrayLike(coll) ? eachOfArrayLike : eachOfGeneric;\n return eachOfImplementation(coll, wrapAsync(iteratee), callback);\n}\n\nvar eachOf$1 = awaitify(eachOf, 3);\n\n/**\n * Produces a new collection of values by mapping each value in `coll` through\n * the `iteratee` function. The `iteratee` is called with an item from `coll`\n * and a callback for when it has finished processing. Each of these callback\n * takes 2 arguments: an `error`, and the transformed item from `coll`. If\n * `iteratee` passes an error to its callback, the main `callback` (for the\n * `map` function) is immediately called with the error.\n *\n * Note, that since this function applies the `iteratee` to each item in\n * parallel, there is no guarantee that the `iteratee` functions will complete\n * in order. However, the results array will be in the same order as the\n * original `coll`.\n *\n * If `map` is passed an Object, the results will be an Array. The results\n * will roughly be in the order of the original Objects' keys (but this can\n * vary across JavaScript engines).\n *\n * @name map\n * @static\n * @memberOf module:Collections\n * @method\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * The iteratee should complete with the transformed item.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. Results is an Array of the\n * transformed items from the `coll`. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback is passed\n * @example\n *\n * // file1.txt is a file that is 1000 bytes in size\n * // file2.txt is a file that is 2000 bytes in size\n * // file3.txt is a file that is 3000 bytes in size\n * // file4.txt does not exist\n *\n * const fileList = ['file1.txt','file2.txt','file3.txt'];\n * const withMissingFileList = ['file1.txt','file2.txt','file4.txt'];\n *\n * // asynchronous function that returns the file size in bytes\n * function getFileSizeInBytes(file, callback) {\n * fs.stat(file, function(err, stat) {\n * if (err) {\n * return callback(err);\n * }\n * callback(null, stat.size);\n * });\n * }\n *\n * // Using callbacks\n * async.map(fileList, getFileSizeInBytes, function(err, results) {\n * if (err) {\n * console.log(err);\n * } else {\n * console.log(results);\n * // results is now an array of the file size in bytes for each file, e.g.\n * // [ 1000, 2000, 3000]\n * }\n * });\n *\n * // Error Handling\n * async.map(withMissingFileList, getFileSizeInBytes, function(err, results) {\n * if (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * } else {\n * console.log(results);\n * }\n * });\n *\n * // Using Promises\n * async.map(fileList, getFileSizeInBytes)\n * .then( results => {\n * console.log(results);\n * // results is now an array of the file size in bytes for each file, e.g.\n * // [ 1000, 2000, 3000]\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * // Error Handling\n * async.map(withMissingFileList, getFileSizeInBytes)\n * .then( results => {\n * console.log(results);\n * }).catch( err => {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let results = await async.map(fileList, getFileSizeInBytes);\n * console.log(results);\n * // results is now an array of the file size in bytes for each file, e.g.\n * // [ 1000, 2000, 3000]\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * // Error Handling\n * async () => {\n * try {\n * let results = await async.map(withMissingFileList, getFileSizeInBytes);\n * console.log(results);\n * }\n * catch (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * }\n * }\n *\n */\nfunction map (coll, iteratee, callback) {\n return _asyncMap(eachOf$1, coll, iteratee, callback)\n}\nvar map$1 = awaitify(map, 3);\n\n/**\n * Applies the provided arguments to each function in the array, calling\n * `callback` after all functions have completed. If you only provide the first\n * argument, `fns`, then it will return a function which lets you pass in the\n * arguments as if it were a single function call. If more arguments are\n * provided, `callback` is required while `args` is still optional. The results\n * for each of the applied async functions are passed to the final callback\n * as an array.\n *\n * @name applyEach\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {Array|Iterable|AsyncIterable|Object} fns - A collection of {@link AsyncFunction}s\n * to all call with the same arguments\n * @param {...*} [args] - any number of separate arguments to pass to the\n * function.\n * @param {Function} [callback] - the final argument should be the callback,\n * called when all functions have completed processing.\n * @returns {AsyncFunction} - Returns a function that takes no args other than\n * an optional callback, that is the result of applying the `args` to each\n * of the functions.\n * @example\n *\n * const appliedFn = async.applyEach([enableSearch, updateSchema], 'bucket')\n *\n * appliedFn((err, results) => {\n * // results[0] is the results for `enableSearch`\n * // results[1] is the results for `updateSchema`\n * });\n *\n * // partial application example:\n * async.each(\n * buckets,\n * async (bucket) => async.applyEach([enableSearch, updateSchema], bucket)(),\n * callback\n * );\n */\nvar applyEach$1 = applyEach(map$1);\n\n/**\n * The same as [`eachOf`]{@link module:Collections.eachOf} but runs only a single async operation at a time.\n *\n * @name eachOfSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.eachOf]{@link module:Collections.eachOf}\n * @alias forEachOfSeries\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * Invoked with (item, key, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. Invoked with (err).\n * @returns {Promise} a promise, if a callback is omitted\n */\nfunction eachOfSeries(coll, iteratee, callback) {\n return eachOfLimit$2(coll, 1, iteratee, callback)\n}\nvar eachOfSeries$1 = awaitify(eachOfSeries, 3);\n\n/**\n * The same as [`map`]{@link module:Collections.map} but runs only a single async operation at a time.\n *\n * @name mapSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.map]{@link module:Collections.map}\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * The iteratee should complete with the transformed item.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. Results is an array of the\n * transformed items from the `coll`. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback is passed\n */\nfunction mapSeries (coll, iteratee, callback) {\n return _asyncMap(eachOfSeries$1, coll, iteratee, callback)\n}\nvar mapSeries$1 = awaitify(mapSeries, 3);\n\n/**\n * The same as [`applyEach`]{@link module:ControlFlow.applyEach} but runs only a single async operation at a time.\n *\n * @name applyEachSeries\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.applyEach]{@link module:ControlFlow.applyEach}\n * @category Control Flow\n * @param {Array|Iterable|AsyncIterable|Object} fns - A collection of {@link AsyncFunction}s to all\n * call with the same arguments\n * @param {...*} [args] - any number of separate arguments to pass to the\n * function.\n * @param {Function} [callback] - the final argument should be the callback,\n * called when all functions have completed processing.\n * @returns {AsyncFunction} - A function, that when called, is the result of\n * appling the `args` to the list of functions. It takes no args, other than\n * a callback.\n */\nvar applyEachSeries = applyEach(mapSeries$1);\n\nconst PROMISE_SYMBOL = Symbol('promiseCallback');\n\nfunction promiseCallback () {\n let resolve, reject;\n function callback (err, ...args) {\n if (err) return reject(err)\n resolve(args.length > 1 ? args : args[0]);\n }\n\n callback[PROMISE_SYMBOL] = new Promise((res, rej) => {\n resolve = res,\n reject = rej;\n });\n\n return callback\n}\n\n/**\n * Determines the best order for running the {@link AsyncFunction}s in `tasks`, based on\n * their requirements. Each function can optionally depend on other functions\n * being completed first, and each function is run as soon as its requirements\n * are satisfied.\n *\n * If any of the {@link AsyncFunction}s pass an error to their callback, the `auto` sequence\n * will stop. Further tasks will not execute (so any other functions depending\n * on it will not run), and the main `callback` is immediately called with the\n * error.\n *\n * {@link AsyncFunction}s also receive an object containing the results of functions which\n * have completed so far as the first argument, if they have dependencies. If a\n * task function has no dependencies, it will only be passed a callback.\n *\n * @name auto\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {Object} tasks - An object. Each of its properties is either a\n * function or an array of requirements, with the {@link AsyncFunction} itself the last item\n * in the array. The object's key of a property serves as the name of the task\n * defined by that property, i.e. can be used when specifying requirements for\n * other tasks. The function receives one or two arguments:\n * * a `results` object, containing the results of the previously executed\n * functions, only passed if the task has any dependencies,\n * * a `callback(err, result)` function, which must be called when finished,\n * passing an `error` (which can be `null`) and the result of the function's\n * execution.\n * @param {number} [concurrency=Infinity] - An optional `integer` for\n * determining the maximum number of tasks that can be run in parallel. By\n * default, as many as possible.\n * @param {Function} [callback] - An optional callback which is called when all\n * the tasks have been completed. It receives the `err` argument if any `tasks`\n * pass an error to their callback. Results are always returned; however, if an\n * error occurs, no further `tasks` will be performed, and the results object\n * will only contain partial results. Invoked with (err, results).\n * @returns {Promise} a promise, if a callback is not passed\n * @example\n *\n * //Using Callbacks\n * async.auto({\n * get_data: function(callback) {\n * // async code to get some data\n * callback(null, 'data', 'converted to array');\n * },\n * make_folder: function(callback) {\n * // async code to create a directory to store a file in\n * // this is run at the same time as getting the data\n * callback(null, 'folder');\n * },\n * write_file: ['get_data', 'make_folder', function(results, callback) {\n * // once there is some data and the directory exists,\n * // write the data to a file in the directory\n * callback(null, 'filename');\n * }],\n * email_link: ['write_file', function(results, callback) {\n * // once the file is written let's email a link to it...\n * callback(null, {'file':results.write_file, 'email':'user@example.com'});\n * }]\n * }, function(err, results) {\n * if (err) {\n * console.log('err = ', err);\n * }\n * console.log('results = ', results);\n * // results = {\n * // get_data: ['data', 'converted to array']\n * // make_folder; 'folder',\n * // write_file: 'filename'\n * // email_link: { file: 'filename', email: 'user@example.com' }\n * // }\n * });\n *\n * //Using Promises\n * async.auto({\n * get_data: function(callback) {\n * console.log('in get_data');\n * // async code to get some data\n * callback(null, 'data', 'converted to array');\n * },\n * make_folder: function(callback) {\n * console.log('in make_folder');\n * // async code to create a directory to store a file in\n * // this is run at the same time as getting the data\n * callback(null, 'folder');\n * },\n * write_file: ['get_data', 'make_folder', function(results, callback) {\n * // once there is some data and the directory exists,\n * // write the data to a file in the directory\n * callback(null, 'filename');\n * }],\n * email_link: ['write_file', function(results, callback) {\n * // once the file is written let's email a link to it...\n * callback(null, {'file':results.write_file, 'email':'user@example.com'});\n * }]\n * }).then(results => {\n * console.log('results = ', results);\n * // results = {\n * // get_data: ['data', 'converted to array']\n * // make_folder; 'folder',\n * // write_file: 'filename'\n * // email_link: { file: 'filename', email: 'user@example.com' }\n * // }\n * }).catch(err => {\n * console.log('err = ', err);\n * });\n *\n * //Using async/await\n * async () => {\n * try {\n * let results = await async.auto({\n * get_data: function(callback) {\n * // async code to get some data\n * callback(null, 'data', 'converted to array');\n * },\n * make_folder: function(callback) {\n * // async code to create a directory to store a file in\n * // this is run at the same time as getting the data\n * callback(null, 'folder');\n * },\n * write_file: ['get_data', 'make_folder', function(results, callback) {\n * // once there is some data and the directory exists,\n * // write the data to a file in the directory\n * callback(null, 'filename');\n * }],\n * email_link: ['write_file', function(results, callback) {\n * // once the file is written let's email a link to it...\n * callback(null, {'file':results.write_file, 'email':'user@example.com'});\n * }]\n * });\n * console.log('results = ', results);\n * // results = {\n * // get_data: ['data', 'converted to array']\n * // make_folder; 'folder',\n * // write_file: 'filename'\n * // email_link: { file: 'filename', email: 'user@example.com' }\n * // }\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\nfunction auto(tasks, concurrency, callback) {\n if (typeof concurrency !== 'number') {\n // concurrency is optional, shift the args.\n callback = concurrency;\n concurrency = null;\n }\n callback = once(callback || promiseCallback());\n var numTasks = Object.keys(tasks).length;\n if (!numTasks) {\n return callback(null);\n }\n if (!concurrency) {\n concurrency = numTasks;\n }\n\n var results = {};\n var runningTasks = 0;\n var canceled = false;\n var hasError = false;\n\n var listeners = Object.create(null);\n\n var readyTasks = [];\n\n // for cycle detection:\n var readyToCheck = []; // tasks that have been identified as reachable\n // without the possibility of returning to an ancestor task\n var uncheckedDependencies = {};\n\n Object.keys(tasks).forEach(key => {\n var task = tasks[key];\n if (!Array.isArray(task)) {\n // no dependencies\n enqueueTask(key, [task]);\n readyToCheck.push(key);\n return;\n }\n\n var dependencies = task.slice(0, task.length - 1);\n var remainingDependencies = dependencies.length;\n if (remainingDependencies === 0) {\n enqueueTask(key, task);\n readyToCheck.push(key);\n return;\n }\n uncheckedDependencies[key] = remainingDependencies;\n\n dependencies.forEach(dependencyName => {\n if (!tasks[dependencyName]) {\n throw new Error('async.auto task `' + key +\n '` has a non-existent dependency `' +\n dependencyName + '` in ' +\n dependencies.join(', '));\n }\n addListener(dependencyName, () => {\n remainingDependencies--;\n if (remainingDependencies === 0) {\n enqueueTask(key, task);\n }\n });\n });\n });\n\n checkForDeadlocks();\n processQueue();\n\n function enqueueTask(key, task) {\n readyTasks.push(() => runTask(key, task));\n }\n\n function processQueue() {\n if (canceled) return\n if (readyTasks.length === 0 && runningTasks === 0) {\n return callback(null, results);\n }\n while(readyTasks.length && runningTasks < concurrency) {\n var run = readyTasks.shift();\n run();\n }\n\n }\n\n function addListener(taskName, fn) {\n var taskListeners = listeners[taskName];\n if (!taskListeners) {\n taskListeners = listeners[taskName] = [];\n }\n\n taskListeners.push(fn);\n }\n\n function taskComplete(taskName) {\n var taskListeners = listeners[taskName] || [];\n taskListeners.forEach(fn => fn());\n processQueue();\n }\n\n\n function runTask(key, task) {\n if (hasError) return;\n\n var taskCallback = onlyOnce((err, ...result) => {\n runningTasks--;\n if (err === false) {\n canceled = true;\n return\n }\n if (result.length < 2) {\n [result] = result;\n }\n if (err) {\n var safeResults = {};\n Object.keys(results).forEach(rkey => {\n safeResults[rkey] = results[rkey];\n });\n safeResults[key] = result;\n hasError = true;\n listeners = Object.create(null);\n if (canceled) return\n callback(err, safeResults);\n } else {\n results[key] = result;\n taskComplete(key);\n }\n });\n\n runningTasks++;\n var taskFn = wrapAsync(task[task.length - 1]);\n if (task.length > 1) {\n taskFn(results, taskCallback);\n } else {\n taskFn(taskCallback);\n }\n }\n\n function checkForDeadlocks() {\n // Kahn's algorithm\n // https://en.wikipedia.org/wiki/Topological_sorting#Kahn.27s_algorithm\n // http://connalle.blogspot.com/2013/10/topological-sortingkahn-algorithm.html\n var currentTask;\n var counter = 0;\n while (readyToCheck.length) {\n currentTask = readyToCheck.pop();\n counter++;\n getDependents(currentTask).forEach(dependent => {\n if (--uncheckedDependencies[dependent] === 0) {\n readyToCheck.push(dependent);\n }\n });\n }\n\n if (counter !== numTasks) {\n throw new Error(\n 'async.auto cannot execute tasks due to a recursive dependency'\n );\n }\n }\n\n function getDependents(taskName) {\n var result = [];\n Object.keys(tasks).forEach(key => {\n const task = tasks[key];\n if (Array.isArray(task) && task.indexOf(taskName) >= 0) {\n result.push(key);\n }\n });\n return result;\n }\n\n return callback[PROMISE_SYMBOL]\n}\n\nvar FN_ARGS = /^(?:async\\s+)?(?:function)?\\s*\\w*\\s*\\(\\s*([^)]+)\\s*\\)(?:\\s*{)/;\nvar ARROW_FN_ARGS = /^(?:async\\s+)?\\(?\\s*([^)=]+)\\s*\\)?(?:\\s*=>)/;\nvar FN_ARG_SPLIT = /,/;\nvar FN_ARG = /(=.+)?(\\s*)$/;\nvar STRIP_COMMENTS = /((\\/\\/.*$)|(\\/\\*[\\s\\S]*?\\*\\/))/mg;\n\nfunction parseParams(func) {\n const src = func.toString().replace(STRIP_COMMENTS, '');\n let match = src.match(FN_ARGS);\n if (!match) {\n match = src.match(ARROW_FN_ARGS);\n }\n if (!match) throw new Error('could not parse args in autoInject\\nSource:\\n' + src)\n let [, args] = match;\n return args\n .replace(/\\s/g, '')\n .split(FN_ARG_SPLIT)\n .map((arg) => arg.replace(FN_ARG, '').trim());\n}\n\n/**\n * A dependency-injected version of the [async.auto]{@link module:ControlFlow.auto} function. Dependent\n * tasks are specified as parameters to the function, after the usual callback\n * parameter, with the parameter names matching the names of the tasks it\n * depends on. This can provide even more readable task graphs which can be\n * easier to maintain.\n *\n * If a final callback is specified, the task results are similarly injected,\n * specified as named parameters after the initial error parameter.\n *\n * The autoInject function is purely syntactic sugar and its semantics are\n * otherwise equivalent to [async.auto]{@link module:ControlFlow.auto}.\n *\n * @name autoInject\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.auto]{@link module:ControlFlow.auto}\n * @category Control Flow\n * @param {Object} tasks - An object, each of whose properties is an {@link AsyncFunction} of\n * the form 'func([dependencies...], callback). The object's key of a property\n * serves as the name of the task defined by that property, i.e. can be used\n * when specifying requirements for other tasks.\n * * The `callback` parameter is a `callback(err, result)` which must be called\n * when finished, passing an `error` (which can be `null`) and the result of\n * the function's execution. The remaining parameters name other tasks on\n * which the task is dependent, and the results from those tasks are the\n * arguments of those parameters.\n * @param {Function} [callback] - An optional callback which is called when all\n * the tasks have been completed. It receives the `err` argument if any `tasks`\n * pass an error to their callback, and a `results` object with any completed\n * task results, similar to `auto`.\n * @returns {Promise} a promise, if no callback is passed\n * @example\n *\n * // The example from `auto` can be rewritten as follows:\n * async.autoInject({\n * get_data: function(callback) {\n * // async code to get some data\n * callback(null, 'data', 'converted to array');\n * },\n * make_folder: function(callback) {\n * // async code to create a directory to store a file in\n * // this is run at the same time as getting the data\n * callback(null, 'folder');\n * },\n * write_file: function(get_data, make_folder, callback) {\n * // once there is some data and the directory exists,\n * // write the data to a file in the directory\n * callback(null, 'filename');\n * },\n * email_link: function(write_file, callback) {\n * // once the file is written let's email a link to it...\n * // write_file contains the filename returned by write_file.\n * callback(null, {'file':write_file, 'email':'user@example.com'});\n * }\n * }, function(err, results) {\n * console.log('err = ', err);\n * console.log('email_link = ', results.email_link);\n * });\n *\n * // If you are using a JS minifier that mangles parameter names, `autoInject`\n * // will not work with plain functions, since the parameter names will be\n * // collapsed to a single letter identifier. To work around this, you can\n * // explicitly specify the names of the parameters your task function needs\n * // in an array, similar to Angular.js dependency injection.\n *\n * // This still has an advantage over plain `auto`, since the results a task\n * // depends on are still spread into arguments.\n * async.autoInject({\n * //...\n * write_file: ['get_data', 'make_folder', function(get_data, make_folder, callback) {\n * callback(null, 'filename');\n * }],\n * email_link: ['write_file', function(write_file, callback) {\n * callback(null, {'file':write_file, 'email':'user@example.com'});\n * }]\n * //...\n * }, function(err, results) {\n * console.log('err = ', err);\n * console.log('email_link = ', results.email_link);\n * });\n */\nfunction autoInject(tasks, callback) {\n var newTasks = {};\n\n Object.keys(tasks).forEach(key => {\n var taskFn = tasks[key];\n var params;\n var fnIsAsync = isAsync(taskFn);\n var hasNoDeps =\n (!fnIsAsync && taskFn.length === 1) ||\n (fnIsAsync && taskFn.length === 0);\n\n if (Array.isArray(taskFn)) {\n params = [...taskFn];\n taskFn = params.pop();\n\n newTasks[key] = params.concat(params.length > 0 ? newTask : taskFn);\n } else if (hasNoDeps) {\n // no dependencies, use the function as-is\n newTasks[key] = taskFn;\n } else {\n params = parseParams(taskFn);\n if ((taskFn.length === 0 && !fnIsAsync) && params.length === 0) {\n throw new Error(\"autoInject task functions require explicit parameters.\");\n }\n\n // remove callback param\n if (!fnIsAsync) params.pop();\n\n newTasks[key] = params.concat(newTask);\n }\n\n function newTask(results, taskCb) {\n var newArgs = params.map(name => results[name]);\n newArgs.push(taskCb);\n wrapAsync(taskFn)(...newArgs);\n }\n });\n\n return auto(newTasks, callback);\n}\n\n// Simple doubly linked list (https://en.wikipedia.org/wiki/Doubly_linked_list) implementation\n// used for queues. This implementation assumes that the node provided by the user can be modified\n// to adjust the next and last properties. We implement only the minimal functionality\n// for queue support.\nclass DLL {\n constructor() {\n this.head = this.tail = null;\n this.length = 0;\n }\n\n removeLink(node) {\n if (node.prev) node.prev.next = node.next;\n else this.head = node.next;\n if (node.next) node.next.prev = node.prev;\n else this.tail = node.prev;\n\n node.prev = node.next = null;\n this.length -= 1;\n return node;\n }\n\n empty () {\n while(this.head) this.shift();\n return this;\n }\n\n insertAfter(node, newNode) {\n newNode.prev = node;\n newNode.next = node.next;\n if (node.next) node.next.prev = newNode;\n else this.tail = newNode;\n node.next = newNode;\n this.length += 1;\n }\n\n insertBefore(node, newNode) {\n newNode.prev = node.prev;\n newNode.next = node;\n if (node.prev) node.prev.next = newNode;\n else this.head = newNode;\n node.prev = newNode;\n this.length += 1;\n }\n\n unshift(node) {\n if (this.head) this.insertBefore(this.head, node);\n else setInitial(this, node);\n }\n\n push(node) {\n if (this.tail) this.insertAfter(this.tail, node);\n else setInitial(this, node);\n }\n\n shift() {\n return this.head && this.removeLink(this.head);\n }\n\n pop() {\n return this.tail && this.removeLink(this.tail);\n }\n\n toArray() {\n return [...this]\n }\n\n *[Symbol.iterator] () {\n var cur = this.head;\n while (cur) {\n yield cur.data;\n cur = cur.next;\n }\n }\n\n remove (testFn) {\n var curr = this.head;\n while(curr) {\n var {next} = curr;\n if (testFn(curr)) {\n this.removeLink(curr);\n }\n curr = next;\n }\n return this;\n }\n}\n\nfunction setInitial(dll, node) {\n dll.length = 1;\n dll.head = dll.tail = node;\n}\n\nfunction queue(worker, concurrency, payload) {\n if (concurrency == null) {\n concurrency = 1;\n }\n else if(concurrency === 0) {\n throw new RangeError('Concurrency must not be zero');\n }\n\n var _worker = wrapAsync(worker);\n var numRunning = 0;\n var workersList = [];\n const events = {\n error: [],\n drain: [],\n saturated: [],\n unsaturated: [],\n empty: []\n };\n\n function on (event, handler) {\n events[event].push(handler);\n }\n\n function once (event, handler) {\n const handleAndRemove = (...args) => {\n off(event, handleAndRemove);\n handler(...args);\n };\n events[event].push(handleAndRemove);\n }\n\n function off (event, handler) {\n if (!event) return Object.keys(events).forEach(ev => events[ev] = [])\n if (!handler) return events[event] = []\n events[event] = events[event].filter(ev => ev !== handler);\n }\n\n function trigger (event, ...args) {\n events[event].forEach(handler => handler(...args));\n }\n\n var processingScheduled = false;\n function _insert(data, insertAtFront, rejectOnError, callback) {\n if (callback != null && typeof callback !== 'function') {\n throw new Error('task callback must be a function');\n }\n q.started = true;\n\n var res, rej;\n function promiseCallback (err, ...args) {\n // we don't care about the error, let the global error handler\n // deal with it\n if (err) return rejectOnError ? rej(err) : res()\n if (args.length <= 1) return res(args[0])\n res(args);\n }\n\n var item = {\n data,\n callback: rejectOnError ?\n promiseCallback :\n (callback || promiseCallback)\n };\n\n if (insertAtFront) {\n q._tasks.unshift(item);\n } else {\n q._tasks.push(item);\n }\n\n if (!processingScheduled) {\n processingScheduled = true;\n setImmediate$1(() => {\n processingScheduled = false;\n q.process();\n });\n }\n\n if (rejectOnError || !callback) {\n return new Promise((resolve, reject) => {\n res = resolve;\n rej = reject;\n })\n }\n }\n\n function _createCB(tasks) {\n return function (err, ...args) {\n numRunning -= 1;\n\n for (var i = 0, l = tasks.length; i < l; i++) {\n var task = tasks[i];\n\n var index = workersList.indexOf(task);\n if (index === 0) {\n workersList.shift();\n } else if (index > 0) {\n workersList.splice(index, 1);\n }\n\n task.callback(err, ...args);\n\n if (err != null) {\n trigger('error', err, task.data);\n }\n }\n\n if (numRunning <= (q.concurrency - q.buffer) ) {\n trigger('unsaturated');\n }\n\n if (q.idle()) {\n trigger('drain');\n }\n q.process();\n };\n }\n\n function _maybeDrain(data) {\n if (data.length === 0 && q.idle()) {\n // call drain immediately if there are no tasks\n setImmediate$1(() => trigger('drain'));\n return true\n }\n return false\n }\n\n const eventMethod = (name) => (handler) => {\n if (!handler) {\n return new Promise((resolve, reject) => {\n once(name, (err, data) => {\n if (err) return reject(err)\n resolve(data);\n });\n })\n }\n off(name);\n on(name, handler);\n\n };\n\n var isProcessing = false;\n var q = {\n _tasks: new DLL(),\n *[Symbol.iterator] () {\n yield* q._tasks[Symbol.iterator]();\n },\n concurrency,\n payload,\n buffer: concurrency / 4,\n started: false,\n paused: false,\n push (data, callback) {\n if (Array.isArray(data)) {\n if (_maybeDrain(data)) return\n return data.map(datum => _insert(datum, false, false, callback))\n }\n return _insert(data, false, false, callback);\n },\n pushAsync (data, callback) {\n if (Array.isArray(data)) {\n if (_maybeDrain(data)) return\n return data.map(datum => _insert(datum, false, true, callback))\n }\n return _insert(data, false, true, callback);\n },\n kill () {\n off();\n q._tasks.empty();\n },\n unshift (data, callback) {\n if (Array.isArray(data)) {\n if (_maybeDrain(data)) return\n return data.map(datum => _insert(datum, true, false, callback))\n }\n return _insert(data, true, false, callback);\n },\n unshiftAsync (data, callback) {\n if (Array.isArray(data)) {\n if (_maybeDrain(data)) return\n return data.map(datum => _insert(datum, true, true, callback))\n }\n return _insert(data, true, true, callback);\n },\n remove (testFn) {\n q._tasks.remove(testFn);\n },\n process () {\n // Avoid trying to start too many processing operations. This can occur\n // when callbacks resolve synchronously (#1267).\n if (isProcessing) {\n return;\n }\n isProcessing = true;\n while(!q.paused && numRunning < q.concurrency && q._tasks.length){\n var tasks = [], data = [];\n var l = q._tasks.length;\n if (q.payload) l = Math.min(l, q.payload);\n for (var i = 0; i < l; i++) {\n var node = q._tasks.shift();\n tasks.push(node);\n workersList.push(node);\n data.push(node.data);\n }\n\n numRunning += 1;\n\n if (q._tasks.length === 0) {\n trigger('empty');\n }\n\n if (numRunning === q.concurrency) {\n trigger('saturated');\n }\n\n var cb = onlyOnce(_createCB(tasks));\n _worker(data, cb);\n }\n isProcessing = false;\n },\n length () {\n return q._tasks.length;\n },\n running () {\n return numRunning;\n },\n workersList () {\n return workersList;\n },\n idle() {\n return q._tasks.length + numRunning === 0;\n },\n pause () {\n q.paused = true;\n },\n resume () {\n if (q.paused === false) { return; }\n q.paused = false;\n setImmediate$1(q.process);\n }\n };\n // define these as fixed properties, so people get useful errors when updating\n Object.defineProperties(q, {\n saturated: {\n writable: false,\n value: eventMethod('saturated')\n },\n unsaturated: {\n writable: false,\n value: eventMethod('unsaturated')\n },\n empty: {\n writable: false,\n value: eventMethod('empty')\n },\n drain: {\n writable: false,\n value: eventMethod('drain')\n },\n error: {\n writable: false,\n value: eventMethod('error')\n },\n });\n return q;\n}\n\n/**\n * Creates a `cargo` object with the specified payload. Tasks added to the\n * cargo will be processed altogether (up to the `payload` limit). If the\n * `worker` is in progress, the task is queued until it becomes available. Once\n * the `worker` has completed some tasks, each callback of those tasks is\n * called. Check out [these](https://camo.githubusercontent.com/6bbd36f4cf5b35a0f11a96dcd2e97711ffc2fb37/68747470733a2f2f662e636c6f75642e6769746875622e636f6d2f6173736574732f313637363837312f36383130382f62626330636662302d356632392d313165322d393734662d3333393763363464633835382e676966) [animations](https://camo.githubusercontent.com/f4810e00e1c5f5f8addbe3e9f49064fd5d102699/68747470733a2f2f662e636c6f75642e6769746875622e636f6d2f6173736574732f313637363837312f36383130312f38346339323036362d356632392d313165322d383134662d3964336430323431336266642e676966)\n * for how `cargo` and `queue` work.\n *\n * While [`queue`]{@link module:ControlFlow.queue} passes only one task to one of a group of workers\n * at a time, cargo passes an array of tasks to a single worker, repeating\n * when the worker is finished.\n *\n * @name cargo\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.queue]{@link module:ControlFlow.queue}\n * @category Control Flow\n * @param {AsyncFunction} worker - An asynchronous function for processing an array\n * of queued tasks. Invoked with `(tasks, callback)`.\n * @param {number} [payload=Infinity] - An optional `integer` for determining\n * how many tasks should be processed per round; if omitted, the default is\n * unlimited.\n * @returns {module:ControlFlow.QueueObject} A cargo object to manage the tasks. Callbacks can\n * attached as certain properties to listen for specific events during the\n * lifecycle of the cargo and inner queue.\n * @example\n *\n * // create a cargo object with payload 2\n * var cargo = async.cargo(function(tasks, callback) {\n * for (var i=0; i {\n * console.log(result);\n * // 6000\n * // which is the sum of the file sizes of the three files\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * // Error Handling\n * async.reduce(withMissingFileList, 0, getFileSizeInBytes)\n * .then( result => {\n * console.log(result);\n * }).catch( err => {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let result = await async.reduce(fileList, 0, getFileSizeInBytes);\n * console.log(result);\n * // 6000\n * // which is the sum of the file sizes of the three files\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * // Error Handling\n * async () => {\n * try {\n * let result = await async.reduce(withMissingFileList, 0, getFileSizeInBytes);\n * console.log(result);\n * }\n * catch (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * }\n * }\n *\n */\nfunction reduce(coll, memo, iteratee, callback) {\n callback = once(callback);\n var _iteratee = wrapAsync(iteratee);\n return eachOfSeries$1(coll, (x, i, iterCb) => {\n _iteratee(memo, x, (err, v) => {\n memo = v;\n iterCb(err);\n });\n }, err => callback(err, memo));\n}\nvar reduce$1 = awaitify(reduce, 4);\n\n/**\n * Version of the compose function that is more natural to read. Each function\n * consumes the return value of the previous function. It is the equivalent of\n * [compose]{@link module:ControlFlow.compose} with the arguments reversed.\n *\n * Each function is executed with the `this` binding of the composed function.\n *\n * @name seq\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.compose]{@link module:ControlFlow.compose}\n * @category Control Flow\n * @param {...AsyncFunction} functions - the asynchronous functions to compose\n * @returns {Function} a function that composes the `functions` in order\n * @example\n *\n * // Requires lodash (or underscore), express3 and dresende's orm2.\n * // Part of an app, that fetches cats of the logged user.\n * // This example uses `seq` function to avoid overnesting and error\n * // handling clutter.\n * app.get('/cats', function(request, response) {\n * var User = request.models.User;\n * async.seq(\n * _.bind(User.get, User), // 'User.get' has signature (id, callback(err, data))\n * function(user, fn) {\n * user.getCats(fn); // 'getCats' has signature (callback(err, data))\n * }\n * )(req.session.user_id, function (err, cats) {\n * if (err) {\n * console.error(err);\n * response.json({ status: 'error', message: err.message });\n * } else {\n * response.json({ status: 'ok', message: 'Cats found', data: cats });\n * }\n * });\n * });\n */\nfunction seq(...functions) {\n var _functions = functions.map(wrapAsync);\n return function (...args) {\n var that = this;\n\n var cb = args[args.length - 1];\n if (typeof cb == 'function') {\n args.pop();\n } else {\n cb = promiseCallback();\n }\n\n reduce$1(_functions, args, (newargs, fn, iterCb) => {\n fn.apply(that, newargs.concat((err, ...nextargs) => {\n iterCb(err, nextargs);\n }));\n },\n (err, results) => cb(err, ...results));\n\n return cb[PROMISE_SYMBOL]\n };\n}\n\n/**\n * Creates a function which is a composition of the passed asynchronous\n * functions. Each function consumes the return value of the function that\n * follows. Composing functions `f()`, `g()`, and `h()` would produce the result\n * of `f(g(h()))`, only this version uses callbacks to obtain the return values.\n *\n * If the last argument to the composed function is not a function, a promise\n * is returned when you call it.\n *\n * Each function is executed with the `this` binding of the composed function.\n *\n * @name compose\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {...AsyncFunction} functions - the asynchronous functions to compose\n * @returns {Function} an asynchronous function that is the composed\n * asynchronous `functions`\n * @example\n *\n * function add1(n, callback) {\n * setTimeout(function () {\n * callback(null, n + 1);\n * }, 10);\n * }\n *\n * function mul3(n, callback) {\n * setTimeout(function () {\n * callback(null, n * 3);\n * }, 10);\n * }\n *\n * var add1mul3 = async.compose(mul3, add1);\n * add1mul3(4, function (err, result) {\n * // result now equals 15\n * });\n */\nfunction compose(...args) {\n return seq(...args.reverse());\n}\n\n/**\n * The same as [`map`]{@link module:Collections.map} but runs a maximum of `limit` async operations at a time.\n *\n * @name mapLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.map]{@link module:Collections.map}\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * The iteratee should complete with the transformed item.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. Results is an array of the\n * transformed items from the `coll`. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback is passed\n */\nfunction mapLimit (coll, limit, iteratee, callback) {\n return _asyncMap(eachOfLimit(limit), coll, iteratee, callback)\n}\nvar mapLimit$1 = awaitify(mapLimit, 4);\n\n/**\n * The same as [`concat`]{@link module:Collections.concat} but runs a maximum of `limit` async operations at a time.\n *\n * @name concatLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.concat]{@link module:Collections.concat}\n * @category Collection\n * @alias flatMapLimit\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - A function to apply to each item in `coll`,\n * which should use an array as its result. Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished, or an error occurs. Results is an array\n * containing the concatenated results of the `iteratee` function. Invoked with\n * (err, results).\n * @returns A Promise, if no callback is passed\n */\nfunction concatLimit(coll, limit, iteratee, callback) {\n var _iteratee = wrapAsync(iteratee);\n return mapLimit$1(coll, limit, (val, iterCb) => {\n _iteratee(val, (err, ...args) => {\n if (err) return iterCb(err);\n return iterCb(err, args);\n });\n }, (err, mapResults) => {\n var result = [];\n for (var i = 0; i < mapResults.length; i++) {\n if (mapResults[i]) {\n result = result.concat(...mapResults[i]);\n }\n }\n\n return callback(err, result);\n });\n}\nvar concatLimit$1 = awaitify(concatLimit, 4);\n\n/**\n * Applies `iteratee` to each item in `coll`, concatenating the results. Returns\n * the concatenated list. The `iteratee`s are called in parallel, and the\n * results are concatenated as they return. The results array will be returned in\n * the original order of `coll` passed to the `iteratee` function.\n *\n * @name concat\n * @static\n * @memberOf module:Collections\n * @method\n * @category Collection\n * @alias flatMap\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - A function to apply to each item in `coll`,\n * which should use an array as its result. Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished, or an error occurs. Results is an array\n * containing the concatenated results of the `iteratee` function. Invoked with\n * (err, results).\n * @returns A Promise, if no callback is passed\n * @example\n *\n * // dir1 is a directory that contains file1.txt, file2.txt\n * // dir2 is a directory that contains file3.txt, file4.txt\n * // dir3 is a directory that contains file5.txt\n * // dir4 does not exist\n *\n * let directoryList = ['dir1','dir2','dir3'];\n * let withMissingDirectoryList = ['dir1','dir2','dir3', 'dir4'];\n *\n * // Using callbacks\n * async.concat(directoryList, fs.readdir, function(err, results) {\n * if (err) {\n * console.log(err);\n * } else {\n * console.log(results);\n * // [ 'file1.txt', 'file2.txt', 'file3.txt', 'file4.txt', file5.txt ]\n * }\n * });\n *\n * // Error Handling\n * async.concat(withMissingDirectoryList, fs.readdir, function(err, results) {\n * if (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * // since dir4 does not exist\n * } else {\n * console.log(results);\n * }\n * });\n *\n * // Using Promises\n * async.concat(directoryList, fs.readdir)\n * .then(results => {\n * console.log(results);\n * // [ 'file1.txt', 'file2.txt', 'file3.txt', 'file4.txt', file5.txt ]\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * // Error Handling\n * async.concat(withMissingDirectoryList, fs.readdir)\n * .then(results => {\n * console.log(results);\n * }).catch(err => {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * // since dir4 does not exist\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let results = await async.concat(directoryList, fs.readdir);\n * console.log(results);\n * // [ 'file1.txt', 'file2.txt', 'file3.txt', 'file4.txt', file5.txt ]\n * } catch (err) {\n * console.log(err);\n * }\n * }\n *\n * // Error Handling\n * async () => {\n * try {\n * let results = await async.concat(withMissingDirectoryList, fs.readdir);\n * console.log(results);\n * } catch (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * // since dir4 does not exist\n * }\n * }\n *\n */\nfunction concat(coll, iteratee, callback) {\n return concatLimit$1(coll, Infinity, iteratee, callback)\n}\nvar concat$1 = awaitify(concat, 3);\n\n/**\n * The same as [`concat`]{@link module:Collections.concat} but runs only a single async operation at a time.\n *\n * @name concatSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.concat]{@link module:Collections.concat}\n * @category Collection\n * @alias flatMapSeries\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - A function to apply to each item in `coll`.\n * The iteratee should complete with an array an array of results.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished, or an error occurs. Results is an array\n * containing the concatenated results of the `iteratee` function. Invoked with\n * (err, results).\n * @returns A Promise, if no callback is passed\n */\nfunction concatSeries(coll, iteratee, callback) {\n return concatLimit$1(coll, 1, iteratee, callback)\n}\nvar concatSeries$1 = awaitify(concatSeries, 3);\n\n/**\n * Returns a function that when called, calls-back with the values provided.\n * Useful as the first function in a [`waterfall`]{@link module:ControlFlow.waterfall}, or for plugging values in to\n * [`auto`]{@link module:ControlFlow.auto}.\n *\n * @name constant\n * @static\n * @memberOf module:Utils\n * @method\n * @category Util\n * @param {...*} arguments... - Any number of arguments to automatically invoke\n * callback with.\n * @returns {AsyncFunction} Returns a function that when invoked, automatically\n * invokes the callback with the previous given arguments.\n * @example\n *\n * async.waterfall([\n * async.constant(42),\n * function (value, next) {\n * // value === 42\n * },\n * //...\n * ], callback);\n *\n * async.waterfall([\n * async.constant(filename, \"utf8\"),\n * fs.readFile,\n * function (fileData, next) {\n * //...\n * }\n * //...\n * ], callback);\n *\n * async.auto({\n * hostname: async.constant(\"https://server.net/\"),\n * port: findFreePort,\n * launchServer: [\"hostname\", \"port\", function (options, cb) {\n * startServer(options, cb);\n * }],\n * //...\n * }, callback);\n */\nfunction constant(...args) {\n return function (...ignoredArgs/*, callback*/) {\n var callback = ignoredArgs.pop();\n return callback(null, ...args);\n };\n}\n\nfunction _createTester(check, getResult) {\n return (eachfn, arr, _iteratee, cb) => {\n var testPassed = false;\n var testResult;\n const iteratee = wrapAsync(_iteratee);\n eachfn(arr, (value, _, callback) => {\n iteratee(value, (err, result) => {\n if (err || err === false) return callback(err);\n\n if (check(result) && !testResult) {\n testPassed = true;\n testResult = getResult(true, value);\n return callback(null, breakLoop);\n }\n callback();\n });\n }, err => {\n if (err) return cb(err);\n cb(null, testPassed ? testResult : getResult(false));\n });\n };\n}\n\n/**\n * Returns the first value in `coll` that passes an async truth test. The\n * `iteratee` is applied in parallel, meaning the first iteratee to return\n * `true` will fire the detect `callback` with that result. That means the\n * result might not be the first item in the original `coll` (in terms of order)\n * that passes the test.\n\n * If order within the original `coll` is important, then look at\n * [`detectSeries`]{@link module:Collections.detectSeries}.\n *\n * @name detect\n * @static\n * @memberOf module:Collections\n * @method\n * @alias find\n * @category Collections\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - A truth test to apply to each item in `coll`.\n * The iteratee must complete with a boolean value as its result.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called as soon as any\n * iteratee returns `true`, or after all the `iteratee` functions have finished.\n * Result will be the first item in the array that passes the truth test\n * (iteratee) or the value `undefined` if none passed. Invoked with\n * (err, result).\n * @returns A Promise, if no callback is passed\n * @example\n *\n * // dir1 is a directory that contains file1.txt, file2.txt\n * // dir2 is a directory that contains file3.txt, file4.txt\n * // dir3 is a directory that contains file5.txt\n *\n * // asynchronous function that checks if a file exists\n * function fileExists(file, callback) {\n * fs.access(file, fs.constants.F_OK, (err) => {\n * callback(null, !err);\n * });\n * }\n *\n * async.detect(['file3.txt','file2.txt','dir1/file1.txt'], fileExists,\n * function(err, result) {\n * console.log(result);\n * // dir1/file1.txt\n * // result now equals the first file in the list that exists\n * }\n *);\n *\n * // Using Promises\n * async.detect(['file3.txt','file2.txt','dir1/file1.txt'], fileExists)\n * .then(result => {\n * console.log(result);\n * // dir1/file1.txt\n * // result now equals the first file in the list that exists\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let result = await async.detect(['file3.txt','file2.txt','dir1/file1.txt'], fileExists);\n * console.log(result);\n * // dir1/file1.txt\n * // result now equals the file in the list that exists\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\nfunction detect(coll, iteratee, callback) {\n return _createTester(bool => bool, (res, item) => item)(eachOf$1, coll, iteratee, callback)\n}\nvar detect$1 = awaitify(detect, 3);\n\n/**\n * The same as [`detect`]{@link module:Collections.detect} but runs a maximum of `limit` async operations at a\n * time.\n *\n * @name detectLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.detect]{@link module:Collections.detect}\n * @alias findLimit\n * @category Collections\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - A truth test to apply to each item in `coll`.\n * The iteratee must complete with a boolean value as its result.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called as soon as any\n * iteratee returns `true`, or after all the `iteratee` functions have finished.\n * Result will be the first item in the array that passes the truth test\n * (iteratee) or the value `undefined` if none passed. Invoked with\n * (err, result).\n * @returns a Promise if no callback is passed\n */\nfunction detectLimit(coll, limit, iteratee, callback) {\n return _createTester(bool => bool, (res, item) => item)(eachOfLimit(limit), coll, iteratee, callback)\n}\nvar detectLimit$1 = awaitify(detectLimit, 4);\n\n/**\n * The same as [`detect`]{@link module:Collections.detect} but runs only a single async operation at a time.\n *\n * @name detectSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.detect]{@link module:Collections.detect}\n * @alias findSeries\n * @category Collections\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - A truth test to apply to each item in `coll`.\n * The iteratee must complete with a boolean value as its result.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called as soon as any\n * iteratee returns `true`, or after all the `iteratee` functions have finished.\n * Result will be the first item in the array that passes the truth test\n * (iteratee) or the value `undefined` if none passed. Invoked with\n * (err, result).\n * @returns a Promise if no callback is passed\n */\nfunction detectSeries(coll, iteratee, callback) {\n return _createTester(bool => bool, (res, item) => item)(eachOfLimit(1), coll, iteratee, callback)\n}\n\nvar detectSeries$1 = awaitify(detectSeries, 3);\n\nfunction consoleFunc(name) {\n return (fn, ...args) => wrapAsync(fn)(...args, (err, ...resultArgs) => {\n /* istanbul ignore else */\n if (typeof console === 'object') {\n /* istanbul ignore else */\n if (err) {\n /* istanbul ignore else */\n if (console.error) {\n console.error(err);\n }\n } else if (console[name]) { /* istanbul ignore else */\n resultArgs.forEach(x => console[name](x));\n }\n }\n })\n}\n\n/**\n * Logs the result of an [`async` function]{@link AsyncFunction} to the\n * `console` using `console.dir` to display the properties of the resulting object.\n * Only works in Node.js or in browsers that support `console.dir` and\n * `console.error` (such as FF and Chrome).\n * If multiple arguments are returned from the async function,\n * `console.dir` is called on each argument in order.\n *\n * @name dir\n * @static\n * @memberOf module:Utils\n * @method\n * @category Util\n * @param {AsyncFunction} function - The function you want to eventually apply\n * all arguments to.\n * @param {...*} arguments... - Any number of arguments to apply to the function.\n * @example\n *\n * // in a module\n * var hello = function(name, callback) {\n * setTimeout(function() {\n * callback(null, {hello: name});\n * }, 1000);\n * };\n *\n * // in the node repl\n * node> async.dir(hello, 'world');\n * {hello: 'world'}\n */\nvar dir = consoleFunc('dir');\n\n/**\n * The post-check version of [`whilst`]{@link module:ControlFlow.whilst}. To reflect the difference in\n * the order of operations, the arguments `test` and `iteratee` are switched.\n *\n * `doWhilst` is to `whilst` as `do while` is to `while` in plain JavaScript.\n *\n * @name doWhilst\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.whilst]{@link module:ControlFlow.whilst}\n * @category Control Flow\n * @param {AsyncFunction} iteratee - A function which is called each time `test`\n * passes. Invoked with (callback).\n * @param {AsyncFunction} test - asynchronous truth test to perform after each\n * execution of `iteratee`. Invoked with (...args, callback), where `...args` are the\n * non-error args from the previous callback of `iteratee`.\n * @param {Function} [callback] - A callback which is called after the test\n * function has failed and repeated execution of `iteratee` has stopped.\n * `callback` will be passed an error and any arguments passed to the final\n * `iteratee`'s callback. Invoked with (err, [results]);\n * @returns {Promise} a promise, if no callback is passed\n */\nfunction doWhilst(iteratee, test, callback) {\n callback = onlyOnce(callback);\n var _fn = wrapAsync(iteratee);\n var _test = wrapAsync(test);\n var results;\n\n function next(err, ...args) {\n if (err) return callback(err);\n if (err === false) return;\n results = args;\n _test(...args, check);\n }\n\n function check(err, truth) {\n if (err) return callback(err);\n if (err === false) return;\n if (!truth) return callback(null, ...results);\n _fn(next);\n }\n\n return check(null, true);\n}\n\nvar doWhilst$1 = awaitify(doWhilst, 3);\n\n/**\n * Like ['doWhilst']{@link module:ControlFlow.doWhilst}, except the `test` is inverted. Note the\n * argument ordering differs from `until`.\n *\n * @name doUntil\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.doWhilst]{@link module:ControlFlow.doWhilst}\n * @category Control Flow\n * @param {AsyncFunction} iteratee - An async function which is called each time\n * `test` fails. Invoked with (callback).\n * @param {AsyncFunction} test - asynchronous truth test to perform after each\n * execution of `iteratee`. Invoked with (...args, callback), where `...args` are the\n * non-error args from the previous callback of `iteratee`\n * @param {Function} [callback] - A callback which is called after the test\n * function has passed and repeated execution of `iteratee` has stopped. `callback`\n * will be passed an error and any arguments passed to the final `iteratee`'s\n * callback. Invoked with (err, [results]);\n * @returns {Promise} a promise, if no callback is passed\n */\nfunction doUntil(iteratee, test, callback) {\n const _test = wrapAsync(test);\n return doWhilst$1(iteratee, (...args) => {\n const cb = args.pop();\n _test(...args, (err, truth) => cb (err, !truth));\n }, callback);\n}\n\nfunction _withoutIndex(iteratee) {\n return (value, index, callback) => iteratee(value, callback);\n}\n\n/**\n * Applies the function `iteratee` to each item in `coll`, in parallel.\n * The `iteratee` is called with an item from the list, and a callback for when\n * it has finished. If the `iteratee` passes an error to its `callback`, the\n * main `callback` (for the `each` function) is immediately called with the\n * error.\n *\n * Note, that since this function applies `iteratee` to each item in parallel,\n * there is no guarantee that the iteratee functions will complete in order.\n *\n * @name each\n * @static\n * @memberOf module:Collections\n * @method\n * @alias forEach\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async function to apply to\n * each item in `coll`. Invoked with (item, callback).\n * The array index is not passed to the iteratee.\n * If you need the index, use `eachOf`.\n * @param {Function} [callback] - A callback which is called when all\n * `iteratee` functions have finished, or an error occurs. Invoked with (err).\n * @returns {Promise} a promise, if a callback is omitted\n * @example\n *\n * // dir1 is a directory that contains file1.txt, file2.txt\n * // dir2 is a directory that contains file3.txt, file4.txt\n * // dir3 is a directory that contains file5.txt\n * // dir4 does not exist\n *\n * const fileList = [ 'dir1/file2.txt', 'dir2/file3.txt', 'dir/file5.txt'];\n * const withMissingFileList = ['dir1/file1.txt', 'dir4/file2.txt'];\n *\n * // asynchronous function that deletes a file\n * const deleteFile = function(file, callback) {\n * fs.unlink(file, callback);\n * };\n *\n * // Using callbacks\n * async.each(fileList, deleteFile, function(err) {\n * if( err ) {\n * console.log(err);\n * } else {\n * console.log('All files have been deleted successfully');\n * }\n * });\n *\n * // Error Handling\n * async.each(withMissingFileList, deleteFile, function(err){\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * // since dir4/file2.txt does not exist\n * // dir1/file1.txt could have been deleted\n * });\n *\n * // Using Promises\n * async.each(fileList, deleteFile)\n * .then( () => {\n * console.log('All files have been deleted successfully');\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * // Error Handling\n * async.each(fileList, deleteFile)\n * .then( () => {\n * console.log('All files have been deleted successfully');\n * }).catch( err => {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * // since dir4/file2.txt does not exist\n * // dir1/file1.txt could have been deleted\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * await async.each(files, deleteFile);\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * // Error Handling\n * async () => {\n * try {\n * await async.each(withMissingFileList, deleteFile);\n * }\n * catch (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * // since dir4/file2.txt does not exist\n * // dir1/file1.txt could have been deleted\n * }\n * }\n *\n */\nfunction eachLimit(coll, iteratee, callback) {\n return eachOf$1(coll, _withoutIndex(wrapAsync(iteratee)), callback);\n}\n\nvar each = awaitify(eachLimit, 3);\n\n/**\n * The same as [`each`]{@link module:Collections.each} but runs a maximum of `limit` async operations at a time.\n *\n * @name eachLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.each]{@link module:Collections.each}\n * @alias forEachLimit\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * The array index is not passed to the iteratee.\n * If you need the index, use `eachOfLimit`.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called when all\n * `iteratee` functions have finished, or an error occurs. Invoked with (err).\n * @returns {Promise} a promise, if a callback is omitted\n */\nfunction eachLimit$1(coll, limit, iteratee, callback) {\n return eachOfLimit(limit)(coll, _withoutIndex(wrapAsync(iteratee)), callback);\n}\nvar eachLimit$2 = awaitify(eachLimit$1, 4);\n\n/**\n * The same as [`each`]{@link module:Collections.each} but runs only a single async operation at a time.\n *\n * Note, that unlike [`each`]{@link module:Collections.each}, this function applies iteratee to each item\n * in series and therefore the iteratee functions will complete in order.\n\n * @name eachSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.each]{@link module:Collections.each}\n * @alias forEachSeries\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async function to apply to each\n * item in `coll`.\n * The array index is not passed to the iteratee.\n * If you need the index, use `eachOfSeries`.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called when all\n * `iteratee` functions have finished, or an error occurs. Invoked with (err).\n * @returns {Promise} a promise, if a callback is omitted\n */\nfunction eachSeries(coll, iteratee, callback) {\n return eachLimit$2(coll, 1, iteratee, callback)\n}\nvar eachSeries$1 = awaitify(eachSeries, 3);\n\n/**\n * Wrap an async function and ensure it calls its callback on a later tick of\n * the event loop. If the function already calls its callback on a next tick,\n * no extra deferral is added. This is useful for preventing stack overflows\n * (`RangeError: Maximum call stack size exceeded`) and generally keeping\n * [Zalgo](http://blog.izs.me/post/59142742143/designing-apis-for-asynchrony)\n * contained. ES2017 `async` functions are returned as-is -- they are immune\n * to Zalgo's corrupting influences, as they always resolve on a later tick.\n *\n * @name ensureAsync\n * @static\n * @memberOf module:Utils\n * @method\n * @category Util\n * @param {AsyncFunction} fn - an async function, one that expects a node-style\n * callback as its last argument.\n * @returns {AsyncFunction} Returns a wrapped function with the exact same call\n * signature as the function passed in.\n * @example\n *\n * function sometimesAsync(arg, callback) {\n * if (cache[arg]) {\n * return callback(null, cache[arg]); // this would be synchronous!!\n * } else {\n * doSomeIO(arg, callback); // this IO would be asynchronous\n * }\n * }\n *\n * // this has a risk of stack overflows if many results are cached in a row\n * async.mapSeries(args, sometimesAsync, done);\n *\n * // this will defer sometimesAsync's callback if necessary,\n * // preventing stack overflows\n * async.mapSeries(args, async.ensureAsync(sometimesAsync), done);\n */\nfunction ensureAsync(fn) {\n if (isAsync(fn)) return fn;\n return function (...args/*, callback*/) {\n var callback = args.pop();\n var sync = true;\n args.push((...innerArgs) => {\n if (sync) {\n setImmediate$1(() => callback(...innerArgs));\n } else {\n callback(...innerArgs);\n }\n });\n fn.apply(this, args);\n sync = false;\n };\n}\n\n/**\n * Returns `true` if every element in `coll` satisfies an async test. If any\n * iteratee call returns `false`, the main `callback` is immediately called.\n *\n * @name every\n * @static\n * @memberOf module:Collections\n * @method\n * @alias all\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async truth test to apply to each item\n * in the collection in parallel.\n * The iteratee must complete with a boolean result value.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Result will be either `true` or `false`\n * depending on the values of the async tests. Invoked with (err, result).\n * @returns {Promise} a promise, if no callback provided\n * @example\n *\n * // dir1 is a directory that contains file1.txt, file2.txt\n * // dir2 is a directory that contains file3.txt, file4.txt\n * // dir3 is a directory that contains file5.txt\n * // dir4 does not exist\n *\n * const fileList = ['dir1/file1.txt','dir2/file3.txt','dir3/file5.txt'];\n * const withMissingFileList = ['file1.txt','file2.txt','file4.txt'];\n *\n * // asynchronous function that checks if a file exists\n * function fileExists(file, callback) {\n * fs.access(file, fs.constants.F_OK, (err) => {\n * callback(null, !err);\n * });\n * }\n *\n * // Using callbacks\n * async.every(fileList, fileExists, function(err, result) {\n * console.log(result);\n * // true\n * // result is true since every file exists\n * });\n *\n * async.every(withMissingFileList, fileExists, function(err, result) {\n * console.log(result);\n * // false\n * // result is false since NOT every file exists\n * });\n *\n * // Using Promises\n * async.every(fileList, fileExists)\n * .then( result => {\n * console.log(result);\n * // true\n * // result is true since every file exists\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * async.every(withMissingFileList, fileExists)\n * .then( result => {\n * console.log(result);\n * // false\n * // result is false since NOT every file exists\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let result = await async.every(fileList, fileExists);\n * console.log(result);\n * // true\n * // result is true since every file exists\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * async () => {\n * try {\n * let result = await async.every(withMissingFileList, fileExists);\n * console.log(result);\n * // false\n * // result is false since NOT every file exists\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\nfunction every(coll, iteratee, callback) {\n return _createTester(bool => !bool, res => !res)(eachOf$1, coll, iteratee, callback)\n}\nvar every$1 = awaitify(every, 3);\n\n/**\n * The same as [`every`]{@link module:Collections.every} but runs a maximum of `limit` async operations at a time.\n *\n * @name everyLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.every]{@link module:Collections.every}\n * @alias allLimit\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - An async truth test to apply to each item\n * in the collection in parallel.\n * The iteratee must complete with a boolean result value.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Result will be either `true` or `false`\n * depending on the values of the async tests. Invoked with (err, result).\n * @returns {Promise} a promise, if no callback provided\n */\nfunction everyLimit(coll, limit, iteratee, callback) {\n return _createTester(bool => !bool, res => !res)(eachOfLimit(limit), coll, iteratee, callback)\n}\nvar everyLimit$1 = awaitify(everyLimit, 4);\n\n/**\n * The same as [`every`]{@link module:Collections.every} but runs only a single async operation at a time.\n *\n * @name everySeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.every]{@link module:Collections.every}\n * @alias allSeries\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async truth test to apply to each item\n * in the collection in series.\n * The iteratee must complete with a boolean result value.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Result will be either `true` or `false`\n * depending on the values of the async tests. Invoked with (err, result).\n * @returns {Promise} a promise, if no callback provided\n */\nfunction everySeries(coll, iteratee, callback) {\n return _createTester(bool => !bool, res => !res)(eachOfSeries$1, coll, iteratee, callback)\n}\nvar everySeries$1 = awaitify(everySeries, 3);\n\nfunction filterArray(eachfn, arr, iteratee, callback) {\n var truthValues = new Array(arr.length);\n eachfn(arr, (x, index, iterCb) => {\n iteratee(x, (err, v) => {\n truthValues[index] = !!v;\n iterCb(err);\n });\n }, err => {\n if (err) return callback(err);\n var results = [];\n for (var i = 0; i < arr.length; i++) {\n if (truthValues[i]) results.push(arr[i]);\n }\n callback(null, results);\n });\n}\n\nfunction filterGeneric(eachfn, coll, iteratee, callback) {\n var results = [];\n eachfn(coll, (x, index, iterCb) => {\n iteratee(x, (err, v) => {\n if (err) return iterCb(err);\n if (v) {\n results.push({index, value: x});\n }\n iterCb(err);\n });\n }, err => {\n if (err) return callback(err);\n callback(null, results\n .sort((a, b) => a.index - b.index)\n .map(v => v.value));\n });\n}\n\nfunction _filter(eachfn, coll, iteratee, callback) {\n var filter = isArrayLike(coll) ? filterArray : filterGeneric;\n return filter(eachfn, coll, wrapAsync(iteratee), callback);\n}\n\n/**\n * Returns a new array of all the values in `coll` which pass an async truth\n * test. This operation is performed in parallel, but the results array will be\n * in the same order as the original.\n *\n * @name filter\n * @static\n * @memberOf module:Collections\n * @method\n * @alias select\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {Function} iteratee - A truth test to apply to each item in `coll`.\n * The `iteratee` is passed a `callback(err, truthValue)`, which must be called\n * with a boolean argument once it has completed. Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback provided\n * @example\n *\n * // dir1 is a directory that contains file1.txt, file2.txt\n * // dir2 is a directory that contains file3.txt, file4.txt\n * // dir3 is a directory that contains file5.txt\n *\n * const files = ['dir1/file1.txt','dir2/file3.txt','dir3/file6.txt'];\n *\n * // asynchronous function that checks if a file exists\n * function fileExists(file, callback) {\n * fs.access(file, fs.constants.F_OK, (err) => {\n * callback(null, !err);\n * });\n * }\n *\n * // Using callbacks\n * async.filter(files, fileExists, function(err, results) {\n * if(err) {\n * console.log(err);\n * } else {\n * console.log(results);\n * // [ 'dir1/file1.txt', 'dir2/file3.txt' ]\n * // results is now an array of the existing files\n * }\n * });\n *\n * // Using Promises\n * async.filter(files, fileExists)\n * .then(results => {\n * console.log(results);\n * // [ 'dir1/file1.txt', 'dir2/file3.txt' ]\n * // results is now an array of the existing files\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let results = await async.filter(files, fileExists);\n * console.log(results);\n * // [ 'dir1/file1.txt', 'dir2/file3.txt' ]\n * // results is now an array of the existing files\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\nfunction filter (coll, iteratee, callback) {\n return _filter(eachOf$1, coll, iteratee, callback)\n}\nvar filter$1 = awaitify(filter, 3);\n\n/**\n * The same as [`filter`]{@link module:Collections.filter} but runs a maximum of `limit` async operations at a\n * time.\n *\n * @name filterLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.filter]{@link module:Collections.filter}\n * @alias selectLimit\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {Function} iteratee - A truth test to apply to each item in `coll`.\n * The `iteratee` is passed a `callback(err, truthValue)`, which must be called\n * with a boolean argument once it has completed. Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback provided\n */\nfunction filterLimit (coll, limit, iteratee, callback) {\n return _filter(eachOfLimit(limit), coll, iteratee, callback)\n}\nvar filterLimit$1 = awaitify(filterLimit, 4);\n\n/**\n * The same as [`filter`]{@link module:Collections.filter} but runs only a single async operation at a time.\n *\n * @name filterSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.filter]{@link module:Collections.filter}\n * @alias selectSeries\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {Function} iteratee - A truth test to apply to each item in `coll`.\n * The `iteratee` is passed a `callback(err, truthValue)`, which must be called\n * with a boolean argument once it has completed. Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Invoked with (err, results)\n * @returns {Promise} a promise, if no callback provided\n */\nfunction filterSeries (coll, iteratee, callback) {\n return _filter(eachOfSeries$1, coll, iteratee, callback)\n}\nvar filterSeries$1 = awaitify(filterSeries, 3);\n\n/**\n * Calls the asynchronous function `fn` with a callback parameter that allows it\n * to call itself again, in series, indefinitely.\n\n * If an error is passed to the callback then `errback` is called with the\n * error, and execution stops, otherwise it will never be called.\n *\n * @name forever\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {AsyncFunction} fn - an async function to call repeatedly.\n * Invoked with (next).\n * @param {Function} [errback] - when `fn` passes an error to it's callback,\n * this function will be called, and execution stops. Invoked with (err).\n * @returns {Promise} a promise that rejects if an error occurs and an errback\n * is not passed\n * @example\n *\n * async.forever(\n * function(next) {\n * // next is suitable for passing to things that need a callback(err [, whatever]);\n * // it will result in this function being called again.\n * },\n * function(err) {\n * // if next is called with a value in its first parameter, it will appear\n * // in here as 'err', and execution will stop.\n * }\n * );\n */\nfunction forever(fn, errback) {\n var done = onlyOnce(errback);\n var task = wrapAsync(ensureAsync(fn));\n\n function next(err) {\n if (err) return done(err);\n if (err === false) return;\n task(next);\n }\n return next();\n}\nvar forever$1 = awaitify(forever, 2);\n\n/**\n * The same as [`groupBy`]{@link module:Collections.groupBy} but runs a maximum of `limit` async operations at a time.\n *\n * @name groupByLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.groupBy]{@link module:Collections.groupBy}\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * The iteratee should complete with a `key` to group the value under.\n * Invoked with (value, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. Result is an `Object` whoses\n * properties are arrays of values which returned the corresponding key.\n * @returns {Promise} a promise, if no callback is passed\n */\nfunction groupByLimit(coll, limit, iteratee, callback) {\n var _iteratee = wrapAsync(iteratee);\n return mapLimit$1(coll, limit, (val, iterCb) => {\n _iteratee(val, (err, key) => {\n if (err) return iterCb(err);\n return iterCb(err, {key, val});\n });\n }, (err, mapResults) => {\n var result = {};\n // from MDN, handle object having an `hasOwnProperty` prop\n var {hasOwnProperty} = Object.prototype;\n\n for (var i = 0; i < mapResults.length; i++) {\n if (mapResults[i]) {\n var {key} = mapResults[i];\n var {val} = mapResults[i];\n\n if (hasOwnProperty.call(result, key)) {\n result[key].push(val);\n } else {\n result[key] = [val];\n }\n }\n }\n\n return callback(err, result);\n });\n}\n\nvar groupByLimit$1 = awaitify(groupByLimit, 4);\n\n/**\n * Returns a new object, where each value corresponds to an array of items, from\n * `coll`, that returned the corresponding key. That is, the keys of the object\n * correspond to the values passed to the `iteratee` callback.\n *\n * Note: Since this function applies the `iteratee` to each item in parallel,\n * there is no guarantee that the `iteratee` functions will complete in order.\n * However, the values for each key in the `result` will be in the same order as\n * the original `coll`. For Objects, the values will roughly be in the order of\n * the original Objects' keys (but this can vary across JavaScript engines).\n *\n * @name groupBy\n * @static\n * @memberOf module:Collections\n * @method\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * The iteratee should complete with a `key` to group the value under.\n * Invoked with (value, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. Result is an `Object` whoses\n * properties are arrays of values which returned the corresponding key.\n * @returns {Promise} a promise, if no callback is passed\n * @example\n *\n * // dir1 is a directory that contains file1.txt, file2.txt\n * // dir2 is a directory that contains file3.txt, file4.txt\n * // dir3 is a directory that contains file5.txt\n * // dir4 does not exist\n *\n * const files = ['dir1/file1.txt','dir2','dir4']\n *\n * // asynchronous function that detects file type as none, file, or directory\n * function detectFile(file, callback) {\n * fs.stat(file, function(err, stat) {\n * if (err) {\n * return callback(null, 'none');\n * }\n * callback(null, stat.isDirectory() ? 'directory' : 'file');\n * });\n * }\n *\n * //Using callbacks\n * async.groupBy(files, detectFile, function(err, result) {\n * if(err) {\n * console.log(err);\n * } else {\n *\t console.log(result);\n * // {\n * // file: [ 'dir1/file1.txt' ],\n * // none: [ 'dir4' ],\n * // directory: [ 'dir2']\n * // }\n * // result is object containing the files grouped by type\n * }\n * });\n *\n * // Using Promises\n * async.groupBy(files, detectFile)\n * .then( result => {\n * console.log(result);\n * // {\n * // file: [ 'dir1/file1.txt' ],\n * // none: [ 'dir4' ],\n * // directory: [ 'dir2']\n * // }\n * // result is object containing the files grouped by type\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let result = await async.groupBy(files, detectFile);\n * console.log(result);\n * // {\n * // file: [ 'dir1/file1.txt' ],\n * // none: [ 'dir4' ],\n * // directory: [ 'dir2']\n * // }\n * // result is object containing the files grouped by type\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\nfunction groupBy (coll, iteratee, callback) {\n return groupByLimit$1(coll, Infinity, iteratee, callback)\n}\n\n/**\n * The same as [`groupBy`]{@link module:Collections.groupBy} but runs only a single async operation at a time.\n *\n * @name groupBySeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.groupBy]{@link module:Collections.groupBy}\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * The iteratee should complete with a `key` to group the value under.\n * Invoked with (value, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. Result is an `Object` whose\n * properties are arrays of values which returned the corresponding key.\n * @returns {Promise} a promise, if no callback is passed\n */\nfunction groupBySeries (coll, iteratee, callback) {\n return groupByLimit$1(coll, 1, iteratee, callback)\n}\n\n/**\n * Logs the result of an `async` function to the `console`. Only works in\n * Node.js or in browsers that support `console.log` and `console.error` (such\n * as FF and Chrome). If multiple arguments are returned from the async\n * function, `console.log` is called on each argument in order.\n *\n * @name log\n * @static\n * @memberOf module:Utils\n * @method\n * @category Util\n * @param {AsyncFunction} function - The function you want to eventually apply\n * all arguments to.\n * @param {...*} arguments... - Any number of arguments to apply to the function.\n * @example\n *\n * // in a module\n * var hello = function(name, callback) {\n * setTimeout(function() {\n * callback(null, 'hello ' + name);\n * }, 1000);\n * };\n *\n * // in the node repl\n * node> async.log(hello, 'world');\n * 'hello world'\n */\nvar log = consoleFunc('log');\n\n/**\n * The same as [`mapValues`]{@link module:Collections.mapValues} but runs a maximum of `limit` async operations at a\n * time.\n *\n * @name mapValuesLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.mapValues]{@link module:Collections.mapValues}\n * @category Collection\n * @param {Object} obj - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - A function to apply to each value and key\n * in `coll`.\n * The iteratee should complete with the transformed value as its result.\n * Invoked with (value, key, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. `result` is a new object consisting\n * of each key from `obj`, with each transformed value on the right-hand side.\n * Invoked with (err, result).\n * @returns {Promise} a promise, if no callback is passed\n */\nfunction mapValuesLimit(obj, limit, iteratee, callback) {\n callback = once(callback);\n var newObj = {};\n var _iteratee = wrapAsync(iteratee);\n return eachOfLimit(limit)(obj, (val, key, next) => {\n _iteratee(val, key, (err, result) => {\n if (err) return next(err);\n newObj[key] = result;\n next(err);\n });\n }, err => callback(err, newObj));\n}\n\nvar mapValuesLimit$1 = awaitify(mapValuesLimit, 4);\n\n/**\n * A relative of [`map`]{@link module:Collections.map}, designed for use with objects.\n *\n * Produces a new Object by mapping each value of `obj` through the `iteratee`\n * function. The `iteratee` is called each `value` and `key` from `obj` and a\n * callback for when it has finished processing. Each of these callbacks takes\n * two arguments: an `error`, and the transformed item from `obj`. If `iteratee`\n * passes an error to its callback, the main `callback` (for the `mapValues`\n * function) is immediately called with the error.\n *\n * Note, the order of the keys in the result is not guaranteed. The keys will\n * be roughly in the order they complete, (but this is very engine-specific)\n *\n * @name mapValues\n * @static\n * @memberOf module:Collections\n * @method\n * @category Collection\n * @param {Object} obj - A collection to iterate over.\n * @param {AsyncFunction} iteratee - A function to apply to each value and key\n * in `coll`.\n * The iteratee should complete with the transformed value as its result.\n * Invoked with (value, key, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. `result` is a new object consisting\n * of each key from `obj`, with each transformed value on the right-hand side.\n * Invoked with (err, result).\n * @returns {Promise} a promise, if no callback is passed\n * @example\n *\n * // file1.txt is a file that is 1000 bytes in size\n * // file2.txt is a file that is 2000 bytes in size\n * // file3.txt is a file that is 3000 bytes in size\n * // file4.txt does not exist\n *\n * const fileMap = {\n * f1: 'file1.txt',\n * f2: 'file2.txt',\n * f3: 'file3.txt'\n * };\n *\n * const withMissingFileMap = {\n * f1: 'file1.txt',\n * f2: 'file2.txt',\n * f3: 'file4.txt'\n * };\n *\n * // asynchronous function that returns the file size in bytes\n * function getFileSizeInBytes(file, key, callback) {\n * fs.stat(file, function(err, stat) {\n * if (err) {\n * return callback(err);\n * }\n * callback(null, stat.size);\n * });\n * }\n *\n * // Using callbacks\n * async.mapValues(fileMap, getFileSizeInBytes, function(err, result) {\n * if (err) {\n * console.log(err);\n * } else {\n * console.log(result);\n * // result is now a map of file size in bytes for each file, e.g.\n * // {\n * // f1: 1000,\n * // f2: 2000,\n * // f3: 3000\n * // }\n * }\n * });\n *\n * // Error handling\n * async.mapValues(withMissingFileMap, getFileSizeInBytes, function(err, result) {\n * if (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * } else {\n * console.log(result);\n * }\n * });\n *\n * // Using Promises\n * async.mapValues(fileMap, getFileSizeInBytes)\n * .then( result => {\n * console.log(result);\n * // result is now a map of file size in bytes for each file, e.g.\n * // {\n * // f1: 1000,\n * // f2: 2000,\n * // f3: 3000\n * // }\n * }).catch (err => {\n * console.log(err);\n * });\n *\n * // Error Handling\n * async.mapValues(withMissingFileMap, getFileSizeInBytes)\n * .then( result => {\n * console.log(result);\n * }).catch (err => {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let result = await async.mapValues(fileMap, getFileSizeInBytes);\n * console.log(result);\n * // result is now a map of file size in bytes for each file, e.g.\n * // {\n * // f1: 1000,\n * // f2: 2000,\n * // f3: 3000\n * // }\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * // Error Handling\n * async () => {\n * try {\n * let result = await async.mapValues(withMissingFileMap, getFileSizeInBytes);\n * console.log(result);\n * }\n * catch (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * }\n * }\n *\n */\nfunction mapValues(obj, iteratee, callback) {\n return mapValuesLimit$1(obj, Infinity, iteratee, callback)\n}\n\n/**\n * The same as [`mapValues`]{@link module:Collections.mapValues} but runs only a single async operation at a time.\n *\n * @name mapValuesSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.mapValues]{@link module:Collections.mapValues}\n * @category Collection\n * @param {Object} obj - A collection to iterate over.\n * @param {AsyncFunction} iteratee - A function to apply to each value and key\n * in `coll`.\n * The iteratee should complete with the transformed value as its result.\n * Invoked with (value, key, callback).\n * @param {Function} [callback] - A callback which is called when all `iteratee`\n * functions have finished, or an error occurs. `result` is a new object consisting\n * of each key from `obj`, with each transformed value on the right-hand side.\n * Invoked with (err, result).\n * @returns {Promise} a promise, if no callback is passed\n */\nfunction mapValuesSeries(obj, iteratee, callback) {\n return mapValuesLimit$1(obj, 1, iteratee, callback)\n}\n\n/**\n * Caches the results of an async function. When creating a hash to store\n * function results against, the callback is omitted from the hash and an\n * optional hash function can be used.\n *\n * **Note: if the async function errs, the result will not be cached and\n * subsequent calls will call the wrapped function.**\n *\n * If no hash function is specified, the first argument is used as a hash key,\n * which may work reasonably if it is a string or a data type that converts to a\n * distinct string. Note that objects and arrays will not behave reasonably.\n * Neither will cases where the other arguments are significant. In such cases,\n * specify your own hash function.\n *\n * The cache of results is exposed as the `memo` property of the function\n * returned by `memoize`.\n *\n * @name memoize\n * @static\n * @memberOf module:Utils\n * @method\n * @category Util\n * @param {AsyncFunction} fn - The async function to proxy and cache results from.\n * @param {Function} hasher - An optional function for generating a custom hash\n * for storing results. It has all the arguments applied to it apart from the\n * callback, and must be synchronous.\n * @returns {AsyncFunction} a memoized version of `fn`\n * @example\n *\n * var slow_fn = function(name, callback) {\n * // do something\n * callback(null, result);\n * };\n * var fn = async.memoize(slow_fn);\n *\n * // fn can now be used as if it were slow_fn\n * fn('some name', function() {\n * // callback\n * });\n */\nfunction memoize(fn, hasher = v => v) {\n var memo = Object.create(null);\n var queues = Object.create(null);\n var _fn = wrapAsync(fn);\n var memoized = initialParams((args, callback) => {\n var key = hasher(...args);\n if (key in memo) {\n setImmediate$1(() => callback(null, ...memo[key]));\n } else if (key in queues) {\n queues[key].push(callback);\n } else {\n queues[key] = [callback];\n _fn(...args, (err, ...resultArgs) => {\n // #1465 don't memoize if an error occurred\n if (!err) {\n memo[key] = resultArgs;\n }\n var q = queues[key];\n delete queues[key];\n for (var i = 0, l = q.length; i < l; i++) {\n q[i](err, ...resultArgs);\n }\n });\n }\n });\n memoized.memo = memo;\n memoized.unmemoized = fn;\n return memoized;\n}\n\n/**\n * Calls `callback` on a later loop around the event loop. In Node.js this just\n * calls `process.nextTick`. In the browser it will use `setImmediate` if\n * available, otherwise `setTimeout(callback, 0)`, which means other higher\n * priority events may precede the execution of `callback`.\n *\n * This is used internally for browser-compatibility purposes.\n *\n * @name nextTick\n * @static\n * @memberOf module:Utils\n * @method\n * @see [async.setImmediate]{@link module:Utils.setImmediate}\n * @category Util\n * @param {Function} callback - The function to call on a later loop around\n * the event loop. Invoked with (args...).\n * @param {...*} args... - any number of additional arguments to pass to the\n * callback on the next tick.\n * @example\n *\n * var call_order = [];\n * async.nextTick(function() {\n * call_order.push('two');\n * // call_order now equals ['one','two']\n * });\n * call_order.push('one');\n *\n * async.setImmediate(function (a, b, c) {\n * // a, b, and c equal 1, 2, and 3\n * }, 1, 2, 3);\n */\nvar _defer$1;\n\nif (hasNextTick) {\n _defer$1 = process.nextTick;\n} else if (hasSetImmediate) {\n _defer$1 = setImmediate;\n} else {\n _defer$1 = fallback;\n}\n\nvar nextTick = wrap(_defer$1);\n\nvar _parallel = awaitify((eachfn, tasks, callback) => {\n var results = isArrayLike(tasks) ? [] : {};\n\n eachfn(tasks, (task, key, taskCb) => {\n wrapAsync(task)((err, ...result) => {\n if (result.length < 2) {\n [result] = result;\n }\n results[key] = result;\n taskCb(err);\n });\n }, err => callback(err, results));\n}, 3);\n\n/**\n * Run the `tasks` collection of functions in parallel, without waiting until\n * the previous function has completed. If any of the functions pass an error to\n * its callback, the main `callback` is immediately called with the value of the\n * error. Once the `tasks` have completed, the results are passed to the final\n * `callback` as an array.\n *\n * **Note:** `parallel` is about kicking-off I/O tasks in parallel, not about\n * parallel execution of code. If your tasks do not use any timers or perform\n * any I/O, they will actually be executed in series. Any synchronous setup\n * sections for each task will happen one after the other. JavaScript remains\n * single-threaded.\n *\n * **Hint:** Use [`reflect`]{@link module:Utils.reflect} to continue the\n * execution of other tasks when a task fails.\n *\n * It is also possible to use an object instead of an array. Each property will\n * be run as a function and the results will be passed to the final `callback`\n * as an object instead of an array. This can be a more readable way of handling\n * results from {@link async.parallel}.\n *\n * @name parallel\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {Array|Iterable|AsyncIterable|Object} tasks - A collection of\n * [async functions]{@link AsyncFunction} to run.\n * Each async function can complete with any number of optional `result` values.\n * @param {Function} [callback] - An optional callback to run once all the\n * functions have completed successfully. This function gets a results array\n * (or object) containing all the result arguments passed to the task callbacks.\n * Invoked with (err, results).\n * @returns {Promise} a promise, if a callback is not passed\n *\n * @example\n *\n * //Using Callbacks\n * async.parallel([\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'one');\n * }, 200);\n * },\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'two');\n * }, 100);\n * }\n * ], function(err, results) {\n * console.log(results);\n * // results is equal to ['one','two'] even though\n * // the second function had a shorter timeout.\n * });\n *\n * // an example using an object instead of an array\n * async.parallel({\n * one: function(callback) {\n * setTimeout(function() {\n * callback(null, 1);\n * }, 200);\n * },\n * two: function(callback) {\n * setTimeout(function() {\n * callback(null, 2);\n * }, 100);\n * }\n * }, function(err, results) {\n * console.log(results);\n * // results is equal to: { one: 1, two: 2 }\n * });\n *\n * //Using Promises\n * async.parallel([\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'one');\n * }, 200);\n * },\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'two');\n * }, 100);\n * }\n * ]).then(results => {\n * console.log(results);\n * // results is equal to ['one','two'] even though\n * // the second function had a shorter timeout.\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * // an example using an object instead of an array\n * async.parallel({\n * one: function(callback) {\n * setTimeout(function() {\n * callback(null, 1);\n * }, 200);\n * },\n * two: function(callback) {\n * setTimeout(function() {\n * callback(null, 2);\n * }, 100);\n * }\n * }).then(results => {\n * console.log(results);\n * // results is equal to: { one: 1, two: 2 }\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * //Using async/await\n * async () => {\n * try {\n * let results = await async.parallel([\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'one');\n * }, 200);\n * },\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'two');\n * }, 100);\n * }\n * ]);\n * console.log(results);\n * // results is equal to ['one','two'] even though\n * // the second function had a shorter timeout.\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * // an example using an object instead of an array\n * async () => {\n * try {\n * let results = await async.parallel({\n * one: function(callback) {\n * setTimeout(function() {\n * callback(null, 1);\n * }, 200);\n * },\n * two: function(callback) {\n * setTimeout(function() {\n * callback(null, 2);\n * }, 100);\n * }\n * });\n * console.log(results);\n * // results is equal to: { one: 1, two: 2 }\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\nfunction parallel(tasks, callback) {\n return _parallel(eachOf$1, tasks, callback);\n}\n\n/**\n * The same as [`parallel`]{@link module:ControlFlow.parallel} but runs a maximum of `limit` async operations at a\n * time.\n *\n * @name parallelLimit\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.parallel]{@link module:ControlFlow.parallel}\n * @category Control Flow\n * @param {Array|Iterable|AsyncIterable|Object} tasks - A collection of\n * [async functions]{@link AsyncFunction} to run.\n * Each async function can complete with any number of optional `result` values.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {Function} [callback] - An optional callback to run once all the\n * functions have completed successfully. This function gets a results array\n * (or object) containing all the result arguments passed to the task callbacks.\n * Invoked with (err, results).\n * @returns {Promise} a promise, if a callback is not passed\n */\nfunction parallelLimit(tasks, limit, callback) {\n return _parallel(eachOfLimit(limit), tasks, callback);\n}\n\n/**\n * A queue of tasks for the worker function to complete.\n * @typedef {Iterable} QueueObject\n * @memberOf module:ControlFlow\n * @property {Function} length - a function returning the number of items\n * waiting to be processed. Invoke with `queue.length()`.\n * @property {boolean} started - a boolean indicating whether or not any\n * items have been pushed and processed by the queue.\n * @property {Function} running - a function returning the number of items\n * currently being processed. Invoke with `queue.running()`.\n * @property {Function} workersList - a function returning the array of items\n * currently being processed. Invoke with `queue.workersList()`.\n * @property {Function} idle - a function returning false if there are items\n * waiting or being processed, or true if not. Invoke with `queue.idle()`.\n * @property {number} concurrency - an integer for determining how many `worker`\n * functions should be run in parallel. This property can be changed after a\n * `queue` is created to alter the concurrency on-the-fly.\n * @property {number} payload - an integer that specifies how many items are\n * passed to the worker function at a time. only applies if this is a\n * [cargo]{@link module:ControlFlow.cargo} object\n * @property {AsyncFunction} push - add a new task to the `queue`. Calls `callback`\n * once the `worker` has finished processing the task. Instead of a single task,\n * a `tasks` array can be submitted. The respective callback is used for every\n * task in the list. Invoke with `queue.push(task, [callback])`,\n * @property {AsyncFunction} unshift - add a new task to the front of the `queue`.\n * Invoke with `queue.unshift(task, [callback])`.\n * @property {AsyncFunction} pushAsync - the same as `q.push`, except this returns\n * a promise that rejects if an error occurs.\n * @property {AsyncFunction} unshiftAsync - the same as `q.unshift`, except this returns\n * a promise that rejects if an error occurs.\n * @property {Function} remove - remove items from the queue that match a test\n * function. The test function will be passed an object with a `data` property,\n * and a `priority` property, if this is a\n * [priorityQueue]{@link module:ControlFlow.priorityQueue} object.\n * Invoked with `queue.remove(testFn)`, where `testFn` is of the form\n * `function ({data, priority}) {}` and returns a Boolean.\n * @property {Function} saturated - a function that sets a callback that is\n * called when the number of running workers hits the `concurrency` limit, and\n * further tasks will be queued. If the callback is omitted, `q.saturated()`\n * returns a promise for the next occurrence.\n * @property {Function} unsaturated - a function that sets a callback that is\n * called when the number of running workers is less than the `concurrency` &\n * `buffer` limits, and further tasks will not be queued. If the callback is\n * omitted, `q.unsaturated()` returns a promise for the next occurrence.\n * @property {number} buffer - A minimum threshold buffer in order to say that\n * the `queue` is `unsaturated`.\n * @property {Function} empty - a function that sets a callback that is called\n * when the last item from the `queue` is given to a `worker`. If the callback\n * is omitted, `q.empty()` returns a promise for the next occurrence.\n * @property {Function} drain - a function that sets a callback that is called\n * when the last item from the `queue` has returned from the `worker`. If the\n * callback is omitted, `q.drain()` returns a promise for the next occurrence.\n * @property {Function} error - a function that sets a callback that is called\n * when a task errors. Has the signature `function(error, task)`. If the\n * callback is omitted, `error()` returns a promise that rejects on the next\n * error.\n * @property {boolean} paused - a boolean for determining whether the queue is\n * in a paused state.\n * @property {Function} pause - a function that pauses the processing of tasks\n * until `resume()` is called. Invoke with `queue.pause()`.\n * @property {Function} resume - a function that resumes the processing of\n * queued tasks when the queue is paused. Invoke with `queue.resume()`.\n * @property {Function} kill - a function that removes the `drain` callback and\n * empties remaining tasks from the queue forcing it to go idle. No more tasks\n * should be pushed to the queue after calling this function. Invoke with `queue.kill()`.\n *\n * @example\n * const q = async.queue(worker, 2)\n * q.push(item1)\n * q.push(item2)\n * q.push(item3)\n * // queues are iterable, spread into an array to inspect\n * const items = [...q] // [item1, item2, item3]\n * // or use for of\n * for (let item of q) {\n * console.log(item)\n * }\n *\n * q.drain(() => {\n * console.log('all done')\n * })\n * // or\n * await q.drain()\n */\n\n/**\n * Creates a `queue` object with the specified `concurrency`. Tasks added to the\n * `queue` are processed in parallel (up to the `concurrency` limit). If all\n * `worker`s are in progress, the task is queued until one becomes available.\n * Once a `worker` completes a `task`, that `task`'s callback is called.\n *\n * @name queue\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {AsyncFunction} worker - An async function for processing a queued task.\n * If you want to handle errors from an individual task, pass a callback to\n * `q.push()`. Invoked with (task, callback).\n * @param {number} [concurrency=1] - An `integer` for determining how many\n * `worker` functions should be run in parallel. If omitted, the concurrency\n * defaults to `1`. If the concurrency is `0`, an error is thrown.\n * @returns {module:ControlFlow.QueueObject} A queue object to manage the tasks. Callbacks can be\n * attached as certain properties to listen for specific events during the\n * lifecycle of the queue.\n * @example\n *\n * // create a queue object with concurrency 2\n * var q = async.queue(function(task, callback) {\n * console.log('hello ' + task.name);\n * callback();\n * }, 2);\n *\n * // assign a callback\n * q.drain(function() {\n * console.log('all items have been processed');\n * });\n * // or await the end\n * await q.drain()\n *\n * // assign an error callback\n * q.error(function(err, task) {\n * console.error('task experienced an error');\n * });\n *\n * // add some items to the queue\n * q.push({name: 'foo'}, function(err) {\n * console.log('finished processing foo');\n * });\n * // callback is optional\n * q.push({name: 'bar'});\n *\n * // add some items to the queue (batch-wise)\n * q.push([{name: 'baz'},{name: 'bay'},{name: 'bax'}], function(err) {\n * console.log('finished processing item');\n * });\n *\n * // add some items to the front of the queue\n * q.unshift({name: 'bar'}, function (err) {\n * console.log('finished processing bar');\n * });\n */\nfunction queue$1 (worker, concurrency) {\n var _worker = wrapAsync(worker);\n return queue((items, cb) => {\n _worker(items[0], cb);\n }, concurrency, 1);\n}\n\n// Binary min-heap implementation used for priority queue.\n// Implementation is stable, i.e. push time is considered for equal priorities\nclass Heap {\n constructor() {\n this.heap = [];\n this.pushCount = Number.MIN_SAFE_INTEGER;\n }\n\n get length() {\n return this.heap.length;\n }\n\n empty () {\n this.heap = [];\n return this;\n }\n\n percUp(index) {\n let p;\n\n while (index > 0 && smaller(this.heap[index], this.heap[p=parent(index)])) {\n let t = this.heap[index];\n this.heap[index] = this.heap[p];\n this.heap[p] = t;\n\n index = p;\n }\n }\n\n percDown(index) {\n let l;\n\n while ((l=leftChi(index)) < this.heap.length) {\n if (l+1 < this.heap.length && smaller(this.heap[l+1], this.heap[l])) {\n l = l+1;\n }\n\n if (smaller(this.heap[index], this.heap[l])) {\n break;\n }\n\n let t = this.heap[index];\n this.heap[index] = this.heap[l];\n this.heap[l] = t;\n\n index = l;\n }\n }\n\n push(node) {\n node.pushCount = ++this.pushCount;\n this.heap.push(node);\n this.percUp(this.heap.length-1);\n }\n\n unshift(node) {\n return this.heap.push(node);\n }\n\n shift() {\n let [top] = this.heap;\n\n this.heap[0] = this.heap[this.heap.length-1];\n this.heap.pop();\n this.percDown(0);\n\n return top;\n }\n\n toArray() {\n return [...this];\n }\n\n *[Symbol.iterator] () {\n for (let i = 0; i < this.heap.length; i++) {\n yield this.heap[i].data;\n }\n }\n\n remove (testFn) {\n let j = 0;\n for (let i = 0; i < this.heap.length; i++) {\n if (!testFn(this.heap[i])) {\n this.heap[j] = this.heap[i];\n j++;\n }\n }\n\n this.heap.splice(j);\n\n for (let i = parent(this.heap.length-1); i >= 0; i--) {\n this.percDown(i);\n }\n\n return this;\n }\n}\n\nfunction leftChi(i) {\n return (i<<1)+1;\n}\n\nfunction parent(i) {\n return ((i+1)>>1)-1;\n}\n\nfunction smaller(x, y) {\n if (x.priority !== y.priority) {\n return x.priority < y.priority;\n }\n else {\n return x.pushCount < y.pushCount;\n }\n}\n\n/**\n * The same as [async.queue]{@link module:ControlFlow.queue} only tasks are assigned a priority and\n * completed in ascending priority order.\n *\n * @name priorityQueue\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.queue]{@link module:ControlFlow.queue}\n * @category Control Flow\n * @param {AsyncFunction} worker - An async function for processing a queued task.\n * If you want to handle errors from an individual task, pass a callback to\n * `q.push()`.\n * Invoked with (task, callback).\n * @param {number} concurrency - An `integer` for determining how many `worker`\n * functions should be run in parallel. If omitted, the concurrency defaults to\n * `1`. If the concurrency is `0`, an error is thrown.\n * @returns {module:ControlFlow.QueueObject} A priorityQueue object to manage the tasks. There are two\n * differences between `queue` and `priorityQueue` objects:\n * * `push(task, priority, [callback])` - `priority` should be a number. If an\n * array of `tasks` is given, all tasks will be assigned the same priority.\n * * The `unshift` method was removed.\n */\nfunction priorityQueue(worker, concurrency) {\n // Start with a normal queue\n var q = queue$1(worker, concurrency);\n var processingScheduled = false;\n\n q._tasks = new Heap();\n\n // Override push to accept second parameter representing priority\n q.push = function(data, priority = 0, callback = () => {}) {\n if (typeof callback !== 'function') {\n throw new Error('task callback must be a function');\n }\n q.started = true;\n if (!Array.isArray(data)) {\n data = [data];\n }\n if (data.length === 0 && q.idle()) {\n // call drain immediately if there are no tasks\n return setImmediate$1(() => q.drain());\n }\n\n for (var i = 0, l = data.length; i < l; i++) {\n var item = {\n data: data[i],\n priority,\n callback\n };\n\n q._tasks.push(item);\n }\n\n if (!processingScheduled) {\n processingScheduled = true;\n setImmediate$1(() => {\n processingScheduled = false;\n q.process();\n });\n }\n };\n\n // Remove unshift function\n delete q.unshift;\n\n return q;\n}\n\n/**\n * Runs the `tasks` array of functions in parallel, without waiting until the\n * previous function has completed. Once any of the `tasks` complete or pass an\n * error to its callback, the main `callback` is immediately called. It's\n * equivalent to `Promise.race()`.\n *\n * @name race\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {Array} tasks - An array containing [async functions]{@link AsyncFunction}\n * to run. Each function can complete with an optional `result` value.\n * @param {Function} callback - A callback to run once any of the functions have\n * completed. This function gets an error or result from the first function that\n * completed. Invoked with (err, result).\n * @returns undefined\n * @example\n *\n * async.race([\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'one');\n * }, 200);\n * },\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'two');\n * }, 100);\n * }\n * ],\n * // main callback\n * function(err, result) {\n * // the result will be equal to 'two' as it finishes earlier\n * });\n */\nfunction race(tasks, callback) {\n callback = once(callback);\n if (!Array.isArray(tasks)) return callback(new TypeError('First argument to race must be an array of functions'));\n if (!tasks.length) return callback();\n for (var i = 0, l = tasks.length; i < l; i++) {\n wrapAsync(tasks[i])(callback);\n }\n}\n\nvar race$1 = awaitify(race, 2);\n\n/**\n * Same as [`reduce`]{@link module:Collections.reduce}, only operates on `array` in reverse order.\n *\n * @name reduceRight\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.reduce]{@link module:Collections.reduce}\n * @alias foldr\n * @category Collection\n * @param {Array} array - A collection to iterate over.\n * @param {*} memo - The initial state of the reduction.\n * @param {AsyncFunction} iteratee - A function applied to each item in the\n * array to produce the next step in the reduction.\n * The `iteratee` should complete with the next state of the reduction.\n * If the iteratee completes with an error, the reduction is stopped and the\n * main `callback` is immediately called with the error.\n * Invoked with (memo, item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Result is the reduced value. Invoked with\n * (err, result).\n * @returns {Promise} a promise, if no callback is passed\n */\nfunction reduceRight (array, memo, iteratee, callback) {\n var reversed = [...array].reverse();\n return reduce$1(reversed, memo, iteratee, callback);\n}\n\n/**\n * Wraps the async function in another function that always completes with a\n * result object, even when it errors.\n *\n * The result object has either the property `error` or `value`.\n *\n * @name reflect\n * @static\n * @memberOf module:Utils\n * @method\n * @category Util\n * @param {AsyncFunction} fn - The async function you want to wrap\n * @returns {Function} - A function that always passes null to it's callback as\n * the error. The second argument to the callback will be an `object` with\n * either an `error` or a `value` property.\n * @example\n *\n * async.parallel([\n * async.reflect(function(callback) {\n * // do some stuff ...\n * callback(null, 'one');\n * }),\n * async.reflect(function(callback) {\n * // do some more stuff but error ...\n * callback('bad stuff happened');\n * }),\n * async.reflect(function(callback) {\n * // do some more stuff ...\n * callback(null, 'two');\n * })\n * ],\n * // optional callback\n * function(err, results) {\n * // values\n * // results[0].value = 'one'\n * // results[1].error = 'bad stuff happened'\n * // results[2].value = 'two'\n * });\n */\nfunction reflect(fn) {\n var _fn = wrapAsync(fn);\n return initialParams(function reflectOn(args, reflectCallback) {\n args.push((error, ...cbArgs) => {\n let retVal = {};\n if (error) {\n retVal.error = error;\n }\n if (cbArgs.length > 0){\n var value = cbArgs;\n if (cbArgs.length <= 1) {\n [value] = cbArgs;\n }\n retVal.value = value;\n }\n reflectCallback(null, retVal);\n });\n\n return _fn.apply(this, args);\n });\n}\n\n/**\n * A helper function that wraps an array or an object of functions with `reflect`.\n *\n * @name reflectAll\n * @static\n * @memberOf module:Utils\n * @method\n * @see [async.reflect]{@link module:Utils.reflect}\n * @category Util\n * @param {Array|Object|Iterable} tasks - The collection of\n * [async functions]{@link AsyncFunction} to wrap in `async.reflect`.\n * @returns {Array} Returns an array of async functions, each wrapped in\n * `async.reflect`\n * @example\n *\n * let tasks = [\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'one');\n * }, 200);\n * },\n * function(callback) {\n * // do some more stuff but error ...\n * callback(new Error('bad stuff happened'));\n * },\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'two');\n * }, 100);\n * }\n * ];\n *\n * async.parallel(async.reflectAll(tasks),\n * // optional callback\n * function(err, results) {\n * // values\n * // results[0].value = 'one'\n * // results[1].error = Error('bad stuff happened')\n * // results[2].value = 'two'\n * });\n *\n * // an example using an object instead of an array\n * let tasks = {\n * one: function(callback) {\n * setTimeout(function() {\n * callback(null, 'one');\n * }, 200);\n * },\n * two: function(callback) {\n * callback('two');\n * },\n * three: function(callback) {\n * setTimeout(function() {\n * callback(null, 'three');\n * }, 100);\n * }\n * };\n *\n * async.parallel(async.reflectAll(tasks),\n * // optional callback\n * function(err, results) {\n * // values\n * // results.one.value = 'one'\n * // results.two.error = 'two'\n * // results.three.value = 'three'\n * });\n */\nfunction reflectAll(tasks) {\n var results;\n if (Array.isArray(tasks)) {\n results = tasks.map(reflect);\n } else {\n results = {};\n Object.keys(tasks).forEach(key => {\n results[key] = reflect.call(this, tasks[key]);\n });\n }\n return results;\n}\n\nfunction reject(eachfn, arr, _iteratee, callback) {\n const iteratee = wrapAsync(_iteratee);\n return _filter(eachfn, arr, (value, cb) => {\n iteratee(value, (err, v) => {\n cb(err, !v);\n });\n }, callback);\n}\n\n/**\n * The opposite of [`filter`]{@link module:Collections.filter}. Removes values that pass an `async` truth test.\n *\n * @name reject\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.filter]{@link module:Collections.filter}\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {Function} iteratee - An async truth test to apply to each item in\n * `coll`.\n * The should complete with a boolean value as its `result`.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback is passed\n * @example\n *\n * // dir1 is a directory that contains file1.txt, file2.txt\n * // dir2 is a directory that contains file3.txt, file4.txt\n * // dir3 is a directory that contains file5.txt\n *\n * const fileList = ['dir1/file1.txt','dir2/file3.txt','dir3/file6.txt'];\n *\n * // asynchronous function that checks if a file exists\n * function fileExists(file, callback) {\n * fs.access(file, fs.constants.F_OK, (err) => {\n * callback(null, !err);\n * });\n * }\n *\n * // Using callbacks\n * async.reject(fileList, fileExists, function(err, results) {\n * // [ 'dir3/file6.txt' ]\n * // results now equals an array of the non-existing files\n * });\n *\n * // Using Promises\n * async.reject(fileList, fileExists)\n * .then( results => {\n * console.log(results);\n * // [ 'dir3/file6.txt' ]\n * // results now equals an array of the non-existing files\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let results = await async.reject(fileList, fileExists);\n * console.log(results);\n * // [ 'dir3/file6.txt' ]\n * // results now equals an array of the non-existing files\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\nfunction reject$1 (coll, iteratee, callback) {\n return reject(eachOf$1, coll, iteratee, callback)\n}\nvar reject$2 = awaitify(reject$1, 3);\n\n/**\n * The same as [`reject`]{@link module:Collections.reject} but runs a maximum of `limit` async operations at a\n * time.\n *\n * @name rejectLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.reject]{@link module:Collections.reject}\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {Function} iteratee - An async truth test to apply to each item in\n * `coll`.\n * The should complete with a boolean value as its `result`.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback is passed\n */\nfunction rejectLimit (coll, limit, iteratee, callback) {\n return reject(eachOfLimit(limit), coll, iteratee, callback)\n}\nvar rejectLimit$1 = awaitify(rejectLimit, 4);\n\n/**\n * The same as [`reject`]{@link module:Collections.reject} but runs only a single async operation at a time.\n *\n * @name rejectSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.reject]{@link module:Collections.reject}\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {Function} iteratee - An async truth test to apply to each item in\n * `coll`.\n * The should complete with a boolean value as its `result`.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback is passed\n */\nfunction rejectSeries (coll, iteratee, callback) {\n return reject(eachOfSeries$1, coll, iteratee, callback)\n}\nvar rejectSeries$1 = awaitify(rejectSeries, 3);\n\nfunction constant$1(value) {\n return function () {\n return value;\n }\n}\n\n/**\n * Attempts to get a successful response from `task` no more than `times` times\n * before returning an error. If the task is successful, the `callback` will be\n * passed the result of the successful task. If all attempts fail, the callback\n * will be passed the error and result (if any) of the final attempt.\n *\n * @name retry\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @see [async.retryable]{@link module:ControlFlow.retryable}\n * @param {Object|number} [opts = {times: 5, interval: 0}| 5] - Can be either an\n * object with `times` and `interval` or a number.\n * * `times` - The number of attempts to make before giving up. The default\n * is `5`.\n * * `interval` - The time to wait between retries, in milliseconds. The\n * default is `0`. The interval may also be specified as a function of the\n * retry count (see example).\n * * `errorFilter` - An optional synchronous function that is invoked on\n * erroneous result. If it returns `true` the retry attempts will continue;\n * if the function returns `false` the retry flow is aborted with the current\n * attempt's error and result being returned to the final callback.\n * Invoked with (err).\n * * If `opts` is a number, the number specifies the number of times to retry,\n * with the default interval of `0`.\n * @param {AsyncFunction} task - An async function to retry.\n * Invoked with (callback).\n * @param {Function} [callback] - An optional callback which is called when the\n * task has succeeded, or after the final failed attempt. It receives the `err`\n * and `result` arguments of the last attempt at completing the `task`. Invoked\n * with (err, results).\n * @returns {Promise} a promise if no callback provided\n *\n * @example\n *\n * // The `retry` function can be used as a stand-alone control flow by passing\n * // a callback, as shown below:\n *\n * // try calling apiMethod 3 times\n * async.retry(3, apiMethod, function(err, result) {\n * // do something with the result\n * });\n *\n * // try calling apiMethod 3 times, waiting 200 ms between each retry\n * async.retry({times: 3, interval: 200}, apiMethod, function(err, result) {\n * // do something with the result\n * });\n *\n * // try calling apiMethod 10 times with exponential backoff\n * // (i.e. intervals of 100, 200, 400, 800, 1600, ... milliseconds)\n * async.retry({\n * times: 10,\n * interval: function(retryCount) {\n * return 50 * Math.pow(2, retryCount);\n * }\n * }, apiMethod, function(err, result) {\n * // do something with the result\n * });\n *\n * // try calling apiMethod the default 5 times no delay between each retry\n * async.retry(apiMethod, function(err, result) {\n * // do something with the result\n * });\n *\n * // try calling apiMethod only when error condition satisfies, all other\n * // errors will abort the retry control flow and return to final callback\n * async.retry({\n * errorFilter: function(err) {\n * return err.message === 'Temporary error'; // only retry on a specific error\n * }\n * }, apiMethod, function(err, result) {\n * // do something with the result\n * });\n *\n * // to retry individual methods that are not as reliable within other\n * // control flow functions, use the `retryable` wrapper:\n * async.auto({\n * users: api.getUsers.bind(api),\n * payments: async.retryable(3, api.getPayments.bind(api))\n * }, function(err, results) {\n * // do something with the results\n * });\n *\n */\nconst DEFAULT_TIMES = 5;\nconst DEFAULT_INTERVAL = 0;\n\nfunction retry(opts, task, callback) {\n var options = {\n times: DEFAULT_TIMES,\n intervalFunc: constant$1(DEFAULT_INTERVAL)\n };\n\n if (arguments.length < 3 && typeof opts === 'function') {\n callback = task || promiseCallback();\n task = opts;\n } else {\n parseTimes(options, opts);\n callback = callback || promiseCallback();\n }\n\n if (typeof task !== 'function') {\n throw new Error(\"Invalid arguments for async.retry\");\n }\n\n var _task = wrapAsync(task);\n\n var attempt = 1;\n function retryAttempt() {\n _task((err, ...args) => {\n if (err === false) return\n if (err && attempt++ < options.times &&\n (typeof options.errorFilter != 'function' ||\n options.errorFilter(err))) {\n setTimeout(retryAttempt, options.intervalFunc(attempt - 1));\n } else {\n callback(err, ...args);\n }\n });\n }\n\n retryAttempt();\n return callback[PROMISE_SYMBOL]\n}\n\nfunction parseTimes(acc, t) {\n if (typeof t === 'object') {\n acc.times = +t.times || DEFAULT_TIMES;\n\n acc.intervalFunc = typeof t.interval === 'function' ?\n t.interval :\n constant$1(+t.interval || DEFAULT_INTERVAL);\n\n acc.errorFilter = t.errorFilter;\n } else if (typeof t === 'number' || typeof t === 'string') {\n acc.times = +t || DEFAULT_TIMES;\n } else {\n throw new Error(\"Invalid arguments for async.retry\");\n }\n}\n\n/**\n * A close relative of [`retry`]{@link module:ControlFlow.retry}. This method\n * wraps a task and makes it retryable, rather than immediately calling it\n * with retries.\n *\n * @name retryable\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.retry]{@link module:ControlFlow.retry}\n * @category Control Flow\n * @param {Object|number} [opts = {times: 5, interval: 0}| 5] - optional\n * options, exactly the same as from `retry`, except for a `opts.arity` that\n * is the arity of the `task` function, defaulting to `task.length`\n * @param {AsyncFunction} task - the asynchronous function to wrap.\n * This function will be passed any arguments passed to the returned wrapper.\n * Invoked with (...args, callback).\n * @returns {AsyncFunction} The wrapped function, which when invoked, will\n * retry on an error, based on the parameters specified in `opts`.\n * This function will accept the same parameters as `task`.\n * @example\n *\n * async.auto({\n * dep1: async.retryable(3, getFromFlakyService),\n * process: [\"dep1\", async.retryable(3, function (results, cb) {\n * maybeProcessData(results.dep1, cb);\n * })]\n * }, callback);\n */\nfunction retryable (opts, task) {\n if (!task) {\n task = opts;\n opts = null;\n }\n let arity = (opts && opts.arity) || task.length;\n if (isAsync(task)) {\n arity += 1;\n }\n var _task = wrapAsync(task);\n return initialParams((args, callback) => {\n if (args.length < arity - 1 || callback == null) {\n args.push(callback);\n callback = promiseCallback();\n }\n function taskFn(cb) {\n _task(...args, cb);\n }\n\n if (opts) retry(opts, taskFn, callback);\n else retry(taskFn, callback);\n\n return callback[PROMISE_SYMBOL]\n });\n}\n\n/**\n * Run the functions in the `tasks` collection in series, each one running once\n * the previous function has completed. If any functions in the series pass an\n * error to its callback, no more functions are run, and `callback` is\n * immediately called with the value of the error. Otherwise, `callback`\n * receives an array of results when `tasks` have completed.\n *\n * It is also possible to use an object instead of an array. Each property will\n * be run as a function, and the results will be passed to the final `callback`\n * as an object instead of an array. This can be a more readable way of handling\n * results from {@link async.series}.\n *\n * **Note** that while many implementations preserve the order of object\n * properties, the [ECMAScript Language Specification](http://www.ecma-international.org/ecma-262/5.1/#sec-8.6)\n * explicitly states that\n *\n * > The mechanics and order of enumerating the properties is not specified.\n *\n * So if you rely on the order in which your series of functions are executed,\n * and want this to work on all platforms, consider using an array.\n *\n * @name series\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {Array|Iterable|AsyncIterable|Object} tasks - A collection containing\n * [async functions]{@link AsyncFunction} to run in series.\n * Each function can complete with any number of optional `result` values.\n * @param {Function} [callback] - An optional callback to run once all the\n * functions have completed. This function gets a results array (or object)\n * containing all the result arguments passed to the `task` callbacks. Invoked\n * with (err, result).\n * @return {Promise} a promise, if no callback is passed\n * @example\n *\n * //Using Callbacks\n * async.series([\n * function(callback) {\n * setTimeout(function() {\n * // do some async task\n * callback(null, 'one');\n * }, 200);\n * },\n * function(callback) {\n * setTimeout(function() {\n * // then do another async task\n * callback(null, 'two');\n * }, 100);\n * }\n * ], function(err, results) {\n * console.log(results);\n * // results is equal to ['one','two']\n * });\n *\n * // an example using objects instead of arrays\n * async.series({\n * one: function(callback) {\n * setTimeout(function() {\n * // do some async task\n * callback(null, 1);\n * }, 200);\n * },\n * two: function(callback) {\n * setTimeout(function() {\n * // then do another async task\n * callback(null, 2);\n * }, 100);\n * }\n * }, function(err, results) {\n * console.log(results);\n * // results is equal to: { one: 1, two: 2 }\n * });\n *\n * //Using Promises\n * async.series([\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'one');\n * }, 200);\n * },\n * function(callback) {\n * setTimeout(function() {\n * callback(null, 'two');\n * }, 100);\n * }\n * ]).then(results => {\n * console.log(results);\n * // results is equal to ['one','two']\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * // an example using an object instead of an array\n * async.series({\n * one: function(callback) {\n * setTimeout(function() {\n * // do some async task\n * callback(null, 1);\n * }, 200);\n * },\n * two: function(callback) {\n * setTimeout(function() {\n * // then do another async task\n * callback(null, 2);\n * }, 100);\n * }\n * }).then(results => {\n * console.log(results);\n * // results is equal to: { one: 1, two: 2 }\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * //Using async/await\n * async () => {\n * try {\n * let results = await async.series([\n * function(callback) {\n * setTimeout(function() {\n * // do some async task\n * callback(null, 'one');\n * }, 200);\n * },\n * function(callback) {\n * setTimeout(function() {\n * // then do another async task\n * callback(null, 'two');\n * }, 100);\n * }\n * ]);\n * console.log(results);\n * // results is equal to ['one','two']\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * // an example using an object instead of an array\n * async () => {\n * try {\n * let results = await async.parallel({\n * one: function(callback) {\n * setTimeout(function() {\n * // do some async task\n * callback(null, 1);\n * }, 200);\n * },\n * two: function(callback) {\n * setTimeout(function() {\n * // then do another async task\n * callback(null, 2);\n * }, 100);\n * }\n * });\n * console.log(results);\n * // results is equal to: { one: 1, two: 2 }\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\nfunction series(tasks, callback) {\n return _parallel(eachOfSeries$1, tasks, callback);\n}\n\n/**\n * Returns `true` if at least one element in the `coll` satisfies an async test.\n * If any iteratee call returns `true`, the main `callback` is immediately\n * called.\n *\n * @name some\n * @static\n * @memberOf module:Collections\n * @method\n * @alias any\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async truth test to apply to each item\n * in the collections in parallel.\n * The iteratee should complete with a boolean `result` value.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called as soon as any\n * iteratee returns `true`, or after all the iteratee functions have finished.\n * Result will be either `true` or `false` depending on the values of the async\n * tests. Invoked with (err, result).\n * @returns {Promise} a promise, if no callback provided\n * @example\n *\n * // dir1 is a directory that contains file1.txt, file2.txt\n * // dir2 is a directory that contains file3.txt, file4.txt\n * // dir3 is a directory that contains file5.txt\n * // dir4 does not exist\n *\n * // asynchronous function that checks if a file exists\n * function fileExists(file, callback) {\n * fs.access(file, fs.constants.F_OK, (err) => {\n * callback(null, !err);\n * });\n * }\n *\n * // Using callbacks\n * async.some(['dir1/missing.txt','dir2/missing.txt','dir3/file5.txt'], fileExists,\n * function(err, result) {\n * console.log(result);\n * // true\n * // result is true since some file in the list exists\n * }\n *);\n *\n * async.some(['dir1/missing.txt','dir2/missing.txt','dir4/missing.txt'], fileExists,\n * function(err, result) {\n * console.log(result);\n * // false\n * // result is false since none of the files exists\n * }\n *);\n *\n * // Using Promises\n * async.some(['dir1/missing.txt','dir2/missing.txt','dir3/file5.txt'], fileExists)\n * .then( result => {\n * console.log(result);\n * // true\n * // result is true since some file in the list exists\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * async.some(['dir1/missing.txt','dir2/missing.txt','dir4/missing.txt'], fileExists)\n * .then( result => {\n * console.log(result);\n * // false\n * // result is false since none of the files exists\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let result = await async.some(['dir1/missing.txt','dir2/missing.txt','dir3/file5.txt'], fileExists);\n * console.log(result);\n * // true\n * // result is true since some file in the list exists\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n * async () => {\n * try {\n * let result = await async.some(['dir1/missing.txt','dir2/missing.txt','dir4/missing.txt'], fileExists);\n * console.log(result);\n * // false\n * // result is false since none of the files exists\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\nfunction some(coll, iteratee, callback) {\n return _createTester(Boolean, res => res)(eachOf$1, coll, iteratee, callback)\n}\nvar some$1 = awaitify(some, 3);\n\n/**\n * The same as [`some`]{@link module:Collections.some} but runs a maximum of `limit` async operations at a time.\n *\n * @name someLimit\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.some]{@link module:Collections.some}\n * @alias anyLimit\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - An async truth test to apply to each item\n * in the collections in parallel.\n * The iteratee should complete with a boolean `result` value.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called as soon as any\n * iteratee returns `true`, or after all the iteratee functions have finished.\n * Result will be either `true` or `false` depending on the values of the async\n * tests. Invoked with (err, result).\n * @returns {Promise} a promise, if no callback provided\n */\nfunction someLimit(coll, limit, iteratee, callback) {\n return _createTester(Boolean, res => res)(eachOfLimit(limit), coll, iteratee, callback)\n}\nvar someLimit$1 = awaitify(someLimit, 4);\n\n/**\n * The same as [`some`]{@link module:Collections.some} but runs only a single async operation at a time.\n *\n * @name someSeries\n * @static\n * @memberOf module:Collections\n * @method\n * @see [async.some]{@link module:Collections.some}\n * @alias anySeries\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async truth test to apply to each item\n * in the collections in series.\n * The iteratee should complete with a boolean `result` value.\n * Invoked with (item, callback).\n * @param {Function} [callback] - A callback which is called as soon as any\n * iteratee returns `true`, or after all the iteratee functions have finished.\n * Result will be either `true` or `false` depending on the values of the async\n * tests. Invoked with (err, result).\n * @returns {Promise} a promise, if no callback provided\n */\nfunction someSeries(coll, iteratee, callback) {\n return _createTester(Boolean, res => res)(eachOfSeries$1, coll, iteratee, callback)\n}\nvar someSeries$1 = awaitify(someSeries, 3);\n\n/**\n * Sorts a list by the results of running each `coll` value through an async\n * `iteratee`.\n *\n * @name sortBy\n * @static\n * @memberOf module:Collections\n * @method\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {AsyncFunction} iteratee - An async function to apply to each item in\n * `coll`.\n * The iteratee should complete with a value to use as the sort criteria as\n * its `result`.\n * Invoked with (item, callback).\n * @param {Function} callback - A callback which is called after all the\n * `iteratee` functions have finished, or an error occurs. Results is the items\n * from the original `coll` sorted by the values returned by the `iteratee`\n * calls. Invoked with (err, results).\n * @returns {Promise} a promise, if no callback passed\n * @example\n *\n * // bigfile.txt is a file that is 251100 bytes in size\n * // mediumfile.txt is a file that is 11000 bytes in size\n * // smallfile.txt is a file that is 121 bytes in size\n *\n * // asynchronous function that returns the file size in bytes\n * function getFileSizeInBytes(file, callback) {\n * fs.stat(file, function(err, stat) {\n * if (err) {\n * return callback(err);\n * }\n * callback(null, stat.size);\n * });\n * }\n *\n * // Using callbacks\n * async.sortBy(['mediumfile.txt','smallfile.txt','bigfile.txt'], getFileSizeInBytes,\n * function(err, results) {\n * if (err) {\n * console.log(err);\n * } else {\n * console.log(results);\n * // results is now the original array of files sorted by\n * // file size (ascending by default), e.g.\n * // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']\n * }\n * }\n * );\n *\n * // By modifying the callback parameter the\n * // sorting order can be influenced:\n *\n * // ascending order\n * async.sortBy(['mediumfile.txt','smallfile.txt','bigfile.txt'], function(file, callback) {\n * getFileSizeInBytes(file, function(getFileSizeErr, fileSize) {\n * if (getFileSizeErr) return callback(getFileSizeErr);\n * callback(null, fileSize);\n * });\n * }, function(err, results) {\n * if (err) {\n * console.log(err);\n * } else {\n * console.log(results);\n * // results is now the original array of files sorted by\n * // file size (ascending by default), e.g.\n * // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']\n * }\n * }\n * );\n *\n * // descending order\n * async.sortBy(['bigfile.txt','mediumfile.txt','smallfile.txt'], function(file, callback) {\n * getFileSizeInBytes(file, function(getFileSizeErr, fileSize) {\n * if (getFileSizeErr) {\n * return callback(getFileSizeErr);\n * }\n * callback(null, fileSize * -1);\n * });\n * }, function(err, results) {\n * if (err) {\n * console.log(err);\n * } else {\n * console.log(results);\n * // results is now the original array of files sorted by\n * // file size (ascending by default), e.g.\n * // [ 'bigfile.txt', 'mediumfile.txt', 'smallfile.txt']\n * }\n * }\n * );\n *\n * // Error handling\n * async.sortBy(['mediumfile.txt','smallfile.txt','missingfile.txt'], getFileSizeInBytes,\n * function(err, results) {\n * if (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * } else {\n * console.log(results);\n * }\n * }\n * );\n *\n * // Using Promises\n * async.sortBy(['mediumfile.txt','smallfile.txt','bigfile.txt'], getFileSizeInBytes)\n * .then( results => {\n * console.log(results);\n * // results is now the original array of files sorted by\n * // file size (ascending by default), e.g.\n * // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']\n * }).catch( err => {\n * console.log(err);\n * });\n *\n * // Error handling\n * async.sortBy(['mediumfile.txt','smallfile.txt','missingfile.txt'], getFileSizeInBytes)\n * .then( results => {\n * console.log(results);\n * }).catch( err => {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * });\n *\n * // Using async/await\n * (async () => {\n * try {\n * let results = await async.sortBy(['bigfile.txt','mediumfile.txt','smallfile.txt'], getFileSizeInBytes);\n * console.log(results);\n * // results is now the original array of files sorted by\n * // file size (ascending by default), e.g.\n * // [ 'smallfile.txt', 'mediumfile.txt', 'bigfile.txt']\n * }\n * catch (err) {\n * console.log(err);\n * }\n * })();\n *\n * // Error handling\n * async () => {\n * try {\n * let results = await async.sortBy(['missingfile.txt','mediumfile.txt','smallfile.txt'], getFileSizeInBytes);\n * console.log(results);\n * }\n * catch (err) {\n * console.log(err);\n * // [ Error: ENOENT: no such file or directory ]\n * }\n * }\n *\n */\nfunction sortBy (coll, iteratee, callback) {\n var _iteratee = wrapAsync(iteratee);\n return map$1(coll, (x, iterCb) => {\n _iteratee(x, (err, criteria) => {\n if (err) return iterCb(err);\n iterCb(err, {value: x, criteria});\n });\n }, (err, results) => {\n if (err) return callback(err);\n callback(null, results.sort(comparator).map(v => v.value));\n });\n\n function comparator(left, right) {\n var a = left.criteria, b = right.criteria;\n return a < b ? -1 : a > b ? 1 : 0;\n }\n}\nvar sortBy$1 = awaitify(sortBy, 3);\n\n/**\n * Sets a time limit on an asynchronous function. If the function does not call\n * its callback within the specified milliseconds, it will be called with a\n * timeout error. The code property for the error object will be `'ETIMEDOUT'`.\n *\n * @name timeout\n * @static\n * @memberOf module:Utils\n * @method\n * @category Util\n * @param {AsyncFunction} asyncFn - The async function to limit in time.\n * @param {number} milliseconds - The specified time limit.\n * @param {*} [info] - Any variable you want attached (`string`, `object`, etc)\n * to timeout Error for more information..\n * @returns {AsyncFunction} Returns a wrapped function that can be used with any\n * of the control flow functions.\n * Invoke this function with the same parameters as you would `asyncFunc`.\n * @example\n *\n * function myFunction(foo, callback) {\n * doAsyncTask(foo, function(err, data) {\n * // handle errors\n * if (err) return callback(err);\n *\n * // do some stuff ...\n *\n * // return processed data\n * return callback(null, data);\n * });\n * }\n *\n * var wrapped = async.timeout(myFunction, 1000);\n *\n * // call `wrapped` as you would `myFunction`\n * wrapped({ bar: 'bar' }, function(err, data) {\n * // if `myFunction` takes < 1000 ms to execute, `err`\n * // and `data` will have their expected values\n *\n * // else `err` will be an Error with the code 'ETIMEDOUT'\n * });\n */\nfunction timeout(asyncFn, milliseconds, info) {\n var fn = wrapAsync(asyncFn);\n\n return initialParams((args, callback) => {\n var timedOut = false;\n var timer;\n\n function timeoutCallback() {\n var name = asyncFn.name || 'anonymous';\n var error = new Error('Callback function \"' + name + '\" timed out.');\n error.code = 'ETIMEDOUT';\n if (info) {\n error.info = info;\n }\n timedOut = true;\n callback(error);\n }\n\n args.push((...cbArgs) => {\n if (!timedOut) {\n callback(...cbArgs);\n clearTimeout(timer);\n }\n });\n\n // setup timer and call original function\n timer = setTimeout(timeoutCallback, milliseconds);\n fn(...args);\n });\n}\n\nfunction range(size) {\n var result = Array(size);\n while (size--) {\n result[size] = size;\n }\n return result;\n}\n\n/**\n * The same as [times]{@link module:ControlFlow.times} but runs a maximum of `limit` async operations at a\n * time.\n *\n * @name timesLimit\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.times]{@link module:ControlFlow.times}\n * @category Control Flow\n * @param {number} count - The number of times to run the function.\n * @param {number} limit - The maximum number of async operations at a time.\n * @param {AsyncFunction} iteratee - The async function to call `n` times.\n * Invoked with the iteration index and a callback: (n, next).\n * @param {Function} callback - see [async.map]{@link module:Collections.map}.\n * @returns {Promise} a promise, if no callback is provided\n */\nfunction timesLimit(count, limit, iteratee, callback) {\n var _iteratee = wrapAsync(iteratee);\n return mapLimit$1(range(count), limit, _iteratee, callback);\n}\n\n/**\n * Calls the `iteratee` function `n` times, and accumulates results in the same\n * manner you would use with [map]{@link module:Collections.map}.\n *\n * @name times\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.map]{@link module:Collections.map}\n * @category Control Flow\n * @param {number} n - The number of times to run the function.\n * @param {AsyncFunction} iteratee - The async function to call `n` times.\n * Invoked with the iteration index and a callback: (n, next).\n * @param {Function} callback - see {@link module:Collections.map}.\n * @returns {Promise} a promise, if no callback is provided\n * @example\n *\n * // Pretend this is some complicated async factory\n * var createUser = function(id, callback) {\n * callback(null, {\n * id: 'user' + id\n * });\n * };\n *\n * // generate 5 users\n * async.times(5, function(n, next) {\n * createUser(n, function(err, user) {\n * next(err, user);\n * });\n * }, function(err, users) {\n * // we should now have 5 users\n * });\n */\nfunction times (n, iteratee, callback) {\n return timesLimit(n, Infinity, iteratee, callback)\n}\n\n/**\n * The same as [times]{@link module:ControlFlow.times} but runs only a single async operation at a time.\n *\n * @name timesSeries\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.times]{@link module:ControlFlow.times}\n * @category Control Flow\n * @param {number} n - The number of times to run the function.\n * @param {AsyncFunction} iteratee - The async function to call `n` times.\n * Invoked with the iteration index and a callback: (n, next).\n * @param {Function} callback - see {@link module:Collections.map}.\n * @returns {Promise} a promise, if no callback is provided\n */\nfunction timesSeries (n, iteratee, callback) {\n return timesLimit(n, 1, iteratee, callback)\n}\n\n/**\n * A relative of `reduce`. Takes an Object or Array, and iterates over each\n * element in parallel, each step potentially mutating an `accumulator` value.\n * The type of the accumulator defaults to the type of collection passed in.\n *\n * @name transform\n * @static\n * @memberOf module:Collections\n * @method\n * @category Collection\n * @param {Array|Iterable|AsyncIterable|Object} coll - A collection to iterate over.\n * @param {*} [accumulator] - The initial state of the transform. If omitted,\n * it will default to an empty Object or Array, depending on the type of `coll`\n * @param {AsyncFunction} iteratee - A function applied to each item in the\n * collection that potentially modifies the accumulator.\n * Invoked with (accumulator, item, key, callback).\n * @param {Function} [callback] - A callback which is called after all the\n * `iteratee` functions have finished. Result is the transformed accumulator.\n * Invoked with (err, result).\n * @returns {Promise} a promise, if no callback provided\n * @example\n *\n * // file1.txt is a file that is 1000 bytes in size\n * // file2.txt is a file that is 2000 bytes in size\n * // file3.txt is a file that is 3000 bytes in size\n *\n * // helper function that returns human-readable size format from bytes\n * function formatBytes(bytes, decimals = 2) {\n * // implementation not included for brevity\n * return humanReadbleFilesize;\n * }\n *\n * const fileList = ['file1.txt','file2.txt','file3.txt'];\n *\n * // asynchronous function that returns the file size, transformed to human-readable format\n * // e.g. 1024 bytes = 1KB, 1234 bytes = 1.21 KB, 1048576 bytes = 1MB, etc.\n * function transformFileSize(acc, value, key, callback) {\n * fs.stat(value, function(err, stat) {\n * if (err) {\n * return callback(err);\n * }\n * acc[key] = formatBytes(stat.size);\n * callback(null);\n * });\n * }\n *\n * // Using callbacks\n * async.transform(fileList, transformFileSize, function(err, result) {\n * if(err) {\n * console.log(err);\n * } else {\n * console.log(result);\n * // [ '1000 Bytes', '1.95 KB', '2.93 KB' ]\n * }\n * });\n *\n * // Using Promises\n * async.transform(fileList, transformFileSize)\n * .then(result => {\n * console.log(result);\n * // [ '1000 Bytes', '1.95 KB', '2.93 KB' ]\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * // Using async/await\n * (async () => {\n * try {\n * let result = await async.transform(fileList, transformFileSize);\n * console.log(result);\n * // [ '1000 Bytes', '1.95 KB', '2.93 KB' ]\n * }\n * catch (err) {\n * console.log(err);\n * }\n * })();\n *\n * @example\n *\n * // file1.txt is a file that is 1000 bytes in size\n * // file2.txt is a file that is 2000 bytes in size\n * // file3.txt is a file that is 3000 bytes in size\n *\n * // helper function that returns human-readable size format from bytes\n * function formatBytes(bytes, decimals = 2) {\n * // implementation not included for brevity\n * return humanReadbleFilesize;\n * }\n *\n * const fileMap = { f1: 'file1.txt', f2: 'file2.txt', f3: 'file3.txt' };\n *\n * // asynchronous function that returns the file size, transformed to human-readable format\n * // e.g. 1024 bytes = 1KB, 1234 bytes = 1.21 KB, 1048576 bytes = 1MB, etc.\n * function transformFileSize(acc, value, key, callback) {\n * fs.stat(value, function(err, stat) {\n * if (err) {\n * return callback(err);\n * }\n * acc[key] = formatBytes(stat.size);\n * callback(null);\n * });\n * }\n *\n * // Using callbacks\n * async.transform(fileMap, transformFileSize, function(err, result) {\n * if(err) {\n * console.log(err);\n * } else {\n * console.log(result);\n * // { f1: '1000 Bytes', f2: '1.95 KB', f3: '2.93 KB' }\n * }\n * });\n *\n * // Using Promises\n * async.transform(fileMap, transformFileSize)\n * .then(result => {\n * console.log(result);\n * // { f1: '1000 Bytes', f2: '1.95 KB', f3: '2.93 KB' }\n * }).catch(err => {\n * console.log(err);\n * });\n *\n * // Using async/await\n * async () => {\n * try {\n * let result = await async.transform(fileMap, transformFileSize);\n * console.log(result);\n * // { f1: '1000 Bytes', f2: '1.95 KB', f3: '2.93 KB' }\n * }\n * catch (err) {\n * console.log(err);\n * }\n * }\n *\n */\nfunction transform (coll, accumulator, iteratee, callback) {\n if (arguments.length <= 3 && typeof accumulator === 'function') {\n callback = iteratee;\n iteratee = accumulator;\n accumulator = Array.isArray(coll) ? [] : {};\n }\n callback = once(callback || promiseCallback());\n var _iteratee = wrapAsync(iteratee);\n\n eachOf$1(coll, (v, k, cb) => {\n _iteratee(accumulator, v, k, cb);\n }, err => callback(err, accumulator));\n return callback[PROMISE_SYMBOL]\n}\n\n/**\n * It runs each task in series but stops whenever any of the functions were\n * successful. If one of the tasks were successful, the `callback` will be\n * passed the result of the successful task. If all tasks fail, the callback\n * will be passed the error and result (if any) of the final attempt.\n *\n * @name tryEach\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {Array|Iterable|AsyncIterable|Object} tasks - A collection containing functions to\n * run, each function is passed a `callback(err, result)` it must call on\n * completion with an error `err` (which can be `null`) and an optional `result`\n * value.\n * @param {Function} [callback] - An optional callback which is called when one\n * of the tasks has succeeded, or all have failed. It receives the `err` and\n * `result` arguments of the last attempt at completing the `task`. Invoked with\n * (err, results).\n * @returns {Promise} a promise, if no callback is passed\n * @example\n * async.tryEach([\n * function getDataFromFirstWebsite(callback) {\n * // Try getting the data from the first website\n * callback(err, data);\n * },\n * function getDataFromSecondWebsite(callback) {\n * // First website failed,\n * // Try getting the data from the backup website\n * callback(err, data);\n * }\n * ],\n * // optional callback\n * function(err, results) {\n * Now do something with the data.\n * });\n *\n */\nfunction tryEach(tasks, callback) {\n var error = null;\n var result;\n return eachSeries$1(tasks, (task, taskCb) => {\n wrapAsync(task)((err, ...args) => {\n if (err === false) return taskCb(err);\n\n if (args.length < 2) {\n [result] = args;\n } else {\n result = args;\n }\n error = err;\n taskCb(err ? null : {});\n });\n }, () => callback(error, result));\n}\n\nvar tryEach$1 = awaitify(tryEach);\n\n/**\n * Undoes a [memoize]{@link module:Utils.memoize}d function, reverting it to the original,\n * unmemoized form. Handy for testing.\n *\n * @name unmemoize\n * @static\n * @memberOf module:Utils\n * @method\n * @see [async.memoize]{@link module:Utils.memoize}\n * @category Util\n * @param {AsyncFunction} fn - the memoized function\n * @returns {AsyncFunction} a function that calls the original unmemoized function\n */\nfunction unmemoize(fn) {\n return (...args) => {\n return (fn.unmemoized || fn)(...args);\n };\n}\n\n/**\n * Repeatedly call `iteratee`, while `test` returns `true`. Calls `callback` when\n * stopped, or an error occurs.\n *\n * @name whilst\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {AsyncFunction} test - asynchronous truth test to perform before each\n * execution of `iteratee`. Invoked with ().\n * @param {AsyncFunction} iteratee - An async function which is called each time\n * `test` passes. Invoked with (callback).\n * @param {Function} [callback] - A callback which is called after the test\n * function has failed and repeated execution of `iteratee` has stopped. `callback`\n * will be passed an error and any arguments passed to the final `iteratee`'s\n * callback. Invoked with (err, [results]);\n * @returns {Promise} a promise, if no callback is passed\n * @example\n *\n * var count = 0;\n * async.whilst(\n * function test(cb) { cb(null, count < 5); },\n * function iter(callback) {\n * count++;\n * setTimeout(function() {\n * callback(null, count);\n * }, 1000);\n * },\n * function (err, n) {\n * // 5 seconds have passed, n = 5\n * }\n * );\n */\nfunction whilst(test, iteratee, callback) {\n callback = onlyOnce(callback);\n var _fn = wrapAsync(iteratee);\n var _test = wrapAsync(test);\n var results = [];\n\n function next(err, ...rest) {\n if (err) return callback(err);\n results = rest;\n if (err === false) return;\n _test(check);\n }\n\n function check(err, truth) {\n if (err) return callback(err);\n if (err === false) return;\n if (!truth) return callback(null, ...results);\n _fn(next);\n }\n\n return _test(check);\n}\nvar whilst$1 = awaitify(whilst, 3);\n\n/**\n * Repeatedly call `iteratee` until `test` returns `true`. Calls `callback` when\n * stopped, or an error occurs. `callback` will be passed an error and any\n * arguments passed to the final `iteratee`'s callback.\n *\n * The inverse of [whilst]{@link module:ControlFlow.whilst}.\n *\n * @name until\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @see [async.whilst]{@link module:ControlFlow.whilst}\n * @category Control Flow\n * @param {AsyncFunction} test - asynchronous truth test to perform before each\n * execution of `iteratee`. Invoked with (callback).\n * @param {AsyncFunction} iteratee - An async function which is called each time\n * `test` fails. Invoked with (callback).\n * @param {Function} [callback] - A callback which is called after the test\n * function has passed and repeated execution of `iteratee` has stopped. `callback`\n * will be passed an error and any arguments passed to the final `iteratee`'s\n * callback. Invoked with (err, [results]);\n * @returns {Promise} a promise, if a callback is not passed\n *\n * @example\n * const results = []\n * let finished = false\n * async.until(function test(cb) {\n * cb(null, finished)\n * }, function iter(next) {\n * fetchPage(url, (err, body) => {\n * if (err) return next(err)\n * results = results.concat(body.objects)\n * finished = !!body.next\n * next(err)\n * })\n * }, function done (err) {\n * // all pages have been fetched\n * })\n */\nfunction until(test, iteratee, callback) {\n const _test = wrapAsync(test);\n return whilst$1((cb) => _test((err, truth) => cb (err, !truth)), iteratee, callback);\n}\n\n/**\n * Runs the `tasks` array of functions in series, each passing their results to\n * the next in the array. However, if any of the `tasks` pass an error to their\n * own callback, the next function is not executed, and the main `callback` is\n * immediately called with the error.\n *\n * @name waterfall\n * @static\n * @memberOf module:ControlFlow\n * @method\n * @category Control Flow\n * @param {Array} tasks - An array of [async functions]{@link AsyncFunction}\n * to run.\n * Each function should complete with any number of `result` values.\n * The `result` values will be passed as arguments, in order, to the next task.\n * @param {Function} [callback] - An optional callback to run once all the\n * functions have completed. This will be passed the results of the last task's\n * callback. Invoked with (err, [results]).\n * @returns undefined\n * @example\n *\n * async.waterfall([\n * function(callback) {\n * callback(null, 'one', 'two');\n * },\n * function(arg1, arg2, callback) {\n * // arg1 now equals 'one' and arg2 now equals 'two'\n * callback(null, 'three');\n * },\n * function(arg1, callback) {\n * // arg1 now equals 'three'\n * callback(null, 'done');\n * }\n * ], function (err, result) {\n * // result now equals 'done'\n * });\n *\n * // Or, with named functions:\n * async.waterfall([\n * myFirstFunction,\n * mySecondFunction,\n * myLastFunction,\n * ], function (err, result) {\n * // result now equals 'done'\n * });\n * function myFirstFunction(callback) {\n * callback(null, 'one', 'two');\n * }\n * function mySecondFunction(arg1, arg2, callback) {\n * // arg1 now equals 'one' and arg2 now equals 'two'\n * callback(null, 'three');\n * }\n * function myLastFunction(arg1, callback) {\n * // arg1 now equals 'three'\n * callback(null, 'done');\n * }\n */\nfunction waterfall (tasks, callback) {\n callback = once(callback);\n if (!Array.isArray(tasks)) return callback(new Error('First argument to waterfall must be an array of functions'));\n if (!tasks.length) return callback();\n var taskIndex = 0;\n\n function nextTask(args) {\n var task = wrapAsync(tasks[taskIndex++]);\n task(...args, onlyOnce(next));\n }\n\n function next(err, ...args) {\n if (err === false) return\n if (err || taskIndex === tasks.length) {\n return callback(err, ...args);\n }\n nextTask(args);\n }\n\n nextTask([]);\n}\n\nvar waterfall$1 = awaitify(waterfall);\n\n/**\n * An \"async function\" in the context of Async is an asynchronous function with\n * a variable number of parameters, with the final parameter being a callback.\n * (`function (arg1, arg2, ..., callback) {}`)\n * The final callback is of the form `callback(err, results...)`, which must be\n * called once the function is completed. The callback should be called with a\n * Error as its first argument to signal that an error occurred.\n * Otherwise, if no error occurred, it should be called with `null` as the first\n * argument, and any additional `result` arguments that may apply, to signal\n * successful completion.\n * The callback must be called exactly once, ideally on a later tick of the\n * JavaScript event loop.\n *\n * This type of function is also referred to as a \"Node-style async function\",\n * or a \"continuation passing-style function\" (CPS). Most of the methods of this\n * library are themselves CPS/Node-style async functions, or functions that\n * return CPS/Node-style async functions.\n *\n * Wherever we accept a Node-style async function, we also directly accept an\n * [ES2017 `async` function]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function}.\n * In this case, the `async` function will not be passed a final callback\n * argument, and any thrown error will be used as the `err` argument of the\n * implicit callback, and the return value will be used as the `result` value.\n * (i.e. a `rejected` of the returned Promise becomes the `err` callback\n * argument, and a `resolved` value becomes the `result`.)\n *\n * Note, due to JavaScript limitations, we can only detect native `async`\n * functions and not transpilied implementations.\n * Your environment must have `async`/`await` support for this to work.\n * (e.g. Node > v7.6, or a recent version of a modern browser).\n * If you are using `async` functions through a transpiler (e.g. Babel), you\n * must still wrap the function with [asyncify]{@link module:Utils.asyncify},\n * because the `async function` will be compiled to an ordinary function that\n * returns a promise.\n *\n * @typedef {Function} AsyncFunction\n * @static\n */\n\nvar index = {\n apply,\n applyEach: applyEach$1,\n applyEachSeries,\n asyncify,\n auto,\n autoInject,\n cargo,\n cargoQueue: cargo$1,\n compose,\n concat: concat$1,\n concatLimit: concatLimit$1,\n concatSeries: concatSeries$1,\n constant,\n detect: detect$1,\n detectLimit: detectLimit$1,\n detectSeries: detectSeries$1,\n dir,\n doUntil,\n doWhilst: doWhilst$1,\n each,\n eachLimit: eachLimit$2,\n eachOf: eachOf$1,\n eachOfLimit: eachOfLimit$2,\n eachOfSeries: eachOfSeries$1,\n eachSeries: eachSeries$1,\n ensureAsync,\n every: every$1,\n everyLimit: everyLimit$1,\n everySeries: everySeries$1,\n filter: filter$1,\n filterLimit: filterLimit$1,\n filterSeries: filterSeries$1,\n forever: forever$1,\n groupBy,\n groupByLimit: groupByLimit$1,\n groupBySeries,\n log,\n map: map$1,\n mapLimit: mapLimit$1,\n mapSeries: mapSeries$1,\n mapValues,\n mapValuesLimit: mapValuesLimit$1,\n mapValuesSeries,\n memoize,\n nextTick,\n parallel,\n parallelLimit,\n priorityQueue,\n queue: queue$1,\n race: race$1,\n reduce: reduce$1,\n reduceRight,\n reflect,\n reflectAll,\n reject: reject$2,\n rejectLimit: rejectLimit$1,\n rejectSeries: rejectSeries$1,\n retry,\n retryable,\n seq,\n series,\n setImmediate: setImmediate$1,\n some: some$1,\n someLimit: someLimit$1,\n someSeries: someSeries$1,\n sortBy: sortBy$1,\n timeout,\n times,\n timesLimit,\n timesSeries,\n transform,\n tryEach: tryEach$1,\n unmemoize,\n until,\n waterfall: waterfall$1,\n whilst: whilst$1,\n\n // aliases\n all: every$1,\n allLimit: everyLimit$1,\n allSeries: everySeries$1,\n any: some$1,\n anyLimit: someLimit$1,\n anySeries: someSeries$1,\n find: detect$1,\n findLimit: detectLimit$1,\n findSeries: detectSeries$1,\n flatMap: concat$1,\n flatMapLimit: concatLimit$1,\n flatMapSeries: concatSeries$1,\n forEach: each,\n forEachSeries: eachSeries$1,\n forEachLimit: eachLimit$2,\n forEachOf: eachOf$1,\n forEachOfSeries: eachOfSeries$1,\n forEachOfLimit: eachOfLimit$2,\n inject: reduce$1,\n foldl: reduce$1,\n foldr: reduceRight,\n select: filter$1,\n selectLimit: filterLimit$1,\n selectSeries: filterSeries$1,\n wrapSync: asyncify,\n during: whilst$1,\n doDuring: doWhilst$1\n};\n\nexport default index;\nexport { apply, applyEach$1 as applyEach, applyEachSeries, asyncify, auto, autoInject, cargo, cargo$1 as cargoQueue, compose, concat$1 as concat, concatLimit$1 as concatLimit, concatSeries$1 as concatSeries, constant, detect$1 as detect, detectLimit$1 as detectLimit, detectSeries$1 as detectSeries, dir, doUntil, doWhilst$1 as doWhilst, each, eachLimit$2 as eachLimit, eachOf$1 as eachOf, eachOfLimit$2 as eachOfLimit, eachOfSeries$1 as eachOfSeries, eachSeries$1 as eachSeries, ensureAsync, every$1 as every, everyLimit$1 as everyLimit, everySeries$1 as everySeries, filter$1 as filter, filterLimit$1 as filterLimit, filterSeries$1 as filterSeries, forever$1 as forever, groupBy, groupByLimit$1 as groupByLimit, groupBySeries, log, map$1 as map, mapLimit$1 as mapLimit, mapSeries$1 as mapSeries, mapValues, mapValuesLimit$1 as mapValuesLimit, mapValuesSeries, memoize, nextTick, parallel, parallelLimit, priorityQueue, queue$1 as queue, race$1 as race, reduce$1 as reduce, reduceRight, reflect, reflectAll, reject$2 as reject, rejectLimit$1 as rejectLimit, rejectSeries$1 as rejectSeries, retry, retryable, seq, series, setImmediate$1 as setImmediate, some$1 as some, someLimit$1 as someLimit, someSeries$1 as someSeries, sortBy$1 as sortBy, timeout, times, timesLimit, timesSeries, transform, tryEach$1 as tryEach, unmemoize, until, waterfall$1 as waterfall, whilst$1 as whilst, every$1 as all, everyLimit$1 as allLimit, everySeries$1 as allSeries, some$1 as any, someLimit$1 as anyLimit, someSeries$1 as anySeries, detect$1 as find, detectLimit$1 as findLimit, detectSeries$1 as findSeries, concat$1 as flatMap, concatLimit$1 as flatMapLimit, concatSeries$1 as flatMapSeries, each as forEach, eachSeries$1 as forEachSeries, eachLimit$2 as forEachLimit, eachOf$1 as forEachOf, eachOfSeries$1 as forEachOfSeries, eachOfLimit$2 as forEachOfLimit, reduce$1 as inject, reduce$1 as foldl, reduceRight as foldr, filter$1 as select, filterLimit$1 as selectLimit, filterSeries$1 as selectSeries, asyncify as wrapSync, whilst$1 as during, doWhilst$1 as doDuring };\n"]},"metadata":{},"sourceType":"module"}